software.amazon.awssdk.services.cognitoidentity.DefaultCognitoIdentityAsyncClient Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of cognitoidentity Show documentation
Show all versions of cognitoidentity Show documentation
The AWS Java SDK for Amazon Cognito Identity module holds the client classes that are used for
communicating with Amazon Cognito Identity Service
/*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
* the License. A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
* and limitations under the License.
*/
package software.amazon.awssdk.services.cognitoidentity;
import java.util.concurrent.CompletableFuture;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import software.amazon.awssdk.annotations.Generated;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.awscore.client.handler.AwsAsyncClientHandler;
import software.amazon.awssdk.awscore.exception.AwsServiceException;
import software.amazon.awssdk.core.client.config.SdkClientConfiguration;
import software.amazon.awssdk.core.client.handler.AsyncClientHandler;
import software.amazon.awssdk.core.client.handler.ClientExecutionParams;
import software.amazon.awssdk.core.http.HttpResponseHandler;
import software.amazon.awssdk.protocols.core.ExceptionMetadata;
import software.amazon.awssdk.protocols.json.AwsJsonProtocol;
import software.amazon.awssdk.protocols.json.AwsJsonProtocolFactory;
import software.amazon.awssdk.protocols.json.BaseAwsJsonProtocolFactory;
import software.amazon.awssdk.protocols.json.JsonOperationMetadata;
import software.amazon.awssdk.services.cognitoidentity.model.CognitoIdentityException;
import software.amazon.awssdk.services.cognitoidentity.model.ConcurrentModificationException;
import software.amazon.awssdk.services.cognitoidentity.model.CreateIdentityPoolRequest;
import software.amazon.awssdk.services.cognitoidentity.model.CreateIdentityPoolResponse;
import software.amazon.awssdk.services.cognitoidentity.model.DeleteIdentitiesRequest;
import software.amazon.awssdk.services.cognitoidentity.model.DeleteIdentitiesResponse;
import software.amazon.awssdk.services.cognitoidentity.model.DeleteIdentityPoolRequest;
import software.amazon.awssdk.services.cognitoidentity.model.DeleteIdentityPoolResponse;
import software.amazon.awssdk.services.cognitoidentity.model.DescribeIdentityPoolRequest;
import software.amazon.awssdk.services.cognitoidentity.model.DescribeIdentityPoolResponse;
import software.amazon.awssdk.services.cognitoidentity.model.DescribeIdentityRequest;
import software.amazon.awssdk.services.cognitoidentity.model.DescribeIdentityResponse;
import software.amazon.awssdk.services.cognitoidentity.model.DeveloperUserAlreadyRegisteredException;
import software.amazon.awssdk.services.cognitoidentity.model.ExternalServiceException;
import software.amazon.awssdk.services.cognitoidentity.model.GetCredentialsForIdentityRequest;
import software.amazon.awssdk.services.cognitoidentity.model.GetCredentialsForIdentityResponse;
import software.amazon.awssdk.services.cognitoidentity.model.GetIdRequest;
import software.amazon.awssdk.services.cognitoidentity.model.GetIdResponse;
import software.amazon.awssdk.services.cognitoidentity.model.GetIdentityPoolRolesRequest;
import software.amazon.awssdk.services.cognitoidentity.model.GetIdentityPoolRolesResponse;
import software.amazon.awssdk.services.cognitoidentity.model.GetOpenIdTokenForDeveloperIdentityRequest;
import software.amazon.awssdk.services.cognitoidentity.model.GetOpenIdTokenForDeveloperIdentityResponse;
import software.amazon.awssdk.services.cognitoidentity.model.GetOpenIdTokenRequest;
import software.amazon.awssdk.services.cognitoidentity.model.GetOpenIdTokenResponse;
import software.amazon.awssdk.services.cognitoidentity.model.InternalErrorException;
import software.amazon.awssdk.services.cognitoidentity.model.InvalidIdentityPoolConfigurationException;
import software.amazon.awssdk.services.cognitoidentity.model.InvalidParameterException;
import software.amazon.awssdk.services.cognitoidentity.model.LimitExceededException;
import software.amazon.awssdk.services.cognitoidentity.model.ListIdentitiesRequest;
import software.amazon.awssdk.services.cognitoidentity.model.ListIdentitiesResponse;
import software.amazon.awssdk.services.cognitoidentity.model.ListIdentityPoolsRequest;
import software.amazon.awssdk.services.cognitoidentity.model.ListIdentityPoolsResponse;
import software.amazon.awssdk.services.cognitoidentity.model.ListTagsForResourceRequest;
import software.amazon.awssdk.services.cognitoidentity.model.ListTagsForResourceResponse;
import software.amazon.awssdk.services.cognitoidentity.model.LookupDeveloperIdentityRequest;
import software.amazon.awssdk.services.cognitoidentity.model.LookupDeveloperIdentityResponse;
import software.amazon.awssdk.services.cognitoidentity.model.MergeDeveloperIdentitiesRequest;
import software.amazon.awssdk.services.cognitoidentity.model.MergeDeveloperIdentitiesResponse;
import software.amazon.awssdk.services.cognitoidentity.model.NotAuthorizedException;
import software.amazon.awssdk.services.cognitoidentity.model.ResourceConflictException;
import software.amazon.awssdk.services.cognitoidentity.model.ResourceNotFoundException;
import software.amazon.awssdk.services.cognitoidentity.model.SetIdentityPoolRolesRequest;
import software.amazon.awssdk.services.cognitoidentity.model.SetIdentityPoolRolesResponse;
import software.amazon.awssdk.services.cognitoidentity.model.TagResourceRequest;
import software.amazon.awssdk.services.cognitoidentity.model.TagResourceResponse;
import software.amazon.awssdk.services.cognitoidentity.model.TooManyRequestsException;
import software.amazon.awssdk.services.cognitoidentity.model.UnlinkDeveloperIdentityRequest;
import software.amazon.awssdk.services.cognitoidentity.model.UnlinkDeveloperIdentityResponse;
import software.amazon.awssdk.services.cognitoidentity.model.UnlinkIdentityRequest;
import software.amazon.awssdk.services.cognitoidentity.model.UnlinkIdentityResponse;
import software.amazon.awssdk.services.cognitoidentity.model.UntagResourceRequest;
import software.amazon.awssdk.services.cognitoidentity.model.UntagResourceResponse;
import software.amazon.awssdk.services.cognitoidentity.model.UpdateIdentityPoolRequest;
import software.amazon.awssdk.services.cognitoidentity.model.UpdateIdentityPoolResponse;
import software.amazon.awssdk.services.cognitoidentity.transform.CreateIdentityPoolRequestMarshaller;
import software.amazon.awssdk.services.cognitoidentity.transform.DeleteIdentitiesRequestMarshaller;
import software.amazon.awssdk.services.cognitoidentity.transform.DeleteIdentityPoolRequestMarshaller;
import software.amazon.awssdk.services.cognitoidentity.transform.DescribeIdentityPoolRequestMarshaller;
import software.amazon.awssdk.services.cognitoidentity.transform.DescribeIdentityRequestMarshaller;
import software.amazon.awssdk.services.cognitoidentity.transform.GetCredentialsForIdentityRequestMarshaller;
import software.amazon.awssdk.services.cognitoidentity.transform.GetIdRequestMarshaller;
import software.amazon.awssdk.services.cognitoidentity.transform.GetIdentityPoolRolesRequestMarshaller;
import software.amazon.awssdk.services.cognitoidentity.transform.GetOpenIdTokenForDeveloperIdentityRequestMarshaller;
import software.amazon.awssdk.services.cognitoidentity.transform.GetOpenIdTokenRequestMarshaller;
import software.amazon.awssdk.services.cognitoidentity.transform.ListIdentitiesRequestMarshaller;
import software.amazon.awssdk.services.cognitoidentity.transform.ListIdentityPoolsRequestMarshaller;
import software.amazon.awssdk.services.cognitoidentity.transform.ListTagsForResourceRequestMarshaller;
import software.amazon.awssdk.services.cognitoidentity.transform.LookupDeveloperIdentityRequestMarshaller;
import software.amazon.awssdk.services.cognitoidentity.transform.MergeDeveloperIdentitiesRequestMarshaller;
import software.amazon.awssdk.services.cognitoidentity.transform.SetIdentityPoolRolesRequestMarshaller;
import software.amazon.awssdk.services.cognitoidentity.transform.TagResourceRequestMarshaller;
import software.amazon.awssdk.services.cognitoidentity.transform.UnlinkDeveloperIdentityRequestMarshaller;
import software.amazon.awssdk.services.cognitoidentity.transform.UnlinkIdentityRequestMarshaller;
import software.amazon.awssdk.services.cognitoidentity.transform.UntagResourceRequestMarshaller;
import software.amazon.awssdk.services.cognitoidentity.transform.UpdateIdentityPoolRequestMarshaller;
import software.amazon.awssdk.utils.CompletableFutureUtils;
/**
* Internal implementation of {@link CognitoIdentityAsyncClient}.
*
* @see CognitoIdentityAsyncClient#builder()
*/
@Generated("software.amazon.awssdk:codegen")
@SdkInternalApi
final class DefaultCognitoIdentityAsyncClient implements CognitoIdentityAsyncClient {
private static final Logger log = LoggerFactory.getLogger(DefaultCognitoIdentityAsyncClient.class);
private final AsyncClientHandler clientHandler;
private final AwsJsonProtocolFactory protocolFactory;
private final SdkClientConfiguration clientConfiguration;
protected DefaultCognitoIdentityAsyncClient(SdkClientConfiguration clientConfiguration) {
this.clientHandler = new AwsAsyncClientHandler(clientConfiguration);
this.clientConfiguration = clientConfiguration;
this.protocolFactory = init(AwsJsonProtocolFactory.builder()).build();
}
@Override
public final String serviceName() {
return SERVICE_NAME;
}
/**
*
* Creates a new identity pool. The identity pool is a store of user identity information that is specific to your
* AWS account. The keys for SupportedLoginProviders are as follows:
*
*
* -
*
* Facebook: graph.facebook.com
*
*
* -
*
* Google: accounts.google.com
*
*
* -
*
* Amazon: www.amazon.com
*
*
* -
*
* Twitter: api.twitter.com
*
*
* -
*
* Digits: www.digits.com
*
*
*
*
* You must use AWS Developer credentials to call this API.
*
*
* @param createIdentityPoolRequest
* Input to the CreateIdentityPool action.
* @return A Java Future containing the result of the CreateIdentityPool operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidParameterException Thrown for missing or bad input parameter(s).
* - NotAuthorizedException Thrown when a user is not authorized to access the requested resource.
* - ResourceConflictException Thrown when a user tries to use a login which is already linked to another
* account.
* - TooManyRequestsException Thrown when a request is throttled.
* - InternalErrorException Thrown when the service encounters an error during processing the request.
* - LimitExceededException Thrown when the total number of user pools has exceeded a preset limit.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CognitoIdentityException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample CognitoIdentityAsyncClient.CreateIdentityPool
* @see AWS API Documentation
*/
@Override
public CompletableFuture createIdentityPool(CreateIdentityPoolRequest createIdentityPoolRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, CreateIdentityPoolResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("CreateIdentityPool")
.withMarshaller(new CreateIdentityPoolRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(createIdentityPoolRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Deletes identities from an identity pool. You can specify a list of 1-60 identities that you want to delete.
*
*
* You must use AWS Developer credentials to call this API.
*
*
* @param deleteIdentitiesRequest
* Input to the DeleteIdentities action.
* @return A Java Future containing the result of the DeleteIdentities operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidParameterException Thrown for missing or bad input parameter(s).
* - TooManyRequestsException Thrown when a request is throttled.
* - InternalErrorException Thrown when the service encounters an error during processing the request.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CognitoIdentityException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample CognitoIdentityAsyncClient.DeleteIdentities
* @see AWS API Documentation
*/
@Override
public CompletableFuture deleteIdentities(DeleteIdentitiesRequest deleteIdentitiesRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, DeleteIdentitiesResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("DeleteIdentities")
.withMarshaller(new DeleteIdentitiesRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(deleteIdentitiesRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Deletes an identity pool. Once a pool is deleted, users will not be able to authenticate with the pool.
*
*
* You must use AWS Developer credentials to call this API.
*
*
* @param deleteIdentityPoolRequest
* Input to the DeleteIdentityPool action.
* @return A Java Future containing the result of the DeleteIdentityPool operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidParameterException Thrown for missing or bad input parameter(s).
* - ResourceNotFoundException Thrown when the requested resource (for example, a dataset or record) does
* not exist.
* - NotAuthorizedException Thrown when a user is not authorized to access the requested resource.
* - TooManyRequestsException Thrown when a request is throttled.
* - InternalErrorException Thrown when the service encounters an error during processing the request.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CognitoIdentityException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample CognitoIdentityAsyncClient.DeleteIdentityPool
* @see AWS API Documentation
*/
@Override
public CompletableFuture deleteIdentityPool(DeleteIdentityPoolRequest deleteIdentityPoolRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, DeleteIdentityPoolResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("DeleteIdentityPool")
.withMarshaller(new DeleteIdentityPoolRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(deleteIdentityPoolRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Returns metadata related to the given identity, including when the identity was created and any associated linked
* logins.
*
*
* You must use AWS Developer credentials to call this API.
*
*
* @param describeIdentityRequest
* Input to the DescribeIdentity action.
* @return A Java Future containing the result of the DescribeIdentity operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidParameterException Thrown for missing or bad input parameter(s).
* - ResourceNotFoundException Thrown when the requested resource (for example, a dataset or record) does
* not exist.
* - NotAuthorizedException Thrown when a user is not authorized to access the requested resource.
* - TooManyRequestsException Thrown when a request is throttled.
* - InternalErrorException Thrown when the service encounters an error during processing the request.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CognitoIdentityException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample CognitoIdentityAsyncClient.DescribeIdentity
* @see AWS API Documentation
*/
@Override
public CompletableFuture describeIdentity(DescribeIdentityRequest describeIdentityRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, DescribeIdentityResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("DescribeIdentity")
.withMarshaller(new DescribeIdentityRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(describeIdentityRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Gets details about a particular identity pool, including the pool name, ID description, creation date, and
* current number of users.
*
*
* You must use AWS Developer credentials to call this API.
*
*
* @param describeIdentityPoolRequest
* Input to the DescribeIdentityPool action.
* @return A Java Future containing the result of the DescribeIdentityPool operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidParameterException Thrown for missing or bad input parameter(s).
* - ResourceNotFoundException Thrown when the requested resource (for example, a dataset or record) does
* not exist.
* - NotAuthorizedException Thrown when a user is not authorized to access the requested resource.
* - TooManyRequestsException Thrown when a request is throttled.
* - InternalErrorException Thrown when the service encounters an error during processing the request.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CognitoIdentityException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample CognitoIdentityAsyncClient.DescribeIdentityPool
* @see AWS API Documentation
*/
@Override
public CompletableFuture describeIdentityPool(
DescribeIdentityPoolRequest describeIdentityPoolRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, DescribeIdentityPoolResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("DescribeIdentityPool")
.withMarshaller(new DescribeIdentityPoolRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(describeIdentityPoolRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Returns credentials for 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.
*
*
* This is a public API. You do not need any credentials to call this API.
*
*
* @param getCredentialsForIdentityRequest
* Input to the GetCredentialsForIdentity action.
* @return A Java Future containing the result of the GetCredentialsForIdentity operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidParameterException Thrown for missing or bad input parameter(s).
* - ResourceNotFoundException Thrown when the requested resource (for example, a dataset or record) does
* not exist.
* - NotAuthorizedException Thrown when a user is not authorized to access the requested resource.
* - ResourceConflictException Thrown when a user tries to use a login which is already linked to another
* account.
* - TooManyRequestsException Thrown when a request is throttled.
* - InvalidIdentityPoolConfigurationException Thrown if the identity pool has no role associated for the
* given auth type (auth/unauth) or if the AssumeRole fails.
* - InternalErrorException Thrown when the service encounters an error during processing the request.
* - ExternalServiceException An exception thrown when a dependent service such as Facebook or Twitter is
* not responding
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CognitoIdentityException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample CognitoIdentityAsyncClient.GetCredentialsForIdentity
* @see AWS API Documentation
*/
@Override
public CompletableFuture getCredentialsForIdentity(
GetCredentialsForIdentityRequest getCredentialsForIdentityRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, GetCredentialsForIdentityResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("GetCredentialsForIdentity")
.withMarshaller(new GetCredentialsForIdentityRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(getCredentialsForIdentityRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Generates (or retrieves) a Cognito ID. Supplying multiple logins will create an implicit linked account.
*
*
* This is a public API. You do not need any credentials to call this API.
*
*
* @param getIdRequest
* Input to the GetId action.
* @return A Java Future containing the result of the GetId operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidParameterException Thrown for missing or bad input parameter(s).
* - ResourceNotFoundException Thrown when the requested resource (for example, a dataset or record) does
* not exist.
* - NotAuthorizedException Thrown when a user is not authorized to access the requested resource.
* - ResourceConflictException Thrown when a user tries to use a login which is already linked to another
* account.
* - TooManyRequestsException Thrown when a request is throttled.
* - InternalErrorException Thrown when the service encounters an error during processing the request.
* - LimitExceededException Thrown when the total number of user pools has exceeded a preset limit.
* - ExternalServiceException An exception thrown when a dependent service such as Facebook or Twitter is
* not responding
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CognitoIdentityException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample CognitoIdentityAsyncClient.GetId
* @see AWS API
* Documentation
*/
@Override
public CompletableFuture getId(GetIdRequest getIdRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
GetIdResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams().withOperationName("GetId")
.withMarshaller(new GetIdRequestMarshaller(protocolFactory)).withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(getIdRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Gets the roles for an identity pool.
*
*
* You must use AWS Developer credentials to call this API.
*
*
* @param getIdentityPoolRolesRequest
* Input to the GetIdentityPoolRoles action.
* @return A Java Future containing the result of the GetIdentityPoolRoles operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidParameterException Thrown for missing or bad input parameter(s).
* - ResourceNotFoundException Thrown when the requested resource (for example, a dataset or record) does
* not exist.
* - NotAuthorizedException Thrown when a user is not authorized to access the requested resource.
* - ResourceConflictException Thrown when a user tries to use a login which is already linked to another
* account.
* - TooManyRequestsException Thrown when a request is throttled.
* - InternalErrorException Thrown when the service encounters an error during processing the request.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CognitoIdentityException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample CognitoIdentityAsyncClient.GetIdentityPoolRoles
* @see AWS API Documentation
*/
@Override
public CompletableFuture getIdentityPoolRoles(
GetIdentityPoolRolesRequest getIdentityPoolRolesRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, GetIdentityPoolRolesResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("GetIdentityPoolRoles")
.withMarshaller(new GetIdentityPoolRolesRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(getIdentityPoolRolesRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Gets an OpenID token, using a known Cognito ID. This known Cognito ID is returned by GetId. You can
* optionally add additional logins for the identity. Supplying multiple logins creates an implicit link.
*
*
* The OpenId token is valid for 10 minutes.
*
*
* This is a public API. You do not need any credentials to call this API.
*
*
* @param getOpenIdTokenRequest
* Input to the GetOpenIdToken action.
* @return A Java Future containing the result of the GetOpenIdToken operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidParameterException Thrown for missing or bad input parameter(s).
* - ResourceNotFoundException Thrown when the requested resource (for example, a dataset or record) does
* not exist.
* - NotAuthorizedException Thrown when a user is not authorized to access the requested resource.
* - ResourceConflictException Thrown when a user tries to use a login which is already linked to another
* account.
* - TooManyRequestsException Thrown when a request is throttled.
* - InternalErrorException Thrown when the service encounters an error during processing the request.
* - ExternalServiceException An exception thrown when a dependent service such as Facebook or Twitter is
* not responding
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CognitoIdentityException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample CognitoIdentityAsyncClient.GetOpenIdToken
* @see AWS API Documentation
*/
@Override
public CompletableFuture getOpenIdToken(GetOpenIdTokenRequest getOpenIdTokenRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, GetOpenIdTokenResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("GetOpenIdToken")
.withMarshaller(new GetOpenIdTokenRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(getOpenIdTokenRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Registers (or retrieves) a Cognito IdentityId and an OpenID Connect token for a user authenticated
* by your backend authentication process. Supplying multiple logins will create an implicit linked account. You can
* only specify one developer provider as part of the Logins map, which is linked to the identity pool.
* The developer provider is the "domain" by which Cognito will refer to your users.
*
*
* You can use GetOpenIdTokenForDeveloperIdentity to create a new identity and to link new logins (that
* is, user credentials issued by a public provider or developer provider) to an existing identity. When you want to
* create a new identity, the IdentityId should be null. When you want to associate a new login with an
* existing authenticated/unauthenticated identity, you can do so by providing the existing IdentityId.
* This API will create the identity in the specified IdentityPoolId.
*
*
* You must use AWS Developer credentials to call this API.
*
*
* @param getOpenIdTokenForDeveloperIdentityRequest
* Input to the GetOpenIdTokenForDeveloperIdentity action.
* @return A Java Future containing the result of the GetOpenIdTokenForDeveloperIdentity operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidParameterException Thrown for missing or bad input parameter(s).
* - ResourceNotFoundException Thrown when the requested resource (for example, a dataset or record) does
* not exist.
* - NotAuthorizedException Thrown when a user is not authorized to access the requested resource.
* - ResourceConflictException Thrown when a user tries to use a login which is already linked to another
* account.
* - TooManyRequestsException Thrown when a request is throttled.
* - InternalErrorException Thrown when the service encounters an error during processing the request.
* - DeveloperUserAlreadyRegisteredException The provided developer user identifier is already registered
* with Cognito under a different identity ID.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CognitoIdentityException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample CognitoIdentityAsyncClient.GetOpenIdTokenForDeveloperIdentity
* @see AWS API Documentation
*/
@Override
public CompletableFuture getOpenIdTokenForDeveloperIdentity(
GetOpenIdTokenForDeveloperIdentityRequest getOpenIdTokenForDeveloperIdentityRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory
.createResponseHandler(operationMetadata, GetOpenIdTokenForDeveloperIdentityResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("GetOpenIdTokenForDeveloperIdentity")
.withMarshaller(new GetOpenIdTokenForDeveloperIdentityRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(getOpenIdTokenForDeveloperIdentityRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Lists the identities in an identity pool.
*
*
* You must use AWS Developer credentials to call this API.
*
*
* @param listIdentitiesRequest
* Input to the ListIdentities action.
* @return A Java Future containing the result of the ListIdentities operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidParameterException Thrown for missing or bad input parameter(s).
* - ResourceNotFoundException Thrown when the requested resource (for example, a dataset or record) does
* not exist.
* - NotAuthorizedException Thrown when a user is not authorized to access the requested resource.
* - TooManyRequestsException Thrown when a request is throttled.
* - InternalErrorException Thrown when the service encounters an error during processing the request.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CognitoIdentityException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample CognitoIdentityAsyncClient.ListIdentities
* @see AWS API Documentation
*/
@Override
public CompletableFuture listIdentities(ListIdentitiesRequest listIdentitiesRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, ListIdentitiesResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("ListIdentities")
.withMarshaller(new ListIdentitiesRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(listIdentitiesRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Lists all of the Cognito identity pools registered for your account.
*
*
* You must use AWS Developer credentials to call this API.
*
*
* @param listIdentityPoolsRequest
* Input to the ListIdentityPools action.
* @return A Java Future containing the result of the ListIdentityPools operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidParameterException Thrown for missing or bad input parameter(s).
* - NotAuthorizedException Thrown when a user is not authorized to access the requested resource.
* - TooManyRequestsException Thrown when a request is throttled.
* - ResourceNotFoundException Thrown when the requested resource (for example, a dataset or record) does
* not exist.
* - InternalErrorException Thrown when the service encounters an error during processing the request.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CognitoIdentityException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample CognitoIdentityAsyncClient.ListIdentityPools
* @see AWS API Documentation
*/
@Override
public CompletableFuture listIdentityPools(ListIdentityPoolsRequest listIdentityPoolsRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, ListIdentityPoolsResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("ListIdentityPools")
.withMarshaller(new ListIdentityPoolsRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(listIdentityPoolsRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Lists the tags that are assigned to an Amazon Cognito identity pool.
*
*
* A tag is a label that you can apply to identity pools to categorize and manage them in different ways, such as by
* purpose, owner, environment, or other criteria.
*
*
* You can use this action up to 10 times per second, per account.
*
*
* @param listTagsForResourceRequest
* @return A Java Future containing the result of the ListTagsForResource operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidParameterException Thrown for missing or bad input parameter(s).
* - ResourceNotFoundException Thrown when the requested resource (for example, a dataset or record) does
* not exist.
* - NotAuthorizedException Thrown when a user is not authorized to access the requested resource.
* - TooManyRequestsException Thrown when a request is throttled.
* - InternalErrorException Thrown when the service encounters an error during processing the request.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CognitoIdentityException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample CognitoIdentityAsyncClient.ListTagsForResource
* @see AWS API Documentation
*/
@Override
public CompletableFuture listTagsForResource(
ListTagsForResourceRequest listTagsForResourceRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, ListTagsForResourceResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("ListTagsForResource")
.withMarshaller(new ListTagsForResourceRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(listTagsForResourceRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Retrieves the IdentityID associated with a DeveloperUserIdentifier or the list of
* DeveloperUserIdentifier values associated with an IdentityId for an existing identity.
* Either IdentityID or DeveloperUserIdentifier must not be null. If you supply only one
* of these values, the other value will be searched in the database and returned as a part of the response. If you
* supply both, DeveloperUserIdentifier will be matched against IdentityID. If the values
* are verified against the database, the response returns both values and is the same as the request. Otherwise a
* ResourceConflictException is thrown.
*
*
* LookupDeveloperIdentity is intended for low-throughput control plane operations: for example, to
* enable customer service to locate an identity ID by username. If you are using it for higher-volume operations
* such as user authentication, your requests are likely to be throttled. GetOpenIdTokenForDeveloperIdentity
* is a better option for higher-volume operations for user authentication.
*
*
* You must use AWS Developer credentials to call this API.
*
*
* @param lookupDeveloperIdentityRequest
* Input to the LookupDeveloperIdentityInput action.
* @return A Java Future containing the result of the LookupDeveloperIdentity operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidParameterException Thrown for missing or bad input parameter(s).
* - ResourceNotFoundException Thrown when the requested resource (for example, a dataset or record) does
* not exist.
* - NotAuthorizedException Thrown when a user is not authorized to access the requested resource.
* - ResourceConflictException Thrown when a user tries to use a login which is already linked to another
* account.
* - TooManyRequestsException Thrown when a request is throttled.
* - InternalErrorException Thrown when the service encounters an error during processing the request.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CognitoIdentityException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample CognitoIdentityAsyncClient.LookupDeveloperIdentity
* @see AWS API Documentation
*/
@Override
public CompletableFuture lookupDeveloperIdentity(
LookupDeveloperIdentityRequest lookupDeveloperIdentityRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, LookupDeveloperIdentityResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("LookupDeveloperIdentity")
.withMarshaller(new LookupDeveloperIdentityRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(lookupDeveloperIdentityRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Merges two users having different IdentityIds, existing in the same identity pool, and identified by
* the same developer provider. You can use this action to request that discrete users be merged and identified as a
* single user in the Cognito environment. Cognito associates the given source user (
* SourceUserIdentifier) with the IdentityId of the DestinationUserIdentifier
* . Only developer-authenticated users can be merged. If the users to be merged are associated with the same public
* provider, but as two different users, an exception will be thrown.
*
*
* The number of linked logins is limited to 20. So, the number of linked logins for the source user,
* SourceUserIdentifier, and the destination user, DestinationUserIdentifier, together
* should not be larger than 20. Otherwise, an exception will be thrown.
*
*
* You must use AWS Developer credentials to call this API.
*
*
* @param mergeDeveloperIdentitiesRequest
* Input to the MergeDeveloperIdentities action.
* @return A Java Future containing the result of the MergeDeveloperIdentities operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidParameterException Thrown for missing or bad input parameter(s).
* - ResourceNotFoundException Thrown when the requested resource (for example, a dataset or record) does
* not exist.
* - NotAuthorizedException Thrown when a user is not authorized to access the requested resource.
* - ResourceConflictException Thrown when a user tries to use a login which is already linked to another
* account.
* - TooManyRequestsException Thrown when a request is throttled.
* - InternalErrorException Thrown when the service encounters an error during processing the request.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CognitoIdentityException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample CognitoIdentityAsyncClient.MergeDeveloperIdentities
* @see AWS API Documentation
*/
@Override
public CompletableFuture mergeDeveloperIdentities(
MergeDeveloperIdentitiesRequest mergeDeveloperIdentitiesRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, MergeDeveloperIdentitiesResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("MergeDeveloperIdentities")
.withMarshaller(new MergeDeveloperIdentitiesRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(mergeDeveloperIdentitiesRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Sets the roles for an identity pool. These roles are used when making calls to GetCredentialsForIdentity
* action.
*
*
* You must use AWS Developer credentials to call this API.
*
*
* @param setIdentityPoolRolesRequest
* Input to the SetIdentityPoolRoles action.
* @return A Java Future containing the result of the SetIdentityPoolRoles operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidParameterException Thrown for missing or bad input parameter(s).
* - ResourceNotFoundException Thrown when the requested resource (for example, a dataset or record) does
* not exist.
* - NotAuthorizedException Thrown when a user is not authorized to access the requested resource.
* - ResourceConflictException Thrown when a user tries to use a login which is already linked to another
* account.
* - TooManyRequestsException Thrown when a request is throttled.
* - InternalErrorException Thrown when the service encounters an error during processing the request.
* - ConcurrentModificationException Thrown if there are parallel requests to modify a resource.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CognitoIdentityException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample CognitoIdentityAsyncClient.SetIdentityPoolRoles
* @see AWS API Documentation
*/
@Override
public CompletableFuture setIdentityPoolRoles(
SetIdentityPoolRolesRequest setIdentityPoolRolesRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, SetIdentityPoolRolesResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("SetIdentityPoolRoles")
.withMarshaller(new SetIdentityPoolRolesRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(setIdentityPoolRolesRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Assigns a set of tags to an Amazon Cognito identity pool. A tag is a label that you can use to categorize and
* manage identity pools in different ways, such as by purpose, owner, environment, or other criteria.
*
*
* Each tag consists of a key and value, both of which you define. A key is a general category for more specific
* values. For example, if you have two versions of an identity pool, one for testing and another for production,
* you might assign an Environment tag key to both identity pools. The value of this key might be
* Test for one identity pool and Production for the other.
*
*
* Tags are useful for cost tracking and access control. You can activate your tags so that they appear on the
* Billing and Cost Management console, where you can track the costs associated with your identity pools. In an IAM
* policy, you can constrain permissions for identity pools based on specific tags or tag values.
*
*
* You can use this action up to 5 times per second, per account. An identity pool can have as many as 50 tags.
*
*
* @param tagResourceRequest
* @return A Java Future containing the result of the TagResource operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidParameterException Thrown for missing or bad input parameter(s).
* - ResourceNotFoundException Thrown when the requested resource (for example, a dataset or record) does
* not exist.
* - NotAuthorizedException Thrown when a user is not authorized to access the requested resource.
* - TooManyRequestsException Thrown when a request is throttled.
* - InternalErrorException Thrown when the service encounters an error during processing the request.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CognitoIdentityException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample CognitoIdentityAsyncClient.TagResource
* @see AWS
* API Documentation
*/
@Override
public CompletableFuture tagResource(TagResourceRequest tagResourceRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
TagResourceResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("TagResource").withMarshaller(new TagResourceRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(tagResourceRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Unlinks a DeveloperUserIdentifier from an existing identity. Unlinked developer users will be
* considered new identities next time they are seen. If, for a given Cognito identity, you remove all federated
* identities as well as the developer user identifier, the Cognito identity becomes inaccessible.
*
*
* You must use AWS Developer credentials to call this API.
*
*
* @param unlinkDeveloperIdentityRequest
* Input to the UnlinkDeveloperIdentity action.
* @return A Java Future containing the result of the UnlinkDeveloperIdentity operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidParameterException Thrown for missing or bad input parameter(s).
* - ResourceNotFoundException Thrown when the requested resource (for example, a dataset or record) does
* not exist.
* - NotAuthorizedException Thrown when a user is not authorized to access the requested resource.
* - ResourceConflictException Thrown when a user tries to use a login which is already linked to another
* account.
* - TooManyRequestsException Thrown when a request is throttled.
* - InternalErrorException Thrown when the service encounters an error during processing the request.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CognitoIdentityException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample CognitoIdentityAsyncClient.UnlinkDeveloperIdentity
* @see AWS API Documentation
*/
@Override
public CompletableFuture unlinkDeveloperIdentity(
UnlinkDeveloperIdentityRequest unlinkDeveloperIdentityRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, UnlinkDeveloperIdentityResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("UnlinkDeveloperIdentity")
.withMarshaller(new UnlinkDeveloperIdentityRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(unlinkDeveloperIdentityRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Unlinks a federated identity from an existing account. Unlinked logins will be considered new identities next
* time they are seen. Removing the last linked login will make this identity inaccessible.
*
*
* This is a public API. You do not need any credentials to call this API.
*
*
* @param unlinkIdentityRequest
* Input to the UnlinkIdentity action.
* @return A Java Future containing the result of the UnlinkIdentity operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidParameterException Thrown for missing or bad input parameter(s).
* - ResourceNotFoundException Thrown when the requested resource (for example, a dataset or record) does
* not exist.
* - NotAuthorizedException Thrown when a user is not authorized to access the requested resource.
* - ResourceConflictException Thrown when a user tries to use a login which is already linked to another
* account.
* - TooManyRequestsException Thrown when a request is throttled.
* - InternalErrorException Thrown when the service encounters an error during processing the request.
* - ExternalServiceException An exception thrown when a dependent service such as Facebook or Twitter is
* not responding
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CognitoIdentityException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample CognitoIdentityAsyncClient.UnlinkIdentity
* @see AWS API Documentation
*/
@Override
public CompletableFuture unlinkIdentity(UnlinkIdentityRequest unlinkIdentityRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, UnlinkIdentityResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("UnlinkIdentity")
.withMarshaller(new UnlinkIdentityRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(unlinkIdentityRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Removes the specified tags from an Amazon Cognito identity pool. You can use this action up to 5 times per
* second, per account
*
*
* @param untagResourceRequest
* @return A Java Future containing the result of the UntagResource operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidParameterException Thrown for missing or bad input parameter(s).
* - ResourceNotFoundException Thrown when the requested resource (for example, a dataset or record) does
* not exist.
* - NotAuthorizedException Thrown when a user is not authorized to access the requested resource.
* - TooManyRequestsException Thrown when a request is throttled.
* - InternalErrorException Thrown when the service encounters an error during processing the request.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CognitoIdentityException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample CognitoIdentityAsyncClient.UntagResource
* @see AWS
* API Documentation
*/
@Override
public CompletableFuture untagResource(UntagResourceRequest untagResourceRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
UntagResourceResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("UntagResource")
.withMarshaller(new UntagResourceRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(untagResourceRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Updates an identity pool.
*
*
* You must use AWS Developer credentials to call this API.
*
*
* @param updateIdentityPoolRequest
* An object representing an Amazon Cognito identity pool.
* @return A Java Future containing the result of the UpdateIdentityPool operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidParameterException Thrown for missing or bad input parameter(s).
* - ResourceNotFoundException Thrown when the requested resource (for example, a dataset or record) does
* not exist.
* - NotAuthorizedException Thrown when a user is not authorized to access the requested resource.
* - ResourceConflictException Thrown when a user tries to use a login which is already linked to another
* account.
* - TooManyRequestsException Thrown when a request is throttled.
* - InternalErrorException Thrown when the service encounters an error during processing the request.
* - ConcurrentModificationException Thrown if there are parallel requests to modify a resource.
* - LimitExceededException Thrown when the total number of user pools has exceeded a preset limit.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CognitoIdentityException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample CognitoIdentityAsyncClient.UpdateIdentityPool
* @see AWS API Documentation
*/
@Override
public CompletableFuture updateIdentityPool(UpdateIdentityPoolRequest updateIdentityPoolRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, UpdateIdentityPoolResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("UpdateIdentityPool")
.withMarshaller(new UpdateIdentityPoolRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(updateIdentityPoolRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
@Override
public void close() {
clientHandler.close();
}
private > T init(T builder) {
return builder
.clientConfiguration(clientConfiguration)
.defaultServiceExceptionSupplier(CognitoIdentityException::builder)
.protocol(AwsJsonProtocol.AWS_JSON)
.protocolVersion("1.1")
.registerModeledException(
ExceptionMetadata.builder().errorCode("ConcurrentModificationException")
.exceptionBuilderSupplier(ConcurrentModificationException::builder).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("InvalidParameterException")
.exceptionBuilderSupplier(InvalidParameterException::builder).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("ResourceNotFoundException")
.exceptionBuilderSupplier(ResourceNotFoundException::builder).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("DeveloperUserAlreadyRegisteredException")
.exceptionBuilderSupplier(DeveloperUserAlreadyRegisteredException::builder).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("ResourceConflictException")
.exceptionBuilderSupplier(ResourceConflictException::builder).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("ExternalServiceException")
.exceptionBuilderSupplier(ExternalServiceException::builder).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("NotAuthorizedException")
.exceptionBuilderSupplier(NotAuthorizedException::builder).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("InvalidIdentityPoolConfigurationException")
.exceptionBuilderSupplier(InvalidIdentityPoolConfigurationException::builder).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("InternalErrorException")
.exceptionBuilderSupplier(InternalErrorException::builder).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("TooManyRequestsException")
.exceptionBuilderSupplier(TooManyRequestsException::builder).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("LimitExceededException")
.exceptionBuilderSupplier(LimitExceededException::builder).build());
}
private HttpResponseHandler createErrorResponseHandler(BaseAwsJsonProtocolFactory protocolFactory,
JsonOperationMetadata operationMetadata) {
return protocolFactory.createErrorResponseHandler(operationMetadata);
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy