cpee 1.5.20 → 2.0

data/log/xes_xml.rb

@@ -1,121 +0,0 @@
-#!/usr/bin/ruby
-require 'pp'
-require 'json'
-require 'rubygems'
-require 'riddl/server'
-require 'riddl/client'
-require 'riddl/utils/notifications_producer'
-require 'riddl/utils/properties'
-require 'riddl/utils/fileserve'
-require 'riddl/utils/downloadify'
-require 'riddl/utils/turtle'
-require 'time'
-
-class Logging < Riddl::Implementation #{{{
-  def doc(event_name,log_dir,instancenr,notification)
-    uuid = notification['instance_uuid']
-    activity = notification["activity"]
-    parameters = notification['parameters']
-    receiving = notification['received']
-    Dir.mkdir(log_dir+'/'+uuid) unless Dir.exist?(log_dir+'/'+uuid)
-    time_added=false
-    cpee_time =  notification['time']
-    XML::Smart.modify(log_dir+'/'+uuid+'/log.xes',LOGTEMPLATE) do |xml|
-      begin
-        trace = xml.find("/xmlns:log/xmlns:trace").first
-        trace.add 'string', :key => "concept:name", :value => "Instance #{instancenr}" if trace.find('xmlns:string').empty?
-        event = trace.add "event"
-        if parameters && parameters.has_key?('label')
-          event.add 'string', :key => "concept:name", :value => parameters["label"]
-        else
-          event.add 'string', :key => "concept:name", :value => trace.find("string(xmlns:event[xmlns:string[@key='id:id' and @value='#{activity}']]/xmlns:string[@key='concept:name']/@value)")
-        end
-        event.add 'string', :key => "concept:endpoint", :value => notification["endpoint"] if notification["endpoint"]
-        event.add 'string', :key => "id:id", :value => activity
-        unless event_name=='receiving'
-          event.add 'string', :key => "lifecycle:transition", :value => event_name=='done'?"complete":"start"
-        else
-          event.add 'string', :key => "lifecycle:transition", :value => "unknown"
-        end
-        data_send = ((parameters["arguments"].nil? ? [] : parameters["arguments"]) rescue [])
-        if data_send && data_send.any?
-          list = event.add 'list', :key => "data_send"
-          data_send.each do |e|
-            list.add 'string', :key => e['name'] , :value => e['value']
-          end
-        end
-        if receiving && receiving.any?
-          if receiving.is_a? Array
-            receiving.each do |e|
-              e.each do |k,v|
-                case v['mimetype']
-                  when /\/xml$/
-          					list = event.add 'list', :key => "data_received"
-                    node = list.add 'string', :key => k
-                    node.add XML::Smart.string(v['content']).root
-                  when /\/json$/
-                    rec_unjson(JSON.parse(v['content']),event,"data_received")
-                  when /\/html$/
-          					list = event.add 'list', :key => "data_received"
-                    list.add 'string', :key => k, :value => v['content']
-                  else
-          					list = event.add 'list', :key => "data_received"
-                    list.add 'string', :key => k, :value => v
-                end
-              end
-            end
-          else
-            pp receiving
-          end
-        end
-        event.add 'date', :key => "time:timestamp", :value => cpee_time unless time_added
-        pid, size = `ps ax -o pid,rss | grep -E "^[[:space:]]*#{$$}"`.strip.split.map(&:to_i)
-        File.open(log_dir+'/'+uuid+'/memory.file',"a+"){ |f| f<< size << "\n" }
-      rescue => e
-        puts e.message
-        puts e.backtrace
-      end
-    end
-  end
-
-	def rec_unjson(value,list,key)
-		case value
-			when Array then
-				li = list.add 'list', :key => key
-				value.each_with_index do |v,k|
-					rec_unjson(v,li,k)
-				end
-			when Hash then
-				li = list.add 'list', :key => key
-				value.each do |k,v|
-					rec_unjson(v,li,k)
-				end
-			else
-				list.add 'string', :key => key, :value => value
-		end
-	end
-
-  def response
-    topic = @p[1].value
-    event_name = @p[2].value
-    log_dir = @a[0]
-    instancenr = @h['CPEE_INSTANCE_URL'].split('/').last
-    notification = JSON.parse(@p[3].value)
-    doc(event_name,log_dir,instancenr,notification)
-  end
-end  #}}}
-
-
-Riddl::Server.new(File.join(__dir__,'/log.xml'), :host => 'localhost', :port => 9299) do #{{{
-  accessible_description true
-  cross_site_xhr true
-  @riddllog_dir = File.join(__dir__,logs)"
-
-  interface 'events' do
-	  run Logging if post 'event'
-  end
-  interface 'logoverlay' do |r|
-    run Riddl::Utils::FileServe, log_dir + r[:h]["RIDDL_DECLARATION_PATH"]+ ".xes","text/xml" if get
-  end
-
-end.loop! #}}}

data/log/xes_yaml.rb

@@ -1,96 +0,0 @@
-#!/usr/bin/ruby
-require 'pp'
-require 'json'
-require 'yaml'
-require 'rubygems'
-require 'riddl/server'
-require 'riddl/utils/fileserve'
-require 'time'
-
-class Logging < Riddl::Implementation #{{{
-  def doc(topic,event_name,log_dir,template,instancenr,notification)
-    instance = notification['instance_uuid']
-    return unless instance
-
-    activity = notification['activity']
-    parameters = notification['parameters']
-    receiving = notification['received']
-
-    log = YAML::load(File.read(template))
-    log["log"]["trace"]["concept:name"] ||= instancenr
-    log["log"]["trace"]["cpee:name"] ||= notification['instance_name'] if notification['instance_name']
-    log["log"]["trace"]["cpee:instance"] ||= instance
-    File.open(File.join(log_dir,instance+'.xes.yaml'),'w'){|f| f.puts log.to_yaml} unless File.exists? File.join(log_dir,instance+'.xes.yaml')
-    event = {}
-    event["concept:instance"] = instancenr
-    event["concept:name"] = notification["label"] if notification["label"]
-    if notification["endpoint"]
-      event["concept:endpoint"] = notification["endpoint"]
-    end
-    event["id:id"] = (activity.nil? || activity == "") ? 'external' : activity
-    event["cpee:activity"] = event["id:id"]
-    event["cpee:activity_uuid"] = notification['activity_uuid'] if notification['activity_uuid']
-    event["cpee:instance"] = instance
-    case event_name
-      when 'receiving', 'change', 'instantiation'
-        event["lifecycle:transition"] = "unknown"
-      when 'done'
-        event["lifecycle:transition"] = "complete"
-      else
-        event["lifecycle:transition"] = "start"
-    end
-    event["cpee:lifecycle:transition"] = "#{topic}/#{event_name}"
-    data_send = ((parameters["arguments"].nil? ? [] : parameters["arguments"]) rescue [])
-    event["data"] = {"data_send" => data_send} unless data_send.empty?
-    if notification['changed']&.any?
-      if event.has_key? "data"
-        event["data"]["data_changed"] ||= notification['changed']
-      else
-        event["data"] = {"data_changer" => notification['changed']}
-      end
-    end
-    if notification['values']&.any?
-      if event.has_key? "data"
-        event["data"]["data_values"] ||= notification['values']
-      else
-        event["data"] = {"data_values" => notification['values']}
-      end
-    end
-    unless receiving&.empty?
-      if event.has_key? "data"
-        event["data"]["data_received"] ||= receiving
-      else
-        event["data"] = {"data_receiver" => receiving}
-      end
-    end
-    event["time:timestamp"]= event['cpee:timestamp'] || Time.now.strftime("%Y-%m-%dT%H:%M:%S.%L%:z")
-    File.open(File.join(log_dir,instance+'.xes.yaml'),'a') do |f|
-      f << {'event' => event}.to_yaml
-    end
-    nil
-  end
-
-  def response
-    topic         = @p[1].value
-    event_name    = @p[2].value
-    log_dir       = @a[0]
-    template      = @a[1]
-    instancenr    = @h['CPEE_INSTANCE_URL'].split('/').last
-    notification  = JSON.parse(@p[3].value)
-    doc topic, event_name, log_dir, template, instancenr, notification
-  end
-end #}}}
-
-Riddl::Server.new(File.join(__dir__,'/log.xml'), :host => 'localhost', :port => 9299) do
-  accessible_description true
-  cross_site_xhr true
-  @riddl_opts[:log_dir] ||= File.join(__dir__,'logs')
-  @riddl_opts[:template] ||= File.join(__dir__,'template.xes_yaml')
-
-  interface 'events' do
-	  run Logging, @riddl_opts[:log_dir], @riddl_opts[:template] if post 'event'
-  end
-  interface 'logoverlay' do |r|
-    run Riddl::Utils::FileServe, log_dir + r[:h]["RIDDL_DECLARATION_PATH"]+ ".xes","text/plain" if get
-  end
-end.loop!

data/server/handlerwrappers/soap.rb

@@ -1,146 +0,0 @@
-# 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 'savon'
-
-class SOAPHandlerWrapper < WEEL::HandlerWrapperBase
-  def initialize(arguments,endpoint=nil,position=nil,continue=nil) # {{{
-    @controller = arguments[0]
-    @url = arguments[1]
-    @handler_continue = continue
-    @handler_endpoint = endpoint
-    @handler_position = position
-    @handler_passthrough = nil
-    @handler_returnValue = nil
-  end # }}}
-
-  def activity_handle(passthrough, parameters) # {{{
-    @controller.notify("activity/calling", :instance => "#{@url}/#{@controller.id}", :activity => @handler_position, :passthrough => passthrough, :endpoint => @handler_endpoint, :parameters => parameters)
-
-    if passthrough.nil?
-      callback = Digest::MD5.hexdigest(Kernel::rand().to_s)
-      begin
-        client = Savon.client do
-          wsdl @handler_endpoint
-          log false
-          log_level :info
-          soap_header(
-            "CPEE-BASE" => @url,
-            "CPEE-INSTANCE" => "#{@url}/#{@controller.id}",
-            "CPEE-CALLBACK" => callback
-          )
-        end
-        params = {}
-        (parameters[:parameters] || {}).each do |h|
-          if h.class == Hash
-            h.each do |k,v|
-              params[k] = JSON::generate(v)
-            end
-          end
-        end
-        response = client.call parameters[:method].to_sym, params
-        result = response.body.first[1].first[1]
-      rescue Savon::Error => error
-        raise "Could not soap #{@handler_endpoint}->#{parameters[:method].to_sym}'s back: #{error.to_s}"
-      end
-
-      if response.http.headers["CPEE_CALLBACK"] && response.http.headers["CPEE_CALLBACK"] == 'true'
-        @controller.callbacks[callback] = CPEE::Callback.new("callback activity: #{@handler_position}",self,:callback,nil,nil,:http)
-        @handler_passthrough = callback
-        return
-      end
-    else
-      @controller.callbacks[passthrough] = CPEE::Callback.new("callback activity: #{@handler_position}",self,:callback,nil,nil,:http)
-      @handler_passthrough = passthrough
-      return
-    end
-
-    @handler_returnValue = result
-    @handler_continue.continue
-  end # }}}
-
-  def activity_result_value # {{{
-    @handler_returnValue
-  end # }}}
-
-  def activity_stop # {{{
-    unless @handler_passthrough.nil?
-      @controller.callbacks.delete(@handler_passthrough)
-    end
-  end # }}}
-  def activity_passthrough_value # {{{
-    @handler_passthrough
-  end # }}}
-
-  def activity_no_longer_necessary # {{{
-    true
-  end # }}}
-
-  def inform_activity_done # {{{
-    @controller.notify("activity/done", :endpoint => @handler_endpoint, :instance => "#{@url}/#{@controller.id}", :activity => @handler_position)
-  end # }}}
-  def inform_activity_manipulate # {{{
-    @controller.notify("activity/manipulating", :endpoint => @handler_endpoint, :instance => "#{@url}/#{@controller.id}", :activity => @handler_position)
-  end # }}}
-  def inform_activity_failed(err) # {{{
-    puts err.message
-    puts err.backtrace
-    @controller.notify("activity/failed", :endpoint => @handler_endpoint, :instance => "#{@url}/#{@controller.id}", :activity => @handler_position, :message => err.message, :line => err.backtrace[0].match(/(.*?):(\d+):/)[2], :where => err.backtrace[0].match(/(.*?):(\d+):/)[1])
-  end # }}}
-
-  def inform_syntax_error(err,code)# {{{
-    puts err.message
-    puts err.backtrace
-    @controller.notify("description/error", :instance => "#{@url}/#{@controller.id}", :message => err.message)
-  end# }}}
-  def inform_manipulate_change(status,dataelements,endpoints) # {{{
-    unless status.nil?
-      @controller.serialize_status!
-      @controller.notify("status/change", :endpoint => @handler_endpoint, :instance => "#{@url}/#{@controller.id}", :activity => @handler_position, :id => status.id, :message => status.message)
-    end
-    unless dataelements.nil?
-      @controller.serialize_dataelements!
-      @controller.notify("dataelements/change", :endpoint => @handler_endpoint, :instance => "#{@url}/#{@controller.id}", :activity => @handler_position, :changed => dataelements)
-    end
-    unless endpoints.nil?
-      @controller.serialize_endpoints!
-      @controller.notify("endpoints/change", :endpoint => @handler_endpoint, :instance => "#{@url}/#{@controller.id}", :activity => @handler_position, :changed => endpoints)
-    end
-  end # }}}
-  def inform_position_change(ipc={}) # {{{
-    @controller.serialize_positions!
-    ipc[:instance] = "#{@url}/#{@controller.id}"
-    @controller.notify("position/change", ipc)
-  end # }}}
-  def inform_state_change(newstate) # {{{
-    if @controller
-      @controller.serialize_state!
-      @controller.notify("state/change", :instance => "#{@url}/#{@controller.id}", :state => newstate)
-    end
-  end # }}}
-
-  def vote_sync_after # {{{
-    @controller.call_vote("activity/syncing_after", :endpoint => @handler_endpoint, :instance => "#{@url}/#{@controller.id}", :activity => @handler_position)
-  end # }}}
-  def vote_sync_before # {{{
-    @controller.call_vote("activity/syncing_before", :endpoint => @handler_endpoint, :instance => "#{@url}/#{@controller.id}", :activity => @handler_position)
-  end # }}}
-
-  def callback(result=nil,options={})
-    @handler_returnValue = result
-    @controller.callbacks.delete(@handler_passthrough)
-    @handler_passthrough = nil
-    @handler_continue.continue
-  end
-end

data/server/resources/notifications/logging/consumer-secret

@@ -1 +0,0 @@
-f7c77861ac613eeac8fb9829c9a545a2

data/server/resources/notifications/logging/producer-secret

@@ -1 +0,0 @@
-2a24d172b1aeb05fe94fdc5e095dec32

data/server/resources/properties.schema.active

@@ -1,139 +0,0 @@
-<!--
-  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/>.
--->
-
-<properties xmlns="http://riddl.org/ns/common-patterns/properties/1.0">
-  <attributes type="complex" modifiable="false" mutable="false">
-    <zeroOrMore>
-      <element><anyName/><text/></element>
-    </zeroOrMore>
-  </attributes>
-  <handlerwrapper type="simple" modifiable="false" mutable="false">
-    <data type="string">
-      <param name="pattern">[A-Z][a-zA-Z]*</param>
-    </data>
-  </handlerwrapper>
-  <dsl type="simple" modifiable="false" mutable="false">
-    <text/>
-  </dsl>
-  <dslx type="arbitrary" modifiable="false" mutable="false"/>
-  <description type="arbitrary" modifiable="false" mutable="false"/>
-  <transformation type="complex" modifiable="false" mutable="false">
-    <element name='description'>
-      <attribute name='type'>
-        <choice>
-          <value>copy</value>
-          <value>rest</value>
-          <value>xslt</value>
-          <value>clean</value>
-          <value>none</value>
-        </choice>
-      </attribute>
-      <data type="anyURI"/>
-    </element>
-    <element name='dataelements'>
-      <attribute name='type'>
-        <choice>
-          <value>rest</value>
-          <value>xslt</value>
-          <value>clean</value>
-          <value>none</value>
-        </choice>
-      </attribute>
-      <data type="anyURI"/>
-    </element>
-    <element name='endpoints'>
-      <attribute name='type'>
-        <choice>
-          <value>rest</value>
-          <value>xslt</value>
-          <value>clean</value>
-          <value>none</value>
-        </choice>
-      </attribute>
-      <data type="anyURI"/>
-    </element>
-  </transformation>
-  <state type="state" modifiable="true">
-    <ready>
-      <running putable="true"/>
-      <ready putable="true"/>
-      <simulating putable="true"/>
-      <replaying putable="true"/>
-      <abandoned putable="true"/>
-    </ready>
-    <running>
-      <stopping putable="true"/>
-      <finishing putable="false"/>
-      <finished putable="false"/>
-    </running>
-    <simulating>
-      <ready putable="false"/>
-      <stopped putable="false"/>
-    </simulating>
-    <replaying>
-      <stopping putable="true"/>
-      <finishing putable="false"/>
-      <finished putable="false"/>
-    </replaying>
-    <stopping>
-      <stopped putable="false"/>
-    </stopping>
-    <stopped>
-      <abandoned putable="true"/>
-      <stopped putable="true"/>
-      <running putable="true"/>
-      <replaying putable="true"/>
-      <simulating putable="true"/>
-    </stopped>
-    <abandoned/>
-    <finished/>
-  </state>
-  <status type="complex" modifiable="false" mutable="true">
-    <optional>
-      <element name='id'>
-        <data type="integer"/>
-      </element>
-      <element name='message'>
-        <data type="string"/>
-      </element>
-    </optional>
-  </status>
-  <positions type="complex" modifiable="false" mutable="true">
-    <zeroOrMore>
-      <element>
-        <anyName/>
-        <optional>
-          <attribute name='passthrough'>
-            <data type="string"/>
-          </attribute>
-        </optional>
-        <data type="string">
-          <param name="pattern">(at|after)</param>
-        </data>
-      </element>
-    </zeroOrMore>
-  </positions>
-  <dataelements type="complex" modifiable="false" mutable="true">
-    <zeroOrMore>
-      <element><anyName/><text/></element>
-    </zeroOrMore>
-  </dataelements>
-  <endpoints type="complex" modifiable="false" mutable="true">
-    <zeroOrMore>
-      <element><anyName/><text/></element>
-    </zeroOrMore>
-  </endpoints>
-</properties>