vtools 0.0.1

data/lib/vtools/job.rb

@@ -0,0 +1,48 @@
+# -*- encoding: binary -*-
+
+module VTools
+
+  # job instance
+  class Job
+    attr_reader   :video, :id
+
+    # constructor
+    def initialize config
+      @id = self.object_id.to_i
+      @config = validate config
+      @video  = Video.new @config.file
+    end
+
+    # execute job
+    def execute
+      # start callback
+      Handler.exec :job_started, @video, @config.action
+
+      result = @video.get_info # we always get info
+
+      case @config.action
+      when /^convert$/i
+        result = @video.convert @config.setup # will return video
+      when /^thumbs$/i
+        result = @video.create_thumbs @config.setup # will return thumbs array
+      end
+
+      # final callbacks
+      Handler.exec :job_finished, result, @video, @config.action
+      result
+    end
+
+    # parse video options
+    def validate options
+      unless options.action =~ /^convert|thumbs|info$/ && options.file && !options.file.empty?
+        raise ConfigError, "Invalid action (config: #{options.marshal_dump})"
+      else
+        return options if options.action =~ /^info$/
+        # empty set error
+        raise ConfigError, "Configuration is empty" if !options.setup || options.setup.empty?
+      end
+      options
+    end
+
+  end # Job
+end # VTools

data/lib/vtools/options.rb

@@ -0,0 +1,101 @@
+# -*- encoding: binary -*-
+
+module VTools
+
+  # Takes care about passed via ARGV options
+  class Options
+    class << self
+      # parse config data
+      def parse! args
+        # slice options afer "--" sign if given
+        # catch help & version calls
+        case
+        when(args.include? '--')
+          argv = args[ ( args.index('--') + 1)..-1]
+        when(args.include? '-h')
+          argv = ['-h']
+        when(args.include? '-v')
+          argv = ['-v']
+        else
+          return
+        end
+
+        # parse passed options
+        OptionParser.new do |opts|
+
+          dot = ' ' * 4
+          opts.banner = "Usage: vtools <command> <daemon options> -- <options>\n" +
+            "\n" +
+            "Commands:\n" +
+            "#{dot}start         start an instance of the application\n" +
+            "#{dot}stop          stop all instances of the application\n" +
+            "#{dot}restart       stop all instances and restart them afterwards\n" +
+            "#{dot}reload        send a SIGHUP to all instances of the application\n" +
+            "#{dot}run           start the application and stay on top\n" +
+            "#{dot}zap           set the application to a stopped state\n" +
+            "#{dot}status        show status (PID) of application instances\n" +
+            "\n" +
+            "Daemon options:\n" +
+
+            "#{dot}-t, --ontop                      Stay on top (does not daemonize)\n" +
+            "#{dot}-f, --force                      Force operation\n" +
+            "#{dot}-n, --no_wait                    Do not wait for processes to stop"
+
+          opts.separator ""
+          opts.separator "Options:"
+
+          # add config file
+          opts.on("-c", "--config-file FILE", "Use configuration file") do |f|
+            CONFIG[:config_file] = f
+          end
+
+          # add log file
+          opts.on("-l", "--log-file [FILE]", "Log process into file (default STDOUT)") do |l|
+            CONFIG[:logging]  = true
+            CONFIG[:log_file] = "#{CONFIG[:PWD]}/#{l}" if l
+          end
+
+          # include path
+          opts.on("-I", "--include PATH",
+                  "specify $LOAD_PATH (may be used more than once)") do |path|
+            $LOAD_PATH.unshift(*path.split(/:/))
+          end
+
+          # connect additional library
+          opts.on("-r", "--require LIBRARY",
+                  "require the library, before daemon starts") do |library|
+            CONFIG[:library] << library
+          end
+
+          opts.separator ""
+
+          # VTools version
+          opts.on_tail("-v", "--version", "Show current version") do |operator|
+            puts VERSION.join(',')
+            exit
+          end
+
+          # options help
+          opts.on_tail("-h", "--help", "Show this message") do
+            puts opts
+            exit
+          end
+
+          # do parse!
+          begin
+            if argv.empty?
+              argv = ["-h"]
+              STDERR.puts "ERROR: No command given\n\n"
+            end
+
+            opts.parse!(argv)
+            Handler.exec :config_parsed # callback
+          rescue OptionParser::ParseError => e
+            STDERR.puts "ERROR: #{e.message}\n\n", opts
+            exit(-1)
+          end
+        end # OptionParser.new
+      end # parse!
+    end # class <<
+  end # Options
+end # VTools

data/lib/vtools/shared_methods.rb

@@ -0,0 +1,131 @@
+# -*- encoding: binary -*-
+
+module VTools
+
+  # shared methods
+  module SharedMethods
+    # both static & instance bindings
+    module Common
+
+      @@logger = nil
+  
+      # custom logger
+      def logger= logger
+        @@logger = logger
+      end
+
+      # logger mechanics
+      def log level, message = ""
+  
+        if CONFIG[:logging]
+          unless @@logger
+            output = CONFIG[:log_file] || STDOUT
+            logger = Logger.new(output, 1000, 1024000)
+            logger.level = Logger::INFO
+            @@logger = logger
+          end
+
+          @@logger.send(level, message) if @@logger
+        end
+      end
+      
+      # converts json to the ruby object
+      # returns nil on invalid JSON
+      def json_to_obj json_str
+        hash_to_obj(parse_json(json_str))
+      end
+
+      # convert hash into object
+      def hash_to_obj hash
+        OpenStruct.new(hash) rescue raise ConfigError, "Can't convert setup to object"
+      end
+
+      # parse json string into hash
+      def parse_json str
+        JSON.parse str rescue raise ConfigError, "Invalid JSON"
+      end
+
+      # set symbols in place of string keys
+      def keys_to_sym hash
+        return hash unless hash.is_a? Hash
+        hash.inject({}){ |opts,(k,v)| opts[k.to_sym] = v; opts }
+      end
+
+      # config accessor
+      def config data
+        CONFIG[data]
+      end
+
+      # calls TCP/IP applications
+      def network_call url
+        require "socket"
+
+        url =~ %r#^([a-z]+://)?(?:www.)?([^/:]+)(:[\d]+)?(.*)$#
+        protocol, host, port, route =
+          ($1 || '')[0...-3], $2, ($3 || ":80")[1..-1].to_i, "/#{$4.to_s.gsub(/^\//, '')}"
+
+        begin
+          sock = TCPSocket.open(host, port)
+          sock.print "GET #{route} HTTP/1.0\r\n\r\n"
+          response = sock.read.split("\r\n\r\n", 2).reverse[0]
+          sock.close
+        rescue => e
+          log :error, e
+        end
+
+        response
+      end
+
+      # function to create correct subdirectories to the file
+      def generate_path file_name, scope = "video"
+        storage = CONFIG[:"#{scope}_storage"]
+        return instance_exec(file_name, &storage) if storage.is_a? Proc
+        (!storage || storage.empty? ? CONFIG[:PWD] : storage).to_s.strip.gsub(%r#/$#, '')
+      end
+
+      # path generator setter
+      def path_generator scope = nil, &block
+        if scope
+          scope = "thumb" unless scope == "video"
+          CONFIG[:"#{scope}_storage"] = block
+        else
+          CONFIG[:thumb_storage] = CONFIG[:video_storage] = block
+        end if block_given?
+      end
+
+      # encoding fixer for iso-8859-1
+      def fix_encoding(output)
+        output[/test/] # Running a regexp on the string throws error if it's not UTF-8
+      rescue ArgumentError
+        output.force_encoding("ISO-8859-1")
+      end
+    end # Common
+
+    # class bindings
+    module Static
+      include Common
+      # load external libs
+      def load_libs
+        CONFIG[:library].each do |lib|
+          begin
+            require lib
+          rescue LoadError => e
+            print "Library file could not be found (#{lib})\n"
+          rescue SyntaxError => e
+            print "Library may contain non ascii characters (#{lib}).\n\n" +
+              "Try to set file encoding to 'binary'.\n\n"
+          end
+        end
+      end
+    end # Static
+
+    # instance bindings
+    module Instance
+      include Common
+    end # Instance
+
+    # extend it
+    def self.included (klass) klass.extend Static end
+    include Instance
+  end # SharedMethods
+end # VTools

data/lib/vtools/storage.rb

@@ -0,0 +1,67 @@
+# -*- encoding: binary -*-
+
+module VTools
+
+  # Interface API to the Message Queue or Database Server (AdapterInterface)
+  class Storage
+    include SharedMethods
+
+    @actions = {}
+
+    class << self
+
+      # constructor (cretes connection)
+      def connect
+        fails __method__ unless @actions[:connect]
+        @actions[:connect].call
+      end
+
+      # recv basic method
+      def recv
+        fails __method__ unless @actions[:recv]
+        @actions[:recv].call
+      end
+
+      # send masic method
+      def send data
+        fails __method__ unless @actions[:send]
+        @actions[:send].call(data)
+      end
+
+      # callback setter to connect to the storage
+      def connect_action &block
+        @actions[:connect] = block
+      end
+
+      # callback setter to recieve data
+      def recv_action &block
+        @actions[:recv] = block
+      end
+
+      # callback setter to send data when done successfully
+      # Storage#send will pass Hash with content:
+      #     :data   => Job.execution_result,
+      #     :action => Job.executed_action
+      def send_action &block
+        @actions[:send] = block
+      end
+
+      # callback setter for the collection
+      # usage:
+      # VTools::Storage.setup do
+      #   connect_action { ... }
+      #   send_action { |data| ... }
+      #   recv_action { ... }
+      def setup &block
+        instance_eval &block if block_given?
+      end
+
+      private
+      # errors generator
+      def fails meth
+p "fails orig: #{meth}"
+        raise NotImplementedError, "VTools::Storage##{meth}_action must be set"
+      end
+    end # class << self
+  end # Storage
+end # VTools

data/lib/vtools/thumbnailer.rb

@@ -0,0 +1,93 @@
+# -*- encoding: binary -*-
+
+module VTools
+
+  # Takes care about generating thumbnails
+  # requires ffmpegthumbnailer
+  class Thumbnailer
+    include SharedMethods
+
+    # constructor
+    def initialize video
+      @video = video
+    end
+
+    # thumbnailer job
+    def run
+
+      options = @video.thumbs_options
+      errors = []
+      thumbs = []
+      postfix = options[:postfix]
+      @total = options[:thumb_count].to_i
+
+      @output_file = "#{generate_path @video.name, "thumb"}/#{@video.name}_"
+      command = "#{CONFIG[:thumb_binary]} -i '#{@video.path}' #{options} "
+
+      # callback
+      Handler.exec :before_thumb, @video, options
+
+      # process cicle
+      @total.times do |count|
+
+        seconds = (options && options[:t]) || set_point(options || count)
+
+        file = "#{@output_file}#{ postfix || (options && options[:t]) || count }.jpg"
+        exec = "#{command} -t #{seconds} -o '#{file}' 2>&1"
+        options = nil
+
+        Open3.popen3(exec) do |stdin, stdout, stderr|
+          # save thumb if no error
+          if (error = VTools.fix_encoding(stdout.readlines).join(" ")).empty?
+            thumbs << thumb = {:path => file, :offset => time_offset(seconds)}
+
+            Handler.exec :in_thumb, @video, thumb # callbacks
+          else
+            errors << "#{error} (#{file})"
+          end
+        end
+      end
+
+      # callbacks
+      if errors.empty?
+        Handler.exec :thumb_success, @video, thumbs
+      else
+        errors = " Errors: #{errors.flatten.join(";").gsub(/\n/, ' ')}. "
+        Handler.exec :thumb_error, @video, errors
+        raise ProcessError, "Thumbnailer error: #{errors}" if thumbs.empty? && @total > 0
+      end
+
+      thumbs
+    end
+
+    private
+    # permits to set checkpoint
+    # for the current thumb
+    def set_point config
+
+      # start point as config hash given
+      checkpoint = if config.is_a? Hash
+
+        case config[:thumb_start_point].to_s
+        when /(\d+(\.\d+)?)%$/ # shift in percents
+          offset = $1.to_i
+        when /(\d+)$/ # shift in seconds
+          offset = time_offset $1
+        end
+      elsif config.is_a? Integer # thumb number
+        offset = (config * 100 / @total).to_i
+      end
+
+      offset ||= 0
+    end
+
+    # calculates time offset string
+    # by given seconds length
+    def time_offset seconds
+      shift = (@video.duration > seconds.to_f ? seconds : @video.duration).to_i
+      hours, mins = (shift / 360), (shift / 60)
+      sec = shift - (hours * 360 + mins * 60)
+      "%02d:%02d:%02d" % [hours, mins, sec]
+    end
+  end # Thumbnailer
+end # VTools

data/lib/vtools/thumbs_options.rb

@@ -0,0 +1,80 @@
+# -*- encoding: binary -*-
+
+module VTools
+
+  # options for the thumbnailer
+  class ThumbsOptions < Hash
+    include SharedMethods
+
+    # constructor
+    def initialize options = {}
+
+      @ignore = [:thumb_count, :thumb_start_point, :quality, :width, :time, :postfix]
+      # default values
+      merge!(
+        :thumb_count        => 0,
+        :thumb_start_point  => 0,
+      )
+
+      parse! options
+    end
+
+    # redefine native method
+    # for more readable options
+    def []= index, value
+      case
+      when [:quality, :q].include?(index)
+        former = {:q => value, :quality => value}
+      when [:width, :s].include?(index)
+        former = {:s => value, :width => value}
+      when [:time, :t].include?(index)
+        former = {:t => value, :time => value}
+      else
+        return super
+      end
+      merge! former
+      value
+    end
+
+    # to string
+    def to_s
+      params = collect do |key, value|
+        "-#{key} #{value}" unless @ignore.include?(key)
+      end.compact
+
+      params.join " "
+    end
+    
+    # options parser
+    def parse! options
+
+      case
+      # predefined
+      when options.is_a?(String) && CONFIG[:thumb_set].include?(options.to_sym)
+        # get config data
+        s, q, count, start_point = CONFIG[:thumb_set][options.to_sym]
+        options = {:thumb_count => count, :thumb_start_point => start_point, :s => s, :q => q}
+
+      # niether string nor hash..
+      when !options.is_a?(Hash)
+        raise ConfigError, "Options should be a Hash or String (predefined set)"
+      # convert keys to symbols
+      else
+        options = keys_to_sym options
+        # check inline predefined
+        parse! options.delete(:set) if options.has_key? :set
+      end
+
+      perform options
+      merge! options
+    end
+
+    private
+    # revalidate special options
+    def perform hash
+      { :quality => :q, :width => :s, :time => :t }.each do |name, orig|
+        hash[orig] = hash[name] if hash.include?(name)
+      end
+    end
+  end # ThumbsOptions
+end # VTools