openc3 5.8.1 → 5.9.0

data/lib/openc3/microservices/trigger_group_microservice.rb

@@ -25,40 +25,47 @@ require 'openc3/models/notification_model'
 require 'openc3/models/trigger_model'
 require 'openc3/topics/autonomic_topic'
 require 'openc3/utilities/authentication'
+require 'openc3/packets/json_packet'
 
 require 'openc3/script'
 
 module OpenC3
-
   class TriggerLoopError < TriggerError; end
 
   # Stored in the TriggerGroupShare this should be a thread safe
   # hash that triggers will be added, updated, and removed from
   class PacketBase
-
     def initialize(scope:)
       @scope = scope
       @mutex = Mutex.new
       @packets = Hash.new
     end
 
-    # ["#{@scope}__DECOM__{#{@target}}__#{@packet}"]
     def packet(target:, packet:)
       topic = "#{@scope}__DECOM__{#{target}}__#{packet}"
       @mutex.synchronize do
-        return Marshal.load( Marshal.dump(@packets[topic]) )
+        return nil unless @packets[topic]
+        # Deep copy the packet so it doesn't change under us
+        return Marshal.load( Marshal.dump(@packets[topic][-1]) )
       end
     end
 
-    def get(topic:)
+    def previous_packet(target:, packet:)
+      topic = "#{@scope}__DECOM__{#{target}}__#{packet}"
       @mutex.synchronize do
-        return Marshal.load( Marshal.dump(@packets[topic]) )
+        return nil unless @packets[topic] and @packets[topic].length == 2
+        # Deep copy the packet so it doesn't change under us
+        return Marshal.load( Marshal.dump(@packets[topic][0]) )
       end
     end
 
     def add(topic:, packet:)
       @mutex.synchronize do
-        @packets[topic] = packet
+        @packets[topic] ||= []
+        if @packets[topic].length == 2
+          @packets[topic].shift
+        end
+        @packets[topic].push(packet)
       end
     end
 
@@ -72,8 +79,7 @@ module OpenC3
   # Stored in the TriggerGroupShare this should be a thread safe
   # hash that triggers will be added, updated, and removed from.
   class TriggerBase
-
-    attr_reader :autonomic_topic
+    attr_reader :autonomic_topic, :triggers
 
     def initialize(scope:)
       @scope = scope
@@ -84,8 +90,8 @@ module OpenC3
       @lookup = Hash.new
     end
 
-    # Get triggers to evaluate based on the topic. IF the
-    # topic is the equal to the autonomic topic it will
+    # Get triggers to evaluate based on the topic. If the
+    # topic is equal to the autonomic topic it will
     # return only triggers with roots
     def get_triggers(topic:)
       if @autonomic_topic == topic
@@ -104,19 +110,19 @@ module OpenC3
         data = @triggers[name]
         return unless data
         trigger = TriggerModel.from_json(data, name: data['name'], scope: data['scope'])
-        if value == -1 && trigger.active
-          trigger.deactivate()
+        if value == -1 && trigger.enabled
+          trigger.disable()
         elsif value == 1 && trigger.state == false
-          trigger.enable()
+          trigger.state = true
         elsif value == 0 && trigger.state == true
-          trigger.disable()
+          trigger.state = false
         end
         @triggers[name] = trigger.as_json(:allow_nan => true)
       end
     end
 
-    # returns a Hash of ALL active Trigger objects
-    def triggers
+    # returns a Hash of ALL enabled Trigger objects
+    def enabled_triggers
       val = nil
       @triggers_mutex.synchronize do
         val = Marshal.load( Marshal.dump(@triggers) )
@@ -124,12 +130,12 @@ module OpenC3
       ret = Hash.new
       val.each do | name, data |
         trigger = TriggerModel.from_json(data, name: data['name'], scope: data['scope'])
-        ret[name] = trigger if trigger.active
+        ret[name] = trigger if trigger.enabled
       end
       return ret
     end
 
-    # returns an Array of active Trigger objects that have roots to other triggers
+    # returns an Array of enabled Trigger objects that have roots to other triggers
     def triggers_with_roots
       val = nil
       @triggers_mutex.synchronize do
@@ -138,12 +144,12 @@ module OpenC3
       ret = []
       val.each do | _name, data |
         trigger = TriggerModel.from_json(data, name: data['name'], scope: data['scope'])
-        ret << trigger if trigger.active && ! trigger.roots.empty?
+        ret << trigger if trigger.enabled && ! trigger.roots.empty?
       end
       return ret
     end
 
-    # returns an Array of active Trigger objects that use a topic
+    # returns an Array of enabled Trigger objects that use a topic
     def triggers_from(topic:)
       val = nil
       @lookup_mutex.synchronize do
@@ -152,10 +158,10 @@ module OpenC3
       return [] if val.nil?
       ret = []
       @triggers_mutex.synchronize do
-        val.each do | trigger_name, _v |
+        val.each do | trigger_name |
           data = Marshal.load( Marshal.dump(@triggers[trigger_name]) )
           trigger = TriggerModel.from_json(data, name: data['name'], scope: data['scope'])
-          ret << trigger if trigger.active
+          ret << trigger if trigger.enabled
         end
       end
       return ret
@@ -168,53 +174,60 @@ module OpenC3
       end
     end
 
-    # database update of all triggers in the group
-    def update(triggers:)
+    # Rebuild the database lookup of all triggers in the group
+    def rebuild(triggers:)
       @triggers_mutex.synchronize do
         @triggers = Marshal.load( Marshal.dump(triggers) )
       end
       @lookup_mutex.synchronize do
-        @lookup = {@autonomic_topic => {}}
+        @lookup = { @autonomic_topic => [] }
         triggers.each do | _name, data |
           trigger = TriggerModel.from_json(data, name: data['name'], scope: data['scope'])
           trigger.generate_topics.each do | topic |
-            if @lookup[topic].nil?
-              @lookup[topic] = { trigger.name => 1 }
-            else
-              @lookup[topic][trigger.name] = 1
-            end
+            @lookup[topic] ||= []
+            @lookup[topic] << trigger.name
           end
         end
       end
     end
 
-    # add a trigger from TriggerBase
+    # Add a trigger from TriggerBase, must only be called once per trigger
     def add(trigger:)
       @triggers_mutex.synchronize do
         @triggers[trigger['name']] = Marshal.load( Marshal.dump(trigger) )
       end
-      t = TriggerModel.from_json(trigger, name: trigger['name'], scope: trigger['scope'])
+      trigger = TriggerModel.from_json(trigger, name: trigger['name'], scope: trigger['scope'])
       @lookup_mutex.synchronize do
-        t.generate_topics.each do | topic |
-          if @lookup[topic].nil?
-            @lookup[topic] = { t.name => 1 }
-          else
-            @lookup[topic][t.name] = 1
-          end
+        trigger.generate_topics.each do | topic |
+          @lookup[topic] ||= []
+          @lookup[topic] << trigger.name
         end
       end
     end
 
+    # update a trigger from TriggerBase
+    def update(trigger:)
+      @triggers_mutex.synchronize do
+        model = TriggerModel.from_json(trigger, name: trigger['name'], scope: trigger['scope'])
+        model.update()
+        @triggers[trigger['name']] = model.as_json(:allow_nan => true)
+      end
+    end
+
     # remove a trigger from TriggerBase
     def remove(trigger:)
+      topics = []
       @triggers_mutex.synchronize do
         @triggers.delete(trigger['name'])
+        model = TriggerModel.from_json(trigger, name: trigger['name'], scope: trigger['scope'])
+        topics = model.generate_topics()
+        TriggerModel.delete(name: trigger['name'], group: trigger['group'], scope: trigger['scope'])
       end
-      t = TriggerModel.from_json(trigger, name: trigger['name'], scope: trigger['scope'])
       @lookup_mutex.synchronize do
-        t.generate_topics.each do | topic |
+        topics.each do | topic |
           unless @lookup[topic].nil?
-            @lookup[topic].delete(t.name)
+            @lookup[topic].delete(trigger['name'])
+            @lookup.delete(topic) if @lookup[topic].empty?
           end
         end
       end
@@ -223,13 +236,8 @@ module OpenC3
 
   # Shared between the monitor thread and the manager thread to
   # share the triggers. This should remain a thread
-  # safe implamentation.
+  # safe implementation.
   class TriggerGroupShare
-
-    def self.get_group(name:)
-      return name.split('__')[2]
-    end
-
     attr_reader :trigger_base, :packet_base
 
     def initialize(scope:)
@@ -241,16 +249,16 @@ module OpenC3
 
   # The TriggerGroupWorker is a very simple thread pool worker. Once
   # the trigger manager has pushed a packet to the queue one of
-  # these workers will evaluate the triggers in the kit and
-  # evaluate triggers for that packet.
+  # these workers will evaluate the triggers for that packet.
   class TriggerGroupWorker
     TYPE = 'type'.freeze
-    ITEM_RAW = 'raw'.freeze
     ITEM_TARGET = 'target'.freeze
     ITEM_PACKET = 'packet'.freeze
     ITEM_TYPE = 'item'.freeze
+    ITEM_VALUE_TYPE = 'valueType'.freeze
     FLOAT_TYPE = 'float'.freeze
     STRING_TYPE = 'string'.freeze
+    REGEX_TYPE = 'regex'.freeze
     LIMIT_TYPE = 'limit'.freeze
     TRIGGER_TYPE = 'trigger'.freeze
 
@@ -266,13 +274,29 @@ module OpenC3
       @ident = ident
     end
 
+    def notify(name:, severity:, message:)
+      data = {}
+      # All AutonomicTopic notifications must have 'name' and 'updated_at' in the data
+      data['name'] = name
+      data['updated_at'] = Time.now.to_nsec_from_epoch
+      data['severity'] = severity
+      data['message'] = message
+      notification = {
+        'kind' => 'error',
+        'type' => 'trigger',
+        'data' => JSON.generate(data),
+      }
+      AutonomicTopic.write_notification(notification, scope: @scope)
+      @logger.public_send(severity.intern, message)
+    end
+
     def run
       @logger.info "TriggerGroupWorker-#{@ident} running"
       loop do
         topic = @queue.pop
         break if topic.nil?
         begin
-          evaluate_wrapper(topic: topic)
+          evaluate_data_packet(topic: topic)
         rescue StandardError => e
           @logger.error "TriggerGroupWorker-#{@ident} failed to evaluate data packet from topic: #{topic}\n#{e.formatted}"
         end
@@ -280,24 +304,18 @@ module OpenC3
       @logger.info "TriggerGroupWorker-#{@ident} exiting"
     end
 
-    def evaluate_wrapper(topic:)
-      evaluate_data_packet(topic: topic, triggers: @share.trigger_base.triggers)
-    end
-
     # Each packet will be evaluated to all triggers and use the result to send
     # the results back to the topic to be used by the reaction microservice.
-    def evaluate_data_packet(topic:, triggers:)
+    def evaluate_data_packet(topic:)
       visited = Hash.new
       @logger.debug "TriggerGroupWorker-#{@ident} topic: #{topic}"
-      triggers_to_eval = @share.trigger_base.get_triggers(topic: topic)
-      @logger.debug "TriggerGroupWorker-#{@ident} triggers_to_eval: #{triggers_to_eval}"
-      triggers_to_eval.each do | trigger |
+      @share.trigger_base.get_triggers(topic: topic).each do |trigger|
         @logger.debug "TriggerGroupWorker-#{@ident} eval head: #{trigger}"
         value = evaluate_trigger(
           head: trigger,
           trigger: trigger,
           visited: visited,
-          triggers: triggers
+          triggers: @share.trigger_base.enabled_triggers
         )
         @logger.debug "TriggerGroupWorker-#{@ident} trigger: #{trigger} value: #{value}"
         # value MUST be -1, 0, or 1
@@ -315,36 +333,54 @@ module OpenC3
         packet: operand[ITEM_PACKET]
       )
       return nil if packet.nil?
-      limit = packet["#{operand[ITEM_TYPE]}__L"]
-      if limit.nil? == false && limit.include?('_')
-        return other[LIMIT_TYPE] if limit.include?(other[LIMIT_TYPE])
-      end
+      _, limit = packet.read_with_limits_state(operand[ITEM_TYPE], operand[ITEM_VALUE_TYPE].intern)
       return limit
     end
 
     # extract the value outlined in the operand to get the packet item value
     # IF raw in operand it will pull the raw value over the converted
-    def get_packet_value(operand:)
-      packet = @share.packet_base.packet(
-        target: operand[ITEM_TARGET],
-        packet: operand[ITEM_PACKET]
-      )
-      return nil if packet.nil?
-
-      value_type = operand[ITEM_RAW] ? '' : '__C'
-      return packet["#{operand[ITEM_TYPE]}#{value_type}"]
+    def get_packet_value(operand:, previous:)
+      if previous
+        packet = @share.packet_base.previous_packet(
+          target: operand[ITEM_TARGET],
+          packet: operand[ITEM_PACKET]
+        )
+        # Previous might not be populated ... that's ok just return nil
+        return nil unless packet
+      else
+        packet = @share.packet_base.packet(
+          target: operand[ITEM_TARGET],
+          packet: operand[ITEM_PACKET]
+        )
+      end
+      # This shouldn't happen because the frontend provides valid items but good to check
+      # The raise is ultimately rescued inside evaluate_trigger when operand_value is called
+      raise "Packet #{operand[ITEM_TARGET]} #{operand[ITEM_PACKET]} not found" if packet.nil?
+      value = packet.read(operand[ITEM_TYPE], operand[ITEM_VALUE_TYPE].intern)
+      raise "Item #{operand[ITEM_TARGET]} #{operand[ITEM_PACKET]} #{operand[ITEM_TYPE]} not found" if value.nil?
+      value
     end
 
     # extract the value of the operand from the packet
-    def operand_value(operand:, other:, visited:)
-      if operand[TYPE] == ITEM_TYPE && other[TYPE] == LIMIT_TYPE
+    def operand_value(operand:, other:, visited:, previous: false)
+      if operand[TYPE] == ITEM_TYPE && other && other[TYPE] == LIMIT_TYPE
         return get_packet_limit(operand: operand, other: other)
       elsif operand[TYPE] == ITEM_TYPE
-        return get_packet_value(operand: operand)
+        return get_packet_value(operand: operand, previous: previous)
       elsif operand[TYPE] == TRIGGER_TYPE
         return visited["#{operand[TRIGGER_TYPE]}__R"] == 1
-      else
+      elsif operand[TYPE] == FLOAT_TYPE
+        return operand[operand[TYPE]].to_f
+      elsif operand[TYPE] == STRING_TYPE
+        return operand[operand[TYPE]].to_s
+      elsif operand[TYPE] == REGEX_TYPE
+        # This can potentially throw an exception on badly formatted Regexp
+        return Regexp.new(operand[operand[TYPE]])
+      elsif operand[TYPE] == LIMIT_TYPE
         return operand[operand[TYPE]]
+      else
+        # This is a logic error ... should never get here
+        raise "Unknown operand type: #{operand}"
       end
     end
 
@@ -353,8 +389,8 @@ module OpenC3
     #    0 (the value is considered as a false value)
     #    1 (the value is considered as a true value)
     #
-    def evaluate(left:, operator:, right:)
-      @logger.debug "TriggerGroupWorker-#{@ident} evaluate: (#{left} #{operator} #{right})"
+    def evaluate(name:, left:, operator:, right:)
+      @logger.debug "TriggerGroupWorker-#{@ident} evaluate: (#{left}(#{left.class}) #{operator} #{right}(#{right.class}))"
       begin
         case operator
         when '>'
@@ -365,17 +401,22 @@ module OpenC3
           return left >= right ? 1 : 0
         when '<='
           return left <= right ? 1 : 0
-        when '!='
+        when '!=', 'CHANGES'
           return left != right ? 1 : 0
-        when '=='
+        when '==', 'DOES NOT CHANGE'
           return left == right ? 1 : 0
+        when '!~'
+          return left !~ right ? 1 : 0
+        when '=~'
+          return left =~ right ? 1 : 0
         when 'AND'
           return left && right ? 1 : 0
         when 'OR'
           return left || right ? 1 : 0
         end
-      rescue ArgumentError
-        @logger.error "invalid evaluate: (#{left} #{operator} #{right})"
+      rescue ArgumentError => error
+        message = "invalid evaluate: (#{left} #{operator} #{right})"
+        notify(name: name, severity: 'error', message: message)
         return -1
       end
     end
@@ -384,7 +425,7 @@ module OpenC3
     # TriggerGroupWorkers to call. It will use the trigger name and append a
     # __P for path or __R for result. The Path is a Hash that contains
     # a key for each node traveled to get results. When the result has
-    # been found it will be stored in the result key __R in the vistied Hash
+    # been found it will be stored in the result key __R in the visited Hash
     # and eval_trigger will return a number.
     #   -1 (the value is considered an error used to disable the trigger)
     #    0 (the value is considered as a false value)
@@ -401,14 +442,16 @@ module OpenC3
       end
       if visited["#{head.name}__P"][trigger.name]
         # Not sure if this is posible as on create it validates that the dependents are already created
-        @logger.error "loop detected from #{head} -> #{trigger} path: #{visited["#{head.name}__P"]}"
+        message = "loop detected from #{head.name} -> #{trigger.name} path: #{visited["#{head.name}__P"]}"
+        notify(name: trigger.name, severity: 'error', message: error.message)
         return visited["#{trigger.name}__R"] = -1
       end
       trigger.roots.each do | root_trigger_name |
         next if visited["#{root_trigger_name}__R"]
         root_trigger = triggers[root_trigger_name]
         if head.name == root_trigger.name
-          @logger.error "loop detected from #{head} -> #{root_trigger} path: #{visited["#{head.name}__P"]}"
+          message = "loop detected from #{head.name} -> #{root_trigger_name} path: #{visited["#{head.name}__P"]}"
+          notify(name: trigger.name, severity: 'error', message: error.message)
           return visited["#{trigger.name}__R"] = -1
         end
         result = evaluate_trigger(
@@ -420,23 +463,36 @@ module OpenC3
         @logger.debug "TriggerGroupWorker-#{@ident} #{root_trigger.name} result: #{result}"
         visited["#{root_trigger.name}__R"] = visited["#{head.name}__P"][root_trigger.name] = result
       end
-      left = operand_value(operand: trigger.left, other: trigger.right, visited: visited)
-      right = operand_value(operand: trigger.right, other: trigger.left, visited: visited)
+      begin
+        left = operand_value(operand: trigger.left, other: trigger.right, visited: visited)
+        if trigger.operator.include?('CHANGE')
+          right = operand_value(operand: trigger.left, other: trigger.right, visited: visited, previous: true)
+        else
+          right = operand_value(operand: trigger.right, other: trigger.left, visited: visited)
+        end
+      rescue => error
+        # This will primarily happen when the user inputs a bad Regexp
+        notify(name: trigger.name, severity: 'error', message: error.message)
+        return visited["#{trigger.name}__R"] = -1
+      end
+      # Convert the standard '==' and '!=' into Ruby Regexp operators
+      operator = trigger.operator
+      if right and right.is_a? Regexp
+        operator = '=~' if operator == '=='
+        operator = '!~' if operator == '!='
+      end
       if left.nil? || right.nil?
         return visited["#{trigger.name}__R"] = 0
       end
-      result = evaluate(left: left, operator: trigger.operator, right: right)
+      result = evaluate(name: trigger.name,left: left, operator: operator, right: right)
       return visited["#{trigger.name}__R"] = result
     end
-
   end
 
   # The trigger manager starts a thread pool and subscribes
-  # to the telemtry decom topic add the packet to a queue.
-  # TriggerGroupManager adds the "packet" to the thread pool queue
+  # to the telemtry decom topic. It adds the "packet" to the thread pool queue
   # and the thread will evaluate the "trigger".
   class TriggerGroupManager
-
     attr_reader :name, :scope, :share, :group, :topics, :thread_pool
 
     def initialize(name:, logger:, scope:, group:, share:)
@@ -480,7 +536,6 @@ module OpenC3
           @logger.error "TriggerGroupManager failed to update topics.\n#{e.formatted}"
         end
         break if @cancel_thread
-
         block_for_updates()
         break if @cancel_thread
       end
@@ -503,7 +558,7 @@ module OpenC3
           Topic.read_topics(@topics) do |topic, _msg_id, msg_hash, _redis|
             @logger.debug "TriggerGroupManager block_for_updates: #{topic} #{msg_hash.to_s}"
             if topic != @share.trigger_base.autonomic_topic
-              packet = JSON.parse(msg_hash['json_data'], :allow_nan => true, :create_additions => true)
+              packet = JsonPacket.new(:TLM, msg_hash['target_name'], msg_hash['packet_name'], msg_hash['time'].to_i, false, msg_hash["json_data"])
               @share.packet_base.add(topic: topic, packet: packet)
             end
             @queue << "#{topic}"
@@ -533,10 +588,23 @@ module OpenC3
   # stream this will trigger an update again to the schedule.
   class TriggerGroupMicroservice < Microservice
     attr_reader :name, :scope, :share, :group, :manager, :manager_thread
+    # This lookup is mapping all the different trigger notifications
+    # which are primarily sent by notify in TriggerModel
+    TOPIC_LOOKUP = {
+      'error' => :no_op, # Sent by TriggerGroupWorker
+      'created' => :created_trigger_event,
+      'updated' => :rebuild_trigger_event,
+      'deleted' => :deleted_trigger_event,
+      'enabled' => :updated_trigger_event,
+      'disabled' => :updated_trigger_event,
+      'true' => :no_op, # Sent by TriggerGroupWorker
+      'false' => :no_op, # Sent by TriggerGroupWorker
+    }
 
     def initialize(*args)
       super(*args)
-      @group = TriggerGroupShare.get_group(name: @name)
+      # The name is passed in via the trigger_group_model as "#{scope}__TRIGGER_GROUP__#{name}"
+      @group = @name.split('__')[2]
       @share = TriggerGroupShare.new(scope: @scope)
       @manager = TriggerGroupManager.new(name: @name, logger: @logger, scope: @scope, group: @group, share: @share)
       @manager_thread = nil
@@ -548,36 +616,26 @@ module OpenC3
       @manager_thread = Thread.new { @manager.run }
       loop do
         triggers = TriggerModel.all(scope: @scope, group: @group)
-        @share.trigger_base.update(triggers: triggers)
+        @share.trigger_base.rebuild(triggers: triggers)
+        @manager.refresh() # Everytime we do a full base update we refesh the manager
         break if @cancel_thread
-
         block_for_updates()
         break if @cancel_thread
       end
       @logger.info "TriggerGroupMicroservice exiting"
     end
 
-    def topic_lookup_functions
-      return {
-        'created' => :created_trigger_event,
-        'updated' => :created_trigger_event,
-        'deleted' => :deleted_trigger_event,
-        'enabled' => :created_trigger_event,
-        'disabled' => :created_trigger_event,
-        'activated' => :created_trigger_event,
-        'deactivated' => :created_trigger_event,
-      }
-    end
-
     def block_for_updates
       @read_topic = true
-      while @read_topic
+      while @read_topic && !@cancel_thread
         begin
           AutonomicTopic.read_topics(@topics) do |_topic, _msg_id, msg_hash, _redis|
+            break if @cancel_thread
             @logger.debug "TriggerGroupMicroservice block_for_updates: #{msg_hash.to_s}"
+            # Process trigger notifications created by TriggerModel notify
             if msg_hash['type'] == 'trigger'
               data = JSON.parse(msg_hash['data'], :allow_nan => true, :create_additions => true)
-              public_send(topic_lookup_functions[msg_hash['kind']], data)
+              public_send(TOPIC_LOOKUP[msg_hash['kind']], data)
             end
           end
         rescue StandardError => e
@@ -590,11 +648,6 @@ module OpenC3
       @logger.debug "TriggerGroupMicroservice web socket event: #{data}"
     end
 
-    def refresh_event(data)
-      @logger.debug "TriggerGroupMicroservice web socket schedule refresh: #{data}"
-      @read_topic = false
-    end
-
     # Add the trigger to the share.
     def created_trigger_event(data)
       @logger.debug "TriggerGroupMicroservice created_trigger_event #{data}"
@@ -604,6 +657,23 @@ module OpenC3
       end
     end
 
+    def updated_trigger_event(data)
+      @logger.debug "TriggerGroupMicroservice updated_trigger_event #{data}"
+      if data['group'] == @group
+        @share.trigger_base.update(trigger: data)
+      end
+    end
+
+    # When a trigger is updated it could change items which modifies topics and
+    # potentially adds or removes topics so refresh everything just to be safe
+    def rebuild_trigger_event(data)
+      @logger.debug "TriggerGroupMicroservice rebuild_trigger_event #{data}"
+      if data['group'] == @group
+        @share.trigger_base.update(trigger: data)
+        @read_topic = false
+      end
+    end
+
     # Remove the trigger from the share.
     def deleted_trigger_event(data)
       @logger.debug "TriggerGroupMicroservice deleted_trigger_event #{data}"