Class: Aws::Deadline::Client

Inherits:
Seahorse::Client::Base
  • Object
show all
Includes:
ClientStubs
Defined in:
lib/aws-sdk-deadline/client.rb,
sig/client.rbs

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.

Defined Under Namespace

Modules: _AssociateMemberToFarmResponseSuccess, _AssociateMemberToFleetResponseSuccess, _AssociateMemberToJobResponseSuccess, _AssociateMemberToQueueResponseSuccess, _AssumeFleetRoleForReadResponseSuccess, _AssumeFleetRoleForWorkerResponseSuccess, _AssumeQueueRoleForReadResponseSuccess, _AssumeQueueRoleForUserResponseSuccess, _AssumeQueueRoleForWorkerResponseSuccess, _BatchGetJobEntityResponseSuccess, _BatchGetJobResponseSuccess, _BatchGetSessionActionResponseSuccess, _BatchGetSessionResponseSuccess, _BatchGetStepResponseSuccess, _BatchGetTaskResponseSuccess, _BatchGetWorkerResponseSuccess, _BatchUpdateJobResponseSuccess, _BatchUpdateTaskResponseSuccess, _CopyJobTemplateResponseSuccess, _CreateBudgetResponseSuccess, _CreateFarmResponseSuccess, _CreateFleetResponseSuccess, _CreateJobResponseSuccess, _CreateLicenseEndpointResponseSuccess, _CreateLimitResponseSuccess, _CreateMonitorResponseSuccess, _CreateQueueEnvironmentResponseSuccess, _CreateQueueFleetAssociationResponseSuccess, _CreateQueueLimitAssociationResponseSuccess, _CreateQueueResponseSuccess, _CreateStorageProfileResponseSuccess, _CreateWorkerResponseSuccess, _DeleteBudgetResponseSuccess, _DeleteFarmResponseSuccess, _DeleteFleetResponseSuccess, _DeleteLicenseEndpointResponseSuccess, _DeleteLimitResponseSuccess, _DeleteMeteredProductResponseSuccess, _DeleteMonitorResponseSuccess, _DeleteQueueEnvironmentResponseSuccess, _DeleteQueueFleetAssociationResponseSuccess, _DeleteQueueLimitAssociationResponseSuccess, _DeleteQueueResponseSuccess, _DeleteStorageProfileResponseSuccess, _DeleteVolumeResponseSuccess, _DeleteWorkerResponseSuccess, _DisassociateMemberFromFarmResponseSuccess, _DisassociateMemberFromFleetResponseSuccess, _DisassociateMemberFromJobResponseSuccess, _DisassociateMemberFromQueueResponseSuccess, _GetBudgetResponseSuccess, _GetFarmResponseSuccess, _GetFleetResponseSuccess, _GetJobResponseSuccess, _GetLicenseEndpointResponseSuccess, _GetLimitResponseSuccess, _GetMonitorResponseSuccess, _GetMonitorSettingsResponseSuccess, _GetQueueEnvironmentResponseSuccess, _GetQueueFleetAssociationResponseSuccess, _GetQueueLimitAssociationResponseSuccess, _GetQueueResponseSuccess, _GetSessionActionResponseSuccess, _GetSessionResponseSuccess, _GetSessionsStatisticsAggregationResponseSuccess, _GetStepResponseSuccess, _GetStorageProfileForQueueResponseSuccess, _GetStorageProfileResponseSuccess, _GetTaskResponseSuccess, _GetVolumeResponseSuccess, _GetWorkerResponseSuccess, _ListAvailableMeteredProductsResponseSuccess, _ListBudgetsResponseSuccess, _ListFarmMembersResponseSuccess, _ListFarmsResponseSuccess, _ListFleetMembersResponseSuccess, _ListFleetsResponseSuccess, _ListJobMembersResponseSuccess, _ListJobParameterDefinitionsResponseSuccess, _ListJobsResponseSuccess, _ListLicenseEndpointsResponseSuccess, _ListLimitsResponseSuccess, _ListMeteredProductsResponseSuccess, _ListMonitorsResponseSuccess, _ListQueueEnvironmentsResponseSuccess, _ListQueueFleetAssociationsResponseSuccess, _ListQueueLimitAssociationsResponseSuccess, _ListQueueMembersResponseSuccess, _ListQueuesResponseSuccess, _ListSessionActionsResponseSuccess, _ListSessionsForWorkerResponseSuccess, _ListSessionsResponseSuccess, _ListStepConsumersResponseSuccess, _ListStepDependenciesResponseSuccess, _ListStepsResponseSuccess, _ListStorageProfilesForQueueResponseSuccess, _ListStorageProfilesResponseSuccess, _ListTagsForResourceResponseSuccess, _ListTasksResponseSuccess, _ListVolumesResponseSuccess, _ListWorkersResponseSuccess, _PutMeteredProductResponseSuccess, _SearchJobsResponseSuccess, _SearchStepsResponseSuccess, _SearchTasksResponseSuccess, _SearchWorkersResponseSuccess, _StartSessionsStatisticsAggregationResponseSuccess, _TagResourceResponseSuccess, _UntagResourceResponseSuccess, _UpdateBudgetResponseSuccess, _UpdateFarmResponseSuccess, _UpdateFleetResponseSuccess, _UpdateJobResponseSuccess, _UpdateLimitResponseSuccess, _UpdateMonitorResponseSuccess, _UpdateMonitorSettingsResponseSuccess, _UpdateQueueEnvironmentResponseSuccess, _UpdateQueueFleetAssociationResponseSuccess, _UpdateQueueLimitAssociationResponseSuccess, _UpdateQueueResponseSuccess, _UpdateSessionResponseSuccess, _UpdateStepResponseSuccess, _UpdateStorageProfileResponseSuccess, _UpdateTaskResponseSuccess, _UpdateWorkerResponseSuccess, _UpdateWorkerScheduleResponseSuccess

Constant Summary collapse

Params =

Returns:

  • (:search_sort_expression) 

      
    

  




  
Class Attribute Summary collapse

  




  
    

      API Operations
      collapse
    


    
    
  
    

      Class Method Summary
      collapse
    


    
    
  
    

      Instance Method Summary
      collapse
    


    
    
  


  
  

  
Constructor Details

  
    

  

  
    #initialize(options)  ⇒ Client 
  

  

  


  

    
Returns a new instance of Client.


  





  
  

  

    

  





  
Parameters:


    
  
    
  • 
      
        options
      
      
        (Hash)
      
      
      
    
    • 
  



  
    
    
    
Options Hash (options):

    
    
      
        
  • 
          :plugins
          (Array<Seahorse::Client::Plugin>)
          
            
              — default:
              []]
            
          
          
            — 
    A list of plugins to apply to the client. Each plugin is either a
class name or an instance of a plugin class.
    
          
        
    • 
      
        
  • 
          :credentials
          (required, Aws::CredentialProvider)
          
            
          
          
            — 
    Your AWS credentials used for authentication. This can be any class that includes and implements
Aws::CredentialProvider, or instance of any one of the following classes:
    

      

    • 

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

      • 

    • 

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

      • 

    • 

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

      • 

    • 

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

      • 

    • 

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

      • 

    • 

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

      • 

    • 

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

      • 

    • 

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

      • 

    • 

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

      • 

    

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

      

    • 

      Aws.config[:credentials]
      

      • 

    • 

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

      • 

    • 

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

      • 

    • 

      ~/.aws/credentials
      

      • 

    • 

      ~/.aws/config
      

      • 

    • 

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

      • 

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

      

    • Aws.config[:region]
      • 

    • ENV['AWS_REGION']
      • 

    • ENV['AMAZON_REGION']
      • 

    • ENV['AWS_DEFAULT_REGION']
      • 

    • ~/.aws/credentials
      • 

    • ~/.aws/config
      • 

    
          
        
    • 
      
        
  • 
          :access_key_id
          (String)
          
            
          
          
        
    • 
      
        
  • 
          :account_id
          (String)
          
            
          
          
        
    • 
      
        
  • 
          :active_endpoint_cache
          (Boolean)
          
            
              — default:
              false
            
          
          
            — 
    When set to true, a thread polling for endpoints will be running in
the background every 60 secs (default). Defaults to false.
    
          
        
    • 
      
        
  • 
          :adaptive_retry_wait_to_fill
          (Boolean)
          
            
              — default:
              true
            
          
          
            — 
    Used only in adaptive retry mode.  When true, the request will sleep
until there is sufficent client side capacity to retry the request.
When false, the request will raise a RetryCapacityNotAvailableError and will
not retry instead of sleeping.
    
          
        
    • 
      
        
  • 
          :auth_scheme_preference
          (Array<String>)
          
            
          
          
            — 
    A list of preferred authentication schemes to use when making a request. Supported values are:
sigv4, sigv4a, httpBearerAuth, and noAuth. When set using ENV['AWS_AUTH_SCHEME_PREFERENCE'] or in
shared config as auth_scheme_preference, the value should be a comma-separated list.
    
          
        
    • 
      
        
  • 
          :client_side_monitoring
          (Boolean)
          
            
              — default:
              false
            
          
          
            — 
    When true, client-side metrics will be collected for all API requests from
this client.
    
          
        
    • 
      
        
  • 
          :client_side_monitoring_client_id
          (String)
          
            
              — default:
              ""
            
          
          
            — 
    Allows you to provide an identifier for this client which will be attached to
all generated client side metrics. Defaults to an empty string.
    
          
        
    • 
      
        
  • 
          :client_side_monitoring_host
          (String)
          
            
              — default:
              "127.0.0.1"
            
          
          
            — 
    Allows you to specify the DNS hostname or IPv4 or IPv6 address that the client
side monitoring agent is running on, where client metrics will be published via UDP.
    
          
        
    • 
      
        
  • 
          :client_side_monitoring_port
          (Integer)
          
            
              — default:
              31000
            
          
          
            — 
    Required for publishing client metrics. The port that the client side monitoring
agent is running on, where client metrics will be published via UDP.
    
          
        
    • 
      
        
  • 
          :client_side_monitoring_publisher
          (Aws::ClientSideMonitoring::Publisher)
          
            
              — default:
              Aws::ClientSideMonitoring::Publisher
            
          
          
            — 
    Allows you to provide a custom client-side monitoring publisher class. By default,
will use the Client Side Monitoring Agent Publisher.
    
          
        
    • 
      
        
  • 
          :convert_params
          (Boolean)
          
            
              — default:
              true
            
          
          
            — 
    When true, an attempt is made to coerce request parameters into
the required types.
    
          
        
    • 
      
        
  • 
          :correct_clock_skew
          (Boolean)
          
            
              — default:
              true
            
          
          
            — 
    Used only in standard and adaptive retry modes. Specifies whether to apply
a clock skew correction and retry requests with skewed client clocks.
    
          
        
    • 
      
        
  • 
          :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
            
          
          
            — 
    When true, the SDK will not prepend the modeled host prefix to the endpoint.
    
          
        
    • 
      
        
  • 
          :disable_request_compression
          (Boolean)
          
            
              — default:
              false
            
          
          
            — 
    When set to 'true' the request body will not be compressed
for supported operations.
    
          
        
    • 
      
        
  • 
          :endpoint
          (String, URI::HTTPS, URI::HTTP)
          
            
          
          
            — 
    Normally you should not configure the :endpoint option
directly. This is normally constructed from the :region
option. Configuring :endpoint is normally reserved for
connecting to test or custom endpoints. The endpoint should
be a URI formatted like:
    

    'http://example.com'
'https://example.com'
'http://example.com:123'
    
          
        
    • 
      
        
  • 
          :endpoint_cache_max_entries
          (Integer)
          
            
              — default:
              1000
            
          
          
            — 
    Used for the maximum size limit of the LRU cache storing endpoints data
for endpoint discovery enabled operations. Defaults to 1000.
    
          
        
    • 
      
        
  • 
          :endpoint_cache_max_threads
          (Integer)
          
            
              — default:
              10
            
          
          
            — 
    Used for the maximum threads in use for polling endpoints to be cached, defaults to 10.
    
          
        
    • 
      
        
  • 
          :endpoint_cache_poll_interval
          (Integer)
          
            
              — default:
              60
            
          
          
            — 
    When :endpoint_discovery and :active_endpoint_cache is enabled,
Use this option to config the time interval in seconds for making
requests fetching endpoints information. Defaults to 60 sec.
    
          
        
    • 
      
        
  • 
          :endpoint_discovery
          (Boolean)
          
            
              — default:
              false
            
          
          
            — 
    When set to true, endpoint discovery will be enabled for operations when available.
    
          
        
    • 
      
        
  • 
          :ignore_configured_endpoint_urls
          (Boolean)
          
            
          
          
            — 
    Setting to true disables use of endpoint URLs provided via environment
variables and the shared configuration file.
    
          
        
    • 
      
        
  • 
          :log_formatter
          (Aws::Log::Formatter)
          
            
              — default:
              Aws::Log::Formatter.default
            
          
          
            — 
    The log formatter.
    
          
        
    • 
      
        
  • 
          :log_level
          (Symbol)
          
            
              — default:
              :info
            
          
          
            — 
    The log level to send messages to the :logger at.
    
          
        
    • 
      
        
  • 
          :logger
          (Logger)
          
            
          
          
            — 
    The Logger instance to send log messages to.  If this option
is not set, logging will be disabled.
    
          
        
    • 
      
        
  • 
          :max_attempts
          (Integer)
          
            
              — default:
              3
            
          
          
            — 
    An integer representing the maximum number attempts that will be made for
a single request, including the initial attempt.  For example,
setting this value to 5 will result in a request being retried up to
4 times. Used in standard and adaptive retry modes.
    
          
        
    • 
      
        
  • 
          :profile
          (String)
          
            
              — default:
              "default"
            
          
          
            — 
    Used when loading credentials from the shared credentials file at HOME/.aws/credentials.
When not specified, 'default' is used.
    
          
        
    • 
      
        
  • 
          :request_checksum_calculation
          (String)
          
            
              — default:
              "when_supported"
            
          
          
            — 
    Determines when a checksum will be calculated for request payloads. Values are:
    

      

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

    • when_required - When set, a checksum will only be calculated for
request payloads of operations modeled with the  httpChecksum trait where
requestChecksumRequired is true or where a requestAlgorithmMember
is modeled and supplied.
      • 

    
          
        
    • 
      
        
  • 
          :request_min_compression_size_bytes
          (Integer)
          
            
              — default:
              10240
            
          
          
            — 
    The minimum size in bytes that triggers compression for request
bodies. The value must be non-negative integer value between 0
and 10485780 bytes inclusive.
    
          
        
    • 
      
        
  • 
          :response_checksum_validation
          (String)
          
            
              — default:
              "when_supported"
            
          
          
            — 
    Determines when checksum validation will be performed on response payloads. Values are:
    

      

    • when_supported - (default) When set, checksum validation is performed on all
response payloads of operations modeled with the httpChecksum trait where
responseAlgorithms is modeled, except when no modeled checksum algorithms
are supported.
      • 

    • when_required - When set, checksum validation is not performed on
response payloads of operations unless the checksum algorithm is supported and
the requestValidationModeMember member is set to ENABLED.
      • 

    
          
        
    • 
      
        
  • 
          :retry_backoff
          (Proc)
          
            
          
          
            — 
    A proc or lambda used for backoff. Defaults to 2**retries * retry_base_delay.
This option is only used in the legacy retry mode.
    
          
        
    • 
      
        
  • 
          :retry_base_delay
          (Float)
          
            
              — default:
              0.3
            
          
          
            — 
    The base delay in seconds used by the default backoff function. This option
is only used in the legacy retry mode.
    
          
        
    • 
      
        
  • 
          :retry_jitter
          (Symbol)
          
            
              — default:
              :none
            
          
          
            — 
    A delay randomiser function used by the default backoff function.
Some predefined functions can be referenced by name - :none, :equal, :full,
otherwise a Proc that takes and returns a number. This option is only used
in the legacy retry mode.
    

    @see https://www.awsarchitectureblog.com/2015/03/backoff.html
    
          
        
    • 
      
        
  • 
          :retry_limit
          (Integer)
          
            
              — default:
              3
            
          
          
            — 
    The maximum number of times to retry failed requests.  Only
~ 500 level server errors and certain ~ 400 level client errors
are retried.  Generally, these are throttling errors, data
checksum errors, networking errors, timeout errors, auth errors,
endpoint discovery, and errors from expired credentials.
This option is only used in the legacy retry mode.
    
          
        
    • 
      
        
  • 
          :retry_max_delay
          (Integer)
          
            
              — default:
              0
            
          
          
            — 
    The maximum number of seconds to delay between retries (0 for no limit)
used by the default backoff function. This option is only used in the
legacy retry mode.
    
          
        
    • 
      
        
  • 
          :retry_mode
          (String)
          
            
              — default:
              "legacy"
            
          
          
            — 
    Specifies which retry algorithm to use. Values are:
    

      

    • 

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

      • 

    • 

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

      • 

    • 

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

      • 

    
          
        
    • 
      
        
  • 
          :sdk_ua_app_id
          (String)
          
            
          
          
            — 
    A unique and opaque application ID that is appended to the
User-Agent header as app/sdk_ua_app_id. It should have a
maximum length of 50. This variable is sourced from environment
variable AWS_SDK_UA_APP_ID or the shared config profile attribute sdk_ua_app_id.
    
          
        
    • 
      
        
  • 
          :secret_access_key
          (String)
          
            
          
          
        
    • 
      
        
  • 
          :session_token
          (String)
          
            
          
          
        
    • 
      
        
  • 
          :sigv4a_signing_region_set
          (Array)
          
            
          
          
            — 
    A list of regions that should be signed with SigV4a signing. When
not passed, a default :sigv4a_signing_region_set is searched for
in the following locations:
    

      

    • Aws.config[:sigv4a_signing_region_set]
      • 

    • ENV['AWS_SIGV4A_SIGNING_REGION_SET']
      • 

    • ~/.aws/config
      • 

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

    ** Please note ** When response stubbing is enabled, no HTTP
requests are made, and retries are disabled.
    
          
        
    • 
      
        
  • 
          :telemetry_provider
          (Aws::Telemetry::TelemetryProviderBase)
          
            
              — default:
              Aws::Telemetry::NoOpTelemetryProvider
            
          
          
            — 
    Allows you to provide a telemetry provider, which is used to
emit telemetry data. By default, uses NoOpTelemetryProvider which
will not record or emit any telemetry data. The SDK supports the
following telemetry providers:
    

      

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

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

      

    • 

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

      • 

    • 

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

      • 

    

    When :token_provider is not configured directly, the Aws::TokenProviderChain
will be used to search for tokens configured for your profile in shared configuration files.
    
          
        
    • 
      
        
  • 
          :use_dualstack_endpoint
          (Boolean)
          
            
          
          
            — 
    When set to true, dualstack enabled endpoints (with .aws TLD)
will be used if available.
    
          
        
    • 
      
        
  • 
          :use_fips_endpoint
          (Boolean)
          
            
          
          
            — 
    When set to true, fips compatible endpoints will be used if available.
When a fips region is used, the region is normalized and this config
is set to true.
    
          
        
    • 
      
        
  • 
          :validate_params
          (Boolean)
          
            
              — default:
              true
            
          
          
            — 
    When true, request parameters are validated before
sending the request.
    
          
        
    • 
      
        
  • 
          :endpoint_provider
          (Aws::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_cert
          (OpenSSL::X509::Certificate)
          
            
          
          
            — 
    Sets a client certificate when creating http connections.
    
          
        
    • 
      
        
  • 
          :ssl_key
          (OpenSSL::PKey)
          
            
          
          
            — 
    Sets a client key when creating http connections.
    
          
        
    • 
      
        
  • 
          :ssl_timeout
          (Float)
          
            
          
          
            — 
    Sets the SSL timeout in seconds
    
          
        
    • 
      
        
  • 
          :ssl_verify_peer
          (Boolean)
          
            
              — default:
              true
            
          
          
            — 
    When true, SSL peer certificates are verified when establishing a connection.
    
          
        
    • 
      
    

  








  

    
      


471
472
473

    		
    
      
# File 'lib/aws-sdk-deadline/client.rb', line 471

def initialize(*args)
  super
end

    		
  





  



  

    
Class Attribute Details

    
      
      
      

  

  
    .identifier  ⇒ Object  (readonly)
  

  

  


  

    

  This method is part of a private API.
  You should avoid using this method if possible, as it may be removed or be changed in the future.




  





  



  

    
      


8509
8510
8511

    		
    
      
# File 'lib/aws-sdk-deadline/client.rb', line 8509

def identifier
  @identifier
end

    		
  





    
  



  

    
Class Method Details


    
      

  

  
    .errors_module  ⇒ Object 
  

  

  


  

    

  This method is part of a private API.
  You should avoid using this method if possible, as it may be removed or be changed in the future.




  





  



  

    
      


8512
8513
8514

    		
    
      
# File 'lib/aws-sdk-deadline/client.rb', line 8512

def errors_module
  Errors
end

    		
  





    
      

  

  
    .new  ⇒ Object 
  

  

  


  

    
https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Deadline/Client.html#initialize-instance_method


  





  



  

    
      


14

    		
    
      
# File 'sig/client.rbs', line 14

def self.new: (

    		
  





    
  


  

    
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
  principal_type: "USER", # required, accepts USER, GROUP
  identity_store_id: "IdentityStoreId", # required
  membership_level: "VIEWER", # required, accepts VIEWER, CONTRIBUTOR, OWNER, MANAGER
  principal_id: "IdentityCenterPrincipalId", # required
  identity_center_region: "Region",
})

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The ID of the farm to associate with the member.
    
          
        
    • 
      
        
  • 
          :principal_type
          (required, String)
          
            
          
          
            — 
    The principal type of the member to associate with the farm.
    
          
        
    • 
      
        
  • 
          :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.
    
          
        
    • 
      
        
  • 
          :identity_center_region
          (String)
          
            
          
          
            — 
    The Region of the IAM Identity Center instance. If not provided, the
service defaults to the Region of the farm.
    
          
        
    • 
      
    

  
    
    


Returns:


    
  
    
  • 
      
      
        (Struct)
      
      
      
        —
        
    Returns an empty response.
    
      
    
    • 
  



  
See Also:

  



  

    
      


85

    		
    
      
# File 'sig/client.rbs', line 85

def associate_member_to_farm: (

    		
  





    
      

  

  
    #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
  principal_type: "USER", # required, accepts USER, GROUP
  identity_store_id: "IdentityStoreId", # required
  membership_level: "VIEWER", # required, accepts VIEWER, CONTRIBUTOR, OWNER, MANAGER
  principal_id: "IdentityCenterPrincipalId", # required
  identity_center_region: "Region",
})

    
  


  

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.
    
          
        
    • 
      
        
  • 
          :principal_type
          (required, String)
          
            
          
          
            — 
    The member's principal type to associate with the fleet.
    
          
        
    • 
      
        
  • 
          :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.
    
          
        
    • 
      
        
  • 
          :identity_center_region
          (String)
          
            
          
          
            — 
    The Region of the IAM Identity Center instance. If not provided, the
service defaults to the Region of the farm.
    
          
        
    • 
      
    

  
    
    


Returns:


    
  
    
  • 
      
      
        (Struct)
      
      
      
        —
        
    Returns an empty response.
    
      
    
    • 
  



  
See Also:

  



  

    
      


99

    		
    
      
# File 'sig/client.rbs', line 99

def associate_member_to_fleet: (

    		
  





    
      

  

  
    #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
  queue_id: "QueueId", # required
  job_id: "JobId", # required
  principal_type: "USER", # required, accepts USER, GROUP
  identity_store_id: "IdentityStoreId", # required
  membership_level: "VIEWER", # required, accepts VIEWER, CONTRIBUTOR, OWNER, MANAGER
  principal_id: "IdentityCenterPrincipalId", # required
  identity_center_region: "Region",
})

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID of the job to associate with the member.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The queue ID to associate to the member.
    
          
        
    • 
      
        
  • 
          :job_id
          (required, String)
          
            
          
          
            — 
    The job ID to associate with the member.
    
          
        
    • 
      
        
  • 
          :principal_type
          (required, String)
          
            
          
          
            — 
    The member's principal type to associate with the job.
    
          
        
    • 
      
        
  • 
          :identity_store_id
          (required, String)
          
            
          
          
            — 
    The member's identity store ID to associate with the job.
    
          
        
    • 
      
        
  • 
          :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.
    
          
        
    • 
      
        
  • 
          :identity_center_region
          (String)
          
            
          
          
            — 
    The Region of the IAM Identity Center instance. If not provided, the
service defaults to the Region of the farm.
    
          
        
    • 
      
    

  
    
    


Returns:


    
  
    
  • 
      
      
        (Struct)
      
      
      
        —
        
    Returns an empty response.
    
      
    
    • 
  



  
See Also:

  



  

    
      


114

    		
    
      
# File 'sig/client.rbs', line 114

def associate_member_to_job: (

    		
  





    
      

  

  
    #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
  queue_id: "QueueId", # required
  principal_type: "USER", # required, accepts USER, GROUP
  identity_store_id: "IdentityStoreId", # required
  membership_level: "VIEWER", # required, accepts VIEWER, CONTRIBUTOR, OWNER, MANAGER
  principal_id: "IdentityCenterPrincipalId", # required
  identity_center_region: "Region",
})

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID of the queue to associate with the member.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The ID of the queue to associate to the member.
    
          
        
    • 
      
        
  • 
          :principal_type
          (required, String)
          
            
          
          
            — 
    The member's principal type to associate with the queue.
    
          
        
    • 
      
        
  • 
          :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.
    
          
        
    • 
      
        
  • 
          :identity_center_region
          (String)
          
            
          
          
            — 
    The Region of the IAM Identity Center instance. If not provided, the
service defaults to the Region of the farm.
    
          
        
    • 
      
    

  
    
    


Returns:


    
  
    
  • 
      
      
        (Struct)
      
      
      
        —
        
    Returns an empty response.
    
      
    
    • 
  



  
See Also:

  



  

    
      


130

    		
    
      
# File 'sig/client.rbs', line 130

def associate_member_to_queue: (

    		
  





    
      

  

  
    #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.secret_access_key #=> String
resp.credentials.session_token #=> String
resp.credentials.expiration #=> Time

    
  


  

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:

  



  

    
      


146

    		
    
      
# File 'sig/client.rbs', line 146

def assume_fleet_role_for_read: (

    		
  





    
      

  

  
    #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.secret_access_key #=> String
resp.credentials.session_token #=> String
resp.credentials.expiration #=> Time

    
  


  

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:

  



  

    
      


157

    		
    
      
# File 'sig/client.rbs', line 157

def assume_fleet_role_for_worker: (

    		
  





    
      

  

  
    #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.secret_access_key #=> String
resp.credentials.session_token #=> String
resp.credentials.expiration #=> Time

    
  


  

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:

  



  

    
      


169

    		
    
      
# File 'sig/client.rbs', line 169

def assume_queue_role_for_read: (

    		
  





    
      

  

  
    #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.secret_access_key #=> String
resp.credentials.session_token #=> String
resp.credentials.expiration #=> Time

    
  


  

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:

  



  

    
      


180

    		
    
      
# File 'sig/client.rbs', line 180

def assume_queue_role_for_user: (

    		
  





    
      

  

  
    #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
  worker_id: "WorkerId", # required
  queue_id: "QueueId", # required
})

    
      
        
Response structure

      
      

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

    
  


  

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.
    
          
        
    • 
      
        
  • 
          :worker_id
          (required, String)
          
            
          
          
            — 
    The worker ID of the worker assuming the queue role.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The queue ID of the worker assuming the queue role.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


191

    		
    
      
# File 'sig/client.rbs', line 191

def assume_queue_role_for_worker: (

    		
  





    
      

  

  
    #batch_get_job(params = {})  ⇒ Types::BatchGetJobResponse 
  

  

  


  

    
Retrieves multiple jobs in a single request. This is a batch version
of the GetJob API.


The result of getting each job is reported individually in the
response. Because the batch request can result in a combination of
successful and unsuccessful actions, you should check for batch errors
even when the call returns an HTTP status code of 200.


  





  
  

    
Examples:

    
      
        
Example: Get multiple jobs in a single request

      
      

resp = client.batch_get_job({
  identifiers: [
    {
      farm_id: "farm-1234567890abcdef1234567890abcdef", 
      job_id: "job-1234567890abcdef1234567890abcdef", 
      queue_id: "queue-1234567890abcdef1234567890abcdef", 
    }, 
    {
      farm_id: "farm-1234567890abcdef1234567890abcdef", 
      job_id: "job-234567890abcdef1234567890abcdef1", 
      queue_id: "queue-1234567890abcdef1234567890abcdef", 
    }, 
  ], 
})

    
      
        
Request syntax with placeholder values

      
      

resp = client.batch_get_job({
  identifiers: [ # required
    {
      farm_id: "FarmId", # required
      queue_id: "QueueId", # required
      job_id: "JobId", # required
    },
  ],
})

    
      
        
Response structure

      
      

resp.jobs #=> Array
resp.jobs[0].farm_id #=> String
resp.jobs[0].queue_id #=> String
resp.jobs[0].job_id #=> String
resp.jobs[0].name #=> 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].priority #=> Integer
resp.jobs[0].created_at #=> Time
resp.jobs[0].created_by #=> String
resp.jobs[0].updated_at #=> Time
resp.jobs[0].updated_by #=> String
resp.jobs[0].started_at #=> Time
resp.jobs[0].ended_at #=> Time
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].target_task_run_status #=> String, one of "READY", "FAILED", "SUCCEEDED", "CANCELED", "SUSPENDED", "PENDING"
resp.jobs[0].task_run_status_counts #=> Hash
resp.jobs[0].task_run_status_counts["TaskRunStatus"] #=> Integer
resp.jobs[0].task_failure_retry_count #=> Integer
resp.jobs[0].storage_profile_id #=> String
resp.jobs[0].max_failed_tasks_count #=> Integer
resp.jobs[0].max_retries_per_task #=> Integer
resp.jobs[0].parameters #=> Hash
resp.jobs[0].parameters["JobParametersKeyString"].int #=> String
resp.jobs[0].parameters["JobParametersKeyString"].float #=> String
resp.jobs[0].parameters["JobParametersKeyString"].string #=> String
resp.jobs[0].parameters["JobParametersKeyString"].path #=> String
resp.jobs[0].attachments.manifests #=> Array
resp.jobs[0].attachments.manifests[0].file_system_location_name #=> String
resp.jobs[0].attachments.manifests[0].root_path #=> String
resp.jobs[0].attachments.manifests[0].root_path_format #=> String, one of "windows", "posix"
resp.jobs[0].attachments.manifests[0].output_relative_directories #=> Array
resp.jobs[0].attachments.manifests[0].output_relative_directories[0] #=> String
resp.jobs[0].attachments.manifests[0].input_manifest_path #=> String
resp.jobs[0].attachments.manifests[0].input_manifest_hash #=> String
resp.jobs[0].attachments.file_system #=> String, one of "COPIED", "VIRTUAL"
resp.jobs[0].description #=> String
resp.jobs[0].max_worker_count #=> Integer
resp.jobs[0].source_job_id #=> String
resp.errors #=> Array
resp.errors[0].farm_id #=> String
resp.errors[0].queue_id #=> String
resp.errors[0].job_id #=> String
resp.errors[0].code #=> String, one of "InternalServerErrorException", "ResourceNotFoundException", "ValidationException", "AccessDeniedException", "ThrottlingException"
resp.errors[0].message #=> String

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :identifiers
          (required, Array<Types::BatchGetJobIdentifier>)
          
            
          
          
            — 
    The list of job identifiers to retrieve. You can specify up to 100
identifiers per request.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


205

    		
    
      
# File 'sig/client.rbs', line 205

def batch_get_job: (

    		
  





    
      

  

  
    #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
  worker_id: "WorkerId", # required
  identifiers: [ # required
    {
      job_details: {
        job_id: "JobId", # required
      },
      job_attachment_details: {
        job_id: "JobId", # required
      },
      step_details: {
        job_id: "JobId", # required
        step_id: "StepId", # required
      },
      environment_details: {
        job_id: "JobId", # required
        environment_id: "EnvironmentId", # required
      },
    },
  ],
})

    
      
        
Response structure

      
      

resp.entities #=> Array
resp.entities[0].job_details.job_id #=> String
resp.entities[0].job_details.job_attachment_settings.s3_bucket_name #=> String
resp.entities[0].job_details.job_attachment_settings.root_prefix #=> String
resp.entities[0].job_details.job_run_as_user.posix.user #=> String
resp.entities[0].job_details.job_run_as_user.posix.group #=> String
resp.entities[0].job_details.job_run_as_user.windows.user #=> String
resp.entities[0].job_details.job_run_as_user.windows.password_arn #=> 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.log_group_name #=> String
resp.entities[0].job_details.queue_role_arn #=> String
resp.entities[0].job_details.parameters #=> Hash
resp.entities[0].job_details.parameters["JobParametersKeyString"].int #=> String
resp.entities[0].job_details.parameters["JobParametersKeyString"].float #=> String
resp.entities[0].job_details.parameters["JobParametersKeyString"].string #=> String
resp.entities[0].job_details.parameters["JobParametersKeyString"].path #=> String
resp.entities[0].job_details.schema_version #=> String
resp.entities[0].job_details.path_mapping_rules #=> Array
resp.entities[0].job_details.path_mapping_rules[0].source_path_format #=> String, one of "windows", "posix"
resp.entities[0].job_details.path_mapping_rules[0].source_path #=> String
resp.entities[0].job_details.path_mapping_rules[0].destination_path #=> String
resp.entities[0].job_attachment_details.job_id #=> String
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].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.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].input_manifest_path #=> String
resp.entities[0].job_attachment_details.attachments.manifests[0].input_manifest_hash #=> String
resp.entities[0].job_attachment_details.attachments.file_system #=> String, one of "COPIED", "VIRTUAL"
resp.entities[0].step_details.job_id #=> String
resp.entities[0].step_details.step_id #=> String
resp.entities[0].step_details.schema_version #=> String
resp.entities[0].step_details.dependencies #=> Array
resp.entities[0].step_details.dependencies[0] #=> String
resp.entities[0].environment_details.job_id #=> String
resp.entities[0].environment_details.environment_id #=> String
resp.entities[0].environment_details.schema_version #=> String
resp.errors #=> Array
resp.errors[0].job_details.job_id #=> String
resp.errors[0].job_details.code #=> String, one of "AccessDeniedException", "InternalServerException", "ValidationException", "ResourceNotFoundException", "MaxPayloadSizeExceeded", "ConflictException"
resp.errors[0].job_details.message #=> String
resp.errors[0].job_attachment_details.job_id #=> String
resp.errors[0].job_attachment_details.code #=> String, one of "AccessDeniedException", "InternalServerException", "ValidationException", "ResourceNotFoundException", "MaxPayloadSizeExceeded", "ConflictException"
resp.errors[0].job_attachment_details.message #=> String
resp.errors[0].step_details.job_id #=> String
resp.errors[0].step_details.step_id #=> String
resp.errors[0].step_details.code #=> String, one of "AccessDeniedException", "InternalServerException", "ValidationException", "ResourceNotFoundException", "MaxPayloadSizeExceeded", "ConflictException"
resp.errors[0].step_details.message #=> String
resp.errors[0].environment_details.job_id #=> String
resp.errors[0].environment_details.environment_id #=> String
resp.errors[0].environment_details.code #=> String, one of "AccessDeniedException", "InternalServerException", "ValidationException", "ResourceNotFoundException", "MaxPayloadSizeExceeded", "ConflictException"
resp.errors[0].environment_details.message #=> 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.
    
          
        
    • 
      
        
  • 
          :worker_id
          (required, String)
          
            
          
          
            — 
    The worker ID of the worker containing the job details to get.
    
          
        
    • 
      
        
  • 
          :identifiers
          (required, Array<Types::JobEntityIdentifiersUnion>)
          
            
          
          
            — 
    The job identifiers to include within the job entity batch details.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


222

    		
    
      
# File 'sig/client.rbs', line 222

def batch_get_job_entity: (

    		
  





    
      

  

  
    #batch_get_session(params = {})  ⇒ Types::BatchGetSessionResponse 
  

  

  


  

    
Retrieves multiple sessions in a single request. This is a batch
version of the GetSession API.


The result of getting each session is reported individually in the
response. Because the batch request can result in a combination of
successful and unsuccessful actions, you should check for batch errors
even when the call returns an HTTP status code of 200.


  





  
  

    
Examples:

    
      
        
Example: Get multiple sessions in a single request

      
      

resp = client.batch_get_session({
  identifiers: [
    {
      farm_id: "farm-1234567890abcdef1234567890abcdef", 
      job_id: "job-1234567890abcdef1234567890abcdef", 
      queue_id: "queue-1234567890abcdef1234567890abcdef", 
      session_id: "session-1234567890abcdef1234567890abcdef", 
    }, 
    {
      farm_id: "farm-1234567890abcdef1234567890abcdef", 
      job_id: "job-1234567890abcdef1234567890abcdef", 
      queue_id: "queue-1234567890abcdef1234567890abcdef", 
      session_id: "session-234567890abcdef1234567890abcdef1", 
    }, 
  ], 
})

    
      
        
Request syntax with placeholder values

      
      

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

    
      
        
Response structure

      
      

resp.sessions #=> Array
resp.sessions[0].farm_id #=> String
resp.sessions[0].queue_id #=> String
resp.sessions[0].job_id #=> String
resp.sessions[0].session_id #=> String
resp.sessions[0].fleet_id #=> String
resp.sessions[0].worker_id #=> String
resp.sessions[0].started_at #=> Time
resp.sessions[0].lifecycle_status #=> String, one of "STARTED", "UPDATE_IN_PROGRESS", "UPDATE_SUCCEEDED", "UPDATE_FAILED", "ENDED"
resp.sessions[0].ended_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].log.log_driver #=> String
resp.sessions[0].log.options #=> Hash
resp.sessions[0].log.options["String"] #=> String
resp.sessions[0].log.parameters #=> Hash
resp.sessions[0].log.parameters["String"] #=> String
resp.sessions[0].log.error #=> String
resp.sessions[0].host_properties.ip_addresses.ip_v4_addresses #=> Array
resp.sessions[0].host_properties.ip_addresses.ip_v4_addresses[0] #=> String
resp.sessions[0].host_properties.ip_addresses.ip_v6_addresses #=> Array
resp.sessions[0].host_properties.ip_addresses.ip_v6_addresses[0] #=> String
resp.sessions[0].host_properties.host_name #=> String
resp.sessions[0].host_properties.ec2_instance_arn #=> String
resp.sessions[0].host_properties.ec2_instance_type #=> String
resp.sessions[0].worker_log.log_driver #=> String
resp.sessions[0].worker_log.options #=> Hash
resp.sessions[0].worker_log.options["String"] #=> String
resp.sessions[0].worker_log.parameters #=> Hash
resp.sessions[0].worker_log.parameters["String"] #=> String
resp.sessions[0].worker_log.error #=> String
resp.errors #=> Array
resp.errors[0].farm_id #=> String
resp.errors[0].queue_id #=> String
resp.errors[0].job_id #=> String
resp.errors[0].session_id #=> String
resp.errors[0].code #=> String, one of "InternalServerErrorException", "ResourceNotFoundException", "ValidationException"
resp.errors[0].message #=> String

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :identifiers
          (required, Array<Types::BatchGetSessionIdentifier>)
          
            
          
          
            — 
    The list of session identifiers to retrieve. You can specify up to 100
identifiers per request.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


253

    		
    
      
# File 'sig/client.rbs', line 253

def batch_get_session: (

    		
  





    
      

  

  
    #batch_get_session_action(params = {})  ⇒ Types::BatchGetSessionActionResponse 
  

  

  


  

    
Retrieves multiple session actions in a single request. This is a
batch version of the GetSessionAction API.


The result of getting each session action is reported individually in
the response. Because the batch request can result in a combination of
successful and unsuccessful actions, you should check for batch errors
even when the call returns an HTTP status code of 200.


  





  
  

    
Examples:

    
      
        
Example: Get multiple session actions in a single request

      
      

resp = client.batch_get_session_action({
  identifiers: [
    {
      farm_id: "farm-1234567890abcdef1234567890abcdef", 
      job_id: "job-1234567890abcdef1234567890abcdef", 
      queue_id: "queue-1234567890abcdef1234567890abcdef", 
      session_action_id: "sessionaction-1234567890abcdef1234567890abcdef-0", 
    }, 
    {
      farm_id: "farm-1234567890abcdef1234567890abcdef", 
      job_id: "job-1234567890abcdef1234567890abcdef", 
      queue_id: "queue-1234567890abcdef1234567890abcdef", 
      session_action_id: "sessionaction-1234567890abcdef1234567890abcdef-1", 
    }, 
  ], 
})

    
      
        
Request syntax with placeholder values

      
      

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

    
      
        
Response structure

      
      

resp.session_actions #=> Array
resp.session_actions[0].farm_id #=> String
resp.session_actions[0].queue_id #=> String
resp.session_actions[0].job_id #=> String
resp.session_actions[0].session_action_id #=> String
resp.session_actions[0].status #=> String, one of "ASSIGNED", "RUNNING", "CANCELING", "SUCCEEDED", "FAILED", "INTERRUPTED", "CANCELED", "NEVER_ATTEMPTED", "SCHEDULED", "RECLAIMING", "RECLAIMED"
resp.session_actions[0].started_at #=> Time
resp.session_actions[0].ended_at #=> Time
resp.session_actions[0].worker_updated_at #=> Time
resp.session_actions[0].progress_percent #=> Float
resp.session_actions[0].manifests #=> Array
resp.session_actions[0].manifests[0].output_manifest_path #=> String
resp.session_actions[0].manifests[0].output_manifest_hash #=> String
resp.session_actions[0].session_id #=> String
resp.session_actions[0].process_exit_code #=> Integer
resp.session_actions[0].progress_message #=> String
resp.session_actions[0].acquired_limits #=> Array
resp.session_actions[0].acquired_limits[0].limit_id #=> String
resp.session_actions[0].acquired_limits[0].count #=> Integer
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.task_run.task_id #=> String
resp.session_actions[0].definition.task_run.step_id #=> String
resp.session_actions[0].definition.task_run.parameters #=> Hash
resp.session_actions[0].definition.task_run.parameters["String"].int #=> String
resp.session_actions[0].definition.task_run.parameters["String"].float #=> String
resp.session_actions[0].definition.task_run.parameters["String"].string #=> String
resp.session_actions[0].definition.task_run.parameters["String"].path #=> String
resp.session_actions[0].definition.task_run.parameters["String"].chunk_int #=> String
resp.session_actions[0].definition.sync_input_job_attachments.step_id #=> String
resp.errors #=> Array
resp.errors[0].farm_id #=> String
resp.errors[0].queue_id #=> String
resp.errors[0].job_id #=> String
resp.errors[0].session_action_id #=> String
resp.errors[0].code #=> String, one of "InternalServerErrorException", "ResourceNotFoundException", "ValidationException"
resp.errors[0].message #=> String

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
  
    
    


Returns:



  
See Also:

  



  

    
      


271

    		
    
      
# File 'sig/client.rbs', line 271

def batch_get_session_action: (

    		
  





    
      

  

  
    #batch_get_step(params = {})  ⇒ Types::BatchGetStepResponse 
  

  

  


  

    
Retrieves multiple steps in a single request. This is a batch version
of the GetStep API.


The result of getting each step is reported individually in the
response. Because the batch request can result in a combination of
successful and unsuccessful actions, you should check for batch errors
even when the call returns an HTTP status code of 200.


  





  
  

    
Examples:

    
      
        
Example: Get multiple steps in a single request

      
      

resp = client.batch_get_step({
  identifiers: [
    {
      farm_id: "farm-1234567890abcdef1234567890abcdef", 
      job_id: "job-1234567890abcdef1234567890abcdef", 
      queue_id: "queue-1234567890abcdef1234567890abcdef", 
      step_id: "step-1234567890abcdef1234567890abcdef", 
    }, 
    {
      farm_id: "farm-1234567890abcdef1234567890abcdef", 
      job_id: "job-1234567890abcdef1234567890abcdef", 
      queue_id: "queue-1234567890abcdef1234567890abcdef", 
      step_id: "step-234567890abcdef1234567890abcdef1", 
    }, 
  ], 
})

    
      
        
Request syntax with placeholder values

      
      

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

    
      
        
Response structure

      
      

resp.steps #=> Array
resp.steps[0].farm_id #=> String
resp.steps[0].queue_id #=> String
resp.steps[0].job_id #=> String
resp.steps[0].step_id #=> String
resp.steps[0].name #=> 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].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].task_failure_retry_count #=> Integer
resp.steps[0].target_task_run_status #=> String, one of "READY", "FAILED", "SUCCEEDED", "CANCELED", "SUSPENDED", "PENDING"
resp.steps[0].created_at #=> Time
resp.steps[0].created_by #=> String
resp.steps[0].updated_at #=> Time
resp.steps[0].updated_by #=> String
resp.steps[0].started_at #=> Time
resp.steps[0].ended_at #=> Time
resp.steps[0].dependency_counts.dependencies_resolved #=> Integer
resp.steps[0].dependency_counts.dependencies_unresolved #=> Integer
resp.steps[0].dependency_counts.consumers_resolved #=> Integer
resp.steps[0].dependency_counts.consumers_unresolved #=> Integer
resp.steps[0].required_capabilities.attributes #=> Array
resp.steps[0].required_capabilities.attributes[0].name #=> String
resp.steps[0].required_capabilities.attributes[0].any_of #=> Array
resp.steps[0].required_capabilities.attributes[0].any_of[0] #=> String
resp.steps[0].required_capabilities.attributes[0].all_of #=> Array
resp.steps[0].required_capabilities.attributes[0].all_of[0] #=> String
resp.steps[0].required_capabilities.amounts #=> Array
resp.steps[0].required_capabilities.amounts[0].name #=> String
resp.steps[0].required_capabilities.amounts[0].min #=> Float
resp.steps[0].required_capabilities.amounts[0].max #=> Float
resp.steps[0].required_capabilities.amounts[0].value #=> Float
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", "CHUNK_INT"
resp.steps[0].parameter_space.parameters[0].chunks.default_task_count #=> Integer
resp.steps[0].parameter_space.parameters[0].chunks.target_runtime_seconds #=> Integer
resp.steps[0].parameter_space.parameters[0].chunks.range_constraint #=> String, one of "CONTIGUOUS", "NONCONTIGUOUS"
resp.steps[0].parameter_space.combination #=> String
resp.steps[0].description #=> String
resp.errors #=> Array
resp.errors[0].farm_id #=> String
resp.errors[0].queue_id #=> String
resp.errors[0].job_id #=> String
resp.errors[0].step_id #=> String
resp.errors[0].code #=> String, one of "InternalServerErrorException", "ResourceNotFoundException", "ValidationException", "AccessDeniedException", "ThrottlingException"
resp.errors[0].message #=> String

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :identifiers
          (required, Array<Types::BatchGetStepIdentifier>)
          
            
          
          
            — 
    The list of step identifiers to retrieve. You can specify up to 100
identifiers per request.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


289

    		
    
      
# File 'sig/client.rbs', line 289

def batch_get_step: (

    		
  





    
      

  

  
    #batch_get_task(params = {})  ⇒ Types::BatchGetTaskResponse 
  

  

  


  

    
Retrieves multiple tasks in a single request. This is a batch version
of the GetTask API.


The result of getting each task is reported individually in the
response. Because the batch request can result in a combination of
successful and unsuccessful actions, you should check for batch errors
even when the call returns an HTTP status code of 200.


  





  
  

    
Examples:

    
      
        
Example: Get multiple tasks in a single request

      
      

resp = client.batch_get_task({
  identifiers: [
    {
      farm_id: "farm-1234567890abcdef1234567890abcdef", 
      job_id: "job-1234567890abcdef1234567890abcdef", 
      queue_id: "queue-1234567890abcdef1234567890abcdef", 
      step_id: "step-1234567890abcdef1234567890abcdef", 
      task_id: "task-1234567890abcdef1234567890abcdef-0", 
    }, 
    {
      farm_id: "farm-1234567890abcdef1234567890abcdef", 
      job_id: "job-1234567890abcdef1234567890abcdef", 
      queue_id: "queue-1234567890abcdef1234567890abcdef", 
      step_id: "step-1234567890abcdef1234567890abcdef", 
      task_id: "task-1234567890abcdef1234567890abcdef-1", 
    }, 
  ], 
})

    
      
        
Request syntax with placeholder values

      
      

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

    
      
        
Response structure

      
      

resp.tasks #=> Array
resp.tasks[0].farm_id #=> String
resp.tasks[0].queue_id #=> String
resp.tasks[0].job_id #=> String
resp.tasks[0].step_id #=> String
resp.tasks[0].task_id #=> String
resp.tasks[0].created_at #=> Time
resp.tasks[0].created_by #=> 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].target_run_status #=> String, one of "READY", "FAILED", "SUCCEEDED", "CANCELED", "SUSPENDED", "PENDING"
resp.tasks[0].failure_retry_count #=> Integer
resp.tasks[0].started_at #=> Time
resp.tasks[0].ended_at #=> Time
resp.tasks[0].updated_at #=> Time
resp.tasks[0].updated_by #=> String
resp.tasks[0].latest_session_action_id #=> String
resp.tasks[0].parameters #=> Hash
resp.tasks[0].parameters["String"].int #=> String
resp.tasks[0].parameters["String"].float #=> String
resp.tasks[0].parameters["String"].string #=> String
resp.tasks[0].parameters["String"].path #=> String
resp.tasks[0].parameters["String"].chunk_int #=> String
resp.errors #=> Array
resp.errors[0].farm_id #=> String
resp.errors[0].queue_id #=> String
resp.errors[0].job_id #=> String
resp.errors[0].step_id #=> String
resp.errors[0].task_id #=> String
resp.errors[0].code #=> String, one of "InternalServerErrorException", "ResourceNotFoundException", "ValidationException", "AccessDeniedException", "ThrottlingException"
resp.errors[0].message #=> String

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :identifiers
          (required, Array<Types::BatchGetTaskIdentifier>)
          
            
          
          
            — 
    The list of task identifiers to retrieve. You can specify up to 100
identifiers per request.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


307

    		
    
      
# File 'sig/client.rbs', line 307

def batch_get_task: (

    		
  





    
      

  

  
    #batch_get_worker(params = {})  ⇒ Types::BatchGetWorkerResponse 
  

  

  


  

    
Retrieves multiple workers in a single request. This is a batch
version of the GetWorker API.


The result of getting each worker is reported individually in the
response. Because the batch request can result in a combination of
successful and unsuccessful actions, you should check for batch errors
even when the call returns an HTTP status code of 200.


  





  
  

    
Examples:

    
      
        
Example: Get multiple workers in a single request

      
      

resp = client.batch_get_worker({
  identifiers: [
    {
      farm_id: "farm-1234567890abcdef1234567890abcdef", 
      fleet_id: "fleet-1234567890abcdef1234567890abcdef", 
      worker_id: "worker-1234567890abcdef1234567890abcdef", 
    }, 
    {
      farm_id: "farm-1234567890abcdef1234567890abcdef", 
      fleet_id: "fleet-1234567890abcdef1234567890abcdef", 
      worker_id: "worker-234567890abcdef1234567890abcdef1", 
    }, 
  ], 
})

    
      
        
Request syntax with placeholder values

      
      

resp = client.batch_get_worker({
  identifiers: [ # required
    {
      farm_id: "FarmId", # required
      fleet_id: "FleetId", # required
      worker_id: "WorkerId", # required
    },
  ],
})

    
      
        
Response structure

      
      

resp.workers #=> Array
resp.workers[0].farm_id #=> String
resp.workers[0].fleet_id #=> String
resp.workers[0].worker_id #=> 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].host_properties.host_name #=> String
resp.workers[0].host_properties.ec2_instance_arn #=> String
resp.workers[0].host_properties.ec2_instance_type #=> String
resp.workers[0].status #=> String, one of "CREATED", "STARTED", "STOPPING", "STOPPED", "NOT_RESPONDING", "NOT_COMPATIBLE", "RUNNING", "IDLE"
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].log.error #=> String
resp.workers[0].created_at #=> Time
resp.workers[0].created_by #=> String
resp.workers[0].updated_at #=> Time
resp.workers[0].updated_by #=> String
resp.errors #=> Array
resp.errors[0].farm_id #=> String
resp.errors[0].fleet_id #=> String
resp.errors[0].worker_id #=> String
resp.errors[0].code #=> String, one of "InternalServerErrorException", "ResourceNotFoundException", "ValidationException"
resp.errors[0].message #=> String

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :identifiers
          (required, Array<Types::BatchGetWorkerIdentifier>)
          
            
          
          
            — 
    The list of worker identifiers to retrieve. You can specify up to 100
identifiers per request.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


326

    		
    
      
# File 'sig/client.rbs', line 326

def batch_get_worker: (

    		
  





    
      

  

  
    #batch_update_job(params = {})  ⇒ Types::BatchUpdateJobResponse 
  

  

  


  

    
Updates multiple jobs in a single request. This is a batch version of
the UpdateJob API.


The result of updating each job is reported individually in the
response. Because the batch request can result in a combination of
successful and unsuccessful actions, you should check for batch errors
even when the call returns an HTTP status code of 200.


When you change the status of a job to ARCHIVED, the job can't be
scheduled or archived.


An archived job and its steps and tasks are deleted after 120 days.
The job can't be recovered.


  





  
  

    
Examples:

    
      
        
Example: Update multiple jobs in a single request

      
      

resp = client.batch_update_job({
  jobs: [
    {
      farm_id: "farm-1234567890abcdef1234567890abcdef", 
      job_id: "job-1234567890abcdef1234567890abcdef", 
      queue_id: "queue-1234567890abcdef1234567890abcdef", 
      target_task_run_status: "FAILED", 
    }, 
    {
      farm_id: "farm-1234567890abcdef1234567890abcdef", 
      job_id: "job-234567890abcdef1234567890abcdef1", 
      queue_id: "queue-1234567890abcdef1234567890abcdef", 
      target_task_run_status: "FAILED", 
    }, 
  ], 
})

    
      
        
Request syntax with placeholder values

      
      

resp = client.batch_update_job({
  client_token: "ClientToken",
  jobs: [ # required
    {
      farm_id: "FarmId", # required
      queue_id: "QueueId", # required
      job_id: "JobId", # required
      target_task_run_status: "READY", # accepts READY, FAILED, SUCCEEDED, CANCELED, SUSPENDED, PENDING
      priority: 1,
      max_failed_tasks_count: 1,
      max_retries_per_task: 1,
      lifecycle_status: "ARCHIVED", # accepts ARCHIVED
      max_worker_count: 1,
      name: "JobName",
      description: "JobDescriptionOverride",
    },
  ],
})

    
      
        
Response structure

      
      

resp.errors #=> Array
resp.errors[0].farm_id #=> String
resp.errors[0].queue_id #=> String
resp.errors[0].job_id #=> String
resp.errors[0].code #=> String, one of "ConflictException", "InternalServerErrorException", "ResourceNotFoundException", "ValidationException", "AccessDeniedException", "ThrottlingException"
resp.errors[0].message #=> 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.**
    
          
        
    • 
      
        
  • 
          :jobs
          (required, Array<Types::BatchUpdateJobItem>)
          
            
          
          
            — 
    The list of jobs to update. You can specify up to 100 jobs per
request.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


342

    		
    
      
# File 'sig/client.rbs', line 342

def batch_update_job: (

    		
  





    
      

  

  
    #batch_update_task(params = {})  ⇒ Types::BatchUpdateTaskResponse 
  

  

  


  

    
Updates multiple tasks in a single request. This is a batch version of
the UpdateTask API.


The result of updating each task is reported individually in the
response. Because the batch request can result in a combination of
successful and unsuccessful actions, you should check for batch errors
even when the call returns an HTTP status code of 200.


  





  
  

    
Examples:

    
      
        
Example: Update multiple tasks in a single request

      
      

resp = client.batch_update_task({
  tasks: [
    {
      farm_id: "farm-1234567890abcdef1234567890abcdef", 
      job_id: "job-1234567890abcdef1234567890abcdef", 
      queue_id: "queue-1234567890abcdef1234567890abcdef", 
      step_id: "step-1234567890abcdef1234567890abcdef", 
      target_run_status: "FAILED", 
      task_id: "task-1234567890abcdef1234567890abcdef-0", 
    }, 
    {
      farm_id: "farm-1234567890abcdef1234567890abcdef", 
      job_id: "job-1234567890abcdef1234567890abcdef", 
      queue_id: "queue-1234567890abcdef1234567890abcdef", 
      step_id: "step-1234567890abcdef1234567890abcdef", 
      target_run_status: "FAILED", 
      task_id: "task-1234567890abcdef1234567890abcdef-1", 
    }, 
  ], 
})

    
      
        
Request syntax with placeholder values

      
      

resp = client.batch_update_task({
  client_token: "ClientToken",
  tasks: [ # required
    {
      farm_id: "FarmId", # required
      queue_id: "QueueId", # required
      job_id: "JobId", # required
      step_id: "StepId", # required
      task_id: "TaskId", # required
      target_run_status: "READY", # required, accepts READY, FAILED, SUCCEEDED, CANCELED, SUSPENDED, PENDING
    },
  ],
})

    
      
        
Response structure

      
      

resp.errors #=> Array
resp.errors[0].farm_id #=> String
resp.errors[0].queue_id #=> String
resp.errors[0].job_id #=> String
resp.errors[0].step_id #=> String
resp.errors[0].task_id #=> String
resp.errors[0].code #=> String, one of "ConflictException", "InternalServerErrorException", "ResourceNotFoundException", "ValidationException", "AccessDeniedException", "ThrottlingException"
resp.errors[0].message #=> 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.**
    
          
        
    • 
      
        
  • 
          :tasks
          (required, Array<Types::BatchUpdateTaskItem>)
          
            
          
          
            — 
    The list of tasks to update. You can specify up to 100 tasks per
request.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


367

    		
    
      
# File 'sig/client.rbs', line 367

def batch_update_task: (

    		
  





    
      

  

  
    #build_request(operation_name, params = {})  ⇒ Object 
  

  

  


  

    

  This method is part of a private API.
  You should avoid using this method if possible, as it may be removed or be changed in the future.




  





  
Parameters:


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






  

    
      


8351
8352
8353
8354
8355
8356
8357
8358
8359
8360
8361
8362
8363
8364
8365
8366
8367

    		
    
      
# File 'lib/aws-sdk-deadline/client.rb', line 8351

def build_request(operation_name, params = {})
  handlers = @handlers.for(operation_name)
  tracer = config.telemetry_provider.tracer_provider.tracer(
    Aws::Telemetry.module_to_tracer_name('Aws::Deadline')
  )
  context = Seahorse::Client::RequestContext.new(
    operation_name: operation_name,
    operation: config.api.operation(operation_name),
    client: self,
    params: params,
    config: config,
    tracer: tracer
  )
  context[:gem_name] = 'aws-sdk-deadline'
  context[:gem_version] = '1.59.0'
  Seahorse::Client::Request.new(handlers, context)
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
  queue_id: "QueueId", # required
  job_id: "JobId", # 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.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The queue ID to copy.
    
          
        
    • 
      
        
  • 
          :job_id
          (required, String)
          
            
          
          
            — 
    The job 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:

  



  

    
      


387

    		
    
      
# File 'sig/client.rbs', line 387

def copy_job_template: (

    		
  





    
      

  

  
    #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({
  farm_id: "FarmId", # required
  display_name: "ResourceName", # required
  description: "Description",
  client_token: "ClientToken",
  usage_tracking_resource: { # required
    queue_id: "QueueId",
  },
  approximate_dollar_limit: 1.0, # required
  actions: [ # required
    {
      type: "STOP_SCHEDULING_AND_COMPLETE_TASKS", # required, accepts STOP_SCHEDULING_AND_COMPLETE_TASKS, STOP_SCHEDULING_AND_CANCEL_TASKS
      threshold_percentage: 1.0, # required
      description: "Description",
    },
  ],
  schedule: { # required
    fixed: {
      start_time: Time.now, # required
      end_time: Time.now, # required
    },
  },
  tags: {
    "String" => "String",
  },
})

    
      
        
Response structure

      
      

resp.budget_id #=> String

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID to include in this budget.
    
          
        
    • 
      
        
  • 
          :display_name
          (required, String)
          
            
          
          
            — 
    The display name of the budget.
    

    This field can store any content. Escape or encode this content before
displaying it on a webpage or any other system that might interpret
the content of this field.
    
          
        
    • 
      
        
  • 
          :description
          (String)
          
            
          
          
            — 
    The description of the budget.
    

    This field can store any content. Escape or encode this content before
displaying it on a webpage or any other system that might interpret
the content of this field.
    
          
        
    • 
      
        
  • 
          :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.**
    
          
        
    • 
      
        
  • 
          :usage_tracking_resource
          (required, Types::UsageTrackingResource)
          
            
          
          
            — 
    The queue ID provided to this budget to track usage.
    
          
        
    • 
      
        
  • 
          :approximate_dollar_limit
          (required, Float)
          
            
          
          
            — 
    The dollar limit based on consumed usage.
    
          
        
    • 
      
        
  • 
          :actions
          (required, Array<Types::BudgetActionToAdd>)
          
            
          
          
            — 
    The budget actions to specify what happens when the budget runs out.
    
          
        
    • 
      
        
  • 
          :schedule
          (required, Types::BudgetSchedule)
          
            
          
          
            — 
    The schedule to associate with this budget.
    
          
        
    • 
      
        
  • 
          :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:

  



  

    
      


403

    		
    
      
# File 'sig/client.rbs', line 403

def create_budget: (

    		
  





    
      

  

  
    #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",
  display_name: "ResourceName", # required
  description: "Description",
  kms_key_arn: "KmsKeyArn",
  cost_scale_factor: 1.0,
  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.**
    
          
        
    • 
      
        
  • 
          :display_name
          (required, String)
          
            
          
          
            — 
    The display name of the farm.
    

    This field can store any content. Escape or encode this content before
displaying it on a webpage or any other system that might interpret
the content of this field.
    
          
        
    • 
      
        
  • 
          :description
          (String)
          
            
          
          
            — 
    The description of the farm.
    

    This field can store any content. Escape or encode this content before
displaying it on a webpage or any other system that might interpret
the content of this field.
    
          
        
    • 
      
        
  • 
          :kms_key_arn
          (String)
          
            
          
          
            — 
    The ARN of the KMS key to use on the farm.
    
          
        
    • 
      
        
  • 
          :cost_scale_factor
          (Float)
          
            
          
          
            — 
    A multiplier applied to the farm's calculated costs for usage data
and budget tracking. A value less than 1 represents a discount, a
value greater than 1 represents a premium, and a value of 1 represents
no adjustment. The default value is 1.
    
          
        
    • 
      
        
  • 
          :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:

  



  

    
      


434

    		
    
      
# File 'sig/client.rbs', line 434

def create_farm: (

    		
  





    
      

  

  
    #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({
  farm_id: "FarmId", # required
  client_token: "ClientToken",
  display_name: "ResourceName", # required
  description: "Description",
  role_arn: "IamRoleArn", # required
  min_worker_count: 1,
  max_worker_count: 1, # required
  configuration: { # required
    customer_managed: {
      mode: "NO_SCALING", # required, accepts NO_SCALING, EVENT_BASED_AUTO_SCALING
      auto_scaling_configuration: {
        standby_worker_count: 1,
        worker_idle_duration_seconds: 1,
        scale_out_workers_per_minute: 1,
      },
      worker_capabilities: { # required
        v_cpu_count: { # required
          min: 1, # required
          max: 1,
        },
        memory_mi_b: { # required
          min: 1, # required
          max: 1,
        },
        accelerator_types: ["gpu"], # accepts gpu
        accelerator_count: {
          min: 1, # required
          max: 1,
        },
        accelerator_total_memory_mi_b: {
          min: 1, # required
          max: 1,
        },
        os_family: "WINDOWS", # required, accepts WINDOWS, LINUX, MACOS
        cpu_architecture_type: "x86_64", # required, accepts x86_64, arm64
        custom_amounts: [
          {
            name: "AmountCapabilityName", # required
            min: 1.0, # required
            max: 1.0,
          },
        ],
        custom_attributes: [
          {
            name: "AttributeCapabilityName", # required
            values: ["AttributeCapabilityValue"], # required
          },
        ],
      },
      storage_profile_id: "StorageProfileId",
      tag_propagation_mode: "NO_PROPAGATION", # accepts NO_PROPAGATION, PROPAGATE_TAGS_TO_WORKERS_AT_LAUNCH
    },
    service_managed_ec2: {
      instance_capabilities: { # required
        v_cpu_count: { # required
          min: 1, # required
          max: 1,
        },
        memory_mi_b: { # required
          min: 1, # required
          max: 1,
        },
        os_family: "WINDOWS", # required, accepts WINDOWS, LINUX
        cpu_architecture_type: "x86_64", # required, accepts x86_64, arm64
        root_ebs_volume: {
          size_gi_b: 1,
          iops: 1,
          throughput_mi_b: 1,
        },
        accelerator_capabilities: {
          selections: [ # required
            {
              name: "t4", # required, accepts t4, a10g, l4, l40s, rtx-pro-server-6000
              runtime: "AcceleratorRuntime",
            },
          ],
          count: {
            min: 1, # required
            max: 1,
          },
        },
        allowed_instance_types: ["InstanceType"],
        excluded_instance_types: ["InstanceType"],
        custom_amounts: [
          {
            name: "AmountCapabilityName", # required
            min: 1.0, # required
            max: 1.0,
          },
        ],
        custom_attributes: [
          {
            name: "AttributeCapabilityName", # required
            values: ["AttributeCapabilityValue"], # required
          },
        ],
      },
      instance_market_options: { # required
        type: "on-demand", # required, accepts on-demand, spot, wait-and-save
      },
      vpc_configuration: {
        resource_configuration_arns: ["VpcResourceConfigurationArn"],
      },
      storage_profile_id: "StorageProfileId",
      persistent_volume_configuration: {
        size_gi_b: 1,
        iops: 1,
        throughput_mi_b: 1,
        mount_path: "MountPath", # required
        last_used_ttl_hours: 1,
      },
      auto_scaling_configuration: {
        standby_worker_count: 1,
        worker_idle_duration_seconds: 1,
        scale_out_workers_per_minute: 1,
      },
    },
  },
  tags: {
    "String" => "String",
  },
  host_configuration: {
    script_body: "HostConfigurationScript", # required
    script_timeout_seconds: 1,
  },
})

    
      
        
Response structure

      
      

resp.fleet_id #=> String

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID of the farm to connect to the fleet.
    
          
        
    • 
      
        
  • 
          :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 fleet.
    

    This field can store any content. Escape or encode this content before
displaying it on a webpage or any other system that might interpret
the content of this field.
    
          
        
    • 
      
        
  • 
          :description
          (String)
          
            
          
          
            — 
    The description of the fleet.
    

    This field can store any content. Escape or encode this content before
displaying it on a webpage or any other system that might interpret
the content of this field.
    
          
        
    • 
      
        
  • 
          :role_arn
          (required, String)
          
            
          
          
            — 
    The IAM role ARN for the role that the fleet's workers will use.
    
          
        
    • 
      
        
  • 
          :min_worker_count
          (Integer)
          
            
          
          
            — 
    The minimum number of workers for the fleet.
    
          
        
    • 
      
        
  • 
          :max_worker_count
          (required, Integer)
          
            
          
          
            — 
    The maximum number of workers for the fleet.
    

    Deadline Cloud limits the number of workers to less than or equal to
the fleet's maximum worker count. The service maintains eventual
consistency for the worker count. If you make multiple rapid calls to
CreateWorker before the field updates, you might exceed your
fleet's maximum worker count. For example, if your maxWorkerCount
is 10 and you currently have 9 workers, making two quick
CreateWorker calls might successfully create 2 workers instead of 1,
resulting in 11 total workers.
    
          
        
    • 
      
        
  • 
          :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.
    
          
        
    • 
      
        
  • 
          :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.
    
          
        
    • 
      
        
  • 
          :host_configuration
          (Types::HostConfiguration)
          
            
          
          
            — 
    Provides a script that runs as a worker is starting up that you can
use to provide additional configuration for workers in your fleet.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


449

    		
    
      
# File 'sig/client.rbs', line 449

def create_fleet: (

    		
  





    
      

  

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

  

  


  

    
Creates a job. A job is a set of instructions that Deadline Cloud uses
to schedule and run work on available workers. For more information,
see Deadline Cloud jobs.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

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

    
      
        
Response structure

      
      

resp.job_id #=> String

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID of the farm to connect to the job.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The ID of the queue that the job is submitted to.
    
          
        
    • 
      
        
  • 
          :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.**
    
          
        
    • 
      
        
  • 
          :template
          (String)
          
            
          
          
            — 
    The job template to use for this job.
    
          
        
    • 
      
        
  • 
          :template_type
          (String)
          
            
          
          
            — 
    The file type for the job template.
    
          
        
    • 
      
        
  • 
          :priority
          (required, Integer)
          
            
          
          
            — 
    The priority of the job. The highest priority (first scheduled) is
100. When two jobs have the same priority, the oldest job is scheduled
first.
    
          
        
    • 
      
        
  • 
          :parameters
          (Hash<String,Types::JobParameter>)
          
            
          
          
            — 
    The parameters for the job.
    
          
        
    • 
      
        
  • 
          :attachments
          (Types::Attachments)
          
            
          
          
            — 
    The attachments for the job. Attach files required for the job to run
to a render job.
    
          
        
    • 
      
        
  • 
          :storage_profile_id
          (String)
          
            
          
          
            — 
    The storage profile ID for the storage profile to connect to the job.
    
          
        
    • 
      
        
  • 
          :target_task_run_status
          (String)
          
            
          
          
            — 
    The initial job status when it is created. Jobs that are created with
a SUSPENDED status will not run until manually requeued.
    
          
        
    • 
      
        
  • 
          :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 each task.
    
          
        
    • 
      
        
  • 
          :max_worker_count
          (Integer)
          
            
          
          
            — 
    The maximum number of worker hosts that can concurrently process a
job. When the maxWorkerCount is reached, no more workers will be
assigned to process the job, even if the fleets assigned to the job's
queue has available workers.
    

    You can't set the maxWorkerCount to 0. If you set it to -1, there
is no maximum number of workers.
    

    If you don't specify the maxWorkerCount, Deadline Cloud won't
throttle the number of workers used to process the job.
    
          
        
    • 
      
        
  • 
          :source_job_id
          (String)
          
            
          
          
            — 
    The job ID for the source job.
    
          
        
    • 
      
        
  • 
          :name_override
          (String)
          
            
          
          
            — 
    A custom name to override the job name derived from the job template.
    
          
        
    • 
      
        
  • 
          :description_override
          (String)
          
            
          
          
            — 
    A custom description to override the job description derived from the
job template.
    
          
        
    • 
      
        
  • 
          :tags
          (Hash<String,String>)
          
            
          
          
            — 
    The tags to add to your job. 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:

  



  

    
      


471

    		
    
      
# File 'sig/client.rbs', line 471

def create_job: (

    		
  





    
      

  

  
    #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",
  vpc_id: "VpcId", # required
  subnet_ids: ["SubnetId"], # required
  security_group_ids: ["SecurityGroupId"], # required
  tags: {
    "String" => "String",
  },
})

    
      
        
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.**
    
          
        
    • 
      
        
  • 
          :vpc_id
          (required, String)
          
            
          
          
            — 
    The VPC (virtual private cloud) ID to use with the license endpoint.
    
          
        
    • 
      
        
  • 
          :subnet_ids
          (required, Array<String>)
          
            
          
          
            — 
    The subnet IDs.
    
          
        
    • 
      
        
  • 
          :security_group_ids
          (required, Array<String>)
          
            
          
          
            — 
    The security group 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.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


514

    		
    
      
# File 'sig/client.rbs', line 514

def create_license_endpoint: (

    		
  





    
      

  

  
    #create_limit(params = {})  ⇒ Types::CreateLimitResponse 
  

  

  


  

    
Creates a limit that manages the distribution of shared resources,
such as floating licenses. A limit can throttle work assignments, help
manage workloads, and track current usage. Before you use a limit, you
must associate the limit with one or more queues.


You must add the amountRequirementName to a step in a job template
to declare the limit requirement.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.create_limit({
  farm_id: "FarmId", # required
  client_token: "ClientToken",
  display_name: "ResourceName", # required
  amount_requirement_name: "AmountRequirementName", # required
  max_count: 1, # required
  description: "Description",
})

    
      
        
Response structure

      
      

resp.limit_id #=> String

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID of the farm that contains the limit.
    
          
        
    • 
      
        
  • 
          :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 limit.
    

    This field can store any content. Escape or encode this content before
displaying it on a webpage or any other system that might interpret
the content of this field.
    
          
        
    • 
      
        
  • 
          :amount_requirement_name
          (required, String)
          
            
          
          
            — 
    The value that you specify as the name in the amounts field of the
hostRequirements in a step of a job template to declare the limit
requirement.
    
          
        
    • 
      
        
  • 
          :max_count
          (required, Integer)
          
            
          
          
            — 
    The maximum number of resources constrained by this limit. When all of
the resources are in use, steps that require the limit won't be
scheduled until the resource is available.
    

    The maxCount must not be 0. If the value is -1, there is no
restriction on the number of resources that can be acquired for this
limit.
    
          
        
    • 
      
        
  • 
          :description
          (String)
          
            
          
          
            — 
    A description of the limit. A description helps you identify the
purpose of the limit.
    

    This field can store any content. Escape or encode this content before
displaying it on a webpage or any other system that might interpret
the content of this field.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


528

    		
    
      
# File 'sig/client.rbs', line 528

def create_limit: (

    		
  





    
      

  

  
    #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
  identity_center_region: "Region",
  subdomain: "Subdomain", # required
  role_arn: "IamRoleArn", # required
  tags: {
    "String" => "String",
  },
})

    
      
        
Response structure

      
      

resp.monitor_id #=> String
resp.identity_center_application_arn #=> 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.
    

    This field can store any content. Escape or encode this content before
displaying it on a webpage or any other system that might interpret
the content of this field.
    
          
        
    • 
      
        
  • 
          :identity_center_instance_arn
          (required, String)
          
            
          
          
            — 
    The Amazon Resource Name of the IAM Identity Center instance that
authenticates monitor users.
    
          
        
    • 
      
        
  • 
          :identity_center_region
          (String)
          
            
          
          
            — 
    The Region where IAM Identity Center is enabled. Required when IAM
Identity Center is in a different Region than the monitor.
    
          
        
    • 
      
        
  • 
          :subdomain
          (required, String)
          
            
          
          
            — 
    The subdomain to use when creating the monitor URL. The full URL of
the monitor is subdomain.Region.deadlinecloud.amazonaws.com.
    
          
        
    • 
      
        
  • 
          :role_arn
          (required, String)
          
            
          
          
            — 
    The Amazon Resource Name 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.
    
          
        
    • 
      
        
  • 
          :tags
          (Hash<String,String>)
          
            
          
          
            — 
    The tags to add to your monitor. 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:

  



  

    
      


544

    		
    
      
# File 'sig/client.rbs', line 544

def create_monitor: (

    		
  





    
      

  

  
    #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({
  farm_id: "FarmId", # required
  client_token: "ClientToken",
  display_name: "ResourceName", # required
  description: "Description",
  default_budget_action: "NONE", # accepts NONE, STOP_SCHEDULING_AND_COMPLETE_TASKS, STOP_SCHEDULING_AND_CANCEL_TASKS
  job_attachment_settings: {
    s3_bucket_name: "S3BucketName", # required
    root_prefix: "S3Prefix", # required
  },
  role_arn: "IamRoleArn",
  job_run_as_user: {
    posix: {
      user: "PosixUserUserString", # required
      group: "PosixUserGroupString", # required
    },
    windows: {
      user: "WindowsUserUserString", # required
      password_arn: "WindowsUserPasswordArnString", # required
    },
    run_as: "QUEUE_CONFIGURED_USER", # required, accepts QUEUE_CONFIGURED_USER, WORKER_AGENT_USER
  },
  required_file_system_location_names: ["FileSystemLocationName"],
  allowed_storage_profile_ids: ["StorageProfileId"],
  tags: {
    "String" => "String",
  },
  scheduling_configuration: {
    priority_fifo: {
    },
    priority_balanced: {
      rendering_task_buffer: 1,
    },
    weighted_balanced: {
      priority_weight: 1.0,
      error_weight: 1.0,
      submission_time_weight: 1.0,
      rendering_task_weight: 1.0,
      rendering_task_buffer: 1,
      max_priority_override: {
        always_schedule_first: {
        },
      },
      min_priority_override: {
        always_schedule_last: {
        },
      },
    },
  },
})

    
      
        
Response structure

      
      

resp.queue_id #=> String

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID of the farm to connect to 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.**
    
          
        
    • 
      
        
  • 
          :display_name
          (required, String)
          
            
          
          
            — 
    The display name of the queue.
    

    This field can store any content. Escape or encode this content before
displaying it on a webpage or any other system that might interpret
the content of this field.
    
          
        
    • 
      
        
  • 
          :description
          (String)
          
            
          
          
            — 
    The description of the queue.
    

    This field can store any content. Escape or encode this content before
displaying it on a webpage or any other system that might interpret
the content of this field.
    
          
        
    • 
      
        
  • 
          :default_budget_action
          (String)
          
            
          
          
            — 
    The default action to take on a queue if a budget isn't configured.
    
          
        
    • 
      
        
  • 
          :job_attachment_settings
          (Types::JobAttachmentSettings)
          
            
          
          
            — 
    The job attachment settings for the queue. These are the Amazon S3
bucket name and the Amazon S3 prefix.
    
          
        
    • 
      
        
  • 
          :role_arn
          (String)
          
            
          
          
            — 
    The IAM role ARN that workers will use while running jobs for this
queue.
    
          
        
    • 
      
        
  • 
          :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.
    
          
        
    • 
      
        
  • 
          :allowed_storage_profile_ids
          (Array<String>)
          
            
          
          
            — 
    The storage profile IDs to include in the 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.
    
          
        
    • 
      
        
  • 
          :scheduling_configuration
          (Types::SchedulingConfiguration)
          
            
          
          
            — 
    The scheduling configuration for the queue. This configuration
determines how workers are assigned to jobs in the queue.
    

    If not specified, the queue defaults to the priorityFifo scheduling
configuration.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


560

    		
    
      
# File 'sig/client.rbs', line 560

def create_queue: (

    		
  





    
      

  

  
    #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({
  farm_id: "FarmId", # required
  queue_id: "QueueId", # required
  client_token: "ClientToken",
  priority: 1, # required
  template_type: "JSON", # required, accepts JSON, YAML
  template: "EnvironmentTemplate", # required
})

    
      
        
Response structure

      
      

resp.queue_environment_id #=> String

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID of the farm to connect to the environment.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The queue ID to connect the queue and environment.
    
          
        
    • 
      
        
  • 
          :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.**
    
          
        
    • 
      
        
  • 
          :priority
          (required, Integer)
          
            
          
          
            — 
    Sets the priority of the environments in the queue from 0 to 10,000,
where 0 is the highest priority (activated first and deactivated
last). If two environments share the same priority value, the
environment created first takes higher priority.
    
          
        
    • 
      
        
  • 
          :template_type
          (required, String)
          
            
          
          
            — 
    The template's file type, JSON or YAML.
    
          
        
    • 
      
        
  • 
          :template
          (required, String)
          
            
          
          
            — 
    The environment template to use in the queue.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


584

    		
    
      
# File 'sig/client.rbs', line 584

def create_queue_environment: (

    		
  





    
      

  

  
    #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
  queue_id: "QueueId", # required
  fleet_id: "FleetId", # 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.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The queue ID.
    
          
        
    • 
      
        
  • 
          :fleet_id
          (required, String)
          
            
          
          
            — 
    The fleet ID.
    
          
        
    • 
      
    

  
    
    


Returns:


    
  
    
  • 
      
      
        (Struct)
      
      
      
        —
        
    Returns an empty response.
    
      
    
    • 
  



  
See Also:

  



  

    
      


598

    		
    
      
# File 'sig/client.rbs', line 598

def create_queue_fleet_association: (

    		
  





    
      

  

  
    #create_queue_limit_association(params = {})  ⇒ Struct 
  

  

  


  

    
Associates a limit with a particular queue. After the limit is
associated, all workers for jobs that specify the limit associated
with the queue are subject to the limit. You can't associate two
limits with the same amountRequirementName to the same queue.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

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

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The unique identifier of the farm that contains the queue and limit to
associate.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The unique identifier of the queue to associate with the limit.
    
          
        
    • 
      
        
  • 
          :limit_id
          (required, String)
          
            
          
          
            — 
    The unique identifier of the limit to associate with the queue.
    
          
        
    • 
      
    

  
    
    


Returns:


    
  
    
  • 
      
      
        (Struct)
      
      
      
        —
        
    Returns an empty response.
    
      
    
    • 
  



  
See Also:

  



  

    
      


609

    		
    
      
# File 'sig/client.rbs', line 609

def create_queue_limit_association: (

    		
  





    
      

  

  
    #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({
  farm_id: "FarmId", # required
  client_token: "ClientToken",
  display_name: "ResourceName", # required
  os_family: "WINDOWS", # required, accepts WINDOWS, LINUX, MACOS
  file_system_locations: [
    {
      name: "FileSystemLocationName", # required
      path: "PathString", # required
      type: "SHARED", # required, accepts SHARED, LOCAL
    },
  ],
})

    
      
        
Response structure

      
      

resp.storage_profile_id #=> String

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID of the farm to connect to the storage profile.
    
          
        
    • 
      
        
  • 
          :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.
    

    This field can store any content. Escape or encode this content before
displaying it on a webpage or any other system that might interpret
the content of this field.
    
          
        
    • 
      
        
  • 
          :os_family
          (required, String)
          
            
          
          
            — 
    The type of operating system (OS) for the storage profile.
    
          
        
    • 
      
        
  • 
          :file_system_locations
          (Array<Types::FileSystemLocation>)
          
            
          
          
            — 
    File system paths to include in the storage profile.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


621

    		
    
      
# File 'sig/client.rbs', line 621

def create_storage_profile: (

    		
  





    
      

  

  
    #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.


Deadline Cloud limits the number of workers to less than or equal to
the fleet's maximum worker count. The service maintains eventual
consistency for the worker count. If you make multiple rapid calls to
CreateWorker before the field updates, you might exceed your
fleet's maximum worker count. For example, if your maxWorkerCount
is 10 and you currently have 9 workers, making two quick
CreateWorker calls might successfully create 2 workers instead of 1,
resulting in 11 total workers.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

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

    
      
        
Response structure

      
      

resp.worker_id #=> String

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

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

  



  

    
      


641

    		
    
      
# File 'sig/client.rbs', line 641

def create_worker: (

    		
  





    
      

  

  
    #delete_budget(params = {})  ⇒ Struct 
  

  

  


  

    
Deletes a budget.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

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

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID of the farm to remove from the budget.
    
          
        
    • 
      
        
  • 
          :budget_id
          (required, String)
          
            
          
          
            — 
    The budget ID of the budget to delete.
    
          
        
    • 
      
    

  
    
    


Returns:


    
  
    
  • 
      
      
        (Struct)
      
      
      
        —
        
    Returns an empty response.
    
      
    
    • 
  



  
See Also:

  



  

    
      


660

    		
    
      
# File 'sig/client.rbs', line 660

def delete_budget: (

    		
  





    
      

  

  
    #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:

  



  

    
      


670

    		
    
      
# File 'sig/client.rbs', line 670

def delete_farm: (

    		
  





    
      

  

  
    #delete_fleet(params = {})  ⇒ Struct 
  

  

  


  

    
Deletes a fleet.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

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

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

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

  
    
    


Returns:


    
  
    
  • 
      
      
        (Struct)
      
      
      
        —
        
    Returns an empty response.
    
      
    
    • 
  



  
See Also:

  



  

    
      


679

    		
    
      
# File 'sig/client.rbs', line 679

def delete_fleet: (

    		
  





    
      

  

  
    #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:

  



  

    
      


690

    		
    
      
# File 'sig/client.rbs', line 690

def delete_license_endpoint: (

    		
  





    
      

  

  
    #delete_limit(params = {})  ⇒ Struct 
  

  

  


  

    
Removes a limit from the specified farm. Before you delete a limit you
must use the DeleteQueueLimitAssociation operation to remove the
association with any queues.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.delete_limit({
  farm_id: "FarmId", # required
  limit_id: "LimitId", # required
})

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The unique identifier of the farm that contains the limit to delete.
    
          
        
    • 
      
        
  • 
          :limit_id
          (required, String)
          
            
          
          
            — 
    The unique identifier of the limit to delete.
    
          
        
    • 
      
    

  
    
    


Returns:


    
  
    
  • 
      
      
        (Struct)
      
      
      
        —
        
    Returns an empty response.
    
      
    
    • 
  



  
See Also:

  



  

    
      


699

    		
    
      
# File 'sig/client.rbs', line 699

def delete_limit: (

    		
  





    
      

  

  
    #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:

  



  

    
      


709

    		
    
      
# File 'sig/client.rbs', line 709

def delete_metered_product: (

    		
  





    
      

  

  
    #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:

  



  

    
      


719

    		
    
      
# File 'sig/client.rbs', line 719

def delete_monitor: (

    		
  





    
      

  

  
    #delete_queue(params = {})  ⇒ Struct 
  

  

  


  

    
Deletes a queue.


You can't recover the jobs in a queue if you delete the queue.
Deleting the queue also deletes the jobs in that 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:

  



  

    
      


728

    		
    
      
# File 'sig/client.rbs', line 728

def delete_queue: (

    		
  





    
      

  

  
    #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_id: "QueueId", # required
  queue_environment_id: "QueueEnvironmentId", # 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_id
          (required, String)
          
            
          
          
            — 
    The queue ID of the queue environment to delete.
    
          
        
    • 
      
        
  • 
          :queue_environment_id
          (required, String)
          
            
          
          
            — 
    The queue environment ID of the queue environment to delete.
    
          
        
    • 
      
    

  
    
    


Returns:


    
  
    
  • 
      
      
        (Struct)
      
      
      
        —
        
    Returns an empty response.
    
      
    
    • 
  



  
See Also:

  



  

    
      


738

    		
    
      
# File 'sig/client.rbs', line 738

def delete_queue_environment: (

    		
  





    
      

  

  
    #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
  queue_id: "QueueId", # required
  fleet_id: "FleetId", # 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.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The queue ID of the queue-fleet association.
    
          
        
    • 
      
        
  • 
          :fleet_id
          (required, String)
          
            
          
          
            — 
    The fleet ID of the queue-fleet association.
    
          
        
    • 
      
    

  
    
    


Returns:


    
  
    
  • 
      
      
        (Struct)
      
      
      
        —
        
    Returns an empty response.
    
      
    
    • 
  



  
See Also:

  



  

    
      


749

    		
    
      
# File 'sig/client.rbs', line 749

def delete_queue_fleet_association: (

    		
  





    
      

  

  
    #delete_queue_limit_association(params = {})  ⇒ Struct 
  

  

  


  

    
Removes the association between a queue and a limit. You must use the
UpdateQueueLimitAssociation operation to set the status to
STOP_LIMIT_USAGE_AND_COMPLETE_TASKS or
STOP_LIMIT_USAGE_AND_CANCEL_TASKS. The status does not change
immediately. Use the GetQueueLimitAssociation operation to see if
the status changed to STOPPED before deleting the association.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

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

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The unique identifier of the farm that contains the queue and limit to
disassociate.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The unique identifier of the queue to disassociate.
    
          
        
    • 
      
        
  • 
          :limit_id
          (required, String)
          
            
          
          
            — 
    The unique identifier of the limit to disassociate.
    
          
        
    • 
      
    

  
    
    


Returns:


    
  
    
  • 
      
      
        (Struct)
      
      
      
        —
        
    Returns an empty response.
    
      
    
    • 
  



  
See Also:

  



  

    
      


760

    		
    
      
# File 'sig/client.rbs', line 760

def delete_queue_limit_association: (

    		
  





    
      

  

  
    #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:

  



  

    
      


771

    		
    
      
# File 'sig/client.rbs', line 771

def delete_storage_profile: (

    		
  





    
      

  

  
    #delete_volume(params = {})  ⇒ Struct 
  

  

  


  

    
Deletes a persistent volume.


  





  
  

    
Examples:

    
      
        
Example: Delete a volume

      
      

resp = client.delete_volume({
  farm_id: "farm-1234567890abcdef1234567890abcdef", 
  fleet_id: "fleet-1234567890abcdef1234567890abcdef", 
  volume_id: "volume-1234567890abcdef1234567890abcdef", 
})

    
      
        
Request syntax with placeholder values

      
      

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

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID of the farm that contains the fleet.
    
          
        
    • 
      
        
  • 
          :fleet_id
          (required, String)
          
            
          
          
            — 
    The fleet ID of the fleet that contains the volume.
    
          
        
    • 
      
        
  • 
          :volume_id
          (required, String)
          
            
          
          
            — 
    The volume ID of the volume to delete.
    
          
        
    • 
      
    

  
    
    


Returns:


    
  
    
  • 
      
      
        (Struct)
      
      
      
        —
        
    Returns an empty response.
    
      
    
    • 
  



  
See Also:

  



  

    
      


781

    		
    
      
# File 'sig/client.rbs', line 781

def delete_volume: (

    		
  





    
      

  

  
    #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:

  



  

    
      


792

    		
    
      
# File 'sig/client.rbs', line 792

def delete_worker: (

    		
  





    
      

  

  
    #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:

  



  

    
      


803

    		
    
      
# File 'sig/client.rbs', line 803

def disassociate_member_from_farm: (

    		
  





    
      

  

  
    #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:

  



  

    
      


813

    		
    
      
# File 'sig/client.rbs', line 813

def disassociate_member_from_fleet: (

    		
  





    
      

  

  
    #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
  queue_id: "QueueId", # required
  job_id: "JobId", # required
  principal_id: "IdentityCenterPrincipalId", # required
})

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID for the job to disassociate from the member.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The queue ID connected to a job for which you're disassociating a
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.
    
          
        
    • 
      
    

  
    
    


Returns:


    
  
    
  • 
      
      
        (Struct)
      
      
      
        —
        
    Returns an empty response.
    
      
    
    • 
  



  
See Also:

  



  

    
      


824

    		
    
      
# File 'sig/client.rbs', line 824

def disassociate_member_from_job: (

    		
  





    
      

  

  
    #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
  queue_id: "QueueId", # required
  principal_id: "IdentityCenterPrincipalId", # required
})

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID for the queue to disassociate from a member.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The queue ID of the queue in which you're disassociating from a
member.
    
          
        
    • 
      
        
  • 
          :principal_id
          (required, String)
          
            
          
          
            — 
    A member's principal ID to disassociate from a queue.
    
          
        
    • 
      
    

  
    
    


Returns:


    
  
    
  • 
      
      
        (Struct)
      
      
      
        —
        
    Returns an empty response.
    
      
    
    • 
  



  
See Also:

  



  

    
      


836

    		
    
      
# File 'sig/client.rbs', line 836

def disassociate_member_from_queue: (

    		
  





    
      

  

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

  

  


  

    
Get a budget.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

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

    
      
        
Response structure

      
      

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

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID of the farm connected to the budget.
    
          
        
    • 
      
        
  • 
          :budget_id
          (required, String)
          
            
          
          
            — 
    The budget ID.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


861

    		
    
      
# File 'sig/client.rbs', line 861

def get_budget: (

    		
  





    
      

  

  
    #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.farm_id #=> String
resp.display_name #=> String
resp.kms_key_arn #=> String
resp.created_at #=> Time
resp.created_by #=> String
resp.updated_at #=> Time
resp.updated_by #=> String
resp.description #=> String
resp.cost_scale_factor #=> Float

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID of the farm.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


880

    		
    
      
# File 'sig/client.rbs', line 880

def get_farm: (

    		
  





    
      

  

  
    #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.fleet_id #=> String
resp.farm_id #=> String
resp.display_name #=> String
resp.status #=> String, one of "ACTIVE", "CREATE_IN_PROGRESS", "UPDATE_IN_PROGRESS", "CREATE_FAILED", "UPDATE_FAILED", "SUSPENDED"
resp.status_message #=> String
resp.auto_scaling_status #=> String, one of "GROWING", "STEADY", "SHRINKING"
resp.target_worker_count #=> Integer
resp.worker_count #=> Integer
resp.min_worker_count #=> Integer
resp.max_worker_count #=> Integer
resp.configuration.customer_managed.mode #=> String, one of "NO_SCALING", "EVENT_BASED_AUTO_SCALING"
resp.configuration.customer_managed.auto_scaling_configuration.standby_worker_count #=> Integer
resp.configuration.customer_managed.auto_scaling_configuration.worker_idle_duration_seconds #=> Integer
resp.configuration.customer_managed.auto_scaling_configuration.scale_out_workers_per_minute #=> Integer
resp.configuration.customer_managed.worker_capabilities.v_cpu_count.min #=> Integer
resp.configuration.customer_managed.worker_capabilities.v_cpu_count.max #=> Integer
resp.configuration.customer_managed.worker_capabilities.memory_mi_b.min #=> Integer
resp.configuration.customer_managed.worker_capabilities.memory_mi_b.max #=> 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.accelerator_count.min #=> Integer
resp.configuration.customer_managed.worker_capabilities.accelerator_count.max #=> Integer
resp.configuration.customer_managed.worker_capabilities.accelerator_total_memory_mi_b.min #=> Integer
resp.configuration.customer_managed.worker_capabilities.accelerator_total_memory_mi_b.max #=> Integer
resp.configuration.customer_managed.worker_capabilities.os_family #=> String, one of "WINDOWS", "LINUX", "MACOS"
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].name #=> String
resp.configuration.customer_managed.worker_capabilities.custom_amounts[0].min #=> Float
resp.configuration.customer_managed.worker_capabilities.custom_amounts[0].max #=> Float
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.storage_profile_id #=> String
resp.configuration.customer_managed.tag_propagation_mode #=> String, one of "NO_PROPAGATION", "PROPAGATE_TAGS_TO_WORKERS_AT_LAUNCH"
resp.configuration.service_managed_ec2.instance_capabilities.v_cpu_count.min #=> Integer
resp.configuration.service_managed_ec2.instance_capabilities.v_cpu_count.max #=> Integer
resp.configuration.service_managed_ec2.instance_capabilities.memory_mi_b.min #=> Integer
resp.configuration.service_managed_ec2.instance_capabilities.memory_mi_b.max #=> Integer
resp.configuration.service_managed_ec2.instance_capabilities.os_family #=> String, one of "WINDOWS", "LINUX"
resp.configuration.service_managed_ec2.instance_capabilities.cpu_architecture_type #=> String, one of "x86_64", "arm64"
resp.configuration.service_managed_ec2.instance_capabilities.root_ebs_volume.size_gi_b #=> Integer
resp.configuration.service_managed_ec2.instance_capabilities.root_ebs_volume.iops #=> Integer
resp.configuration.service_managed_ec2.instance_capabilities.root_ebs_volume.throughput_mi_b #=> Integer
resp.configuration.service_managed_ec2.instance_capabilities.accelerator_capabilities.selections #=> Array
resp.configuration.service_managed_ec2.instance_capabilities.accelerator_capabilities.selections[0].name #=> String, one of "t4", "a10g", "l4", "l40s", "rtx-pro-server-6000"
resp.configuration.service_managed_ec2.instance_capabilities.accelerator_capabilities.selections[0].runtime #=> String
resp.configuration.service_managed_ec2.instance_capabilities.accelerator_capabilities.count.min #=> Integer
resp.configuration.service_managed_ec2.instance_capabilities.accelerator_capabilities.count.max #=> 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.excluded_instance_types #=> Array
resp.configuration.service_managed_ec2.instance_capabilities.excluded_instance_types[0] #=> String
resp.configuration.service_managed_ec2.instance_capabilities.custom_amounts #=> Array
resp.configuration.service_managed_ec2.instance_capabilities.custom_amounts[0].name #=> String
resp.configuration.service_managed_ec2.instance_capabilities.custom_amounts[0].min #=> Float
resp.configuration.service_managed_ec2.instance_capabilities.custom_amounts[0].max #=> Float
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_market_options.type #=> String, one of "on-demand", "spot", "wait-and-save"
resp.configuration.service_managed_ec2.vpc_configuration.resource_configuration_arns #=> Array
resp.configuration.service_managed_ec2.vpc_configuration.resource_configuration_arns[0] #=> String
resp.configuration.service_managed_ec2.storage_profile_id #=> String
resp.configuration.service_managed_ec2.persistent_volume_configuration.size_gi_b #=> Integer
resp.configuration.service_managed_ec2.persistent_volume_configuration.iops #=> Integer
resp.configuration.service_managed_ec2.persistent_volume_configuration.throughput_mi_b #=> Integer
resp.configuration.service_managed_ec2.persistent_volume_configuration.mount_path #=> String
resp.configuration.service_managed_ec2.persistent_volume_configuration.last_used_ttl_hours #=> Integer
resp.configuration.service_managed_ec2.auto_scaling_configuration.standby_worker_count #=> Integer
resp.configuration.service_managed_ec2.auto_scaling_configuration.worker_idle_duration_seconds #=> Integer
resp.configuration.service_managed_ec2.auto_scaling_configuration.scale_out_workers_per_minute #=> Integer
resp.created_at #=> Time
resp.created_by #=> String
resp.updated_at #=> Time
resp.updated_by #=> String
resp.description #=> String
resp.host_configuration.script_body #=> String
resp.host_configuration.script_timeout_seconds #=> Integer
resp.capabilities.amounts #=> Array
resp.capabilities.amounts[0].name #=> String
resp.capabilities.amounts[0].min #=> Float
resp.capabilities.amounts[0].max #=> Float
resp.capabilities.attributes #=> Array
resp.capabilities.attributes[0].name #=> String
resp.capabilities.attributes[0].values #=> Array
resp.capabilities.attributes[0].values[0] #=> String
resp.role_arn #=> String

    
  


  

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:

  



  

    
      


908

    		
    
      
# File 'sig/client.rbs', line 908

def get_fleet: (

    		
  





    
      

  

  
    #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_complete
* job_create_complete
* job_succeeded


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

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

    
      
        
Response structure

      
      

resp.job_id #=> String
resp.name #=> 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.priority #=> Integer
resp.created_at #=> Time
resp.created_by #=> String
resp.updated_at #=> Time
resp.updated_by #=> String
resp.started_at #=> Time
resp.ended_at #=> Time
resp.task_run_status #=> String, one of "PENDING", "READY", "ASSIGNED", "STARTING", "SCHEDULED", "INTERRUPTING", "RUNNING", "SUSPENDED", "CANCELED", "FAILED", "SUCCEEDED", "NOT_COMPATIBLE"
resp.target_task_run_status #=> String, one of "READY", "FAILED", "SUCCEEDED", "CANCELED", "SUSPENDED", "PENDING"
resp.task_run_status_counts #=> Hash
resp.task_run_status_counts["TaskRunStatus"] #=> Integer
resp.task_failure_retry_count #=> Integer
resp.storage_profile_id #=> String
resp.max_failed_tasks_count #=> Integer
resp.max_retries_per_task #=> Integer
resp.parameters #=> Hash
resp.parameters["JobParametersKeyString"].int #=> String
resp.parameters["JobParametersKeyString"].float #=> String
resp.parameters["JobParametersKeyString"].string #=> String
resp.parameters["JobParametersKeyString"].path #=> String
resp.attachments.manifests #=> Array
resp.attachments.manifests[0].file_system_location_name #=> String
resp.attachments.manifests[0].root_path #=> String
resp.attachments.manifests[0].root_path_format #=> String, one of "windows", "posix"
resp.attachments.manifests[0].output_relative_directories #=> Array
resp.attachments.manifests[0].output_relative_directories[0] #=> String
resp.attachments.manifests[0].input_manifest_path #=> String
resp.attachments.manifests[0].input_manifest_hash #=> String
resp.attachments.file_system #=> String, one of "COPIED", "VIRTUAL"
resp.description #=> String
resp.max_worker_count #=> Integer
resp.source_job_id #=> String

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID of the farm in the job.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The queue ID associated with the job.
    
          
        
    • 
      
        
  • 
          :job_id
          (required, String)
          
            
          
          
            — 
    The job ID.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


941

    		
    
      
# File 'sig/client.rbs', line 941

def get_job: (

    		
  





    
      

  

  
    #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.license_endpoint_id #=> String
resp.status #=> String, one of "CREATE_IN_PROGRESS", "DELETE_IN_PROGRESS", "READY", "NOT_READY"
resp.status_message #=> String
resp.vpc_id #=> String
resp.dns_name #=> String
resp.subnet_ids #=> Array
resp.subnet_ids[0] #=> String
resp.security_group_ids #=> Array
resp.security_group_ids[0] #=> String

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :license_endpoint_id
          (required, String)
          
            
          
          
            — 
    The license endpoint ID.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


959

    		
    
      
# File 'sig/client.rbs', line 959

def get_license_endpoint: (

    		
  





    
      

  

  
    #get_limit(params = {})  ⇒ Types::GetLimitResponse 
  

  

  


  

    
Gets information about a specific limit.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.get_limit({
  farm_id: "FarmId", # required
  limit_id: "LimitId", # required
})

    
      
        
Response structure

      
      

resp.farm_id #=> String
resp.limit_id #=> String
resp.current_count #=> Integer
resp.created_at #=> Time
resp.created_by #=> String
resp.updated_at #=> Time
resp.updated_by #=> String
resp.display_name #=> String
resp.amount_requirement_name #=> String
resp.max_count #=> Integer
resp.description #=> String

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The unique identifier of the farm that contains the limit.
    
          
        
    • 
      
        
  • 
          :limit_id
          (required, String)
          
            
          
          
            — 
    The unique identifier of the limit to return.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


979

    		
    
      
# File 'sig/client.rbs', line 979

def get_limit: (

    		
  





    
      

  

  
    #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.monitor_id #=> String
resp.display_name #=> String
resp.subdomain #=> String
resp.url #=> String
resp.role_arn #=> String
resp.identity_center_instance_arn #=> String
resp.identity_center_region #=> String
resp.identity_center_application_arn #=> String
resp.created_at #=> Time
resp.created_by #=> String
resp.updated_at #=> Time
resp.updated_by #=> 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:

  



  

    
      


1001

    		
    
      
# File 'sig/client.rbs', line 1001

def get_monitor: (

    		
  





    
      

  

  
    #get_monitor_settings(params = {})  ⇒ Types::GetMonitorSettingsResponse 
  

  

  


  

    
Gets the settings for a Deadline Cloud monitor.


  





  
  

    
Examples:

    
      
        
Example: Get monitor settings

      
      

resp = client.get_monitor_settings({
  monitor_id: "monitor-1234567890abcdef1234567890abcdef", 
})

    
      
        
Request syntax with placeholder values

      
      

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

    
      
        
Response structure

      
      

resp.settings #=> Hash
resp.settings["SettingKey"] #=> String

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :monitor_id
          (required, String)
          
            
          
          
            — 
    The unique identifier of the monitor. This ID is returned by the
CreateMonitor operation, and is included in the response to the
ListMonitors operation.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1011

    		
    
      
# File 'sig/client.rbs', line 1011

def get_monitor_settings: (

    		
  





    
      

  

  
    #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.farm_id #=> String
resp.queue_id #=> String
resp.display_name #=> String
resp.status #=> String, one of "IDLE", "SCHEDULING", "SCHEDULING_BLOCKED"
resp.default_budget_action #=> String, one of "NONE", "STOP_SCHEDULING_AND_COMPLETE_TASKS", "STOP_SCHEDULING_AND_CANCEL_TASKS"
resp.blocked_reason #=> String, one of "NO_BUDGET_CONFIGURED", "BUDGET_THRESHOLD_REACHED"
resp.created_at #=> Time
resp.created_by #=> String
resp.updated_at #=> Time
resp.updated_by #=> String
resp.description #=> String
resp.job_attachment_settings.s3_bucket_name #=> String
resp.job_attachment_settings.root_prefix #=> String
resp.role_arn #=> String
resp.required_file_system_location_names #=> Array
resp.required_file_system_location_names[0] #=> String
resp.allowed_storage_profile_ids #=> Array
resp.allowed_storage_profile_ids[0] #=> String
resp.job_run_as_user.posix.user #=> String
resp.job_run_as_user.posix.group #=> String
resp.job_run_as_user.windows.user #=> String
resp.job_run_as_user.windows.password_arn #=> String
resp.job_run_as_user.run_as #=> String, one of "QUEUE_CONFIGURED_USER", "WORKER_AGENT_USER"
resp.scheduling_configuration.priority_balanced.rendering_task_buffer #=> Integer
resp.scheduling_configuration.weighted_balanced.priority_weight #=> Float
resp.scheduling_configuration.weighted_balanced.error_weight #=> Float
resp.scheduling_configuration.weighted_balanced.submission_time_weight #=> Float
resp.scheduling_configuration.weighted_balanced.rendering_task_weight #=> Float
resp.scheduling_configuration.weighted_balanced.rendering_task_buffer #=> Integer

    
  


  

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:

  



  

    
      


1037

    		
    
      
# File 'sig/client.rbs', line 1037

def get_queue: (

    		
  





    
      

  

  
    #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_id: "QueueId", # required
  queue_environment_id: "QueueEnvironmentId", # required
})

    
      
        
Response structure

      
      

resp.queue_environment_id #=> String
resp.name #=> String
resp.priority #=> Integer
resp.template_type #=> String, one of "JSON", "YAML"
resp.template #=> String
resp.created_at #=> Time
resp.created_by #=> 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 queue environment.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The queue ID for the queue environment.
    
          
        
    • 
      
        
  • 
          :queue_environment_id
          (required, String)
          
            
          
          
            — 
    The queue environment ID.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1056

    		
    
      
# File 'sig/client.rbs', line 1056

def get_queue_environment: (

    		
  





    
      

  

  
    #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
  queue_id: "QueueId", # required
  fleet_id: "FleetId", # required
})

    
      
        
Response structure

      
      

resp.queue_id #=> String
resp.fleet_id #=> String
resp.status #=> String, one of "ACTIVE", "STOP_SCHEDULING_AND_COMPLETE_TASKS", "STOP_SCHEDULING_AND_CANCEL_TASKS", "STOPPED"
resp.created_at #=> Time
resp.created_by #=> 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 that contains the queue-fleet association.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The queue ID for the queue-fleet association.
    
          
        
    • 
      
        
  • 
          :fleet_id
          (required, String)
          
            
          
          
            — 
    The fleet ID for the queue-fleet association.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1074

    		
    
      
# File 'sig/client.rbs', line 1074

def get_queue_fleet_association: (

    		
  





    
      

  

  
    #get_queue_limit_association(params = {})  ⇒ Types::GetQueueLimitAssociationResponse 
  

  

  


  

    
Gets information about a specific association between a queue and a
limit.


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


* queue_limit_association_stopped


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

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

    
      
        
Response structure

      
      

resp.queue_id #=> String
resp.limit_id #=> String
resp.status #=> String, one of "ACTIVE", "STOP_LIMIT_USAGE_AND_COMPLETE_TASKS", "STOP_LIMIT_USAGE_AND_CANCEL_TASKS", "STOPPED"
resp.created_at #=> Time
resp.created_by #=> String
resp.updated_at #=> Time
resp.updated_by #=> String

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The unique identifier of the farm that contains the associated queue
and limit.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The unique identifier of the queue associated with the limit.
    
          
        
    • 
      
        
  • 
          :limit_id
          (required, String)
          
            
          
          
            — 
    The unique identifier of the limit associated with the queue.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1092

    		
    
      
# File 'sig/client.rbs', line 1092

def get_queue_limit_association: (

    		
  





    
      

  

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

  

  


  

    
Gets a session.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

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

    
      
        
Response structure

      
      

resp.session_id #=> String
resp.fleet_id #=> String
resp.worker_id #=> String
resp.started_at #=> Time
resp.lifecycle_status #=> String, one of "STARTED", "UPDATE_IN_PROGRESS", "UPDATE_SUCCEEDED", "UPDATE_FAILED", "ENDED"
resp.ended_at #=> Time
resp.target_lifecycle_status #=> String, one of "ENDED"
resp.updated_at #=> Time
resp.updated_by #=> 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.log.error #=> 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.host_properties.host_name #=> String
resp.host_properties.ec2_instance_arn #=> String
resp.host_properties.ec2_instance_type #=> 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
resp.worker_log.error #=> String

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID for the session.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The queue ID for the session.
    
          
        
    • 
      
        
  • 
          :job_id
          (required, String)
          
            
          
          
            — 
    The job ID for the session.
    
          
        
    • 
      
        
  • 
          :session_id
          (required, String)
          
            
          
          
            — 
    The session ID.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1115

    		
    
      
# File 'sig/client.rbs', line 1115

def get_session: (

    		
  





    
      

  

  
    #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
  queue_id: "QueueId", # required
  job_id: "JobId", # required
  session_action_id: "SessionActionId", # required
})

    
      
        
Response structure

      
      

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

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID for the session action.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The queue ID for the session action.
    
          
        
    • 
      
        
  • 
          :job_id
          (required, String)
          
            
          
          
            — 
    The job ID for the session.
    
          
        
    • 
      
        
  • 
          :session_action_id
          (required, String)
          
            
          
          
            — 
    The session action ID for the session.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1139

    		
    
      
# File 'sig/client.rbs', line 1139

def get_session_action: (

    		
  





    
      

  

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

    
      
        
Response structure

      
      

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

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :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.
    
          
        
    • 
      
        
  • 
          :next_token
          (String)
          
            
          
          
            — 
    The token for the next set of results, or null to start from the
beginning.
    
          
        
    • 
      
        
  • 
          :max_results
          (Integer)
          
            
          
          
            — 
    The maximum number of results to return. Use this parameter with
NextToken to get results as a set of sequential pages.
    
          
        
    • 
      
        
  • 
          :aggregation_id
          (required, String)
          
            
          
          
            — 
    The identifier returned by the StartSessionsStatisticsAggregation
operation that identifies the aggregated statistics.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1155

    		
    
      
# File 'sig/client.rbs', line 1155

def get_sessions_statistics_aggregation: (

    		
  





    
      

  

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

  

  


  

    
Gets a step.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

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

    
      
        
Response structure

      
      

resp.step_id #=> String
resp.name #=> String
resp.lifecycle_status #=> String, one of "CREATE_COMPLETE", "UPDATE_IN_PROGRESS", "UPDATE_FAILED", "UPDATE_SUCCEEDED"
resp.lifecycle_status_message #=> String
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.task_failure_retry_count #=> Integer
resp.target_task_run_status #=> String, one of "READY", "FAILED", "SUCCEEDED", "CANCELED", "SUSPENDED", "PENDING"
resp.created_at #=> Time
resp.created_by #=> String
resp.updated_at #=> Time
resp.updated_by #=> String
resp.started_at #=> Time
resp.ended_at #=> Time
resp.dependency_counts.dependencies_resolved #=> Integer
resp.dependency_counts.dependencies_unresolved #=> Integer
resp.dependency_counts.consumers_resolved #=> Integer
resp.dependency_counts.consumers_unresolved #=> Integer
resp.required_capabilities.attributes #=> Array
resp.required_capabilities.attributes[0].name #=> String
resp.required_capabilities.attributes[0].any_of #=> Array
resp.required_capabilities.attributes[0].any_of[0] #=> String
resp.required_capabilities.attributes[0].all_of #=> Array
resp.required_capabilities.attributes[0].all_of[0] #=> String
resp.required_capabilities.amounts #=> Array
resp.required_capabilities.amounts[0].name #=> String
resp.required_capabilities.amounts[0].min #=> Float
resp.required_capabilities.amounts[0].max #=> Float
resp.required_capabilities.amounts[0].value #=> Float
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", "CHUNK_INT"
resp.parameter_space.parameters[0].chunks.default_task_count #=> Integer
resp.parameter_space.parameters[0].chunks.target_runtime_seconds #=> Integer
resp.parameter_space.parameters[0].chunks.range_constraint #=> String, one of "CONTIGUOUS", "NONCONTIGUOUS"
resp.parameter_space.combination #=> String
resp.description #=> String

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID for the step.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The queue ID for the step.
    
          
        
    • 
      
        
  • 
          :job_id
          (required, String)
          
            
          
          
            — 
    The job ID for the step.
    
          
        
    • 
      
        
  • 
          :step_id
          (required, String)
          
            
          
          
            — 
    The step ID.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1185

    		
    
      
# File 'sig/client.rbs', line 1185

def get_step: (

    		
  





    
      

  

  
    #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.storage_profile_id #=> String
resp.display_name #=> String
resp.os_family #=> String, one of "WINDOWS", "LINUX", "MACOS"
resp.created_at #=> Time
resp.created_by #=> String
resp.updated_at #=> Time
resp.updated_by #=> 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"

    
  


  

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:

  



  

    
      


1205

    		
    
      
# File 'sig/client.rbs', line 1205

def get_storage_profile: (

    		
  





    
      

  

  
    #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.storage_profile_id #=> String
resp.display_name #=> String
resp.os_family #=> String, one of "WINDOWS", "LINUX", "MACOS"
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"

    
  


  

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:

  



  

    
      


1219

    		
    
      
# File 'sig/client.rbs', line 1219

def get_storage_profile_for_queue: (

    		
  





    
      

  

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

  

  


  

    
Gets a task.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

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

    
      
        
Response structure

      
      

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

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID of the farm connected to the task.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The queue ID for the queue connected to the task.
    
          
        
    • 
      
        
  • 
          :job_id
          (required, String)
          
            
          
          
            — 
    The job ID of the job 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:

  



  

    
      


1242

    		
    
      
# File 'sig/client.rbs', line 1242

def get_task: (

    		
  





    
      

  

  
    #get_volume(params = {})  ⇒ Types::GetVolumeResponse 
  

  

  


  

    
Gets a persistent volume.


  





  
  

    
Examples:

    
      
        
Example: Get a volume

      
      

resp = client.get_volume({
  farm_id: "farm-1234567890abcdef1234567890abcdef", 
  fleet_id: "fleet-1234567890abcdef1234567890abcdef", 
  volume_id: "volume-1234567890abcdef1234567890abcdef", 
})

    
      
        
Request syntax with placeholder values

      
      

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

    
      
        
Response structure

      
      

resp.volume_id #=> String
resp.farm_id #=> String
resp.fleet_id #=> String
resp.state #=> String, one of "PENDING_CREATION", "PENDING_ATTACHMENT", "IN_USE", "AVAILABLE", "PENDING_DELETION"
resp.size_gi_b #=> Integer
resp.availability_zone_id #=> String
resp.attached_worker_id #=> String
resp.volume_type #=> String, one of "gp3"
resp.iops #=> Integer
resp.throughput_mi_b #=> Integer
resp.created_at #=> Time
resp.last_assigned_at #=> Time
resp.last_released_at #=> Time
resp.expires_at #=> Time

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID of the farm that contains the fleet.
    
          
        
    • 
      
        
  • 
          :fleet_id
          (required, String)
          
            
          
          
            — 
    The fleet ID of the fleet that contains the volume.
    
          
        
    • 
      
        
  • 
          :volume_id
          (required, String)
          
            
          
          
            — 
    The volume ID of the volume to retrieve.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1269

    		
    
      
# File 'sig/client.rbs', line 1269

def get_volume: (

    		
  





    
      

  

  
    #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.farm_id #=> String
resp.fleet_id #=> String
resp.worker_id #=> 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.host_properties.host_name #=> String
resp.host_properties.ec2_instance_arn #=> String
resp.host_properties.ec2_instance_type #=> String
resp.status #=> String, one of "CREATED", "STARTED", "STOPPING", "STOPPED", "NOT_RESPONDING", "NOT_COMPATIBLE", "RUNNING", "IDLE"
resp.log.log_driver #=> String
resp.log.options #=> Hash
resp.log.options["String"] #=> String
resp.log.parameters #=> Hash
resp.log.parameters["String"] #=> String
resp.log.error #=> String
resp.created_at #=> Time
resp.created_by #=> 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 worker.
    
          
        
    • 
      
        
  • 
          :fleet_id
          (required, String)
          
            
          
          
            — 
    The fleet ID of the worker.
    
          
        
    • 
      
        
  • 
          :worker_id
          (required, String)
          
            
          
          
            — 
    The worker ID.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1290

    		
    
      
# File 'sig/client.rbs', line 1290

def get_worker: (

    		
  





    
      

  

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

    
      
        
Response structure

      
      

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

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :next_token
          (String)
          
            
          
          
            — 
    The token for the next set of results, or null to start from the
beginning.
    
          
        
    • 
      
        
  • 
          :max_results
          (Integer)
          
            
          
          
            — 
    The maximum number of results to return. Use this parameter with
NextToken to get results as a set of sequential pages.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1303

    		
    
      
# File 'sig/client.rbs', line 1303

def list_available_metered_products: (

    		
  





    
      

  

  
    #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
  next_token: "NextToken",
  max_results: 1,
  status: "ACTIVE", # accepts ACTIVE, INACTIVE
})

    
      
        
Response structure

      
      

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

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID associated with the budgets.
    
          
        
    • 
      
        
  • 
          :next_token
          (String)
          
            
          
          
            — 
    The token for the next set of results, or null to start from the
beginning.
    
          
        
    • 
      
        
  • 
          :max_results
          (Integer)
          
            
          
          
            — 
    The maximum number of results to return. Use this parameter with
NextToken to get results as a set of sequential pages.
    
          
        
    • 
      
        
  • 
          :status
          (String)
          
            
          
          
            — 
    The status to list for the budgets.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1315

    		
    
      
# File 'sig/client.rbs', line 1315

def list_budgets: (

    		
  





    
      

  

  
    #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
  next_token: "NextToken",
  max_results: 1,
})

    
      
        
Response structure

      
      

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

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID.
    
          
        
    • 
      
        
  • 
          :next_token
          (String)
          
            
          
          
            — 
    The token for the next set of results, or null to start from the
beginning.
    
          
        
    • 
      
        
  • 
          :max_results
          (Integer)
          
            
          
          
            — 
    The maximum number of results to return. Use this parameter with
NextToken to get results as a set of sequential pages.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1329

    		
    
      
# File 'sig/client.rbs', line 1329

def list_farm_members: (

    		
  





    
      

  

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

    
      
        
Response structure

      
      

resp.farms #=> Array
resp.farms[0].farm_id #=> String
resp.farms[0].display_name #=> String
resp.farms[0].kms_key_arn #=> String
resp.farms[0].created_at #=> Time
resp.farms[0].created_by #=> 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):

    
    
      
        
  • 
          :next_token
          (String)
          
            
          
          
            — 
    The token for the next set of results, or null to start from the
beginning.
    
          
        
    • 
      
        
  • 
          :max_results
          (Integer)
          
            
          
          
            — 
    The maximum number of results to return. Use this parameter with
NextToken to get results as a set of sequential pages.
    
          
        
    • 
      
        
  • 
          :principal_id
          (String)
          
            
          
          
            — 
    The principal ID of the member to list on the farm.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1342

    		
    
      
# File 'sig/client.rbs', line 1342

def list_farms: (

    		
  





    
      

  

  
    #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
  next_token: "NextToken",
  max_results: 1,
})

    
      
        
Response structure

      
      

resp.members #=> Array
resp.members[0].farm_id #=> String
resp.members[0].fleet_id #=> String
resp.members[0].principal_id #=> String
resp.members[0].principal_type #=> String, one of "USER", "GROUP"
resp.members[0].identity_store_id #=> String
resp.members[0].membership_level #=> String, one of "VIEWER", "CONTRIBUTOR", "OWNER", "MANAGER"
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.
    
          
        
    • 
      
        
  • 
          :next_token
          (String)
          
            
          
          
            — 
    The token for the next set of results, or null to start from the
beginning.
    
          
        
    • 
      
        
  • 
          :max_results
          (Integer)
          
            
          
          
            — 
    The maximum number of results to return. Use this parameter with
NextToken to get results as a set of sequential pages.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1355

    		
    
      
# File 'sig/client.rbs', line 1355

def list_fleet_members: (

    		
  





    
      

  

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

    
      
        
Response structure

      
      

resp.fleets #=> Array
resp.fleets[0].fleet_id #=> String
resp.fleets[0].farm_id #=> String
resp.fleets[0].display_name #=> String
resp.fleets[0].status #=> String, one of "ACTIVE", "CREATE_IN_PROGRESS", "UPDATE_IN_PROGRESS", "CREATE_FAILED", "UPDATE_FAILED", "SUSPENDED"
resp.fleets[0].status_message #=> String
resp.fleets[0].auto_scaling_status #=> String, one of "GROWING", "STEADY", "SHRINKING"
resp.fleets[0].target_worker_count #=> Integer
resp.fleets[0].worker_count #=> Integer
resp.fleets[0].min_worker_count #=> Integer
resp.fleets[0].max_worker_count #=> Integer
resp.fleets[0].configuration.customer_managed.mode #=> String, one of "NO_SCALING", "EVENT_BASED_AUTO_SCALING"
resp.fleets[0].configuration.customer_managed.auto_scaling_configuration.standby_worker_count #=> Integer
resp.fleets[0].configuration.customer_managed.auto_scaling_configuration.worker_idle_duration_seconds #=> Integer
resp.fleets[0].configuration.customer_managed.auto_scaling_configuration.scale_out_workers_per_minute #=> Integer
resp.fleets[0].configuration.customer_managed.worker_capabilities.v_cpu_count.min #=> Integer
resp.fleets[0].configuration.customer_managed.worker_capabilities.v_cpu_count.max #=> Integer
resp.fleets[0].configuration.customer_managed.worker_capabilities.memory_mi_b.min #=> Integer
resp.fleets[0].configuration.customer_managed.worker_capabilities.memory_mi_b.max #=> 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.accelerator_count.min #=> Integer
resp.fleets[0].configuration.customer_managed.worker_capabilities.accelerator_count.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_total_memory_mi_b.max #=> 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.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].name #=> String
resp.fleets[0].configuration.customer_managed.worker_capabilities.custom_amounts[0].min #=> Float
resp.fleets[0].configuration.customer_managed.worker_capabilities.custom_amounts[0].max #=> Float
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.storage_profile_id #=> String
resp.fleets[0].configuration.customer_managed.tag_propagation_mode #=> String, one of "NO_PROPAGATION", "PROPAGATE_TAGS_TO_WORKERS_AT_LAUNCH"
resp.fleets[0].configuration.service_managed_ec2.instance_capabilities.v_cpu_count.min #=> Integer
resp.fleets[0].configuration.service_managed_ec2.instance_capabilities.v_cpu_count.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.memory_mi_b.max #=> 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.cpu_architecture_type #=> String, one of "x86_64", "arm64"
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.iops #=> 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.accelerator_capabilities.selections #=> Array
resp.fleets[0].configuration.service_managed_ec2.instance_capabilities.accelerator_capabilities.selections[0].name #=> String, one of "t4", "a10g", "l4", "l40s", "rtx-pro-server-6000"
resp.fleets[0].configuration.service_managed_ec2.instance_capabilities.accelerator_capabilities.selections[0].runtime #=> String
resp.fleets[0].configuration.service_managed_ec2.instance_capabilities.accelerator_capabilities.count.min #=> Integer
resp.fleets[0].configuration.service_managed_ec2.instance_capabilities.accelerator_capabilities.count.max #=> 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.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.custom_amounts #=> Array
resp.fleets[0].configuration.service_managed_ec2.instance_capabilities.custom_amounts[0].name #=> String
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].max #=> Float
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_market_options.type #=> String, one of "on-demand", "spot", "wait-and-save"
resp.fleets[0].configuration.service_managed_ec2.vpc_configuration.resource_configuration_arns #=> Array
resp.fleets[0].configuration.service_managed_ec2.vpc_configuration.resource_configuration_arns[0] #=> String
resp.fleets[0].configuration.service_managed_ec2.storage_profile_id #=> String
resp.fleets[0].configuration.service_managed_ec2.persistent_volume_configuration.size_gi_b #=> Integer
resp.fleets[0].configuration.service_managed_ec2.persistent_volume_configuration.iops #=> Integer
resp.fleets[0].configuration.service_managed_ec2.persistent_volume_configuration.throughput_mi_b #=> Integer
resp.fleets[0].configuration.service_managed_ec2.persistent_volume_configuration.mount_path #=> String
resp.fleets[0].configuration.service_managed_ec2.persistent_volume_configuration.last_used_ttl_hours #=> Integer
resp.fleets[0].configuration.service_managed_ec2.auto_scaling_configuration.standby_worker_count #=> Integer
resp.fleets[0].configuration.service_managed_ec2.auto_scaling_configuration.worker_idle_duration_seconds #=> Integer
resp.fleets[0].configuration.service_managed_ec2.auto_scaling_configuration.scale_out_workers_per_minute #=> Integer
resp.fleets[0].created_at #=> Time
resp.fleets[0].created_by #=> String
resp.fleets[0].updated_at #=> Time
resp.fleets[0].updated_by #=> String
resp.next_token #=> String

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID of the fleets.
    
          
        
    • 
      
        
  • 
          :next_token
          (String)
          
            
          
          
            — 
    The token for the next set of results, or null to start from the
beginning.
    
          
        
    • 
      
        
  • 
          :max_results
          (Integer)
          
            
          
          
            — 
    The maximum number of results to return. Use this parameter with
NextToken to get results as a set of sequential pages.
    
          
        
    • 
      
        
  • 
          :principal_id
          (String)
          
            
          
          
            — 
    The principal ID of the members to include in the fleet.
    
          
        
    • 
      
        
  • 
          :display_name
          (String)
          
            
          
          
            — 
    The display names of a list of fleets.
    

    This field can store any content. Escape or encode this content before
displaying it on a webpage or any other system that might interpret
the content of this field.
    
          
        
    • 
      
        
  • 
          :status
          (String)
          
            
          
          
            — 
    The status of the fleet.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1369

    		
    
      
# File 'sig/client.rbs', line 1369

def list_fleets: (

    		
  





    
      

  

  
    #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
  queue_id: "QueueId", # required
  job_id: "JobId", # required
  next_token: "NextToken",
  max_results: 1,
})

    
      
        
Response structure

      
      

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

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID of the job to list.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The queue ID to include on the list.
    
          
        
    • 
      
        
  • 
          :job_id
          (required, String)
          
            
          
          
            — 
    The job ID to include on the list.
    
          
        
    • 
      
        
  • 
          :next_token
          (String)
          
            
          
          
            — 
    The token for the next set of results, or null to start from the
beginning.
    
          
        
    • 
      
        
  • 
          :max_results
          (Integer)
          
            
          
          
            — 
    The maximum number of results to return. Use this parameter with
NextToken to get results as a set of sequential pages.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1385

    		
    
      
# File 'sig/client.rbs', line 1385

def list_job_members: (

    		
  





    
      

  

  
    #list_job_parameter_definitions(params = {})  ⇒ Types::ListJobParameterDefinitionsResponse 
  

  

  


  

    
Lists parameter definitions of 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_parameter_definitions({
  farm_id: "FarmId", # required
  queue_id: "QueueId", # required
  job_id: "JobId", # required
  next_token: "NextToken",
  max_results: 1,
})

    
      
        
Response structure

      
      

resp.job_parameter_definitions #=> Array
resp.next_token #=> String

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID of the job to list.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The queue ID to include on the list.
    
          
        
    • 
      
        
  • 
          :job_id
          (required, String)
          
            
          
          
            — 
    The job ID to include on the list.
    
          
        
    • 
      
        
  • 
          :next_token
          (String)
          
            
          
          
            — 
    The token for the next set of results, or null to start from the
beginning.
    
          
        
    • 
      
        
  • 
          :max_results
          (Integer)
          
            
          
          
            — 
    The maximum number of results to return. Use this parameter with
NextToken to get results as a set of sequential pages.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1400

    		
    
      
# File 'sig/client.rbs', line 1400

def list_job_parameter_definitions: (

    		
  





    
      

  

  
    #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
  queue_id: "QueueId", # required
  next_token: "NextToken",
  max_results: 1,
  principal_id: "IdentityCenterPrincipalId",
})

    
      
        
Response structure

      
      

resp.jobs #=> Array
resp.jobs[0].job_id #=> String
resp.jobs[0].name #=> 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].priority #=> Integer
resp.jobs[0].created_at #=> Time
resp.jobs[0].created_by #=> String
resp.jobs[0].updated_at #=> Time
resp.jobs[0].updated_by #=> String
resp.jobs[0].started_at #=> Time
resp.jobs[0].ended_at #=> Time
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].target_task_run_status #=> String, one of "READY", "FAILED", "SUCCEEDED", "CANCELED", "SUSPENDED", "PENDING"
resp.jobs[0].task_run_status_counts #=> Hash
resp.jobs[0].task_run_status_counts["TaskRunStatus"] #=> Integer
resp.jobs[0].task_failure_retry_count #=> Integer
resp.jobs[0].max_failed_tasks_count #=> Integer
resp.jobs[0].max_retries_per_task #=> Integer
resp.jobs[0].max_worker_count #=> Integer
resp.jobs[0].source_job_id #=> String
resp.next_token #=> String

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID for the jobs.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The queue ID for the job.
    
          
        
    • 
      
        
  • 
          :next_token
          (String)
          
            
          
          
            — 
    The token for the next set of results, or null to start from the
beginning.
    
          
        
    • 
      
        
  • 
          :max_results
          (Integer)
          
            
          
          
            — 
    The maximum number of results to return. Use this parameter with
NextToken to get results as a set of sequential pages.
    
          
        
    • 
      
        
  • 
          :principal_id
          (String)
          
            
          
          
            — 
    The principal ID of the members on the jobs.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1415

    		
    
      
# File 'sig/client.rbs', line 1415

def list_jobs: (

    		
  





    
      

  

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

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

    
    
      
        
  • 
          :next_token
          (String)
          
            
          
          
            — 
    The token for the next set of results, or null to start from the
beginning.
    
          
        
    • 
      
        
  • 
          :max_results
          (Integer)
          
            
          
          
            — 
    The maximum number of results to return. Use this parameter with
NextToken to get results as a set of sequential pages.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1430

    		
    
      
# File 'sig/client.rbs', line 1430

def list_license_endpoints: (

    		
  





    
      

  

  
    #list_limits(params = {})  ⇒ Types::ListLimitsResponse 
  

  

  


  

    
Gets a list of limits defined in the specified 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_limits({
  farm_id: "FarmId", # required
  next_token: "NextToken",
  max_results: 1,
})

    
      
        
Response structure

      
      

resp.limits #=> Array
resp.limits[0].farm_id #=> String
resp.limits[0].limit_id #=> String
resp.limits[0].current_count #=> Integer
resp.limits[0].created_at #=> Time
resp.limits[0].created_by #=> String
resp.limits[0].updated_at #=> Time
resp.limits[0].updated_by #=> String
resp.limits[0].display_name #=> String
resp.limits[0].amount_requirement_name #=> String
resp.limits[0].max_count #=> Integer
resp.next_token #=> String

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The unique identifier of the farm that contains the limits.
    
          
        
    • 
      
        
  • 
          :next_token
          (String)
          
            
          
          
            — 
    The token for the next set of results, or null to start from the
beginning.
    
          
        
    • 
      
        
  • 
          :max_results
          (Integer)
          
            
          
          
            — 
    The maximum number of limits to return in each page of results.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1442

    		
    
      
# File 'sig/client.rbs', line 1442

def list_limits: (

    		
  





    
      

  

  
    #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
  next_token: "NextToken",
  max_results: 1,
})

    
      
        
Response structure

      
      

resp.metered_products #=> Array
resp.metered_products[0].product_id #=> String
resp.metered_products[0].family #=> String
resp.metered_products[0].vendor #=> String
resp.metered_products[0].port #=> Integer
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.
    
          
        
    • 
      
        
  • 
          :next_token
          (String)
          
            
          
          
            — 
    The token for the next set of results, or null to start from the
beginning.
    
          
        
    • 
      
        
  • 
          :max_results
          (Integer)
          
            
          
          
            — 
    The maximum number of results to return. Use this parameter with
NextToken to get results as a set of sequential pages.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1455

    		
    
      
# File 'sig/client.rbs', line 1455

def list_metered_products: (

    		
  





    
      

  

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

    
      
        
Response structure

      
      

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

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :next_token
          (String)
          
            
          
          
            — 
    The token for the next set of results, or null to start from the
beginning.
    
          
        
    • 
      
        
  • 
          :max_results
          (Integer)
          
            
          
          
            — 
    The maximum number of results to return. Use this parameter with
NextToken to get results as a set of sequential pages.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1468

    		
    
      
# File 'sig/client.rbs', line 1468

def list_monitors: (

    		
  





    
      

  

  
    #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
  queue_id: "QueueId", # required
  next_token: "NextToken",
  max_results: 1,
})

    
      
        
Response structure

      
      

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

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID for the queue environment list.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The queue ID for the queue environment list.
    
          
        
    • 
      
        
  • 
          :next_token
          (String)
          
            
          
          
            — 
    The token for the next set of results, or null to start from the
beginning.
    
          
        
    • 
      
        
  • 
          :max_results
          (Integer)
          
            
          
          
            — 
    The maximum number of results to return. Use this parameter with
NextToken to get results as a set of sequential pages.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1480

    		
    
      
# File 'sig/client.rbs', line 1480

def list_queue_environments: (

    		
  





    
      

  

  
    #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
  next_token: "NextToken",
  max_results: 1,
  queue_id: "QueueId",
  fleet_id: "FleetId",
})

    
      
        
Response structure

      
      

resp.queue_fleet_associations #=> Array
resp.queue_fleet_associations[0].queue_id #=> String
resp.queue_fleet_associations[0].fleet_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].created_at #=> Time
resp.queue_fleet_associations[0].created_by #=> String
resp.queue_fleet_associations[0].updated_at #=> Time
resp.queue_fleet_associations[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 queue-fleet association list.
    
          
        
    • 
      
        
  • 
          :next_token
          (String)
          
            
          
          
            — 
    The token for the next set of results, or null to start from the
beginning.
    
          
        
    • 
      
        
  • 
          :max_results
          (Integer)
          
            
          
          
            — 
    The maximum number of results to return. Use this parameter with
NextToken to get results as a set of sequential pages.
    
          
        
    • 
      
        
  • 
          :queue_id
          (String)
          
            
          
          
            — 
    The queue ID for the queue-fleet association list.
    
          
        
    • 
      
        
  • 
          :fleet_id
          (String)
          
            
          
          
            — 
    The fleet ID for the queue-fleet association list.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1494

    		
    
      
# File 'sig/client.rbs', line 1494

def list_queue_fleet_associations: (

    		
  





    
      

  

  
    #list_queue_limit_associations(params = {})  ⇒ Types::ListQueueLimitAssociationsResponse 
  

  

  


  

    
Gets a list of the associations between queues and limits defined 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_queue_limit_associations({
  farm_id: "FarmId", # required
  next_token: "NextToken",
  max_results: 1,
  queue_id: "QueueId",
  limit_id: "LimitId",
})

    
      
        
Response structure

      
      

resp.queue_limit_associations #=> Array
resp.queue_limit_associations[0].queue_id #=> String
resp.queue_limit_associations[0].limit_id #=> String
resp.queue_limit_associations[0].status #=> String, one of "ACTIVE", "STOP_LIMIT_USAGE_AND_COMPLETE_TASKS", "STOP_LIMIT_USAGE_AND_CANCEL_TASKS", "STOPPED"
resp.queue_limit_associations[0].created_at #=> Time
resp.queue_limit_associations[0].created_by #=> String
resp.queue_limit_associations[0].updated_at #=> Time
resp.queue_limit_associations[0].updated_by #=> String
resp.next_token #=> String

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The unique identifier of the farm that contains the limits and
associations.
    
          
        
    • 
      
        
  • 
          :next_token
          (String)
          
            
          
          
            — 
    The token for the next set of results, or null to start from the
beginning.
    
          
        
    • 
      
        
  • 
          :max_results
          (Integer)
          
            
          
          
            — 
    The maximum number of associations to return in each page of results.
    
          
        
    • 
      
        
  • 
          :queue_id
          (String)
          
            
          
          
            — 
    Specifies that the operation should return only the queue limit
associations for the specified queue. If you specify both the
queueId and the limitId, only the specified limit is returned if
it exists.
    
          
        
    • 
      
        
  • 
          :limit_id
          (String)
          
            
          
          
            — 
    Specifies that the operation should return only the queue limit
associations for the specified limit. If you specify both the
queueId and the limitId, only the specified limit is returned if
it exists.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1509

    		
    
      
# File 'sig/client.rbs', line 1509

def list_queue_limit_associations: (

    		
  





    
      

  

  
    #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
  queue_id: "QueueId", # required
  next_token: "NextToken",
  max_results: 1,
})

    
      
        
Response structure

      
      

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

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID for the queue.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The queue ID to include on the list.
    
          
        
    • 
      
        
  • 
          :next_token
          (String)
          
            
          
          
            — 
    The token for the next set of results, or null to start from the
beginning.
    
          
        
    • 
      
        
  • 
          :max_results
          (Integer)
          
            
          
          
            — 
    The maximum number of results to return. Use this parameter with
NextToken to get results as a set of sequential pages.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1524

    		
    
      
# File 'sig/client.rbs', line 1524

def list_queue_members: (

    		
  





    
      

  

  
    #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
  next_token: "NextToken",
  max_results: 1,
  principal_id: "IdentityCenterPrincipalId",
  status: "IDLE", # accepts IDLE, SCHEDULING, SCHEDULING_BLOCKED
})

    
      
        
Response structure

      
      

resp.queues #=> Array
resp.queues[0].farm_id #=> String
resp.queues[0].queue_id #=> String
resp.queues[0].display_name #=> String
resp.queues[0].status #=> String, one of "IDLE", "SCHEDULING", "SCHEDULING_BLOCKED"
resp.queues[0].default_budget_action #=> String, one of "NONE", "STOP_SCHEDULING_AND_COMPLETE_TASKS", "STOP_SCHEDULING_AND_CANCEL_TASKS"
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].updated_at #=> Time
resp.queues[0].updated_by #=> String
resp.next_token #=> String

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID of the queue.
    
          
        
    • 
      
        
  • 
          :next_token
          (String)
          
            
          
          
            — 
    The token for the next set of results, or null to start from the
beginning.
    
          
        
    • 
      
        
  • 
          :max_results
          (Integer)
          
            
          
          
            — 
    The maximum number of results to return. Use this parameter with
NextToken to get results as a set of sequential pages.
    
          
        
    • 
      
        
  • 
          :principal_id
          (String)
          
            
          
          
            — 
    The principal IDs to include in the list of queues.
    
          
        
    • 
      
        
  • 
          :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:

  



  

    
      


1538

    		
    
      
# File 'sig/client.rbs', line 1538

def list_queues: (

    		
  





    
      

  

  
    #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
  queue_id: "QueueId", # required
  job_id: "JobId", # required
  next_token: "NextToken",
  max_results: 1,
  session_id: "SessionId",
  task_id: "TaskId",
})

    
      
        
Response structure

      
      

resp.session_actions #=> Array
resp.session_actions[0].session_action_id #=> String
resp.session_actions[0].status #=> String, one of "ASSIGNED", "RUNNING", "CANCELING", "SUCCEEDED", "FAILED", "INTERRUPTED", "CANCELED", "NEVER_ATTEMPTED", "SCHEDULED", "RECLAIMING", "RECLAIMED"
resp.session_actions[0].started_at #=> Time
resp.session_actions[0].ended_at #=> Time
resp.session_actions[0].worker_updated_at #=> Time
resp.session_actions[0].progress_percent #=> Float
resp.session_actions[0].manifests #=> Array
resp.session_actions[0].manifests[0].output_manifest_path #=> String
resp.session_actions[0].manifests[0].output_manifest_hash #=> String
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.task_run.task_id #=> String
resp.session_actions[0].definition.task_run.step_id #=> String
resp.session_actions[0].definition.task_run.parameters #=> Hash
resp.session_actions[0].definition.task_run.parameters["String"].int #=> String
resp.session_actions[0].definition.task_run.parameters["String"].float #=> String
resp.session_actions[0].definition.task_run.parameters["String"].string #=> String
resp.session_actions[0].definition.task_run.parameters["String"].path #=> String
resp.session_actions[0].definition.task_run.parameters["String"].chunk_int #=> String
resp.session_actions[0].definition.sync_input_job_attachments.step_id #=> String
resp.next_token #=> String

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID for the session actions list.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The queue ID for the session actions list.
    
          
        
    • 
      
        
  • 
          :job_id
          (required, String)
          
            
          
          
            — 
    The job ID for the session actions list.
    
          
        
    • 
      
        
  • 
          :next_token
          (String)
          
            
          
          
            — 
    The token for the next set of results, or null to start from the
beginning.
    
          
        
    • 
      
        
  • 
          :max_results
          (Integer)
          
            
          
          
            — 
    The maximum number of results to return. Use this parameter with
NextToken to get results as a set of sequential pages.
    
          
        
    • 
      
        
  • 
          :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:

  



  

    
      


1553

    		
    
      
# File 'sig/client.rbs', line 1553

def list_session_actions: (

    		
  





    
      

  

  
    #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
  queue_id: "QueueId", # required
  job_id: "JobId", # required
  next_token: "NextToken",
  max_results: 1,
})

    
      
        
Response structure

      
      

resp.sessions #=> Array
resp.sessions[0].session_id #=> String
resp.sessions[0].fleet_id #=> String
resp.sessions[0].worker_id #=> String
resp.sessions[0].started_at #=> Time
resp.sessions[0].lifecycle_status #=> String, one of "STARTED", "UPDATE_IN_PROGRESS", "UPDATE_SUCCEEDED", "UPDATE_FAILED", "ENDED"
resp.sessions[0].ended_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.next_token #=> String

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID for the list of sessions.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The queue ID for the list of sessions
    
          
        
    • 
      
        
  • 
          :job_id
          (required, String)
          
            
          
          
            — 
    The job ID for the list of sessions.
    
          
        
    • 
      
        
  • 
          :next_token
          (String)
          
            
          
          
            — 
    The token for the next set of results, or null to start from the
beginning.
    
          
        
    • 
      
        
  • 
          :max_results
          (Integer)
          
            
          
          
            — 
    The maximum number of results to return. Use this parameter with
NextToken to get results as a set of sequential pages.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1570

    		
    
      
# File 'sig/client.rbs', line 1570

def list_sessions: (

    		
  





    
      

  

  
    #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
  worker_id: "WorkerId", # required
  next_token: "NextToken",
  max_results: 1,
})

    
      
        
Response structure

      
      

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

    
  


  

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.
    
          
        
    • 
      
        
  • 
          :worker_id
          (required, String)
          
            
          
          
            — 
    The worker ID for the session.
    
          
        
    • 
      
        
  • 
          :next_token
          (String)
          
            
          
          
            — 
    The token for the next set of results, or null to start from the
beginning.
    
          
        
    • 
      
        
  • 
          :max_results
          (Integer)
          
            
          
          
            — 
    The maximum number of results to return. Use this parameter with
NextToken to get results as a set of sequential pages.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1585

    		
    
      
# File 'sig/client.rbs', line 1585

def list_sessions_for_worker: (

    		
  





    
      

  

  
    #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
  queue_id: "QueueId", # required
  job_id: "JobId", # required
  step_id: "StepId", # required
  next_token: "NextToken",
  max_results: 1,
})

    
      
        
Response structure

      
      

resp.consumers #=> Array
resp.consumers[0].step_id #=> String
resp.consumers[0].status #=> String, one of "RESOLVED", "UNRESOLVED"
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.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The queue ID for the step consumer.
    
          
        
    • 
      
        
  • 
          :job_id
          (required, String)
          
            
          
          
            — 
    The job ID for the step consumer.
    
          
        
    • 
      
        
  • 
          :step_id
          (required, String)
          
            
          
          
            — 
    The step ID to include on the list.
    
          
        
    • 
      
        
  • 
          :next_token
          (String)
          
            
          
          
            — 
    The token for the next set of results, or null to start from the
beginning.
    
          
        
    • 
      
        
  • 
          :max_results
          (Integer)
          
            
          
          
            — 
    The maximum number of results to return. Use this parameter with
NextToken to get results as a set of sequential pages.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1600

    		
    
      
# File 'sig/client.rbs', line 1600

def list_step_consumers: (

    		
  





    
      

  

  
    #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
  queue_id: "QueueId", # required
  job_id: "JobId", # required
  step_id: "StepId", # required
  next_token: "NextToken",
  max_results: 1,
})

    
      
        
Response structure

      
      

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

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID for the step dependencies list.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The queue ID for the step dependencies list.
    
          
        
    • 
      
        
  • 
          :job_id
          (required, String)
          
            
          
          
            — 
    The job ID for the step dependencies list.
    
          
        
    • 
      
        
  • 
          :step_id
          (required, String)
          
            
          
          
            — 
    The step ID to include on the list.
    
          
        
    • 
      
        
  • 
          :next_token
          (String)
          
            
          
          
            — 
    The token for the next set of results, or null to start from the
beginning.
    
          
        
    • 
      
        
  • 
          :max_results
          (Integer)
          
            
          
          
            — 
    The maximum number of results to return. Use this parameter with
NextToken to get results as a set of sequential pages.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1616

    		
    
      
# File 'sig/client.rbs', line 1616

def list_step_dependencies: (

    		
  





    
      

  

  
    #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
  queue_id: "QueueId", # required
  job_id: "JobId", # required
  next_token: "NextToken",
  max_results: 1,
})

    
      
        
Response structure

      
      

resp.steps #=> Array
resp.steps[0].step_id #=> String
resp.steps[0].name #=> 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].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].task_failure_retry_count #=> Integer
resp.steps[0].target_task_run_status #=> String, one of "READY", "FAILED", "SUCCEEDED", "CANCELED", "SUSPENDED", "PENDING"
resp.steps[0].created_at #=> Time
resp.steps[0].created_by #=> String
resp.steps[0].updated_at #=> Time
resp.steps[0].updated_by #=> String
resp.steps[0].started_at #=> Time
resp.steps[0].ended_at #=> Time
resp.steps[0].dependency_counts.dependencies_resolved #=> Integer
resp.steps[0].dependency_counts.dependencies_unresolved #=> Integer
resp.steps[0].dependency_counts.consumers_resolved #=> Integer
resp.steps[0].dependency_counts.consumers_unresolved #=> Integer
resp.next_token #=> String

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID to include on the list of steps.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The queue ID to include on the list of steps.
    
          
        
    • 
      
        
  • 
          :job_id
          (required, String)
          
            
          
          
            — 
    The job ID to include on the list of steps.
    
          
        
    • 
      
        
  • 
          :next_token
          (String)
          
            
          
          
            — 
    The token for the next set of results, or null to start from the
beginning.
    
          
        
    • 
      
        
  • 
          :max_results
          (Integer)
          
            
          
          
            — 
    The maximum number of results to return. Use this parameter with
NextToken to get results as a set of sequential pages.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1632

    		
    
      
# File 'sig/client.rbs', line 1632

def list_steps: (

    		
  





    
      

  

  
    #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
  next_token: "NextToken",
  max_results: 1,
})

    
      
        
Response structure

      
      

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

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID of the storage profile.
    
          
        
    • 
      
        
  • 
          :next_token
          (String)
          
            
          
          
            — 
    The token for the next set of results, or null to start from the
beginning.
    
          
        
    • 
      
        
  • 
          :max_results
          (Integer)
          
            
          
          
            — 
    The maximum number of results to return. Use this parameter with
NextToken to get results as a set of sequential pages.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1647

    		
    
      
# File 'sig/client.rbs', line 1647

def list_storage_profiles: (

    		
  





    
      

  

  
    #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
  queue_id: "QueueId", # required
  next_token: "NextToken",
  max_results: 1,
})

    
      
        
Response structure

      
      

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

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID of the queue's storage profile.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The queue ID for the storage profile.
    
          
        
    • 
      
        
  • 
          :next_token
          (String)
          
            
          
          
            — 
    The token for the next set of results, or null to start from the
beginning.
    
          
        
    • 
      
        
  • 
          :max_results
          (Integer)
          
            
          
          
            — 
    The maximum number of results to return. Use this parameter with
NextToken to get results as a set of sequential pages.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1660

    		
    
      
# File 'sig/client.rbs', line 1660

def list_storage_profiles_for_queue: (

    		
  





    
      

  

  
    #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:

  



  

    
      


1673

    		
    
      
# File 'sig/client.rbs', line 1673

def list_tags_for_resource: (

    		
  





    
      

  

  
    #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
  queue_id: "QueueId", # required
  job_id: "JobId", # required
  step_id: "StepId", # required
  next_token: "NextToken",
  max_results: 1,
})

    
      
        
Response structure

      
      

resp.tasks #=> Array
resp.tasks[0].task_id #=> String
resp.tasks[0].created_at #=> Time
resp.tasks[0].created_by #=> 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].target_run_status #=> String, one of "READY", "FAILED", "SUCCEEDED", "CANCELED", "SUSPENDED", "PENDING"
resp.tasks[0].failure_retry_count #=> Integer
resp.tasks[0].started_at #=> Time
resp.tasks[0].ended_at #=> Time
resp.tasks[0].updated_at #=> Time
resp.tasks[0].updated_by #=> String
resp.tasks[0].latest_session_action_id #=> String
resp.tasks[0].parameters #=> Hash
resp.tasks[0].parameters["String"].int #=> String
resp.tasks[0].parameters["String"].float #=> String
resp.tasks[0].parameters["String"].string #=> String
resp.tasks[0].parameters["String"].path #=> String
resp.tasks[0].parameters["String"].chunk_int #=> String
resp.next_token #=> String

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID connected to the tasks.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The queue ID connected to the tasks.
    
          
        
    • 
      
        
  • 
          :job_id
          (required, String)
          
            
          
          
            — 
    The job ID for the tasks.
    
          
        
    • 
      
        
  • 
          :step_id
          (required, String)
          
            
          
          
            — 
    The step ID for the tasks.
    
          
        
    • 
      
        
  • 
          :next_token
          (String)
          
            
          
          
            — 
    The token for the next set of results, or null to start from the
beginning.
    
          
        
    • 
      
        
  • 
          :max_results
          (Integer)
          
            
          
          
            — 
    The maximum number of results to return. Use this parameter with
NextToken to get results as a set of sequential pages.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1684

    		
    
      
# File 'sig/client.rbs', line 1684

def list_tasks: (

    		
  





    
      

  

  
    #list_volumes(params = {})  ⇒ Types::ListVolumesResponse 
  

  

  


  

    
Lists the persistent volumes in a fleet.


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


  





  
  

    
Examples:

    
      
        
Example: List volumes for a fleet

      
      

resp = client.list_volumes({
  farm_id: "farm-1234567890abcdef1234567890abcdef", 
  fleet_id: "fleet-1234567890abcdef1234567890abcdef", 
})

    
      
        
Request syntax with placeholder values

      
      

resp = client.list_volumes({
  farm_id: "FarmId", # required
  fleet_id: "FleetId", # required
  next_token: "NextToken",
  max_results: 1,
})

    
      
        
Response structure

      
      

resp.volumes #=> Array
resp.volumes[0].volume_id #=> String
resp.volumes[0].farm_id #=> String
resp.volumes[0].fleet_id #=> String
resp.volumes[0].state #=> String, one of "PENDING_CREATION", "PENDING_ATTACHMENT", "IN_USE", "AVAILABLE", "PENDING_DELETION"
resp.volumes[0].size_gi_b #=> Integer
resp.volumes[0].availability_zone_id #=> String
resp.volumes[0].attached_worker_id #=> String
resp.next_token #=> String

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID of the farm that contains the fleet.
    
          
        
    • 
      
        
  • 
          :fleet_id
          (required, String)
          
            
          
          
            — 
    The fleet ID of the fleet that contains the volumes.
    
          
        
    • 
      
        
  • 
          :next_token
          (String)
          
            
          
          
            — 
    The token for the next set of results, or null to start from the
beginning.
    
          
        
    • 
      
        
  • 
          :max_results
          (Integer)
          
            
          
          
            — 
    The maximum number of results to return. Use this parameter with
NextToken to get results as a set of sequential pages.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1700

    		
    
      
# File 'sig/client.rbs', line 1700

def list_volumes: (

    		
  





    
      

  

  
    #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
  next_token: "NextToken",
  max_results: 1,
})

    
      
        
Response structure

      
      

resp.workers #=> Array
resp.workers[0].farm_id #=> String
resp.workers[0].fleet_id #=> String
resp.workers[0].worker_id #=> 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].host_properties.host_name #=> String
resp.workers[0].host_properties.ec2_instance_arn #=> String
resp.workers[0].host_properties.ec2_instance_type #=> String
resp.workers[0].status #=> String, one of "CREATED", "STARTED", "STOPPING", "STOPPED", "NOT_RESPONDING", "NOT_COMPATIBLE", "RUNNING", "IDLE"
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].log.error #=> String
resp.workers[0].created_at #=> Time
resp.workers[0].created_by #=> String
resp.workers[0].updated_at #=> Time
resp.workers[0].updated_by #=> String
resp.next_token #=> 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.
    
          
        
    • 
      
        
  • 
          :next_token
          (String)
          
            
          
          
            — 
    The token for the next set of results, or null to start from the
beginning.
    
          
        
    • 
      
        
  • 
          :max_results
          (Integer)
          
            
          
          
            — 
    The maximum number of results to return. Use this parameter with
NextToken to get results as a set of sequential pages.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1714

    		
    
      
# File 'sig/client.rbs', line 1714

def list_workers: (

    		
  





    
      

  

  
    #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:

  



  

    
      


1726

    		
    
      
# File 'sig/client.rbs', line 1726

def put_metered_product: (

    		
  





    
      

  

  
    #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: {
          name: "String", # required
          operator: "EQUAL", # required, accepts EQUAL, NOT_EQUAL, GREATER_THAN_EQUAL_TO, GREATER_THAN, LESS_THAN_EQUAL_TO, LESS_THAN, ANY_EQUALS, ALL_NOT_EQUALS
          date_time: Time.now, # required
        },
        parameter_filter: {
          name: "String", # required
          operator: "EQUAL", # required, accepts EQUAL, NOT_EQUAL, GREATER_THAN_EQUAL_TO, GREATER_THAN, LESS_THAN_EQUAL_TO, LESS_THAN, ANY_EQUALS, ALL_NOT_EQUALS
          value: "ParameterValue", # required
        },
        search_term_filter: {
          search_term: "SearchTerm", # required
          match_type: "FUZZY_MATCH", # accepts FUZZY_MATCH, CONTAINS
        },
        string_filter: {
          name: "String", # required
          operator: "EQUAL", # required, accepts EQUAL, NOT_EQUAL, GREATER_THAN_EQUAL_TO, GREATER_THAN, LESS_THAN_EQUAL_TO, LESS_THAN, ANY_EQUALS, ALL_NOT_EQUALS
          value: "StringFilter", # required
        },
        string_list_filter: {
          name: "String", # required
          operator: "EQUAL", # required, accepts EQUAL, NOT_EQUAL, GREATER_THAN_EQUAL_TO, GREATER_THAN, LESS_THAN_EQUAL_TO, LESS_THAN, ANY_EQUALS, ALL_NOT_EQUALS
          values: ["StringFilter"], # required
        },
        group_filter: {
          # recursive SearchGroupedFilterExpressions
        },
      },
    ],
    operator: "AND", # required, accepts AND, OR
  },
  sort_expressions: [
    {
      user_jobs_first: {
        user_identity_id: "String", # required
      },
      field_sort: {
        sort_order: "ASCENDING", # required, accepts ASCENDING, DESCENDING
        name: "String", # required
      },
      parameter_sort: {
        sort_order: "ASCENDING", # required, accepts ASCENDING, DESCENDING
        name: "String", # required
      },
    },
  ],
  item_offset: 1, # required
  page_size: 1,
  queue_ids: ["QueueId"], # required
})

    
      
        
Response structure

      
      

resp.jobs #=> Array
resp.jobs[0].job_id #=> String
resp.jobs[0].queue_id #=> String
resp.jobs[0].name #=> 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].task_run_status #=> String, one of "PENDING", "READY", "ASSIGNED", "STARTING", "SCHEDULED", "INTERRUPTING", "RUNNING", "SUSPENDED", "CANCELED", "FAILED", "SUCCEEDED", "NOT_COMPATIBLE"
resp.jobs[0].target_task_run_status #=> String, one of "READY", "FAILED", "SUCCEEDED", "CANCELED", "SUSPENDED", "PENDING"
resp.jobs[0].task_run_status_counts #=> Hash
resp.jobs[0].task_run_status_counts["TaskRunStatus"] #=> Integer
resp.jobs[0].task_failure_retry_count #=> Integer
resp.jobs[0].priority #=> Integer
resp.jobs[0].max_failed_tasks_count #=> Integer
resp.jobs[0].max_retries_per_task #=> Integer
resp.jobs[0].created_by #=> String
resp.jobs[0].created_at #=> Time
resp.jobs[0].ended_at #=> Time
resp.jobs[0].started_at #=> Time
resp.jobs[0].updated_at #=> Time
resp.jobs[0].updated_by #=> String
resp.jobs[0].job_parameters #=> Hash
resp.jobs[0].job_parameters["JobParametersKeyString"].int #=> String
resp.jobs[0].job_parameters["JobParametersKeyString"].float #=> String
resp.jobs[0].job_parameters["JobParametersKeyString"].string #=> String
resp.jobs[0].job_parameters["JobParametersKeyString"].path #=> String
resp.jobs[0].max_worker_count #=> Integer
resp.jobs[0].source_job_id #=> String
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 search terms for a resource.
    
          
        
    • 
      
        
  • 
          :sort_expressions
          (Array<Types::SearchSortExpression>)
          
            
          
          
            — 
    The search terms for a resource.
    
          
        
    • 
      
        
  • 
          :item_offset
          (required, Integer)
          
            
          
          
            — 
    The offset for the search results.
    
          
        
    • 
      
        
  • 
          :page_size
          (Integer)
          
            
          
          
            — 
    Specifies the number of results to return.
    
          
        
    • 
      
        
  • 
          :queue_ids
          (required, Array<String>)
          
            
          
          
            — 
    The queue ID to use in the job search.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1739

    		
    
      
# File 'sig/client.rbs', line 1739

def search_jobs: (

    		
  





    
      

  

  
    #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: {
          name: "String", # required
          operator: "EQUAL", # required, accepts EQUAL, NOT_EQUAL, GREATER_THAN_EQUAL_TO, GREATER_THAN, LESS_THAN_EQUAL_TO, LESS_THAN, ANY_EQUALS, ALL_NOT_EQUALS
          date_time: Time.now, # required
        },
        parameter_filter: {
          name: "String", # required
          operator: "EQUAL", # required, accepts EQUAL, NOT_EQUAL, GREATER_THAN_EQUAL_TO, GREATER_THAN, LESS_THAN_EQUAL_TO, LESS_THAN, ANY_EQUALS, ALL_NOT_EQUALS
          value: "ParameterValue", # required
        },
        search_term_filter: {
          search_term: "SearchTerm", # required
          match_type: "FUZZY_MATCH", # accepts FUZZY_MATCH, CONTAINS
        },
        string_filter: {
          name: "String", # required
          operator: "EQUAL", # required, accepts EQUAL, NOT_EQUAL, GREATER_THAN_EQUAL_TO, GREATER_THAN, LESS_THAN_EQUAL_TO, LESS_THAN, ANY_EQUALS, ALL_NOT_EQUALS
          value: "StringFilter", # required
        },
        string_list_filter: {
          name: "String", # required
          operator: "EQUAL", # required, accepts EQUAL, NOT_EQUAL, GREATER_THAN_EQUAL_TO, GREATER_THAN, LESS_THAN_EQUAL_TO, LESS_THAN, ANY_EQUALS, ALL_NOT_EQUALS
          values: ["StringFilter"], # required
        },
        group_filter: {
          # recursive SearchGroupedFilterExpressions
        },
      },
    ],
    operator: "AND", # required, accepts AND, OR
  },
  sort_expressions: [
    {
      user_jobs_first: {
        user_identity_id: "String", # required
      },
      field_sort: {
        sort_order: "ASCENDING", # required, accepts ASCENDING, DESCENDING
        name: "String", # required
      },
      parameter_sort: {
        sort_order: "ASCENDING", # required, accepts ASCENDING, DESCENDING
        name: "String", # required
      },
    },
  ],
  item_offset: 1, # required
  page_size: 1,
  queue_ids: ["QueueId"], # required
  job_id: "JobId",
})

    
      
        
Response structure

      
      

resp.steps #=> Array
resp.steps[0].step_id #=> String
resp.steps[0].job_id #=> String
resp.steps[0].queue_id #=> String
resp.steps[0].name #=> 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].task_run_status #=> String, one of "PENDING", "READY", "ASSIGNED", "STARTING", "SCHEDULED", "INTERRUPTING", "RUNNING", "SUSPENDED", "CANCELED", "FAILED", "SUCCEEDED", "NOT_COMPATIBLE"
resp.steps[0].target_task_run_status #=> String, one of "READY", "FAILED", "SUCCEEDED", "CANCELED", "SUSPENDED", "PENDING"
resp.steps[0].task_run_status_counts #=> Hash
resp.steps[0].task_run_status_counts["TaskRunStatus"] #=> Integer
resp.steps[0].task_failure_retry_count #=> Integer
resp.steps[0].created_at #=> Time
resp.steps[0].created_by #=> String
resp.steps[0].started_at #=> Time
resp.steps[0].ended_at #=> Time
resp.steps[0].updated_at #=> Time
resp.steps[0].updated_by #=> 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", "CHUNK_INT"
resp.steps[0].parameter_space.parameters[0].chunks.default_task_count #=> Integer
resp.steps[0].parameter_space.parameters[0].chunks.target_runtime_seconds #=> Integer
resp.steps[0].parameter_space.parameters[0].chunks.range_constraint #=> String, one of "CONTIGUOUS", "NONCONTIGUOUS"
resp.steps[0].parameter_space.combination #=> String
resp.next_item_offset #=> 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 search terms for a resource.
    
          
        
    • 
      
        
  • 
          :sort_expressions
          (Array<Types::SearchSortExpression>)
          
            
          
          
            — 
    The search terms for a resource.
    
          
        
    • 
      
        
  • 
          :item_offset
          (required, Integer)
          
            
          
          
            — 
    The offset for the search results.
    
          
        
    • 
      
        
  • 
          :page_size
          (Integer)
          
            
          
          
            — 
    Specifies the number of results to return.
    
          
        
    • 
      
        
  • 
          :queue_ids
          (required, Array<String>)
          
            
          
          
            — 
    The queue IDs in the step search.
    
          
        
    • 
      
        
  • 
          :job_id
          (String)
          
            
          
          
            — 
    The job ID to use in the step search.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1758

    		
    
      
# File 'sig/client.rbs', line 1758

def search_steps: (

    		
  





    
      

  

  
    #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: {
          name: "String", # required
          operator: "EQUAL", # required, accepts EQUAL, NOT_EQUAL, GREATER_THAN_EQUAL_TO, GREATER_THAN, LESS_THAN_EQUAL_TO, LESS_THAN, ANY_EQUALS, ALL_NOT_EQUALS
          date_time: Time.now, # required
        },
        parameter_filter: {
          name: "String", # required
          operator: "EQUAL", # required, accepts EQUAL, NOT_EQUAL, GREATER_THAN_EQUAL_TO, GREATER_THAN, LESS_THAN_EQUAL_TO, LESS_THAN, ANY_EQUALS, ALL_NOT_EQUALS
          value: "ParameterValue", # required
        },
        search_term_filter: {
          search_term: "SearchTerm", # required
          match_type: "FUZZY_MATCH", # accepts FUZZY_MATCH, CONTAINS
        },
        string_filter: {
          name: "String", # required
          operator: "EQUAL", # required, accepts EQUAL, NOT_EQUAL, GREATER_THAN_EQUAL_TO, GREATER_THAN, LESS_THAN_EQUAL_TO, LESS_THAN, ANY_EQUALS, ALL_NOT_EQUALS
          value: "StringFilter", # required
        },
        string_list_filter: {
          name: "String", # required
          operator: "EQUAL", # required, accepts EQUAL, NOT_EQUAL, GREATER_THAN_EQUAL_TO, GREATER_THAN, LESS_THAN_EQUAL_TO, LESS_THAN, ANY_EQUALS, ALL_NOT_EQUALS
          values: ["StringFilter"], # required
        },
        group_filter: {
          # recursive SearchGroupedFilterExpressions
        },
      },
    ],
    operator: "AND", # required, accepts AND, OR
  },
  sort_expressions: [
    {
      user_jobs_first: {
        user_identity_id: "String", # required
      },
      field_sort: {
        sort_order: "ASCENDING", # required, accepts ASCENDING, DESCENDING
        name: "String", # required
      },
      parameter_sort: {
        sort_order: "ASCENDING", # required, accepts ASCENDING, DESCENDING
        name: "String", # required
      },
    },
  ],
  item_offset: 1, # required
  page_size: 1,
  queue_ids: ["QueueId"], # required
  job_id: "JobId",
})

    
      
        
Response structure

      
      

resp.tasks #=> Array
resp.tasks[0].task_id #=> String
resp.tasks[0].step_id #=> String
resp.tasks[0].job_id #=> 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].target_run_status #=> String, one of "READY", "FAILED", "SUCCEEDED", "CANCELED", "SUSPENDED", "PENDING"
resp.tasks[0].parameters #=> Hash
resp.tasks[0].parameters["String"].int #=> String
resp.tasks[0].parameters["String"].float #=> String
resp.tasks[0].parameters["String"].string #=> String
resp.tasks[0].parameters["String"].path #=> String
resp.tasks[0].parameters["String"].chunk_int #=> String
resp.tasks[0].failure_retry_count #=> Integer
resp.tasks[0].started_at #=> Time
resp.tasks[0].ended_at #=> Time
resp.tasks[0].updated_at #=> Time
resp.tasks[0].updated_by #=> String
resp.tasks[0].latest_session_action_id #=> String
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 task.
    
          
        
    • 
      
        
  • 
          :filter_expressions
          (Types::SearchGroupedFilterExpressions)
          
            
          
          
            — 
    The search terms for a resource.
    
          
        
    • 
      
        
  • 
          :sort_expressions
          (Array<Types::SearchSortExpression>)
          
            
          
          
            — 
    The search terms for a resource.
    
          
        
    • 
      
        
  • 
          :item_offset
          (required, Integer)
          
            
          
          
            — 
    The offset for the search results.
    
          
        
    • 
      
        
  • 
          :page_size
          (Integer)
          
            
          
          
            — 
    Specifies the number of results to return.
    
          
        
    • 
      
        
  • 
          :queue_ids
          (required, Array<String>)
          
            
          
          
            — 
    The queue IDs to include in the search.
    
          
        
    • 
      
        
  • 
          :job_id
          (String)
          
            
          
          
            — 
    The job ID for the task search.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1778

    		
    
      
# File 'sig/client.rbs', line 1778

def search_tasks: (

    		
  





    
      

  

  
    #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: {
          name: "String", # required
          operator: "EQUAL", # required, accepts EQUAL, NOT_EQUAL, GREATER_THAN_EQUAL_TO, GREATER_THAN, LESS_THAN_EQUAL_TO, LESS_THAN, ANY_EQUALS, ALL_NOT_EQUALS
          date_time: Time.now, # required
        },
        parameter_filter: {
          name: "String", # required
          operator: "EQUAL", # required, accepts EQUAL, NOT_EQUAL, GREATER_THAN_EQUAL_TO, GREATER_THAN, LESS_THAN_EQUAL_TO, LESS_THAN, ANY_EQUALS, ALL_NOT_EQUALS
          value: "ParameterValue", # required
        },
        search_term_filter: {
          search_term: "SearchTerm", # required
          match_type: "FUZZY_MATCH", # accepts FUZZY_MATCH, CONTAINS
        },
        string_filter: {
          name: "String", # required
          operator: "EQUAL", # required, accepts EQUAL, NOT_EQUAL, GREATER_THAN_EQUAL_TO, GREATER_THAN, LESS_THAN_EQUAL_TO, LESS_THAN, ANY_EQUALS, ALL_NOT_EQUALS
          value: "StringFilter", # required
        },
        string_list_filter: {
          name: "String", # required
          operator: "EQUAL", # required, accepts EQUAL, NOT_EQUAL, GREATER_THAN_EQUAL_TO, GREATER_THAN, LESS_THAN_EQUAL_TO, LESS_THAN, ANY_EQUALS, ALL_NOT_EQUALS
          values: ["StringFilter"], # required
        },
        group_filter: {
          # recursive SearchGroupedFilterExpressions
        },
      },
    ],
    operator: "AND", # required, accepts AND, OR
  },
  sort_expressions: [
    {
      user_jobs_first: {
        user_identity_id: "String", # required
      },
      field_sort: {
        sort_order: "ASCENDING", # required, accepts ASCENDING, DESCENDING
        name: "String", # required
      },
      parameter_sort: {
        sort_order: "ASCENDING", # required, accepts ASCENDING, DESCENDING
        name: "String", # required
      },
    },
  ],
  item_offset: 1, # required
  page_size: 1,
  fleet_ids: ["FleetId"], # required
})

    
      
        
Response structure

      
      

resp.workers #=> Array
resp.workers[0].fleet_id #=> String
resp.workers[0].worker_id #=> String
resp.workers[0].status #=> String, one of "CREATED", "STARTED", "STOPPING", "STOPPED", "NOT_RESPONDING", "NOT_COMPATIBLE", "RUNNING", "IDLE"
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].host_properties.host_name #=> String
resp.workers[0].host_properties.ec2_instance_arn #=> String
resp.workers[0].host_properties.ec2_instance_type #=> String
resp.workers[0].created_by #=> String
resp.workers[0].created_at #=> Time
resp.workers[0].updated_by #=> String
resp.workers[0].updated_at #=> Time
resp.next_item_offset #=> Integer
resp.total_results #=> Integer

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID in the workers search.
    
          
        
    • 
      
        
  • 
          :filter_expressions
          (Types::SearchGroupedFilterExpressions)
          
            
          
          
            — 
    The search terms for a resource.
    
          
        
    • 
      
        
  • 
          :sort_expressions
          (Array<Types::SearchSortExpression>)
          
            
          
          
            — 
    The search terms for a resource.
    
          
        
    • 
      
        
  • 
          :item_offset
          (required, Integer)
          
            
          
          
            — 
    The offset for the search results.
    
          
        
    • 
      
        
  • 
          :page_size
          (Integer)
          
            
          
          
            — 
    Specifies the number of results to return.
    
          
        
    • 
      
        
  • 
          :fleet_ids
          (required, Array<String>)
          
            
          
          
            — 
    The fleet ID of the workers to search for.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1798

    		
    
      
# File 'sig/client.rbs', line 1798

def search_workers: (

    		
  





    
      

  

  
    #start_sessions_statistics_aggregation(params = {})  ⇒ Types::StartSessionsStatisticsAggregationResponse 
  

  

  


  

    
Starts an asynchronous request for getting aggregated statistics about
queues and farms. Get the statistics using the
GetSessionsStatisticsAggregation operation. You can only have one
running aggregation for your Deadline Cloud farm. Call the
GetSessionsStatisticsAggregation operation and check the status
field to see if an aggregation is running. Statistics are available
for 1 hour after you call the StartSessionsStatisticsAggregation
operation.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.start_sessions_statistics_aggregation({
  farm_id: "FarmId", # required
  resource_ids: { # required
    queue_ids: ["QueueId"],
    fleet_ids: ["FleetId"],
  },
  start_time: Time.now, # required
  end_time: Time.now, # required
  timezone: "Timezone",
  period: "HOURLY", # accepts HOURLY, DAILY, WEEKLY, MONTHLY
  group_by: ["QUEUE_ID"], # required, accepts QUEUE_ID, FLEET_ID, JOB_ID, USER_ID, USAGE_TYPE, INSTANCE_TYPE, LICENSE_PRODUCT
  statistics: ["SUM"], # required, accepts SUM, MIN, MAX, AVG
})

    
      
        
Response structure

      
      

resp.aggregation_id #=> String

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The identifier of the farm that contains queues or fleets to return
statistics for.
    
          
        
    • 
      
        
  • 
          :resource_ids
          (required, Types::SessionsStatisticsResources)
          
            
          
          
            — 
    A list of fleet IDs or queue IDs to gather statistics for.
    
          
        
    • 
      
        
  • 
          :start_time
          (required, Time, DateTime, Date, Integer, String)
          
            
          
          
            — 
    The Linux timestamp of the date and time that the statistics start.
    
          
        
    • 
      
        
  • 
          :end_time
          (required, Time, DateTime, Date, Integer, String)
          
            
          
          
            — 
    The Linux timestamp of the date and time that the statistics end.
    
          
        
    • 
      
        
  • 
          :timezone
          (String)
          
            
          
          
            — 
    The timezone to use for the statistics. Use UTC notation such as
"UTC+8."
    
          
        
    • 
      
        
  • 
          :period
          (String)
          
            
          
          
            — 
    The period to aggregate the statistics.
    
          
        
    • 
      
        
  • 
          :group_by
          (required, Array<String>)
          
            
          
          
            — 
    The field to use to group the statistics.
    
          
        
    • 
      
        
  • 
          :statistics
          (required, Array<String>)
          
            
          
          
            — 
    One to four statistics to return.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


1815

    		
    
      
# File 'sig/client.rbs', line 1815

def start_sessions_statistics_aggregation: (

    		
  





    
      

  

  
    #tag_resource(params = {})  ⇒ Struct 
  

  

  


  

    
Tags a resource using the resource's ARN and desired tags.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.tag_resource({
  resource_arn: "String", # required
  tags: {
    "String" => "String",
  },
})

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :resource_arn
          (required, String)
          
            
          
          
            — 
    The ARN of the resource to apply tags to.
    
          
        
    • 
      
        
  • 
          :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:


    
  
    
  • 
      
      
        (Struct)
      
      
      
        —
        
    Returns an empty response.
    
      
    
    • 
  



  
See Also:

  



  

    
      


1834

    		
    
      
# File 'sig/client.rbs', line 1834

def tag_resource: (

    		
  





    
      

  

  
    #untag_resource(params = {})  ⇒ Struct 
  

  

  


  

    
Removes a tag from a resource using the resource's ARN and tag to
remove.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.untag_resource({
  resource_arn: "String", # required
  tag_keys: ["String"], # required
})

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :resource_arn
          (required, String)
          
            
          
          
            — 
    The ARN of the resource to remove the tag from.
    
          
        
    • 
      
        
  • 
          :tag_keys
          (required, Array<String>)
          
            
          
          
            — 
    They keys of the tag.
    
          
        
    • 
      
    

  
    
    


Returns:


    
  
    
  • 
      
      
        (Struct)
      
      
      
        —
        
    Returns an empty response.
    
      
    
    • 
  



  
See Also:

  



  

    
      


1844

    		
    
      
# File 'sig/client.rbs', line 1844

def untag_resource: (

    		
  





    
      

  

  
    #update_budget(params = {})  ⇒ Struct 
  

  

  


  

    
Updates a budget that sets spending thresholds for rendering activity.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.update_budget({
  farm_id: "FarmId", # required
  budget_id: "BudgetId", # required
  client_token: "ClientToken",
  display_name: "ResourceName",
  description: "Description",
  status: "ACTIVE", # accepts ACTIVE, INACTIVE
  approximate_dollar_limit: 1.0,
  actions_to_add: [
    {
      type: "STOP_SCHEDULING_AND_COMPLETE_TASKS", # required, accepts STOP_SCHEDULING_AND_COMPLETE_TASKS, STOP_SCHEDULING_AND_CANCEL_TASKS
      threshold_percentage: 1.0, # required
      description: "Description",
    },
  ],
  actions_to_remove: [
    {
      type: "STOP_SCHEDULING_AND_COMPLETE_TASKS", # required, accepts STOP_SCHEDULING_AND_COMPLETE_TASKS, STOP_SCHEDULING_AND_CANCEL_TASKS
      threshold_percentage: 1.0, # required
    },
  ],
  schedule: {
    fixed: {
      start_time: Time.now, # required
      end_time: Time.now, # required
    },
  },
})

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID of the budget to update.
    
          
        
    • 
      
        
  • 
          :budget_id
          (required, String)
          
            
          
          
            — 
    The budget ID to update.
    
          
        
    • 
      
        
  • 
          :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
          (String)
          
            
          
          
            — 
    The display name of the budget to update.
    

    This field can store any content. Escape or encode this content before
displaying it on a webpage or any other system that might interpret
the content of this field.
    
          
        
    • 
      
        
  • 
          :description
          (String)
          
            
          
          
            — 
    The description of the budget to update.
    

    This field can store any content. Escape or encode this content before
displaying it on a webpage or any other system that might interpret
the content of this field.
    
          
        
    • 
      
        
  • 
          :status
          (String)
          
            
          
          
            — 
    Updates the status of the budget.
    

      

    • 

      ACTIVE–The budget is being evaluated.
      

      • 

    • 

      INACTIVE–The budget is inactive. This can include Expired,
Canceled, or deleted Deleted statuses.
      

      • 

    
          
        
    • 
      
        
  • 
          :approximate_dollar_limit
          (Float)
          
            
          
          
            — 
    The dollar limit to update on the budget. Based on consumed usage.
    
          
        
    • 
      
        
  • 
          :actions_to_add
          (Array<Types::BudgetActionToAdd>)
          
            
          
          
            — 
    The budget actions to add. Budget actions specify what happens when
the budget runs out.
    
          
        
    • 
      
        
  • 
          :actions_to_remove
          (Array<Types::BudgetActionToRemove>)
          
            
          
          
            — 
    The budget actions to remove from the budget.
    
          
        
    • 
      
        
  • 
          :schedule
          (Types::BudgetSchedule)
          
            
          
          
            — 
    The schedule to update.
    
          
        
    • 
      
    

  
    
    


Returns:


    
  
    
  • 
      
      
        (Struct)
      
      
      
        —
        
    Returns an empty response.
    
      
    
    • 
  



  
See Also:

  



  

    
      


1854

    		
    
      
# File 'sig/client.rbs', line 1854

def update_budget: (

    		
  





    
      

  

  
    #update_farm(params = {})  ⇒ Struct 
  

  

  


  

    
Updates a farm.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.update_farm({
  farm_id: "FarmId", # required
  display_name: "ResourceName",
  description: "Description",
  cost_scale_factor: 1.0,
})

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID to update.
    
          
        
    • 
      
        
  • 
          :display_name
          (String)
          
            
          
          
            — 
    The display name of the farm to update.
    

    This field can store any content. Escape or encode this content before
displaying it on a webpage or any other system that might interpret
the content of this field.
    
          
        
    • 
      
        
  • 
          :description
          (String)
          
            
          
          
            — 
    The description of the farm to update.
    

    This field can store any content. Escape or encode this content before
displaying it on a webpage or any other system that might interpret
the content of this field.
    
          
        
    • 
      
        
  • 
          :cost_scale_factor
          (Float)
          
            
          
          
            — 
    A multiplier applied to the farm's calculated costs for usage data
and budget tracking. A value less than 1 represents a discount, a
value greater than 1 represents a premium, and a value of 1 represents
no adjustment.
    
          
        
    • 
      
    

  
    
    


Returns:


    
  
    
  • 
      
      
        (Struct)
      
      
      
        —
        
    Returns an empty response.
    
      
    
    • 
  



  
See Also:

  



  

    
      


1888

    		
    
      
# File 'sig/client.rbs', line 1888

def update_farm: (

    		
  





    
      

  

  
    #update_fleet(params = {})  ⇒ Struct 
  

  

  


  

    
Updates a fleet.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.update_fleet({
  farm_id: "FarmId", # required
  fleet_id: "FleetId", # required
  client_token: "ClientToken",
  display_name: "ResourceName",
  description: "Description",
  role_arn: "IamRoleArn",
  min_worker_count: 1,
  max_worker_count: 1,
  configuration: {
    customer_managed: {
      mode: "NO_SCALING", # required, accepts NO_SCALING, EVENT_BASED_AUTO_SCALING
      auto_scaling_configuration: {
        standby_worker_count: 1,
        worker_idle_duration_seconds: 1,
        scale_out_workers_per_minute: 1,
      },
      worker_capabilities: { # required
        v_cpu_count: { # required
          min: 1, # required
          max: 1,
        },
        memory_mi_b: { # required
          min: 1, # required
          max: 1,
        },
        accelerator_types: ["gpu"], # accepts gpu
        accelerator_count: {
          min: 1, # required
          max: 1,
        },
        accelerator_total_memory_mi_b: {
          min: 1, # required
          max: 1,
        },
        os_family: "WINDOWS", # required, accepts WINDOWS, LINUX, MACOS
        cpu_architecture_type: "x86_64", # required, accepts x86_64, arm64
        custom_amounts: [
          {
            name: "AmountCapabilityName", # required
            min: 1.0, # required
            max: 1.0,
          },
        ],
        custom_attributes: [
          {
            name: "AttributeCapabilityName", # required
            values: ["AttributeCapabilityValue"], # required
          },
        ],
      },
      storage_profile_id: "StorageProfileId",
      tag_propagation_mode: "NO_PROPAGATION", # accepts NO_PROPAGATION, PROPAGATE_TAGS_TO_WORKERS_AT_LAUNCH
    },
    service_managed_ec2: {
      instance_capabilities: { # required
        v_cpu_count: { # required
          min: 1, # required
          max: 1,
        },
        memory_mi_b: { # required
          min: 1, # required
          max: 1,
        },
        os_family: "WINDOWS", # required, accepts WINDOWS, LINUX
        cpu_architecture_type: "x86_64", # required, accepts x86_64, arm64
        root_ebs_volume: {
          size_gi_b: 1,
          iops: 1,
          throughput_mi_b: 1,
        },
        accelerator_capabilities: {
          selections: [ # required
            {
              name: "t4", # required, accepts t4, a10g, l4, l40s, rtx-pro-server-6000
              runtime: "AcceleratorRuntime",
            },
          ],
          count: {
            min: 1, # required
            max: 1,
          },
        },
        allowed_instance_types: ["InstanceType"],
        excluded_instance_types: ["InstanceType"],
        custom_amounts: [
          {
            name: "AmountCapabilityName", # required
            min: 1.0, # required
            max: 1.0,
          },
        ],
        custom_attributes: [
          {
            name: "AttributeCapabilityName", # required
            values: ["AttributeCapabilityValue"], # required
          },
        ],
      },
      instance_market_options: { # required
        type: "on-demand", # required, accepts on-demand, spot, wait-and-save
      },
      vpc_configuration: {
        resource_configuration_arns: ["VpcResourceConfigurationArn"],
      },
      storage_profile_id: "StorageProfileId",
      persistent_volume_configuration: {
        size_gi_b: 1,
        iops: 1,
        throughput_mi_b: 1,
        mount_path: "MountPath", # required
        last_used_ttl_hours: 1,
      },
      auto_scaling_configuration: {
        standby_worker_count: 1,
        worker_idle_duration_seconds: 1,
        scale_out_workers_per_minute: 1,
      },
    },
  },
  host_configuration: {
    script_body: "HostConfigurationScript", # required
    script_timeout_seconds: 1,
  },
})

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID to update.
    
          
        
    • 
      
        
  • 
          :fleet_id
          (required, String)
          
            
          
          
            — 
    The fleet ID to update.
    
          
        
    • 
      
        
  • 
          :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
          (String)
          
            
          
          
            — 
    The display name of the fleet to update.
    

    This field can store any content. Escape or encode this content before
displaying it on a webpage or any other system that might interpret
the content of this field.
    
          
        
    • 
      
        
  • 
          :description
          (String)
          
            
          
          
            — 
    The description of the fleet to update.
    

    This field can store any content. Escape or encode this content before
displaying it on a webpage or any other system that might interpret
the content of this field.
    
          
        
    • 
      
        
  • 
          :role_arn
          (String)
          
            
          
          
            — 
    The IAM role ARN that the fleet's workers assume while running jobs.
    
          
        
    • 
      
        
  • 
          :min_worker_count
          (Integer)
          
            
          
          
            — 
    The minimum number of workers in the fleet.
    
          
        
    • 
      
        
  • 
          :max_worker_count
          (Integer)
          
            
          
          
            — 
    The maximum number of workers in the fleet.
    

    Deadline Cloud limits the number of workers to less than or equal to
the fleet's maximum worker count. The service maintains eventual
consistency for the worker count. If you make multiple rapid calls to
CreateWorker before the field updates, you might exceed your
fleet's maximum worker count. For example, if your maxWorkerCount
is 10 and you currently have 9 workers, making two quick
CreateWorker calls might successfully create 2 workers instead of 1,
resulting in 11 total workers.
    
          
        
    • 
      
        
  • 
          :configuration
          (Types::FleetConfiguration)
          
            
          
          
            — 
    The fleet configuration to update.
    
          
        
    • 
      
        
  • 
          :host_configuration
          (Types::HostConfiguration)
          
            
          
          
            — 
    Provides a script that runs as a worker is starting up that you can
use to provide additional configuration for workers in your fleet.
    
          
        
    • 
      
    

  
    
    


Returns:


    
  
    
  • 
      
      
        (Struct)
      
      
      
        —
        
    Returns an empty response.
    
      
    
    • 
  



  
See Also:

  



  

    
      


1900

    		
    
      
# File 'sig/client.rbs', line 1900

def update_fleet: (

    		
  





    
      

  

  
    #update_job(params = {})  ⇒ Struct 
  

  

  


  

    
Updates a job.


When you change the status of the job to ARCHIVED, the job can't be
scheduled or archived.


An archived jobs and its steps and tasks are deleted after 120 days.
The job can't be recovered.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.update_job({
  farm_id: "FarmId", # required
  queue_id: "QueueId", # required
  job_id: "JobId", # required
  client_token: "ClientToken",
  target_task_run_status: "READY", # accepts READY, FAILED, SUCCEEDED, CANCELED, SUSPENDED, PENDING
  priority: 1,
  max_failed_tasks_count: 1,
  max_retries_per_task: 1,
  lifecycle_status: "ARCHIVED", # accepts ARCHIVED
  max_worker_count: 1,
  name: "JobName",
  description: "JobDescriptionOverride",
})

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID of the job to update.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The queue ID of the job to update.
    
          
        
    • 
      
        
  • 
          :job_id
          (required, String)
          
            
          
          
            — 
    The job ID to update.
    
          
        
    • 
      
        
  • 
          :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.**
    
          
        
    • 
      
        
  • 
          :target_task_run_status
          (String)
          
            
          
          
            — 
    The task status to update the job's tasks to.
    
          
        
    • 
      
        
  • 
          :priority
          (Integer)
          
            
          
          
            — 
    The updated job priority.
    
          
        
    • 
      
        
  • 
          :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.
    
          
        
    • 
      
        
  • 
          :lifecycle_status
          (String)
          
            
          
          
            — 
    The status of a job in its lifecycle. When you change the status of
the job to ARCHIVED, the job can't be scheduled or archived.
    

    An archived jobs and its steps and tasks are deleted after 120 days.
The job can't be recovered.
    
          
        
    • 
      
        
  • 
          :max_worker_count
          (Integer)
          
            
          
          
            — 
    The maximum number of worker hosts that can concurrently process a
job. When the maxWorkerCount is reached, no more workers will be
assigned to process the job, even if the fleets assigned to the job's
queue has available workers.
    

    You can't set the maxWorkerCount to 0. If you set it to -1, there
is no maximum number of workers.
    

    If you don't specify the maxWorkerCount, the default is -1.
    

    The maximum number of workers that can process tasks in the job.
    
          
        
    • 
      
        
  • 
          :name
          (String)
          
            
          
          
            — 
    The updated job name.
    
          
        
    • 
      
        
  • 
          :description
          (String)
          
            
          
          
            — 
    The updated job description.
    
          
        
    • 
      
    

  
    
    


Returns:


    
  
    
  • 
      
      
        (Struct)
      
      
      
        —
        
    Returns an empty response.
    
      
    
    • 
  



  
See Also:

  



  

    
      


1921

    		
    
      
# File 'sig/client.rbs', line 1921

def update_job: (

    		
  





    
      

  

  
    #update_limit(params = {})  ⇒ Struct 
  

  

  


  

    
Updates the properties of the specified limit.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.update_limit({
  farm_id: "FarmId", # required
  limit_id: "LimitId", # required
  display_name: "ResourceName",
  description: "Description",
  max_count: 1,
})

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The unique identifier of the farm that contains the limit.
    
          
        
    • 
      
        
  • 
          :limit_id
          (required, String)
          
            
          
          
            — 
    The unique identifier of the limit to update.
    
          
        
    • 
      
        
  • 
          :display_name
          (String)
          
            
          
          
            — 
    The new display name of the limit.
    

    This field can store any content. Escape or encode this content before
displaying it on a webpage or any other system that might interpret
the content of this field.
    
          
        
    • 
      
        
  • 
          :description
          (String)
          
            
          
          
            — 
    The new description of the limit.
    

    This field can store any content. Escape or encode this content before
displaying it on a webpage or any other system that might interpret
the content of this field.
    
          
        
    • 
      
        
  • 
          :max_count
          (Integer)
          
            
          
          
            — 
    The maximum number of resources constrained by this limit. When all of
the resources are in use, steps that require the limit won't be
scheduled until the resource is available.
    

    If more than the new maximum number is currently in use, running jobs
finish but no new jobs are started until the number of resources in
use is below the new maximum number.
    

    The maxCount must not be 0. If the value is -1, there is no
restriction on the number of resources that can be acquired for this
limit.
    
          
        
    • 
      
    

  
    
    


Returns:


    
  
    
  • 
      
      
        (Struct)
      
      
      
        —
        
    Returns an empty response.
    
      
    
    • 
  



  
See Also:

  



  

    
      


1941

    		
    
      
# File 'sig/client.rbs', line 1941

def update_limit: (

    		
  





    
      

  

  
    #update_monitor(params = {})  ⇒ Struct 
  

  

  


  

    
Modifies the settings for a Deadline Cloud monitor. You can modify one
or all of the settings when you call UpdateMonitor.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.update_monitor({
  monitor_id: "MonitorId", # required
  subdomain: "Subdomain",
  display_name: "ResourceName",
  role_arn: "IamRoleArn",
})

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :monitor_id
          (required, String)
          
            
          
          
            — 
    The unique identifier of the monitor to update.
    
          
        
    • 
      
        
  • 
          :subdomain
          (String)
          
            
          
          
            — 
    The new value of the subdomain to use when forming the monitor URL.
    
          
        
    • 
      
        
  • 
          :display_name
          (String)
          
            
          
          
            — 
    The new value to use for the monitor's display name.
    

    This field can store any content. Escape or encode this content before
displaying it on a webpage or any other system that might interpret
the content of this field.
    
          
        
    • 
      
        
  • 
          :role_arn
          (String)
          
            
          
          
            — 
    The Amazon Resource Name of the new IAM role to use with the monitor.
    
          
        
    • 
      
    

  
    
    


Returns:


    
  
    
  • 
      
      
        (Struct)
      
      
      
        —
        
    Returns an empty response.
    
      
    
    • 
  



  
See Also:

  



  

    
      


1954

    		
    
      
# File 'sig/client.rbs', line 1954

def update_monitor: (

    		
  





    
      

  

  
    #update_monitor_settings(params = {})  ⇒ Struct 
  

  

  


  

    
Updates the settings for a Deadline Cloud monitor. Keys present in the
request are upserted; keys absent are left unchanged. Send an empty
string value to delete a key.


  





  
  

    
Examples:

    
      
        
Example: Update monitor settings

      
      

resp = client.update_monitor_settings({
  monitor_id: "monitor-1234567890abcdef1234567890abcdef", 
  settings: {
    "idcApplicationArn" => "arn:aws:sso::123456789012:application/ins-1234567890abcdef/apl-1234567890abcdef", 
  }, 
})

    
      
        
Request syntax with placeholder values

      
      

resp = client.update_monitor_settings({
  monitor_id: "MonitorId", # required
  settings: { # required
    "SettingKey" => "SettingValue",
  },
})

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :monitor_id
          (required, String)
          
            
          
          
            — 
    The unique identifier of the monitor to update settings for.
    
          
        
    • 
      
        
  • 
          :settings
          (required, Hash<String,String>)
          
            
          
          
            — 
    The monitor settings to update as key-value pairs. Keys present in the
request are upserted; keys absent are left unchanged. Send an empty
string value to delete a key.
    
          
        
    • 
      
    

  
    
    


Returns:


    
  
    
  • 
      
      
        (Struct)
      
      
      
        —
        
    Returns an empty response.
    
      
    
    • 
  



  
See Also:

  



  

    
      


1966

    		
    
      
# File 'sig/client.rbs', line 1966

def update_monitor_settings: (

    		
  





    
      

  

  
    #update_queue(params = {})  ⇒ Struct 
  

  

  


  

    
Updates a queue.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.update_queue({
  farm_id: "FarmId", # required
  queue_id: "QueueId", # required
  client_token: "ClientToken",
  display_name: "ResourceName",
  description: "Description",
  default_budget_action: "NONE", # accepts NONE, STOP_SCHEDULING_AND_COMPLETE_TASKS, STOP_SCHEDULING_AND_CANCEL_TASKS
  job_attachment_settings: {
    s3_bucket_name: "S3BucketName", # required
    root_prefix: "S3Prefix", # required
  },
  role_arn: "IamRoleArn",
  job_run_as_user: {
    posix: {
      user: "PosixUserUserString", # required
      group: "PosixUserGroupString", # required
    },
    windows: {
      user: "WindowsUserUserString", # required
      password_arn: "WindowsUserPasswordArnString", # required
    },
    run_as: "QUEUE_CONFIGURED_USER", # required, accepts QUEUE_CONFIGURED_USER, WORKER_AGENT_USER
  },
  required_file_system_location_names_to_add: ["FileSystemLocationName"],
  required_file_system_location_names_to_remove: ["FileSystemLocationName"],
  allowed_storage_profile_ids_to_add: ["StorageProfileId"],
  allowed_storage_profile_ids_to_remove: ["StorageProfileId"],
  scheduling_configuration: {
    priority_fifo: {
    },
    priority_balanced: {
      rendering_task_buffer: 1,
    },
    weighted_balanced: {
      priority_weight: 1.0,
      error_weight: 1.0,
      submission_time_weight: 1.0,
      rendering_task_weight: 1.0,
      rendering_task_buffer: 1,
      max_priority_override: {
        always_schedule_first: {
        },
      },
      min_priority_override: {
        always_schedule_last: {
        },
      },
    },
  },
})

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID to update in the queue.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The queue ID to update.
    
          
        
    • 
      
        
  • 
          :client_token
          (String)
          
            
          
          
            — 
    The idempotency token to update in the queue.
    

    A suitable default value is auto-generated. You should normally
not need to pass this option.**
    
          
        
    • 
      
        
  • 
          :display_name
          (String)
          
            
          
          
            — 
    The display name of the queue to update.
    

    This field can store any content. Escape or encode this content before
displaying it on a webpage or any other system that might interpret
the content of this field.
    
          
        
    • 
      
        
  • 
          :description
          (String)
          
            
          
          
            — 
    The description of the queue to update.
    

    This field can store any content. Escape or encode this content before
displaying it on a webpage or any other system that might interpret
the content of this field.
    
          
        
    • 
      
        
  • 
          :default_budget_action
          (String)
          
            
          
          
            — 
    The default action to take for a queue update if a budget isn't
configured.
    
          
        
    • 
      
        
  • 
          :job_attachment_settings
          (Types::JobAttachmentSettings)
          
            
          
          
            — 
    The job attachment settings to update for the queue.
    
          
        
    • 
      
        
  • 
          :role_arn
          (String)
          
            
          
          
            — 
    The IAM role ARN that's used to run jobs from this queue.
    
          
        
    • 
      
        
  • 
          :job_run_as_user
          (Types::JobRunAsUser)
          
            
          
          
            — 
    Update the jobs in the queue to run as a specified POSIX user.
    
          
        
    • 
      
        
  • 
          :required_file_system_location_names_to_add
          (Array<String>)
          
            
          
          
            — 
    The required file system location names to add to the queue.
    
          
        
    • 
      
        
  • 
          :required_file_system_location_names_to_remove
          (Array<String>)
          
            
          
          
            — 
    The required file system location names to remove from the queue.
    
          
        
    • 
      
        
  • 
          :allowed_storage_profile_ids_to_add
          (Array<String>)
          
            
          
          
            — 
    The storage profile IDs to add.
    
          
        
    • 
      
        
  • 
          :allowed_storage_profile_ids_to_remove
          (Array<String>)
          
            
          
          
            — 
    The storage profile ID to remove.
    
          
        
    • 
      
        
  • 
          :scheduling_configuration
          (Types::SchedulingConfiguration)
          
            
          
          
            — 
    The scheduling configuration for the queue. This configuration
determines how workers are assigned to jobs in the queue.
    

    When updating the scheduling configuration, the entire configuration
is replaced.
    

    In-progress tasks run to completion before the new scheduling
configuration takes effect.
    
          
        
    • 
      
    

  
    
    


Returns:


    
  
    
  • 
      
      
        (Struct)
      
      
      
        —
        
    Returns an empty response.
    
      
    
    • 
  



  
See Also:

  



  

    
      


1976

    		
    
      
# File 'sig/client.rbs', line 1976

def update_queue: (

    		
  





    
      

  

  
    #update_queue_environment(params = {})  ⇒ Struct 
  

  

  


  

    
Updates the queue environment.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

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

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID of the queue environment to update.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The queue ID of the queue environment to update.
    
          
        
    • 
      
        
  • 
          :queue_environment_id
          (required, String)
          
            
          
          
            — 
    The queue environment ID to update.
    
          
        
    • 
      
        
  • 
          :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.**
    
          
        
    • 
      
        
  • 
          :priority
          (Integer)
          
            
          
          
            — 
    The priority to update.
    
          
        
    • 
      
        
  • 
          :template_type
          (String)
          
            
          
          
            — 
    The template type to update.
    
          
        
    • 
      
        
  • 
          :template
          (String)
          
            
          
          
            — 
    The template to update.
    
          
        
    • 
      
    

  
    
    


Returns:


    
  
    
  • 
      
      
        (Struct)
      
      
      
        —
        
    Returns an empty response.
    
      
    
    • 
  



  
See Also:

  



  

    
      


2001

    		
    
      
# File 'sig/client.rbs', line 2001

def update_queue_environment: (

    		
  





    
      

  

  
    #update_queue_fleet_association(params = {})  ⇒ Struct 
  

  

  


  

    
Updates a queue-fleet association.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.update_queue_fleet_association({
  farm_id: "FarmId", # required
  queue_id: "QueueId", # required
  fleet_id: "FleetId", # required
  status: "ACTIVE", # required, accepts ACTIVE, STOP_SCHEDULING_AND_COMPLETE_TASKS, STOP_SCHEDULING_AND_CANCEL_TASKS
})

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID to update.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The queue ID to update.
    
          
        
    • 
      
        
  • 
          :fleet_id
          (required, String)
          
            
          
          
            — 
    The fleet ID to update.
    
          
        
    • 
      
        
  • 
          :status
          (required, String)
          
            
          
          
            — 
    The status to update.
    
          
        
    • 
      
    

  
    
    


Returns:


    
  
    
  • 
      
      
        (Struct)
      
      
      
        —
        
    Returns an empty response.
    
      
    
    • 
  



  
See Also:

  



  

    
      


2016

    		
    
      
# File 'sig/client.rbs', line 2016

def update_queue_fleet_association: (

    		
  





    
      

  

  
    #update_queue_limit_association(params = {})  ⇒ Struct 
  

  

  


  

    
Updates the status of the queue. If you set the status to one of the
STOP_LIMIT_USAGE* values, there will be a delay before the status
transitions to the STOPPED state.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.update_queue_limit_association({
  farm_id: "FarmId", # required
  queue_id: "QueueId", # required
  limit_id: "LimitId", # required
  status: "ACTIVE", # required, accepts ACTIVE, STOP_LIMIT_USAGE_AND_COMPLETE_TASKS, STOP_LIMIT_USAGE_AND_CANCEL_TASKS
})

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The unique identifier of the farm that contains the associated queues
and limits.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The unique identifier of the queue associated to the limit.
    
          
        
    • 
      
        
  • 
          :limit_id
          (required, String)
          
            
          
          
            — 
    The unique identifier of the limit associated to the queue.
    
          
        
    • 
      
        
  • 
          :status
          (required, String)
          
            
          
          
            — 
    Sets the status of the limit. You can mark the limit active, or you
can stop usage of the limit and either complete existing tasks or
cancel any existing tasks immediately.
    
          
        
    • 
      
    

  
    
    


Returns:


    
  
    
  • 
      
      
        (Struct)
      
      
      
        —
        
    Returns an empty response.
    
      
    
    • 
  



  
See Also:

  



  

    
      


2028

    		
    
      
# File 'sig/client.rbs', line 2028

def update_queue_limit_association: (

    		
  





    
      

  

  
    #update_session(params = {})  ⇒ Struct 
  

  

  


  

    
Updates a session.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.update_session({
  farm_id: "FarmId", # required
  queue_id: "QueueId", # required
  job_id: "JobId", # required
  session_id: "SessionId", # required
  client_token: "ClientToken",
  target_lifecycle_status: "ENDED", # required, accepts ENDED
})

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID to update in the session.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The queue ID to update in the session.
    
          
        
    • 
      
        
  • 
          :job_id
          (required, String)
          
            
          
          
            — 
    The job ID to update in the session.
    
          
        
    • 
      
        
  • 
          :session_id
          (required, String)
          
            
          
          
            — 
    The session ID to update.
    
          
        
    • 
      
        
  • 
          :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.**
    
          
        
    • 
      
        
  • 
          :target_lifecycle_status
          (required, String)
          
            
          
          
            — 
    The life cycle status to update in the session.
    
          
        
    • 
      
    

  
    
    


Returns:


    
  
    
  • 
      
      
        (Struct)
      
      
      
        —
        
    Returns an empty response.
    
      
    
    • 
  



  
See Also:

  



  

    
      


2040

    		
    
      
# File 'sig/client.rbs', line 2040

def update_session: (

    		
  





    
      

  

  
    #update_step(params = {})  ⇒ Struct 
  

  

  


  

    
Updates a step.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.update_step({
  farm_id: "FarmId", # required
  queue_id: "QueueId", # required
  job_id: "JobId", # required
  step_id: "StepId", # required
  client_token: "ClientToken",
  target_task_run_status: "READY", # required, accepts READY, FAILED, SUCCEEDED, CANCELED, SUSPENDED, PENDING
})

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID to update.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The queue ID to update.
    
          
        
    • 
      
        
  • 
          :job_id
          (required, String)
          
            
          
          
            — 
    The job ID to update.
    
          
        
    • 
      
        
  • 
          :step_id
          (required, String)
          
            
          
          
            — 
    The step ID to update.
    
          
        
    • 
      
        
  • 
          :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.**
    
          
        
    • 
      
        
  • 
          :target_task_run_status
          (required, String)
          
            
          
          
            — 
    The task status to update the step's tasks to.
    
          
        
    • 
      
    

  
    
    


Returns:


    
  
    
  • 
      
      
        (Struct)
      
      
      
        —
        
    Returns an empty response.
    
      
    
    • 
  



  
See Also:

  



  

    
      


2054

    		
    
      
# File 'sig/client.rbs', line 2054

def update_step: (

    		
  





    
      

  

  
    #update_storage_profile(params = {})  ⇒ Struct 
  

  

  


  

    
Updates a storage profile.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

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

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID to update.
    
          
        
    • 
      
        
  • 
          :storage_profile_id
          (required, String)
          
            
          
          
            — 
    The storage profile ID to update.
    
          
        
    • 
      
        
  • 
          :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
          (String)
          
            
          
          
            — 
    The display name of the storage profile to update.
    

    This field can store any content. Escape or encode this content before
displaying it on a webpage or any other system that might interpret
the content of this field.
    
          
        
    • 
      
        
  • 
          :os_family
          (String)
          
            
          
          
            — 
    The OS system to update.
    
          
        
    • 
      
        
  • 
          :file_system_locations_to_add
          (Array<Types::FileSystemLocation>)
          
            
          
          
            — 
    The file system location names to add.
    
          
        
    • 
      
        
  • 
          :file_system_locations_to_remove
          (Array<Types::FileSystemLocation>)
          
            
          
          
            — 
    The file system location names to remove.
    
          
        
    • 
      
    

  
    
    


Returns:


    
  
    
  • 
      
      
        (Struct)
      
      
      
        —
        
    Returns an empty response.
    
      
    
    • 
  



  
See Also:

  



  

    
      


2068

    		
    
      
# File 'sig/client.rbs', line 2068

def update_storage_profile: (

    		
  





    
      

  

  
    #update_task(params = {})  ⇒ Struct 
  

  

  


  

    
Updates a task.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.update_task({
  farm_id: "FarmId", # required
  queue_id: "QueueId", # required
  job_id: "JobId", # required
  step_id: "StepId", # required
  task_id: "TaskId", # required
  client_token: "ClientToken",
  target_run_status: "READY", # required, accepts READY, FAILED, SUCCEEDED, CANCELED, SUSPENDED, PENDING
})

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID to update.
    
          
        
    • 
      
        
  • 
          :queue_id
          (required, String)
          
            
          
          
            — 
    The queue ID to update.
    
          
        
    • 
      
        
  • 
          :job_id
          (required, String)
          
            
          
          
            — 
    The job ID to update.
    
          
        
    • 
      
        
  • 
          :step_id
          (required, String)
          
            
          
          
            — 
    The step ID to update.
    
          
        
    • 
      
        
  • 
          :task_id
          (required, String)
          
            
          
          
            — 
    The task ID to update.
    
          
        
    • 
      
        
  • 
          :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.**
    
          
        
    • 
      
        
  • 
          :target_run_status
          (required, String)
          
            
          
          
            — 
    The run status with which to start the task.
    
          
        
    • 
      
    

  
    
    


Returns:


    
  
    
  • 
      
      
        (Struct)
      
      
      
        —
        
    Returns an empty response.
    
      
    
    • 
  



  
See Also:

  



  

    
      


2095

    		
    
      
# File 'sig/client.rbs', line 2095

def update_task: (

    		
  





    
      

  

  
    #update_worker(params = {})  ⇒ Types::UpdateWorkerResponse 
  

  

  


  

    
Updates a worker.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.update_worker({
  farm_id: "FarmId", # required
  fleet_id: "FleetId", # required
  worker_id: "WorkerId", # required
  status: "STARTED", # accepts STARTED, STOPPING, STOPPED
  capabilities: {
    amounts: [ # required
      {
        name: "AmountCapabilityName", # required
        value: 1.0, # required
      },
    ],
    attributes: [ # required
      {
        name: "AttributeCapabilityName", # required
        values: ["AttributeCapabilityValue"], # required
      },
    ],
  },
  host_properties: {
    ip_addresses: {
      ip_v4_addresses: ["IpV4Address"],
      ip_v6_addresses: ["IpV6Address"],
    },
    host_name: "HostName",
  },
})

    
      
        
Response structure

      
      

resp.log.log_driver #=> String
resp.log.options #=> Hash
resp.log.options["String"] #=> String
resp.log.parameters #=> Hash
resp.log.parameters["String"] #=> String
resp.log.error #=> String
resp.host_configuration.script_body #=> String
resp.host_configuration.script_timeout_seconds #=> Integer

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID to update.
    
          
        
    • 
      
        
  • 
          :fleet_id
          (required, String)
          
            
          
          
            — 
    The fleet ID to update.
    
          
        
    • 
      
        
  • 
          :worker_id
          (required, String)
          
            
          
          
            — 
    The worker ID to update.
    
          
        
    • 
      
        
  • 
          :status
          (String)
          
            
          
          
            — 
    The worker status to update.
    
          
        
    • 
      
        
  • 
          :capabilities
          (Types::WorkerCapabilities)
          
            
          
          
            — 
    The worker capabilities to update.
    
          
        
    • 
      
        
  • 
          :host_properties
          (Types::HostPropertiesRequest)
          
            
          
          
            — 
    The host properties to update.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


2112

    		
    
      
# File 'sig/client.rbs', line 2112

def update_worker: (

    		
  





    
      

  

  
    #update_worker_schedule(params = {})  ⇒ Types::UpdateWorkerScheduleResponse 
  

  

  


  

    
Updates the schedule for a worker.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.update_worker_schedule({
  farm_id: "FarmId", # required
  fleet_id: "FleetId", # required
  worker_id: "WorkerId", # required
  updated_session_actions: {
    "SessionActionId" => {
      completed_status: "SUCCEEDED", # accepts SUCCEEDED, FAILED, INTERRUPTED, CANCELED, NEVER_ATTEMPTED
      process_exit_code: 1,
      progress_message: "SessionActionProgressMessage",
      started_at: Time.now,
      ended_at: Time.now,
      updated_at: Time.now,
      progress_percent: 1.0,
      manifests: [
        {
          output_manifest_path: "TaskRunManifestPropertiesRequestOutputManifestPathString",
          output_manifest_hash: "TaskRunManifestPropertiesRequestOutputManifestHashString",
        },
      ],
    },
  },
})

    
      
        
Response structure

      
      

resp.assigned_sessions #=> Hash
resp.assigned_sessions["SessionId"].queue_id #=> String
resp.assigned_sessions["SessionId"].job_id #=> String
resp.assigned_sessions["SessionId"].session_actions #=> Array
resp.assigned_sessions["SessionId"].session_actions[0].session_action_id #=> String
resp.assigned_sessions["SessionId"].session_actions[0].definition.env_enter.environment_id #=> String
resp.assigned_sessions["SessionId"].session_actions[0].definition.env_exit.environment_id #=> String
resp.assigned_sessions["SessionId"].session_actions[0].definition.task_run.task_id #=> String
resp.assigned_sessions["SessionId"].session_actions[0].definition.task_run.step_id #=> String
resp.assigned_sessions["SessionId"].session_actions[0].definition.task_run.parameters #=> Hash
resp.assigned_sessions["SessionId"].session_actions[0].definition.task_run.parameters["String"].int #=> String
resp.assigned_sessions["SessionId"].session_actions[0].definition.task_run.parameters["String"].float #=> String
resp.assigned_sessions["SessionId"].session_actions[0].definition.task_run.parameters["String"].string #=> String
resp.assigned_sessions["SessionId"].session_actions[0].definition.task_run.parameters["String"].path #=> String
resp.assigned_sessions["SessionId"].session_actions[0].definition.task_run.parameters["String"].chunk_int #=> String
resp.assigned_sessions["SessionId"].session_actions[0].definition.sync_input_job_attachments.step_id #=> String
resp.assigned_sessions["SessionId"].log_configuration.log_driver #=> String
resp.assigned_sessions["SessionId"].log_configuration.options #=> Hash
resp.assigned_sessions["SessionId"].log_configuration.options["String"] #=> String
resp.assigned_sessions["SessionId"].log_configuration.parameters #=> Hash
resp.assigned_sessions["SessionId"].log_configuration.parameters["String"] #=> String
resp.assigned_sessions["SessionId"].log_configuration.error #=> String
resp.cancel_session_actions #=> Hash
resp.cancel_session_actions["SessionId"] #=> Array
resp.cancel_session_actions["SessionId"][0] #=> String
resp.desired_worker_status #=> String, one of "STOPPED"
resp.update_interval_seconds #=> Integer

    
  


  

Parameters:


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



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :farm_id
          (required, String)
          
            
          
          
            — 
    The farm ID to update.
    
          
        
    • 
      
        
  • 
          :fleet_id
          (required, String)
          
            
          
          
            — 
    The fleet ID to update.
    
          
        
    • 
      
        
  • 
          :worker_id
          (required, String)
          
            
          
          
            — 
    The worker ID to update.
    
          
        
    • 
      
        
  • 
          :updated_session_actions
          (Hash<String,Types::UpdatedSessionActionInfo>)
          
            
          
          
            — 
    The session actions associated with the worker schedule to update.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


2149

    		
    
      
# File 'sig/client.rbs', line 2149

def update_worker_schedule: (

    		
  





    
      

  

  
    #wait_until(waiter_name, params = {}, options = {}) {|w.waiter| ... } ⇒ Boolean 
  

  

  


  

    
Polls an API operation until a resource enters a desired state.


Basic Usage


A waiter will call an API operation until:


    

  • It is successful
    • 

  • It enters a terminal state
    • 

  • It makes the maximum number of attempts
    • 



In between attempts, the waiter will sleep.


# polls in a loop, sleeping between attempts
client.wait_until(waiter_name, params)



Configuration


You can configure the maximum number of polling attempts, and the
delay (in seconds) between each polling attempt. You can pass
configuration as the final arguments hash.


# poll for ~25 seconds
client.wait_until(waiter_name, params, {
  max_attempts: 5,
  delay: 5,
})



Callbacks


You can be notified before each polling attempt and before each
delay. If you throw :success or :failure from these callbacks,
it will terminate the waiter.


started_at = Time.now
client.wait_until(waiter_name, params, {

  # disable max attempts
  max_attempts: nil,

  # poll for 1 hour, instead of a number of attempts
  before_wait: -> (attempts, response) do
    throw :failure if Time.now - started_at > 3600
  end
})



Handling Errors


When a waiter is unsuccessful, it will raise an error.
All of the failure errors extend from
Waiters::Errors::WaiterFailed.


begin
  client.wait_until(...)
rescue Aws::Waiters::Errors::WaiterFailed
  # resource did not enter the desired state in time
end



Valid Waiters


The following table lists the valid waiter names, the operations they call,
and the default :delay and :max_attempts values.






waiter_name
params
:delay
:max_attempts






fleet_active
#get_fleet
5
180




job_complete
#get_job
15
240




job_create_complete
#get_job
1
120




job_succeeded
#get_job
15
240




license_endpoint_deleted
#get_license_endpoint
10
234




license_endpoint_valid
#get_license_endpoint
10
114




queue_fleet_association_stopped
#get_queue_fleet_association
10
60




queue_limit_association_stopped
#get_queue_limit_association
10
60




queue_scheduling
#get_queue
10
70




queue_scheduling_blocked
#get_queue
10
30






  





  
Parameters:


    
  
    
  • 
      
        waiter_name
      
      
        (Symbol)
      
      
      
    
    • 
  
    
  • 
      
        params
      
      
        (Hash)
      
      
        (defaults to: {})
      
      
        —
        
    ({})
    
      
    
    • 
  
    
  • 
      
        options
      
      
        (Hash)
      
      
        (defaults to: {})
      
      
        —
        
    ({})
    
      
    
    • 
  



  
    
    
    
    
    
    
    
Options Hash (options):

    
    
      
        
  • 
          :max_attempts
          (Integer)
          
            
          
          
        
    • 
      
        
  • 
          :delay
          (Integer)
          
            
          
          
        
    • 
      
        
  • 
          :before_attempt
          (Proc)
          
            
          
          
        
    • 
      
        
  • 
          :before_wait
          (Proc)
          
            
          
          
        
    • 
      
    

  


Yields:


    
  
    
  • 
      
      
        (w.waiter)
      
      
      
    
    • 
  



Returns:


    
  
    
  • 
      
      
        (Boolean)
      
      
      
        —
        
    Returns true if the waiter was successful.
    
      
    
    • 
  



Raises:


    
  
    
  • 
      
      
        (Errors::FailureStateError)
      
      
      
        —
        
    Raised when the waiter terminates
because the waiter has entered a state that it will not transition
out of, preventing success.
    
      
    
    • 
  
    
  • 
      
      
        (Errors::TooManyAttemptsError)
      
      
      
        —
        
    Raised when the configured
maximum number of attempts have been made, and the waiter is not
yet successful.
    
      
    
    • 
  
    
  • 
      
      
        (Errors::UnexpectedError)
      
      
      
        —
        
    Raised when an error is encounted
while polling for a resource that is not expected.
    
      
    
    • 
  
    
  • 
      
      
        (Errors::NoSuchWaiterError)
      
      
      
        —
        
    Raised when you request to wait
for an unknown state.
    
      
    
    • 
  





  

    
      


2172

    		
    
      
# File 'sig/client.rbs', line 2172

def wait_until: (:fleet_active waiter_name,

    		
  





    
      

  

  
    #waiter_names  ⇒ Object 
  

  

  


  

    

  This method is part of a private API.
  You should avoid using this method if possible, as it may be removed or be changed in the future.



Deprecated. 



  





  



  

    
      


8474
8475
8476

    		
    
      
# File 'lib/aws-sdk-deadline/client.rb', line 8474

def waiter_names
  waiters.keys
end