isono 0.1.0

data/lib/isono.rb

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+
+module Isono
+  VERSION='0.1.0'
+
+  autoload :Node, 'isono/node'
+  autoload :AmqpClient, 'isono/amqp_client'
+  autoload :Daemonize, 'isono/daemonize'
+  autoload :Util, 'isono/util'
+  autoload :ThreadPool, 'isono/thread_pool'
+  autoload :Logger, 'isono/logger'
+  autoload :Manifest, 'isono/manifest'
+  autoload :Serializer, 'isono/serializer'
+  autoload :EventObservable, 'isono/event_observable'
+  autoload :EventDelegateContext, 'isono/event_delegate_context'
+  autoload :ResourceManifest, 'isono/resource_manifest'
+  autoload :MessagingClient, 'isono/messaging_client'
+  module NodeModules
+    autoload :Base, 'isono/node_modules/base'
+    autoload :DataStore, 'isono/node_modules/data_store'
+    autoload :EventChannel, 'isono/node_modules/event_channel'
+    autoload :RpcChannel, 'isono/node_modules/rpc_channel'
+    autoload :NodeHeartbeat, 'isono/node_modules/node_heartbeat'
+    autoload :NodeCollector, 'isono/node_modules/node_collector'
+    autoload :EventLogger, 'isono/node_modules/event_logger'
+    autoload :JobWorker, 'isono/node_modules/job_worker'
+    autoload :JobChannel, 'isono/node_modules/job_channel'
+    autoload :JobCollector, 'isono/node_modules/job_collector'
+  end  
+  module Runner
+    autoload :Agent, 'isono/runner/agent'
+    autoload :RpcServer, 'isono/runner/rpc_server'
+  end
+  module Rack
+    require 'isono/rack'
+    autoload :Builder, 'isono/rack/builder'
+    autoload :ObjectMethod, 'isono/rack/object_method'
+    autoload :Proc, 'isono/rack/proc'
+    autoload :ThreadPass, 'isono/rack/thread_pass'
+    autoload :Job, 'isono/rack/job'
+    autoload :DataStore, 'isono/rack/data_store'
+    autoload :Map, 'isono/rack/map'
+  end
+
+  module Models
+    autoload :NodeState, 'isono/models/node_state'
+    autoload :ResourceInstance, 'isono/models/resource_instance'
+    autoload :EventLog, 'isono/models/event_log'
+    autoload :JobState, 'isono/models/job_state'
+  end
+
+  class << self
+    def home
+      if Kernel.const_defined?(:Gem) && (gemspec = Gem.loaded_specs['isono'])
+        gemspec.full_gem_path
+      else
+        File.expand_path('../../', __FILE__)
+      end
+    end
+  end
+end

data/lib/isono/amqp_client.rb

@@ -0,0 +1,169 @@
+# -*- coding: utf-8 -*-
+
+require 'thread'
+
+require 'eventmachine'
+require 'amqp'
+require 'mq'
+
+require 'uri/generic'
+
+module URI
+  # Declare amqp:// URI scheme.
+  class AMQP < Generic
+    COMPONENT = [
+      :scheme,
+      :userinfo, :host, :port,
+      :path
+    ].freeze
+
+    DEFAULT_PORT=5672
+
+    def self.build(args)
+      tmp = Util::make_components_hash(self, args)
+      return super(tmp)
+    end
+
+    def initialize(*args)
+      args[5] = '/' if args[5].nil? || args[5] == ''
+      super(*args)
+    end
+
+    alias :vhost :path
+    alias :vhost= :path=
+  end
+
+  @@schemes['AMQP'] = AMQP
+end
+
+
+module Isono
+  # AMQP Client module for master and agent
+  # 
+  # @example 
+  # class Client
+  #   include Isono::AmqpClient
+  #
+  #   def logger()
+  #   end
+  # end
+  module AmqpClient
+    attr_reader :mq, :amqp_client
+    
+    def amqp_server_uri
+      raise "The connection is not established yet." unless @amqp_client && connected?
+
+      URI::AMQP.build(:host => @amqp_client.settings[:host],
+                      :port => @amqp_client.settings[:port],
+                      :path => @amqp_client.settings[:vhost]
+                      )
+    end
+
+    def connect(broker_uri, *args, &blk)
+      raise "the connection is still alive for: #{amqp_server_uri}" if connected?
+
+      broker_uri = URI.parse(broker_uri.to_s) unless broker_uri.is_a?(URI)
+      default = ::AMQP.settings
+      opts = {:host => broker_uri.host, 
+        :port => broker_uri.port || default[:port],
+        :vhost => broker_uri.vhost || default[:vhost],
+        :user=>broker_uri.user || default[:user],
+        :pass=>broker_uri.password ||default[:pass]
+      }
+      opts.merge!(args) if args.is_a?(Hash)
+      
+      @amqp_client = ::AMQP.connect(opts)
+      @amqp_client.instance_eval {
+        def settings
+          @settings
+        end
+      }
+      @amqp_client.callback {
+        on_connect
+        if blk
+          blk.arity == 1 ? blk.call(:success) : blk.call
+        end            
+      }
+      @amqp_client.errback {
+        logger.error("Failed to connect to the broker: #{amqp_server_uri}")
+        blk.call(:error) if blk && blk.arity == 1
+      }
+      # Note: Thread.current[:mq] is utilized in amqp gem.
+      Thread.current[:mq] = ::MQ.new(@amqp_client)
+
+      self
+    end
+
+    def connected?
+      !@amqp_client.nil? && @amqp_client.connected?
+    end
+
+    def amq
+      raise 'AMQP connection is not established yet' unless connected?
+      Thread.current[:mq]
+    end
+
+    def on_connect
+    end
+    
+    def on_close
+    end
+
+    def close(&blk)
+      return unless connected?
+
+      @amqp_client.close {
+        begin
+          on_close
+          blk.call if blk
+        ensure
+          @amqp_client = nil
+          Thread.current[:mq] = nil
+        end
+      }
+    end
+
+    # Publish a message to the designated exchange.
+    # 
+    # @param [String] exname The exchange name
+    # @param [String] message Message body to be sent
+    # @param [Hash] opts Options with the message.
+    #    :key => 'keyname'
+    # @return [void]
+    #
+    # @example Want to broadcast the data to all bound queues:
+    #  publish_to('topic exchange', 'data', :key=>'*')
+    # @example Want to send the data to the specific queue(s):
+    #  publish_to('exchange name', 'group.1', 'data')
+    def publish_to(exname, message, opts={})
+      EventMachine.schedule {
+        ex = amq.exchanges[exname] || raise("Undefined exchange name : #{exname}")
+        case ex.type
+        when :topic
+          unless opts.has_key? :key
+            opts[:key] = '*'
+          end
+        end
+        ex.publish(Serializer.instance.marshal(message), opts)
+      }
+    end
+
+    def define_queue(queue_name, exchange_name, opts={}, &blk)
+      q = amq.queue(queue_name, opts)
+      amq.exchanges.has_key? exchange_name
+      q.bind( exchange_name, opts ).subscribe &blk
+    end
+
+
+    def identity_queue(unique_id)
+      amq.direct('identity')
+      begin
+        define_queue("ident.#{unique_id}", "identity", {:exclusive=>true, :nowait=>false})
+      rescue MQ::Error => e
+        logger.error("The node having same ID already exists: #{unique_id}")
+        raise e
+      end
+    end
+
+  end
+end

data/lib/isono/daemonize.rb

@@ -0,0 +1,96 @@
+
+
+require 'daemons/daemonize'
+require 'fileutils'
+
+module Process
+  # Returns +true+ the process identied by +pid+ is running.
+  def running?(pid)
+    Process.getpgid(pid) != -1
+  rescue Errno::ESRCH
+    false
+  end
+  module_function :running?
+end
+
+
+module Wakame
+  module Daemonize
+    # Change privileges of the process
+    # to the specified user and group.
+    def change_privilege(user, group=user)
+      Wakame.log.info("Changing process privilege to #{user}:#{group}")
+
+      uid, gid = Process.euid, Process.egid
+      target_uid = Etc.getpwnam(user).uid
+      target_gid = Etc.getgrnam(group).gid
+
+      if uid != target_uid || gid != target_gid
+        if pid_file && File.exist?(pid_file) && uid == 0
+          File.chown(target_uid, target_gid, pid_file)
+        end
+
+        # Change process ownership
+        Process.initgroups(user, target_gid)
+        Process::GID.change_privilege(target_gid)
+        Process::UID.change_privilege(target_uid)
+      end
+    rescue Errno::EPERM => e
+      Wakame.log.error("Couldn't change user and group to #{user}:#{group}: #{e}")
+    end
+
+    def pid_file
+      @options[:pid_file]
+    end
+
+    def pid
+      File.exist?(pid_file) ? open(pid_file).read.to_i : nil
+    end
+
+    def setup_pidfile
+      #raise 'Please implement pid_file() method' unless respond_to? :pid_file
+
+      unless File.exist?(File.dirname(pid_file))
+        FileUtils.mkpath(File.dirname(pid_file))
+      end
+
+      open(pid_file, "w") { |f| f.write(Process.pid) }
+      File.chmod(0644, pid_file)
+    end
+
+    def daemonize(log_path)
+      # Cleanup stale pidfile or prevent from multiple process running.
+      if File.exist?(pid_file)
+        if pid && Process.running?(pid)
+          raise "#{pid_file} already exists, seems like it's already running (process ID: #{pid}). " +
+            "Stop the process or delete #{pid_file}."
+        else
+          Wakame.log.info "Deleting the stale PID file: #{pid_file}"
+          remove_pidfile
+        end
+      end
+
+      ::Daemonize.daemonize(log_path, File.basename($0.to_s))
+
+      setup_pidfile
+      #Signal.trap('HUP') {}
+    end
+
+    def on_restart(&blk)
+      @on_restart = blk
+    end
+
+    def restart
+      raise '' if @on_restart.nil?
+
+      @on_restart.call
+    end
+    
+    def remove_pidfile
+      File.delete(pid_file) if pid_file && File.exist?(pid_file)
+    rescue => e
+      Wakame.log.error(e)
+    end
+    
+  end
+end

data/lib/isono/event_delegate_context.rb

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+
+require 'statemachine'
+
+module Isono
+  # Catch all the event from the Statemachine and delegate.
+  class EventDelegateContext
+    include EventObservable
+    include Logger
+    
+    def initialize(stm)
+      raise ArgumentError unless stm.is_a? Statemachine::Statemachine
+      initialize_event_observable
+      @stm = stm
+      @stm.context = self
+      inject_event_handlers
+    end
+
+    protected
+    def on_event_fired(evtype, *args)
+      logger.debug("#{evtype}")
+    end
+    
+    private
+    # analyze the current statemachine object and inject
+    # event handlers where the stm can trigger the events:
+    # - all entry/exit events from/to each state.
+    # - transition events
+    def inject_event_handlers
+      states = @stm.instance_variable_get(:@states)
+      states.each { |k, st|
+        prev = st.entry_action
+        st.entry_action = proc { |*args|
+          on_entry_state(st.id, *args)
+        }
+        prev = st.exit_action
+        st.exit_action = proc { |*args|
+          on_exit_state(st.id, *args)
+        }
+      }
+    end
+    
+    def on_entry_state(state, *args)
+      evname = "on_entry_of_#{state}"
+      fire_event(:on_entry_state, {:evname=>evname.to_sym, :args=>args})
+      fire_event(evname.to_sym, args)
+    end
+
+    def on_exit_state(state, *args)
+      evname = "on_exit_of_#{state}"
+      fire_event(:on_exit_state, {:evname=>evname.to_sym, :args=>args})
+      fire_event(evname.to_sym, args)
+    end
+    
+  end
+end

data/lib/isono/event_observable.rb

@@ -0,0 +1,86 @@
+# -*- coding: utf-8 -*-
+
+module Isono
+  # Add event handling support to the arbitrary class.
+  # TODO: make it thread safe.
+  module EventObservable
+    class Timeout
+    end
+    
+    def fire_event(evtype, *args)
+      if logger && @debug_event
+        logger.debug("fire_event(#{evtype}, #{args.nil? ? 'nil' : args.inspect})")
+      end
+      begin
+        on_event_fired(evtype, *args)
+      rescue => e
+        if logger
+          logger.error(e)
+        else
+          puts e
+        end
+      end
+      return unless @tickets[evtype]
+
+      deleted_tickets = []
+      @tickets[evtype].each { |ticket|
+        h = @handlers[ticket]
+        if h
+          begin
+            h.call(*args)
+          rescue Exception => e
+            logger.error("caught exception: #{ticket}, proc=#{h.to_s}: #{e.to_s}")
+            logger.error(e)
+          end
+        else
+          deleted_tickets << ticket
+        end
+      }
+
+      @tickets[evtype] -= deleted_tickets
+    end
+
+    def add_observer(evtype, &blk)
+      ticket = Util.gen_id
+      @handlers[ticket] = blk
+      (@tickets[evtype] ||= []) << ticket
+      ticket
+    end
+
+    def add_observer_once(evtype, timeout=0, &blk)
+      ticket = add_observer(evtype) { |*args|
+        begin
+          blk.call(*args)
+        ensure
+          remove_observer(ticket)
+        end
+      }
+
+      if timeout > 0
+        EM.add_timer(timeout) {
+          if @handlers.has_key? ticket
+            blk.call(Timeout.new)
+            remove_observer(ticket)
+          end
+        }
+      end
+      
+      ticket
+    end
+
+    def remove_observer(ticket)
+      @handlers.delete(ticket)
+    end
+
+    protected
+    def initialize_event_observable
+      @tickets = {}
+      @handlers = {}
+      @debug_event = false
+    end
+
+
+    def on_event_fired(evtype, *args)
+    end
+  end
+end