openc3 5.1.1 → 5.2.0

data/lib/openc3/microservices/timeline_microservice.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/utilities/authentication'
@@ -35,31 +35,38 @@ module OpenC3
   # these workers will run the CMD (command) or SCRIPT (script)
   # or anything that could be expanded in the future.
   class TimelineWorker
-    def initialize(name:, scope:, queue:)
+    def initialize(name:, logger:, scope:, queue:)
       @timeline_name = name
+      @logger = logger
       @scope = scope
       @queue = queue
-      @authentication = generate_auth()
     end
 
-    # generate the auth object
-    def generate_auth
-      if ENV['OPENC3_API_USER'].nil? || ENV['OPENC3_API_CLIENT'].nil?
-        return OpenC3Authentication.new()
+    def get_token(username)
+      if ENV['OPENC3_API_CLIENT'].nil?
+        return OpenC3Authentication.new().token
       else
-        return OpenC3KeycloakAuthentication.new(ENV['OPENC3_KEYCLOAK_URL'])
+        # Check for offline access token
+        model = nil
+        model = OpenC3::OfflineAccessModel.get_model(name: username, scope: @scope) if username and username != ''
+        if model and model.offline_access_token
+          auth = OpenC3KeycloakAuthentication.new(ENV['OPENC3_KEYCLOAK_URL'])
+          return auth.get_token_from_refresh_token(model.offline_access_token)
+        else
+          return nil
+        end
       end
     end
 
     def run
-      Logger.info "#{@timeline_name} timeline worker running"
+      @logger.info "#{@timeline_name} timeline worker running"
       loop do
         activity = @queue.pop
         break if activity.nil?
 
         run_activity(activity)
       end
-      Logger.info "#{@timeline_name} timeine worker exiting"
+      @logger.info "#{@timeline_name} timeine worker exiting"
     end
 
     def run_activity(activity)
@@ -71,28 +78,34 @@ module OpenC3
       when 'EXPIRE'
         clear_expired(activity)
       else
-        Logger.error "Unknown kind passed to microservice #{@timeline_name}: #{activity.as_json(:allow_nan => true)}"
+        @logger.error "Unknown kind passed to microservice #{@timeline_name}: #{activity.as_json(:allow_nan => true)}"
       end
     end
 
     def run_command(activity)
-      Logger.info "#{@timeline_name} run_command > #{activity.as_json(:allow_nan => true)}"
+      @logger.info "#{@timeline_name} run_command > #{activity.as_json(:allow_nan => true)}"
       begin
-        cmd_no_hazardous_check(activity.data['command'], scope: @scope)
+        username = activity.data['username']
+        token = get_token(username)
+        raise "No token available for username: #{username}" unless token
+        cmd_no_hazardous_check(activity.data['command'], scope: @scope, token: token)
         activity.commit(status: 'completed', fulfillment: true)
       rescue StandardError => e
         activity.commit(status: 'failed', message: e.message)
-        Logger.error "#{@timeline_name} run_cmd failed > #{activity.as_json(:allow_nan => true)}, #{e.message}"
+        @logger.error "#{@timeline_name} run_cmd failed > #{activity.as_json(:allow_nan => true)}, #{e.formatted}"
       end
     end
 
     def run_script(activity)
-      Logger.info "#{@timeline_name} run_script > #{activity.as_json(:allow_nan => true)}"
+      @logger.info "#{@timeline_name} run_script > #{activity.as_json(:allow_nan => true)}"
       begin
+        username = activity.data['username']
+        token = get_token(username)
+        raise "No token available for username: #{username}" unless token
         request = Net::HTTP::Post.new(
           "/script-api/scripts/#{activity.data['script']}/run?scope=#{@scope}",
           'Content-Type' => 'application/json',
-          'Authorization' => @authentication.token()
+          'Authorization' => token
         )
         request.body = JSON.generate({
           'scope' => @scope,
@@ -107,7 +120,7 @@ module OpenC3
         activity.commit(status: 'completed', message: "#{activity.data['script']} => #{response.body}", fulfillment: true)
       rescue StandardError => e
         activity.commit(status: 'failed', message: e.message)
-        Logger.error "#{@timeline_name} run_script failed > #{activity.as_json(:allow_nan => true).to_s}, #{e.message}"
+        @logger.error "#{@timeline_name} run_script failed > #{activity.as_json(:allow_nan => true).to_s}, #{e.message}"
       end
     end
 
@@ -116,7 +129,7 @@ module OpenC3
         ActivityModel.range_destroy(name: @timeline_name, scope: @scope, min: activity.start, max: 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}"
+        @logger.error "#{@timeline_name} clear_expired failed > #{activity.as_json(:allow_nan => true)} #{e.message}"
       end
     end
   end
@@ -174,8 +187,9 @@ module OpenC3
   # adds the "activity" to the thread pool and the thread will
   # execute the "activity".
   class TimelineManager
-    def initialize(name:, scope:, schedule:)
+    def initialize(name:, logger:, scope:, schedule:)
       @timeline_name = name
+      @logger = logger
       @scope = scope
       @schedule = schedule
       @worker_count = 3
@@ -188,20 +202,20 @@ module OpenC3
     def generate_thread_pool
       thread_pool = []
       @worker_count.times {
-        worker = TimelineWorker.new(name: @timeline_name, scope: @scope, queue: @queue)
+        worker = TimelineWorker.new(name: @timeline_name, logger: @logger, scope: @scope, queue: @queue)
         thread_pool << Thread.new { worker.run }
       }
       return thread_pool
     end
 
     def run
-      Logger.info "#{@timeline_name} timeline manager running"
+      @logger.info "#{@timeline_name} timeline manager running"
       loop do
         start = Time.now.to_i
         @schedule.activities.each do |activity|
           start_difference = activity.start - start
           if start_difference <= 0 && @schedule.not_queued?(activity.start)
-            Logger.debug "#{@timeline_name} #{@scope} current start: #{start}, vs #{activity.start}, #{start_difference}"
+            @logger.debug "#{@timeline_name} #{@scope} current start: #{start}, vs #{activity.start}, #{start_difference}"
             activity.add_event(status: 'queued')
             @queue << activity
           end
@@ -215,7 +229,7 @@ module OpenC3
         sleep(1)
         break if @cancel_thread
       end
-      Logger.info "#{@timeline_name} timeine manager exiting"
+      @logger.info "#{@timeline_name} timeine manager exiting"
     end
 
     # Add task to remove events older than 7 time
@@ -247,7 +261,7 @@ module OpenC3
       begin
         TimelineTopic.write_activity(notification, scope: @scope)
       rescue StandardError
-        Logger.error "#{@name} manager failed to request update"
+        @logger.error "#{@name} manager failed to request update"
       end
     end
 
@@ -270,13 +284,13 @@ module OpenC3
       super(name)
       @timeline_name = name.split('__')[2]
       @schedule = Schedule.new(@timeline_name)
-      @manager = TimelineManager.new(name: @timeline_name, scope: scope, schedule: @schedule)
+      @manager = TimelineManager.new(name: @timeline_name, logger: @logger, scope: scope, schedule: @schedule)
       @manager_thread = nil
       @read_topic = true
     end
 
     def run
-      Logger.info "#{@name} timeine running"
+      @logger.info "#{@name} timeine running"
       @manager_thread = Thread.new { @manager.run }
       loop do
         start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
@@ -290,7 +304,7 @@ module OpenC3
         block_for_updates()
         break if @cancel_thread
       end
-      Logger.info "#{@name} timeine exitting"
+      @logger.info "#{@name} timeine exitting"
     end
 
     def topic_lookup_functions
@@ -321,17 +335,17 @@ module OpenC3
             end
           end
         rescue StandardError => e
-          Logger.error "#{@timeline_name} failed to read topics #{@topics}\n#{e.formatted}"
+          @logger.error "#{@timeline_name} failed to read topics #{@topics}\n#{e.formatted}"
         end
       end
     end
 
     def timeline_nop(data)
-      Logger.debug "#{@name} timeline web socket event: #{data}"
+      @logger.debug "#{@name} timeline web socket event: #{data}"
     end
 
     def schedule_refresh(data)
-      Logger.debug "#{@name} timeline web socket schedule refresh: #{data}"
+      @logger.debug "#{@name} timeline web socket schedule refresh: #{data}"
       @read_topic = false
     end
 

data/lib/openc3/microservices/trigger_group_microservice.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/microservices/microservice'
@@ -194,7 +194,7 @@ module OpenC3
         @triggers[trigger['name']] = Marshal.load( Marshal.dump(trigger) )
       end
       t = TriggerModel.from_json(trigger, name: trigger['name'], scope: trigger['scope'])
-      @lookup_mutex.synchronize do 
+      @lookup_mutex.synchronize do
         t.generate_topics.each do | topic |
           if @lookup[topic].nil?
             @lookup[topic] = { t.name => 1 }
@@ -211,7 +211,7 @@ module OpenC3
         @triggers.delete(trigger['name'])
       end
       t = TriggerModel.from_json(trigger, name: trigger['name'], scope: trigger['scope'])
-      @lookup_mutex.synchronize do 
+      @lookup_mutex.synchronize do
         t.generate_topics.each do | topic |
           unless @lookup[topic].nil?
             @lookup[topic].delete(t.name)
@@ -258,8 +258,9 @@ module OpenC3
 
     attr_reader :name, :scope, :target, :packet, :group
 
-    def initialize(name:, scope:, group:, queue:, share:, ident:)
+    def initialize(name:, logger:, scope:, group:, queue:, share:, ident:)
       @name = name
+      @logger = logger
       @scope = scope
       @group = group
       @queue = queue
@@ -270,7 +271,7 @@ module OpenC3
     end
 
     def run
-      Logger.info "TriggerGroupWorker-#{@ident} running"
+      @logger.info "TriggerGroupWorker-#{@ident} running"
       loop do
         topic = @queue.pop
         break if topic.nil?
@@ -282,10 +283,10 @@ module OpenC3
             @metric_output_time = current_time + 120
           end
         rescue StandardError => e
-          Logger.error "TriggerGroupWorker-#{@ident} failed to evaluate data packet from topic: #{topic}\n#{e.formatted}"
+          @logger.error "TriggerGroupWorker-#{@ident} failed to evaluate data packet from topic: #{topic}\n#{e.formatted}"
         end
       end
-      Logger.info "TriggerGroupWorker-#{@ident} exiting"
+      @logger.info "TriggerGroupWorker-#{@ident} exiting"
     end
 
     # time how long each packet takes to eval and produce a metric to public
@@ -294,25 +295,25 @@ module OpenC3
       evaluate_data_packet(topic: topic, triggers: @share.trigger_base.triggers)
       diff = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start # seconds as a float
       metric_labels = { 'trigger_group' => @group, 'thread' => "worker-#{@ident}" }
-      @metric.add_sample(name: TRIGGER_METRIC_NAME, value: diff, labels: metric_labels) 
+      @metric.add_sample(name: TRIGGER_METRIC_NAME, value: diff, labels: metric_labels)
     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:)
       visited = Hash.new
-      Logger.debug "TriggerGroupWorker-#{@ident} topic: #{topic}"
+      @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}"
+      @logger.debug "TriggerGroupWorker-#{@ident} triggers_to_eval: #{triggers_to_eval}"
       triggers_to_eval.each do | trigger |
-        Logger.debug "TriggerGroupWorker-#{@ident} eval head: #{trigger}"
+        @logger.debug "TriggerGroupWorker-#{@ident} eval head: #{trigger}"
         value = evaluate_trigger(
           head: trigger,
           trigger: trigger,
           visited: visited,
           triggers: triggers
         )
-        Logger.debug "TriggerGroupWorker-#{@ident} trigger: #{trigger} value: #{value}"
+        @logger.debug "TriggerGroupWorker-#{@ident} trigger: #{trigger} value: #{value}"
         # value MUST be -1, 0, or 1
         @share.trigger_base.update_state(name: trigger.name, value: value)
       end
@@ -367,7 +368,7 @@ module OpenC3
     #    1 (the value is considered as a true value)
     #
     def evaluate(left:, operator:, right:)
-      Logger.debug "TriggerGroupWorker-#{@ident} evaluate: (#{left} #{operator} #{right})"
+      @logger.debug "TriggerGroupWorker-#{@ident} evaluate: (#{left} #{operator} #{right})"
       begin
         case operator
         when '>'
@@ -388,7 +389,7 @@ module OpenC3
           return left || right ? 1 : 0
         end
       rescue ArgumentError
-        Logger.error "invalid evaluate: (#{left} #{operator} #{right})"
+        @logger.error "invalid evaluate: (#{left} #{operator} #{right})"
         return -1
       end
     end
@@ -407,21 +408,21 @@ module OpenC3
     # IF a loop is detected it will log an error and return -1
     def evaluate_trigger(head:, trigger:, visited:, triggers:)
       if visited["#{trigger.name}__R"]
-        return visited["#{trigger.name}__R"] 
+        return visited["#{trigger.name}__R"]
       end
       if visited["#{trigger.name}__P"].nil?
         visited["#{trigger.name}__P"] = Hash.new
       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"]}"
+        @logger.error "loop detected from #{head} -> #{trigger} path: #{visited["#{head.name}__P"]}"
         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"]}"
+          @logger.error "loop detected from #{head} -> #{root_trigger} path: #{visited["#{head.name}__P"]}"
           return visited["#{trigger.name}__R"] = -1
         end
         result = evaluate_trigger(
@@ -430,7 +431,7 @@ module OpenC3
           visited: visited,
           triggers: triggers
         )
-        Logger.debug "TriggerGroupWorker-#{@ident} #{root_trigger.name} result: #{result}"
+        @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)
@@ -452,8 +453,9 @@ module OpenC3
 
     attr_reader :name, :scope, :share, :group, :topics, :thread_pool
 
-    def initialize(name:, scope:, group:, share:)
+    def initialize(name:, logger:, scope:, group:, share:)
       @name = name
+      @logger = logger
       @scope = scope
       @group = group
       @share = share
@@ -470,6 +472,7 @@ module OpenC3
       @worker_count.times do | i |
         worker = TriggerGroupWorker.new(
           name: @name,
+          logger: @logger,
           scope: @scope,
           group: @group,
           queue: @queue,
@@ -482,26 +485,26 @@ module OpenC3
     end
 
     def run
-      Logger.info "TriggerGroupManager running"
+      @logger.info "TriggerGroupManager running"
       @thread_pool = generate_thread_pool()
       loop do
         begin
           update_topics()
         rescue StandardError => e
-          Logger.error "TriggerGroupManager failed to update topics.\n#{e.formatted}"
+          @logger.error "TriggerGroupManager failed to update topics.\n#{e.formatted}"
         end
         break if @cancel_thread
 
         block_for_updates()
         break if @cancel_thread
       end
-      Logger.info "TriggerGroupManager exiting"
+      @logger.info "TriggerGroupManager exiting"
     end
 
     def update_topics
       past_topics = @topics
       @topics = @share.trigger_base.topics()
-      Logger.debug "TriggerGroupManager past_topics: #{past_topics} topics: #{@topics}"
+      @logger.debug "TriggerGroupManager past_topics: #{past_topics} topics: #{@topics}"
       (past_topics - @topics).each do | removed_topic |
         @share.packet_base.remove(topic: removed_topic)
       end
@@ -512,7 +515,7 @@ module OpenC3
       while @read_topic
         begin
           Topic.read_topics(@topics) do |topic, _msg_id, msg_hash, _redis|
-            Logger.debug "TriggerGroupManager block_for_updates: #{topic} #{msg_hash.to_s}"
+            @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)
               @share.packet_base.add(topic: topic, packet: packet)
@@ -520,11 +523,11 @@ module OpenC3
             @queue << "#{topic}"
           end
         rescue StandardError => e
-          Logger.error "TriggerGroupManager failed to read topics #{@topics}\n#{e.formatted}"
+          @logger.error "TriggerGroupManager failed to read topics #{@topics}\n#{e.formatted}"
         end
       end
     end
-    
+
     def refresh
       @read_topic = false
     end
@@ -551,13 +554,13 @@ module OpenC3
       super(*args)
       @group = TriggerGroupShare.get_group(name: @name)
       @share = TriggerGroupShare.new(scope: @scope)
-      @manager = TriggerGroupManager.new(name: @name, scope: @scope, group: @group, share: @share)
+      @manager = TriggerGroupManager.new(name: @name, logger: @logger, scope: @scope, group: @group, share: @share)
       @manager_thread = nil
       @read_topic = true
     end
 
     def run
-      Logger.info "TriggerGroupMicroservice running"
+      @logger.info "TriggerGroupMicroservice running"
       @manager_thread = Thread.new { @manager.run }
       loop do
         start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
@@ -571,7 +574,7 @@ module OpenC3
         block_for_updates()
         break if @cancel_thread
       end
-      Logger.info "TriggerGroupMicroservice exiting"
+      @logger.info "TriggerGroupMicroservice exiting"
     end
 
     def topic_lookup_functions
@@ -591,30 +594,30 @@ module OpenC3
       while @read_topic
         begin
           AutonomicTopic.read_topics(@topics) do |_topic, _msg_id, msg_hash, _redis|
-            Logger.debug "TriggerGroupMicroservice block_for_updates: #{msg_hash.to_s}"
+            @logger.debug "TriggerGroupMicroservice block_for_updates: #{msg_hash.to_s}"
             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)
             end
           end
         rescue StandardError => e
-          Logger.error "TriggerGroupMicroservice failed to read topics #{@topics}\n#{e.formatted}"
+          @logger.error "TriggerGroupMicroservice failed to read topics #{@topics}\n#{e.formatted}"
         end
       end
     end
 
     def no_op(data)
-      Logger.debug "TriggerGroupMicroservice web socket event: #{data}"
+      @logger.debug "TriggerGroupMicroservice web socket event: #{data}"
     end
 
     def refresh_event(data)
-      Logger.debug "TriggerGroupMicroservice web socket schedule refresh: #{data}"
+      @logger.debug "TriggerGroupMicroservice web socket schedule refresh: #{data}"
       @read_topic = false
     end
 
-    # Add the trigger to the share. 
+    # Add the trigger to the share.
     def created_trigger_event(data)
-      Logger.debug "TriggerGroupMicroservice created_trigger_event #{data}"
+      @logger.debug "TriggerGroupMicroservice created_trigger_event #{data}"
       if data['group'] == @group
         @share.trigger_base.add(trigger: data)
         @manager.refresh()
@@ -623,7 +626,7 @@ module OpenC3
 
     # Remove the trigger from the share.
     def deleted_trigger_event(data)
-      Logger.debug "TriggerGroupMicroservice deleted_trigger_event #{data}"
+      @logger.debug "TriggerGroupMicroservice deleted_trigger_event #{data}"
       if data['group'] == @group
         @share.trigger_base.remove(trigger: data)
         @manager.refresh()

data/lib/openc3/migrations/20221202214600_add_target_names.rb

@@ -0,0 +1,30 @@
+require 'openc3/utilities/migration'
+require 'openc3/models/scope_model'
+
+module OpenC3
+  class AddTargetNames < Migration
+    def self.run
+      ScopeModel.names.each do |scope|
+        # Get all existing InterfaceModels and add cmd_target_names / tlm_target_names if necessary
+        interface_models = InterfaceModel.all(scope: scope)
+        interface_models.each do |key, model_hash|
+          target_names = model_hash['target_names']
+          model_hash['cmd_target_names'] = target_names unless model_hash['cmd_target_names']
+          model_hash['tlm_target_names'] = target_names unless model_hash['tlm_target_names']
+          InterfaceModel.from_json(model_hash, scope: scope).update
+        end
+        router_models = RouterModel.all(scope: scope)
+        router_models.each do |key, model_hash|
+          target_names = model_hash['target_names']
+          model_hash['cmd_target_names'] = target_names unless model_hash['cmd_target_names']
+          model_hash['tlm_target_names'] = target_names unless model_hash['tlm_target_names']
+          RouterModel.from_json(model_hash, scope: scope).update
+        end
+      end
+    end
+  end
+end
+
+unless ENV['OPENC3_NO_MIGRATE']
+  OpenC3::AddTargetNames.run
+end

data/lib/openc3/migrations/20221210174900_convert_to_multi.rb

@@ -0,0 +1,65 @@
+require 'openc3/utilities/migration'
+require 'openc3/models/scope_model'
+require 'openc3/models/target_model'
+
+module OpenC3
+  class ConvertToMulti < Migration
+    def self.run
+      # Add parent to preexisting scope microservies and deploy new periodic and multi
+      ScopeModel.get_all_models(scope: nil).each do |scope, scope_model|
+        parent = "#{scope}__SCOPEMULTI__#{scope}"
+        model = MicroserviceModel.get_model(name: "#{scope}__OPENC3__LOG", scope: scope)
+        if model
+          model.parent = parent
+          model.update
+          scope_model.children << "#{scope}__OPENC3__LOG"
+        end
+        model = MicroserviceModel.get_model(name: "#{scope}__NOTIFICATION__LOG", scope: scope)
+        if model
+          model.parent = parent
+          model.update
+          scope_model.children << "#{scope}__NOTIFICATION__LOG"
+        end
+        model = MicroserviceModel.get_model(name: "#{scope}__COMMANDLOG__UNKNOWN", scope: scope)
+        if model
+          model.parent = parent
+          model.update
+          scope_model.children << "#{scope}__COMMANDLOG__UNKNOWN"
+        end
+        model = MicroserviceModel.get_model(name: "#{scope}__PACKETLOG__UNKNOWN", scope: scope)
+        if model
+          model.parent = parent
+          model.update
+          scope_model.children << "#{scope}__PACKETLOG__UNKNOWN"
+        end
+        scope_model.deploy_periodic_microservice("", {}, parent)
+        scope_model.deploy_scopemulti_microservice("", {})
+
+        # Add parent to preexisting target microservices and deploy new multi
+        TargetModel.get_all_models(scope: scope).each do |target_name, target_model|
+          next if target_name == 'UNKNOWN'
+          parent = "#{scope}__MULTI__#{target_name}"
+          %w(DECOM COMMANDLOG DECOMCMDLOG PACKETLOG DECOMLOG REDUCER CLEANUP).each do |type|
+            model = MicroserviceModel.get_model(name: "#{scope}__#{type}__#{target_name}", scope: scope)
+            if model
+              model.parent = parent
+              if %w(COMMANDLOG DECOMCMDLOG).include?(type)
+                model.options << ["BUFFER_DEPTH", 5]
+              end
+              if %w(PACKETLOG DECOMLOG).include?(type)
+                model.options << ["BUFFER_DEPTH", 60]
+              end
+              model.update
+              target_model.children << "#{scope}__#{type}__#{target_name}"
+            end
+          end
+          target_model.deploy_multi_microservice("", {}, nil)
+        end
+      end
+    end
+  end
+end
+
+unless ENV['OPENC3_NO_MIGRATE']
+  OpenC3::ConvertToMulti.run
+end

data/lib/openc3/models/cvt_model.rb

@@ -93,7 +93,7 @@ module OpenC3
     # @param stale_time [Integer] Time in seconds from Time.now that value will be marked stale
     # @return [Array] Array of values
     def self.get_tlm_values(items, stale_time: 30, scope: $openc3_scope)
-      now = Time.now.to_f
+      now = Time.now.sys.to_f
       results = []
       lookups = []
       packet_lookup = {}

data/lib/openc3/models/gem_model.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 'fileutils'
@@ -66,27 +66,31 @@ module OpenC3
     end
 
     def self.install(name_or_path, scope:)
+      if File.exist?(name_or_path)
+        gem_file_path = name_or_path
+      else
+        gem_file_path = get(name_or_path)
+      end
       begin
-        if File.exist?(name_or_path)
-          gem_file_path = name_or_path
-        else
-          gem_file_path = get(name_or_path)
-        end
-        begin
-          rubygems_url = get_setting('rubygems_url', scope: scope)
-        rescue
-          # If Redis isn't running try the ENV, then simply rubygems.org
-          rubygems_url = ENV['RUBYGEMS_URL']
-          rubygems_url ||= 'https://rubygems.org'
-        end
-        Gem.sources = [rubygems_url] if rubygems_url
-        Gem.done_installing_hooks.clear
-        Gem.install(gem_file_path, "> 0.pre", :build_args => ['--no-document'], :prerelease => true)
-      rescue => err
-        message = "Gem file #{gem_file_path} error installing to #{ENV['GEM_HOME']}\n#{err.formatted}"
-        Logger.error message
-        raise err
+        rubygems_url = get_setting('rubygems_url', scope: scope)
+      rescue
+        # If Redis isn't running try the ENV, then simply rubygems.org
+        rubygems_url = ENV['RUBYGEMS_URL']
+        rubygems_url ||= 'https://rubygems.org'
+      end
+      Gem.sources = [rubygems_url] if rubygems_url
+      Gem.done_installing_hooks.clear
+      begin
+        # Look for local gems only first, this avoids lengthly timeouts when checking rubygems in airgap env
+        Gem.install(gem_file_path, "> 0.pre", build_args: ['--no-document'], prerelease: true, domain: :local)
+      rescue Gem::Exception => err
+        # If there is a failure look for both local and remote gems
+        Gem.install(gem_file_path, "> 0.pre", build_args: ['--no-document'], prerelease: true, domain: :both)
       end
+    rescue => err
+      message = "Gem file #{gem_file_path} error installing to #{ENV['GEM_HOME']}\n#{err.formatted}"
+      Logger.error message
+      raise err
     end
 
     def self.destroy(name)