aliyun / ossutil / 53

pending completion

Build # 53

Build Type

Pull #2

travis-ci

Committed by

web-flow

Commit Message

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

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

Pull Request Pull Request #2: Features/travis ci

Run Details

79 of 79 new or added lines in 10 files covered. (100.0%)

651 of 2578 relevant lines covered (25.25%)

19.65 hits per line

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

11.59

/lib/set_acl.go

package lib

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

var aclMap = map[oss.ACLType][]string{
        oss.ACLPublicReadWrite: []string{},
        oss.ACLPublicRead:      []string{},
        oss.ACLPrivate:         []string{},
        oss.ACLDefault:         []string{},
}

var bucketACLList = []oss.ACLType{
        oss.ACLPublicReadWrite,
        oss.ACLPublicRead,
        oss.ACLPrivate,
}

var objectACLList = []oss.ACLType{
        oss.ACLPublicReadWrite,
        oss.ACLPublicRead,
        oss.ACLPrivate,
        oss.ACLDefault,
}

type setACLType int

const (
        bucketACL setACLType = iota
        objectACL
)

func formatACLString(aclType setACLType, sep string) string {
        var list []oss.ACLType
        if aclType == bucketACL {
                list = bucketACLList
        } else {
                list = objectACLList
        }

        strList := []string{}
        for _, acl := range list {
                str := string(acl)
                if len(aclMap[acl]) != 0 {
                        str += "(" + strings.Join(aclMap[acl][:], ",") + ")"
                }
                strList = append(strList, str)
        }
        return strings.Join(strList, sep)
}

var specChineseSetACL = SpecText{

        synopsisText: "设置bucket或者objects的acl",

        paramText: "url [acl] [options]",

        syntaxText: ` 
    ossutil set-acl oss://bucket[/prefix] [acl] [-r] [-b] [-f] [-c file] 
`,

        detailHelpText: ` 
    该命令设置指定bucket或者objects的acl。使用命令时若缺失了acl信息时，ossutil会询问用户acl信息。

        （1）设置bucket的acl，参考用法1)
        （2）设置单个object的acl，参考用法2)
        （3）批量设置objects的acl，不设置bucket的acl，参考用法3)

    对bucket设置acl，需要添加--bucket选项，否则视为对其中的objects设置acl。
    该命令不支持同时设置bucket和objects的acl，请分开操作。

    结果：显示命令耗时前未报错，则表示成功设置。
    查看bucket或者object的acl信息，请使用stat命令。

ACL：

    bucket的acl有三种，括号里为ossutil额外支持的简写模式：
        ` + formatACLString(bucketACL, "\n        ") + `

    object的acl有四种：
        ` + formatACLString(objectACL, "\n        ") + `

    acl的详细信息请参见：https://help.aliyun.com/document_detail/31867.html?spm=5176.doc31960.6.147.8dVwsh中的权限控制。

用法：

    该命令有三种用法：

    1) ossutil set-acl oss://bucket [acl] -b [-c file]
        当设置了--bucket选项时，ossutil会尝试设置bucket的acl，此时不支持--recursive选项，并且请
    确保输入的url精确匹配想要设置acl的bucket，无论--force选项是否指定，都不会进行询问提示。如果
    用户在命令行中缺失acl信息，会进入交互模式，询问用户的acl信息。 

    2) ossutil set-acl oss://bucket/object [acl] [-c file]
        该用法设置指定单个object的acl，当指定object不存在时，ossutil会提示错误，此时请确保指定的
    url精确匹配需要设置acl的object，并且不要指定--recursive选项（否则ossutil会进行前缀匹配，设置
    多个objects的acl），无论--force选项是否指定，都不会进行询问提示。如果用户在命令行中缺失acl信
    息，会进入交互模式，询问用户的acl信息。

    3) ossutil set-acl oss://bucket[/prefix] [acl] -r [-f] [-c file]
        该用法可批量设置objects的acl，此时必须输入--recursive选项，ossutil会查找所有前缀匹配url的
    objects，设置它们的acl，当错误出现时会终止命令。此时不支持--bucket选项，即ossutil不支持同时设
    置bucket和其中objects的acl，如有需要，请分开操作。如果--force选项被指定，则不会进行询问提示。
    如果用户在命令行中缺失acl信息，会进入交互模式，询问用户的acl信息。
`,

        sampleText: ` 
    (1)ossutil set-acl oss://bucket1 public-read-write -b 

    (2)ossutil set-acl oss://bucket1/obj1 pr 

    (3)ossutil set-acl oss://bucket1/obj def -r
`,
}

var specEnglishSetACL = SpecText{

        synopsisText: "Set acl on bucket or objects",

        paramText: "url [acl] [options]",

        syntaxText: ` 
    ossutil set-acl oss://bucket[/prefix] [acl] [-r] [-b] [-f] [-c file] 
`,

        detailHelpText: ` 
    The command set acl on the specified bucket or objects. If you use the command 
    witout acl information, ossutil will ask user for it.

    (1) set acl on bucket, see usage 1)
    (2) set acl on single object, see usage 2)
    (3) batch set acl on many objects, see usage 3)

    When set acl on bucket, the --bucket option must be specified. 
    Set acl on bucket an objects inside simultaneously is not supported, please 
    operate independently.

    Result: if no error displayed before show elasped time, then the setting is completed successfully.
    User can use stat command to check the acl information of bucket or objects.

ACL:

    ossutil supports following bucket acls, shorthand versions in brackets:
        ` + formatACLString(bucketACL, "\n        ") + `

    ossutil support following objet acls:
        ` + formatACLString(objectACL, "\n        ") + `

    More information about acl see ACL Control in https://help.aliyun.com/document_detail/31867.html?spm=5176.doc31960.6.147.8dVwsh.

Usage：

    There are three usages:    

    1) ossutil set-acl oss://bucket [acl] -b [-c file]
        If --bucket option is specified, ossutil will try to set acl on bucket. In the 
    usage, please make sure url exactly specified the bucket you want to set acl on, 
    and --recursive option is not supported here. No matter --force option is specified 
    or not, ossutil will not show prompt question. If acl information is missed, ossutil 
    will enter interactive mode and ask you for it. 

    2) ossutil set-acl oss://bucket/object [acl] [-c file]
        The usage set acl on single object, if object not exist, error occurs. In the 
    usage, please make sure url exactly specified the object you want to set acl on, 
    and --recursive option is not specified(or ossutil will search for prefix-matching 
    objects and set acl on those objects). No matter --force option is specified or not, 
    ossutil will not show prompt question. If acl information is missed, ossutil will 
    enter interactive mode and ask you for it. 

    3) ossutil set-acl oss://bucket[/prefix] [acl] -r [-f] [-c file]
        The usage can set acl on many objects, --recursive option is required for the 
    usage, ossutil will search for prefix-matching objects and set acl on those objects, 
    if error occurs, the operation is terminated. In the usage, --bucket option is not 
    supported, which means set acl on bucket an objects inside simultaneously is not 
    supported. If --force option is specified, ossutil will not show prompt question. If 
    acl information is missed, ossutil will enter interactive mode and ask you for it. 
`,

        sampleText: ` 
    (1)ossutil set-acl oss://bucket1 public-read-write -b 

    (2)ossutil set-acl oss://bucket1/obj1 pr 

    (3)ossutil set-acl oss://bucket1/obj def -r
`,
}

// SetACLCommand is the command set acl 
type SetACLCommand struct {
        command Command
}

var setACLCommand = SetACLCommand{
        command: Command{
                name:        "set-acl",
                nameAlias:   []string{"setacl", "set_acl"},
                minArgc:     1,
                maxArgc:     2,
                specChinese: specChineseSetACL,
                specEnglish: specEnglishSetACL,
                group:       GroupTypeNormalCommand,
                validOptionNames: []string{
                        OptionRecursion,
                        OptionBucket,
                        OptionForce,
                        OptionConfigFile,
            OptionEndpoint,
            OptionAccessKeyID,
            OptionAccessKeySecret,
            OptionSTSToken,
                        OptionRetryTimes,
                        OptionRoutines,
                },
        },
}

// function for FormatHelper interface
func (sc *SetACLCommand) formatHelpForWhole() string {
        return sc.command.formatHelpForWhole()
}

func (sc *SetACLCommand) formatIndependHelp() string {
        return sc.command.formatIndependHelp()
}

// Init simulate inheritance, and polymorphism
func (sc *SetACLCommand) Init(args []string, options OptionMapType) error {
        return sc.command.Init(args, options, sc)
}

// RunCommand simulate inheritance, and polymorphism
func (sc *SetACLCommand) RunCommand() error {
        recursive, _ := GetBool(OptionRecursion, sc.command.options)
        toBucket, _ := GetBool(OptionBucket, sc.command.options)
        force, _ := GetBool(OptionForce, sc.command.options)
        routines, _ := GetInt(OptionRoutines, sc.command.options)

        cloudURL, err := CloudURLFromString(sc.command.args[0])
        if err != nil {
                return err
        }

        if cloudURL.bucket == "" {
                return fmt.Errorf("invalid cloud url: %s, miss bucket", sc.command.args[0])
        }

        bucket, err := sc.command.ossBucket(cloudURL.bucket)
        if err != nil {
                return err
        }

        if toBucket {
                return sc.setBucketACL(&bucket.Client, cloudURL, recursive)
        }
        if !recursive {
                return sc.setObjectACL(bucket, cloudURL)
        }
        return sc.batchSetObjectACL(bucket, cloudURL, force, routines)
}

func (sc *SetACLCommand) setBucketACL(client *oss.Client, cloudURL CloudURL, recursive bool) error {
        if cloudURL.object != "" {
                return fmt.Errorf("set bucket acl invalid url: %s, object not empty, if you mean set object acl, you should not use --bucket option", sc.command.args[0])
        }

        if recursive {
                return fmt.Errorf("set bucket acl do not support --recursive option, if you mean set object acl recursivlly, you should not use --bucket option")
        }

        acl, err := sc.getACL(bucketACL, recursive)
        if err != nil {
                return err
        }

        return sc.ossSetBucketACLRetry(client, cloudURL.bucket, acl)
}

func (sc *SetACLCommand) getACL(aclType setACLType, recursive bool) (oss.ACLType, error) {
        var acl string
        if len(sc.command.args) == 2 {
                acl = sc.command.args[1]
        } else {
        str := "bucket"
        if aclType == objectACL {
            str = "object"
            if recursive {
                str = "objects"
            }
        }
                fmt.Printf("Please enter the acl you want to set on the %s(%s):", str, formatACLString(aclType, ", "))
                if _, err := fmt.Scanln(&acl); err != nil {
                        return "", fmt.Errorf("invalid acl: %s, please check", acl)
                }
        }

        return sc.checkACL(acl, aclType)
}

func (sc *SetACLCommand) checkACL(acl string, aclType setACLType) (oss.ACLType, error) {
        var list []oss.ACLType
        if aclType == bucketACL {
                list = bucketACLList
        } else {
                list = objectACLList
        }

        for _, acll := range list {
                if acl == string(acll) {
                        return acll, nil
                }
                for _, aclll := range aclMap[acll] {
                        if acl == aclll {
                                return acll, nil
                        }
                }
        }
        return "", fmt.Errorf("invalid acl: %s, please check", acl)
}

func (sc *SetACLCommand) ossSetBucketACLRetry(client *oss.Client, bucket string, acl oss.ACLType) error {
        retryTimes, _ := GetInt(OptionRetryTimes, sc.command.options)
        for i := 1; ; i++ {
                err := client.SetBucketACL(bucket, acl)
                if err == nil {
                        return err
                }
                if int64(i) >= retryTimes {
                        return BucketError{err, bucket}
                }
        }
}

func (sc *SetACLCommand) setObjectACL(bucket *oss.Bucket, cloudURL CloudURL) error {
        if cloudURL.object == "" {
                return fmt.Errorf("set object acl invalid url: %s, object not empty, if you mean set bucket acl, you should use --bucket option", sc.command.args[0])
        }

        acl, err := sc.getACL(objectACL, false)
        if err != nil {
                return err
        }

        return sc.ossSetObjectACLRetry(bucket, cloudURL.object, acl)
}

func (sc *SetACLCommand) ossSetObjectACLRetry(bucket *oss.Bucket, object string, acl oss.ACLType) error {
        retryTimes, _ := GetInt(OptionRetryTimes, sc.command.options)
        for i := 1; ; i++ {
                err := bucket.SetObjectACL(object, acl)
                if err == nil {
                        return err
                }
                if int64(i) >= retryTimes {
                        return ObjectError{err, object}
                }
        }
}

func (sc *SetACLCommand) batchSetObjectACL(bucket *oss.Bucket, cloudURL CloudURL, force bool, routines int64) error {
        if !force {
                var val string
                fmt.Printf("Do you really mean to recursivlly set acl on objects of %s(y or n)? ", sc.command.args[0])
                if _, err := fmt.Scanln(&val); err != nil || (val != "yes" && val != "y") {
                        fmt.Println("operation is canceled.")
                        return nil
                }
        }

        acl, err := sc.getACL(objectACL, true)
        if err != nil {
                return err
        }

        // producer list objects
        // consumer set acl
        chObjects := make(chan string, ChannelBuf)
        chFinishObjects := make(chan string, ChannelBuf)
        chError := make(chan error, routines+1)
        go sc.command.objectProducer(bucket, cloudURL, chObjects, chError)
        for i := 0; int64(i) < routines; i++ {
                go sc.setObjectACLConsumer(bucket, acl, chObjects, chFinishObjects, chError)
        }

        completed := 0
        num := 0
        for int64(completed) <= routines {
                select {
                case <-chFinishObjects:
                        num++
                        fmt.Printf("\rsetted object acl on %d objects...", num)
                case err := <-chError:
                        if err != nil {
                                fmt.Printf("\rsetted object acl on %d objects, when error happens.\n", num)
                                return err
                        }
                        completed++
                }
        }
        fmt.Printf("\rSucceed: scanned %d objects, setted object acl on %d objects.\n", num, num)
        return nil
}

func (sc *SetACLCommand) setObjectACLConsumer(bucket *oss.Bucket, acl oss.ACLType, chObjects <-chan string, chFinishObjects chan<- string, chError chan<- error) {
        for object := range chObjects {
                err := sc.ossSetObjectACLRetry(bucket, object, acl)
                if err != nil {
                        chError <- err
                        return
                }
                chFinishObjects <- object
        }

        chError <- nil
}

1	package lib
2
3	import (
4	"fmt"
5	oss "github.com/aliyun/aliyun-oss-go-sdk/oss"
6	"strings"
7	)
8
9	var aclMap = map[oss.ACLType][]string{
10	oss.ACLPublicReadWrite: []string{},
11	oss.ACLPublicRead: []string{},
12	oss.ACLPrivate: []string{},
13	oss.ACLDefault: []string{},
14	}
15
16	var bucketACLList = []oss.ACLType{
17	oss.ACLPublicReadWrite,
18	oss.ACLPublicRead,
19	oss.ACLPrivate,
20	}
21
22	var objectACLList = []oss.ACLType{
23	oss.ACLPublicReadWrite,
24	oss.ACLPublicRead,
25	oss.ACLPrivate,
26	oss.ACLDefault,
27	}
28
29	type setACLType int
30
31	const (
32	bucketACL setACLType = iota
33	objectACL
34	)
35
36	func formatACLString(aclType setACLType, sep string) string {	6✔
37	var list []oss.ACLType	6✔
38	if aclType == bucketACL {	10✔
39	list = bucketACLList	4✔
40	} else {	6✔
41	list = objectACLList	2✔
42	}	2✔
43
44	strList := []string{}	6✔
45	for _, acl := range list {	26✔
46	str := string(acl)	20✔
47	if len(aclMap[acl]) != 0 {	20✔
48	str += "(" + strings.Join(aclMap[acl][:], ",") + ")"	×
49	}	×
50	strList = append(strList, str)	20✔
51	}
52	return strings.Join(strList, sep)	6✔
53	}
54
55	var specChineseSetACL = SpecText{
56
57	synopsisText: "设置bucket或者objects的acl",
58
59	paramText: "url [acl] [options]",
60
61	syntaxText: `
62	ossutil set-acl oss://bucket[/prefix] [acl] [-r] [-b] [-f] [-c file]
63	`,
64
65	detailHelpText: `
66	该命令设置指定bucket或者objects的acl。使用命令时若缺失了acl信息时，ossutil会询问用户acl信息。
67
68	（1）设置bucket的acl，参考用法1)
69	（2）设置单个object的acl，参考用法2)
70	（3）批量设置objects的acl，不设置bucket的acl，参考用法3)
71
72	对bucket设置acl，需要添加--bucket选项，否则视为对其中的objects设置acl。
73	该命令不支持同时设置bucket和objects的acl，请分开操作。
74
75	结果：显示命令耗时前未报错，则表示成功设置。
76	查看bucket或者object的acl信息，请使用stat命令。
77
78	ACL：
79
80	bucket的acl有三种，括号里为ossutil额外支持的简写模式：
81	` + formatACLString(bucketACL, "\n ") + `
82
83	object的acl有四种：
84	` + formatACLString(objectACL, "\n ") + `
85
86	acl的详细信息请参见：https://help.aliyun.com/document_detail/31867.html?spm=5176.doc31960.6.147.8dVwsh中的权限控制。
87
88	用法：
89
90	该命令有三种用法：
91
92	1) ossutil set-acl oss://bucket [acl] -b [-c file]
93	当设置了--bucket选项时，ossutil会尝试设置bucket的acl，此时不支持--recursive选项，并且请
94	确保输入的url精确匹配想要设置acl的bucket，无论--force选项是否指定，都不会进行询问提示。如果
95	用户在命令行中缺失acl信息，会进入交互模式，询问用户的acl信息。
96
97	2) ossutil set-acl oss://bucket/object [acl] [-c file]
98	该用法设置指定单个object的acl，当指定object不存在时，ossutil会提示错误，此时请确保指定的
99	url精确匹配需要设置acl的object，并且不要指定--recursive选项（否则ossutil会进行前缀匹配，设置
100	多个objects的acl），无论--force选项是否指定，都不会进行询问提示。如果用户在命令行中缺失acl信
101	息，会进入交互模式，询问用户的acl信息。
102
103	3) ossutil set-acl oss://bucket[/prefix] [acl] -r [-f] [-c file]
104	该用法可批量设置objects的acl，此时必须输入--recursive选项，ossutil会查找所有前缀匹配url的
105	objects，设置它们的acl，当错误出现时会终止命令。此时不支持--bucket选项，即ossutil不支持同时设
106	置bucket和其中objects的acl，如有需要，请分开操作。如果--force选项被指定，则不会进行询问提示。
107	如果用户在命令行中缺失acl信息，会进入交互模式，询问用户的acl信息。
108	`,
109
110	sampleText: `
111	(1)ossutil set-acl oss://bucket1 public-read-write -b
112
113	(2)ossutil set-acl oss://bucket1/obj1 pr
114
115	(3)ossutil set-acl oss://bucket1/obj def -r
116	`,
117	}
118
119	var specEnglishSetACL = SpecText{
120
121	synopsisText: "Set acl on bucket or objects",
122
123	paramText: "url [acl] [options]",
124
125	syntaxText: `
126	ossutil set-acl oss://bucket[/prefix] [acl] [-r] [-b] [-f] [-c file]
127	`,
128
129	detailHelpText: `
130	The command set acl on the specified bucket or objects. If you use the command
131	witout acl information, ossutil will ask user for it.
132
133	(1) set acl on bucket, see usage 1)
134	(2) set acl on single object, see usage 2)
135	(3) batch set acl on many objects, see usage 3)
136
137	When set acl on bucket, the --bucket option must be specified.
138	Set acl on bucket an objects inside simultaneously is not supported, please
139	operate independently.
140
141	Result: if no error displayed before show elasped time, then the setting is completed successfully.
142	User can use stat command to check the acl information of bucket or objects.
143
144	ACL:
145
146	ossutil supports following bucket acls, shorthand versions in brackets:
147	` + formatACLString(bucketACL, "\n ") + `
148
149	ossutil support following objet acls:
150	` + formatACLString(objectACL, "\n ") + `
151
152	More information about acl see ACL Control in https://help.aliyun.com/document_detail/31867.html?spm=5176.doc31960.6.147.8dVwsh.
153
154	Usage：
155
156	There are three usages:
157
158	1) ossutil set-acl oss://bucket [acl] -b [-c file]
159	If --bucket option is specified, ossutil will try to set acl on bucket. In the
160	usage, please make sure url exactly specified the bucket you want to set acl on,
161	and --recursive option is not supported here. No matter --force option is specified
162	or not, ossutil will not show prompt question. If acl information is missed, ossutil
163	will enter interactive mode and ask you for it.
164
165	2) ossutil set-acl oss://bucket/object [acl] [-c file]
166	The usage set acl on single object, if object not exist, error occurs. In the
167	usage, please make sure url exactly specified the object you want to set acl on,
168	and --recursive option is not specified(or ossutil will search for prefix-matching
169	objects and set acl on those objects). No matter --force option is specified or not,
170	ossutil will not show prompt question. If acl information is missed, ossutil will
171	enter interactive mode and ask you for it.
172
173	3) ossutil set-acl oss://bucket[/prefix] [acl] -r [-f] [-c file]
174	The usage can set acl on many objects, --recursive option is required for the
175	usage, ossutil will search for prefix-matching objects and set acl on those objects,
176	if error occurs, the operation is terminated. In the usage, --bucket option is not
177	supported, which means set acl on bucket an objects inside simultaneously is not
178	supported. If --force option is specified, ossutil will not show prompt question. If
179	acl information is missed, ossutil will enter interactive mode and ask you for it.
180	`,
181
182	sampleText: `
183	(1)ossutil set-acl oss://bucket1 public-read-write -b
184
185	(2)ossutil set-acl oss://bucket1/obj1 pr
186
187	(3)ossutil set-acl oss://bucket1/obj def -r
188	`,
189	}
190
191	// SetACLCommand is the command set acl
192	type SetACLCommand struct {
193	command Command
194	}
195
196	var setACLCommand = SetACLCommand{
197	command: Command{
198	name: "set-acl",
199	nameAlias: []string{"setacl", "set_acl"},
200	minArgc: 1,
201	maxArgc: 2,
202	specChinese: specChineseSetACL,
203	specEnglish: specEnglishSetACL,
204	group: GroupTypeNormalCommand,
205	validOptionNames: []string{
206	OptionRecursion,
207	OptionBucket,
208	OptionForce,
209	OptionConfigFile,
210	OptionEndpoint,
211	OptionAccessKeyID,
212	OptionAccessKeySecret,
213	OptionSTSToken,
214	OptionRetryTimes,
215	OptionRoutines,
216	},
217	},
218	}
219
220	// function for FormatHelper interface
221	func (sc *SetACLCommand) formatHelpForWhole() string {	4✔
222	return sc.command.formatHelpForWhole()	4✔
223	}	4✔
224
225	func (sc *SetACLCommand) formatIndependHelp() string {	3✔
226	return sc.command.formatIndependHelp()	3✔
227	}	3✔
228
229	// Init simulate inheritance, and polymorphism
230	func (sc *SetACLCommand) Init(args []string, options OptionMapType) error {	×
231	return sc.command.Init(args, options, sc)	×
232	}	×
233
234	// RunCommand simulate inheritance, and polymorphism
235	func (sc *SetACLCommand) RunCommand() error {	×
236	recursive, _ := GetBool(OptionRecursion, sc.command.options)	×
237	toBucket, _ := GetBool(OptionBucket, sc.command.options)	×
238	force, _ := GetBool(OptionForce, sc.command.options)	×
239	routines, _ := GetInt(OptionRoutines, sc.command.options)	×
240		×
241	cloudURL, err := CloudURLFromString(sc.command.args[0])	×
242	if err != nil {	×
243	return err	×
244	}	×
245
246	if cloudURL.bucket == "" {	×
247	return fmt.Errorf("invalid cloud url: %s, miss bucket", sc.command.args[0])	×
248	}	×
249
250	bucket, err := sc.command.ossBucket(cloudURL.bucket)	×
251	if err != nil {	×
252	return err	×
253	}	×
254
255	if toBucket {	×
256	return sc.setBucketACL(&bucket.Client, cloudURL, recursive)	×
257	}	×
258	if !recursive {	×
259	return sc.setObjectACL(bucket, cloudURL)	×
260	}	×
261	return sc.batchSetObjectACL(bucket, cloudURL, force, routines)	×
262	}
263
264	func (sc SetACLCommand) setBucketACL(client oss.Client, cloudURL CloudURL, recursive bool) error {	×
265	if cloudURL.object != "" {	×
266	return fmt.Errorf("set bucket acl invalid url: %s, object not empty, if you mean set object acl, you should not use --bucket option", sc.command.args[0])	×
267	}	×
268
269	if recursive {	×
270	return fmt.Errorf("set bucket acl do not support --recursive option, if you mean set object acl recursivlly, you should not use --bucket option")	×
271	}	×
272
273	acl, err := sc.getACL(bucketACL, recursive)	×
274	if err != nil {	×
275	return err	×
276	}	×
277
278	return sc.ossSetBucketACLRetry(client, cloudURL.bucket, acl)	×
279	}
280
281	func (sc *SetACLCommand) getACL(aclType setACLType, recursive bool) (oss.ACLType, error) {	×
282	var acl string	×
283	if len(sc.command.args) == 2 {	×
284	acl = sc.command.args[1]	×
285	} else {	×
286	str := "bucket"	×
287	if aclType == objectACL {	×
288	str = "object"	×
289	if recursive {	×
290	str = "objects"	×
291	}	×
292	}
293	fmt.Printf("Please enter the acl you want to set on the %s(%s):", str, formatACLString(aclType, ", "))	×
294	if _, err := fmt.Scanln(&acl); err != nil {	×
295	return "", fmt.Errorf("invalid acl: %s, please check", acl)	×
296	}	×
297	}
298
299	return sc.checkACL(acl, aclType)	×
300	}
301
302	func (sc *SetACLCommand) checkACL(acl string, aclType setACLType) (oss.ACLType, error) {	×
303	var list []oss.ACLType	×
304	if aclType == bucketACL {	×
305	list = bucketACLList	×
306	} else {	×
307	list = objectACLList	×
308	}	×
309
310	for _, acll := range list {	×
311	if acl == string(acll) {	×
312	return acll, nil	×
313	}	×
314	for _, aclll := range aclMap[acll] {	×
315	if acl == aclll {	×
316	return acll, nil	×
317	}	×
318	}
319	}
320	return "", fmt.Errorf("invalid acl: %s, please check", acl)	×
321	}
322
323	func (sc SetACLCommand) ossSetBucketACLRetry(client oss.Client, bucket string, acl oss.ACLType) error {	×
324	retryTimes, _ := GetInt(OptionRetryTimes, sc.command.options)	×
325	for i := 1; ; i++ {	×
326	err := client.SetBucketACL(bucket, acl)	×
327	if err == nil {	×
328	return err	×
329	}	×
330	if int64(i) >= retryTimes {	×
331	return BucketError{err, bucket}	×
332	}	×
333	}
334	}
335
336	func (sc SetACLCommand) setObjectACL(bucket oss.Bucket, cloudURL CloudURL) error {	×
337	if cloudURL.object == "" {	×
338	return fmt.Errorf("set object acl invalid url: %s, object not empty, if you mean set bucket acl, you should use --bucket option", sc.command.args[0])	×
339	}	×
340
341	acl, err := sc.getACL(objectACL, false)	×
342	if err != nil {	×
343	return err	×
344	}	×
345
346	return sc.ossSetObjectACLRetry(bucket, cloudURL.object, acl)	×
347	}
348
349	func (sc SetACLCommand) ossSetObjectACLRetry(bucket oss.Bucket, object string, acl oss.ACLType) error {	×
350	retryTimes, _ := GetInt(OptionRetryTimes, sc.command.options)	×
351	for i := 1; ; i++ {	×
352	err := bucket.SetObjectACL(object, acl)	×
353	if err == nil {	×
354	return err	×
355	}	×
356	if int64(i) >= retryTimes {	×
357	return ObjectError{err, object}	×
358	}	×
359	}
360	}
361
362	func (sc SetACLCommand) batchSetObjectACL(bucket oss.Bucket, cloudURL CloudURL, force bool, routines int64) error {	×
363	if !force {	×
364	var val string	×
365	fmt.Printf("Do you really mean to recursivlly set acl on objects of %s(y or n)? ", sc.command.args[0])	×
366	if _, err := fmt.Scanln(&val); err != nil \|\| (val != "yes" && val != "y") {	×
367	fmt.Println("operation is canceled.")	×
368	return nil	×
369	}	×
370	}
371
372	acl, err := sc.getACL(objectACL, true)	×
373	if err != nil {	×
374	return err	×
375	}	×
376
377	// producer list objects
378	// consumer set acl
379	chObjects := make(chan string, ChannelBuf)	×
380	chFinishObjects := make(chan string, ChannelBuf)	×
381	chError := make(chan error, routines+1)	×
382	go sc.command.objectProducer(bucket, cloudURL, chObjects, chError)	×
383	for i := 0; int64(i) < routines; i++ {	×
384	go sc.setObjectACLConsumer(bucket, acl, chObjects, chFinishObjects, chError)	×
385	}	×
386
387	completed := 0	×
388	num := 0	×
389	for int64(completed) <= routines {	×
390	select {	×
391	case <-chFinishObjects:	×
392	num++	×
393	fmt.Printf("\rsetted object acl on %d objects...", num)	×
394	case err := <-chError:	×
395	if err != nil {	×
396	fmt.Printf("\rsetted object acl on %d objects, when error happens.\n", num)	×
397	return err	×
398	}	×
399	completed++	×
400	}
401	}
402	fmt.Printf("\rSucceed: scanned %d objects, setted object acl on %d objects.\n", num, num)	×
403	return nil	×
404	}
405
406	func (sc SetACLCommand) setObjectACLConsumer(bucket oss.Bucket, acl oss.ACLType, chObjects <-chan string, chFinishObjects chan<- string, chError chan<- error) {	×
407	for object := range chObjects {	×
408	err := sc.ossSetObjectACLRetry(bucket, object, acl)	×
409	if err != nil {	×
410	chError <- err	×
411	return	×
412	}	×
413	chFinishObjects <- object	×
414	}
415
416	chError <- nil	×
417	}

aliyun / ossutil / 53

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