ably-pubsub-core 0.0.1.pre → 2.0.0

data/lib/ably/pubsub/realtime/channel.rb

@@ -0,0 +1,545 @@
+require 'ably/pubsub/realtime/channel/publisher'
+
+module Ably
+  module PubSub
+    module Realtime
+      # Enables messages to be published and subscribed to. Also enables historic messages to be retrieved and provides
+      # access to the {Ably::PubSub::Realtime::Channel} object of a channel.
+      #
+      # Channels will always be in one of the following states:
+      #
+      #   initialized: 0
+      #   attaching:   1
+      #   attached:    2
+      #   detaching:   3
+      #   detached:    4
+      #   failed:      5
+      #
+      # Note that the states are available as Enum-like constants:
+      #
+      #   Channel::STATE.Initialized  The channel has been initialized but no attach has yet been attempted.
+      #   Channel::STATE.Attaching    An attach has been initiated by sending a request to Ably.
+      #                               This is a transient state, followed either by a transition to ATTACHED, SUSPENDED, or FAILED.
+      #   Channel::STATE.Attached     The attach has succeeded. In the ATTACHED state a client may publish and subscribe to messages, or be present on the channel.
+      #   Channel::STATE.Detaching    A detach has been initiated on an ATTACHED channel by sending a request to Ably.
+      #                               This is a transient state, followed either by a transition to DETACHED or FAILED.
+      #   Channel::STATE.Detached     The channel, having previously been ATTACHED, has been detached by the user.
+      #   Channel::STATE.Suspended    The channel, having previously been ATTACHED, has lost continuity, usually due to
+      #                               the client being disconnected from Ably for longer than two minutes. It will automatically attempt to reattach as soon as connectivity is restored.
+      #   Channel::STATE.Failed       An indefinite failure condition. This state is entered if a channel error
+      #                               has been received from the Ably service, such as an attempt to attach without the necessary access rights.
+      #
+      class Channel
+        include Ably::Modules::Conversions
+        include Ably::Modules::EventEmitter
+        include Ably::Modules::EventMachineHelpers
+        include Ably::Modules::AsyncWrapper
+        include Ably::Modules::MessageEmitter
+        include Ably::PubSub::Realtime::Channel::Publisher
+        extend Ably::Modules::Enum
+        extend Forwardable
+
+        # The current {Abbly::Realtime::Channel::STATE} of the channel.
+        #
+        # @spec RTL2b
+        #
+        # The permitted states for this channel
+        STATE = ruby_enum('STATE',
+          :initialized,
+          :attaching,
+          :attached,
+          :detaching,
+          :detached,
+          :suspended,
+          :failed
+        )
+
+        # Describes the events emitted by a {Ably::PubSub::Http::Channel} or {Ably::PubSub::Realtime::Channel} object.
+        # An event is either an UPDATE or a {Ably::PubSub::Http::Channel::STATE}.
+        #
+        # The permitted channel events that are emitted for this channel
+        #
+        # @spec RTL2g
+        #
+        EVENT = ruby_enum('EVENT',
+          STATE.to_sym_arr + [:update]
+        )
+
+        include Ably::Modules::StateEmitter
+        include Ably::Modules::UsesStateMachine
+        ensure_state_machine_emits 'Ably::Models::ChannelStateChange'
+
+        # Max number of messages to bundle in a single ProtocolMessage
+        MAX_PROTOCOL_MESSAGE_BATCH_SIZE = 50
+
+        # {Ably::PubSub::Realtime::Client} associated with this channel
+        #
+        # @return [Ably::PubSub::Realtime::Client]
+        #
+        # @api private
+        attr_reader :client
+
+        # The channel name.
+        # @return [String]
+        attr_reader :name
+
+        # A {Ably::PubSub::Realtime::Channel::PushChannel} object.
+        #
+        # @return [Ably::PubSub::Realtime::Channel::PushChannel]
+        attr_reader :push
+
+        # Channel options configured for this channel, see {#initialize} for channel_options
+        # @return [Hash]
+        attr_reader :options
+
+        # A {Ably::PubSub::Realtime::Channel::ChannelProperties} object.
+        #
+        # @spec CP1, RTL15
+        #
+        # @return [{Ably::PubSub::Realtime::Channel::ChannelProperties}]
+        attr_reader :properties
+
+        # An {Ably::Models::ErrorInfo} object describing the last error which occurred on the channel, if any.
+        # @spec RTL4e
+        # @return [Ably::Models::ErrorInfo,Ably::Exceptions::BaseAblyException]
+        attr_reader :error_reason
+
+        # The Channel manager responsible for attaching, detaching and handling failures for this channel
+        # @return [Ably::PubSub::Realtime::Channel::ChannelManager]
+        # @api private
+        attr_reader :manager
+
+        # Flag that specifies whether channel is resuming attachment(reattach) or is doing a 'clean attach' RTL4j1
+        # @return [Boolean]
+        # @api private
+        attr_reader :attach_resume
+
+        # Optional channel parameters that configure the behavior of the channel.
+        # @spec RTL4k1
+        # return [Hash]
+        def_delegators :options, :params
+
+        # Initialize a new Channel object
+        #
+        # @param  client [Ably::PubSub::Http::Client]
+        # @param  name [String] The name of the channel
+        # @param  channel_options [Hash, Ably::Models::ChannelOptions]     A hash of options or a {Ably::Models::ChannelOptions}
+        #
+        def initialize(client, name, channel_options = {})
+          name = ensure_utf_8(:name, name)
+
+          @options       = Ably::Models::ChannelOptions(channel_options)
+          @client        = client
+          @name          = name
+          @queue         = []
+
+          @state_machine = ChannelStateMachine.new(self)
+          @state         = STATE(state_machine.current_state)
+          @manager       = ChannelManager.new(self, client.connection)
+          @push          = PushChannel.new(self)
+          @properties    = ChannelProperties.new(self)
+          @attach_resume = false
+
+          setup_event_handlers
+          setup_presence
+        end
+
+        # Publish a message to the channel. A callback may optionally be passed in to this call to be notified of success
+        # or failure of the operation. When publish is called with this client library, it won't attempt to implicitly
+        # attach to the channel.
+        #
+        # @spec RTL6i
+        #
+        # @param name [String, Array<Ably::Models::Message|Hash>, nil]   The event name of the message to publish, or an Array of [Ably::Model::Message] objects or [Hash] objects with +:name+ and +:data+ pairs
+        # @param data [String, ByteArray, nil]   The message payload unless an Array of [Ably::Model::Message] objects passed in the first argument
+        # @param attributes [Hash, nil]   Optional additional message attributes such as :client_id or :connection_id, applied when name attribute is nil or a string
+        #
+        # @yield [Ably::Models::Message,Array<Ably::Models::Message>] On success, will call the block with the {Ably::Models::Message} if a single message is published, or an Array of {Ably::Models::Message} when multiple messages are published
+        # @return [Ably::Util::SafeDeferrable] Deferrable that supports both success (callback) and failure (errback) callbacks
+        #
+        # @example
+        #   # Publish a single message form
+        #   channel.publish 'click', { x: 1, y: 2 }
+        #
+        #   # Publish a single message with single Hash form
+        #   message = { name: 'click', data: { x: 1, y: 2 } }
+        #   channel.publish message
+        #
+        #   # Publish an array of message Hashes form
+        #   messages = [
+        #     { name: 'click', data: { x: 1, y: 2 } },
+        #     { name: 'click', data: { x: 2, y: 3 } }
+        #   ]
+        #   channel.publish messages
+        #
+        #   # Publish an array of Ably::Models::Message objects form
+        #   messages = [
+        #     Ably::Models::Message(name: 'click', data: { x: 1, y: 2 })
+        #     Ably::Models::Message(name: 'click', data: { x: 2, y: 3 })
+        #   ]
+        #   channel.publish messages
+        #
+        #   # Publish an array of Ably::Models::Message objects form
+        #   message = Ably::Models::Message(name: 'click', data: { x: 1, y: 2 })
+        #   channel.publish message
+        #
+        #   channel.publish('click', 'body') do |message|
+        #     puts "#{message.name} event received with #{message.data}"
+        #   end
+        #
+        #   channel.publish('click', 'body').errback do |error, message|
+        #     puts "#{message.name} was not received, error #{error.message}"
+        #   end
+        #
+        def publish(name, data = nil, attributes = {}, &success_block)
+          if suspended? || failed?
+            error = Ably::Exceptions::ChannelInactive.new("Cannot publish messages on a channel in state #{state}")
+            return Ably::Util::SafeDeferrable.new_and_fail_immediately(logger, error)
+          end
+
+          if !connection.can_publish_messages?
+            error = Ably::Exceptions::MessageQueueingDisabled.new("Message cannot be published. Client is not allowed to queue messages when connection is in state #{connection.state}")
+            return Ably::Util::SafeDeferrable.new_and_fail_immediately(logger, error)
+          end
+
+          messages = build_messages(name, data, attributes) # (RSL1a, RSL1b)
+
+          if messages.length > Realtime::Connection::MAX_PROTOCOL_MESSAGE_BATCH_SIZE
+            error = Ably::Exceptions::InvalidRequest.new("It is not possible to publish more than #{Realtime::Connection::MAX_PROTOCOL_MESSAGE_BATCH_SIZE} messages with a single publish request.")
+            return Ably::Util::SafeDeferrable.new_and_fail_immediately(logger, error)
+          end
+
+          enqueue_messages_on_connection(client, messages, channel_name, options).tap do |deferrable|
+            deferrable.callback(&success_block) if block_given?
+          end
+        end
+
+        # Updates a previously published message on the channel. A callback may optionally be passed in to this
+        # call to be notified of success or failure of the operation.
+        #
+        # @spec RTL32
+        #
+        # @param message [Ably::Models::Message, Hash] A Message object or Hash containing a populated :serial field
+        #   and the fields to update.
+        # @param operation [Hash, Ably::Models::MessageOperation, nil] Optional operation metadata.
+        # @param params [Hash, nil] Optional parameters sent as part of the protocol message.
+        #
+        # @yield [Ably::Models::UpdateDeleteResult] On success, calls the block with the result containing version_serial.
+        # @return [Ably::Util::SafeDeferrable] Deferrable that supports both success (callback) and failure (errback) callbacks
+        #
+        def update_message(message, operation = nil, params = {}, &success_block)
+          send_message_action(message, Ably::Models::Message::ACTION.MessageUpdate, operation, params, &success_block)
+        end
+
+        # Deletes a previously published message on the channel. A callback may optionally be passed in to this
+        # call to be notified of success or failure of the operation.
+        #
+        # @spec RTL32
+        #
+        # @param message [Ably::Models::Message, Hash] A Message object or Hash containing a populated :serial field.
+        # @param operation [Hash, Ably::Models::MessageOperation, nil] Optional operation metadata.
+        # @param params [Hash, nil] Optional parameters sent as part of the protocol message.
+        #
+        # @yield [Ably::Models::UpdateDeleteResult] On success, calls the block with the result containing version_serial.
+        # @return [Ably::Util::SafeDeferrable] Deferrable that supports both success (callback) and failure (errback) callbacks
+        #
+        def delete_message(message, operation = nil, params = {}, &success_block)
+          send_message_action(message, Ably::Models::Message::ACTION.MessageDelete, operation, params, &success_block)
+        end
+
+        # Appends data to a previously published message on the channel. A callback may optionally be passed in to this
+        # call to be notified of success or failure of the operation.
+        #
+        # @spec RTL32
+        #
+        # @param message [Ably::Models::Message, Hash] A Message object or Hash containing a populated :serial field
+        #   and the data to append.
+        # @param operation [Hash, Ably::Models::MessageOperation, nil] Optional operation metadata.
+        # @param params [Hash, nil] Optional parameters sent as part of the protocol message.
+        #
+        # @yield [Ably::Models::UpdateDeleteResult] On success, calls the block with the result containing version_serial.
+        # @return [Ably::Util::SafeDeferrable] Deferrable that supports both success (callback) and failure (errback) callbacks
+        #
+        def append_message(message, operation = nil, params = {}, &success_block)
+          send_message_action(message, Ably::Models::Message::ACTION.MessageAppend, operation, params, &success_block)
+        end
+
+        # Registers a listener for messages on this channel. The caller supplies a listener function, which is called
+        # each time one or more messages arrives on the channel. A callback may optionally be passed in to this call
+        # to be notified of success or failure of the channel {Ably::PubSub::Realtime::Channel#attach} operation.
+        #
+        # @spec RTL7a
+        #
+        # @param names [String] The event name of the message to subscribe to if provided.  Defaults to all events.
+        # @yield [Ably::Models::Message] For each message received, the block is called
+        #
+        # @return [void]
+        #
+        def subscribe(*names, &callback)
+          attach unless attached? || attaching?
+          super
+        end
+
+        # Deregisters the given listener for the specified event name(s). This removes an earlier event-specific subscription.
+        #
+        # @spec RTL8a
+        #
+        # @param names [String] The event name of the message to subscribe to if provided.  Defaults to all events.
+        #
+        # @return [void]
+        #
+        def unsubscribe(*names, &callback)
+          super
+        end
+
+        # Attach to this channel ensuring the channel is created in the Ably system and all messages published on
+        # the channel are received by any channel listeners registered using {Ably::PubSub::Realtime::Channel#subscribe}.
+        # Any resulting channel state change will be emitted to any listeners registered using the {Ably::Modules::EventEmitter#on}
+        # or {Ably::Modules::EventEmitter#once} methods. A callback may optionally be passed in to this call to be notified
+        # of success or failure of the operation. As a convenience, attach() is called implicitly
+        # if {Ably::PubSub::Realtime::Channel#subscribe} for the channel is called, or {Ably::PubSub::Realtime::Presence#enter}
+        # or {Ably::PubSub::Realtime::Presence#subscribe} are called on the {Ably::PubSub::Realtime::Presence} object for this channel.
+        #
+        # @spec RTL4d
+        #
+        # @yield [Ably::PubSub::Realtime::Channel] Block is called as soon as this channel is in the Attached state
+        # @return [Ably::Util::SafeDeferrable] Deferrable that supports both success (callback) and failure (errback) callback
+        #
+        def attach(&success_block)
+          if connection.closing? || connection.closed? || connection.suspended? || connection.failed?
+            error = Ably::Exceptions::InvalidStateChange.new("Cannot ATTACH channel when the connection is in a closed, suspended or failed state. Connection state: #{connection.state}")
+            return Ably::Util::SafeDeferrable.new_and_fail_immediately(logger, error)
+          end
+
+          if !attached?
+            if detaching?
+              # Let the pending operation complete (#RTL4h)
+              once_state_changed { transition_state_machine :attaching if can_transition_to?(:attaching) }
+            else
+              transition_state_machine :attaching if can_transition_to?(:attaching)
+            end
+          end
+
+          deferrable_for_state_change_to(STATE.Attached, &success_block)
+        end
+
+        # Detach from this channel. Any resulting channel state change is emitted to any listeners registered using
+        # the {Ably::Modules::EventEmitter#on} or {Ably::Modules::EventEmitter#once} methods. A callback may optionally
+        # be passed in to this call to be notified of success or failure of the operation. Once all clients globally
+        # have detached from the channel, the channel will be released in the Ably service within two minutes.
+        #
+        # @spec RTL5e
+        #
+        # @yield [Ably::PubSub::Realtime::Channel] Block is called as soon as this channel is in the Detached or Failed state
+        # @return [Ably::Util::SafeDeferrable] Deferrable that supports both success (callback) and failure (errback) callback
+        #
+        def detach(&success_block)
+          if initialized?
+            success_block.call if block_given?
+            return Ably::Util::SafeDeferrable.new_and_succeed_immediately(logger)
+          end
+
+          if failed? || connection.closing? || connection.failed?
+            return Ably::Util::SafeDeferrable.new_and_fail_immediately(logger, exception_for_state_change_to(:detaching))
+          end
+
+          if !detached?
+            if attaching?
+              # Let the pending operation complete (#RTL5i)
+              once_state_changed { transition_state_machine :detaching if can_transition_to?(:detaching) }
+            elsif can_transition_to?(:detaching)
+              transition_state_machine :detaching
+            else
+              transition_state_machine! :detached
+            end
+          end
+
+          deferrable_for_state_change_to(STATE.Detached, &success_block)
+        end
+
+        # A {Ably::PubSub::Realtime::Presence} object.
+        #
+        # @spec RTL9
+        #
+        # @return {Ably::PubSub::Realtime::Presence}
+        #
+        def presence
+          @presence
+        end
+
+        # Retrieves a {Ably::Models::PaginatedResult} object, containing an array of historical
+        # {Ably::Models::Message} objects for the channel. If the channel is configured to persist messages,
+        # then messages can be retrieved from history for up to 72 hours in the past. If not, messages can only
+        # be retrieved from history for up to two minutes in the past.
+        #
+        # @spec RSL2a
+        #
+        # @param (see {Ably::PubSub::Http::Channel#history})
+        # @option options (see {Ably::PubSub::Http::Channel#history})
+        # @option options [Boolean]  :until_attach  When true, the history request will be limited only to messages published before this channel was attached. Channel must be attached
+        #
+        # @yield [Ably::Models::PaginatedResult<Ably::Models::Message>] First {Ably::Models::PaginatedResult page} of {Ably::Models::Message} objects accessible with {Ably::Models::PaginatedResult#items #items}.
+        #
+        # @return [Ably::Util::SafeDeferrable]
+        #
+        def history(options = {}, &callback)
+          # RTL10b
+          if options.delete(:until_attach)
+            unless attached?
+              error = Ably::Exceptions::InvalidRequest.new('option :until_attach is invalid as the channel is not attached' )
+              return Ably::Util::SafeDeferrable.new_and_fail_immediately(logger, error)
+            end
+            options[:from_serial] = properties.attach_serial
+          end
+
+          async_wrap(callback) do
+            rest_channel.history(options.merge(async_blocking_operations: true))
+          end
+        end
+
+        # @return [Ably::Util::PubSub] Client library internal channel incoming message bus
+        #
+        # @api private
+        def __incoming_msgbus__
+          @__incoming_msgbus__ ||= Ably::Util::PubSub.new(
+            coerce_into: lambda { |event| Ably::Models::ProtocolMessage::ACTION(event) }
+          )
+        end
+
+        # Sets the {Ably::Models::ChannelOptions} for the channel.
+        # An optional callback may be provided to notify of the success or failure of the operation.
+        #
+        # @spec RTL16
+        #
+        # @param channel_options [Hash, Ably::Models::ChannelOptions]     A hash of options or a {Ably::Models::ChannelOptions}
+        # @return [Ably::Models::ChannelOptions]
+        def set_options(channel_options)
+          @options = Ably::Models::ChannelOptions(channel_options)
+          # RTL4i
+          manager.request_reattach if (need_reattach? and connection.state?(:connected))
+        end
+        alias options= set_options
+
+        # @api private
+        def set_channel_error_reason(error)
+          @error_reason = error
+        end
+
+        # @api private
+        def clear_error_reason
+          @error_reason = nil
+        end
+
+        # Used by {Ably::Modules::StateEmitter} to debug state changes
+        # @api private
+        def logger
+          client.logger
+        end
+
+        # @api private
+        def attach_resume!
+          @attach_resume = true
+        end
+
+        # @api private
+        def reset_attach_resume!
+          @attach_resume = false
+        end
+
+        # As we are using a state machine, do not allow change_state to be used
+        # #transition_state_machine must be used instead
+        private :change_state
+
+        def need_reattach?
+          !!(attaching? || attached?) && !!(options.modes || options.params)
+        end
+
+        private
+
+        def send_message_action(message, action_enum, operation = nil, params = {}, &success_block)
+          if suspended? || failed?
+            error = Ably::Exceptions::ChannelInactive.new("Cannot send message action on a channel in state #{state}")
+            return Ably::Util::SafeDeferrable.new_and_fail_immediately(logger, error)
+          end
+
+          if !connection.can_publish_messages?
+            error = Ably::Exceptions::MessageQueueingDisabled.new(
+              "Message action cannot be sent. Client is not allowed to queue messages when connection is in state #{connection.state}"
+            )
+            return Ably::Util::SafeDeferrable.new_and_fail_immediately(logger, error)
+          end
+
+          message = Ably::Models::Message(message)
+
+          unless message.serial
+            error = Ably::Exceptions::InvalidRequest.new('Message serial is required. Ensure the message has a serial field.')
+            return Ably::Util::SafeDeferrable.new_and_fail_immediately(logger, error)
+          end
+
+          update_attrs = message.as_json
+          update_attrs['action'] = action_enum.to_i
+
+          if operation
+            op_hash = operation.respond_to?(:as_json) ? operation.as_json : operation
+            update_attrs['version'] = op_hash
+          end
+
+          updated_message = Ably::Models::Message.new(update_attrs)
+          updated_message.encode(client.encoders, options) do |encode_error, error_message|
+            client.logger.error error_message
+          end
+
+          pm_params = { action: Ably::Models::ProtocolMessage::ACTION.Message.to_i, channel: name, messages: [updated_message] }
+          pm_params[:params] = params.transform_values(&:to_s) if params && !params.empty?
+
+          connection.send_protocol_message(pm_params)
+
+          Ably::Util::SafeDeferrable.new(logger).tap do |deferrable|
+            updated_message.callback do |result|
+              if result.is_a?(Ably::Models::UpdateDeleteResult)
+                deferrable.succeed result
+              else
+                deferrable.succeed Ably::Models::UpdateDeleteResult.new(version_serial: nil)
+              end
+            end
+            updated_message.errback do |error|
+              deferrable.fail error
+            end
+            deferrable.callback(&success_block) if block_given?
+          end
+        end
+
+        def setup_event_handlers
+          __incoming_msgbus__.subscribe(:message) do |message|
+            message.decode(client.encoders, options) do |encode_error, error_message|
+              client.logger.error error_message
+            end
+            emit_message message.name, message
+          end
+        end
+
+        def rest_channel
+          client.rest_client.channel(name)
+        end
+
+        def connection
+          client.connection
+        end
+
+        def setup_presence
+          @presence ||= Presence.new(self)
+        end
+
+        # Alias useful for methods with a name argument
+        def channel_name
+          name
+        end
+      end
+    end
+  end
+end
+
+require 'ably/pubsub/realtime/channel/channel_manager'
+require 'ably/pubsub/realtime/channel/channel_state_machine'
+require 'ably/pubsub/realtime/channel/push_channel'
+require 'ably/pubsub/realtime/channel/channel_properties'

data/lib/ably/pubsub/realtime/channels.rb

@@ -0,0 +1,92 @@
+module Ably
+  module PubSub
+    module Realtime
+      # Class that maintains a map of Channels ensuring Channels are reused
+      class Channels
+        include Ably::Modules::ChannelsCollection
+
+        # @return [Ably::PubSub::Realtime::Channels]
+        #
+        def initialize(client)
+          super client, Ably::PubSub::Realtime::Channel
+        end
+
+        # Return a {Ably::PubSub::Realtime::Channel} for the given name
+        #
+        # @param name [String] The name of the channel
+        # @param channel_options [Hash, Ably::Models::ChannelOptions] A hash of options or a {Ably::Models::ChannelOptions}
+        #
+        # @return [Ably::PubSub::Realtime::Channel]
+        #
+        def get(*args)
+          super
+        end
+
+        # Return a {Ably::PubSub::Realtime::Channel} for the given name if it exists, else the block will be called.
+        # This method is intentionally similar to {http://ruby-doc.org/core-2.1.3/Hash.html#method-i-fetch Hash#fetch} providing a simple way to check if a channel exists or not without creating one
+        #
+        # @param name [String] The name of the channel
+        # @yield [options] (optional) if a missing_block is passed to this method and no channel exists matching the name, this block is called
+        # @yieldparam [String] name of the missing channel
+        #
+        # @return [Ably::PubSub::Realtime::Channel]
+        #
+        def fetch(*args)
+          super
+        end
+
+        # Releases the {Ably::PubSub::Realtime::Channel Realtime Channel} with the given name and all associated resources.
+        #
+        # Releasing a Realtime Channel is not typically necessary as a channel, once detached, consumes no resources other than
+        # the memory footprint of the {Ably::PubSub::Realtime::Channel Realtime Channel object}. Release channels to free up resources if required
+        #
+        # A realtime channel can only be released when it is in the +INITIALIZED+, +DETACHED+, or +FAILED+ state.
+        #
+        # @spec RTS4c, RTS4d, RTS4e
+        #
+        # @param channel [String] The name of the channel
+        #
+        # @raise [Ably::Exceptions::InvalidState] if the channel is not in the +INITIALIZED+, +DETACHED+, or +FAILED+ state
+        #
+        # @return [void]
+        #
+        def release(channel)
+          return unless @channels.has_key?(channel)
+
+          released_channel = get(channel)
+          unless released_channel.initialized? || released_channel.detached? || released_channel.failed?
+            raise Ably::Exceptions::InvalidState.new(
+              "Can only release a channel in a state where there is no possibility of further updates from the server being received " \
+                "(initialized, detached, or failed). The current state is #{released_channel.state.to_sym}",
+              400,
+              90011
+            )
+          end
+
+          @channels.delete(channel)
+          nil
+        end
+
+        # Sets channel serial to each channel from given serials hashmap
+        # @param [Hash] serials - map of channel name to respective channel serial
+        # @api private
+        def set_channel_serials(serials)
+          serials.each do |channel_name, channel_serial|
+            get(channel_name).properties.channel_serial = channel_serial
+          end
+        end
+
+        # @return [Hash] serials - map of channel name to respective channel serial
+        # @api private
+        def get_channel_serials
+          channel_serials = {}
+          self.each do |channel|
+            channel_serials[channel.name] = channel.properties.channel_serial if channel.state == :attached
+          end
+          channel_serials
+        end
+
+      end
+    end
+  end
+end