isono 0.1.0

data/lib/isono/rack.rb

@@ -0,0 +1,67 @@
+# -*- coding: utf-8 -*-
+
+module Isono
+module Rack
+  class RpcError < RuntimeError; end
+  class UnknownMethodError < RpcError; end
+  class ResponseIncompleteError < RpcError; end
+  
+  class << self
+    def build(&blk)
+      Builder.new(&blk)
+    end
+  end
+  
+  class Decorator
+    attr_reader :app
+    
+    def initialize(app)
+      raise TypeError unless app.respond_to?(:call)
+      @app = app
+      
+      set_instance_logger(@app.class.to_s) if self.respond_to? :set_instance_logger
+    end
+    
+    def call(req, res)
+      app.call(req, res)
+    end
+  end
+
+  class Request
+    attr_reader :r
+    
+    def initialize(request_hash)
+      @r = request_hash
+    end
+    
+    def command() @r[:command]; end
+    alias :key :command
+    def args() @r[:args]; end
+    def sender() @r[:sender]; end
+    def message_id() @r[:message_id]; end
+  end
+
+  class Response
+    attr_reader :ctx
+    
+    # @param [NodeModules::RpcChannel::ResponseContext] ctx
+    def initialize(ctx)
+      raise TypeError unless ctx.is_a?(NodeModules::RpcChannel::ResponseContext)
+      @ctx = ctx
+    end
+
+    def responded?
+      @ctx.responded?
+    end
+
+    def progress(msg)
+      @ctx.progress(msg)
+    end
+
+    def response(msg)
+      @ctx.response(msg)
+    end
+    
+  end
+end  
+end

data/lib/isono/rack/builder.rb

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+
+module Isono
+module Rack
+  class Builder
+    def initialize(&blk)
+      @filters = []
+      @app = Map.new
+      instance_eval(&blk) if blk
+    end
+    
+    def use(decorator_class, *args)
+      raise TypeError unless decorator_class < Decorator
+      @filters << lambda {|disp| decorator_class.new(disp, *args) }
+    end
+    
+    def run(app)
+      raise TypeError unless app.respond_to?(:call)
+      @app.map('', app)
+    end
+
+    def map(command, app=nil, &blk)
+      raise ArgumentError if app && blk
+      if app
+        raise TypeError unless app.respond_to?(:call)
+        @app.map(command, app)
+      elsif blk
+        @app.map(command, self.class.new(&blk))
+      else
+        raise ArgumentError
+      end
+    end
+
+    def call(req, res)
+      raise "main app is not set" if @app.nil?
+      @filters.reverse.inject(@app) {|d, f| f.call(d) }.call(req, res)
+    end
+  end
+end
+end

data/lib/isono/rack/data_store.rb

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+
+module Isono
+module Rack
+  # Runs app.call() in the thread context of DataStore's worker.
+  class DataStore < Decorator
+    def call(req, res)
+      NodeModules::DataStore.pass {
+        begin
+          ret = @app.call(req, res)
+          res.response(ret) unless res.responded?
+        rescue ::Exception => e
+          res.response(e) unless res.responded?
+          raise e
+        end
+      }
+    end
+  end
+end
+end

data/lib/isono/rack/job.rb

@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*-
+
+module Isono
+module Rack
+  class Job < Decorator
+    include Logger
+
+    # Response class for nothing response.
+    # It is used when the job request type is :submit.
+    class NullResponse < Response
+      def progress(ret)
+      end
+
+      def response(ret)
+      end
+    end
+
+    class JobResponse < Response
+      # @param [NodeModules::RpcChannel::ResponseContext] ctx
+      # @param [NodeModules::JobWorker::JobContext] jobctx
+      def initialize(ctx, jobctx)
+        super(ctx)
+        @job = jobctx
+      end
+
+      # Register call back which called on the job failure. 
+      def fail_cb(&blk)
+        @job.fail_cb = blk
+      end
+    end
+
+    class JobRequest < Request
+      # @param [Hash] request_hash
+      # @param [NodeModules::JobWorker::JobContext] jobctx
+      def initialize(request_hash, jobctx)
+        @job = jobctx
+        @r = request_hash
+      end
+    end
+    
+    def initialize(app, job_worker)
+      super(app)
+      @job_worker = job_worker
+    end
+    
+    def call(req, res)
+      orig_res = res
+      case req.r[:job_request_type]
+      when :submit
+        res = NullResponse.new(res.ctx)
+      end
+      
+      job = @job_worker.run(req.r[:parent_job_id]){
+        begin
+          @app.call(JobRequest.new(req.r, job), JobResponse.new(res.ctx, job))
+          res.response(nil) unless res.responded?
+        rescue Exception => e
+          res.response(e) unless res.responded?
+          raise e
+        end
+      }
+
+      case req.r[:job_request_type]
+      when :submit
+        orig_res.response(job.to_hash)
+      else
+        # send job context info back at the first progress message.
+        # following progress messages to be handled as usual.
+        res.progress(job.to_hash)
+      end
+    end
+  end
+end
+end

data/lib/isono/rack/map.rb

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+
+
+module Isono
+  module Rack
+    class Map
+      def self.build(&blk)
+        n = self.new
+        blk.call(n)
+        n
+      end
+      
+      def initialize(&blk)
+        @table = {}
+        instance_eval(&blk) if blk
+      end
+
+      # @example
+      #  map :xxxx do
+      #    response.response('xxxxx')
+      #  end
+      # @example
+      #   map :xxxx, A.new do
+      #     puts self # A.new
+      #   end
+      # @example
+      #   map :xxxx, App.new
+      def map(command, app=nil, &blk)
+        command = command.to_s
+        
+        if app && blk
+          @table[command]=Rack::Proc.new(app, &blk)
+        elsif app && !blk
+          raise TypeError unless app.respond_to?(:call)
+          @table[command]=app
+        elsif !app && blk
+          @table[command]=Rack::Proc.new(&blk)
+        else
+          raise ArgumentError
+        end
+        self
+      end
+      
+      def default(&blk)
+        map('', blk)
+      end
+      
+      def call(req, res)
+        mapped_app = @table[req.command.to_s] || @table['']
+        raise UnknownMethodError if mapped_app.nil?
+        
+        mapped_app.call(req, res)
+      end
+    end
+  end
+end

data/lib/isono/rack/object_method.rb

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+
+module Isono
+module Rack
+  class ObjectMethod
+    include Logger
+    
+    def initialize(obj)
+      @obj = obj
+    end
+    
+    def call(req, res)
+      m = @obj.method(req.command)
+      raise UnknownMethodError, "#{req.command}" if m.nil?
+      res.response(m.arity.abs > 0 ? m.call(*req.args) : m.call)
+    end
+    
+  end
+end
+end

data/lib/isono/rack/proc.rb

@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+
+module Isono
+module Rack
+  class Proc
+    include Logger
+
+    THREAD_LOCAL_KEY=self.to_s
+    
+    attr_accessor :context
+    
+    def initialize(context=nil, opts={}, &blk)
+      @context = context || Object.new
+      @blk = blk
+    end
+    
+    def call(req, res)
+      Thread.current["#{THREAD_LOCAL_KEY}/request"] = req
+      Thread.current["#{THREAD_LOCAL_KEY}/response"] = res
+      begin
+        # create per-request context object from original.
+        c = @context.dup
+        c.extend InjectMethods
+        begin
+          c.instance_eval(&@blk)
+          # send empty message back to client if the response is not handled in block.
+          res.response(nil) unless res.responded?
+        rescue ::Exception => e
+          res.response(e) unless res.responded?
+          raise e
+        end
+      ensure
+        Thread.current["#{THREAD_LOCAL_KEY}/request"] = nil
+        Thread.current["#{THREAD_LOCAL_KEY}/response"] = nil
+      end
+    end
+
+    module InjectMethods
+      def request
+        Thread.current["#{THREAD_LOCAL_KEY}/request"]
+      end
+      
+      def response
+        Thread.current["#{THREAD_LOCAL_KEY}/response"]
+      end
+    end
+    
+  end
+end
+end

data/lib/isono/rack/thread_pass.rb

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+
+module Isono
+module Rack
+  class ThreadPass < Decorator
+    include Logger
+    
+    def call(req, res)
+      ::Thread.new {
+        begin
+          app.call(req, res)
+        rescue Exception => e
+          logger.error(e)
+          res.response(e) unless res.responded?
+        else
+          raise ResponseIncompleteError unless res.responded?
+        end
+      }
+    end
+  end
+end
+end

data/lib/isono/resource_manifest.rb

@@ -0,0 +1,273 @@
+# -*- coding: utf-8 -*-
+
+require 'statemachine'
+require 'pathname'
+require 'yaml'
+
+module Isono
+  class ResourceManifest
+    include Logger
+
+    # DSL to define a new resource manifest.
+    class Loader
+      include Logger
+      
+      def initialize(m)
+        @manifest = m
+      end
+      
+      def description(desc)
+        @manifest.description = desc
+      end
+      alias :desc :description
+
+      def statemachine(&blk)
+        @manifest.stm = Statemachine.build(&blk)
+      end
+
+      def load_path(path)
+        @manifest.append_load_path(path)
+      end
+
+      def name(name)
+        @manifest.name = name
+      end
+            
+      def entry_state(state, &blk)
+       @manifest.entry_state[state] ||= StateItem.new
+       EntryState.new( @manifest.entry_state[state] ).instance_eval(&blk)
+      end
+      
+      def exit_state(state, &blk)
+       @manifest.entry_state[state] ||= StateItem.new
+       ExitState.new( @manifest.entry_state[state] ).instance_eval(&blk)
+      end
+
+      def plugin(klass)
+        logger.debug("plugin: #{klass.to_s}")
+        if klass.const_defined?(:ClassMethods) && klass.const_get(:ClassMethods).is_a?(Module)
+          self.extend(klass.const_get(:ClassMethods))
+        end
+
+        #if klass.respond_to? :extend_task
+        if klass.const_defined?(:TaskMethods) && klass.const_get(:TaskMethods).is_a?(Module)
+          TaskBlock.class_eval {
+            include klass.const_get(:TaskMethods)
+          }
+        end
+      end
+
+      def manifest
+        @manifest
+      end
+
+      def config(&blk)
+        Manifest::ConfigStructBuilder.new(@manifest.config).instance_eval &blk
+      end
+
+      class EntryState
+        def initialize(stitem)
+          @state_item = stitem
+        end
+        
+        def on_event(evname, sender, &blk)
+          @state_item.on_event[evname] = {
+            :evname => evname,
+            :sender => sender,
+            :task => TaskBlock.new(blk)
+          }
+        end
+
+        def on_command(cmd, &blk)
+          @state_item.on_command[cmd] = {:task=> TaskBlock.new(blk)}
+        end
+        
+        def task(&blk)
+          @state_item.task = TaskBlock.new(blk)
+        end
+      end
+
+      class ExitState
+        def initialize(stitem)
+          @state_item = stitem
+        end
+        
+        def on_event(evname, sender, &blk)
+          @state_item.on_event[evname] = {
+            :evname => evname,
+            :sender => sender,
+            :task => TaskBlock.new(blk)
+          }
+        end
+
+        def on_command(cmd, &blk)
+          @state_item.on_command[cmd] = {:task=> TaskBlock.new(blk)}
+        end
+        
+        def task(&blk)
+          @state_item.task = TaskBlock.new(blk)
+        end
+      end
+      
+    end
+    
+    def self.load(path)
+      root_path = File.dirname(path)
+      manifest = new(root_path)
+
+      # instance_data has to be loaded before manifest file
+      # evaluation.
+      if File.file?(manifest.instance_data_path)
+        manifest.instance_data = YAML.load(File.read(manifest.instance_data_path)).freeze
+      end
+
+      logger.info("Loading resource.manifest: #{path}")
+      buf = File.read(path)
+      Loader.new(manifest).instance_eval(buf, path)
+      manifest
+    end
+
+    attr_reader :resource_root_path, :entry_state, :exit_state, :helpers, :load_path
+    attr_reader :config
+    attr_accessor :name, :description, :stm, :state_monitor, :instance_data
+    
+    def initialize(root_path)
+      @resource_root_path = root_path
+      @entry_state = {}
+      @exit_state  = {}
+      @helpers = {}
+      @load_path = []
+      @config = Manifest::ConfigStruct.new
+
+      append_load_path('lib')
+    end
+
+    def instance_data_path
+      File.expand_path('instance_data.yml', @resource_root_path)
+    end
+    
+    def append_load_path(path)
+      real_path = if Pathname.new(path).absolute?
+                    path
+                  else
+                    File.expand_path(path, @resource_root_path)
+                  end
+      unless $LOAD_PATH.member? real_path
+        load_path << path
+        $LOAD_PATH.unshift real_path
+      end
+    end
+    
+    class StateItem
+      attr_accessor :task
+      attr_reader :on_event, :on_command
+      
+      def initialize()
+        @task = nil
+        @on_event = {}
+        @on_command = {}
+      end
+    end
+
+    class TaskBlock
+      include Logger
+      
+      def initialize(blk)
+        @blk = blk
+      end
+
+      def call(resource_instance, args=[])
+        raise ArgumentError unless resource_instance.is_a?(ManagerModules::ResourceInstance)
+        @ri = resource_instance
+
+        instance_eval &@blk
+      end
+      
+      private
+      def state_monitor
+        manifest.state_monitor
+      end
+      
+      def next_event(ev, *args)
+        manifest.stm.process_event(ev, *args)
+      end
+
+      def manifest
+        @ri.manifest
+      end
+    end
+    
+    module RakeHelper
+      module ClassMethods
+        def default_rakefile(rakefile)
+          rakefile =
+            if Pathname.new(rakefile).absolute?
+              rakefile.dup
+            else
+              File.expand_path(rakefile, @manifest.resource_root_path)
+            end
+          raise "File does not exist: #{rakefile}" unless File.exist?(rakefile)
+          @manifest.helpers[:default_rakefile] = rakefile
+        end
+
+        def rake_bin_path(path)
+          @manifest.helpers[:rake_bin_path] = path
+        end
+      end
+
+      module TaskMethods
+        def rake(task, rakefile=nil, &blk)
+          rake_path = manifest.helpers[:rake_bin_path] || Gem.bin_path('rake', 'rake')
+          rakefile = if rakefile
+                       rakefile
+                     elsif manifest.helpers[:default_rakefile]
+                       manifest.helpers[:default_rakefile]
+                     else
+                       raise "Rakefile is not specified."
+                     end
+
+          cmd = Util.quote_args("%s -I%s -f %s --rakelib %s RESOURCE_MANIFEST=%s %s",
+                                [rake_path,
+                                 File.join(Isono.home, 'lib'),
+                                 rakefile,
+                                 #File.join(Isono.home, 'tasks/load_resource_manifest.rake'),
+                                 File.join(Isono.home, 'tasks'),
+                                 File.expand_path('resource.manifest', manifest.resource_root_path),
+                                 task
+                                ])
+          logger.debug(cmd)
+          system(cmd)
+        end
+      end
+    end
+
+    module MonitorHelper
+      module ClassMethods
+
+        def state_monitor(monitor_class, &blk)
+          @manifest.config.state_monitor = self.monitor(monitor_class, &blk)
+        end
+        
+        def monitor(monitor_class, &blk)
+          raise ArgumentError unless monitor_class.is_a?(Class) && monitor_class < Isono::Monitors::Base
+          @manifest.config.monitors ||= {}
+          
+          raise "duplicate registration: #{monitor_class}" if @manifest.config.monitors.has_key?(monitor_class)
+          
+          m = monitor_class.new()
+          m.instance_eval &blk if blk
+          @manifest.config.monitors[monitor_class] = m
+        end
+        
+      end
+
+      module TaskMethods
+        def monitor(monitor_class)
+          manifest.config.monitors[monitor_class] || raise("unknown monitor class: #{monitor_class.to_s}")
+        end
+      end
+      
+    end
+    
+  end
+end