rtsp_server 0.0.1

data/lib/rtsp/transport_parser.rb

@@ -0,0 +1,96 @@
+require 'parslet'
+
+module RTSP
+
+  # Used for parsing the Transport header--mainly as the response from the
+  # SETUP request.  The values from this are used to determine what to use for
+  # other requests.
+  class TransportParser < Parslet::Parser
+    rule(:transport_specifier) do
+      match('[A-Za-z]').repeat(3).as(:streaming_protocol) >> forward_slash >>
+        match('[A-Za-z]').repeat(3).as(:profile) >>
+        (forward_slash >> match('[A-Za-z]').repeat(3).as(:transport_protocol)).maybe
+    end
+
+    rule(:broadcast_type) do
+      str('unicast') | str('multicast')
+    end
+
+    rule(:destination) do
+      str('destination=') >> ip_address.as(:destination)
+    end
+
+    rule(:source) do
+      str('source=') >> ip_address.as(:source)
+    end
+
+    rule(:client_port) do
+      str('client_port=') >> number.as(:rtp) >> dash >> number.as(:rtcp)
+    end
+
+    rule(:server_port) do
+      str('server_port=') >> number.as(:rtp) >> dash >> number.as(:rtcp)
+    end
+
+    rule(:interleaved) do
+      str('interleaved=') >> number.as(:rtp_channel) >> dash >>
+        number.as(:rtcp_channel)
+    end
+
+    rule(:ttl) do
+      str('ttl=') >> match('[\d]').repeat(1,3).as(:ttl)
+    end
+
+    rule(:port) do
+      str('port=') >> match('[\d]').repeat(1,5).as(:rtp) >>
+      dash.maybe >> match('[\d]').repeat(1,5).as(:rtcp).maybe
+    end
+
+    rule(:ssrc) do
+      str('ssrc=') >> match('[0-9A-Fa-f]').repeat(8).as(:ssrc)
+    end
+
+    rule(:channel) do
+      str('channel=') >> match('[\w]').repeat(1,3).as(:channel)
+    end
+
+    rule(:address) do
+      str('address=') >> match('[\S]').repeat.as(:address)
+    end
+
+    rule(:mode) do
+      str('mode=') >> str('"').maybe >> match('[A-Za-z]').repeat.as(:mode) >>
+      str('"').maybe
+    end
+
+    rule(:ip_address) do
+      match('[\d]').repeat(1,3) >> str('.') >>
+        match('[\d]').repeat(1,3) >> str('.') >>
+        match('[\d]').repeat(1,3) >> str('.') >>
+        match('[\d]').repeat(1,3)
+    end
+
+    rule(:number)         { match('[\d]').repeat }
+    rule(:forward_slash)  { match('[/]') }
+    rule(:semi_colon)     { match('[;]') }
+    rule(:dash)           { match('[-]') }
+
+    rule(:header_field) do
+      transport_specifier >>
+        (semi_colon >> broadcast_type.as(:broadcast_type)).maybe >>
+        (semi_colon >> destination).maybe >>
+        (semi_colon >> source).maybe >>
+        (semi_colon >> client_port.as(:client_port)).maybe >>
+        (semi_colon >> server_port.as(:server_port)).maybe >>
+        (semi_colon >> interleaved.as(:interleaved)).maybe >>
+        (semi_colon >> ttl).maybe >>
+        (semi_colon >> port.as(:port)).maybe >>
+        (semi_colon >> ssrc).maybe >>
+        (semi_colon >> channel).maybe >>
+        (semi_colon >> address).maybe >>
+        (semi_colon >> mode).maybe
+    end
+
+    root :header_field
+  end
+end

data/lib/rtsp/version.rb

@@ -0,0 +1,4 @@
+module RTSP
+  # rtsp version
+  VERSION = "0.0.1"
+end

data/lib/rtsp.rb

@@ -0,0 +1,6 @@
+require 'pathname'
+require_relative 'rtsp/version'
+
+# This base module simply defines properties about the library.  See child
+# classes/modules for the meat.
+module RTSP; end

data/rtsp.gemspec

@@ -0,0 +1,42 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('lib/', File.dirname(__FILE__))
+$:.unshift lib unless $:.include?(lib)
+
+require 'rtsp/version'
+
+Gem::Specification.new do |s|
+  s.name = "rtsp_server"
+  s.version = RTSP::VERSION
+
+  s.homepage = %q{https://github.com/turboladen/rtsp}
+  s.authors = ["Steve Loveless, Mike Kirby", "Sujin Philip"]
+  s.summary = %q{Library to allow RTSP streaming from RTSP-enabled devices.}
+  s.description = %q{This library intends to follow the RTSP RFC document (2326)
+to allow for working with RTSP servers.  At this point, it's up to you to parse
+the data from a play call, but we'll get there.  ...eventually.
+For more information see: http://www.ietf.org/rfc/rfc2326.txt}
+  s.email = %w{steve.loveless@gmail.com}
+  s.licenses = %w{MIT}
+
+  s.executables = %w{rtsp_client}
+  s.files = Dir.glob("{lib,bin,spec,tasks}/**/*") + Dir.glob("*.rdoc") +
+    %w(.gemtest rtsp.gemspec Gemfile Rakefile)
+  s.extra_rdoc_files = %w{ChangeLog.rdoc LICENSE.rdoc README.rdoc}
+  s.require_paths = %w{lib}
+  s.rubygems_version = %q{1.7.2}
+  s.test_files = Dir.glob("{spec,features}/**/*")
+
+  s.add_runtime_dependency(%q<parslet>, [">= 1.1.0"])
+  s.add_runtime_dependency(%q<rtp>, [">= 0.0.1"])
+  s.add_runtime_dependency(%q<sdp>, ["~> 0.2.6"])
+  s.add_runtime_dependency(%q<sys-proctable>, ["> 0"])
+
+  s.add_development_dependency(%q<bundler>)
+  s.add_development_dependency(%q<code_statistics>, ["~> 0.2.13"])
+  s.add_development_dependency(%q<cucumber>, [">= 1.1.0"])
+  s.add_development_dependency(%q<roodi>, [">= 2.1.0"])
+  s.add_development_dependency(%q<rake>, [">= 0.8.7"])
+  s.add_development_dependency(%q<rspec>, [">= 2.5.0"])
+  s.add_development_dependency(%q<simplecov>, [">= 0.4.0"])
+  s.add_development_dependency(%q<yard>, [">= 0.6.0"])
+end

data/spec/rtsp/client_spec.rb

@@ -0,0 +1,326 @@
+require 'sdp'
+require_relative '../spec_helper'
+require 'rtsp/client'
+require_relative '../support/fake_rtsp_server'
+
+describe RTSP::Client do
+  def setup_client_at(url)
+    fake_rtsp_server = FakeRTSPServer.new
+    mock_logger = double 'MockLogger', :send => nil
+
+    client = RTSP::Client.new(url) do |connection|
+      connection.socket = fake_rtsp_server
+    end
+
+    RTSP::Client.reset_config!
+    RTSP::Client.configure { |config| config.log = false }
+    client.logger = mock_logger
+
+    client
+  end
+
+  before do
+    RTP::Receiver.any_instance.stub(:run)
+    RTP::Receiver.any_instance.stub(:stop)
+  end
+
+  describe "#initialize" do
+    before :each do
+      mock_socket = double 'MockSocket'
+      @client = RTSP::Client.new("rtsp://localhost") do |connection|
+        connection.socket = mock_socket
+      end
+    end
+
+    it "sets @cseq to 1" do
+      @client.instance_variable_get(:@cseq).should == 1
+    end
+
+    it "sets @session_state to :init" do
+      @client.instance_variable_get(:@session_state).should == :init
+    end
+
+    it "sets @server_uri to be a URI containing the first init param + 554" do
+      @client.instance_variable_get(:@server_uri).should be_a(URI)
+      @client.instance_variable_get(:@server_uri).to_s.should ==
+          "rtsp://localhost:554"
+    end
+  end
+
+  describe ".configure" do
+    around do |example|
+      RTSP::Client.reset_config!
+      example.run
+      RTSP::Client.reset_config!
+      RTSP::Client.log = false
+    end
+
+    before :each do
+      mock_socket = double 'MockSocket'
+
+      @client = RTSP::Client.new("rtsp://localhost") do |connection|
+        connection.socket = mock_socket
+      end
+    end
+
+    describe "log" do
+      it "should default to true" do
+        RTSP::Client.log?.should be_true
+      end
+
+      it "should set whether to log RTSP requests/responses" do
+        RTSP::Client.configure { |config| config.log = false }
+        RTSP::Client.log?.should be_false
+      end
+    end
+
+    describe "logger" do
+      it "should set the logger to use" do
+        MyLogger = Class.new
+        RTSP::Client.configure { |config| config.logger = MyLogger }
+        RTSP::Client.logger.should == MyLogger
+      end
+
+      it "should default to Logger writing to STDOUT" do
+        RTSP::Client.logger.should be_a(Logger)
+      end
+    end
+
+    describe "log_level" do
+      it "should default to :debug" do
+        RTSP::Client.log_level.should == :debug
+      end
+
+      it "should set the log level to use" do
+        RTSP::Client.configure { |config| config.log_level = :info }
+        RTSP::Client.log_level.should == :info
+      end
+    end
+  end
+
+  it "handles empty non-existent CSeq header" do
+    pending
+  end
+
+  context "#server_url" do
+    before :each do
+      @client = setup_client_at "rtsp://localhost"
+    end
+
+    it "allows for changing the server URL on the fly" do
+      @client.server_uri.to_s.should == "rtsp://localhost:554"
+      @client.server_url = "rtsp://localhost:8080"
+      @client.server_uri.to_s.should == "rtsp://localhost:8080"
+    end
+
+    it "raises when passing in something other than a String" do
+      @client.server_uri.to_s.should == "rtsp://localhost:554"
+      lambda { @client.server_url = [] }.should raise_error
+    end
+  end
+
+  describe "#options" do
+    before :each do
+      @client = setup_client_at "rtsp://localhost"
+    end
+
+    it "extracts the server's supported methods" do
+      @client.options
+      @client.supported_methods.should ==
+          [:describe, :setup, :teardown, :play, :pause]
+    end
+
+    it "returns a Response" do
+      response = @client.options
+      response.is_a?(RTSP::Response).should be_true
+    end
+  end
+
+  describe "#describe" do
+    before do
+      @client = setup_client_at "rtsp://localhost"
+      @response = @client.describe
+    end
+
+    it "extracts the aggregate control track" do
+      @client.aggregate_control_track.should == "rtsp://64.202.98.91:554/sa.sdp/"
+    end
+
+    it "extracts the media control tracks" do
+      @client.media_control_tracks.should == ["rtsp://64.202.98.91:554/sa.sdp/trackID=1"]
+    end
+
+    it "extracts the SDP object" do
+      @client.instance_variable_get(:@session_description).should ==
+          @response.body
+    end
+
+    it "extracts the Content-Base header" do
+      @client.instance_variable_get(:@content_base).should ==
+          URI.parse("rtsp://64.202.98.91:554/sa.sdp/")
+    end
+
+    it "returns a Response" do
+      @response.is_a?(RTSP::Response).should be_true
+    end
+  end
+
+  describe "#announce" do
+    it "returns a Response" do
+      client = setup_client_at "rtsp://localhost"
+      sdp = SDP::Description.new
+      client.setup("rtsp://localhost/another_track")
+      response = client.announce("rtsp://localhost/another_track", sdp)
+      response.is_a?(RTSP::Response).should be_true
+    end
+  end
+
+  describe "#setup" do
+    before :each do
+      @client = setup_client_at "rtsp://localhost"
+    end
+
+    it "extracts the session number" do
+      @client.session.should be_empty
+      @client.setup("rtsp://localhost/some_track")
+      @client.session[:session_id].should == 1234567890
+    end
+
+    it "changes the session_state to :ready" do
+      @client.setup("rtsp://localhost/some_track")
+      @client.session_state.should == :ready
+    end
+
+    it "extracts the transport header info" do
+      @client.instance_variable_get(:@transport).should be_nil
+      @client.setup("rtsp://localhost/some_track")
+      @client.instance_variable_get(:@transport).should_not be_nil
+    end
+
+    it "returns a Response" do
+      response = @client.setup("rtsp://localhost/some_track")
+      response.is_a?(RTSP::Response).should be_true
+    end
+  end
+
+  describe "#play" do
+    before :each do
+      @client = setup_client_at "rtsp://localhost"
+    end
+
+    after :each do
+      @client.teardown "rtsp://localhost"
+    end
+
+    it "changes the session_state to :playing" do
+      @client.setup("rtsp://localhost/some_track")
+      @client.play("rtsp://localhost/some_track")
+      @client.session_state.should == :playing
+    end
+
+    it "returns a Response" do
+      @client.setup("rtsp://localhost/some_track")
+      response = @client.play("rtsp://localhost/some_track")
+      response.is_a?(RTSP::Response).should be_true
+    end
+  end
+
+  describe "#pause" do
+    before :each do
+      @client = setup_client_at "rtsp://localhost"
+      @client.setup("rtsp://localhost/some_track")
+    end
+
+    after :each do
+      @client.teardown "rtsp://localhost"
+    end
+
+    it "changes the session_state from :playing to :ready" do
+      @client.play("rtsp://localhost/some_track")
+      @client.pause("rtsp://localhost/some_track")
+      @client.session_state.should == :ready
+    end
+
+    it "changes the session_state from :recording to :ready" do
+      @client.record("rtsp://localhost/some_track")
+      @client.pause("rtsp://localhost/some_track")
+      @client.session_state.should == :ready
+    end
+
+    it "returns a Response" do
+      response = @client.pause("rtsp://localhost/some_track")
+      response.is_a?(RTSP::Response).should be_true
+    end
+  end
+
+  describe "#teardown" do
+    before :each do
+      @client = setup_client_at "rtsp://localhost"
+      @client.setup("rtsp://localhost/some_track")
+    end
+
+    it "changes the session_state to :init" do
+      @client.session_state.should_not == :init
+      @client.teardown("rtsp://localhost/some_track")
+      @client.session_state.should == :init
+    end
+
+    it "changes the session_id back to 0" do
+      @client.session.should_not be_empty
+      @client.teardown("rtsp://localhost/some_track")
+      @client.session.should be_empty
+    end
+
+    it "returns a Response" do
+      response = @client.teardown("rtsp://localhost/some_track")
+      response.is_a?(RTSP::Response).should be_true
+    end
+  end
+
+  describe "#get_parameter" do
+    before :each do
+      @client = setup_client_at "rtsp://localhost"
+    end
+
+    it "returns a Response" do
+      response = @client.get_parameter("rtsp://localhost/some_track", "ping!")
+      response.is_a?(RTSP::Response).should be_true
+    end
+  end
+
+  describe "#set_parameter" do
+    before :each do
+      @client = setup_client_at "rtsp://localhost"
+    end
+
+    it "returns a Response" do
+      response = @client.set_parameter("rtsp://localhost/some_track", "ping!")
+      response.is_a?(RTSP::Response).should be_true
+    end
+  end
+
+  describe "#record" do
+    before :each do
+      @client = setup_client_at "rtsp://localhost"
+      @client.setup("rtsp://localhost/some_track")
+    end
+
+    it "returns a Response" do
+      response = @client.record("rtsp://localhost/some_track")
+      response.is_a?(RTSP::Response).should be_true
+    end
+
+    it "changes the session_state to :recording" do
+      @client.session_state.should == :ready
+      @client.record("rtsp://localhost/some_track")
+      @client.session_state.should == :recording
+    end
+  end
+
+  describe "#send_message" do
+    it "raises if the send takes longer than the timeout" do
+      pending "until I figure out how to test the time out raises"
+      @client = setup_client_at "rtsp://localhost"
+    end
+  end
+end

data/spec/rtsp/helpers_spec.rb

@@ -0,0 +1,53 @@
+require_relative '../spec_helper'
+require 'rtsp/helpers'
+
+class HelperTest
+  include RTSP::Helpers
+end
+
+describe RTSP::Helpers do
+  describe "#build_resource_uri_from" do
+    before do
+      @my_object = HelperTest.new
+    end
+
+    context "parses the resource URL to a URI" do
+      it "with scheme, IP, path; port defaults to 554" do
+        uri = @my_object.build_resource_uri_from "rtsp://64.202.98.91/sa.sdp"
+        uri.scheme.should == "rtsp"
+        uri.host.should == "64.202.98.91"
+        uri.port.should == 554
+        uri.path.should == "/sa.sdp"
+      end
+
+      it "with IP, path; port defaults to 554; scheme defaults to 'rtsp'" do
+        uri = @my_object.build_resource_uri_from "64.202.98.91/sa.sdp"
+        uri.scheme.should == "rtsp"
+        uri.host.should == "64.202.98.91"
+        uri.port.should == 554
+        uri.path.should == "/sa.sdp"
+      end
+
+      it "with scheme, IP, port" do
+        uri = @my_object.build_resource_uri_from "rtsp://64.202.98.91"
+        uri.scheme.should == "rtsp"
+        uri.host.should == "64.202.98.91"
+        uri.port.should == 554
+        uri.path.should == ""
+        uri.to_s.should == "rtsp://64.202.98.91:554"
+      end
+
+      it "handles passing in a URI" do
+        uri = @my_object.build_resource_uri_from "rtsp://64.202.98.91"
+        lambda { @my_object.build_resource_uri_from uri
+          }.should raise_error
+      end
+
+      it "raises if not given a String" do
+        lambda do
+          @my_object.build_resource_uri_from URI.parse "rtsp://64.202.98.91"
+        end.should raise_exception RTSP::Error
+      end
+    end
+  end
+end