openc3 5.11.3 → 5.12.0

data/lib/openc3/api/tlm_api.rb

@@ -67,22 +67,19 @@ module OpenC3
     # @param type [Symbol] Telemetry type, :RAW, :CONVERTED (default), :FORMATTED, or :WITH_UNITS
     # @return [Object] The telemetry value formatted as requested
     def tlm(*args, type: :CONVERTED, cache_timeout: 0.1, scope: $openc3_scope, token: $openc3_token)
-      target_name, packet_name, item_name = tlm_process_args(args, 'tlm', cache_timeout: cache_timeout, scope: scope)
+      target_name, packet_name, item_name = _tlm_process_args(args, 'tlm', cache_timeout: cache_timeout, scope: scope)
       authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
       CvtModel.get_item(target_name, packet_name, item_name, type: type.intern, cache_timeout: cache_timeout, scope: scope)
     end
 
-    # @deprecated Use tlm with type: :RAW
     def tlm_raw(*args, cache_timeout: 0.1, scope: $openc3_scope, token: $openc3_token)
       tlm(*args, type: :RAW, cache_timeout: cache_timeout, scope: scope, token: token)
     end
 
-    # @deprecated Use tlm with type: :FORMATTED
     def tlm_formatted(*args, cache_timeout: 0.1, scope: $openc3_scope, token: $openc3_token)
       tlm(*args, type: :FORMATTED, cache_timeout: cache_timeout, scope: scope, token: token)
     end
 
-    # @deprecated Use tlm with type: :WITH_UNITS
     def tlm_with_units(*args, cache_timeout: 0.1, scope: $openc3_scope, token: $openc3_token)
       tlm(*args, type: :WITH_UNITS, cache_timeout: cache_timeout, scope: scope, token: token)
     end
@@ -108,7 +105,7 @@ module OpenC3
     # @param args [String|Array<String>] See the description for calling style
     # @param type [Symbol] Telemetry type, :RAW, :CONVERTED (default), :FORMATTED, or :WITH_UNITS
     def set_tlm(*args, type: :CONVERTED, scope: $openc3_scope, token: $openc3_token)
-      target_name, packet_name, item_name, value = set_tlm_process_args(args, __method__, scope: scope)
+      target_name, packet_name, item_name, value = _set_tlm_process_args(args, __method__, scope: scope)
       authorize(permission: 'tlm_set', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
       CvtModel.set_item(target_name, packet_name, item_name, value, type: type.intern, scope: scope)
     end
@@ -169,7 +166,7 @@ module OpenC3
     #   description).
     # @param type [Symbol] Telemetry type, :ALL (default), :RAW, :CONVERTED, :FORMATTED, :WITH_UNITS
     def override_tlm(*args, type: :ALL, scope: $openc3_scope, token: $openc3_token)
-      target_name, packet_name, item_name, value = set_tlm_process_args(args, __method__, scope: scope)
+      target_name, packet_name, item_name, value = _set_tlm_process_args(args, __method__, scope: scope)
       authorize(permission: 'tlm_set', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
       CvtModel.override(target_name, packet_name, item_name, value, type: type.intern, scope: scope)
     end
@@ -194,7 +191,7 @@ module OpenC3
     # @param type [Symbol] Telemetry type, :ALL (default), :RAW, :CONVERTED, :FORMATTED, :WITH_UNITS
     #   Also takes :ALL which means to normalize all telemetry types
     def normalize_tlm(*args, type: :ALL, scope: $openc3_scope, token: $openc3_token)
-      target_name, packet_name, item_name = tlm_process_args(args, __method__, scope: scope)
+      target_name, packet_name, item_name = _tlm_process_args(args, __method__, scope: scope)
       authorize(permission: 'tlm_set', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
       CvtModel.normalize(target_name, packet_name, item_name, type: type.intern, scope: scope)
     end
@@ -389,7 +386,7 @@ module OpenC3
     # Get the transmit counts for telemetry packets
     #
     # @param target_packets [Array<Array<String, String>>] Array of arrays containing target_name, packet_name
-    # @return [Numeric] Transmit count for the command
+    # @return [Array<Numeric>] Receive count for the telemetry packets
     def get_tlm_cnts(target_packets, scope: $openc3_scope, token: $openc3_token)
       authorize(permission: 'system', scope: scope, token: token)
       counts = []
@@ -430,7 +427,7 @@ module OpenC3
       return nil
     end
 
-    def tlm_process_args(args, method_name, cache_timeout: 0.1, scope: $openc3_scope, token: $openc3_token)
+    def _tlm_process_args(args, method_name, cache_timeout: 0.1, scope: $openc3_scope, token: $openc3_token)
       case args.length
       when 1
         target_name, packet_name, item_name = extract_fields_from_tlm_text(args[0])
@@ -456,7 +453,7 @@ module OpenC3
       return [target_name, packet_name, item_name]
     end
 
-    def set_tlm_process_args(args, method_name, scope: $openc3_scope, token: $openc3_token)
+    def _set_tlm_process_args(args, method_name, scope: $openc3_scope, token: $openc3_token)
       case args.length
       when 1
         target_name, packet_name, item_name, value = extract_fields_from_set_tlm_text(args[0])

data/lib/openc3/conversions/unix_time_conversion.rb

@@ -31,30 +31,32 @@ module OpenC3
     #   represents the number of seconds since the UNIX time epoch
     # @param microseconds_item_name [String] The telemetry item in the packet
     #   which represents microseconds
-    def initialize(seconds_item_name, microseconds_item_name = nil)
+    def initialize(seconds_item_name, microseconds_item_name = nil, seconds_type = 'RAW', microseconds_type = 'RAW')
       super()
       @seconds_item_name = seconds_item_name
       @microseconds_item_name = microseconds_item_name
       @converted_type = :RUBY_TIME
       @converted_bit_size = 0
+      @seconds_type = seconds_type.to_sym
+      @microseconds_type = microseconds_type.to_sym
     end
 
     # @param (see Conversion#call)
     # @return [Float] Packet time in seconds since UNIX epoch
     def call(value, packet, buffer)
       if @microseconds_item_name
-        return Time.at(packet.read(@seconds_item_name, :RAW, buffer), packet.read(@microseconds_item_name, :RAW, buffer)).sys
+        return Time.at(packet.read(@seconds_item_name, @seconds_type, buffer), packet.read(@microseconds_item_name, @microseconds_type, buffer)).sys
       else
-        return Time.at(packet.read(@seconds_item_name, :RAW, buffer), 0).sys
+        return Time.at(packet.read(@seconds_item_name, @seconds_type, buffer), 0).sys
       end
     end
 
     # @return [String] The name of the class followed by the time conversion
     def to_s
       if @microseconds_item_name
-        return "Time.at(packet.read('#{@seconds_item_name}', :RAW, buffer), packet.read('#{@microseconds_item_name}', :RAW, buffer)).sys"
+        return "Time.at(packet.read('#{@seconds_item_name}', :#{@seconds_type}, buffer), packet.read('#{@microseconds_item_name}', :#{@microseconds_type}, buffer)).sys"
       else
-        return "Time.at(packet.read('#{@seconds_item_name}', :RAW, buffer), 0).sys"
+        return "Time.at(packet.read('#{@seconds_item_name}', :#{@seconds_type}, buffer), 0).sys"
       end
     end
 
@@ -66,7 +68,7 @@ module OpenC3
 
     def as_json(*a)
       result = super(*a)
-      result['params'] = [@seconds_item_name, @microseconds_item_name]
+      result['params'] = [@seconds_item_name, @microseconds_item_name, @seconds_type, @microseconds_type]
       result
     end
   end # class UnixTimeConversion

data/lib/openc3/interfaces/tcpip_server_interface.rb

@@ -500,13 +500,6 @@ module OpenC3
       write_to_clients(:write_raw, data) if data
     end
 
-    def interface_disconnect(interface_info)
-      Logger.info "#{@name}: Tcpip server lost write connection to "\
-                           "#{interface_info.hostname}(#{interface_info.host_ip}):#{interface_info.port}"
-      interface_info.interface.disconnect
-      interface_info.interface.stream_log_pair.stop if interface_info.interface.stream_log_pair
-    end
-
     def write_thread_hook(packet)
       packet # By default just return the packet
     end

data/lib/openc3/io/json_drb.rb

@@ -28,7 +28,8 @@ require 'drb/drb'
 require 'set'
 require 'openc3/io/json_rpc'
 require 'openc3/io/json_drb_rack'
-require 'rack/handler/puma'
+require 'rackup'
+require 'puma'
 
 # Add methods to the Puma::Launcher and Puma::Single class so we can tell
 # if the server has been started.
@@ -150,7 +151,7 @@ module OpenC3
           }
 
           # The run call will block until the server is stopped.
-          Rack::Handler::Puma.run(JsonDrbRack.new(self), server_config) do |server|
+          Rackup::Handler::Puma.run(JsonDrbRack.new(self), server_config) do |server|
             @server_mutex.synchronize do
               @server = server
             end

data/lib/openc3/io/json_rpc.rb

@@ -36,9 +36,9 @@ end
 
 class Struct #:nodoc:
   def as_json(options = nil)
-    pairs = []
-    self.each_pair { |k, v| pairs << k.to_s; pairs << v.as_json(options) }
-    Hash[*pairs]
+    hash = {}
+    self.each_pair { |k, v| hash[k.to_s] = v.as_json(options) }
+    hash
   end
 end
 
@@ -115,9 +115,9 @@ end
 
 class Hash
   def as_json(options = nil) #:nodoc:
-    pairs = []
-    self.each { |k, v| pairs << k.to_s; pairs << v.as_json(options) }
-    Hash[*pairs]
+    hash = {}
+    self.each {|k,v| hash[k.to_s] = v.as_json(options) }
+    hash
   end
 end
 

data/lib/openc3/logs/buffered_packet_log_writer.rb

@@ -44,7 +44,8 @@ module OpenC3
       cycle_hour = nil,
       cycle_minute = nil,
       enforce_time_order = true,
-      buffer_depth = 60 # Default assumes 1 minute of 1Hz data
+      buffer_depth = 60, # Default assumes 1 minute of 1Hz data
+      scope: $openc3_scope
     )
       super(
         remote_log_directory,
@@ -54,7 +55,8 @@ module OpenC3
         cycle_size,
         cycle_hour,
         cycle_minute,
-        enforce_time_order
+        enforce_time_order,
+        scope: scope
       )
       @buffer_depth = Integer(buffer_depth)
       @buffer = []

data/lib/openc3/logs/packet_log_writer.rb

@@ -22,6 +22,7 @@
 
 require 'openc3/logs/log_writer'
 require 'openc3/logs/packet_log_constants'
+require 'openc3/models/target_model'
 require 'cbor'
 
 module OpenC3
@@ -52,7 +53,8 @@ module OpenC3
       cycle_size = 1_000_000_000,
       cycle_hour = nil,
       cycle_minute = nil,
-      enforce_time_order = true
+      enforce_time_order = true,
+      scope: $openc3_scope
     )
       super(
         remote_log_directory,
@@ -73,6 +75,9 @@ module OpenC3
       @target_indexes = {}
       @next_target_index = 0
       @data_format = :CBOR # Default to CBOR for improved compression
+      @target_id_cache = {}
+      @packet_id_cache = {}
+      @scope = scope
     end
 
     # Write a packet to the log file.
@@ -171,8 +176,14 @@ module OpenC3
           @tlm_packet_table[target_name] = target_table
         end
         id = nil
-        target = System.targets[target_name]
-        id = target.id if target
+        unless ENV['OPENC3_NO_STORE']
+          id = @target_id_cache[target_name]
+          unless id
+            target = TargetModel.get(name: target_name, scope: @scope)
+            id = target["id"] if target
+            @target_id_cache[target_name] = id
+          end
+        end
         write_entry(:TARGET_DECLARATION, cmd_or_tlm, target_name, packet_name, nil, nil, nil, id)
       end
 
@@ -187,10 +198,14 @@ module OpenC3
 
       id = nil
       begin
-        if cmd_or_tlm == :CMD
-          id = System.commands.packet(target_nam, packet_name).config_name
-        else
-          id = System.telemetry.packet(target_name, packet_name).config_name
+        unless ENV['OPENC3_NO_STORE']
+          cache_key = "#{cmd_or_tlm}__#{target_name}__#{packet_name}"
+          id = @packet_id_cache[cache_key]
+          unless id
+            target_model_packet = TargetModel.packet(target_name, packet_name, type: cmd_or_tlm, scope: @scope)
+            id = target_model_packet["config_name"] if target_model_packet
+            @packet_id_cache[cache_key] = id
+          end
         end
       rescue
         # No packet def

data/lib/openc3/microservices/cleanup_microservice.rb

@@ -49,7 +49,14 @@ module OpenC3
           if oldest_list.length > 0
             @state = 'DELETING_OBJECTS'
             oldest_list.each_slice(1000) do |slice|
-              bucket.delete_objects(bucket: ENV['OPENC3_LOGS_BUCKET'], keys: slice)
+              # The delete_objects function utilizes an MD5 hash when verifying the checksums, which is not
+              # FIPS compliant (https://github.com/aws/aws-sdk-ruby/issues/2645).
+              # delete_object does NOT require an MD5 hash and will work on FIPS compliant systems. It is
+              # probably less performant, but we can instead delete each item one at a time.
+              # bucket.delete_objects(bucket: ENV['OPENC3_LOGS_BUCKET'], keys: slice)
+              slice.each do |item|
+                bucket.delete_object(bucket: ENV['OPENC3_LOGS_BUCKET'], key: item)
+              end
               @logger.debug("Cleanup deleted #{slice.length} log files")
               @delete_count += slice.length
               @metric.set(name: 'cleanup_delete_total', value: @delete_count, type: 'counter')

data/lib/openc3/microservices/decom_microservice.rb

@@ -34,7 +34,7 @@ module OpenC3
       # Should only be one target, but there might be multiple decom microservices for a given target
       # First Decom microservice has no number in the name
       if @name =~ /__DECOM__/
-        @topics << "#{scope}__DECOMINTERFACE__{#{@target_names[0]}}"
+        @topics << "#{@scope}__DECOMINTERFACE__{#{@target_names[0]}}"
       end
       Topic.update_topic_offsets(@topics)
       System.telemetry.limits_change_callback = method(:limits_change_callback)

data/lib/openc3/microservices/interface_microservice.rb

@@ -348,13 +348,13 @@ module OpenC3
     def initialize(name)
       @mutex = Mutex.new
       super(name)
+      @interface_or_router = self.class.name.to_s.split("Microservice")[0].upcase.split("::")[-1]
       if @interface_or_router == 'INTERFACE'
         @metric.set(name: 'interface_tlm_total', value: @count, type: 'counter')
       else
         @metric.set(name: 'router_cmd_total', value: @count, type: 'counter')
       end
 
-      @interface_or_router = self.class.name.to_s.split("Microservice")[0].upcase.split("::")[-1]
       @scope = name.split("__")[0]
       interface_name = name.split("__")[2]
       if @interface_or_router == 'INTERFACE'
@@ -553,7 +553,7 @@ module OpenC3
         unknown_packet.extra = packet.extra
         packet = unknown_packet
         json_hash = CvtModel.build_json_from_packet(packet)
-        CvtModel.set(json_hash, target_name: packet.target_name, packet_name: packet.packet_name, scope: scope)
+        CvtModel.set(json_hash, target_name: packet.target_name, packet_name: packet.packet_name, scope: @scope)
         num_bytes_to_print = [UNKNOWN_BYTES_TO_PRINT, packet.length].min
         data = packet.buffer(false)[0..(num_bytes_to_print - 1)]
         prefix = data.each_byte.map { | byte | sprintf("%02X", byte) }.join()

data/lib/openc3/microservices/microservice.rb

@@ -14,7 +14,7 @@
 # GNU Affero General Public License for more details.
 
 # Modified by OpenC3, Inc.
-# All changes Copyright 2022, OpenC3, Inc.
+# All changes Copyright 2023, OpenC3, Inc.
 # All Rights Reserved
 #
 # This file may also be used under the terms of a commercial license
@@ -79,7 +79,7 @@ module OpenC3
     end
 
     def initialize(name, is_plugin: false)
-      Logger.info("Microservice running from: ruby #{$0} #{ARGV.join(" ")}")
+      @shutdown_complete = false
       raise "Microservice must be named" unless name
 
       @name = name
@@ -120,6 +120,7 @@ module OpenC3
       # Get configuration for any targets
       @target_names = @config["target_names"]
       @target_names ||= []
+      # NOTE: setup_targets doesn't do anything if @target_names is empty
       System.setup_targets(@target_names, @temp_dir, scope: @scope) unless is_plugin
 
       # Use at_exit to shutdown cleanly no matter how we die
@@ -199,6 +200,7 @@ module OpenC3
     end
 
     def shutdown
+      return if @shutdown_complete
       @logger.info("Shutting down microservice: #{@name}")
       @cancel_thread = true
       @microservice_status_sleeper.cancel if @microservice_status_sleeper
@@ -206,6 +208,7 @@ module OpenC3
       FileUtils.remove_entry(@temp_dir) if File.exist?(@temp_dir)
       @metric.shutdown
       @logger.info("Shutting down microservice complete: #{@name}")
+      @shutdown_complete = true
     end
   end
 end

data/lib/openc3/microservices/reaction_microservice.rb

@@ -229,6 +229,7 @@ module OpenC3
 
     def get_token(username)
       if ENV['OPENC3_API_CLIENT'].nil?
+        ENV['OPENC3_API_PASSWORD'] ||= ENV['OPENC3_SERVICE_PASSWORD']
         return OpenC3Authentication.new().token
       else
         # Check for offline access token

data/lib/openc3/microservices/timeline_microservice.rb

@@ -14,7 +14,7 @@
 # GNU Affero General Public License for more details.
 
 # Modified by OpenC3, Inc.
-# All changes Copyright 2022, OpenC3, Inc.
+# All changes Copyright 2023, OpenC3, Inc.
 # All Rights Reserved
 #
 # This file may also be used under the terms of a commercial license
@@ -43,6 +43,7 @@ module OpenC3
 
     def get_token(username)
       if ENV['OPENC3_API_CLIENT'].nil?
+        ENV['OPENC3_API_PASSWORD'] ||= ENV['OPENC3_SERVICE_PASSWORD']
         return OpenC3Authentication.new().token
       else
         # Check for offline access token
@@ -125,7 +126,8 @@ module OpenC3
 
     def clear_expired(activity)
       begin
-        ActivityModel.range_destroy(name: @timeline_name, scope: @scope, min: activity.start, max: activity.stop)
+        num = ActivityModel.range_destroy(name: @timeline_name, scope: @scope, min: activity.start, max: activity.stop)
+        @logger.info "#{@timeline_name} clear_expired removed #{num} items from #{activity.start} to #{activity.stop}"
         activity.add_event(status: 'completed')
       rescue StandardError => e
         @logger.error "#{@timeline_name} clear_expired failed > #{activity.as_json(:allow_nan => true)} #{e.message}"
@@ -231,15 +233,15 @@ module OpenC3
       @logger.info "#{@timeline_name} timeine manager exiting"
     end
 
-    # Add task to remove events older than 7 time
+    # Add task to remove events older than 7 days
     def add_expire_activity
       now = Time.now.to_i
       @expire = now + 3_000
       activity = ActivityModel.new(
         name: @timeline_name,
         scope: @scope,
-        start: (now - 86_400 * 7),
-        stop: (now - 82_800 * 7),
+        start: 0,
+        stop: (now - 86_400 * 7),
         kind: 'EXPIRE',
         data: {}
       )

data/lib/openc3/migrations/20231022000000_tlm_viewer_config.rb

@@ -0,0 +1,22 @@
+require 'openc3/utilities/migration'
+require 'openc3/models/tool_config_model'
+
+module OpenC3
+  class TlmViewerConfig < Migration
+    def self.run
+      ScopeModel.names.each do |scope|
+        # Get all existing ToolConfigModels and change keys from tlm_viewer to telemetry_viewer
+        names = ToolConfigModel.list_configs('tlm_viewer')
+        names.each do |name|
+          config = ToolConfigModel.load_config('tlm_viewer', name)
+          ToolConfigModel.save_config('telemetry_viewer', name, config)
+          ToolConfigModel.delete_config('tlm_viewer', name)
+        end
+      end
+    end
+  end
+end
+
+unless ENV['OPENC3_NO_MIGRATE']
+  OpenC3::TlmViewerConfig.run
+end

data/lib/openc3/models/activity_model.rb

@@ -14,7 +14,7 @@
 # GNU Affero General Public License for more details.
 
 # Modified by OpenC3, Inc.
-# All changes Copyright 2022, OpenC3, Inc.
+# All changes Copyright 2023, OpenC3, Inc.
 # All Rights Reserved
 #
 # This file may also be used under the terms of a commercial license
@@ -94,13 +94,31 @@ module OpenC3
     # Remove one member from a sorted set.
     # @return [Integer] count of the members removed
     def self.destroy(name:, scope:, score:)
-      Store.zremrangebyscore("#{scope}#{PRIMARY_KEY}__#{name}", score, score)
+      result = Store.zremrangebyscore("#{scope}#{PRIMARY_KEY}__#{name}", score, score)
+      notification = {
+        # start / stop to match SortedModel
+        'data' => JSON.generate({'start' => score}),
+        'kind' => 'deleted',
+        'type' => 'activity',
+        'timeline' => name
+      }
+      TimelineTopic.write_activity(notification, scope: scope)
+      return result
     end
 
     # Remove members from min to max of the sorted set.
     # @return [Integer] count of the members removed
     def self.range_destroy(name:, scope:, min:, max:)
-      Store.zremrangebyscore("#{scope}#{PRIMARY_KEY}__#{name}", min, max)
+      result = Store.zremrangebyscore("#{scope}#{PRIMARY_KEY}__#{name}", min, max)
+      notification = {
+        # start / stop to match SortedModel
+        'data' => JSON.generate({'start' => min, 'stop' => max}),
+        'kind' => 'deleted',
+        'type' => 'activity',
+        'timeline' => name
+      }
+      TimelineTopic.write_activity(notification, scope: scope)
+      return result
     end
 
     # @return [ActivityModel] Model generated from the passed JSON

data/lib/openc3/models/cvt_model.rb

@@ -237,10 +237,11 @@ module OpenC3
       end
 
       tgt_pkt_key = "#{scope}__tlm__#{target_name}__#{packet_name}"
-      @@override_cache[tgt_pkt_key] = [Time.now, hash]
       if hash.empty?
+        @@override_cache.delete(tgt_pkt_key)
         Store.hdel("#{scope}__override__#{target_name}", packet_name)
       else
+        @@override_cache[tgt_pkt_key] = [Time.now, hash]
         Store.hset("#{scope}__override__#{target_name}", packet_name, JSON.generate(hash.as_json(:allow_nan => true)))
       end
     end

data/lib/openc3/models/gem_model.rb

@@ -27,6 +27,7 @@ require 'rubygems'
 require 'rubygems/uninstaller'
 require 'tempfile'
 require 'openc3/utilities/process_manager'
+require 'openc3/api/api'
 require 'pathname'
 
 module OpenC3
@@ -35,6 +36,8 @@ module OpenC3
   # and destroy to allow interaction with gem files from the PluginModel and
   # the GemsController.
   class GemModel
+    include Api
+
     def self.names
       result = Pathname.new("#{ENV['GEM_HOME']}/gems").children.select { |c| c.directory? }.collect { |p| File.basename(p) + '.gem' }
       return result.sort
@@ -53,7 +56,7 @@ module OpenC3
         FileUtils.cp(gem_file_path, "#{ENV['GEM_HOME']}/cache/#{File.basename(gem_file_path)}")
         if gem_install
           Logger.info "Installing gem: #{gem_filename}"
-          result = OpenC3::ProcessManager.instance.spawn(["ruby", "/openc3/bin/openc3cli", "geminstall", gem_filename, scope], "gem_install", gem_filename, Time.now + 3600.0, scope: scope)
+          result = OpenC3::ProcessManager.instance.spawn(["ruby", "/openc3/bin/openc3cli", "geminstall", gem_filename, scope], "package_install", gem_filename, Time.now + 3600.0, scope: scope)
           return result.name
         end
       else

data/lib/openc3/models/interface_model.rb

@@ -145,7 +145,13 @@ module OpenC3
       unless @cmd
         type = self.class._get_type
         microservice_name = "#{@scope}__#{type}__#{@name}"
-        @cmd = ["ruby", "#{type.downcase}_microservice.rb", microservice_name]
+        if config_params[0] and File.extname(config_params[0]) == '.py'
+          work_dir.sub!('openc3/lib', 'openc3/python')
+          @cmd = ["python", "#{type.downcase}_microservice.py", microservice_name]
+        else
+          # If there are no config_params we assume ruby
+          @cmd = ["ruby", "#{type.downcase}_microservice.rb", microservice_name]
+        end
       end
       @work_dir = work_dir
       @ports = ports
@@ -417,7 +423,7 @@ module OpenC3
       # Respawn the microservice
       type = self.class._get_type
       microservice_name = "#{@scope}__#{type}__#{@name}"
-      microservice = MicroserviceModel.get_model(name: microservice_name, scope: scope)
+      microservice = MicroserviceModel.get_model(name: microservice_name, scope: @scope)
       microservice.target_names.delete(target_name) unless @target_names.include?(target_name)
       microservice.update
     end
@@ -432,11 +438,11 @@ module OpenC3
 
       if unmap_old
         # Remove from old interface
-        all_interfaces = InterfaceModel.all(scope: scope)
+        all_interfaces = InterfaceModel.all(scope: @scope)
         old_interface = nil
         all_interfaces.each do |old_interface_name, old_interface_details|
           if old_interface_details['target_names'].include?(target_name)
-            old_interface = InterfaceModel.from_json(old_interface_details, scope: scope)
+            old_interface = InterfaceModel.from_json(old_interface_details, scope: @scope)
             old_interface.unmap_target(target_name, cmd_only: cmd_only, tlm_only: tlm_only) if old_interface
           end
         end
@@ -451,7 +457,7 @@ module OpenC3
       # Respawn the microservice
       type = self.class._get_type
       microservice_name = "#{@scope}__#{type}__#{@name}"
-      microservice = MicroserviceModel.get_model(name: microservice_name, scope: scope)
+      microservice = MicroserviceModel.get_model(name: microservice_name, scope: @scope)
       microservice.target_names << target_name unless microservice.target_names.include?(target_name)
       microservice.update
     end

data/lib/openc3/models/metadata_model.rb

@@ -33,6 +33,17 @@ module OpenC3
       "#{scope}#{PRIMARY_KEY}"
     end
 
+    def self.notify(scope:, kind:, start:, stop: nil)
+      json = {'type' => METADATA_TYPE, 'start' => start}
+      json['stop'] = stop if stop
+      notification = {
+        'data' => JSON.generate(json),
+        'kind' => kind,
+        'type' => 'calendar',
+      }
+      CalendarTopic.write_entry(notification, scope: scope)
+    end
+
     attr_reader :color, :metadata, :constraints, :type
 
     # @param [Integer] start - Time metadata is active in seconds from Epoch

data/lib/openc3/models/microservice_model.rb

@@ -42,6 +42,7 @@ module OpenC3
     attr_accessor :parent
     attr_accessor :secrets
     attr_accessor :prefix
+    attr_accessor :disable_erb
 
     # NOTE: The following three class methods are used by the ModelController
     # and are reimplemented to enable various Model class methods to work
@@ -101,6 +102,7 @@ module OpenC3
       needs_dependencies: false,
       secrets: [],
       prefix: nil,
+      disable_erb: nil,
       scope:
     )
       parts = name.split("__")
@@ -125,6 +127,7 @@ module OpenC3
       @needs_dependencies = needs_dependencies
       @secrets = secrets
       @prefix = prefix
+      @disable_erb = disable_erb
       @bucket = Bucket.getClient()
     end
 
@@ -145,7 +148,8 @@ module OpenC3
         'plugin' => @plugin,
         'needs_dependencies' => @needs_dependencies,
         'secrets' => @secrets.as_json(*a),
-        'prefix' => @prefix
+        'prefix' => @prefix,
+        'disable_erb' => @disable_erb
       }
     end
 
@@ -201,6 +205,12 @@ module OpenC3
       when 'ROUTE_PREFIX'
         parser.verify_num_parameters(1, 1, "#{keyword} <Route Prefix>")
         @prefix = parameters[0]
+      when 'DISABLE_ERB'
+        # 0 to unlimited parameters
+        @disable_erb ||= []
+        if parameters
+          @disable_erb.concat(parameters)
+        end
       else
         raise ConfigParser::Error.new(parser, "Unknown keyword and parameters for Microservice: #{keyword} #{parameters.join(" ")}")
       end
@@ -220,8 +230,11 @@ module OpenC3
 
         # Load microservice files
         data = File.read(filename, mode: "rb")
-        OpenC3.set_working_dir(File.dirname(filename)) do
-          data = ERB.new(data.comment_erb(), trim_mode: "-").result(binding.set_variables(variables)) if data.is_printable? and File.basename(filename)[0] != '_'
+        erb_disabled = check_disable_erb(filename)
+        unless erb_disabled
+          OpenC3.set_working_dir(File.dirname(filename)) do
+            data = ERB.new(data.comment_erb(), trim_mode: "-").result(binding.set_variables(variables)) if data.is_printable? and File.basename(filename)[0] != '_'
+          end
         end
         unless validate_only
           @bucket.put_object(bucket: ENV['OPENC3_CONFIG_BUCKET'], key: key, body: data)