queso-daemon-kit 0.1.7.10

data/lib/daemon_kit/ruote_workitem.rb

@@ -0,0 +1,169 @@
+module DaemonKit
+
+  # Dual purpose class that is a) responsible for parsing incoming workitems and
+  # delegating to the correct RuotePseudoParticipant, and b) wrapping the
+  # workitem hash into something a bit more digestable.
+  class RuoteWorkitem
+
+    class << self
+
+      # = Process incoming commands via an AMQP queue
+      #
+      # Expects a JSON workitem from ruote that has these fields set in
+      # attributes key:
+      #
+      #   {
+      #     'reply_queue'    => 'queue to send replies to',
+      #     'params' => {
+      #       'command'  => '/actor/method'
+      #     }
+      #   }
+      #
+      # == Notes on the command key:
+      #
+      # It looks like a resource, and will be treated as such. Is should
+      # be in the format of +/class/method+, and it will be passed the
+      # complete workitem as a hash.
+      #
+      # == Notes on replies
+      #
+      # Replies are sent back to the queue specified in the +reply_queue+ key.
+      #
+      # == Notes on errors
+      #
+      # Where daemon-kit detects errors in attempting to parse and delegate the
+      # workitems, it will reply to the engine and set the following field with
+      # the error information:
+      #
+      #   daemon_kit.error
+      def process( transport, workitem )
+        # keep it singleton
+        @instance ||= new
+
+        work = parse( workitem )
+
+        DaemonKit.logger.warn "Processing workitem that has timed out!" if work.timed_out?
+
+        target, method = parse_command( work )
+
+        if target.nil? || method.nil?
+          msg = "Missing target/method in command parameter, or command parameter missing"
+          DaemonKit.logger.error( msg )
+          work["daemon_kit"] = { "error" => msg }
+
+        elsif target.public_methods.include?( method )
+          target.perform( method, work )
+
+        else
+          msg = "Workitem cannot be processes: #{method} not exposed by #{target.inspect}"
+          DaemonKit.logger.error( msg )
+          work["daemon_kit"] = { "error" => msg }
+        end
+
+        reply_to_engine( transport, work )
+      end
+
+      # Extract the class and method name from the workitem, then pick the matching
+      # class from the registered list of participants
+      def parse_command( work )
+        return nil if work['params']['command'].nil?
+
+        _, klass, method = work['params']['command'].split('/')
+
+        instance = RuoteParticipants.instance.participants[ klass ]
+
+        if instance.nil?
+          msg = "No instance registered for #{klass}"
+          DaemonKit.logger.error( msg )
+          raise DaemonKit::MissingParticipant, msg
+        end
+
+        return instance, method
+      end
+
+      def reply_to_engine( transport, response )
+        send( "reply_via_#{transport}", response )
+      end
+
+      def reply_via_amqp( response )
+        DaemonKit.logger.debug("Replying to engine via AMQP with #{response.inspect}")
+
+        ::MQ.queue( response['reply_queue'] ).publish( response.to_json )
+
+        response
+      end
+
+      def parse( workitem )
+        new( JSON.parse( workitem ) )
+      end
+    end
+
+    def initialize( workitem = {} )
+      @workitem = workitem
+    end
+
+    def fei
+      @workitem['flow_expression_id']
+    end
+
+    def short_fei
+      @short_fei ||=
+        '(' + [
+               'fei', self.fei['owfe_version'], self.fei['engine_id'],
+               self.fei['workflow_definition_url'], self.fei['workflow_definition_name'],
+               self.fei['workflow_definition_revision'], self.fei['workflow_instance_id'],
+               self.fei['expression_name'], self.fei['expression_id']
+              ].join(' ') + ')'
+    end
+
+    def dispatch_time
+      @dispath_time ||= Time.parse( @workitem['dispatch_time'] )
+    end
+
+    def last_modified
+      @last_modified ||= Time.parse( @workitem['last_modified'] )
+    end
+
+    def participant_name
+      @workitem['participant_name']
+    end
+
+    def attributes
+      @workitem['attributes']
+    end
+
+    def []( key )
+      self.attributes[ key ]
+    end
+
+    def []=( key, value )
+      self.attributes[ key ] = value
+    end
+
+    def to_json
+      @workitem.to_json
+    end
+
+    # Look at the workitem payload and attempt to determine if this workitem
+    # has timed out or not. This method will only ever work if you used the
+    # +:timeout: parameter was set for the expression.
+    def timed_out?
+      key = fei['workflow_instance_id'] + '__' + fei['expression_id']
+
+      if self.attributes["__timeouts__"] && timeout = self.attributes["__timeouts__"][ key ]
+        return Time.at( timeout.last ) < Time.now
+      end
+
+      return false
+    end
+
+    def method_missing( method_name, *args )
+      if self.attributes.keys.include?( method_name.to_s )
+        return self.attributes[ method_name.to_s ]
+      end
+
+      super
+    end
+
+  end
+end

data/lib/daemon_kit/safety.rb

@@ -0,0 +1,85 @@
+module DaemonKit
+  # Provides a wrapper for running code inside a 'safety net' Any
+  # exceptions raised inside a safety net is handled and reported via
+  # loggers, email or Hoptoad.
+  #
+  # The safety net can be configured via DaemonKit.config.safety,
+  # which holds the only instance of the safety net.
+  class Safety
+
+    # Who get's notified.
+    @handler = nil
+    attr_accessor :handler
+
+    # Registered error handlers
+    @error_handlers = {}
+    attr_reader :error_handlers
+
+    class << self
+
+      # Singleton
+      @instance = nil
+
+      def instance
+        @instance ||= new
+      end
+      private :new
+
+      # Run the provided block inside a safety net.
+      def run(&block)
+        self.instance.run(&block)
+      end
+
+      def register_error_handler( klass )
+        name = klass.to_s.split('::').last.downcase
+
+        DaemonKit.logger.debug( "Registering error handler '#{name}' (#{klass})" ) if DaemonKit.logger
+
+        instance.instance_eval( <<-EOF, __FILE__, __LINE__ )
+        def #{name}
+          @#{name} ||= #{klass}.instance
+        end
+        EOF
+      end
+    end
+
+    # Run the provided block inside a safety net.
+    def run(&block)
+      begin
+        block.call
+      rescue => e
+        # Log
+        DaemonKit.logger.fatal "Safety net caught exception: #{e.message}"
+        DaemonKit.logger.fatal "Backtrace: #{e.backtrace.join("\n    ")}"
+
+        get_handler.handle_exception( e ) if get_handler
+      end
+    end
+
+    def get_handler
+      if @handler && self.respond_to?( @handler )
+        h = send( @handler )
+        return h if h.class.ancestors.include?( DaemonKit::ErrorHandlers::Base )
+      end
+
+      return nil
+    end
+  end
+end
+
+class Object
+  class << self
+    def safely(&block)
+      DaemonKit::Safety.run(&block)
+    end
+  end
+
+  def safely(&block)
+    DaemonKit::Safety.run(&block)
+  end
+end
+
+# Load our error handlers
+require 'daemon_kit/error_handlers/base'
+require 'daemon_kit/error_handlers/mail'
+require 'daemon_kit/error_handlers/hoptoad'

data/lib/daemon_kit/tasks.rb

@@ -0,0 +1,2 @@
+# Load all the take tasks in the gem
+Dir[File.join(File.dirname(__FILE__), '**/*.rake')].each { |rake| load rake }

data/lib/daemon_kit/tasks/environment.rake

@@ -0,0 +1,10 @@
+task :environment do
+  $daemon_kit_rake_task = true
+
+  require 'config/environment'
+end
+
+task "Execute system commands in other tasks with sudo"
+task :sudo do
+  $RAKE_USE_SUDO = true
+end

data/lib/daemon_kit/tasks/framework.rake

@@ -0,0 +1,120 @@
+namespace :daemon_kit do
+  namespace :freeze do
+    desc "Lock this application to the current gem (by unpacking it into vendor/daemon_kit)"
+    task :gems do
+      deps = %w()
+      require 'rubygems'
+      require 'rubygems/gem_runner'
+
+      kit = (version = ENV['VERSION']) ?
+        Gem.cache.find_name('daemon-kit', "= #{version}").first :
+        Gem.cache.find_name('daemon-kit').sort_by { |g| g.version }.last
+
+      version ||= kit.version
+
+      unless kit
+        puts "No daemon_kit gem #{version} is installed.  Do 'gem list daemon_kit' to see what you have available."
+        exit
+      end
+
+      puts "Freezing the gem for DaemonKit #{kit.version}"
+      rm_rf   "vendor/daemon_kit"
+      mkdir_p "vendor/daemon_kit"
+
+      begin
+        chdir("vendor/daemon_kit") do
+          kit.dependencies.select { |g| deps.include? g.name }.each do |g|
+            Gem::GemRunner.new.run(["unpack", g.name, "--version", g.version_requirements.to_s])
+            mv(Dir.glob("#{g.name}*").first, g.name)
+          end
+
+          Gem::GemRunner.new.run(["unpack", "daemon-kit", "--version", "=#{version}"])
+          FileUtils.mv(Dir.glob("daemon-kit*").first, "daemon-kit")
+        end
+      rescue Exception
+        rm_rf "vendor/daemon_kit"
+        raise
+      end
+    end
+
+    desc 'Lock to latest edge daemon_kit'
+    task :edge do
+      require 'open-uri'
+      #version = ENV["RELEASE"] || "edge"
+      commits = "http://github.com/api/v1/yaml/kennethkalmer/daemon-kit/commits/master"
+      url     = "http://github.com/kennethkalmer/daemon-kit/zipball/master"
+
+      rm_rf   "vendor/daemon_kit"
+      mkdir_p "vendor/daemon_kit"
+
+      chdir 'vendor/daemon_kit' do
+        latest_revision = YAML.load(open(commits))["commits"].first["id"]
+
+        puts "Downloading DaemonKit from #{url}"
+        File.open('daemon-kit.zip', 'wb') do |dst|
+          open url do |src|
+            while chunk = src.read(4096)
+              dst << chunk
+            end
+          end
+        end
+
+        puts 'Unpacking DaemonKit'
+        rm_rf 'daemon-kit'
+        `unzip daemon-kit.zip`
+        FileUtils.mv(Dir.glob("kennethkalmer-daemon-kit*").first, "daemon-kit")
+        %w(daemon-kit.zip).each do |goner|
+          rm_f goner
+        end
+
+        touch "REVISION_#{latest_revision}"
+      end
+    end
+
+  end
+
+  desc "Upgrade your local files for a daemon after upgrading daemon-kit"
+  task :upgrade => 'environment' do
+    # Run these
+    %w{ initializers rakefile scripts }.each do |t|
+      Rake::Task["daemon_kit:upgrade:#{t}"].invoke
+    end
+
+    puts
+    puts "#{DaemonKit.configuration.daemon_name} has been upgraded."
+  end
+
+  namespace :upgrade do
+    # Upgrade the initializers
+    task :initializers do
+      copy_framework_template( 'config', 'boot.rb' )
+
+      if File.directory?( File.join(DaemonKit.root, 'config', 'initializers') )
+        mv File.join(DaemonKit.root, 'config', 'initializers'), File.join(DAEMON_ROOT, 'config', 'pre-daemonize')
+        copy_framework_template( 'config', 'pre-daemonize', 'readme' )
+      end
+
+      unless File.directory?( File.join(DAEMON_ROOT, 'config', 'post-daemonize') )
+        mkdir_p File.join(DAEMON_ROOT, 'config', 'post-daemonize')
+        copy_framework_template( 'config', 'post-daemonize', 'readme' )
+      end
+    end
+
+    # Upgrade the Rakefile
+    task :rakefile do
+      copy_framework_template( 'Rakefile' )
+    end
+
+    # Upgrade the scripts
+    task :scripts do
+      %w{ console destroy generate }.each do |s|
+        copy_framework_template( "script", s )
+      end
+    end
+  end
+end
+
+def copy_framework_template( *args )
+  src_dir = File.join(DaemonKit.framework_root, 'app_generators', 'daemon_kit', 'templates')
+  cp File.join( src_dir, *args ), File.join( DaemonKit.root, *args )
+end

data/lib/daemon_kit/tasks/god.rake

@@ -0,0 +1,62 @@
+require 'erb'
+
+namespace :god do
+  desc "Generate a stub god config file template for the daemon"
+  task :template => 'environment' do
+    # Preserve local changes
+    if File.exists?( "#{DaemonKit.root}/config/god.erb" ) && ENV['FORCE'].nil?
+      puts "Template already exists, use FORCE=1 to overwrite."
+      exit 1
+    end
+
+    cp "#{DaemonKit.framework_root}/templates/god/god.erb", "#{DaemonKit.root}/config/god.erb"
+  end
+
+  desc "Parse the god config template into a god config file"
+  task :generate => 'environment' do
+
+    unless File.exists?( "#{DaemonKit.root}/config/god.erb" )
+      Rake::Task["god:template"].invoke
+    end
+
+    name = DaemonKit.configuration.daemon_name
+
+    File.open( "#{DaemonKit.root}/config/#{name}.god", "w+" ) do |f|
+      t = File.read( "#{DaemonKit.root}/config/god.erb" )
+      f.write( ERB.new( t ).result( binding )  )
+    end
+
+    puts "Monit config generated in config/#{name}.god"
+  end
+
+  desc "Load the god file into god"
+  task :load => 'environment' do
+    name = DaemonKit.configuration.daemon_name
+
+    sh "#{$RAKE_USE_SUDO ? 'sudo' : ''} god load #{DaemonKit.root}/config/#{name}.god"
+  end
+
+  desc "Refresh the god config file in the running god"
+  task :refresh => 'environment' do
+    name = DaemonKit.configuration.daemon_name
+
+    sh "#{$RAKE_USE_SUDO ? 'sudo' : ''} god unmonitor #{name}"
+    sh "#{$RAKE_USE_SUDO ? 'sudo' : ''} god remove #{name}"
+    sh "#{$RAKE_USE_SUDO ? 'sudo' : ''} god load #{DaemonKit.root}/config/#{name}.god"
+    sh "#{$RAKE_USE_SUDO ? 'sudo' : ''} god monitor #{name}"
+  end
+
+  desc "Start god monitoring of the config file"
+  task :monitor => 'environment' do
+    name = DaemonKit.configuration.daemon_name
+
+    sh "#{$RAKE_USE_SUDO ? 'sudo' : ''} god monitor #{name}"
+  end
+
+  desc "Stop god monitoring of the config file"
+  task :unmonitor => 'environment' do
+    name = DaemonKit.configuration.daemon_name
+
+    sh "#{$RAKE_USE_SUDO ? 'sudo' : ''} god unmonitor #{name}"
+  end
+end