openc3 5.1.1 → 5.2.0

data/lib/openc3/operators/microservice_operator.rb

@@ -17,7 +17,7 @@
 # All changes Copyright 2022, OpenC3, Inc.
 # All Rights Reserved
 #
-# This file may also be used under the terms of a commercial license 
+# This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
 require 'openc3'
@@ -64,27 +64,65 @@ module OpenC3
       # Detect new and changed microservices
       @new_microservices = {}
       @changed_microservices = {}
+      @removed_microservices = {}
       @microservices.each do |microservice_name, microservice_config|
+        parent = microservice_config['parent']
         if @previous_microservices[microservice_name]
+          previous_parent = @previous_microservices[microservice_name]['parent']
           if @previous_microservices[microservice_name] != microservice_config
+            # CHANGED
             scope = microservice_name.split("__")[0]
             Logger.info("Changed microservice detected: #{microservice_name}\nWas: #{@previous_microservices[microservice_name]}\nIs: #{microservice_config}", scope: scope)
-            @changed_microservices[microservice_name] = microservice_config
+            if parent or previous_parent
+              if parent == previous_parent
+                # Same Parent - Respawn parent
+                @changed_microservices[parent] = @microservices[parent] if @microservices[parent] and @previous_microservices[parent]
+              elsif parent and previous_parent
+                # Parent changed - Respawn both parents
+                @changed_microservices[parent] = @microservices[parent] if @microservices[parent] and @previous_microservices[parent]
+                @changed_microservices[previous_parent] = @microservices[previous_parent] if @microservices[previous_parent] and @previous_microservices[previous_parent]
+              elsif parent
+                # Moved under a parent - Respawn parent and kill standalone
+                @changed_microservices[parent] = @microservices[parent] if @microservices[parent] and @previous_microservices[parent]
+                @removed_microservices[microservice_name] = microservice_config
+              else # previous_parent
+                # Moved to standalone - Respawn previous parent and make new
+                @changed_microservices[previous_parent] = @microservices[previous_parent] if @microservices[previous_parent] and @previous_microservices[previous_parent]
+                @new_microservices[microservice_name] = microservice_config
+              end
+            else
+              # Respawn regular microservice
+              @changed_microservices[microservice_name] = microservice_config
+            end
           end
         else
+          # NEW
           scope = microservice_name.split("__")[0]
           Logger.info("New microservice detected: #{microservice_name}", scope: scope)
-          @new_microservices[microservice_name] = microservice_config
+          if parent
+            # Respawn parent
+            @changed_microservices[parent] = @microservices[parent] if @microservices[parent] and @previous_microservices[parent]
+          else
+            # New process be spawned
+            @new_microservices[microservice_name] = microservice_config
+          end
         end
       end
 
       # Detect removed microservices
-      @removed_microservices = {}
       @previous_microservices.each do |microservice_name, microservice_config|
+        previous_parent = microservice_config['parent']
         unless @microservices[microservice_name]
+          # REMOVED
           scope = microservice_name.split("__")[0]
           Logger.info("Removed microservice detected: #{microservice_name}", scope: scope)
-          @removed_microservices[microservice_name] = microservice_config
+          if previous_parent
+            # Respawn previous parent
+            @changed_microservices[previous_parent] = @microservices[previous_parent] if @microservices[previous_parent] and @previous_microservices[previous_parent]
+          else
+            # Regular process to be removed
+            @removed_microservices[microservice_name] = microservice_config
+          end
         end
       end
 
@@ -109,7 +147,8 @@ module OpenC3
               process.new_temp_dir = nil
               process.env = env
               @changed_processes[microservice_name] = process
-            else # TODO: How is this even possible?
+            else
+              # This shouldn't be possible, but still needs to be handled
               Logger.error("Changed microservice #{microservice_name} does not exist. Creating new...", scope: scope)
               process = OperatorProcess.new(cmd_array, work_dir: work_dir, env: env, scope: scope, container: container, config: microservice_config)
               @new_processes[microservice_name] = process

data/lib/openc3/operators/operator.rb

@@ -225,12 +225,11 @@ module OpenC3
     @@instance = nil
 
     CYCLE_TIME = 5.0 # cycle time to check for new microservices
+    PROCESS_SHUTDOWN_SECONDS = 5.0
 
     def initialize
       Logger.level = Logger::INFO
-      # TODO: This is pretty generic. Can we pass in more information to help identify the operator?
       Logger.microservice_name = 'MicroserviceOperator'
-      Logger.tag = "operator.log"
 
       OperatorProcess.setup()
       @cycle_time = (ENV['OPERATOR_CYCLE_TIME'] and ENV['OPERATOR_CYCLE_TIME'].to_f) || CYCLE_TIME # time in seconds
@@ -305,9 +304,31 @@ module OpenC3
     end
 
     def shutdown_processes(processes)
+      Logger.info("Commanding soft stops...")
       processes.each { |name, p| p.soft_stop }
-      sleep(4) # TODO: This is an arbitrary sleep of 4s ...
-      processes.each { |name, p| p.hard_stop }
+      start_time = Time.now
+      # Allow sufficient time for processes to shutdown cleanly
+      while (Time.now - start_time) < PROCESS_SHUTDOWN_SECONDS
+        processes_to_remove = []
+        processes.each do |name, p|
+          unless p.alive?
+            processes_to_remove << name
+            Logger.info("Soft stop process successful: #{p.cmd_line}", scope: p.scope)
+          end
+        end
+        processes_to_remove.each do |name|
+          processes.delete(name)
+        end
+        if processes.length <= 0
+          Logger.info("Soft stop all successful")
+          break
+        end
+        sleep(0.1)
+      end
+      if processes.length > 0
+        Logger.info("Commanding hard stops...")
+        processes.each { |name, p| p.hard_stop }
+      end
     end
 
     def run
@@ -317,6 +338,7 @@ module OpenC3
         @mutex.synchronize do
           Logger.info("Shutting down processes...")
           shutdown_processes(@processes)
+          Logger.info("Shutting down processes complete")
           @shutdown_complete = true
         end
       end
@@ -337,7 +359,7 @@ module OpenC3
 
       loop do
         break if @shutdown_complete
-        sleep(1)
+        sleep(0.1)
       end
     ensure
       Logger.info("#{self.class} shutdown complete")

data/lib/openc3/packets/commands.rb

@@ -17,7 +17,7 @@
 # All changes Copyright 2022, OpenC3, Inc.
 # All Rights Reserved
 #
-# This file may also be used under the terms of a commercial license 
+# This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
 require 'openc3/packets/packet_config'
@@ -297,30 +297,6 @@ module OpenC3
       end
     end
 
-    # Returns an array with a "TARGET_NAME PACKET_NAME" string for every command in the system (PACKET_NAME == command name)
-    def all_packet_strings(include_hidden = false, splash = nil)
-      strings = []
-      tnames = target_names()
-      total = tnames.length.to_f
-      tnames.each_with_index do |target_name, index|
-        if splash
-          splash.message = "Processing #{target_name} command"
-          splash.progress = index / total
-        end
-
-        # TODO: This wasn't being used ... should it be
-        # ignored_items = System.targets[target_name].ignored_items
-
-        packets(target_name).each do |command_name, packet|
-          # We don't audit against hidden or disabled packets/commands
-          next if !include_hidden and (packet.hidden || packet.disabled)
-
-          strings << "#{target_name} #{command_name}"
-        end
-      end
-      strings
-    end
-
     def all
       @config.commands
     end

data/lib/openc3/packets/limits.rb

@@ -62,86 +62,11 @@ module OpenC3
       return items
     end
 
-    # @param ignored_items [Array<Array<String, String, String>>] Items to ignore from the consideration
-    # @return [Symbol] The overall limits state for the system
-    def overall_limits_state(ignored_items = nil)
-      overall = :GREEN
-      limits_packet_stale = false
-      items_out_of_limits = []
-      # Note: If anything with limits is stale then overall limits state cannot be green or blue
-      @config.telemetry.each do |target_name, target_packets|
-        target_packets.each do |packet_name, packet|
-          if packet.stale && !packet.limits_items.empty?
-            if ignored_items
-              all_ignored = true
-              packet.limits_items.each do |item|
-                all_ignored = false unless includes_item?(ignored_items, target_name, packet_name, item.name)
-              end
-            else
-              all_ignored = false
-            end
-            limits_packet_stale = true unless all_ignored
-          end
-          items_out_of_limits.concat(packet.out_of_limits)
-        end
-      end
-      items_out_of_limits.each do |target_name, packet_name, item_name, limits_state|
-        next if ignored_items && includes_item?(ignored_items, target_name, packet_name, item_name)
-
-        case overall
-        # If our overall state is currently blue or green we can go to any state
-        when :BLUE, :GREEN, :GREEN_HIGH, :GREEN_LOW
-          overall = limits_state
-        # If our overal state is yellow we can only go higher to red
-        when :YELLOW, :YELLOW_HIGH, :YELLOW_LOW
-          if limits_state == :RED || limits_state == :RED_HIGH || limits_state == :RED_LOW
-            overall = limits_state
-            break # Red is as high as we go so no need to look for more
-          end
-        end
-      end
-      overall = :GREEN if overall == :GREEN_HIGH || overall == :GREEN_LOW || overall == :BLUE
-      overall = :YELLOW if overall == :YELLOW_HIGH || overall == :YELLOW_LOW
-      overall = :RED if overall == :RED_HIGH || overall == :RED_LOW
-      overall = :STALE if (overall == :GREEN || overall == :BLUE) && limits_packet_stale
-      return overall
-    end
-
     # @return [Hash(String, Array)] The defined limits groups
     def groups
       return @config.limits_groups
     end
 
-    # Enables limit checking for all the items in the given group.
-    #
-    # @param group_name [String] Name of the group to enable
-    def enable_group(group_name)
-      group_upcase = group_name.to_s.upcase
-      limits_group = @config.limits_groups[group_upcase]
-      if limits_group
-        limits_group.each do |target_name, packet_name, item_name|
-          enable(target_name, packet_name, item_name)
-        end
-      else
-        raise "LIMITS_GROUP #{group_upcase} undefined. Ensure your telemetry definition contains the line: LIMITS_GROUP #{group_upcase}"
-      end
-    end
-
-    # Disables limit checking for all the items in the given group.
-    #
-    # @param group_name [String] Name of the group to disable
-    def disable_group(group_name)
-      group_upcase = group_name.to_s.upcase
-      limits_group = @config.limits_groups[group_upcase]
-      if limits_group
-        limits_group.each do |target_name, packet_name, item_name|
-          disable(target_name, packet_name, item_name)
-        end
-      else
-        raise "LIMITS_GROUP #{group_upcase} undefined. Ensure your telemetry definition contains the line: LIMITS_GROUP #{group_upcase}"
-      end
-    end
-
     # Checks whether the limits are enabled for the specified item
     #
     # @param target_name [String] The target name

data/lib/openc3/packets/packet.rb

@@ -62,9 +62,6 @@ module OpenC3
     # @return [Hash<Item Name, Value>] Given values when constructing the packet
     attr_reader :given_values
 
-    # @return [Boolean] Flag indicating if the packet is stale (hasn't been received recently)
-    attr_reader :stale
-
     # @return [Boolean] Whether or not this is a 'raw' packet
     attr_accessor :raw
 
@@ -119,7 +116,6 @@ module OpenC3
         @given_values = nil
         @limits_items = nil
         @processors = nil
-        @stale = true
         @limits_change_callback = nil
         @read_conversion_cache = nil
         @raw = nil
@@ -896,13 +892,6 @@ module OpenC3
       return items
     end
 
-    # Set the limits state for all items to the given state
-    #
-    # @param state [Symbol] Must be one of PacketItemLimits::LIMITS_STATES
-    def set_all_limits_states(state)
-      @sorted_items.each { |item| item.limits.state = state }
-    end
-
     # Check all the items in the packet against their defined limits. Update
     # their internal limits state and persistence and call the
     # limits_change_callback as necessary.
@@ -912,14 +901,6 @@ module OpenC3
     # @param ignore_persistence [Boolean] Whether to ignore persistence when
     #   checking for out of limits
     def check_limits(limits_set = :DEFAULT, ignore_persistence = false)
-      # If check_limits is being called, then a new packet has arrived and
-      # this packet is no longer stale
-      # Stored telemetry doesn't affect the current value table and such doesn't affect stale
-      if @stale and !@stored
-        @stale = false
-        set_all_limits_states(nil)
-      end
-
       return unless @limits_items
 
       @limits_items.each do |item|
@@ -937,13 +918,6 @@ module OpenC3
       end
     end
 
-    # Sets the overall packet stale state to true and sets each packet item
-    # limits state to :STALE.
-    def set_stale
-      @stale = true
-      set_all_limits_states(:STALE)
-    end
-
     # Reset temporary packet data
     # This includes packet received time, received count, and processor state
     def reset
@@ -1063,7 +1037,6 @@ module OpenC3
       config['messages_disabled'] = true if @messages_disabled
       config['disabled'] = true if @disabled
       config['hidden'] = true if @hidden
-      config['stale'] = true if @stale
       config['accessor'] = @accessor.to_s
       config['template'] = Base64.encode64(@template) if @template
 
@@ -1103,7 +1076,6 @@ module OpenC3
       packet.messages_disabled = hash['messages_disabled']
       packet.disabled = hash['disabled']
       packet.hidden = hash['hidden']
-      # packet.stale is read only
       if hash['accessor']
         begin
           packet.accessor = OpenC3::const_get(hash['accessor'])

data/lib/openc3/packets/packet_item.rb

@@ -78,6 +78,10 @@ module OpenC3
     #   description was given the value will be nil.
     attr_reader :hazardous
 
+    # @return [Hash] Whether or not messages should be printed for this state.
+    #   Given as STATE_NAME => true / false.
+    attr_accessor :messages_disabled
+
     # Colors associated with states
     # @return [Hash] State colors given as STATE_NAME => COLOR
     attr_reader :state_colors
@@ -104,6 +108,7 @@ module OpenC3
       @range = nil
       @required = false
       @hazardous = nil
+      @messages_disabled = nil
       @state_colors = nil
       @limits = PacketItemLimits.new
       @persistence_setting = 1
@@ -250,6 +255,16 @@ module OpenC3
       end
     end
 
+    def messages_disabled=(messages_disabled)
+      if messages_disabled
+        raise ArgumentError, "#{@name}: messages_disabled must be a Hash but is a #{messages_disabled.class}" unless Hash === messages_disabled
+
+        @messages_disabled = messages_disabled.clone
+      else
+        @messages_disabled = nil
+      end
+    end
+
     def state_colors=(state_colors)
       if state_colors
         raise ArgumentError, "#{@name}: state_colors must be a Hash but is a #{state_colors.class}" unless Hash === state_colors
@@ -296,6 +311,7 @@ module OpenC3
       item.units = self.units.clone if self.units
       item.default = self.default.clone if self.default and String === self.default
       item.hazardous = self.hazardous.clone if self.hazardous
+      item.messages_disabled = self.messages_disabled.clone if self.messages_disabled
       item.state_colors = self.state_colors.clone if self.state_colors
       item.limits = self.limits.clone if self.limits
       item.meta = self.meta.clone if @meta
@@ -325,6 +341,7 @@ module OpenC3
       hash['range'] = self.range
       hash['required'] = self.required
       hash['hazardous'] = self.hazardous
+      hash['messages_disabled'] = self.messages_disabled
       hash['state_colors'] = self.state_colors
       hash['limits'] = self.limits.to_hash
       hash['meta'] = nil
@@ -394,6 +411,9 @@ module OpenC3
           if @hazardous and @hazardous[state_name]
             config << " HAZARDOUS #{@hazardous[state_name].to_s.quote_if_necessary}"
           end
+          if @messages_disabled and @messages_disabled[state_name]
+            config << " DISABLE_MESSAGES"
+          end
           if @state_colors and @state_colors[state_name]
             config << " #{@state_colors[state_name]}"
           end
@@ -459,6 +479,7 @@ module OpenC3
           states[state_name] = state
           state['value'] = state_value.as_json(*a)
           state['hazardous'] = @hazardous[state_name] if @hazardous and @hazardous[state_name]
+          state['messages_disabled'] = @messages_disabled[state_name] if @messages_disabled and @messages_disabled[state_name]
           state['color'] = @state_colors[state_name].to_s if @state_colors and @state_colors[state_name]
         end
       end
@@ -509,10 +530,12 @@ module OpenC3
       if hash['states']
         item.states = {}
         item.hazardous = {}
+        item.messages_disabled = {}
         item.state_colors = {}
         hash['states'].each do |state_name, state|
           item.states[state_name] = state['value']
           item.hazardous[state_name] = state['hazardous']
+          item.messages_disabled[state_name] = state['messages_disabled']
           item.state_colors[state_name] = state['color'].to_sym if state['color']
         end
       end

data/lib/openc3/packets/packet_item_limits.rb

@@ -17,7 +17,7 @@
 # All changes Copyright 2022, OpenC3, Inc.
 # All Rights Reserved
 #
-# This file may also be used under the terms of a commercial license 
+# This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
 require 'openc3/packets/limits_response'
@@ -71,7 +71,7 @@ module OpenC3
     def initialize
       @values = nil
       @enabled = false
-      @state = :STALE
+      @state = nil
       @response = nil
       @persistence_setting = 1
       @persistence_count = 0

data/lib/openc3/packets/parsers/state_parser.rb

@@ -17,7 +17,7 @@
 # All changes Copyright 2022, OpenC3, Inc.
 # All Rights Reserved
 #
-# This file may also be used under the terms of a commercial license 
+# This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
 require 'openc3/packets/packet_item'
@@ -48,7 +48,7 @@ module OpenC3
     def verify_parameters(cmd_or_tlm)
       @usage = "STATE <STATE NAME> <STATE VALUE> "
       if cmd_or_tlm == PacketConfig::COMMAND
-        @usage << "<HAZARDOUS (Optional)> <Hazardous Description (Optional)>"
+        @usage << "<HAZARDOUS / DISABLE_MESSAGES (Optional)> <Hazardous Description (Optional)>"
         @parser.verify_num_parameters(2, 4, @usage)
       else
         @usage << "<COLOR: GREEN/YELLOW/RED (Optional)>"
@@ -96,23 +96,27 @@ module OpenC3
       return unless @parser.parameters.length > 2
 
       if cmd_or_tlm == PacketConfig::COMMAND
-        get_hazardous(item)
+        get_hazardous_or_disable_messages(item)
       else
         get_state_colors(item)
         packet.update_limits_items_cache(item)
       end
     end
 
-    def get_hazardous(item)
-      if @parser.parameters[2].upcase == 'HAZARDOUS'
+    def get_hazardous_or_disable_messages(item)
+      case @parser.parameters[2].upcase
+      when 'HAZARDOUS'
         item.hazardous ||= {}
         if @parser.parameters[3]
           item.hazardous[get_state_name()] = @parser.parameters[3]
         else
           item.hazardous[get_state_name()] = ""
         end
+      when 'DISABLE_MESSAGES'
+        item.messages_disabled ||= {}
+        item.messages_disabled[get_state_name()] = true
       else
-        raise @parser.error("HAZARDOUS expected as third parameter for this line.", @usage)
+        raise @parser.error("HAZARDOUS or DISABLE_MESSAGES expected as third parameter for this line.", @usage)
       end
     end
 

data/lib/openc3/packets/telemetry.rb

@@ -17,7 +17,7 @@
 # All changes Copyright 2022, OpenC3, Inc.
 # All Rights Reserved
 #
-# This file may also be used under the terms of a commercial license 
+# This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
 require 'openc3/packets/packet_config'
@@ -372,50 +372,6 @@ module OpenC3
       end
     end
 
-    # Iterates through all the telemetry packets and marks them stale if they
-    # haven't been received for over the System.staleness_seconds value.
-    #
-    # @return [Array(Packet)] Array of the stale packets
-    def check_stale
-      stale = []
-      time = Time.now.sys
-      @config.telemetry.each do |target_name, target_packets|
-        target_packets.each do |packet_name, packet|
-          if packet.received_time and (!packet.stale) and (time - packet.received_time > System.staleness_seconds)
-            packet.set_stale
-            stale << packet
-          end
-        end
-      end
-      stale
-    end
-
-    # @param with_limits_only [Boolean] Return only the stale packets
-    #   that have limits items and thus affect the overall limits
-    #   state of the system
-    # @param target [String] Target name or nil for all targets
-    # @return [Array(Packet)] Array of the stale packets
-    def stale(with_limits_only = false, target = nil)
-      if target && !target_names.include?(target)
-        raise "Telemetry target '#{target.upcase}' does not exist"
-      end
-
-      stale = []
-      @config.telemetry.each do |target_name, target_packets|
-        next if target && target != target_name
-        next if target_name == 'UNKNOWN'
-
-        target_packets.each do |packet_name, packet|
-          if packet.stale
-            next if with_limits_only && packet.limits_items.empty?
-
-            stale << packet
-          end
-        end
-      end
-      stale
-    end
-
     # Clears the received_count value on every packet in every target
     def clear_counters
       @config.telemetry.each do |target_name, target_packets|