Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /*
    * Copyright 2010-2015 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.directory;
  
  
  
Asynchronous client for accessing AWSDirectoryService. All asynchronous calls made using this client are non-blocking. Callers could either process the result and handle the exceptions in the worker thread by providing a callback handler when making the call, or use the returned Future object to check the result of the call in the calling thread. AWS Directory Service

This is the AWS Directory Service API Reference . This guide provides detailed information about AWS Directory Service operations, data types, parameters, and errors.

  
          implements AWSDirectoryServiceAsync {

    
Executor service for executing asynchronous requests.
  
      private ExecutorService executorService;
  
      private static final int DEFAULT_THREAD_POOL_SIZE = 50;

    
Constructs a new asynchronous client to invoke service methods on AWSDirectoryService. A credentials provider chain will be used that searches for credentials in this order:
  • Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY
  • Java System Properties - aws.accessKeyId and aws.secretKey
  • Instance profile credentials delivered through the Amazon EC2 metadata service

All service calls made using this new client object are blocking, and will not return until the service call completes.

  
      public AWSDirectoryServiceAsyncClient() {
          this(new DefaultAWSCredentialsProviderChain());
      }

    
Constructs a new asynchronous client to invoke service methods on AWSDirectoryService. A credentials provider chain will be used that searches for credentials in this order:
  • Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY
  • Java System Properties - aws.accessKeyId and aws.secretKey
  • Instance profile credentials delivered through the Amazon EC2 metadata service

All service calls made using this new client object are blocking, and will not return until the service call completes.

Parameters:
clientConfiguration The client configuration options controlling how this client connects to AWSDirectoryService (ex: proxy settings, retry counts, etc.).
See also:
com.amazonaws.auth.DefaultAWSCredentialsProviderChain
  
      public AWSDirectoryServiceAsyncClient(ClientConfiguration clientConfiguration) {
          this(new DefaultAWSCredentialsProviderChain(), clientConfiguration, Executors.newFixedThreadPool(clientConfiguration.getMaxConnections()));
      }

    
Constructs a new asynchronous client to invoke service methods on AWSDirectoryService using the specified AWS account credentials. Default client settings will be used, and a fixed size thread pool will be created for executing the asynchronous tasks.

All calls made using this new client object are non-blocking, and will immediately return a Java Future object that the caller can later check to see if the service call has actually completed.

Parameters:
awsCredentials The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
 
     public AWSDirectoryServiceAsyncClient(AWSCredentials awsCredentials) {
         this(awsCredentials, Executors.newFixedThreadPool());
     }

    
Constructs a new asynchronous client to invoke service methods on AWSDirectoryService using the specified AWS account credentials and executor service. Default client settings will be used.

All calls made using this new client object are non-blocking, and will immediately return a Java Future object that the caller can later check to see if the service call has actually completed.

Parameters:
awsCredentials The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
executorService The executor service by which all asynchronous requests will be executed.
 
     public AWSDirectoryServiceAsyncClient(AWSCredentials awsCredentialsExecutorService executorService) {
         super(awsCredentials);
         this. = executorService;
     }

    
Constructs a new asynchronous client to invoke service methods on AWSDirectoryService using the specified AWS account credentials, executor service, and client configuration options.

All calls made using this new client object are non-blocking, and will immediately return a Java Future object that the caller can later check to see if the service call has actually completed.

Parameters:
awsCredentials The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
clientConfiguration Client configuration options (ex: max retry limit, proxy settings, etc).
executorService The executor service by which all asynchronous requests will be executed.
 
     public AWSDirectoryServiceAsyncClient(AWSCredentials awsCredentials,
                 ClientConfiguration clientConfigurationExecutorService executorService) {
         super(awsCredentialsclientConfiguration);
         this. = executorService;
     }

    
Constructs a new asynchronous client to invoke service methods on AWSDirectoryService using the specified AWS account credentials provider. Default client settings will be used, and a fixed size thread pool will be created for executing the asynchronous tasks.

All calls made using this new client object are non-blocking, and will immediately return a Java Future object that the caller can later check to see if the service call has actually completed.

Parameters:
awsCredentialsProvider The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
 
     public AWSDirectoryServiceAsyncClient(AWSCredentialsProvider awsCredentialsProvider) {
         this(awsCredentialsProvider, Executors.newFixedThreadPool());
     }

    
Constructs a new asynchronous client to invoke service methods on AWSDirectoryService using the specified AWS account credentials provider and executor service. Default client settings will be used.

All calls made using this new client object are non-blocking, and will immediately return a Java Future object that the caller can later check to see if the service call has actually completed.

Parameters:
awsCredentialsProvider The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
executorService The executor service by which all asynchronous requests will be executed.
 
     public AWSDirectoryServiceAsyncClient(AWSCredentialsProvider awsCredentialsProviderExecutorService executorService) {
         this(awsCredentialsProvidernew ClientConfiguration(), executorService);
     }

    
Constructs a new asynchronous client to invoke service methods on AWSDirectoryService using the specified AWS account credentials provider and client configuration options.

All calls made using this new client object are non-blocking, and will immediately return a Java Future object that the caller can later check to see if the service call has actually completed.

Parameters:
awsCredentialsProvider The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
clientConfiguration Client configuration options (ex: max retry limit, proxy settings, etc).
 
     public AWSDirectoryServiceAsyncClient(AWSCredentialsProvider awsCredentialsProvider,
                 ClientConfiguration clientConfiguration) {
         this(awsCredentialsProviderclientConfiguration, Executors.newFixedThreadPool(clientConfiguration.getMaxConnections()));
     }

    
Constructs a new asynchronous client to invoke service methods on AWSDirectoryService using the specified AWS account credentials provider, executor service, and client configuration options.

All calls made using this new client object are non-blocking, and will immediately return a Java Future object that the caller can later check to see if the service call has actually completed.

Parameters:
awsCredentialsProvider The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
clientConfiguration Client configuration options (ex: max retry limit, proxy settings, etc).
executorService The executor service by which all asynchronous requests will be executed.
 
     public AWSDirectoryServiceAsyncClient(AWSCredentialsProvider awsCredentialsProvider,
                 ClientConfiguration clientConfigurationExecutorService executorService) {
         super(awsCredentialsProviderclientConfiguration);
         this. = executorService;
     }

    
Returns the executor service used by this async client to execute requests.

Returns:
The executor service used by this async client to execute requests.
 
     public ExecutorService getExecutorService() {
         return ;
     }

    
Shuts down the client, releasing all managed resources. This includes forcibly terminating all pending asynchronous service calls. Clients who wish to give pending asynchronous service calls time to complete should call getExecutorService().shutdown() followed by getExecutorService().awaitTermination() prior to calling this method.
 
     @Override
     public void shutdown() {
         super.shutdown();
         .shutdownNow();
     }
            
    

Obtains information about the directory snapshots that belong to this account.

This operation supports pagination with the use of the NextToken request and response parameters. If more results are available, the DescribeSnapshots.NextToken member contains a token that you pass in the next call to DescribeSnapshots to retrieve the next set of items.

You can also specify a maximum number of return results with the Limit parameter.

Parameters:
describeSnapshotsRequest Container for the necessary parameters to execute the DescribeSnapshots operation on AWSDirectoryService.
Returns:
A Java Future object containing the response from the DescribeSnapshots service method, as returned by AWSDirectoryService.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AWSDirectoryService indicating either a problem with the data in the request, or a server side issue.
 
     public Future<DescribeSnapshotsResultdescribeSnapshotsAsync(final DescribeSnapshotsRequest describeSnapshotsRequest
             throws AmazonServiceExceptionAmazonClientException {
         return .submit(new Callable<DescribeSnapshotsResult>() {
             public DescribeSnapshotsResult call() throws Exception {
                 return describeSnapshots(describeSnapshotsRequest);
         }
     });
     }

    

Obtains information about the directory snapshots that belong to this account.

This operation supports pagination with the use of the NextToken request and response parameters. If more results are available, the DescribeSnapshots.NextToken member contains a token that you pass in the next call to DescribeSnapshots to retrieve the next set of items.

You can also specify a maximum number of return results with the Limit parameter.

Parameters:
describeSnapshotsRequest Container for the necessary parameters to execute the DescribeSnapshots operation on AWSDirectoryService.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the DescribeSnapshots service method, as returned by AWSDirectoryService.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AWSDirectoryService indicating either a problem with the data in the request, or a server side issue.
 
             final DescribeSnapshotsRequest describeSnapshotsRequest,
             final AsyncHandler<DescribeSnapshotsRequestDescribeSnapshotsResultasyncHandler)
                     throws AmazonServiceExceptionAmazonClientException {
         return .submit(new Callable<DescribeSnapshotsResult>() {
             public DescribeSnapshotsResult call() throws Exception {
               DescribeSnapshotsResult result;
                 try {
                 result = describeSnapshots(describeSnapshotsRequest);
               } catch (Exception ex) {
                   asyncHandler.onError(ex);
             throw ex;
               }
               asyncHandler.onSuccess(describeSnapshotsRequestresult);
                  return result;
         }
     });
     }
    
    

Creates an alias for a directory and assigns the alias to the directory. The alias is used to construct the access URL for the directory, such as http://<alias>.awsapps.com .

IMPORTANT: After an alias has been created, it cannot be deleted or reused, so this operation should only be used when absolutely necessary.

Parameters:
createAliasRequest Container for the necessary parameters to execute the CreateAlias operation on AWSDirectoryService.
Returns:
A Java Future object containing the response from the CreateAlias service method, as returned by AWSDirectoryService.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AWSDirectoryService indicating either a problem with the data in the request, or a server side issue.
 
     public Future<CreateAliasResultcreateAliasAsync(final CreateAliasRequest createAliasRequest
             throws AmazonServiceExceptionAmazonClientException {
         return .submit(new Callable<CreateAliasResult>() {
             public CreateAliasResult call() throws Exception {
                 return createAlias(createAliasRequest);
         }
     });
     }

    

Creates an alias for a directory and assigns the alias to the directory. The alias is used to construct the access URL for the directory, such as http://<alias>.awsapps.com .

IMPORTANT: After an alias has been created, it cannot be deleted or reused, so this operation should only be used when absolutely necessary.

Parameters:
createAliasRequest Container for the necessary parameters to execute the CreateAlias operation on AWSDirectoryService.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the CreateAlias service method, as returned by AWSDirectoryService.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AWSDirectoryService indicating either a problem with the data in the request, or a server side issue.
 
             final CreateAliasRequest createAliasRequest,
             final AsyncHandler<CreateAliasRequestCreateAliasResultasyncHandler)
                     throws AmazonServiceExceptionAmazonClientException {
         return .submit(new Callable<CreateAliasResult>() {
             public CreateAliasResult call() throws Exception {
               CreateAliasResult result;
                 try {
                 result = createAlias(createAliasRequest);
               } catch (Exception ex) {
                   asyncHandler.onError(ex);
             throw ex;
               }
               asyncHandler.onSuccess(createAliasRequestresult);
                  return result;
         }
     });
     }
    
    

Deletes a directory snapshot.

Parameters:
deleteSnapshotRequest Container for the necessary parameters to execute the DeleteSnapshot operation on AWSDirectoryService.
Returns:
A Java Future object containing the response from the DeleteSnapshot service method, as returned by AWSDirectoryService.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AWSDirectoryService indicating either a problem with the data in the request, or a server side issue.
 
     public Future<DeleteSnapshotResultdeleteSnapshotAsync(final DeleteSnapshotRequest deleteSnapshotRequest
             throws AmazonServiceExceptionAmazonClientException {
         return .submit(new Callable<DeleteSnapshotResult>() {
             public DeleteSnapshotResult call() throws Exception {
                 return deleteSnapshot(deleteSnapshotRequest);
         }
     });
     }

    

Deletes a directory snapshot.

Parameters:
deleteSnapshotRequest Container for the necessary parameters to execute the DeleteSnapshot operation on AWSDirectoryService.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the DeleteSnapshot service method, as returned by AWSDirectoryService.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AWSDirectoryService indicating either a problem with the data in the request, or a server side issue.
 
             final DeleteSnapshotRequest deleteSnapshotRequest,
             final AsyncHandler<DeleteSnapshotRequestDeleteSnapshotResultasyncHandler)
                     throws AmazonServiceExceptionAmazonClientException {
         return .submit(new Callable<DeleteSnapshotResult>() {
             public DeleteSnapshotResult call() throws Exception {
               DeleteSnapshotResult result;
                 try {
                 result = deleteSnapshot(deleteSnapshotRequest);
               } catch (Exception ex) {
                   asyncHandler.onError(ex);
             throw ex;
               }
               asyncHandler.onSuccess(deleteSnapshotRequestresult);
                  return result;
         }
     });
     }
    
    

Updates the Remote Authentication Dial In User Service (RADIUS) server information for an AD Connector directory.

Parameters:
updateRadiusRequest Container for the necessary parameters to execute the UpdateRadius operation on AWSDirectoryService.
Returns:
A Java Future object containing the response from the UpdateRadius service method, as returned by AWSDirectoryService.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AWSDirectoryService indicating either a problem with the data in the request, or a server side issue.
 
     public Future<UpdateRadiusResultupdateRadiusAsync(final UpdateRadiusRequest updateRadiusRequest
             throws AmazonServiceExceptionAmazonClientException {
         return .submit(new Callable<UpdateRadiusResult>() {
             public UpdateRadiusResult call() throws Exception {
                 return updateRadius(updateRadiusRequest);
         }
     });
     }

    

Updates the Remote Authentication Dial In User Service (RADIUS) server information for an AD Connector directory.

Parameters:
updateRadiusRequest Container for the necessary parameters to execute the UpdateRadius operation on AWSDirectoryService.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the UpdateRadius service method, as returned by AWSDirectoryService.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AWSDirectoryService indicating either a problem with the data in the request, or a server side issue.
 
             final UpdateRadiusRequest updateRadiusRequest,
             final AsyncHandler<UpdateRadiusRequestUpdateRadiusResultasyncHandler)
                     throws AmazonServiceExceptionAmazonClientException {
         return .submit(new Callable<UpdateRadiusResult>() {
             public UpdateRadiusResult call() throws Exception {
               UpdateRadiusResult result;
                 try {
                 result = updateRadius(updateRadiusRequest);
               } catch (Exception ex) {
                   asyncHandler.onError(ex);
             throw ex;
               }
               asyncHandler.onSuccess(updateRadiusRequestresult);
                  return result;
         }
     });
     }
    
    

Obtains information about the directories that belong to this account.

You can retrieve information about specific directories by passing the directory identifiers in the DirectoryIds parameter. Otherwise, all directories that belong to the current account are returned.

This operation supports pagination with the use of the NextToken request and response parameters. If more results are available, the DescribeDirectoriesResult.NextToken member contains a token that you pass in the next call to DescribeDirectories to retrieve the next set of items.

You can also specify a maximum number of return results with the Limit parameter.

Parameters:
describeDirectoriesRequest Container for the necessary parameters to execute the DescribeDirectories operation on AWSDirectoryService.
Returns:
A Java Future object containing the response from the DescribeDirectories service method, as returned by AWSDirectoryService.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AWSDirectoryService indicating either a problem with the data in the request, or a server side issue.
 
     public Future<DescribeDirectoriesResultdescribeDirectoriesAsync(final DescribeDirectoriesRequest describeDirectoriesRequest
             throws AmazonServiceExceptionAmazonClientException {
         return .submit(new Callable<DescribeDirectoriesResult>() {
             public DescribeDirectoriesResult call() throws Exception {
                 return describeDirectories(describeDirectoriesRequest);
         }
     });
     }

    

Obtains information about the directories that belong to this account.

You can retrieve information about specific directories by passing the directory identifiers in the DirectoryIds parameter. Otherwise, all directories that belong to the current account are returned.

This operation supports pagination with the use of the NextToken request and response parameters. If more results are available, the DescribeDirectoriesResult.NextToken member contains a token that you pass in the next call to DescribeDirectories to retrieve the next set of items.

You can also specify a maximum number of return results with the Limit parameter.

Parameters:
describeDirectoriesRequest Container for the necessary parameters to execute the DescribeDirectories operation on AWSDirectoryService.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the DescribeDirectories service method, as returned by AWSDirectoryService.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AWSDirectoryService indicating either a problem with the data in the request, or a server side issue.
 
             final DescribeDirectoriesRequest describeDirectoriesRequest,
             final AsyncHandler<DescribeDirectoriesRequestDescribeDirectoriesResultasyncHandler)
                     throws AmazonServiceExceptionAmazonClientException {
         return .submit(new Callable<DescribeDirectoriesResult>() {
             public DescribeDirectoriesResult call() throws Exception {
               DescribeDirectoriesResult result;
                 try {
                 result = describeDirectories(describeDirectoriesRequest);
               } catch (Exception ex) {
                   asyncHandler.onError(ex);
             throw ex;
               }
               asyncHandler.onSuccess(describeDirectoriesRequestresult);
                  return result;
         }
     });
     }
    
    

Creates an AD Connector to connect an on-premises directory.

Parameters:
connectDirectoryRequest Container for the necessary parameters to execute the ConnectDirectory operation on AWSDirectoryService.
Returns:
A Java Future object containing the response from the ConnectDirectory service method, as returned by AWSDirectoryService.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AWSDirectoryService indicating either a problem with the data in the request, or a server side issue.
 
     public Future<ConnectDirectoryResultconnectDirectoryAsync(final ConnectDirectoryRequest connectDirectoryRequest
             throws AmazonServiceExceptionAmazonClientException {
         return .submit(new Callable<ConnectDirectoryResult>() {
             public ConnectDirectoryResult call() throws Exception {
                 return connectDirectory(connectDirectoryRequest);
         }
     });
     }

    

Creates an AD Connector to connect an on-premises directory.

Parameters:
connectDirectoryRequest Container for the necessary parameters to execute the ConnectDirectory operation on AWSDirectoryService.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the ConnectDirectory service method, as returned by AWSDirectoryService.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AWSDirectoryService indicating either a problem with the data in the request, or a server side issue.
 
             final ConnectDirectoryRequest connectDirectoryRequest,
             final AsyncHandler<ConnectDirectoryRequestConnectDirectoryResultasyncHandler)
                     throws AmazonServiceExceptionAmazonClientException {
         return .submit(new Callable<ConnectDirectoryResult>() {
             public ConnectDirectoryResult call() throws Exception {
               ConnectDirectoryResult result;
                 try {
                 result = connectDirectory(connectDirectoryRequest);
               } catch (Exception ex) {
                   asyncHandler.onError(ex);
             throw ex;
               }
               asyncHandler.onSuccess(connectDirectoryRequestresult);
                  return result;
         }
     });
     }
    
    

Creates a snapshot of an existing directory.

You cannot take snapshots of extended or connected directories.

Parameters:
createSnapshotRequest Container for the necessary parameters to execute the CreateSnapshot operation on AWSDirectoryService.
Returns:
A Java Future object containing the response from the CreateSnapshot service method, as returned by AWSDirectoryService.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AWSDirectoryService indicating either a problem with the data in the request, or a server side issue.
 
     public Future<CreateSnapshotResultcreateSnapshotAsync(final CreateSnapshotRequest createSnapshotRequest
             throws AmazonServiceExceptionAmazonClientException {
         return .submit(new Callable<CreateSnapshotResult>() {
             public CreateSnapshotResult call() throws Exception {
                 return createSnapshot(createSnapshotRequest);
         }
     });
     }

    

Creates a snapshot of an existing directory.

You cannot take snapshots of extended or connected directories.

Parameters:
createSnapshotRequest Container for the necessary parameters to execute the CreateSnapshot operation on AWSDirectoryService.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the CreateSnapshot service method, as returned by AWSDirectoryService.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AWSDirectoryService indicating either a problem with the data in the request, or a server side issue.
 
             final CreateSnapshotRequest createSnapshotRequest,
             final AsyncHandler<CreateSnapshotRequestCreateSnapshotResultasyncHandler)
                     throws AmazonServiceExceptionAmazonClientException {
         return .submit(new Callable<CreateSnapshotResult>() {
             public CreateSnapshotResult call() throws Exception {
               CreateSnapshotResult result;
                 try {
                 result = createSnapshot(createSnapshotRequest);
               } catch (Exception ex) {
                   asyncHandler.onError(ex);
             throw ex;
               }
               asyncHandler.onSuccess(createSnapshotRequestresult);
                  return result;
         }
     });
     }
    
    

Deletes an AWS Directory Service directory.

Parameters:
deleteDirectoryRequest Container for the necessary parameters to execute the DeleteDirectory operation on AWSDirectoryService.
Returns:
A Java Future object containing the response from the DeleteDirectory service method, as returned by AWSDirectoryService.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AWSDirectoryService indicating either a problem with the data in the request, or a server side issue.
 
     public Future<DeleteDirectoryResultdeleteDirectoryAsync(final DeleteDirectoryRequest deleteDirectoryRequest
             throws AmazonServiceExceptionAmazonClientException {
         return .submit(new Callable<DeleteDirectoryResult>() {
             public DeleteDirectoryResult call() throws Exception {
                 return deleteDirectory(deleteDirectoryRequest);
         }
     });
     }

    

Deletes an AWS Directory Service directory.

Parameters:
deleteDirectoryRequest Container for the necessary parameters to execute the DeleteDirectory operation on AWSDirectoryService.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the DeleteDirectory service method, as returned by AWSDirectoryService.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AWSDirectoryService indicating either a problem with the data in the request, or a server side issue.
 
             final DeleteDirectoryRequest deleteDirectoryRequest,
             final AsyncHandler<DeleteDirectoryRequestDeleteDirectoryResultasyncHandler)
                     throws AmazonServiceExceptionAmazonClientException {
         return .submit(new Callable<DeleteDirectoryResult>() {
             public DeleteDirectoryResult call() throws Exception {
               DeleteDirectoryResult result;
                 try {
                 result = deleteDirectory(deleteDirectoryRequest);
               } catch (Exception ex) {
                   asyncHandler.onError(ex);
             throw ex;
               }
               asyncHandler.onSuccess(deleteDirectoryRequestresult);
                  return result;
         }
     });
     }
    
    

Obtains directory limit information for the current region.

Parameters:
getDirectoryLimitsRequest Container for the necessary parameters to execute the GetDirectoryLimits operation on AWSDirectoryService.
Returns:
A Java Future object containing the response from the GetDirectoryLimits service method, as returned by AWSDirectoryService.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AWSDirectoryService indicating either a problem with the data in the request, or a server side issue.
 
     public Future<GetDirectoryLimitsResultgetDirectoryLimitsAsync(final GetDirectoryLimitsRequest getDirectoryLimitsRequest
             throws AmazonServiceExceptionAmazonClientException {
         return .submit(new Callable<GetDirectoryLimitsResult>() {
             public GetDirectoryLimitsResult call() throws Exception {
                 return getDirectoryLimits(getDirectoryLimitsRequest);
         }
     });
     }

    

Obtains directory limit information for the current region.

Parameters:
getDirectoryLimitsRequest Container for the necessary parameters to execute the GetDirectoryLimits operation on AWSDirectoryService.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the GetDirectoryLimits service method, as returned by AWSDirectoryService.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AWSDirectoryService indicating either a problem with the data in the request, or a server side issue.
 
             final GetDirectoryLimitsRequest getDirectoryLimitsRequest,
             final AsyncHandler<GetDirectoryLimitsRequestGetDirectoryLimitsResultasyncHandler)
                     throws AmazonServiceExceptionAmazonClientException {
         return .submit(new Callable<GetDirectoryLimitsResult>() {
             public GetDirectoryLimitsResult call() throws Exception {
               GetDirectoryLimitsResult result;
                 try {
                result = getDirectoryLimits(getDirectoryLimitsRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(getDirectoryLimitsRequestresult);
                 return result;
        }
    });
    }
    
    

Disables single-sign on for a directory.

Parameters:
disableSsoRequest Container for the necessary parameters to execute the DisableSso operation on AWSDirectoryService.
Returns:
A Java Future object containing the response from the DisableSso service method, as returned by AWSDirectoryService.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AWSDirectoryService indicating either a problem with the data in the request, or a server side issue.
    public Future<DisableSsoResultdisableSsoAsync(final DisableSsoRequest disableSsoRequest
            throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<DisableSsoResult>() {
            public DisableSsoResult call() throws Exception {
                return disableSso(disableSsoRequest);
        }
    });
    }

    

Disables single-sign on for a directory.

Parameters:
disableSsoRequest Container for the necessary parameters to execute the DisableSso operation on AWSDirectoryService.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the DisableSso service method, as returned by AWSDirectoryService.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AWSDirectoryService indicating either a problem with the data in the request, or a server side issue.
            final DisableSsoRequest disableSsoRequest,
            final AsyncHandler<DisableSsoRequestDisableSsoResultasyncHandler)
                    throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<DisableSsoResult>() {
            public DisableSsoResult call() throws Exception {
              DisableSsoResult result;
                try {
                result = disableSso(disableSsoRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(disableSsoRequestresult);
                 return result;
        }
    });
    }
    
    

Enables multi-factor authentication (MFA) with Remote Authentication Dial In User Service (RADIUS) for an AD Connector directory.

Parameters:
enableRadiusRequest Container for the necessary parameters to execute the EnableRadius operation on AWSDirectoryService.
Returns:
A Java Future object containing the response from the EnableRadius service method, as returned by AWSDirectoryService.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AWSDirectoryService indicating either a problem with the data in the request, or a server side issue.
    public Future<EnableRadiusResultenableRadiusAsync(final EnableRadiusRequest enableRadiusRequest
            throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<EnableRadiusResult>() {
            public EnableRadiusResult call() throws Exception {
                return enableRadius(enableRadiusRequest);
        }
    });
    }

    

Enables multi-factor authentication (MFA) with Remote Authentication Dial In User Service (RADIUS) for an AD Connector directory.

Parameters:
enableRadiusRequest Container for the necessary parameters to execute the EnableRadius operation on AWSDirectoryService.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the EnableRadius service method, as returned by AWSDirectoryService.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AWSDirectoryService indicating either a problem with the data in the request, or a server side issue.
            final EnableRadiusRequest enableRadiusRequest,
            final AsyncHandler<EnableRadiusRequestEnableRadiusResultasyncHandler)
                    throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<EnableRadiusResult>() {
            public EnableRadiusResult call() throws Exception {
              EnableRadiusResult result;
                try {
                result = enableRadius(enableRadiusRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(enableRadiusRequestresult);
                 return result;
        }
    });
    }
    
    

Creates a computer account in the specified directory, and joins the computer to the directory.

Parameters:
createComputerRequest Container for the necessary parameters to execute the CreateComputer operation on AWSDirectoryService.
Returns:
A Java Future object containing the response from the CreateComputer service method, as returned by AWSDirectoryService.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AWSDirectoryService indicating either a problem with the data in the request, or a server side issue.
    public Future<CreateComputerResultcreateComputerAsync(final CreateComputerRequest createComputerRequest
            throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<CreateComputerResult>() {
            public CreateComputerResult call() throws Exception {
                return createComputer(createComputerRequest);
        }
    });
    }

    

Creates a computer account in the specified directory, and joins the computer to the directory.

Parameters:
createComputerRequest Container for the necessary parameters to execute the CreateComputer operation on AWSDirectoryService.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the CreateComputer service method, as returned by AWSDirectoryService.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AWSDirectoryService indicating either a problem with the data in the request, or a server side issue.
            final CreateComputerRequest createComputerRequest,
            final AsyncHandler<CreateComputerRequestCreateComputerResultasyncHandler)
                    throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<CreateComputerResult>() {
            public CreateComputerResult call() throws Exception {
              CreateComputerResult result;
                try {
                result = createComputer(createComputerRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(createComputerRequestresult);
                 return result;
        }
    });
    }
    
    

Enables single-sign on for a directory.

Parameters:
enableSsoRequest Container for the necessary parameters to execute the EnableSso operation on AWSDirectoryService.
Returns:
A Java Future object containing the response from the EnableSso service method, as returned by AWSDirectoryService.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AWSDirectoryService indicating either a problem with the data in the request, or a server side issue.
    public Future<EnableSsoResultenableSsoAsync(final EnableSsoRequest enableSsoRequest
            throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<EnableSsoResult>() {
            public EnableSsoResult call() throws Exception {
                return enableSso(enableSsoRequest);
        }
    });
    }

    

Enables single-sign on for a directory.

Parameters:
enableSsoRequest Container for the necessary parameters to execute the EnableSso operation on AWSDirectoryService.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the EnableSso service method, as returned by AWSDirectoryService.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AWSDirectoryService indicating either a problem with the data in the request, or a server side issue.
            final EnableSsoRequest enableSsoRequest,
            final AsyncHandler<EnableSsoRequestEnableSsoResultasyncHandler)
                    throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<EnableSsoResult>() {
            public EnableSsoResult call() throws Exception {
              EnableSsoResult result;
                try {
                result = enableSso(enableSsoRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(enableSsoRequestresult);
                 return result;
        }
    });
    }
    
    

Creates a Simple AD directory.

Parameters:
createDirectoryRequest Container for the necessary parameters to execute the CreateDirectory operation on AWSDirectoryService.
Returns:
A Java Future object containing the response from the CreateDirectory service method, as returned by AWSDirectoryService.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AWSDirectoryService indicating either a problem with the data in the request, or a server side issue.
    public Future<CreateDirectoryResultcreateDirectoryAsync(final CreateDirectoryRequest createDirectoryRequest
            throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<CreateDirectoryResult>() {
            public CreateDirectoryResult call() throws Exception {
                return createDirectory(createDirectoryRequest);
        }
    });
    }

    

Creates a Simple AD directory.

Parameters:
createDirectoryRequest Container for the necessary parameters to execute the CreateDirectory operation on AWSDirectoryService.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the CreateDirectory service method, as returned by AWSDirectoryService.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AWSDirectoryService indicating either a problem with the data in the request, or a server side issue.
            final CreateDirectoryRequest createDirectoryRequest,
            final AsyncHandler<CreateDirectoryRequestCreateDirectoryResultasyncHandler)
                    throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<CreateDirectoryResult>() {
            public CreateDirectoryResult call() throws Exception {
              CreateDirectoryResult result;
                try {
                result = createDirectory(createDirectoryRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(createDirectoryRequestresult);
                 return result;
        }
    });
    }
    
    

Restores a directory using an existing directory snapshot.

When you restore a directory from a snapshot, any changes made to the directory after the snapshot date are overwritten.

This action returns as soon as the restore operation is initiated. You can monitor the progress of the restore operation by calling the DescribeDirectories operation with the directory identifier. When the DirectoryDescription.Stage value changes to Active , the restore operation is complete.

Parameters:
restoreFromSnapshotRequest Container for the necessary parameters to execute the RestoreFromSnapshot operation on AWSDirectoryService.
Returns:
A Java Future object containing the response from the RestoreFromSnapshot service method, as returned by AWSDirectoryService.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AWSDirectoryService indicating either a problem with the data in the request, or a server side issue.
    public Future<RestoreFromSnapshotResultrestoreFromSnapshotAsync(final RestoreFromSnapshotRequest restoreFromSnapshotRequest
            throws AmazonServiceExceptionAmazonClientException {
            public RestoreFromSnapshotResult call() throws Exception {
                return restoreFromSnapshot(restoreFromSnapshotRequest);
        }
    });
    }

    

Restores a directory using an existing directory snapshot.

When you restore a directory from a snapshot, any changes made to the directory after the snapshot date are overwritten.

This action returns as soon as the restore operation is initiated. You can monitor the progress of the restore operation by calling the DescribeDirectories operation with the directory identifier. When the DirectoryDescription.Stage value changes to Active , the restore operation is complete.

Parameters:
restoreFromSnapshotRequest Container for the necessary parameters to execute the RestoreFromSnapshot operation on AWSDirectoryService.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the RestoreFromSnapshot service method, as returned by AWSDirectoryService.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AWSDirectoryService indicating either a problem with the data in the request, or a server side issue.
            final RestoreFromSnapshotRequest restoreFromSnapshotRequest,
            final AsyncHandler<RestoreFromSnapshotRequestRestoreFromSnapshotResultasyncHandler)
                    throws AmazonServiceExceptionAmazonClientException {
            public RestoreFromSnapshotResult call() throws Exception {
              RestoreFromSnapshotResult result;
                try {
                result = restoreFromSnapshot(restoreFromSnapshotRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(restoreFromSnapshotRequestresult);
                 return result;
        }
    });
    }
    
    

Disables multi-factor authentication (MFA) with Remote Authentication Dial In User Service (RADIUS) for an AD Connector directory.

Parameters:
disableRadiusRequest Container for the necessary parameters to execute the DisableRadius operation on AWSDirectoryService.
Returns:
A Java Future object containing the response from the DisableRadius service method, as returned by AWSDirectoryService.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AWSDirectoryService indicating either a problem with the data in the request, or a server side issue.
    public Future<DisableRadiusResultdisableRadiusAsync(final DisableRadiusRequest disableRadiusRequest
            throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<DisableRadiusResult>() {
            public DisableRadiusResult call() throws Exception {
                return disableRadius(disableRadiusRequest);
        }
    });
    }

    

Disables multi-factor authentication (MFA) with Remote Authentication Dial In User Service (RADIUS) for an AD Connector directory.

Parameters:
disableRadiusRequest Container for the necessary parameters to execute the DisableRadius operation on AWSDirectoryService.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the DisableRadius service method, as returned by AWSDirectoryService.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AWSDirectoryService indicating either a problem with the data in the request, or a server side issue.
            final DisableRadiusRequest disableRadiusRequest,
            final AsyncHandler<DisableRadiusRequestDisableRadiusResultasyncHandler)
                    throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<DisableRadiusResult>() {
            public DisableRadiusResult call() throws Exception {
              DisableRadiusResult result;
                try {
                result = disableRadius(disableRadiusRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(disableRadiusRequestresult);
                 return result;
        }
    });
    }
    
    

Obtains the manual snapshot limits for a directory.

Parameters:
getSnapshotLimitsRequest Container for the necessary parameters to execute the GetSnapshotLimits operation on AWSDirectoryService.
Returns:
A Java Future object containing the response from the GetSnapshotLimits service method, as returned by AWSDirectoryService.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AWSDirectoryService indicating either a problem with the data in the request, or a server side issue.
    public Future<GetSnapshotLimitsResultgetSnapshotLimitsAsync(final GetSnapshotLimitsRequest getSnapshotLimitsRequest
            throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<GetSnapshotLimitsResult>() {
            public GetSnapshotLimitsResult call() throws Exception {
                return getSnapshotLimits(getSnapshotLimitsRequest);
        }
    });
    }

    

Obtains the manual snapshot limits for a directory.

Parameters:
getSnapshotLimitsRequest Container for the necessary parameters to execute the GetSnapshotLimits operation on AWSDirectoryService.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the GetSnapshotLimits service method, as returned by AWSDirectoryService.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AWSDirectoryService indicating either a problem with the data in the request, or a server side issue.
            final GetSnapshotLimitsRequest getSnapshotLimitsRequest,
            final AsyncHandler<GetSnapshotLimitsRequestGetSnapshotLimitsResultasyncHandler)
                    throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<GetSnapshotLimitsResult>() {
            public GetSnapshotLimitsResult call() throws Exception {
              GetSnapshotLimitsResult result;
                try {
                result = getSnapshotLimits(getSnapshotLimitsRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(getSnapshotLimitsRequestresult);
                 return result;
        }
    });
    }
    
}
        
New to GrepCode? Check out our FAQ X