pione 0.1.0

data/example/Sum/Sum.pione

@@ -0,0 +1,52 @@
+Rule Main
+  input 'list.txt'
+  output 'sum.txt'
+Flow
+rule CalcEachLine
+rule Aggregation
+End
+
+Rule CalcEachLine
+  input 'list.txt'
+  output 'line_sum*.txt'.all
+Flow
+rule MakeHeadTail
+rule Sum
+End
+
+Rule MakeHeadTail
+  input 'list.txt'
+  output 'head*.txt'.all
+  output 'tail*.txt'.all
+Action
+#!/usr/bin/env ruby
+i = 1
+File.readlines('list.txt').each do |line|
+  head, tail = line.split(',')
+  File.open("head#{i}.txt", "w+"){|f| f.print head}
+  File.open("tail#{i}.txt", "w+"){|f| f.print tail}
+  i += 1
+end
+End
+
+Rule Sum
+  input 'head*.txt'
+  input 'tail{$*}.txt'
+  output 'line_sum{$*}.txt'.stdout
+Action
+expr `cat {$INPUT[1]}` + `cat {$INPUT[2]}`
+End
+
+Rule Aggregation
+  input 'line_sum*.txt'.all
+  output 'sum.txt'.stdout
+Action
+#!/usr/bin/env ruby
+sum = 0
+'{$INPUT[1]}'.split(':').sort.each do |filename|
+  n = File.read(filename)
+  sum += n.to_i
+  puts n
+end
+puts "total: #{sum}"
+End

data/example/SyntaxError/call_rule_error.pione

@@ -0,0 +1,6 @@
+Rule ABC
+  input '*.a'
+  output '*.b'
+Flow
+  rule "abc"
+End

data/example/SyntaxError/feature_line_error.pione

@@ -0,0 +1,7 @@
+Rule ABC
+  input '*.a'
+  output '*.b'
+  feature GGGGG
+Action
+cat {$I[1]} > {$O[1]}
+End

data/example/SyntaxError/flow_block_error.pione

@@ -0,0 +1,5 @@
+Rule ABC
+  input '*.a'
+  output '*.b'
+Flow
+End

data/example/SyntaxError/input_line_error.pione

@@ -0,0 +1,6 @@
+Rule ABC
+  input #####
+  output '*.b'
+Action
+cat {$I[1]} > {$O[1]}
+End

data/example/SyntaxError/invalid_rule_name.pione

@@ -0,0 +1,6 @@
+Rule "aaa"
+  input '*.a'
+  output '*.b'
+Action
+cat {$I[1]} > {$O[1]}
+End

data/example/SyntaxError/param_line_error.pione

@@ -0,0 +1,7 @@
+Rule ABC
+  input '*.a'
+  output '*.b'
+  param 1
+Action
+cat {$I[1]} > {$O[1]}
+End

data/example/SyntaxError/variable-binding-error.pione

@@ -0,0 +1,11 @@
+$X := 1
+
+Rule Main
+  input '*.a'
+  output '*b'
+Action
+cat {$I[1]} > {$O[1]}
+echo {$X} >> {$O[1]}
+End
+
+$X := 2

data/lib/pione.rb

@@ -0,0 +1,241 @@
+#
+# load libraries
+#
+require 'bundler/setup'
+require 'set'
+require 'socket'
+require 'digest'
+require 'forwardable'
+require 'socket'
+require 'drb/drb'
+require 'drb/ssl'
+require 'rinda/rinda'
+require 'rinda/tuplespace'
+require 'tempfile'
+require 'yaml'
+require 'singleton'
+require 'timeout'
+require 'thread'
+require 'monitor'
+require 'uri'
+require 'pathname'
+require 'time'
+require 'etc'
+require 'json'
+
+require 'uuidtools'
+require 'parslet'
+require 'ostruct'
+require 'net/ftp'
+require 'highline'
+require 'dropbox_sdk'
+
+#
+# load pione
+#
+
+# version
+require 'pione/version'
+
+# util
+require 'pione/util/misc'
+require 'pione/util/terminal'
+require 'pione/util/message'
+require 'pione/util/log'
+require 'pione/util/waiter-table'
+require 'pione/util/error-report'
+
+# patch
+require 'pione/patch/array-patch'
+require 'pione/patch/drb-patch'
+require 'pione/patch/rinda-patch'
+require 'pione/patch/uri-patch'
+require 'pione/patch/monitor-patch'
+
+# system
+require 'pione/system/object'
+require 'pione/system/common'
+require 'pione/system/config'
+require 'pione/system/global'
+require 'pione/system/init'
+require 'pione/system/identifier'
+require 'pione/system/document'
+require 'pione/system/file-cache'
+
+Pione.module_exec {const_set(:PioneObject, Pione::System::PioneObject)}
+Pione.module_exec {const_set(:Global, Pione::System::Global)}
+
+# uri-scheme
+require 'pione/uri-scheme/basic-scheme'
+require 'pione/uri-scheme/local-scheme'
+require 'pione/uri-scheme/dropbox-scheme'
+require 'pione/uri-scheme/broadcast-scheme'
+
+# relay
+require 'pione/relay/transmitter-socket'
+require 'pione/relay/trampoline'
+require 'pione/relay/receiver-socket'
+require 'pione/relay/relay-socket'
+require 'pione/relay/relay-client-db'
+require 'pione/relay/relay-account-db'
+
+# model
+require 'pione/model/basic-model'
+require 'pione/model/undefined-value'
+require 'pione/model/list'
+require 'pione/model/boolean'
+require 'pione/model/integer'
+require 'pione/model/float'
+require 'pione/model/string'
+require 'pione/model/feature-expr'
+require 'pione/model/variable'
+require 'pione/model/variable-table'
+require 'pione/model/data-expr'
+require 'pione/model/parameters'
+require 'pione/model/package'
+require 'pione/model/rule-expr'
+require 'pione/model/binary-operator'
+require 'pione/model/message'
+require 'pione/model/call-rule'
+require 'pione/model/assignment'
+require 'pione/model/block'
+require 'pione/model/rule'
+require 'pione/model/rule-io'
+
+# tuple
+require 'pione/tuple/basic-tuple'
+require 'pione/tuple/agent-tuple'
+require 'pione/tuple/data-tuple'
+require 'pione/tuple/finished-tuple'
+require 'pione/tuple/process-info-tuple'
+require 'pione/tuple/shift-tuple'
+require 'pione/tuple/working-tuple'
+require 'pione/tuple/attribute-tuple'
+require 'pione/tuple/bye-tuple'
+require 'pione/tuple/dry-run-tuple'
+require 'pione/tuple/foreground-tuple'
+require 'pione/tuple/request-rule-tuple'
+require 'pione/tuple/task-tuple'
+require 'pione/tuple/base-uri-tuple'
+require 'pione/tuple/command-tuple'
+require 'pione/tuple/exception-tuple'
+require 'pione/tuple/log-tuple'
+require 'pione/tuple/rule-tuple'
+require 'pione/tuple/task-worker-resource-tuple'
+
+# tuple-space
+require 'pione/tuple-space/tuple-space-server-interface'
+require 'pione/tuple-space/presence-notifier'
+require 'pione/tuple-space/tuple-space-server'
+require 'pione/tuple-space/tuple-space-receiver'
+require 'pione/tuple-space/tuple-space-provider'
+require 'pione/tuple-space/data-finder'
+require 'pione/tuple-space/update-criteria'
+
+# parser
+require 'pione/parser/syntax-error'
+require 'pione/parser/common-parser'
+require 'pione/parser/literal-parser'
+require 'pione/parser/feature-expr-parser'
+require 'pione/parser/expr-parser'
+require 'pione/parser/flow-element-parser'
+require 'pione/parser/block-parser'
+require 'pione/parser/rule-definition-parser'
+require 'pione/parser/document-parser'
+
+# transformer
+require 'pione/transformer/transformer-module'
+require 'pione/transformer/literal-transformer'
+require 'pione/transformer/feature-expr-transformer'
+require 'pione/transformer/expr-transformer'
+require 'pione/transformer/flow-element-transformer'
+require 'pione/transformer/block-transformer'
+require 'pione/transformer/rule-definition-transformer'
+require 'pione/transformer/document-transformer'
+
+# resource
+require 'pione/resource/basic-resource'
+require 'pione/resource/local'
+require 'pione/resource/ftp'
+require 'pione/resource/dropbox-resource'
+
+# rule-handler
+require 'pione/rule-handler/basic-handler'
+require 'pione/rule-handler/flow-handler'
+require 'pione/rule-handler/action-handler'
+require 'pione/rule-handler/root-handler'
+require 'pione/rule-handler/system-handler'
+
+# agent
+require 'pione/agent/basic-agent'
+require 'pione/agent/tuple-space-client'
+require 'pione/agent/command-listener'
+require 'pione/agent/task-worker'
+require 'pione/agent/input-generator'
+require 'pione/agent/rule-provider'
+require 'pione/agent/logger'
+require 'pione/agent/broker'
+require 'pione/agent/process-manager'
+require 'pione/agent/trivial-routine-worker'
+require 'pione/agent/tuple-space-server-client-life-checker'
+
+# front
+require 'pione/front/basic-front'
+require 'pione/front/task-worker-owner'
+require 'pione/front/tuple-space-provider-owner'
+require 'pione/front/client-front'
+require 'pione/front/broker-front'
+require 'pione/front/task-worker-front'
+require 'pione/front/tuple-space-provider-front'
+require 'pione/front/tuple-space-receiver-front'
+require 'pione/front/relay-front'
+
+# command-option
+require 'pione/command-option/basic-option'
+require 'pione/command-option/common-option'
+require 'pione/command-option/daemon-option'
+require 'pione/command-option/child-process-option'
+require 'pione/command-option/presence-notifier-option'
+require 'pione/command-option/tuple-space-provider-option'
+require 'pione/command-option/tuple-space-provider-owner-option'
+require 'pione/command-option/tuple-space-receiver-option'
+require 'pione/command-option/task-worker-owner-option'
+
+# command
+require 'pione/command/basic-command'
+require 'pione/command/front-owner-command'
+require 'pione/command/daemon-process'
+require 'pione/command/child-process'
+require 'pione/command/pione-client'
+require 'pione/command/pione-task-worker'
+require 'pione/command/pione-broker'
+require 'pione/command/pione-tuple-space-provider'
+require 'pione/command/pione-tuple-space-receiver'
+require 'pione/command/pione-tuple-space-viewer'
+require 'pione/command/pione-relay'
+require 'pione/command/pione-relay-client-db'
+require 'pione/command/pione-relay-account-db'
+require 'pione/command/pione-clean'
+require 'pione/command/pione-syntax-checker'
+
+
+#
+# other settings
+#
+module Pione
+  include System
+  include Relay
+  include Util
+  include Util::Message
+  include Model
+  include TupleSpace
+  include Parser
+  include Transformer
+
+  module_function :debug_mode=
+  module_function :debug_mode?
+end
+
+include Pione
+Thread.abort_on_exception = true
+Pione::System::Init.new.init

data/lib/pione/agent/basic-agent.rb

@@ -0,0 +1,333 @@
+module Pione
+  module Agent
+    # @api private
+    @table = Hash.new
+
+    class << self
+      # Returns a class corresponding to the agent type.
+      # @param [Symbol] type
+      #   agent type
+      # @return [Pione::Agent::BasicAgent]
+      #   agent class
+      def [](type)
+        @table[type]
+      end
+
+      # Sets an agent of the system.
+      # @param [Pione::Agent::BasicAgent] klass
+      #   agent class
+      # @return [void]
+      def set_agent(klass)
+        @table[klass.agent_type] = klass
+      end
+    end
+
+    # Aborting is an exception for aborting agents.
+    class Aborting < Exception; end
+
+    # TransitionError happens when
+    class TransitionError < StandardError; end
+
+    # TimeoutStateWaiting happens when not reached expected in time.
+    class TimeoutStateWaiting < StandardError
+      # expected status
+      attr_reader :expected
+
+      # current status
+      attr_reader :current
+
+      # Creates an exception.
+      #
+      # @param [Symbol] expected
+      #   expected state
+      # @param [Symbol] current
+      #   current state
+      def initialize(expected, current)
+        @expected_state = expected
+        @current_state = current
+      end
+
+      # @private
+      def message
+        msg = "expected state is '%s' but current state is '%s'"
+        msg % [@expected_state, @current_state]
+      end
+    end
+
+    # StateTransitionSingleMethod provides state transition singleton methods.
+    module StateTransitionSingletonMethod
+      # Sets pre-defined states when the module is extended by others.
+      # @api private
+      def self.extended(mod)
+        mod.define_state :initialized
+        mod.define_state :terminated
+        mod.define_state :error
+
+        mod.define_state_transition :error => :terminated
+      end
+
+      # Defines new agent state.
+      # @param [Symbol] name
+      #   state name
+      # @return [void]
+      def define_state(name)
+        @states ||= []
+        unless @states.include?(name)
+          @states << name
+
+          # define an instance method for checking current state
+          define_method("#{name}?") do
+            @__current_state__ == name
+          end
+
+          # define an instance method for transition
+          unless method_defined?("transit_to_#{name}")
+            define_method("transit_to_#{name}"){}
+          end
+        end
+      end
+
+      # Returns all states.
+      # @return [Array<Symbol>]
+      #   state name list
+      def states
+        @states
+      end
+
+      # Returns state transition table.
+      # @return [Hash{Symbol => Symbol}]
+      #   state transition table
+      def state_transition_table
+        @__state_transition_table__ ||= {nil => :initialized}
+      end
+
+      # Defines a state transition.
+      # @param [Hash{Symbol => Symbol}] data
+      #   state transition as the key value pair of from-state and to-state
+      # @return [void]
+      def define_state_transition(data)
+        table = state_transition_table
+        table.merge!(data)
+      end
+
+      # Returns exception handler table.
+      # @return [Hash{Symbol => Symbol}]
+      #   exception handler table
+      def exception_handler_table
+        @__exception_handler_table__ ||= {}
+      end
+
+      # Defines a state for handling exceptions.
+      # @param [Hash{Exception => Symbol}] data
+      #   exception handler definition
+      # @return [void]
+      # @example
+      #   define_exception_handler(StopIetration => :end_process)
+      def define_exception_handler(data)
+        table = exception_handler_table
+        table.merge!(data)
+      end
+
+      # Creates an agent and starts it.
+      # @param [Array<Object>] args
+      #   arguments of state change
+      def start(*args, &b)
+        agent = new(*args)
+        b.call(self) if block_given?
+        agent.start
+        return agent
+      end
+
+      # Returns list of exceptions
+      # @return [Array<Exception>]
+      #   exceptions
+      def known_exceptions
+        exception_handler_table.keys
+      end
+    end
+
+    # StateTransitionMethod provides state transition methods.
+    module StateTransitionMethod
+      # State transition thread.
+      attr_reader :running_thread
+
+      attr_accessor :show_agent_status
+
+      # Start agent activity.
+      # @return the agent
+      def start
+        raise TransitionError.new(current_state) if current_state == :terminated
+
+        @__owner_thread__ = Thread.current
+        @__result__ = nil
+        @running_thread = Thread.new { start_running }
+        return self
+      end
+
+      # Return state of current agent.
+      # @return [Symbol]
+      #   state of current agent
+      def current_state
+        @__current_state__ ||= nil
+      end
+
+      # Transits to the next state.
+      # @return [void]
+      def transit
+        # raise error if the current state is terminated
+        if current_state == :terminated
+          raise TransitionError.new(current_state)
+        end
+
+        state_transition_table = self.class.state_transition_table
+        begin
+          next_state = get_next_state(state_transition_table[current_state])
+          set_current_state(next_state)
+          p next_state if @show_agent_status
+          @__result__ = call_transition_method(current_state, *@__result__)
+        rescue Aborting
+          raise
+        rescue Exception => e
+          if error_state = exception_handler(e)
+            # known exception : go error state
+            set_next_state(error_state)
+            @__result__ = [e]
+          else
+            # unknown exception : raise it to owner thread
+            if @__owner_thread__.alive?
+              @__owner_thread__.raise e
+            else
+              raise e
+            end
+          end
+        end
+      end
+
+      # Sleep till the agent becomes the state.
+      def wait_till(state, sec=5)
+        begin
+          timeout(sec) do
+            sleep 0.1 while not(current_state == state)
+          end
+        rescue Timeout::Error
+          raise TimeoutStateWaiting.new(state, current_state)
+        end
+      end
+
+      # Terminate to transit.
+      def terminate
+        # abort the agent when called by other thread
+        abort unless @running_thread == Thread.current
+        # transit to terminated
+        begin
+          res = call_transition_method(:terminated)
+        rescue DRb::DRbConnError, DRb::ReplyReaderThreadError
+        end
+        # set agent state
+        set_current_state(:terminated)
+        return res
+      end
+
+      private
+
+      # Set new agent's state.
+      def set_current_state(state)
+        @__current_state__ = state
+      end
+
+      # Return a transition method of the state.
+      def transition_method(state)
+        method("transit_to_#{state}")
+      end
+
+      # Call a transition method.
+      def call_transition_method(state, *args)
+        method = transition_method(state)
+        arity = method.arity
+        _args = args[0...arity]
+        method.call(*_args)
+      end
+
+      # Returns the handling state for the exception.
+      def exception_handler(e)
+        handler = nil
+        table = self.class.exception_handler_table
+        e.class.ancestors.each do |mod|
+          if table.has_key?(mod)
+            handler = table[mod]
+            break
+          end
+        end
+        return handler
+      end
+
+      # Start to transit agent's state.
+      # For example, logger should transit initialized, logging, logging, ...
+      def start_running
+        begin
+          while not(terminated?)
+            transit
+          end
+        rescue Aborting
+          # do nothing, agent will be dead...
+        end
+      end
+
+      def set_next_state(state)
+        @__next_state__ = state
+      end
+
+      def get_next_state(state)
+        if @__next_state__
+          next_state = @__next_state__
+          @__next_state__ = nil
+          return next_state
+        else
+          next_state = state.kind_of?(Proc) ? state.call(self, @__result__) : state
+          unless next_state
+            msg = "unknown state transition: #{current_state} -> #{state} at #{self}"
+            raise ScriptError.new(msg)
+          end
+          return next_state
+        end
+      end
+
+      # Abort the agent.
+      def abort
+        if @running_thread.alive?
+          # raise Aborting exception
+          @running_thread.raise Aborting
+          # wait to stop the thread
+          @running_thread.join
+        end if @running_thread
+      end
+    end
+
+    # BasicAgent is a super class for PIONE agents.
+    class BasicAgent < PioneObject
+      include DRbUndumped
+      extend StateTransitionSingletonMethod
+      include StateTransitionMethod
+
+      def self.inherited(subclass)
+        states.each {|state| subclass.define_state state }
+        define_state_transition(state_transition_table)
+      end
+
+      # Set the agent type.
+      def self.set_agent_type(agent_type)
+        @agent_type = agent_type
+      end
+
+      # Return the agent type.
+      def self.agent_type
+        @agent_type
+      end
+
+      # Return agent type of the object.
+      def agent_type
+        self.class.agent_type
+      end
+    end
+  end
+end