package oss import ( "bytes" "errors" "fmt" "hash/crc32" "hash/crc64" "io" "net/http" "os" "os/exec" "runtime" "strconv" "strings" "time" ) var sys_name string var sys_release string var sys_machine string func init() { sys_name = runtime.GOOS sys_release = "-" sys_machine = runtime.GOARCH if out, err := exec.Command("uname", "-s").CombinedOutput(); err == nil { sys_name = string(bytes.TrimSpace(out)) } if out, err := exec.Command("uname", "-r").CombinedOutput(); err == nil { sys_release = string(bytes.TrimSpace(out)) } if out, err := exec.Command("uname", "-m").CombinedOutput(); err == nil { sys_machine = string(bytes.TrimSpace(out)) } } // userAgent gets user agent // It has the SDK version information, OS information and GO version func userAgent() string { sys := getSysInfo() return fmt.Sprintf("aliyun-sdk-go/%s (%s/%s/%s;%s)", Version, sys.name, sys.release, sys.machine, runtime.Version()) } type sysInfo struct { name string // OS name such as windows/Linux release string // OS version 2.6.32-220.23.2.ali1089.el5.x86_64 etc machine string // CPU type amd64/x86_64 } // getSysInfo gets system info // gets the OS information and CPU type func getSysInfo() sysInfo { return sysInfo{name: sys_name, release: sys_release, machine: sys_machine} } // GetRangeConfig gets the download range from the options. func GetRangeConfig(options []Option) (*UnpackedRange, error) { rangeOpt, err := FindOption(options, HTTPHeaderRange, nil) if err != nil || rangeOpt == nil { return nil, err } return ParseRange(rangeOpt.(string)) } // UnpackedRange type UnpackedRange struct { HasStart bool // Flag indicates if the start point is specified HasEnd bool // Flag indicates if the end point is specified Start int64 // Start point End int64 // End point } // InvalidRangeError returns invalid range error func InvalidRangeError(r string) error { return fmt.Errorf("InvalidRange %s", r) } func GetRangeString(unpackRange UnpackedRange) string { var strRange string if unpackRange.HasStart && unpackRange.HasEnd { strRange = fmt.Sprintf("%d-%d", unpackRange.Start, unpackRange.End) } else if unpackRange.HasStart { strRange = fmt.Sprintf("%d-", unpackRange.Start) } else if unpackRange.HasEnd { strRange = fmt.Sprintf("-%d", unpackRange.End) } return strRange } // ParseRange parse various styles of range such as bytes=M-N func ParseRange(normalizedRange string) (*UnpackedRange, error) { var err error hasStart := false hasEnd := false var start int64 var end int64 // Bytes==M-N or ranges=M-N nrSlice := strings.Split(normalizedRange, "=") if len(nrSlice) != 2 || nrSlice[0] != "bytes" { return nil, InvalidRangeError(normalizedRange) } // Bytes=M-N,X-Y rSlice := strings.Split(nrSlice[1], ",") rStr := rSlice[0] if strings.HasSuffix(rStr, "-") { // M- startStr := rStr[:len(rStr)-1] start, err = strconv.ParseInt(startStr, 10, 64) if err != nil { return nil, InvalidRangeError(normalizedRange) } hasStart = true } else if strings.HasPrefix(rStr, "-") { // -N len := rStr[1:] end, err = strconv.ParseInt(len, 10, 64) if err != nil { return nil, InvalidRangeError(normalizedRange) } if end == 0 { // -0 return nil, InvalidRangeError(normalizedRange) } hasEnd = true } else { // M-N valSlice := strings.Split(rStr, "-") if len(valSlice) != 2 { return nil, InvalidRangeError(normalizedRange) } start, err = strconv.ParseInt(valSlice[0], 10, 64) if err != nil { return nil, InvalidRangeError(normalizedRange) } hasStart = true end, err = strconv.ParseInt(valSlice[1], 10, 64) if err != nil { return nil, InvalidRangeError(normalizedRange) } hasEnd = true } return &UnpackedRange{hasStart, hasEnd, start, end}, nil } // AdjustRange returns adjusted range, adjust the range according to the length of the file func AdjustRange(ur *UnpackedRange, size int64) (start, end int64) { if ur == nil { return 0, size } if ur.HasStart && ur.HasEnd { start = ur.Start end = ur.End + 1 if ur.Start < 0 || ur.Start >= size || ur.End > size || ur.Start > ur.End { start = 0 end = size } } else if ur.HasStart { start = ur.Start end = size if ur.Start < 0 || ur.Start >= size { start = 0 } } else if ur.HasEnd { start = size - ur.End end = size if ur.End < 0 || ur.End > size { start = 0 end = size } } return } // GetNowSec returns Unix time, the number of seconds elapsed since January 1, 1970 UTC. // gets the current time in Unix time, in seconds. func GetNowSec() int64 { return time.Now().Unix() } // GetNowNanoSec returns t as a Unix time, the number of nanoseconds elapsed // since January 1, 1970 UTC. The result is undefined if the Unix time // in nanoseconds cannot be represented by an int64. Note that this // means the result of calling UnixNano on the zero Time is undefined. // gets the current time in Unix time, in nanoseconds. func GetNowNanoSec() int64 { return time.Now().UnixNano() } // GetNowGMT gets the current time in GMT format. func GetNowGMT() string { return time.Now().UTC().Format(http.TimeFormat) } // FileChunk is the file chunk definition type FileChunk struct { Number int // Chunk number Offset int64 // Chunk offset Size int64 // Chunk size. } // SplitFileByPartNum splits big file into parts by the num of parts. // Split the file with specified parts count, returns the split result when error is nil. func SplitFileByPartNum(fileName string, chunkNum int) ([]FileChunk, error) { if chunkNum <= 0 || chunkNum > 10000 { return nil, errors.New("chunkNum invalid") } file, err := os.Open(fileName) if err != nil { return nil, err } defer file.Close() stat, err := file.Stat() if err != nil { return nil, err } if int64(chunkNum) > stat.Size() { return nil, errors.New("oss: chunkNum invalid") } var chunks []FileChunk var chunk = FileChunk{} var chunkN = (int64)(chunkNum) for i := int64(0); i < chunkN; i++ { chunk.Number = int(i + 1) chunk.Offset = i * (stat.Size() / chunkN) if i == chunkN-1 { chunk.Size = stat.Size()/chunkN + stat.Size()%chunkN } else { chunk.Size = stat.Size() / chunkN } chunks = append(chunks, chunk) } return chunks, nil } // SplitFileByPartSize splits big file into parts by the size of parts. // Splits the file by the part size. Returns the FileChunk when error is nil. func SplitFileByPartSize(fileName string, chunkSize int64) ([]FileChunk, error) { if chunkSize <= 0 { return nil, errors.New("chunkSize invalid") } file, err := os.Open(fileName) if err != nil { return nil, err } defer file.Close() stat, err := file.Stat() if err != nil { return nil, err } var chunkN = stat.Size() / chunkSize if chunkN >= 10000 { return nil, errors.New("Too many parts, please increase part size") } var chunks []FileChunk var chunk = FileChunk{} for i := int64(0); i < chunkN; i++ { chunk.Number = int(i + 1) chunk.Offset = i * chunkSize chunk.Size = chunkSize chunks = append(chunks, chunk) } if stat.Size()%chunkSize > 0 { chunk.Number = len(chunks) + 1 chunk.Offset = int64(len(chunks)) * chunkSize chunk.Size = stat.Size() % chunkSize chunks = append(chunks, chunk) } return chunks, nil } // GetPartEnd calculates the end position func GetPartEnd(begin int64, total int64, per int64) int64 { if begin+per > total { return total - 1 } return begin + per - 1 } // CrcTable returns the table constructed from the specified polynomial var CrcTable = func() *crc64.Table { return crc64.MakeTable(crc64.ECMA) } // CrcTable returns the table constructed from the specified polynomial var crc32Table = func() *crc32.Table { return crc32.MakeTable(crc32.IEEE) } // choiceTransferPartOption choices valid option supported by Uploadpart or DownloadPart func ChoiceTransferPartOption(options []Option) []Option { var outOption []Option listener, _ := FindOption(options, progressListener, nil) if listener != nil { outOption = append(outOption, Progress(listener.(ProgressListener))) } payer, _ := FindOption(options, HTTPHeaderOssRequester, nil) if payer != nil { outOption = append(outOption, RequestPayer(PayerType(payer.(string)))) } versionId, _ := FindOption(options, "versionId", nil) if versionId != nil { outOption = append(outOption, VersionId(versionId.(string))) } trafficLimit, _ := FindOption(options, HTTPHeaderOssTrafficLimit, nil) if trafficLimit != nil { speed, _ := strconv.ParseInt(trafficLimit.(string), 10, 64) outOption = append(outOption, TrafficLimitHeader(speed)) } respHeader, _ := FindOption(options, responseHeader, nil) if respHeader != nil { outOption = append(outOption, GetResponseHeader(respHeader.(*http.Header))) } return outOption } // ChoiceCompletePartOption choices valid option supported by CompleteMulitiPart func ChoiceCompletePartOption(options []Option) []Option { var outOption []Option listener, _ := FindOption(options, progressListener, nil) if listener != nil { outOption = append(outOption, Progress(listener.(ProgressListener))) } payer, _ := FindOption(options, HTTPHeaderOssRequester, nil) if payer != nil { outOption = append(outOption, RequestPayer(PayerType(payer.(string)))) } acl, _ := FindOption(options, HTTPHeaderOssObjectACL, nil) if acl != nil { outOption = append(outOption, ObjectACL(ACLType(acl.(string)))) } callback, _ := FindOption(options, HTTPHeaderOssCallback, nil) if callback != nil { outOption = append(outOption, Callback(callback.(string))) } callbackVar, _ := FindOption(options, HTTPHeaderOssCallbackVar, nil) if callbackVar != nil { outOption = append(outOption, CallbackVar(callbackVar.(string))) } respHeader, _ := FindOption(options, responseHeader, nil) if respHeader != nil { outOption = append(outOption, GetResponseHeader(respHeader.(*http.Header))) } forbidOverWrite, _ := FindOption(options, HTTPHeaderOssForbidOverWrite, nil) if forbidOverWrite != nil { if forbidOverWrite.(string) == "true" { outOption = append(outOption, ForbidOverWrite(true)) } else { outOption = append(outOption, ForbidOverWrite(false)) } } return outOption } // ChoiceAbortPartOption choices valid option supported by AbortMultipartUpload func ChoiceAbortPartOption(options []Option) []Option { var outOption []Option payer, _ := FindOption(options, HTTPHeaderOssRequester, nil) if payer != nil { outOption = append(outOption, RequestPayer(PayerType(payer.(string)))) } respHeader, _ := FindOption(options, responseHeader, nil) if respHeader != nil { outOption = append(outOption, GetResponseHeader(respHeader.(*http.Header))) } return outOption } // ChoiceHeadObjectOption choices valid option supported by HeadObject func ChoiceHeadObjectOption(options []Option) []Option { var outOption []Option // not select HTTPHeaderRange to get whole object length payer, _ := FindOption(options, HTTPHeaderOssRequester, nil) if payer != nil { outOption = append(outOption, RequestPayer(PayerType(payer.(string)))) } versionId, _ := FindOption(options, "versionId", nil) if versionId != nil { outOption = append(outOption, VersionId(versionId.(string))) } respHeader, _ := FindOption(options, responseHeader, nil) if respHeader != nil { outOption = append(outOption, GetResponseHeader(respHeader.(*http.Header))) } return outOption } func CheckBucketName(bucketName string) error { nameLen := len(bucketName) if nameLen < 3 || nameLen > 63 { return fmt.Errorf("bucket name %s len is between [3-63],now is %d", bucketName, nameLen) } for _, v := range bucketName { if !(('a' <= v && v <= 'z') || ('0' <= v && v <= '9') || v == '-') { return fmt.Errorf("bucket name %s can only include lowercase letters, numbers, and -", bucketName) } } if bucketName[0] == '-' || bucketName[nameLen-1] == '-' { return fmt.Errorf("bucket name %s must start and end with a lowercase letter or number", bucketName) } return nil } func GetReaderLen(reader io.Reader) (int64, error) { var contentLength int64 var err error switch v := reader.(type) { case *bytes.Buffer: contentLength = int64(v.Len()) case *bytes.Reader: contentLength = int64(v.Len()) case *strings.Reader: contentLength = int64(v.Len()) case *os.File: fInfo, fError := v.Stat() if fError != nil { err = fmt.Errorf("can't get reader content length,%s", fError.Error()) } else { contentLength = fInfo.Size() } case *io.LimitedReader: contentLength = int64(v.N) case *LimitedReadCloser: contentLength = int64(v.N) default: err = fmt.Errorf("can't get reader content length,unkown reader type") } return contentLength, err } func LimitReadCloser(r io.Reader, n int64) io.Reader { var lc LimitedReadCloser lc.R = r lc.N = n return &lc } // LimitedRC support Close() type LimitedReadCloser struct { io.LimitedReader } func (lc *LimitedReadCloser) Close() error { if closer, ok := lc.R.(io.ReadCloser); ok { return closer.Close() } return nil } type DiscardReadCloser struct { RC io.ReadCloser Discard int } func (drc *DiscardReadCloser) Read(b []byte) (int, error) { n, err := drc.RC.Read(b) if drc.Discard == 0 || n <= 0 { return n, err } if n <= drc.Discard { drc.Discard -= n return 0, err } realLen := n - drc.Discard copy(b[0:realLen], b[drc.Discard:n]) drc.Discard = 0 return realLen, err } func (drc *DiscardReadCloser) Close() error { closer, ok := drc.RC.(io.ReadCloser) if ok { return closer.Close() } return nil }