vidibus-recording 0.0.7 → 1.0.0

data/README.rdoc

@@ -3,8 +3,9 @@
 Allows recording of RTMP video streams. Uses RTMPdump.
 Further description goes here.
 
+Requires Ruby 1.9
 
 
 == Copyright
 
-Copyright (c) 2011 Andre Pankratz. See LICENSE for details.
+Copyright (c) 2013 Andre Pankratz. See LICENSE for details.

data/Rakefile

@@ -1,2 +1,16 @@
+$:.unshift File.expand_path('../lib/', __FILE__)
+
 require 'bundler'
+require 'rdoc/task'
+require 'rspec'
+require 'rspec/core/rake_task'
+
 Bundler::GemHelper.install_tasks
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = 'Vidibus::Encoder'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.options << '--charset=utf-8'
+end

data/lib/generators/vidibus/recording_generator.rb

@@ -0,0 +1,14 @@
+require 'rails/generators'
+require 'rails/generators/named_base'
+
+module Vidibus
+  class RecorderGenerator < Rails::Generators::Base
+
+    self.source_paths << File.join(File.dirname(__FILE__), 'templates')
+
+    def create_script_file
+      template 'script', 'script/recording'
+      chmod 'script/recording', 0755
+    end
+  end
+end

data/lib/generators/vidibus/templates/script

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require File.expand_path('../../config/environment', __FILE__)
+require 'vidibus/recorder/daemon'
+
+Vidibus::WatchFolder::Daemon.new(ARGV).daemonize

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

@@ -0,0 +1 @@
+railtie.rb

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

@@ -5,6 +5,14 @@ module Vidibus::Recording::Backend
 
     attr_accessor :stream, :file, :live, :metadata
 
+    def self.executable=(path)
+      @executable = path
+    end
+
+    def self.executable
+      @executable || 'rtmpdump'
+    end
+
     # Sets up a new dumper.
     #
     # Required attributes:
@@ -14,9 +22,11 @@ module Vidibus::Recording::Backend
     #   :live
     #
     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.stream = attributes[:stream]
+      self.file = attributes[:file]
       self.live = attributes[:live]
+      raise ConfigurationError.new('No output file defined') unless file
+      raise ConfigurationError.new('No input stream given') unless stream
     end
 
     # Command for starting the recording.
@@ -26,16 +36,15 @@ module Vidibus::Recording::Backend
         a << "-o #{file}"
         a << "--live" if live
       end
-      %(rtmpdump #{args.join(" ")} 2>&1)
+      %(#{self.class.executable} #{args.join(" ")} 2>&1)
     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
+    # (c) 2010 Andrej Stepanchuk, Howard Chu, The Flvstreamer Team
     # Connecting ...
-    # ERROR: rtmp server sent error
     # Starting Live Stream
     # Metadata:
     #   author
@@ -69,5 +78,20 @@ module Vidibus::Recording::Backend
         self.metadata = Hash[tuples]
       end
     end
+
+    # Extract metadata from stdout or stderr.
+    # Output delivered by rtmpdump looks like this:
+    #
+    # RTMPDump v2.4
+    # (c) 2010 Andrej Stepanchuk, Howard Chu, The Flvstreamer Team
+    # Connecting ...
+    # ERROR: Problem accessing the DNS. (addr: whatever.domain)
+    #
+    def detect_error(string)
+      prefix = /(?:ERROR\:\ (.+))/ if string.match(/ERROR\:/)
+      if string.match(/(?:ERROR\:\ (.+))/)
+        raise RuntimeError.new($1)
+      end
+    end
   end
 end

data/lib/vidibus/recording/backend.rb

@@ -1,5 +1,8 @@
+require 'vidibus/recording/backend/rtmpdump'
+
 module Vidibus::Recording
   module Backend
+    class RuntimeError < StandardError; end
     class ConfigurationError < StandardError; end
     class ProtocolError < ConfigurationError; end
 
@@ -8,12 +11,12 @@ module Vidibus::Recording
     # 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")
+      stream = attributes[:stream]
+      raise ConfigurationError.new("No input stream given") unless stream
       protocol = stream.match(/^[^:]+/).to_s
-      raise ProtocolError.new(%(No protocol could be derived stream "#{stream}")) if protocol == ""
+      raise ProtocolError.new(%(No protocol could be derived stream "#{stream}")) if protocol == ''
 
       for backend in BACKENDS
-        require "vidibus/recording/backend/#{backend}"
         backend_class = "Vidibus::Recording::Backend::#{backend.classify}".constantize
         if backend_class::PROTOCOLS.include?(protocol)
           return backend_class.new(attributes)

data/lib/vidibus/recording/capistrano/recipes.rb

@@ -0,0 +1,40 @@
+# Capistrano Recipes for watching folders.
+#
+# Load this file from your Capistrano config.rb:
+# require 'vidibus/recording/capistrano/recipes'
+#
+# Add these callbacks to have the recording process restart when the server
+# is restarted:
+#
+#   after 'deploy:stop',    'vidibus:recording:stop'
+#   after 'deploy:start',   'vidibus:recording:start'
+#   after 'deploy:restart', 'vidibus:recording:restart'
+#
+Capistrano::Configuration.instance.load do
+  namespace :vidibus do
+    namespace :recording do
+      def rails_env
+        fetch(:rails_env, false) ? "RAILS_ENV=#{fetch(:rails_env)}" : ''
+      end
+
+      def roles
+        fetch(:app)
+      end
+
+      desc 'Stop the recording process'
+      task :stop, :roles => lambda { roles } do
+        run "cd #{current_path};#{rails_env} script/recording stop"
+      end
+
+      desc 'Start the recording process'
+      task :start, :roles => lambda { roles } do
+        run "cd #{current_path};#{rails_env} script/recording start"
+      end
+
+      desc 'Restart the recording process'
+      task :restart, :roles => lambda { roles } do
+        run "cd #{current_path};#{rails_env} script/recording restart"
+      end
+    end
+  end
+end

data/lib/vidibus/recording/capistrano.rb

@@ -0,0 +1,12 @@
+require 'vidibus/recording/capistrano/recipes'
+
+# Run Capistrano Recipes for watching folders.
+#
+# Load this file from your Capistrano config.rb:
+# require 'vidibus/watch_folder/capistrano'
+#
+Capistrano::Configuration.instance.load do
+  after 'deploy:stop',    'vidibus:watch_folder:stop'
+  after 'deploy:start',   'vidibus:watch_folder:start'
+  after 'deploy:restart', 'vidibus:watch_folder:restart'
+end

data/lib/vidibus/recording/daemon.rb

@@ -0,0 +1,46 @@
+begin
+  require 'daemons'
+rescue LoadError
+  raise %(Please add `gem 'daemons' gem to your Gemfile for this to work)
+end
+require 'optparse'
+
+module Vidibus
+  module Recorder
+    class Daemon
+
+      def initialize(args)
+        @options = {:pid_dir => "#{Rails.root}/tmp/pids"}
+        options = OptionParser.new do |options|
+          options.banner = "Usage: #{File.basename($0)} start|stop|restart"
+          options.on('-h', '--help', 'Show this message') do
+            puts options
+            exit 1
+          end
+        end
+        @args = options.parse!(args)
+      end
+
+      def daemonize
+        dir = @options[:pid_dir]
+        Dir.mkdir(dir) unless File.exists?(dir)
+        run_process('recording', dir)
+      end
+
+      def run_process(name, dir)
+        Daemons.run_proc(name, :dir => dir, :dir_mode => :normal) { run }
+      end
+
+      def run
+        Dir.chdir(Rails.root)
+        log = File.join(Rails.root, 'log', 'recording.log')
+        Vidibus::Recorder.logger = ActiveSupport::BufferedLogger.new(log)
+        Vidibus::Recorder.monitor
+      rescue => e
+        Vidibus::Recorder.logger.fatal(e)
+        STDERR.puts(e.message)
+        exit 1
+      end
+    end
+  end
+end

data/lib/vidibus/recording/helpers.rb

@@ -32,4 +32,4 @@ module Vidibus::Recording
       value
     end
   end
-end
+end

data/lib/vidibus/recording/mongoid.rb

@@ -2,17 +2,15 @@ module Vidibus::Recording
   module Mongoid
     extend ActiveSupport::Concern
 
-    class ProcessError < StandardError; end
-    class StreamError < StandardError; end
-
     included do
       include ::Mongoid::Timestamps
-      include Vidibus::Recording::Helpers
       include Vidibus::Uuid::Mongoid
 
+      embeds_many :parts, :as => :recording, :class_name => 'Vidibus::Recording::Part'
+
       field :name
       field :stream
-      field :live, :type => Boolean
+      # field :live, :type => Boolean
       field :pid, :type => Integer
       field :info, :type => Hash
       field :size, :type => Integer
@@ -22,6 +20,8 @@ module Vidibus::Recording
       field :started_at, :type => DateTime
       field :stopped_at, :type => DateTime
       field :failed_at, :type => DateTime
+      field :running, :type => Boolean, :default => false
+      field :monitoring_job_identifier, :type => String
 
       validates :name, :presence => true
       validates :stream, :format => {:with => /^rtmp.*?:\/\/.+$/}
@@ -29,67 +29,107 @@ module Vidibus::Recording
       before_destroy :cleanup
     end
 
-    # Starts a recording job now, unless it has been done already.
+    # Starts a recording worker now, unless it has been done already.
     # Provide a Time object to schedule start.
     def start(time = :now)
-      return false if done? or started?
+      return false if done? || started?
       if time == :now
-        job.start
-        update_attributes(:pid => job.pid, :started_at => Time.now)
-        job.pid
+        self.started_at = Time.now
+        start_worker
+        start_monitoring_job
+        save!
       else
         schedule(time)
       end
     end
 
-    # Resets data and stars anew.
-    def restart(time = :now)
+    # Continue recording that is not running anymore.
+    def resume
+      return false if running? || !started?
+      self.stopped_at = nil
+      self.failed_at = nil
+      start_worker
+      start_monitoring_job
+      save!
+    end
+
+    # Resets data and starts anew.
+    def restart
       stop
       reset
-      start(time)
+      start
     end
 
-    # Stops the recording job and starts postprocessing.
+    # Stops the recording worker and starts postprocessing.
     def stop
-      return false if !started_at? or done?
-      job.stop
+      return false if done? || !started?
+      worker.stop
       self.pid = nil
       self.stopped_at = Time.now
+      self.running = false
+      self.monitoring_job_identifier = nil
+      postprocess
+    end
+
+    # Gets called from recording worker if it receives no more data.
+    def halt(msg = nil)
+      return false unless running?
+      worker.stop
+      self.pid = nil
+      self.running = false
       postprocess
     end
 
-    # Receives an error from recording job and stores it.
-    # The job gets stopped and postprocessing is started.
+    # Receives an error from recording worker and stores it.
+    # The worker gets stopped and postprocessing is started.
     def fail(msg)
-      return if done?
-      job.stop
+      return false unless running?
+      worker.stop
       self.pid = nil
       self.error = msg
       self.failed_at = Time.now
+      self.running = false
       postprocess
     end
 
-    # Removes all acquired data
+    # TODO: really a public method?
+    # 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)
+      [
+        :started_at,
+        :stopped_at,
+        :failed_at,
+        :info,
+        :error,
+        :size,
+        :duration,
+        :monitoring_job_identifier
+      ].map {|a| blank[a] = nil }
+      update_attributes!(blank)
+      destroy_all_parts
     end
 
-    # Returns an instance of the recording job.
-    def job
-      @job ||= Vidibus::Recording::Job.new(self)
+    # TODO: really a public method?
+    # Returns an instance of the recording worker.
+    def worker
+      @worker ||= Vidibus::Recording::Worker.new(self)
     end
 
+    # TODO: really a public method?
     # Returns an instance of a fitting recording backend.
     def backend
-      @backend ||= Vidibus::Recording::Backend.load(:stream => stream, :file => file, :live => live)
+      @backend ||= Vidibus::Recording::Backend.load({
+        :stream => stream,
+        :file => current_part.data_file,
+        :live => true
+      })
     end
 
     # Returns true if recording has either been stopped or failed.
     def done?
-      stopped_at or failed?
+      stopped? || failed?
     end
 
     # Returns true if recording has failed.
@@ -97,20 +137,35 @@ module Vidibus::Recording
       !!failed_at
     end
 
-    # Returns true if if job has been started.
+    # Returns true if recording has been started.
     def started?
       !!started_at
     end
 
-    # Returns true if recording job is still running.
-    def running?
-      started? and job.running?
+    def stopped?
+      !!stopped_at
+    end
+
+    def has_data?
+      size.to_i > 0
+    end
+
+    # Returns true if recording worker is still running.
+    # Persists attributes accordingly.
+    def worker_running?
+      if worker.running?
+        update_attributes(:running => true) unless running?
+        true
+      else
+        update_attributes(:pid => nil, :running => false)
+        false
+      end
     end
 
     # Return folder to store recordings in.
     def folder
       @folder ||= begin
-        f = ["recordings"]
+        f = ['recordings']
         f.unshift(Rails.root) if defined?(Rails)
         path = File.join(f)
         FileUtils.mkdir_p(path) unless File.exist?(path)
@@ -118,64 +173,115 @@ module Vidibus::Recording
       end
     end
 
-    # Returns the file name of this recording.
-    def file
-      @file ||= "#{folder}/#{uuid}.rec"
+    def basename
+      "#{folder}/#{uuid}"
     end
 
     # Returns the log file name for this recording.
     def log_file
-      @log_file ||= file.gsub(/\.[^\.]+$/, ".log")
+      @log_file ||= "#{basename}.log"
+    end
+
+    # Returns the file name of this recording.
+    # DEPRECATED: this is kept for existing records only.
+    def file
+      @file ||= "#{basename}.rec"
     end
 
     # Returns the YAML file name for this recording.
+    # DEPRECATED: this is kept for existing records only.
     def yml_file
-      @info_file ||= file.gsub(/\.[^\.]+$/, ".yml")
+      @yml_file ||= "#{basename}.yml"
     end
 
-    protected
-
-    def schedule(time)
-      self.delay(:run_at => time).start
+    def current_part
+      parts.last
     end
 
-    def postprocess
-      process_yml_file
+    def track_progress
+      current_part.track_progress if current_part
       set_size
       set_duration
       save!
     end
 
-    def process_yml_file
-      if str = read_file(yml_file)
-        if values = YAML::load(str)
-          fix_value_classes!(values)
-          self.info = values
+    private
+
+    def destroy_all_parts
+      parts.each do |part|
+        part.destroy
+      end
+      self.update_attributes!(:parts => [])
+    end
+
+    def start_worker
+      return if worker_running?
+      setup_next_part
+      worker.start
+      self.running = true
+      self.pid = worker.pid
+    end
+
+    # Start a new monitoring job
+    def start_monitoring_job
+      self.monitoring_job_identifier = Vidibus::Uuid.generate
+      Vidibus::Recording::MonitoringJob.create({
+        :class_name => self.class.to_s,
+        :uuid => uuid,
+        :identifier => monitoring_job_identifier
+      })
+    end
+
+    def setup_next_part
+      number = nil
+      if current_part
+        if current_part.has_data?
+          number = current_part.number + 1
+        else
+          current_part.reset
         end
+      else
+        number = 1
       end
+      if number
+        parts.build(:number => number)
+      end
+      current_part.start
+    end
+
+    def schedule(time)
+      self.delay(:run_at => time).start
+    end
+
+    def postprocess
+      current_part.postprocess if current_part
+      set_size
+      set_duration
+      save!
     end
 
     def set_size
-      self.size = File.exists?(file) ? File.size(file) : nil
+      accumulate_parts(:size)
     end
 
     def set_duration
-      self.duration = failed? ? 0 : Time.now - started_at
+      accumulate_parts(:duration)
     end
 
-    def read_file(file)
-      if File.exists?(file)
-        str = File.read(file)
-        File.delete(file)
-        str
+    def accumulate_parts(attr)
+      value = 0
+      parts.each do |part|
+        value += part.send(attr).to_i
       end
+      self.send("#{attr}=", value)
     end
 
     def cleanup
-      job.stop
+      worker.stop
       remove_files
     end
 
+    # DEPRECATED: this is kept for existing records only.
     def remove_files
       [file, log_file, yml_file].each do |f|
         File.delete(f) if File.exists?(f)

data/lib/vidibus/recording/monitoring_job.rb

@@ -0,0 +1,52 @@
+module Vidibus::Recording
+  class MonitoringJob
+    INTERVAL = 10.seconds
+
+    def initialize(args)
+      unless @uuid = args[:uuid]
+        raise(ArgumentError, 'No recording UUID given')
+      end
+      unless @class_name = args[:class_name]
+        raise(ArgumentError, 'Must provide class name of recording')
+      end
+      unless @identifier = args[:identifier]
+        raise(ArgumentError, 'Must provide identifier of monitoring job')
+      end
+      ensure_recording
+    end
+
+    def perform
+      r = recording.reload
+      return unless r.monitoring_job_identifier == @identifier
+      if r.worker_running?
+        r.track_progress
+        run_again
+      elsif !r.stopped?
+        r.resume
+      end
+    end
+
+    # Returns job
+    def self.create(args)
+      job = new(args)
+      Delayed::Job.enqueue(job)
+    end
+
+    private
+
+    def recording
+      @class_name.constantize.where(:uuid => @uuid).first
+    end
+
+    def ensure_recording
+      recording || raise(ArgumentError, 'No valid recording UUID given')
+    end
+
+    def run_again
+      obj = self.class.new({
+        :uuid => @uuid, :class_name => @class_name, :identifier => @identifier
+      })
+      Delayed::Job.enqueue(obj, 0, INTERVAL.from_now)
+    end
+  end
+end

data/lib/vidibus/recording/part.rb

@@ -0,0 +1,106 @@
+module Vidibus::Recording
+  class Part
+    include Mongoid::Document
+    include Mongoid::Timestamps
+    include Vidibus::Recording::Helpers
+
+    SIZE_THRESHOLD = 2000
+
+    embedded_in :recording, :polymorphic => true
+
+    field :number, :type => Integer
+    field :info, :type => Hash
+    field :size, :type => Integer
+    field :duration, :type => Integer
+    field :started_at, :type => DateTime
+    field :stopped_at, :type => DateTime
+
+    validates :number, :presence => true
+
+    before_destroy :remove_files
+
+    # Returns the file path of this part.
+    def data_file
+      @data_file ||= "#{basename}.f4v"
+    end
+
+    # Returns the YAML file path of this part.
+    def yml_file
+      @yml_file ||= "#{basename}.yml"
+    end
+
+    def has_data?
+      size.to_i >= SIZE_THRESHOLD
+    end
+
+    def stopped?
+      !!stopped_at
+    end
+
+    def reset
+      remove_files
+      blanks = {}
+      [
+        :info,
+        :size,
+        :duration,
+        :started_at
+      ].map {|a| blanks[a] = nil }
+      update_attributes(blanks)
+    end
+
+    def track_progress
+      set_size
+      set_duration
+    end
+
+    def postprocess
+      process_yml_file
+      track_progress
+      self.stopped_at = Time.now
+      # save!
+    end
+
+    def start
+      self.started_at = Time.now
+      self.stopped_at = nil
+    end
+
+    private
+
+    def process_yml_file
+      if str = read_and_delete_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?(data_file) ? File.size(data_file) : 0
+    end
+
+    def set_duration
+      self.duration = has_data? ? Time.now - started_at : 0
+    end
+
+    def read_and_delete_file(file)
+      if File.exists?(file)
+        str = File.read(file)
+        File.delete(file)
+        str
+      end
+    end
+
+    def basename
+      "#{_parent.basename}_#{number}"
+    end
+
+    def remove_files
+      [data_file, yml_file].each do |f|
+        File.delete(f) if File.exists?(f)
+      end
+    end
+  end
+end

data/lib/vidibus/recording/railtie.rb

@@ -0,0 +1 @@
+railtie.rb

data/lib/vidibus/recording/version.rb

@@ -1,5 +1,5 @@
 module Vidibus
   module Recording
-    VERSION = '0.0.7'
+    VERSION = '1.0.0'
   end
 end

data/lib/vidibus/recording/worker.rb

@@ -0,0 +1,135 @@
+require 'timeout'
+
+module Vidibus::Recording
+  class Worker
+    class ProcessError < StandardError; end
+
+    # START_TIMEOUT = 20
+    STOP_TIMEOUT = 10
+
+    attr_accessor :recording, :pid, :metadata
+
+    def initialize(recording)
+      self.recording = recording
+      self.pid = recording.pid
+      self.metadata = nil
+    end
+
+    def start
+      self.pid = fork do
+        begin
+          record
+        rescue => e
+          fail(e.inspect)
+        end
+      end
+      Process.detach(pid)
+      pid
+    end
+
+    def stop
+      if running?
+        begin
+          Timeout::timeout(STOP_TIMEOUT) do
+            begin
+              log("Stopping process #{pid}...")
+              # Use SIGQUIT to terminate because DelayedJob traps INT and TERM
+              Process.kill('SIGQUIT', pid)
+              Process.wait(pid)
+              log('STOPPED')
+            rescue Errno::ECHILD
+              log('STOPPED')
+            end
+          end
+        rescue Timeout::Error
+          begin
+            log("Killing process #{pid}")
+            Process.kill('KILL', pid)
+            Process.wait(pid)
+            log('KILLED')
+          rescue Errno::ECHILD
+            log('KILLED')
+          end
+        end
+      end
+    end
+
+    def running?
+      return false unless pid
+      begin
+        Process.kill(0, pid)
+        return true
+      rescue Errno::ESRCH
+        return false
+      rescue Errno::EPERM
+        raise ProcessError.new("No permission to check process #{pid}")
+      rescue
+        raise ProcessError.new("Unable to determine status of process #{pid}: #{$!}")
+      end
+    end
+
+    protected
+
+    def record
+      cmd = recording.backend.command
+      log("START: #{recording.stream}", true)
+      Open3::popen3(cmd) do |stdin, stdout, stderr|
+        maxloops = 10
+        loop do
+          begin
+            string = stdout.read_nonblock(1024).force_encoding('UTF-8')
+            log(string)
+            extract_metadata(string) unless metadata
+            recording.backend.detect_error(string)
+          rescue Errno::EAGAIN
+          rescue EOFError
+            if metadata
+              halt('No more data!') && break
+            end
+          rescue Backend::RuntimeError => e
+            fail(e.message) && break
+          end
+          unless metadata
+            maxloops -= 1
+            if maxloops == 0
+              halt('No Metadata has been received so far.') && break
+            end
+          end
+          sleep 2
+        end
+      end
+    end
+
+    def log(msg, print_header = false)
+      if print_header
+        header = "--- #{Time.now.strftime('%F %R:%S %z')}"
+        header << " | Process #{Process.pid}"
+        msg = "#{header}\n#{msg}\n"
+      end
+      msg = "\n#{msg}" unless msg[/A\n/]
+      File.open(recording.log_file, "a") do |f|
+        f.write(msg)
+      end
+    end
+
+    def fail(msg)
+      log("ERROR: #{msg}", true)
+      recording.reload.fail(msg)
+    end
+
+    def halt(msg)
+      log("HALT: #{msg}", true)
+      recording.reload.halt(msg)
+    end
+
+    def extract_metadata(string)
+      self.metadata = recording.backend.extract_metadata(string)
+      if metadata
+        File.open(recording.current_part.yml_file, 'w') do |f|
+          f.write(metadata.to_yaml)
+        end
+      end
+      metadata
+    end
+  end
+end

data/lib/vidibus/recording.rb

@@ -1,4 +1,6 @@
-require 'vidibus/recording/job'
+require 'vidibus/recording/worker'
+require 'vidibus/recording/monitoring_job'
 require 'vidibus/recording/backend'
 require 'vidibus/recording/helpers'
+require 'vidibus/recording/part'
 require 'vidibus/recording/mongoid'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vidibus-recording
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 1.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-30 00:00:00.000000000 Z
+date: 2013-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -124,39 +124,39 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rcov
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: rr
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: '2'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: '2'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: rr
+  name: simplecov
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -177,12 +177,21 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/generators/vidibus/recording_generator.rb
+- lib/generators/vidibus/templates/script
+- lib/vidibus/recording/backend/railtie.rb
 - lib/vidibus/recording/backend/rtmpdump.rb
 - lib/vidibus/recording/backend.rb
+- lib/vidibus/recording/capistrano/recipes.rb
+- lib/vidibus/recording/capistrano.rb
+- lib/vidibus/recording/daemon.rb
 - lib/vidibus/recording/helpers.rb
-- lib/vidibus/recording/job.rb
 - lib/vidibus/recording/mongoid.rb
+- lib/vidibus/recording/monitoring_job.rb
+- lib/vidibus/recording/part.rb
+- lib/vidibus/recording/railtie.rb
 - lib/vidibus/recording/version.rb
+- lib/vidibus/recording/worker.rb
 - lib/vidibus/recording.rb
 - lib/vidibus-recording.rb
 - app/models/recording.rb
@@ -201,6 +210,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 766807753862642645
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:

data/lib/vidibus/recording/job.rb

@@ -1,101 +0,0 @@
-# TODO: extend from Vidibus::Loop
-
-module Vidibus::Recording
-  class Job
-    class ProcessError < StandardError; end
-
-    attr_accessor :recording, :pid, :metadata
-
-    def initialize(recording)
-      self.recording = recording
-      self.pid = recording.pid
-      self.metadata = nil
-    end
-
-    def start
-      self.pid = fork do
-        begin
-          record!
-        rescue => e
-          fail(e.inspect)
-          return
-        end
-      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 record!
-      Open3::popen3(recording.backend.command) do |stdin, stdout, stderr, process|
-        maxloops = 10
-        loop do
-          begin
-            string = stdout.read_nonblock(1024).force_encoding('UTF-8')
-            log(string)
-            extract_metadata(string) unless metadata
-          rescue Errno::EAGAIN
-          rescue EOFError
-          end
-
-          unless metadata
-            maxloops -= 1
-            if maxloops == 0
-              fail('No Metadata has been received. This stream does not work.')
-              return
-            end
-          end
-          sleep 2
-        end
-      end
-      process.join
-    end
-
-    def log(msg)
-      File.open(recording.log_file, "a") do |f|
-        f.write(msg)
-      end
-    end
-
-    def fail(msg)
-      log("\n\n---------\nError:\n#{msg}")
-      recording.fail(msg)
-    end
-
-    def extract_metadata(string)
-      self.metadata = recording.backend.extract_metadata(string)
-      if metadata
-        File.open(recording.yml_file, "w") do |f|
-          f.write(metadata.to_yaml)
-        end
-      end
-      metadata
-    end
-  end
-end