示例#1
0
        /// 获取对象 ACL
        public void GetObjectAcl()
        {
            //.cssg-snippet-body-start:[get-object-acl]
            try
            {
                string bucket = "examplebucket-1250000000"; //存储桶,格式:BucketName-APPID
                string key    = "exampleobject";            //对象键
                GetObjectACLRequest request = new GetObjectACLRequest(bucket, key);
                //执行请求
                GetObjectACLResult result = cosXml.GetObjectACL(request);
                //对象的 ACL 信息
                AccessControlPolicy acl = result.accessControlPolicy;
            }
            catch (COSXML.CosException.CosClientException clientEx)
            {
                //请求失败
                Console.WriteLine("CosClientException: " + clientEx);
            }
            catch (COSXML.CosException.CosServerException serverEx)
            {
                //请求失败
                Console.WriteLine("CosServerException: " + serverEx.GetInfo());
            }

            //.cssg-snippet-body-end
        }
        public async Task <AccessMode> GetObjectAclAsync(string bucketName, string objectName)
        {
            if (string.IsNullOrEmpty(bucketName))
            {
                throw new ArgumentNullException(nameof(bucketName));
            }
            if (string.IsNullOrEmpty(objectName))
            {
                throw new ArgumentNullException(nameof(objectName));
            }
            bool isPublicRead  = false;
            bool isPublicWrite = false;

            //此处存在一个问题
            //当储存桶权限设置为公共读,对象权限设置为继承,但是获取到的权限仍然是私有的。但是此时对象是可以呗公共访问到。
            //同样,储存桶设置为公共读,对象设置为私有,获取到的权限仍然是私有的。

            //获取储存桶权限
            //AccessMode bucketMode = await GetBucketAclAsync(bucketName);
            //switch (bucketMode)
            //{
            //    case AccessMode.PublicRead:
            //        {
            //            isPublicRead = true;
            //            isPublicWrite = false;
            //            break;
            //        }
            //    case AccessMode.PublicReadWrite:
            //        {
            //            isPublicRead = true;
            //            isPublicWrite = true;
            //            break;
            //        }
            //    case AccessMode.Default:
            //    case AccessMode.Private:
            //    default:
            //        {
            //            isPublicRead = false;
            //            isPublicWrite = false;
            //            break;
            //        }
            //}

            bucketName = ConvertBucketName(bucketName);
            GetObjectACLRequest request = new GetObjectACLRequest(bucketName, objectName);
            GetObjectACLResult  result  = _client.GetObjectACL(request);
            AccessControlPolicy acl     = result.accessControlPolicy;

            if (acl != null &&
                acl.accessControlList != null &&
                acl.accessControlList.grants != null &&
                acl.accessControlList.grants.Count > 0)
            {
                foreach (var item in acl.accessControlList.grants)
                {
                    if (string.IsNullOrEmpty(item.grantee.uri))
                    {
                        continue;
                    }
                    if (item.grantee.uri.Contains("allusers", StringComparison.OrdinalIgnoreCase))
                    {
                        switch (item.permission.ToLower())
                        {
                        case "read":
                            isPublicRead = true;
                            break;

                        case "write":
                            isPublicWrite = true;
                            break;
                        }
                    }
                }
            }

            //结果
            if (isPublicRead && !isPublicWrite)
            {
                return(await Task.FromResult(AccessMode.PublicRead));
            }
            else if (isPublicRead && isPublicWrite)
            {
                return(await Task.FromResult(AccessMode.PublicReadWrite));
            }
            else if (!isPublicRead && isPublicWrite)
            {
                return(await Task.FromResult(AccessMode.Private));
            }
            else
            {
                return(await Task.FromResult(AccessMode.Private));
            }
        }