em-rtmp 0.0.3

data/lib/em-rtmp/logger.rb

@@ -0,0 +1,48 @@
+module EventMachine
+  module RTMP
+    class Logger
+
+      LEVEL_DEBUG = 0
+      LEVEL_INFO = 1
+      LEVEL_ERROR = 2
+
+      @@level = LEVEL_INFO
+
+      class << self
+        attr_accessor :level
+      end
+
+      def self.level(level)
+        @@level = level
+      end
+
+      def self.debug(message, options={})
+        return unless @@level <= LEVEL_DEBUG
+        print message, {level: "DEBUG", caller: caller}.merge(options)
+      end
+
+      def self.info(message, options={})
+        return unless @@level <= LEVEL_INFO
+        print message, {level: "INFO", caller: caller}.merge(options)
+      end
+
+      def self.error(message, options={})
+        return unless @@level <= LEVEL_ERROR
+        print message, {level: "ERROR", caller: caller}.merge(options)
+      end
+
+      def self.print(message, options={})
+        options[:level] ||= "PRINT"
+        options[:caller] ||= caller
+
+        caller_splat = options[:caller][0].split(":")
+        ruby_file = caller_splat[0].split("/").last
+        ruby_line = caller_splat[1]
+        ruby_method = caller_splat[2].match(/`(.*)'/)[1]
+
+        puts "%-10s%-30s%-30s%s" % ["[#{options[:level]}]", "#{ruby_file}:#{ruby_line}", ruby_method, message.encode("UTF-8")]
+      end
+
+    end
+  end
+end

data/lib/em-rtmp/message.rb

@@ -0,0 +1,96 @@
+module EventMachine
+  module RTMP
+    class Message
+
+      class << self
+        attr_accessor :transaction_id
+      end
+
+      attr_accessor :_amf_data, :_amf_error, :_amf_unparsed
+      attr_accessor :version, :command, :transaction_id, :values
+
+      # Initialize, setting attributes as given
+      #
+      # attrs - Hash of attributes
+      #
+      # Returns nothing
+      def initialize(attrs={})
+        attrs.each {|k,v| send("#{k}=", v)}
+        self.command ||= nil
+        self.transaction_id ||= self.class.next_transaction_id
+        self.values ||= []
+        self.version ||= 0x00
+      end
+
+      def amf3?
+        version == 0x03
+      end
+
+      # Encode this message with the chosen serializer
+      #
+      # Returns a string containing an encoded message
+      def encode
+        Logger.debug "encoding #{self.inspect}"
+        class_mapper = RocketAMF::ClassMapper.new
+        ser = RocketAMF::Serializer.new class_mapper
+
+        if amf3?
+          ser.stream << "\x00"
+        end
+
+        ser.serialize 0, command
+        ser.serialize 0, transaction_id
+
+        if amf3?
+          ser.stream << "\x05"
+          ser.stream << "\x11"
+          ser.serialize 3, values.first
+        else
+          values.each do |value|
+            ser.serialize 0, value
+          end
+        end
+
+        ser.stream
+      end
+
+      def decode(string)
+        class_mapper = RocketAMF::ClassMapper.new
+        io = StringIO.new string
+        des = RocketAMF::Deserializer.new class_mapper
+
+        begin
+
+          if amf3?
+            byte = des.deserialize 3, io
+            unless byte == nil
+              raise AMFException, "wanted amf3 first byte of 0x00, got #{byte}"
+            end
+          end
+
+          until io.eof?
+            self.values << des.deserialize(0, io)
+          end
+
+        rescue => e
+          self._amf_data = string
+          self._amf_error = e
+          self._amf_unparsed = io.read(100_000)
+        end
+
+        self.command = values.delete_at(0)
+        self.transaction_id = values.delete_at(0)
+      end
+
+      def success?
+        (command != "_error") && _amf_error.nil?
+      end
+
+      def self.next_transaction_id
+        self.transaction_id ||= 0
+        self.transaction_id += 1
+      end
+
+    end
+  end
+end

data/lib/em-rtmp/pending_request.rb

@@ -0,0 +1,48 @@
+module EventMachine
+  module RTMP
+    class PendingRequest
+      attr_accessor :request, :connection
+
+      # Create a new pending request from a request
+      #
+      # Returns nothing
+      def initialize(request, connection)
+        self.request = request
+        self.connection = connection
+      end
+
+      # Delete the current request from the list of pending requests
+      #
+      # Returns nothing
+      def delete
+        connection.pending_requests[request.header.message_type].delete(request.message.transaction_id.to_i)
+      end
+
+      # Find a request by message type and transaction id
+      #
+      # message_type - Symbol representing the message type (from header)
+      # transaction_id - Integer representing the transaction id
+      #
+      # Returns the request or nothing
+      def self.find(message_type, transaction_id, connection)
+        if connection.pending_requests[message_type]
+          connection.pending_requests[message_type][transaction_id.to_i]
+        end
+      end
+
+      # Create a request and add it to the pending requests hash
+      #
+      # request - Request to add
+      #
+      # Returns the request
+      def self.create(request, connection)
+        message_type = request.header.message_type
+        transaction_id = request.message.transaction_id.to_i
+        connection.pending_requests[message_type] ||= {}
+        connection.pending_requests[message_type][transaction_id] = new(request, connection)
+        connection.pending_requests[message_type][transaction_id]
+      end
+
+    end
+  end
+end

data/lib/em-rtmp/request.rb

@@ -0,0 +1,101 @@
+require "em-rtmp/connection_delegate"
+
+module EventMachine
+  module RTMP
+    class Request < ConnectionDelegate
+      include EventMachine::Deferrable
+
+      # An RTMP packet includes a header and a body. Each packet is typically no
+      # longer than 128 bytes, including the header. Multiple streams can be
+      # ongoing (and interweaving) at the same time, so we track them via their
+      # stream id.
+
+      # The request implementation here references a Header object and a message body.
+      # The body can be any object that responds to to_s.
+
+      attr_accessor :header, :body, :message
+
+      # Initialize, setting attributes
+      #
+      # attrs - Hash of attributes to write
+      #
+      # Returns nothing
+      def initialize(connection)
+        super connection
+        self.header = Header.new
+        self.message = Message.new
+        self.body = ""
+      end
+
+      # Updates the header to reflect the actual length of the body
+      #
+      # Returns nothing
+      def update_header
+        header.body_length = body.length
+      end
+
+      # Determines the proper chunk size for each packet we will send
+      #
+      # Returns the chunk size as an Integer
+      def chunk_size
+        @connection.chunk_size
+      end
+
+      # Determines the number of chunks we will send
+      #
+      # Returns the chunk count as an Integer
+      def chunk_count
+        (body.length / chunk_size.to_f).ceil
+      end
+
+      # Splits the body into chunks for sending
+      #
+      # Returns an Array of Strings, each a chunk to send
+      def chunks
+        (0...chunk_count).map do |chunk|
+          offset_start = chunk_size * chunk
+          offset_end = [offset_start + chunk_size, body.length].min - 1
+          body[offset_start..offset_end]
+        end
+      end
+
+      # Determine the proper header length for a given chunk
+      #
+      # Returns an Integer
+      def header_length_for_chunk(offset)
+        offset == 0 ? 12 : 1
+      end
+
+      # Update the header and send each chunk with an appropriate header.
+      #
+      # Returns the number of bytes written
+      def send
+        bytes_sent = 0
+        update_header
+
+        Logger.info "head: #{header.inspect}"
+        Logger.info "body: #{message.inspect}"
+
+        for i in 0..(chunk_count-1)
+          self.header.header_length = header_length_for_chunk(i)
+          bytes_sent += send_chunk chunks[i]
+        end
+
+        PendingRequest.create self, @connection
+
+        bytes_sent
+      end
+
+      # Send a chunk to the stream
+      #
+      # body - Body string to write
+      #
+      # Returns the number of bytes written
+      def send_chunk(chunk)
+        Logger.debug "sending chunk (#{chunk.length})", indent: 1
+        write(header.encode) + write(chunk)
+      end
+
+    end
+  end
+end

data/lib/em-rtmp/response.rb

@@ -0,0 +1,108 @@
+module EventMachine
+  module RTMP
+    class Response < ConnectionDelegate
+      attr_accessor :channel_id, :header, :body, :message, :waiting_on_bytes
+
+      # Initialize as a logical stream on a given stream ID
+      #
+      # Returns nothing.
+      def initialize(channel_id, connection)
+        super connection
+
+        self.channel_id = channel_id
+        self.header = Header.new
+        self.body = ""
+        self.waiting_on_bytes = 0
+      end
+
+      # Reset the body (leave the header) between successful responses
+      #
+      # Returns nothing
+      def reset
+        self.body = ""
+      end
+
+      # Inherit values from a given header
+      #
+      # h - Header to add
+      #
+      # Returns the instance header
+      def add_header(header)
+        self.header += header
+      end
+
+      # Determines the proper chunk size from the connection
+      #
+      # Returns the chunk size as an Integer
+      def chunk_size
+        @connection.chunk_size
+      end
+
+      # Determines the proper amount of data to read this time around
+      #
+      # Returns the chunk size as an Integer
+      def read_size
+        if waiting_on_bytes > 0
+          waiting_on_bytes
+        else
+          [header.body_length - body.length, chunk_size].min
+        end
+      end
+
+      # Read the next data chunk from the stream
+      #
+      # Returns the instance body
+      def read_next_chunk
+        raise "No more data to read from stream" if header.body_length <= body.length
+
+        Logger.debug "want #{read_size} (#{body.length}/#{header.body_length})"
+
+        desired_size = read_size
+        data = read(desired_size)
+        data_length = data ? data.length : 0
+
+        if data_length > 0
+          self.body << data
+        end
+
+        if data_length != desired_size
+          self.waiting_on_bytes = desired_size - data_length
+        else
+          self.waiting_on_bytes = 0
+        end
+
+        self.body
+      end
+
+      # Determines whether or not we're in the middle of a chunk waiting for more
+      # data, or it's ok to go ahead and peek for a header.
+      #
+      # Returns true or false
+      def waiting_in_chunk?
+        waiting_on_bytes > 0
+      end
+
+      # Determine whether or not the stream is complete by checking the length
+      # of our body against that we expected from headers
+      #
+      # Returns true or false
+      def complete?
+        complete = body.length >= header.body_length
+        Logger.debug "response complete? #{complete} (#{body.length}/#{header.body_length})"
+        complete
+      end
+
+      # Find or create a channel by ID
+      #
+      # channel_id - ID of channel to find or create
+      # connection - Connection to attach
+      #
+      # Returns a Response instance
+      def self.find_or_create(channel_id, connection)
+        connection.channels[channel_id] ||= Response.new(channel_id, connection)
+        connection.channels[channel_id]
+      end
+
+    end
+  end
+end

data/lib/em-rtmp/response_router.rb

@@ -0,0 +1,130 @@
+module EventMachine
+  module RTMP
+    class ResponseRouter < ConnectionDelegate
+
+      attr_accessor :active_response
+
+      # Create a new response router object to delegate to. Start with a state
+      # of looking for a fresh header.
+      #
+      # Returns nothing
+      def initialize(connection)
+        super connection
+        @state = :wait_header
+      end
+
+      # Called by the connection when the buffer changes and it's appropriate to
+      # delegate to the response router. Take action depending on our state.
+      #
+      # Returns nothing
+      def buffer_changed
+        case state
+        when :wait_header
+          header = Header.read_from_connection(@connection)
+          Logger.debug "routing new header channel=#{header.channel_id}, type=#{header.message_type_id} length=#{header.body_length}"
+          receive_header header
+        when :wait_chunk
+          receive_chunk active_response
+        end
+      end
+
+      # Receive a fresh header, add it to the appropriate response and receive
+      # a chunk of data for that response.
+      #
+      # header - Header to receive and act on
+      #
+      # Returns nothing
+      def receive_header(header)
+        response = Response.find_or_create(header.channel_id, @connection)
+        response.add_header header
+        receive_chunk response
+      end
+
+      # Receive a chunk of data for a given response. Change our state depending
+      # on the result of the chunk read. If it was read in full, we'll look for
+      # a header next time around. Otherwise, we will continue to read into that
+      # chunk until it is satisfied.
+      #
+      # If the response is completely received, we'll clone it and route that to
+      # the appropriate action, then reset that response so that it can receive something
+      # else in the future.
+      #
+      # response - the Response object to act on
+      #
+      # Returns nothing
+      def receive_chunk(response)
+        response.read_next_chunk
+
+        if response.waiting_in_chunk?
+          self.active_response = response
+          change_state :wait_chunk
+        else
+          self.active_response = nil
+          change_state :wait_header
+        end
+
+        if response.complete?
+          Logger.debug "response is complete, routing it!"
+          route_response response.dup
+          response.reset
+        end
+      end
+
+      # Route any response to its proper destination. AMF responses are routed to their
+      # pending request. Chunk size updates the connection, others are ignored for now.
+      #
+      # response - Response object to route or act on.
+      #
+      # Returns nothing.
+      def route_response(response)
+        case response.header.message_type
+        when :amf0
+          response.message = Message.new version: 0
+          response.message.decode response.body
+          Logger.info "head: #{response.header.inspect}"
+          Logger.info "amf0: #{response.message.inspect}"
+          route_amf :amf0, response
+        when :amf3
+          response.message = Message.new version: 3
+          response.message.decode response.body
+          Logger.info "head: #{response.header.inspect}"
+          Logger.info "amf3: #{response.message.inspect}"
+          route_amf :amf3, response
+        when :chunk_size
+          connection.chunk_size = response.body.unpack('N')[0]
+          Logger.info "setting chunk_size to #{chunk_size}"
+        when :ack_size
+          ack_size = response.body.unpack('N')[0]
+          Logger.info "setting ack_size to #{ack_size}"
+        when :bandwidth
+          bandwidth = response.body[0..3].unpack('N')[0]
+          bandwidth_type = response.body[4].unpack('c')[0]
+          Logger.info "setting bandwidth to #{bandwidth} (#{bandwidth_type})"
+        else
+          Logger.info "cannot route unknown response: #{response.inspect}"
+        end
+      end
+
+      # Route an AMF response to it's pending request
+      #
+      # version - AMF version (:amf0 or :amf3)
+      # response - Response object
+      #
+      # Returns nothing
+      def route_amf(version, response)
+        Logger.debug "routing #{version} response for tid #{response.message.transaction_id}"
+        if pending_request = PendingRequest.find(version, response.message.transaction_id, @connection)
+          if response.message.success?
+            pending_request.request.succeed(response)
+          else
+            pending_request.request.fail(response)
+          end
+          pending_request.delete
+        else
+          Logger.error "unable to find a matching transaction"
+        end
+      end
+
+    end
+  end
+end