google-cloud-pubsub 1.9.0

data/lib/google/cloud/pubsub/received_message.rb

@@ -0,0 +1,297 @@
+# Copyright 2015 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+require "google/cloud/errors"
+require "google/cloud/pubsub/message"
+
+module Google
+  module Cloud
+    module PubSub
+      ##
+      # # ReceivedMessage
+      #
+      # Represents a Pub/Sub {Message} that can be acknowledged or delayed.
+      #
+      # @example
+      #   require "google/cloud/pubsub"
+      #
+      #   pubsub = Google::Cloud::PubSub.new
+      #
+      #   sub = pubsub.subscription "my-topic-sub"
+      #   subscriber = sub.listen do |received_message|
+      #     puts received_message.message.data
+      #     received_message.acknowledge!
+      #   end
+      #
+      #   # Start background threads that will call the block passed to listen.
+      #   subscriber.start
+      #
+      #   # Shut down the subscriber when ready to stop receiving messages.
+      #   subscriber.stop.wait!
+      #
+      class ReceivedMessage
+        ##
+        # @private The {Subscription} object.
+        attr_accessor :subscription
+
+        ##
+        # @private The gRPC Google::Cloud::PubSub::V1::ReceivedMessage object.
+        attr_accessor :grpc
+
+        ##
+        # @private Create an empty {Subscription} object.
+        def initialize
+          @subscription = nil
+          @grpc = Google::Cloud::PubSub::V1::ReceivedMessage.new
+        end
+
+        ##
+        # The acknowledgment ID for the message.
+        def ack_id
+          @grpc.ack_id
+        end
+
+        ##
+        # Returns the delivery attempt counter for the message. If a dead letter policy is not set on the subscription,
+        # this will be `nil`. See {Topic#subscribe}, {Subscription#dead_letter_topic=} and
+        # {Subscription#dead_letter_max_delivery_attempts=}.
+        #
+        # The delivery attempt counter is `1 + (the sum of number of NACKs and number of ack_deadline exceeds)` for the
+        # message.
+        #
+        # A NACK is any call to `ModifyAckDeadline` with a `0` deadline. An `ack_deadline` exceeds event is whenever a
+        # message is not acknowledged within `ack_deadline`. Note that `ack_deadline` is initially
+        # `Subscription.ackDeadlineSeconds`, but may get extended automatically by the client library.
+        #
+        # The first delivery of a given message will have this value as `1`. The value is calculated at best effort and
+        # is approximate.
+        #
+        # @return [Integer, nil] A delivery attempt value of `1` or greater, or `nil` if a dead letter policy is not set
+        #   on the subscription.
+        #
+        # @example
+        #   require "google/cloud/pubsub"
+        #
+        #   pubsub = Google::Cloud::PubSub.new
+        #
+        #   topic = pubsub.topic "my-topic"
+        #   dead_letter_topic = pubsub.topic "my-dead-letter-topic", skip_lookup: true
+        #   sub = topic.subscribe "my-topic-sub",
+        #                         dead_letter_topic: dead_letter_topic,
+        #                         dead_letter_max_delivery_attempts: 10
+        #
+        #   subscriber = sub.listen do |received_message|
+        #     puts received_message.message.delivery_attempt
+        #   end
+        #
+        def delivery_attempt
+          return nil if @grpc.delivery_attempt && @grpc.delivery_attempt < 1
+          @grpc.delivery_attempt
+        end
+
+        ##
+        # The received message.
+        def message
+          Message.from_grpc @grpc.message
+        end
+        alias msg message
+
+        ##
+        # The received message payload. This data is a list of bytes encoded as
+        # ASCII-8BIT.
+        def data
+          message.data
+        end
+
+        ##
+        # Optional attributes for the received message.
+        def attributes
+          message.attributes
+        end
+
+        ##
+        # The ID of the received message, assigned by the server at publication
+        # time. Guaranteed to be unique within the topic.
+        def message_id
+          message.message_id
+        end
+        alias msg_id message_id
+
+        ##
+        # Identifies related messages for which publish order should be
+        # respected.
+        #
+        # Google Cloud Pub/Sub ordering keys provide the ability to ensure
+        # related messages are sent to subscribers in the order in which they
+        # were published. Messages can be tagged with an ordering key, a string
+        # that identifies related messages for which publish order should be
+        # respected. The service guarantees that, for a given ordering key and
+        # publisher, messages are sent to subscribers in the order in which they
+        # were published. Ordering does not require sacrificing high throughput
+        # or scalability, as the service automatically distributes messages for
+        # different ordering keys across subscribers.
+        #
+        # See {Topic#publish_async} and {Subscription#listen}.
+        #
+        # @return [String]
+        #
+        def ordering_key
+          message.ordering_key
+        end
+
+        ##
+        # The time at which the message was published.
+        def published_at
+          message.published_at
+        end
+        alias publish_time published_at
+
+        ##
+        # Acknowledges receipt of the message.
+        #
+        # @example
+        #   require "google/cloud/pubsub"
+        #
+        #   pubsub = Google::Cloud::PubSub.new
+        #
+        #   sub = pubsub.subscription "my-topic-sub"
+        #   subscriber = sub.listen do |received_message|
+        #     puts received_message.message.data
+        #
+        #     received_message.acknowledge!
+        #   end
+        #
+        #   # Start background threads that will call block passed to listen.
+        #   subscriber.start
+        #
+        #   # Shut down the subscriber when ready to stop receiving messages.
+        #   subscriber.stop.wait!
+        #
+        def acknowledge!
+          ensure_subscription!
+          subscription.acknowledge ack_id
+        end
+        alias ack! acknowledge!
+
+        ##
+        # Modifies the acknowledge deadline for the message.
+        #
+        # This indicates that more time is needed to process the message, or to
+        # make the message available for redelivery.
+        #
+        # @param [Integer] new_deadline The new ack deadline in seconds from the
+        #   time this request is sent to the Pub/Sub system. Must be >= 0. For
+        #   example, if the value is `10`, the new ack deadline will expire 10
+        #   seconds after the call is made. Specifying `0` may immediately make
+        #   the message available for another pull request.
+        #
+        # @example
+        #   require "google/cloud/pubsub"
+        #
+        #   pubsub = Google::Cloud::PubSub.new
+        #
+        #   sub = pubsub.subscription "my-topic-sub"
+        #   subscriber = sub.listen do |received_message|
+        #     puts received_message.message.data
+        #
+        #     # Delay for 2 minutes
+        #     received_message.modify_ack_deadline! 120
+        #   end
+        #
+        #   # Start background threads that will call block passed to listen.
+        #   subscriber.start
+        #
+        #   # Shut down the subscriber when ready to stop receiving messages.
+        #   subscriber.stop.wait!
+        #
+        def modify_ack_deadline! new_deadline
+          ensure_subscription!
+          subscription.modify_ack_deadline new_deadline, ack_id
+        end
+
+        ##
+        # Resets the acknowledge deadline for the message without acknowledging
+        # it.
+        #
+        # This will make the message available for redelivery.
+        #
+        # @example
+        #   require "google/cloud/pubsub"
+        #
+        #   pubsub = Google::Cloud::PubSub.new
+        #
+        #   sub = pubsub.subscription "my-topic-sub"
+        #   subscriber = sub.listen do |received_message|
+        #     puts received_message.message.data
+        #
+        #     # Release message back to the API.
+        #     received_message.reject!
+        #   end
+        #
+        #   # Start background threads that will call block passed to listen.
+        #   subscriber.start
+        #
+        #   # Shut down the subscriber when ready to stop receiving messages.
+        #   subscriber.stop.wait!
+        #
+        def reject!
+          modify_ack_deadline! 0
+        end
+        alias nack! reject!
+        alias ignore! reject!
+
+        # @private
+        def hash
+          @grpc.hash
+        end
+
+        # @private
+        def eql? other
+          return false unless other.is_a? self.class
+          @grpc.hash == other.hash
+        end
+        # @private
+        alias == eql?
+
+        # @private
+        def <=> other
+          return nil unless other.is_a? self.class
+          other_grpc = other.instance_variable_get :@grpc
+          @grpc <=> other_grpc
+        end
+
+        ##
+        # @private New ReceivedMessage from a
+        # Google::Cloud::PubSub::V1::ReceivedMessage object.
+        def self.from_grpc grpc, subscription
+          new.tap do |rm|
+            rm.grpc         = grpc
+            rm.subscription = subscription
+          end
+        end
+
+        protected
+
+        ##
+        # Raise an error unless an active subscription is available.
+        def ensure_subscription!
+          raise "Must have active subscription" unless subscription
+        end
+      end
+    end
+
+    Pubsub = PubSub unless const_defined? :Pubsub
+  end
+end

data/lib/google/cloud/pubsub/retry_policy.rb

@@ -0,0 +1,90 @@
+# Copyright 2016 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+require "google/cloud/errors"
+
+module Google
+  module Cloud
+    module PubSub
+      ##
+      # # RetryPolicy
+      #
+      # An immutable Retry Policy value object that specifies how Cloud Pub/Sub retries message delivery.
+      #
+      # Retry delay will be exponential based on provided minimum and maximum backoffs. (See [Exponential
+      # backoff](https://en.wikipedia.org/wiki/Exponential_backoff).)
+      #
+      # Retry Policy will be triggered on NACKs or acknowledgement deadline exceeded events for a given message.
+      #
+      # Retry Policy is implemented on a best effort basis. At times, the delay between consecutive deliveries may not
+      # match the configuration. That is, delay can be more or less than configured backoff.
+      #
+      # **EXPERIMENTAL:** This API might be changed in backward-incompatible ways and is not recommended for production
+      # use. It is not subject to any SLA or deprecation policy.
+      #
+      # @attr [Numeric] minimum_backoff The minimum delay between consecutive deliveries of a given message. Value
+      #   should be between 0 and 600 seconds. The default value is 10 seconds.
+      # @attr [Numeric] maximum_backoff The maximum delay between consecutive deliveries of a given message. Value
+      #   should be between 0 and 600 seconds. The default value is 600 seconds.
+      #
+      # @example
+      #   require "google/cloud/pubsub"
+      #
+      #   pubsub = Google::Cloud::PubSub.new
+      #
+      #   sub = pubsub.subscription "my-topic-sub"
+      #
+      #   sub.retry_policy = Google::Cloud::PubSub::RetryPolicy.new minimum_backoff: 5, maximum_backoff: 300
+      #
+      #   sub.retry_policy.minimum_backoff #=> 5
+      #   sub.retry_policy.maximum_backoff #=> 300
+      #
+      class RetryPolicy
+        attr_reader :minimum_backoff, :maximum_backoff
+
+        ##
+        # Creates a new, immutable RetryPolicy value object.
+        #
+        # @attr [Numeric, nil] minimum_backoff The minimum delay between consecutive deliveries of a given message.
+        #   Value should be between 0 and 600 seconds. If `nil` is provided, the default value is 10 seconds.
+        # @attr [Numeric, nil] maximum_backoff The maximum delay between consecutive deliveries of a given message.
+        #   Value should be between 0 and 600 seconds. If `nil` is provided, the default value is 600 seconds.
+        #
+        def initialize minimum_backoff: nil, maximum_backoff: nil
+          @minimum_backoff = minimum_backoff
+          @maximum_backoff = maximum_backoff
+        end
+
+        ##
+        # @private Convert the RetryPolicy to a Google::Cloud::PubSub::V1::RetryPolicy object.
+        def to_grpc
+          Google::Cloud::PubSub::V1::RetryPolicy.new(
+            minimum_backoff: Convert.number_to_duration(minimum_backoff),
+            maximum_backoff: Convert.number_to_duration(maximum_backoff)
+          )
+        end
+
+        ##
+        # @private New RetryPolicy from a Google::Cloud::PubSub::V1::RetryPolicy object.
+        def self.from_grpc grpc
+          new(
+            minimum_backoff: Convert.duration_to_number(grpc.minimum_backoff),
+            maximum_backoff: Convert.duration_to_number(grpc.maximum_backoff)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/google/cloud/pubsub/service.rb

@@ -0,0 +1,514 @@
+# Copyright 2016 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+require "google/cloud/errors"
+require "google/cloud/pubsub/credentials"
+require "google/cloud/pubsub/convert"
+require "google/cloud/pubsub/version"
+require "google/cloud/pubsub/v1"
+require "google/gax/errors"
+require "securerandom"
+
+module Google
+  module Cloud
+    module PubSub
+      ##
+      # @private Represents the GAX Pub/Sub service, including all the API
+      # methods.
+      class Service
+        attr_accessor :project, :credentials, :host, :timeout, :client_config
+        ###
+        # The same client_id is used across all streaming pull connections that are created by this client. This is
+        # intentional, as it indicates to the server that any guarantees, such as message ordering, made for a stream
+        # that is disconnected will be made for the stream that is created to replace it. The attr_accessor allows the
+        # value to be replaced for unit testing.
+        attr_accessor :client_id
+
+        ##
+        # Creates a new Service instance.
+        def initialize project, credentials, host: nil, timeout: nil,
+                       client_config: nil
+          @project = project
+          @credentials = credentials
+          @host = host || V1::PublisherClient::SERVICE_ADDRESS
+          @timeout = timeout
+          @client_config = client_config || {}
+          @client_id = SecureRandom.uuid.freeze
+        end
+
+        def channel
+          require "grpc"
+          GRPC::Core::Channel.new host, chan_args, chan_creds
+        end
+
+        def chan_args
+          { "grpc.max_send_message_length"           => -1,
+            "grpc.max_receive_message_length"        => -1,
+            "grpc.keepalive_time_ms"                 => 300_000,
+            "grpc.service_config_disable_resolution" => 1 }
+        end
+
+        def chan_creds
+          return credentials if insecure?
+          require "grpc"
+          GRPC::Core::ChannelCredentials.new.compose GRPC::Core::CallCredentials.new credentials.client.updater_proc
+        end
+
+        def subscriber
+          return mocked_subscriber if mocked_subscriber
+          @subscriber ||= begin
+            V1::SubscriberClient.new(
+              credentials:   channel,
+              timeout:       timeout,
+              client_config: client_config,
+              lib_name:      "gccl",
+              lib_version:   Google::Cloud::PubSub::VERSION
+            )
+          end
+        end
+        attr_accessor :mocked_subscriber
+
+        def publisher
+          return mocked_publisher if mocked_publisher
+          @publisher ||= begin
+            V1::PublisherClient.new(
+              credentials:   channel,
+              timeout:       timeout,
+              client_config: client_config,
+              lib_name:      "gccl",
+              lib_version:   Google::Cloud::PubSub::VERSION
+            )
+          end
+        end
+        attr_accessor :mocked_publisher
+
+        def insecure?
+          credentials == :this_channel_is_insecure
+        end
+
+        ##
+        # Gets the configuration of a topic.
+        # Since the topic only has the name attribute,
+        # this method is only useful to check the existence of a topic.
+        # If other attributes are added in the future,
+        # they will be returned here.
+        def get_topic topic_name, options = {}
+          execute do
+            publisher.get_topic topic_path(topic_name, options),
+                                options: default_options
+          end
+        end
+
+        ##
+        # Lists matching topics.
+        def list_topics options = {}
+          call_options = default_options
+          if (token = options[:token])
+            call_options = Google::Gax::CallOptions.new(
+              kwargs:     default_headers,
+              page_token: token
+            )
+          end
+
+          execute do
+            paged_enum = publisher.list_topics project_path(options),
+                                               page_size: options[:max],
+                                               options:   call_options
+
+            paged_enum.page.response
+          end
+        end
+
+        ##
+        # Creates the given topic with the given name.
+        def create_topic topic_name, labels: nil, kms_key_name: nil, persistence_regions: nil, options: {}
+          if persistence_regions
+            message_storage_policy = {
+              allowed_persistence_regions: Array(persistence_regions)
+            }
+          end
+
+          execute do
+            publisher.create_topic \
+              topic_path(topic_name, options),
+              labels:                 labels,
+              kms_key_name:           kms_key_name,
+              message_storage_policy: message_storage_policy,
+              options:                default_options
+          end
+        end
+
+        def update_topic topic_obj, *fields
+          mask = Google::Protobuf::FieldMask.new paths: fields.map(&:to_s)
+          execute do
+            publisher.update_topic topic_obj, mask, options: default_options
+          end
+        end
+
+        ##
+        # Deletes the topic with the given name. All subscriptions to this topic
+        # are also deleted. Raises GRPC status code 5 if the topic does not
+        # exist. After a topic is deleted, a new topic may be created with the
+        # same name.
+        def delete_topic topic_name
+          execute do
+            publisher.delete_topic topic_path(topic_name),
+                                   options: default_options
+          end
+        end
+
+        ##
+        # Adds one or more messages to the topic.
+        # Raises GRPC status code 5 if the topic does not exist.
+        # The messages parameter is an array of arrays.
+        # The first element is the data, second is attributes hash.
+        def publish topic, messages
+          execute do
+            publisher.publish topic_path(topic), messages,
+                              options: default_options
+          end
+        end
+
+        ##
+        # Gets the details of a subscription.
+        def get_subscription subscription_name, options = {}
+          subscription = subscription_path subscription_name, options
+          execute do
+            subscriber.get_subscription subscription, options: default_options
+          end
+        end
+
+        ##
+        # Lists matching subscriptions by project and topic.
+        def list_topics_subscriptions topic, options = {}
+          call_options = default_options
+          if (token = options[:token])
+            call_options = Google::Gax::CallOptions.new(
+              kwargs:     default_headers,
+              page_token: token
+            )
+          end
+
+          execute do
+            paged_enum = publisher.list_topic_subscriptions \
+              topic_path(topic, options),
+              page_size: options[:max],
+              options:   call_options
+
+            paged_enum.page.response
+          end
+        end
+
+        ##
+        # Lists matching subscriptions by project.
+        def list_subscriptions options = {}
+          call_options = default_options
+          if (token = options[:token])
+            call_options = Google::Gax::CallOptions.new(
+              kwargs:     default_headers,
+              page_token: token
+            )
+          end
+
+          execute do
+            paged_enum = subscriber.list_subscriptions project_path(options),
+                                                       page_size: options[:max],
+                                                       options:   call_options
+
+            paged_enum.page.response
+          end
+        end
+
+        ##
+        # Creates a subscription on a given topic for a given subscriber.
+        def create_subscription topic, subscription_name, options = {}
+          name = subscription_path subscription_name, options
+          topic = topic_path topic
+          push_config = if options[:endpoint]
+                          Google::Cloud::PubSub::V1::PushConfig.new \
+                            push_endpoint: options[:endpoint],
+                            attributes:    (options[:attributes] || {}).to_h
+                        end
+          mrd = Convert.number_to_duration options[:retention]
+          execute do
+            subscriber.create_subscription \
+              name, topic,
+              push_config:                push_config,
+              ack_deadline_seconds:       options[:deadline],
+              retain_acked_messages:      options[:retain_acked],
+              message_retention_duration: mrd,
+              labels:                     options[:labels],
+              enable_message_ordering:    options[:message_ordering],
+              filter:                     options[:filter],
+              dead_letter_policy:         dead_letter_policy(options),
+              retry_policy:               options[:retry_policy],
+              options:                    default_options
+          end
+        end
+
+        def update_subscription subscription_obj, *fields
+          mask = Google::Protobuf::FieldMask.new paths: fields.map(&:to_s)
+          execute do
+            subscriber.update_subscription subscription_obj, mask, options: default_options
+          end
+        end
+
+        ##
+        # Deletes an existing subscription.
+        # All pending messages in the subscription are immediately dropped.
+        def delete_subscription subscription
+          execute do
+            subscriber.delete_subscription subscription_path(subscription),
+                                           options: default_options
+          end
+        end
+
+        ##
+        # Pulls a single message from the server.
+        def pull subscription, options = {}
+          subscription = subscription_path subscription, options
+          max_messages = options.fetch(:max, 100).to_i
+          return_immediately = !(!options.fetch(:immediate, true))
+
+          execute do
+            subscriber.pull subscription,
+                            max_messages,
+                            return_immediately: return_immediately,
+                            options:            default_options
+          end
+        end
+
+        def streaming_pull request_enum
+          execute do
+            subscriber.streaming_pull request_enum, options: default_options
+          end
+        end
+
+        ##
+        # Acknowledges receipt of a message.
+        def acknowledge subscription, *ack_ids
+          execute do
+            subscriber.acknowledge subscription_path(subscription), ack_ids,
+                                   options: default_options
+          end
+        end
+
+        ##
+        # Modifies the PushConfig for a specified subscription.
+        def modify_push_config subscription, endpoint, attributes
+          subscription = subscription_path subscription
+          # Convert attributes to strings to match the protobuf definition
+          attributes = Hash[attributes.map { |k, v| [String(k), String(v)] }]
+          push_config = Google::Cloud::PubSub::V1::PushConfig.new(
+            push_endpoint: endpoint,
+            attributes:    attributes
+          )
+
+          execute do
+            subscriber.modify_push_config subscription, push_config,
+                                          options: default_options
+          end
+        end
+
+        ##
+        # Modifies the ack deadline for a specific message.
+        def modify_ack_deadline subscription, ids, deadline
+          execute do
+            subscriber.modify_ack_deadline subscription_path(subscription),
+                                           Array(ids),
+                                           deadline, options: default_options
+          end
+        end
+
+        ##
+        # Lists snapshots by project.
+        def list_snapshots options = {}
+          call_options = default_options
+          if (token = options[:token])
+            call_options = Google::Gax::CallOptions.new(
+              kwargs:     default_headers,
+              page_token: token
+            )
+          end
+
+          execute do
+            paged_enum = subscriber.list_snapshots project_path(options),
+                                                   page_size: options[:max],
+                                                   options:   call_options
+
+            paged_enum.page.response
+          end
+        end
+
+        ##
+        # Creates a snapshot on a given subscription.
+        def create_snapshot subscription, snapshot_name, labels: nil
+          name = snapshot_path snapshot_name
+          execute do
+            subscriber.create_snapshot name,
+                                       subscription_path(subscription),
+                                       labels:  labels,
+                                       options: default_options
+          end
+        end
+
+        def update_snapshot snapshot_obj, *fields
+          mask = Google::Protobuf::FieldMask.new paths: fields.map(&:to_s)
+          execute do
+            subscriber.update_snapshot snapshot_obj, mask, options: default_options
+          end
+        end
+
+        ##
+        # Deletes an existing snapshot.
+        # All pending messages in the snapshot are immediately dropped.
+        def delete_snapshot snapshot
+          execute do
+            subscriber.delete_snapshot snapshot_path(snapshot),
+                                       options: default_options
+          end
+        end
+
+        ##
+        # Adjusts the given subscription to a time or snapshot.
+        def seek subscription, time_or_snapshot
+          subscription = subscription_path subscription
+          execute do
+            if a_time? time_or_snapshot
+              time = Convert.time_to_timestamp time_or_snapshot
+              subscriber.seek subscription, time: time, options: default_options
+            else
+              time_or_snapshot = time_or_snapshot.name if time_or_snapshot.is_a? Snapshot
+              subscriber.seek subscription,
+                              snapshot: snapshot_path(time_or_snapshot),
+                              options:  default_options
+            end
+          end
+        end
+
+        def get_topic_policy topic_name, options = {}
+          execute do
+            publisher.get_iam_policy topic_path(topic_name, options),
+                                     options: default_options
+          end
+        end
+
+        def set_topic_policy topic_name, new_policy, options = {}
+          resource = topic_path topic_name, options
+
+          execute do
+            publisher.set_iam_policy resource, new_policy,
+                                     options: default_options
+          end
+        end
+
+        def test_topic_permissions topic_name, permissions, options = {}
+          resource = topic_path topic_name, options
+
+          execute do
+            publisher.test_iam_permissions resource, permissions,
+                                           options: default_options
+          end
+        end
+
+        def get_subscription_policy subscription_name, options = {}
+          resource = subscription_path subscription_name, options
+
+          execute do
+            subscriber.get_iam_policy resource, options: default_options
+          end
+        end
+
+        def set_subscription_policy subscription_name, new_policy, options = {}
+          resource = subscription_path subscription_name, options
+
+          execute do
+            subscriber.set_iam_policy resource, new_policy,
+                                      options: default_options
+          end
+        end
+
+        def test_subscription_permissions subscription_name,
+                                          permissions, options = {}
+          resource = subscription_path subscription_name, options
+
+          execute do
+            subscriber.test_iam_permissions resource, permissions,
+                                            options: default_options
+          end
+        end
+
+        def project_path options = {}
+          project_name = options[:project] || project
+          "projects/#{project_name}"
+        end
+
+        def topic_path topic_name, options = {}
+          return topic_name if topic_name.to_s.include? "/"
+          "#{project_path options}/topics/#{topic_name}"
+        end
+
+        def subscription_path subscription_name, options = {}
+          return subscription_name if subscription_name.to_s.include? "/"
+          "#{project_path options}/subscriptions/#{subscription_name}"
+        end
+
+        def snapshot_path snapshot_name, options = {}
+          return snapshot_name if snapshot_name.nil? || snapshot_name.to_s.include?("/")
+          "#{project_path options}/snapshots/#{snapshot_name}"
+        end
+
+        def inspect
+          "#<#{self.class.name} (#{@project})>"
+        end
+
+        protected
+
+        def a_time? obj
+          return false unless obj.respond_to? :to_time
+          # Rails' String#to_time returns nil if the string doesn't parse.
+          return false if obj.to_time.nil?
+          true
+        end
+
+        def dead_letter_policy options
+          return nil unless options[:dead_letter_topic_name]
+          policy = Google::Cloud::PubSub::V1::DeadLetterPolicy.new dead_letter_topic: options[:dead_letter_topic_name]
+          if options[:dead_letter_max_delivery_attempts]
+            policy.max_delivery_attempts = options[:dead_letter_max_delivery_attempts]
+          end
+          policy
+        end
+
+        def default_headers
+          { "google-cloud-resource-prefix" => "projects/#{@project}" }
+        end
+
+        def default_options
+          Google::Gax::CallOptions.new kwargs: default_headers
+        end
+
+        def execute
+          yield
+        rescue Google::Gax::GaxError => e
+          # GaxError wraps BadStatus, but exposes it as #cause
+          raise Google::Cloud::Error.from_error(e.cause)
+        end
+      end
+    end
+
+    Pubsub = PubSub unless const_defined? :Pubsub
+  end
+end