pione 0.2.2 → 0.3.0

data/example/SerialProcessing/package.yml

@@ -1,5 +0,0 @@
-PackageName: "SerialProcessing"
-Documents:
-  - "SerialProcessing.pione"
-Scenarios:
-  - "scenario"

data/example/SerialProcessing/scenario/scenario.yml

@@ -1,10 +0,0 @@
-ScenarioName: SerialProcessing Test
-Outputs:
-  - "1.a"
-  - "2.a"
-  - "3.a"
-  - "4.a"
-  - "1.b"
-  - "2.b"
-  - "3.b"
-  - "4.b"

data/lib/pione/agent/command-listener.rb

@@ -1,47 +0,0 @@
-module Pione
-  module Agent
-    class CommandListener < TupleSpaceClient
-      set_agent_type :command_listener
-
-      define_state :waiting_command
-      define_state :doing_command
-
-      define_state_transition :initialized => :waiting_command
-      define_state_transition :waiting_command => :doing_command
-      define_state_transition :doing_command => :waiting_command
-
-      define_exception_handler Exception => :error
-
-      def hello
-      end
-
-      def bye
-      end
-
-      def initialize(tuple_space_server, target)
-        @target = target
-        super(tuple_space_server)
-      end
-
-      def transit_to_waiting_command
-        return read(Tuple[:command].any)
-      end
-
-      def transit_to_doing_command(cmd=nil)
-        return unless cmd # the case we got null command
-        return unless cmd.kind_of?(Tuple::Command)
-        case cmd.type
-        when "terminate"
-          @target.terminate
-          terminate
-        end
-      end
-
-      def transit_to_error(e)
-        terminate
-      end
-    end
-
-    set_agent CommandListener
-  end
-end

data/lib/pione/agent/rule-provider.rb

@@ -1,59 +0,0 @@
-module Pione
-  module Agent
-    # RuleProvider is an agent for providing rules to other agents.
-    class RuleProvider < TupleSpaceClient
-      set_agent_type :rule_provider
-
-      def initialize(tuple_space_server)
-        super(tuple_space_server)
-        @table = {}
-
-        # import system rules
-        Component::SYSTEM_RULES.each do |command_rule|
-          @table[command_rule.path] = command_rule
-        end
-      end
-
-      # Read rules from the document or the package.
-      #
-      # @param document [Component::Document,Component::Package]
-      #   document or package
-      # @return [void]
-      def read_rules(document)
-        document.rules.each {|rule| @table[rule.path] = rule}
-      end
-
-      # Return known rule pathes.
-      def known_rules
-        @table.keys
-      end
-
-      define_state :request_waiting
-      define_state :rule_loading
-
-      define_state_transition :initialized => :request_waiting
-      define_state_transition :request_waiting => :rule_loading
-      define_state_transition :rule_loading => :request_waiting
-
-      private
-
-      def transit_to_request_waiting
-        return take(Tuple[:request_rule].any)
-      end
-
-      def transit_to_rule_loading(request)
-        if known_rule?(request.rule_path)
-          write(Tuple[:rule].new(rule_path: request.rule_path, content: @table[request.rule_path]))
-        else
-          processing_error("rule '%s' is unknonw" % request.rule_path)
-        end
-      end
-
-      def known_rule?(rule_path)
-        @table.has_key?(rule_path)
-      end
-    end
-
-    set_agent RuleProvider
-  end
-end

data/lib/pione/agent/trivial-routine-worker.rb

@@ -1,29 +0,0 @@
-module Pione
-  module Agent
-    # TrivialRoutineWorker represents agent class for doing action periodly.
-    class TrivialRoutineWorker < BasicAgent
-      # state
-      define_state :working
-
-      # transition table
-      define_state_transition :initialized => :working
-      define_state_transition :working => :working
-
-      # Create a trivial routine worker.
-      #
-      # @param action [Proc]
-      #   worker's action as proc object
-      def initialize(action)
-        raise ArgumentError.new(action) unless action.kind_of?(Proc)
-        @action = action
-      end
-
-      # Call the action.
-      #
-      # @return [void]
-      def transit_to_working
-        @action.call
-      end
-    end
-  end
-end

data/lib/pione/agent/tuple-space-server-client-life-checker.rb

@@ -1,31 +0,0 @@
-module Pione
-  module Agent
-    class TupleSpaceServerClientLifeChecker < BasicAgent
-      include TupleSpaceServerInterface
-
-      define_state :checking_bye
-      define_state :cleaning_agent
-      define_state :sleeping
-
-      define_state_transition :initialized => :checking_bye
-      define_state_transition :checking_bye => :cleaning_agent
-      define_state_transition :cleaning_agent => :checking_bye
-
-      def initialize(tuple_space_server)
-        super()
-        set_tuple_space_server(tuple_space_server)
-      end
-
-      def transit_to_checking_bye
-        return take(Tuple[:bye].any)
-      end
-
-      def transit_to_cleaning_agent(bye=nil)
-        if bye
-          take(Tuple[:agent].new(uuid: bye.uuid))
-          return nil
-        end
-      end
-    end
-  end
-end

data/lib/pione/command/child-process.rb

@@ -1,56 +0,0 @@
-module Pione
-  module Command
-    # ChildProcess is a superclass for commands that are children of other
-    # processes.
-    class ChildProcess < FrontOwnerCommand
-      define_option do
-        define(:parent_front) do |item|
-          item.long = '--parent-front=URI'
-          item.desc = 'set parent front URI'
-          item.default = false
-          item.action = proc do |option, uri|
-            option[:parent_front] = DRbObject.new_with_uri(uri)
-          end
-        end
-
-        define(:no_parent) do |item|
-          item.long = '--no-parent'
-          item.desc = 'turn on no parent mode'
-          item.default = false
-          item.action = proc do |option|
-            option[:no_parent_mode] = true
-          end
-        end
-
-        # validate do |option|
-        #   if not(option[:no_parent_mode]) and option[:parent_front].nil?
-        #     abort("option error: no caller front address")
-        #   end
-        # end
-      end
-
-      prepare do
-        # "ppid == 1" means the parent is dead
-        terminater = Proc.new do
-          if Process.ppid == 1
-            abort
-            terminate
-          end
-          sleep 3
-        end
-
-        # watch that the parent process exists
-        @watchdog = Agent::TrivialRoutineWorker.new(terminater)
-      end
-
-      start do
-        @watchdog.start
-      end
-
-      terminate do
-        # kill watchdog
-        @watchdog.terminate
-      end
-    end
-  end
-end

data/lib/pione/command/daemon-process.rb

@@ -1,10 +0,0 @@
-module Pione
-  module Command
-    # DaemonProcess is a class for commands that enable to daemonize.
-    class DaemonProcess < FrontOwnerCommand
-      prepare(:post) do
-        Process.daemon(true, true) if option[:daemon]
-      end
-    end
-  end
-end

data/lib/pione/command/front-owner-command.rb

@@ -1,25 +0,0 @@
-module Pione
-  module Command
-    # FrontOwnerCommand is a parent of classes that own front server.
-    class FrontOwnerCommand < BasicCommand
-      prepare do
-        Global.front = create_front
-      end
-
-      # Create a front server. This method should be overridden in subclasses.
-      #
-      # @return [BasicFront]
-      #   front server
-      def create_front
-        raise NotImplementedError
-      end
-
-      terminate do
-        Global.monitor.synchronize do
-          # stop DRb service
-          # DRb.stop_service
-        end
-      end
-    end
-  end
-end

data/lib/pione/component.rb

@@ -1,13 +0,0 @@
-module Pione
-  module Component
-  end
-end
-
-require 'pione/component/rule'
-require 'pione/component/document'
-require 'pione/component/package'
-require 'pione/component/package-filename'
-require 'pione/component/package-reader'
-require 'pione/component/package-archiver'
-require 'pione/component/package-expander'
-

data/lib/pione/component/document.rb

@@ -1,88 +0,0 @@
-module Pione
-  module Component
-    class DuplicatedRuleError < StandardError
-      def initialize(rule_path)
-        @rule_path = rule_path
-      end
-
-      def message
-        "There are duplicated rule %s in docuemtn" % @rule_path
-      end
-    end
-
-    class Document < StructX
-      class << self
-        # Load a PIONE rule document as file.
-        #
-        # @param location [BasicLocation]
-        #   location of the PIONE document
-        # @param package_name [String]
-        #   package name
-        # @param package_path [String]
-        #   relative path of the document in package
-        # @return [Component::Document]
-        #   the document
-        def load(src, package_name="Main", package_path="Unknown.pione")
-          parse(src.read, package_name, package_path)
-        end
-
-        # Parse a PIONE rule document as string.
-        #
-        # @param location [String]
-        #   PIONE document
-        # @param package_name [String]
-        #   package name
-        # @param path [String]
-        #   relative path of the document
-        # @return [Component::Document]
-        #   the document as Ruby object
-        def parse(src, package_name="Main", package_path="Unknown.pione")
-          # parse the document and build the model
-          parser = Parser::DocumentParser.new
-          transformer = Transformer::DocumentTransformer.new(package_name)
-          toplevels = transformer.apply(parser.parse(src))
-
-          # rules and assignments
-          rules = toplevels.select{|elt| elt.kind_of?(Component::Rule)}
-          assignments = Naming[:AssignmentLine, :ParamLine, :ParamBlock].values(toplevels).flatten
-
-          # make document parameters
-          params = assignments.inject(VariableTable.empty) do |vtable, a|
-            vtable.tap{|t| t.set(a.variable, a.expr)}
-          end.to_params
-
-          # set document parameters into rules
-          rules.each {|rule| rule.condition.params.merge!(params)}
-
-          return new(package_name, rules, params, package_path)
-        end
-      end
-
-      member :package_name
-      member :rules
-      member :params
-      member :package_path
-
-      # Find the named rule.
-      #
-      # @param name [String]
-      #   rule name
-      # @return [Component::Rule]
-      def find(name)
-        rules.find {|rule| rule.name == name}
-      end
-
-      # Create a root rule which calls the rule with the parameters.
-      #
-      # @param rule [Component::Rule]
-      #   rule that is called by the root rule
-      # @param [Parameters] params
-      #   user parameters
-      # @return [Component::RootRule]
-      #   root rule
-      def create_root_rule(rule, user_params)
-        Component::RootRule.new(rule, params.merge(user_params))
-      end
-    end
-  end
-end

data/lib/pione/component/package-archiver.rb

@@ -1,92 +0,0 @@
-module Pione
-  module Component
-    # PackageArchiver makes PPG file as PIONE archive.
-    class PackageArchiver
-      attr_reader :location
-
-      # @param location [BasicLoaction]
-      #   the location of package
-      def initialize(location, option={})
-        if location.location_type == :git_repository
-          location = location + option
-        end
-        @package = PackageReader.read(location)
-        @location = @package.location
-        @tag = option[:tag]
-        @branch = option[:branch]
-      end
-
-      # Create a package archive file.
-      #
-      # @param output_location [BasicLocation]
-      #   the location of output directory
-      def archive(output_location)
-        output = output_location + filename
-        path = Temppath.create
-        Zip::Archive.open(path.to_s, Zip::CREATE) do |ar|
-          archive_package_info(ar)
-          archive_documents(ar)
-          archive_scenarios(ar)
-        end
-        Location[path].copy(output)
-        return output
-      end
-
-      private
-
-      def filename
-        PackageFilename.new(
-          package_name: @package.name,
-          edition: @package.edition,
-          tag: @tag || @branch || @package.tag,
-          hash_id: @package.hash_id
-        ).to_s
-      end
-
-      def archive_package_info(ar)
-        ar.add_buffer("package.yml", (@location + "package.yml").read)
-      end
-
-      def archive_documents(ar)
-        @package.documents.each do |doc|
-          ar.add_buffer(doc.package_path, (@location + doc.package_path).read)
-        end
-      end
-
-      def archive_scenarios(ar)
-        @package.scenarios.each do |scenario|
-          ar.add_dir(scenario.package_path)
-          archive_scenario_info(ar, scenario)
-          archive_scenario_inputs(ar, scenario)
-          archive_scenario_outputs(ar, scenario)
-        end
-      end
-
-      def archive_scenario_info(ar, scenario)
-        package_path = File.join(scenario.package_path, "scenario.yml")
-        location = @location + scenario.package_path + "scenario.yml"
-        ar.add_buffer(package_path, location.read)
-      end
-
-      def archive_scenario_inputs(ar, scenario)
-        if not(scenario.inputs.empty?)
-          ar.add_dir(File.join(scenario.package_path, "input"))
-          scenario.inputs.each do |input|
-            package_path = File.join(scenario.package_path, "input", input.basename)
-            ar.add_buffer(package_path, input.read)
-          end
-        end
-      end
-
-      def archive_scenario_outputs(ar, scenario)
-        if not(scenario.outputs.empty?)
-          ar.add_dir(File.join(scenario.package_path, "output"))
-         scenario.outputs.each do |output|
-            package_path = File.join(scenario.package_path, "output", output.basename)
-            ar.add_buffer(package_path, output.read)
-          end
-        end
-      end
-    end
-  end
-end