amqp-daemon-kit 0.1.8.1

data/lib/daemon_kit/jabber.rb

@@ -0,0 +1,171 @@
+require 'yaml'
+
+module DaemonKit
+  # Thin wrapper around xmpp4r-simple, specifically designed to ease
+  # configuration of a jabber daemon and provide some added simplicity.
+  class Jabber
+
+    # Jabber connection
+    attr_reader :connection
+
+    @@instance = nil
+    @@message_handler = nil
+    @@presence_handler = nil
+    @@subscription_handler = nil
+
+    class << self
+
+      # Deliver a message to the specified jid.
+      def deliver( jid, message )
+        instance.connection.deliver( jid, message )
+      end
+
+      # Use this instead of initializing, keeps it singleton
+      def instance
+        @instance ||= new
+        @instance.startup!
+      end
+      private :new
+
+      def run
+        DaemonKit.logger.warn "Please use the new XMPP daemons, this class is deprecated"
+        DaemonKit.logger.info "Starting jabber loop"
+
+        loop do
+          process_messages
+          process_updates
+          process_subscriptions
+
+          begin
+            sleep 1
+          rescue Interrupt
+            DaemonKit.logger.warn "Jabber loop interrupted"
+            break
+          end
+        end
+      end
+
+      def process_messages
+        @message_handler ||= Proc.new { |m| DaemonKit.logger.info "Received message from #{m.from}: #{m.body}" }
+
+        instance.valid_messages { |m| @message_handler.call(m) }
+      end
+
+      def process_updates
+        @presence_handler ||= Proc.new { |friend, old_presence, new_presence|
+          DaemonKit.logger.debug "Received presence update: #{friend} went from #{old_presence} to #{new_presence}"
+        }
+
+        instance.connection.presence_updates { |friend, old_presence, new_presence|
+          @presence_handler.call(friend, old_presence, new_presence)
+        }
+
+      end
+
+      def process_subscriptions
+        @subscription_handler ||= Proc.new { |friend,presence| DaemonKit.logger.debug "Received presence update from #{friend}: #{presence}" }
+
+        instance.connection.subscription_requests { |friend,presence| @subscription_handler.call(friend,presence) }
+      end
+
+      def received_messages(&block)
+        @message_handler = block
+      end
+
+      def presence_updates(&block)
+        @presence_handler = block
+      end
+
+      def subscription_requests(&block)
+        @subscription_handler = block
+      end
+
+    end
+
+    def initialize
+      options = DaemonKit::Config.load( 'jabber' )
+
+      @jabber_id  = options.delete("jabber_id")
+      @password   = options.delete("password")
+      @resource   = options.delete("resource") || 'daemon_kit'
+      @masters    = options.delete("masters") || []
+      @supporters = options.delete("supporters") || []
+
+      raise ArgumentError if [ @jabber_id, @password ].any? { |a| a.nil? }
+    end
+
+    def startup!
+      return self if @booted
+
+      connect!
+      setup_roster!
+
+      DaemonKit.trap( 'INT', Proc.new { self.shutdown! } )
+      DaemonKit.trap( 'TERM', Proc.new { self.shutdown! } )
+
+      @booted = true
+
+      self
+    end
+
+    def shutdown!
+      DaemonKit.logger.warn "Disconnecting jabber connection"
+      self.connection.disconnect
+    end
+
+    def contacts
+      @masters + @supporters
+    end
+
+    def valid_messages(&block)
+      self.connection.received_messages.each do |message|
+        next unless valid_master?( message.from )
+
+        busy do
+          block.call message
+        end
+      end
+    end
+
+    def valid_master?( jid )
+      @masters.include?( jid.strip.to_s )
+    end
+
+    def busy(&block)
+      self.connection.status(:dnd, "Working...")
+      yield
+      self.connection.status(:chat, self.status_line )
+    end
+
+    def status_line
+      "#{DaemonKit.configuration.daemon_name} ready for instructions"
+    end
+
+    private
+
+    def connect!
+      jid = @jabber_id + '/' + @resource
+
+      @connection = ::Jabber::Simple.new( jid, @password, nil, self.status_line )
+    end
+
+    def setup_roster!
+      # cleanup the roster
+      self.connection.roster.items.each_pair do |jid, roster_item|
+        jid = jid.strip.to_s
+        unless self.contacts.include?( jid )
+          self.connection.remove( jid )
+        end
+      end
+
+      # add missing contacts
+      self.contacts.each do |jid|
+        unless self.connection.subscribed_to?( jid )
+          self.connection.add( jid )
+          #self.connection.accept_subscription( jid )
+        end
+      end
+    end
+
+  end
+end

data/lib/daemon_kit/nanite.rb

@@ -0,0 +1,7 @@
+module DaemonKit
+  # For building daemons that integrate with nanite, either as mappers
+  # or agents. See #DaemonKit::Nanite::Agent so far
+  module Nanite
+    autoload :Agent, "daemon_kit/nanite/agent"
+  end
+end

data/lib/daemon_kit/nanite/agent.rb

@@ -0,0 +1,77 @@
+module Nanite
+  class Agent
+
+    attr_accessor :init_block
+
+    def load_actors_with_daemon_kit_changes( &block )
+      actors = @options[:actors]
+      Dir["#{DaemonKit.root}/lib/actors/*.rb"].each do |actor|
+        next if actors && !actors.include?( File.basename(actor, '.rb') )
+        Nanite::Log.info( "[setup] loading #{actor}" )
+        require actor
+      end
+
+      self.init_block.call( self )
+    end
+
+    alias_method :load_actors_without_daemon_kit_changes, :load_actors
+    alias_method :load_actors, :load_actors_with_daemon_kit_changes
+  end
+end
+
+module DaemonKit
+  module Nanite
+    # Pull support into a daemon for being a nanite agent.
+    class Agent
+
+      @@instance = nil
+
+      class << self
+
+        def instance
+          @instance ||= new
+        end
+
+        private :new
+
+        def run(&block)
+          instance.run(&block)
+        end
+
+      end
+
+      def initialize
+        @config = DaemonKit::Config.load( 'nanite' ).to_h( true )
+
+        config_agent
+      end
+
+      def run(&block)
+        # Ensure graceful shutdown of the connection to the broker
+        DaemonKit.trap('INT') { ::EM.stop }
+        DaemonKit.trap('TERM') { ::EM.stop }
+        ::Nanite::Log.logger = DaemonKit.logger
+
+        # Start our mapper
+        mapper_thread = Thread.new do
+          EM.run do
+            agent = ::Nanite::Agent.new( @config )
+            agent.init_block = block
+            agent.run
+          end
+        end
+
+        mapper_thread.join
+      end
+
+      private
+
+      # Make sure to fine tune the agent config to be DK friendly
+      def config_agent
+        @config[:root] = DAEMON_ROOT
+        @config[:daemonize] = false
+        @config[:actors_dir] = File.join(DAEMON_ROOT, 'lib', 'actors')
+      end
+    end
+  end
+end

data/lib/daemon_kit/pid_file.rb

@@ -0,0 +1,61 @@
+module DaemonKit
+
+  # Simple pidfile handling for daemon processes
+  class PidFile
+
+    def initialize( path )
+      @path = path.to_absolute_path
+    end
+
+    def exists?
+      File.exists?( @path )
+    end
+
+    # Returns true if the process is running
+    def running?
+      return false unless self.exists?
+
+      # Check if process is in existence
+      # The simplest way to do this is to send signal '0'
+      # (which is a single system call) that doesn't actually
+      # send a signal
+      begin
+        Process.kill(0, self.pid)
+        return true
+      rescue Errno::ESRCH
+        return false
+      rescue ::Exception   # for example on EPERM (process exists but does not belong to us)
+        return true
+      #rescue Errno::EPERM
+      #  return false
+      end
+    end
+
+    # Return the pid contained in the pidfile, or nil
+    def pid
+      return nil unless self.exists?
+
+      File.open( @path ) { |f|
+        return f.gets.to_i
+      }
+    end
+
+    def ensure_stopped!
+      if self.running?
+        puts "Process already running with id #{self.pid}"
+        exit 1
+      end
+    end
+
+    def cleanup
+      File.delete( @path ) rescue Errno::ENOENT
+    end
+    alias zap cleanup
+
+    def write!
+      File.open( @path, 'w' ) { |f|
+        f.puts Process.pid
+      }
+    end
+  end
+end

data/lib/daemon_kit/ruote_participants.rb

@@ -0,0 +1,125 @@
+module DaemonKit
+  # Class that cleanly abstracts away the different remote participants in
+  # ruote and allows daemon writers to just worry about processing workitems
+  # without worrying over the transport mechanism or anything else...
+  class RuoteParticipants
+
+    class << self
+
+      # Configure this daemon as a remote participant to ruote.
+      def configure(&block)
+        instance.configure(&block)
+      end
+
+      # Activate and run the remote participant code, calling the optional
+      # block for additional daemon logic.
+      def run(&block)
+        instance.run(&block)
+      end
+
+      private :new
+
+      def instance
+        @instance ||= new
+      end
+
+      private
+
+      def instance=( obj )
+        @instance = obj
+      end
+    end
+
+    attr_reader :participants
+
+    def initialize
+      @transports = []
+      @participants = {}
+      @runtime_queues = []
+
+      @configuration = Config.load('ruote')
+    end
+
+    # Yields +self+ and configures the remote participants
+    def configure(&block)
+      block.call( self )
+
+      @transports.freeze
+      @participants.freeze
+    end
+
+    # Enable the use of a specific transport for workitems. Can be :amqp to use
+    # the AMQPParticipant/AMQPListener pair in ruote.
+    def use( transport )
+      @transports << transport
+    end
+
+    # Register classes as pseudo-participants. Two styles of registration are
+    # supported:
+    #
+    #   register( Foo )
+    #   register( 'short', ShortParticipant )
+    #
+    # The first format uses the class name (downcased and underscored) as the
+    # key for identifying the pseudo-participant, the second uses the the
+    # provided key.
+    #
+    # Pseudo-participant classes are instantiated when registered, and the
+    # instances are re-used.
+    def register( *args )
+      key, klass = if args.size == 1
+        [ underscore( args.first.to_s ), args.first ]
+      else
+        [ args[0].to_s, args[1] ]
+      end
+
+      @participants[ key ] = klass.new
+    end
+
+    # Run the participants
+    def run(&block)
+      run_amqp! if @transports.include?( :amqp )
+    end
+
+    # Subscribe to additional queues not specified in ruote.yml
+    def subscribe_to( queue )
+      @runtime_queues << queue
+    end
+
+    private
+
+    def run_amqp!
+      AMQP.run do
+        mq = ::MQ.new
+        queues = @configuration['amqp']['queues'].to_a | @runtime_queues
+
+        queues.each do |q|
+          DaemonKit.logger.debug("Subscribing to #{q} for workitems")
+
+          cmdq = mq.queue( q, :durable => true )
+          cmdq.subscribe( :ack => true ) do |header, message|
+            safely do
+              DaemonKit.logger.debug("Received workitem: #{message.inspect}")
+
+              RuoteWorkitem.process( :amqp, message )
+
+              DaemonKit.logger.debug("Processed workitem.")
+
+              header.ack
+            end
+          end
+        end
+      end
+    end
+
+    # Shamelessly lifted from the ActiveSupport inflector
+    def underscore(camel_cased_word)
+      camel_cased_word.to_s.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+    end
+  end
+
+end

data/lib/daemon_kit/ruote_pseudo_participant.rb

@@ -0,0 +1,68 @@
+module DaemonKit
+  # Common convenience methods for making ruote pseudo-participants more DRY
+  # and unified
+  class RuotePseudoParticipant
+
+    class << self
+
+      attr_reader :exception_handler_method, :exception_handler_block,
+        :on_complete_handler_method, :on_complete_handler_block
+
+      # Register a callback method or block that gets called when an exception
+      # occurs during the processing of an action. +handler+ can be a symbol or
+      # string with a method name, or a block. Both will get the exception as
+      # the first parameter, and the block handler will receive the participant
+      # instance as the second parameter
+      def on_exception( handler = nil, &block )
+        @exception_handler_method = handler
+        @exception_handler_block = block
+      end
+
+      # Register a callback method or block that gets called when the action
+      # was successfully completed. Block callbacks get the workitem as
+      # parameter.
+      def on_complete( handler = nil, &block )
+        @on_complete_handler_method = handler
+        @on_complete_handler_block = block
+      end
+    end
+
+    # Current workitem
+    attr_reader :workitem
+
+    # Current action
+    attr_reader :action
+
+    # Perform the specified action with the provided workitem
+    def perform( action, workitem )
+      @action, @workitem = action, workitem
+
+      begin
+        send( action )
+        run_callbacks
+      rescue => e
+        handle_exception( e )
+      end
+    end
+
+    def handle_exception( e )
+      raise e if self.class.exception_handler_method.nil? && self.class.exception_handler_block.nil?
+
+      if self.class.exception_handler_method
+        send( self.class.exception_handler_method, e )
+      else
+        self.class.exception_handler_block.call( e, self )
+      end
+    end
+
+    def run_callbacks
+      return if self.class.on_complete_handler_block.nil? && self.class.on_complete_handler_method.nil?
+
+      if self.class.on_complete_handler_method
+        send( self.class.on_complete_handler_method )
+      else
+        self.class.on_complete_handler_block.call( workitem )
+      end
+    end
+  end
+end