Class: Aws::ApplicationDiscoveryService::Client

Inherits:
Seahorse::Client::Base show all
Includes:
ClientStubs
Defined in:
gems/aws-sdk-applicationdiscoveryservice/lib/aws-sdk-applicationdiscoveryservice/client.rb

Overview

An API client for ApplicationDiscoveryService. To construct a client, you need to configure a :region and :credentials.

client = Aws::ApplicationDiscoveryService::Client.new(
  region: region_name,
  credentials: credentials,
  # ...
)

For details on configuring region and credentials see the developer guide.

See #initialize for a full list of supported configuration options.

Instance Attribute Summary

Attributes inherited from Seahorse::Client::Base

#config, #handlers

API Operations collapse

Instance Method Summary collapse

Methods included from ClientStubs

#api_requests, #stub_data, #stub_responses

Methods inherited from Seahorse::Client::Base

add_plugin, api, clear_plugins, define, new, #operation_names, plugins, remove_plugin, set_api, set_plugins

Methods included from Seahorse::Client::HandlerBuilder

#handle, #handle_request, #handle_response

Constructor Details

#initialize(options) ⇒ Client

Returns a new instance of Client.

Parameters:

  • options (Hash)

Options Hash (options):

  • :plugins (Array<Seahorse::Client::Plugin>) — default: []] —

    A list of plugins to apply to the client. Each plugin is either a class name or an instance of a plugin class.

  • :credentials (required, Aws::CredentialProvider) —

    Your AWS credentials used for authentication. This can be any class that includes and implements Aws::CredentialProvider, or instance of any one of the following classes:

    • Aws::Credentials - Used for configuring static, non-refreshing credentials.

    • Aws::SharedCredentials - Used for loading static credentials from a shared file, such as ~/.aws/config.

    • Aws::AssumeRoleCredentials - Used when you need to assume a role.

    • Aws::AssumeRoleWebIdentityCredentials - Used when you need to assume a role after providing credentials via the web.

    • Aws::SSOCredentials - Used for loading credentials from AWS SSO using an access token generated from aws login.

    • Aws::ProcessCredentials - Used for loading credentials from a process that outputs to stdout.

    • Aws::InstanceProfileCredentials - Used for loading credentials from an EC2 IMDS on an EC2 instance.

    • Aws::ECSCredentials - Used for loading credentials from instances running in ECS.

    • Aws::CognitoIdentityCredentials - Used for loading credentials from the Cognito Identity service.

    When :credentials are not configured directly, the following locations will be searched for credentials:

    • Aws.config[:credentials]

    • The :access_key_id, :secret_access_key, :session_token, and :account_id options.

    • ENV['AWS_ACCESS_KEY_ID'], ENV['AWS_SECRET_ACCESS_KEY'], ENV['AWS_SESSION_TOKEN'], and ENV['AWS_ACCOUNT_ID'].

    • ~/.aws/credentials

    • ~/.aws/config

    • EC2/ECS IMDS instance profile - When used by default, the timeouts are very aggressive. Construct and pass an instance of Aws::InstanceProfileCredentials or Aws::ECSCredentials to enable retries and extended timeouts. Instance profile credential fetching can be disabled by setting ENV['AWS_EC2_METADATA_DISABLED'] to true.

  • :region (required, String) —

    The AWS region to connect to. The configured :region is used to determine the service :endpoint. When not passed, a default :region is searched for in the following locations:

    • Aws.config[:region]
    • ENV['AWS_REGION']
    • ENV['AMAZON_REGION']
    • ENV['AWS_DEFAULT_REGION']
    • ~/.aws/credentials
    • ~/.aws/config
  • :access_key_id (String)
  • :account_id (String)
  • :active_endpoint_cache (Boolean) — default: false —

    When set to true, a thread polling for endpoints will be running in the background every 60 secs (default). Defaults to false.

  • :adaptive_retry_wait_to_fill (Boolean) — default: true —

    Used only in adaptive retry mode. When true, the request will sleep until there is sufficent client side capacity to retry the request. When false, the request will raise a RetryCapacityNotAvailableError and will not retry instead of sleeping.

  • :auth_scheme_preference (Array<String>) —

    A list of preferred authentication schemes to use when making a request. Supported values are: sigv4, sigv4a, httpBearerAuth, and noAuth. When set using ENV['AWS_AUTH_SCHEME_PREFERENCE'] or in shared config as auth_scheme_preference, the value should be a comma-separated list.

  • :client_side_monitoring (Boolean) — default: false —

    When true, client-side metrics will be collected for all API requests from this client.

  • :client_side_monitoring_client_id (String) — default: "" —

    Allows you to provide an identifier for this client which will be attached to all generated client side metrics. Defaults to an empty string.

  • :client_side_monitoring_host (String) — default: "127.0.0.1" —

    Allows you to specify the DNS hostname or IPv4 or IPv6 address that the client side monitoring agent is running on, where client metrics will be published via UDP.

  • :client_side_monitoring_port (Integer) — default: 31000 —

    Required for publishing client metrics. The port that the client side monitoring agent is running on, where client metrics will be published via UDP.

  • :client_side_monitoring_publisher (Aws::ClientSideMonitoring::Publisher) — default: Aws::ClientSideMonitoring::Publisher —

    Allows you to provide a custom client-side monitoring publisher class. By default, will use the Client Side Monitoring Agent Publisher.

  • :convert_params (Boolean) — default: true —

    When true, an attempt is made to coerce request parameters into the required types.

  • :correct_clock_skew (Boolean) — default: true —

    Used only in standard and adaptive retry modes. Specifies whether to apply a clock skew correction and retry requests with skewed client clocks. Takes effect only when disable_clock_skew_correction is not set.

  • :defaults_mode (String) — default: "legacy" —

    See DefaultsModeConfiguration for a list of the accepted modes and the configuration defaults that are included.

  • :disable_clock_skew_correction (Boolean) —

    Used only in standard and adaptive retry modes. When true, the SDK does not apply a clock skew correction, does not update its stored skew from responses, and does not retry clock skew errors. Clock skew correction is enabled by default.

  • :disable_host_prefix_injection (Boolean) — default: false —

    When true, the SDK will not prepend the modeled host prefix to the endpoint.

  • :disable_request_compression (Boolean) — default: false —

    When set to 'true' the request body will not be compressed for supported operations.

  • :endpoint (String, URI::HTTPS, URI::HTTP) —

    Normally you should not configure the :endpoint option directly. This is normally constructed from the :region option. Configuring :endpoint is normally reserved for connecting to test or custom endpoints. The endpoint should be a URI formatted like:

    'http://example.com'
'https://example.com'
'http://example.com:123'
  • :endpoint_cache_max_entries (Integer) — default: 1000 —

    Used for the maximum size limit of the LRU cache storing endpoints data for endpoint discovery enabled operations. Defaults to 1000.

  • :endpoint_cache_max_threads (Integer) — default: 10 —

    Used for the maximum threads in use for polling endpoints to be cached, defaults to 10.

  • :endpoint_cache_poll_interval (Integer) — default: 60 —

    When :endpoint_discovery and :active_endpoint_cache is enabled, Use this option to config the time interval in seconds for making requests fetching endpoints information. Defaults to 60 sec.

  • :endpoint_discovery (Boolean) — default: false —

    When set to true, endpoint discovery will be enabled for operations when available.

  • :ignore_configured_endpoint_urls (Boolean) —

    Setting to true disables use of endpoint URLs provided via environment variables and the shared configuration file.

  • :log_formatter (Aws::Log::Formatter) — default: Aws::Log::Formatter.default —

    The log formatter.

  • :log_level (Symbol) — default: :info —

    The log level to send messages to the :logger at.

  • :logger (Logger) —

    The Logger instance to send log messages to. If this option is not set, logging will be disabled.

  • :max_attempts (Integer) — default: 3 —

    An integer representing the maximum number attempts that will be made for a single request, including the initial attempt. For example, setting this value to 5 will result in a request being retried up to 4 times. Used in standard and adaptive retry modes.

  • :profile (String) — default: "default" —

    Used when loading credentials from the shared credentials file at HOME/.aws/credentials. When not specified, 'default' is used.

  • :request_checksum_calculation (String) — default: "when_supported" —

    Determines when a checksum will be calculated for request payloads. Values are:

    • when_supported - (default) When set, a checksum will be calculated for all request payloads of operations modeled with the httpChecksum trait where requestChecksumRequired is true and/or a requestAlgorithmMember is modeled.
    • when_required - When set, a checksum will only be calculated for request payloads of operations modeled with the httpChecksum trait where requestChecksumRequired is true or where a requestAlgorithmMember is modeled and supplied.
  • :request_min_compression_size_bytes (Integer) — default: 10240 —

    The minimum size in bytes that triggers compression for request bodies. The value must be non-negative integer value between 0 and 10485780 bytes inclusive.

  • :response_checksum_validation (String) — default: "when_supported" —

    Determines when checksum validation will be performed on response payloads. Values are:

    • when_supported - (default) When set, checksum validation is performed on all response payloads of operations modeled with the httpChecksum trait where responseAlgorithms is modeled, except when no modeled checksum algorithms are supported.
    • when_required - When set, checksum validation is not performed on response payloads of operations unless the checksum algorithm is supported and the requestValidationModeMember member is set to ENABLED.
  • :retry_backoff (Proc) —

    A proc or lambda used for backoff. Defaults to 2**retries * retry_base_delay. This option is only used in the legacy retry mode.

  • :retry_base_delay (Float) — default: 0.3 —

    The base delay in seconds used by the default backoff function. This option is only used in the legacy retry mode.

  • :retry_jitter (Symbol) — default: :none —

    A delay randomiser function used by the default backoff function. Some predefined functions can be referenced by name - :none, :equal, :full, otherwise a Proc that takes and returns a number. This option is only used in the legacy retry mode.

    @see https://www.awsarchitectureblog.com/2015/03/backoff.html

  • :retry_limit (Integer) — default: 3 —

    The maximum number of times to retry failed requests. Only ~ 500 level server errors and certain ~ 400 level client errors are retried. Generally, these are throttling errors, data checksum errors, networking errors, timeout errors, auth errors, endpoint discovery, and errors from expired credentials. This option is only used in the legacy retry mode.

  • :retry_max_delay (Integer) — default: 0 —

    The maximum number of seconds to delay between retries (0 for no limit) used by the default backoff function. This option is only used in the legacy retry mode.

  • :retry_mode (String) — default: "legacy" —

    Specifies which retry algorithm to use. Values are:

    • legacy - The pre-existing retry behavior. This is the default value if no retry mode is provided.

    • standard - A standardized set of retry rules across the AWS SDKs. This includes support for retry quotas, which limit the number of unsuccessful retries a client can make.

    • adaptive - A retry mode that includes all the functionality of standard mode along with automatic client side throttling.

  • :sdk_ua_app_id (String) —

    A unique and opaque application ID that is appended to the User-Agent header as app/sdk_ua_app_id. It should have a maximum length of 50. This variable is sourced from environment variable AWS_SDK_UA_APP_ID or the shared config profile attribute sdk_ua_app_id.

  • :secret_access_key (String)
  • :session_token (String)
  • :sigv4a_signing_region_set (Array) —

    A list of regions that should be signed with SigV4a signing. When not passed, a default :sigv4a_signing_region_set is searched for in the following locations:

    • Aws.config[:sigv4a_signing_region_set]
    • ENV['AWS_SIGV4A_SIGNING_REGION_SET']
    • ~/.aws/config
  • :simple_json (Boolean) — default: false —

    Disables request parameter conversion, validation, and formatting. Also disables response data type conversions. The request parameters hash must be formatted exactly as the API expects.This option is useful when you want to ensure the highest level of performance by avoiding overhead of walking request parameters and response data structures.

  • :stub_responses (Boolean) — default: false —

    Causes the client to return stubbed responses. By default fake responses are generated and returned. You can specify the response data to return or errors to raise by calling ClientStubs#stub_responses. See ClientStubs for more information.

    Please note When response stubbing is enabled, no HTTP requests are made, and retries are disabled.

  • :telemetry_provider (Aws::Telemetry::TelemetryProviderBase) — default: Aws::Telemetry::NoOpTelemetryProvider —

    Allows you to provide a telemetry provider, which is used to emit telemetry data. By default, uses NoOpTelemetryProvider which will not record or emit any telemetry data. The SDK supports the following telemetry providers:

    • OpenTelemetry (OTel) - To use the OTel provider, install and require the opentelemetry-sdk gem and then, pass in an instance of a Aws::Telemetry::OTelProvider for telemetry provider.
  • :token_provider (Aws::TokenProvider) —

    Your Bearer token used for authentication. This can be any class that includes and implements Aws::TokenProvider, or instance of any one of the following classes:

    • Aws::StaticTokenProvider - Used for configuring static, non-refreshing tokens.

    • Aws::SSOTokenProvider - Used for loading tokens from AWS SSO using an access token generated from aws login.

    When :token_provider is not configured directly, the Aws::TokenProviderChain will be used to search for tokens configured for your profile in shared configuration files.

  • :use_dualstack_endpoint (Boolean) —

    When set to true, dualstack enabled endpoints (with .aws TLD) will be used if available.

  • :use_fips_endpoint (Boolean) —

    When set to true, fips compatible endpoints will be used if available. When a fips region is used, the region is normalized and this config is set to true.

  • :validate_params (Boolean) — default: true —

    When true, request parameters are validated before sending the request.

  • :endpoint_provider (Aws::ApplicationDiscoveryService::EndpointProvider) —

    The endpoint provider used to resolve endpoints. Any object that responds to #resolve_endpoint(parameters) where parameters is a Struct similar to Aws::ApplicationDiscoveryService::EndpointParameters.

  • :http_continue_timeout (Float) — default: 1 —

    The number of seconds to wait for a 100-continue response before sending the request body. This option has no effect unless the request has "Expect" header set to "100-continue". Defaults to nil which disables this behaviour. This value can safely be set per request on the session.

  • :http_idle_timeout (Float) — default: 5 —

    The number of seconds a connection is allowed to sit idle before it is considered stale. Stale connections are closed and removed from the pool before making a request.

  • :http_open_timeout (Float) — default: 15 —

    The default number of seconds to wait for response data. This value can safely be set per-request on the session.

  • :http_proxy (URI::HTTP, String) —

    A proxy to send requests through. Formatted like 'http://proxy.com:123'.

  • :http_read_timeout (Float) — default: 60 —

    The default number of seconds to wait for response data. This value can safely be set per-request on the session.

  • :http_wire_trace (Boolean) — default: false —

    When true, HTTP debug output will be sent to the :logger.

  • :on_chunk_received (Proc) —

    When a Proc object is provided, it will be used as callback when each chunk of the response body is received. It provides three arguments: the chunk, the number of bytes received, and the total number of bytes in the response (or nil if the server did not send a content-length).

  • :on_chunk_sent (Proc) —

    When a Proc object is provided, it will be used as callback when each chunk of the request body is sent. It provides three arguments: the chunk, the number of bytes read from the body, and the total number of bytes in the body.

  • :raise_response_errors (Boolean) — default: true —

    When true, response errors are raised.

  • :ssl_ca_bundle (String) —

    Full path to the SSL certificate authority bundle file that should be used when verifying peer certificates. If you do not pass :ssl_ca_bundle or :ssl_ca_directory the the system default will be used if available.

  • :ssl_ca_directory (String) —

    Full path of the directory that contains the unbundled SSL certificate authority files for verifying peer certificates. If you do not pass :ssl_ca_bundle or :ssl_ca_directory the the system default will be used if available.

  • :ssl_ca_store (String) —

    Sets the X509::Store to verify peer certificate.

  • :ssl_cert (OpenSSL::X509::Certificate) —

    Sets a client certificate when creating http connections.

  • :ssl_key (OpenSSL::PKey) —

    Sets a client key when creating http connections.

  • :ssl_timeout (Float) —

    Sets the SSL timeout in seconds

  • :ssl_verify_peer (Boolean) — default: true —

    When true, SSL peer certificates are verified when establishing a connection.



485
486
487
 
# File 'gems/aws-sdk-applicationdiscoveryservice/lib/aws-sdk-applicationdiscoveryservice/client.rb', line 485

def initialize(*args)
  super
end

Instance Method Details

#associate_configuration_items_to_application(params = {}) ⇒ Struct

Associates one or more configuration items with an application.

Examples:

Request syntax with placeholder values


resp = client.associate_configuration_items_to_application({
  application_configuration_id: "ApplicationId", # required
  configuration_ids: ["ConfigurationId"], # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :application_configuration_id (required, String) —

    The configuration ID of an application with which items are to be associated.

  • :configuration_ids (required, Array<String>) —

    The ID of each configuration item to be associated with an application.

Returns:

  • (Struct) —

    Returns an empty response.



512
513
514
515
 
# File 'gems/aws-sdk-applicationdiscoveryservice/lib/aws-sdk-applicationdiscoveryservice/client.rb', line 512

def associate_configuration_items_to_application(params = {}, options = {})
  req = build_request(:associate_configuration_items_to_application, params)
  req.send_request(options)
end

#batch_delete_agents(params = {}) ⇒ Types::BatchDeleteAgentsResponse

Deletes one or more agents or collectors as specified by ID. Deleting an agent or collector does not delete the previously discovered data. To delete the data collected, use StartBatchDeleteConfigurationTask.

Examples:

Request syntax with placeholder values


resp = client.batch_delete_agents({
  delete_agents: [ # required
    {
      agent_id: "AgentId", # required
      force: false,
    },
  ],
})

Response structure


resp.errors #=> Array
resp.errors[0].agent_id #=> String
resp.errors[0].error_message #=> String
resp.errors[0].error_code #=> String, one of "NOT_FOUND", "INTERNAL_SERVER_ERROR", "AGENT_IN_USE"

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

Returns:



548
549
550
551
 
# File 'gems/aws-sdk-applicationdiscoveryservice/lib/aws-sdk-applicationdiscoveryservice/client.rb', line 548

def batch_delete_agents(params = {}, options = {})
  req = build_request(:batch_delete_agents, params)
  req.send_request(options)
end

#batch_delete_import_data(params = {}) ⇒ Types::BatchDeleteImportDataResponse

Deletes one or more import tasks, each identified by their import ID. Each import task has a number of records that can identify servers or applications.

Amazon Web Services Application Discovery Service has built-in matching logic that will identify when discovered servers match existing entries that you've previously discovered, the information for the already-existing discovered server is updated. When you delete an import task that contains records that were used to match, the information in those matched records that comes from the deleted records will also be deleted.

Examples:

Request syntax with placeholder values


resp = client.batch_delete_import_data({
  import_task_ids: ["ImportTaskIdentifier"], # required
  delete_history: false,
})

Response structure


resp.errors #=> Array
resp.errors[0].import_task_id #=> String
resp.errors[0].error_code #=> String, one of "NOT_FOUND", "INTERNAL_SERVER_ERROR", "OVER_LIMIT"
resp.errors[0].error_description #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :import_task_ids (required, Array<String>) —

    The IDs for the import tasks that you want to delete.

  • :delete_history (Boolean) —

    Set to true to remove the deleted import task from DescribeImportTasks.

Returns:



592
593
594
595
 
# File 'gems/aws-sdk-applicationdiscoveryservice/lib/aws-sdk-applicationdiscoveryservice/client.rb', line 592

def batch_delete_import_data(params = {}, options = {})
  req = build_request(:batch_delete_import_data, params)
  req.send_request(options)
end

#create_application(params = {}) ⇒ Types::CreateApplicationResponse

Creates an application with the given name and description.

Examples:

Request syntax with placeholder values


resp = client.create_application({
  name: "ApplicationName", # required
  description: "ApplicationDescription",
  wave: "ApplicationWave",
})

Response structure


resp.configuration_id #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :name (required, String) —

    The name of the application to be created.

  • :description (String) —

    The description of the application to be created.

  • :wave (String) —

    The name of the migration wave of the application to be created.

Returns:



626
627
628
629
 
# File 'gems/aws-sdk-applicationdiscoveryservice/lib/aws-sdk-applicationdiscoveryservice/client.rb', line 626

def create_application(params = {}, options = {})
  req = build_request(:create_application, params)
  req.send_request(options)
end

#create_tags(params = {}) ⇒ Struct

Creates one or more tags for configuration items. Tags are metadata that help you categorize IT assets. This API accepts a list of multiple configuration items.

Do not store sensitive information (like personal data) in tags.

Examples:

Request syntax with placeholder values


resp = client.create_tags({
  configuration_ids: ["ConfigurationId"], # required
  tags: [ # required
    {
      key: "TagKey", # required
      value: "TagValue", # required
    },
  ],
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :configuration_ids (required, Array<String>) —

    A list of configuration items that you want to tag.

  • :tags (required, Array<Types::Tag>) —

    Tags that you want to associate with one or more configuration items. Specify the tags that you want to create in a key-value format. For example:

    {"key": "serverType", "value": "webServer"}

Returns:

  • (Struct) —

    Returns an empty response.



663
664
665
666
 
# File 'gems/aws-sdk-applicationdiscoveryservice/lib/aws-sdk-applicationdiscoveryservice/client.rb', line 663

def create_tags(params = {}, options = {})
  req = build_request(:create_tags, params)
  req.send_request(options)
end

#delete_applications(params = {}) ⇒ Struct

Deletes a list of applications and their associations with configuration items.

Examples:

Request syntax with placeholder values


resp = client.delete_applications({
  configuration_ids: ["ApplicationId"], # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :configuration_ids (required, Array<String>) —

    Configuration ID of an application to be deleted.

Returns:

  • (Struct) —

    Returns an empty response.



684
685
686
687
 
# File 'gems/aws-sdk-applicationdiscoveryservice/lib/aws-sdk-applicationdiscoveryservice/client.rb', line 684

def delete_applications(params = {}, options = {})
  req = build_request(:delete_applications, params)
  req.send_request(options)
end

#delete_tags(params = {}) ⇒ Struct

Deletes the association between configuration items and one or more tags. This API accepts a list of multiple configuration items.

Examples:

Request syntax with placeholder values


resp = client.delete_tags({
  configuration_ids: ["ConfigurationId"], # required
  tags: [
    {
      key: "TagKey", # required
      value: "TagValue", # required
    },
  ],
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :configuration_ids (required, Array<String>) —

    A list of configuration items with tags that you want to delete.

  • :tags (Array<Types::Tag>) —

    Tags that you want to delete from one or more configuration items. Specify the tags that you want to delete in a key-value format. For example:

    {"key": "serverType", "value": "webServer"}

Returns:

  • (Struct) —

    Returns an empty response.



718
719
720
721
 
# File 'gems/aws-sdk-applicationdiscoveryservice/lib/aws-sdk-applicationdiscoveryservice/client.rb', line 718

def delete_tags(params = {}, options = {})
  req = build_request(:delete_tags, params)
  req.send_request(options)
end

#describe_agents(params = {}) ⇒ Types::DescribeAgentsResponse

Lists agents or collectors as specified by ID or other filters. All agents/collectors associated with your user can be listed if you call DescribeAgents as is without passing any parameters.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.describe_agents({
  agent_ids: ["AgentId"],
  filters: [
    {
      name: "String", # required
      values: ["FilterValue"], # required
      condition: "Condition", # required
    },
  ],
  max_results: 1,
  next_token: "NextToken",
})

Response structure


resp.agents_info #=> Array
resp.agents_info[0].agent_id #=> String
resp.agents_info[0].host_name #=> String
resp.agents_info[0].agent_network_info_list #=> Array
resp.agents_info[0].agent_network_info_list[0].ip_address #=> String
resp.agents_info[0].agent_network_info_list[0].mac_address #=> String
resp.agents_info[0].connector_id #=> String
resp.agents_info[0].version #=> String
resp.agents_info[0].health #=> String, one of "HEALTHY", "UNHEALTHY", "RUNNING", "UNKNOWN", "BLACKLISTED", "SHUTDOWN"
resp.agents_info[0].last_health_ping_time #=> String
resp.agents_info[0].collection_status #=> String
resp.agents_info[0].agent_type #=> String
resp.agents_info[0].registered_time #=> String
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :agent_ids (Array<String>) —

    The agent or the collector IDs for which you want information. If you specify no IDs, the system returns information about all agents/collectors associated with your user.

  • :filters (Array<Types::Filter>) —

    You can filter the request using various logical operators and a key-value format. For example:

    {"key": "collectionStatus", "value": "STARTED"}

  • :max_results (Integer) —

    The total number of agents/collectors to return in a single page of output. The maximum value is 100.

  • :next_token (String) —

    Token to retrieve the next set of results. For example, if you previously specified 100 IDs for DescribeAgentsRequest$agentIds but set DescribeAgentsRequest$maxResults to 10, you received a set of 10 results along with a token. Use that token in this query to get the next set of 10.

Returns:



790
791
792
793
 
# File 'gems/aws-sdk-applicationdiscoveryservice/lib/aws-sdk-applicationdiscoveryservice/client.rb', line 790

def describe_agents(params = {}, options = {})
  req = build_request(:describe_agents, params)
  req.send_request(options)
end

#describe_batch_delete_configuration_task(params = {}) ⇒ Types::DescribeBatchDeleteConfigurationTaskResponse

Takes a unique deletion task identifier as input and returns metadata about a configuration deletion task.

Examples:

Request syntax with placeholder values


resp = client.describe_batch_delete_configuration_task({
  task_id: "UUID", # required
})

Response structure


resp.task.task_id #=> String
resp.task.status #=> String, one of "INITIALIZING", "VALIDATING", "DELETING", "COMPLETED", "FAILED"
resp.task.start_time #=> Time
resp.task.end_time #=> Time
resp.task.configuration_type #=> String, one of "SERVER"
resp.task.requested_configurations #=> Array
resp.task.requested_configurations[0] #=> String
resp.task.deleted_configurations #=> Array
resp.task.deleted_configurations[0] #=> String
resp.task.failed_configurations #=> Array
resp.task.failed_configurations[0].configuration_id #=> String
resp.task.failed_configurations[0].error_status_code #=> Integer
resp.task.failed_configurations[0].error_message #=> String
resp.task.deletion_warnings #=> Array
resp.task.deletion_warnings[0].configuration_id #=> String
resp.task.deletion_warnings[0].warning_code #=> Integer
resp.task.deletion_warnings[0].warning_text #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :task_id (required, String) —

    The ID of the task to delete.

Returns:



833
834
835
836
 
# File 'gems/aws-sdk-applicationdiscoveryservice/lib/aws-sdk-applicationdiscoveryservice/client.rb', line 833

def describe_batch_delete_configuration_task(params = {}, options = {})
  req = build_request(:describe_batch_delete_configuration_task, params)
  req.send_request(options)
end

#describe_configurations(params = {}) ⇒ Types::DescribeConfigurationsResponse

Retrieves attributes for a list of configuration item IDs.

All of the supplied IDs must be for the same asset type from one of the following:

  • server

  • application

  • process

  • connection

Output fields are specific to the asset type specified. For example, the output for a server configuration item includes a list of attributes about the server, such as host name, operating system, number of network cards, etc.

For a complete list of outputs for each asset type, see Using the DescribeConfigurations Action in the Amazon Web Services Application Discovery Service User Guide.

Examples:

Request syntax with placeholder values


resp = client.describe_configurations({
  configuration_ids: ["ConfigurationId"], # required
})

Response structure


resp.configurations #=> Array
resp.configurations[0] #=> Hash
resp.configurations[0]["String"] #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :configuration_ids (required, Array<String>) —

    One or more configuration IDs.

Returns:



887
888
889
890
 
# File 'gems/aws-sdk-applicationdiscoveryservice/lib/aws-sdk-applicationdiscoveryservice/client.rb', line 887

def describe_configurations(params = {}, options = {})
  req = build_request(:describe_configurations, params)
  req.send_request(options)
end

#describe_continuous_exports(params = {}) ⇒ Types::DescribeContinuousExportsResponse

Lists exports as specified by ID. All continuous exports associated with your user can be listed if you call DescribeContinuousExports as is without passing any parameters.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.describe_continuous_exports({
  export_ids: ["ConfigurationsExportId"],
  max_results: 1,
  next_token: "NextToken",
})

Response structure


resp.descriptions #=> Array
resp.descriptions[0].export_id #=> String
resp.descriptions[0].status #=> String, one of "START_IN_PROGRESS", "START_FAILED", "ACTIVE", "ERROR", "STOP_IN_PROGRESS", "STOP_FAILED", "INACTIVE"
resp.descriptions[0].status_detail #=> String
resp.descriptions[0].s3_bucket #=> String
resp.descriptions[0].start_time #=> Time
resp.descriptions[0].stop_time #=> Time
resp.descriptions[0].data_source #=> String, one of "AGENT"
resp.descriptions[0].schema_storage_config #=> Hash
resp.descriptions[0].schema_storage_config["DatabaseName"] #=> String
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :export_ids (Array<String>) —

    The unique IDs assigned to the exports.

  • :max_results (Integer) —

    A number between 1 and 100 specifying the maximum number of continuous export descriptions returned.

  • :next_token (String) —

    The token from the previous call to DescribeExportTasks.

Returns:



937
938
939
940
 
# File 'gems/aws-sdk-applicationdiscoveryservice/lib/aws-sdk-applicationdiscoveryservice/client.rb', line 937

def describe_continuous_exports(params = {}, options = {})
  req = build_request(:describe_continuous_exports, params)
  req.send_request(options)
end

#describe_export_configurations(params = {}) ⇒ Types::DescribeExportConfigurationsResponse

DescribeExportConfigurations is deprecated. Use DescribeExportTasks, instead.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.describe_export_configurations({
  export_ids: ["ConfigurationsExportId"],
  max_results: 1,
  next_token: "NextToken",
})

Response structure


resp.exports_info #=> Array
resp.exports_info[0].export_id #=> String
resp.exports_info[0].export_status #=> String, one of "FAILED", "SUCCEEDED", "IN_PROGRESS"
resp.exports_info[0].status_message #=> String
resp.exports_info[0].configurations_download_url #=> String
resp.exports_info[0].export_request_time #=> Time
resp.exports_info[0].is_truncated #=> Boolean
resp.exports_info[0].requested_start_time #=> Time
resp.exports_info[0].requested_end_time #=> Time
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :export_ids (Array<String>) —

    A list of continuous export IDs to search for.

  • :max_results (Integer) —

    A number between 1 and 100 specifying the maximum number of continuous export descriptions returned.

  • :next_token (String) —

    The token from the previous call to describe-export-tasks.

Returns:



989
990
991
992
 
# File 'gems/aws-sdk-applicationdiscoveryservice/lib/aws-sdk-applicationdiscoveryservice/client.rb', line 989

def describe_export_configurations(params = {}, options = {})
  req = build_request(:describe_export_configurations, params)
  req.send_request(options)
end

#describe_export_tasks(params = {}) ⇒ Types::DescribeExportTasksResponse

Retrieve status of one or more export tasks. You can retrieve the status of up to 100 export tasks.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.describe_export_tasks({
  export_ids: ["ConfigurationsExportId"],
  filters: [
    {
      name: "FilterName", # required
      values: ["FilterValue"], # required
      condition: "Condition", # required
    },
  ],
  max_results: 1,
  next_token: "NextToken",
})

Response structure


resp.exports_info #=> Array
resp.exports_info[0].export_id #=> String
resp.exports_info[0].export_status #=> String, one of "FAILED", "SUCCEEDED", "IN_PROGRESS"
resp.exports_info[0].status_message #=> String
resp.exports_info[0].configurations_download_url #=> String
resp.exports_info[0].export_request_time #=> Time
resp.exports_info[0].is_truncated #=> Boolean
resp.exports_info[0].requested_start_time #=> Time
resp.exports_info[0].requested_end_time #=> Time
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :export_ids (Array<String>) —

    One or more unique identifiers used to query the status of an export request.

  • :filters (Array<Types::ExportFilter>) —

    One or more filters.

    • AgentId - ID of the agent whose collected data will be exported

    ^

  • :max_results (Integer) —

    The maximum number of volume results returned by DescribeExportTasks in paginated output. When this parameter is used, DescribeExportTasks only returns maxResults results in a single page along with a nextToken response element.

  • :next_token (String) —

    The nextToken value returned from a previous paginated DescribeExportTasks request where maxResults was used and the results exceeded the value of that parameter. Pagination continues from the end of the previous results that returned the nextToken value. This value is null when there are no more results to return.

Returns:



1058
1059
1060
1061
 
# File 'gems/aws-sdk-applicationdiscoveryservice/lib/aws-sdk-applicationdiscoveryservice/client.rb', line 1058

def describe_export_tasks(params = {}, options = {})
  req = build_request(:describe_export_tasks, params)
  req.send_request(options)
end

#describe_import_tasks(params = {}) ⇒ Types::DescribeImportTasksResponse

Returns an array of import tasks for your account, including status information, times, IDs, the Amazon S3 Object URL for the import file, and more.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.describe_import_tasks({
  filters: [
    {
      name: "IMPORT_TASK_ID", # accepts IMPORT_TASK_ID, STATUS, NAME, FILE_CLASSIFICATION
      values: ["ImportTaskFilterValue"],
    },
  ],
  max_results: 1,
  next_token: "NextToken",
})

Response structure


resp.next_token #=> String
resp.tasks #=> Array
resp.tasks[0].import_task_id #=> String
resp.tasks[0].client_request_token #=> String
resp.tasks[0].name #=> String
resp.tasks[0].import_url #=> String
resp.tasks[0].status #=> String, one of "IMPORT_IN_PROGRESS", "IMPORT_COMPLETE", "IMPORT_COMPLETE_WITH_ERRORS", "IMPORT_FAILED", "IMPORT_FAILED_SERVER_LIMIT_EXCEEDED", "IMPORT_FAILED_RECORD_LIMIT_EXCEEDED", "IMPORT_FAILED_UNSUPPORTED_FILE_TYPE", "DELETE_IN_PROGRESS", "DELETE_COMPLETE", "DELETE_FAILED", "DELETE_FAILED_LIMIT_EXCEEDED", "INTERNAL_ERROR"
resp.tasks[0].import_request_time #=> Time
resp.tasks[0].import_completion_time #=> Time
resp.tasks[0].import_deleted_time #=> Time
resp.tasks[0].file_classification #=> String, one of "MODELIZEIT_EXPORT", "RVTOOLS_EXPORT", "VMWARE_NSX_EXPORT", "IMPORT_TEMPLATE"
resp.tasks[0].server_import_success #=> Integer
resp.tasks[0].server_import_failure #=> Integer
resp.tasks[0].application_import_success #=> Integer
resp.tasks[0].application_import_failure #=> Integer
resp.tasks[0].errors_and_failed_entries_zip #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :filters (Array<Types::ImportTaskFilter>) —

    An array of name-value pairs that you provide to filter the results for the DescribeImportTask request to a specific subset of results. Currently, wildcard values aren't supported for filters.

  • :max_results (Integer) —

    The maximum number of results that you want this request to return, up to 100.

  • :next_token (String) —

    The token to request a specific page of results.

Returns:



1120
1121
1122
1123
 
# File 'gems/aws-sdk-applicationdiscoveryservice/lib/aws-sdk-applicationdiscoveryservice/client.rb', line 1120

def describe_import_tasks(params = {}, options = {})
  req = build_request(:describe_import_tasks, params)
  req.send_request(options)
end

#describe_tags(params = {}) ⇒ Types::DescribeTagsResponse

Retrieves a list of configuration items that have tags as specified by the key-value pairs, name and value, passed to the optional parameter filters.

There are three valid tag filter names:

  • tagKey

  • tagValue

  • configurationId

Also, all configuration items associated with your user that have tags can be listed if you call DescribeTags as is without passing any parameters.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.describe_tags({
  filters: [
    {
      name: "FilterName", # required
      values: ["FilterValue"], # required
    },
  ],
  max_results: 1,
  next_token: "NextToken",
})

Response structure


resp.tags #=> Array
resp.tags[0].configuration_type #=> String, one of "SERVER", "PROCESS", "CONNECTION", "APPLICATION"
resp.tags[0].configuration_id #=> String
resp.tags[0].key #=> String
resp.tags[0].value #=> String
resp.tags[0].time_of_creation #=> Time
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :filters (Array<Types::TagFilter>) —

    You can filter the list using a key-value format. You can separate these items by using logical operators. Allowed filters include tagKey, tagValue, and configurationId.

  • :max_results (Integer) —

    The total number of items to return in a single page of output. The maximum value is 100.

  • :next_token (String) —

    A token to start the list. Use this token to get the next set of results.

Returns:



1186
1187
1188
1189
 
# File 'gems/aws-sdk-applicationdiscoveryservice/lib/aws-sdk-applicationdiscoveryservice/client.rb', line 1186

def describe_tags(params = {}, options = {})
  req = build_request(:describe_tags, params)
  req.send_request(options)
end

#disassociate_configuration_items_from_application(params = {}) ⇒ Struct

Disassociates one or more configuration items from an application.

Examples:

Request syntax with placeholder values


resp = client.disassociate_configuration_items_from_application({
  application_configuration_id: "ApplicationId", # required
  configuration_ids: ["ConfigurationId"], # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :application_configuration_id (required, String) —

    Configuration ID of an application from which each item is disassociated.

  • :configuration_ids (required, Array<String>) —

    Configuration ID of each item to be disassociated from an application.

Returns:

  • (Struct) —

    Returns an empty response.



1211
1212
1213
1214
 
# File 'gems/aws-sdk-applicationdiscoveryservice/lib/aws-sdk-applicationdiscoveryservice/client.rb', line 1211

def disassociate_configuration_items_from_application(params = {}, options = {})
  req = build_request(:disassociate_configuration_items_from_application, params)
  req.send_request(options)
end

#export_configurations(params = {}) ⇒ Types::ExportConfigurationsResponse

Deprecated. Use StartExportTask instead.

Exports all discovered configuration data to an Amazon S3 bucket or an application that enables you to view and evaluate the data. Data includes tags and tag associations, processes, connections, servers, and system performance. This API returns an export ID that you can query using the DescribeExportConfigurations API. The system imposes a limit of two configuration exports in six hours.

Examples:

Response structure


resp.export_id #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Returns:



1235
1236
1237
1238
 
# File 'gems/aws-sdk-applicationdiscoveryservice/lib/aws-sdk-applicationdiscoveryservice/client.rb', line 1235

def export_configurations(params = {}, options = {})
  req = build_request(:export_configurations, params)
  req.send_request(options)
end

#get_discovery_summary(params = {}) ⇒ Types::GetDiscoverySummaryResponse

Retrieves a short summary of discovered assets.

This API operation takes no request parameters and is called as is at the command prompt as shown in the example.

Examples:

Response structure


resp.servers #=> Integer
resp.applications #=> Integer
resp.servers_mapped_to_applications #=> Integer
resp.servers_mappedto_tags #=> Integer
resp.agent_summary.active_agents #=> Integer
resp.agent_summary.healthy_agents #=> Integer
resp.agent_summary.black_listed_agents #=> Integer
resp.agent_summary.shutdown_agents #=> Integer
resp.agent_summary.unhealthy_agents #=> Integer
resp.agent_summary.total_agents #=> Integer
resp.agent_summary.unknown_agents #=> Integer
resp.connector_summary.active_connectors #=> Integer
resp.connector_summary.healthy_connectors #=> Integer
resp.connector_summary.black_listed_connectors #=> Integer
resp.connector_summary.shutdown_connectors #=> Integer
resp.connector_summary.unhealthy_connectors #=> Integer
resp.connector_summary.total_connectors #=> Integer
resp.connector_summary.unknown_connectors #=> Integer
resp.me_collector_summary.active_me_collectors #=> Integer
resp.me_collector_summary.healthy_me_collectors #=> Integer
resp.me_collector_summary.deny_listed_me_collectors #=> Integer
resp.me_collector_summary.shutdown_me_collectors #=> Integer
resp.me_collector_summary.unhealthy_me_collectors #=> Integer
resp.me_collector_summary.total_me_collectors #=> Integer
resp.me_collector_summary.unknown_me_collectors #=> Integer
resp.agentless_collector_summary.active_agentless_collectors #=> Integer
resp.agentless_collector_summary.healthy_agentless_collectors #=> Integer
resp.agentless_collector_summary.deny_listed_agentless_collectors #=> Integer
resp.agentless_collector_summary.shutdown_agentless_collectors #=> Integer
resp.agentless_collector_summary.unhealthy_agentless_collectors #=> Integer
resp.agentless_collector_summary.total_agentless_collectors #=> Integer
resp.agentless_collector_summary.unknown_agentless_collectors #=> Integer

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Returns:



1293
1294
1295
1296
 
# File 'gems/aws-sdk-applicationdiscoveryservice/lib/aws-sdk-applicationdiscoveryservice/client.rb', line 1293

def get_discovery_summary(params = {}, options = {})
  req = build_request(:get_discovery_summary, params)
  req.send_request(options)
end

#list_configurations(params = {}) ⇒ Types::ListConfigurationsResponse

Retrieves a list of configuration items as specified by the value passed to the required parameter configurationType. Optional filtering may be applied to refine search results.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_configurations({
  configuration_type: "SERVER", # required, accepts SERVER, PROCESS, CONNECTION, APPLICATION
  filters: [
    {
      name: "String", # required
      values: ["FilterValue"], # required
      condition: "Condition", # required
    },
  ],
  max_results: 1,
  next_token: "NextToken",
  order_by: [
    {
      field_name: "OrderByElementFieldName", # required
      sort_order: "ASC", # accepts ASC, DESC
    },
  ],
})

Response structure


resp.configurations #=> Array
resp.configurations[0] #=> Hash
resp.configurations[0]["String"] #=> String
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :configuration_type (required, String) —

    A valid configuration identified by Application Discovery Service.

  • :filters (Array<Types::Filter>) —

    You can filter the request using various logical operators and a key-value format. For example:

    {"key": "serverType", "value": "webServer"}

    For a complete list of filter options and guidance about using them with this action, see Using the ListConfigurations Action in the Amazon Web Services Application Discovery Service User Guide.

  • :max_results (Integer) —

    The total number of items to return. The maximum value is 100.

  • :next_token (String) —

    Token to retrieve the next set of results. For example, if a previous call to ListConfigurations returned 100 items, but you set ListConfigurationsRequest$maxResults to 10, you received a set of 10 results along with a token. Use that token in this query to get the next set of 10.

  • :order_by (Array<Types::OrderByElement>) —

    Certain filter criteria return output that can be sorted in ascending or descending order. For a list of output characteristics for each filter, see Using the ListConfigurations Action in the Amazon Web Services Application Discovery Service User Guide.

Returns:



1376
1377
1378
1379
 
# File 'gems/aws-sdk-applicationdiscoveryservice/lib/aws-sdk-applicationdiscoveryservice/client.rb', line 1376

def list_configurations(params = {}, options = {})
  req = build_request(:list_configurations, params)
  req.send_request(options)
end

#list_server_neighbors(params = {}) ⇒ Types::ListServerNeighborsResponse

Retrieves a list of servers that are one network hop away from a specified server.

Examples:

Request syntax with placeholder values


resp = client.list_server_neighbors({
  configuration_id: "ConfigurationId", # required
  port_information_needed: false,
  neighbor_configuration_ids: ["ConfigurationId"],
  max_results: 1,
  next_token: "String",
})

Response structure


resp.neighbors #=> Array
resp.neighbors[0].source_server_id #=> String
resp.neighbors[0].destination_server_id #=> String
resp.neighbors[0].destination_port #=> Integer
resp.neighbors[0].transport_protocol #=> String
resp.neighbors[0].connections_count #=> Integer
resp.next_token #=> String
resp.known_dependency_count #=> Integer

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :configuration_id (required, String) —

    Configuration ID of the server for which neighbors are being listed.

  • :port_information_needed (Boolean) —

    Flag to indicate if port and protocol information is needed as part of the response.

  • :neighbor_configuration_ids (Array<String>) —

    List of configuration IDs to test for one-hop-away.

  • :max_results (Integer) —

    Maximum number of results to return in a single page of output.

  • :next_token (String) —

    Token to retrieve the next set of results. For example, if you previously specified 100 IDs for ListServerNeighborsRequest$neighborConfigurationIds but set ListServerNeighborsRequest$maxResults to 10, you received a set of 10 results along with a token. Use that token in this query to get the next set of 10.

Returns:



1434
1435
1436
1437
 
# File 'gems/aws-sdk-applicationdiscoveryservice/lib/aws-sdk-applicationdiscoveryservice/client.rb', line 1434

def list_server_neighbors(params = {}, options = {})
  req = build_request(:list_server_neighbors, params)
  req.send_request(options)
end

#start_batch_delete_configuration_task(params = {}) ⇒ Types::StartBatchDeleteConfigurationTaskResponse

Takes a list of configurationId as input and starts an asynchronous deletion task to remove the configurationItems. Returns a unique deletion task identifier.

Examples:

Request syntax with placeholder values


resp = client.start_batch_delete_configuration_task({
  configuration_type: "SERVER", # required, accepts SERVER
  configuration_ids: ["ConfigurationId"], # required
})

Response structure


resp.task_id #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :configuration_type (required, String) —

    The type of configuration item to delete. Supported types are: SERVER.

  • :configuration_ids (required, Array<String>) —

    The list of configuration IDs that will be deleted by the task.

Returns:



1466
1467
1468
1469
 
# File 'gems/aws-sdk-applicationdiscoveryservice/lib/aws-sdk-applicationdiscoveryservice/client.rb', line 1466

def start_batch_delete_configuration_task(params = {}, options = {})
  req = build_request(:start_batch_delete_configuration_task, params)
  req.send_request(options)
end

#start_continuous_export(params = {}) ⇒ Types::StartContinuousExportResponse

Start the continuous flow of agent's discovered data into Amazon Athena.

Examples:

Response structure


resp.export_id #=> String
resp.s3_bucket #=> String
resp.start_time #=> Time
resp.data_source #=> String, one of "AGENT"
resp.schema_storage_config #=> Hash
resp.schema_storage_config["DatabaseName"] #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Returns:



1493
1494
1495
1496
 
# File 'gems/aws-sdk-applicationdiscoveryservice/lib/aws-sdk-applicationdiscoveryservice/client.rb', line 1493

def start_continuous_export(params = {}, options = {})
  req = build_request(:start_continuous_export, params)
  req.send_request(options)
end

#start_data_collection_by_agent_ids(params = {}) ⇒ Types::StartDataCollectionByAgentIdsResponse

Instructs the specified agents to start collecting data.

Examples:

Request syntax with placeholder values


resp = client.start_data_collection_by_agent_ids({
  agent_ids: ["AgentId"], # required
})

Response structure


resp.agents_configuration_status #=> Array
resp.agents_configuration_status[0].agent_id #=> String
resp.agents_configuration_status[0].operation_succeeded #=> Boolean
resp.agents_configuration_status[0].description #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :agent_ids (required, Array<String>) —

    The IDs of the agents from which to start collecting data. If you send a request to an agent ID that you do not have permission to contact, according to your Amazon Web Services account, the service does not throw an exception. Instead, it returns the error in the Description field. If you send a request to multiple agents and you do not have permission to contact some of those agents, the system does not throw an exception. Instead, the system shows Failed in the Description field.

Returns:



1529
1530
1531
1532
 
# File 'gems/aws-sdk-applicationdiscoveryservice/lib/aws-sdk-applicationdiscoveryservice/client.rb', line 1529

def start_data_collection_by_agent_ids(params = {}, options = {})
  req = build_request(:start_data_collection_by_agent_ids, params)
  req.send_request(options)
end

#start_export_task(params = {}) ⇒ Types::StartExportTaskResponse

Begins the export of a discovered data report to an Amazon S3 bucket managed by Amazon Web Services.

Exports might provide an estimate of fees and savings based on certain information that you provide. Fee estimates do not include any taxes that might apply. Your actual fees and savings depend on a variety of factors, including your actual usage of Amazon Web Services services, which might vary from the estimates provided in this report.

If you do not specify preferences or agentIds in the filter, a summary of all servers, applications, tags, and performance is generated. This data is an aggregation of all server data collected through on-premises tooling, file import, application grouping and applying tags.

If you specify agentIds in a filter, the task exports up to 72 hours of detailed data collected by the identified Application Discovery Agent, including network, process, and performance details. A time range for exported agent data may be set by using startTime and endTime. Export of detailed agent data is limited to five concurrently running exports. Export of detailed agent data is limited to two exports per day.

If you enable ec2RecommendationsPreferences in preferences , an Amazon EC2 instance matching the characteristics of each server in Application Discovery Service is generated. Changing the attributes of the ec2RecommendationsPreferences changes the criteria of the recommendation.

Examples:

Request syntax with placeholder values


resp = client.start_export_task({
  export_data_format: ["CSV"], # accepts CSV
  filters: [
    {
      name: "FilterName", # required
      values: ["FilterValue"], # required
      condition: "Condition", # required
    },
  ],
  start_time: Time.now,
  end_time: Time.now,
  preferences: {
    ec2_recommendations_preferences: {
      enabled: false,
      cpu_performance_metric_basis: {
        name: "UsageMetricBasisName",
        percentage_adjust: 1.0,
      },
      ram_performance_metric_basis: {
        name: "UsageMetricBasisName",
        percentage_adjust: 1.0,
      },
      tenancy: "DEDICATED", # accepts DEDICATED, SHARED
      excluded_instance_types: ["EC2InstanceType"],
      preferred_region: "UserPreferredRegion",
      reserved_instance_options: {
        purchasing_option: "ALL_UPFRONT", # required, accepts ALL_UPFRONT, PARTIAL_UPFRONT, NO_UPFRONT
        offering_class: "STANDARD", # required, accepts STANDARD, CONVERTIBLE
        term_length: "ONE_YEAR", # required, accepts ONE_YEAR, THREE_YEAR
      },
    },
  },
})

Response structure


resp.export_id #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :export_data_format (Array<String>) —

    The file format for the returned export data. Default value is CSV. Note: The GRAPHML option has been deprecated.

  • :filters (Array<Types::ExportFilter>) —

    If a filter is present, it selects the single agentId of the Application Discovery Agent for which data is exported. The agentId can be found in the results of the DescribeAgents API or CLI. If no filter is present, startTime and endTime are ignored and exported data includes both Amazon Web Services Application Discovery Service Agentless Collector collectors data and summary data from Application Discovery Agent agents.

  • :start_time (Time, DateTime, Date, Integer, String) —

    The start timestamp for exported data from the single Application Discovery Agent selected in the filters. If no value is specified, data is exported starting from the first data collected by the agent.

  • :end_time (Time, DateTime, Date, Integer, String) —

    The end timestamp for exported data from the single Application Discovery Agent selected in the filters. If no value is specified, exported data includes the most recent data collected by the agent.

  • :preferences (Types::ExportPreferences) —

    Indicates the type of data that needs to be exported. Only one ExportPreferences can be enabled at any time.

Returns:



1642
1643
1644
1645
 
# File 'gems/aws-sdk-applicationdiscoveryservice/lib/aws-sdk-applicationdiscoveryservice/client.rb', line 1642

def start_export_task(params = {}, options = {})
  req = build_request(:start_export_task, params)
  req.send_request(options)
end

#start_import_task(params = {}) ⇒ Types::StartImportTaskResponse

Starts an import task, which allows you to import details of your on-premises environment directly into Amazon Web Services Migration Hub without having to use the Amazon Web Services Application Discovery Service (Application Discovery Service) tools such as the Amazon Web Services Application Discovery Service Agentless Collector or Application Discovery Agent. This gives you the option to perform migration assessment and planning directly from your imported data, including the ability to group your devices as applications and track their migration status.

To start an import request, do this:

  1. Download the specially formatted comma separated value (CSV) import template, which you can find here: https://s3.us-west-2.amazonaws.com/templates-7cffcf56-bd96-4b1c-b45b-a5b42f282e46/import_template.csv.

  2. Fill out the template with your server and application data.

  3. Upload your import file to an Amazon S3 bucket, and make a note of it's Object URL. Your import file must be in the CSV format.

  4. Use the console or the StartImportTask command with the Amazon Web Services CLI or one of the Amazon Web Services SDKs to import the records from your file.

For more information, including step-by-step procedures, see Migration Hub Import in the Amazon Web Services Application Discovery Service User Guide.

There are limits to the number of import tasks you can create (and delete) in an Amazon Web Services account. For more information, see Amazon Web Services Application Discovery Service Limits in the Amazon Web Services Application Discovery Service User Guide.

Examples:

Request syntax with placeholder values


resp = client.start_import_task({
  client_request_token: "ClientRequestToken",
  name: "ImportTaskName", # required
  import_url: "ImportURL", # required
})

Response structure


resp.task.import_task_id #=> String
resp.task.client_request_token #=> String
resp.task.name #=> String
resp.task.import_url #=> String
resp.task.status #=> String, one of "IMPORT_IN_PROGRESS", "IMPORT_COMPLETE", "IMPORT_COMPLETE_WITH_ERRORS", "IMPORT_FAILED", "IMPORT_FAILED_SERVER_LIMIT_EXCEEDED", "IMPORT_FAILED_RECORD_LIMIT_EXCEEDED", "IMPORT_FAILED_UNSUPPORTED_FILE_TYPE", "DELETE_IN_PROGRESS", "DELETE_COMPLETE", "DELETE_FAILED", "DELETE_FAILED_LIMIT_EXCEEDED", "INTERNAL_ERROR"
resp.task.import_request_time #=> Time
resp.task.import_completion_time #=> Time
resp.task.import_deleted_time #=> Time
resp.task.file_classification #=> String, one of "MODELIZEIT_EXPORT", "RVTOOLS_EXPORT", "VMWARE_NSX_EXPORT", "IMPORT_TEMPLATE"
resp.task.server_import_success #=> Integer
resp.task.server_import_failure #=> Integer
resp.task.application_import_success #=> Integer
resp.task.application_import_failure #=> Integer
resp.task.errors_and_failed_entries_zip #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :client_request_token (String) —

    Optional. A unique token that you can provide to prevent the same import request from occurring more than once. If you don't provide a token, a token is automatically generated.

    Sending more than one StartImportTask request with the same client request token will return information about the original import task with that client request token.

    A suitable default value is auto-generated. You should normally not need to pass this option.**

  • :name (required, String) —

    A descriptive name for this request. You can use this name to filter future requests related to this import task, such as identifying applications and servers that were included in this import task. We recommend that you use a meaningful name for each import task.

  • :import_url (required, String) —

    The URL for your import file that you've uploaded to Amazon S3.

    If you're using the Amazon Web Services CLI, this URL is structured as follows: s3://BucketName/ImportFileName.CSV

Returns:



1746
1747
1748
1749
 
# File 'gems/aws-sdk-applicationdiscoveryservice/lib/aws-sdk-applicationdiscoveryservice/client.rb', line 1746

def start_import_task(params = {}, options = {})
  req = build_request(:start_import_task, params)
  req.send_request(options)
end

#stop_continuous_export(params = {}) ⇒ Types::StopContinuousExportResponse

Stop the continuous flow of agent's discovered data into Amazon Athena.

Examples:

Request syntax with placeholder values


resp = client.stop_continuous_export({
  export_id: "ConfigurationsExportId", # required
})

Response structure


resp.start_time #=> Time
resp.stop_time #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :export_id (required, String) —

    The unique ID assigned to this export.

Returns:



1775
1776
1777
1778
 
# File 'gems/aws-sdk-applicationdiscoveryservice/lib/aws-sdk-applicationdiscoveryservice/client.rb', line 1775

def stop_continuous_export(params = {}, options = {})
  req = build_request(:stop_continuous_export, params)
  req.send_request(options)
end

#stop_data_collection_by_agent_ids(params = {}) ⇒ Types::StopDataCollectionByAgentIdsResponse

Instructs the specified agents to stop collecting data.

Examples:

Request syntax with placeholder values


resp = client.stop_data_collection_by_agent_ids({
  agent_ids: ["AgentId"], # required
})

Response structure


resp.agents_configuration_status #=> Array
resp.agents_configuration_status[0].agent_id #=> String
resp.agents_configuration_status[0].operation_succeeded #=> Boolean
resp.agents_configuration_status[0].description #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :agent_ids (required, Array<String>) —

    The IDs of the agents from which to stop collecting data.

Returns:



1804
1805
1806
1807
 
# File 'gems/aws-sdk-applicationdiscoveryservice/lib/aws-sdk-applicationdiscoveryservice/client.rb', line 1804

def stop_data_collection_by_agent_ids(params = {}, options = {})
  req = build_request(:stop_data_collection_by_agent_ids, params)
  req.send_request(options)
end

#update_application(params = {}) ⇒ Struct

Updates metadata about an application.

Examples:

Request syntax with placeholder values


resp = client.update_application({
  configuration_id: "ApplicationId", # required
  name: "ApplicationName",
  description: "ApplicationDescription",
  wave: "ApplicationWave",
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :configuration_id (required, String) —

    Configuration ID of the application to be updated.

  • :name (String) —

    New name of the application to be updated.

  • :description (String) —

    New description of the application to be updated.

  • :wave (String) —

    The new migration wave of the application that you want to update.

Returns:

  • (Struct) —

    Returns an empty response.



1836
1837
1838
1839
 
# File 'gems/aws-sdk-applicationdiscoveryservice/lib/aws-sdk-applicationdiscoveryservice/client.rb', line 1836

def update_application(params = {}, options = {})
  req = build_request(:update_application, params)
  req.send_request(options)
end