/// <summary>
/// Initiates the asynchronous execution of the PutACL operation.
/// <seealso cref="Amazon.S3.IAmazonS3.PutACL"/>
/// </summary>
///
/// <param name="putACLRequest">Container for the necessary parameters to execute the PutACL operation on IAmazonS3.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
public IAsyncResult BeginPutACL(PutACLRequest putACLRequest, AsyncCallback callback, object state)
{
return invokePutACL(putACLRequest, callback, state, false);
}
IAsyncResult invokePutACL(PutACLRequest putACLRequest, AsyncCallback callback, object state, bool synchronized)
{
IRequest irequest = new PutACLRequestMarshaller().Marshall(putACLRequest);
var unmarshaller = PutACLResponseUnmarshaller.GetInstance();
AsyncResult result = new AsyncResult(irequest, callback, state, synchronized, signer, unmarshaller);
Invoke(result);
return result;
}
/// <summary>
/// Initiates the asynchronous execution of the PutACL operation.
/// This API is supported only when AWSConfigs.HttpClient is set to AWSConfigs.HttpClientOption.UnityWebRequest, the default value for this configuration option is AWSConfigs.HttpClientOption.UnityWWW
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the PutACL operation on AmazonS3Client.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
public void PutACLAsync(PutACLRequest request, AmazonServiceCallback<PutACLRequest, PutACLResponse> callback, AsyncOptions options = null)
{
if (AWSConfigs.HttpClient == AWSConfigs.HttpClientOption.UnityWWW)
{
throw new InvalidOperationException("PutACL is only allowed with AWSConfigs.HttpClientOption.UnityWebRequest API option");
}
options = options == null?new AsyncOptions():options;
var marshaller = new PutACLRequestMarshaller();
var unmarshaller = PutACLResponseUnmarshaller.Instance;
Action<AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult<PutACLRequest,PutACLResponse> responseObject
= new AmazonServiceResult<PutACLRequest,PutACLResponse>((PutACLRequest)req, (PutACLResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke<PutACLRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
/// <summary>
/// <para>uses the acl subresource to set the access control list (ACL) permissions for an object that already exists in a bucket</para>
/// </summary>
///
/// <param name="putACLRequest">Container for the necessary parameters to execute the PutObjectAcl service method on AmazonS3.</param>
///
public PutACLResponse PutACL(PutACLRequest putACLRequest)
{
IAsyncResult asyncResult = invokePutACL(putACLRequest, null, null, true);
return EndPutACL(asyncResult);
}
internal PutACLResponse PutACL(PutACLRequest request)
{
var marshaller = new PutACLRequestMarshaller();
var unmarshaller = PutACLResponseUnmarshaller.Instance;
return Invoke<PutACLRequest,PutACLResponse>(request, marshaller, unmarshaller);
}
/// <summary>
/// <para>uses the acl subresource to set the access control list (ACL) permissions for an object that already exists in a bucket</para>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the PutObjectAcl service method on AmazonS3.</param>
public PutACLResponse PutACL(PutACLRequest request)
{
var task = PutACLAsync(request);
try
{
return task.Result;
}
catch(AggregateException e)
{
ExceptionDispatchInfo.Capture(e.InnerException).Throw();
return null;
}
}
/// <summary>
/// Initiates the asynchronous execution of the PutACL operation.
/// <seealso cref="Amazon.S3.IAmazonS3.PutACL"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the PutACL operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task<PutACLResponse> PutACLAsync(PutACLRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new PutACLRequestMarshaller();
var unmarshaller = PutACLResponseUnmarshaller.GetInstance();
return Invoke<IRequest, PutACLRequest, PutACLResponse>(request, marshaller, unmarshaller, signer, cancellationToken);
}
public object Execute(ExecutorContext context)
{
var cmdletContext = context as CmdletContext;
// create request
var request = new Amazon.S3.Model.PutACLRequest();
// populate AccessControlList
var requestAccessControlListIsNull = true;
request.AccessControlList = new Amazon.S3.Model.S3AccessControlList();
List <Amazon.S3.Model.S3Grant> requestAccessControlList_accessControlList_Grant = null;
if (cmdletContext.AccessControlList_Grant != null)
{
requestAccessControlList_accessControlList_Grant = cmdletContext.AccessControlList_Grant;
}
if (requestAccessControlList_accessControlList_Grant != null)
{
request.AccessControlList.Grants = requestAccessControlList_accessControlList_Grant;
requestAccessControlListIsNull = false;
}
Amazon.S3.Model.Owner requestAccessControlList_accessControlList_Owner = null;
// populate Owner
var requestAccessControlList_accessControlList_OwnerIsNull = true;
requestAccessControlList_accessControlList_Owner = new Amazon.S3.Model.Owner();
System.String requestAccessControlList_accessControlList_Owner_owner_DisplayName = null;
if (cmdletContext.Owner_DisplayName != null)
{
requestAccessControlList_accessControlList_Owner_owner_DisplayName = cmdletContext.Owner_DisplayName;
}
if (requestAccessControlList_accessControlList_Owner_owner_DisplayName != null)
{
requestAccessControlList_accessControlList_Owner.DisplayName = requestAccessControlList_accessControlList_Owner_owner_DisplayName;
requestAccessControlList_accessControlList_OwnerIsNull = false;
}
System.String requestAccessControlList_accessControlList_Owner_owner_Id = null;
if (cmdletContext.Owner_Id != null)
{
requestAccessControlList_accessControlList_Owner_owner_Id = cmdletContext.Owner_Id;
}
if (requestAccessControlList_accessControlList_Owner_owner_Id != null)
{
requestAccessControlList_accessControlList_Owner.Id = requestAccessControlList_accessControlList_Owner_owner_Id;
requestAccessControlList_accessControlList_OwnerIsNull = false;
}
// determine if requestAccessControlList_accessControlList_Owner should be set to null
if (requestAccessControlList_accessControlList_OwnerIsNull)
{
requestAccessControlList_accessControlList_Owner = null;
}
if (requestAccessControlList_accessControlList_Owner != null)
{
request.AccessControlList.Owner = requestAccessControlList_accessControlList_Owner;
requestAccessControlListIsNull = false;
}
// determine if request.AccessControlList should be set to null
if (requestAccessControlListIsNull)
{
request.AccessControlList = null;
}
if (cmdletContext.CannedACL != null)
{
request.CannedACL = cmdletContext.CannedACL;
}
if (cmdletContext.BucketName != null)
{
request.BucketName = cmdletContext.BucketName;
}
if (cmdletContext.ExpectedBucketOwner != null)
{
request.ExpectedBucketOwner = cmdletContext.ExpectedBucketOwner;
}
if (cmdletContext.Key != null)
{
request.Key = cmdletContext.Key;
}
if (cmdletContext.VersionId != null)
{
request.VersionId = cmdletContext.VersionId;
}
CmdletOutput output;
// issue call
var client = Client ?? CreateClient(_CurrentCredentials, _RegionEndpoint);
try
{
var response = CallAWSServiceOperation(client, request);
object pipelineOutput = null;
pipelineOutput = cmdletContext.Select(response, this);
output = new CmdletOutput
{
PipelineOutput = pipelineOutput,
ServiceResponse = response
};
}
catch (Exception e)
{
output = new CmdletOutput {
ErrorResponse = e
};
}
return(output);
}
public void SetACL(S3AccessControlList acl)
{
var request = new PutACLRequest
{
BucketName = this.linker.s3.bucket,
Key = this.linker.s3.key,
AccessControlList = acl
};
this.s3ClientCache.GetClient(this.RegionAsEndpoint).PutACL(request);
}
/// <summary>
/// <para>uses the acl subresource to set the access control list (ACL) permissions for an object that already exists in a bucket</para>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the PutObjectAcl service method on AmazonS3.</param>
public PutACLResponse PutACL(PutACLRequest request)
{
var task = PutACLAsync(request);
try
{
return task.Result;
}
catch(AggregateException e)
{
throw e.InnerException;
}
}
public void SetACL(S3CannedACL cannedACL)
{
var request = new PutACLRequest
{
BucketName = this.linker.s3.bucket,
Key = this.linker.s3.key,
CannedACL = cannedACL
};
this.s3ClientCache.GetClient(this.RegionAsEndpoint).PutACL(request);
}
/// <summary>
/// If enable is set to true the object will have its permission set to PublicRead otherwise the permissions will be set to Private.
/// </summary>
/// <param name="enable">If true the object will have its permission set to PublicRead otherwise the permissions will be set to Private.</param>
public void MakeS3ObjectPublic(bool enable)
{
var request = new PutACLRequest
{
BucketName = this.linker.s3.bucket,
Key = this.linker.s3.key,
CannedACL = enable ? S3CannedACL.PublicRead : S3CannedACL.Private
};
this.s3ClientCache.GetClient(this.RegionAsEndpoint).PutACL(request);
}
/// <summary>
/// <para>uses the acl subresource to set the access control list (ACL) permissions for an object that already exists in a bucket</para>
/// </summary>
///
/// <param name="putACLRequest">Container for the necessary parameters to execute the PutObjectAcl service method on AmazonS3.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
public async Task<PutACLResponse> PutACLAsync(PutACLRequest putACLRequest, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new PutACLRequestMarshaller();
var unmarshaller = PutACLResponseUnmarshaller.GetInstance();
var response = await Invoke<IRequest, PutACLRequest, PutACLResponse>(putACLRequest, marshaller, unmarshaller, signer, cancellationToken)
.ConfigureAwait(continueOnCapturedContext: false);
return response;
}
public void SetFileAcl(string key) {
var request = new PutACLRequest();
request.Key = key;
request.BucketName = BucketName;
request.CannedACL = S3CannedACL.PublicRead;
var response = _client.PutACL(request);
}
void ICoreAmazonS3.MakeObjectPublic(string bucket, string objectKey, bool enable)
{
var request = new PutACLRequest
{
BucketName = bucket,
Key = objectKey,
CannedACL = enable ? S3CannedACL.PublicRead : S3CannedACL.Private
};
this.PutACL(request);
}
public virtual void MakeObjectPublic(AmazonS3Client s3Client, string bucketName, string key)
{
// Create the request
var putAclRequest = new PutACLRequest {
BucketName = bucketName,
Key = key,
CannedACL = S3CannedACL.PublicRead
};
// Submit the request
s3Client.PutACL(putAclRequest);
}
/// <summary>
/// Sets up the request needed to make an exact copy of the object leaving the parent method
/// the ability to change just the attribute being requested to change.
/// </summary>
/// <param name="bucketName"></param>
/// <param name="key"></param>
/// <param name="version"></param>
/// <param name="s3Client"></param>
/// <param name="copyRequest"></param>
/// <param name="putACLRequest"></param>
static void SetupForObjectModification(IAmazonS3 s3Client, string bucketName, string key, string version,
out CopyObjectRequest copyRequest, out PutACLRequest putACLRequest)
{
// Get the existing ACL of the object
GetACLRequest getACLRequest = new GetACLRequest();
getACLRequest.BucketName = bucketName;
getACLRequest.Key = key;
if (version != null)
getACLRequest.VersionId = version;
GetACLResponse getACLResponse = s3Client.GetACL(getACLRequest);
// Set the object's original ACL back onto it because a COPY
// operation resets the ACL on the destination object.
putACLRequest = new PutACLRequest();
putACLRequest.BucketName = bucketName;
putACLRequest.Key = key;
putACLRequest.AccessControlList = getACLResponse.AccessControlList;
ListObjectsResponse listObjectResponse = s3Client.ListObjects(new ListObjectsRequest
{
BucketName = bucketName,
Prefix = key,
MaxKeys = 1
});
if (listObjectResponse.S3Objects.Count != 1)
{
throw new InvalidOperationException("No object exists with this bucket name and key.");
}
GetObjectMetadataRequest getMetaRequest = new GetObjectMetadataRequest()
{
BucketName = bucketName,
Key = key
};
GetObjectMetadataResponse getMetaResponse = s3Client.GetObjectMetadata(getMetaRequest);
// Set the storage class on the object
copyRequest = new CopyObjectRequest();
copyRequest.SourceBucket = copyRequest.DestinationBucket = bucketName;
copyRequest.SourceKey = copyRequest.DestinationKey = key;
copyRequest.StorageClass = listObjectResponse.S3Objects[0].StorageClass == "STANDARD" ? S3StorageClass.Standard : S3StorageClass.ReducedRedundancy;
if (version != null)
copyRequest.SourceVersionId = version;
copyRequest.WebsiteRedirectLocation = getMetaResponse.WebsiteRedirectLocation;
copyRequest.ServerSideEncryptionMethod = getMetaResponse.ServerSideEncryptionMethod;
}
private Amazon.S3.Model.PutACLResponse CallAWSServiceOperation(IAmazonS3 client, Amazon.S3.Model.PutACLRequest request)
{
Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "Amazon Simple Storage Service (S3)", "PutACL");
try
{
#if DESKTOP
return(client.PutACL(request));
#elif CORECLR
return(client.PutACLAsync(request).GetAwaiter().GetResult());
#else
#error "Unknown build edition"
#endif
}
catch (AmazonServiceException exc)
{
var webException = exc.InnerException as System.Net.WebException;
if (webException != null)
{
throw new Exception(Utils.Common.FormatNameResolutionFailureMessage(client.Config, webException.Message), webException);
}
throw;
}
}
/// <summary>
/// Initiates the asynchronous execution of the PutACL operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the PutACL operation on AmazonS3Client.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndPutACL
/// operation.</returns>
public IAsyncResult BeginPutACL(PutACLRequest request, AsyncCallback callback, object state)
{
var marshaller = new PutACLRequestMarshaller();
var unmarshaller = PutACLResponseUnmarshaller.Instance;
return BeginInvoke<PutACLRequest>(request, marshaller, unmarshaller,
callback, state);
}
/// <summary>
/// Initiates the asynchronous execution of the PutACL operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the PutACL operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task<PutACLResponse> PutACLAsync(PutACLRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new PutACLRequestMarshaller();
var unmarshaller = PutACLResponseUnmarshaller.Instance;
return InvokeAsync<PutACLRequest,PutACLResponse>(request, marshaller,
unmarshaller, cancellationToken);
}
/// <summary>
/// Set access rights of an object.
/// </summary>
/// <param name="bucketName">The name of the bucket.</param>
/// <param name="key">The key of the object.</param>
/// <param name="acl">The desired access rights.</param>
public void SetAcl(string bucketName, string key, S3CannedACL acl)
{
var request = new PutACLRequest
{
BucketName = bucketName,
CannedACL = acl,
Key = key
};
_amazonS3Client.PutACL(request);
}
