google-cloud-pubsub 1.0.2 → 1.1.0

data/lib/google/cloud/pubsub/subscriber/stream.rb

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 
+require "google/cloud/pubsub/subscriber/sequencer"
 require "google/cloud/pubsub/subscriber/enumerator_queue"
 require "google/cloud/pubsub/subscriber/inventory"
 require "google/cloud/pubsub/service"
@@ -34,9 +35,17 @@ module Google
           attr_reader :callback_thread_pool
 
           ##
-          # Subscriber attributes.
+          # @private Subscriber attributes.
           attr_reader :subscriber
 
+          ##
+          # @private Inventory.
+          attr_reader :inventory
+
+          ##
+          # @private Sequencer.
+          attr_reader :sequencer
+
           ##
           # @private Create an empty Subscriber::Stream object.
           def initialize subscriber
@@ -48,16 +57,16 @@ module Google
             @pause_cond = new_cond
 
             @inventory = Inventory.new self, @subscriber.stream_inventory
-            @callback_thread_pool = Concurrent::ThreadPoolExecutor.new \
-              max_threads: @subscriber.callback_threads
+
+            @sequencer = Sequencer.new(&method(:perform_callback_async)) if subscriber.message_ordering
+
+            @callback_thread_pool = Concurrent::ThreadPoolExecutor.new max_threads: @subscriber.callback_threads
 
             @stream_keepalive_task = Concurrent::TimerTask.new(
               execution_interval: 30
             ) do
               # push empty request every 30 seconds to keep stream alive
-              unless inventory.empty?
-                push Google::Cloud::PubSub::V1::StreamingPullRequest.new
-              end
+              push Google::Cloud::PubSub::V1::StreamingPullRequest.new unless inventory.empty?
             end.execute
 
             super() # to init MonitorMixin
@@ -81,7 +90,7 @@ module Google
 
               # Close the stream by pushing the sentinel value.
               # The unary pusher does not use the stream, so it can close here.
-              @request_queue.push self unless @request_queue.nil?
+              @request_queue&.push self
 
               # Signal to the background thread that we are stopped.
               @stopped = true
@@ -107,6 +116,10 @@ module Google
             synchronize { @paused }
           end
 
+          def running?
+            !stopped?
+          end
+
           def wait! timeout = nil
             # Wait for all queued callbacks to be processed.
             @callback_thread_pool.wait_for_termination timeout
@@ -162,10 +175,6 @@ module Google
             synchronize { @request_queue.push request }
           end
 
-          def inventory
-            synchronize { @inventory }
-          end
-
           ##
           # @private
           def renew_lease!
@@ -182,8 +191,8 @@ module Google
 
           # @private
           def to_s
-            "(inventory: #{@inventory.count}, " \
-              "status: #{status}, thread: #{thread_status})"
+            seq_str = "sequenced: #{sequencer}, " if sequencer
+            "(inventory: #{@inventory.count}, #{seq_str}status: #{status}, thread: #{thread_status})"
           end
 
           # @private
@@ -237,6 +246,7 @@ module Google
                 # Create a list of all the received ack_id values
                 received_ack_ids = response.received_messages.map(&:ack_id)
 
+                # Use synchronize so both changes happen atomically
                 synchronize do
                   # Create receipt of received messages reception
                   @subscriber.buffer.modify_ack_deadline @subscriber.deadline,
@@ -248,10 +258,8 @@ module Google
 
                 response.received_messages.each do |rec_msg_grpc|
                   rec_msg = ReceivedMessage.from_grpc(rec_msg_grpc, self)
-                  synchronize do
-                    # Call user provided code for received message
-                    perform_callback_async rec_msg
-                  end
+                  # No need to synchronize the callback future
+                  register_callback rec_msg
                 end
                 synchronize { pause_streaming! }
               rescue StopIteration
@@ -282,18 +290,35 @@ module Google
 
           # rubocop:enable all
 
+          def register_callback rec_msg
+            if @sequencer
+              # Add the message to the sequencer to invoke the callback.
+              @sequencer.add rec_msg
+            else
+              # Call user provided code for received message
+              perform_callback_async rec_msg
+            end
+          end
+
           def perform_callback_async rec_msg
             return unless callback_thread_pool.running?
 
             Concurrent::Promises.future_on(
-              callback_thread_pool, self, rec_msg
-            ) do |stream, msg|
+              callback_thread_pool, rec_msg, &method(:perform_callback_sync)
+            )
+          end
+
+          def perform_callback_sync rec_msg
+            @subscriber.callback.call rec_msg unless stopped?
+          rescue StandardError => e
+            @subscriber.error! e
+          ensure
+            release rec_msg
+            if @sequencer && running?
               begin
-                stream.subscriber.callback.call msg unless stream.stopped?
-              rescue StandardError => callback_error
-                stream.subscriber.error! callback_error
-              ensure
-                stream.release msg
+                @sequencer.next rec_msg
+              rescue OrderedMessageDeliveryError => e
+                @subscriber.error! e
               end
             end
           end
@@ -341,8 +366,7 @@ module Google
               req.subscription = @subscriber.subscription_name
               req.stream_ack_deadline_seconds = @subscriber.deadline
               req.modify_deadline_ack_ids += @inventory.ack_ids
-              req.modify_deadline_seconds += \
-                @inventory.ack_ids.map { @subscriber.deadline }
+              req.modify_deadline_seconds += @inventory.ack_ids.map { @subscriber.deadline }
             end
           end
 

data/lib/google/cloud/pubsub/subscriber/timed_unary_buffer.rb

@@ -27,7 +27,7 @@ module Google
 
           attr_reader :max_bytes, :interval
 
-          def initialize subscriber, max_bytes: 500000, interval: 1.0
+          def initialize subscriber, max_bytes: 500_000, interval: 1.0
             super() # to init MonitorMixin
 
             @subscriber = subscriber
@@ -91,15 +91,13 @@ module Google
             with_threadpool do |pool|
               requests[:acknowledge].each do |ack_req|
                 add_future pool do
-                  @subscriber.service.acknowledge \
-                    ack_req.subscription, *ack_req.ack_ids
+                  @subscriber.service.acknowledge ack_req.subscription, *ack_req.ack_ids
                 end
               end
               requests[:modify_ack_deadline].each do |mod_ack_req|
                 add_future pool do
-                  @subscriber.service.modify_ack_deadline \
-                    mod_ack_req.subscription, mod_ack_req.ack_ids,
-                    mod_ack_req.ack_deadline_seconds
+                  @subscriber.service.modify_ack_deadline mod_ack_req.subscription, mod_ack_req.ack_ids,
+                                                          mod_ack_req.ack_deadline_seconds
                 end
               end
             end
@@ -144,9 +142,7 @@ module Google
 
             requests = { acknowledge: [] }
             ack_ids = Array(req_hash.delete(:ack)) # ack has no deadline set
-            if ack_ids.any?
-              requests[:acknowledge] = create_acknowledge_requests ack_ids
-            end
+            requests[:acknowledge] = create_acknowledge_requests ack_ids if ack_ids.any?
             requests[:modify_ack_deadline] =
               req_hash.map do |mod_deadline, mod_ack_ids|
                 create_modify_ack_deadline_requests mod_deadline, mod_ack_ids
@@ -201,8 +197,7 @@ module Google
           end
 
           def with_threadpool
-            pool = Concurrent::ThreadPoolExecutor.new \
-              max_threads: @subscriber.push_threads
+            pool = Concurrent::ThreadPoolExecutor.new max_threads: @subscriber.push_threads
 
             yield pool
 
@@ -213,8 +208,8 @@ module Google
             pool.kill
             begin
               raise "Timeout making subscriber API calls"
-            rescue StandardError => error
-              error! error
+            rescue StandardError => e
+              error! e
             end
           end
 
@@ -222,8 +217,8 @@ module Google
             Concurrent::Promises.future_on pool do
               begin
                 yield
-              rescue StandardError => error
-                error! error
+              rescue StandardError => e
+                error! e
               end
             end
           end

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

@@ -117,10 +117,8 @@ module Google
         # @param [Integer] new_deadline The new deadline value.
         #
         def deadline= new_deadline
-          update_grpc = Google::Cloud::PubSub::V1::Subscription.new \
-            name: name, ack_deadline_seconds: new_deadline
-          @grpc = service.update_subscription update_grpc,
-                                              :ack_deadline_seconds
+          update_grpc = Google::Cloud::PubSub::V1::Subscription.new name: name, ack_deadline_seconds: new_deadline
+          @grpc = service.update_subscription update_grpc, :ack_deadline_seconds
           @resource_name = nil
         end
 
@@ -148,10 +146,9 @@ module Google
         #   value.
         #
         def retain_acked= new_retain_acked
-          update_grpc = Google::Cloud::PubSub::V1::Subscription.new \
-            name: name, retain_acked_messages: !(!new_retain_acked)
-          @grpc = service.update_subscription update_grpc,
-                                              :retain_acked_messages
+          update_grpc = Google::Cloud::PubSub::V1::Subscription.new name:                  name,
+                                                                    retain_acked_messages: !(!new_retain_acked)
+          @grpc = service.update_subscription update_grpc, :retain_acked_messages
           @resource_name = nil
         end
 
@@ -181,10 +178,9 @@ module Google
         #
         def retention= new_retention
           new_retention_duration = Convert.number_to_duration new_retention
-          update_grpc = Google::Cloud::PubSub::V1::Subscription.new \
-            name: name, message_retention_duration: new_retention_duration
-          @grpc = service.update_subscription update_grpc,
-                                              :message_retention_duration
+          update_grpc = Google::Cloud::PubSub::V1::Subscription.new name:                       name,
+                                                                    message_retention_duration: new_retention_duration
+          @grpc = service.update_subscription update_grpc, :message_retention_duration
           @resource_name = nil
         end
 
@@ -200,7 +196,7 @@ module Google
         #
         def endpoint
           ensure_grpc!
-          @grpc.push_config.push_endpoint if @grpc.push_config
+          @grpc.push_config&.push_endpoint
         end
 
         ##
@@ -271,8 +267,7 @@ module Google
             new_config = config.to_grpc
 
             if old_config != new_config # has the object been changed?
-              update_grpc = Google::Cloud::PubSub::V1::Subscription.new \
-                name: name, push_config: new_config
+              update_grpc = Google::Cloud::PubSub::V1::Subscription.new name: name, push_config: new_config
               @grpc = service.update_subscription update_grpc, :push_config
             end
           end
@@ -312,8 +307,7 @@ module Google
         #
         def labels= new_labels
           raise ArgumentError, "Value must be a Hash" if new_labels.nil?
-          update_grpc = Google::Cloud::PubSub::V1::Subscription.new \
-            name: name, labels: new_labels
+          update_grpc = Google::Cloud::PubSub::V1::Subscription.new name: name, labels: new_labels
           @grpc = service.update_subscription update_grpc, :labels
           @resource_name = nil
         end
@@ -350,16 +344,34 @@ module Google
         #   to unset.
         #
         def expires_in= ttl
-          new_expiration_policy = Google::Pubsub::V1::ExpirationPolicy.new(
-            ttl: Convert.number_to_duration(ttl)
-          )
+          new_expiration_policy = Google::Pubsub::V1::ExpirationPolicy.new ttl: Convert.number_to_duration(ttl)
 
-          update_grpc = Google::Cloud::PubSub::V1::Subscription.new \
-            name: name, expiration_policy: new_expiration_policy
+          update_grpc = Google::Cloud::PubSub::V1::Subscription.new name: name, expiration_policy: new_expiration_policy
           @grpc = service.update_subscription update_grpc, :expiration_policy
           @resource_name = nil
         end
 
+        ##
+        # Whether message ordering has been enabled. When enabled, messages
+        # published with the same `ordering_key` will be delivered in the order
+        # they were published. When disabled, messages may be delivered in any
+        # order.
+        #
+        # @note At the time of this release, ordering keys are not yet publicly
+        #   enabled and requires special project enablements.
+        #
+        # See {Topic#publish_async}, {#listen}, and {Message#ordering_key}.
+        #
+        # Makes an API call to retrieve the retain_acked value when called on a
+        # reference object. See {#reference?}.
+        #
+        # @return [Boolean]
+        #
+        def message_ordering?
+          ensure_grpc!
+          @grpc.enable_message_ordering
+        end
+
         ##
         # Determines whether the subscription exists in the Pub/Sub service.
         #
@@ -508,13 +520,40 @@ module Google
         # message will be removed from the subscriber and made available for
         # redelivery after the callback is completed.
         #
+        # 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.
+        #
+        # To use ordering keys, the subscription must be created with message
+        # ordering enabled (See {Topic#subscribe} and {#message_ordering?})
+        # before calling {#listen}. When enabled, the subscriber will deliver
+        # messages with the same `ordering_key` in the order they were
+        # published.
+        #
+        # @note At the time of this release, ordering keys are not yet publicly
+        #   enabled and requires special project enablements.
+        #
         # @param [Numeric] deadline The default number of seconds the stream
         #   will hold received messages before modifying the message's ack
         #   deadline. The minimum is 10, the maximum is 600. Default is
         #   {#deadline}. Optional.
         #
-        #   Makes an API call to retrieve the deadline value when called on a
-        #   reference object. See {#reference?}.
+        #   When using a reference object an API call will be made to retrieve
+        #   the default deadline value for the subscription when this argument
+        #   is not provided. See {#reference?}.
+        # @param [Boolean] message_ordering Whether message ordering has been
+        #   enabled. The value provided must match the value set on the Pub/Sub
+        #   service. See {#message_ordering?}. Optional.
+        #
+        #   When using a reference object an API call will be made to retrieve
+        #   the default message_ordering value for the subscription when this
+        #   argument is not provided. See {#reference?}.
         # @param [Integer] streams The number of concurrent streams to open to
         #   pull messages from the subscription. Default is 4. Optional.
         # @param [Integer] inventory The number of received messages to be
@@ -571,14 +610,36 @@ module Google
         #   # Start background threads that will call block passed to listen.
         #   subscriber.start
         #
-        def listen deadline: nil, streams: nil, inventory: nil, threads: {},
-                   &block
+        #   # Shut down the subscriber when ready to stop receiving messages.
+        #   subscriber.stop.wait!
+        #
+        # @example Ordered messages are supported using ordering_key:
+        #   require "google/cloud/pubsub"
+        #
+        #   pubsub = Google::Cloud::PubSub.new
+        #
+        #   sub = pubsub.subscription "my-ordered-topic-sub"
+        #   sub.message_ordering? #=> true
+        #
+        #   subscriber = sub.listen do |received_message|
+        #     # messsages with the same ordering_key are received
+        #     # in the order in which they were published.
+        #     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 listen deadline: nil, message_ordering: nil, streams: nil, inventory: nil, threads: {}, &block
           ensure_service!
           deadline ||= self.deadline
+          message_ordering = message_ordering? if message_ordering.nil?
 
-          Subscriber.new name, block, deadline: deadline, streams: streams,
-                                      inventory: inventory, threads: threads,
-                                      service: service
+          Subscriber.new name, block, deadline: deadline, streams: streams, inventory: inventory,
+                                      message_ordering: message_ordering, threads: threads, service: service
         end
 
         ##

data/lib/google/cloud/pubsub/subscription/list.rb

@@ -132,15 +132,13 @@ module Google
           #
           def all request_limit: nil
             request_limit = request_limit.to_i if request_limit
-            unless block_given?
-              return enum_for :all, request_limit: request_limit
-            end
+            return enum_for :all, request_limit: request_limit unless block_given?
             results = self
             loop do
               results.each { |r| yield r }
               if request_limit
                 request_limit -= 1
-                break if request_limit < 0
+                break if request_limit.negative?
               end
               break unless results.next?
               results = results.next

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

@@ -126,8 +126,7 @@ module Google
         #
         def labels= new_labels
           raise ArgumentError, "Value must be a Hash" if new_labels.nil?
-          update_grpc = Google::Cloud::PubSub::V1::Topic.new \
-            name: name, labels: new_labels
+          update_grpc = Google::Cloud::PubSub::V1::Topic.new name: name, labels: new_labels
           @grpc = service.update_topic update_grpc, :labels
           @resource_name = nil
         end
@@ -176,8 +175,7 @@ module Google
         #   topic.kms_key = key_name
         #
         def kms_key= new_kms_key_name
-          update_grpc = Google::Cloud::PubSub::V1::Topic.new \
-            name: name, kms_key_name: new_kms_key_name
+          update_grpc = Google::Cloud::PubSub::V1::Topic.new name: name, kms_key_name: new_kms_key_name
           @grpc = service.update_topic update_grpc, :kms_key_name
           @resource_name = nil
         end
@@ -229,9 +227,7 @@ module Google
         #
         def persistence_regions= new_persistence_regions
           update_grpc = Google::Cloud::PubSub::V1::Topic.new \
-            name: name, message_storage_policy: {
-              allowed_persistence_regions: Array(new_persistence_regions)
-            }
+            name: name, message_storage_policy: { allowed_persistence_regions: Array(new_persistence_regions) }
           @grpc = service.update_topic update_grpc, :message_storage_policy
           @resource_name = nil
         end
@@ -287,6 +283,8 @@ module Google
         #   values are optional. Label keys must start with a letter and each
         #   label in the list must have a different key. See [Creating and
         #   Managing Labels](https://cloud.google.com/pubsub/docs/labels).
+        # @param [Boolean] message_ordering Whether to enable message ordering
+        #   on the subscription.
         #
         # @return [Google::Cloud::PubSub::Subscription]
         #
@@ -309,11 +307,11 @@ module Google
         #                         deadline: 120,
         #                         endpoint: "https://example.com/push"
         #
-        def subscribe subscription_name, deadline: nil, retain_acked: false,
-                      retention: nil, endpoint: nil, labels: nil
+        def subscribe subscription_name, deadline: nil, retain_acked: false, retention: nil, endpoint: nil, labels: nil,
+                      message_ordering: nil
           ensure_service!
-          options = { deadline: deadline, retain_acked: retain_acked,
-                      retention: retention, endpoint: endpoint, labels: labels }
+          options = { deadline: deadline, retain_acked: retain_acked, retention: retention, endpoint: endpoint,
+                      labels: labels, message_ordering: message_ordering }
           grpc = service.create_subscription name, subscription_name, options
           Subscription.from_grpc grpc, service
         end
@@ -355,9 +353,7 @@ module Google
         #
         def subscription subscription_name, skip_lookup: nil
           ensure_service!
-          if skip_lookup
-            return Subscription.from_name subscription_name, service
-          end
+          return Subscription.from_name subscription_name, service if skip_lookup
           grpc = service.get_subscription subscription_name
           Subscription.from_grpc grpc, service
         rescue Google::Cloud::NotFoundError
@@ -473,17 +469,48 @@ module Google
         end
 
         ##
-        # Publishes a message asynchronously to the topic.
+        # Publishes a message asynchronously to the topic using
+        # {#async_publisher}.
         #
         # The message payload must not be empty; it must contain either a
         # non-empty data field, or at least one attribute.
         #
+        # 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.
+        #
+        # To use ordering keys, specify `ordering_key`. Before specifying
+        # `ordering_key` on a message a call to `#enable_message_ordering!` must
+        # be made or an error will be raised.
+        #
+        # @note At the time of this release, ordering keys are not yet publicly
+        #   enabled and requires special project enablements.
+        #
         # @param [String, File] data The message payload. This will be converted
         #   to bytes encoded as ASCII-8BIT.
         # @param [Hash] attributes Optional attributes for the message.
+        # @param [String] ordering_key Identifies related messages for which
+        #   publish order should be respected.
         # @yield [result] the callback for when the message has been published
         # @yieldparam [PublishResult] result the result of the asynchronous
         #   publish
+        # @raise [Google::Cloud::PubSub::AsyncPublisherStopped] when the
+        #   publisher is stopped. (See {AsyncPublisher#stop} and
+        #   {AsyncPublisher#stopped?}.)
+        # @raise [Google::Cloud::PubSub::OrderedMessagesDisabled] when
+        #   publishing a message with an `ordering_key` but ordered messages are
+        #   not enabled. (See {#message_ordering?} and
+        #   {#enable_message_ordering!}.)
+        # @raise [Google::Cloud::PubSub::OrderingKeyError] when publishing a
+        #   message with an `ordering_key` that has already failed when
+        #   publishing. Use {#resume_publish} to allow this `ordering_key` to be
+        #   published again.
         #
         # @example
         #   require "google/cloud/pubsub"
@@ -499,6 +526,7 @@ module Google
         #     end
         #   end
         #
+        #   # Shut down the publisher when ready to stop publishing messages.
         #   topic.async_publisher.stop.wait!
         #
         # @example A message can be published using a File object:
@@ -510,6 +538,7 @@ module Google
         #   file = File.open "message.txt", mode: "rb"
         #   topic.publish_async file
         #
+        #   # Shut down the publisher when ready to stop publishing messages.
         #   topic.async_publisher.stop.wait!
         #
         # @example Additionally, a message can be published with attributes:
@@ -521,13 +550,76 @@ module Google
         #   topic.publish_async "task completed",
         #                       foo: :bar, this: :that
         #
+        #   # Shut down the publisher when ready to stop publishing messages.
         #   topic.async_publisher.stop.wait!
         #
-        def publish_async data = nil, attributes = {}, &block
+        # @example Ordered messages are supported using ordering_key:
+        #   require "google/cloud/pubsub"
+        #
+        #   pubsub = Google::Cloud::PubSub.new
+        #
+        #   topic = pubsub.topic "my-ordered-topic"
+        #
+        #   # Ensure that message ordering is enabled.
+        #   topic.enable_message_ordering!
+        #
+        #   # Publish an ordered message with an ordering key.
+        #   topic.publish_async "task completed",
+        #                       ordering_key: "task-key"
+        #
+        #   # Shut down the publisher when ready to stop publishing messages.
+        #   topic.async_publisher.stop.wait!
+        #
+        def publish_async data = nil, attributes = nil, ordering_key: nil, **extra_attrs, &callback
           ensure_service!
 
           @async_publisher ||= AsyncPublisher.new name, service, @async_opts
-          @async_publisher.publish data, attributes, &block
+          @async_publisher.publish data, attributes, ordering_key: ordering_key, **extra_attrs, &callback
+        end
+
+        ##
+        # Enables message ordering for messages with ordering keys on the
+        # {#async_publisher}. When enabled, messages published with the same
+        # `ordering_key` will be delivered in the order they were published.
+        #
+        # @note At the time of this release, ordering keys are not yet publicly
+        #   enabled and requires special project enablements.
+        #
+        # See {#message_ordering?}.  See {#publish_async},
+        # {Subscription#listen}, and {Message#ordering_key}.
+        #
+        def enable_message_ordering!
+          @async_publisher ||= AsyncPublisher.new name, service, @async_opts
+          @async_publisher.enable_message_ordering!
+        end
+
+        ##
+        # Whether message ordering for messages with ordering keys has been
+        # enabled on the {#async_publisher}. When enabled, messages published
+        # with the same `ordering_key` will be delivered in the order they were
+        # published. When disabled, messages may be delivered in any order.
+        #
+        # See {#enable_message_ordering!}. See {#publish_async},
+        # {Subscription#listen}, and {Message#ordering_key}.
+        #
+        # @return [Boolean]
+        #
+        def message_ordering?
+          @async_publisher ||= AsyncPublisher.new name, service, @async_opts
+          @async_publisher.message_ordering?
+        end
+
+        ##
+        # Resume publishing ordered messages for the provided ordering key.
+        #
+        # @param [String] ordering_key Identifies related messages for which
+        #   publish order should be respected.
+        #
+        # @return [boolean] `true` when resumed, `false` otherwise.
+        #
+        def resume_publish ordering_key
+          @async_publisher ||= AsyncPublisher.new name, service, @async_opts
+          @async_publisher.resume_publish ordering_key
         end
 
         ##