Class: OpenC3::TriggerBase

Inherits:
Object show all
Defined in:
lib/openc3/microservices/trigger_group_microservice.rb

Overview

Stored in the TriggerGroupShare this should be a thread safe hash that triggers will be added, updated, and removed from.

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(scope:) ⇒ TriggerBase

Returns a new instance of TriggerBase.



84
85
86
87
88
89
90
91
 
# File 'lib/openc3/microservices/trigger_group_microservice.rb', line 84

def initialize(scope:)
  @scope = scope
  @autonomic_topic = "#{@scope}__openc3_autonomic".freeze
  @triggers_mutex = Mutex.new
  @triggers = Hash.new
  @lookup_mutex = Mutex.new
  @lookup = Hash.new
end

Instance Attribute Details

#autonomic_topic ⇒ Object (readonly)

Returns the value of attribute autonomic_topic.



82
83
84
 
# File 'lib/openc3/microservices/trigger_group_microservice.rb', line 82

def autonomic_topic
  @autonomic_topic
end

#triggers ⇒ Object (readonly)

Returns the value of attribute triggers.



82
83
84
 
# File 'lib/openc3/microservices/trigger_group_microservice.rb', line 82

def triggers
  @triggers
end

Instance Method Details

#add(trigger:) ⇒ Object

Add a trigger from TriggerBase, must only be called once per trigger



195
196
197
198
199
200
201
202
203
204
205
206
 
# File 'lib/openc3/microservices/trigger_group_microservice.rb', line 195

def add(trigger:)
  @triggers_mutex.synchronize do
    @triggers[trigger['name']] = Marshal.load( Marshal.dump(trigger) )
  end
  trigger = TriggerModel.from_json(trigger, name: trigger['name'], scope: trigger['scope'])
  @lookup_mutex.synchronize do
    trigger.generate_topics.each do | topic |
      @lookup[topic] ||= []
      @lookup[topic] << trigger.name
    end
  end
end

#enabled_triggers ⇒ Object

returns a Hash of ALL enabled Trigger objects



125
126
127
128
129
130
131
132
133
134
135
136
 
# File 'lib/openc3/microservices/trigger_group_microservice.rb', line 125

def enabled_triggers
  val = nil
  @triggers_mutex.synchronize do
    val = Marshal.load( Marshal.dump(@triggers) )
  end
  ret = Hash.new
  val.each do | name, data |
    trigger = TriggerModel.from_json(data, name: data['name'], scope: data['scope'])
    ret[name] = trigger if trigger.enabled
  end
  return ret
end

#get_triggers(topic:) ⇒ Object

Get triggers to evaluate based on the topic. If the topic is equal to the autonomic topic it will return only triggers with roots



96
97
98
99
100
101
102
 
# File 'lib/openc3/microservices/trigger_group_microservice.rb', line 96

def get_triggers(topic:)
  if @autonomic_topic == topic
    return triggers_with_roots()
  else
    return triggers_from(topic: topic)
  end
end

#rebuild(triggers:) ⇒ Object

Rebuild the database lookup of all triggers in the group



178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
 
# File 'lib/openc3/microservices/trigger_group_microservice.rb', line 178

def rebuild(triggers:)
  @triggers_mutex.synchronize do
    @triggers = Marshal.load( Marshal.dump(triggers) )
  end
  @lookup_mutex.synchronize do
    @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 |
        @lookup[topic] ||= []
        @lookup[topic] << trigger.name
      end
    end
  end
end

#remove(trigger:) ⇒ Object

remove a trigger from TriggerBase



218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
 
# File 'lib/openc3/microservices/trigger_group_microservice.rb', line 218

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
  @lookup_mutex.synchronize do
    topics.each do | topic |
      unless @lookup[topic].nil?
        @lookup[topic].delete(trigger['name'])
        @lookup.delete(topic) if @lookup[topic].empty?
      end
    end
  end
end

#topics ⇒ Object

get all topics group is working with



171
172
173
174
175
 
# File 'lib/openc3/microservices/trigger_group_microservice.rb', line 171

def topics
  @lookup_mutex.synchronize do
    return Marshal.load( Marshal.dump(@lookup.keys()) )
  end
end

#triggers_from(topic:) ⇒ Object

returns an Array of enabled Trigger objects that use a topic



153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
 
# File 'lib/openc3/microservices/trigger_group_microservice.rb', line 153

def triggers_from(topic:)
  val = nil
  @lookup_mutex.synchronize do
    val = Marshal.load( Marshal.dump(@lookup[topic]) )
  end
  return [] if val.nil?
  ret = []
  @triggers_mutex.synchronize do
    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.enabled
    end
  end
  return ret
end

#triggers_with_roots ⇒ Object

returns an Array of enabled Trigger objects that have roots to other triggers



139
140
141
142
143
144
145
146
147
148
149
150
 
# File 'lib/openc3/microservices/trigger_group_microservice.rb', line 139

def triggers_with_roots
  val = nil
  @triggers_mutex.synchronize do
    val = Marshal.load( Marshal.dump(@triggers) )
  end
  ret = []
  val.each do | _name, data |
    trigger = TriggerModel.from_json(data, name: data['name'], scope: data['scope'])
    ret << trigger if trigger.enabled && ! trigger.roots.empty?
  end
  return ret
end

#update(trigger:) ⇒ Object

update a trigger from TriggerBase



209
210
211
212
213
214
215
 
# File 'lib/openc3/microservices/trigger_group_microservice.rb', line 209

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

#update_state(name:, value:) ⇒ Object

update trigger state after evaluated -1 (the value is considered an error used to disable the trigger)

0 (the value is considered as a false value)
1 (the value is considered as a true value)



108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
 
# File 'lib/openc3/microservices/trigger_group_microservice.rb', line 108

def update_state(name:, value:)
  @triggers_mutex.synchronize do
    data = @triggers[name]
    return unless data
    trigger = TriggerModel.from_json(data, name: data['name'], scope: data['scope'])
    if value == -1 && trigger.enabled
      trigger.disable()
    elsif value == 1 && trigger.state == false
      trigger.state = true
    elsif value == 0 && trigger.state == true
      trigger.state = false
    end
    @triggers[name] = trigger.as_json(:allow_nan => true)
  end
end