func()

in oss/lib/du.go [165:261]
83 lines of code
19 McCabe index (conditional complexity)

func (duc *DuCommand) RunCommand() error {
	// clear for go tests
	duc.duOption.countTypeMap = make(map[string]int64)
	duc.duOption.sizeTypeMap = make(map[string]int64)
	duc.duOption.totalObjectCount = 0
	duc.duOption.sumObjectSize = 0
	duc.duOption.totalPartCount = 0
	duc.duOption.sumPartSize = 0

	blockSizeMap := make(map[string]int64)
	blockSizeMap["byte"] = 1
	blockSizeMap["KB"] = 1024
	blockSizeMap["MB"] = 1024 * 1024
	blockSizeMap["GB"] = 1024 * 1024 * 1024
	blockSizeMap["TB"] = 1024 * 1024 * 1024 * 1024

	encodingType, _ := GetString(OptionEncodingType, duc.command.options)
	srcBucketUrL, err := GetCloudUrl(duc.command.args[0], encodingType)
	if err != nil {
		return err
	}

	payer, _ := GetString(OptionRequestPayer, duc.command.options)
	if payer != "" {
		if strings.ToLower(payer) != strings.ToLower(string(oss.Requester)) &&
			strings.ToLower(payer) != strings.ToLower(string(oss.BucketOwner)) {
			return fmt.Errorf("option payer value must be %s or %s",
				strings.ToLower(string(oss.Requester)), strings.ToLower(string(oss.BucketOwner)))
		}
	}
	allVersions, _ := GetBool(OptionAllversions, duc.command.options)

	strBlockSize, _ := GetString(OptionBlockSize, duc.command.options)
	strBlockSize = strings.ToUpper(strBlockSize)
	if strBlockSize == "" {
		strBlockSize = "byte"
	}

	if strBlockSize != "byte" && strBlockSize != "KB" && strBlockSize != "MB" && strBlockSize != "GB" && strBlockSize != "TB" {
		return fmt.Errorf("-B value must be KB, MB, GB or TB")
	}
	duc.duOption.displayUnit = strBlockSize
	duc.duOption.blockSize = blockSizeMap[strBlockSize]

	duc.duOption.bucketName = srcBucketUrL.bucket
	duc.duOption.object = srcBucketUrL.object
	duc.duOption.payer = payer
	bucket, err := duc.command.ossBucket(duc.duOption.bucketName)
	if err != nil {
		return err
	}

	// first:get all object size
	if allVersions {
		err = duc.getAllObjectVersionsSize(bucket)
	} else {
		err = duc.getAllObjectSize(bucket)
	}

	if err != nil {
		return err
	}

	printHeader := false
	for k, v := range duc.duOption.countTypeMap {
		if !printHeader {
			fmt.Printf("\r                                                                      ")
			fmt.Printf("\r%-14s\t%-20s\t%-30s\n", "storage class", "object count", "sum size(byte)")
			fmt.Printf("----------------------------------------------------------\n")
			printHeader = true
		}
		fmt.Printf("%-14s\t%-20d\t%-30d\n", k, v, duc.duOption.sizeTypeMap[k])
	}
	if !printHeader {
		fmt.Printf("\r")
	} else {
		fmt.Printf("----------------------------------------------------------\n")
	}
	fmt.Printf("%-20s%-20d\t%-23s%d\n", "total object count:", duc.duOption.totalObjectCount, "total object sum size:", duc.duOption.sumObjectSize)

	//second:get all part size
	err = duc.GetAllPartSize(bucket)
	if err != nil {
		return err
	}
	fmt.Printf("\r                                                                      ")
	fmt.Printf("\r%-20s%-20d\t%-23s%d\n\n", "total part count:", duc.duOption.totalPartCount, "total part sum size:", duc.duOption.sumPartSize)

	if duc.duOption.blockSize == int64(1) {
		displaySize := (duc.duOption.sumObjectSize + duc.duOption.sumPartSize) / duc.duOption.blockSize
		fmt.Printf("total du size(%s):%d\n", duc.duOption.displayUnit, displaySize)
	} else {
		displaySize := float64(duc.duOption.sumObjectSize+duc.duOption.sumPartSize) / float64(duc.duOption.blockSize)
		fmt.Printf("total du size(%s):%.4f\n", duc.duOption.displayUnit, displaySize)
	}
	return nil
}