/// <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 static void AsyncExecutor(Action action, AsyncOptions options)
{
if (options.ExecuteCallbackOnMainThread)
{
if (UnityInitializer.IsMainThread())
{
SafeExecute(action);
}
else
{
UnityRequestQueue.Instance.ExecuteOnMainThread(action);
}
}
else
{
if (!UnityInitializer.IsMainThread())
{
SafeExecute(action);
}
else
{
ThreadPool.QueueUserWorkItem((state) =>
{
SafeExecute(action);
});
}
}
}
/// <summary>
/// Initiates the asynchronous execution of the GetRemaining operation.
/// <seealso cref="Amazon.DynamoDBv2.DocumentModel.Search.GetRemaining"/>
/// </summary>
/// <param name="callback">The callback that will be invoked when the asynchronous operation completes.</param>
/// <param name="asyncOptions">An instance of AsyncOptions that specifies how the async method should be executed.</param>
public void GetRemainingAsync(AmazonDynamoDBCallback<List<Document>> callback, AsyncOptions asyncOptions = null)
{
asyncOptions = asyncOptions ?? new AsyncOptions();
DynamoDBAsyncExecutor.ExecuteAsync<List<Document>>(
() => { return GetRemainingHelper(true); },
asyncOptions,
callback);
}
internal static void LoadTableAsync(IAmazonDynamoDB ddbClient, string tableName, Table.DynamoDBConsumer consumer, DynamoDBEntryConversion conversion, AmazonDynamoDBCallback<Table> callback, AsyncOptions asyncOptions = null)
{
asyncOptions = asyncOptions??new AsyncOptions();
DynamoDBAsyncExecutor.ExecuteAsync<Table>(
()=>{
return LoadTable(ddbClient,tableName,consumer,conversion);
},asyncOptions,callback);
}
/// <summary>
/// Initiates the asynchronous execution of the Execute operation.
/// <seealso cref="Amazon.DynamoDBv2.DataModel.MultiTableBatchWrite.Execute"/>
/// </summary>
/// <param name="callback">The callback that will be invoked when the asynchronous operation completes.</param>
/// <param name="asyncOptions">An instance of AsyncOptions that specifies how the async method should be executed.</param>
public void ExecuteAsync(AmazonDynamoDBCallback callback, AsyncOptions asyncOptions = null)
{
asyncOptions = asyncOptions ?? new AsyncOptions();
DynamoDBAsyncExecutor.ExecuteAsync(
() => { ExecuteHelper(true); },
asyncOptions,
callback);
}
/// <summary>
/// Initiates the asynchronous execution of the PutItem operation.
/// </summary>
/// <param name="doc">Document to save.</param>
/// <param name="callback">The callback that will be invoked when the asynchronous operation completes.</param>
/// <param name="asyncOptions">An instance of AsyncOptions that specifies how the async method should be executed.</param>
public void PutItemAsync(Document doc, AmazonDynamoDBCallback<Document> callback, AsyncOptions asyncOptions = null)
{
asyncOptions = asyncOptions ?? new AsyncOptions();
DynamoDBAsyncExecutor.ExecuteAsync<Document>(
() => { return PutItemHelper(doc, null, true); },
asyncOptions,
callback);
}
/// <summary>
/// Synchronize <see cref="Dataset"/> between local storage and remote storage.
/// </summary>
public virtual void SynchronizeAsync(AsyncOptions options = null)
{
options = options == null ? new AsyncOptions() : options;
if (_netReachability.NetworkStatus == NetworkStatus.NotReachable)
{
FireSyncFailureEvent(new NetworkException("Network connectivity unavailable."), options);
return;
}
SynchronizeHelperAsync(options);
}
/// <summary>
/// Initiates the asynchronous execution of the UploadFrom operation.
/// </summary>
/// <param name="sourcePath">Path of the file to be uploaded.</param>
/// <param name="callback">The callback that will be invoked when the asynchronous operation completes.</param>
/// <param name="asyncOptions">An instance of AsyncOptions that specifies how the async method should be executed.</param>
public void UploadFromAsync(string sourcePath, AmazonDynamoDBCallback callback, AsyncOptions asyncOptions = null)
{
asyncOptions = asyncOptions ?? new AsyncOptions();
DynamoDBAsyncExecutor.ExecuteAsync(
() =>
{
this.s3ClientCache.GetClient(this.RegionAsEndpoint).UploadObjectFromFilePath(
this.linker.s3.bucket, this.linker.s3.key, sourcePath, null);
},
asyncOptions,
callback);
}
/// <summary>
/// Attempt to synchronize <see cref="Dataset"/> when connectivity is available. If
/// the connectivity is available right away, it behaves the same as
/// <see cref="Dataset.SynchronizeAsync(AsyncOptions)"/>. Otherwise it listens to connectivity
/// changes, and will do a sync once the connectivity is back. Note that if
/// this method is called multiple times, only the last synchronize request
/// is kept. If either the dataset or the callback is garbage collected
/// , this method will not perform a sync and the callback won't fire.
/// </summary>
public virtual void SynchronizeOnConnectivity(AsyncOptions options = null)
{
if (_netReachability.NetworkStatus != NetworkStatus.NotReachable)
{
SynchronizeAsync(options);
}
else
{
waitingForConnectivity = true;
OnConnectivityOptions = options;
}
}
/// <summary>
/// Initiates the asynchronous execution of the DownloadTo operation.
/// </summary>
/// <param name="downloadPath">Path to save the file.</param>
/// <param name="callback">The callback that will be invoked when the asynchronous operation completes.</param>
/// <param name="asyncOptions">An instance of AsyncOptions that specifies how the async method should be executed.</param>
public void DownloadToAsync(string downloadPath, AmazonDynamoDBCallback callback, AsyncOptions asyncOptions = null)
{
asyncOptions = asyncOptions ?? new AsyncOptions();
DynamoDBAsyncExecutor.ExecuteAsync(
() =>
{
this.s3ClientCache.GetClient(this.RegionAsEndpoint).DownloadToFilePath(
this.linker.s3.bucket, this.linker.s3.key, downloadPath, null);
},
asyncOptions,
callback);
}
/// <summary>
/// Refreshes dataset metadata. Dataset metadata is pulled from remote
/// storage and stored in local storage. Their record data isn't pulled down
/// until you sync each dataset.
/// </summary>
/// <param name="callback">Callback once the refresh is complete</param>
/// <param name="options">Options for asynchronous execution</param>
/// <exception cref="Amazon.CognitoSync.SyncManager.DataStorageException">Thrown when fail to fresh dataset metadata</exception>
public void RefreshDatasetMetadataAsync(AmazonCognitoSyncCallback<List<DatasetMetadata>> callback, AsyncOptions options = null)
{
options = options ?? new AsyncOptions();
AmazonCognitoSyncResult<List<DatasetMetadata>> cognitoResult = new AmazonCognitoSyncResult<List<DatasetMetadata>>(options.State);
InternalSDKUtils.AsyncExecutor(() =>
{
try
{
var response = Remote.ListDatasetMetadata();
Local.UpdateDatasetMetadata(IdentityId, response);
cognitoResult.Response = response;
}
catch (Exception e)
{
cognitoResult.Exception = e;
}
callback(cognitoResult);
}, options);
}
private void PopulateGetDatasetMetadataAsync(string nextToken, List<DatasetMetadata> datasets, AmazonCognitoSyncCallback<List<DatasetMetadata>> callback, AsyncOptions options)
{
ListDatasetsRequest request = new ListDatasetsRequest();
// a large enough number to reduce # of requests
request.MaxResults = 64;
request.NextToken = nextToken;
client.ListDatasetsAsync(request, (responseObj) =>
{
Exception ex = responseObj.Exception;
ListDatasetsResponse response = responseObj.Response;
object obj = responseObj.state;
if (ex != null)
{
InternalSDKUtils.AsyncExecutor(() => callback(new AmazonCognitoSyncResult<List<DatasetMetadata>>(null, ex, obj)), options);
}
else
{
foreach (Amazon.CognitoSync.Model.Dataset dataset in response.Datasets)
{
datasets.Add(ModelToDatasetMetadata(dataset));
}
nextToken = response.NextToken;
if (nextToken == null)
{
InternalSDKUtils.AsyncExecutor(() => callback(new AmazonCognitoSyncResult<List<DatasetMetadata>>(datasets, null, obj)), options);
return;
}
PopulateGetDatasetMetadataAsync(nextToken, datasets, callback, options);
}
},
options);
}
/// <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>
/// 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>
/// 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);
}
protected IAsyncResult BeginInvoke <TRequest>(TRequest request,
IMarshaller <IRequest, AmazonWebServiceRequest> marshaller, ResponseUnmarshaller unmarshaller, AsyncOptions asyncOptions,
Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper)
where TRequest : AmazonWebServiceRequest
{
ThrowIfDisposed();
asyncOptions = asyncOptions ?? new AsyncOptions();
var executionContext = new AsyncExecutionContext(
new AsyncRequestContext(this.Config.LogMetrics, Signer)
{
ClientConfig = this.Config,
Marshaller = marshaller,
OriginalRequest = request,
Unmarshaller = unmarshaller,
Action = callbackHelper,
AsyncOptions = asyncOptions,
IsAsync = true
},
new AsyncResponseContext()
);
return(this.RuntimePipeline.InvokeAsync(executionContext));
}
/// <summary>
/// Returns an instance of ImmutableCredentials for this instance
/// </summary>
/// <param name="callback">The callback which is executed when the asynchronous operations is completed</param>
/// <param name="options">Options for executing asynchronous operation</param>
public void GetCredentialsAsync(AmazonCognitoIdentityCallback<ImmutableCredentials> callback, AsyncOptions options = null)
{
options = options == null ? new AsyncOptions() : options;
CognitoIdentityAsyncExecutor.ExecuteAsync<ImmutableCredentials>(() =>
{
return GetCredentials();
}, options, callback);
}
/// <summary>
/// Gets the Identity Id corresponding to the credentials retrieved from Cognito.
/// Note: this setting may change during execution. To be notified of its
/// new value, attach a listener to IdentityChangedEvent
/// </summary>
/// <param name="callback">The callback which is executed when the asynchronous operations is completed</param>
/// <param name="options">Options for executing asynchronous operation</param>
public void GetIdentityIdAsync(AmazonCognitoIdentityCallback<string> callback, AsyncOptions options = null)
{
options = options == null ? new AsyncOptions() : options;
CognitoIdentityAsyncExecutor.ExecuteAsync<string>(() =>
{
return GetIdentityId();
}, options, callback);
}
/// <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);
}
/// <summary>
/// Refreshes dataset metadata. Dataset metadata is pulled from remote
/// storage and stored in local storage. Their record data isn't pulled down
/// until you sync each dataset.
/// </summary>
/// <param name="callback">Callback once the refresh is complete</param>
/// <param name="options">Options for asynchronous execution</param>
/// <exception cref="Amazon.CognitoSync.SyncManager.DataStorageException">Thrown when fail to fresh dataset metadata</exception>
public void RefreshDatasetMetadataAsync(AmazonCognitoSyncCallback<List<DatasetMetadata>> callback, AsyncOptions options = null)
{
options = options ?? new AsyncOptions();
remote.GetDatasetMetadataAsync((cognitoResult) =>
{
Exception ex = cognitoResult.Exception;
List<DatasetMetadata> res = cognitoResult.Response;
if (ex != null)
{
InternalSDKUtils.AsyncExecutor(() => callback(cognitoResult), options);
}
else
{
Local.UpdateDatasetMetadata(GetIdentityId(), res);
InternalSDKUtils.AsyncExecutor(() => callback(cognitoResult), options);
}
}, options);
}
/// <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>
/// 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);
}
protected IAsyncResult BeginInvoke <TRequest>(TRequest request,
IMarshaller <IRequest, AmazonWebServiceRequest> marshaller, ResponseUnmarshaller unmarshaller, AsyncOptions asyncOptions,
Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper)
where TRequest : AmazonWebServiceRequest
{
var options = new InvokeOptions();
options.RequestMarshaller = marshaller;
options.ResponseUnmarshaller = unmarshaller;
return(BeginInvoke(request, options, asyncOptions, callbackHelper));
}
/// <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 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>
/// 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);
}
protected IAsyncResult BeginInvoke(AmazonWebServiceRequest request, InvokeOptionsBase options, AsyncOptions asyncOptions,
Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper)
{
ThrowIfDisposed();
asyncOptions = asyncOptions ?? new AsyncOptions();
var executionContext = new AsyncExecutionContext(
new AsyncRequestContext(this.Config.LogMetrics, Signer)
{
ClientConfig = this.Config,
Marshaller = options.RequestMarshaller,
OriginalRequest = request,
Unmarshaller = options.ResponseUnmarshaller,
Action = callbackHelper,
AsyncOptions = asyncOptions,
IsAsync = true,
ServiceMetaData = this.ServiceMetadata,
Options = options
},
new AsyncResponseContext()
);
return(this.RuntimePipeline.InvokeAsync(executionContext));
}
/// <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>
/// 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>
/// 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>
/// 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);
}
/// <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);
}
/// <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);
}