vidibus-recording 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+pkg/*
+*.gem
+.bundle
+cli
+recordings

data/Gemfile

@@ -0,0 +1,4 @@
+source :gemcutter
+
+# Specify your gem's dependencies in vidibus-rtmpdump.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,75 @@
+PATH
+  remote: .
+  specs:
+    vidibus-recording (0.0.1)
+      delayed_job_mongoid
+      mongoid (~> 2.0.0.beta.20)
+      open4
+      robustthread
+      vidibus-uuid
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.0.3)
+      activesupport (= 3.0.3)
+      builder (~> 2.1.2)
+      i18n (~> 0.4)
+    activesupport (3.0.3)
+    bson (1.2.0)
+    builder (2.1.2)
+    daemons (1.1.0)
+    delayed_job (2.1.3)
+      activesupport (~> 3.0)
+      daemons
+    delayed_job_mongoid (1.0.2)
+      delayed_job (~> 2.1.1)
+      mongoid (~> 2.0.0.rc)
+    diff-lcs (1.1.2)
+    i18n (0.5.0)
+    macaddr (1.0.0)
+    mongo (1.2.0)
+      bson (>= 1.2.0)
+    mongoid (2.0.0.rc.6)
+      activemodel (~> 3.0)
+      mongo (~> 1.2)
+      tzinfo (~> 0.3.22)
+      will_paginate (~> 3.0.pre)
+    open4 (1.0.1)
+    rake (0.8.7)
+    relevance-rcov (0.9.2.1)
+    robustthread (0.5.2)
+    rr (1.0.2)
+    rspec (2.0.1)
+      rspec-core (~> 2.0.1)
+      rspec-expectations (~> 2.0.1)
+      rspec-mocks (~> 2.0.1)
+    rspec-core (2.0.1)
+    rspec-expectations (2.0.1)
+      diff-lcs (>= 1.1.2)
+    rspec-mocks (2.0.1)
+      rspec-core (~> 2.0.1)
+      rspec-expectations (~> 2.0.1)
+    tzinfo (0.3.24)
+    uuid (2.3.1)
+      macaddr (~> 1.0)
+    vidibus-uuid (0.3.8)
+      mongoid (~> 2.0.0.beta.20)
+      uuid (~> 2.3.1)
+    will_paginate (3.0.pre2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (>= 1.0.0)
+  delayed_job_mongoid
+  mongoid (~> 2.0.0.beta.20)
+  open4
+  rake
+  relevance-rcov
+  robustthread
+  rr
+  rspec (~> 2.0.0.beta.20)
+  vidibus-recording!
+  vidibus-uuid

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Andre Pankratz
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,10 @@
+= Vidibus::Recording
+
+Allows recording of RTMP video streams. Uses RTMPdump.
+Further description goes here.
+
+
+
+== Copyright
+
+Copyright (c) 2011 Andre Pankratz. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/app/models/recording.rb

@@ -0,0 +1,4 @@
+class Recording
+  include Mongoid::Document
+  include Vidibus::Recording::Mongoid
+end

data/lib/vidibus/recording/backend/rtmpdump.rb

@@ -0,0 +1,66 @@
+module Vidibus::Recording::Backend
+  class Rtmpdump
+
+    PROTOCOLS = %[rtmp rtmpt rtmpe rtmpte rtmps rtmpts]
+
+    attr_accessor :stream, :file, :live, :metadata
+
+    def initialize(attributes)
+      self.stream = attributes[:stream] or raise ConfigurationError.new("No input stream given")
+      self.file = attributes[:file] or raise ConfigurationError.new("No output file defined")
+      self.live = attributes[:live]
+    end
+
+    # Command for starting the recording.
+    # Required options:
+    #   :stream, :file
+    # Optional:
+    #   :live
+    #
+    def command(options = {})
+      c = %(rtmpdump -r "#{stream}" -o #{file})
+      c << " --live" if live
+      c
+    end
+
+    # Extract metadata from stdout or stderr.
+    # Output delivered by rtmpdump looks like this:
+    #
+    # RTMPDump v2.2
+    # (c) 2010 Andrej Stepanchuk, Howard Chu, The Flvstreamer Team; license: GPL
+    # Connecting ...
+    # ERROR: rtmp server sent error
+    # Starting Live Stream
+    # Metadata:
+    #   author
+    #   copyright
+    #   description
+    #   keywords
+    #   rating
+    #   title
+    #   presetname            Custom
+    #   creationdate          Mon Jan 17 15:22:50 2011
+    #   videodevice           Osprey-210 Video Device 1
+    #   framerate             25.00
+    #   width                 680.00
+    #   height                394.00
+    #   videocodecid          avc1
+    #   videodatarate         650.00
+    #   avclevel              31.00
+    #   avcprofile            66.00
+    #   videokeyframe_frequency5.00
+    #   audiodevice           Osprey-210 Audio Device 1
+    #   audiosamplerate       22050.00
+    #   audiochannels         1.00
+    #   audioinputvolume      75.00
+    #   audiocodecid          .mp3
+    #   audiodatarate         48.00
+    #
+    def extract_metadata(std)
+      if metadata = std.match(/Metadata\:\n\s+(.+)\Z/m)
+        tuples = $1.scan(/([^\n\s\d]+)\s*([^\n]+)\n/m)
+        self.metadata = Hash[tuples]
+      end
+    end
+  end
+end

data/lib/vidibus/recording/backend.rb

@@ -0,0 +1,25 @@
+module Vidibus::Recording
+  module Backend
+    class ConfigurationError < StandardError; end
+    class ProtocolError < ConfigurationError; end
+
+    BACKENDS = %[rtmpdump]
+    
+    # Returns an instance of a backend processor
+    # that is able to record the given stream.
+    def self.load(attributes)
+      stream = attributes[:stream] or raise ConfigurationError.new("No input stream given")
+      protocol = stream.match(/^[^:]+/).to_s
+      raise ProtocolError.new(%(No protocol could be derived stream "#{stream}")) if protocol == ""
+
+      for backend in BACKENDS
+        require "recording/backend/#{backend}"
+        backend_class = "Vidibus::Recording::Backend::#{backend.classify}".constantize
+        if backend_class::PROTOCOLS.include?(protocol)
+          return backend_class.new(attributes)
+        end
+      end
+      raise ProtocolError.new(%(No recording backend available for "#{protocol}" protocol.))
+    end
+  end
+end

data/lib/vidibus/recording/helpers.rb

@@ -0,0 +1,35 @@
+module Vidibus::Recording
+  module Helpers
+
+    # Recursively fixes classes of value strings
+    def fix_value_classes!(value)
+      c = value.class
+
+      # Get nested items in Hash
+      if c == Hash
+        value.each do |v|
+          value[v[0]] = fix_value_classes!(v[1])
+        end
+
+      # Get nested items in Array
+      elsif c == Array
+        value.each_with_index do |v,i|
+          value[i] = fix_value_classes!(v)
+        end
+
+      # Fix classes of values
+      else
+        if value.match /^\d+[\.,]\d+$/
+          value = value.to_f
+        elsif value.match /^\d+$/
+          value = value.to_i
+        elsif value.match /^true$/
+          value = true
+        elsif value.match /^false$/
+          value = false
+        end
+      end
+      value
+    end
+  end
+end

data/lib/vidibus/recording/job.rb

@@ -0,0 +1,103 @@
+module Vidibus::Recording
+  class Job
+    include Open4
+
+    class ProcessError < StandardError; end
+
+    attr_accessor :recording, :pid
+
+    def initialize(recording)
+      self.recording = recording
+      self.pid = recording.pid
+    end
+
+    def start
+      start_logger
+      self.pid = fork do
+        start_thread
+      end
+      Process.detach(pid)
+      pid
+    end
+
+    def stop
+      if pid and running?
+        Process.kill("SIGTERM", pid)
+        sleep 2
+        raise ProcessError.new("Recording job is still running!") if running?
+      end
+    end
+
+    def running?
+      pid and self.class.running?(pid)
+    end
+
+    def self.running?(pid)
+      begin
+        Process.kill(0, pid)
+        return true
+      rescue Errno::ESRCH
+        return false
+      rescue Errno::EPERM
+        raise ProcessError.new("No permission to check #{pid}")
+      rescue
+        raise ProcessError.new("Unable to determine status for #{pid}: #{$!}")
+      end
+    end
+
+    protected
+
+    def start_thread
+      stdin = ""
+      stdout = ""
+      stderr = ""
+      last_stderr = ""
+      last_stdout = ""
+      task = background(recording.backend.command, 0=>stdin, 1=>stdout, 2=>stderr)
+
+      waiter = Thread.new {y(task.pid => task.exitstatus)} # t.exitstatus is a blocking call!
+      timeout = 5
+
+      while(status = task.status)
+        unless stderr == last_stderr
+          metadata = extract_metadata(stderr)
+          last_stderr = stderr
+        end
+
+        unless stdout == last_stdout
+          metadata = extract_metadata(stdout)
+          last_stdout = stdout
+        end
+
+        unless metadata
+          timeout -= 1
+          if timeout == 0
+            recording.fail("No Metadata has been received. This stream does not work.")
+            return
+          end
+        end
+
+        sleep 2
+      end
+
+      waiter.join
+    end
+
+    def extract_metadata(std)
+      metadata = recording.backend.extract_metadata(std)
+      if metadata
+        File.open(recording.yml_file, "w") do |file|
+          file.write(metadata.to_yaml)
+        end
+      end
+      metadata
+    end
+
+    def start_logger
+      RobustThread.logger = Logger.new(recording.log_file)
+      RobustThread.exception_handler do |exception|
+        RobustThread.log exception
+      end
+    end
+  end
+end

data/lib/vidibus/recording/mongoid.rb

@@ -0,0 +1,195 @@
+module Vidibus::Recording
+  module Mongoid
+    extend ActiveSupport::Concern
+
+    class ProcessError < StandardError; end
+    class StreamError < StandardError; end
+
+    included do
+      include Vidibus::Recording::Helpers
+      include Vidibus::Uuid::Mongoid
+
+      field :name
+      field :stream
+      field :live, :type => Boolean
+      field :pid, :type => Integer
+      field :info, :type => Hash
+      field :size, :type => Integer
+      field :duration, :type => Integer
+      field :log
+      field :error
+      field :scheduled_at, :type => DateTime
+      field :started_at, :type => DateTime
+      field :stopped_at, :type => DateTime
+      field :failed_at, :type => DateTime
+
+      validates :name, :presence => true
+      validates :stream, :format => {:with => /^rtmp.*?:\/\/.+$/}
+
+      before_destroy :cleanup
+    end
+
+    # Starts a recording job now, unless it has been done already.
+    # Provide a Time object to schedule start.
+    def start(time = :now)
+      return false if done? or started?
+      if time == :now
+        job.start
+        update_attributes(:pid => job.pid, :started_at => Time.now)
+        job.pid
+      else
+        schedule(time)
+      end
+    end
+
+    # Resets data and stars anew.
+    def restart(time = :now)
+      stop
+      reset
+      start(time)
+    end
+
+    # Stops the recording job and starts postprocessing.
+    def stop
+      return false if !started_at? or done?
+      job.stop
+      self.pid = nil
+      self.stopped_at = Time.now
+      postprocess
+    end
+
+    # Receives an error from recording job and stores it.
+    # The job gets stopped and postprocessing is started.
+    def fail(msg)
+      return if done?
+      job.stop
+      self.pid = nil
+      self.error = msg
+      self.failed_at = Time.now
+      postprocess
+    end
+
+    # Removes all acquired data
+    def reset
+      remove_files
+      blank = {}
+      [:started_at, :stopped_at, :failed_at, :info, :log, :error, :size, :duration].map {|a| blank[a] = nil }
+      update_attributes(blank)
+    end
+
+    # Returns an instance of the recording job.
+    def job
+      @job ||= Vidibus::Recording::Job.new(self)
+    end
+
+    # Returns an instance of a fitting recording backend.
+    def backend
+      @backend ||= Vidibus::Recording::Backend.load(:stream => stream, :file => file, :live => live)
+    end
+
+    # Returns true if recording has either been stopped or failed.
+    def done?
+      stopped_at or failed?
+    end
+
+    # Returns true if recording has failed.
+    def failed?
+      !!failed_at
+    end
+
+    # Returns true if if job has been started.
+    def started?
+      !!started_at
+    end
+
+    # Returns true if recording job is still running.
+    def running?
+      started? and job.running?
+    end
+
+    # Return folder to store recordings in.
+    def folder
+      @folder ||= begin
+        f = ["recordings"]
+        f.unshift(Rails.root) if defined?(Rails)
+        path = File.join(f)
+        FileUtils.mkdir_p(path) unless File.exist?(path)
+        path
+      end
+    end
+
+    # Returns the file name of this recording.
+    def file
+      @file ||= "#{folder}/#{uuid}.rec"
+    end
+
+    # Returns the log file name for this recording.
+    def log_file
+      @log_file ||= file.gsub(/\.[^\.]+$/, ".log")
+    end
+
+    # Returns the YAML file name for this recording.
+    def yml_file
+      @info_file ||= file.gsub(/\.[^\.]+$/, ".yml")
+    end
+
+    protected
+
+    def schedule(time)
+      self.delay(:run_at => time).start
+    end
+
+    def postprocess
+      process_log_file
+      process_yml_file
+      set_size
+      set_duration
+      save!
+    end
+
+    def process_log_file
+      if str = read_file(log_file)
+        str.gsub!(/\A[^\n]+\n/, "") # remove first line
+        unless str == ""
+          self.log = str
+        end
+      end
+    end
+
+    def process_yml_file
+      if str = read_file(yml_file)
+        if values = YAML::load(str)
+          fix_value_classes!(values)
+          self.info = values
+        end
+      end
+    end
+
+    def set_size
+      self.size = File.exists?(file) ? File.size(file) : nil
+    end
+
+    def set_duration
+      self.duration = failed? ? 0 : Time.now - started_at
+    end
+
+    def read_file(file)
+      if File.exists?(file)
+        str = File.read(file)
+        File.delete(file)
+        str
+      end
+    end
+
+    def cleanup
+      job.stop
+      remove_files
+    end
+
+    def remove_files
+      [file, log_file, yml_file].each do |f|
+        File.delete(f) if File.exists?(f)
+      end
+    end
+  end
+end

data/lib/vidibus/recording/version.rb

@@ -0,0 +1,5 @@
+module Vidibus
+  module Recording
+    VERSION = "0.0.1"
+  end
+end

data/lib/vidibus/recording.rb

@@ -0,0 +1,4 @@
+require "recording/job"
+require "recording/backend"
+require "recording/helpers"
+require "recording/mongoid"

data/lib/vidibus-recording.rb

@@ -0,0 +1,17 @@
+require "open4"
+require "yaml"
+require "robustthread"
+require "delayed_job_mongoid"
+require "active_support/core_ext"
+require "vidibus-uuid"
+
+module Vidibus
+  module Recording
+    if defined?(Rails)
+      class Engine < ::Rails::Engine; end
+    end
+  end
+end
+
+$:.unshift(File.join(File.dirname(__FILE__), "vidibus"))
+require "recording"

data/spec/spec_helper.rb

@@ -0,0 +1,38 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+
+require "rubygems"
+require "rspec"
+require "rr"
+require "mongoid"
+
+require "vidibus-recording"
+require "app/models/recording"
+
+Mongoid.configure do |config|
+  name = "vidibus-recording_test"
+  host = "localhost"
+  config.master = Mongo::Connection.new.db(name)
+  config.logger = nil
+end
+
+RSpec.configure do |config|
+  config.mock_with :rr
+  config.before(:each) do
+    Mongoid.master.collections.select {|c| c.name !~ /system/}.each(&:drop)
+  end
+end
+
+# Helper for stubbing time. Define String to be set as Time.now.
+# Usage:
+#   stub_time('01.01.2010 14:00')
+#   stub_time(2.days.ago)
+#
+def stub_time(string = nil)
+  string ||= Time.now.to_s(:db)
+  now = Time.parse(string.to_s)
+  stub(Time).now { now }
+  now
+end
+
+#I18n.load_path += Dir[File.join('config', 'locales', '**', '*.{rb,yml}')]

data/spec/vidibus/recording/backend_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+describe "Vidibus::Recording::Backend" do
+
+  describe ".load" do
+    it "should return an error unless a stream attribute is given" do
+      expect {
+        Vidibus::Recording::Backend.load({})
+      }.to raise_error(Vidibus::Recording::Backend::ConfigurationError)
+    end
+
+    it "should return a backend instance for given stream protocol" do
+      Vidibus::Recording::Backend.load(:stream => "rtmp://something", :file => "test").
+        should be_an_instance_of(Vidibus::Recording::Backend::Rtmpdump)
+    end
+
+    it "should return an error unless a stream attribute with consumable protocol is given" do
+      expect {
+        Vidibus::Recording::Backend.load({:stream => "mms://something", :file => "test"})
+      }.to raise_error(Vidibus::Recording::Backend::ProtocolError)
+    end
+
+    it "should return an error unless a stream attribute with a protocol is given" do
+      expect {
+        Vidibus::Recording::Backend.load({:stream => "something", :file => "test"})
+      }.to raise_error(Vidibus::Recording::Backend::ProtocolError)
+    end
+  end
+end

data/spec/vidibus/recording/mongoid_spec.rb

@@ -0,0 +1,111 @@
+require "spec_helper"
+
+describe "Vidibus::Recording::Mongoid" do
+
+  let(:this) do
+    Recording.new(:name => "N-TV Live", :stream => "rtmp://fms.rtl.de/ntvlive/livestream/channel1", :live => true)
+  end
+
+  def cleanup(recording)
+    Process.kill("SIGTERM", recording.pid) if recording.pid
+    delete_safely(recording.file)
+    delete_safely(recording.log_file)
+    delete_safely(recording.yml_file)
+  end
+
+  def delete_safely(file)
+    return unless file.match(/.{32}\..{3}/)
+    File.delete(file) if File.exists?(file)
+  end
+
+  describe "validation" do
+    it "should pass with valid attributes" do
+      this.should be_valid
+    end
+
+    it "should fail without a stream" do
+      this.stream = nil
+      this.should be_invalid
+    end
+
+    it "should fail without a valid stream address" do
+      this.stream = "something"
+      this.should be_invalid
+    end
+
+    it "should fail without a valid rtmp stream address" do
+      this.stream = "rtmp://something"
+      this.should be_valid
+    end
+
+    it "should fail without a name" do
+      this.name = nil
+      this.should be_invalid
+    end
+  end
+
+  describe "job" do
+    it "should return a job instance" do
+      this.job.should be_an_instance_of(Vidibus::Recording::Job)
+    end
+  end
+
+  describe "backend" do
+    it "should return a backend instance for given stream protocol" do
+      this.backend.should be_an_instance_of(Vidibus::Recording::Backend::Rtmpdump)
+    end
+  end
+
+  describe "start" do
+    before {this.save}
+
+    it "should return a process id" do
+      this.start.should be_a(Fixnum)
+    end
+
+    context "without params" do
+      it "should start a recording job now" do
+        pid = this.start
+        Vidibus::Recording::Job.running?(pid).should be_true
+      end
+    end
+
+    context "with a given Time" do
+      it "should schedule a recording job" do
+        stub_time("2011-01-12 00:00")
+        run_at = 10.minutes.since
+        this.start(run_at)
+        Delayed::Backend::Mongoid::Job.count.should eql(1)
+        Delayed::Backend::Mongoid::Job.first.run_at.should eql(run_at)
+      end
+    end
+
+    after {cleanup(this)}
+  end
+
+  describe "stop" do
+    before {this.save}
+
+    it "should return false unless recording has been started" do
+      this.stop.should be_false
+    end
+
+    it "should return false if recording is done" do
+      this.stopped_at = Time.now
+      this.stop.should be_false
+    end
+
+    context "with started job" do
+      before {this.start}
+
+      it "should stop the recording job" do
+        pid = this.pid
+        this.stop
+        sleep 1
+        Vidibus::Recording::Job.running?(pid).should be_false
+      end
+
+      after {cleanup(this)}
+    end
+  end
+end

data/vidibus-recording.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path("../lib/vidibus/recording/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name              = "vidibus-recording"
+  s.rubyforge_project = "vidibus-recording"
+  s.version           = Vidibus::Recording::VERSION
+  s.platform          = Gem::Platform::RUBY
+  s.authors           = "Andre Pankratz"
+  s.email             = "andre@vidibus.com"
+  s.homepage          = "http://rubygems.org/gems/vidibus-rtmpdump"
+  s.summary           = "Video stream recording tools"
+  s.description       = "Allows recording of RTMP video streams. Uses RTMPdump."
+
+  s.required_rubygems_version = ">= 1.3.6"
+
+  s.add_dependency "mongoid", "~> 2.0.0.beta.20"
+  s.add_dependency "open4"
+  s.add_dependency "robustthread"
+  s.add_dependency "delayed_job_mongoid"
+
+  s.add_dependency "vidibus-uuid"
+
+  s.add_development_dependency "bundler", ">= 1.0.0"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec", "~> 2.0.0.beta.20"
+  s.add_development_dependency "rr"
+  s.add_development_dependency "relevance-rcov"
+
+  s.files        = `git ls-files`.split("\n")
+  s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
+  s.require_path = 'lib'
+end

metadata

@@ -0,0 +1,236 @@
+--- !ruby/object:Gem::Specification 
+name: vidibus-recording
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Andre Pankratz
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-23 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mongoid
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 62196427
+        segments: 
+        - 2
+        - 0
+        - 0
+        - beta
+        - 20
+        version: 2.0.0.beta.20
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: open4
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: robustthread
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: delayed_job_mongoid
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: vidibus-uuid
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 62196427
+        segments: 
+        - 2
+        - 0
+        - 0
+        - beta
+        - 20
+        version: 2.0.0.beta.20
+  type: :development
+  version_requirements: *id008
+- !ruby/object:Gem::Dependency 
+  name: rr
+  prerelease: false
+  requirement: &id009 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id009
+- !ruby/object:Gem::Dependency 
+  name: relevance-rcov
+  prerelease: false
+  requirement: &id010 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id010
+description: Allows recording of RTMP video streams. Uses RTMPdump.
+email: andre@vidibus.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.rdoc
+- Rakefile
+- app/models/recording.rb
+- lib/vidibus-recording.rb
+- lib/vidibus/recording.rb
+- lib/vidibus/recording/backend.rb
+- lib/vidibus/recording/backend/rtmpdump.rb
+- lib/vidibus/recording/helpers.rb
+- lib/vidibus/recording/job.rb
+- lib/vidibus/recording/mongoid.rb
+- lib/vidibus/recording/version.rb
+- spec/spec_helper.rb
+- spec/vidibus/recording/backend_spec.rb
+- spec/vidibus/recording/mongoid_spec.rb
+- vidibus-recording.gemspec
+has_rdoc: true
+homepage: http://rubygems.org/gems/vidibus-rtmpdump
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: vidibus-recording
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Video stream recording tools
+test_files: []
+