isono 0.1.0

data/lib/isono/logger.rb

@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+
+require 'log4r'
+
+module Isono
+  # Injects +logger+ method to the included class.
+  # The output message from the logger methods starts the module name trailing message body.
+  module Logger
+
+    # Isono top level logger
+    rootlog = Log4r::Logger.new('Isono')
+    formatter = Log4r::PatternFormatter.new(:depth => 9999, # stack trace depth
+                                            :pattern => "%d %c [%l]: %M",
+                                            :date_format => "%Y/%m/%d %H:%M:%S"
+                                            )
+    rootlog.add(Log4r::StdoutOutputter.new('stdout', :formatter => formatter))
+    
+    
+    def self.included(klass)
+      klass.class_eval {
+
+        @class_logger = Log4r::Logger.new(klass.to_s)
+
+        def self.logger
+          @class_logger
+        end
+
+        def logger
+          @instance_logger || self.class.logger
+        end
+        
+        def self.logger_name
+          @class_logger.path
+        end
+
+        #def self.logger_name=(name)
+        #  @logger_name = name
+        #end
+
+        def set_instance_logger(suffix=nil)
+          suffix ||= self.__id__.abs.to_s(16)
+          @instance_logger = Log4r::Logger.new("#{self.class} for #{suffix}")
+        end
+      }
+    end
+
+  end
+end

data/lib/isono/manifest.rb

@@ -0,0 +1,161 @@
+# -*- coding: utf-8 -*-
+
+require 'ostruct'
+require 'pathname'
+
+module Isono
+  # Deals with .isono manifest file and its data.
+  class Manifest
+    # Loads .isono manifest file
+    # @param [String] path to which you want to load.
+    # @return [Isono::Manifest] new manifest object
+    def self.load_file(path)
+      buf = File.read(path)
+      # use the parent directory as the application root.
+      app_root = File.dirname(path)
+      m = eval("#{self.to_s}.new('#{app_root}') {\n" + buf + "\n}", TOPLEVEL_BINDING, path)
+
+      # use the manifest filename as the node name if not set.
+      m.node_name(File.basename(path, '.isono')) if m.node_name.nil?
+
+      m
+    end
+
+    attr_reader :node_modules, :app_root
+    
+    # @param [String] app_root Application root folder
+    # @param [block]
+    def initialize(app_root, &blk)
+      @node_modules = []
+      resolve_abs_app_root(app_root)
+      @config = ConfigStruct.new
+      @config.app_root = app_root
+
+      instance_eval(&blk) if blk
+      load_config
+    end
+
+    # Regist a node module class to be initialized/terminated.
+    # @param [Class] mod_class
+    def load_module(mod_class, *args)
+      unless mod_class.is_a?(Class) && mod_class < Isono::NodeModules::Base
+        raise ArgumentError, ""
+      end
+
+      return if @node_modules.find{|i| i[0] == mod_class }
+
+      sec_builder = mod_class.instance_variable_get(:@config_section_builder)
+      if sec_builder.is_a? Proc
+        sec_name = mod_class.instance_variable_get(:@config_section_name)
+        #sec_builder.call(ConfigStructBuilder.new(@config.add_section(sec_name)))
+        ConfigStructBuilder.new(@config.add_section(sec_name)).instance_eval &sec_builder
+      end
+      @node_modules << [mod_class, *args]
+    end
+    alias manager load_module
+
+    def node_name(name=nil)
+      @node_name = name.to_s if name
+      @node_name
+    end
+
+    def node_instance_id(instance_id=nil)
+      @node_instance_id = instance_id.to_s if instance_id
+      @node_instance_id
+    end
+
+    def node_id
+      "#{@node_name}-#{@node_instance_id}"
+    end
+
+    def config_path(path=nil)
+      @config_path = path if path
+      @config_path
+    end
+
+    def config(&blk)
+      if blk
+        @config.instance_eval &blk
+      end
+      @config
+    end
+
+    
+    private
+    # load config file and merge up with the config tree.
+    # it will not work when the config_path is nil or the file is missed
+    def load_config
+      if @config_path && File.exist?(@config_path)
+        buf = File.read(@config_path) 
+        eval("#{buf}", binding, @config_path)
+      end
+    end
+
+    def resolve_abs_app_root(app_root_path)
+      pt = Pathname.new(app_root_path)
+      if pt.absolute?
+        @app_root = app_root_path
+      else
+        @app_root = pt.realpath
+      end
+    end
+
+
+    class ConfigStruct < OpenStruct
+      attr_reader :desc
+      
+      def initialize()
+        super
+        @desc = {}
+      end
+      
+      # create sub config tree
+      def add_section(name)
+        newsec = self.class.new
+        self.instance_eval %Q"
+          def #{name}(&blk)
+            blk.call(self) if blk
+            @table[:#{name}]
+          end
+        "
+        @table[name.to_sym] = newsec
+      end
+
+      def inspect
+        @table.keys.map { |k|
+          "#{k}=#{@table[k]}"
+        }.join(', ')
+      end
+
+    end
+
+
+    class ConfigStructBuilder
+      def initialize(config)
+        @cur_desc=nil
+        @config = config
+      end
+
+      def add_config(name, default_val=nil)
+        @config.send("#{name}=".to_sym, default_val)
+        @config.desc[name.to_sym] = @cur_desc
+        
+        @cur_desc = nil
+      end
+
+      def desc(desc)
+        @cur_desc = desc
+      end
+
+      def method_missing(name, *args)
+        return if name.to_sym == :add_config
+        if name.to_s =~ /=$/
+          add_config(name.to_s.sub(/=$/,''), args[0])
+        else
+          add_config(name, *args)
+        end
+      end
+    end
+    
+  end
+end

data/lib/isono/messaging_client.rb

@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+
+require 'isono'
+require 'eventmachine'
+
+module Isono
+  # @example Sync RPC call with object method. 
+  # mc = MessagingClient.start
+  # puts mc.request('endpoint', 'func1', xxxx, xxxx)
+  # puts mc.request('endpoint', 'func2', xxx, xxx)
+  #
+  # @example Sync RPC call using delegated object
+  # mc = MessagingClient.start
+  # endpoint = mc.sync_rpc('endpoint')
+  # endpoint.func1(xxxx, xxxx)
+  # endpoint.func2(xxx, xxx)
+  #
+  class MessagingClient < Node
+    include Logger
+
+    def self.start(amqp_uri, manifest=nil, &blk)
+      node = self.new(manifest, &blk)
+
+      if EventMachine.reactor_thread?
+        EventMachine.schedule {
+          node.connect(amqp_uri)
+        }
+      else
+        q = ::Queue.new
+        EventMachine.schedule {
+          node.connect(amqp_uri) { |type|
+            q << type
+          }
+        }
+        case q.deq
+        when :success
+        when :error
+          raise "Connection failed: #{amqp_uri}"
+        end
+      end
+
+      node
+    end
+
+    def stop
+      if connected?
+        close {
+          EventMachine.schedule {
+            EventMachine.stop
+          }
+        }
+      end
+    end
+    
+    def initialize(m=nil, &blk)
+      m ||= Manifest.new(Dir.pwd) {
+        node_name 'msgclient'
+        node_instance_id Util.gen_id
+
+        load_module NodeModules::EventChannel
+        load_module NodeModules::RpcChannel
+        load_module NodeModules::JobChannel
+      }
+      m.instance_eval(&blk) if blk
+      super(m)
+    end
+
+    class RpcSyncDelegator
+      attr_reader :endpoint
+      
+      def initialize(rpc, endpoint, opts={})
+        @rpc = rpc
+        @endpoint = endpoint
+        @opts = {:timeout=>0.0, :oneshot=>false}.merge(opts)
+      end
+
+      private
+      def method_missing(m, *args)
+        if @opts[:oneshot]
+          oneshot_request(m, *args)
+        else
+          normal_request(m, *args)
+        end
+      end
+
+      def oneshot_request(m, *args)
+        @rpc.request(@endpoint, m, *args) { |req|
+          req.oneshot = true
+        }
+      end
+
+      def normal_request(m, *args)
+        @rpc.request(@endpoint, m, *args)
+      end
+    end
+    
+    def sync_rpc(endpoint, opts={})
+      rpc = NodeModules::RpcChannel.new(self)
+      RpcSyncDelegator.new(rpc, endpoint, opts)
+    end
+
+    def request(endpoint, key, *args, &blk)
+      rpc = NodeModules::RpcChannel.new(self)
+      rpc.request(endpoint, key, *args, &blk)
+    end
+
+    def submit(job_endpoint, key, *args)
+      NodeModules::JobChannel.new(self).submit(job_endpoint, key, *args)
+    end
+
+    def event_publish(evname, opts={})
+      NodeModules::EventChannel.new(self).publish(evname, opts)
+    end
+
+  end
+end

data/lib/isono/models/event_log.rb

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+
+module Isono
+  module Models
+    class EventLog < Sequel::Model
+      include Logger
+      plugin :schema
+      plugin :hook_class_methods
+
+      set_schema {
+        primary_key :id, :type => Integer, :auto_increment=>true, :unsigned=>true
+        column :event, :varchar, :size=>80, :null=>false
+        column :sender, :varchar, :size=>80, :null=>false
+        column :message, :text, :null=>false
+        column :publised_at, :datetime, :null=>false
+        column :created_at, :datetime, :null=>false
+        #index [:agent_id, :boot_token], {:unique=>true}
+      }
+
+      before_create(:set_created_at) do
+        self.created_at = Time.now
+      end
+      before_update(:set_updated_at) do
+      end
+
+    end
+  end
+end

data/lib/isono/models/job_state.rb

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+
+require 'sequel/model'
+
+module Isono
+  module Models
+    class JobState < Sequel::Model
+      include Logger
+      plugin :schema
+      plugin :hook_class_methods
+
+      set_schema {
+        primary_key :id, :type => Integer, :auto_increment=>true, :unsigned=>true
+        column :job_id, :varchar, :size=>80, :null=>false
+        column :parent_job_id, :varchar, :size=>80, :null=>true
+        column :node_id, :varchar, :size=>80, :null=>false
+        column :state, :varchar, :size=>10, :null=>false
+        column :message, :text, :null=>false, :default=>''
+        column :created_at, :datetime, :null=>false
+        column :updated_at, :datetime, :null=>false
+        column :started_at, :datetime, :null=>true
+        column :finished_at, :datetime, :null=>true
+        index :job_id, {:unique=>true}
+      }
+
+      before_create(:set_created_at) do
+        self.created_at = self.updated_at= Time.now
+      end
+      before_update(:set_updated_at) do
+        self.updated_at= Time.now
+      end
+
+    end
+  end
+end

data/lib/isono/models/node_state.rb

@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*-
+
+require 'sequel/model'
+require 'statemachine'
+
+module Isono
+  module Models
+    class NodeState < Sequel::Model
+      include Logger
+      plugin :schema
+      plugin :hook_class_methods
+
+      set_schema {
+        primary_key :id, :type => Integer, :auto_increment=>true, :unsigned=>true
+        column :node_id, :varchar, :size=>80, :null=>false
+        column :boot_token, :varchar, :size=>10, :null=>false
+        column :state, :varchar, :size=>10
+        column :created_at, :datetime, :null=>false
+        column :updated_at, :datetime, :null=>false
+        column :last_ping_at, :datetime, :null=>false
+        index :node_id, {:unique=>true}
+      }
+
+      before_create(:set_created_at) do
+        self.updated_at = self.created_at = Time.now
+      end
+      before_update(:set_updated_at) do
+        self.updated_at = Time.now
+      end
+
+
+      def state_machine
+        model = self
+        st = Statemachine.build do
+          startstate :init
+          trans :init,    :on_ping,      :online, proc {model.last_ping_at = Time.now}
+          trans :online,  :on_timeout,   :timeout
+          trans :timeout, :on_ping,      :online, proc {model.last_ping_at = Time.now}
+          trans :online,  :on_unmonitor, :offline
+          trans :timeout, :on_unmonitor, :offline
+          # do nothing on transition from and to the same state
+          trans :online,  :on_ping,      :online, proc {model.last_ping_at = Time.now}
+          trans :timeout, :on_timeout,   :timeout
+
+          on_entry_of :online, proc {
+            model.state = :online
+          }
+          on_entry_of :timeout, proc {
+            model.state = :timeout
+          }
+          on_entry_of :offline, proc {
+            model.state = :offline
+          }
+        end
+
+        if self[:state]
+          if st.has_state(self[:state].to_sym)
+            st.state = self[:state].to_sym
+          else
+            raise "Unknown state: #{self[:state]}"
+          end
+        else
+          st.reset
+        end
+        st
+      end
+
+    end
+  end
+end