public object Execute(ExecutorContext context) { var cmdletContext = context as CmdletContext; // create request var request = new Amazon.S3.Model.PutBucketPolicyRequest(); if (cmdletContext.BucketName != null) { request.BucketName = cmdletContext.BucketName; } if (cmdletContext.ContentMD5 != null) { request.ContentMD5 = cmdletContext.ContentMD5; } if (cmdletContext.Policy != null) { request.Policy = cmdletContext.Policy; } if (cmdletContext.ConfirmRemoveSelfBucketAccess != null) { request.ConfirmRemoveSelfBucketAccess = cmdletContext.ConfirmRemoveSelfBucketAccess.Value; } if (cmdletContext.ExpectedBucketOwner != null) { request.ExpectedBucketOwner = cmdletContext.ExpectedBucketOwner; } 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 static bool Add_Global_Read_premissions(String bucket_name, String bucket_arn) { PutBucketPolicyRequest request = new PutBucketPolicyRequest(); request.BucketName = bucket_name; Dictionary<String,Object> dict = new Dictionary<string,object>(); dict["Version"] = "2008-10-17"; Dictionary<String,Object> inner_1 = new Dictionary<string,object>(); inner_1["Sid"] = bucket_name + "_all_read"; inner_1["Effect"] = "Allow"; inner_1["Principal"] = "{\"AWS\": \"*\"}"; inner_1["Action"] = "[\"s3:GetObject\"]"; inner_1["Resource"] = "[\""+bucket_arn+"\"]"; dict["Statement"] = inner_1; JavaScriptSerializer serializer = new JavaScriptSerializer(); //creating serializer instance of JavaScriptSerializer class string jsonString = serializer.Serialize((object)dict); request.Policy = jsonString; PutBucketPolicyResponse response = s3_client.PutBucketPolicy(request); return true; }
/// <summary> /// Replaces a policy on a bucket. If the bucket already has a policy, the one in this /// request completely replaces it. /// This API is supported only when AWSConfigs.HttpClient is set to AWSConfigs.HttpClientOption.UnityWebRequest, the default value of this configuration option is AWSConfigs.HttpClientOption.UnityWWW /// </summary> /// <param name="bucketName">A property of PutBucketPolicyRequest used to execute the PutBucketPolicy service method.</param> /// <param name="policy">The bucket policy as a JSON document.</param> /// <param name="contentMD5">A property of PutBucketPolicyRequest used to execute the PutBucketPolicy service method.</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> /// /// <returns>The response from the PutBucketPolicy service method, as returned by S3.</returns> public void PutBucketPolicyAsync(string bucketName, string policy, string contentMD5, AmazonServiceCallback<PutBucketPolicyRequest, PutBucketPolicyResponse> callback, AsyncOptions options = null) { var request = new PutBucketPolicyRequest(); request.BucketName = bucketName; request.Policy = policy; request.ContentMD5 = contentMD5; PutBucketPolicyAsync(request, callback, options); }
/// <summary> /// Replaces a policy on a bucket. If the bucket already has a policy, the one in this /// request completely replaces it. /// </summary> /// <param name="bucketName">A property of PutBucketPolicyRequest used to execute the PutBucketPolicy service method.</param> /// <param name="policy">The bucket policy as a JSON document.</param> /// <param name="contentMD5">A property of PutBucketPolicyRequest used to execute the PutBucketPolicy service method.</param> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// </param> /// /// <returns>The response from the PutBucketPolicy service method, as returned by S3.</returns> public Task<PutBucketPolicyResponse> PutBucketPolicyAsync(string bucketName, string policy, string contentMD5, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var request = new PutBucketPolicyRequest(); request.BucketName = bucketName; request.Policy = policy; request.ContentMD5 = contentMD5; return PutBucketPolicyAsync(request, cancellationToken); }
/// <summary> /// Replaces a policy on a bucket. If the bucket already has a policy, the one in this /// request completely replaces it. /// </summary> /// <param name="bucketName">A property of PutBucketPolicyRequest used to execute the PutBucketPolicy service method.</param> /// <param name="policy">The bucket policy as a JSON document.</param> /// <param name="contentMD5">A property of PutBucketPolicyRequest used to execute the PutBucketPolicy service method.</param> /// /// <returns>The response from the PutBucketPolicy service method, as returned by S3.</returns> public PutBucketPolicyResponse PutBucketPolicy(string bucketName, string policy, string contentMD5) { var request = new PutBucketPolicyRequest(); request.BucketName = bucketName; request.Policy = policy; request.ContentMD5 = contentMD5; return PutBucketPolicy(request); }
/// <summary> /// Initiates the asynchronous execution of the PutBucketPolicy operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the PutBucketPolicy 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 EndPutBucketPolicy /// operation.</returns> public IAsyncResult BeginPutBucketPolicy(PutBucketPolicyRequest request, AsyncCallback callback, object state) { var marshaller = new PutBucketPolicyRequestMarshaller(); var unmarshaller = PutBucketPolicyResponseUnmarshaller.Instance; return BeginInvoke<PutBucketPolicyRequest>(request, marshaller, unmarshaller, callback, state); }
public void BucketSamples() { { #region ListBuckets Sample // Create a client AmazonS3Client client = new AmazonS3Client(); // Issue call ListBucketsResponse response = client.ListBuckets(); // View response data Console.WriteLine("Buckets owner - {0}", response.Owner.DisplayName); foreach (S3Bucket bucket in response.Buckets) { Console.WriteLine("Bucket {0}, Created on {1}", bucket.BucketName, bucket.CreationDate); } #endregion } { #region BucketPolicy Sample // Create a client AmazonS3Client client = new AmazonS3Client(); // Put sample bucket policy (overwrite an existing policy) string newPolicy = @"{ ""Statement"":[{ ""Sid"":""BasicPerms"", ""Effect"":""Allow"", ""Principal"": ""*"", ""Action"":[""s3:PutObject"",""s3:GetObject""], ""Resource"":[""arn:aws:s3:::samplebucketname/*""] }]}"; PutBucketPolicyRequest putRequest = new PutBucketPolicyRequest { BucketName = "SampleBucket", Policy = newPolicy }; client.PutBucketPolicy(putRequest); // Retrieve current policy GetBucketPolicyRequest getRequest = new GetBucketPolicyRequest { BucketName = "SampleBucket" }; string policy = client.GetBucketPolicy(getRequest).Policy; Console.WriteLine(policy); Debug.Assert(policy.Contains("BasicPerms")); // Delete current policy DeleteBucketPolicyRequest deleteRequest = new DeleteBucketPolicyRequest { BucketName = "SampleBucket" }; client.DeleteBucketPolicy(deleteRequest); // Retrieve current policy and verify that it is null policy = client.GetBucketPolicy(getRequest).Policy; Debug.Assert(policy == null); #endregion } { #region GetBucketLocation Sample // Create a client AmazonS3Client client = new AmazonS3Client(); // Construct request GetBucketLocationRequest request = new GetBucketLocationRequest { BucketName = "SampleBucket" }; // Issue call GetBucketLocationResponse response = client.GetBucketLocation(request); // View response data Console.WriteLine("Bucket location - {0}", response.Location); #endregion } { #region PutBucket Sample // Create a client AmazonS3Client client = new AmazonS3Client(); // Construct request PutBucketRequest request = new PutBucketRequest { BucketName = "SampleBucket", BucketRegion = S3Region.EU, // set region to EU CannedACL = S3CannedACL.PublicRead // make bucket publicly readable }; // Issue call PutBucketResponse response = client.PutBucket(request); #endregion } { #region DeleteBucket Sample 1 // Create a client AmazonS3Client client = new AmazonS3Client(); // Construct request DeleteBucketRequest request = new DeleteBucketRequest { BucketName = "SampleBucket" }; // Issue call DeleteBucketResponse response = client.DeleteBucket(request); #endregion } { #region DeleteBucket Sample 2 // Create a client AmazonS3Client client = new AmazonS3Client(); // List and delete all objects ListObjectsRequest listRequest = new ListObjectsRequest { BucketName = "SampleBucket" }; ListObjectsResponse listResponse; do { // Get a list of objects listResponse = client.ListObjects(listRequest); foreach (S3Object obj in listResponse.S3Objects) { // Delete each object client.DeleteObject(new DeleteObjectRequest { BucketName = "SampleBucket", Key = obj.Key }); } // Set the marker property listRequest.Marker = listResponse.NextMarker; } while (listResponse.IsTruncated); // Construct DeleteBucket request DeleteBucketRequest request = new DeleteBucketRequest { BucketName = "SampleBucket" }; // Issue call DeleteBucketResponse response = client.DeleteBucket(request); #endregion } { #region LifecycleConfiguration Sample // Create a client AmazonS3Client client = new AmazonS3Client(); // Put sample lifecycle configuration (overwrite an existing configuration) LifecycleConfiguration newConfiguration = new LifecycleConfiguration { Rules = new List<LifecycleRule> { // Rule to delete keys with prefix "Test-" after 5 days new LifecycleRule { Prefix = "Test-", Expiration = new LifecycleRuleExpiration { Days = 5 } }, // Rule to delete keys in subdirectory "Logs" after 2 days new LifecycleRule { Prefix = "Logs/", Expiration = new LifecycleRuleExpiration { Days = 2 }, Id = "log-file-removal" } } }; PutLifecycleConfigurationRequest putRequest = new PutLifecycleConfigurationRequest { BucketName = "SampleBucket", Configuration = newConfiguration }; client.PutLifecycleConfiguration(putRequest); // Retrieve current configuration GetLifecycleConfigurationRequest getRequest = new GetLifecycleConfigurationRequest { BucketName = "SampleBucket" }; LifecycleConfiguration configuration = client.GetLifecycleConfiguration(getRequest).Configuration; Console.WriteLine("Configuration contains {0} rules", configuration.Rules.Count); foreach (LifecycleRule rule in configuration.Rules) { Console.WriteLine("Rule"); Console.WriteLine(" Prefix = " + rule.Prefix); Console.WriteLine(" Expiration (days) = " + rule.Expiration.Days); Console.WriteLine(" Id = " + rule.Id); Console.WriteLine(" Status = " + rule.Status); } // Put a new configuration and overwrite the existing configuration configuration.Rules.RemoveAt(0); // remove first rule client.PutLifecycleConfiguration(putRequest); // Delete current configuration DeleteLifecycleConfigurationRequest deleteRequest = new DeleteLifecycleConfigurationRequest { BucketName = "SampleBucket" }; client.DeleteLifecycleConfiguration(deleteRequest); // Retrieve current configuration and verify that it is null configuration = client.GetLifecycleConfiguration(getRequest).Configuration; Debug.Assert(configuration == null); #endregion } }
internal PutBucketPolicyResponse PutBucketPolicy(PutBucketPolicyRequest request) { var marshaller = new PutBucketPolicyRequestMarshaller(); var unmarshaller = PutBucketPolicyResponseUnmarshaller.Instance; return Invoke<PutBucketPolicyRequest,PutBucketPolicyResponse>(request, marshaller, unmarshaller); }
/// <summary> /// Initiates the asynchronous execution of the PutBucketPolicy operation. /// <seealso cref="Amazon.S3.IAmazonS3.PutBucketPolicy"/> /// </summary> /// /// <param name="putBucketPolicyRequest">Container for the necessary parameters to execute the PutBucketPolicy operation on AmazonS3.</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 BeginPutBucketPolicy(PutBucketPolicyRequest putBucketPolicyRequest, AsyncCallback callback, object state) { return invokePutBucketPolicy(putBucketPolicyRequest, callback, state, false); }
/// <summary> /// <para>Replaces a policy on a bucket. If the bucket already has a policy, the one in this request completely replaces it.</para> /// </summary> /// /// <param name="putBucketPolicyRequest">Container for the necessary parameters to execute the PutBucketPolicy 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<PutBucketPolicyResponse> PutBucketPolicyAsync(PutBucketPolicyRequest putBucketPolicyRequest, CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new PutBucketPolicyRequestMarshaller(); var unmarshaller = PutBucketPolicyResponseUnmarshaller.GetInstance(); var response = await Invoke<IRequest, PutBucketPolicyRequest, PutBucketPolicyResponse>(putBucketPolicyRequest, marshaller, unmarshaller, signer, cancellationToken) .ConfigureAwait(continueOnCapturedContext: false); return response; }
/// <summary> /// <para>Replaces a policy on a bucket. If the bucket already has a policy, the one in this request completely replaces it.</para> /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the PutBucketPolicy service method on /// AmazonS3.</param> public PutBucketPolicyResponse PutBucketPolicy(PutBucketPolicyRequest request) { var task = PutBucketPolicyAsync(request); try { return task.Result; } catch(AggregateException e) { ExceptionDispatchInfo.Capture(e.InnerException).Throw(); return null; } }
public void BucketH_PutBucketPolicyTest_ForException_EmptyPolicyName() { string actualValue = string.Empty; string emptyPolicy = string.Empty; //Create request object. PutBucketPolicyRequest request = new PutBucketPolicyRequest() { BucketName = _bucketNameForBucketAPIs, Policy = emptyPolicy }; _client.PutBucketPolicy(request); EnqueueTestComplete(); }
public void BucketH_PutBucketPolicyTest() { Func<String> PolicyValue = () => "{\"Version\": \"2008-10-17\",\"Id\": \"aaaa-bbbb-cccc-dddd\",\"Statement\" :" + "[{\"Effect\": \"Allow\",\"Sid\": \"1\",\"Principal\": {\"AWS\": \"*\"}," + "\"Action\": [\"s3:*\"],\"Resource\": \"arn:aws:s3:::" + _bucketNameForBucketAPIs + "/*\"}]}"; bool expectedValue = true; bool actualValue = false; bool hasCallbackArrived = false; S3ResponseEventHandler<object, ResponseEventArgs> handler = null; handler = delegate(object sender, ResponseEventArgs args) { IS3Response result = args.Response; //Unhook from event. _client.OnS3Response -= handler; PutBucketPolicyResponse response = result as PutBucketPolicyResponse; if (null != response) actualValue = response.IsRequestSuccessful; hasCallbackArrived = true; }; _client.OnS3Response += handler; PutBucketPolicyRequest request = new PutBucketPolicyRequest() { BucketName = _bucketNameForBucketAPIs, Policy = PolicyValue.Invoke() }; _client.PutBucketPolicy(request); EnqueueConditional(() => hasCallbackArrived); EnqueueCallback(() => Assert.IsTrue(expectedValue == actualValue, string.Format("Expected Value = {0}, Actual Value = {1}", expectedValue, actualValue))); EnqueueTestComplete(); }
/// <summary> /// Initiates the asynchronous execution of the PutBucketPolicy 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 PutBucketPolicy 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 PutBucketPolicyAsync(PutBucketPolicyRequest request, AmazonServiceCallback<PutBucketPolicyRequest, PutBucketPolicyResponse> callback, AsyncOptions options = null) { if (AWSConfigs.HttpClient == AWSConfigs.HttpClientOption.UnityWWW) { throw new InvalidOperationException("PutBucketPolicy is only allowed with AWSConfigs.HttpClientOption.UnityWebRequest API option"); } options = options == null?new AsyncOptions():options; var marshaller = new PutBucketPolicyRequestMarshaller(); var unmarshaller = PutBucketPolicyResponseUnmarshaller.Instance; Action<AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null; if(callback !=null ) callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => { AmazonServiceResult<PutBucketPolicyRequest,PutBucketPolicyResponse> responseObject = new AmazonServiceResult<PutBucketPolicyRequest,PutBucketPolicyResponse>((PutBucketPolicyRequest)req, (PutBucketPolicyResponse)res, ex , ao.State); callback(responseObject); }; BeginInvoke<PutBucketPolicyRequest>(request, marshaller, unmarshaller, options, callbackHelper); }
private Amazon.S3.Model.PutBucketPolicyResponse CallAWSServiceOperation(IAmazonS3 client, Amazon.S3.Model.PutBucketPolicyRequest request) { Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "Amazon Simple Storage Service (S3)", "PutBucketPolicy"); try { #if DESKTOP return(client.PutBucketPolicy(request)); #elif CORECLR return(client.PutBucketPolicyAsync(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> /// <para>Replaces a policy on a bucket. If the bucket already has a policy, the one in this request completely replaces it.</para> /// </summary> /// /// <param name="putBucketPolicyRequest">Container for the necessary parameters to execute the PutBucketPolicy service method on /// AmazonS3.</param> /// public PutBucketPolicyResponse PutBucketPolicy(PutBucketPolicyRequest putBucketPolicyRequest) { IAsyncResult asyncResult = invokePutBucketPolicy(putBucketPolicyRequest, null, null, true); return EndPutBucketPolicy(asyncResult); }
/// <summary> /// <para>Replaces a policy on a bucket. If the bucket already has a policy, the one in this request completely replaces it.</para> /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the PutBucketPolicy service method on /// AmazonS3.</param> public PutBucketPolicyResponse PutBucketPolicy(PutBucketPolicyRequest request) { var task = PutBucketPolicyAsync(request); try { return task.Result; } catch(AggregateException e) { throw e.InnerException; } }
IAsyncResult invokePutBucketPolicy(PutBucketPolicyRequest putBucketPolicyRequest, AsyncCallback callback, object state, bool synchronized) { IRequest irequest = new PutBucketPolicyRequestMarshaller().Marshall(putBucketPolicyRequest); var unmarshaller = PutBucketPolicyResponseUnmarshaller.GetInstance(); AsyncResult result = new AsyncResult(irequest, callback, state, synchronized, signer, unmarshaller); Invoke(result); return result; }
/// <summary> /// Initiates the asynchronous execution of the PutBucketPolicy operation. /// <seealso cref="Amazon.S3.IAmazonS3.PutBucketPolicy"/> /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the PutBucketPolicy 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<PutBucketPolicyResponse> PutBucketPolicyAsync(PutBucketPolicyRequest request, CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new PutBucketPolicyRequestMarshaller(); var unmarshaller = PutBucketPolicyResponseUnmarshaller.GetInstance(); return Invoke<IRequest, PutBucketPolicyRequest, PutBucketPolicyResponse>(request, marshaller, unmarshaller, signer, cancellationToken); }
/// <summary> /// Initiates the asynchronous execution of the PutBucketPolicy operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the PutBucketPolicy 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<PutBucketPolicyResponse> PutBucketPolicyAsync(PutBucketPolicyRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new PutBucketPolicyRequestMarshaller(); var unmarshaller = PutBucketPolicyResponseUnmarshaller.Instance; return InvokeAsync<PutBucketPolicyRequest,PutBucketPolicyResponse>(request, marshaller, unmarshaller, cancellationToken); }
private void PutBucketPolicyButton_Click(object sender, RoutedEventArgs e) { try { S3Common.client.OnS3Response += PutBucketPolicyWebResponse; PutBucketPolicyRequest putRequest = new PutBucketPolicyRequest(); putRequest.BucketName = SelectedBucketName; putRequest.Policy = GetPolicy(SelectedBucketName); S3Common.client.PutBucketPolicy(putRequest); } catch (Exception ex) { S3Common.client.OnS3Response -= PutBucketPolicyWebResponse; this.Dispatcher.BeginInvoke(() => { MessageBox.Show(ex.Message); }); } }