aliyun / ossutil / 52

pending completion

Build # 52

Build Type

push

travis-ci

Committed by

mars-coder

Commit Message

<a href="https://github.com/aliyun/ossutil/commit/05deeb137">change travis ci env params

Change-Id: I</a><a class="double-link" href="https://github.com/aliyun/ossutil/commit/db356c510">db356c510</a>

Run Details

651 of 2578 relevant lines covered (25.25%)

19.67 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

67.93

/lib/command.go

package lib

import (
        "fmt"
        oss "github.com/aliyun/aliyun-oss-go-sdk/oss"
        "net/http"
        "strconv"
        "strings"
)

// group spec text of all commands
const (
        GroupTypeNormalCommand string = "\nCommands:\n"

        GroupTypeAdditionalCommand string = "\nAdditional Commands:\n"

        GroupTypeDeprecatedCommand string = "\nDeprecated Commands:\n"
)

// CommandGroups is the array of all group types
var CommandGroups = []string{
        GroupTypeNormalCommand,
        GroupTypeAdditionalCommand,
        GroupTypeDeprecatedCommand,
}

// SpecText is the spec text of a command
type SpecText struct {
        synopsisText   string
        paramText      string
        syntaxText     string
        detailHelpText string
        sampleText     string
}

// Command contains all elements of a command, it's the base class of all commands
type Command struct {
        name             string
        nameAlias        []string
        minArgc          int
        maxArgc          int
        specChinese      SpecText
        specEnglish      SpecText
        validOptionNames []string
        group            string
        args             []string
        options          OptionMapType
        configOptions    OptionMapType
}

// Commander is the interface of all commands
type Commander interface {
        RunCommand() error
        Init(args []string, options OptionMapType) error
}

// RewriteLoadConfiger is the interface for those commands, which do not need to load config, or have other action
type RewriteLoadConfiger interface {
        rewriteLoadConfig(string) error
}

// RewriteAssembleOptioner is the interface for those commands, which do not need to assemble options
type RewriteAssembleOptioner interface {
        rewriteAssembleOptions()
}

// Init is the common functions for all commands, they use Init to initialize itself
func (cmd *Command) Init(args []string, options OptionMapType, cmder interface{}) error {
        cmd.args = args
        cmd.options = options
        cmd.configOptions = OptionMapType{}

        if err := cmd.checkArgs(); err != nil {
                return err
        }

        val, _ := GetString(OptionConfigFile, cmd.options)
        if err := cmd.loadConfig(val, cmder); err != nil {
                return err
        }

        if err := cmd.checkOptions(); err != nil {
                return err
        }

        cmd.assembleOptions(cmder)
        return nil
}

func (cmd *Command) checkArgs() error {
        str := ""
        if cmd.minArgc > 1 {
                str = "s"
        }
        if len(cmd.args) < cmd.minArgc {
                msg := fmt.Sprintf("the command needs at least %d argument%s", cmd.minArgc, str)
                return CommandError{cmd.name, msg}
        }

        str = ""
        if cmd.minArgc > 1 {
                str = "s"
        }

        if len(cmd.args) > cmd.maxArgc {
                msg := fmt.Sprintf("the command needs at most %d argument%s", cmd.maxArgc, str)
                return CommandError{cmd.name, msg}
        }
        return nil
}

func (cmd *Command) loadConfig(configFile string, cmder interface{}) error {
        if cmdder, ok := cmder.(RewriteLoadConfiger); ok {
                return cmdder.rewriteLoadConfig(configFile)
        }
        var err error
        if cmd.configOptions, err = LoadConfig(configFile); err != nil {
                return err
        }
        return nil
}

func (cmd *Command) checkOptions() error {
        for name := range cmd.options {
                msg := fmt.Sprintf("the command does not support option: \"%s\"", name)
                switch OptionMap[name].optionType {
                case OptionTypeFlagTrue:
                        if val, _ := GetBool(name, cmd.options); val {
                                if FindPos(name, cmd.validOptionNames) == -1 {
                                        return CommandError{cmd.name, msg}
                                }
                        }
                default:
                        if val, _ := GetString(name, cmd.options); val != "" {
                                if FindPos(name, cmd.validOptionNames) == -1 {
                                        return CommandError{cmd.name, msg}
                                }
                        }
                }
        }
        return nil
}

func (cmd *Command) assembleOptions(cmder interface{}) {
        if cmdder, ok := cmder.(RewriteAssembleOptioner); ok {
                cmdder.rewriteAssembleOptions()
                return
        }

        for name, option := range cmd.configOptions {
                if _, ok := cmd.options[name]; ok {
                        if OptionMap[name].optionType != OptionTypeFlagTrue {
                                if val, _ := GetString(name, cmd.options); val == "" {
                                        opval := option.(string)
                                        cmd.options[name] = &opval
                                        delete(cmd.configOptions, name)
                                } else if name == OptionEndpoint {
                    delete(cmd.configOptions, BucketCnameSection)
                    delete(cmd.configOptions, BucketEndpointSection)
                }
                        }
                }
        }

        for name := range cmd.options {
                if OptionMap[name].def != "" {
                        switch OptionMap[name].optionType {
                        case OptionTypeInt64:
                                if val, _ := GetString(name, cmd.options); val == "" {
                                        def, _ := strconv.ParseInt(OptionMap[name].def, 10, 64)
                                        cmd.options[name] = &def
                                }
            case OptionTypeAlternative: 
                fallthrough
                        case OptionTypeString:
                                if val, _ := GetString(name, cmd.options); val == "" {
                                        def := OptionMap[name].def
                                        cmd.options[name] = &def
                                }
                        }
                }
        }
}

// FormatHelper is the interface for all commands to format spec information
type FormatHelper interface {
        formatHelpForWhole() string
        formatIndependHelp() string
}

func (cmd *Command) formatHelpForWhole() string {
        formatStr := "  %-" + strconv.Itoa(MaxCommandNameLen) + "s%s\n%s%s%s\n"
        spec := cmd.getSpecText()
        return fmt.Sprintf(formatStr, cmd.name, spec.paramText, FormatTAB, FormatTAB, spec.synopsisText)
}

func (cmd *Command) getSpecText() SpecText {
    val, _ := GetString(OptionLanguage, helpCommand.command.options)
        switch strings.ToLower(val) {
        case LEnglishLanguage:
                return cmd.specEnglish
        default:
                return cmd.specChinese
        }
}

func (cmd *Command) formatIndependHelp() string {
        spec := cmd.getSpecText()
        text := fmt.Sprintf("SYNOPSIS\n\n%s%s\n", FormatTAB, strings.TrimSpace(spec.synopsisText))
        if spec.syntaxText != "" {
                text += fmt.Sprintf("\nSYNTAX\n\n%s%s\n", FormatTAB, strings.TrimSpace(spec.syntaxText))
        }
        if spec.detailHelpText != "" {
                text += fmt.Sprintf("\nDETAIL DESCRIPTION\n\n%s%s\n", FormatTAB, strings.TrimSpace(spec.detailHelpText))
        }
        if spec.sampleText != "" {
                text += fmt.Sprintf("\nSAMPLE\n\n%s%s\n", FormatTAB, strings.TrimSpace(spec.sampleText))
        }
        if len(cmd.validOptionNames) != 0 {
                text += fmt.Sprintf("\nOPTIONS\n\n%s\n", cmd.formatOptionsHelp(cmd.validOptionNames))
        }
        return text
}

func (cmd *Command) formatOptionsHelp(validOptionNames []string) string {
        text := ""
        for _, optionName := range validOptionNames {
                if option, ok := OptionMap[optionName]; ok {
                        text += cmd.formatOption(option)
                }
        }
        return text
}

func (cmd *Command) formatOption(option Option) string {
        text := FormatTAB
        if option.name != "" {
                text += option.name
                if option.def != "" {
                        text += " " + option.def
                }
        }

        if option.name != "" && option.nameAlias != "" {
                text += ", "
        }

        if option.nameAlias != "" {
                text += option.nameAlias
                if option.def != "" {
                        text += fmt.Sprintf("=%s", option.def)
                }
        }

    val, _ := GetString(OptionLanguage, helpCommand.command.options)
    val = strings.ToLower(val)
    opHelp := option.getHelp(val)
        if opHelp != "" {
                text += fmt.Sprintf("\n%s%s%s\n\n", FormatTAB, FormatTAB, opHelp)
        }

        return text
}

// OSS common function
// get oss client according to bucket(if bucket not empty)
func (cmd *Command) ossClient(bucket string) (*oss.Client, error) {
        endpoint, isCname := cmd.getEndpoint(bucket)
        accessKeyID, _ := GetString(OptionAccessKeyID, cmd.options)
        accessKeySecret, _ := GetString(OptionAccessKeySecret, cmd.options)
        stsToken, _ := GetString(OptionSTSToken, cmd.options)
        client, err := oss.New(endpoint, accessKeyID, accessKeySecret, oss.UseCname(isCname), oss.SecurityToken(stsToken), oss.UserAgent(getUserAgent()), oss.Timeout(120, 1200), oss.EnableCRC(false))
        if err != nil {
                return nil, err
        }
        return client, nil
}

func (cmd *Command) getEndpoint(bucket string) (string, bool) {
        if cnameMap, ok := cmd.configOptions[BucketCnameSection]; ok {
                if endpoint, ok := cnameMap.(map[string]string)[bucket]; ok {
                        return endpoint, true
                }
        }

        if eMap, ok := cmd.configOptions[BucketEndpointSection]; ok {
                if endpoint, ok := eMap.(map[string]string)[bucket]; ok {
                        return endpoint, false
                }
        }

        endpoint, _ := GetString(OptionEndpoint, cmd.options)
        return endpoint, false
}

// get oss operable bucket
func (cmd *Command) ossBucket(bucketName string) (*oss.Bucket, error) {
        client, err := cmd.ossClient(bucketName)
        if err != nil {
                return nil, err
        }

        bucket, err := client.Bucket(bucketName)
        if err != nil {
                return nil, err
        }
        return bucket, nil
}

func (cmd *Command) ossListObjectsRetry(bucket *oss.Bucket, options ...oss.Option) (oss.ListObjectsResult, error) {
        retryTimes, _ := GetInt(OptionRetryTimes, cmd.options)
        for i := 1; ; i++ {
                lor, err := bucket.ListObjects(options...)
                if err == nil || int64(i) >= retryTimes {
                        return lor, err
                }
        }
}

func (cmd *Command) ossGetObjectStatRetry(bucket *oss.Bucket, object string) (http.Header, error) {
        retryTimes, _ := GetInt(OptionRetryTimes, cmd.options)
        for i := 1; ; i++ {
                props, err := bucket.GetObjectDetailedMeta(object)
                if err == nil {
                        return props, err
                }
                if int64(i) >= retryTimes {
                        return props, ObjectError{err, object}
                }
        }
}

func (cmd *Command) ossDownloadFileRetry(bucket *oss.Bucket, objectName, fileName string) error {
        retryTimes, _ := GetInt(OptionRetryTimes, cmd.options)
        for i := 1; ; i++ {
                err := bucket.GetObjectToFile(objectName, fileName)
                if err == nil {
                        return err
                }
                if int64(i) >= retryTimes {
                        return ObjectError{err, objectName}
                }
        }
}


func (cmd *Command) objectProducer(bucket *oss.Bucket, cloudURL CloudURL, chObjects chan<- string, chError chan<- error) {
        pre := oss.Prefix(cloudURL.object)
        marker := oss.Marker("")
        for i := 0; ; i++ {
                lor, err := cmd.ossListObjectsRetry(bucket, marker, pre)
                if err != nil {
                        chError <- err
                        break
                }

                for _, object := range lor.Objects {
                        chObjects <- object.Key
                }

                pre = oss.Prefix(lor.Prefix)
                marker = oss.Marker(lor.NextMarker)
                if !lor.IsTruncated {
                        break
                }
        }
        defer close(chObjects)
        chError <- nil
}

// GetAllCommands returns all commands list
func GetAllCommands() []interface{} {
        return []interface{}{
                &helpCommand,
                &configCommand,
        &makeBucketCommand,
                &listCommand,
                &removeCommand,
                &statCommand,
                &setACLCommand,
                &setMetaCommand,
                &copyCommand,
        &hashCommand,
        &updateCommand,
        }
}

1	package lib
2
3	import (
4	"fmt"
5	oss "github.com/aliyun/aliyun-oss-go-sdk/oss"
6	"net/http"
7	"strconv"
8	"strings"
9	)
10
11	// group spec text of all commands
12	const (
13	GroupTypeNormalCommand string = "\nCommands:\n"
14
15	GroupTypeAdditionalCommand string = "\nAdditional Commands:\n"
16
17	GroupTypeDeprecatedCommand string = "\nDeprecated Commands:\n"
18	)
19
20	// CommandGroups is the array of all group types
21	var CommandGroups = []string{
22	GroupTypeNormalCommand,
23	GroupTypeAdditionalCommand,
24	GroupTypeDeprecatedCommand,
25	}
26
27	// SpecText is the spec text of a command
28	type SpecText struct {
29	synopsisText string
30	paramText string
31	syntaxText string
32	detailHelpText string
33	sampleText string
34	}
35
36	// Command contains all elements of a command, it's the base class of all commands
37	type Command struct {
38	name string
39	nameAlias []string
40	minArgc int
41	maxArgc int
42	specChinese SpecText
43	specEnglish SpecText
44	validOptionNames []string
45	group string
46	args []string
47	options OptionMapType
48	configOptions OptionMapType
49	}
50
51	// Commander is the interface of all commands
52	type Commander interface {
53	RunCommand() error
54	Init(args []string, options OptionMapType) error
55	}
56
57	// RewriteLoadConfiger is the interface for those commands, which do not need to load config, or have other action
58	type RewriteLoadConfiger interface {
59	rewriteLoadConfig(string) error
60	}
61
62	// RewriteAssembleOptioner is the interface for those commands, which do not need to assemble options
63	type RewriteAssembleOptioner interface {
64	rewriteAssembleOptions()
65	}
66
67	// Init is the common functions for all commands, they use Init to initialize itself
68	func (cmd *Command) Init(args []string, options OptionMapType, cmder interface{}) error {	291✔
69	cmd.args = args	291✔
70	cmd.options = options	291✔
71	cmd.configOptions = OptionMapType{}	291✔
72		291✔
73	if err := cmd.checkArgs(); err != nil {	291✔
74	return err	×
75	}	×
76
77	val, _ := GetString(OptionConfigFile, cmd.options)	291✔
78	if err := cmd.loadConfig(val, cmder); err != nil {	291✔
79	return err	×
80	}	×
81
82	if err := cmd.checkOptions(); err != nil {	523✔
83	return err	232✔
84	}	232✔
85
86	cmd.assembleOptions(cmder)	59✔
87	return nil	59✔
88	}
89
90	func (cmd *Command) checkArgs() error {	291✔
91	str := ""	291✔
92	if cmd.minArgc > 1 {	291✔
93	str = "s"	×
94	}	×
95	if len(cmd.args) < cmd.minArgc {	291✔
96	msg := fmt.Sprintf("the command needs at least %d argument%s", cmd.minArgc, str)	×
97	return CommandError{cmd.name, msg}	×
98	}	×
99
100	str = ""	291✔
101	if cmd.minArgc > 1 {	291✔
102	str = "s"	×
103	}	×
104
105	if len(cmd.args) > cmd.maxArgc {	291✔
106	msg := fmt.Sprintf("the command needs at most %d argument%s", cmd.maxArgc, str)	×
107	return CommandError{cmd.name, msg}	×
108	}	×
109	return nil	291✔
110	}
111
112	func (cmd *Command) loadConfig(configFile string, cmder interface{}) error {	291✔
113	if cmdder, ok := cmder.(RewriteLoadConfiger); ok {	579✔
114	return cmdder.rewriteLoadConfig(configFile)	288✔
115	}	288✔
116	var err error	3✔
117	if cmd.configOptions, err = LoadConfig(configFile); err != nil {	3✔
118	return err	×
119	}	×
120	return nil	3✔
121	}
122
123	func (cmd *Command) checkOptions() error {	291✔
124	for name := range cmd.options {	617✔
125	msg := fmt.Sprintf("the command does not support option: \"%s\"", name)	326✔
126	switch OptionMap[name].optionType {	326✔
127	case OptionTypeFlagTrue:	9✔
128	if val, _ := GetBool(name, cmd.options); val {	16✔
129	if FindPos(name, cmd.validOptionNames) == -1 {	8✔
130	return CommandError{cmd.name, msg}	1✔
131	}	1✔
132	}
133	default:	317✔
134	if val, _ := GetString(name, cmd.options); val != "" {	620✔
135	if FindPos(name, cmd.validOptionNames) == -1 {	534✔
136	return CommandError{cmd.name, msg}	231✔
137	}	231✔
138	}
139	}
140	}
141	return nil	59✔
142	}
143
144	func (cmd *Command) assembleOptions(cmder interface{}) {	59✔
145	if cmdder, ok := cmder.(RewriteAssembleOptioner); ok {	71✔
146	cmdder.rewriteAssembleOptions()	12✔
147	return	12✔
148	}	12✔
149
150	for name, option := range cmd.configOptions {	59✔
151	if _, ok := cmd.options[name]; ok {	21✔
152	if OptionMap[name].optionType != OptionTypeFlagTrue {	18✔
153	if val, _ := GetString(name, cmd.options); val == "" {	18✔
154	opval := option.(string)	9✔
155	cmd.options[name] = &opval	9✔
156	delete(cmd.configOptions, name)	9✔
157	} else if name == OptionEndpoint {	9✔
158	delete(cmd.configOptions, BucketCnameSection)	×
159	delete(cmd.configOptions, BucketEndpointSection)	×
160	}	×
161	}
162	}
163	}
164
165	for name := range cmd.options {	103✔
166	if OptionMap[name].def != "" {	89✔
167	switch OptionMap[name].optionType {	33✔
168	case OptionTypeInt64:	×
169	if val, _ := GetString(name, cmd.options); val == "" {	×
170	def, _ := strconv.ParseInt(OptionMap[name].def, 10, 64)	×
171	cmd.options[name] = &def	×
172	}	×
173	case OptionTypeAlternative:	33✔
174	fallthrough	33✔
175	case OptionTypeString:	33✔
176	if val, _ := GetString(name, cmd.options); val == "" {	33✔
177	def := OptionMap[name].def	×
178	cmd.options[name] = &def	×
179	}	×
180	}
181	}
182	}
183	}
184
185	// FormatHelper is the interface for all commands to format spec information
186	type FormatHelper interface {
187	formatHelpForWhole() string
188	formatIndependHelp() string
189	}
190
191	func (cmd *Command) formatHelpForWhole() string {	44✔
192	formatStr := " %-" + strconv.Itoa(MaxCommandNameLen) + "s%s\n%s%s%s\n"	44✔
193	spec := cmd.getSpecText()	44✔
194	return fmt.Sprintf(formatStr, cmd.name, spec.paramText, FormatTAB, FormatTAB, spec.synopsisText)	44✔
195	}	44✔
196
197	func (cmd *Command) getSpecText() SpecText {	74✔
198	val, _ := GetString(OptionLanguage, helpCommand.command.options)	74✔
199	switch strings.ToLower(val) {	74✔
200	case LEnglishLanguage:	42✔
201	return cmd.specEnglish	42✔
202	default:	32✔
203	return cmd.specChinese	32✔
204	}
205	}
206
207	func (cmd *Command) formatIndependHelp() string {	30✔
208	spec := cmd.getSpecText()	30✔
209	text := fmt.Sprintf("SYNOPSIS\n\n%s%s\n", FormatTAB, strings.TrimSpace(spec.synopsisText))	30✔
210	if spec.syntaxText != "" {	60✔
211	text += fmt.Sprintf("\nSYNTAX\n\n%s%s\n", FormatTAB, strings.TrimSpace(spec.syntaxText))	30✔
212	}	30✔
213	if spec.detailHelpText != "" {	60✔
214	text += fmt.Sprintf("\nDETAIL DESCRIPTION\n\n%s%s\n", FormatTAB, strings.TrimSpace(spec.detailHelpText))	30✔
215	}	30✔
216	if spec.sampleText != "" {	60✔
217	text += fmt.Sprintf("\nSAMPLE\n\n%s%s\n", FormatTAB, strings.TrimSpace(spec.sampleText))	30✔
218	}	30✔
219	if len(cmd.validOptionNames) != 0 {	60✔
220	text += fmt.Sprintf("\nOPTIONS\n\n%s\n", cmd.formatOptionsHelp(cmd.validOptionNames))	30✔
221	}	30✔
222	return text	30✔
223	}
224
225	func (cmd *Command) formatOptionsHelp(validOptionNames []string) string {	30✔
226	text := ""	30✔
227	for _, optionName := range validOptionNames {	255✔
228	if option, ok := OptionMap[optionName]; ok {	450✔
229	text += cmd.formatOption(option)	225✔
230	}	225✔
231	}
232	return text	30✔
233	}
234
235	func (cmd *Command) formatOption(option Option) string {	225✔
236	text := FormatTAB	225✔
237	if option.name != "" {	399✔
238	text += option.name	174✔
239	if option.def != "" {	189✔
240	text += " " + option.def	15✔
241	}	15✔
242	}
243
244	if option.name != "" && option.nameAlias != "" {	399✔
245	text += ", "	174✔
246	}	174✔
247
248	if option.nameAlias != "" {	450✔
249	text += option.nameAlias	225✔
250	if option.def != "" {	279✔
251	text += fmt.Sprintf("=%s", option.def)	54✔
252	}	54✔
253	}
254
255	val, _ := GetString(OptionLanguage, helpCommand.command.options)	225✔
256	val = strings.ToLower(val)	225✔
257	opHelp := option.getHelp(val)	225✔
258	if opHelp != "" {	450✔
259	text += fmt.Sprintf("\n%s%s%s\n\n", FormatTAB, FormatTAB, opHelp)	225✔
260	}	225✔
261
262	return text	225✔
263	}
264
265	// OSS common function
266	// get oss client according to bucket(if bucket not empty)
267	func (cmd Command) ossClient(bucket string) (oss.Client, error) {	3✔
268	endpoint, isCname := cmd.getEndpoint(bucket)	3✔
269	accessKeyID, _ := GetString(OptionAccessKeyID, cmd.options)	3✔
270	accessKeySecret, _ := GetString(OptionAccessKeySecret, cmd.options)	3✔
271	stsToken, _ := GetString(OptionSTSToken, cmd.options)	3✔
272	client, err := oss.New(endpoint, accessKeyID, accessKeySecret, oss.UseCname(isCname), oss.SecurityToken(stsToken), oss.UserAgent(getUserAgent()), oss.Timeout(120, 1200), oss.EnableCRC(false))	3✔
273	if err != nil {	3✔
274	return nil, err	×
275	}	×
276	return client, nil	3✔
277	}
278
279	func (cmd *Command) getEndpoint(bucket string) (string, bool) {	3✔
280	if cnameMap, ok := cmd.configOptions[BucketCnameSection]; ok {	3✔
281	if endpoint, ok := cnameMap.(map[string]string)[bucket]; ok {	×
282	return endpoint, true	×
283	}	×
284	}
285
286	if eMap, ok := cmd.configOptions[BucketEndpointSection]; ok {	3✔
287	if endpoint, ok := eMap.(map[string]string)[bucket]; ok {	×
288	return endpoint, false	×
289	}	×
290	}
291
292	endpoint, _ := GetString(OptionEndpoint, cmd.options)	3✔
293	return endpoint, false	3✔
294	}
295
296	// get oss operable bucket
297	func (cmd Command) ossBucket(bucketName string) (oss.Bucket, error) {	2✔
298	client, err := cmd.ossClient(bucketName)	2✔
299	if err != nil {	2✔
300	return nil, err	×
301	}	×
302
303	bucket, err := client.Bucket(bucketName)	2✔
304	if err != nil {	2✔
305	return nil, err	×
306	}	×
307	return bucket, nil	2✔
308	}
309
310	func (cmd Command) ossListObjectsRetry(bucket oss.Bucket, options ...oss.Option) (oss.ListObjectsResult, error) {	2✔
311	retryTimes, _ := GetInt(OptionRetryTimes, cmd.options)	2✔
312	for i := 1; ; i++ {	4✔
313	lor, err := bucket.ListObjects(options...)	2✔
314	if err == nil \|\| int64(i) >= retryTimes {	4✔
315	return lor, err	2✔
316	}	2✔
317	}
318	}
319
320	func (cmd Command) ossGetObjectStatRetry(bucket oss.Bucket, object string) (http.Header, error) {	×
321	retryTimes, _ := GetInt(OptionRetryTimes, cmd.options)	×
322	for i := 1; ; i++ {	×
323	props, err := bucket.GetObjectDetailedMeta(object)	×
324	if err == nil {	×
325	return props, err	×
326	}	×
327	if int64(i) >= retryTimes {	×
328	return props, ObjectError{err, object}	×
329	}	×
330	}
331	}
332
333	func (cmd Command) ossDownloadFileRetry(bucket oss.Bucket, objectName, fileName string) error {	×
334	retryTimes, _ := GetInt(OptionRetryTimes, cmd.options)	×
335	for i := 1; ; i++ {	×
336	err := bucket.GetObjectToFile(objectName, fileName)	×
337	if err == nil {	×
338	return err	×
339	}	×
340	if int64(i) >= retryTimes {	×
341	return ObjectError{err, objectName}	×
342	}	×
343	}
344	}
345
346
347	func (cmd Command) objectProducer(bucket oss.Bucket, cloudURL CloudURL, chObjects chan<- string, chError chan<- error) {	×
348	pre := oss.Prefix(cloudURL.object)	×
349	marker := oss.Marker("")	×
350	for i := 0; ; i++ {	×
351	lor, err := cmd.ossListObjectsRetry(bucket, marker, pre)	×
352	if err != nil {	×
353	chError <- err	×
354	break	×
355	}
356
357	for _, object := range lor.Objects {	×
358	chObjects <- object.Key	×
359	}	×
360
361	pre = oss.Prefix(lor.Prefix)	×
362	marker = oss.Marker(lor.NextMarker)	×
363	if !lor.IsTruncated {	×
364	break	×
365	}
366	}
367	defer close(chObjects)	×
368	chError <- nil	×
369	}
370
371	// GetAllCommands returns all commands list
372	func GetAllCommands() []interface{} {	47✔
373	return []interface{}{	47✔
374	&helpCommand,	47✔
375	&configCommand,	47✔
376	&makeBucketCommand,	47✔
377	&listCommand,	47✔
378	&removeCommand,	47✔
379	&statCommand,	47✔
380	&setACLCommand,	47✔
381	&setMetaCommand,	47✔
382	&copyCommand,	47✔
383	&hashCommand,	47✔
384	&updateCommand,	47✔
385	}	47✔
386	}	47✔

aliyun / ossutil / 52

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous