rtsp 0.0.1.alpha → 0.1.0

data/lib/rtsp/error.rb

@@ -0,0 +1,6 @@
+module RTSP
+
+  # Custom error for RTSP problems.
+  class Error < StandardError
+  end
+end

data/lib/rtsp/global.rb

@@ -0,0 +1,63 @@
+require_relative '../ext/logger'
+
+module RTSP
+  module Global
+    DEFAULT_RTSP_PORT = 554
+    DEFAULT_VERSION = '1.0'
+
+    # Sets whether to log RTSP requests & responses.
+    attr_writer :log
+
+    # @return [Boolean] true if logging is enabled; false if it's turned off.
+    def log?
+      @log != false
+    end
+
+    # Sets the type logger to use.
+    attr_writer :logger
+
+    # By default, this creates a standard Ruby Logger.  If a different type was
+    # passed in via +#logger=+, this returns that object.
+    #
+    # @return [Logger]
+    def logger
+      @logger ||= ::Logger.new STDOUT
+    end
+
+    # @return [Symbol] The Logger method to use for logging all messages.
+    attr_writer :log_level
+
+    # The Logger method to use for logging all messages.
+    #
+    # @return [Symbol] Defaults to +:debug+.
+    def log_level
+      @log_level ||= :debug
+    end
+
+    # @param [String] message The string to log.
+    def log(message)
+      logger.send(log_level, message) if log?
+    end
+
+    # Use to disable the raising of +RTSP::Error+s.
+    attr_writer :raise_errors
+
+    # @return [Boolean] true if set to raise errors; false if not.
+    def raise_errors?
+      @raise_errors != false
+    end
+
+    # @return [String] The RTSP version.
+    def rtsp_version
+      @version ||= DEFAULT_VERSION
+    end
+
+    # Resets class variables back to defaults.
+    def reset_config!
+      self.log = true
+      self.logger = ::Logger.new STDOUT
+      self.log_level = :debug
+      self.raise_errors = true
+    end
+  end
+end

data/lib/rtsp/helpers.rb

@@ -0,0 +1,28 @@
+require 'uri'
+require_relative 'global'
+require_relative 'error'
+
+module RTSP
+  module Helpers
+    include RTSP::Global
+
+    # Takes the URL given and turns it into a URI.  This allows for enforcing
+    # values for each part of the URI.
+    #
+    # @param [String] url The URL to turn in to a URI.
+    # @return [URI]
+    def build_resource_uri_from url
+      if url.is_a? String
+        url = "rtsp://#{url}" unless url =~ /^rtsp/
+
+        resource_uri = URI.parse url
+        resource_uri.port ||= DEFAULT_RTSP_PORT
+
+        resource_uri
+
+      else
+        raise RTSP::Error, "url must be a String."
+      end
+    end
+  end
+end

data/lib/rtsp/message.rb

@@ -0,0 +1,270 @@
+require_relative 'helpers'
+require_relative 'error'
+require_relative 'version'
+
+module RTSP
+
+  # This class is responsible for building a single RTSP message that can be
+  # used by both clients and servers.
+  #
+  # Only message types defined in {RFC 2326}[http://tools.ietf.org/html/rfc2326]
+  # are implemented, however if you need to add a new message type (perhaps for
+  # some custom server implementation?), you can simply add to the supported
+  # list by:
+  #    RTSP::Message.message_types << :barrel_roll
+  #
+  # You can then build it like a standard message:
+  #   message = RTSP::Message.barrel_roll("192.168.1.10").with_headers({
+  #   cseq: 123, content_type: "video/x-m4v" })
+  class Message
+    include RTSP::Helpers
+
+    RTSP_ACCEPT_TYPE = "application/sdp"
+    RTSP_DEFAULT_NPT             = "0.000-"
+    RTSP_DEFAULT_SEQUENCE_NUMBER = 1
+    USER_AGENT                   =
+        "RubyRTSP/#{RTSP::VERSION} (Ruby #{RUBY_VERSION}-p#{RUBY_PATCHLEVEL})"
+
+    @message_types = [
+        :announce,
+            :describe,
+            :get_parameter,
+            :options,
+            :play,
+            :pause,
+            :record,
+            :redirect,
+            :set_parameter,
+            :setup,
+            :teardown
+    ]
+
+    # TODO: define #describe somewhere so I can actually test that method.
+    class << self
+
+      # Lists the method/message types this class can create.
+      # @return [Array<Symbol>]
+      attr_accessor :message_types
+
+      # Make sure the class responds to our message types.
+      #
+      # @param [Symbol] method
+      def respond_to?(method)
+        @message_types.include?(method) || super
+      end
+
+      # Creates a new message based on the given method type and URI.
+      #
+      # @param [Symbol] method
+      # @param [Array] args
+      # @return [RTSP::Message]
+      def method_missing(method, *args)
+        request_uri = args.first
+
+        if @message_types.include? method
+          self.new(method, request_uri)
+        else
+          super
+        end
+      end
+    end
+
+    attr_reader :method_type
+    attr_reader :request_uri
+    attr_reader :headers
+    attr_reader :body
+    attr_writer :rtsp_version
+
+    # @param [Symbol] :method_type The RTSP method to build and send.
+    # @param [String] request_uri The URL to communicate to.
+    def initialize(method_type, request_uri)
+      @method_type = method_type
+      @request_uri = build_resource_uri_from request_uri
+      @headers     = default_headers
+      @body        = ""
+      @version     = DEFAULT_VERSION
+    end
+
+    # Adds the header and its value to the list of headers for the message.
+    #
+    # @param [Symbol] type The header type.
+    # @param [] value The value to set the header field to.
+    def header(type, value)
+      if type.is_a? Symbol
+        headers[type] = value
+      else
+        raise RTSP::Error, "Header type must be a Symbol (i.e. :cseq)."
+      end
+    end
+
+    # Use to message-chain with one of the method types; used when creating a
+    # new Message to add headers you want.
+    #
+    # @example Simple header
+    #   RTSP::Message.options("192.168.1.10").with_headers({ cseq: @cseq })
+    # @example Multi-word header
+    #   RTSP::Message.options("192.168.1.10").with_headers({ user_agent:
+    #   'My RTSP Client 1.0' })   # => "OPTIONS 192.168.1.10 RTSP 1.0\r\n
+    #                             #     CSeq: 1\r\n
+    #                             #     User-Agent: My RTSP Client 1.0\r\n"
+    # @param [Hash] new_headers The headers to add to the Request.  The Hash
+    #   key of each will be converted from snake_case to Rtsp-Style.
+    # @return [RTSP::Message]
+    def with_headers(new_headers)
+      add_headers new_headers
+
+      self
+    end
+
+    def add_headers(new_headers)
+      @headers.merge! new_headers
+    end
+
+    # Use when creating a new Message to add body you want.
+    #
+    # @example Simple header
+    #   RTSP::Message.options("192.168.1.10").with_body("The body!")
+    # @param [Hash] new_headers The headers to add to the Request.  The Hash
+    #   key will be capitalized; if
+    def with_body(new_body)
+      add_body new_body
+
+      self
+    end
+
+    def add_body new_body
+      add_headers({ content_length: new_body.length })
+      @body = new_body
+    end
+
+    # @param [String] value Content to send as the body of the message.
+    # Generally this will be a String of some sort, but could be binary data as
+    # well. Also, this adds the Content-Length header to the header list.
+    def body= value
+      add_body value
+    end
+
+    # @return [String] The message as a String.
+    def to_s
+      message.to_s
+    end
+
+    ###########################################################################
+    # PRIVATES
+    private
+
+    # Builds the request message to send to the server/client.
+    #
+    # @return [String]
+    def message
+      message = "#{@method_type.to_s.upcase} #{@request_uri} RTSP/#{@version}\r\n"
+      message << headers_to_s(@headers)
+      message << "\r\n"
+      message << "#{@body}" unless @body.nil?
+
+      #message.each_line { |line| RTSP::Client.log line.strip }
+
+      message
+    end
+
+    # Returns the required/default headers for the provided method.
+    #
+    # @return [Hash] The default headers for the given method.
+    def default_headers
+      headers = {}
+
+      headers[:cseq] ||= RTSP_DEFAULT_SEQUENCE_NUMBER
+      headers[:user_agent] ||= USER_AGENT
+
+      case @method_type
+      when :describe
+        headers[:accept] = RTSP_ACCEPT_TYPE
+      when :announce
+        headers[:content_type] = RTSP_ACCEPT_TYPE
+      when :play
+        headers[:range] = "npt=#{RTSP_DEFAULT_NPT}"
+      when :get_parameter
+        headers[:content_type] = 'text/parameters'
+      when :set_parameter
+        headers[:content_type] = 'text/parameters'
+      else
+        {}
+      end
+
+      headers
+    end
+
+    # Turns headers from Hash(es) into a String, where each element
+    # is a String in the form: [Header Type]: value(s)\r\n.
+    #
+    # @param [Hash] headers The headers to put to string.
+    # @return [String]
+    def headers_to_s headers
+      header_string = headers.inject("") do |result, (key, value)|
+        header_name = key.to_s.split(/_/).map { |header| header.capitalize }.join('-')
+
+        header_name = "CSeq" if header_name == "Cseq"
+
+        if value.is_a?(Hash) || value.is_a?(Array)
+          if header_name == "Content-Type"
+            values = values_to_s(value, ", ")
+          else
+            values = values_to_s(value)
+          end
+
+          result << "#{header_name}: #{values}\r\n"
+        else
+          result << "#{header_name}: #{value}\r\n"
+        end
+
+        result
+      end
+
+      arr = header_string.split "\r\n"
+      # Move the Session header to the top
+      session_index = arr.index { |a| a =~ /Session/ }
+      unless session_index.nil?
+        session = arr.delete_at(session_index)
+        arr.unshift(session)
+      end
+
+      # Move the User-Agent header to the top
+      user_agent_index = arr.index { |a| a =~ /User-Agent/ }
+      unless user_agent_index.nil?
+        user_agent = arr.delete_at(user_agent_index)
+        arr.unshift(user_agent)
+      end
+
+      # Move the CSeq header to the top
+      cseq_index = arr.index { |a| a =~ /CSeq/ }
+      cseq = arr.delete_at(cseq_index)
+      arr.unshift(cseq)
+
+      # Put it all back to a String
+      header_string = arr.join("\r\n")
+      header_string << "\r\n"
+    end
+
+    # Turns header values into a single string.
+    #
+    # @param [] values The header values to put to string.
+    # @param [String] separator The character to use to separate multiple values
+    # that define a header.
+    # @return [String] The header values as a single string.
+    def values_to_s(values, separator=";")
+      result = values.inject("") do |values_string, (header_field, header_field_value)|
+        if header_field.is_a? Symbol
+          values_string << "#{header_field}=#{header_field_value}"
+        elsif header_field.is_a? Hash
+          values_string << values_to_s(header_field)
+        else
+          values_string << header_field.to_s
+        end
+
+        values_string + separator
+      end
+
+      result.sub!(/#{separator}$/, '') if result.end_with? separator
+    end
+  end
+end

data/lib/rtsp/response.rb

@@ -1,74 +1,134 @@
 require 'rubygems'
-require 'socket'
 require 'sdp'
+require_relative 'error'
 
 module RTSP
+
+  # Parses raw response data from the server/client and turns it into
+  # attr_readers.
   class Response
+    attr_reader :rtsp_version
     attr_reader :code
     attr_reader :message
     attr_reader :body
-    
-    def initialize(response)
-      response_array = response.split "\r\n\r\n"
 
-      if response_array.empty?
-        response_array = response.split "\n\n"
+    # @param [String] raw_response The raw response string returned from the
+    # server/client.
+    def initialize(raw_response)
+      if raw_response.nil? || raw_response.empty?
+        raise RTSP::Error, "#{self.class} received nil string--this shouldn't happen."
       end
 
-      head = response_array.first
-      body = response_array.last == head ? "" : response_array.last
+      @raw_response = raw_response
+
+      head, body = split_head_and_body_from @raw_response
       parse_head(head)
       @body = parse_body(body)
     end
 
-    # Reads through each line of the RTSP response and creates a
-    # snake-case accessor with that value set.
+    # @return [String] The unparsed response as a String.
+    def to_s
+      @raw_response
+    end
+
+    # Custom redefine to make sure all the dynamically created instance
+    # variables are displayed when this method is called.
+    #
+    # @return [String]
+    def inspect
+      me = "#<#{self.class.name}:#{self.__id__} "
+
+      self.instance_variables.each do |variable|
+        me << "#{variable}=#{instance_variable_get(variable).inspect}, "
+      end
+
+      me.sub!(/, $/, "")
+      me << ">"
+
+      me
+    end
+
+    # Takes the raw response text and splits it into a 2-element Array, where 0
+    # is the text containing the headers and 1 is the text containing the body.
     #
-    # @param [String] head
+    # @param [String] raw_response
+    # @return [Array<String>] 2-element Array containing the head and body of
+    #   the response.  Body will be nil if there wasn't one in the response.
+    def split_head_and_body_from raw_response
+      head_and_body = raw_response.split("\r\n\r\n", 2)
+      head = head_and_body.first
+      body = head_and_body.last == head ? nil : head_and_body.last
+
+      [head, body]
+    end
+
+    # Pulls out the RTSP version, response code, and response message (AKA the
+    # status line info) into instance variables.
+    #
+    # @param [String] line The String containing the status line info.
+    def extract_status_line(line)
+      line =~ /RTSP\/(\d\.\d) (\d\d\d) ([^\r\n]+)/
+      @rtsp_version = $1
+      @code         = $2.to_i
+      @message      = $3
+
+      if @rtsp_version.nil?
+        raise RTSP::Error, "Status line corrupted: #{line}"
+      end
+    end
+
+    # Reads through each header line of the RTSP response, extracts the response
+    # code, response message, response version, and creates a snake-case
+    # accessor with that value set.
+    #
+    # @param [String] head The section of headers from the response text.
     def parse_head head
       lines = head.split "\r\n"
 
       lines.each_with_index do |line, i|
         if i == 0
-          line =~ /RTSP\/1.0 (\d\d\d) ([^\r\n]+)/
-          @code = $1.to_i
-          @message = $2
+          extract_status_line(line)
           next
         end
         
         if line.include? ": "
-          header_field = line.strip.split(": ")
-          header_name = header_field.first.downcase.gsub(/-/, "_")
-          create_reader(header_name, header_field.last)
+          header_and_value = line.strip.split(":", 2)
+          header_name = header_and_value.first.downcase.gsub(/-/, "_")
+          create_reader(header_name, header_and_value[1].strip)
         end
       end
     end
 
+    # Reads through each line of the RTSP response body and parses it if
+    # needed.  Returns a SDP::Description if the Content-Type is
+    # 'application/sdp', otherwise returns the String that was passed in.
+    #
+    # @param [String] body
+    # @return [SDP::Description,String]
     def parse_body body
-      #response[:body] = read_nonblock(size).split("\r\n") unless @content_length == 0
       if body =~ /^(\r\n|\n)/
         body.gsub!(/^(\r\n|\n)/, '')
       end
 
       if @content_type == "application/sdp"
         SDP.parse body
+      else
+        body
       end
     end
 
-    # @param [Number] size
-    # @param [Hash] options
-    # @option options [Number] time Duration to read on the non-blocking socket.
-    def read_nonblock(size, options={})
-      options[:time] ||= 1
-      buffer = nil
-      timeout(options[:time]) { buffer = @socket.read_nonblock(size) }
-
-      buffer
-    end
-
     private
 
+    # Creates an attr_reader with the name given and sets it to the value that's
+    # given.
+    #
+    # @param [String] name
+    # @param [String] value
     def create_reader(name, value)
+      unless value.empty?
+        value = value =~ /^[0-9]*$/ ? value.to_i : value
+      end
+
       instance_variable_set("@#{name}", value)
       self.instance_eval "def #{name}; @#{name}; end"
     end