class Google::Cloud::PubSub::V1::Subscriber::Client

Client for the Subscriber service.

The service that an application uses to manipulate subscriptions and to consume messages from a subscription via the `Pull` method or by establishing a bi-directional stream using the `StreamingPull` method.

Attributes

subscriber_stub[R]

@private

Public Class Methods

configure() { |configure| ... } click to toggle source

Configure the Subscriber Client class.

See {::Google::Cloud::PubSub::V1::Subscriber::Client::Configuration} for a description of the configuration fields.

@example

# Modify the configuration for all Subscriber clients
::Google::Cloud::PubSub::V1::Subscriber::Client.configure do |config|
  config.timeout = 10.0
end

@yield [config] Configure the Client client. @yieldparam config [Client::Configuration]

@return [Client::Configuration]

# File lib/google/cloud/pubsub/v1/subscriber/client.rb, line 58
def self.configure
  @configure ||= begin
    namespace = ["Google", "Cloud", "PubSub", "V1"]
    parent_config = while namespace.any?
                      parent_name = namespace.join "::"
                      parent_const = const_get parent_name
                      break parent_const.configure if parent_const.respond_to? :configure
                      namespace.pop
                    end
    default_config = Client::Configuration.new parent_config

    default_config.rpcs.create_subscription.timeout = 60.0
    default_config.rpcs.create_subscription.retry_policy = {
      initial_delay: 0.1, max_delay: 60.0, multiplier: 1.3, retry_codes: [2, 10, 14]
    }

    default_config.rpcs.get_subscription.timeout = 60.0
    default_config.rpcs.get_subscription.retry_policy = {
      initial_delay: 0.1, max_delay: 60.0, multiplier: 1.3, retry_codes: [2, 10, 14]
    }

    default_config.rpcs.update_subscription.timeout = 60.0
    default_config.rpcs.update_subscription.retry_policy = {
      initial_delay: 0.1, max_delay: 60.0, multiplier: 1.3, retry_codes: [14]
    }

    default_config.rpcs.list_subscriptions.timeout = 60.0
    default_config.rpcs.list_subscriptions.retry_policy = {
      initial_delay: 0.1, max_delay: 60.0, multiplier: 1.3, retry_codes: [2, 10, 14]
    }

    default_config.rpcs.delete_subscription.timeout = 60.0
    default_config.rpcs.delete_subscription.retry_policy = {
      initial_delay: 0.1, max_delay: 60.0, multiplier: 1.3, retry_codes: [14]
    }

    default_config.rpcs.modify_ack_deadline.timeout = 60.0
    default_config.rpcs.modify_ack_deadline.retry_policy = {
      initial_delay: 0.1, max_delay: 60.0, multiplier: 1.3, retry_codes: [14]
    }

    default_config.rpcs.acknowledge.timeout = 60.0
    default_config.rpcs.acknowledge.retry_policy = {
      initial_delay: 0.1, max_delay: 60.0, multiplier: 1.3, retry_codes: [14]
    }

    default_config.rpcs.pull.timeout = 60.0
    default_config.rpcs.pull.retry_policy = {
      initial_delay: 0.1, max_delay: 60.0, multiplier: 1.3, retry_codes: [2, 10, 14]
    }

    default_config.rpcs.streaming_pull.timeout = 900.0
    default_config.rpcs.streaming_pull.retry_policy = {
      initial_delay: 0.1, max_delay: 60.0, multiplier: 1.3, retry_codes: [4, 8, 10, 13, 14]
    }

    default_config.rpcs.modify_push_config.timeout = 60.0
    default_config.rpcs.modify_push_config.retry_policy = {
      initial_delay: 0.1, max_delay: 60.0, multiplier: 1.3, retry_codes: [14]
    }

    default_config.rpcs.get_snapshot.timeout = 60.0
    default_config.rpcs.get_snapshot.retry_policy = {
      initial_delay: 0.1, max_delay: 60.0, multiplier: 1.3, retry_codes: [2, 10, 14]
    }

    default_config.rpcs.list_snapshots.timeout = 60.0
    default_config.rpcs.list_snapshots.retry_policy = {
      initial_delay: 0.1, max_delay: 60.0, multiplier: 1.3, retry_codes: [2, 10, 14]
    }

    default_config.rpcs.create_snapshot.timeout = 60.0
    default_config.rpcs.create_snapshot.retry_policy = {
      initial_delay: 0.1, max_delay: 60.0, multiplier: 1.3, retry_codes: [14]
    }

    default_config.rpcs.update_snapshot.timeout = 60.0
    default_config.rpcs.update_snapshot.retry_policy = {
      initial_delay: 0.1, max_delay: 60.0, multiplier: 1.3, retry_codes: [14]
    }

    default_config.rpcs.delete_snapshot.timeout = 60.0
    default_config.rpcs.delete_snapshot.retry_policy = {
      initial_delay: 0.1, max_delay: 60.0, multiplier: 1.3, retry_codes: [14]
    }

    default_config.rpcs.seek.timeout = 60.0
    default_config.rpcs.seek.retry_policy = {
      initial_delay: 0.1, max_delay: 60.0, multiplier: 1.3, retry_codes: [2, 10, 14]
    }

    default_config
  end
  yield @configure if block_given?
  @configure
end
new() { |config| ... } click to toggle source

Create a new Subscriber client object.

@example

# Create a client using the default configuration
client = ::Google::Cloud::PubSub::V1::Subscriber::Client.new

# Create a client using a custom configuration
client = ::Google::Cloud::PubSub::V1::Subscriber::Client.new do |config|
  config.timeout = 10.0
end

@yield [config] Configure the Subscriber client. @yieldparam config [Client::Configuration]

# File lib/google/cloud/pubsub/v1/subscriber/client.rb, line 191
def initialize
  # These require statements are intentionally placed here to initialize
  # the gRPC module only when it's required.
  # See https://github.com/googleapis/toolkit/issues/446
  require "gapic/grpc"
  require "google/pubsub/v1/pubsub_services_pb"

  # Create the configuration object
  @config = Configuration.new Client.configure

  # Yield the configuration if needed
  yield @config if block_given?

  # Create credentials
  credentials = @config.credentials
  # Use self-signed JWT if the endpoint is unchanged from default,
  # but only if the default endpoint does not have a region prefix.
  enable_self_signed_jwt = @config.endpoint == Client.configure.endpoint &&
                           !@config.endpoint.split(".").first.include?("-")
  credentials ||= Credentials.default scope: @config.scope,
                                      enable_self_signed_jwt: enable_self_signed_jwt
  if credentials.is_a?(::String) || credentials.is_a?(::Hash)
    credentials = Credentials.new credentials, scope: @config.scope
  end
  @quota_project_id = @config.quota_project
  @quota_project_id ||= credentials.quota_project_id if credentials.respond_to? :quota_project_id

  @subscriber_stub = ::Gapic::ServiceStub.new(
    ::Google::Cloud::PubSub::V1::Subscriber::Stub,
    credentials:  credentials,
    endpoint:     @config.endpoint,
    channel_args: @config.channel_args,
    interceptors: @config.interceptors
  )
end

Public Instance Methods

acknowledge(request, options = nil) { |response, operation| ... } click to toggle source

Acknowledges the messages associated with the `ack_ids` in the `AcknowledgeRequest`. The Pub/Sub system can remove the relevant messages from the subscription.

Acknowledging a message whose ack deadline has expired may succeed, but such a message may be redelivered later. Acknowledging a message more than once will not result in an error.

@overload acknowledge(request, options = nil)

Pass arguments to `acknowledge` via a request object, either of type
{::Google::Cloud::PubSub::V1::AcknowledgeRequest} or an equivalent Hash.

@param request [::Google::Cloud::PubSub::V1::AcknowledgeRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload acknowledge(subscription: nil, ack_ids: nil)

Pass arguments to `acknowledge` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param subscription [::String]
  Required. The subscription whose message is being acknowledged.
  Format is `projects/{project}/subscriptions/{sub}`.
@param ack_ids [::Array<::String>]
  Required. The acknowledgment ID for the messages being acknowledged that
  was returned by the Pub/Sub system in the `Pull` response. Must not be
  empty.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Google::Protobuf::Empty] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Google::Protobuf::Empty]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/pubsub/v1/subscriber/client.rb, line 813
def acknowledge request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::PubSub::V1::AcknowledgeRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.acknowledge.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::PubSub::V1::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "subscription" => request.subscription
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.acknowledge.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.acknowledge.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @subscriber_stub.call_rpc :acknowledge, request, options: options do |response, operation|
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
configure() { |config| ... } click to toggle source

Configure the Subscriber Client instance.

The configuration is set to the derived mode, meaning that values can be changed, but structural changes (adding new fields, etc.) are not allowed. Structural changes should be made on {Client.configure}.

See {::Google::Cloud::PubSub::V1::Subscriber::Client::Configuration} for a description of the configuration fields.

@yield [config] Configure the Client client. @yieldparam config [Client::Configuration]

@return [Client::Configuration]

# File lib/google/cloud/pubsub/v1/subscriber/client.rb, line 170
def configure
  yield @config if block_given?
  @config
end
create_snapshot(request, options = nil) { |response, operation| ... } click to toggle source

Creates a snapshot from the requested subscription. Snapshots are used in [Seek](cloud.google.com/pubsub/docs/replay-overview) operations, which allow you to manage message acknowledgments in bulk. That is, you can set the acknowledgment state of messages in an existing subscription to the state captured by a snapshot. If the snapshot already exists, returns `ALREADY_EXISTS`. If the requested subscription doesn't exist, returns `NOT_FOUND`. If the backlog in the subscription is too old – and the resulting snapshot would expire in less than 1 hour – then `FAILED_PRECONDITION` is returned. See also the `Snapshot.expire_time` field. If the name is not provided in the request, the server will assign a random name for this snapshot on the same project as the subscription, conforming to the [resource name format] (cloud.google.com/pubsub/docs/admin#resource_names). The generated name is populated in the returned Snapshot object. Note that for REST API requests, you must specify a name in the request.

@overload create_snapshot(request, options = nil)

Pass arguments to `create_snapshot` via a request object, either of type
{::Google::Cloud::PubSub::V1::CreateSnapshotRequest} or an equivalent Hash.

@param request [::Google::Cloud::PubSub::V1::CreateSnapshotRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload create_snapshot(name: nil, subscription: nil, labels: nil)

Pass arguments to `create_snapshot` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param name [::String]
  Required. User-provided name for this snapshot. If the name is not provided
  in the request, the server will assign a random name for this snapshot on
  the same project as the subscription. Note that for REST API requests, you
  must specify a name.  See the <a
  href="https://cloud.google.com/pubsub/docs/admin#resource_names"> resource
  name rules</a>. Format is `projects/{project}/snapshots/{snap}`.
@param subscription [::String]
  Required. The subscription whose backlog the snapshot retains.
  Specifically, the created snapshot is guaranteed to retain:
   (a) The existing backlog on the subscription. More precisely, this is
       defined as the messages in the subscription's backlog that are
       unacknowledged upon the successful completion of the
       `CreateSnapshot` request; as well as:
   (b) Any messages published to the subscription's topic following the
       successful completion of the CreateSnapshot request.
  Format is `projects/{project}/subscriptions/{sub}`.
@param labels [::Hash{::String => ::String}]
  See <a href="https://cloud.google.com/pubsub/docs/labels"> Creating and
  managing labels</a>.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Google::Cloud::PubSub::V1::Snapshot] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Google::Cloud::PubSub::V1::Snapshot]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/pubsub/v1/subscriber/client.rb, line 1291
def create_snapshot request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::PubSub::V1::CreateSnapshotRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.create_snapshot.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::PubSub::V1::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "name" => request.name
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.create_snapshot.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.create_snapshot.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @subscriber_stub.call_rpc :create_snapshot, request, options: options do |response, operation|
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
create_subscription(request, options = nil) { |response, operation| ... } click to toggle source

Creates a subscription to a given topic. See the [resource name rules] (cloud.google.com/pubsub/docs/admin#resource_names). If the subscription already exists, returns `ALREADY_EXISTS`. If the corresponding topic doesn't exist, returns `NOT_FOUND`.

If the name is not provided in the request, the server will assign a random name for this subscription on the same project as the topic, conforming to the [resource name format] (cloud.google.com/pubsub/docs/admin#resource_names). The generated name is populated in the returned Subscription object. Note that for REST API requests, you must specify a name in the request.

@overload create_subscription(request, options = nil)

Pass arguments to `create_subscription` via a request object, either of type
{::Google::Cloud::PubSub::V1::Subscription} or an equivalent Hash.

@param request [::Google::Cloud::PubSub::V1::Subscription, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload create_subscription(name: nil, topic: nil, push_config: nil, ack_deadline_seconds: nil, retain_acked_messages: nil, message_retention_duration: nil, labels: nil, enable_message_ordering: nil, expiration_policy: nil, filter: nil, dead_letter_policy: nil, retry_policy: nil, detached: nil)

Pass arguments to `create_subscription` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param name [::String]
  Required. The name of the subscription. It must have the format
  `"projects/{project}/subscriptions/{subscription}"`. `{subscription}` must
  start with a letter, and contain only letters (`[A-Za-z]`), numbers
  (`[0-9]`), dashes (`-`), underscores (`_`), periods (`.`), tildes (`~`),
  plus (`+`) or percent signs (`%`). It must be between 3 and 255 characters
  in length, and it must not start with `"goog"`.
@param topic [::String]
  Required. The name of the topic from which this subscription is receiving
  messages. Format is `projects/{project}/topics/{topic}`. The value of this
  field will be `_deleted-topic_` if the topic has been deleted.
@param push_config [::Google::Cloud::PubSub::V1::PushConfig, ::Hash]
  If push delivery is used with this subscription, this field is
  used to configure it. An empty `pushConfig` signifies that the subscriber
  will pull and ack messages using API methods.
@param ack_deadline_seconds [::Integer]
  The approximate amount of time (on a best-effort basis) Pub/Sub waits for
  the subscriber to acknowledge receipt before resending the message. In the
  interval after the message is delivered and before it is acknowledged, it
  is considered to be <i>outstanding</i>. During that time period, the
  message will not be redelivered (on a best-effort basis).

  For pull subscriptions, this value is used as the initial value for the ack
  deadline. To override this value for a given message, call
  `ModifyAckDeadline` with the corresponding `ack_id` if using
  non-streaming pull or send the `ack_id` in a
  `StreamingModifyAckDeadlineRequest` if using streaming pull.
  The minimum custom deadline you can specify is 10 seconds.
  The maximum custom deadline you can specify is 600 seconds (10 minutes).
  If this parameter is 0, a default value of 10 seconds is used.

  For push delivery, this value is also used to set the request timeout for
  the call to the push endpoint.

  If the subscriber never acknowledges the message, the Pub/Sub
  system will eventually redeliver the message.
@param retain_acked_messages [::Boolean]
  Indicates whether to retain acknowledged messages. If true, then
  messages are not expunged from the subscription's backlog, even if they are
  acknowledged, until they fall out of the `message_retention_duration`
  window. This must be true if you would like to [`Seek` to a timestamp]
  (https://cloud.google.com/pubsub/docs/replay-overview#seek_to_a_time) in
  the past to replay previously-acknowledged messages.
@param message_retention_duration [::Google::Protobuf::Duration, ::Hash]
  How long to retain unacknowledged messages in the subscription's backlog,
  from the moment a message is published.
  If `retain_acked_messages` is true, then this also configures the retention
  of acknowledged messages, and thus configures how far back in time a `Seek`
  can be done. Defaults to 7 days. Cannot be more than 7 days or less than 10
  minutes.
@param labels [::Hash{::String => ::String}]
  See <a href="https://cloud.google.com/pubsub/docs/labels"> Creating and
  managing labels</a>.
@param enable_message_ordering [::Boolean]
  If true, messages published with the same `ordering_key` in `PubsubMessage`
  will be delivered to the subscribers in the order in which they
  are received by the Pub/Sub system. Otherwise, they may be delivered in
  any order.
@param expiration_policy [::Google::Cloud::PubSub::V1::ExpirationPolicy, ::Hash]
  A policy that specifies the conditions for this subscription's expiration.
  A subscription is considered active as long as any connected subscriber is
  successfully consuming messages from the subscription or is issuing
  operations on the subscription. If `expiration_policy` is not set, a
  *default policy* with `ttl` of 31 days will be used. The minimum allowed
  value for `expiration_policy.ttl` is 1 day.
@param filter [::String]
  An expression written in the Pub/Sub [filter
  language](https://cloud.google.com/pubsub/docs/filtering). If non-empty,
  then only `PubsubMessage`s whose `attributes` field matches the filter are
  delivered on this subscription. If empty, then no messages are filtered
  out.
@param dead_letter_policy [::Google::Cloud::PubSub::V1::DeadLetterPolicy, ::Hash]
  A policy that specifies the conditions for dead lettering messages in
  this subscription. If dead_letter_policy is not set, dead lettering
  is disabled.

  The Cloud Pub/Sub service account associated with this subscriptions's
  parent project (i.e.,
  service-\\{project_number}@gcp-sa-pubsub.iam.gserviceaccount.com) must have
  permission to Acknowledge() messages on this subscription.
@param retry_policy [::Google::Cloud::PubSub::V1::RetryPolicy, ::Hash]
  A policy that specifies how Pub/Sub retries message delivery for this
  subscription.

  If not set, the default retry policy is applied. This generally implies
  that messages will be retried as soon as possible for healthy subscribers.
  RetryPolicy will be triggered on NACKs or acknowledgement deadline
  exceeded events for a given message.
@param detached [::Boolean]
  Indicates whether the subscription is detached from its topic. Detached
  subscriptions don't receive messages from their topic and don't retain any
  backlog. `Pull` and `StreamingPull` requests will return
  FAILED_PRECONDITION. If the subscription is a push subscription, pushes to
  the endpoint will not be made.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Google::Cloud::PubSub::V1::Subscription] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Google::Cloud::PubSub::V1::Subscription]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/pubsub/v1/subscriber/client.rb, line 360
def create_subscription request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::PubSub::V1::Subscription

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.create_subscription.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::PubSub::V1::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "name" => request.name
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.create_subscription.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.create_subscription.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @subscriber_stub.call_rpc :create_subscription, request, options: options do |response, operation|
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
delete_snapshot(request, options = nil) { |response, operation| ... } click to toggle source

Removes an existing snapshot. Snapshots are used in [Seek] (cloud.google.com/pubsub/docs/replay-overview) operations, which allow you to manage message acknowledgments in bulk. That is, you can set the acknowledgment state of messages in an existing subscription to the state captured by a snapshot. When the snapshot is deleted, all messages retained in the snapshot are immediately dropped. After a snapshot is deleted, a new one may be created with the same name, but the new one has no association with the old snapshot or its subscription, unless the same subscription is specified.

@overload delete_snapshot(request, options = nil)

Pass arguments to `delete_snapshot` via a request object, either of type
{::Google::Cloud::PubSub::V1::DeleteSnapshotRequest} or an equivalent Hash.

@param request [::Google::Cloud::PubSub::V1::DeleteSnapshotRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload delete_snapshot(snapshot: nil)

Pass arguments to `delete_snapshot` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param snapshot [::String]
  Required. The name of the snapshot to delete.
  Format is `projects/{project}/snapshots/{snap}`.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Google::Protobuf::Empty] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Google::Protobuf::Empty]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/pubsub/v1/subscriber/client.rb, line 1444
def delete_snapshot request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::PubSub::V1::DeleteSnapshotRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.delete_snapshot.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::PubSub::V1::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "snapshot" => request.snapshot
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.delete_snapshot.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.delete_snapshot.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @subscriber_stub.call_rpc :delete_snapshot, request, options: options do |response, operation|
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
delete_subscription(request, options = nil) { |response, operation| ... } click to toggle source

Deletes an existing subscription. All messages retained in the subscription are immediately dropped. Calls to `Pull` after deletion will return `NOT_FOUND`. After a subscription is deleted, a new one may be created with the same name, but the new one has no association with the old subscription or its topic unless the same topic is specified.

@overload delete_subscription(request, options = nil)

Pass arguments to `delete_subscription` via a request object, either of type
{::Google::Cloud::PubSub::V1::DeleteSubscriptionRequest} or an equivalent Hash.

@param request [::Google::Cloud::PubSub::V1::DeleteSubscriptionRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload delete_subscription(subscription: nil)

Pass arguments to `delete_subscription` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param subscription [::String]
  Required. The subscription to delete.
  Format is `projects/{project}/subscriptions/{sub}`.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Google::Protobuf::Empty] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Google::Protobuf::Empty]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/pubsub/v1/subscriber/client.rb, line 650
def delete_subscription request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::PubSub::V1::DeleteSubscriptionRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.delete_subscription.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::PubSub::V1::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "subscription" => request.subscription
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.delete_subscription.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.delete_subscription.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @subscriber_stub.call_rpc :delete_subscription, request, options: options do |response, operation|
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
get_snapshot(request, options = nil) { |response, operation| ... } click to toggle source

Gets the configuration details of a snapshot. Snapshots are used in <a href=“Seekcloud.google.com/pubsub/docs/replay-overview”>Seek> operations, which allow you to manage message acknowledgments in bulk. That is, you can set the acknowledgment state of messages in an existing subscription to the state captured by a snapshot.

@overload get_snapshot(request, options = nil)

Pass arguments to `get_snapshot` via a request object, either of type
{::Google::Cloud::PubSub::V1::GetSnapshotRequest} or an equivalent Hash.

@param request [::Google::Cloud::PubSub::V1::GetSnapshotRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload get_snapshot(snapshot: nil)

Pass arguments to `get_snapshot` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param snapshot [::String]
  Required. The name of the snapshot to get.
  Format is `projects/{project}/snapshots/{snap}`.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Google::Cloud::PubSub::V1::Snapshot] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Google::Cloud::PubSub::V1::Snapshot]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/pubsub/v1/subscriber/client.rb, line 1110
def get_snapshot request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::PubSub::V1::GetSnapshotRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.get_snapshot.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::PubSub::V1::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "snapshot" => request.snapshot
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.get_snapshot.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.get_snapshot.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @subscriber_stub.call_rpc :get_snapshot, request, options: options do |response, operation|
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
get_subscription(request, options = nil) { |response, operation| ... } click to toggle source

Gets the configuration details of a subscription.

@overload get_subscription(request, options = nil)

Pass arguments to `get_subscription` via a request object, either of type
{::Google::Cloud::PubSub::V1::GetSubscriptionRequest} or an equivalent Hash.

@param request [::Google::Cloud::PubSub::V1::GetSubscriptionRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload get_subscription(subscription: nil)

Pass arguments to `get_subscription` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param subscription [::String]
  Required. The name of the subscription to get.
  Format is `projects/{project}/subscriptions/{sub}`.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Google::Cloud::PubSub::V1::Subscription] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Google::Cloud::PubSub::V1::Subscription]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/pubsub/v1/subscriber/client.rb, line 429
def get_subscription request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::PubSub::V1::GetSubscriptionRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.get_subscription.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::PubSub::V1::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "subscription" => request.subscription
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.get_subscription.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.get_subscription.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @subscriber_stub.call_rpc :get_subscription, request, options: options do |response, operation|
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
list_snapshots(request, options = nil) { |response, operation| ... } click to toggle source

Lists the existing snapshots. Snapshots are used in [Seek]( cloud.google.com/pubsub/docs/replay-overview) operations, which allow you to manage message acknowledgments in bulk. That is, you can set the acknowledgment state of messages in an existing subscription to the state captured by a snapshot.

@overload list_snapshots(request, options = nil)

Pass arguments to `list_snapshots` via a request object, either of type
{::Google::Cloud::PubSub::V1::ListSnapshotsRequest} or an equivalent Hash.

@param request [::Google::Cloud::PubSub::V1::ListSnapshotsRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload list_snapshots(project: nil, page_size: nil, page_token: nil)

Pass arguments to `list_snapshots` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param project [::String]
  Required. The name of the project in which to list snapshots.
  Format is `projects/{project-id}`.
@param page_size [::Integer]
  Maximum number of snapshots to return.
@param page_token [::String]
  The value returned by the last `ListSnapshotsResponse`; indicates that this
  is a continuation of a prior `ListSnapshots` call, and that the system
  should return the next page of data.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Gapic::PagedEnumerable<::Google::Cloud::PubSub::V1::Snapshot>] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Gapic::PagedEnumerable<::Google::Cloud::PubSub::V1::Snapshot>]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/pubsub/v1/subscriber/client.rb, line 1189
def list_snapshots request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::PubSub::V1::ListSnapshotsRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.list_snapshots.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::PubSub::V1::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "project" => request.project
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.list_snapshots.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.list_snapshots.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @subscriber_stub.call_rpc :list_snapshots, request, options: options do |response, operation|
    response = ::Gapic::PagedEnumerable.new @subscriber_stub, :list_snapshots, request, response, operation, options
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
list_subscriptions(request, options = nil) { |response, operation| ... } click to toggle source

Lists matching subscriptions.

@overload list_subscriptions(request, options = nil)

Pass arguments to `list_subscriptions` via a request object, either of type
{::Google::Cloud::PubSub::V1::ListSubscriptionsRequest} or an equivalent Hash.

@param request [::Google::Cloud::PubSub::V1::ListSubscriptionsRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload list_subscriptions(project: nil, page_size: nil, page_token: nil)

Pass arguments to `list_subscriptions` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param project [::String]
  Required. The name of the project in which to list subscriptions.
  Format is `projects/{project-id}`.
@param page_size [::Integer]
  Maximum number of subscriptions to return.
@param page_token [::String]
  The value returned by the last `ListSubscriptionsResponse`; indicates that
  this is a continuation of a prior `ListSubscriptions` call, and that the
  system should return the next page of data.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Gapic::PagedEnumerable<::Google::Cloud::PubSub::V1::Subscription>] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Gapic::PagedEnumerable<::Google::Cloud::PubSub::V1::Subscription>]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/pubsub/v1/subscriber/client.rb, line 576
def list_subscriptions request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::PubSub::V1::ListSubscriptionsRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.list_subscriptions.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::PubSub::V1::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "project" => request.project
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.list_subscriptions.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.list_subscriptions.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @subscriber_stub.call_rpc :list_subscriptions, request, options: options do |response, operation|
    response = ::Gapic::PagedEnumerable.new @subscriber_stub, :list_subscriptions, request, response, operation, options
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
modify_ack_deadline(request, options = nil) { |response, operation| ... } click to toggle source

Modifies the ack deadline for a specific message. This method is useful to indicate that more time is needed to process a message by the subscriber, or to make the message available for redelivery if the processing was interrupted. Note that this does not modify the subscription-level `ackDeadlineSeconds` used for subsequent messages.

@overload modify_ack_deadline(request, options = nil)

Pass arguments to `modify_ack_deadline` via a request object, either of type
{::Google::Cloud::PubSub::V1::ModifyAckDeadlineRequest} or an equivalent Hash.

@param request [::Google::Cloud::PubSub::V1::ModifyAckDeadlineRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload modify_ack_deadline(subscription: nil, ack_ids: nil, ack_deadline_seconds: nil)

Pass arguments to `modify_ack_deadline` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param subscription [::String]
  Required. The name of the subscription.
  Format is `projects/{project}/subscriptions/{sub}`.
@param ack_ids [::Array<::String>]
  Required. List of acknowledgment IDs.
@param ack_deadline_seconds [::Integer]
  Required. The new ack deadline with respect to the time this request was
  sent to the Pub/Sub system. For example, if the value is 10, the new ack
  deadline will expire 10 seconds after the `ModifyAckDeadline` call was
  made. Specifying zero might immediately make the message available for
  delivery to another subscriber client. This typically results in an
  increase in the rate of message redeliveries (that is, duplicates).
  The minimum deadline you can specify is 0 seconds.
  The maximum deadline you can specify is 600 seconds (10 minutes).

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Google::Protobuf::Empty] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Google::Protobuf::Empty]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/pubsub/v1/subscriber/client.rb, line 734
def modify_ack_deadline request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::PubSub::V1::ModifyAckDeadlineRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.modify_ack_deadline.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::PubSub::V1::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "subscription" => request.subscription
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.modify_ack_deadline.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.modify_ack_deadline.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @subscriber_stub.call_rpc :modify_ack_deadline, request, options: options do |response, operation|
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
modify_push_config(request, options = nil) { |response, operation| ... } click to toggle source

Modifies the `PushConfig` for a specified subscription.

This may be used to change a push subscription to a pull one (signified by an empty `PushConfig`) or vice versa, or change the endpoint URL and other attributes of a push subscription. Messages will accumulate for delivery continuously through the call regardless of changes to the `PushConfig`.

@overload modify_push_config(request, options = nil)

Pass arguments to `modify_push_config` via a request object, either of type
{::Google::Cloud::PubSub::V1::ModifyPushConfigRequest} or an equivalent Hash.

@param request [::Google::Cloud::PubSub::V1::ModifyPushConfigRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload modify_push_config(subscription: nil, push_config: nil)

Pass arguments to `modify_push_config` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param subscription [::String]
  Required. The name of the subscription.
  Format is `projects/{project}/subscriptions/{sub}`.
@param push_config [::Google::Cloud::PubSub::V1::PushConfig, ::Hash]
  Required. The push configuration for future deliveries.

  An empty `pushConfig` indicates that the Pub/Sub system should
  stop pushing messages from the given subscription and allow
  messages to be pulled and acknowledged - effectively pausing
  the subscription if `Pull` or `StreamingPull` is not called.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Google::Protobuf::Empty] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Google::Protobuf::Empty]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/pubsub/v1/subscriber/client.rb, line 1037
def modify_push_config request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::PubSub::V1::ModifyPushConfigRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.modify_push_config.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::PubSub::V1::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "subscription" => request.subscription
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.modify_push_config.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.modify_push_config.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @subscriber_stub.call_rpc :modify_push_config, request, options: options do |response, operation|
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
pull(request, options = nil) { |response, operation| ... } click to toggle source

Pulls messages from the server. The server may return `UNAVAILABLE` if there are too many concurrent pull requests pending for the given subscription.

@overload pull(request, options = nil)

Pass arguments to `pull` via a request object, either of type
{::Google::Cloud::PubSub::V1::PullRequest} or an equivalent Hash.

@param request [::Google::Cloud::PubSub::V1::PullRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload pull(subscription: nil, return_immediately: nil, max_messages: nil)

Pass arguments to `pull` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param subscription [::String]
  Required. The subscription from which messages should be pulled.
  Format is `projects/{project}/subscriptions/{sub}`.
@param return_immediately [::Boolean]
  Optional. If this field set to true, the system will respond immediately
  even if it there are no messages available to return in the `Pull`
  response. Otherwise, the system may wait (for a bounded amount of time)
  until at least one message is available, rather than returning no messages.
  Warning: setting this field to `true` is discouraged because it adversely
  impacts the performance of `Pull` operations. We recommend that users do
  not set this field.
@param max_messages [::Integer]
  Required. The maximum number of messages to return for this request. Must
  be a positive integer. The Pub/Sub system may return fewer than the number
  specified.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Google::Cloud::PubSub::V1::PullResponse] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Google::Cloud::PubSub::V1::PullResponse]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/pubsub/v1/subscriber/client.rb, line 896
def pull request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::PubSub::V1::PullRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.pull.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::PubSub::V1::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "subscription" => request.subscription
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.pull.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.pull.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @subscriber_stub.call_rpc :pull, request, options: options do |response, operation|
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
seek(request, options = nil) { |response, operation| ... } click to toggle source

Seeks an existing subscription to a point in time or to a given snapshot, whichever is provided in the request. Snapshots are used in [Seek] (cloud.google.com/pubsub/docs/replay-overview) operations, which allow you to manage message acknowledgments in bulk. That is, you can set the acknowledgment state of messages in an existing subscription to the state captured by a snapshot. Note that both the subscription and the snapshot must be on the same topic.

@overload seek(request, options = nil)

Pass arguments to `seek` via a request object, either of type
{::Google::Cloud::PubSub::V1::SeekRequest} or an equivalent Hash.

@param request [::Google::Cloud::PubSub::V1::SeekRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload seek(subscription: nil, time: nil, snapshot: nil)

Pass arguments to `seek` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param subscription [::String]
  Required. The subscription to affect.
@param time [::Google::Protobuf::Timestamp, ::Hash]
  The time to seek to.
  Messages retained in the subscription that were published before this
  time are marked as acknowledged, and messages retained in the
  subscription that were published after this time are marked as
  unacknowledged. Note that this operation affects only those messages
  retained in the subscription (configured by the combination of
  `message_retention_duration` and `retain_acked_messages`). For example,
  if `time` corresponds to a point before the message retention
  window (or to a point before the system's notion of the subscription
  creation time), only retained messages will be marked as unacknowledged,
  and already-expunged messages will not be restored.
@param snapshot [::String]
  The snapshot to seek to. The snapshot's topic must be the same as that of
  the provided subscription.
  Format is `projects/{project}/snapshots/{snap}`.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Google::Cloud::PubSub::V1::SeekResponse] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Google::Cloud::PubSub::V1::SeekResponse]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/pubsub/v1/subscriber/client.rb, line 1534
def seek request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::PubSub::V1::SeekRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.seek.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::PubSub::V1::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "subscription" => request.subscription
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.seek.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.seek.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @subscriber_stub.call_rpc :seek, request, options: options do |response, operation|
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
streaming_pull(request, options = nil) { |response, operation| ... } click to toggle source

Establishes a stream with the server, which sends messages down to the client. The client streams acknowledgements and ack deadline modifications back to the server. The server will close the stream and return the status on any error. The server may close the stream with status `UNAVAILABLE` to reassign server-side resources, in which case, the client should re-establish the stream. Flow control can be achieved by configuring the underlying RPC channel.

@param request [::Gapic::StreamInput, ::Enumerable<::Google::Cloud::PubSub::V1::StreamingPullRequest, ::Hash>]

An enumerable of {::Google::Cloud::PubSub::V1::StreamingPullRequest} instances.

@param options [::Gapic::CallOptions, ::Hash]

Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Enumerable<::Google::Cloud::PubSub::V1::StreamingPullResponse>] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Enumerable<::Google::Cloud::PubSub::V1::StreamingPullResponse>]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/pubsub/v1/subscriber/client.rb, line 957
def streaming_pull request, options = nil
  unless request.is_a? ::Enumerable
    raise ::ArgumentError, "request must be an Enumerable" unless request.respond_to? :to_enum
    request = request.to_enum
  end

  request = request.lazy.map do |req|
    ::Gapic::Protobuf.coerce req, to: ::Google::Cloud::PubSub::V1::StreamingPullRequest
  end

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.streaming_pull.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::PubSub::V1::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  options.apply_defaults timeout:      @config.rpcs.streaming_pull.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.streaming_pull.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @subscriber_stub.call_rpc :streaming_pull, request, options: options do |response, operation|
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
update_snapshot(request, options = nil) { |response, operation| ... } click to toggle source

Updates an existing snapshot. Snapshots are used in <a href=“Seekcloud.google.com/pubsub/docs/replay-overview”>Seek> operations, which allow you to manage message acknowledgments in bulk. That is, you can set the acknowledgment state of messages in an existing subscription to the state captured by a snapshot.

@overload update_snapshot(request, options = nil)

Pass arguments to `update_snapshot` via a request object, either of type
{::Google::Cloud::PubSub::V1::UpdateSnapshotRequest} or an equivalent Hash.

@param request [::Google::Cloud::PubSub::V1::UpdateSnapshotRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload update_snapshot(snapshot: nil, update_mask: nil)

Pass arguments to `update_snapshot` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param snapshot [::Google::Cloud::PubSub::V1::Snapshot, ::Hash]
  Required. The updated snapshot object.
@param update_mask [::Google::Protobuf::FieldMask, ::Hash]
  Required. Indicates which fields in the provided snapshot to update.
  Must be specified and non-empty.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Google::Cloud::PubSub::V1::Snapshot] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Google::Cloud::PubSub::V1::Snapshot]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/pubsub/v1/subscriber/client.rb, line 1367
def update_snapshot request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::PubSub::V1::UpdateSnapshotRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.update_snapshot.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::PubSub::V1::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "snapshot.name" => request.snapshot.name
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.update_snapshot.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.update_snapshot.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @subscriber_stub.call_rpc :update_snapshot, request, options: options do |response, operation|
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
update_subscription(request, options = nil) { |response, operation| ... } click to toggle source

Updates an existing subscription. Note that certain properties of a subscription, such as its topic, are not modifiable.

@overload update_subscription(request, options = nil)

Pass arguments to `update_subscription` via a request object, either of type
{::Google::Cloud::PubSub::V1::UpdateSubscriptionRequest} or an equivalent Hash.

@param request [::Google::Cloud::PubSub::V1::UpdateSubscriptionRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload update_subscription(subscription: nil, update_mask: nil)

Pass arguments to `update_subscription` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param subscription [::Google::Cloud::PubSub::V1::Subscription, ::Hash]
  Required. The updated subscription object.
@param update_mask [::Google::Protobuf::FieldMask, ::Hash]
  Required. Indicates which fields in the provided subscription to update.
  Must be specified and non-empty.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Google::Cloud::PubSub::V1::Subscription] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Google::Cloud::PubSub::V1::Subscription]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/pubsub/v1/subscriber/client.rb, line 501
def update_subscription request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::PubSub::V1::UpdateSubscriptionRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.update_subscription.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::PubSub::V1::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "subscription.name" => request.subscription.name
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.update_subscription.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.update_subscription.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @subscriber_stub.call_rpc :update_subscription, request, options: options do |response, operation|
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end