cpee 2.0.16 → 2.0.21

data/lib/cpee/implementation.rb

@@ -16,6 +16,7 @@ require 'fileutils'
 require 'redis'
 require 'riddl/server'
 require 'riddl/client'
+require_relative 'redis'
 require_relative 'message'
 require_relative 'persistence'
 require_relative 'statemachine'
@@ -70,12 +71,22 @@ module CPEE
     opts[:watchdog_start_off]         ||= false
     opts[:backend_instance]           ||= 'instance.rb'
     opts[:infinite_loop_stop]         ||= 10000
-    opts[:redis_path]                 ||= '/tmp/redis.sock'
-    opts[:redis_db]                   ||= 3
-    opts[:sse_keepalive_frequency]    ||= 10
 
+    ### set redis_cmd to nil if you want to do global
+    ### at least redis_path or redis_url and redis_db have to be set if you do global
+    opts[:redis_path]                 ||= 'redis.sock' # use e.g. /tmp/redis.sock for global stuff. Look it up in your redis config
+    opts[:redis_db]                   ||= 0
+    ### optional redis stuff
+    opts[:redis_url]                  ||= nil
+    opts[:redis_cmd]                  ||= 'redis-server --port 0 --unixsocket #redis_path# --unixsocketperm 600 --pidfile #redis_pid# --dir #redis_db_dir# --dbfilename #redis_db_name# --databases 1 --save 900 1 --save 300 10 --save 60 10000 --rdbcompression yes --daemonize yes'
+    opts[:redis_pid]                  ||= 'redis.pid' # use e.g. /var/run/redis.pid if you do global. Look it up in your redis config
+    opts[:redis_db_name]              ||= 'redis.rdb' # use e.g. /var/lib/redis.rdb for global stuff. Look it up in your redis config
+
+    CPEE::redis_connect opts
+
+    opts[:sse_keepalive_frequency]    ||= 10
     opts[:sse_connections]            = {}
-    opts[:redis]                      = Redis.new(path: opts[:redis_path], db: opts[:redis_db])
+
     opts[:statemachine]               = CPEE::StateMachine.new opts[:states], %w{running simulating replaying finishing stopping abandoned finished} do |id|
       opts[:redis].get("instance:#{id}/state")
     end
@@ -90,9 +101,9 @@ module CPEE
 
     Proc.new do
       parallel do
-        CPEE::watch_services(opts[:watchdog_start_off])
+        CPEE::watch_services(opts[:watchdog_start_off],opts[:redis_url],File.join(opts[:basepath],opts[:redis_path]),opts[:redis_db])
         EM.add_periodic_timer(opts[:watchdog_frequency]) do ### start services
-          CPEE::watch_services(opts[:watchdog_start_off])
+          CPEE::watch_services(opts[:watchdog_start_off],opts[:redis_url],File.join(opts[:basepath],opts[:redis_path]),opts[:redis_db])
         end
         EM.defer do ### catch all sse connections
           CPEE::Notifications::sse_distributor(opts)
@@ -132,14 +143,18 @@ module CPEE
     end
   end
 
-  def self::watch_services(watchdog_start_off)
+  def self::watch_services(watchdog_start_off,url,path,db)
     return if watchdog_start_off
      EM.defer do
        Dir[File.join(__dir__,'..','..','server','routing','*.rb')].each do |s|
          s = s.sub(/\.rb$/,'')
          pid = (File.read(s + '.pid').to_i rescue nil)
          if (pid.nil? || !(Process.kill(0, pid) rescue false)) && !File.exist?(s + '.lock')
-           system "#{s}.rb restart 1>/dev/null 2>&1"
+           if url.nil?
+             system "#{s}.rb -p \"#{path}\" -d #{db} restart 1>/dev/null 2>&1"
+           else
+             system "#{s}.rb -u \"#{url}\" -d #{db} restart 1>/dev/null 2>&1"
+           end
            puts "➡ Service #{File.basename(s,'.rb')} started ..."
          end
        end

data/lib/cpee/implementation_notifications.rb

@@ -165,7 +165,7 @@ module CPEE
     end #}}}
 
     def self::sse_distributor(opts) #{{{
-      conn = Redis.new(path: opts[:redis_path], db: opts[:redis_db])
+      conn = opts[:redis_dyn].call
       conn.psubscribe('forward:*','event:state/change') do |on|
         on.pmessage do |pat, what, message|
           if pat == 'forward:*'

data/lib/cpee/persistence.rb

@@ -30,7 +30,8 @@ module CPEE
         YAML::dump({
           :host => opts[:host],
           :url => opts[:url],
-          :redis_path => opts[:redis_path],
+          :redis_url => opts[:redis_url],
+          :redis_path => File.join(opts[:basepath],opts[:redis_path]),
           :redis_db => opts[:redis_db],
           :global_handlerwrappers => opts[:global_handlerwrappers],
           :handlerwrappers => opts[:handlerwrappers]

data/lib/cpee/redis.rb

@@ -0,0 +1,57 @@
+# 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 'redis'
+
+module CPEE
+  def self::redis_connect(opts)
+    if opts[:redis_cmd].nil?
+      begin
+        if opts[:redis_path]
+          opts[:redis_dyn] = Proc.new { Redis.new(path: opts[:redis_path], db: opts[:redis_db]) }
+        elsif opts[:redis_url]
+          opts[:redis_dyn] = Proc.new { Redis.new(url: opts[:redis_url], db: opts[:redis_db]) }
+        else
+          raise
+        end
+        opts[:redis] = opts[:redis_dyn].call
+        opts[:redis].dbsize
+      rescue
+        puts 'can not connect to redis. check if it is running and cpee is configured correctly ...'
+        exit
+      end
+    else # we always assume file socket if redis is startet locally
+      opts[:redis_dyn] = Proc.new { Redis.new(path: File.join(opts[:basepath],opts[:redis_path]), db: opts[:redis_db].to_i) }
+      begin
+        opts[:redis] = opts[:redis_dyn].call
+        opts[:redis].dbsize
+      rescue
+        rcmd = opts[:redis_cmd]
+        rcmd.gsub! /#redis_path#/, File.join(opts[:basepath],opts[:redis_path])
+        rcmd.gsub! /#redis_db_dir#/, opts[:basepath]
+        rcmd.gsub! /#redis_db_name#/, opts[:redis_db_name]
+        rcmd.gsub! /#redis_pid#/, File.join(opts[:basepath],opts[:redis_pid])
+        res = system rcmd
+        if res
+          puts 'starting redis ... it will keep running, just to let you know ...'
+          sleep 1
+          retry
+        else
+          puts 'can not start redis. check if cpee is configured correctly ...'
+          exit
+        end
+      end
+    end
+  end
+end

data/server/handlerwrappers/default.rb

@@ -109,7 +109,7 @@ class DefaultHandlerWrapper < WEEL::HandlerWrapperBase
 
     client = Riddl::Client.new(tendpoint)
 
-    @controller.callback(self,callback,:activity_uuid => @handler_activity_uuid, :label => @label, :activity => @handler_position)
+    @controller.callback(self,callback,:'activity-uuid' => @handler_activity_uuid, :label => @label, :activity => @handler_position)
     @handler_passthrough = callback
 
     status, result, headers = client.request type => params
@@ -120,10 +120,10 @@ class DefaultHandlerWrapper < WEEL::HandlerWrapperBase
       callback([ Riddl::Parameter::Complex.new('error','application/json',StringIO.new(JSON::generate({ 'status' => status, 'error' => c }))) ], headers)
     else
       if headers['CPEE_INSTANTIATION']
-        @controller.notify("task/instantiation", :activity_uuid => @handler_activity_uuid, :label => @label, :activity => @handler_position, :endpoint => @handler_endpoint, :received => CPEE::ValueHelper.parse(headers['CPEE_INSTANTIATION']))
+        @controller.notify("task/instantiation", :'activity-uuid' => @handler_activity_uuid, :label => @label, :activity => @handler_position, :endpoint => @handler_endpoint, :received => CPEE::ValueHelper.parse(headers['CPEE_INSTANTIATION']))
       end
       if headers['CPEE_EVENT']
-        @controller.notify("task/#{headers['CPEE_EVENT'].gsub(/[^\w_-]/,'')}", :activity_uuid => @handler_activity_uuid, :label => @label, :activity => @handler_position, :endpoint => @handler_endpoint)
+        @controller.notify("task/#{headers['CPEE_EVENT'].gsub(/[^\w_-]/,'')}", :'activity-uuid' => @handler_activity_uuid, :label => @label, :activity => @handler_position, :endpoint => @handler_endpoint)
       end
       if headers['CPEE_CALLBACK'] && headers['CPEE_CALLBACK'] == 'true' && result.any?
         headers['CPEE_UPDATE'] = true
@@ -142,11 +142,11 @@ class DefaultHandlerWrapper < WEEL::HandlerWrapperBase
     @sensors = parameters.dig(:stream,:sensors)
     @aggregators = parameters.dig(:stream,:aggregators)
     @costs = parameters.dig(:stream,:costs)
-    @controller.notify("activity/calling", :activity_uuid => @handler_activity_uuid, :label => @label, :activity => @handler_position, :passthrough => passthrough, :endpoint => @handler_endpoint, :parameters => parameters)
+    @controller.notify("activity/calling", :'activity-uuid' => @handler_activity_uuid, :label => @label, :activity => @handler_position, :passthrough => passthrough, :endpoint => @handler_endpoint, :parameters => parameters)
     if passthrough.to_s.empty?
       proto_curl parameters
     else
-      @controller.callback(self,passthrough,:activity_uuid => @handler_activity_uuid, :label => @label, :activity => @handler_position)
+      @controller.callback(self,passthrough,:'activity-uuid' => @handler_activity_uuid, :label => @label, :activity => @handler_position)
       @handler_passthrough = passthrough
     end
   end # }}}
@@ -175,33 +175,33 @@ class DefaultHandlerWrapper < WEEL::HandlerWrapperBase
   end # }}}
 
   def inform_activity_done # {{{
-    @controller.notify("activity/done", :activity_uuid => @handler_activity_uuid, :endpoint => @handler_endpoint, :label => @label, :activity => @handler_position)
+    @controller.notify("activity/done", :'activity-uuid' => @handler_activity_uuid, :endpoint => @handler_endpoint, :label => @label, :activity => @handler_position)
   end # }}}
   def inform_activity_manipulate # {{{
-    @controller.notify("activity/manipulating", :activity_uuid => @handler_activity_uuid, :endpoint => @handler_endpoint, :label => @label, :activity => @handler_position)
+    @controller.notify("activity/manipulating", :'activity-uuid' => @handler_activity_uuid, :endpoint => @handler_endpoint, :label => @label, :activity => @handler_position)
   end # }}}
   def inform_activity_failed(err) # {{{
     puts err.message
     puts err.backtrace
-    @controller.notify("activity/failed", :activity_uuid => @handler_activity_uuid, :endpoint => @handler_endpoint, :label => @label, :activity => @handler_position, :message => err.message, :line => err.backtrace[0].match(/(.*?):(\d+):/)[2], :where => err.backtrace[0].match(/(.*?):(\d+):/)[1])
+    @controller.notify("activity/failed", :'activity-uuid' => @handler_activity_uuid, :endpoint => @handler_endpoint, :label => @label, :activity => @handler_position, :message => err.message, :line => err.backtrace[0].match(/(.*?):(\d+):/)[2], :where => err.backtrace[0].match(/(.*?):(\d+):/)[1])
   end # }}}
   def inform_manipulate_change(status,changed_dataelements,changed_endpoints,dataelements,endpoints) # {{{
     unless status.nil?
-      @controller.notify("status/change", :activity_uuid => @handler_activity_uuid, :endpoint => @handler_endpoint, :label => @label, :activity => @handler_position, :id => status.id, :message => status.message)
+      @controller.notify("status/change", :'activity-uuid' => @handler_activity_uuid, :endpoint => @handler_endpoint, :label => @label, :activity => @handler_position, :id => status.id, :message => status.message)
     end
     unless changed_dataelements.nil?
-      @controller.notify("dataelements/change", :activity_uuid => @handler_activity_uuid, :endpoint => @handler_endpoint, :label => @label, :activity => @handler_position, :changed => changed_dataelements, :values => dataelements)
+      @controller.notify("dataelements/change", :'activity-uuid' => @handler_activity_uuid, :endpoint => @handler_endpoint, :label => @label, :activity => @handler_position, :changed => changed_dataelements, :values => dataelements)
     end
     unless changed_endpoints.nil?
-      @controller.notify("endpoints/change", :activity_uuid => @handler_activity_uuid, :endpoint => @handler_endpoint, :label => @label, :activity => @handler_position, :changed => changed_endpoints, :values => endpoints)
+      @controller.notify("endpoints/change", :'activity-uuid' => @handler_activity_uuid, :endpoint => @handler_endpoint, :label => @label, :activity => @handler_position, :changed => changed_endpoints, :values => endpoints)
     end
   end # }}}
 
   def vote_sync_after # {{{
-    @controller.vote("activity/syncing_after", :activity_uuid => @handler_activity_uuid, :endpoint => @handler_endpoint, :activity => @handler_position, :label => @label)
+    @controller.vote("activity/syncing_after", :'activity-uuid' => @handler_activity_uuid, :endpoint => @handler_endpoint, :activity => @handler_position, :label => @label)
   end # }}}
   def vote_sync_before(parameters=nil) # {{{
-    @controller.vote("activity/syncing_before", :activity_uuid => @handler_activity_uuid, :endpoint => @handler_endpoint, :activity => @handler_position, :label => @label, :parameters => parameters)
+    @controller.vote("activity/syncing_before", :'activity-uuid' => @handler_activity_uuid, :endpoint => @handler_endpoint, :activity => @handler_position, :label => @label, :parameters => parameters)
   end # }}}
 
   def simplify_result(result)
@@ -260,13 +260,13 @@ class DefaultHandlerWrapper < WEEL::HandlerWrapperBase
   end
 
   def callback(result=nil,options={})
-    @controller.notify("activity/receiving", :activity_uuid => @handler_activity_uuid, :label => @label, :activity => @handler_position, :endpoint => @handler_endpoint, :received => structurize_result(result), :sensors => @sensors, :aggregators => @aggregators, :costs => @costs)
+    @controller.notify("activity/receiving", :'activity-uuid' => @handler_activity_uuid, :label => @label, :activity => @handler_position, :endpoint => @handler_endpoint, :received => structurize_result(result), :sensors => @sensors, :aggregators => @aggregators, :costs => @costs)
     result = simplify_result(result)
     @handler_returnValue = result
     @handler_returnOptions = options
     if options['CPEE_UPDATE']
       if options['CPEE_UPDATE_STATUS']
-        @controller.notify("activity/status", :activity_uuid => @handler_activity_uuid, :label => @label, :activity => @handler_position, :endpoint => @handler_endpoint, :status => options['CPEE_UPDATE_STATUS'])
+        @controller.notify("activity/status", :'activity-uuid' => @handler_activity_uuid, :label => @label, :activity => @handler_position, :endpoint => @handler_endpoint, :status => options['CPEE_UPDATE_STATUS'])
       end
       @handler_continue.continue WEEL::Signal::Again
     else
@@ -290,7 +290,7 @@ class DefaultHandlerWrapper < WEEL::HandlerWrapperBase
     pp "#{type} - #{nesting} - #{tid} - #{parent} - #{parameters.inspect}"
 
     @controller.vote("simulating/step",
-      :activity_uuid => @handler_activity_uuid,
+      :'activity-uuid' => @handler_activity_uuid,
       :label => @label,
       :activity => tid,
       :endpoint => @handler_endpoint,

data/server/routing/end.rb

@@ -17,18 +17,30 @@
 require 'json'
 require 'redis'
 require 'daemonite'
+require_relative '../../lib/cpee/redis'
 
 Daemonite.new do |opts|
-  redis = Redis.new(path: "/tmp/redis.sock", db: 3)
-  pubsubredis = Redis.new(path: "/tmp/redis.sock", db: 3)
+  opts[:runtime_opts] += [
+    ["--url=URL", "-uURL", "Specify redis url", ->(p){ opts[:redis_url] = p }],
+    ["--path=PATH", "-pPATH", "Specify redis path, e.g. /tmp/redis.sock", ->(p){ opts[:redis_path] = p }],
+    ["--db=DB", "-dDB", "Specify redis db, e.g. 1", ->(p) { opts[:redis_db] = p.to_i }]
+  ]
+
+  on startup do
+    opts[:redis_path] ||= '/tmp/redis.sock'
+    opts[:redis_db] ||= 1
+
+    CPEE::redis_connect opts
+    opts[:pubsubredis] = opts[:redis_dyn].call
+  end
 
   run do
-    pubsubredis.psubscribe('callback-end:*') do |on|
+    opts[:pubsubredis].psubscribe('callback-end:*') do |on|
       on.pmessage do |pat, what, message|
         _, key = what.split(':')
         index = message.index(' ')
         instance = message[0...index]
-        redis.multi do |multi|
+        opts[:redis].multi do |multi|
           multi.srem("instance:#{instance}/callbacks",key)
           multi.del("instance:#{instance}/callback/#{key}/uuid")
           multi.del("instance:#{instance}/callback/#{key}/label")

data/server/routing/forward-events.rb

@@ -17,13 +17,25 @@
 require 'redis'
 require 'daemonite'
 require 'riddl/client'
+require_relative '../../lib/cpee/redis'
 
 Daemonite.new do |opts|
-  redis = Redis.new(path: "/tmp/redis.sock", db: 3)
-  pubsubredis = Redis.new(path: "/tmp/redis.sock", db: 3)
+  opts[:runtime_opts] += [
+    ["--url=URL", "-uURL", "Specify redis url", ->(p){ opts[:redis_url] = p }],
+    ["--path=PATH", "-pPATH", "Specify redis path, e.g. /tmp/redis.sock", ->(p){ opts[:redis_path] = p }],
+    ["--db=DB", "-dDB", "Specify redis db, e.g. 1", ->(p) { opts[:redis_db] = p.to_i }]
+  ]
+
+  on startup do
+    opts[:redis_path] ||= '/tmp/redis.sock'
+    opts[:redis_db] ||= 1
+
+    CPEE::redis_connect opts
+    opts[:pubsubredis] = opts[:redis_dyn].call
+  end
 
   run do
-    pubsubredis.psubscribe('event:*') do |on|
+    opts[:pubsubredis].psubscribe('event:*') do |on|
       on.pmessage do |pat, what, message|
         index = message.index(' ')
         mess = message[index+1..-1]
@@ -33,11 +45,11 @@ Daemonite.new do |opts|
         topic = ::File::dirname(event)
         name = ::File::basename(event)
         long = File.join(topic,type,name)
-        redis.smembers("instance:#{instance}/handlers").each do |key|
-          if redis.smembers("instance:#{instance}/handlers/#{key}").include? long
-            url = redis.get("instance:#{instance}/handlers/#{key}/url")
+        opts[:redis].smembers("instance:#{instance}/handlers").each do |key|
+          if opts[:redis].smembers("instance:#{instance}/handlers/#{key}").include? long
+            url = opts[:redis].get("instance:#{instance}/handlers/#{key}/url")
             if url.nil? || url == ""
-              redis.publish("forward:#{instance}/#{key}",mess)
+              opts[:redis].publish("forward:#{instance}/#{key}",mess)
             else
               p "#{type}/#{topic}/#{event}-#{url}"
               client = Riddl::Client.new(url)

data/server/routing/forward-votes.rb

@@ -19,6 +19,7 @@ require 'daemonite'
 require 'riddl/client'
 require 'json'
 require_relative '../../lib/cpee/message'
+require_relative '../../lib/cpee/redis'
 
 def persist_handler(instance,key,mess,redis) #{{{
   redis.multi do |multi|
@@ -44,11 +45,22 @@ def send_response(instance,key,url,value,redis) #{{{
 end #}}}
 
 Daemonite.new do |opts|
-  redis = Redis.new(path: "/tmp/redis.sock", db: 3)
-  pubsubredis = Redis.new(path: "/tmp/redis.sock", db: 3)
+  opts[:runtime_opts] += [
+    ["--url=URL", "-uURL", "Specify redis url", ->(p){ opts[:redis_url] = p }],
+    ["--path=PATH", "-pPATH", "Specify redis path, e.g. /tmp/redis.sock", ->(p){ opts[:redis_path] = p }],
+    ["--db=DB", "-dDB", "Specify redis db, e.g. 1", ->(p) { opts[:redis_db] = p.to_i }]
+  ]
+
+  on startup do
+    opts[:redis_path] ||= '/tmp/redis.sock'
+    opts[:redis_db] ||= 1
+
+    CPEE::redis_connect opts
+    opts[:pubsubredis] = opts[:redis_dyn].call
+  end
 
   run do
-    pubsubredis.psubscribe('vote:*') do |on|
+    opts[:pubsubredis].psubscribe('vote:*') do |on|
       on.pmessage do |pat, what, message|
         index = message.index(' ')
         mess = message[index+1..-1]
@@ -60,15 +72,15 @@ Daemonite.new do |opts|
         name = ::File::basename(event)
         long = File.join(topic,type,name)
 
-        redis.smembers("instance:#{instance}/handlers").each do |subscription_key|
-          if redis.smembers("instance:#{instance}/handlers/#{subscription_key}").include? long
+        opts[:redis].smembers("instance:#{instance}/handlers").each do |subscription_key|
+          if opts[:redis].smembers("instance:#{instance}/handlers/#{subscription_key}").include? long
             m = JSON.parse(mess)
             callback_key = m.dig('content','key')
-            url = redis.get("instance:#{instance}/handlers/#{subscription_key}/url")
+            url = opts[:redis].get("instance:#{instance}/handlers/#{subscription_key}/url")
 
             if url.nil? || url == ""
               persist_handler instance, callback_key, m, redis
-              redis.publish("forward:#{instance}/#{subscription_key}",mess)
+              opts[:redis].publish("forward:#{instance}/#{subscription_key}",mess)
             else
               client = Riddl::Client.new(url)
               callback = m['instance-url'] + '/callbacks/' + subscription_key

data/server/routing/persist.rb

@@ -18,6 +18,7 @@ require 'json'
 require 'redis'
 require 'daemonite'
 require_relative '../../lib/cpee/value_helper'
+require_relative '../../lib/cpee/redis'
 
 EVENTS = %w{
   event:state/change
@@ -34,18 +35,29 @@ EVENTS = %w{
 }
 
 Daemonite.new do |opts|
-  redis = Redis.new(path: "/tmp/redis.sock", db: 3)
-  pubsubredis = Redis.new(path: "/tmp/redis.sock", db: 3)
+  opts[:runtime_opts] += [
+    ["--url=URL", "-uURL", "Specify redis url", ->(p){ opts[:redis_url] = p }],
+    ["--path=PATH", "-pPATH", "Specify redis path, e.g. /tmp/redis.sock", ->(p){ opts[:redis_path] = p }],
+    ["--db=DB", "-dDB", "Specify redis db, e.g. 1", ->(p) { opts[:redis_db] = p.to_i }]
+  ]
+
+  on startup do
+    opts[:redis_path] ||= '/tmp/redis.sock'
+    opts[:redis_db] ||= 1
+
+    CPEE::redis_connect opts
+    opts[:pubsubredis] = opts[:redis_dyn].call
+  end
 
   run do
-    pubsubredis.subscribe(EVENTS) do |on|
+    opts[:pubsubredis].subscribe(EVENTS) do |on|
       on.message do |what, message|
         mess = JSON.parse(message[message.index(' ')+1..-1])
         instance = mess.dig('instance')
         case what
           when 'callback:activity/content'
             key = mess.dig('content','key')
-            redis.multi do |multi|
+            opts[:redis].multi do |multi|
               multi.sadd("instance:#{instance}/callbacks",key)
               multi.set("instance:#{instance}/callback/#{key}/uuid",mess.dig('content','activity_uuid'))
               multi.set("instance:#{instance}/callback/#{key}/label",mess.dig('content','label'))
@@ -53,21 +65,21 @@ Daemonite.new do |opts|
               multi.set("instance:#{instance}/callback/#{key}/type",'callback')
             end
           when 'event:state/change'
-            redis.multi do |multi|
+            opts[:redis].multi do |multi|
               multi.set("instance:#{instance}/state",mess.dig('content','state'))
-              multi.set("instance:#{instance}/state/@changed",mess.dig('content','timestamp'))
+              multi.set("instance:#{instance}/state/@changed",mess.dig('timestamp'))
             end
           when 'event:handlerwrapper/change'
-            redis.set("instance:#{instance}/handlerwrapper",mess.dig('content','handlerwrapper'))
+            opts[:redis].set("instance:#{instance}/handlerwrapper",mess.dig('content','handlerwrapper'))
           when 'event:description/change'
-            redis.multi do |multi|
+            opts[:redis].multi do |multi|
               multi.set("instance:#{instance}/description",mess.dig('content','description'))
               multi.set("instance:#{instance}/dslx",mess.dig('content','dslx'))
               multi.set("instance:#{instance}/dsl",mess.dig('content','dsl'))
             end
           when 'event:dataelements/change', 'event:endpoints/change', 'event:attributes/change'
             topic = mess.dig('topic')
-            redis.multi do |multi|
+            opts[:redis].multi do |multi|
               mess.dig('content','changed')&.each_with_index do |c,i|
                 unless what == 'event:attributes/change' && c == 'uuid'
                   multi.zadd("instance:#{instance}/#{topic}",i,c)
@@ -86,7 +98,7 @@ Daemonite.new do |opts|
               end
             end
           when 'event:transformation/change'
-            redis.multi do |multi|
+            opts[:redis].multi do |multi|
               multi.set("instance:#{instance}/transformation/description/",mess.dig('content','description'))
               multi.set("instance:#{instance}/transformation/description/@type",mess.dig('content','description_type'))
               multi.set("instance:#{instance}/transformation/dataelements/",mess.dig('content','dataelements'))
@@ -95,12 +107,12 @@ Daemonite.new do |opts|
               multi.set("instance:#{instance}/transformation/endpoints/@type",mess.dig('content','endpoints_type'))
             end
           when 'event:status/change'
-            redis.multi do |multi|
+            opts[:redis].multi do |multi|
               multi.set("instance:#{instance}/status/id",mess.dig('content','id'))
               multi.set("instance:#{instance}/status/message",mess.dig('content','message'))
             end
           when 'event:position/change'
-            redis.multi do |multi|
+            opts[:redis].multi do |multi|
               c = mess.dig('content')
               c.dig('unmark')&.each do |ele|
                 multi.srem("instance:#{instance}/positions",ele['position'])
@@ -127,7 +139,7 @@ Daemonite.new do |opts|
               end
             end
           when 'event:handler/change'
-            redis.multi do |multi|
+            opts[:redis].multi do |multi|
               mess.dig('content','changed').each do |c|
                 multi.sadd("instance:#{instance}/handlers",mess.dig('content','key'))
                 multi.sadd("instance:#{instance}/handlers/#{mess.dig('content','key')}",c)
@@ -139,8 +151,8 @@ Daemonite.new do |opts|
                 multi.srem("instance:#{instance}/handlers/#{c}",mess.dig('content','key'))
               end
             end
-            if redis.scard("instance:#{instance}/handlers/#{mess.dig('content','key')}") < 1
-              redis.multi do |multi|
+            if opts[:redis].scard("instance:#{instance}/handlers/#{mess.dig('content','key')}") < 1
+              opts[:redis].multi do |multi|
                 multi.del("instance:#{instance}/handlers/#{mess.dig('content','key')}/url")
                 multi.srem("instance:#{instance}/handlers",mess.dig('content','key'))
               end