A RetroSearch Logo

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Search Query:

Showing content from https://docs.aws.amazon.com/sdkforruby/api/Aws/ApiGatewayV2/Client.html below:

Client — AWS SDK for Ruby V2

You are viewing documentation for version 2 of the AWS SDK for Ruby. Version 3 documentation can be found here.

Class: Aws::ApiGatewayV2::Client Overview

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

apigatewayv2 = Aws::ApiGatewayV2::Client.new(
  region: region_name,
  credentials: credentials,
  )

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

Region

You can configure a default region in the following locations:

Go here for a list of supported regions.

Credentials

Default credentials are loaded automatically from the following locations:

You can also construct a credentials object from one of the following classes:

Alternatively, you configure credentials with :access_key_id and :secret_access_key:

creds = YAML.load(File.read('/path/to/secrets'))

Aws::ApiGatewayV2::Client.new(
  access_key_id: creds['access_key_id'],
  secret_access_key: creds['secret_access_key']
)

Always load your credentials from outside your application. Avoid configuring credentials statically and never commit them to source control.

Attribute Summary collapse Instance Attribute Summary Attributes inherited from Seahorse::Client::Base

#config, #handlers

Constructor collapse API Operations collapse Instance Method Summary collapse Methods inherited from Seahorse::Client::Base

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

Methods included from Seahorse::Client::HandlerBuilder

#handle, #handle_request, #handle_response

Instance Method Details

Creates an Authorizer for an API.

#delete_access_log_settings(options = {}) ⇒ Struct

Deletes the AccessLogSettings for a Stage. To disable access logging for a Stage, delete its AccessLogSettings.

#delete_api(options = {}) ⇒ Struct #delete_api_mapping(options = {}) ⇒ Struct #delete_authorizer(options = {}) ⇒ Struct #delete_cors_configuration(options = {}) ⇒ Struct

Deletes a CORS configuration.

#delete_deployment(options = {}) ⇒ Struct #delete_domain_name(options = {}) ⇒ Struct #delete_integration(options = {}) ⇒ Struct #delete_integration_response(options = {}) ⇒ Struct

Deletes an IntegrationResponses.

#delete_model(options = {}) ⇒ Struct #delete_route(options = {}) ⇒ Struct #delete_route_request_parameter(options = {}) ⇒ Struct

Deletes a route request parameter.

#delete_route_response(options = {}) ⇒ Struct #delete_route_settings(options = {}) ⇒ Struct

Deletes the RouteSettings for a stage.

#delete_stage(options = {}) ⇒ Struct #delete_vpc_link(options = {}) ⇒ Struct #export_api(options = {}) ⇒ Types::ExportApiResponse

Exports a definition of an API in a particular output format and specification.

#reset_authorizers_cache(options = {}) ⇒ Struct

Resets all authorizer cache entries for the specified stage. Supported only for HTTP API Lambda authorizers.

#tag_resource(options = {}) ⇒ Struct

Creates a new Tag resource to represent a tag.

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

Waiters polls an API operation until a resource enters a desired state.

Basic Usage

Waiters will poll until they are succesful, they fail by entering a terminal state, or until a maximum number of attempts are made.

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

Configuration

You can configure the maximum number of polling attempts, and the delay (in seconds) between each polling attempt. You configure waiters by passing a block to #wait_until:

# poll for ~25 seconds
client.wait_until(...) do |w|
  w.max_attempts = 5
  w.delay = 5
end
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(...) do |w|

  # disable max attempts
  w.max_attempts = nil

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

end
Handling Errors

When a waiter is successful, it returns true. When a waiter fails, it raises an error. All errors raised extend from Waiters::Errors::WaiterFailed.

begin
  client.wait_until(...)
rescue Aws::Waiters::Errors::WaiterFailed
  # resource did not enter the desired state in time
end
#waiter_names ⇒ Array<Symbol>

Returns the list of supported waiters. The following table lists the supported waiters and the client method they call:

Waiter Name Client Method Default Delay: Default Max Attempts:

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4