isono 0.1.0

data/lib/isono/runner/agent.rb

@@ -0,0 +1,89 @@
+# -*- coding: utf-8 -*-
+
+require 'optparse'
+require 'amqp'
+require 'digest/sha1'
+
+require 'isono/agent'
+
+module Isono
+  module Runner
+    class Agent
+      include Daemonize
+      
+      def initialize(argv)
+        @argv = argv.dup
+        
+        @options = {
+          :amqp_server_uri => URI.parse('amqp://guest:guest@localhost/'),
+          :log_file => nil,
+          :pid_file => nil,
+          :daemonize => true
+        }
+        
+        parser.parse! @argv
+      end
+      
+      
+      def parser
+        @parser ||= OptionParser.new do |opts|
+          opts.banner = "Usage: agent [options]"
+          
+          opts.separator ""
+          opts.separator "Agent options:"
+          opts.on( "-i", "--id ID", "Manually specify the Agent ID" ) {|str| @options[:agent_id] = str }
+          opts.on( "-p", "--pid PIDFILE", "pid file path" ) {|str| @options[:pid_file] = str }
+          opts.on( "-s", "--server AMQP_URI", "amqp broker server to connect" ) {|str|
+            begin
+              @options[:amqp_server_uri] = URI.parse(str)
+            rescue URI::InvalidURIError => e
+              abort "#{e}"
+            end
+          }
+          opts.on("-X", "Run in foreground" ) { @options[:daemonize] = false }
+        end
+      end
+
+      
+      def run(manifest_path=nil)
+        #%w(QUIT INT TERM).each { |i|
+        %w(EXIT).each { |i|
+          Signal.trap(i) { Isono::Agent.stop{ remove_pidfile if @options[:daemonize]} }
+        }
+
+
+        # load manifest file
+        manifest = Manifest.load_file(manifest_path.nil? ? @options[:manifest_path] : manifest_path)
+
+        if @options[:node_id]
+          # force overwrite node_id if the command line arg was given.
+          manifest.node_id(@options[:node_id])
+        elsif manifest.node_id.nil?
+          # nobody specified the node_id then set the ID in the
+          # default manner. 
+          manifest.node_id(default_node_id)
+        end
+
+        @options[:log_file] ||= "/var/log/%s.log" % [manifest.node_name]
+        @options[:pid_file] ||= "/var/run/%s.pid" % [manifest.node_name]
+
+        if @options[:daemonize]
+          daemonize(@options[:log_file])
+        end
+
+        EventMachine.epoll
+        EventMachine.run {
+          Isono::Agent.start(manifest, @options)
+        }
+      end
+
+      private
+      def default_node_id
+        # use the ip address for the default routeas key value
+        Digest::SHA1.hexdigest(`/sbin/ip route get 8.8.8.8`.split("\n")[0].split.last)[0, 10]
+      end
+
+    end
+
+  end
+end

data/lib/isono/runner/rpc_server.rb

@@ -0,0 +1,198 @@
+# -*- coding: utf-8 -*-
+
+require 'optparse'
+require 'amqp'
+require 'digest/sha1'
+
+require 'isono'
+require 'isono/amqp_client'
+
+module Isono
+  module Runner
+    # Run a new agent which provides RPC endpoint and delayed job.
+    #
+    # @example
+    #
+    # class RpcEndpoint1
+    #   def func1
+    #   end
+    # end
+    #
+    # class RpcEndpoint2
+    #   def func2
+    #   end
+    # end
+    # 
+    # Isono::Runner::RpcServer.start do
+    #  endpoint('xxxx1', RpcEndpoint1.new)
+    #  endpoint('xxxx2', RpcEndpoint2.new)
+    # end
+    #
+    # mc = MessagingClient.new
+    # xxxx1 = mc.rpc('xxxx1')
+    # xxxx1.func1
+    #
+    # xxxx2 = mc.rpc('xxxx2')
+    # xxxx2.func2
+    module RpcServer
+
+      class EndpointBuilder
+        module BuildMethods
+          # @exmaple
+          # job 'command1', proc {
+          #     # do somthing.
+          #   }, proc {
+          #     # do somthing on job failure.
+          #   }
+          # @example
+          # job 'command1' do
+          #   response.fail_cb {
+          #     # do somthing on job failure.
+          #   }
+          #   sleep 10
+          # end
+          def job(command, run_cb=nil, fail_cb=nil, &blk)
+            app = if run_cb.is_a?(Proc)
+                    proc {
+                      request.fail_cb do
+                        self.instance_eval(&fail_cb)
+                      end
+
+                      self.instance_eval(&run_cb)
+                    }
+                  elsif blk
+                    blk
+                  else
+                    raise ArgumentError, "callbacks were not set propery"
+                  end
+            add(:job, command, &app)
+          end
+
+          def rpc(command, &blk)
+            add(:rpc, command, &blk)
+          end
+
+          def build(endpoint, node)
+            helper_context = self.new(node)
+            
+            app_builder = lambda { |builders|
+              unless builders.empty?
+                map_app = Rack::Map.new
+                builders.each { |b|
+                  b.call(map_app, helper_context)
+                }
+                map_app
+              end
+            }
+
+            app = app_builder.call(@builders[:job])
+            if app
+              NodeModules::JobChannel.new(node).register_endpoint(endpoint, Rack.build do
+                                                                    run app
+                                                                  end)
+            end
+            
+            app = app_builder.call(@builders[:rpc])
+            if app
+              NodeModules::RpcChannel.new(node).register_endpoint(endpoint, Rack.build do
+                                                                    use Rack::ThreadPass
+                                                                    run app
+                                                                  end
+                                                                  )
+            end
+          end
+          
+          
+          protected
+          def add(type, command, &blk)
+            @builders[type] << lambda { |rack_map, ctx|
+              rack_map.map(command, Rack::Proc.new(ctx, &blk))
+            }
+          end
+        end
+        
+        def self.inherited(klass)
+          klass.class_eval {
+            @builders = {:job=>[], :rpc=>[]}
+            extend BuildMethods
+          }
+        end
+
+        def initialize(node)
+          @node = node
+        end
+      end
+      
+
+      DEFAULT_MANIFEST = Manifest.new(Dir.pwd) do
+        load_module NodeModules::EventChannel
+        load_module NodeModules::RpcChannel
+        load_module NodeModules::JobWorker
+        load_module NodeModules::JobChannel
+      end
+      
+      def start(manifest=nil, &blk)
+        rpcsvr = Server.new(ARGV)
+        rpcsvr.run(manifest, &blk)
+      end
+      module_function :start
+
+      class Server
+        def initialize(argv)
+          @argv = argv.dup
+          
+          @options = {
+            :amqp_server_uri => URI.parse('amqp://guest:guest@localhost/'),
+          }
+          
+          parser.parse! @argv
+        end
+        
+        def parser
+          @parser ||= OptionParser.new do |opts|
+            opts.banner = "Usage: agent [options]"
+            
+            opts.separator ""
+            opts.separator "Agent options:"
+            opts.on( "-i", "--id ID", "Manually specify the Node ID" ) {|str| @options[:node_id] = str }
+            opts.on( "-s", "--server AMQP_URI", "amqp broker server to connect" ) {|str|
+              begin
+                @options[:amqp_server_uri] = URI.parse(str)
+              rescue URI::InvalidURIError => e
+                abort "#{e}"
+              end
+            }
+          end
+        end
+        
+        def run(manifest=nil, &blk)
+          %w(EXIT).each { |i|
+            Signal.trap(i) { Isono::Node.stop }
+          }
+          
+          # .to_s to avoid nil -> String conversion failure.
+          if @options[:node_id]
+            manifest.node_instance_id(@options[:node_id])
+          elsif manifest.node_instance_id.nil?
+            abort("[ERROR]: manifest.node_istance_id is not set")
+          end
+          
+          EventMachine.epoll
+          EventMachine.run {
+            @node = Isono::Node.new(manifest)
+            @node.connect(@options[:amqp_server_uri], @options) do
+              self.instance_eval(&blk) if blk
+            end
+          }
+        end
+        
+        def endpoint(endpoint, builder)
+          raise TypeError unless builder.respond_to?(:build)
+          builder.build(endpoint, @node)
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/isono/serializer.rb

@@ -0,0 +1,43 @@
+
+module Isono
+  # AMQP message serializer
+  class Serializer
+    def self.instance
+      @serializer ||= RubySerializer.new
+    end
+
+    def marshal(buf)
+      raise NotImplementedError
+    end
+
+    def unmarshal(buf)
+      raise NotImplementedError
+    end
+  end
+
+
+  class YamlSerializer < Serializer
+    def initialize
+      require 'yaml'
+    end
+    
+    def marshal(buf)
+      YAML.dump(buf)
+    end
+
+    def unmarshal(buf)
+      YAML.load(buf)
+    end
+  end
+
+  class RubySerializer < Serializer
+    
+    def marshal(buf)
+      ::Marshal.dump(buf)
+    end
+
+    def unmarshal(buf)
+      ::Marshal.load(buf)
+    end
+  end
+end

data/lib/isono/thread_pool.rb

@@ -0,0 +1,169 @@
+# -*- coding: utf-8 -*-
+require 'thread'
+
+module Isono
+  class ThreadPool
+    include Logger
+
+    class WorkerTerminateError < StandardError; end
+    class TimeoutError < StandardError; end
+    
+    def initialize(worker_num=1, name=nil, opts={})
+      set_instance_logger(name)
+      @queue = ::Queue.new
+      @name = name
+      @opts = {:stucked_queue_num=>20}.merge(opts)
+      @last_stuck_warn_at = Time.now
+      
+      @worker_threads = {}
+      worker_num.times {
+        t = Thread.new {
+          loop {
+            begin
+              while op = @queue.pop
+                if @queue.size > @opts[:stucked_queue_num] && Time.now - @last_stuck_warn_at > 5.0
+                  logger.warn("too many stacked workers: #{@queue.size}")
+                  @last_stuck_warn_at = Time.now
+                end
+                op.call
+              end
+            rescue WorkerTerminateError
+              # someone indicated to terminate this thread
+              # exit from the current loop
+              break
+            rescue Exception => e
+              self.logger.error(e)
+            end
+          }
+          @worker_threads.delete(Thread.current.__id__)
+          logger.info("#{Thread.current} is being terminated")
+        }
+        @worker_threads[t.__id__] = t
+      }
+    end
+
+    # Pass a block to a worker thread. The job is queued until the
+    # worker thread found.
+    # @param [Bool] immediage
+    # @param [Proc] blk A block to be proccessed on a worker thread.
+    def pass(immediate=true, &blk)
+      if immediate && member_thread?
+        return blk.call
+      end
+      
+      @queue << blk
+    end
+
+    # Send a block to a worker thread similar with pass(). but this
+    # get the caller thread waited until the block proceeded in a
+    # worker thread.
+    # @param [Bool] immediage
+    # @param [Float] time_out 
+    # @param [Proc] blk
+    def barrier(immediate=true, time_out=nil, &blk)
+      if immediate && member_thread?
+        return blk.call
+      end
+      
+      q = ::Queue.new
+      time_start = ::Time.now
+      
+      self.pass {
+        begin
+          q << blk.call
+        rescue Exception => e
+          q << e
+        end
+      }
+
+      em_sig = nil
+      if time_out
+        em_sig = EventMachine.add_timer(time_out) {
+          q << TimeoutError.new
+        }
+      end
+      
+      res = q.shift
+      EventMachine.cancel_timer(em_sig)
+      time_elapsed = ::Time.now - time_start
+      logger.debug("Elapsed time for #{blk}: #{time_elapsed} secs") if time_elapsed > 0.05
+      if res.is_a?(Exception)
+        raise res
+      end
+      res
+      
+    end
+
+    def clear
+      @queue.clear
+    end
+
+    # Immediatly shutdown all the worker threads
+    def shutdown()
+      @worker_threads.each {|t|
+        t.raise WorkerTerminateError
+      }
+    end
+
+    def member_thread?(thread=Thread.current)
+      @worker_threads.has_key?(thread.__id__)      
+    end
+
+    def shutdown_graceful(timeout)
+      term_sig_q = ::Queue.new
+      worker_num = @worker_threads.size
+      # enqueue the terminate jobs.
+      worker_num.times {
+        @queue.push proc {
+          term_sig_q.enq(1)
+          raise WorkerTerminateError
+        }
+      }
+
+      em_sig = nil
+      if timeout > 0.0
+        em_sig = EventMachine.add_timer(timeout) {
+          worker_num.times {
+            term_sig_q << TimeoutError.new
+          }
+        }
+      end
+
+      timeout_workers = 0
+      while worker_num > 0
+        if term_sig_q.deq.is_a?(TimeoutError)
+          timeout_workers += 1
+        end
+        worker_num -= 1
+      end
+
+      logger.error("#{timeout_workers} of worker threads timed out during the cleanup") if timeout_workers > 0
+    ensure
+      shutdown
+      EventMachine.cancel_timer(em_sig)
+    end
+
+    def graceful_shutdown2
+      # make new jobs push to dummy queue.
+      old_queue = @queue
+      @queue = ::Queue.new
+      # wait until @queue becomes empty
+      if !old_queue.empty?
+        logger.info("Waiting for #{old_queue.size} worker jobs in #{self}")
+        while !old_queue.empty?
+          sleep 1
+        end
+      end
+    
+      @worker_threads.each {|t|
+        t.raise WorkerTerminateError
+      }
+    end
+
+    
+    private
+    def thread_loop
+    end
+     
+  end
+end