ably 1.0.6 → 1.1.3

data/lib/ably/models/protocol_message.rb

@@ -198,12 +198,42 @@ module Ably::Models
 
     # @api private
     def has_backlog_flag?
-      flags & 2 == 2
+      flags & 2 == 2 # 2^1
     end
 
     # @api private
     def has_channel_resumed_flag?
-      flags & 4 == 4
+      flags & 4 == 4 # 2^2
+    end
+
+    # @api private
+    def has_local_presence_flag?
+      flags & 8 == 8 # 2^3
+    end
+
+    # @api private
+    def has_transient_flag?
+      flags & 16 == 16 # 2^4
+    end
+
+    # @api private
+    def has_attach_presence_flag?
+      flags & 65536 == 65536 # 2^16
+    end
+
+    # @api private
+    def has_attach_publish_flag?
+      flags & 131072 == 131072 # 2^17
+    end
+
+    # @api private
+    def has_attach_subscribe_flag?
+      flags & 262144 == 262144 # 2^18
+    end
+
+    # @api private
+    def has_attach_presence_subscribe_flag?
+      flags & 524288 == 524288 # 2^19
     end
 
     def connection_details

data/lib/ably/models/push_channel_subscription.rb

@@ -0,0 +1,89 @@
+module Ably::Modules
+  module Conversions
+    private
+    # Convert push_channel_subscription argument to a {Ably::Models::PushChannelSubscription} object
+    #
+    # @param push_channel_subscription [Ably::Models::PushChannelSubscription,Hash,nil] A device details object
+    #
+    # @return [Ably::Models::PushChannelSubscription]
+    def PushChannelSubscription(push_channel_subscription)
+      case push_channel_subscription
+      when Ably::Models::PushChannelSubscription
+        push_channel_subscription
+      else
+        Ably::Models::PushChannelSubscription.new(push_channel_subscription)
+      end
+    end
+  end
+end
+
+module Ably::Models
+  # An object representing a devices details, used currently for push notifications
+  #
+  # @!attribute [r] channel
+  #   @return [String] The realtime pub/sub channel this subscription is registered to
+  # @!attribute [r] client_id
+  #   @return [String] Client ID that is assigned to one or more registered push devices
+  # @!attribute [r] device_id
+  #   @return [String] Unique device identifier assigned to the push device
+  #
+  class PushChannelSubscription < Ably::Exceptions::BaseAblyException
+    include Ably::Modules::ModelCommon
+
+    # @param hash_object   [Hash,nil]  Device detail attributes
+    #a
+    def initialize(hash_object = {})
+      @raw_hash_object = hash_object || {}
+      @hash_object     = IdiomaticRubyWrapper(hash_object)
+
+      if !attributes[:client_id] && !attributes[:device_id]
+        raise ArgumentError, 'Either client_id or device_id must be provided'
+      end
+      if attributes[:client_id] && attributes[:device_id]
+        raise ArgumentError, 'client_id and device_id cannot both be provided, they are mutually exclusive'
+      end
+      if !attributes[:channel]
+        raise ArgumentError, 'channel is required'
+      end
+    end
+
+    # Constructor for channel subscription by device ID
+    #
+    # @param channel    [String]  the realtime pub/sub channel this subscription is registered to
+    # @param device_id  [String]  Unique device identifier assigned to the push device
+    #
+    # @return [PushChannelSubscription]
+    #
+    def self.for_device(channel, device_id)
+      PushChannelSubscription.new(channel: channel, device_id: device_id)
+    end
+
+    # Constructor for channel subscription by client ID
+    #
+    # @param channel    [String]  the realtime pub/sub channel this subscription is registered to
+    # @param client_id  [String]  Client ID that is assigned to one or more registered push devices
+    #
+    # @return [PushChannelSubscription]
+    #
+    def self.for_client_id(channel, client_id)
+      PushChannelSubscription.new(channel: channel, client_id: client_id)
+    end
+
+    %w(channel client_id device_id).each do |attribute|
+      define_method attribute do
+        attributes[attribute.to_sym]
+      end
+
+      define_method "#{attribute}=" do |val|
+        unless val.nil? || val.kind_of?(String)
+          raise ArgumentError, "#{attribute} must be nil or a string value"
+        end
+        attributes[attribute.to_sym] = val
+      end
+    end
+
+    def attributes
+      @hash_object
+    end
+  end
+end

data/lib/ably/modules/conversions.rb

@@ -113,7 +113,7 @@ module Ably::Modules
         payload.kind_of?(Array) ||
         payload.nil?
 
-      raise Ably::Exceptions::UnsupportedDataType.new('Invalid data payload', 400, 40011)
+      raise Ably::Exceptions::UnsupportedDataType.new('Invalid data payload', 400, Ably::Exceptions::Codes::INVALID_MESSAGE_DATA_OR_ENCODING)
     end
   end
 end

data/lib/ably/modules/encodeable.rb

@@ -27,7 +27,7 @@ module Ably::Modules
       end
 
       # Return an Array of Message or Presence objects from the encoded Array of JSON-like objects, using the optional channel options
-      # @param message_objects [Array<Hash>] Array of JSON-like objects with encoded messages
+      # @param message_object_array [Array<Hash>] Array of JSON-like objects with encoded messages
       # @param channel_options [Hash] Channel options, currently reserved for Encryption options
       # @return [Array<Message,Presence>]
       def from_encoded_array(message_object_array, channel_options = {})

data/lib/ably/modules/exception_codes.rb

@@ -0,0 +1,128 @@
+# This file is generated by running `rake :generate_error_codes`
+# Do not manually modify this file
+# Generated at: 2018-09-18 18:28:58 UTC
+#
+module Ably
+  module Exceptions
+    module Codes
+      NO_ERROR                                                                         = 10000
+      BAD_REQUEST                                                                      = 40000
+      INVALID_REQUEST_BODY                                                             = 40001
+      INVALID_PARAMETER_NAME                                                           = 40002
+      INVALID_PARAMETER_VALUE                                                          = 40003
+      INVALID_HEADER                                                                   = 40004
+      INVALID_CREDENTIAL                                                               = 40005
+      INVALID_CONNECTION_ID                                                            = 40006
+      INVALID_MESSAGE_ID                                                               = 40007
+      INVALID_CONTENT_LENGTH                                                           = 40008
+      MAXIMUM_MESSAGE_LENGTH_EXCEEDED                                                  = 40009
+      INVALID_CHANNEL_NAME                                                             = 40010
+      STALE_RING_STATE                                                                 = 40011
+      INVALID_CLIENT_ID                                                                = 40012
+      INVALID_MESSAGE_DATA_OR_ENCODING                                                 = 40013
+      RESOURCE_DISPOSED                                                                = 40014
+      INVALID_DEVICE_ID                                                                = 40015
+      BATCH_ERROR                                                                      = 40020
+      INVALID_PUBLISH_REQUEST_UNSPECIFIED                                              = 40030
+      INVALID_PUBLISH_REQUEST_INVALID_CLIENTSPECIFIED_ID                               = 40031
+      UNAUTHORIZED                                                                     = 40100
+      INVALID_CREDENTIALS                                                              = 40101
+      INCOMPATIBLE_CREDENTIALS                                                         = 40102
+      INVALID_USE_OF_BASIC_AUTH_OVER_NONTLS_TRANSPORT                                  = 40103
+      TIMESTAMP_NOT_CURRENT                                                            = 40104
+      NONCE_VALUE_REPLAYED                                                             = 40105
+      UNABLE_TO_OBTAIN_CREDENTIALS_FROM_GIVEN_PARAMETERS                               = 40106
+      ACCOUNT_DISABLED                                                                 = 40110
+      ACCOUNT_RESTRICTED_CONNECTION_LIMITS_EXCEEDED                                    = 40111
+      ACCOUNT_BLOCKED_MESSAGE_LIMITS_EXCEEDED                                          = 40112
+      ACCOUNT_BLOCKED                                                                  = 40113
+      ACCOUNT_RESTRICTED_CHANNEL_LIMITS_EXCEEDED                                       = 40114
+      APPLICATION_DISABLED                                                             = 40120
+      KEY_ERROR_UNSPECIFIED                                                            = 40130
+      KEY_REVOKED                                                                      = 40131
+      KEY_EXPIRED                                                                      = 40132
+      KEY_DISABLED                                                                     = 40133
+      TOKEN_ERROR_UNSPECIFIED                                                          = 40140
+      TOKEN_REVOKED                                                                    = 40141
+      TOKEN_EXPIRED                                                                    = 40142
+      TOKEN_UNRECOGNISED                                                               = 40143
+      INVALID_JWT_FORMAT                                                               = 40144
+      INVALID_TOKEN_FORMAT                                                             = 40145
+      CONNECTION_BLOCKED_LIMITS_EXCEEDED                                               = 40150
+      OPERATION_NOT_PERMITTED_WITH_PROVIDED_CAPABILITY                                 = 40160
+      ERROR_FROM_CLIENT_TOKEN_CALLBACK                                                 = 40170
+      FORBIDDEN                                                                        = 40300
+      ACCOUNT_DOES_NOT_PERMIT_TLS_CONNECTION                                           = 40310
+      OPERATION_REQUIRES_TLS_CONNECTION                                                = 40311
+      APPLICATION_REQUIRES_AUTHENTICATION                                              = 40320
+      UNABLE_TO_ACTIVATE_ACCOUNT_DUE_TO_PLACEMENT_CONSTRAINT_UNSPECIFIED               = 40330
+      UNABLE_TO_ACTIVATE_ACCOUNT_DUE_TO_PLACEMENT_CONSTRAINT_INCOMPATIBLE_ENVIRONMENT  = 40331
+      UNABLE_TO_ACTIVATE_ACCOUNT_DUE_TO_PLACEMENT_CONSTRAINT_INCOMPATIBLE_SITE         = 40332
+      NOT_FOUND                                                                        = 40400
+      METHOD_NOT_ALLOWED                                                               = 40500
+      RATE_LIMIT_EXCEEDED_NONFATAL_REQUEST_REJECTED_UNSPECIFIED                        = 42910
+      MAX_PERCONNECTION_PUBLISH_RATE_LIMIT_EXCEEDED_NONFATAL_UNABLE_TO_PUBLISH_MESSAGE = 42911
+      RATE_LIMIT_EXCEEDED_FATAL                                                        = 42920
+      MAX_PERCONNECTION_PUBLISH_RATE_LIMIT_EXCEEDED_FATAL_CLOSING_CONNECTION           = 42921
+      INTERNAL_ERROR                                                                   = 50000
+      INTERNAL_CHANNEL_ERROR                                                           = 50001
+      INTERNAL_CONNECTION_ERROR                                                        = 50002
+      TIMEOUT_ERROR                                                                    = 50003
+      REQUEST_FAILED_DUE_TO_OVERLOADED_INSTANCE                                        = 50004
+      REACTOR_OPERATION_FAILED                                                         = 70000
+      REACTOR_OPERATION_FAILED_POST_OPERATION_FAILED                                   = 70001
+      REACTOR_OPERATION_FAILED_POST_OPERATION_RETURNED_UNEXPECTED_CODE                 = 70002
+      REACTOR_OPERATION_FAILED_MAXIMUM_NUMBER_OF_CONCURRENT_INFLIGHT_REQUESTS_EXCEEDED = 70003
+      EXCHANGE_ERROR_UNSPECIFIED                                                       = 71000
+      FORCED_REATTACHMENT_DUE_TO_PERMISSIONS_CHANGE                                    = 71001
+      EXCHANGE_PUBLISHER_ERROR_UNSPECIFIED                                             = 71100
+      NO_SUCH_PUBLISHER                                                                = 71101
+      PUBLISHER_NOT_ENABLED_AS_AN_EXCHANGE_PUBLISHER                                   = 71102
+      EXCHANGE_PRODUCT_ERROR_UNSPECIFIED                                               = 71200
+      NO_SUCH_PRODUCT                                                                  = 71201
+      PRODUCT_DISABLED                                                                 = 71202
+      NO_SUCH_CHANNEL_IN_THIS_PRODUCT                                                  = 71203
+      EXCHANGE_SUBSCRIPTION_ERROR_UNSPECIFIED                                          = 71300
+      SUBSCRIPTION_DISABLED                                                            = 71301
+      REQUESTER_HAS_NO_SUBSCRIPTION_TO_THIS_PRODUCT                                    = 71302
+      CONNECTION_FAILED                                                                = 80000
+      CONNECTION_FAILED_NO_COMPATIBLE_TRANSPORT                                        = 80001
+      CONNECTION_SUSPENDED                                                             = 80002
+      DISCONNECTED                                                                     = 80003
+      ALREADY_CONNECTED                                                                = 80004
+      INVALID_CONNECTION_ID_REMOTE_NOT_FOUND                                           = 80005
+      UNABLE_TO_RECOVER_CONNECTION_MESSAGES_EXPIRED                                    = 80006
+      UNABLE_TO_RECOVER_CONNECTION_MESSAGE_LIMIT_EXCEEDED                              = 80007
+      UNABLE_TO_RECOVER_CONNECTION_CONNECTION_EXPIRED                                  = 80008
+      CONNECTION_NOT_ESTABLISHED_NO_TRANSPORT_HANDLE                                   = 80009
+      INVALID_OPERATION_INVALID_TRANSPORT_HANDLE                                       = 80010
+      UNABLE_TO_RECOVER_CONNECTION_INCOMPATIBLE_AUTH_PARAMS                            = 80011
+      UNABLE_TO_RECOVER_CONNECTION_INVALID_OR_UNSPECIFIED_CONNECTION_SERIAL            = 80012
+      PROTOCOL_ERROR                                                                   = 80013
+      CONNECTION_TIMED_OUT                                                             = 80014
+      INCOMPATIBLE_CONNECTION_PARAMETERS                                               = 80015
+      OPERATION_ON_SUPERSEDED_TRANSPORT                                                = 80016
+      CONNECTION_CLOSED                                                                = 80017
+      INVALID_CONNECTION_ID_INVALID_FORMAT                                             = 80018
+      CLIENT_CONFIGURED_AUTHENTICATION_PROVIDER_REQUEST_FAILED                         = 80019
+      CONTINUITY_LOSS_DUE_TO_MAXIMUM_SUBSCRIBE_MESSAGE_RATE_EXCEEDED                   = 80020
+      CLIENT_RESTRICTION_NOT_SATISFIED                                                 = 80030
+      CHANNEL_OPERATION_FAILED                                                         = 90000
+      CHANNEL_OPERATION_FAILED_INVALID_CHANNEL_STATE                                   = 90001
+      CHANNEL_OPERATION_FAILED_EPOCH_EXPIRED_OR_NEVER_EXISTED                          = 90002
+      UNABLE_TO_RECOVER_CHANNEL_MESSAGES_EXPIRED                                       = 90003
+      UNABLE_TO_RECOVER_CHANNEL_MESSAGE_LIMIT_EXCEEDED                                 = 90004
+      UNABLE_TO_RECOVER_CHANNEL_NO_MATCHING_EPOCH                                      = 90005
+      UNABLE_TO_RECOVER_CHANNEL_UNBOUNDED_REQUEST                                      = 90006
+      CHANNEL_OPERATION_FAILED_NO_RESPONSE_FROM_SERVER                                 = 90007
+      MAXIMUM_NUMBER_OF_CHANNELS_PER_CONNECTION_EXCEEDED                               = 90010
+      UNABLE_TO_ENTER_PRESENCE_CHANNEL_NO_CLIENTID                                     = 91000
+      UNABLE_TO_ENTER_PRESENCE_CHANNEL_INVALID_CHANNEL_STATE                           = 91001
+      UNABLE_TO_LEAVE_PRESENCE_CHANNEL_THAT_IS_NOT_ENTERED                             = 91002
+      UNABLE_TO_ENTER_PRESENCE_CHANNEL_MAXIMUM_MEMBER_LIMIT_EXCEEDED                   = 91003
+      UNABLE_TO_AUTOMATICALLY_REENTER_PRESENCE_CHANNEL                                 = 91004
+      PRESENCE_STATE_IS_OUT_OF_SYNC                                                    = 91005
+      MEMBER_IMPLICITLY_LEFT_PRESENCE_CHANNEL_CONNECTION_CLOSED                        = 91100
+    end
+  end
+end

data/lib/ably/modules/model_common.rb

@@ -42,10 +42,23 @@ module Ably::Modules
       attributes.hash
     end
 
+    def to_s
+      representation = attributes.map do |key, val|
+        if val.nil?
+          nil
+        else
+          val_str = val.to_s
+          val_str = "#{val_str[0...80]}..." if val_str.length > 80
+          "#{key}=#{val_str}"
+        end
+      end
+      "<#{self.class.name}: #{representation.compact.join(', ')}>"
+    end
+
     module ClassMethods
       # Return a new instance of this object using the provided JSON-like object or JSON string
-      # @param [Hash, String] JSON-like object or JSON string
-      # @return a new instance o this object
+      # @param json_like_object  [Hash, String]  JSON-like object or JSON string
+      # @return a new instance to this object
       def from_json(json_like_object)
         if json_like_object.kind_of?(String)
           new(JSON.parse(json_like_object))

data/lib/ably/modules/state_machine.rb

@@ -23,7 +23,7 @@ module Ably::Modules
     def transition_state(state, *args)
       unless result = transition_to(state.to_sym, *args)
         exception = exception_for_state_change_to(state)
-        logger.fatal { "#{self.class}: #{exception.message}" }
+        logger.fatal { "#{self.class}: #{exception.message}\n#{caller[0..20].join("\n")}" }
       end
       result
     end
@@ -41,7 +41,7 @@ module Ably::Modules
     # @return [Ably::Exceptions::InvalidStateChange]
     def exception_for_state_change_to(state)
       error_message = "#{self.class}: Unable to transition from #{current_state} => #{state}"
-      Ably::Exceptions::InvalidStateChange.new(error_message, nil, 80020)
+      Ably::Exceptions::InvalidStateChange.new(error_message, nil, Ably::Exceptions::Codes::CHANNEL_OPERATION_FAILED_INVALID_CHANNEL_STATE)
     end
 
     module ClassMethods

data/lib/ably/realtime.rb

@@ -9,6 +9,7 @@ require 'ably/realtime/channel'
 require 'ably/realtime/channels'
 require 'ably/realtime/client'
 require 'ably/realtime/connection'
+require 'ably/realtime/push'
 require 'ably/realtime/presence'
 
 require 'ably/models/message_encoders/base'

data/lib/ably/realtime/auth.rb

@@ -239,7 +239,7 @@ module Ably
             # Use base exception if it exists carrying forward the status codes
             deferrable.fail Ably::Exceptions::AuthenticationFailed.new(error.message, nil, nil, error)
           else
-            deferrable.fail Ably::Exceptions::AuthenticationFailed.new(error.message, 500, 80019)
+            deferrable.fail Ably::Exceptions::AuthenticationFailed.new(error.message, 500, Ably::Exceptions::Codes::CLIENT_CONFIGURED_AUTHENTICATION_PROVIDER_REQUEST_FAILED)
           end
         end
         async_wrap(success_callback, fail_callback) do

data/lib/ably/realtime/channel.rb

@@ -1,3 +1,5 @@
+require 'ably/realtime/channel/publisher'
+
 module Ably
   module Realtime
     # The Channel class represents a Channel belonging to this application.
@@ -32,6 +34,7 @@ module Ably
       include Ably::Modules::EventMachineHelpers
       include Ably::Modules::AsyncWrapper
       include Ably::Modules::MessageEmitter
+      include Ably::Realtime::Channel::Publisher
       extend Ably::Modules::Enum
 
       # ChannelState
@@ -61,12 +64,17 @@ module Ably
 
       # {Ably::Realtime::Client} associated with this channel
       # @return [Ably::Realtime::Client]
+      # @api private
       attr_reader :client
 
       # Channel name
       # @return [String]
       attr_reader :name
 
+      # Push channel used for push notification
+      # @return [Ably::Realtime::Channel::PushChannel]
+      attr_reader :push
+
       # Channel options configured for this channel, see {#initialize} for channel_options
       # @return [Hash]
       attr_reader :options
@@ -103,6 +111,7 @@ module Ably
         @state_machine = ChannelStateMachine.new(self)
         @state         = STATE(state_machine.current_state)
         @manager       = ChannelManager.new(self, client.connection)
+        @push          = PushChannel.new(self)
 
         setup_event_handlers
         setup_presence
@@ -116,7 +125,7 @@ module Ably
       # @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 publishde, or an Array of {Ably::Models::Message} when multiple messages are published
+      # @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
@@ -146,13 +155,13 @@ module Ably
       #   end
       #
       def publish(name, data = nil, attributes = {}, &success_block)
-        if detached? || detaching? || failed?
+        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 configured to disallow queueing of messages and connection is currently #{connection.state}")
+          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
 
@@ -164,7 +173,12 @@ module Ably
           [{ name: name, data: data }.merge(attributes)]
         end
 
-        queue_messages(messages).tap do |deferrable|
+        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
@@ -321,12 +335,6 @@ module Ably
         client.logger
       end
 
-      # Internal queue used for messages published that cannot yet be enqueued on the connection
-      # @api private
-      def __queue__
-        @queue
-      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
@@ -339,98 +347,6 @@ module Ably
           end
           emit_message message.name, message
         end
-
-        unsafe_on(STATE.Attached) do
-          process_queue
-        end
-      end
-
-      # Queue messages and process queue if channel is attached.
-      # If channel is not yet attached, attempt to attach it before the message queue is processed.
-      # @return [Ably::Util::SafeDeferrable]
-      def queue_messages(raw_messages)
-        messages = Array(raw_messages).map do |raw_msg|
-          create_message(raw_msg).tap do |message|
-            next if message.client_id.nil?
-            if message.client_id == '*'
-              raise Ably::Exceptions::IncompatibleClientId.new('Wildcard client_id is reserved and cannot be used when publishing messages')
-            end
-            if message.client_id && !message.client_id.kind_of?(String)
-              raise Ably::Exceptions::IncompatibleClientId.new('client_id must be a String when publishing messages')
-            end
-            unless client.auth.can_assume_client_id?(message.client_id)
-              raise Ably::Exceptions::IncompatibleClientId.new("Cannot publish with client_id '#{message.client_id}' as it is incompatible with the current configured client_id '#{client.client_id}'")
-            end
-          end
-        end
-
-        __queue__.push(*messages)
-
-        if attached?
-          process_queue
-        else
-          attach
-        end
-
-        if messages.count == 1
-          # A message is a Deferrable so, if publishing only one message, simply return that Deferrable
-          messages.first
-        else
-          deferrable_for_multiple_messages(messages)
-        end
-      end
-
-      # A deferrable object that calls the success callback once all messages are delivered
-      # If any message fails, the errback is called immediately
-      # Only one callback or errback is ever called i.e. if a group of messages all fail, only once
-      # errback will be invoked
-      def deferrable_for_multiple_messages(messages)
-        expected_deliveries = messages.count
-        actual_deliveries = 0
-        failed = false
-
-        Ably::Util::SafeDeferrable.new(logger).tap do |deferrable|
-          messages.each do |message|
-            message.callback do
-              next if failed
-              actual_deliveries += 1
-              deferrable.succeed messages if actual_deliveries == expected_deliveries
-            end
-            message.errback do |error|
-              next if failed
-              failed = true
-              deferrable.fail error, message
-            end
-          end
-        end
-      end
-
-      def messages_in_queue?
-        !__queue__.empty?
-      end
-
-      # Move messages from Channel Queue into Outgoing Connection Queue
-      def process_queue
-        condition = -> { attached? && messages_in_queue? }
-        non_blocking_loop_while(condition) do
-          send_messages_within_protocol_message __queue__.shift(MAX_PROTOCOL_MESSAGE_BATCH_SIZE)
-        end
-      end
-
-      def send_messages_within_protocol_message(messages)
-        connection.send_protocol_message(
-          action:   Ably::Models::ProtocolMessage::ACTION.Message.to_i,
-          channel:  name,
-          messages: messages
-        )
-      end
-
-      def create_message(message)
-        Ably::Models::Message(message.dup).tap do |msg|
-          msg.encode(client.encoders, options) do |encode_error, error_message|
-            client.logger.error error_message
-          end
-        end
       end
 
       def rest_channel
@@ -444,9 +360,15 @@ module Ably
       def setup_presence
         @presence ||= Presence.new(self)
       end
+
+      # Alias useful for methods with a name argument
+      def channel_name
+        name
+      end
     end
   end
 end
 
 require 'ably/realtime/channel/channel_manager'
 require 'ably/realtime/channel/channel_state_machine'
+require 'ably/realtime/channel/push_channel'