/// <summary> /// Upload data to Amazon S3 using HTTP POST. /// </summary> /// <remarks> /// For more information, <see href="http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingHTTPPOST.html"/> /// </remarks> /// <param name="request">Request object which describes the data to POST</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 PostObjectAsync(PostObjectRequest request, AmazonServiceCallback<PostObjectRequest, PostObjectResponse> callback, AsyncOptions options = null) { options = options == null ? new AsyncOptions() : options; Action<AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => { AmazonServiceResult<PostObjectRequest, PostObjectResponse> responseObject = new AmazonServiceResult<PostObjectRequest, PostObjectResponse>((PostObjectRequest)req, (PostObjectResponse)res, ex, ao.State); if (callback != null) callback(responseObject); }; ThreadPool.QueueUserWorkItem(new WaitCallback(delegate { // Provide a default policy if user doesn't set it. try { InferContentType(request); if (request.SignedPolicy == null) { CreateSignedPolicy(request); } PostObject(request, options, callbackHelper); } catch (Exception e) { callback(new AmazonServiceResult<PostObjectRequest, PostObjectResponse>(request, null, e, options.State)); } })); }
public void RequestUploadCredentialsAsync(RequestUploadCredentialsRequest request, AmazonServiceCallback <RequestUploadCredentialsRequest, RequestUploadCredentialsResponse> callback, AsyncOptions options = null) { throw new System.NotImplementedException(); }
/// <summary> /// Initiates the asynchronous execution of the DescribeIdentityUsage operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the DescribeIdentityUsage operation on AmazonCognitoSyncClient.</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 DescribeIdentityUsageAsync(DescribeIdentityUsageRequest request, AmazonServiceCallback<DescribeIdentityUsageRequest, DescribeIdentityUsageResponse> callback, AsyncOptions options = null) { options = options == null?new AsyncOptions():options; var marshaller = new DescribeIdentityUsageRequestMarshaller(); var unmarshaller = DescribeIdentityUsageResponseUnmarshaller.Instance; Action<AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null; if(callback !=null ) callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => { AmazonServiceResult<DescribeIdentityUsageRequest,DescribeIdentityUsageResponse> responseObject = new AmazonServiceResult<DescribeIdentityUsageRequest,DescribeIdentityUsageResponse>((DescribeIdentityUsageRequest)req, (DescribeIdentityUsageResponse)res, ex , ao.State); callback(responseObject); }; BeginInvoke<DescribeIdentityUsageRequest>(request, marshaller, unmarshaller, options, callbackHelper); }
/// <summary> /// Returns credentials for the the provided identity ID. Any provided logins will be /// validated against supported login providers. If the token is for cognito-identity.amazonaws.com, /// it will be passed through to AWS Security Token Service with the appropriate role /// for the token. /// </summary> /// <param name="identityId">A unique identifier in the format REGION:GUID.</param> /// <param name="logins">A set of optional name-value pairs that map provider names to provider tokens.</param> /// /// <returns>The response from the GetCredentialsForIdentity service method, as returned by CognitoIdentity.</returns> /// <exception cref="Amazon.CognitoIdentity.Model.InternalErrorException"> /// Thrown when the service encounters an error during processing the request. /// </exception> /// <exception cref="Amazon.CognitoIdentity.Model.InvalidIdentityPoolConfigurationException"> /// Thrown if the identity pool has no role associated for the given auth type (auth/unauth) /// or if the AssumeRole fails. /// </exception> /// <exception cref="Amazon.CognitoIdentity.Model.InvalidParameterException"> /// Thrown for missing or bad input parameter(s). /// </exception> /// <exception cref="Amazon.CognitoIdentity.Model.NotAuthorizedException"> /// Thrown when a user is not authorized to access the requested resource. /// </exception> /// <exception cref="Amazon.CognitoIdentity.Model.ResourceConflictException"> /// Thrown when a user tries to use a login which is already linked to another account. /// </exception> /// <exception cref="Amazon.CognitoIdentity.Model.ResourceNotFoundException"> /// Thrown when the requested resource (for example, a dataset or record) does not exist. /// </exception> /// <exception cref="Amazon.CognitoIdentity.Model.TooManyRequestsException"> /// Thrown when a request is throttled. /// </exception> public void GetCredentialsForIdentityAsync(string identityId, Dictionary<string, string> logins, AmazonServiceCallback<GetCredentialsForIdentityRequest, GetCredentialsForIdentityResponse> callback, AsyncOptions options = null) { var request = new GetCredentialsForIdentityRequest(); request.IdentityId = identityId; request.Logins = logins; GetCredentialsForIdentityAsync(request, callback, options); }
/// <summary> /// Removes the null version (if there is one) of an object and inserts a delete marker, /// which becomes the latest version of the object. If there isn't a null version, Amazon /// S3 does not remove any objects. /// 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 DeleteObjectRequest used to execute the DeleteObject service method.</param> /// <param name="key">A property of DeleteObjectRequest used to execute the DeleteObject service method.</param> /// <param name="versionId">VersionId used to reference a specific version of the object.</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 DeleteObject service method, as returned by S3.</returns> public void DeleteObjectAsync(string bucketName, string key, string versionId, AmazonServiceCallback<DeleteObjectRequest, DeleteObjectResponse> callback, AsyncOptions options = null) { var request = new DeleteObjectRequest(); request.BucketName = bucketName; request.Key = key; request.VersionId = versionId; DeleteObjectAsync(request, callback, options); }
/// <summary> /// Restores an archived copy of an object back into Amazon S3 /// </summary> /// <param name="bucketName">A property of RestoreObjectRequest used to execute the RestoreObject service method.</param> /// <param name="key">A property of RestoreObjectRequest used to execute the RestoreObject service method.</param> /// <param name="versionId">A property of RestoreObjectRequest used to execute the RestoreObject service method.</param> /// <param name="days">A property of RestoreObjectRequest used to execute the RestoreObject 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 RestoreObject service method, as returned by S3.</returns> public void RestoreObjectAsync(string bucketName, string key, string versionId, int days, AmazonServiceCallback<RestoreObjectRequest, RestoreObjectResponse> callback, AsyncOptions options = null) { var request = new RestoreObjectRequest(); request.BucketName = bucketName; request.Key = key; request.VersionId = versionId; request.Days = days; RestoreObjectAsync(request, callback, options); }
/// <summary> /// Sets the tags for a bucket. /// 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 PutBucketTaggingRequest used to execute the PutBucketTagging service method.</param> /// <param name="tagSet">A property of PutBucketTaggingRequest used to execute the PutBucketTagging 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 PutBucketTagging service method, as returned by S3.</returns> public void PutBucketTaggingAsync(string bucketName, List<Tag> tagSet, AmazonServiceCallback<PutBucketTaggingRequest, PutBucketTaggingResponse> callback, AsyncOptions options = null) { var request = new PutBucketTaggingRequest(); request.BucketName = bucketName; request.TagSet = tagSet; PutBucketTaggingAsync(request, callback, options); }
/// <summary> /// Returns metadata about all of the versions of objects in a bucket. /// </summary> /// <param name="bucketName">A property of ListVersionsRequest used to execute the ListVersions service method.</param> /// <param name="prefix">Limits the response to keys that begin with the specified prefix.</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 ListVersions service method, as returned by S3.</returns> public void ListVersionsAsync(string bucketName, string prefix, AmazonServiceCallback<ListVersionsRequest, ListVersionsResponse> callback, AsyncOptions options = null) { var request = new ListVersionsRequest(); request.BucketName = bucketName; request.Prefix = prefix; ListVersionsAsync(request, callback, options); }
public void UpdateRuntimeConfigurationAsync(UpdateRuntimeConfigurationRequest request, AmazonServiceCallback <UpdateRuntimeConfigurationRequest, UpdateRuntimeConfigurationResponse> callback, AsyncOptions options = null) { throw new System.NotImplementedException(); }
public void UpdateGameSessionQueueAsync(UpdateGameSessionQueueRequest request, AmazonServiceCallback <UpdateGameSessionQueueRequest, UpdateGameSessionQueueResponse> callback, AsyncOptions options = null) { throw new System.NotImplementedException(); }
public void UpdateFleetPortSettingsAsync(UpdateFleetPortSettingsRequest request, AmazonServiceCallback <UpdateFleetPortSettingsRequest, UpdateFleetPortSettingsResponse> callback, AsyncOptions options = null) { throw new System.NotImplementedException(); }
public void StopMatchmakingAsync(StopMatchmakingRequest request, AmazonServiceCallback <StopMatchmakingRequest, StopMatchmakingResponse> callback, AsyncOptions options = null) { throw new System.NotImplementedException(); }
public void StopGameSessionPlacementAsync(StopGameSessionPlacementRequest request, AmazonServiceCallback <StopGameSessionPlacementRequest, StopGameSessionPlacementResponse> callback, AsyncOptions options = null) { throw new System.NotImplementedException(); }
public void SearchGameSessionsAsync(SearchGameSessionsRequest request, AmazonServiceCallback <SearchGameSessionsRequest, SearchGameSessionsResponse> callback, AsyncOptions options = null) { throw new System.NotImplementedException(); }
public void ResolveAliasAsync(string aliasId, AmazonServiceCallback <ResolveAliasRequest, ResolveAliasResponse> callback, AsyncOptions options = null) { throw new System.NotImplementedException(); }
/// <summary> /// Initiates the asynchronous execution of the ListBucketMetricsConfigurations operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the ListBucketMetricsConfigurations 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 ListBucketMetricsConfigurationsAsync(ListBucketMetricsConfigurationsRequest request, AmazonServiceCallback<ListBucketMetricsConfigurationsRequest, ListBucketMetricsConfigurationsResponse> callback, AsyncOptions options = null) { options = options == null?new AsyncOptions():options; var marshaller = new ListBucketMetricsConfigurationsRequestMarshaller(); var unmarshaller = ListBucketMetricsConfigurationsResponseUnmarshaller.Instance; Action<AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null; if(callback !=null ) callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => { AmazonServiceResult<ListBucketMetricsConfigurationsRequest,ListBucketMetricsConfigurationsResponse> responseObject = new AmazonServiceResult<ListBucketMetricsConfigurationsRequest,ListBucketMetricsConfigurationsResponse>((ListBucketMetricsConfigurationsRequest)req, (ListBucketMetricsConfigurationsResponse)res, ex , ao.State); callback(responseObject); }; BeginInvoke<ListBucketMetricsConfigurationsRequest>(request, marshaller, unmarshaller, options, callbackHelper); }
/// <summary> /// Returns some or all (up to 1000) of the objects in a bucket. You can use the request /// parameters as selection criteria to return a subset of the objects in a bucket. /// </summary> /// <param name="bucketName">A property of ListObjectsRequest used to execute the ListObjects 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 ListObjects service method, as returned by S3.</returns> public void ListObjectsAsync(string bucketName, AmazonServiceCallback<ListObjectsRequest, ListObjectsResponse> callback, AsyncOptions options = null) { var request = new ListObjectsRequest(); request.BucketName = bucketName; ListObjectsAsync(request, callback, options); }
public void CreateMatchmakingRuleSetAsync(CreateMatchmakingRuleSetRequest request, AmazonServiceCallback <CreateMatchmakingRuleSetRequest, CreateMatchmakingRuleSetResponse> callback, AsyncOptions options = null) { throw new System.NotImplementedException(); }
/// <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); }
public void CreatePlayerSessionsAsync(string gameSessionId, List <string> playerIds, AmazonServiceCallback <CreatePlayerSessionsRequest, CreatePlayerSessionsResponse> callback, AsyncOptions options = null) { throw new System.NotImplementedException(); }
/// <summary> /// Set the website configuration for a bucket. /// 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 PutBucketWebsiteRequest used to execute the PutBucketWebsite service method.</param> /// <param name="websiteConfiguration">A property of PutBucketWebsiteRequest used to execute the PutBucketWebsite 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 PutBucketWebsite service method, as returned by S3.</returns> public void PutBucketWebsiteAsync(string bucketName, WebsiteConfiguration websiteConfiguration, AmazonServiceCallback<PutBucketWebsiteRequest, PutBucketWebsiteResponse> callback, AsyncOptions options = null) { var request = new PutBucketWebsiteRequest(); request.BucketName = bucketName; request.WebsiteConfiguration = websiteConfiguration; PutBucketWebsiteAsync(request, callback, options); }
public void CreatePlayerSessionsAsync(CreatePlayerSessionsRequest request, AmazonServiceCallback <CreatePlayerSessionsRequest, CreatePlayerSessionsResponse> callback, AsyncOptions options = null) { throw new System.NotImplementedException(); }
/// <summary> /// This operation removes the website configuration from the bucket. /// 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 DeleteBucketWebsiteRequest used to execute the DeleteBucketWebsite 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 DeleteBucketWebsite service method, as returned by S3.</returns> public void DeleteBucketWebsiteAsync(string bucketName, AmazonServiceCallback<DeleteBucketWebsiteRequest, DeleteBucketWebsiteResponse> callback, AsyncOptions options = null) { var request = new DeleteBucketWebsiteRequest(); request.BucketName = bucketName; DeleteBucketWebsiteAsync(request, callback, options); }
public void CreateVpcPeeringConnectionAsync(CreateVpcPeeringConnectionRequest request, AmazonServiceCallback <CreateVpcPeeringConnectionRequest, CreateVpcPeeringConnectionResponse> callback, AsyncOptions options = null) { throw new System.NotImplementedException(); }
/// <summary> /// Returns a set of temporary credentials for an AWS account or IAM user. The credentials /// consist of an access key ID, a secret access key, and a security token. Typically, /// you use <code>GetSessionToken</code> if you want to use MFA to protect programmatic /// calls to specific AWS APIs like Amazon EC2 <code>StopInstances</code>. MFA-enabled /// IAM users would need to call <code>GetSessionToken</code> and submit an MFA code that /// is associated with their MFA device. Using the temporary security credentials that /// are returned from the call, IAM users can then make programmatic calls to APIs that /// require MFA authentication. /// /// /// <para> /// The <code>GetSessionToken</code> action must be called by using the long-term AWS /// security credentials of the AWS account or an IAM user. Credentials that are created /// by IAM users are valid for the duration that you specify, between 900 seconds (15 /// minutes) and 129600 seconds (36 hours); credentials that are created by using account /// credentials have a maximum duration of 3600 seconds (1 hour). /// </para> /// <note> /// <para> /// We recommend that you do not call <code>GetSessionToken</code> with root account credentials. /// Instead, follow our <a href="http://docs.aws.amazon.com/IAM/latest/UserGuide/IAMBestPractices.html#create-iam-users">best /// practices</a> by creating one or more IAM users, giving them the necessary permissions, /// and using IAM users for everyday interaction with AWS. /// </para> /// </note> /// <para> /// The permissions associated with the temporary security credentials returned by <code>GetSessionToken</code> /// are based on the permissions associated with account or IAM user whose credentials /// are used to call the action. If <code>GetSessionToken</code> is called using root /// account credentials, the temporary credentials have root account permissions. Similarly, /// if <code>GetSessionToken</code> is called using the credentials of an IAM user, the /// temporary credentials have the same permissions as the IAM user. /// </para> /// /// <para> /// For more information about using <code>GetSessionToken</code> to create temporary /// credentials, go to <a href="http://docs.aws.amazon.com/STS/latest/UsingSTS/CreatingSessionTokens.html" /// target="_blank">Creating Temporary Credentials to Enable Access for IAM Users</a>. /// /// </para> /// </summary> /// <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 GetSessionToken service method, as returned by SecurityTokenService.</returns> public void GetSessionTokenAsync(AmazonServiceCallback<GetSessionTokenRequest, GetSessionTokenResponse> callback, AsyncOptions options = null) { GetSessionTokenAsync(new GetSessionTokenRequest(), callback, options); }
public void DeleteAliasAsync(DeleteAliasRequest request, AmazonServiceCallback <DeleteAliasRequest, DeleteAliasResponse> callback, AsyncOptions options = null) { throw new System.NotImplementedException(); }
/// <summary> /// Initiates the asynchronous execution of the GetOpenIdTokenForDeveloperIdentity operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the GetOpenIdTokenForDeveloperIdentity operation on AmazonCognitoIdentityClient.</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 GetOpenIdTokenForDeveloperIdentityAsync(GetOpenIdTokenForDeveloperIdentityRequest request, AmazonServiceCallback<GetOpenIdTokenForDeveloperIdentityRequest, GetOpenIdTokenForDeveloperIdentityResponse> callback, AsyncOptions options = null) { options = options == null?new AsyncOptions():options; var marshaller = new GetOpenIdTokenForDeveloperIdentityRequestMarshaller(); var unmarshaller = GetOpenIdTokenForDeveloperIdentityResponseUnmarshaller.Instance; Action<AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null; if(callback !=null ) callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => { AmazonServiceResult<GetOpenIdTokenForDeveloperIdentityRequest,GetOpenIdTokenForDeveloperIdentityResponse> responseObject = new AmazonServiceResult<GetOpenIdTokenForDeveloperIdentityRequest,GetOpenIdTokenForDeveloperIdentityResponse>((GetOpenIdTokenForDeveloperIdentityRequest)req, (GetOpenIdTokenForDeveloperIdentityResponse)res, ex , ao.State); callback(responseObject); }; BeginInvoke<GetOpenIdTokenForDeveloperIdentityRequest>(request, marshaller, unmarshaller, options, callbackHelper); }
public void DeleteBuildAsync(string buildId, AmazonServiceCallback <DeleteBuildRequest, DeleteBuildResponse> callback, AsyncOptions options = null) { throw new System.NotImplementedException(); }
/// <summary> /// Initiates the asynchronous execution of the SetIdentityPoolConfiguration operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the SetIdentityPoolConfiguration operation on AmazonCognitoSyncClient.</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 SetIdentityPoolConfigurationAsync(SetIdentityPoolConfigurationRequest request, AmazonServiceCallback<SetIdentityPoolConfigurationRequest, SetIdentityPoolConfigurationResponse> callback, AsyncOptions options = null) { options = options == null?new AsyncOptions():options; var marshaller = new SetIdentityPoolConfigurationRequestMarshaller(); var unmarshaller = SetIdentityPoolConfigurationResponseUnmarshaller.Instance; Action<AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null; if(callback !=null ) callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => { AmazonServiceResult<SetIdentityPoolConfigurationRequest,SetIdentityPoolConfigurationResponse> responseObject = new AmazonServiceResult<SetIdentityPoolConfigurationRequest,SetIdentityPoolConfigurationResponse>((SetIdentityPoolConfigurationRequest)req, (SetIdentityPoolConfigurationResponse)res, ex , ao.State); callback(responseObject); }; BeginInvoke<SetIdentityPoolConfigurationRequest>(request, marshaller, unmarshaller, options, callbackHelper); }
/// <summary> /// Initiates the asynchronous execution of the CreateEventSourceMapping operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the CreateEventSourceMapping operation on AmazonLambdaClient.</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 CreateEventSourceMappingAsync(CreateEventSourceMappingRequest request, AmazonServiceCallback <CreateEventSourceMappingRequest, CreateEventSourceMappingResponse> callback, AsyncOptions options = null) { options = options == null?new AsyncOptions():options; var marshaller = new CreateEventSourceMappingRequestMarshaller(); var unmarshaller = CreateEventSourceMappingResponseUnmarshaller.Instance; Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null; if (callback != null) { callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => { AmazonServiceResult <CreateEventSourceMappingRequest, CreateEventSourceMappingResponse> responseObject = new AmazonServiceResult <CreateEventSourceMappingRequest, CreateEventSourceMappingResponse>((CreateEventSourceMappingRequest)req, (CreateEventSourceMappingResponse)res, ex, ao.State); callback(responseObject); } } ; BeginInvoke <CreateEventSourceMappingRequest>(request, marshaller, unmarshaller, options, callbackHelper); }
/// <summary> /// Aborts a multipart upload. /// /// /// <para> /// To verify that all parts have been removed, so you don't get charged for the part /// storage, you should call the List Parts operation and ensure the parts list is empty. /// </para> /// 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 AbortMultipartUploadRequest used to execute the AbortMultipartUpload service method.</param> /// <param name="key">A property of AbortMultipartUploadRequest used to execute the AbortMultipartUpload service method.</param> /// <param name="uploadId">A property of AbortMultipartUploadRequest used to execute the AbortMultipartUpload 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 AbortMultipartUpload service method, as returned by S3.</returns> public void AbortMultipartUploadAsync(string bucketName, string key, string uploadId, AmazonServiceCallback<AbortMultipartUploadRequest, AbortMultipartUploadResponse> callback, AsyncOptions options = null) { var request = new AbortMultipartUploadRequest(); request.BucketName = bucketName; request.Key = key; request.UploadId = uploadId; AbortMultipartUploadAsync(request, callback, options); }
/// <summary> /// Initiates the asynchronous execution of the GetFunctionConfiguration operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the GetFunctionConfiguration operation on AmazonLambdaClient.</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 GetFunctionConfigurationAsync(GetFunctionConfigurationRequest request, AmazonServiceCallback <GetFunctionConfigurationRequest, GetFunctionConfigurationResponse> callback, AsyncOptions options = null) { options = options == null?new AsyncOptions():options; var marshaller = new GetFunctionConfigurationRequestMarshaller(); var unmarshaller = GetFunctionConfigurationResponseUnmarshaller.Instance; Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null; if (callback != null) { callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => { AmazonServiceResult <GetFunctionConfigurationRequest, GetFunctionConfigurationResponse> responseObject = new AmazonServiceResult <GetFunctionConfigurationRequest, GetFunctionConfigurationResponse>((GetFunctionConfigurationRequest)req, (GetFunctionConfigurationResponse)res, ex, ao.State); callback(responseObject); } } ; BeginInvoke <GetFunctionConfigurationRequest>(request, marshaller, unmarshaller, options, callbackHelper); }
/// <summary> /// Returns a list of all buckets owned by the authenticated sender of the request. /// </summary> /// <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 ListBuckets service method, as returned by S3.</returns> public void ListBucketsAsync(AmazonServiceCallback<ListBucketsRequest, ListBucketsResponse> callback, AsyncOptions options = null) { ListBucketsAsync(new ListBucketsRequest(), callback, options); }
/// <summary> /// Returns a list of your Lambda functions. For each function, the response includes /// the function configuration information. You must use <a>GetFunction</a> to retrieve /// the code for your function. /// /// /// <para> /// This operation requires permission for the <code>lambda:ListFunctions</code> action. /// </para> /// </summary> /// <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 ListFunctions service method, as returned by Lambda.</returns> /// <exception cref="Amazon.Lambda.Model.ServiceException"> /// The AWS Lambda service encountered an internal error. /// </exception> /// <exception cref="Amazon.Lambda.Model.TooManyRequestsException"> /// /// </exception> public void ListFunctionsAsync(AmazonServiceCallback <ListFunctionsRequest, ListFunctionsResponse> callback, AsyncOptions options = null) { var request = new ListFunctionsRequest(); ListFunctionsAsync(request, callback, options); }
/// <summary> /// Lists the parts that have been uploaded for a specific multipart upload. /// 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 ListPartsRequest used to execute the ListParts service method.</param> /// <param name="key">A property of ListPartsRequest used to execute the ListParts service method.</param> /// <param name="uploadId">Upload ID identifying the multipart upload whose parts are being listed.</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 ListParts service method, as returned by S3.</returns> public void ListPartsAsync(string bucketName, string key, string uploadId, AmazonServiceCallback<ListPartsRequest, ListPartsResponse> callback, AsyncOptions options = null) { var request = new ListPartsRequest(); request.BucketName = bucketName; request.Key = key; request.UploadId = uploadId; ListPartsAsync(request, callback, options); }
/// <summary> /// Initiates the asynchronous execution of the ListDeliveryStreams operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the ListDeliveryStreams operation on AmazonKinesisFirehoseClient.</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> /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/firehose-2015-08-04/ListDeliveryStreams">REST API Reference for ListDeliveryStreams Operation</seealso> public virtual void ListDeliveryStreamsAsync(ListDeliveryStreamsRequest request, AmazonServiceCallback <ListDeliveryStreamsRequest, ListDeliveryStreamsResponse> callback, AsyncOptions options = null) { options = options == null?new AsyncOptions():options; var marshaller = new ListDeliveryStreamsRequestMarshaller(); var unmarshaller = ListDeliveryStreamsResponseUnmarshaller.Instance; Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null; if (callback != null) { callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => { AmazonServiceResult <ListDeliveryStreamsRequest, ListDeliveryStreamsResponse> responseObject = new AmazonServiceResult <ListDeliveryStreamsRequest, ListDeliveryStreamsResponse>((ListDeliveryStreamsRequest)req, (ListDeliveryStreamsResponse)res, ex, ao.State); callback(responseObject); } } ; BeginInvoke <ListDeliveryStreamsRequest>(request, marshaller, unmarshaller, options, callbackHelper); }
/// <summary> /// Creates a new bucket. /// 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 PutBucketRequest used to execute the PutBucket 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 PutBucket service method, as returned by S3.</returns> public void PutBucketAsync(string bucketName, AmazonServiceCallback<PutBucketRequest, PutBucketResponse> callback, AsyncOptions options = null) { var request = new PutBucketRequest(); request.BucketName = bucketName; PutBucketAsync(request, callback, options); }
/// <summary> /// Writes multiple data records into a delivery stream in a single call, which can achieve /// higher throughput per producer than when writing single records. To write single data /// records into a delivery stream, use <a>PutRecord</a>. Applications using these operations /// are referred to as producers. /// /// /// <para> /// By default, each delivery stream can take in up to 2,000 transactions per second, /// 5,000 records per second, or 5 MB per second. If you use <a>PutRecord</a> and <a>PutRecordBatch</a>, /// the limits are an aggregate across these two operations for each delivery stream. /// For more information about limits, see <a href="http://docs.aws.amazon.com/firehose/latest/dev/limits.html">Amazon /// Kinesis Firehose Limits</a>. /// </para> /// /// <para> /// Each <a>PutRecordBatch</a> request supports up to 500 records. Each record in the /// request can be as large as 1,000 KB (before 64-bit encoding), up to a limit of 4 MB /// for the entire request. These limits cannot be changed. /// </para> /// /// <para> /// You must specify the name of the delivery stream and the data record when using <a>PutRecord</a>. /// The data record consists of a data blob that can be up to 1,000 KB in size, and any /// kind of data. For example, it could be a segment from a log file, geographic location /// data, web site clickstream data, and so on. /// </para> /// /// <para> /// Kinesis Firehose buffers records before delivering them to the destination. To disambiguate /// the data blobs at the destination, a common solution is to use delimiters in the data, /// such as a newline (<code>\n</code>) or some other character unique within the data. /// This allows the consumer application to parse individual data items when reading the /// data from the destination. /// </para> /// /// <para> /// The <a>PutRecordBatch</a> response includes a count of failed records, <b>FailedPutCount</b>, /// and an array of responses, <b>RequestResponses</b>. Each entry in the <b>RequestResponses</b> /// array provides additional information about the processed record. It directly correlates /// with a record in the request array using the same ordering, from the top to the bottom. /// The response array always includes the same number of records as the request array. /// <b>RequestResponses</b> includes both successfully and unsuccessfully processed records. /// Kinesis Firehose attempts to process all records in each <a>PutRecordBatch</a> request. /// A single record failure does not stop the processing of subsequent records. /// </para> /// /// <para> /// A successfully processed record includes a <b>RecordId</b> value, which is unique /// for the record. An unsuccessfully processed record includes <b>ErrorCode</b> and <b>ErrorMessage</b> /// values. <b>ErrorCode</b> reflects the type of error, and is one of the following values: /// <code>ServiceUnavailable</code> or <code>InternalFailure</code>. <b>ErrorMessage</b> /// provides more detailed information about the error. /// </para> /// /// <para> /// If there is an internal server error or a timeout, the write might have completed /// or it might have failed. If <b>FailedPutCount</b> is greater than 0, retry the request, /// resending only those records that might have failed processing. This minimizes the /// possible duplicate records and also reduces the total bytes sent (and corresponding /// charges). We recommend that you handle any duplicates at the destination. /// </para> /// /// <para> /// If <a>PutRecordBatch</a> throws <b>ServiceUnavailableException</b>, back off and retry. /// If the exception persists, it is possible that the throughput limits have been exceeded /// for the delivery stream. /// </para> /// /// <para> /// Data records sent to Kinesis Firehose are stored for 24 hours from the time they are /// added to a delivery stream as it attempts to send the records to the destination. /// If the destination is unreachable for more than 24 hours, the data is no longer available. /// </para> /// </summary> /// <param name="deliveryStreamName">The name of the delivery stream.</param> /// <param name="records">One or more records.</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 PutRecordBatch service method, as returned by KinesisFirehose.</returns> /// <exception cref="Amazon.KinesisFirehose.Model.InvalidArgumentException"> /// The specified input parameter has a value that is not valid. /// </exception> /// <exception cref="Amazon.KinesisFirehose.Model.ResourceNotFoundException"> /// The specified resource could not be found. /// </exception> /// <exception cref="Amazon.KinesisFirehose.Model.ServiceUnavailableException"> /// The service is unavailable, back off and retry the operation. If you continue to see /// the exception, throughput limits for the delivery stream may have been exceeded. For /// more information about limits and how to request an increase, see <a href="http://docs.aws.amazon.com/firehose/latest/dev/limits.html">Amazon /// Kinesis Firehose Limits</a>. /// </exception> /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/firehose-2015-08-04/PutRecordBatch">REST API Reference for PutRecordBatch Operation</seealso> public virtual void PutRecordBatchAsync(string deliveryStreamName, List <Record> records, AmazonServiceCallback <PutRecordBatchRequest, PutRecordBatchResponse> callback, AsyncOptions options = null) { var request = new PutRecordBatchRequest(); request.DeliveryStreamName = deliveryStreamName; request.Records = records; PutRecordBatchAsync(request, callback, options); }
/// <summary> /// Sets the request payment configuration for a bucket. By default, the bucket owner /// pays for downloads from the bucket. This configuration parameter enables the bucket /// owner (only) to specify that the person requesting the download will be charged for /// the download. Documentation on requester pays buckets can be found at http://docs.aws.amazon.com/AmazonS3/latest/dev/RequesterPaysBuckets.html /// 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 PutBucketRequestPaymentRequest used to execute the PutBucketRequestPayment service method.</param> /// <param name="requestPaymentConfiguration">A property of PutBucketRequestPaymentRequest used to execute the PutBucketRequestPayment 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 PutBucketRequestPayment service method, as returned by S3.</returns> public void PutBucketRequestPaymentAsync(string bucketName, RequestPaymentConfiguration requestPaymentConfiguration, AmazonServiceCallback<PutBucketRequestPaymentRequest, PutBucketRequestPaymentResponse> callback, AsyncOptions options = null) { var request = new PutBucketRequestPaymentRequest(); request.BucketName = bucketName; request.RequestPaymentConfiguration = requestPaymentConfiguration; PutBucketRequestPaymentAsync(request, callback, options); }
public void AssumeRoleWithWebIdentityAsync(AssumeRoleWithWebIdentityRequest request, AmazonServiceCallback <AssumeRoleWithWebIdentityRequest, AssumeRoleWithWebIdentityResponse> callback, AsyncOptions options = null) { //IL_0013: Unknown result type (might be due to invalid IL or missing references) options = ((options == null) ? ((object)new AsyncOptions()) : ((object)options)); AssumeRoleWithWebIdentityRequestMarshaller assumeRoleWithWebIdentityRequestMarshaller = new AssumeRoleWithWebIdentityRequestMarshaller(); AssumeRoleWithWebIdentityResponseUnmarshaller instance = AssumeRoleWithWebIdentityResponseUnmarshaller.Instance; Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> action = null; if (callback != null) { action = delegate(AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) { AmazonServiceResult <AssumeRoleWithWebIdentityRequest, AssumeRoleWithWebIdentityResponse> val = new AmazonServiceResult <AssumeRoleWithWebIdentityRequest, AssumeRoleWithWebIdentityResponse>((AssumeRoleWithWebIdentityRequest)req, (AssumeRoleWithWebIdentityResponse)res, ex, ao.get_State()); callback.Invoke(val); }; } this.BeginInvoke <AssumeRoleWithWebIdentityRequest>(request, assumeRoleWithWebIdentityRequestMarshaller, instance, options, action); }
/// <summary> /// Creates a copy of an object that is already stored in Amazon S3. /// 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="sourceBucket">A property of CopyObjectRequest used to execute the CopyObject service method.</param> /// <param name="sourceKey">A property of CopyObjectRequest used to execute the CopyObject service method.</param> /// <param name="destinationBucket">A property of CopyObjectRequest used to execute the CopyObject service method.</param> /// <param name="destinationKey">A property of CopyObjectRequest used to execute the CopyObject 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 CopyObject service method, as returned by S3.</returns> public void CopyObjectAsync(string sourceBucket, string sourceKey, string destinationBucket, string destinationKey, AmazonServiceCallback<CopyObjectRequest, CopyObjectResponse> callback, AsyncOptions options = null) { var request = new CopyObjectRequest(); request.SourceBucket = sourceBucket; request.SourceKey = sourceKey; request.DestinationBucket = destinationBucket; request.DestinationKey = destinationKey; CopyObjectAsync(request, callback, options); }
public void DecodeAuthorizationMessageAsync(DecodeAuthorizationMessageRequest request, AmazonServiceCallback <DecodeAuthorizationMessageRequest, DecodeAuthorizationMessageResponse> callback, AsyncOptions options = null) { //IL_0013: Unknown result type (might be due to invalid IL or missing references) options = ((options == null) ? ((object)new AsyncOptions()) : ((object)options)); DecodeAuthorizationMessageRequestMarshaller decodeAuthorizationMessageRequestMarshaller = new DecodeAuthorizationMessageRequestMarshaller(); DecodeAuthorizationMessageResponseUnmarshaller instance = DecodeAuthorizationMessageResponseUnmarshaller.Instance; Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> action = null; if (callback != null) { action = delegate(AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) { AmazonServiceResult <DecodeAuthorizationMessageRequest, DecodeAuthorizationMessageResponse> val = new AmazonServiceResult <DecodeAuthorizationMessageRequest, DecodeAuthorizationMessageResponse>((DecodeAuthorizationMessageRequest)req, (DecodeAuthorizationMessageResponse)res, ex, ao.get_State()); callback.Invoke(val); }; } this.BeginInvoke <DecodeAuthorizationMessageRequest>(request, decodeAuthorizationMessageRequestMarshaller, instance, options, action); }
/// <summary> /// Sets lifecycle configuration for your bucket. If a lifecycle configuration exists, /// it 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 PutLifecycleConfigurationRequest used to execute the PutLifecycleConfiguration service method.</param> /// <param name="configuration">A property of PutLifecycleConfigurationRequest used to execute the PutLifecycleConfiguration 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 PutLifecycleConfiguration service method, as returned by S3.</returns> public void PutLifecycleConfigurationAsync(string bucketName, LifecycleConfiguration configuration, AmazonServiceCallback<PutLifecycleConfigurationRequest, PutLifecycleConfigurationResponse> callback, AsyncOptions options = null) { var request = new PutLifecycleConfigurationRequest(); request.BucketName = bucketName; request.Configuration = configuration; PutLifecycleConfigurationAsync(request, callback, options); }
/// <summary> /// Initiates the asynchronous execution of the EnableEnhancedMonitoring operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the EnableEnhancedMonitoring operation on AmazonKinesisClient.</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 EnableEnhancedMonitoringAsync(EnableEnhancedMonitoringRequest request, AmazonServiceCallback <EnableEnhancedMonitoringRequest, EnableEnhancedMonitoringResponse> callback, AsyncOptions options = null) { options = options == null?new AsyncOptions():options; var marshaller = new EnableEnhancedMonitoringRequestMarshaller(); var unmarshaller = EnableEnhancedMonitoringResponseUnmarshaller.Instance; Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null; if (callback != null) { callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => { AmazonServiceResult <EnableEnhancedMonitoringRequest, EnableEnhancedMonitoringResponse> responseObject = new AmazonServiceResult <EnableEnhancedMonitoringRequest, EnableEnhancedMonitoringResponse>((EnableEnhancedMonitoringRequest)req, (EnableEnhancedMonitoringResponse)res, ex, ao.State); callback(responseObject); } } ; BeginInvoke <EnableEnhancedMonitoringRequest>(request, marshaller, unmarshaller, options, callbackHelper); }
/// <summary> /// Uploads a part by copying data from an existing object as data source. /// 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="sourceBucket">A property of CopyPartRequest used to execute the CopyPart service method.</param> /// <param name="sourceKey">A property of CopyPartRequest used to execute the CopyPart service method.</param> /// <param name="sourceVersionId">A property of CopyPartRequest used to execute the CopyPart service method.</param> /// <param name="destinationBucket">A property of CopyPartRequest used to execute the CopyPart service method.</param> /// <param name="destinationKey">A property of CopyPartRequest used to execute the CopyPart service method.</param> /// <param name="uploadId">Upload ID identifying the multipart upload whose part is being copied.</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 CopyPart service method, as returned by S3.</returns> public void CopyPartAsync(string sourceBucket, string sourceKey, string sourceVersionId, string destinationBucket, string destinationKey, string uploadId, AmazonServiceCallback<CopyPartRequest, CopyPartResponse> callback, AsyncOptions options = null) { var request = new CopyPartRequest(); request.SourceBucket = sourceBucket; request.SourceKey = sourceKey; request.SourceVersionId = sourceVersionId; request.DestinationBucket = destinationBucket; request.DestinationKey = destinationKey; request.UploadId = uploadId; CopyPartAsync(request, callback, options); }
/// <summary> /// Increases the Amazon Kinesis stream's retention period, which is the length of time /// data records are accessible after they are added to the stream. The maximum value /// of a stream's retention period is 168 hours (7 days). /// /// /// <para> /// Upon choosing a longer stream retention period, this operation will increase the time /// period records are accessible that have not yet expired. However, it will not make /// previous data that has expired (older than the stream's previous retention period) /// accessible after the operation has been called. For example, if a stream's retention /// period is set to 24 hours and is increased to 168 hours, any data that is older than /// 24 hours will remain inaccessible to consumer applications. /// </para> /// </summary> /// <param name="streamName">The name of the stream to modify.</param> /// <param name="retentionPeriodHours">The new retention period of the stream, in hours. Must be more than the current retention period.</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 IncreaseStreamRetentionPeriod service method, as returned by Kinesis.</returns> /// <exception cref="Amazon.Kinesis.Model.InvalidArgumentException"> /// A specified parameter exceeds its restrictions, is not supported, or can't be used. /// For more information, see the returned message. /// </exception> /// <exception cref="Amazon.Kinesis.Model.LimitExceededException"> /// The requested resource exceeds the maximum number allowed, or the number of concurrent /// stream requests exceeds the maximum number allowed (5). /// </exception> /// <exception cref="Amazon.Kinesis.Model.ResourceInUseException"> /// The resource is not available for this operation. For successful operation, the resource /// needs to be in the <code>ACTIVE</code> state. /// </exception> /// <exception cref="Amazon.Kinesis.Model.ResourceNotFoundException"> /// The requested resource could not be found. The stream might not be specified correctly, /// or it might not be in the <code>ACTIVE</code> state if the operation requires it. /// </exception> public void IncreaseStreamRetentionPeriodAsync(string streamName, int retentionPeriodHours, AmazonServiceCallback <IncreaseStreamRetentionPeriodRequest, IncreaseStreamRetentionPeriodResponse> callback, AsyncOptions options = null) { var request = new IncreaseStreamRetentionPeriodRequest(); request.StreamName = streamName; request.RetentionPeriodHours = retentionPeriodHours; IncreaseStreamRetentionPeriodAsync(request, callback, options); }
/// <summary> /// Deletes the lifecycle configuration from the bucket. /// 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 DeleteLifecycleConfigurationRequest used to execute the DeleteLifecycleConfiguration 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 DeleteLifecycleConfiguration service method, as returned by S3.</returns> public void DeleteLifecycleConfigurationAsync(string bucketName, AmazonServiceCallback<DeleteLifecycleConfigurationRequest, DeleteLifecycleConfigurationResponse> callback, AsyncOptions options = null) { var request = new DeleteLifecycleConfigurationRequest(); request.BucketName = bucketName; DeleteLifecycleConfigurationAsync(request, callback, options); }
/// <summary> /// Initiates the asynchronous execution of the IncreaseStreamRetentionPeriod operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the IncreaseStreamRetentionPeriod operation on AmazonKinesisClient.</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 IncreaseStreamRetentionPeriodAsync(IncreaseStreamRetentionPeriodRequest request, AmazonServiceCallback <IncreaseStreamRetentionPeriodRequest, IncreaseStreamRetentionPeriodResponse> callback, AsyncOptions options = null) { options = options == null?new AsyncOptions():options; var marshaller = new IncreaseStreamRetentionPeriodRequestMarshaller(); var unmarshaller = IncreaseStreamRetentionPeriodResponseUnmarshaller.Instance; Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null; if (callback != null) { callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => { AmazonServiceResult <IncreaseStreamRetentionPeriodRequest, IncreaseStreamRetentionPeriodResponse> responseObject = new AmazonServiceResult <IncreaseStreamRetentionPeriodRequest, IncreaseStreamRetentionPeriodResponse>((IncreaseStreamRetentionPeriodRequest)req, (IncreaseStreamRetentionPeriodResponse)res, ex, ao.State); callback(responseObject); } } ; BeginInvoke <IncreaseStreamRetentionPeriodRequest>(request, marshaller, unmarshaller, options, callbackHelper); }
/// <summary> /// Initiates the asynchronous execution of the DeleteObject 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 DeleteObject 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 DeleteObjectAsync(DeleteObjectRequest request, AmazonServiceCallback<DeleteObjectRequest, DeleteObjectResponse> callback, AsyncOptions options = null) { if (AWSConfigs.HttpClient == AWSConfigs.HttpClientOption.UnityWWW) { throw new InvalidOperationException("DeleteObject is only allowed with AWSConfigs.HttpClientOption.UnityWebRequest API option"); } options = options == null?new AsyncOptions():options; var marshaller = new DeleteObjectRequestMarshaller(); var unmarshaller = DeleteObjectResponseUnmarshaller.Instance; Action<AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null; if(callback !=null ) callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => { AmazonServiceResult<DeleteObjectRequest,DeleteObjectResponse> responseObject = new AmazonServiceResult<DeleteObjectRequest,DeleteObjectResponse>((DeleteObjectRequest)req, (DeleteObjectResponse)res, ex , ao.State); callback(responseObject); }; BeginInvoke<DeleteObjectRequest>(request, marshaller, unmarshaller, options, callbackHelper); }
/// <summary> /// Lists your Amazon Kinesis streams. /// /// /// <para> /// The number of streams may be too large to return from a single call to <code>ListStreams</code>. /// You can limit the number of returned streams using the <code>Limit</code> parameter. /// If you do not specify a value for the <code>Limit</code> parameter, Amazon Kinesis /// uses the default limit, which is currently 10. /// </para> /// /// <para> /// You can detect if there are more streams available to list by using the <code>HasMoreStreams</code> /// flag from the returned output. If there are more streams available, you can request /// more streams by using the name of the last stream returned by the <code>ListStreams</code> /// request in the <code>ExclusiveStartStreamName</code> parameter in a subsequent request /// to <code>ListStreams</code>. The group of stream names returned by the subsequent /// request is then added to the list. You can continue this process until all the stream /// names have been collected in the list. /// </para> /// /// <para> /// <a>ListStreams</a> has a limit of 5 transactions per second per account. /// </para> /// </summary> /// <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 ListStreams service method, as returned by Kinesis.</returns> /// <exception cref="Amazon.Kinesis.Model.LimitExceededException"> /// The requested resource exceeds the maximum number allowed, or the number of concurrent /// stream requests exceeds the maximum number allowed (5). /// </exception> public void ListStreamsAsync(AmazonServiceCallback <ListStreamsRequest, ListStreamsResponse> callback, AsyncOptions options = null) { ListStreamsAsync(new ListStreamsRequest(), callback, options); }
/// <summary> /// Sets the roles for an identity pool. These roles are used when making calls to <code>GetCredentialsForIdentity</code> /// action. /// </summary> /// <param name="identityPoolId">An identity pool ID in the format REGION:GUID.</param> /// <param name="roles">The map of roles associated with this pool. Currently only authenticated and unauthenticated roles are supported.</param> /// /// <returns>The response from the SetIdentityPoolRoles service method, as returned by CognitoIdentity.</returns> /// <exception cref="Amazon.CognitoIdentity.Model.InternalErrorException"> /// Thrown when the service encounters an error during processing the request. /// </exception> /// <exception cref="Amazon.CognitoIdentity.Model.InvalidParameterException"> /// Thrown for missing or bad input parameter(s). /// </exception> /// <exception cref="Amazon.CognitoIdentity.Model.NotAuthorizedException"> /// Thrown when a user is not authorized to access the requested resource. /// </exception> /// <exception cref="Amazon.CognitoIdentity.Model.ResourceConflictException"> /// Thrown when a user tries to use a login which is already linked to another account. /// </exception> /// <exception cref="Amazon.CognitoIdentity.Model.ResourceNotFoundException"> /// Thrown when the requested resource (for example, a dataset or record) does not exist. /// </exception> /// <exception cref="Amazon.CognitoIdentity.Model.TooManyRequestsException"> /// Thrown when a request is throttled. /// </exception> public void SetIdentityPoolRolesAsync(string identityPoolId, Dictionary<string, string> roles, AmazonServiceCallback<SetIdentityPoolRolesRequest, SetIdentityPoolRolesResponse> callback, AsyncOptions options = null) { var request = new SetIdentityPoolRolesRequest(); request.IdentityPoolId = identityPoolId; request.Roles = roles; SetIdentityPoolRolesAsync(request, callback, options); }
/// <summary> /// Initiates the asynchronous execution of the AssumeRoleWithWebIdentity operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the AssumeRoleWithWebIdentity operation on AmazonSecurityTokenServiceClient.</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 AssumeRoleWithWebIdentityAsync(AssumeRoleWithWebIdentityRequest request, AmazonServiceCallback <AssumeRoleWithWebIdentityRequest, AssumeRoleWithWebIdentityResponse> callback, AsyncOptions options = null) { options = options == null?new AsyncOptions():options; var marshaller = new AssumeRoleWithWebIdentityRequestMarshaller(); var unmarshaller = AssumeRoleWithWebIdentityResponseUnmarshaller.Instance; Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null; if (callback != null) { callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => { AmazonServiceResult <AssumeRoleWithWebIdentityRequest, AssumeRoleWithWebIdentityResponse> responseObject = new AmazonServiceResult <AssumeRoleWithWebIdentityRequest, AssumeRoleWithWebIdentityResponse>((AssumeRoleWithWebIdentityRequest)req, (AssumeRoleWithWebIdentityResponse)res, ex, ao.State); callback(responseObject); } } ; BeginInvoke <AssumeRoleWithWebIdentityRequest>(request, marshaller, unmarshaller, options, callbackHelper); }
/// <summary> /// Gets an OpenID token, using a known Cognito ID. This known Cognito ID is returned /// by <a>GetId</a>. You can optionally add additional logins for the identity. Supplying /// multiple logins creates an implicit link. /// /// /// <para> /// The OpenId token is valid for 15 minutes. /// </para> /// </summary> /// <param name="identityId">A unique identifier in the format REGION:GUID.</param> /// /// <returns>The response from the GetOpenIdToken service method, as returned by CognitoIdentity.</returns> /// <exception cref="Amazon.CognitoIdentity.Model.InternalErrorException"> /// Thrown when the service encounters an error during processing the request. /// </exception> /// <exception cref="Amazon.CognitoIdentity.Model.InvalidParameterException"> /// Thrown for missing or bad input parameter(s). /// </exception> /// <exception cref="Amazon.CognitoIdentity.Model.NotAuthorizedException"> /// Thrown when a user is not authorized to access the requested resource. /// </exception> /// <exception cref="Amazon.CognitoIdentity.Model.ResourceConflictException"> /// Thrown when a user tries to use a login which is already linked to another account. /// </exception> /// <exception cref="Amazon.CognitoIdentity.Model.ResourceNotFoundException"> /// Thrown when the requested resource (for example, a dataset or record) does not exist. /// </exception> /// <exception cref="Amazon.CognitoIdentity.Model.TooManyRequestsException"> /// Thrown when a request is throttled. /// </exception> public void GetOpenIdTokenAsync(string identityId, AmazonServiceCallback<GetOpenIdTokenRequest, GetOpenIdTokenResponse> callback, AsyncOptions options = null) { var request = new GetOpenIdTokenRequest(); request.IdentityId = identityId; GetOpenIdTokenAsync(request, callback, options); }
/// <summary> /// Initiates the asynchronous execution of the DecodeAuthorizationMessage operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the DecodeAuthorizationMessage operation on AmazonSecurityTokenServiceClient.</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 DecodeAuthorizationMessageAsync(DecodeAuthorizationMessageRequest request, AmazonServiceCallback <DecodeAuthorizationMessageRequest, DecodeAuthorizationMessageResponse> callback, AsyncOptions options = null) { options = options == null?new AsyncOptions():options; var marshaller = new DecodeAuthorizationMessageRequestMarshaller(); var unmarshaller = DecodeAuthorizationMessageResponseUnmarshaller.Instance; Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null; if (callback != null) { callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => { AmazonServiceResult <DecodeAuthorizationMessageRequest, DecodeAuthorizationMessageResponse> responseObject = new AmazonServiceResult <DecodeAuthorizationMessageRequest, DecodeAuthorizationMessageResponse>((DecodeAuthorizationMessageRequest)req, (DecodeAuthorizationMessageResponse)res, ex, ao.State); callback(responseObject); } } ; BeginInvoke <DecodeAuthorizationMessageRequest>(request, marshaller, unmarshaller, options, callbackHelper); }
/// <summary> /// Gets usage details (for example, data storage) about a particular identity pool. /// /// /// <para> /// This API can only be called with developer credentials. You cannot call this API with /// the temporary user credentials provided by Cognito Identity. /// </para> /// </summary> /// <param name="identityPoolId">A name-spaced GUID (for example, us-east-1:23EC4050-6AEA-7089-A2DD-08002EXAMPLE) created by Amazon Cognito. GUID generation is unique within a region.</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 DescribeIdentityPoolUsage service method, as returned by CognitoSync.</returns> /// <exception cref="Amazon.CognitoSync.Model.InternalErrorException"> /// Indicates an internal service error. /// </exception> /// <exception cref="Amazon.CognitoSync.Model.InvalidParameterException"> /// Thrown when a request parameter does not comply with the associated constraints. /// </exception> /// <exception cref="Amazon.CognitoSync.Model.NotAuthorizedException"> /// Thrown when a user is not authorized to access the requested resource. /// </exception> /// <exception cref="Amazon.CognitoSync.Model.ResourceNotFoundException"> /// Thrown if the resource doesn't exist. /// </exception> /// <exception cref="Amazon.CognitoSync.Model.TooManyRequestsException"> /// Thrown if the request is throttled. /// </exception> public void DescribeIdentityPoolUsageAsync(string identityPoolId, AmazonServiceCallback<DescribeIdentityPoolUsageRequest, DescribeIdentityPoolUsageResponse> callback, AsyncOptions options = null) { var request = new DescribeIdentityPoolUsageRequest(); request.IdentityPoolId = identityPoolId; DescribeIdentityPoolUsageAsync(request, callback, options); }
/// <summary> /// Returns a set of temporary credentials for an AWS account or IAM user. The credentials /// consist of an access key ID, a secret access key, and a security token. Typically, /// you use <code>GetSessionToken</code> if you want to use MFA to protect programmatic /// calls to specific AWS APIs like Amazon EC2 <code>StopInstances</code>. MFA-enabled /// IAM users would need to call <code>GetSessionToken</code> and submit an MFA code that /// is associated with their MFA device. Using the temporary security credentials that /// are returned from the call, IAM users can then make programmatic calls to APIs that /// require MFA authentication. If you do not supply a correct MFA code, then the API /// returns an access denied error. /// /// /// <para> /// The <code>GetSessionToken</code> action must be called by using the long-term AWS /// security credentials of the AWS account or an IAM user. Credentials that are created /// by IAM users are valid for the duration that you specify, between 900 seconds (15 /// minutes) and 129600 seconds (36 hours); credentials that are created by using account /// credentials have a maximum duration of 3600 seconds (1 hour). /// </para> /// <note> /// <para> /// We recommend that you do not call <code>GetSessionToken</code> with root account credentials. /// Instead, follow our <a href="http://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#create-iam-users">best /// practices</a> by creating one or more IAM users, giving them the necessary permissions, /// and using IAM users for everyday interaction with AWS. /// </para> /// </note> /// <para> /// The permissions associated with the temporary security credentials returned by <code>GetSessionToken</code> /// are based on the permissions associated with account or IAM user whose credentials /// are used to call the action. If <code>GetSessionToken</code> is called using root /// account credentials, the temporary credentials have root account permissions. Similarly, /// if <code>GetSessionToken</code> is called using the credentials of an IAM user, the /// temporary credentials have the same permissions as the IAM user. /// </para> /// /// <para> /// For more information about using <code>GetSessionToken</code> to create temporary /// credentials, go to <a href="http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#api_getsessiontoken">Temporary /// Credentials for Users in Untrusted Environments</a> in the <i>Using IAM</i>. /// </para> /// </summary> /// <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 GetSessionToken service method, as returned by SecurityTokenService.</returns> /// <exception cref="Amazon.SecurityToken.Model.RegionDisabledException"> /// STS is not activated in the requested region for the account that is being asked to /// create temporary credentials. The account administrator must activate STS in that /// region using the IAM Console. For more information, see <a href="http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html">Activating /// and Deactivating AWS STS in an AWS Region</a> in the <i>Using IAM</i>. /// </exception> public void GetSessionTokenAsync(AmazonServiceCallback <GetSessionTokenRequest, GetSessionTokenResponse> callback, AsyncOptions options = null) { GetSessionTokenAsync(new GetSessionTokenRequest(), callback, options); }
/// <summary> /// Gets the configuration settings of an identity pool. /// /// /// <para> /// This API can only be called with developer credentials. You cannot call this API with /// the temporary user credentials provided by Cognito Identity. /// </para> /// </summary> /// <param name="identityPoolId">A name-spaced GUID (for example, us-east-1:23EC4050-6AEA-7089-A2DD-08002EXAMPLE) created by Amazon Cognito. This is the ID of the pool for which to return a configuration.</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 GetIdentityPoolConfiguration service method, as returned by CognitoSync.</returns> /// <exception cref="Amazon.CognitoSync.Model.InternalErrorException"> /// Indicates an internal service error. /// </exception> /// <exception cref="Amazon.CognitoSync.Model.InvalidParameterException"> /// Thrown when a request parameter does not comply with the associated constraints. /// </exception> /// <exception cref="Amazon.CognitoSync.Model.NotAuthorizedException"> /// Thrown when a user is not authorized to access the requested resource. /// </exception> /// <exception cref="Amazon.CognitoSync.Model.ResourceNotFoundException"> /// Thrown if the resource doesn't exist. /// </exception> /// <exception cref="Amazon.CognitoSync.Model.TooManyRequestsException"> /// Thrown if the request is throttled. /// </exception> public void GetIdentityPoolConfigurationAsync(string identityPoolId, AmazonServiceCallback<GetIdentityPoolConfigurationRequest, GetIdentityPoolConfigurationResponse> callback, AsyncOptions options = null) { var request = new GetIdentityPoolConfigurationRequest(); request.IdentityPoolId = identityPoolId; GetIdentityPoolConfigurationAsync(request, callback, options); }
/// <summary> /// Initiates the asynchronous execution of the GetOpenIdTokenForDeveloperIdentity operation. /// <seealso cref="Amazon.CognitoIdentity.IAmazonCognitoIdentity"/> /// </summary> /// <param name="request">Container for the necessary parameters to execute the GetOpenIdTokenForDeveloperIdentity operation.</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>void</returns> public void GetOpenIdTokenForDeveloperIdentityAsync(GetOpenIdTokenForDeveloperIdentityRequest request, AmazonServiceCallback callback, object state) { if (!AmazonInitializer.IsInitialized) { throw new Exception("AWSPrefab is not added to the scene"); } ThreadPool.QueueUserWorkItem(new WaitCallback(delegate { var marshaller = new GetOpenIdTokenForDeveloperIdentityRequestMarshaller(); var unmarshaller = GetOpenIdTokenForDeveloperIdentityResponseUnmarshaller.Instance; Invoke(request, callback, state, marshaller, unmarshaller, signer); })); return; }
/// <summary> /// Initiates the asynchronous execution of the UpdateRecords operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the UpdateRecords operation on AmazonCognitoSyncClient.</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 UpdateRecordsAsync(UpdateRecordsRequest request, AmazonServiceCallback<UpdateRecordsRequest, UpdateRecordsResponse> callback, AsyncOptions options = null) { options = options == null?new AsyncOptions():options; var marshaller = new UpdateRecordsRequestMarshaller(); var unmarshaller = UpdateRecordsResponseUnmarshaller.Instance; Action<AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null; if(callback !=null ) callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => { AmazonServiceResult<UpdateRecordsRequest,UpdateRecordsResponse> responseObject = new AmazonServiceResult<UpdateRecordsRequest,UpdateRecordsResponse>((UpdateRecordsRequest)req, (UpdateRecordsResponse)res, ex , ao.State); callback(responseObject); }; BeginInvoke<UpdateRecordsRequest>(request, marshaller, unmarshaller, options, callbackHelper); }
public void PutScalingPolicyAsync(PutScalingPolicyRequest request, AmazonServiceCallback <PutScalingPolicyRequest, PutScalingPolicyResponse> callback, AsyncOptions options = null) { throw new System.NotImplementedException(); }