cpee 2.0.25 → 2.1.0

data/server/{handlerwrappers/default.rb → executionhandlers/ruby/connection.rb}

@@ -12,7 +12,7 @@
 # CPEE (file COPYING in the main directory).  If not, see
 # <http://www.gnu.org/licenses/>.
 
-class DefaultHandlerWrapper < WEEL::HandlerWrapperBase
+class ConnectionWrapper < WEEL::ConnectionWrapperBase
   def self::loop_guard(arguments,id,count) # {{{
     controller = arguments[0]
     tsn = Time.now
@@ -30,11 +30,11 @@ class DefaultHandlerWrapper < WEEL::HandlerWrapperBase
     controller = arguments[0]
     controller.notify("description/error", :message => err.message)
   end# }}}
-  def self::inform_handlerwrapper_error(arguments,err) # {{{
+  def self::inform_connectionwrapper_error(arguments,err) # {{{
     controller = arguments[0]
     p err.message
     p err.backtrace
-    controller.notify("handlerwrapper/error", :message => err.message)
+    controller.notify("executionhandler/error", :message => err.message)
   end # }}}
   def self::inform_position_change(arguments,ipc={}) # {{{
     controller = arguments[0]
@@ -72,6 +72,10 @@ class DefaultHandlerWrapper < WEEL::HandlerWrapperBase
     params
   end #}}}
 
+  def additional #{{{
+    { :attributes => @controller.attributes }
+  end #}}}
+
   def proto_curl(parameters) #{{{
     params = []
     callback = Digest::MD5.hexdigest(Kernel::rand().to_s)

data/server/executionhandlers/ruby/controller.rb

@@ -0,0 +1,195 @@
+# This file is part of CPEE.
+#
+# CPEE is free software: you can redistribute it and/or modify it under the terms
+# of the GNU General Public License as published by the Free Software Foundation,
+# either version 3 of the License, or (at your option) any later version.
+#
+# CPEE is distributed in the hope that it will be useful, but WITHOUT ANY
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along with
+# CPEE (file COPYING in the main directory).  If not, see
+# <http://www.gnu.org/licenses/>.
+
+require 'weel'
+require 'json'
+require 'redis'
+require 'securerandom'
+require 'riddl/client'
+require 'cpee/value_helper'
+require 'cpee/attributes_helper'
+require 'cpee/message'
+require 'cpee/redis'
+
+require 'ostruct'
+class ParaStruct < OpenStruct
+  def to_json(*a)
+    table.to_json
+  end
+end
+def →(a); ParaStruct.new(a); end
+def ⭐(a); ParaStruct.new(a); end
+
+class Controller
+  def initialize(id,dir,opts)
+    CPEE::redis_connect(opts)
+
+    @redis = opts[:redis]
+    @votes = []
+
+    @id = id
+
+    @attributes = {}
+    @redis.keys("instance:#{id}/attributes/*").each do |key|
+      @attributes[File.basename(key)] = @redis.get(key)
+    end
+
+    @attributes_helper = AttributesHelper.new
+    @thread = nil
+    @opts = opts
+    @instance = nil
+    @loop_guard = {}
+
+    @callback_keys = {}
+    @psredis = @opts[:redis_dyn].call
+
+    Thread.new do
+      @psredis.psubscribe('callback-response:*','callback-end:*') do |on|
+        on.pmessage do |pat, what, message|
+          if pat == 'callback-response:*' && @callback_keys.has_key?(what[18..-1])
+            index = message.index(' ')
+            mess = message[index+1..-1]
+            instance = message[0...index]
+            m = JSON.parse(mess)
+            resp = []
+            m['content']['values'].each do |e|
+              if e[1][0] == 'simple'
+                resp << Riddl::Parameter::Simple.new(e[0],e[1][1])
+              elsif e[1][0] == 'complex'
+                resp << Riddl::Parameter::Complex.new(e[0],e[1][1],File.open(e[1][2]))
+              end
+            end
+            @callback_keys[what[18..-1]].send(:callback,resp,m['content']['headers'])
+          end
+          if pat == 'callback-end:*'
+            @callback_keys.delete(what[13..-1])
+          end
+        end
+      end
+    end
+  end
+
+  attr_reader :id
+  attr_reader :attributes
+  attr_reader :loop_guard
+
+  def uuid
+    @attributes['uuid']
+  end
+
+  def attributes_translated
+    @attributes_helper.translate(attributes,dataelements,endpoints)
+  end
+
+  def host
+    @opts[:host]
+  end
+  def base_url
+    @opts[:url]
+  end
+  def instance_url
+    File.join(@opts[:url].to_s,@id.to_s)
+  end
+  def instance_id
+    @id
+  end
+  def base
+    base_url
+  end
+  def instance=(inst)
+    @instance = inst
+  end
+  def endpoints
+    @instance.endpoints
+  end
+  def dataelements
+    @instance.data
+  end
+
+  def start
+    if vote("state/change", :state => 'running')
+      @thread = @instance.start
+      @thread.join
+    else
+      @thread = @instance.stop
+      @thread.join
+    end
+  end
+
+  def stop
+    ### tell the instance to stop
+    @instance.stop
+    ### end all votes or it will not work
+    Thread.new do # doing stuff in trap context is a nono. but in a thread its fine :-)
+      @votes.each do |key|
+        CPEE::Message::send(:'vote-response',key,base,@id,uuid,info,true,@redis)
+      end
+    end
+    @thread.join if !@thread.nil? && @thread.alive?
+  end
+
+  def info
+    @attributes['info']
+  end
+
+  def notify(what,content={})
+    content[:attributes] = attributes_translated
+    CPEE::Message::send(:event,what,base,@id,uuid,info,content,@redis)
+  end
+
+  def vote(what,content={})
+    topic, name = what.split('/')
+    handler = File.join(topic,'vote',name)
+    votes = []
+    @redis.smembers("instance:#{id}/handlers/#{handler}").each do |client|
+      voteid = Digest::MD5.hexdigest(Kernel::rand().to_s)
+      content[:key] = voteid
+      content[:attributes] = attributes_translated
+      content[:subscription] = client
+      votes << voteid
+      CPEE::Message::send(:vote,what,base,@id,uuid,info,content,@redis)
+    end
+
+    if votes.length > 0
+      @votes += votes
+      psredis = @opts[:redis_dyn].call
+      collect = []
+      psredis.subscribe(votes.map{|e| ['vote-response:' + e.to_s] }.flatten) do |on|
+        on.message do |what, message|
+          index = message.index(' ')
+          mess = message[index+1..-1]
+          m = JSON.parse(mess)
+          collect << ((m['content'] == true || m['content'] == 'true') || false)
+          @votes.delete m['name']
+          cancel_callback m['name']
+          if collect.length >= votes.length
+            psredis.unsubscribe
+          end
+        end
+      end
+      !collect.include?(false)
+    else
+      true
+    end
+  end
+
+  def callback(hw,key,content)
+    CPEE::Message::send(:callback,'activity/content',base,@id,uuid,info,content.merge(:key => key),@redis)
+    @callback_keys[key] = hw
+  end
+
+  def cancel_callback(key)
+    CPEE::Message::send(:'callback-end',key,base,@id,uuid,info,{},@redis)
+  end
+end

data/server/{resources/transformation_dslx.xsl → executionhandlers/ruby/dsl_to_dslx.xsl}

@@ -4,24 +4,27 @@
   <xsl:strip-space elements="*"/>
   <xsl:variable name="myspacemultiplier">2</xsl:variable>
   <xsl:template match="/">
+    <xsl:text>control flow do</xsl:text>
+    <xsl:call-template name="print-newline"/>
     <xsl:apply-templates select="//d:description"/>
+    <xsl:text>end</xsl:text>
   </xsl:template>
   <xsl:template match="//d:description">
     <xsl:apply-templates>
       <xsl:with-param name="myspace">
-        <xsl:value-of select="-1*$myspacemultiplier"/>
+        <xsl:value-of select="0*$myspacemultiplier"/>
       </xsl:with-param>
     </xsl:apply-templates>
   </xsl:template>
   <xsl:template match="*">
     <xsl:param name="myspace"/>
-    <xsl:call-template name="print-space">
-      <xsl:with-param name="i">1</xsl:with-param>
-      <xsl:with-param name="count">
-        <xsl:value-of select="$myspace+$myspacemultiplier"/>
-      </xsl:with-param>
-    </xsl:call-template>
     <xsl:if test="name()='call' or name()='manipulate'">
+      <xsl:call-template name="print-space">
+        <xsl:with-param name="i">1</xsl:with-param>
+        <xsl:with-param name="count">
+          <xsl:value-of select="$myspace+$myspacemultiplier"/>
+        </xsl:with-param>
+      </xsl:call-template>
       <xsl:value-of select="name()"/>
       <xsl:text> :</xsl:text>
       <xsl:value-of select="@id"/>
@@ -94,26 +97,54 @@
           <xsl:value-of select="$myspace"/>
         </xsl:with-param>
       </xsl:call-template>
-      <xsl:call-template name="print-newline"/>
+      <xsl:call-template name="print-newline"></xsl:call-template>
     </xsl:if>
     <xsl:if test="name()='terminate'">
+      <xsl:call-template name="print-space">
+        <xsl:with-param name="i">1</xsl:with-param>
+        <xsl:with-param name="count">
+          <xsl:value-of select="$myspace+$myspacemultiplier"/>
+        </xsl:with-param>
+      </xsl:call-template>
       <xsl:text>terminate</xsl:text>
       <xsl:call-template name="print-newline"/>
     </xsl:if>
     <xsl:if test="name()='stop'">
+      <xsl:call-template name="print-space">
+        <xsl:with-param name="i">1</xsl:with-param>
+        <xsl:with-param name="count">
+          <xsl:value-of select="$myspace+$myspacemultiplier"/>
+        </xsl:with-param>
+      </xsl:call-template>
       <xsl:text>stop :</xsl:text>
       <xsl:value-of select="@id"/>
       <xsl:call-template name="print-newline"/>
     </xsl:if>
     <xsl:if test="name()='escape'">
+      <xsl:call-template name="print-space">
+        <xsl:with-param name="i">1</xsl:with-param>
+        <xsl:with-param name="count">
+          <xsl:value-of select="$myspace+$myspacemultiplier"/>
+        </xsl:with-param>
+      </xsl:call-template>
       <xsl:text>escape</xsl:text>
       <xsl:call-template name="print-newline"/>
     </xsl:if>
     <xsl:if test="name()='parallel'">
+      <xsl:call-template name="print-space">
+        <xsl:with-param name="i">1</xsl:with-param>
+        <xsl:with-param name="count">
+          <xsl:value-of select="$myspace+$myspacemultiplier"/>
+        </xsl:with-param>
+      </xsl:call-template>
       <xsl:text>parallel</xsl:text>
       <xsl:if test="@wait">
         <xsl:text> :wait =&gt; </xsl:text>
         <xsl:value-of select="@wait"/>
+        <xsl:if test="@cancel">
+          <xsl:text>, :cancel =&gt; :</xsl:text>
+          <xsl:value-of select="@cancel"/>
+        </xsl:if>
       </xsl:if>
       <xsl:text> do</xsl:text>
       <xsl:call-template name="print-newline"/>
@@ -132,6 +163,12 @@
       <xsl:call-template name="print-newline"/>
     </xsl:if>
     <xsl:if test="name()='loop'">
+      <xsl:call-template name="print-space">
+        <xsl:with-param name="i">1</xsl:with-param>
+        <xsl:with-param name="count">
+          <xsl:value-of select="$myspace+$myspacemultiplier"/>
+        </xsl:with-param>
+      </xsl:call-template>
       <xsl:text>loop </xsl:text>
       <xsl:if test="@mode='pre_test'">
         <xsl:choose>
@@ -185,6 +222,12 @@
       <xsl:call-template name="print-newline"/>
     </xsl:if>
     <xsl:if test="name()='choose'">
+      <xsl:call-template name="print-space">
+        <xsl:with-param name="i">1</xsl:with-param>
+        <xsl:with-param name="count">
+          <xsl:value-of select="$myspace+$myspacemultiplier"/>
+        </xsl:with-param>
+      </xsl:call-template>
       <xsl:text>choose </xsl:text>
       <xsl:choose>
         <xsl:when test="@mode='exclusive'">
@@ -219,6 +262,12 @@
       <xsl:call-template name="print-newline"/>
     </xsl:if>
     <xsl:if test="name()='critical'">
+      <xsl:call-template name="print-space">
+        <xsl:with-param name="i">1</xsl:with-param>
+        <xsl:with-param name="count">
+          <xsl:value-of select="$myspace+$myspacemultiplier"/>
+        </xsl:with-param>
+      </xsl:call-template>
       <xsl:text>critical :</xsl:text>
       <xsl:value-of select="@sid"/>
       <xsl:text> do</xsl:text>

data/server/executionhandlers/ruby/execution.rb

@@ -0,0 +1,81 @@
+# This file is part of CPEE.
+#
+# CPEE is free software: you can redistribute it and/or modify it under the terms
+# of the GNU General Public License as published by the Free Software Foundation,
+# either version 3 of the License, or (at your option) any later version.
+#
+# CPEE is distributed in the hope that it will be useful, but WITHOUT ANY
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along with
+# CPEE (file COPYING in the main directory).  If not, see
+# <http://www.gnu.org/licenses/>.
+
+module CPEE
+
+  module ExecutionHandler
+
+    module Ruby
+      BACKEND_INSTANCE = 'instance.rb'
+      BACKEND_OPTS     = 'opts.yaml'
+      DSL_TO_DSLX_XSL  = File.expand_path(File.join(__dir__,'dsl_to_dslx.xsl'))
+      BACKEND_RUN      = File.expand_path(File.join(__dir__,'backend','run'))
+      BACKEND_TEMPLATE = File.expand_path(File.join(__dir__,'backend','instance.template'))
+
+      def self::dslx_to_dsl(dslx) # transpile
+        trans = XML::Smart::open_unprotected(ExecutionHandler::Ruby::DSL_TO_DSLX_XSL)
+        dslx.transform_with(trans).to_s
+      end
+
+      def self::prepare(id,opts) # write result to disk
+        Dir.mkdir(File.join(opts[:instances],id.to_s)) rescue nil
+        FileUtils.copy(ExecutionHandler::Ruby::BACKEND_RUN,File.join(opts[:instances],id.to_s))
+        dsl = CPEE::Persistence::extract_item(id,opts,'dsl')
+        hw = CPEE::Persistence::extract_item(id,opts,'executionhandler')
+        endpoints = CPEE::Persistence::extract_list(id,opts,'endpoints')
+        dataelements = CPEE::Persistence::extract_list(id,opts,'dataelements')
+        positions = CPEE::Persistence::extract_set(id,opts,'positions')
+        positions.map! do |k, v|
+          [ k, v, CPEE::Persistence::extract_item(id,opts,File.join('positions',k,'@passthrough')) ]
+        end
+        File.open(File.join(opts[:instances],id.to_s,ExecutionHandler::Ruby::BACKEND_OPTS),'w') do |f|
+          YAML::dump({
+            :host => opts[:host],
+            :url => opts[:url],
+            :redis_url => opts[:redis_url],
+            :redis_path => File.join(opts[:basepath],opts[:redis_path]),
+            :redis_db => opts[:redis_db],
+            :global_executionhandlers => opts[:global_executionhandlers],
+            :executionhandlers => opts[:executionhandlers],
+            :executionhandler => hw
+          },f)
+        end
+        template = ERB.new(File.read(ExecutionHandler::Ruby::BACKEND_TEMPLATE), trim_mode: '-')
+        res = template.result_with_hash(dsl: dsl, dataelements: dataelements, endpoints: endpoints, positions: positions)
+        File.write(File.join(opts[:instances],id.to_s,ExecutionHandler::Ruby::BACKEND_INSTANCE),res)
+      end
+
+      def self::run(id,opts)
+        exe = File.join(opts[:instances],id.to_s,File.basename(ExecutionHandler::Ruby::BACKEND_RUN))
+        pid = Kernel.spawn(exe , :pgroup => true, :in => '/dev/null', :out => exe + '.out', :err => exe + '.err')
+        Process.detach pid
+        File.write(exe + '.pid',pid)
+      end
+
+      def self::stop(id,opts) ### return: bool to tell if manually changing redis is necessary
+        exe = File.join(opts[:instances],id.to_s,File.basename(ExecutionHandler::Ruby::BACKEND_RUN))
+        pid = File.read(exe + '.pid') rescue nil
+        if pid && (Process.kill(0, pid.to_i) rescue false)
+          Process.kill('HUP', pid.to_i) rescue nil
+          false
+        else # its not running, so clean up
+          File.unlink(exe + '.pid') rescue nil
+          true
+        end
+      end
+    end
+
+  end
+
+end

data/server/resources/properties.empty

@@ -22,7 +22,7 @@
     <id>0</id>
     <message>undefined</message>
   </status>
-  <handlerwrapper>DefaultHandlerWrapper</handlerwrapper>
+  <executionhandler>ruby</executionhandler>
   <positions/>
   <dataelements/>
   <endpoints/>