pione 0.3.2 → 0.4.0

data/lib/pione/notification/recipient.rb

@@ -0,0 +1,68 @@
+module Pione
+  module Notification
+    # Recipient is a wrapper for notification recipients. This wraps a command
+    # and notifies messages to it when a notification listener receives
+    # notifications. Recipients should be registerd to listner periodically
+    # because the listener forgets recipients after some minites. Note that
+    # `Recipient` instance is registered to a listener after it is created
+    # immediately, so the listener is launched up to that time.
+    class Recipient
+      # @param front_uri [URI]
+      #   URI of command front that receives messages
+      # @param listener_uri [URI]
+      #   URI of notification listener
+      def initialize(front_uri, listener_uri)
+        @listener_uri = listener_uri
+        @front_uri = front_uri
+        @__listener_thread__ = keep_connection
+        @__connection__ = false
+      end
+
+      # Notify the message. This is a non-blocking method.
+      def notify(message)
+        name = ("receive_%s" % message.type).downcase
+        if respond_to?(name)
+          __send__(name, message)
+        end
+      end
+
+      def terminate
+        @__listerner_thread__.terminate if @__listener_thread__.alive?
+        disconnect
+      end
+
+      private
+
+      # Keep the listener connection. This is non-blocking.
+      #
+      # @return [Thread]
+      #   a keeping thread
+      def keep_connection
+        Thread.new do
+          loop do
+            begin
+              listener = DRb::DRbObject.new_with_uri(@listener_uri)
+              listener.add(@front_uri.to_s)
+
+              unless @__connection__
+                Log::SystemLog.info('Notification recipient has connected to the listener "%s".' % @listener_uri)
+              end
+              @__connection__ = true
+            rescue Object => e
+              Log::SystemLog.warn('Notification recipient has failed to connect the listener "%s": %s' % [@listener_uri, e.message])
+            ensure
+              sleep 5
+            end
+          end
+        end
+      end
+
+      def disconnect
+        Util.ignore_exception do
+          listener = DRb::DRbObject.new_with_uri(@listener_uri)
+          listener.delete(@front_uri.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/pione/notification/task-worker-broker-recipient.rb

@@ -0,0 +1,85 @@
+module Pione
+  module Notification
+    # TaskWorkerBrokerRecipient is a recipient for task worker broker agent.
+    class TaskWorkerBrokerRecipient < Recipient
+      # @param model [TaskWorkerBrokerModel]
+      #   task worker broker model
+      # @param front_uri [URI]
+      #  URI of command front
+      # @param listener_uri [URI]
+      #   URI of notification listener
+      def initialize(model, front_uri, listener_uri)
+        super(front_uri, listener_uri)
+
+        @model = model
+        @tuple_space = {}
+        @lock = Mutex.new
+
+        # update broker's tuple spaces
+        @thread = Thread.new do
+          while true
+            sleep 1
+            clean
+            update_broker
+          end
+        end
+      end
+
+      # Terminate the recipient.
+      def terminate
+        super
+        @thread.terminate
+      end
+
+      # Receive a "tupele space" message.
+      def receive_tuple_space(message)
+        uri = message["front"]
+        if @tuple_space.has_key?(uri)
+          @lock.synchronize {@tuple_space[uri][:last_time] = Time.now}
+        else
+          if tuple_space = get_tuple_space(uri)
+            @lock.synchronize do
+              @tuple_space[uri] = {:last_time => Time.now, :tuple_space => tuple_space}
+            end
+          end
+        end
+      end
+
+      #
+      # helper method
+      #
+
+      # Get a tuple space from front server at the URI.
+      def get_tuple_space(uri)
+        # build a reference to provider front
+        front = DRb::DRbObject.new_with_uri(uri)
+
+        # return the tuple space reference
+        Timeout.timeout(3) {front.tuple_space}
+      rescue Timeout::Error
+        Log::Debug.notification do
+          'tuple_space notfication ignored the provider "%s" that seems to be something bad' % front.uri
+        end
+      rescue DRb::DRbConnError, DRbPatch::ReplyReaderError => e
+        Log::Debug.notification('The tuple space at "%s" disconnected: %s' % [front.uri, e.message])
+      end
+
+      # Clean tuple space table.
+      def clean
+        @lock.synchronize do
+          now = Time.now
+          dtime = Global.tuple_space_disconnection_time
+          @tuple_space.delete_if {|_, holder| (now - holder[:last_time]) > dtime}
+        end
+      end
+
+      # Update the tuple space list of broker.
+      def update_broker
+        @lock.synchronize do
+          tuple_spaces = @tuple_space.values.map {|holder| holder[:tuple_space]}
+          @model.update_tuple_spaces(tuple_spaces)
+        end
+      end
+    end
+  end
+end

data/lib/pione/notification/transmitter.rb

@@ -0,0 +1,84 @@
+module Pione
+  module Notification
+    # `Notification::Transmitter` is a class for transmitting notification
+    # messages to target URI.
+    class Transmitter
+      # Transmit the notification message to the targets.
+      #
+      # @param message [Notification::Message]
+      #    a notfication message
+      # @param targets [Array<URI>]
+      #    target URIs
+      def self.transmit(message, targets=Global.notification_targets)
+        targets.each do |uri|
+          transmitter = self.new(uri)
+          begin
+            transmitter.transmit(message)
+          rescue => e
+            Log::SystemLog.warn('Notification transmitter has failed to transmit to "%s": %s' % [uri, e.message])
+          ensure
+            transmitter.close
+          end
+        end
+      end
+
+      # a lock for transmitting notification messages
+      LOCK = Mutex.new
+
+      # target URI that the transmitter transmits notification messages to
+      attr_reader :uri
+
+      # @param uri [URI]
+      #   target URI
+      def initialize(uri)
+        # URI scheme should be "pnb"(UDP broadcast), "pnm"(UDP multicast), or
+        # "pnu"(UDP unicast)
+        unless ["pnb", "pnm", "pnu"].include?(uri.scheme)
+          raise ArgumentError.new(uri)
+        end
+
+        if uri.host.nil? or uri.port.nil?
+          raise ArgumentError.new(uri)
+        end
+
+        @uri = uri
+        open
+      end
+
+      # Transmit the notification message to target URI.
+      #
+      # @param message [Notification::Message]
+      #   a notification message
+      # @return [void]
+      def transmit(message)
+        LOCK.synchronize do
+          @socket.send(message.dump, 0, @uri.host, @uri.port)
+        end
+      end
+
+      # Close the transmitter's socket.
+      def close
+        @socket.close
+      end
+
+      private
+
+      # Open a UPD socket and configure it by URI scheme.
+      def open
+        @socket = UDPSocket.open
+
+        case @uri.scheme
+        when "pnb"
+          # enable broadcast flag
+          @socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_BROADCAST, 1)
+        when "pnm"
+          if @uri.interface
+            # enable to bind interface
+            interface = IPAddr.new(@uri.interface).hton
+            @socket.setsockopt(Socket::IPPROTO_IP, Socket::IP_MULTICAST_IF, interface)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pione/pnml.rb

@@ -0,0 +1,35 @@
+module Pione
+  # `PNML` is a namespace for the compiler from PNML to PIONE.
+  module PNML; end
+end
+
+#
+# language model
+#
+
+require 'pione/pnml/pnml-model'  # source models
+require 'pione/pnml/pione-model' # target models
+
+#
+# net rewriting rules
+#
+
+require 'pione/pnml/net-rewriter'
+require 'pione/pnml/output-reduction'
+require 'pione/pnml/input-reduction'
+require 'pione/pnml/isolated-element-elimination'
+require 'pione/pnml/input-merge-complement'
+require 'pione/pnml/input-parallelization-complement'
+require 'pione/pnml/output-decomposition-complement'
+require 'pione/pnml/output-synchronization-complement'
+require 'pione/pnml/io-expansion'
+require 'pione/pnml/invalid-arc-elimination'
+
+#
+# utility
+#
+
+require 'pione/pnml/annotation-extractor'
+require 'pione/pnml/reader'
+require 'pione/pnml/compiler'
+

data/lib/pione/pnml/annotation-extractor.rb

@@ -0,0 +1,47 @@
+module Pione
+  module PNML
+    class AnnotationExtractor
+      def initialize(net, option)
+        @net = net
+        @flow_name = option[:flow_name] || "Main"
+        @package_name = option[:package_name]
+        @editor = option[:editor]
+        @tag = option[:tag]
+      end
+
+      # Extract an annotation from the place. If the place has the name that we
+      # can parse as an annotation declarartion sentence, return the name as
+      # is. Otherwise, return nil.
+
+      # Extract annotations from places.
+      def extract
+        package_annotations = []
+
+        @net.places.each do |place|
+          if line = extract_annotation(place)
+            package_annotations << line
+          end
+        end
+
+        package_annotations << ".@ PackageName :: \"%s\"" % @package_name if @package_name
+        package_annotations << ".@ Editor :: \"%s\"" % @editor if @editor
+        package_annotations << ".@ Tag :: \"%s\"" % @tag if @tag
+
+        return package_annotations
+      end
+
+      private
+
+      # Extract an annotation from the place. If the place has the name that we
+      # can parse as an annotation declarartion sentence, return the name as
+      # is. Otherwise, return nil.
+      def extract_annotation(place)
+        name = place.name
+        Lang::DocumentParser.new.annotation_sentence.parse(name)
+        return name
+      rescue Parslet::ParseFailed => e
+        return nil
+      end
+    end
+  end
+end

data/lib/pione/pnml/compiler.rb

@@ -0,0 +1,176 @@
+module Pione
+  module PNML
+    class Compiler
+      # Compile from the net to PIONE document.
+      #
+      # @param net [PNML::Net]
+      #   source net
+      # @return [String]
+      #   compiled PIONE document
+      def self.compile(net, option={})
+        new(net, option).compile
+      end
+
+      def initialize(net, option={})
+        @net = net
+        @option = option
+        @net_rewriter = NetRewriter.new do |rules|
+          rules << IsolatedElementElimination
+          rules << InvalidArcElimination
+          rules << OutputReduction
+          rules << InputReduction
+          rules << IOExpansion
+          rules << InputMergeComplement
+          rules << InputParallelizationComplement
+          rules << OutputDecompositionComplement
+          rules << OutputSynchronizationComplement
+        end
+      end
+
+      # Compile a PNML file into PIONE document as a string.
+      def compile
+        # annotations
+        annotations = AnnotationExtractor.new(@net, @option).extract
+
+        # apply net rewriting rules
+        @net_rewriter.rewrite(@net)
+
+        # build rules
+        rules, flow_elements = build_constituent_rule_definitions
+        definition_main = build_flow_rule_definition(@option[:flow_rule_name] || "Main", flow_elements)
+
+        # textize
+        [*annotations, "", definition_main.textize, *rules.map {|rule| rule.textize}].join("\n")
+      end
+
+      private
+
+      # Build constituent rule definitions by transitions in the net.
+      def build_constituent_rule_definitions
+        definition = @net.transitions.each_with_object({}) do |transition, table|
+          if Perspective.rule?(transition)
+            rule = RuleDefinition.new(transition.name)
+
+            # inputs
+            @net.find_all_places_by_target_id(transition.id).each do |place|
+              if Perspective.file?(place)
+                rule.inputs << Perspective.normalize_data_name(place.name)
+              end
+            end
+
+            @net.find_all_places_by_source_id(transition.id).each do |place|
+              # outputs
+              if Perspective.file?(place)
+                rule.outputs << Perspective.normalize_data_name(place.name)
+              end
+
+              # params
+              if Perspective.param?(place)
+                rule.params << Param.new(place.name, nil)
+              end
+            end
+
+            table[transition.id] = rule
+          end
+        end
+
+        # save all inner rules
+        rules = definition.values.compact
+        flow_elements = definition.values.compact
+
+        # conditional branch
+        @net.transitions.each do |transition|
+          places = @net.find_all_places_by_target_id(transition.id)
+          inputs = places.select {|place| Perspective.file?(place)}
+          inputs = inputs.map {|input| Perspective.normalize_data_name(input.name)}
+
+          case Perspective.normalize_data_name(transition.name)
+          when "if"
+            # if-branch
+            condition = @net.find_place_by_source_id(transition.id)
+
+            keywords = @net.find_all_transitions_by_source_id(condition.id)
+            key_then = keywords.find{|key| Perspective.compact(key.name) == "then"}
+            key_else = keywords.find{|key| Perspective.compact(key.name) == "else"}
+
+            branch = ConditionalBranch.new(:if, condition.name)
+
+            find_next_rules(key_then).each do |transition|
+              rule = definition[transition.id]
+              rule.inputs += inputs
+              flow_elements.delete(rule)
+              branch.table[:then] << rule
+            end
+
+            find_next_rules(key_else).each do |transition|
+              rule = definition[transition.id]
+              rule.inputs += inputs
+              flow_elements.delete(rule)
+              branch.table[:else] << rule
+            end
+
+            flow_elements << branch
+          when "case"
+            expr = @net.find_place_by_source_id(transition.id)
+
+            keywords = @net.find_all_transtions_by_source_id(expr.id)
+            keys_when = keywords.select{|key| Perspective.compact(key.name) == "then"}
+            key_else = keywords.find{|key| Perspective.compact(key.name) == "else"}
+
+            branch = ConditionalBranch.new(:case, expr.name)
+
+            keys_when.each do |key|
+              find_next_rules(key).each do |transition|
+                rule = definition[transition.id]
+                rule.inputs += inputs
+                flow_elements.delete(rule)
+                branch.table[key.name] << rule
+              end
+            end
+
+            find_next_rules(key_else).each do |transition|
+              rule = definition[transition.id]
+              rule.inputs += inputs
+              flow_elements.delete(rule)
+              branch.table[:else] << rule
+            end
+
+            flow_elements << branch
+          end
+        end
+
+        return [rules, flow_elements]
+      end
+
+      # Make a main rule.
+      def build_flow_rule_definition(name, flow_elements)
+        inputs = @net.places.select {|place| Perspective.file?(place) and Perspective.net_input?(place)}
+        inputs = inputs.map {|input| Perspective.normalize_data_name(input.name)}
+
+        outputs = @net.places.select {|place| Perspective.file?(place) and Perspective.net_output?(place)}
+        outputs = outputs.map {|output| Perspective.normalize_data_name(output.name)}
+
+        option = {
+          :inputs => inputs,
+          :outputs => outputs,
+          :params => @net.places.select {|place| Perspective.param?(place) and Perspective.net_input?},
+          :flow_elements => flow_elements,
+        }
+
+        RuleDefinition.new(name, option)
+      end
+
+      def find_next_rules(base_rule)
+        @net.find_all_places_by_source_id(base_rule.id).each_with_object([]) do |place, res|
+          @net.find_all_transitions_by_source_id(place.id).each do |transition|
+            if Perspective.rule?(transition)
+              res << transition
+            else
+              find_next_rules(transition)
+            end
+          end
+        end
+      end
+    end
+  end
+end