Class: Aws::Deadline::Client

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

Overview

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

client = Aws::Deadline::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):

  • :credentials (required, Aws::CredentialProvider)

    Your AWS credentials. This can be an 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, and :session_token options.
    • ENV['AWS_ACCESS_KEY_ID'], ENV['AWS_SECRET_ACCESS_KEY']
    • ~/.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::InstanceProfileCredentails 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)
  • :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.

  • :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.

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

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

  • :disable_host_prefix_injection (Boolean) — default: false

    Set to true to disable SDK automatically adding host prefix to default service endpoint when available.

  • :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_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.

  • :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 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 - An experimental retry mode that includes all the functionality of standard mode along with automatic client side throttling. This is a provisional mode that may change behavior in the future.

  • :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)
  • :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.

  • :token_provider (Aws::TokenProvider)

    A Bearer Token Provider. This can be an 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::Deadline::EndpointProvider)

    The endpoint provider used to resolve endpoints. Any object that responds to #resolve_endpoint(parameters) where parameters is a Struct similar to Aws::Deadline::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_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.



410
411
412
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 410

def initialize(*args)
  super
end

Instance Method Details

#associate_member_to_farm(params = {}) ⇒ Struct

Assigns a farm membership level to a member.

Examples:

Request syntax with placeholder values


resp = client.associate_member_to_farm({
  farm_id: "FarmId", # required
  identity_store_id: "IdentityStoreId", # required
  membership_level: "VIEWER", # required, accepts VIEWER, CONTRIBUTOR, OWNER, MANAGER
  principal_id: "IdentityCenterPrincipalId", # required
  principal_type: "USER", # required, accepts USER, GROUP
})

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The ID of the farm to associate with the member.

  • :identity_store_id (required, String)

    The identity store ID of the member to associate with the farm.

  • :membership_level (required, String)

    The principal's membership level for the associated farm.

  • :principal_id (required, String)

    The member's principal ID to associate with the farm.

  • :principal_type (required, String)

    The principal type of the member to associate with the farm.

Returns:

  • (Struct)

    Returns an empty response.

See Also:



449
450
451
452
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 449

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

#associate_member_to_fleet(params = {}) ⇒ Struct

Assigns a fleet membership level to a member.

Examples:

Request syntax with placeholder values


resp = client.associate_member_to_fleet({
  farm_id: "FarmId", # required
  fleet_id: "FleetId", # required
  identity_store_id: "IdentityStoreId", # required
  membership_level: "VIEWER", # required, accepts VIEWER, CONTRIBUTOR, OWNER, MANAGER
  principal_id: "IdentityCenterPrincipalId", # required
  principal_type: "USER", # required, accepts USER, GROUP
})

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID of the fleet to associate with the member.

  • :fleet_id (required, String)

    The ID of the fleet to associate with a member.

  • :identity_store_id (required, String)

    The member's identity store ID to associate with the fleet.

  • :membership_level (required, String)

    The principal's membership level for the associated fleet.

  • :principal_id (required, String)

    The member's principal ID to associate with a fleet.

  • :principal_type (required, String)

    The member's principal type to associate with the fleet.

Returns:

  • (Struct)

    Returns an empty response.

See Also:



491
492
493
494
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 491

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

#associate_member_to_job(params = {}) ⇒ Struct

Assigns a job membership level to a member

Examples:

Request syntax with placeholder values


resp = client.associate_member_to_job({
  farm_id: "FarmId", # required
  identity_store_id: "IdentityStoreId", # required
  job_id: "JobId", # required
  membership_level: "VIEWER", # required, accepts VIEWER, CONTRIBUTOR, OWNER, MANAGER
  principal_id: "IdentityCenterPrincipalId", # required
  principal_type: "USER", # required, accepts USER, GROUP
  queue_id: "QueueId", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID of the job to associate with the member.

  • :identity_store_id (required, String)

    The member's identity store ID to associate with the job.

  • :job_id (required, String)

    The job ID to associate with the member.

  • :membership_level (required, String)

    The principal's membership level for the associated job.

  • :principal_id (required, String)

    The member's principal ID to associate with the job.

  • :principal_type (required, String)

    The member's principal type to associate with the job.

  • :queue_id (required, String)

    The queue ID to associate to the member.

Returns:

  • (Struct)

    Returns an empty response.

See Also:



537
538
539
540
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 537

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

#associate_member_to_queue(params = {}) ⇒ Struct

Assigns a queue membership level to a member

Examples:

Request syntax with placeholder values


resp = client.associate_member_to_queue({
  farm_id: "FarmId", # required
  identity_store_id: "IdentityStoreId", # required
  membership_level: "VIEWER", # required, accepts VIEWER, CONTRIBUTOR, OWNER, MANAGER
  principal_id: "IdentityCenterPrincipalId", # required
  principal_type: "USER", # required, accepts USER, GROUP
  queue_id: "QueueId", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID of the queue to associate with the member.

  • :identity_store_id (required, String)

    The member's identity store ID to associate with the queue.

  • :membership_level (required, String)

    The principal's membership level for the associated queue.

  • :principal_id (required, String)

    The member's principal ID to associate with the queue.

  • :principal_type (required, String)

    The member's principal type to associate with the queue.

  • :queue_id (required, String)

    The ID of the queue to associate to the member.

Returns:

  • (Struct)

    Returns an empty response.

See Also:



579
580
581
582
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 579

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

#assume_fleet_role_for_read(params = {}) ⇒ Types::AssumeFleetRoleForReadResponse

Get Amazon Web Services credentials from the fleet role. The IAM permissions of the credentials are scoped down to have read-only access.

Examples:

Request syntax with placeholder values


resp = client.assume_fleet_role_for_read({
  farm_id: "FarmId", # required
  fleet_id: "FleetId", # required
})

Response structure


resp.credentials.access_key_id #=> String
resp.credentials.expiration #=> Time
resp.credentials.secret_access_key #=> String
resp.credentials.session_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID for the fleet's farm.

  • :fleet_id (required, String)

    The fleet ID.

Returns:

See Also:



616
617
618
619
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 616

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

#assume_fleet_role_for_worker(params = {}) ⇒ Types::AssumeFleetRoleForWorkerResponse

Get credentials from the fleet role for a worker.

Examples:

Request syntax with placeholder values


resp = client.assume_fleet_role_for_worker({
  farm_id: "FarmId", # required
  fleet_id: "FleetId", # required
  worker_id: "WorkerId", # required
})

Response structure


resp.credentials.access_key_id #=> String
resp.credentials.expiration #=> Time
resp.credentials.secret_access_key #=> String
resp.credentials.session_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID for the fleet's farm.

  • :fleet_id (required, String)

    The fleet ID that contains the worker.

  • :worker_id (required, String)

    The ID of the worker assuming the fleet role.

Returns:

See Also:



655
656
657
658
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 655

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

#assume_queue_role_for_read(params = {}) ⇒ Types::AssumeQueueRoleForReadResponse

Gets Amazon Web Services credentials from the queue role. The IAM permissions of the credentials are scoped down to have read-only access.

Examples:

Request syntax with placeholder values


resp = client.assume_queue_role_for_read({
  farm_id: "FarmId", # required
  queue_id: "QueueId", # required
})

Response structure


resp.credentials.access_key_id #=> String
resp.credentials.expiration #=> Time
resp.credentials.secret_access_key #=> String
resp.credentials.session_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID of the farm containing the queue.

  • :queue_id (required, String)

    The queue ID.

Returns:

See Also:



692
693
694
695
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 692

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

#assume_queue_role_for_user(params = {}) ⇒ Types::AssumeQueueRoleForUserResponse

Allows a user to assume a role for a queue.

Examples:

Request syntax with placeholder values


resp = client.assume_queue_role_for_user({
  farm_id: "FarmId", # required
  queue_id: "QueueId", # required
})

Response structure


resp.credentials.access_key_id #=> String
resp.credentials.expiration #=> Time
resp.credentials.secret_access_key #=> String
resp.credentials.session_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID of the queue that the user assumes the role for.

  • :queue_id (required, String)

    The queue ID of the queue that the user assumes the role for.

Returns:

See Also:



727
728
729
730
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 727

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

#assume_queue_role_for_worker(params = {}) ⇒ Types::AssumeQueueRoleForWorkerResponse

Allows a worker to assume a queue role.

Examples:

Request syntax with placeholder values


resp = client.assume_queue_role_for_worker({
  farm_id: "FarmId", # required
  fleet_id: "FleetId", # required
  queue_id: "QueueId", # required
  worker_id: "WorkerId", # required
})

Response structure


resp.credentials.access_key_id #=> String
resp.credentials.expiration #=> Time
resp.credentials.secret_access_key #=> String
resp.credentials.session_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID of the worker assuming the queue role.

  • :fleet_id (required, String)

    The fleet ID of the worker assuming the queue role.

  • :queue_id (required, String)

    The queue ID of the worker assuming the queue role.

  • :worker_id (required, String)

    The worker ID of the worker assuming the queue role.

Returns:

See Also:



770
771
772
773
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 770

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

#batch_get_job_entity(params = {}) ⇒ Types::BatchGetJobEntityResponse

Get batched job details for a worker.

Examples:

Request syntax with placeholder values


resp = client.batch_get_job_entity({
  farm_id: "FarmId", # required
  fleet_id: "FleetId", # required
  identifiers: [ # required
    {
      environment_details: {
        environment_id: "EnvironmentId", # required
        job_id: "JobId", # required
      },
      job_attachment_details: {
        job_id: "JobId", # required
      },
      job_details: {
        job_id: "JobId", # required
      },
      step_details: {
        job_id: "JobId", # required
        step_id: "StepId", # required
      },
    },
  ],
  worker_id: "WorkerId", # required
})

Response structure


resp.entities #=> Array
resp.entities[0].environment_details.environment_id #=> String
resp.entities[0].environment_details.job_id #=> String
resp.entities[0].environment_details.schema_version #=> String
resp.entities[0].job_attachment_details.attachments.file_system #=> String, one of "COPIED", "VIRTUAL"
resp.entities[0].job_attachment_details.attachments.manifests #=> Array
resp.entities[0].job_attachment_details.attachments.manifests[0].file_system_location_name #=> String
resp.entities[0].job_attachment_details.attachments.manifests[0].input_manifest_hash #=> String
resp.entities[0].job_attachment_details.attachments.manifests[0].input_manifest_path #=> String
resp.entities[0].job_attachment_details.attachments.manifests[0].output_relative_directories #=> Array
resp.entities[0].job_attachment_details.attachments.manifests[0].output_relative_directories[0] #=> String
resp.entities[0].job_attachment_details.attachments.manifests[0].root_path #=> String
resp.entities[0].job_attachment_details.attachments.manifests[0].root_path_format #=> String, one of "windows", "posix"
resp.entities[0].job_attachment_details.job_id #=> String
resp.entities[0].job_details.job_attachment_settings.root_prefix #=> String
resp.entities[0].job_details.job_attachment_settings.s3_bucket_name #=> String
resp.entities[0].job_details.job_id #=> String
resp.entities[0].job_details.job_run_as_user.posix.group #=> String
resp.entities[0].job_details.job_run_as_user.posix.user #=> String
resp.entities[0].job_details.job_run_as_user.run_as #=> String, one of "QUEUE_CONFIGURED_USER", "WORKER_AGENT_USER"
resp.entities[0].job_details.job_run_as_user.windows.password_arn #=> String
resp.entities[0].job_details.job_run_as_user.windows.user #=> String
resp.entities[0].job_details.log_group_name #=> String
resp.entities[0].job_details.parameters #=> Hash
resp.entities[0].job_details.parameters["String"].float #=> String
resp.entities[0].job_details.parameters["String"].int #=> String
resp.entities[0].job_details.parameters["String"].path #=> String
resp.entities[0].job_details.parameters["String"].string #=> String
resp.entities[0].job_details.path_mapping_rules #=> Array
resp.entities[0].job_details.path_mapping_rules[0].destination_path #=> String
resp.entities[0].job_details.path_mapping_rules[0].source_path #=> String
resp.entities[0].job_details.path_mapping_rules[0].source_path_format #=> String, one of "windows", "posix"
resp.entities[0].job_details.queue_role_arn #=> String
resp.entities[0].job_details.schema_version #=> String
resp.entities[0].step_details.dependencies #=> Array
resp.entities[0].step_details.dependencies[0] #=> String
resp.entities[0].step_details.job_id #=> String
resp.entities[0].step_details.schema_version #=> String
resp.entities[0].step_details.step_id #=> String
resp.errors #=> Array
resp.errors[0].environment_details.code #=> String, one of "AccessDeniedException", "InternalServerException", "ValidationException", "ResourceNotFoundException", "MaxPayloadSizeExceeded", "ConflictException"
resp.errors[0].environment_details.environment_id #=> String
resp.errors[0].environment_details.job_id #=> String
resp.errors[0].environment_details.message #=> String
resp.errors[0].job_attachment_details.code #=> String, one of "AccessDeniedException", "InternalServerException", "ValidationException", "ResourceNotFoundException", "MaxPayloadSizeExceeded", "ConflictException"
resp.errors[0].job_attachment_details.job_id #=> String
resp.errors[0].job_attachment_details.message #=> String
resp.errors[0].job_details.code #=> String, one of "AccessDeniedException", "InternalServerException", "ValidationException", "ResourceNotFoundException", "MaxPayloadSizeExceeded", "ConflictException"
resp.errors[0].job_details.job_id #=> String
resp.errors[0].job_details.message #=> String
resp.errors[0].step_details.code #=> String, one of "AccessDeniedException", "InternalServerException", "ValidationException", "ResourceNotFoundException", "MaxPayloadSizeExceeded", "ConflictException"
resp.errors[0].step_details.job_id #=> String
resp.errors[0].step_details.message #=> String
resp.errors[0].step_details.step_id #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID of the worker that's fetching job details. The worker must have an assignment on a job to fetch job details.

  • :fleet_id (required, String)

    The fleet ID of the worker that's fetching job details. The worker must have an assignment on a job to fetch job details.

  • :identifiers (required, Array<Types::JobEntityIdentifiersUnion>)

    The job identifiers to include within the job entity batch details.

  • :worker_id (required, String)

    The worker ID of the worker containing the job details to get.

Returns:

See Also:



883
884
885
886
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 883

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

#copy_job_template(params = {}) ⇒ Types::CopyJobTemplateResponse

Copies a job template to an Amazon S3 bucket.

Examples:

Request syntax with placeholder values


resp = client.copy_job_template({
  farm_id: "FarmId", # required
  job_id: "JobId", # required
  queue_id: "QueueId", # required
  target_s3_location: { # required
    bucket_name: "S3BucketName", # required
    key: "S3Key", # required
  },
})

Response structure


resp.template_type #=> String, one of "JSON", "YAML"

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID to copy.

  • :job_id (required, String)

    The job ID to copy.

  • :queue_id (required, String)

    The queue ID to copy.

  • :target_s3_location (required, Types::S3Location)

    The Amazon S3 bucket name and key where you would like to add a copy of the job template.

Returns:

See Also:



927
928
929
930
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 927

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

#create_budget(params = {}) ⇒ Types::CreateBudgetResponse

Creates a budget to set spending thresholds for your rendering activity.

Examples:

Request syntax with placeholder values


resp = client.create_budget({
  actions: [ # required
    {
      description: "Description",
      threshold_percentage: 1.0, # required
      type: "STOP_SCHEDULING_AND_COMPLETE_TASKS", # required, accepts STOP_SCHEDULING_AND_COMPLETE_TASKS, STOP_SCHEDULING_AND_CANCEL_TASKS
    },
  ],
  approximate_dollar_limit: 1.0, # required
  client_token: "ClientToken",
  description: "Description",
  display_name: "ResourceName", # required
  farm_id: "FarmId", # required
  schedule: { # required
    fixed: {
      end_time: Time.now, # required
      start_time: Time.now, # required
    },
  },
  usage_tracking_resource: { # required
    queue_id: "QueueId",
  },
})

Response structure


resp.budget_id #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :actions (required, Array<Types::BudgetActionToAdd>)

    The budget actions to specify what happens when the budget runs out.

  • :approximate_dollar_limit (required, Float)

    The dollar limit based on consumed usage.

  • :client_token (String)

    The unique token which the server uses to recognize retries of the same request.

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

  • :description (String)

    The description of the budget.

  • :display_name (required, String)

    The display name of the budget.

  • :farm_id (required, String)

    The farm ID to include in this budget.

  • :schedule (required, Types::BudgetSchedule)

    The schedule to associate with this budget.

  • :usage_tracking_resource (required, Types::UsageTrackingResource)

    The queue ID provided to this budget to track usage.

Returns:

See Also:



1001
1002
1003
1004
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 1001

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

#create_farm(params = {}) ⇒ Types::CreateFarmResponse

Creates a farm to allow space for queues and fleets. Farms are the space where the components of your renders gather and are pieced together in the cloud. Farms contain budgets and allow you to enforce permissions. Deadline Cloud farms are a useful container for large projects.

Examples:

Request syntax with placeholder values


resp = client.create_farm({
  client_token: "ClientToken",
  description: "Description",
  display_name: "ResourceName", # required
  kms_key_arn: "KmsKeyArn",
  tags: {
    "String" => "String",
  },
})

Response structure


resp.farm_id #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :client_token (String)

    The unique token which the server uses to recognize retries of the same request.

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

  • :description (String)

    The description of the farm.

  • :display_name (required, String)

    The display name of the farm.

  • :kms_key_arn (String)

    The ARN of the KMS key to use on the farm.

  • :tags (Hash<String,String>)

    The tags to add to your farm. Each tag consists of a tag key and a tag value. Tag keys and values are both required, but tag values can be empty strings.

Returns:

See Also:



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

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

#create_fleet(params = {}) ⇒ Types::CreateFleetResponse

Creates a fleet. Fleets gather information relating to compute, or capacity, for renders within your farms. You can choose to manage your own capacity or opt to have fleets fully managed by Deadline Cloud.

Examples:

Request syntax with placeholder values


resp = client.create_fleet({
  client_token: "ClientToken",
  configuration: { # required
    customer_managed: {
      mode: "NO_SCALING", # required, accepts NO_SCALING, EVENT_BASED_AUTO_SCALING
      storage_profile_id: "StorageProfileId",
      worker_capabilities: { # required
        accelerator_count: {
          max: 1,
          min: 1, # required
        },
        accelerator_total_memory_mi_b: {
          max: 1,
          min: 1, # required
        },
        accelerator_types: ["gpu"], # accepts gpu
        cpu_architecture_type: "x86_64", # required, accepts x86_64, arm64
        custom_amounts: [
          {
            max: 1.0,
            min: 1.0, # required
            name: "AmountCapabilityName", # required
          },
        ],
        custom_attributes: [
          {
            name: "AttributeCapabilityName", # required
            values: ["AttributeCapabilityValue"], # required
          },
        ],
        memory_mi_b: { # required
          max: 1,
          min: 1, # required
        },
        os_family: "WINDOWS", # required, accepts WINDOWS, LINUX, MACOS
        v_cpu_count: { # required
          max: 1,
          min: 1, # required
        },
      },
    },
    service_managed_ec2: {
      instance_capabilities: { # required
        allowed_instance_types: ["InstanceType"],
        cpu_architecture_type: "x86_64", # required, accepts x86_64, arm64
        custom_amounts: [
          {
            max: 1.0,
            min: 1.0, # required
            name: "AmountCapabilityName", # required
          },
        ],
        custom_attributes: [
          {
            name: "AttributeCapabilityName", # required
            values: ["AttributeCapabilityValue"], # required
          },
        ],
        excluded_instance_types: ["InstanceType"],
        memory_mi_b: { # required
          max: 1,
          min: 1, # required
        },
        os_family: "WINDOWS", # required, accepts WINDOWS, LINUX
        root_ebs_volume: {
          iops: 1,
          size_gi_b: 1,
          throughput_mi_b: 1,
        },
        v_cpu_count: { # required
          max: 1,
          min: 1, # required
        },
      },
      instance_market_options: { # required
        type: "on-demand", # required, accepts on-demand, spot
      },
    },
  },
  description: "Description",
  display_name: "ResourceName", # required
  farm_id: "FarmId", # required
  max_worker_count: 1, # required
  min_worker_count: 1,
  role_arn: "IamRoleArn", # required
  tags: {
    "String" => "String",
  },
})

Response structure


resp.fleet_id #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :client_token (String)

    The unique token which the server uses to recognize retries of the same request.

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

  • :configuration (required, Types::FleetConfiguration)

    The configuration settings for the fleet. Customer managed fleets are self-managed. Service managed Amazon EC2 fleets are managed by Deadline Cloud.

  • :description (String)

    The description of the fleet.

  • :display_name (required, String)

    The display name of the fleet.

  • :farm_id (required, String)

    The farm ID of the farm to connect to the fleet.

  • :max_worker_count (required, Integer)

    The maximum number of workers for the fleet.

  • :min_worker_count (Integer)

    The minimum number of workers for the fleet.

  • :role_arn (required, String)

    The IAM role ARN for the role that the fleet's workers will use.

  • :tags (Hash<String,String>)

    Each tag consists of a tag key and a tag value. Tag keys and values are both required, but tag values can be empty strings.

Returns:

See Also:



1204
1205
1206
1207
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 1204

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

#create_job(params = {}) ⇒ Types::CreateJobResponse

Creates a job. A job is a render submission submitted by a user. It contains specific job properties outlined as steps and tasks.

Examples:

Request syntax with placeholder values


resp = client.create_job({
  attachments: {
    file_system: "COPIED", # accepts COPIED, VIRTUAL
    manifests: [ # required
      {
        file_system_location_name: "FileSystemLocationName",
        input_manifest_hash: "ManifestPropertiesInputManifestHashString",
        input_manifest_path: "ManifestPropertiesInputManifestPathString",
        output_relative_directories: ["OutputRelativeDirectoriesListMemberString"],
        root_path: "ManifestPropertiesRootPathString", # required
        root_path_format: "windows", # required, accepts windows, posix
      },
    ],
  },
  client_token: "ClientToken",
  farm_id: "FarmId", # required
  max_failed_tasks_count: 1,
  max_retries_per_task: 1,
  parameters: {
    "String" => {
      float: "FloatString",
      int: "IntString",
      path: "PathString",
      string: "ParameterString",
    },
  },
  priority: 1, # required
  queue_id: "QueueId", # required
  storage_profile_id: "StorageProfileId",
  target_task_run_status: "READY", # accepts READY, SUSPENDED
  template: "JobTemplate", # required
  template_type: "JSON", # required, accepts JSON, YAML
})

Response structure


resp.job_id #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :attachments (Types::Attachments)

    The attachments for the job. Attach files required for the job to run to a render job.

  • :client_token (String)

    The unique token which the server uses to recognize retries of the same request.

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

  • :farm_id (required, String)

    The farm ID of the farm to connect to the job.

  • :max_failed_tasks_count (Integer)

    The number of task failures before the job stops running and is marked as FAILED.

  • :max_retries_per_task (Integer)

    The maximum number of retries for a job.

  • :parameters (Hash<String,Types::JobParameter>)

    The parameters for the job.

  • :priority (required, Integer)

    The priority of the job on a scale of 1 to 100. The highest priority is 1.

  • :queue_id (required, String)

    The ID of the queue that the job is submitted to.

  • :storage_profile_id (String)

    The storage profile ID for the storage profile to connect to the job.

  • :target_task_run_status (String)

    The initial status of the job's tasks when they are created. Tasks that are created with a SUSPENDED status will not run until you update their status.

  • :template (required, String)

    The job template to use for this job.

  • :template_type (required, String)

    The file type for the job template.

Returns:

See Also:



1305
1306
1307
1308
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 1305

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

#create_license_endpoint(params = {}) ⇒ Types::CreateLicenseEndpointResponse

Creates a license endpoint to integrate your various licensed software used for rendering on Deadline Cloud.

Examples:

Request syntax with placeholder values


resp = client.create_license_endpoint({
  client_token: "ClientToken",
  security_group_ids: ["SecurityGroupId"], # required
  subnet_ids: ["SubnetId"], # required
  tags: {
    "String" => "String",
  },
  vpc_id: "VpcId", # required
})

Response structure


resp.license_endpoint_id #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :client_token (String)

    The unique token which the server uses to recognize retries of the same request.

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

  • :security_group_ids (required, Array<String>)

    The security group IDs.

  • :subnet_ids (required, Array<String>)

    The subnet IDs.

  • :tags (Hash<String,String>)

    Each tag consists of a tag key and a tag value. Tag keys and values are both required, but tag values can be empty strings.

  • :vpc_id (required, String)

    The VPC (virtual private cloud) ID to use with the license endpoint.

Returns:

See Also:



1357
1358
1359
1360
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 1357

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

#create_monitor(params = {}) ⇒ Types::CreateMonitorResponse

Creates an Amazon Web Services Deadline Cloud monitor that you can use to view your farms, queues, and fleets. After you submit a job, you can track the progress of the tasks and steps that make up the job, and then download the job's results.

Examples:

Request syntax with placeholder values


resp = client.create_monitor({
  client_token: "ClientToken",
  display_name: "ResourceName", # required
  identity_center_instance_arn: "IdentityCenterInstanceArn", # required
  role_arn: "IamRoleArn", # required
  subdomain: "Subdomain", # required
})

Response structure


resp.identity_center_application_arn #=> String
resp.monitor_id #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :client_token (String)

    The unique token which the server uses to recognize retries of the same request.

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

  • :display_name (required, String)

    The name that you give the monitor that is displayed in the Deadline Cloud console.

  • :identity_center_instance_arn (required, String)

    The Amazon Resource Name (ARN) of the IAM Identity Center instance that authenticates monitor users.

  • :role_arn (required, String)

    The Amazon Resource Name (ARN) of the IAM role that the monitor uses to connect to Deadline Cloud. Every user that signs in to the monitor using IAM Identity Center uses this role to access Deadline Cloud resources.

  • :subdomain (required, String)

    The subdomain to use when creating the monitor URL. The full URL of the monitor is subdomain.Region.deadlinecloud.amazonaws.com.

Returns:

See Also:



1416
1417
1418
1419
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 1416

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

#create_queue(params = {}) ⇒ Types::CreateQueueResponse

Creates a queue to coordinate the order in which jobs run on a farm. A queue can also specify where to pull resources and indicate where to output completed jobs.

Examples:

Request syntax with placeholder values


resp = client.create_queue({
  allowed_storage_profile_ids: ["StorageProfileId"],
  client_token: "ClientToken",
  default_budget_action: "NONE", # accepts NONE, STOP_SCHEDULING_AND_COMPLETE_TASKS, STOP_SCHEDULING_AND_CANCEL_TASKS
  description: "Description",
  display_name: "ResourceName", # required
  farm_id: "FarmId", # required
  job_attachment_settings: {
    root_prefix: "S3Prefix", # required
    s3_bucket_name: "S3BucketName", # required
  },
  job_run_as_user: {
    posix: {
      group: "PosixUserGroupString", # required
      user: "PosixUserUserString", # required
    },
    run_as: "QUEUE_CONFIGURED_USER", # required, accepts QUEUE_CONFIGURED_USER, WORKER_AGENT_USER
    windows: {
      password_arn: "WindowsUserPasswordArnString", # required
      user: "WindowsUserUserString", # required
    },
  },
  required_file_system_location_names: ["FileSystemLocationName"],
  role_arn: "IamRoleArn",
  tags: {
    "String" => "String",
  },
})

Response structure


resp.queue_id #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :allowed_storage_profile_ids (Array<String>)

    The storage profile IDs to include in the queue.

  • :client_token (String)

    The unique token which the server uses to recognize retries of the same request.

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

  • :default_budget_action (String)

    The default action to take on a queue if a budget isn't configured.

  • :description (String)

    The description of the queue.

  • :display_name (required, String)

    The display name of the queue.

  • :farm_id (required, String)

    The farm ID of the farm to connect to the queue.

  • :job_attachment_settings (Types::JobAttachmentSettings)

    The job attachment settings for the queue. These are the Amazon S3 bucket name and the Amazon S3 prefix.

  • :job_run_as_user (Types::JobRunAsUser)

    The jobs in the queue run as the specified POSIX user.

  • :required_file_system_location_names (Array<String>)

    The file system location name to include in the queue.

  • :role_arn (String)

    The IAM role ARN that workers will use while running jobs for this queue.

  • :tags (Hash<String,String>)

    Each tag consists of a tag key and a tag value. Tag keys and values are both required, but tag values can be empty strings.

Returns:

See Also:



1508
1509
1510
1511
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 1508

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

#create_queue_environment(params = {}) ⇒ Types::CreateQueueEnvironmentResponse

Creates an environment for a queue that defines how jobs in the queue run.

Examples:

Request syntax with placeholder values


resp = client.create_queue_environment({
  client_token: "ClientToken",
  farm_id: "FarmId", # required
  priority: 1, # required
  queue_id: "QueueId", # required
  template: "EnvironmentTemplate", # required
  template_type: "JSON", # required, accepts JSON, YAML
})

Response structure


resp.queue_environment_id #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :client_token (String)

    The unique token which the server uses to recognize retries of the same request.

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

  • :farm_id (required, String)

    The farm ID of the farm to connect to the environment.

  • :priority (required, Integer)

    Sets the priority of the environments in the queue from 0 to 10,000, where 0 is the highest priority. If two environments share the same priority value, the environment created first takes higher priority.

  • :queue_id (required, String)

    The queue ID to connect the queue and environment.

  • :template (required, String)

    The environment template to use in the queue.

  • :template_type (required, String)

    The template's file type, JSON or YAML.

Returns:

See Also:



1563
1564
1565
1566
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 1563

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

#create_queue_fleet_association(params = {}) ⇒ Struct

Creates an association between a queue and a fleet.

Examples:

Request syntax with placeholder values


resp = client.create_queue_fleet_association({
  farm_id: "FarmId", # required
  fleet_id: "FleetId", # required
  queue_id: "QueueId", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The ID of the farm that the queue and fleet belong to.

  • :fleet_id (required, String)

    The fleet ID.

  • :queue_id (required, String)

    The queue ID.

Returns:

  • (Struct)

    Returns an empty response.

See Also:



1593
1594
1595
1596
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 1593

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

#create_storage_profile(params = {}) ⇒ Types::CreateStorageProfileResponse

Creates a storage profile that specifies the operating system, file type, and file location of resources used on a farm.

Examples:

Request syntax with placeholder values


resp = client.create_storage_profile({
  client_token: "ClientToken",
  display_name: "ResourceName", # required
  farm_id: "FarmId", # required
  file_system_locations: [
    {
      name: "FileSystemLocationName", # required
      path: "PathString", # required
      type: "SHARED", # required, accepts SHARED, LOCAL
    },
  ],
  os_family: "WINDOWS", # required, accepts WINDOWS, LINUX, MACOS
})

Response structure


resp.storage_profile_id #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :client_token (String)

    The unique token which the server uses to recognize retries of the same request.

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

  • :display_name (required, String)

    The display name of the storage profile.

  • :farm_id (required, String)

    The farm ID of the farm to connect to the storage profile.

  • :file_system_locations (Array<Types::FileSystemLocation>)

    File system paths to include in the storage profile.

  • :os_family (required, String)

    The type of operating system (OS) for the storage profile.

Returns:

See Also:



1648
1649
1650
1651
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 1648

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

#create_worker(params = {}) ⇒ Types::CreateWorkerResponse

Creates a worker. A worker tells your instance how much processing power (vCPU), and memory (GiB) you’ll need to assemble the digital assets held within a particular instance. You can specify certain instance types to use, or let the worker know which instances types to exclude.

Examples:

Request syntax with placeholder values


resp = client.create_worker({
  client_token: "ClientToken",
  farm_id: "FarmId", # required
  fleet_id: "FleetId", # required
  host_properties: {
    host_name: "HostName",
    ip_addresses: {
      ip_v4_addresses: ["IpV4Address"],
      ip_v6_addresses: ["IpV6Address"],
    },
  },
})

Response structure


resp.worker_id #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :client_token (String)

    The unique token which the server uses to recognize retries of the same request.

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

  • :farm_id (required, String)

    The farm ID of the farm to connect to the worker.

  • :fleet_id (required, String)

    The fleet ID to connect to the worker.

  • :host_properties (Types::HostPropertiesRequest)

    The IP address and host name of the worker.

Returns:

See Also:



1702
1703
1704
1705
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 1702

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

#delete_budget(params = {}) ⇒ Struct

Deletes a budget.

Examples:

Request syntax with placeholder values


resp = client.delete_budget({
  budget_id: "BudgetId", # required
  farm_id: "FarmId", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :budget_id (required, String)

    The budget ID of the budget to delete.

  • :farm_id (required, String)

    The farm ID of the farm to remove from the budget.

Returns:

  • (Struct)

    Returns an empty response.

See Also:



1728
1729
1730
1731
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 1728

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

#delete_farm(params = {}) ⇒ Struct

Deletes a farm.

Examples:

Request syntax with placeholder values


resp = client.delete_farm({
  farm_id: "FarmId", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID of the farm to delete.

Returns:

  • (Struct)

    Returns an empty response.

See Also:



1750
1751
1752
1753
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 1750

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

#delete_fleet(params = {}) ⇒ Struct

Deletes a fleet.

Examples:

Request syntax with placeholder values


resp = client.delete_fleet({
  client_token: "ClientToken",
  farm_id: "FarmId", # required
  fleet_id: "FleetId", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :client_token (String)

    The unique token which the server uses to recognize retries of the same request.

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

  • :farm_id (required, String)

    The farm ID of the farm to remove from the fleet.

  • :fleet_id (required, String)

    The fleet ID of the fleet to delete.

Returns:

  • (Struct)

    Returns an empty response.

See Also:



1784
1785
1786
1787
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 1784

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

#delete_license_endpoint(params = {}) ⇒ Struct

Deletes a license endpoint.

Examples:

Request syntax with placeholder values


resp = client.delete_license_endpoint({
  license_endpoint_id: "LicenseEndpointId", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :license_endpoint_id (required, String)

    The license endpoint ID of the license endpoint to delete.

Returns:

  • (Struct)

    Returns an empty response.

See Also:



1806
1807
1808
1809
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 1806

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

#delete_metered_product(params = {}) ⇒ Struct

Deletes a metered product.

Examples:

Request syntax with placeholder values


resp = client.delete_metered_product({
  license_endpoint_id: "LicenseEndpointId", # required
  product_id: "MeteredProductId", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :license_endpoint_id (required, String)

    The ID of the license endpoint from which to remove the metered product.

  • :product_id (required, String)

    The product ID to remove from the license endpoint.

Returns:

  • (Struct)

    Returns an empty response.

See Also:



1833
1834
1835
1836
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 1833

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

#delete_monitor(params = {}) ⇒ Struct

Removes a Deadline Cloud monitor. After you delete a monitor, you can create a new one and attach farms to the monitor.

Examples:

Request syntax with placeholder values


resp = client.delete_monitor({
  monitor_id: "MonitorId", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :monitor_id (required, String)

    The unique identifier of the monitor to delete. This ID is returned by the CreateMonitor operation, and is included in the response to the GetMonitor operation.

Returns:

  • (Struct)

    Returns an empty response.

See Also:



1858
1859
1860
1861
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 1858

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

#delete_queue(params = {}) ⇒ Struct

Deletes a queue.

Examples:

Request syntax with placeholder values


resp = client.delete_queue({
  farm_id: "FarmId", # required
  queue_id: "QueueId", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The ID of the farm from which to remove the queue.

  • :queue_id (required, String)

    The queue ID of the queue to delete.

Returns:

  • (Struct)

    Returns an empty response.

See Also:



1884
1885
1886
1887
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 1884

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

#delete_queue_environment(params = {}) ⇒ Struct

Deletes a queue environment.

Examples:

Request syntax with placeholder values


resp = client.delete_queue_environment({
  farm_id: "FarmId", # required
  queue_environment_id: "QueueEnvironmentId", # required
  queue_id: "QueueId", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID of the farm from which to remove the queue environment.

  • :queue_environment_id (required, String)

    The queue environment ID of the queue environment to delete.

  • :queue_id (required, String)

    The queue ID of the queue environment to delete.

Returns:

  • (Struct)

    Returns an empty response.

See Also:



1914
1915
1916
1917
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 1914

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

#delete_queue_fleet_association(params = {}) ⇒ Struct

Deletes a queue-fleet association.

Examples:

Request syntax with placeholder values


resp = client.delete_queue_fleet_association({
  farm_id: "FarmId", # required
  fleet_id: "FleetId", # required
  queue_id: "QueueId", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID of the farm that holds the queue-fleet association.

  • :fleet_id (required, String)

    The fleet ID of the queue-fleet association.

  • :queue_id (required, String)

    The queue ID of the queue-fleet association.

Returns:

  • (Struct)

    Returns an empty response.

See Also:



1944
1945
1946
1947
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 1944

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

#delete_storage_profile(params = {}) ⇒ Struct

Deletes a storage profile.

Examples:

Request syntax with placeholder values


resp = client.delete_storage_profile({
  farm_id: "FarmId", # required
  storage_profile_id: "StorageProfileId", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID of the farm from which to remove the storage profile.

  • :storage_profile_id (required, String)

    The storage profile ID of the storage profile to delete.

Returns:

  • (Struct)

    Returns an empty response.

See Also:



1970
1971
1972
1973
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 1970

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

#delete_worker(params = {}) ⇒ Struct

Deletes a worker.

Examples:

Request syntax with placeholder values


resp = client.delete_worker({
  farm_id: "FarmId", # required
  fleet_id: "FleetId", # required
  worker_id: "WorkerId", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID of the worker to delete.

  • :fleet_id (required, String)

    The fleet ID of the worker to delete.

  • :worker_id (required, String)

    The worker ID of the worker to delete.

Returns:

  • (Struct)

    Returns an empty response.

See Also:



2000
2001
2002
2003
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 2000

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

#disassociate_member_from_farm(params = {}) ⇒ Struct

Disassociates a member from a farm.

Examples:

Request syntax with placeholder values


resp = client.disassociate_member_from_farm({
  farm_id: "FarmId", # required
  principal_id: "IdentityCenterPrincipalId", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID of the farm to disassociate from the member.

  • :principal_id (required, String)

    A member's principal ID to disassociate from a farm.

Returns:

  • (Struct)

    Returns an empty response.

See Also:



2026
2027
2028
2029
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 2026

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

#disassociate_member_from_fleet(params = {}) ⇒ Struct

Disassociates a member from a fleet.

Examples:

Request syntax with placeholder values


resp = client.disassociate_member_from_fleet({
  farm_id: "FarmId", # required
  fleet_id: "FleetId", # required
  principal_id: "IdentityCenterPrincipalId", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID of the fleet to disassociate a member from.

  • :fleet_id (required, String)

    The fleet ID of the fleet to from which to disassociate a member.

  • :principal_id (required, String)

    A member's principal ID to disassociate from a fleet.

Returns:

  • (Struct)

    Returns an empty response.

See Also:



2056
2057
2058
2059
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 2056

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

#disassociate_member_from_job(params = {}) ⇒ Struct

Disassociates a member from a job.

Examples:

Request syntax with placeholder values


resp = client.disassociate_member_from_job({
  farm_id: "FarmId", # required
  job_id: "JobId", # required
  principal_id: "IdentityCenterPrincipalId", # required
  queue_id: "QueueId", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID for the job to disassociate from the member.

  • :job_id (required, String)

    The job ID to disassociate from a member in a job.

  • :principal_id (required, String)

    A member's principal ID to disassociate from a job.

  • :queue_id (required, String)

    The queue ID connected to a job for which you're disassociating a member.

Returns:

  • (Struct)

    Returns an empty response.

See Also:



2091
2092
2093
2094
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 2091

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

#disassociate_member_from_queue(params = {}) ⇒ Struct

Disassociates a member from a queue.

Examples:

Request syntax with placeholder values


resp = client.disassociate_member_from_queue({
  farm_id: "FarmId", # required
  principal_id: "IdentityCenterPrincipalId", # required
  queue_id: "QueueId", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID for the queue to disassociate from a member.

  • :principal_id (required, String)

    A member's principal ID to disassociate from a queue.

  • :queue_id (required, String)

    The queue ID of the queue in which you're disassociating from a member.

Returns:

  • (Struct)

    Returns an empty response.

See Also:



2122
2123
2124
2125
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 2122

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

#get_budget(params = {}) ⇒ Types::GetBudgetResponse

Get a budget.

Examples:

Request syntax with placeholder values


resp = client.get_budget({
  budget_id: "BudgetId", # required
  farm_id: "FarmId", # required
})

Response structure


resp.actions #=> Array
resp.actions[0].description #=> String
resp.actions[0].threshold_percentage #=> Float
resp.actions[0].type #=> String, one of "STOP_SCHEDULING_AND_COMPLETE_TASKS", "STOP_SCHEDULING_AND_CANCEL_TASKS"
resp.approximate_dollar_limit #=> Float
resp.budget_id #=> String
resp.created_at #=> Time
resp.created_by #=> String
resp.description #=> String
resp.display_name #=> String
resp.queue_stopped_at #=> Time
resp.schedule.fixed.end_time #=> Time
resp.schedule.fixed.start_time #=> Time
resp.status #=> String, one of "ACTIVE", "INACTIVE"
resp.updated_at #=> Time
resp.updated_by #=> String
resp.usage_tracking_resource.queue_id #=> String
resp.usages.approximate_dollar_usage #=> Float

Parameters:

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

    ({})

Options Hash (params):

  • :budget_id (required, String)

    The budget ID.

  • :farm_id (required, String)

    The farm ID of the farm connected to the budget.

Returns:

See Also:



2184
2185
2186
2187
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 2184

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

#get_farm(params = {}) ⇒ Types::GetFarmResponse

Get a farm.

Examples:

Request syntax with placeholder values


resp = client.get_farm({
  farm_id: "FarmId", # required
})

Response structure


resp.created_at #=> Time
resp.created_by #=> String
resp.description #=> String
resp.display_name #=> String
resp.farm_id #=> String
resp.kms_key_arn #=> String
resp.updated_at #=> Time
resp.updated_by #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID of the farm.

Returns:

See Also:



2226
2227
2228
2229
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 2226

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

#get_fleet(params = {}) ⇒ Types::GetFleetResponse

Get a fleet.

The following waiters are defined for this operation (see #wait_until for detailed usage):

  • fleet_active

Examples:

Request syntax with placeholder values


resp = client.get_fleet({
  farm_id: "FarmId", # required
  fleet_id: "FleetId", # required
})

Response structure


resp.auto_scaling_status #=> String, one of "GROWING", "STEADY", "SHRINKING"
resp.capabilities.amounts #=> Array
resp.capabilities.amounts[0].max #=> Float
resp.capabilities.amounts[0].min #=> Float
resp.capabilities.amounts[0].name #=> String
resp.capabilities.attributes #=> Array
resp.capabilities.attributes[0].name #=> String
resp.capabilities.attributes[0].values #=> Array
resp.capabilities.attributes[0].values[0] #=> String
resp.configuration.customer_managed.mode #=> String, one of "NO_SCALING", "EVENT_BASED_AUTO_SCALING"
resp.configuration.customer_managed.storage_profile_id #=> String
resp.configuration.customer_managed.worker_capabilities.accelerator_count.max #=> Integer
resp.configuration.customer_managed.worker_capabilities.accelerator_count.min #=> Integer
resp.configuration.customer_managed.worker_capabilities.accelerator_total_memory_mi_b.max #=> Integer
resp.configuration.customer_managed.worker_capabilities.accelerator_total_memory_mi_b.min #=> Integer
resp.configuration.customer_managed.worker_capabilities.accelerator_types #=> Array
resp.configuration.customer_managed.worker_capabilities.accelerator_types[0] #=> String, one of "gpu"
resp.configuration.customer_managed.worker_capabilities.cpu_architecture_type #=> String, one of "x86_64", "arm64"
resp.configuration.customer_managed.worker_capabilities.custom_amounts #=> Array
resp.configuration.customer_managed.worker_capabilities.custom_amounts[0].max #=> Float
resp.configuration.customer_managed.worker_capabilities.custom_amounts[0].min #=> Float
resp.configuration.customer_managed.worker_capabilities.custom_amounts[0].name #=> String
resp.configuration.customer_managed.worker_capabilities.custom_attributes #=> Array
resp.configuration.customer_managed.worker_capabilities.custom_attributes[0].name #=> String
resp.configuration.customer_managed.worker_capabilities.custom_attributes[0].values #=> Array
resp.configuration.customer_managed.worker_capabilities.custom_attributes[0].values[0] #=> String
resp.configuration.customer_managed.worker_capabilities.memory_mi_b.max #=> Integer
resp.configuration.customer_managed.worker_capabilities.memory_mi_b.min #=> Integer
resp.configuration.customer_managed.worker_capabilities.os_family #=> String, one of "WINDOWS", "LINUX", "MACOS"
resp.configuration.customer_managed.worker_capabilities.v_cpu_count.max #=> Integer
resp.configuration.customer_managed.worker_capabilities.v_cpu_count.min #=> Integer
resp.configuration.service_managed_ec2.instance_capabilities.allowed_instance_types #=> Array
resp.configuration.service_managed_ec2.instance_capabilities.allowed_instance_types[0] #=> String
resp.configuration.service_managed_ec2.instance_capabilities.cpu_architecture_type #=> String, one of "x86_64", "arm64"
resp.configuration.service_managed_ec2.instance_capabilities.custom_amounts #=> Array
resp.configuration.service_managed_ec2.instance_capabilities.custom_amounts[0].max #=> Float
resp.configuration.service_managed_ec2.instance_capabilities.custom_amounts[0].min #=> Float
resp.configuration.service_managed_ec2.instance_capabilities.custom_amounts[0].name #=> String
resp.configuration.service_managed_ec2.instance_capabilities.custom_attributes #=> Array
resp.configuration.service_managed_ec2.instance_capabilities.custom_attributes[0].name #=> String
resp.configuration.service_managed_ec2.instance_capabilities.custom_attributes[0].values #=> Array
resp.configuration.service_managed_ec2.instance_capabilities.custom_attributes[0].values[0] #=> String
resp.configuration.service_managed_ec2.instance_capabilities.excluded_instance_types #=> Array
resp.configuration.service_managed_ec2.instance_capabilities.excluded_instance_types[0] #=> String
resp.configuration.service_managed_ec2.instance_capabilities.memory_mi_b.max #=> Integer
resp.configuration.service_managed_ec2.instance_capabilities.memory_mi_b.min #=> Integer
resp.configuration.service_managed_ec2.instance_capabilities.os_family #=> String, one of "WINDOWS", "LINUX"
resp.configuration.service_managed_ec2.instance_capabilities.root_ebs_volume.iops #=> Integer
resp.configuration.service_managed_ec2.instance_capabilities.root_ebs_volume.size_gi_b #=> Integer
resp.configuration.service_managed_ec2.instance_capabilities.root_ebs_volume.throughput_mi_b #=> Integer
resp.configuration.service_managed_ec2.instance_capabilities.v_cpu_count.max #=> Integer
resp.configuration.service_managed_ec2.instance_capabilities.v_cpu_count.min #=> Integer
resp.configuration.service_managed_ec2.instance_market_options.type #=> String, one of "on-demand", "spot"
resp.created_at #=> Time
resp.created_by #=> String
resp.description #=> String
resp.display_name #=> String
resp.farm_id #=> String
resp.fleet_id #=> String
resp.max_worker_count #=> Integer
resp.min_worker_count #=> Integer
resp.role_arn #=> String
resp.status #=> String, one of "ACTIVE", "CREATE_IN_PROGRESS", "UPDATE_IN_PROGRESS", "CREATE_FAILED", "UPDATE_FAILED"
resp.target_worker_count #=> Integer
resp.updated_at #=> Time
resp.updated_by #=> String
resp.worker_count #=> Integer

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID of the farm in the fleet.

  • :fleet_id (required, String)

    The fleet ID of the fleet to get.

Returns:

See Also:



2345
2346
2347
2348
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 2345

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

#get_job(params = {}) ⇒ Types::GetJobResponse

Gets a Deadline Cloud job.

The following waiters are defined for this operation (see #wait_until for detailed usage):

  • job_create_complete

Examples:

Request syntax with placeholder values


resp = client.get_job({
  farm_id: "FarmId", # required
  job_id: "JobId", # required
  queue_id: "QueueId", # required
})

Response structure


resp.attachments.file_system #=> String, one of "COPIED", "VIRTUAL"
resp.attachments.manifests #=> Array
resp.attachments.manifests[0].file_system_location_name #=> String
resp.attachments.manifests[0].input_manifest_hash #=> String
resp.attachments.manifests[0].input_manifest_path #=> String
resp.attachments.manifests[0].output_relative_directories #=> Array
resp.attachments.manifests[0].output_relative_directories[0] #=> String
resp.attachments.manifests[0].root_path #=> String
resp.attachments.manifests[0].root_path_format #=> String, one of "windows", "posix"
resp.created_at #=> Time
resp.created_by #=> String
resp.description #=> String
resp.ended_at #=> Time
resp.job_id #=> String
resp.lifecycle_status #=> String, one of "CREATE_IN_PROGRESS", "CREATE_FAILED", "CREATE_COMPLETE", "UPLOAD_IN_PROGRESS", "UPLOAD_FAILED", "UPDATE_IN_PROGRESS", "UPDATE_FAILED", "UPDATE_SUCCEEDED", "ARCHIVED"
resp.lifecycle_status_message #=> String
resp.max_failed_tasks_count #=> Integer
resp.max_retries_per_task #=> Integer
resp.name #=> String
resp.parameters #=> Hash
resp.parameters["String"].float #=> String
resp.parameters["String"].int #=> String
resp.parameters["String"].path #=> String
resp.parameters["String"].string #=> String
resp.priority #=> Integer
resp.started_at #=> Time
resp.storage_profile_id #=> String
resp.target_task_run_status #=> String, one of "READY", "FAILED", "SUCCEEDED", "CANCELED", "SUSPENDED", "PENDING"
resp.task_run_status #=> String, one of "PENDING", "READY", "ASSIGNED", "STARTING", "SCHEDULED", "INTERRUPTING", "RUNNING", "SUSPENDED", "CANCELED", "FAILED", "SUCCEEDED", "NOT_COMPATIBLE"
resp.task_run_status_counts #=> Hash
resp.task_run_status_counts["TaskRunStatus"] #=> Integer
resp.updated_at #=> Time
resp.updated_by #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID of the farm in the job.

  • :job_id (required, String)

    The job ID.

  • :queue_id (required, String)

    The queue ID associated with the job.

Returns:

See Also:



2437
2438
2439
2440
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 2437

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

#get_license_endpoint(params = {}) ⇒ Types::GetLicenseEndpointResponse

Gets a licence endpoint.

The following waiters are defined for this operation (see #wait_until for detailed usage):

  • license_endpoint_deleted
  • license_endpoint_valid

Examples:

Request syntax with placeholder values


resp = client.get_license_endpoint({
  license_endpoint_id: "LicenseEndpointId", # required
})

Response structure


resp.dns_name #=> String
resp.license_endpoint_id #=> String
resp.security_group_ids #=> Array
resp.security_group_ids[0] #=> String
resp.status #=> String, one of "CREATE_IN_PROGRESS", "DELETE_IN_PROGRESS", "READY", "NOT_READY"
resp.status_message #=> String
resp.subnet_ids #=> Array
resp.subnet_ids[0] #=> String
resp.vpc_id #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :license_endpoint_id (required, String)

    The license endpoint ID.

Returns:

See Also:



2485
2486
2487
2488
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 2485

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

#get_monitor(params = {}) ⇒ Types::GetMonitorResponse

Gets information about the specified monitor.

Examples:

Request syntax with placeholder values


resp = client.get_monitor({
  monitor_id: "MonitorId", # required
})

Response structure


resp.created_at #=> Time
resp.created_by #=> String
resp.display_name #=> String
resp.identity_center_application_arn #=> String
resp.identity_center_instance_arn #=> String
resp.monitor_id #=> String
resp.role_arn #=> String
resp.subdomain #=> String
resp.updated_at #=> Time
resp.updated_by #=> String
resp.url #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :monitor_id (required, String)

    The unique identifier for the monitor. This ID is returned by the CreateMonitor operation.

Returns:

See Also:



2534
2535
2536
2537
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 2534

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

#get_queue(params = {}) ⇒ Types::GetQueueResponse

Gets a queue.

The following waiters are defined for this operation (see #wait_until for detailed usage):

  • queue_scheduling
  • queue_scheduling_blocked

Examples:

Request syntax with placeholder values


resp = client.get_queue({
  farm_id: "FarmId", # required
  queue_id: "QueueId", # required
})

Response structure


resp.allowed_storage_profile_ids #=> Array
resp.allowed_storage_profile_ids[0] #=> String
resp.blocked_reason #=> String, one of "NO_BUDGET_CONFIGURED", "BUDGET_THRESHOLD_REACHED"
resp.created_at #=> Time
resp.created_by #=> String
resp.default_budget_action #=> String, one of "NONE", "STOP_SCHEDULING_AND_COMPLETE_TASKS", "STOP_SCHEDULING_AND_CANCEL_TASKS"
resp.description #=> String
resp.display_name #=> String
resp.farm_id #=> String
resp.job_attachment_settings.root_prefix #=> String
resp.job_attachment_settings.s3_bucket_name #=> String
resp.job_run_as_user.posix.group #=> String
resp.job_run_as_user.posix.user #=> String
resp.job_run_as_user.run_as #=> String, one of "QUEUE_CONFIGURED_USER", "WORKER_AGENT_USER"
resp.job_run_as_user.windows.password_arn #=> String
resp.job_run_as_user.windows.user #=> String
resp.queue_id #=> String
resp.required_file_system_location_names #=> Array
resp.required_file_system_location_names[0] #=> String
resp.role_arn #=> String
resp.status #=> String, one of "IDLE", "SCHEDULING", "SCHEDULING_BLOCKED"
resp.updated_at #=> Time
resp.updated_by #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID of the farm in the queue.

  • :queue_id (required, String)

    The queue ID for the queue to retrieve.

Returns:

See Also:



2609
2610
2611
2612
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 2609

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

#get_queue_environment(params = {}) ⇒ Types::GetQueueEnvironmentResponse

Gets a queue environment.

Examples:

Request syntax with placeholder values


resp = client.get_queue_environment({
  farm_id: "FarmId", # required
  queue_environment_id: "QueueEnvironmentId", # required
  queue_id: "QueueId", # required
})

Response structure


resp.created_at #=> Time
resp.created_by #=> String
resp.name #=> String
resp.priority #=> Integer
resp.queue_environment_id #=> String
resp.template #=> String
resp.template_type #=> String, one of "JSON", "YAML"
resp.updated_at #=> Time
resp.updated_by #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID for the queue environment.

  • :queue_environment_id (required, String)

    The queue environment ID.

  • :queue_id (required, String)

    The queue ID for the queue environment.

Returns:

See Also:



2661
2662
2663
2664
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 2661

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

#get_queue_fleet_association(params = {}) ⇒ Types::GetQueueFleetAssociationResponse

Gets a queue-fleet association.

The following waiters are defined for this operation (see #wait_until for detailed usage):

  • queue_fleet_association_stopped

Examples:

Request syntax with placeholder values


resp = client.get_queue_fleet_association({
  farm_id: "FarmId", # required
  fleet_id: "FleetId", # required
  queue_id: "QueueId", # required
})

Response structure


resp.created_at #=> Time
resp.created_by #=> String
resp.fleet_id #=> String
resp.queue_id #=> String
resp.status #=> String, one of "ACTIVE", "STOP_SCHEDULING_AND_COMPLETE_TASKS", "STOP_SCHEDULING_AND_CANCEL_TASKS", "STOPPED"
resp.updated_at #=> Time
resp.updated_by #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID of the farm that contains the queue-fleet association.

  • :fleet_id (required, String)

    The fleet ID for the queue-fleet association.

  • :queue_id (required, String)

    The queue ID for the queue-fleet association.

Returns:

See Also:



2714
2715
2716
2717
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 2714

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

#get_session(params = {}) ⇒ Types::GetSessionResponse

Gets a session.

Examples:

Request syntax with placeholder values


resp = client.get_session({
  farm_id: "FarmId", # required
  job_id: "JobId", # required
  queue_id: "QueueId", # required
  session_id: "SessionId", # required
})

Response structure


resp.ended_at #=> Time
resp.fleet_id #=> String
resp.host_properties.ec2_instance_arn #=> String
resp.host_properties.ec2_instance_type #=> String
resp.host_properties.host_name #=> String
resp.host_properties.ip_addresses.ip_v4_addresses #=> Array
resp.host_properties.ip_addresses.ip_v4_addresses[0] #=> String
resp.host_properties.ip_addresses.ip_v6_addresses #=> Array
resp.host_properties.ip_addresses.ip_v6_addresses[0] #=> String
resp.lifecycle_status #=> String, one of "STARTED", "UPDATE_IN_PROGRESS", "UPDATE_SUCCEEDED", "UPDATE_FAILED", "ENDED"
resp.log.error #=> String
resp.log.log_driver #=> String
resp.log.options #=> Hash
resp.log.options["String"] #=> String
resp.log.parameters #=> Hash
resp.log.parameters["String"] #=> String
resp.session_id #=> String
resp.started_at #=> Time
resp.target_lifecycle_status #=> String, one of "ENDED"
resp.updated_at #=> Time
resp.updated_by #=> String
resp.worker_id #=> String
resp.worker_log.error #=> String
resp.worker_log.log_driver #=> String
resp.worker_log.options #=> Hash
resp.worker_log.options["String"] #=> String
resp.worker_log.parameters #=> Hash
resp.worker_log.parameters["String"] #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID for the session.

  • :job_id (required, String)

    The job ID for the session.

  • :queue_id (required, String)

    The queue ID for the session.

  • :session_id (required, String)

    The session ID.

Returns:

See Also:



2792
2793
2794
2795
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 2792

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

#get_session_action(params = {}) ⇒ Types::GetSessionActionResponse

Gets a session action for the job.

Examples:

Request syntax with placeholder values


resp = client.get_session_action({
  farm_id: "FarmId", # required
  job_id: "JobId", # required
  queue_id: "QueueId", # required
  session_action_id: "SessionActionId", # required
})

Response structure


resp.definition.env_enter.environment_id #=> String
resp.definition.env_exit.environment_id #=> String
resp.definition.sync_input_job_attachments.step_id #=> String
resp.definition.task_run.parameters #=> Hash
resp.definition.task_run.parameters["String"].float #=> String
resp.definition.task_run.parameters["String"].int #=> String
resp.definition.task_run.parameters["String"].path #=> String
resp.definition.task_run.parameters["String"].string #=> String
resp.definition.task_run.step_id #=> String
resp.definition.task_run.task_id #=> String
resp.ended_at #=> Time
resp.process_exit_code #=> Integer
resp.progress_message #=> String
resp.progress_percent #=> Float
resp.session_action_id #=> String
resp.session_id #=> String
resp.started_at #=> Time
resp.status #=> String, one of "ASSIGNED", "RUNNING", "CANCELING", "SUCCEEDED", "FAILED", "INTERRUPTED", "CANCELED", "NEVER_ATTEMPTED", "SCHEDULED", "RECLAIMING", "RECLAIMED"
resp.worker_updated_at #=> Time

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID for the session action.

  • :job_id (required, String)

    The job ID for the session.

  • :queue_id (required, String)

    The queue ID for the session action.

  • :session_action_id (required, String)

    The session action ID for the session.

Returns:

See Also:



2859
2860
2861
2862
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 2859

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

#get_sessions_statistics_aggregation(params = {}) ⇒ Types::GetSessionsStatisticsAggregationResponse

Gets a set of statistics for queues or farms. Before you can call the GetSessionStatisticsAggregation operation, you must first call the StartSessionsStatisticsAggregation operation. Statistics are available for 1 hour after you call the StartSessionsStatisticsAggregation operation.

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

Examples:

Request syntax with placeholder values


resp = client.get_sessions_statistics_aggregation({
  aggregation_id: "AggregationId", # required
  farm_id: "FarmId", # required
  max_results: 1,
  next_token: "String",
})

Response structure


resp.next_token #=> String
resp.statistics #=> Array
resp.statistics[0].aggregation_end_time #=> Time
resp.statistics[0].aggregation_start_time #=> Time
resp.statistics[0].cost_in_usd.avg #=> Float
resp.statistics[0].cost_in_usd.max #=> Float
resp.statistics[0].cost_in_usd.min #=> Float
resp.statistics[0].cost_in_usd.sum #=> Float
resp.statistics[0].count #=> Integer
resp.statistics[0].fleet_id #=> String
resp.statistics[0].instance_type #=> String
resp.statistics[0].job_id #=> String
resp.statistics[0].job_name #=> String
resp.statistics[0].license_product #=> String
resp.statistics[0].queue_id #=> String
resp.statistics[0].runtime_in_seconds.avg #=> Float
resp.statistics[0].runtime_in_seconds.max #=> Float
resp.statistics[0].runtime_in_seconds.min #=> Float
resp.statistics[0].runtime_in_seconds.sum #=> Float
resp.statistics[0].usage_type #=> String, one of "COMPUTE", "LICENSE"
resp.statistics[0].user_id #=> String
resp.status #=> String, one of "IN_PROGRESS", "TIMEOUT", "FAILED", "COMPLETED"
resp.status_message #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :aggregation_id (required, String)

    The identifier returned by the StartSessionsStatisticsAggregation operation that identifies the aggregated statistics.

  • :farm_id (required, String)

    The identifier of the farm to include in the statistics. This should be the same as the farm ID used in the call to the StartSessionsStatisticsAggregation operation.

  • :max_results (Integer)

    The maximum number of results to return. Use this parameter with NextToken to get results as a set of sequential pages.

  • :next_token (String)

    The token for the next set of results, or null to start from the beginning.

Returns:

See Also:



2935
2936
2937
2938
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 2935

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

#get_step(params = {}) ⇒ Types::GetStepResponse

Gets a step.

Examples:

Request syntax with placeholder values


resp = client.get_step({
  farm_id: "FarmId", # required
  job_id: "JobId", # required
  queue_id: "QueueId", # required
  step_id: "StepId", # required
})

Response structure


resp.created_at #=> Time
resp.created_by #=> String
resp.dependency_counts.consumers_resolved #=> Integer
resp.dependency_counts.consumers_unresolved #=> Integer
resp.dependency_counts.dependencies_resolved #=> Integer
resp.dependency_counts.dependencies_unresolved #=> Integer
resp.description #=> String
resp.ended_at #=> Time
resp.lifecycle_status #=> String, one of "CREATE_COMPLETE", "UPDATE_IN_PROGRESS", "UPDATE_FAILED", "UPDATE_SUCCEEDED"
resp.lifecycle_status_message #=> String
resp.name #=> String
resp.parameter_space.combination #=> String
resp.parameter_space.parameters #=> Array
resp.parameter_space.parameters[0].name #=> String
resp.parameter_space.parameters[0].type #=> String, one of "INT", "FLOAT", "STRING", "PATH"
resp.required_capabilities.amounts #=> Array
resp.required_capabilities.amounts[0].max #=> Float
resp.required_capabilities.amounts[0].min #=> Float
resp.required_capabilities.amounts[0].name #=> String
resp.required_capabilities.amounts[0].value #=> Float
resp.required_capabilities.attributes #=> Array
resp.required_capabilities.attributes[0].all_of #=> Array
resp.required_capabilities.attributes[0].all_of[0] #=> String
resp.required_capabilities.attributes[0].any_of #=> Array
resp.required_capabilities.attributes[0].any_of[0] #=> String
resp.required_capabilities.attributes[0].name #=> String
resp.started_at #=> Time
resp.step_id #=> String
resp.target_task_run_status #=> String, one of "READY", "FAILED", "SUCCEEDED", "CANCELED", "SUSPENDED", "PENDING"
resp.task_run_status #=> String, one of "PENDING", "READY", "ASSIGNED", "STARTING", "SCHEDULED", "INTERRUPTING", "RUNNING", "SUSPENDED", "CANCELED", "FAILED", "SUCCEEDED", "NOT_COMPATIBLE"
resp.task_run_status_counts #=> Hash
resp.task_run_status_counts["TaskRunStatus"] #=> Integer
resp.updated_at #=> Time
resp.updated_by #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID for the step.

  • :job_id (required, String)

    The job ID for the step.

  • :queue_id (required, String)

    The queue ID for the step.

  • :step_id (required, String)

    The step ID.

Returns:

See Also:



3024
3025
3026
3027
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 3024

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

#get_storage_profile(params = {}) ⇒ Types::GetStorageProfileResponse

Gets a storage profile.

Examples:

Request syntax with placeholder values


resp = client.get_storage_profile({
  farm_id: "FarmId", # required
  storage_profile_id: "StorageProfileId", # required
})

Response structure


resp.created_at #=> Time
resp.created_by #=> String
resp.display_name #=> String
resp.file_system_locations #=> Array
resp.file_system_locations[0].name #=> String
resp.file_system_locations[0].path #=> String
resp.file_system_locations[0].type #=> String, one of "SHARED", "LOCAL"
resp.os_family #=> String, one of "WINDOWS", "LINUX", "MACOS"
resp.storage_profile_id #=> String
resp.updated_at #=> Time
resp.updated_by #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID for the storage profile.

  • :storage_profile_id (required, String)

    The storage profile ID.

Returns:

See Also:



3073
3074
3075
3076
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 3073

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

#get_storage_profile_for_queue(params = {}) ⇒ Types::GetStorageProfileForQueueResponse

Gets a storage profile for a queue.

Examples:

Request syntax with placeholder values


resp = client.get_storage_profile_for_queue({
  farm_id: "FarmId", # required
  queue_id: "QueueId", # required
  storage_profile_id: "StorageProfileId", # required
})

Response structure


resp.display_name #=> String
resp.file_system_locations #=> Array
resp.file_system_locations[0].name #=> String
resp.file_system_locations[0].path #=> String
resp.file_system_locations[0].type #=> String, one of "SHARED", "LOCAL"
resp.os_family #=> String, one of "WINDOWS", "LINUX", "MACOS"
resp.storage_profile_id #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID for the queue in storage profile.

  • :queue_id (required, String)

    The queue ID the queue in the storage profile.

  • :storage_profile_id (required, String)

    The storage profile ID for the storage profile in the queue.

Returns:

See Also:



3118
3119
3120
3121
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 3118

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

#get_task(params = {}) ⇒ Types::GetTaskResponse

Gets a task.

Examples:

Request syntax with placeholder values


resp = client.get_task({
  farm_id: "FarmId", # required
  job_id: "JobId", # required
  queue_id: "QueueId", # required
  step_id: "StepId", # required
  task_id: "TaskId", # required
})

Response structure


resp.created_at #=> Time
resp.created_by #=> String
resp.ended_at #=> Time
resp.failure_retry_count #=> Integer
resp.latest_session_action_id #=> String
resp.parameters #=> Hash
resp.parameters["String"].float #=> String
resp.parameters["String"].int #=> String
resp.parameters["String"].path #=> String
resp.parameters["String"].string #=> String
resp.run_status #=> String, one of "PENDING", "READY", "ASSIGNED", "STARTING", "SCHEDULED", "INTERRUPTING", "RUNNING", "SUSPENDED", "CANCELED", "FAILED", "SUCCEEDED", "NOT_COMPATIBLE"
resp.started_at #=> Time
resp.target_run_status #=> String, one of "READY", "FAILED", "SUCCEEDED", "CANCELED", "SUSPENDED", "PENDING"
resp.task_id #=> String
resp.updated_at #=> Time
resp.updated_by #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID of the farm connected to the task.

  • :job_id (required, String)

    The job ID of the job connected to the task.

  • :queue_id (required, String)

    The queue ID for the queue connected to the task.

  • :step_id (required, String)

    The step ID for the step connected to the task.

  • :task_id (required, String)

    The task ID.

Returns:

See Also:



3188
3189
3190
3191
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 3188

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

#get_worker(params = {}) ⇒ Types::GetWorkerResponse

Gets a worker.

Examples:

Request syntax with placeholder values


resp = client.get_worker({
  farm_id: "FarmId", # required
  fleet_id: "FleetId", # required
  worker_id: "WorkerId", # required
})

Response structure


resp.created_at #=> Time
resp.created_by #=> String
resp.farm_id #=> String
resp.fleet_id #=> String
resp.host_properties.ec2_instance_arn #=> String
resp.host_properties.ec2_instance_type #=> String
resp.host_properties.host_name #=> String
resp.host_properties.ip_addresses.ip_v4_addresses #=> Array
resp.host_properties.ip_addresses.ip_v4_addresses[0] #=> String
resp.host_properties.ip_addresses.ip_v6_addresses #=> Array
resp.host_properties.ip_addresses.ip_v6_addresses[0] #=> String
resp.log.error #=> String
resp.log.log_driver #=> String
resp.log.options #=> Hash
resp.log.options["String"] #=> String
resp.log.parameters #=> Hash
resp.log.parameters["String"] #=> String
resp.status #=> String, one of "CREATED", "STARTED", "STOPPING", "STOPPED", "NOT_RESPONDING", "NOT_COMPATIBLE", "RUNNING", "IDLE"
resp.updated_at #=> Time
resp.updated_by #=> String
resp.worker_id #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID for the worker.

  • :fleet_id (required, String)

    The fleet ID of the worker.

  • :worker_id (required, String)

    The worker ID.

Returns:

See Also:



3253
3254
3255
3256
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 3253

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

#list_available_metered_products(params = {}) ⇒ Types::ListAvailableMeteredProductsResponse

A list of the available metered products.

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_available_metered_products({
  max_results: 1,
  next_token: "String",
})

Response structure


resp.metered_products #=> Array
resp.metered_products[0].family #=> String
resp.metered_products[0].port #=> Integer
resp.metered_products[0].product_id #=> String
resp.metered_products[0].vendor #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :max_results (Integer)

    The maximum number of results to return. Use this parameter with NextToken to get results as a set of sequential pages.

  • :next_token (String)

    The token for the next set of results, or null to start from the beginning.

Returns:

See Also:



3295
3296
3297
3298
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 3295

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

#list_budgets(params = {}) ⇒ Types::ListBudgetsResponse

A list of budgets in a farm.

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_budgets({
  farm_id: "FarmId", # required
  max_results: 1,
  next_token: "String",
  status: "ACTIVE", # accepts ACTIVE, INACTIVE
})

Response structure


resp.budgets #=> Array
resp.budgets[0].approximate_dollar_limit #=> Float
resp.budgets[0].budget_id #=> String
resp.budgets[0].created_at #=> Time
resp.budgets[0].created_by #=> String
resp.budgets[0].description #=> String
resp.budgets[0].display_name #=> String
resp.budgets[0].status #=> String, one of "ACTIVE", "INACTIVE"
resp.budgets[0].updated_at #=> Time
resp.budgets[0].updated_by #=> String
resp.budgets[0].usage_tracking_resource.queue_id #=> String
resp.budgets[0].usages.approximate_dollar_usage #=> Float
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID associated with the budgets.

  • :max_results (Integer)

    The maximum number of results to return. Use this parameter with NextToken to get results as a set of sequential pages.

  • :next_token (String)

    The token for the next set of results, or null to start from the beginning.

  • :status (String)

    The status to list for the budgets.

Returns:

See Also:



3352
3353
3354
3355
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 3352

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

#list_farm_members(params = {}) ⇒ Types::ListFarmMembersResponse

Lists the members of a farm.

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_farm_members({
  farm_id: "FarmId", # required
  max_results: 1,
  next_token: "String",
})

Response structure


resp.members #=> Array
resp.members[0].farm_id #=> String
resp.members[0].identity_store_id #=> String
resp.members[0].membership_level #=> String, one of "VIEWER", "CONTRIBUTOR", "OWNER", "MANAGER"
resp.members[0].principal_id #=> String
resp.members[0].principal_type #=> String, one of "USER", "GROUP"
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID.

  • :max_results (Integer)

    The maximum number of results to return. Use this parameter with NextToken to get results as a set of sequential pages.

  • :next_token (String)

    The token for the next set of results, or null to start from the beginning.

Returns:

See Also:



3399
3400
3401
3402
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 3399

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

#list_farms(params = {}) ⇒ Types::ListFarmsResponse

Lists farms.

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_farms({
  max_results: 1,
  next_token: "String",
  principal_id: "IdentityCenterPrincipalId",
})

Response structure


resp.farms #=> Array
resp.farms[0].created_at #=> Time
resp.farms[0].created_by #=> String
resp.farms[0].display_name #=> String
resp.farms[0].farm_id #=> String
resp.farms[0].kms_key_arn #=> String
resp.farms[0].updated_at #=> Time
resp.farms[0].updated_by #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :max_results (Integer)

    The maximum number of results to return. Use this parameter with NextToken to get results as a set of sequential pages.

  • :next_token (String)

    The token for the next set of results, or null to start from the beginning.

  • :principal_id (String)

    The principal ID of the member to list on the farm.

Returns:

See Also:



3448
3449
3450
3451
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 3448

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

#list_fleet_members(params = {}) ⇒ Types::ListFleetMembersResponse

Lists fleet members.

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_fleet_members({
  farm_id: "FarmId", # required
  fleet_id: "FleetId", # required
  max_results: 1,
  next_token: "String",
})

Response structure


resp.members #=> Array
resp.members[0].farm_id #=> String
resp.members[0].fleet_id #=> String
resp.members[0].identity_store_id #=> String
resp.members[0].membership_level #=> String, one of "VIEWER", "CONTRIBUTOR", "OWNER", "MANAGER"
resp.members[0].principal_id #=> String
resp.members[0].principal_type #=> String, one of "USER", "GROUP"
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID of the fleet.

  • :fleet_id (required, String)

    The fleet ID to include on the list.

  • :max_results (Integer)

    The maximum number of results to return. Use this parameter with NextToken to get results as a set of sequential pages.

  • :next_token (String)

    The token for the next set of results, or null to start from the beginning.

Returns:

See Also:



3500
3501
3502
3503
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 3500

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

#list_fleets(params = {}) ⇒ Types::ListFleetsResponse

Lists fleets.

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_fleets({
  display_name: "ResourceName",
  farm_id: "FarmId", # required
  max_results: 1,
  next_token: "String",
  principal_id: "IdentityCenterPrincipalId",
  status: "ACTIVE", # accepts ACTIVE, CREATE_IN_PROGRESS, UPDATE_IN_PROGRESS, CREATE_FAILED, UPDATE_FAILED
})

Response structure


resp.fleets #=> Array
resp.fleets[0].auto_scaling_status #=> String, one of "GROWING", "STEADY", "SHRINKING"
resp.fleets[0].configuration.customer_managed.mode #=> String, one of "NO_SCALING", "EVENT_BASED_AUTO_SCALING"
resp.fleets[0].configuration.customer_managed.storage_profile_id #=> String
resp.fleets[0].configuration.customer_managed.worker_capabilities.accelerator_count.max #=> Integer
resp.fleets[0].configuration.customer_managed.worker_capabilities.accelerator_count.min #=> Integer
resp.fleets[0].configuration.customer_managed.worker_capabilities.accelerator_total_memory_mi_b.max #=> Integer
resp.fleets[0].configuration.customer_managed.worker_capabilities.accelerator_total_memory_mi_b.min #=> Integer
resp.fleets[0].configuration.customer_managed.worker_capabilities.accelerator_types #=> Array
resp.fleets[0].configuration.customer_managed.worker_capabilities.accelerator_types[0] #=> String, one of "gpu"
resp.fleets[0].configuration.customer_managed.worker_capabilities.cpu_architecture_type #=> String, one of "x86_64", "arm64"
resp.fleets[0].configuration.customer_managed.worker_capabilities.custom_amounts #=> Array
resp.fleets[0].configuration.customer_managed.worker_capabilities.custom_amounts[0].max #=> Float
resp.fleets[0].configuration.customer_managed.worker_capabilities.custom_amounts[0].min #=> Float
resp.fleets[0].configuration.customer_managed.worker_capabilities.custom_amounts[0].name #=> String
resp.fleets[0].configuration.customer_managed.worker_capabilities.custom_attributes #=> Array
resp.fleets[0].configuration.customer_managed.worker_capabilities.custom_attributes[0].name #=> String
resp.fleets[0].configuration.customer_managed.worker_capabilities.custom_attributes[0].values #=> Array
resp.fleets[0].configuration.customer_managed.worker_capabilities.custom_attributes[0].values[0] #=> String
resp.fleets[0].configuration.customer_managed.worker_capabilities.memory_mi_b.max #=> Integer
resp.fleets[0].configuration.customer_managed.worker_capabilities.memory_mi_b.min #=> Integer
resp.fleets[0].configuration.customer_managed.worker_capabilities.os_family #=> String, one of "WINDOWS", "LINUX", "MACOS"
resp.fleets[0].configuration.customer_managed.worker_capabilities.v_cpu_count.max #=> Integer
resp.fleets[0].configuration.customer_managed.worker_capabilities.v_cpu_count.min #=> Integer
resp.fleets[0].configuration.service_managed_ec2.instance_capabilities.allowed_instance_types #=> Array
resp.fleets[0].configuration.service_managed_ec2.instance_capabilities.allowed_instance_types[0] #=> String
resp.fleets[0].configuration.service_managed_ec2.instance_capabilities.cpu_architecture_type #=> String, one of "x86_64", "arm64"
resp.fleets[0].configuration.service_managed_ec2.instance_capabilities.custom_amounts #=> Array
resp.fleets[0].configuration.service_managed_ec2.instance_capabilities.custom_amounts[0].max #=> Float
resp.fleets[0].configuration.service_managed_ec2.instance_capabilities.custom_amounts[0].min #=> Float
resp.fleets[0].configuration.service_managed_ec2.instance_capabilities.custom_amounts[0].name #=> String
resp.fleets[0].configuration.service_managed_ec2.instance_capabilities.custom_attributes #=> Array
resp.fleets[0].configuration.service_managed_ec2.instance_capabilities.custom_attributes[0].name #=> String
resp.fleets[0].configuration.service_managed_ec2.instance_capabilities.custom_attributes[0].values #=> Array
resp.fleets[0].configuration.service_managed_ec2.instance_capabilities.custom_attributes[0].values[0] #=> String
resp.fleets[0].configuration.service_managed_ec2.instance_capabilities.excluded_instance_types #=> Array
resp.fleets[0].configuration.service_managed_ec2.instance_capabilities.excluded_instance_types[0] #=> String
resp.fleets[0].configuration.service_managed_ec2.instance_capabilities.memory_mi_b.max #=> Integer
resp.fleets[0].configuration.service_managed_ec2.instance_capabilities.memory_mi_b.min #=> Integer
resp.fleets[0].configuration.service_managed_ec2.instance_capabilities.os_family #=> String, one of "WINDOWS", "LINUX"
resp.fleets[0].configuration.service_managed_ec2.instance_capabilities.root_ebs_volume.iops #=> Integer
resp.fleets[0].configuration.service_managed_ec2.instance_capabilities.root_ebs_volume.size_gi_b #=> Integer
resp.fleets[0].configuration.service_managed_ec2.instance_capabilities.root_ebs_volume.throughput_mi_b #=> Integer
resp.fleets[0].configuration.service_managed_ec2.instance_capabilities.v_cpu_count.max #=> Integer
resp.fleets[0].configuration.service_managed_ec2.instance_capabilities.v_cpu_count.min #=> Integer
resp.fleets[0].configuration.service_managed_ec2.instance_market_options.type #=> String, one of "on-demand", "spot"
resp.fleets[0].created_at #=> Time
resp.fleets[0].created_by #=> String
resp.fleets[0].display_name #=> String
resp.fleets[0].farm_id #=> String
resp.fleets[0].fleet_id #=> String
resp.fleets[0].max_worker_count #=> Integer
resp.fleets[0].min_worker_count #=> Integer
resp.fleets[0].status #=> String, one of "ACTIVE", "CREATE_IN_PROGRESS", "UPDATE_IN_PROGRESS", "CREATE_FAILED", "UPDATE_FAILED"
resp.fleets[0].target_worker_count #=> Integer
resp.fleets[0].updated_at #=> Time
resp.fleets[0].updated_by #=> String
resp.fleets[0].worker_count #=> Integer
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :display_name (String)

    The display names of a list of fleets.

  • :farm_id (required, String)

    The farm ID of the fleets.

  • :max_results (Integer)

    The maximum number of results to return. Use this parameter with NextToken to get results as a set of sequential pages.

  • :next_token (String)

    The token for the next set of results, or null to start from the beginning.

  • :principal_id (String)

    The principal ID of the members to include in the fleet.

  • :status (String)

    The status of the fleet.

Returns:

See Also:



3611
3612
3613
3614
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 3611

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

#list_job_members(params = {}) ⇒ Types::ListJobMembersResponse

Lists members on a job.

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_job_members({
  farm_id: "FarmId", # required
  job_id: "JobId", # required
  max_results: 1,
  next_token: "String",
  queue_id: "QueueId", # required
})

Response structure


resp.members #=> Array
resp.members[0].farm_id #=> String
resp.members[0].identity_store_id #=> String
resp.members[0].job_id #=> String
resp.members[0].membership_level #=> String, one of "VIEWER", "CONTRIBUTOR", "OWNER", "MANAGER"
resp.members[0].principal_id #=> String
resp.members[0].principal_type #=> String, one of "USER", "GROUP"
resp.members[0].queue_id #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID of the job to list.

  • :job_id (required, String)

    The job ID to include on the list.

  • :max_results (Integer)

    The maximum number of results to return. Use this parameter with NextToken to get results as a set of sequential pages.

  • :next_token (String)

    The token for the next set of results, or null to start from the beginning.

  • :queue_id (required, String)

    The queue ID to include on the list.

Returns:

See Also:



3668
3669
3670
3671
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 3668

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

#list_jobs(params = {}) ⇒ Types::ListJobsResponse

Lists jobs.

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_jobs({
  farm_id: "FarmId", # required
  max_results: 1,
  next_token: "String",
  principal_id: "IdentityCenterPrincipalId",
  queue_id: "QueueId", # required
})

Response structure


resp.jobs #=> Array
resp.jobs[0].created_at #=> Time
resp.jobs[0].created_by #=> String
resp.jobs[0].ended_at #=> Time
resp.jobs[0].job_id #=> String
resp.jobs[0].lifecycle_status #=> String, one of "CREATE_IN_PROGRESS", "CREATE_FAILED", "CREATE_COMPLETE", "UPLOAD_IN_PROGRESS", "UPLOAD_FAILED", "UPDATE_IN_PROGRESS", "UPDATE_FAILED", "UPDATE_SUCCEEDED", "ARCHIVED"
resp.jobs[0].lifecycle_status_message #=> String
resp.jobs[0].max_failed_tasks_count #=> Integer
resp.jobs[0].max_retries_per_task #=> Integer
resp.jobs[0].name #=> String
resp.jobs[0].priority #=> Integer
resp.jobs[0].started_at #=> Time
resp.jobs[0].target_task_run_status #=> String, one of "READY", "FAILED", "SUCCEEDED", "CANCELED", "SUSPENDED", "PENDING"
resp.jobs[0].task_run_status #=> String, one of "PENDING", "READY", "ASSIGNED", "STARTING", "SCHEDULED", "INTERRUPTING", "RUNNING", "SUSPENDED", "CANCELED", "FAILED", "SUCCEEDED", "NOT_COMPATIBLE"
resp.jobs[0].task_run_status_counts #=> Hash
resp.jobs[0].task_run_status_counts["TaskRunStatus"] #=> Integer
resp.jobs[0].updated_at #=> Time
resp.jobs[0].updated_by #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID for the jobs.

  • :max_results (Integer)

    The maximum number of results to return. Use this parameter with NextToken to get results as a set of sequential pages.

  • :next_token (String)

    The token for the next set of results, or null to start from the beginning.

  • :principal_id (String)

    The principal ID of the members on the jobs.

  • :queue_id (required, String)

    The queue ID for the job.

Returns:

See Also:



3735
3736
3737
3738
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 3735

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

#list_license_endpoints(params = {}) ⇒ Types::ListLicenseEndpointsResponse

Lists license endpoints.

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_license_endpoints({
  max_results: 1,
  next_token: "String",
})

Response structure


resp.license_endpoints #=> Array
resp.license_endpoints[0].license_endpoint_id #=> String
resp.license_endpoints[0].status #=> String, one of "CREATE_IN_PROGRESS", "DELETE_IN_PROGRESS", "READY", "NOT_READY"
resp.license_endpoints[0].status_message #=> String
resp.license_endpoints[0].vpc_id #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :max_results (Integer)

    The maximum number of results to return. Use this parameter with NextToken to get results as a set of sequential pages.

  • :next_token (String)

    The token for the next set of results, or null to start from the beginning.

Returns:

See Also:



3777
3778
3779
3780
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 3777

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

#list_metered_products(params = {}) ⇒ Types::ListMeteredProductsResponse

Lists metered products.

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_metered_products({
  license_endpoint_id: "LicenseEndpointId", # required
  max_results: 1,
  next_token: "String",
})

Response structure


resp.metered_products #=> Array
resp.metered_products[0].family #=> String
resp.metered_products[0].port #=> Integer
resp.metered_products[0].product_id #=> String
resp.metered_products[0].vendor #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :license_endpoint_id (required, String)

    The license endpoint ID to include on the list of metered products.

  • :max_results (Integer)

    The maximum number of results to return. Use this parameter with NextToken to get results as a set of sequential pages.

  • :next_token (String)

    The token for the next set of results, or null to start from the beginning.

Returns:

See Also:



3823
3824
3825
3826
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 3823

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

#list_monitors(params = {}) ⇒ Types::ListMonitorsResponse

Gets a list of your monitors in Deadline Cloud.

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_monitors({
  max_results: 1,
  next_token: "String",
})

Response structure


resp.monitors #=> Array
resp.monitors[0].created_at #=> Time
resp.monitors[0].created_by #=> String
resp.monitors[0].display_name #=> String
resp.monitors[0].identity_center_application_arn #=> String
resp.monitors[0].identity_center_instance_arn #=> String
resp.monitors[0].monitor_id #=> String
resp.monitors[0].role_arn #=> String
resp.monitors[0].subdomain #=> String
resp.monitors[0].updated_at #=> Time
resp.monitors[0].updated_by #=> String
resp.monitors[0].url #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :max_results (Integer)

    The maximum number of results to return. Use this parameter with NextToken to get results as a set of sequential pages.

  • :next_token (String)

    The token for the next set of results, or null to start from the beginning.

Returns:

See Also:



3872
3873
3874
3875
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 3872

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

#list_queue_environments(params = {}) ⇒ Types::ListQueueEnvironmentsResponse

Lists queue environments.

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_queue_environments({
  farm_id: "FarmId", # required
  max_results: 1,
  next_token: "String",
  queue_id: "QueueId", # required
})

Response structure


resp.environments #=> Array
resp.environments[0].name #=> String
resp.environments[0].priority #=> Integer
resp.environments[0].queue_environment_id #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID for the queue environment list.

  • :max_results (Integer)

    The maximum number of results to return. Use this parameter with NextToken to get results as a set of sequential pages.

  • :next_token (String)

    The token for the next set of results, or null to start from the beginning.

  • :queue_id (required, String)

    The queue ID for the queue environment list.

Returns:

See Also:



3921
3922
3923
3924
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 3921

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

#list_queue_fleet_associations(params = {}) ⇒ Types::ListQueueFleetAssociationsResponse

Lists queue-fleet associations.

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_queue_fleet_associations({
  farm_id: "FarmId", # required
  fleet_id: "FleetId",
  max_results: 1,
  next_token: "String",
  queue_id: "QueueId",
})

Response structure


resp.next_token #=> String
resp.queue_fleet_associations #=> Array
resp.queue_fleet_associations[0].created_at #=> Time
resp.queue_fleet_associations[0].created_by #=> String
resp.queue_fleet_associations[0].fleet_id #=> String
resp.queue_fleet_associations[0].queue_id #=> String
resp.queue_fleet_associations[0].status #=> String, one of "ACTIVE", "STOP_SCHEDULING_AND_COMPLETE_TASKS", "STOP_SCHEDULING_AND_CANCEL_TASKS", "STOPPED"
resp.queue_fleet_associations[0].updated_at #=> Time
resp.queue_fleet_associations[0].updated_by #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID for the queue-fleet association list.

  • :fleet_id (String)

    The fleet ID for the queue-fleet association list.

  • :max_results (Integer)

    The maximum number of results to return. Use this parameter with NextToken to get results as a set of sequential pages.

  • :next_token (String)

    The token for the next set of results, or null to start from the beginning.

  • :queue_id (String)

    The queue ID for the queue-fleet association list.

Returns:

See Also:



3978
3979
3980
3981
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 3978

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

#list_queue_members(params = {}) ⇒ Types::ListQueueMembersResponse

Lists the members in a queue.

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_queue_members({
  farm_id: "FarmId", # required
  max_results: 1,
  next_token: "String",
  queue_id: "QueueId", # required
})

Response structure


resp.members #=> Array
resp.members[0].farm_id #=> String
resp.members[0].identity_store_id #=> String
resp.members[0].membership_level #=> String, one of "VIEWER", "CONTRIBUTOR", "OWNER", "MANAGER"
resp.members[0].principal_id #=> String
resp.members[0].principal_type #=> String, one of "USER", "GROUP"
resp.members[0].queue_id #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID for the queue.

  • :max_results (Integer)

    The maximum number of results to return. Use this parameter with NextToken to get results as a set of sequential pages.

  • :next_token (String)

    The token for the next set of results, or null to start from the beginning.

  • :queue_id (required, String)

    The queue ID to include on the list.

Returns:

See Also:



4030
4031
4032
4033
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 4030

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

#list_queues(params = {}) ⇒ Types::ListQueuesResponse

Lists queues.

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_queues({
  farm_id: "FarmId", # required
  max_results: 1,
  next_token: "String",
  principal_id: "IdentityCenterPrincipalId",
  status: "IDLE", # accepts IDLE, SCHEDULING, SCHEDULING_BLOCKED
})

Response structure


resp.next_token #=> String
resp.queues #=> Array
resp.queues[0].blocked_reason #=> String, one of "NO_BUDGET_CONFIGURED", "BUDGET_THRESHOLD_REACHED"
resp.queues[0].created_at #=> Time
resp.queues[0].created_by #=> String
resp.queues[0].default_budget_action #=> String, one of "NONE", "STOP_SCHEDULING_AND_COMPLETE_TASKS", "STOP_SCHEDULING_AND_CANCEL_TASKS"
resp.queues[0].display_name #=> String
resp.queues[0].farm_id #=> String
resp.queues[0].queue_id #=> String
resp.queues[0].status #=> String, one of "IDLE", "SCHEDULING", "SCHEDULING_BLOCKED"
resp.queues[0].updated_at #=> Time
resp.queues[0].updated_by #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID of the queue.

  • :max_results (Integer)

    The maximum number of results to return. Use this parameter with NextToken to get results as a set of sequential pages.

  • :next_token (String)

    The token for the next set of results, or null to start from the beginning.

  • :principal_id (String)

    The principal ID. This filter is only valid when using Nimble Studio credentials and should match the user ID in the credentials of the caller.

  • :status (String)

    The status of the queues listed.

    • ACTIVE–The queues are active.

    • SCHEDULING–The queues are scheduling.

    • SCHEDULING_BLOCKED–The queue scheduling is blocked for these queues.

Returns:

See Also:



4099
4100
4101
4102
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 4099

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

#list_session_actions(params = {}) ⇒ Types::ListSessionActionsResponse

Lists session actions.

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_session_actions({
  farm_id: "FarmId", # required
  job_id: "JobId", # required
  max_results: 1,
  next_token: "String",
  queue_id: "QueueId", # required
  session_id: "SessionId",
  task_id: "TaskId",
})

Response structure


resp.next_token #=> String
resp.session_actions #=> Array
resp.session_actions[0].definition.env_enter.environment_id #=> String
resp.session_actions[0].definition.env_exit.environment_id #=> String
resp.session_actions[0].definition.sync_input_job_attachments.step_id #=> String
resp.session_actions[0].definition.task_run.step_id #=> String
resp.session_actions[0].definition.task_run.task_id #=> String
resp.session_actions[0].ended_at #=> Time
resp.session_actions[0].progress_percent #=> Float
resp.session_actions[0].session_action_id #=> String
resp.session_actions[0].started_at #=> Time
resp.session_actions[0].status #=> String, one of "ASSIGNED", "RUNNING", "CANCELING", "SUCCEEDED", "FAILED", "INTERRUPTED", "CANCELED", "NEVER_ATTEMPTED", "SCHEDULED", "RECLAIMING", "RECLAIMED"
resp.session_actions[0].worker_updated_at #=> Time

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID for the session actions list.

  • :job_id (required, String)

    The job ID for the session actions list.

  • :max_results (Integer)

    The maximum number of results to return. Use this parameter with NextToken to get results as a set of sequential pages.

  • :next_token (String)

    The token for the next set of results, or null to start from the beginning.

  • :queue_id (required, String)

    The queue ID for the session actions list.

  • :session_id (String)

    The session ID to include on the sessions action list.

  • :task_id (String)

    The task ID for the session actions list.

Returns:

See Also:



4168
4169
4170
4171
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 4168

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

#list_sessions(params = {}) ⇒ Types::ListSessionsResponse

Lists sessions.

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_sessions({
  farm_id: "FarmId", # required
  job_id: "JobId", # required
  max_results: 1,
  next_token: "String",
  queue_id: "QueueId", # required
})

Response structure


resp.next_token #=> String
resp.sessions #=> Array
resp.sessions[0].ended_at #=> Time
resp.sessions[0].fleet_id #=> String
resp.sessions[0].lifecycle_status #=> String, one of "STARTED", "UPDATE_IN_PROGRESS", "UPDATE_SUCCEEDED", "UPDATE_FAILED", "ENDED"
resp.sessions[0].session_id #=> String
resp.sessions[0].started_at #=> Time
resp.sessions[0].target_lifecycle_status #=> String, one of "ENDED"
resp.sessions[0].updated_at #=> Time
resp.sessions[0].updated_by #=> String
resp.sessions[0].worker_id #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID for the list of sessions.

  • :job_id (required, String)

    The job ID for the list of sessions.

  • :max_results (Integer)

    The maximum number of results to return. Use this parameter with NextToken to get results as a set of sequential pages.

  • :next_token (String)

    The token for the next set of results, or null to start from the beginning.

  • :queue_id (required, String)

    The queue ID for the list of sessions

Returns:

See Also:



4227
4228
4229
4230
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 4227

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

#list_sessions_for_worker(params = {}) ⇒ Types::ListSessionsForWorkerResponse

Lists sessions for a worker.

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_sessions_for_worker({
  farm_id: "FarmId", # required
  fleet_id: "FleetId", # required
  max_results: 1,
  next_token: "String",
  worker_id: "WorkerId", # required
})

Response structure


resp.next_token #=> String
resp.sessions #=> Array
resp.sessions[0].ended_at #=> Time
resp.sessions[0].job_id #=> String
resp.sessions[0].lifecycle_status #=> String, one of "STARTED", "UPDATE_IN_PROGRESS", "UPDATE_SUCCEEDED", "UPDATE_FAILED", "ENDED"
resp.sessions[0].queue_id #=> String
resp.sessions[0].session_id #=> String
resp.sessions[0].started_at #=> Time
resp.sessions[0].target_lifecycle_status #=> String, one of "ENDED"

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID for the session.

  • :fleet_id (required, String)

    The fleet ID for the session.

  • :max_results (Integer)

    The maximum number of results to return. Use this parameter with NextToken to get results as a set of sequential pages.

  • :next_token (String)

    The token for the next set of results, or null to start from the beginning.

  • :worker_id (required, String)

    The worker ID for the session.

Returns:

See Also:



4284
4285
4286
4287
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 4284

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

#list_step_consumers(params = {}) ⇒ Types::ListStepConsumersResponse

Lists step consumers.

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_step_consumers({
  farm_id: "FarmId", # required
  job_id: "JobId", # required
  max_results: 1,
  next_token: "String",
  queue_id: "QueueId", # required
  step_id: "StepId", # required
})

Response structure


resp.consumers #=> Array
resp.consumers[0].status #=> String, one of "RESOLVED", "UNRESOLVED"
resp.consumers[0].step_id #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID for the list of step consumers.

  • :job_id (required, String)

    The job ID for the step consumer.

  • :max_results (Integer)

    The maximum number of results to return. Use this parameter with NextToken to get results as a set of sequential pages.

  • :next_token (String)

    The token for the next set of results, or null to start from the beginning.

  • :queue_id (required, String)

    The queue ID for the step consumer.

  • :step_id (required, String)

    The step ID to include on the list.

Returns:

See Also:



4340
4341
4342
4343
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 4340

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

#list_step_dependencies(params = {}) ⇒ Types::ListStepDependenciesResponse

Lists the dependencies for a step.

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_step_dependencies({
  farm_id: "FarmId", # required
  job_id: "JobId", # required
  max_results: 1,
  next_token: "String",
  queue_id: "QueueId", # required
  step_id: "StepId", # required
})

Response structure


resp.dependencies #=> Array
resp.dependencies[0].status #=> String, one of "RESOLVED", "UNRESOLVED"
resp.dependencies[0].step_id #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID for the step dependencies list.

  • :job_id (required, String)

    The job ID for the step dependencies list.

  • :max_results (Integer)

    The maximum number of results to return. Use this parameter with NextToken to get results as a set of sequential pages.

  • :next_token (String)

    The token for the next set of results, or null to start from the beginning.

  • :queue_id (required, String)

    The queue ID for the step dependencies list.

  • :step_id (required, String)

    The step ID to include on the list.

Returns:

See Also:



4396
4397
4398
4399
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 4396

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

#list_steps(params = {}) ⇒ Types::ListStepsResponse

Lists steps for a job.

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_steps({
  farm_id: "FarmId", # required
  job_id: "JobId", # required
  max_results: 1,
  next_token: "String",
  queue_id: "QueueId", # required
})

Response structure


resp.next_token #=> String
resp.steps #=> Array
resp.steps[0].created_at #=> Time
resp.steps[0].created_by #=> String
resp.steps[0].dependency_counts.consumers_resolved #=> Integer
resp.steps[0].dependency_counts.consumers_unresolved #=> Integer
resp.steps[0].dependency_counts.dependencies_resolved #=> Integer
resp.steps[0].dependency_counts.dependencies_unresolved #=> Integer
resp.steps[0].ended_at #=> Time
resp.steps[0].lifecycle_status #=> String, one of "CREATE_COMPLETE", "UPDATE_IN_PROGRESS", "UPDATE_FAILED", "UPDATE_SUCCEEDED"
resp.steps[0].lifecycle_status_message #=> String
resp.steps[0].name #=> String
resp.steps[0].started_at #=> Time
resp.steps[0].step_id #=> String
resp.steps[0].target_task_run_status #=> String, one of "READY", "FAILED", "SUCCEEDED", "CANCELED", "SUSPENDED", "PENDING"
resp.steps[0].task_run_status #=> String, one of "PENDING", "READY", "ASSIGNED", "STARTING", "SCHEDULED", "INTERRUPTING", "RUNNING", "SUSPENDED", "CANCELED", "FAILED", "SUCCEEDED", "NOT_COMPATIBLE"
resp.steps[0].task_run_status_counts #=> Hash
resp.steps[0].task_run_status_counts["TaskRunStatus"] #=> Integer
resp.steps[0].updated_at #=> Time
resp.steps[0].updated_by #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID to include on the list of steps.

  • :job_id (required, String)

    The job ID to include on the list of steps.

  • :max_results (Integer)

    The maximum number of results to return. Use this parameter with NextToken to get results as a set of sequential pages.

  • :next_token (String)

    The token for the next set of results, or null to start from the beginning.

  • :queue_id (required, String)

    The queue ID to include on the list of steps.

Returns:

See Also:



4464
4465
4466
4467
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 4464

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

#list_storage_profiles(params = {}) ⇒ Types::ListStorageProfilesResponse

Lists storage profiles.

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_storage_profiles({
  farm_id: "FarmId", # required
  max_results: 1,
  next_token: "String",
})

Response structure


resp.next_token #=> String
resp.storage_profiles #=> Array
resp.storage_profiles[0].display_name #=> String
resp.storage_profiles[0].os_family #=> String, one of "WINDOWS", "LINUX", "MACOS"
resp.storage_profiles[0].storage_profile_id #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID of the storage profile.

  • :max_results (Integer)

    The maximum number of results to return. Use this parameter with NextToken to get results as a set of sequential pages.

  • :next_token (String)

    The token for the next set of results, or null to start from the beginning.

Returns:

See Also:



4509
4510
4511
4512
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 4509

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

#list_storage_profiles_for_queue(params = {}) ⇒ Types::ListStorageProfilesForQueueResponse

Lists storage profiles for a queue.

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_storage_profiles_for_queue({
  farm_id: "FarmId", # required
  max_results: 1,
  next_token: "String",
  queue_id: "QueueId", # required
})

Response structure


resp.next_token #=> String
resp.storage_profiles #=> Array
resp.storage_profiles[0].display_name #=> String
resp.storage_profiles[0].os_family #=> String, one of "WINDOWS", "LINUX", "MACOS"
resp.storage_profiles[0].storage_profile_id #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID of the queue's storage profile.

  • :max_results (Integer)

    The maximum number of results to return. Use this parameter with NextToken to get results as a set of sequential pages.

  • :next_token (String)

    The token for the next set of results, or null to start from the beginning.

  • :queue_id (required, String)

    The queue ID for the storage profile.

Returns:

See Also:



4558
4559
4560
4561
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 4558

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

#list_tags_for_resource(params = {}) ⇒ Types::ListTagsForResourceResponse

Lists tags for a resource.

Examples:

Request syntax with placeholder values


resp = client.list_tags_for_resource({
  resource_arn: "String", # required
})

Response structure


resp.tags #=> Hash
resp.tags["String"] #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :resource_arn (required, String)

    The resource ARN to list tags for.

Returns:

See Also:



4587
4588
4589
4590
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 4587

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

#list_tasks(params = {}) ⇒ Types::ListTasksResponse

Lists tasks for a job.

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_tasks({
  farm_id: "FarmId", # required
  job_id: "JobId", # required
  max_results: 1,
  next_token: "String",
  queue_id: "QueueId", # required
  step_id: "StepId", # required
})

Response structure


resp.next_token #=> String
resp.tasks #=> Array
resp.tasks[0].created_at #=> Time
resp.tasks[0].created_by #=> String
resp.tasks[0].ended_at #=> Time
resp.tasks[0].failure_retry_count #=> Integer
resp.tasks[0].latest_session_action_id #=> String
resp.tasks[0].parameters #=> Hash
resp.tasks[0].parameters["String"].float #=> String
resp.tasks[0].parameters["String"].int #=> String
resp.tasks[0].parameters["String"].path #=> String
resp.tasks[0].parameters["String"].string #=> String
resp.tasks[0].run_status #=> String, one of "PENDING", "READY", "ASSIGNED", "STARTING", "SCHEDULED", "INTERRUPTING", "RUNNING", "SUSPENDED", "CANCELED", "FAILED", "SUCCEEDED", "NOT_COMPATIBLE"
resp.tasks[0].started_at #=> Time
resp.tasks[0].target_run_status #=> String, one of "READY", "FAILED", "SUCCEEDED", "CANCELED", "SUSPENDED", "PENDING"
resp.tasks[0].task_id #=> String
resp.tasks[0].updated_at #=> Time
resp.tasks[0].updated_by #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID connected to the tasks.

  • :job_id (required, String)

    The job ID for the tasks.

  • :max_results (Integer)

    The maximum number of results to return. Use this parameter with NextToken to get results as a set of sequential pages.

  • :next_token (String)

    The token for the next set of results, or null to start from the beginning.

  • :queue_id (required, String)

    The queue ID connected to the tasks.

  • :step_id (required, String)

    The step ID for the tasks.

Returns:

See Also:



4657
4658
4659
4660
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 4657

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

#list_workers(params = {}) ⇒ Types::ListWorkersResponse

Lists workers.

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_workers({
  farm_id: "FarmId", # required
  fleet_id: "FleetId", # required
  max_results: 1,
  next_token: "String",
})

Response structure


resp.next_token #=> String
resp.workers #=> Array
resp.workers[0].created_at #=> Time
resp.workers[0].created_by #=> String
resp.workers[0].farm_id #=> String
resp.workers[0].fleet_id #=> String
resp.workers[0].host_properties.ec2_instance_arn #=> String
resp.workers[0].host_properties.ec2_instance_type #=> String
resp.workers[0].host_properties.host_name #=> String
resp.workers[0].host_properties.ip_addresses.ip_v4_addresses #=> Array
resp.workers[0].host_properties.ip_addresses.ip_v4_addresses[0] #=> String
resp.workers[0].host_properties.ip_addresses.ip_v6_addresses #=> Array
resp.workers[0].host_properties.ip_addresses.ip_v6_addresses[0] #=> String
resp.workers[0].log.error #=> String
resp.workers[0].log.log_driver #=> String
resp.workers[0].log.options #=> Hash
resp.workers[0].log.options["String"] #=> String
resp.workers[0].log.parameters #=> Hash
resp.workers[0].log.parameters["String"] #=> String
resp.workers[0].status #=> String, one of "CREATED", "STARTED", "STOPPING", "STOPPED", "NOT_RESPONDING", "NOT_COMPATIBLE", "RUNNING", "IDLE"
resp.workers[0].updated_at #=> Time
resp.workers[0].updated_by #=> String
resp.workers[0].worker_id #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID connected to the workers.

  • :fleet_id (required, String)

    The fleet ID of the workers.

  • :max_results (Integer)

    The maximum number of results to return. Use this parameter with NextToken to get results as a set of sequential pages.

  • :next_token (String)

    The token for the next set of results, or null to start from the beginning.

Returns:

See Also:



4724
4725
4726
4727
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 4724

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

#put_metered_product(params = {}) ⇒ Struct

Adds a metered product.

Examples:

Request syntax with placeholder values


resp = client.put_metered_product({
  license_endpoint_id: "LicenseEndpointId", # required
  product_id: "MeteredProductId", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :license_endpoint_id (required, String)

    The license endpoint ID to add to the metered product.

  • :product_id (required, String)

    The product ID to add to the metered product.

Returns:

  • (Struct)

    Returns an empty response.

See Also:



4750
4751
4752
4753
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 4750

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

#search_jobs(params = {}) ⇒ Types::SearchJobsResponse

Searches for jobs.

Examples:

Request syntax with placeholder values


resp = client.search_jobs({
  farm_id: "FarmId", # required
  filter_expressions: {
    filters: [ # required
      {
        date_time_filter: {
          date_time: Time.now, # required
          name: "String", # required
          operator: "EQUAL", # required, accepts EQUAL, NOT_EQUAL, GREATER_THAN_EQUAL_TO, GREATER_THAN, LESS_THAN_EQUAL_TO, LESS_THAN
        },
        group_filter: {
          # recursive SearchGroupedFilterExpressions
        },
        parameter_filter: {
          name: "String", # required
          operator: "EQUAL", # required, accepts EQUAL, NOT_EQUAL, GREATER_THAN_EQUAL_TO, GREATER_THAN, LESS_THAN_EQUAL_TO, LESS_THAN
          value: "ParameterValue", # required
        },
        search_term_filter: {
          search_term: "SearchTerm", # required
        },
        string_filter: {
          name: "String", # required
          operator: "EQUAL", # required, accepts EQUAL, NOT_EQUAL, GREATER_THAN_EQUAL_TO, GREATER_THAN, LESS_THAN_EQUAL_TO, LESS_THAN
          value: "StringFilter", # required
        },
      },
    ],
    operator: "AND", # required, accepts AND, OR
  },
  item_offset: 1, # required
  page_size: 1,
  queue_ids: ["QueueId"], # required
  sort_expressions: [
    {
      field_sort: {
        name: "String", # required
        sort_order: "ASCENDING", # required, accepts ASCENDING, DESCENDING
      },
      parameter_sort: {
        name: "String", # required
        sort_order: "ASCENDING", # required, accepts ASCENDING, DESCENDING
      },
      user_jobs_first: {
        user_identity_id: "String", # required
      },
    },
  ],
})

Response structure


resp.jobs #=> Array
resp.jobs[0].created_at #=> Time
resp.jobs[0].created_by #=> String
resp.jobs[0].ended_at #=> Time
resp.jobs[0].job_id #=> String
resp.jobs[0].job_parameters #=> Hash
resp.jobs[0].job_parameters["String"].float #=> String
resp.jobs[0].job_parameters["String"].int #=> String
resp.jobs[0].job_parameters["String"].path #=> String
resp.jobs[0].job_parameters["String"].string #=> String
resp.jobs[0].lifecycle_status #=> String, one of "CREATE_IN_PROGRESS", "CREATE_FAILED", "CREATE_COMPLETE", "UPLOAD_IN_PROGRESS", "UPLOAD_FAILED", "UPDATE_IN_PROGRESS", "UPDATE_FAILED", "UPDATE_SUCCEEDED", "ARCHIVED"
resp.jobs[0].lifecycle_status_message #=> String
resp.jobs[0].max_failed_tasks_count #=> Integer
resp.jobs[0].max_retries_per_task #=> Integer
resp.jobs[0].name #=> String
resp.jobs[0].priority #=> Integer
resp.jobs[0].queue_id #=> String
resp.jobs[0].started_at #=> Time
resp.jobs[0].target_task_run_status #=> String, one of "READY", "FAILED", "SUCCEEDED", "CANCELED", "SUSPENDED", "PENDING"
resp.jobs[0].task_run_status #=> String, one of "PENDING", "READY", "ASSIGNED", "STARTING", "SCHEDULED", "INTERRUPTING", "RUNNING", "SUSPENDED", "CANCELED", "FAILED", "SUCCEEDED", "NOT_COMPATIBLE"
resp.jobs[0].task_run_status_counts #=> Hash
resp.jobs[0].task_run_status_counts["TaskRunStatus"] #=> Integer
resp.next_item_offset #=> Integer
resp.total_results #=> Integer

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID of the job.

  • :filter_expressions (Types::SearchGroupedFilterExpressions)

    The filter expression, AND or OR, to use when searching among a group of search strings in a resource. You can use two groupings per search each within parenthesis ().

  • :item_offset (required, Integer)

    Defines how far into the scrollable list to start the return of results.

  • :page_size (Integer)

    Specifies the number of items per page for the resource.

  • :queue_ids (required, Array<String>)

    The queue ID to use in the job search.

  • :sort_expressions (Array<Types::SearchSortExpression>)

    The search terms for a resource.

Returns:

See Also:



4867
4868
4869
4870
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 4867

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

#search_steps(params = {}) ⇒ Types::SearchStepsResponse

Searches for steps.

Examples:

Request syntax with placeholder values


resp = client.search_steps({
  farm_id: "FarmId", # required
  filter_expressions: {
    filters: [ # required
      {
        date_time_filter: {
          date_time: Time.now, # required
          name: "String", # required
          operator: "EQUAL", # required, accepts EQUAL, NOT_EQUAL, GREATER_THAN_EQUAL_TO, GREATER_THAN, LESS_THAN_EQUAL_TO, LESS_THAN
        },
        group_filter: {
          # recursive SearchGroupedFilterExpressions
        },
        parameter_filter: {
          name: "String", # required
          operator: "EQUAL", # required, accepts EQUAL, NOT_EQUAL, GREATER_THAN_EQUAL_TO, GREATER_THAN, LESS_THAN_EQUAL_TO, LESS_THAN
          value: "ParameterValue", # required
        },
        search_term_filter: {
          search_term: "SearchTerm", # required
        },
        string_filter: {
          name: "String", # required
          operator: "EQUAL", # required, accepts EQUAL, NOT_EQUAL, GREATER_THAN_EQUAL_TO, GREATER_THAN, LESS_THAN_EQUAL_TO, LESS_THAN
          value: "StringFilter", # required
        },
      },
    ],
    operator: "AND", # required, accepts AND, OR
  },
  item_offset: 1, # required
  job_id: "JobId",
  page_size: 1,
  queue_ids: ["QueueId"], # required
  sort_expressions: [
    {
      field_sort: {
        name: "String", # required
        sort_order: "ASCENDING", # required, accepts ASCENDING, DESCENDING
      },
      parameter_sort: {
        name: "String", # required
        sort_order: "ASCENDING", # required, accepts ASCENDING, DESCENDING
      },
      user_jobs_first: {
        user_identity_id: "String", # required
      },
    },
  ],
})

Response structure


resp.next_item_offset #=> Integer
resp.steps #=> Array
resp.steps[0].created_at #=> Time
resp.steps[0].ended_at #=> Time
resp.steps[0].job_id #=> String
resp.steps[0].lifecycle_status #=> String, one of "CREATE_COMPLETE", "UPDATE_IN_PROGRESS", "UPDATE_FAILED", "UPDATE_SUCCEEDED"
resp.steps[0].lifecycle_status_message #=> String
resp.steps[0].name #=> String
resp.steps[0].parameter_space.combination #=> String
resp.steps[0].parameter_space.parameters #=> Array
resp.steps[0].parameter_space.parameters[0].name #=> String
resp.steps[0].parameter_space.parameters[0].type #=> String, one of "INT", "FLOAT", "STRING", "PATH"
resp.steps[0].queue_id #=> String
resp.steps[0].started_at #=> Time
resp.steps[0].step_id #=> String
resp.steps[0].target_task_run_status #=> String, one of "READY", "FAILED", "SUCCEEDED", "CANCELED", "SUSPENDED", "PENDING"
resp.steps[0].task_run_status #=> String, one of "PENDING", "READY", "ASSIGNED", "STARTING", "SCHEDULED", "INTERRUPTING", "RUNNING", "SUSPENDED", "CANCELED", "FAILED", "SUCCEEDED", "NOT_COMPATIBLE"
resp.steps[0].task_run_status_counts #=> Hash
resp.steps[0].task_run_status_counts["TaskRunStatus"] #=> Integer
resp.total_results #=> Integer

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID to use for the step search.

  • :filter_expressions (Types::SearchGroupedFilterExpressions)

    The filter expression, AND or OR, to use when searching among a group of search strings in a resource. You can use two groupings per search each within parenthesis ().

  • :item_offset (required, Integer)

    Defines how far into the scrollable list to start the return of results.

  • :job_id (String)

    The job ID to use in the step search.

  • :page_size (Integer)

    Specifies the number of items per page for the resource.

  • :queue_ids (required, Array<String>)

    The queue IDs in the step search.

  • :sort_expressions (Array<Types::SearchSortExpression>)

    The search terms for a resource.

Returns:

See Also:



4984
4985
4986
4987
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 4984

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

#search_tasks(params = {}) ⇒ Types::SearchTasksResponse

Searches for tasks.

Examples:

Request syntax with placeholder values


resp = client.search_tasks({
  farm_id: "FarmId", # required
  filter_expressions: {
    filters: [ # required
      {
        date_time_filter: {
          date_time: Time.now, # required
          name: "String", # required
          operator: "EQUAL", # required, accepts EQUAL, NOT_EQUAL, GREATER_THAN_EQUAL_TO, GREATER_THAN, LESS_THAN_EQUAL_TO, LESS_THAN
        },
        group_filter: {
          # recursive SearchGroupedFilterExpressions
        },
        parameter_filter: {
          name: "String", # required
          operator: "EQUAL", # required, accepts EQUAL, NOT_EQUAL, GREATER_THAN_EQUAL_TO, GREATER_THAN, LESS_THAN_EQUAL_TO, LESS_THAN
          value: "ParameterValue", # required
        },
        search_term_filter: {
          search_term: "SearchTerm", # required
        },
        string_filter: {
          name: "String", # required
          operator: "EQUAL", # required, accepts EQUAL, NOT_EQUAL, GREATER_THAN_EQUAL_TO, GREATER_THAN, LESS_THAN_EQUAL_TO, LESS_THAN
          value: "StringFilter", # required
        },
      },
    ],
    operator: "AND", # required, accepts AND, OR
  },
  item_offset: 1, # required
  job_id: "JobId",
  page_size: 1,
  queue_ids: ["QueueId"], # required
  sort_expressions: [
    {
      field_sort: {
        name: "String", # required
        sort_order: "ASCENDING", # required, accepts ASCENDING, DESCENDING
      },
      parameter_sort: {
        name: "String", # required
        sort_order: "ASCENDING", # required, accepts ASCENDING, DESCENDING
      },
      user_jobs_first: {
        user_identity_id: "String", # required
      },
    },
  ],
})

Response structure


resp.next_item_offset #=> Integer
resp.tasks #=> Array
resp.tasks[0].ended_at #=> Time
resp.tasks[0].failure_retry_count #=> Integer
resp.tasks[0].job_id #=> String
resp.tasks[0].parameters #=> Hash
resp.tasks[0].parameters["String"].float #=> String
resp.tasks[0].parameters["String"].int #=> String
resp.tasks[0].parameters["String"].path #=> String
resp.tasks[0].parameters["String"].string #=> String
resp.tasks[0].queue_id #=> String
resp.tasks[0].run_status #=> String, one of "PENDING", "READY", "ASSIGNED", "STARTING", "SCHEDULED", "INTERRUPTING", "RUNNING", "SUSPENDED", "CANCELED", "FAILED", "SUCCEEDED", "NOT_COMPATIBLE"
resp.tasks[0].started_at #=> Time
resp.tasks[0].step_id #=> String
resp.tasks[0].target_run_status #=> String, one of "READY", "FAILED", "SUCCEEDED", "CANCELED", "SUSPENDED", "PENDING"
resp.tasks[0].task_id #=> String
resp.total_results #=> Integer

Parameters:

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

    ({})

Options Hash (params):

  • :farm_id (required, String)

    The farm ID of the task.

  • :filter_expressions (Types::SearchGroupedFilterExpressions)

    The filter expression, AND or OR, to use when searching among a group of search strings in a resource. You can use two groupings per search each within parenthesis ().

  • :item_offset (required, Integer)

    Defines how far into the scrollable list to start the return of results.

  • :job_id (String)

    The job ID for the task search.

  • :page_size (Integer)

    Specifies the number of items per page for the resource.

  • :queue_ids (required, Array<String>)

    The queue IDs to include in the search.

  • :sort_expressions (Array<Types::SearchSortExpression>)

    The search terms for a resource.

Returns:

See Also:



5098
5099
5100
5101
# File 'gems/aws-sdk-deadline/lib/aws-sdk-deadline/client.rb', line 5098

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

#search_workers(params = {}) ⇒ Types::SearchWorkersResponse

Searches for workers.

Examples:

Request syntax with placeholder values


resp = client.search_workers({
  farm_id: "FarmId", # required
  filter_expressions: {
    filters: [ # required
      {
        date_time_filter: {
          date_time: Time.now, # required
          name: "String", # required
          operator: "EQUAL", # required, accepts EQUAL, NOT_EQUAL, GREATER_THAN_EQUAL_TO, GREATER_THAN, LESS_THAN_EQUAL_TO, LESS_THAN
        },
        group_filter: {
          # recursive SearchGroupedFilterExpressions
        },
        parameter_filter: {
          name: "String", # required
          operator: "EQUAL", # required, accepts EQUAL, NOT_EQUAL, GREATER_THAN_EQUAL_TO, GREATER_THAN, LESS_THAN_EQUAL_TO, LESS_THAN
          value: "ParameterValue", # required
        },
        search_term_filter: {
          search_term: "SearchTerm", # required
        },
        string_filter: {
          name: "String", # required
          operator: "EQUAL", # required, accepts EQUAL, NOT_EQUAL, GREATER_THAN_EQUAL_TO, GREATER_THAN, LESS_THAN_EQUAL_TO, LESS_THAN
          value: "StringFilter", # required
        },
      },
    ],
    operator: "AND", # required, accepts AND, OR
  },
  fleet_ids: ["FleetId"], # required
  item_offset: 1, # required
  page_size: 1,
  sort_expressions: [
    {
      field_sort: {
        name: "String", # required
        sort_order: "ASCENDING", # required, accepts ASCENDING, DESCENDING
      },
      parameter_sort: {
        name: "String", # required
        sort_order: "ASCENDING", # required, accepts ASCENDING, DESCENDING
      },
      user_jobs_first: {
        user_identity_id: "String", # required
      },
    },
  ],
})

Response structure


resp.next_item_offset #=> Integer
resp.total_results #=> Integer
resp.workers #=> Array
resp.workers[0].created_at #=> Time
resp.workers[0].created_by #=> String
resp.workers[0].fleet_id #=> String
resp.workers[0].host_properties.ec2_instance_arn #=> String
resp.workers[0].host_properties.ec2_instance_type #=> String
resp.workers[0].host_properties.host_name #=> String
resp.workers[0].host_properties.ip_addresses.ip_v4_addresses #=> Array
resp.workers[0].host_properties.ip_addresses.ip_v4_addresses[0] #=> String
resp.workers[0].host_properties.ip_addresses.ip_v6_addresses #=> Array
resp.workers[0].host_properties.ip_addresses.ip_v6_addresses[0] #=> String
resp.workers[0].status #=> String, one of "CREATED", "STARTED", "STOPPING", "STOPPED", "NOT_RESPONDING", "NOT_COMPATIBLE", "RUNNING", "IDLE"
resp.workers[0].updated_at #=> Time
resp.workers[0].updated_by #=> String
resp.workers[0]