pione 0.4.0 → 0.4.1

data/lib/pione/rule-engine.rb

@@ -1,27 +1,56 @@
 module Pione
   # RuleEngine is a namespace for rule engine classes.
   module RuleEngine
-    def self.make(space, env, package_id, rule_name, inputs, param_set, domain_id, caller_id)
-      rule_definition = env.rule_get(Lang::RuleExpr.new(rule_name, package_id))
-      handler =
-        case rule_definition
-        when Lang::FlowRuleDefinition  ; FlowHandler
-        when Lang::ActionRuleDefinition; ActionHandler
-        when Lang::EmptyRuleDefinition ; EmptyHandler
-        when Lang::RootRuleDefinition  ; RootHandler
+    require 'pione/rule-engine/engine-exception'
+    require 'pione/rule-engine/data-finder'
+    require 'pione/rule-engine/basic-handler'
+    require 'pione/rule-engine/update-criteria'
+    require 'pione/rule-engine/flow-handler'
+    require 'pione/rule-engine/action-handler'
+    require 'pione/rule-engine/root-handler'
+    require 'pione/rule-engine/system-handler'
+    require 'pione/rule-engine/empty-handler'
+
+    # Relation from rule definition to the handler.
+    HANDLER = {
+      Lang::FlowRuleDefinition   => FlowHandler,
+      Lang::ActionRuleDefinition => ActionHandler,
+      Lang::EmptyRuleDefinition  => EmptyHandler,
+      Lang::RootRuleDefinition   => RootHandler
+    }
+
+    # Make a rule handler with target rule's informations.
+    #
+    # @param [Hash.new] param
+    # @option param [String] :package_id
+    #   package ID
+    # @option param [String] :rule_name
+    #   rule name
+    # @option param [Array] :inputs
+    #   input data
+    # @option param [Object] :param_set
+    #   parameter set
+    # @option param [String] :domain_id
+    #   domain ID
+    # @option param [String] :caller_id
+    #   caller ID
+    # @option param [URI] :request_from
+    #   URI that the client requested the job from
+    # @option param [String] :session_id
+    #   session ID
+    def self.make(param)
+      # check requisite parameters
+      requisites = [:tuple_space, :env, :package_id, :rule_name, :inputs, :param_set, :domain_id, :caller_id]
+      requisites.each do |requisite|
+        unless param.has_key?(requisite)
+          raise ArgumentError.new("parameter '%s' is requisite for rule engine." % requisite)
         end
-      handler.new(space, env, package_id, rule_name, rule_definition, inputs, param_set, domain_id, caller_id)
+      end
+
+      # make a rule handler
+      rule_definition = param[:env].rule_get(Lang::RuleExpr.new(param[:rule_name], param[:package_id]))
+      HANDLER[rule_definition.class].new(param.merge(rule_definition: rule_definition))
     end
   end
 end
 
-require 'pione/rule-engine/engine-exception'
-require 'pione/rule-engine/data-finder'
-require 'pione/rule-engine/basic-handler'
-require 'pione/rule-engine/update-criteria'
-require 'pione/rule-engine/flow-handler'
-require 'pione/rule-engine/action-handler'
-require 'pione/rule-engine/root-handler'
-require 'pione/rule-engine/system-handler'
-require 'pione/rule-engine/empty-handler'
-

data/lib/pione/rule-engine/action-handler.rb

@@ -8,8 +8,8 @@ module Pione
 
       attr_reader :working_directory
 
-      def initialize(*args)
-        super(*args)
+      def initialize(param)
+        super(param)
         @working_directory = Location[Global.working_directory_generator.mkdir]
         @env.variable_set(
           Lang::Variable.new("__WORKING_DIRECTORY__"),
@@ -22,7 +22,7 @@ module Pione
         # prepare input files
         setup_working_directory
         # prepare shell script
-        write_shell_script {|path| call_shell_script(path) }
+        write_shell_script {|path| call_shell_script(path)}
         # collect outputs
         outputs = collect_outputs
         # write output data
@@ -68,16 +68,30 @@ module Pione
           bin.entries.each do |entry|
             dest = @working_directory + "bin" + entry.basename
             unless dest.exist?
+              # copy and set executable flag
               entry.copy(dest)
               dest.path.chmod(0700)
             end
           end
         end
+
+        # FIXME: should not copy files in the package each time
+        file_dir = @base_location + "package" + "etc"
+        if file_dir.exist?
+          file_dir.entries.each do |entry|
+            dest = @working_directory + "etc" + entry.basename
+            unless dest.exist?
+              # copy and unset executable flag
+              entry.copy(dest)
+              dest.path.chmod(0600)
+            end
+          end
+        end
       end
 
       # Write the action into a shell script.
       def write_shell_script(&b)
-        file = @working_directory + "__pione-action__.sh"
+        file = @working_directory + "__pione__.sh"
         content = @rule_definition.action_context.eval(@env).content
         sh = Util::EmbededExprExpander.expand(@env, content)
 
@@ -113,7 +127,17 @@ module Pione
         err = ".stderr"
 
         # execute command
-        `cd #{@working_directory.path}; PATH=#{(@working_directory + "bin").path}:$PATH ; ./#{scriptname} > #{out} 2> #{err}`
+        # `cd #{}; PATH=#{(@working_directory + "bin").path}:$PATH; ./#{scriptname} > #{out} 2> #{err}`
+        callee_env = {
+          "PATH" => (@working_directory + "bin").path.to_s + ";" + ENV["PATH"],
+          "PIONE_SESSION_ID" => @session_id,
+          "PIONE_REQUEST_FROM" => @request_from.to_s,
+          "PIONE_CLIENT_UI" => @client_ui.to_s
+        }
+        command = "./#{scriptname} > #{out} 2> #{err}"
+        options = {:chdir => @working_directory.path.to_s}
+
+        system(callee_env, command, options)
 
         # the case the script has errored
         unless $?.success?

data/lib/pione/rule-engine/basic-handler.rb

@@ -22,26 +22,32 @@ module Pione
       attr_reader :caller_id        # from domain
 
       # Create a new handler for rule.
-      def initialize(space, env, package_id, rule_name, rule_definition, inputs, param_set, domain_id, caller_id)
+      #
+      # @param [Hash] param
+      #   see `RuleEngine.make`
+      def initialize(param)
         ### set tuple space server
-        set_tuple_space(space)
+        set_tuple_space(param[:tuple_space])
 
         ### set informations
-        @plain_env = env
-        @env = setup_env(env, param_set)
-        @package_id = package_id
-        @rule_name = rule_name
-        @rule_definition = rule_definition
-        @rule_condition = rule_definition.rule_condition_context.eval(@env)
-        @inputs = inputs
+        @plain_env = param[:env]
+        @env = setup_env(param[:env], param[:param_set])
+        @package_id = param[:package_id]
+        @rule_name = param[:rule_name]
+        @rule_definition = param[:rule_definition]
+        @rule_condition = @rule_definition.rule_condition_context.eval(@env)
+        @inputs = param[:inputs]
         @outputs = []
-        @param_set = param_set
-        @digest = Util::TaskDigest.generate(package_id, rule_name, inputs, param_set)
+        @param_set = param[:param_set]
+        @digest = Util::TaskDigest.generate(@package_id, @rule_name, @inputs, @param_set)
         @base_location = read!(TupleSpace::BaseLocationTuple.any).location
         @dry_run = begin read!(TupleSpace::DryRunTuple.any).availability rescue false end
-        @domain_id = domain_id
+        @domain_id = param[:domain_id]
         @domain_location = make_location("", @domain_id)
-        @caller_id = caller_id
+        @caller_id = param[:caller_id]
+        @request_from = param[:request_from]
+        @session_id = param[:session_id]
+        @client_ui = param[:client_ui]
       end
 
       # Handle the rule and return the outputs.
@@ -54,12 +60,14 @@ module Pione
         user_message(@digest, 0, "==>")
         debug_message("caller: %s" % @caller_id)
 
-        # save domain log
-        Log::DomainLog.new(self).save
+        unless @domain_id == "root"
+          # save domain log
+          Log::DomainLog.new(self).save
 
-        # save a domain dump file
-        domain_dump_location = @working_directory ? @working_directory :@domain_location
-        System::DomainDump.new(env.dumpable).write(domain_dump_location)
+          # save a domain dump file
+          domain_dump_location = @working_directory ? @working_directory :@domain_location
+          System::DomainDump.new(env.dumpable).write(domain_dump_location)
+        end
 
         # execute the rule
         outputs = execute
@@ -96,7 +104,7 @@ module Pione
       #   the location
       def make_location(name, domain_id)
         if domain_id == "root"
-          return @base_location + "./%s" % name
+          return @base_location + "./output/%s" % name
         else
           # make relative path
           pakcage_id, rule_name, task_id = domain_id.split(":")

data/lib/pione/test-helper/command-helper.rb

@@ -11,7 +11,7 @@ module Pione
       def self.test(context, &b)
         # with client mode
         new(context: context).tap do |runner|
-          runner.default_arguments = ["-o", runner.base.path.to_s]
+          runner.default_arguments = ["--base", runner.base.path.to_s]
           b.call(runner)
         end
       end

data/lib/pione/tuple-space/tuple-definition.yml

@@ -10,9 +10,8 @@ AgentTuple:
 
 AttributeTuple:
   - attribute
-  - key:  # attribute name
-      "String"
-  - value # attribute value
+  - key: String # attribute name
+  - value       # attribute value
 
 BaseLocationTuple:
   - base_location

data/lib/pione/tuple-space/tuple-space-server.rb

@@ -191,6 +191,14 @@ module Pione
         end
       end
 
+      def attribute(name)
+        if tuple = read!(TupleSpace::AttributeTuple.new(key: name))
+          return tuple.value
+        else
+          return nil
+        end
+      end
+
       def inspect
         "#<Pione::TupleSpace::TupleSpaceServer:%s>" % object_id
       end

data/lib/pione/util/cgi.rb

@@ -0,0 +1,326 @@
+module Pione
+  module Util
+    module CGIUtils
+      def self.decode(string)
+        URI.decode_www_form_component(string)
+      end
+    end
+
+    # CGIInfo is a store of CGI meta-variables based on RFC3875.
+    class CGIInfo
+      # CGI meta-variable "AUTH_TYPE"
+      attr_accessor :auth_type
+
+      # CGI meta-variable "CONTENT_LENGTH"
+      attr_accessor :content_length
+
+      # CGI meta-variable "CONTENT_TYPE"
+      attr_accessor :content_type
+
+      # CGI meta-variable "GATEWAY_INTERFACE"
+      attr_accessor :gateway_interface
+
+      # CGI meta-variable "PATH_INFO"
+      attr_accessor :path_info
+
+      # CGI meta-variable "PATH_TRANSLATED"
+      attr_accessor :path_translated
+
+      # CGI meta-variable "QUERY_STRING"
+      attr_accessor :query_string
+
+      # CGI meta-variable "REMOTE_ADDR"
+      attr_accessor :remote_addr
+
+      # CGI meta-variable "REMOTE_HOST"
+      attr_accessor :remote_host
+
+      # CGI meta-variable "REMOTE_IDENT"
+      attr_accessor :remote_ident
+
+      # CGI meta-variable "REMOTE_USER"
+      attr_accessor :remote_user
+
+      # CGI meta-variable "REQUEST_METHOD"
+      attr_accessor :request_method
+
+      # CGI meta-variable "SCRIPT_NAME"
+      attr_accessor :script_name
+
+      # CGI meta-variable "SERVER_NAME"
+      attr_accessor :server_name
+
+      # CGI meta-variable "SERVER_PORT"
+      attr_accessor :server_port
+
+      # CGI meta-variable "SERVER_PROTOCOL"
+      attr_accessor :server_protocol
+
+      # CGI meta-variable "SERVER_SOFTWARE"
+      attr_accessor :server_software
+
+      # HTTP specific variable table
+      attr_accessor :http_header
+
+      # request body
+      attr_accessor :body
+
+      def initialize
+        @auth_type = nil
+        @content_length = nil
+        @content_type = nil
+        @gateway_interface = "CGI/1.1"
+        @path_info = nil
+        @path_translated = nil
+        @query_string = nil
+        @remote_addr = nil
+        @remote_host = nil
+        @remote_ident = nil
+        @remote_user = nil
+        @request_method = nil
+        @script_name = nil
+        @server_name = nil
+        @server_port = nil
+        @server_protocol = "HTTP/1.1"
+        @server_software = "PIONE/%s" % Pione::VERSION
+        @body = nil
+        @http_header = Hash.new
+      end
+
+      # Create environment variables.
+      # @return [Hash]
+      #   environment variables
+      def create_env
+        env = Hash.new
+
+        # store CGI meta-variables
+        env["AUTH_TYPE"] = @auth_type if @auth_type
+        env["CONTENT_LENGTH"] = @content_length if @content_length
+        env["CONTENT_TYPE"] = @content_type if @content_type
+        env["GATEWAY_INTERFACE"] = @gateway_interface
+        env["PATH_INFO"] = @path_info
+        env["PATH_TRANSLATED"] = @path_translated
+        env["QUERY_STRING"] = @query_string
+        env["REMOTE_ADDR"] = @remote_addr
+        env["REMOTE_HOST"] = @remote_host
+        env["REMOTE_IDENT"] = @remote_ident if @remote_ident
+        env["REMOTE_USER"] = @remote_user if @remote_user
+        env["REQUEST_METHOD"] = @request_method.to_s
+        env["SCRIPT_NAME"] = @script_name
+        env["SERVER_NAME"] = @server_name
+        env["SERVER_PORT"] = @server_port
+        env["SERVER_PROTOCOL"] = @server_protocol
+        env["SERVER_SOFTWARE"] = @server_software
+
+        # store HTTP specific variables
+        @http_header.each do |key, val|
+          env["HTTP_%s" % key] = val
+        end
+
+        return env
+      end
+
+      def create_arguments
+        unless @query_string.include?("=")
+          return @query_string.split("+").map do |arg|
+            begin
+              CGIUtils.decode(arg)
+            rescue
+              raise CGIError.failed_to_decode(@query_string)
+            end
+          end
+        end
+
+        return []
+      end
+    end
+
+    # CGIExecutor is a execution helper for CGI programs.
+    class CGIExecutor
+      # @param [Pathname] cgi_path
+      #   path of the CGI program
+      # @param [CGIInfo] cgi_info
+      #   various informations for CGI program
+      def initialize(cgi_path, cgi_info, chdir, timeout)
+        @cgi_path = cgi_path
+        @cgi_info = cgi_info
+        @chdir = chdir
+        @timeout = timeout
+        @umask = 077
+        @cgi_stdin = Temppath.create
+        @cgi_stdout = Temppath.create
+        @pid = nil
+      end
+
+      # Execute the CGI program.
+      def exec
+        unless @cgi_path.exist?
+          raise CGIError.not_exist(@cgi_path)
+        end
+
+        env = @cgi_info.create_env
+        options = create_options
+        args = @cgi_info.create_arguments
+
+        Timeout.timeout(@timeout) do
+          @pid = Kernel.spawn(env, @cgi_path.to_s, *args, options)
+          Process.waitpid(@pid)
+          if @cgi_stdout.exist?
+            return analyze_response(Location[@cgi_stdout].read)
+          else
+            raise CGIError.response_not_found
+          end
+        end
+      rescue Timeout::Error
+        if @pid
+          begin
+            Process.kill(15, @pid)
+          rescue
+          ensure
+            CGIError.timeouted
+          end
+        end
+      rescue Errno::EACCES => e
+        CGIError.cannot_execute_cgi(@cgi_path)
+      end
+
+      private
+
+      def nph?
+        Pathname.new(@cgi_path).basename.to_s.start_with?("nph-")
+      end
+
+      def create_options
+        options = Hash.new
+        options[:chdir] = @chdir.path.to_s
+        options[:umask] = @umask
+        if @cgi_info.body
+          Location[@cgi_stdin].write(@cgi_info.body)
+          options[:in] = @cgi_stdin.to_s
+        end
+        options[:out] = @cgi_stdout.to_s
+        return options
+      end
+
+      def analyze_response(stdout)
+        cgi_response = CGIResponse.new
+
+        if nph?
+          cgi_response.nph = true
+          cgi_response.body = stdout
+        else
+          cgi_response.nph = false
+
+          # parse headers
+          headers, body = stdout.split(/\r\n\r\n|\r\r|\n\n/, 2)
+          header = headers.split(/\r\n|\r|\n/).each_with_object(Hash.new) do |line, table|
+            name, value = line.split(/:[\s\t]*/, 2)
+            if name.nil? or name.size == 0 or /\s/.match(name) or value.nil?
+              raise CGIError.invalid_response_header(line)
+            else
+              table[name.downcase] = value
+            end
+          end
+
+          # content-type
+          if header.has_key?("content-type")
+            cgi_response.content_type = header["content-type"]
+          else
+            raise CGIError.content_type_not_found
+          end
+
+          # location
+          if header["location"]
+            begin
+              uri = URI.parse(header["location"])
+              cgi_response.location = header["location"]
+            rescue
+              raise CGIError.invalid_location(header["location"])
+            end
+          end
+
+          # status
+          if header["status"]
+            code, reason_phrase = status.split(/\s+/, 2)
+            if /\d\d\d/.match(code)
+              cgi_response.status_code = code
+              cgi_response.reason_phrase = reason_phrase
+            else
+              raise CGIError.invalid_status(code)
+            end
+          end
+
+          # body
+          cgi_response.body = body
+        end
+
+        return cgi_response
+      end
+    end
+
+    class CGIResponse
+      attr_accessor :nph
+      attr_accessor :content_type
+      attr_accessor :location
+      attr_accessor :status_code
+      attr_accessor :reason_phrase
+      attr_accessor :body
+
+      def initialize
+        @nph = false
+        @content_type = nil
+        @location = nil
+        @status_code = 200
+        @reason_phrase = nil
+        @body = nil
+      end
+
+      def nph?
+        @nph
+      end
+
+      def valid?
+        not(@content_type.nil?)
+      end
+    end
+
+    # CGIError is an error class for occuring errors of CGI execution.
+    class CGIError < StandardError
+      def self.not_exist(path)
+        new("CGI program not exist at %s." % path)
+      end
+
+      def self.failed_to_decode(string)
+        new("Failed to decode the string as URL: %s" % string)
+      end
+
+      def self.invalid_response_header(line)
+        new("Inlivad CGI response header has found: \"%s\"" % line)
+      end
+
+      def self.content_type_not_found
+        new("Requisite CGI response header \"Content-Type\" has not found.")
+      end
+
+      def self.invalid_location(value)
+        new("Invalid location has found: \"%s\"" % value)
+      end
+
+      def self.invalid_status(code)
+        new("Invalid status code has found: \"%s\"" % code)
+      end
+
+      def self.response_not_found
+        "No CGI response."
+      end
+
+      def self.cannot_execute_cgi(cgi_path)
+        "Cannot execute the CGI: %s" % cgi_path.to_s
+      end
+
+      def self.timeouted
+        "CGI exectuion has been timeouted."
+      end
+    end
+  end
+end