com.amazonaws.services.lambda.AWSLambdaAsync Maven / Gradle / Ivy
Show all versions of aws-java-sdk-lambda Show documentation
/*
* Copyright 2017-2022 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 com.amazonaws.services.lambda;
import javax.annotation.Generated;
import com.amazonaws.services.lambda.model.*;
/**
* Interface for accessing AWS Lambda asynchronously. Each asynchronous method will return a Java Future object
* representing the asynchronous operation; overloads which accept an {@code AsyncHandler} can be used to receive
* notification when an asynchronous operation completes.
*
* Note: Do not directly implement this interface, new methods are added to it regularly. Extend from
* {@link com.amazonaws.services.lambda.AbstractAWSLambdaAsync} instead.
*
*
* Lambda
*
* Overview
*
*
* Lambda is a compute service that lets you run code without provisioning or managing servers. Lambda runs your code on
* a high-availability compute infrastructure and performs all of the administration of the compute resources, including
* server and operating system maintenance, capacity provisioning and automatic scaling, code monitoring and logging.
* With Lambda, you can run code for virtually any type of application or backend service. For more information about
* the Lambda service, see What is Lambda in the
* Lambda Developer Guide.
*
*
* The Lambda API Reference provides information about each of the API methods, including details about the
* parameters in each API request and response.
*
*
*
* You can use Software Development Kits (SDKs), Integrated Development Environment (IDE) Toolkits, and command line
* tools to access the API. For installation instructions, see Tools for Amazon
* Web Services.
*
*
* For a list of Region-specific endpoints that Lambda supports, see Lambda endpoints and quotas in the
* Amazon Web Services General Reference..
*
*
* When making the API calls, you will need to authenticate your request by providing a signature. Lambda supports
* signature version 4. For more information, see Signature Version 4 signing process
* in the Amazon Web Services General Reference..
*
*
* CA certificates
*
*
* Because Amazon Web Services SDKs use the CA certificates from your computer, changes to the certificates on the
* Amazon Web Services servers can cause connection failures when you attempt to use an SDK. You can prevent these
* failures by keeping your computer's CA certificates and operating system up-to-date. If you encounter this issue in a
* corporate environment and do not manage your own computer, you might need to ask an administrator to assist with the
* update process. The following list shows minimum operating system and Java versions:
*
*
* -
*
* Microsoft Windows versions that have updates from January 2005 or later installed contain at least one of the
* required CAs in their trust list.
*
*
* -
*
* Mac OS X 10.4 with Java for Mac OS X 10.4 Release 5 (February 2007), Mac OS X 10.5 (October 2007), and later versions
* contain at least one of the required CAs in their trust list.
*
*
* -
*
* Red Hat Enterprise Linux 5 (March 2007), 6, and 7 and CentOS 5, 6, and 7 all contain at least one of the required CAs
* in their default trusted CA list.
*
*
* -
*
* Java 1.4.2_12 (May 2006), 5 Update 2 (March 2005), and all later versions, including Java 6 (December 2006), 7, and
* 8, contain at least one of the required CAs in their default trusted CA list.
*
*
*
*
* When accessing the Lambda management console or Lambda API endpoints, whether through browsers or programmatically,
* you will need to ensure your client machines support any of the following CAs:
*
*
* -
*
* Amazon Root CA 1
*
*
* -
*
* Starfield Services Root Certificate Authority - G2
*
*
* -
*
* Starfield Class 2 Certification Authority
*
*
*
*
* Root certificates from the first two authorities are available from Amazon trust services, but keeping your computer up-to-date is the
* more straightforward solution. To learn more about ACM-provided certificates, see Amazon Web Services Certificate Manager FAQs.
*
*/
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public interface AWSLambdaAsync extends AWSLambda {
/**
*
* Adds permissions to the resource-based policy of a version of an Lambda layer. Use this action
* to grant layer usage permission to other accounts. You can grant permission to a single account, all accounts in
* an organization, or all Amazon Web Services accounts.
*
*
* To revoke permission, call RemoveLayerVersionPermission with the statement ID that you specified when you
* added it.
*
*
* @param addLayerVersionPermissionRequest
* @return A Java Future containing the result of the AddLayerVersionPermission operation returned by the service.
* @sample AWSLambdaAsync.AddLayerVersionPermission
* @see AWS API Documentation
*/
java.util.concurrent.Future addLayerVersionPermissionAsync(
AddLayerVersionPermissionRequest addLayerVersionPermissionRequest);
/**
*
* Adds permissions to the resource-based policy of a version of an Lambda layer. Use this action
* to grant layer usage permission to other accounts. You can grant permission to a single account, all accounts in
* an organization, or all Amazon Web Services accounts.
*
*
* To revoke permission, call RemoveLayerVersionPermission with the statement ID that you specified when you
* added it.
*
*
* @param addLayerVersionPermissionRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the AddLayerVersionPermission operation returned by the service.
* @sample AWSLambdaAsyncHandler.AddLayerVersionPermission
* @see AWS API Documentation
*/
java.util.concurrent.Future addLayerVersionPermissionAsync(
AddLayerVersionPermissionRequest addLayerVersionPermissionRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Grants an Amazon Web Services service, account, or organization permission to use a function. You can apply the
* policy at the function level, or specify a qualifier to restrict access to a single version or alias. If you use
* a qualifier, the invoker must use the full Amazon Resource Name (ARN) of that version or alias to invoke the
* function. Note: Lambda does not support adding policies to version $LATEST.
*
*
* To grant permission to another account, specify the account ID as the Principal. To grant permission
* to an organization defined in Organizations, specify the organization ID as the PrincipalOrgID. For
* Amazon Web Services services, the principal is a domain-style identifier defined by the service, like
* s3.amazonaws.com or sns.amazonaws.com. For Amazon Web Services services, you can also
* specify the ARN of the associated resource as the SourceArn. If you grant permission to a service
* principal without specifying the source, other accounts could potentially configure resources in their account to
* invoke your Lambda function.
*
*
* This action adds a statement to a resource-based permissions policy for the function. For more information about
* function policies, see Lambda Function
* Policies.
*
*
* @param addPermissionRequest
* @return A Java Future containing the result of the AddPermission operation returned by the service.
* @sample AWSLambdaAsync.AddPermission
* @see AWS API
* Documentation
*/
java.util.concurrent.Future addPermissionAsync(AddPermissionRequest addPermissionRequest);
/**
*
* Grants an Amazon Web Services service, account, or organization permission to use a function. You can apply the
* policy at the function level, or specify a qualifier to restrict access to a single version or alias. If you use
* a qualifier, the invoker must use the full Amazon Resource Name (ARN) of that version or alias to invoke the
* function. Note: Lambda does not support adding policies to version $LATEST.
*
*
* To grant permission to another account, specify the account ID as the Principal. To grant permission
* to an organization defined in Organizations, specify the organization ID as the PrincipalOrgID. For
* Amazon Web Services services, the principal is a domain-style identifier defined by the service, like
* s3.amazonaws.com or sns.amazonaws.com. For Amazon Web Services services, you can also
* specify the ARN of the associated resource as the SourceArn. If you grant permission to a service
* principal without specifying the source, other accounts could potentially configure resources in their account to
* invoke your Lambda function.
*
*
* This action adds a statement to a resource-based permissions policy for the function. For more information about
* function policies, see Lambda Function
* Policies.
*
*
* @param addPermissionRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the AddPermission operation returned by the service.
* @sample AWSLambdaAsyncHandler.AddPermission
* @see AWS API
* Documentation
*/
java.util.concurrent.Future addPermissionAsync(AddPermissionRequest addPermissionRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Creates an alias for a Lambda
* function version. Use aliases to provide clients with a function identifier that you can update to invoke a
* different version.
*
*
* You can also map an alias to split invocation requests between two versions. Use the RoutingConfig
* parameter to specify a second version and the percentage of invocation requests that it receives.
*
*
* @param createAliasRequest
* @return A Java Future containing the result of the CreateAlias operation returned by the service.
* @sample AWSLambdaAsync.CreateAlias
* @see AWS API
* Documentation
*/
java.util.concurrent.Future createAliasAsync(CreateAliasRequest createAliasRequest);
/**
*
* Creates an alias for a Lambda
* function version. Use aliases to provide clients with a function identifier that you can update to invoke a
* different version.
*
*
* You can also map an alias to split invocation requests between two versions. Use the RoutingConfig
* parameter to specify a second version and the percentage of invocation requests that it receives.
*
*
* @param createAliasRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the CreateAlias operation returned by the service.
* @sample AWSLambdaAsyncHandler.CreateAlias
* @see AWS API
* Documentation
*/
java.util.concurrent.Future createAliasAsync(CreateAliasRequest createAliasRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Creates a code signing configuration. A code signing configuration
* defines a list of allowed signing profiles and defines the code-signing validation policy (action to be taken if
* deployment validation checks fail).
*
*
* @param createCodeSigningConfigRequest
* @return A Java Future containing the result of the CreateCodeSigningConfig operation returned by the service.
* @sample AWSLambdaAsync.CreateCodeSigningConfig
* @see AWS
* API Documentation
*/
java.util.concurrent.Future createCodeSigningConfigAsync(CreateCodeSigningConfigRequest createCodeSigningConfigRequest);
/**
*
* Creates a code signing configuration. A code signing configuration
* defines a list of allowed signing profiles and defines the code-signing validation policy (action to be taken if
* deployment validation checks fail).
*
*
* @param createCodeSigningConfigRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the CreateCodeSigningConfig operation returned by the service.
* @sample AWSLambdaAsyncHandler.CreateCodeSigningConfig
* @see AWS
* API Documentation
*/
java.util.concurrent.Future createCodeSigningConfigAsync(CreateCodeSigningConfigRequest createCodeSigningConfigRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Creates a mapping between an event source and an Lambda function. Lambda reads items from the event source and
* triggers the function.
*
*
* For details about how to configure different event sources, see the following topics.
*
*
* -
*
*
* -
*
*
* Amazon Kinesis
*
*
* -
*
* Amazon SQS
*
*
* -
*
*
* -
*
* Amazon MSK
*
*
* -
*
* Apache Kafka
*
*
*
*
* The following error handling options are only available for stream sources (DynamoDB and Kinesis):
*
*
* -
*
* BisectBatchOnFunctionError - If the function returns an error, split the batch in two and retry.
*
*
* -
*
* DestinationConfig - Send discarded records to an Amazon SQS queue or Amazon SNS topic.
*
*
* -
*
* MaximumRecordAgeInSeconds - Discard records older than the specified age. The default value is
* infinite (-1). When set to infinite (-1), failed records are retried until the record expires
*
*
* -
*
* MaximumRetryAttempts - Discard records after the specified number of retries. The default value is
* infinite (-1). When set to infinite (-1), failed records are retried until the record expires.
*
*
* -
*
* ParallelizationFactor - Process multiple batches from each shard concurrently.
*
*
*
*
* For information about which configuration parameters apply to each event source, see the following topics.
*
*
* -
*
*
* -
*
* Amazon
* Kinesis
*
*
* -
*
* Amazon SQS
*
*
* -
*
*
* -
*
* Amazon MSK
*
*
* -
*
* Apache Kafka
*
*
*
*
* @param createEventSourceMappingRequest
* @return A Java Future containing the result of the CreateEventSourceMapping operation returned by the service.
* @sample AWSLambdaAsync.CreateEventSourceMapping
* @see AWS API Documentation
*/
java.util.concurrent.Future createEventSourceMappingAsync(CreateEventSourceMappingRequest createEventSourceMappingRequest);
/**
*
* Creates a mapping between an event source and an Lambda function. Lambda reads items from the event source and
* triggers the function.
*
*
* For details about how to configure different event sources, see the following topics.
*
*
* -
*
*
* -
*
*
* Amazon Kinesis
*
*
* -
*
* Amazon SQS
*
*
* -
*
*
* -
*
* Amazon MSK
*
*
* -
*
* Apache Kafka
*
*
*
*
* The following error handling options are only available for stream sources (DynamoDB and Kinesis):
*
*
* -
*
* BisectBatchOnFunctionError - If the function returns an error, split the batch in two and retry.
*
*
* -
*
* DestinationConfig - Send discarded records to an Amazon SQS queue or Amazon SNS topic.
*
*
* -
*
* MaximumRecordAgeInSeconds - Discard records older than the specified age. The default value is
* infinite (-1). When set to infinite (-1), failed records are retried until the record expires
*
*
* -
*
* MaximumRetryAttempts - Discard records after the specified number of retries. The default value is
* infinite (-1). When set to infinite (-1), failed records are retried until the record expires.
*
*
* -
*
* ParallelizationFactor - Process multiple batches from each shard concurrently.
*
*
*
*
* For information about which configuration parameters apply to each event source, see the following topics.
*
*
* -
*
*
* -
*
* Amazon
* Kinesis
*
*
* -
*
* Amazon SQS
*
*
* -
*
*
* -
*
* Amazon MSK
*
*
* -
*
* Apache Kafka
*
*
*
*
* @param createEventSourceMappingRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the CreateEventSourceMapping operation returned by the service.
* @sample AWSLambdaAsyncHandler.CreateEventSourceMapping
* @see AWS API Documentation
*/
java.util.concurrent.Future createEventSourceMappingAsync(CreateEventSourceMappingRequest createEventSourceMappingRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Creates a Lambda function. To create a function, you need a deployment package and an
* execution role. The deployment package is a .zip file archive or container image that contains your function
* code. The execution role grants the function permission to use Amazon Web Services services, such as Amazon
* CloudWatch Logs for log streaming and X-Ray for request tracing.
*
*
* You set the package type to Image if the deployment package is a container image. For a container
* image, the code property must include the URI of a container image in the Amazon ECR registry. You do not need to
* specify the handler and runtime properties.
*
*
* You set the package type to Zip if the deployment package is a .zip
* file archive. For a .zip file archive, the code property specifies the location of the .zip file. You must
* also specify the handler and runtime properties. The code in the deployment package must be compatible with the
* target instruction set architecture of the function (x86-64 or arm64). If you do not
* specify the architecture, the default value is x86-64.
*
*
* When you create a function, Lambda provisions an instance of the function and its supporting resources. If your
* function connects to a VPC, this process can take a minute or so. During this time, you can't invoke or modify
* the function. The State, StateReason, and StateReasonCode fields in the
* response from GetFunctionConfiguration indicate when the function is ready to invoke. For more
* information, see Function
* States.
*
*
* A function has an unpublished version, and can have published versions and aliases. The unpublished version
* changes when you update your function's code and configuration. A published version is a snapshot of your
* function code and configuration that can't be changed. An alias is a named resource that maps to a version, and
* can be changed to map to a different version. Use the Publish parameter to create version
* 1 of your function from its initial configuration.
*
*
* The other parameters let you configure version-specific and function-level settings. You can modify
* version-specific settings later with UpdateFunctionConfiguration. Function-level settings apply to both
* the unpublished and published versions of the function, and include tags (TagResource) and per-function
* concurrency limits (PutFunctionConcurrency).
*
*
* You can use code signing if your deployment package is a .zip file archive. To enable code signing for this
* function, specify the ARN of a code-signing configuration. When a user attempts to deploy a code package with
* UpdateFunctionCode, Lambda checks that the code package has a valid signature from a trusted publisher.
* The code-signing configuration includes set set of signing profiles, which define the trusted publishers for this
* function.
*
*
* If another account or an Amazon Web Services service invokes your function, use AddPermission to grant
* permission by creating a resource-based IAM policy. You can grant permissions at the function level, on a
* version, or on an alias.
*
*
* To invoke your function directly, use Invoke. To invoke your function in response to events in other
* Amazon Web Services services, create an event source mapping (CreateEventSourceMapping), or configure a
* function trigger in the other service. For more information, see Invoking Functions.
*
*
* @param createFunctionRequest
* @return A Java Future containing the result of the CreateFunction operation returned by the service.
* @sample AWSLambdaAsync.CreateFunction
* @see AWS API
* Documentation
*/
java.util.concurrent.Future createFunctionAsync(CreateFunctionRequest createFunctionRequest);
/**
*
* Creates a Lambda function. To create a function, you need a deployment package and an
* execution role. The deployment package is a .zip file archive or container image that contains your function
* code. The execution role grants the function permission to use Amazon Web Services services, such as Amazon
* CloudWatch Logs for log streaming and X-Ray for request tracing.
*
*
* You set the package type to Image if the deployment package is a container image. For a container
* image, the code property must include the URI of a container image in the Amazon ECR registry. You do not need to
* specify the handler and runtime properties.
*
*
* You set the package type to Zip if the deployment package is a .zip
* file archive. For a .zip file archive, the code property specifies the location of the .zip file. You must
* also specify the handler and runtime properties. The code in the deployment package must be compatible with the
* target instruction set architecture of the function (x86-64 or arm64). If you do not
* specify the architecture, the default value is x86-64.
*
*
* When you create a function, Lambda provisions an instance of the function and its supporting resources. If your
* function connects to a VPC, this process can take a minute or so. During this time, you can't invoke or modify
* the function. The State, StateReason, and StateReasonCode fields in the
* response from GetFunctionConfiguration indicate when the function is ready to invoke. For more
* information, see Function
* States.
*
*
* A function has an unpublished version, and can have published versions and aliases. The unpublished version
* changes when you update your function's code and configuration. A published version is a snapshot of your
* function code and configuration that can't be changed. An alias is a named resource that maps to a version, and
* can be changed to map to a different version. Use the Publish parameter to create version
* 1 of your function from its initial configuration.
*
*
* The other parameters let you configure version-specific and function-level settings. You can modify
* version-specific settings later with UpdateFunctionConfiguration. Function-level settings apply to both
* the unpublished and published versions of the function, and include tags (TagResource) and per-function
* concurrency limits (PutFunctionConcurrency).
*
*
* You can use code signing if your deployment package is a .zip file archive. To enable code signing for this
* function, specify the ARN of a code-signing configuration. When a user attempts to deploy a code package with
* UpdateFunctionCode, Lambda checks that the code package has a valid signature from a trusted publisher.
* The code-signing configuration includes set set of signing profiles, which define the trusted publishers for this
* function.
*
*
* If another account or an Amazon Web Services service invokes your function, use AddPermission to grant
* permission by creating a resource-based IAM policy. You can grant permissions at the function level, on a
* version, or on an alias.
*
*
* To invoke your function directly, use Invoke. To invoke your function in response to events in other
* Amazon Web Services services, create an event source mapping (CreateEventSourceMapping), or configure a
* function trigger in the other service. For more information, see Invoking Functions.
*
*
* @param createFunctionRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the CreateFunction operation returned by the service.
* @sample AWSLambdaAsyncHandler.CreateFunction
* @see AWS API
* Documentation
*/
java.util.concurrent.Future createFunctionAsync(CreateFunctionRequest createFunctionRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Creates a Lambda function URL with the specified configuration parameters. A function URL is a dedicated HTTP(S)
* endpoint that you can use to invoke your function.
*
*
* @param createFunctionUrlConfigRequest
* @return A Java Future containing the result of the CreateFunctionUrlConfig operation returned by the service.
* @sample AWSLambdaAsync.CreateFunctionUrlConfig
* @see AWS
* API Documentation
*/
java.util.concurrent.Future createFunctionUrlConfigAsync(CreateFunctionUrlConfigRequest createFunctionUrlConfigRequest);
/**
*
* Creates a Lambda function URL with the specified configuration parameters. A function URL is a dedicated HTTP(S)
* endpoint that you can use to invoke your function.
*
*
* @param createFunctionUrlConfigRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the CreateFunctionUrlConfig operation returned by the service.
* @sample AWSLambdaAsyncHandler.CreateFunctionUrlConfig
* @see AWS
* API Documentation
*/
java.util.concurrent.Future createFunctionUrlConfigAsync(CreateFunctionUrlConfigRequest createFunctionUrlConfigRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Deletes a Lambda function alias.
*
*
* @param deleteAliasRequest
* @return A Java Future containing the result of the DeleteAlias operation returned by the service.
* @sample AWSLambdaAsync.DeleteAlias
* @see AWS API
* Documentation
*/
java.util.concurrent.Future deleteAliasAsync(DeleteAliasRequest deleteAliasRequest);
/**
*
* Deletes a Lambda function alias.
*
*
* @param deleteAliasRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DeleteAlias operation returned by the service.
* @sample AWSLambdaAsyncHandler.DeleteAlias
* @see AWS API
* Documentation
*/
java.util.concurrent.Future deleteAliasAsync(DeleteAliasRequest deleteAliasRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Deletes the code signing configuration. You can delete the code signing configuration only if no function is
* using it.
*
*
* @param deleteCodeSigningConfigRequest
* @return A Java Future containing the result of the DeleteCodeSigningConfig operation returned by the service.
* @sample AWSLambdaAsync.DeleteCodeSigningConfig
* @see AWS
* API Documentation
*/
java.util.concurrent.Future deleteCodeSigningConfigAsync(DeleteCodeSigningConfigRequest deleteCodeSigningConfigRequest);
/**
*
* Deletes the code signing configuration. You can delete the code signing configuration only if no function is
* using it.
*
*
* @param deleteCodeSigningConfigRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DeleteCodeSigningConfig operation returned by the service.
* @sample AWSLambdaAsyncHandler.DeleteCodeSigningConfig
* @see AWS
* API Documentation
*/
java.util.concurrent.Future deleteCodeSigningConfigAsync(DeleteCodeSigningConfigRequest deleteCodeSigningConfigRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Deletes an event source
* mapping. You can get the identifier of a mapping from the output of ListEventSourceMappings.
*
*
* When you delete an event source mapping, it enters a Deleting state and might not be completely
* deleted for several seconds.
*
*
* @param deleteEventSourceMappingRequest
* @return A Java Future containing the result of the DeleteEventSourceMapping operation returned by the service.
* @sample AWSLambdaAsync.DeleteEventSourceMapping
* @see AWS API Documentation
*/
java.util.concurrent.Future deleteEventSourceMappingAsync(DeleteEventSourceMappingRequest deleteEventSourceMappingRequest);
/**
*
* Deletes an event source
* mapping. You can get the identifier of a mapping from the output of ListEventSourceMappings.
*
*
* When you delete an event source mapping, it enters a Deleting state and might not be completely
* deleted for several seconds.
*
*
* @param deleteEventSourceMappingRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DeleteEventSourceMapping operation returned by the service.
* @sample AWSLambdaAsyncHandler.DeleteEventSourceMapping
* @see AWS API Documentation
*/
java.util.concurrent.Future deleteEventSourceMappingAsync(DeleteEventSourceMappingRequest deleteEventSourceMappingRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Deletes a Lambda function. To delete a specific function version, use the Qualifier parameter.
* Otherwise, all versions and aliases are deleted.
*
*
* To delete Lambda event source mappings that invoke a function, use DeleteEventSourceMapping. For Amazon
* Web Services services and resources that invoke your function directly, delete the trigger in the service where
* you originally configured it.
*
*
* @param deleteFunctionRequest
* @return A Java Future containing the result of the DeleteFunction operation returned by the service.
* @sample AWSLambdaAsync.DeleteFunction
* @see AWS API
* Documentation
*/
java.util.concurrent.Future deleteFunctionAsync(DeleteFunctionRequest deleteFunctionRequest);
/**
*
* Deletes a Lambda function. To delete a specific function version, use the Qualifier parameter.
* Otherwise, all versions and aliases are deleted.
*
*
* To delete Lambda event source mappings that invoke a function, use DeleteEventSourceMapping. For Amazon
* Web Services services and resources that invoke your function directly, delete the trigger in the service where
* you originally configured it.
*
*
* @param deleteFunctionRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DeleteFunction operation returned by the service.
* @sample AWSLambdaAsyncHandler.DeleteFunction
* @see AWS API
* Documentation
*/
java.util.concurrent.Future deleteFunctionAsync(DeleteFunctionRequest deleteFunctionRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Removes the code signing configuration from the function.
*
*
* @param deleteFunctionCodeSigningConfigRequest
* @return A Java Future containing the result of the DeleteFunctionCodeSigningConfig operation returned by the
* service.
* @sample AWSLambdaAsync.DeleteFunctionCodeSigningConfig
* @see AWS API Documentation
*/
java.util.concurrent.Future deleteFunctionCodeSigningConfigAsync(
DeleteFunctionCodeSigningConfigRequest deleteFunctionCodeSigningConfigRequest);
/**
*
* Removes the code signing configuration from the function.
*
*
* @param deleteFunctionCodeSigningConfigRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DeleteFunctionCodeSigningConfig operation returned by the
* service.
* @sample AWSLambdaAsyncHandler.DeleteFunctionCodeSigningConfig
* @see AWS API Documentation
*/
java.util.concurrent.Future deleteFunctionCodeSigningConfigAsync(
DeleteFunctionCodeSigningConfigRequest deleteFunctionCodeSigningConfigRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Removes a concurrent execution limit from a function.
*
*
* @param deleteFunctionConcurrencyRequest
* @return A Java Future containing the result of the DeleteFunctionConcurrency operation returned by the service.
* @sample AWSLambdaAsync.DeleteFunctionConcurrency
* @see AWS API Documentation
*/
java.util.concurrent.Future deleteFunctionConcurrencyAsync(
DeleteFunctionConcurrencyRequest deleteFunctionConcurrencyRequest);
/**
*
* Removes a concurrent execution limit from a function.
*
*
* @param deleteFunctionConcurrencyRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DeleteFunctionConcurrency operation returned by the service.
* @sample AWSLambdaAsyncHandler.DeleteFunctionConcurrency
* @see AWS API Documentation
*/
java.util.concurrent.Future deleteFunctionConcurrencyAsync(
DeleteFunctionConcurrencyRequest deleteFunctionConcurrencyRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Deletes the configuration for asynchronous invocation for a function, version, or alias.
*
*
* To configure options for asynchronous invocation, use PutFunctionEventInvokeConfig.
*
*
* @param deleteFunctionEventInvokeConfigRequest
* @return A Java Future containing the result of the DeleteFunctionEventInvokeConfig operation returned by the
* service.
* @sample AWSLambdaAsync.DeleteFunctionEventInvokeConfig
* @see AWS API Documentation
*/
java.util.concurrent.Future deleteFunctionEventInvokeConfigAsync(
DeleteFunctionEventInvokeConfigRequest deleteFunctionEventInvokeConfigRequest);
/**
*
* Deletes the configuration for asynchronous invocation for a function, version, or alias.
*
*
* To configure options for asynchronous invocation, use PutFunctionEventInvokeConfig.
*
*
* @param deleteFunctionEventInvokeConfigRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DeleteFunctionEventInvokeConfig operation returned by the
* service.
* @sample AWSLambdaAsyncHandler.DeleteFunctionEventInvokeConfig
* @see AWS API Documentation
*/
java.util.concurrent.Future deleteFunctionEventInvokeConfigAsync(
DeleteFunctionEventInvokeConfigRequest deleteFunctionEventInvokeConfigRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Deletes a Lambda function URL. When you delete a function URL, you can't recover it. Creating a new function URL
* results in a different URL address.
*
*
* @param deleteFunctionUrlConfigRequest
* @return A Java Future containing the result of the DeleteFunctionUrlConfig operation returned by the service.
* @sample AWSLambdaAsync.DeleteFunctionUrlConfig
* @see AWS
* API Documentation
*/
java.util.concurrent.Future deleteFunctionUrlConfigAsync(DeleteFunctionUrlConfigRequest deleteFunctionUrlConfigRequest);
/**
*
* Deletes a Lambda function URL. When you delete a function URL, you can't recover it. Creating a new function URL
* results in a different URL address.
*
*
* @param deleteFunctionUrlConfigRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DeleteFunctionUrlConfig operation returned by the service.
* @sample AWSLambdaAsyncHandler.DeleteFunctionUrlConfig
* @see AWS
* API Documentation
*/
java.util.concurrent.Future deleteFunctionUrlConfigAsync(DeleteFunctionUrlConfigRequest deleteFunctionUrlConfigRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Deletes a version of an Lambda
* layer. Deleted versions can no longer be viewed or added to functions. To avoid breaking functions, a copy of
* the version remains in Lambda until no functions refer to it.
*
*
* @param deleteLayerVersionRequest
* @return A Java Future containing the result of the DeleteLayerVersion operation returned by the service.
* @sample AWSLambdaAsync.DeleteLayerVersion
* @see AWS API
* Documentation
*/
java.util.concurrent.Future deleteLayerVersionAsync(DeleteLayerVersionRequest deleteLayerVersionRequest);
/**
*
* Deletes a version of an Lambda
* layer. Deleted versions can no longer be viewed or added to functions. To avoid breaking functions, a copy of
* the version remains in Lambda until no functions refer to it.
*
*
* @param deleteLayerVersionRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DeleteLayerVersion operation returned by the service.
* @sample AWSLambdaAsyncHandler.DeleteLayerVersion
* @see AWS API
* Documentation
*/
java.util.concurrent.Future deleteLayerVersionAsync(DeleteLayerVersionRequest deleteLayerVersionRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Deletes the provisioned concurrency configuration for a function.
*
*
* @param deleteProvisionedConcurrencyConfigRequest
* @return A Java Future containing the result of the DeleteProvisionedConcurrencyConfig operation returned by the
* service.
* @sample AWSLambdaAsync.DeleteProvisionedConcurrencyConfig
* @see AWS API Documentation
*/
java.util.concurrent.Future deleteProvisionedConcurrencyConfigAsync(
DeleteProvisionedConcurrencyConfigRequest deleteProvisionedConcurrencyConfigRequest);
/**
*
* Deletes the provisioned concurrency configuration for a function.
*
*
* @param deleteProvisionedConcurrencyConfigRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DeleteProvisionedConcurrencyConfig operation returned by the
* service.
* @sample AWSLambdaAsyncHandler.DeleteProvisionedConcurrencyConfig
* @see AWS API Documentation
*/
java.util.concurrent.Future deleteProvisionedConcurrencyConfigAsync(
DeleteProvisionedConcurrencyConfigRequest deleteProvisionedConcurrencyConfigRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Retrieves details about your account's limits and usage in an Amazon Web Services
* Region.
*
*
* @param getAccountSettingsRequest
* @return A Java Future containing the result of the GetAccountSettings operation returned by the service.
* @sample AWSLambdaAsync.GetAccountSettings
* @see AWS API
* Documentation
*/
java.util.concurrent.Future getAccountSettingsAsync(GetAccountSettingsRequest getAccountSettingsRequest);
/**
*
* Retrieves details about your account's limits and usage in an Amazon Web Services
* Region.
*
*
* @param getAccountSettingsRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the GetAccountSettings operation returned by the service.
* @sample AWSLambdaAsyncHandler.GetAccountSettings
* @see AWS API
* Documentation
*/
java.util.concurrent.Future getAccountSettingsAsync(GetAccountSettingsRequest getAccountSettingsRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Returns details about a Lambda function alias.
*
*
* @param getAliasRequest
* @return A Java Future containing the result of the GetAlias operation returned by the service.
* @sample AWSLambdaAsync.GetAlias
* @see AWS API
* Documentation
*/
java.util.concurrent.Future getAliasAsync(GetAliasRequest getAliasRequest);
/**
*
* Returns details about a Lambda function alias.
*
*
* @param getAliasRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the GetAlias operation returned by the service.
* @sample AWSLambdaAsyncHandler.GetAlias
* @see AWS API
* Documentation
*/
java.util.concurrent.Future getAliasAsync(GetAliasRequest getAliasRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Returns information about the specified code signing configuration.
*
*
* @param getCodeSigningConfigRequest
* @return A Java Future containing the result of the GetCodeSigningConfig operation returned by the service.
* @sample AWSLambdaAsync.GetCodeSigningConfig
* @see AWS
* API Documentation
*/
java.util.concurrent.Future getCodeSigningConfigAsync(GetCodeSigningConfigRequest getCodeSigningConfigRequest);
/**
*
* Returns information about the specified code signing configuration.
*
*
* @param getCodeSigningConfigRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the GetCodeSigningConfig operation returned by the service.
* @sample AWSLambdaAsyncHandler.GetCodeSigningConfig
* @see AWS
* API Documentation
*/
java.util.concurrent.Future getCodeSigningConfigAsync(GetCodeSigningConfigRequest getCodeSigningConfigRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Returns details about an event source mapping. You can get the identifier of a mapping from the output of
* ListEventSourceMappings.
*
*
* @param getEventSourceMappingRequest
* @return A Java Future containing the result of the GetEventSourceMapping operation returned by the service.
* @sample AWSLambdaAsync.GetEventSourceMapping
* @see AWS
* API Documentation
*/
java.util.concurrent.Future getEventSourceMappingAsync(GetEventSourceMappingRequest getEventSourceMappingRequest);
/**
*
* Returns details about an event source mapping. You can get the identifier of a mapping from the output of
* ListEventSourceMappings.
*
*
* @param getEventSourceMappingRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the GetEventSourceMapping operation returned by the service.
* @sample AWSLambdaAsyncHandler.GetEventSourceMapping
* @see AWS
* API Documentation
*/
java.util.concurrent.Future getEventSourceMappingAsync(GetEventSourceMappingRequest getEventSourceMappingRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Returns information about the function or function version, with a link to download the deployment package that's
* valid for 10 minutes. If you specify a function version, only details that are specific to that version are
* returned.
*
*
* @param getFunctionRequest
* @return A Java Future containing the result of the GetFunction operation returned by the service.
* @sample AWSLambdaAsync.GetFunction
* @see AWS API
* Documentation
*/
java.util.concurrent.Future getFunctionAsync(GetFunctionRequest getFunctionRequest);
/**
*
* Returns information about the function or function version, with a link to download the deployment package that's
* valid for 10 minutes. If you specify a function version, only details that are specific to that version are
* returned.
*
*
* @param getFunctionRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the GetFunction operation returned by the service.
* @sample AWSLambdaAsyncHandler.GetFunction
* @see AWS API
* Documentation
*/
java.util.concurrent.Future getFunctionAsync(GetFunctionRequest getFunctionRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Returns the code signing configuration for the specified function.
*
*
* @param getFunctionCodeSigningConfigRequest
* @return A Java Future containing the result of the GetFunctionCodeSigningConfig operation returned by the
* service.
* @sample AWSLambdaAsync.GetFunctionCodeSigningConfig
* @see AWS API Documentation
*/
java.util.concurrent.Future getFunctionCodeSigningConfigAsync(
GetFunctionCodeSigningConfigRequest getFunctionCodeSigningConfigRequest);
/**
*
* Returns the code signing configuration for the specified function.
*
*
* @param getFunctionCodeSigningConfigRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the GetFunctionCodeSigningConfig operation returned by the
* service.
* @sample AWSLambdaAsyncHandler.GetFunctionCodeSigningConfig
* @see AWS API Documentation
*/
java.util.concurrent.Future getFunctionCodeSigningConfigAsync(
GetFunctionCodeSigningConfigRequest getFunctionCodeSigningConfigRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Returns details about the reserved concurrency configuration for a function. To set a concurrency limit for a
* function, use PutFunctionConcurrency.
*
*
* @param getFunctionConcurrencyRequest
* @return A Java Future containing the result of the GetFunctionConcurrency operation returned by the service.
* @sample AWSLambdaAsync.GetFunctionConcurrency
* @see AWS
* API Documentation
*/
java.util.concurrent.Future getFunctionConcurrencyAsync(GetFunctionConcurrencyRequest getFunctionConcurrencyRequest);
/**
*
* Returns details about the reserved concurrency configuration for a function. To set a concurrency limit for a
* function, use PutFunctionConcurrency.
*
*
* @param getFunctionConcurrencyRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the GetFunctionConcurrency operation returned by the service.
* @sample AWSLambdaAsyncHandler.GetFunctionConcurrency
* @see AWS
* API Documentation
*/
java.util.concurrent.Future getFunctionConcurrencyAsync(GetFunctionConcurrencyRequest getFunctionConcurrencyRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Returns the version-specific settings of a Lambda function or version. The output includes only options that can
* vary between versions of a function. To modify these settings, use UpdateFunctionConfiguration.
*
*
* To get all of a function's details, including function-level settings, use GetFunction.
*
*
* @param getFunctionConfigurationRequest
* @return A Java Future containing the result of the GetFunctionConfiguration operation returned by the service.
* @sample AWSLambdaAsync.GetFunctionConfiguration
* @see AWS API Documentation
*/
java.util.concurrent.Future getFunctionConfigurationAsync(GetFunctionConfigurationRequest getFunctionConfigurationRequest);
/**
*
* Returns the version-specific settings of a Lambda function or version. The output includes only options that can
* vary between versions of a function. To modify these settings, use UpdateFunctionConfiguration.
*
*
* To get all of a function's details, including function-level settings, use GetFunction.
*
*
* @param getFunctionConfigurationRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the GetFunctionConfiguration operation returned by the service.
* @sample AWSLambdaAsyncHandler.GetFunctionConfiguration
* @see AWS API Documentation
*/
java.util.concurrent.Future getFunctionConfigurationAsync(GetFunctionConfigurationRequest getFunctionConfigurationRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Retrieves the configuration for asynchronous invocation for a function, version, or alias.
*
*
* To configure options for asynchronous invocation, use PutFunctionEventInvokeConfig.
*
*
* @param getFunctionEventInvokeConfigRequest
* @return A Java Future containing the result of the GetFunctionEventInvokeConfig operation returned by the
* service.
* @sample AWSLambdaAsync.GetFunctionEventInvokeConfig
* @see AWS API Documentation
*/
java.util.concurrent.Future getFunctionEventInvokeConfigAsync(
GetFunctionEventInvokeConfigRequest getFunctionEventInvokeConfigRequest);
/**
*
* Retrieves the configuration for asynchronous invocation for a function, version, or alias.
*
*
* To configure options for asynchronous invocation, use PutFunctionEventInvokeConfig.
*
*
* @param getFunctionEventInvokeConfigRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the GetFunctionEventInvokeConfig operation returned by the
* service.
* @sample AWSLambdaAsyncHandler.GetFunctionEventInvokeConfig
* @see AWS API Documentation
*/
java.util.concurrent.Future getFunctionEventInvokeConfigAsync(
GetFunctionEventInvokeConfigRequest getFunctionEventInvokeConfigRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Returns details about a Lambda function URL.
*
*
* @param getFunctionUrlConfigRequest
* @return A Java Future containing the result of the GetFunctionUrlConfig operation returned by the service.
* @sample AWSLambdaAsync.GetFunctionUrlConfig
* @see AWS
* API Documentation
*/
java.util.concurrent.Future getFunctionUrlConfigAsync(GetFunctionUrlConfigRequest getFunctionUrlConfigRequest);
/**
*
* Returns details about a Lambda function URL.
*
*
* @param getFunctionUrlConfigRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the GetFunctionUrlConfig operation returned by the service.
* @sample AWSLambdaAsyncHandler.GetFunctionUrlConfig
* @see AWS
* API Documentation
*/
java.util.concurrent.Future getFunctionUrlConfigAsync(GetFunctionUrlConfigRequest getFunctionUrlConfigRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Returns information about a version of an Lambda layer, with a link to
* download the layer archive that's valid for 10 minutes.
*
*
* @param getLayerVersionRequest
* @return A Java Future containing the result of the GetLayerVersion operation returned by the service.
* @sample AWSLambdaAsync.GetLayerVersion
* @see AWS API
* Documentation
*/
java.util.concurrent.Future getLayerVersionAsync(GetLayerVersionRequest getLayerVersionRequest);
/**
*
* Returns information about a version of an Lambda layer, with a link to
* download the layer archive that's valid for 10 minutes.
*
*
* @param getLayerVersionRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the GetLayerVersion operation returned by the service.
* @sample AWSLambdaAsyncHandler.GetLayerVersion
* @see AWS API
* Documentation
*/
java.util.concurrent.Future getLayerVersionAsync(GetLayerVersionRequest getLayerVersionRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Returns information about a version of an Lambda layer, with a link to
* download the layer archive that's valid for 10 minutes.
*
*
* @param getLayerVersionByArnRequest
* @return A Java Future containing the result of the GetLayerVersionByArn operation returned by the service.
* @sample AWSLambdaAsync.GetLayerVersionByArn
* @see AWS
* API Documentation
*/
java.util.concurrent.Future getLayerVersionByArnAsync(GetLayerVersionByArnRequest getLayerVersionByArnRequest);
/**
*
* Returns information about a version of an Lambda layer, with a link to
* download the layer archive that's valid for 10 minutes.
*
*
* @param getLayerVersionByArnRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the GetLayerVersionByArn operation returned by the service.
* @sample AWSLambdaAsyncHandler.GetLayerVersionByArn
* @see AWS
* API Documentation
*/
java.util.concurrent.Future getLayerVersionByArnAsync(GetLayerVersionByArnRequest getLayerVersionByArnRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Returns the permission policy for a version of an Lambda layer. For more
* information, see AddLayerVersionPermission.
*
*
* @param getLayerVersionPolicyRequest
* @return A Java Future containing the result of the GetLayerVersionPolicy operation returned by the service.
* @sample AWSLambdaAsync.GetLayerVersionPolicy
* @see AWS
* API Documentation
*/
java.util.concurrent.Future getLayerVersionPolicyAsync(GetLayerVersionPolicyRequest getLayerVersionPolicyRequest);
/**
*
* Returns the permission policy for a version of an Lambda layer. For more
* information, see AddLayerVersionPermission.
*
*
* @param getLayerVersionPolicyRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the GetLayerVersionPolicy operation returned by the service.
* @sample AWSLambdaAsyncHandler.GetLayerVersionPolicy
* @see AWS
* API Documentation
*/
java.util.concurrent.Future getLayerVersionPolicyAsync(GetLayerVersionPolicyRequest getLayerVersionPolicyRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Returns the resource-based IAM
* policy for a function, version, or alias.
*
*
* @param getPolicyRequest
* @return A Java Future containing the result of the GetPolicy operation returned by the service.
* @sample AWSLambdaAsync.GetPolicy
* @see AWS API
* Documentation
*/
java.util.concurrent.Future getPolicyAsync(GetPolicyRequest getPolicyRequest);
/**
*
* Returns the resource-based IAM
* policy for a function, version, or alias.
*
*
* @param getPolicyRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the GetPolicy operation returned by the service.
* @sample AWSLambdaAsyncHandler.GetPolicy
* @see AWS API
* Documentation
*/
java.util.concurrent.Future getPolicyAsync(GetPolicyRequest getPolicyRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Retrieves the provisioned concurrency configuration for a function's alias or version.
*
*
* @param getProvisionedConcurrencyConfigRequest
* @return A Java Future containing the result of the GetProvisionedConcurrencyConfig operation returned by the
* service.
* @sample AWSLambdaAsync.GetProvisionedConcurrencyConfig
* @see AWS API Documentation
*/
java.util.concurrent.Future getProvisionedConcurrencyConfigAsync(
GetProvisionedConcurrencyConfigRequest getProvisionedConcurrencyConfigRequest);
/**
*
* Retrieves the provisioned concurrency configuration for a function's alias or version.
*
*
* @param getProvisionedConcurrencyConfigRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the GetProvisionedConcurrencyConfig operation returned by the
* service.
* @sample AWSLambdaAsyncHandler.GetProvisionedConcurrencyConfig
* @see AWS API Documentation
*/
java.util.concurrent.Future getProvisionedConcurrencyConfigAsync(
GetProvisionedConcurrencyConfigRequest getProvisionedConcurrencyConfigRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Invokes a Lambda function. You can invoke a function synchronously (and wait for the response), or
* asynchronously. To invoke a function asynchronously, set InvocationType to Event.
*
*
* For synchronous invocation,
* details about the function response, including errors, are included in the response body and headers. For either
* invocation type, you can find more information in the execution log and trace.
*
*
* When an error occurs, your function may be invoked multiple times. Retry behavior varies by error type, client,
* event source, and invocation type. For example, if you invoke a function asynchronously and it returns an error,
* Lambda executes the function up to two more times. For more information, see Retry Behavior.
*
*
* For asynchronous invocation,
* Lambda adds events to a queue before sending them to your function. If your function does not have enough
* capacity to keep up with the queue, events may be lost. Occasionally, your function may receive the same event
* multiple times, even if no error occurs. To retain events that were not processed, configure your function with a
* dead-letter queue.
*
*
* The status code in the API response doesn't reflect function errors. Error codes are reserved for errors that
* prevent your function from executing, such as permissions errors, limit errors, or issues with your function's
* code and configuration. For example, Lambda returns TooManyRequestsException if executing the
* function would cause you to exceed a concurrency limit at either the account level (
* ConcurrentInvocationLimitExceeded) or function level (
* ReservedFunctionConcurrentInvocationLimitExceeded).
*
*
* For functions with a long timeout, your client might be disconnected during synchronous invocation while it waits
* for a response. Configure your HTTP client, SDK, firewall, proxy, or operating system to allow for long
* connections with timeout or keep-alive settings.
*
*
* This operation requires permission for the lambda:InvokeFunction action.
*
*
* @param invokeRequest
* @return A Java Future containing the result of the Invoke operation returned by the service.
* @sample AWSLambdaAsync.Invoke
* @see AWS API
* Documentation
*/
java.util.concurrent.Future invokeAsync(InvokeRequest invokeRequest);
/**
*
* Invokes a Lambda function. You can invoke a function synchronously (and wait for the response), or
* asynchronously. To invoke a function asynchronously, set InvocationType to Event.
*
*
* For synchronous invocation,
* details about the function response, including errors, are included in the response body and headers. For either
* invocation type, you can find more information in the execution log and trace.
*
*
* When an error occurs, your function may be invoked multiple times. Retry behavior varies by error type, client,
* event source, and invocation type. For example, if you invoke a function asynchronously and it returns an error,
* Lambda executes the function up to two more times. For more information, see Retry Behavior.
*
*
* For asynchronous invocation,
* Lambda adds events to a queue before sending them to your function. If your function does not have enough
* capacity to keep up with the queue, events may be lost. Occasionally, your function may receive the same event
* multiple times, even if no error occurs. To retain events that were not processed, configure your function with a
* dead-letter queue.
*
*
* The status code in the API response doesn't reflect function errors. Error codes are reserved for errors that
* prevent your function from executing, such as permissions errors, limit errors, or issues with your function's
* code and configuration. For example, Lambda returns TooManyRequestsException if executing the
* function would cause you to exceed a concurrency limit at either the account level (
* ConcurrentInvocationLimitExceeded) or function level (
* ReservedFunctionConcurrentInvocationLimitExceeded).
*
*
* For functions with a long timeout, your client might be disconnected during synchronous invocation while it waits
* for a response. Configure your HTTP client, SDK, firewall, proxy, or operating system to allow for long
* connections with timeout or keep-alive settings.
*
*
* This operation requires permission for the lambda:InvokeFunction action.
*
*
* @param invokeRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the Invoke operation returned by the service.
* @sample AWSLambdaAsyncHandler.Invoke
* @see AWS API
* Documentation
*/
java.util.concurrent.Future invokeAsync(InvokeRequest invokeRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
*
* For asynchronous function invocation, use Invoke.
*
*
*
* Invokes a function asynchronously.
*
*
* @param invokeAsyncRequest
* @return A Java Future containing the result of the InvokeAsync operation returned by the service.
* @sample AWSLambdaAsync.InvokeAsync
* @see AWS API
* Documentation
*/
@Deprecated
java.util.concurrent.Future invokeAsyncAsync(InvokeAsyncRequest invokeAsyncRequest);
/**
*
*
* For asynchronous function invocation, use Invoke.
*
*
*
* Invokes a function asynchronously.
*
*
* @param invokeAsyncRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the InvokeAsync operation returned by the service.
* @sample AWSLambdaAsyncHandler.InvokeAsync
* @see AWS API
* Documentation
*/
@Deprecated
java.util.concurrent.Future invokeAsyncAsync(InvokeAsyncRequest invokeAsyncRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Returns a list of aliases for
* a Lambda function.
*
*
* @param listAliasesRequest
* @return A Java Future containing the result of the ListAliases operation returned by the service.
* @sample AWSLambdaAsync.ListAliases
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listAliasesAsync(ListAliasesRequest listAliasesRequest);
/**
*
* Returns a list of aliases for
* a Lambda function.
*
*
* @param listAliasesRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the ListAliases operation returned by the service.
* @sample AWSLambdaAsyncHandler.ListAliases
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listAliasesAsync(ListAliasesRequest listAliasesRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Returns a list of code
* signing configurations. A request returns up to 10,000 configurations per call. You can use the
* MaxItems parameter to return fewer configurations per call.
*
*
* @param listCodeSigningConfigsRequest
* @return A Java Future containing the result of the ListCodeSigningConfigs operation returned by the service.
* @sample AWSLambdaAsync.ListCodeSigningConfigs
* @see AWS
* API Documentation
*/
java.util.concurrent.Future listCodeSigningConfigsAsync(ListCodeSigningConfigsRequest listCodeSigningConfigsRequest);
/**
*
* Returns a list of code
* signing configurations. A request returns up to 10,000 configurations per call. You can use the
* MaxItems parameter to return fewer configurations per call.
*
*
* @param listCodeSigningConfigsRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the ListCodeSigningConfigs operation returned by the service.
* @sample AWSLambdaAsyncHandler.ListCodeSigningConfigs
* @see AWS
* API Documentation
*/
java.util.concurrent.Future listCodeSigningConfigsAsync(ListCodeSigningConfigsRequest listCodeSigningConfigsRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Lists event source mappings. Specify an EventSourceArn to only show event source mappings for a
* single event source.
*
*
* @param listEventSourceMappingsRequest
* @return A Java Future containing the result of the ListEventSourceMappings operation returned by the service.
* @sample AWSLambdaAsync.ListEventSourceMappings
* @see AWS
* API Documentation
*/
java.util.concurrent.Future listEventSourceMappingsAsync(ListEventSourceMappingsRequest listEventSourceMappingsRequest);
/**
*
* Lists event source mappings. Specify an EventSourceArn to only show event source mappings for a
* single event source.
*
*
* @param listEventSourceMappingsRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the ListEventSourceMappings operation returned by the service.
* @sample AWSLambdaAsyncHandler.ListEventSourceMappings
* @see AWS
* API Documentation
*/
java.util.concurrent.Future listEventSourceMappingsAsync(ListEventSourceMappingsRequest listEventSourceMappingsRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
* Simplified method form for invoking the ListEventSourceMappings operation.
*
* @see #listEventSourceMappingsAsync(ListEventSourceMappingsRequest)
*/
java.util.concurrent.Future listEventSourceMappingsAsync();
/**
* Simplified method form for invoking the ListEventSourceMappings operation with an AsyncHandler.
*
* @see #listEventSourceMappingsAsync(ListEventSourceMappingsRequest, com.amazonaws.handlers.AsyncHandler)
*/
java.util.concurrent.Future listEventSourceMappingsAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Retrieves a list of configurations for asynchronous invocation for a function.
*
*
* To configure options for asynchronous invocation, use PutFunctionEventInvokeConfig.
*
*
* @param listFunctionEventInvokeConfigsRequest
* @return A Java Future containing the result of the ListFunctionEventInvokeConfigs operation returned by the
* service.
* @sample AWSLambdaAsync.ListFunctionEventInvokeConfigs
* @see AWS API Documentation
*/
java.util.concurrent.Future listFunctionEventInvokeConfigsAsync(
ListFunctionEventInvokeConfigsRequest listFunctionEventInvokeConfigsRequest);
/**
*
* Retrieves a list of configurations for asynchronous invocation for a function.
*
*
* To configure options for asynchronous invocation, use PutFunctionEventInvokeConfig.
*
*
* @param listFunctionEventInvokeConfigsRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the ListFunctionEventInvokeConfigs operation returned by the
* service.
* @sample AWSLambdaAsyncHandler.ListFunctionEventInvokeConfigs
* @see AWS API Documentation
*/
java.util.concurrent.Future listFunctionEventInvokeConfigsAsync(
ListFunctionEventInvokeConfigsRequest listFunctionEventInvokeConfigsRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Returns a list of Lambda function URLs for the specified function.
*
*
* @param listFunctionUrlConfigsRequest
* @return A Java Future containing the result of the ListFunctionUrlConfigs operation returned by the service.
* @sample AWSLambdaAsync.ListFunctionUrlConfigs
* @see AWS
* API Documentation
*/
java.util.concurrent.Future listFunctionUrlConfigsAsync(ListFunctionUrlConfigsRequest listFunctionUrlConfigsRequest);
/**
*
* Returns a list of Lambda function URLs for the specified function.
*
*
* @param listFunctionUrlConfigsRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the ListFunctionUrlConfigs operation returned by the service.
* @sample AWSLambdaAsyncHandler.ListFunctionUrlConfigs
* @see AWS
* API Documentation
*/
java.util.concurrent.Future listFunctionUrlConfigsAsync(ListFunctionUrlConfigsRequest listFunctionUrlConfigsRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Returns a list of Lambda functions, with the version-specific configuration of each. Lambda returns up to 50
* functions per call.
*
*
* Set FunctionVersion to ALL to include all published versions of each function in
* addition to the unpublished version.
*
*
*
* The ListFunctions action returns a subset of the FunctionConfiguration fields. To get the
* additional fields (State, StateReasonCode, StateReason, LastUpdateStatus, LastUpdateStatusReason,
* LastUpdateStatusReasonCode) for a function or version, use GetFunction.
*
*
*
* @param listFunctionsRequest
* @return A Java Future containing the result of the ListFunctions operation returned by the service.
* @sample AWSLambdaAsync.ListFunctions
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listFunctionsAsync(ListFunctionsRequest listFunctionsRequest);
/**
*
* Returns a list of Lambda functions, with the version-specific configuration of each. Lambda returns up to 50
* functions per call.
*
*
* Set FunctionVersion to ALL to include all published versions of each function in
* addition to the unpublished version.
*
*
*
* The ListFunctions action returns a subset of the FunctionConfiguration fields. To get the
* additional fields (State, StateReasonCode, StateReason, LastUpdateStatus, LastUpdateStatusReason,
* LastUpdateStatusReasonCode) for a function or version, use GetFunction.
*
*
*
* @param listFunctionsRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the ListFunctions operation returned by the service.
* @sample AWSLambdaAsyncHandler.ListFunctions
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listFunctionsAsync(ListFunctionsRequest listFunctionsRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
* Simplified method form for invoking the ListFunctions operation.
*
* @see #listFunctionsAsync(ListFunctionsRequest)
*/
java.util.concurrent.Future listFunctionsAsync();
/**
* Simplified method form for invoking the ListFunctions operation with an AsyncHandler.
*
* @see #listFunctionsAsync(ListFunctionsRequest, com.amazonaws.handlers.AsyncHandler)
*/
java.util.concurrent.Future listFunctionsAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* List the functions that use the specified code signing configuration. You can use this method prior to deleting a
* code signing configuration, to verify that no functions are using it.
*
*
* @param listFunctionsByCodeSigningConfigRequest
* @return A Java Future containing the result of the ListFunctionsByCodeSigningConfig operation returned by the
* service.
* @sample AWSLambdaAsync.ListFunctionsByCodeSigningConfig
* @see AWS API Documentation
*/
java.util.concurrent.Future listFunctionsByCodeSigningConfigAsync(
ListFunctionsByCodeSigningConfigRequest listFunctionsByCodeSigningConfigRequest);
/**
*
* List the functions that use the specified code signing configuration. You can use this method prior to deleting a
* code signing configuration, to verify that no functions are using it.
*
*
* @param listFunctionsByCodeSigningConfigRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the ListFunctionsByCodeSigningConfig operation returned by the
* service.
* @sample AWSLambdaAsyncHandler.ListFunctionsByCodeSigningConfig
* @see AWS API Documentation
*/
java.util.concurrent.Future listFunctionsByCodeSigningConfigAsync(
ListFunctionsByCodeSigningConfigRequest listFunctionsByCodeSigningConfigRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Lists the versions of an Lambda
* layer. Versions that have been deleted aren't listed. Specify a runtime identifier to list only
* versions that indicate that they're compatible with that runtime. Specify a compatible architecture to include
* only layer versions that are compatible with that architecture.
*
*
* @param listLayerVersionsRequest
* @return A Java Future containing the result of the ListLayerVersions operation returned by the service.
* @sample AWSLambdaAsync.ListLayerVersions
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listLayerVersionsAsync(ListLayerVersionsRequest listLayerVersionsRequest);
/**
*
* Lists the versions of an Lambda
* layer. Versions that have been deleted aren't listed. Specify a runtime identifier to list only
* versions that indicate that they're compatible with that runtime. Specify a compatible architecture to include
* only layer versions that are compatible with that architecture.
*
*
* @param listLayerVersionsRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the ListLayerVersions operation returned by the service.
* @sample AWSLambdaAsyncHandler.ListLayerVersions
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listLayerVersionsAsync(ListLayerVersionsRequest listLayerVersionsRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Lists Lambda layers and shows
* information about the latest version of each. Specify a runtime identifier to list only
* layers that indicate that they're compatible with that runtime. Specify a compatible architecture to include only
* layers that are compatible with that instruction set architecture.
*
*
* @param listLayersRequest
* @return A Java Future containing the result of the ListLayers operation returned by the service.
* @sample AWSLambdaAsync.ListLayers
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listLayersAsync(ListLayersRequest listLayersRequest);
/**
*
* Lists Lambda layers and shows
* information about the latest version of each. Specify a runtime identifier to list only
* layers that indicate that they're compatible with that runtime. Specify a compatible architecture to include only
* layers that are compatible with that instruction set architecture.
*
*
* @param listLayersRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the ListLayers operation returned by the service.
* @sample AWSLambdaAsyncHandler.ListLayers
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listLayersAsync(ListLayersRequest listLayersRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Retrieves a list of provisioned concurrency configurations for a function.
*
*
* @param listProvisionedConcurrencyConfigsRequest
* @return A Java Future containing the result of the ListProvisionedConcurrencyConfigs operation returned by the
* service.
* @sample AWSLambdaAsync.ListProvisionedConcurrencyConfigs
* @see AWS API Documentation
*/
java.util.concurrent.Future listProvisionedConcurrencyConfigsAsync(
ListProvisionedConcurrencyConfigsRequest listProvisionedConcurrencyConfigsRequest);
/**
*
* Retrieves a list of provisioned concurrency configurations for a function.
*
*
* @param listProvisionedConcurrencyConfigsRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the ListProvisionedConcurrencyConfigs operation returned by the
* service.
* @sample AWSLambdaAsyncHandler.ListProvisionedConcurrencyConfigs
* @see AWS API Documentation
*/
java.util.concurrent.Future listProvisionedConcurrencyConfigsAsync(
ListProvisionedConcurrencyConfigsRequest listProvisionedConcurrencyConfigsRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Returns a function's tags. You can also
* view tags with GetFunction.
*
*
* @param listTagsRequest
* @return A Java Future containing the result of the ListTags operation returned by the service.
* @sample AWSLambdaAsync.ListTags
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listTagsAsync(ListTagsRequest listTagsRequest);
/**
*
* Returns a function's tags. You can also
* view tags with GetFunction.
*
*
* @param listTagsRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the ListTags operation returned by the service.
* @sample AWSLambdaAsyncHandler.ListTags
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listTagsAsync(ListTagsRequest listTagsRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Returns a list of versions,
* with the version-specific configuration of each. Lambda returns up to 50 versions per call.
*
*
* @param listVersionsByFunctionRequest
* @return A Java Future containing the result of the ListVersionsByFunction operation returned by the service.
* @sample AWSLambdaAsync.ListVersionsByFunction
* @see AWS
* API Documentation
*/
java.util.concurrent.Future listVersionsByFunctionAsync(ListVersionsByFunctionRequest listVersionsByFunctionRequest);
/**
*
* Returns a list of versions,
* with the version-specific configuration of each. Lambda returns up to 50 versions per call.
*
*
* @param listVersionsByFunctionRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the ListVersionsByFunction operation returned by the service.
* @sample AWSLambdaAsyncHandler.ListVersionsByFunction
* @see AWS
* API Documentation
*/
java.util.concurrent.Future listVersionsByFunctionAsync(ListVersionsByFunctionRequest listVersionsByFunctionRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Creates an Lambda layer from
* a ZIP archive. Each time you call PublishLayerVersion with the same layer name, a new version is
* created.
*
*
* Add layers to your function with CreateFunction or UpdateFunctionConfiguration.
*
*
* @param publishLayerVersionRequest
* @return A Java Future containing the result of the PublishLayerVersion operation returned by the service.
* @sample AWSLambdaAsync.PublishLayerVersion
* @see AWS API
* Documentation
*/
java.util.concurrent.Future publishLayerVersionAsync(PublishLayerVersionRequest publishLayerVersionRequest);
/**
*
* Creates an Lambda layer from
* a ZIP archive. Each time you call PublishLayerVersion with the same layer name, a new version is
* created.
*
*
* Add layers to your function with CreateFunction or UpdateFunctionConfiguration.
*
*
* @param publishLayerVersionRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the PublishLayerVersion operation returned by the service.
* @sample AWSLambdaAsyncHandler.PublishLayerVersion
* @see AWS API
* Documentation
*/
java.util.concurrent.Future publishLayerVersionAsync(PublishLayerVersionRequest publishLayerVersionRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Creates a version from the
* current code and configuration of a function. Use versions to create a snapshot of your function code and
* configuration that doesn't change.
*
*
* Lambda doesn't publish a version if the function's configuration and code haven't changed since the last version.
* Use UpdateFunctionCode or UpdateFunctionConfiguration to update the function before publishing a
* version.
*
*
* Clients can invoke versions directly or with an alias. To create an alias, use CreateAlias.
*
*
* @param publishVersionRequest
* @return A Java Future containing the result of the PublishVersion operation returned by the service.
* @sample AWSLambdaAsync.PublishVersion
* @see AWS API
* Documentation
*/
java.util.concurrent.Future publishVersionAsync(PublishVersionRequest publishVersionRequest);
/**
*
* Creates a version from the
* current code and configuration of a function. Use versions to create a snapshot of your function code and
* configuration that doesn't change.
*
*
* Lambda doesn't publish a version if the function's configuration and code haven't changed since the last version.
* Use UpdateFunctionCode or UpdateFunctionConfiguration to update the function before publishing a
* version.
*
*
* Clients can invoke versions directly or with an alias. To create an alias, use CreateAlias.
*
*
* @param publishVersionRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the PublishVersion operation returned by the service.
* @sample AWSLambdaAsyncHandler.PublishVersion
* @see AWS API
* Documentation
*/
java.util.concurrent.Future publishVersionAsync(PublishVersionRequest publishVersionRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Update the code signing configuration for the function. Changes to the code signing configuration take effect the
* next time a user tries to deploy a code package to the function.
*
*
* @param putFunctionCodeSigningConfigRequest
* @return A Java Future containing the result of the PutFunctionCodeSigningConfig operation returned by the
* service.
* @sample AWSLambdaAsync.PutFunctionCodeSigningConfig
* @see AWS API Documentation
*/
java.util.concurrent.Future putFunctionCodeSigningConfigAsync(
PutFunctionCodeSigningConfigRequest putFunctionCodeSigningConfigRequest);
/**
*
* Update the code signing configuration for the function. Changes to the code signing configuration take effect the
* next time a user tries to deploy a code package to the function.
*
*
* @param putFunctionCodeSigningConfigRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the PutFunctionCodeSigningConfig operation returned by the
* service.
* @sample AWSLambdaAsyncHandler.PutFunctionCodeSigningConfig
* @see AWS API Documentation
*/
java.util.concurrent.Future putFunctionCodeSigningConfigAsync(
PutFunctionCodeSigningConfigRequest putFunctionCodeSigningConfigRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Sets the maximum number of simultaneous executions for a function, and reserves capacity for that concurrency
* level.
*
*
* Concurrency settings apply to the function as a whole, including all published versions and the unpublished
* version. Reserving concurrency both ensures that your function has capacity to process the specified number of
* events simultaneously, and prevents it from scaling beyond that level. Use GetFunction to see the current
* setting for a function.
*
*
* Use GetAccountSettings to see your Regional concurrency limit. You can reserve concurrency for as many
* functions as you like, as long as you leave at least 100 simultaneous executions unreserved for functions that
* aren't configured with a per-function limit. For more information, see Managing Concurrency.
*
*
* @param putFunctionConcurrencyRequest
* @return A Java Future containing the result of the PutFunctionConcurrency operation returned by the service.
* @sample AWSLambdaAsync.PutFunctionConcurrency
* @see AWS
* API Documentation
*/
java.util.concurrent.Future putFunctionConcurrencyAsync(PutFunctionConcurrencyRequest putFunctionConcurrencyRequest);
/**
*
* Sets the maximum number of simultaneous executions for a function, and reserves capacity for that concurrency
* level.
*
*
* Concurrency settings apply to the function as a whole, including all published versions and the unpublished
* version. Reserving concurrency both ensures that your function has capacity to process the specified number of
* events simultaneously, and prevents it from scaling beyond that level. Use GetFunction to see the current
* setting for a function.
*
*
* Use GetAccountSettings to see your Regional concurrency limit. You can reserve concurrency for as many
* functions as you like, as long as you leave at least 100 simultaneous executions unreserved for functions that
* aren't configured with a per-function limit. For more information, see Managing Concurrency.
*
*
* @param putFunctionConcurrencyRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the PutFunctionConcurrency operation returned by the service.
* @sample AWSLambdaAsyncHandler.PutFunctionConcurrency
* @see AWS
* API Documentation
*/
java.util.concurrent.Future putFunctionConcurrencyAsync(PutFunctionConcurrencyRequest putFunctionConcurrencyRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Configures options for asynchronous
* invocation on a function, version, or alias. If a configuration already exists for a function, version, or
* alias, this operation overwrites it. If you exclude any settings, they are removed. To set one option without
* affecting existing settings for other options, use UpdateFunctionEventInvokeConfig.
*
*
* By default, Lambda retries an asynchronous invocation twice if the function returns an error. It retains events
* in a queue for up to six hours. When an event fails all processing attempts or stays in the asynchronous
* invocation queue for too long, Lambda discards it. To retain discarded events, configure a dead-letter queue with
* UpdateFunctionConfiguration.
*
*
* To send an invocation record to a queue, topic, function, or event bus, specify a destination. You can configure separate destinations for successful invocations (on-success) and events that
* fail all processing attempts (on-failure). You can configure destinations in addition to or instead of a
* dead-letter queue.
*
*
* @param putFunctionEventInvokeConfigRequest
* @return A Java Future containing the result of the PutFunctionEventInvokeConfig operation returned by the
* service.
* @sample AWSLambdaAsync.PutFunctionEventInvokeConfig
* @see AWS API Documentation
*/
java.util.concurrent.Future putFunctionEventInvokeConfigAsync(
PutFunctionEventInvokeConfigRequest putFunctionEventInvokeConfigRequest);
/**
*
* Configures options for asynchronous
* invocation on a function, version, or alias. If a configuration already exists for a function, version, or
* alias, this operation overwrites it. If you exclude any settings, they are removed. To set one option without
* affecting existing settings for other options, use UpdateFunctionEventInvokeConfig.
*
*
* By default, Lambda retries an asynchronous invocation twice if the function returns an error. It retains events
* in a queue for up to six hours. When an event fails all processing attempts or stays in the asynchronous
* invocation queue for too long, Lambda discards it. To retain discarded events, configure a dead-letter queue with
* UpdateFunctionConfiguration.
*
*
* To send an invocation record to a queue, topic, function, or event bus, specify a destination. You can configure separate destinations for successful invocations (on-success) and events that
* fail all processing attempts (on-failure). You can configure destinations in addition to or instead of a
* dead-letter queue.
*
*
* @param putFunctionEventInvokeConfigRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the PutFunctionEventInvokeConfig operation returned by the
* service.
* @sample AWSLambdaAsyncHandler.PutFunctionEventInvokeConfig
* @see AWS API Documentation
*/
java.util.concurrent.Future putFunctionEventInvokeConfigAsync(
PutFunctionEventInvokeConfigRequest putFunctionEventInvokeConfigRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Adds a provisioned concurrency configuration to a function's alias or version.
*
*
* @param putProvisionedConcurrencyConfigRequest
* @return A Java Future containing the result of the PutProvisionedConcurrencyConfig operation returned by the
* service.
* @sample AWSLambdaAsync.PutProvisionedConcurrencyConfig
* @see AWS API Documentation
*/
java.util.concurrent.Future putProvisionedConcurrencyConfigAsync(
PutProvisionedConcurrencyConfigRequest putProvisionedConcurrencyConfigRequest);
/**
*
* Adds a provisioned concurrency configuration to a function's alias or version.
*
*
* @param putProvisionedConcurrencyConfigRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the PutProvisionedConcurrencyConfig operation returned by the
* service.
* @sample AWSLambdaAsyncHandler.PutProvisionedConcurrencyConfig
* @see AWS API Documentation
*/
java.util.concurrent.Future putProvisionedConcurrencyConfigAsync(
PutProvisionedConcurrencyConfigRequest putProvisionedConcurrencyConfigRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Removes a statement from the permissions policy for a version of an Lambda layer. For more
* information, see AddLayerVersionPermission.
*
*
* @param removeLayerVersionPermissionRequest
* @return A Java Future containing the result of the RemoveLayerVersionPermission operation returned by the
* service.
* @sample AWSLambdaAsync.RemoveLayerVersionPermission
* @see AWS API Documentation
*/
java.util.concurrent.Future removeLayerVersionPermissionAsync(
RemoveLayerVersionPermissionRequest removeLayerVersionPermissionRequest);
/**
*
* Removes a statement from the permissions policy for a version of an Lambda layer. For more
* information, see AddLayerVersionPermission.
*
*
* @param removeLayerVersionPermissionRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the RemoveLayerVersionPermission operation returned by the
* service.
* @sample AWSLambdaAsyncHandler.RemoveLayerVersionPermission
* @see AWS API Documentation
*/
java.util.concurrent.Future removeLayerVersionPermissionAsync(
RemoveLayerVersionPermissionRequest removeLayerVersionPermissionRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Revokes function-use permission from an Amazon Web Services service or another account. You can get the ID of the
* statement from the output of GetPolicy.
*
*
* @param removePermissionRequest
* @return A Java Future containing the result of the RemovePermission operation returned by the service.
* @sample AWSLambdaAsync.RemovePermission
* @see AWS API
* Documentation
*/
java.util.concurrent.Future removePermissionAsync(RemovePermissionRequest removePermissionRequest);
/**
*
* Revokes function-use permission from an Amazon Web Services service or another account. You can get the ID of the
* statement from the output of GetPolicy.
*
*
* @param removePermissionRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the RemovePermission operation returned by the service.
* @sample AWSLambdaAsyncHandler.RemovePermission
* @see AWS API
* Documentation
*/
java.util.concurrent.Future removePermissionAsync(RemovePermissionRequest removePermissionRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Adds tags to a function.
*
*
* @param tagResourceRequest
* @return A Java Future containing the result of the TagResource operation returned by the service.
* @sample AWSLambdaAsync.TagResource
* @see AWS API
* Documentation
*/
java.util.concurrent.Future tagResourceAsync(TagResourceRequest tagResourceRequest);
/**
*
* Adds tags to a function.
*
*
* @param tagResourceRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the TagResource operation returned by the service.
* @sample AWSLambdaAsyncHandler.TagResource
* @see AWS API
* Documentation
*/
java.util.concurrent.Future tagResourceAsync(TagResourceRequest tagResourceRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Removes tags from a function.
*
*
* @param untagResourceRequest
* @return A Java Future containing the result of the UntagResource operation returned by the service.
* @sample AWSLambdaAsync.UntagResource
* @see AWS API
* Documentation
*/
java.util.concurrent.Future untagResourceAsync(UntagResourceRequest untagResourceRequest);
/**
*
* Removes tags from a function.
*
*
* @param untagResourceRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the UntagResource operation returned by the service.
* @sample AWSLambdaAsyncHandler.UntagResource
* @see AWS API
* Documentation
*/
java.util.concurrent.Future untagResourceAsync(UntagResourceRequest untagResourceRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Updates the configuration of a Lambda function alias.
*
*
* @param updateAliasRequest
* @return A Java Future containing the result of the UpdateAlias operation returned by the service.
* @sample AWSLambdaAsync.UpdateAlias
* @see AWS API
* Documentation
*/
java.util.concurrent.Future updateAliasAsync(UpdateAliasRequest updateAliasRequest);
/**
*
* Updates the configuration of a Lambda function alias.
*
*
* @param updateAliasRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the UpdateAlias operation returned by the service.
* @sample AWSLambdaAsyncHandler.UpdateAlias
* @see AWS API
* Documentation
*/
java.util.concurrent.Future updateAliasAsync(UpdateAliasRequest updateAliasRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Update the code signing configuration. Changes to the code signing configuration take effect the next time a user
* tries to deploy a code package to the function.
*
*
* @param updateCodeSigningConfigRequest
* @return A Java Future containing the result of the UpdateCodeSigningConfig operation returned by the service.
* @sample AWSLambdaAsync.UpdateCodeSigningConfig
* @see AWS
* API Documentation
*/
java.util.concurrent.Future updateCodeSigningConfigAsync(UpdateCodeSigningConfigRequest updateCodeSigningConfigRequest);
/**
*
* Update the code signing configuration. Changes to the code signing configuration take effect the next time a user
* tries to deploy a code package to the function.
*
*
* @param updateCodeSigningConfigRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the UpdateCodeSigningConfig operation returned by the service.
* @sample AWSLambdaAsyncHandler.UpdateCodeSigningConfig
* @see AWS
* API Documentation
*/
java.util.concurrent.Future updateCodeSigningConfigAsync(UpdateCodeSigningConfigRequest updateCodeSigningConfigRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Updates an event source mapping. You can change the function that Lambda invokes, or pause invocation and resume
* later from the same location.
*
*
* For details about how to configure different event sources, see the following topics.
*
*
* -
*
*
* -
*
*
* Amazon Kinesis
*
*
* -
*
* Amazon SQS
*
*
* -
*
*
* -
*
* Amazon MSK
*
*
* -
*
* Apache Kafka
*
*
*
*
* The following error handling options are only available for stream sources (DynamoDB and Kinesis):
*
*
* -
*
* BisectBatchOnFunctionError - If the function returns an error, split the batch in two and retry.
*
*
* -
*
* DestinationConfig - Send discarded records to an Amazon SQS queue or Amazon SNS topic.
*
*
* -
*
* MaximumRecordAgeInSeconds - Discard records older than the specified age. The default value is
* infinite (-1). When set to infinite (-1), failed records are retried until the record expires
*
*
* -
*
* MaximumRetryAttempts - Discard records after the specified number of retries. The default value is
* infinite (-1). When set to infinite (-1), failed records are retried until the record expires.
*
*
* -
*
* ParallelizationFactor - Process multiple batches from each shard concurrently.
*
*
*
*
* For information about which configuration parameters apply to each event source, see the following topics.
*
*
* -
*
*
* -
*
* Amazon
* Kinesis
*
*
* -
*
* Amazon SQS
*
*
* -
*
*
* -
*
* Amazon MSK
*
*
* -
*
* Apache Kafka
*
*
*
*
* @param updateEventSourceMappingRequest
* @return A Java Future containing the result of the UpdateEventSourceMapping operation returned by the service.
* @sample AWSLambdaAsync.UpdateEventSourceMapping
* @see AWS API Documentation
*/
java.util.concurrent.Future updateEventSourceMappingAsync(UpdateEventSourceMappingRequest updateEventSourceMappingRequest);
/**
*
* Updates an event source mapping. You can change the function that Lambda invokes, or pause invocation and resume
* later from the same location.
*
*
* For details about how to configure different event sources, see the following topics.
*
*
* -
*
*
* -
*
*
* Amazon Kinesis
*
*
* -
*
* Amazon SQS
*
*
* -
*
*
* -
*
* Amazon MSK
*
*
* -
*
* Apache Kafka
*
*
*
*
* The following error handling options are only available for stream sources (DynamoDB and Kinesis):
*
*
* -
*
* BisectBatchOnFunctionError - If the function returns an error, split the batch in two and retry.
*
*
* -
*
* DestinationConfig - Send discarded records to an Amazon SQS queue or Amazon SNS topic.
*
*
* -
*
* MaximumRecordAgeInSeconds - Discard records older than the specified age. The default value is
* infinite (-1). When set to infinite (-1), failed records are retried until the record expires
*
*
* -
*
* MaximumRetryAttempts - Discard records after the specified number of retries. The default value is
* infinite (-1). When set to infinite (-1), failed records are retried until the record expires.
*
*
* -
*
* ParallelizationFactor - Process multiple batches from each shard concurrently.
*
*
*
*
* For information about which configuration parameters apply to each event source, see the following topics.
*
*
* -
*
*
* -
*
* Amazon
* Kinesis
*
*
* -
*
* Amazon SQS
*
*
* -
*
*
* -
*
* Amazon MSK
*
*
* -
*
* Apache Kafka
*
*
*
*
* @param updateEventSourceMappingRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the UpdateEventSourceMapping operation returned by the service.
* @sample AWSLambdaAsyncHandler.UpdateEventSourceMapping
* @see AWS API Documentation
*/
java.util.concurrent.Future updateEventSourceMappingAsync(UpdateEventSourceMappingRequest updateEventSourceMappingRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Updates a Lambda function's code. If code signing is enabled for the function, the code package must be signed by
* a trusted publisher. For more information, see Configuring code signing.
*
*
* If the function's package type is Image, you must specify the code package in ImageUri
* as the URI of a container image in
* the Amazon ECR registry.
*
*
* If the function's package type is Zip, you must specify the deployment package as a .zip
* file archive. Enter the Amazon S3 bucket and key of the code .zip file location. You can also provide the
* function code inline using the ZipFile field.
*
*
* The code in the deployment package must be compatible with the target instruction set architecture of the
* function (x86-64 or arm64).
*
*
* The function's code is locked when you publish a version. You can't modify the code of a published version, only
* the unpublished version.
*
*
*
* For a function defined as a container image, Lambda resolves the image tag to an image digest. In Amazon ECR, if
* you update the image tag to a new image, Lambda does not automatically update the function.
*
*
*
* @param updateFunctionCodeRequest
* @return A Java Future containing the result of the UpdateFunctionCode operation returned by the service.
* @sample AWSLambdaAsync.UpdateFunctionCode
* @see AWS API
* Documentation
*/
java.util.concurrent.Future updateFunctionCodeAsync(UpdateFunctionCodeRequest updateFunctionCodeRequest);
/**
*
* Updates a Lambda function's code. If code signing is enabled for the function, the code package must be signed by
* a trusted publisher. For more information, see Configuring code signing.
*
*
* If the function's package type is Image, you must specify the code package in ImageUri
* as the URI of a container image in
* the Amazon ECR registry.
*
*
* If the function's package type is Zip, you must specify the deployment package as a .zip
* file archive. Enter the Amazon S3 bucket and key of the code .zip file location. You can also provide the
* function code inline using the ZipFile field.
*
*
* The code in the deployment package must be compatible with the target instruction set architecture of the
* function (x86-64 or arm64).
*
*
* The function's code is locked when you publish a version. You can't modify the code of a published version, only
* the unpublished version.
*
*
*
* For a function defined as a container image, Lambda resolves the image tag to an image digest. In Amazon ECR, if
* you update the image tag to a new image, Lambda does not automatically update the function.
*
*
*
* @param updateFunctionCodeRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the UpdateFunctionCode operation returned by the service.
* @sample AWSLambdaAsyncHandler.UpdateFunctionCode
* @see AWS API
* Documentation
*/
java.util.concurrent.Future updateFunctionCodeAsync(UpdateFunctionCodeRequest updateFunctionCodeRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Modify the version-specific settings of a Lambda function.
*
*
* When you update a function, Lambda provisions an instance of the function and its supporting resources. If your
* function connects to a VPC, this process can take a minute. During this time, you can't modify the function, but
* you can still invoke it. The LastUpdateStatus, LastUpdateStatusReason, and
* LastUpdateStatusReasonCode fields in the response from GetFunctionConfiguration indicate when
* the update is complete and the function is processing events with the new configuration. For more information,
* see Function States.
*
*
* These settings can vary between versions of a function and are locked when you publish a version. You can't
* modify the configuration of a published version, only the unpublished version.
*
*
* To configure function concurrency, use PutFunctionConcurrency. To grant invoke permissions to an account
* or Amazon Web Services service, use AddPermission.
*
*
* @param updateFunctionConfigurationRequest
* @return A Java Future containing the result of the UpdateFunctionConfiguration operation returned by the service.
* @sample AWSLambdaAsync.UpdateFunctionConfiguration
* @see AWS API Documentation
*/
java.util.concurrent.Future updateFunctionConfigurationAsync(
UpdateFunctionConfigurationRequest updateFunctionConfigurationRequest);
/**
*
* Modify the version-specific settings of a Lambda function.
*
*
* When you update a function, Lambda provisions an instance of the function and its supporting resources. If your
* function connects to a VPC, this process can take a minute. During this time, you can't modify the function, but
* you can still invoke it. The LastUpdateStatus, LastUpdateStatusReason, and
* LastUpdateStatusReasonCode fields in the response from GetFunctionConfiguration indicate when
* the update is complete and the function is processing events with the new configuration. For more information,
* see Function States.
*
*
* These settings can vary between versions of a function and are locked when you publish a version. You can't
* modify the configuration of a published version, only the unpublished version.
*
*
* To configure function concurrency, use PutFunctionConcurrency. To grant invoke permissions to an account
* or Amazon Web Services service, use AddPermission.
*
*
* @param updateFunctionConfigurationRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the UpdateFunctionConfiguration operation returned by the service.
* @sample AWSLambdaAsyncHandler.UpdateFunctionConfiguration
* @see AWS API Documentation
*/
java.util.concurrent.Future updateFunctionConfigurationAsync(
UpdateFunctionConfigurationRequest updateFunctionConfigurationRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Updates the configuration for asynchronous invocation for a function, version, or alias.
*
*
* To configure options for asynchronous invocation, use PutFunctionEventInvokeConfig.
*
*
* @param updateFunctionEventInvokeConfigRequest
* @return A Java Future containing the result of the UpdateFunctionEventInvokeConfig operation returned by the
* service.
* @sample AWSLambdaAsync.UpdateFunctionEventInvokeConfig
* @see AWS API Documentation
*/
java.util.concurrent.Future updateFunctionEventInvokeConfigAsync(
UpdateFunctionEventInvokeConfigRequest updateFunctionEventInvokeConfigRequest);
/**
*
* Updates the configuration for asynchronous invocation for a function, version, or alias.
*
*
* To configure options for asynchronous invocation, use PutFunctionEventInvokeConfig.
*
*
* @param updateFunctionEventInvokeConfigRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the UpdateFunctionEventInvokeConfig operation returned by the
* service.
* @sample AWSLambdaAsyncHandler.UpdateFunctionEventInvokeConfig
* @see AWS API Documentation
*/
java.util.concurrent.Future updateFunctionEventInvokeConfigAsync(
UpdateFunctionEventInvokeConfigRequest updateFunctionEventInvokeConfigRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Updates the configuration for a Lambda function URL.
*
*
* @param updateFunctionUrlConfigRequest
* @return A Java Future containing the result of the UpdateFunctionUrlConfig operation returned by the service.
* @sample AWSLambdaAsync.UpdateFunctionUrlConfig
* @see AWS
* API Documentation
*/
java.util.concurrent.Future updateFunctionUrlConfigAsync(UpdateFunctionUrlConfigRequest updateFunctionUrlConfigRequest);
/**
*
* Updates the configuration for a Lambda function URL.
*
*
* @param updateFunctionUrlConfigRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the UpdateFunctionUrlConfig operation returned by the service.
* @sample AWSLambdaAsyncHandler.UpdateFunctionUrlConfig
* @see AWS
* API Documentation
*/
java.util.concurrent.Future updateFunctionUrlConfigAsync(UpdateFunctionUrlConfigRequest updateFunctionUrlConfigRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
}