videoreg 0.1

data/lib/videoreg.rb

@@ -0,0 +1,232 @@
+Dir[File.dirname(File.expand_path(__FILE__))+"/videoreg/*.rb"].each { |f| require f }
+require 'rubygems'
+require 'logger'
+require 'ostruct'
+require 'amqp'
+require 'json'
+require_relative './videoreg/util'
+
+####################################################
+# Main videoreg module
+module Videoreg
+
+  # configurable constants
+  VERSION = "0.1"
+  DAEMON_NAME = "videoreg"
+  MAX_THREAD_WAIT_LIMIT_SEC = 600 # time while daemon waits until capture thread exists
+  UDEV_RULES_FILE = '/etc/udev/rules.d/50-udev-videoreg.rules'
+  DEV_SYMLINK = "webcam" # name of the devices symlinks
+
+  # internal constants
+  ALLOWED_CONFIG_OPTIONS = %w[mq_host mq_queue pid_path log_path device]
+  MSG_HALT = 'HALT'
+  MSG_RECOVER = 'RECOVER'
+  MSG_PAUSE = 'PAUSE'
+  MSG_RESUME = 'RESUME'
+  MSG2ACTION = {MSG_HALT => :halt!, MSG_PAUSE => :pause!, MSG_RESUME => :resume!, MSG_RECOVER => :recover!}
+
+  @registered_regs = {}
+  @time_started = Time.now
+  @run_options = OpenStruct.new(
+      :device => :all,
+      :action => :run,
+      :log_path => 'videoreg.log',
+      :pid_path => '/tmp/videoreg.pid',
+      :mq_host => '127.0.0.1',
+      :mq_queue => 'ifree.videoreg.server'
+  )
+
+  class << self
+    # Version info
+    def version_info
+      "#{DAEMON_NAME} v.#{VERSION}"
+    end
+
+    # Disconnect from RabbitMQ
+    def mq_disconnect(connection)
+      logger.info "Disconnecting from RabbitMQ..."
+      connection.close { EM.stop { exit } }
+    end
+
+    # Listen the incoming messages from RabbitMQ
+    def mq_listen(&block)
+      Thread.new {
+        begin
+          logger.info "New messaging thread created for RabbitMQ #{opt.mq_host} / #{opt.mq_queue}"
+          AMQP.start(:host => opt.mq_host) do |connection|
+            q = AMQP::Channel.new(connection).queue(opt.mq_queue)
+            q.subscribe do |msg|
+              Videoreg::Base.logger.info "Received message from RabbitMQ #{msg}..."
+              block.call(connection, msg) if block_given?
+            end
+            Signal.add_trap("TERM") { q.delete; mq_disconnect(connection) }
+            Signal.add_trap(0) { q.delete; mq_disconnect(connection) }
+          end
+        rescue => e
+          logger.error "Error during establishing the connection to RabbitMQ: #{e.message}"
+          @dante_runner.stop if @dante_runner
+        end
+      }
+    end
+
+    # Send a message to the RabbitMQ
+    def mq_send(message, arg = nil)
+      AMQP.start(:host => opt.mq_host) do |connection|
+        channel = AMQP::Channel.new(connection)
+        logger.info "Publish message to RabbitMQ '#{message}' with arg '#{arg}' to '#{opt.mq_queue}'..."
+        channel.default_exchange.publish({:msg => message, :arg => arg}.to_json, :routing_key => opt.mq_queue)
+        EM.add_timer(0.5) { mq_disconnect(connection) }
+      end
+    end
+
+    def run_options
+      @run_options
+    end
+
+    def registrars
+      @registered_regs
+    end
+
+    def logger
+      Videoreg::Base.logger
+    end
+
+
+    ####################################################
+    # Options
+    def opt(*args)
+      if !args.empty? && args[0].is_a?(Hash)
+        op = args[0].flatten
+        run_options.send("#{op[0]}=", op[1])
+      else
+        run_options
+      end
+    end
+
+    # Capture some other opts
+    ALLOWED_CONFIG_OPTIONS.each do |op|
+      self.send(:define_method, op) do |value|
+        opt.send("#{op}=".to_sym, value)
+      end
+    end
+
+    # Shortcut to create new registrar's configuration
+    def reg(&block)
+      r = Registrar.new
+      Signal.add_trap(0) { r.safe_release! }
+      r.logger = opt.logger if opt.logger
+      r.config.instance_eval(&block)
+      registrars[r.config.device] = r
+    end
+
+    # Calculate current registrars list
+    def calc_reg_list(device = :all)
+      registrars.find_all { |dev, reg| device.to_sym == :all || device.to_s == dev }.map { |vp| vp[1] }
+    end
+
+    # Initiate new dante runner
+    def init_dante_runner
+      dante_opts = {:pid_path => '/tmp/videoreg.pid', :log_path => opt.log_path}
+      dante_opts.merge!(:kill => true) if opt.action == :kill
+      dante_opts.merge!(:pid_path => opt.pid_path) if opt.pid_path
+      Dante::Runner.new(DAEMON_NAME, dante_opts)
+    end
+
+    # Run daemon
+    def run_daemon(regs)
+      Signal.add_trap("TERM") { File.unlink(opt.pid_path) if File.exists?(opt.pid_path) }
+      @time_started = Time.now
+      # Run message thread
+      mq_listen do |connection, message|
+        begin
+          raise "Unexpected message struct received: #{message}!" unless (message = JSON.parse(message)).is_a?(Hash)
+          opt.device = message["arg"] if message["arg"]
+          if (action = MSG2ACTION[message["msg"]])
+            logger.info "#{message["msg"]} MESSAGE RECEIVED!"
+            calc_reg_list(opt.device).each { |reg| reg.send(action) }
+          else
+            logger.error "UNKNOWN MESSAGE RECEIVED!"
+          end
+        rescue => e
+          logger.error "Exception during incoming message processing: #{e.message}: \n#{e.backtrace.join("\n")}"
+        end
+      end
+      # Run main thread
+      regs.map { |reg|
+        logger.info "Starting continuous registration from device #{reg.device}..."
+        {:reg => reg, :thread => reg.continuous}
+      }.each { |reg_hash|
+        while true do # avoid deadlock exception
+          reg_hash[:thread].join(MAX_THREAD_WAIT_LIMIT_SEC)
+          break if reg_hash[:reg].terminated? # break if thread was terminated
+        end if reg_hash[:reg] && reg_hash[:thread]
+      }
+      @time_ended = Time.now
+      logger.info "Daemon finished execution. Uptime #{@time_ended - @time_started} sec"
+    end
+
+    # Shortcut to run action on registrar(s)
+    def run(device = :all, action = opt.action)
+
+      # Input
+      @registrars = calc_reg_list(device)
+      @dante_runner = init_dante_runner
+      opt.action, action = :run, :run if @dante_runner.daemon_stopped? && opt.action == :recover
+
+      # Main actions switch
+      puts "Running command '#{opt.action}' for device(s): '#{device}'..."
+      case action
+        when :kill then
+          @dante_runner.stop
+        when :pause then
+          mq_send(MSG_PAUSE, device) if @dante_runner.daemon_running?
+        when :resume then
+          mq_send(MSG_RESUME, device) if @dante_runner.daemon_running?
+        when :recover then
+          mq_send(MSG_RECOVER, device) if @dante_runner.daemon_running?
+        when :ensure then
+          uptime = (@dante_runner.daemon_running?) ? Time.now - File.stat(opt.pid_path).ctime : 0
+          [{:daemon_running? => @dante_runner.daemon_running?, :uptime => uptime}] + @registrars.map { |reg|
+            {
+                :device => reg.device,
+                :device_exists? => reg.device_exists?,
+                :process_alive? => reg.process_alive?,
+                :paused? => reg.paused?
+            }
+          }
+        when :halt then
+          mq_send(MSG_HALT, device) if @dante_runner.daemon_running?
+        when :run then
+          @dante_runner.execute(:daemonize => true) {
+            logger.info "Starting daemon with options: #{opt.marshal_dump}"
+            run_daemon(@registrars)
+          }
+        when :reset then
+          @registrars.each { |reg|
+            reg.force_release_lock!
+          }
+          logger.info "Forced to release pidfile #{opt.pid_path}"
+          File.unlink(opt.pid_path) if File.exists?(opt.pid_path)
+        else
+          raise "Unsupported action #{action} provided to runner!"
+      end
+    end
+
+  end
+
+
+end
+
+####################################################
+# Extend ruby signal to support several listeners
+def Signal.add_trap(sig, &block)
+  @added_signals = {} unless @added_signals
+  @added_signals[sig] = [] unless @added_signals[sig]
+  @added_signals[sig] << block
+end
+
+# catch interrupt signal && call all listeners
+Signal.trap("TERM", proc { @added_signals && @added_signals[0].each { |p| p.call } })
+
+
+

data/lib/videoreg/base.rb

@@ -0,0 +1,41 @@
+require 'logger'
+require 'stringio'
+require_relative 'util'
+module Videoreg
+  class Base
+    @@logger = ::Logger.new(STDOUT)
+
+    def logger
+      self.class.logger
+    end
+
+    def logger=(log)
+      self.class.logger=log
+    end
+
+    def self.logger=(log)
+      @@logger = log
+    end
+
+    def self.logger
+      @@logger
+    end
+
+    # Applies current context to the templated string
+    def tpl(str)
+      eval("\"#{str}\"")
+    end
+
+    # Check if process is alive
+    def proc_alive?(pid)
+      Videoreg::Util.proc_alive?(pid)
+    end
+
+    # Cross-platform way of finding an executable in the $PATH.
+    #
+    #   which('ruby') #=> /usr/bin/ruby
+    def which(cmd)
+      Videoreg::Util.which(cmd)
+    end
+  end
+end

data/lib/videoreg/config.rb

@@ -0,0 +1,55 @@
+require_relative 'base'
+module Videoreg
+  class Config < Base
+
+    def initialize
+      @device = '/dev/video1'
+      @resolution = '320x240'
+      @fps = 25
+      @duration = 10
+      @filename = '#{time}-#{devname}.DEFAULT.avi'
+      @command = 'ffmpeg -r #{fps} -s #{resolution} -f video4linux2 -r ntsc -i #{device} -vcodec  mjpeg -t #{duration} -an -y #{outfile}'
+      @storage = '/tmp/#{devname}'
+      @lockfile = '/tmp/videoreg.#{devname}.DEFAULT.lck'
+      @store_max = 50
+    end
+
+    def time
+      "#{Time.new.strftime("%Y%m%d-%H%M%S%L")}"
+    end
+
+    def logger
+      @logger || self.class.logger
+    end
+
+    def store_max(*args)
+      (args.length > 0) ? (self.store_max=(args.shift)) : (@store_max.to_i)
+    end
+
+    def outfile
+      "#{storage}/#{filename}"
+    end
+
+    def base_cmd
+      command.split(" ").first
+    end
+
+    # set or get inner variable value
+    # depending on arguments count
+    def method_missing(*args)
+      if args.length == 2 || args[0] =~ /=$/
+        mname = args[0].to_s.gsub(/=/, '')
+        value = args.last
+        eval("@#{mname}='#{value}'")
+      elsif args.length == 1
+        tpl(eval("@#{args[0]}"))
+      else
+        super
+      end
+    end
+
+    def devname
+      device.split('/').last
+    end
+  end
+end

data/lib/videoreg/lockfile.rb

@@ -0,0 +1,100 @@
+module Videoreg
+  #
+  #  Lockfile.rb  --  Implement a simple lock file method
+  #
+  class Lockfile
+    attr_accessor :lockfile
+
+    KEY_LENGTH = 80
+    @lockcode = ""
+
+    def initialize(lckf)
+      @lockfile = lckf
+    end
+
+    def lock(initial_lockcode = nil)
+      @initial_lockcode = initial_lockcode
+      if File.exists?(@lockfile)
+        return false
+      else
+        create
+        ## verify that we indeed did get the lock
+        verify
+      end
+    end
+
+    def verify
+      if not File.exists?(@lockfile)
+        return false
+      end
+      if readlock == @lockcode.to_s
+        return true
+      else
+        return false
+      end
+    end
+
+    def lockcode
+      readlock
+    end
+
+    def release
+      if self.verify
+        begin
+          File.delete(@lockfile)
+          @lockcode = ""
+        rescue Exception => e
+          return false
+        end
+        return true
+      else
+        return false
+      end
+    end
+
+    def get_or_create_key
+      @initial_lockcode || create_key
+    end
+
+    def create_key
+      alpha = [('a'..'z'), ('A'..'Z')].map { |i| i.to_a }.flatten
+      return (0..KEY_LENGTH).map { alpha[rand(alpha.length)] }.join
+    end
+
+    def finalize(id)
+      #
+      # Ensure lock file is erased when object dies before being released
+      #
+      File.delete(@lockfile)
+    end
+
+    ##-----------------##
+    private
+    ##-----------------##
+
+    def create
+      @lockcode = get_or_create_key
+      begin
+        g = File.open(@lockfile, "w")
+        g.write @lockcode
+        g.close
+      rescue Exception => e
+        return false
+      end
+      return true
+    end
+
+    def readlock
+      code = ""
+      begin
+        g = File.open(@lockfile, "r")
+        code = g.read
+        g.close
+      rescue
+        return ""
+      end
+      return code
+    end
+
+  end
+end

data/lib/videoreg/registrar.rb

@@ -0,0 +1,196 @@
+require 'open4'
+require 'pathname'
+
+require_relative "base"
+
+module Videoreg
+  class Registrar < Videoreg::Base
+    DELEGATE_TO_CONFIG = [:command, :outfile, :resolution, :fps, :duration, :device, :storage, :base_cmd, :store_max]
+    attr_reader :config
+
+    #################################
+    public # Public methods:
+
+    def initialize(&block)
+      @config = Videoreg::Config.new
+      @pid = nil
+      @halted_mutex = nil
+      @terminated = false
+      configure(&block) if block_given?
+    end
+
+    def configure
+      @thread = nil
+      yield @config
+    end
+
+    def method_missing(m)
+      DELEGATE_TO_CONFIG.include?(m.to_sym) ? config.send(m) : super
+    end
+
+    def continuous
+      logger.info "Starting the continuous capture..."
+      @terminated = false
+      @thread = Thread.new do
+        while true do
+          unless @halted_mutex.nil?
+            logger.info "Registrar (#{device}) HALTED. Waiting for the restore message..."
+            @halted_mutex.lock
+          end
+          unless device_exists?
+            logger.error "Capture failed! Device #{device} does not exist!"
+            terminate!
+          end
+          begin
+            logger.info "Cleaning old files from storage (#{storage})... (MAX: #{config.store_max})"
+            clean_old_files!
+            logger.info "Waiting for registrar (#{device}) to finish the part (#{outfile})..."
+            run # perform one registration
+            logger.info "Registrar (#{device}) has finished to capture the part (#{outfile})..."
+          rescue RuntimeError => e
+            logger.error(e.message)
+            logger.info "Registrar (#{device}) has failed to capture the part (#{outfile})..."
+            terminate!
+          end
+        end
+      end
+    end
+
+    def run
+      logger.info "Spawning a new process to capture video from device '#{device}'..."
+      raise "Lockfile already exists '#{config.lockfile}'..." if File.exist?(config.lockfile)
+      logger.info "Running the command: '#{command}'..."
+      raise "#{base_cmd} not found on your system. Please install it or add it to your PATH" if which(base_cmd).nil?&& !File.exists?(base_cmd)
+      Open4::popen4(command) do |pid, stdin, stdout, stderr|
+        @pid = pid
+        raise "Cannot lock the lock-file '#{config.lockfile}'..." unless lock(pid)
+        output = stdout.read + stderr.read
+        raise "FATAL ERROR: Cannot capture video: \n #{output}" if error?(output)
+      end
+    ensure
+      release
+    end
+
+    def pid
+      @pid || ((rpid = lockfile.lockcode) ? rpid.to_i : nil)
+    end
+
+    def clean_old_files!
+      all_saved_files = Dir[Pathname.new(storage).join("*#{File.extname(config.filename)}").to_s].sort_by { |c|
+        File.stat(c).ctime
+      }.reverse
+      if all_saved_files.length > config.store_max.to_i
+        all_saved_files[config.store_max.to_i..-1].each do |saved_file|
+          logger.info "Removing saved file #{saved_file}..."
+          File.unlink(saved_file) if File.exists?(saved_file)
+        end
+      end
+    end
+
+    def halt!
+      logger.info "Registrar #{device} HALTED! Killing process..."
+      @halted_mutex = Mutex.new
+      @halted_mutex.lock
+      kill_process!
+    end
+
+    def pause!
+      logger.info "Registrar #{device} pausing process with pid #{pid}..."
+      Process.kill("STOP", pid) if process_alive?
+    end
+
+    def recover!
+      logger.info "Registrar #{device} UNHALTED! Recovering process..."
+      @halted_mutex.unlock if @halted_mutex && @halted_mutex.locked?
+      @halted_mutex = nil
+    end
+
+    def resume!
+      logger.info "Registrar #{device} resuming process with pid #{pid}..."
+      Process.kill("CONT", pid) if process_alive?
+    end
+
+    # Kill just the underlying process
+    def kill_process!
+      begin
+        logger.info("Killing the process for #{device} : #{pid}")
+        Process.kill("KILL", pid) if process_alive?
+        Process.getpgid
+      rescue => e
+        logger.warn("An attempt to kill already killed process (#{pid}): #{e.message}")
+      end
+    end
+
+    # Kill completely
+    def kill!
+      terminate!
+      kill_process! if process_alive?
+    ensure
+      safe_release!
+    end
+
+    # Terminate the main thread
+    def terminate!
+      @terminated = true
+      @thread.kill if @thread
+    ensure
+      safe_release!
+    end
+
+    def safe_release!
+      release if File.exists?(config.lockfile)
+    end
+
+    def force_release_lock!
+      logger.info("Forced to release lockfile #{config.lockfile}...")
+      File.unlink(config.lockfile) if File.exists?(config.lockfile)
+    end
+
+    def device_exists?
+      File.exists?(device)
+    end
+
+    def self_alive?
+      process_alive? && lockfile.readlock
+    end
+
+    def process_alive?
+      !pid.to_s.empty? && pid.to_i != 0 && proc_alive?(pid)
+    end
+
+    def terminated?
+      @terminated
+    end
+
+    def paused?
+      process_alive? && (`ps -p #{pid} -o stat=`.chomp == "T")
+    end
+
+    #################################
+    private # Private methods:
+
+    def error?(output)
+      if output =~ /No such file or directory/ || output =~ /I\/O error occurred/ ||
+          output =~ /Input\/output error/ || output =~ /ioctl\(VIDIOC_QBUF\)/
+        output.split("\n").last
+      else
+        nil
+      end
+    end
+
+    def lockfile
+      @lockfile ||= Lockfile.new(config.lockfile)
+    end
+
+    def lock(pid)
+      logger.info "Locking registrar's #{config.device} (PID: #{pid}) lock file #{config.lockfile}..."
+      lockfile.lock(pid)
+    end
+
+    def release
+      logger.info "Releasing registrar's #{config.device} lock file #{config.lockfile}..."
+      lockfile.release
+    end
+
+  end
+end