em-rtmp 0.0.3

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/README.md

@@ -0,0 +1,26 @@
+# EM-RTMP
+
+Asynchronous RTMP client powered by EventMachine.
+
+## Usage
+
+```ruby
+require "em-rtmp"
+# Start the EventMachine
+EventMachine.run do
+
+  # Establish a connection
+  connection = EventMachine::RTMP.connect 'flashserver.bigmediacompany.com'
+
+  # Issue an RTMP connect after the RTMP handshake
+  connection.on_handshake_complete do
+    EventMachine::RTMP::ConnectRequest.new(connection).send
+  end
+
+  # After the RTMP connect succeeds, continue on
+  connection.on_ready do
+    ...
+  end
+
+end
+```

data/Rakefile

@@ -0,0 +1,96 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+
+desc 'Run all specs in the spec directory'
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+desc 'Load an interactive console in our environment'
+task :console do
+  require "eventmachine"
+  require "em-rtmp"
+  require "irb"
+  require "irb/completion"
+  module EventMachine
+    module RTMP
+      ARGV.clear
+      IRB.start
+    end
+  end
+end
+
+desc 'Start the test'
+task :test do
+  require "eventmachine"
+  require "em-rtmp"
+  EventMachine.run do
+    connection = EventMachine::RTMP.ssl_connect '216.133.234.22', 2099
+
+    connection.on_handshake_complete do
+      req = EventMachine::RTMP::ConnectRequest.new connection
+      req.swfUrl = 'app:/mod_ser.dat'
+      req.tcUrl = 'rtmps://prod.na1.lol.riotgames.com:2099'
+      req.send
+    end
+
+    connection.on_ready do
+      obj = RocketAMF::Values::RemotingMessage.new
+      obj.destination = "playerStatsService"
+      obj.operation = "getRecentGames"
+      obj.body = [32310898]
+
+      req = EventMachine::RTMP::Request.new connection
+      req.header.channel_id = 3
+      req.header.message_stream_id = 0
+      req.header.message_type_id = 17
+
+      req.message.version = 3
+      req.message.command = nil
+      req.message.values = [obj]
+
+      req.body = req.message.encode
+
+      req.callback do |res|
+        p "I GOT A MOTHERFUCKING CALLBACK!"
+      end
+
+      req.errback do |res|
+        p "Couldn't do it..."
+      end
+
+      req.send
+    end
+#
+#    connection.on_ready do
+#      obj = RocketAMF::Values::RemotingMessage.new
+#      obj.destination = "playerStatsService"
+#      obj.operation = "getRecentGames"
+#      obj.body = [32310898]
+#
+#      req = EventMachine::RTMP::Request.new connection
+#      req.header.channel_id = 3
+#      req.header.message_stream_id = 0
+#      req.header.message_type_id = 17
+#
+#      req.message.version = 3
+#      req.message.command = nil
+#      req.message.values = [obj]
+#
+#      req.body = req.message.encode
+#
+#      req.callback do |res|
+#        p "I GOT A MOTHERFUCKING CALLBACK!"
+#      end
+#
+#      req.errback do |res|
+#        p "Couldn't do it..."
+#      end
+#
+#      req.send
+#    end
+
+  end
+end

data/lib/em-rtmp.rb

@@ -0,0 +1,18 @@
+require "eventmachine"
+require "rocketamf"
+
+require "em-rtmp/buffer"
+require "em-rtmp/connection"
+require "em-rtmp/connect_request"
+require "em-rtmp/handshake"
+require "em-rtmp/heartbeat"
+require "em-rtmp/header"
+require "em-rtmp/logger"
+require "em-rtmp/message"
+require "em-rtmp/pending_request"
+require "em-rtmp/request"
+require "em-rtmp/response"
+require "em-rtmp/response_router"
+require "em-rtmp/rtmp"
+require "em-rtmp/uuid"
+require "em-rtmp/version"

data/lib/em-rtmp/buffer.rb

@@ -0,0 +1,33 @@
+require "stringio"
+require "em-rtmp/io_helpers"
+
+module EventMachine
+  module RTMP
+    class Buffer < StringIO
+      include EventMachine::RTMP::IOHelpers
+
+      # Gets the number of remaining bytes in the buffer
+      #
+      # Returns an Integer representing the number of bytes left
+      def remaining
+        length - pos
+      end
+
+      # Truncate the buffer to nothing and set the position to zero
+      #
+      # Returns the new position (zero)
+      def reset
+        truncate 0
+        seek 0
+      end
+
+      # Append to the end of the string without changing our position
+      #
+      # Returns nothing
+      def append(string)
+        self.string << string
+      end
+
+    end
+  end
+end

data/lib/em-rtmp/connect_request.rb

@@ -0,0 +1,84 @@
+require "em-rtmp/request"
+
+module EventMachine
+  module RTMP
+    class ConnectRequest < Request
+
+      DEFAULT_PARAMETERS = {
+        app: '',
+        flashVer: 'WIN 10,1,85,3',
+        swfUrl: '',
+        tcUrl: '',
+        fpad: false,
+        capabilities: 239,
+        audioCodecs: 3191,
+        videoCodecs: 252,
+        videoFunction: 1,
+        pageUrl: nil,
+        objectEncoding: 3
+      }
+
+      attr_accessor :app, :flashVer, :swfUrl, :tcUrl, :fpad, :capabilities,
+                    :audioCodecs, :videoCodecs, :videoFunction, :pageUrl, :objectEncoding
+
+      # Initialize the request and set sane defaults for an RTMP connect
+      # request (transaction_id, command, header values)
+      #
+      # Returns nothing
+      def initialize(connection)
+        super connection
+
+        self.header.channel_id = 3
+        self.header.message_type = :amf0
+        self.header
+
+        self.message.version = 0
+        self.message.transaction_id = 1
+        self.message.command = "connect"
+
+        callback do |res|
+          Logger.debug "rtmp connect failed, becoming ready"
+          @connection.change_state :ready
+        end
+
+        errback do |res|
+          Logger.debug "rtmp connect failed, closing connection"
+          @connection.close_connection
+        end
+      end
+
+      # Construct a list of parameters given our class attributes, used
+      # to form the connect message object.
+      #
+      # Returns a Hash of symbols => values
+      def parameters
+        instance_values = Hash[instance_variables.map {|k| [k.to_s[1..-1].to_sym, instance_variable_get(k)]}]
+        DEFAULT_PARAMETERS.merge instance_values.select {|k,v| DEFAULT_PARAMETERS.key? k }
+      end
+
+      def command_message
+        cm = RocketAMF::Values::CommandMessage.new
+        cm.operation = 5
+        cm.correlationId = ""
+        cm.timestamp = 0
+        cm.timeToLive = 0
+        cm.messageId = UUID.random
+        cm.body = {}
+        cm.destination = ""
+        cm.headers = { "DSMessagingVersion" => 1, "DSId" => "my-rtmps" }
+        cm
+      end
+
+      # Given the specific nature of a connect request, we can just set the message
+      # values to our params then encode that as our body before sending.
+      #
+      # Returns the result of super
+      def send
+        self.message.values = [parameters, false, "nil", "", command_message]
+        self.body = message.encode
+        super
+      end
+
+    end
+  end
+end

data/lib/em-rtmp/connection.rb

@@ -0,0 +1,189 @@
+require "em-rtmp/io_helpers"
+
+module EventMachine
+  module RTMP
+    class Connection < EventMachine::Connection
+      include IOHelpers
+
+      attr_accessor :state, :chunk_size, :channels, :pending_requests
+
+      # Initialize the connection and setup our handshake
+      #
+      # Returns nothing
+      def initialize
+        super
+        @buffer = Buffer.new
+        @chunk_size = 128
+        @response_router = ResponseRouter.new(self)
+        @handshake = Handshake.new(self)
+        @callbacks = { :handshake_complete => [], :ready => [], :disconnected => [] }
+        @channels = []
+        @pending_requests = {}
+        @state = :connecting
+      end
+
+      # Used to track changes in state
+      #
+      # state - Symbol, new state to enter
+      #
+      # Returns nothing
+      def change_state(state)
+        return if @state == state
+        Logger.info "state changed from #{@state} to #{state}", caller: caller
+        @state = state
+        run_callbacks state
+      end
+
+      # Start the RTMP handshake process
+      #
+      # Returns nothing
+      def begin_rtmp_handshake
+        change_state :handshake
+        @handshake.issue_challenge
+      end
+
+      # Called to add a callback for when the RTMP handshake is
+      # completed. Most useful for issuing an RTMP connect request.
+      #
+      # blk - block to execute
+      #
+      # Returns nothing
+      def on_handshake_complete(&blk)
+        @callbacks[:handshake_complete] << blk
+      end
+
+      # Called to add a callback for when the RTMP connection has
+      # been established and is ready for work.
+      #
+      # blk - block to execute
+      #
+      # Returns nothing
+      def on_ready(&blk)
+        @callbacks[:ready] << blk
+      end
+
+      # Called to add a callback for when the TCP connection has
+      # been disconnected.
+      #
+      # blk - block to execute
+      #
+      # Returns nothing
+      def on_disconnected(&blk)
+        @callbacks[:disconnected] << blk
+      end
+
+      # Called to run the callbacks for a specific event
+      #
+      # event - symbol representing the event to run callbacks for
+      #
+      # Returns nothing
+      def run_callbacks(event)
+        if @callbacks.keys.include? event
+          @callbacks[event].each do |blk|
+            blk.call
+          end
+        end
+      end
+
+      # Reads from the buffer, to facilitate IO operations
+      #
+      # Returns the result of the read
+      def read(length)
+        Logger.debug "reading #{length} bytes from buffer"
+        @buffer.read length
+      end
+
+      # Writes data to the EventMachine connection
+      #
+      # Returns nothing
+      def write(data)
+        Logger.debug "sending #{data.length} bytes to stream"
+        send_data data
+      end
+
+      # Obtain the number of bytes waiting to be read in the buffer
+      #
+      # Returns an Integer
+      def bytes_waiting
+        @buffer.remaining
+      end
+
+      # Perform the next step after the connection has been established
+      # Called by the Event Machine
+      #
+      # Returns nothing
+      def connection_completed
+        Logger.info "connection completed, issuing rtmp handshake"
+        begin_rtmp_handshake
+      end
+
+      # Change our state to disconnected if we lose the connection.
+      # Called by the Event Machine
+      #
+      # Returns nothing
+      def unbind
+        Logger.info "disconnected from peer"
+        change_state :disconnected
+      end
+
+      # Receives data and offers it to the appropriate delegate object.
+      # Fires a method call to buffer_changed to take action.
+      # Called by the Event machine
+      #
+      # data - data received
+      #
+      # Returns nothing
+      def receive_data(data)
+        Logger.debug "received #{data.length} bytes"
+        @buffer.append data
+        buffer_changed
+      end
+
+      # Called when the buffer is changed, indicating that we may want
+      # to change state or delegate to another object
+      #
+      # Returns nothing
+      def buffer_changed
+
+        loop do
+          break if bytes_waiting < 1
+
+          case state
+
+          when :handshake
+            if @handshake.buffer_changed == :handshake_complete
+              @handshake = nil
+              change_state :handshake_complete
+            end
+            break
+
+          when :handshake_complete, :ready
+            @response_router.buffer_changed
+            next
+
+          end
+        end
+
+      end
+    end
+
+    # A secure connection behaves identically except that it delays the
+    # RTMP handshake until after the ssl handshake occurs.
+    class SecureConnection < Connection
+
+      # When the connection is established, make it secure before
+      # starting the RTMP handshake process.
+      def connection_completed
+        Logger.info "connection completed, starting tls"
+        start_tls verify_peer: false
+      end
+
+      # Connection is now secure, issue the RTMP handshake challenge
+      def ssl_handshake_completed
+        Logger.info "ssl handshake completed, issuing rtmp handshake"
+        begin_rtmp_handshake
+      end
+    end
+
+  end
+end