openc3 5.18.0 → 5.19.0

data/lib/openc3/models/activity_model.rb

@@ -47,41 +47,28 @@ module OpenC3
       start_score = now - 15
       stop_score = (now + 3660)
       array = Store.zrangebyscore("#{scope}#{PRIMARY_KEY}__#{name}", start_score, stop_score)
-      ret_array = Array.new
-      array.each do |value|
-        ret_array << ActivityModel.from_json(value, name: name, scope: scope)
-      end
-      return ret_array
+      return array.map { |value| ActivityModel.from_json(value, name: name, scope: scope) }
     end
 
     # @return [Array|nil] Array up to 100 of this model or empty array if name not found under primary_key
     def self.get(name:, start:, stop:, scope:, limit: 100)
       if start > stop
-        raise ActivityInputError.new "start: #{start} must be before stop: #{stop}"
+        raise ActivityInputError.new "start: #{start} must be <= stop: #{stop}"
       end
-
       array = Store.zrangebyscore("#{scope}#{PRIMARY_KEY}__#{name}", start, stop, :limit => [0, limit])
-      ret_array = Array.new
-      array.each do |value|
-        ret_array << JSON.parse(value, :allow_nan => true, :create_additions => true)
-      end
-      return ret_array
+      return array.map { |value| JSON.parse(value, :allow_nan => true, :create_additions => true) }
     end
 
     # @return [Array<Hash>] Array up to the limit of the models (as Hash objects) stored under the primary key
     def self.all(name:, scope:, limit: 100)
       array = Store.zrange("#{scope}#{PRIMARY_KEY}__#{name}", 0, -1, :limit => [0, limit])
-      ret_array = Array.new
-      array.each do |value|
-        ret_array << JSON.parse(value, :allow_nan => true, :create_additions => true)
-      end
-      return ret_array
+      return array.map { |value| JSON.parse(value, :allow_nan => true, :create_additions => true) }
     end
 
     # @return [String|nil] String of the saved json or nil if score not found under primary_key
     def self.score(name:, score:, scope:)
-      array = Store.zrangebyscore("#{scope}#{PRIMARY_KEY}__#{name}", score, score, :limit => [0, 1])
-      array.each do |value|
+      value = Store.zrangebyscore("#{scope}#{PRIMARY_KEY}__#{name}", score, score, :limit => [0, 1]).first
+      if value
         return ActivityModel.from_json(value, name: name, scope: scope)
       end
       return nil
@@ -93,9 +80,45 @@ module OpenC3
     end
 
     # Remove one member from a sorted set.
-    # @return [Integer] count of the members removed
-    def self.destroy(name:, scope:, score:)
-      result = Store.zremrangebyscore("#{scope}#{PRIMARY_KEY}__#{name}", score, score)
+    # @return [Integer] count of the members removed, 0 indicates the member was not found
+    def self.destroy(name:, scope:, score:, uuid: nil, recurring: nil)
+      result = 0
+
+      # Delete all recurring activities
+      if recurring
+        activity = self.score(name: name, score: score, scope: scope)
+        if activity and activity.recurring['end'] and activity.recurring['uuid']
+          json = Store.zrangebyscore("#{scope}#{PRIMARY_KEY}__#{name}", activity.recurring['start'], activity.recurring['end'])
+          parsed = json.map { |value| ActivityModel.from_json(value, name: name, scope: scope) }
+          parsed.each_with_index do |value, index|
+            if value.recurring['uuid'] == uuid
+              Store.zrem("#{scope}#{PRIMARY_KEY}__#{name}", json[index])
+              result += 1
+            end
+          end
+        end
+      end
+
+      # First find all the activities at the score
+      json = Store.zrangebyscore("#{scope}#{PRIMARY_KEY}__#{name}", score, score, :limit => [0, 100])
+      parsed = json.map { |value| JSON.parse(value, :allow_nan => true, :create_additions => true) }
+      parsed.each_with_index do |value, index|
+        if uuid
+          # If the uuid is given then only delete activities that match the uuid
+          if value['uuid'] == uuid
+            Store.zrem("#{scope}#{PRIMARY_KEY}__#{name}", json[index])
+            result += 1
+            break
+          end
+        else
+          # If the uuid is not given (backwards compatibility) then delete all activities
+          # at the score that do NOT have a uuid
+          next if value['uuid']
+          Store.zrem("#{scope}#{PRIMARY_KEY}__#{name}", json[index])
+          result += 1
+        end
+      end
+
       notification = {
         # start / stop to match SortedModel
         'data' => JSON.generate({'start' => score}),
@@ -129,27 +152,30 @@ module OpenC3
       self.new(**json.transform_keys(&:to_sym), name: name, scope: scope)
     end
 
-    attr_reader :start, :stop, :kind, :data, :events, :fulfillment, :recurring
+    attr_reader :start, :stop, :kind, :data, :fulfillment, :uuid, :events, :recurring
 
     def initialize(
-      name:,
+      name:, # part of Model
       start:,
       stop:,
       kind:,
       data:,
-      scope:,
-      updated_at: 0,
+      scope:, # part of Model
+      updated_at: 0, # part of Model
       fulfillment: nil,
+      uuid: nil,
       events: nil,
       recurring: {}
     )
       super("#{scope}#{PRIMARY_KEY}__#{name}", name: name, scope: scope)
+      # Validate everything that isn't already in Model
       set_input(
-        fulfillment: fulfillment,
         start: start,
         stop: stop,
         kind: kind,
         data: data,
+        fulfillment: fulfillment,
+        uuid: uuid,
         events: events,
         recurring: recurring,
       )
@@ -162,19 +188,19 @@ module OpenC3
     # need to return all the activities that may start before us and verify that we don't overlap them.
     # Activities are only inserted by @start time so we need to go back to verify we don't overlap existing @stop.
     # Note: Score is the Seconds since the Unix Epoch: (%s) Number of seconds since 1970-01-01 00:00:00 UTC.
-    # zrange rev byscore finds activites from in reverse order so the first task is the closest task to the current score.
+    # zrange rev byscore finds activities from in reverse order so the first task is the closest task to the current score.
     # In this case a parameter ignore_score allows the request to ignore that time and skip to the next time
     # but if nothing is found in the time range we can return nil.
     #
     # @param [Integer] ignore_score - should be nil unless you want to ignore a time when doing an update
-    def validate_time(ignore_score = nil)
+    def validate_time(start, stop, ignore_score: nil)
       # Adding a '(' makes the max value exclusive
-      array = Store.zrevrangebyscore(@primary_key, "(#{@stop}", @start - MAX_DURATION)
+      array = Store.zrevrangebyscore(@primary_key, "(#{stop}", start - MAX_DURATION)
       array.each do |value|
         activity = JSON.parse(value, :allow_nan => true, :create_additions => true)
         if ignore_score == activity['start']
           next
-        elsif activity['stop'] > @start
+        elsif activity['stop'] > start
           return activity['start']
         else
           return nil
@@ -204,7 +230,7 @@ module OpenC3
       end
       if now_f >= start and kind != 'expire'
         raise ActivityInputError.new "activity must be in the future, current_time: #{now_f} vs #{start}"
-      elsif duration >= MAX_DURATION and kind != 'expire'
+      elsif duration > MAX_DURATION and kind != 'expire'
         raise ActivityInputError.new "activity can not be longer than #{MAX_DURATION} seconds"
       elsif duration <= 0
         raise ActivityInputError.new "start: #{start} must be before stop: #{stop}"
@@ -218,7 +244,7 @@ module OpenC3
     end
 
     # Set the values of the instance, @start, @kind, @data, @events...
-    def set_input(start:, stop:, kind: nil, data: nil, events: nil, fulfillment: nil, recurring: nil)
+    def set_input(start:, stop:, kind: nil, data: nil, uuid: nil, events: nil, fulfillment: nil, recurring: nil)
       kind = kind.to_s.downcase
       validate_input(start: start, stop: stop, kind: kind, data: data)
       @start = start
@@ -226,6 +252,7 @@ module OpenC3
       @fulfillment = fulfillment.nil? ? false : fulfillment
       @kind = kind
       @data = data.nil? ? @data : data
+      @uuid = uuid.nil? ? SecureRandom.uuid : uuid
       @events = events.nil? ? Array.new : events
       @recurring = recurring.nil? ? @recurring : recurring
     end
@@ -241,20 +268,22 @@ module OpenC3
         @recurring['uuid'] = SecureRandom.uuid
         @recurring['start'] = @start
         duration = @stop - @start
-        recurrance = 0
+        recurrence = 0
         case @recurring['span']
         when 'minutes'
-          recurrance = @recurring['frequency'].to_i * 60
+          recurrence = @recurring['frequency'].to_i * 60
         when 'hours'
-          recurrance = @recurring['frequency'].to_i * 3600
+          recurrence = @recurring['frequency'].to_i * 3600
         when 'days'
-          recurrance = @recurring['frequency'].to_i * 86400
+          recurrence = @recurring['frequency'].to_i * 86400
         end
 
-        # Get all the existing events in the recurring time range as well as those before
-        # the start of the recurring time range to ensure we don't start inside an existing event
-        existing = Store.zrevrangebyscore(@primary_key, @recurring['end'] - 1, @recurring['start'] - MAX_DURATION)
-        existing.map! {|value| JSON.parse(value, :allow_nan => true, :create_additions => true) }
+        unless overlap
+          # Get all the existing events in the recurring time range as well as those before
+          # the start of the recurring time range to ensure we don't start inside an existing event
+          existing = Store.zrevrangebyscore(@primary_key, @recurring['end'] - 1, @recurring['start'] - MAX_DURATION)
+          existing.map! {|value| JSON.parse(value, :allow_nan => true, :create_additions => true) }
+        end
         last_stop = nil
 
         # Update @updated_at and add an event assuming it all completes ok
@@ -262,19 +291,21 @@ module OpenC3
         add_event(status: 'created')
 
         Store.multi do |multi|
-          (@start..@recurring['end']).step(recurrance).each do |start_time|
+          (@start..@recurring['end']).step(recurrence).each do |start_time|
             @start = start_time
             @stop = start_time + duration
 
             if last_stop and @start < last_stop
               @events.pop # Remove previously created event
-              raise ActivityOverlapError.new "Recurring activity overlap. Increase recurrance delta or decrease activity duration."
+              raise ActivityOverlapError.new "Recurring activity overlap. Increase recurrence delta or decrease activity duration."
             end
-            existing.each do |value|
-              if (@start >= value['start'] and @start < value['stop']) ||
-                (@stop > value['start'] and @stop <= value['stop'])
-                @events.pop # Remove previously created event
-                raise ActivityOverlapError.new "activity overlaps existing at #{value['start']}"
+            unless overlap
+              existing.each do |value|
+                if (@start >= value['start'] and @start < value['stop']) ||
+                  (@stop > value['start'] and @stop <= value['stop'])
+                  @events.pop # Remove previously created event
+                  raise ActivityOverlapError.new "activity overlaps existing at #{value['start']}"
+                end
               end
             end
             multi.zadd(@primary_key, @start, JSON.generate(self.as_json(:allow_nan => true)))
@@ -284,9 +315,9 @@ module OpenC3
         notify(kind: 'created')
       else
         validate_input(start: @start, stop: @stop, kind: @kind, data: @data)
-        if !overlap
+        unless overlap
           # If we don't allow overlap we need to validate the time
-          collision = validate_time()
+          collision = validate_time(@start, @stop)
           unless collision.nil?
             raise ActivityOverlapError.new "activity overlaps existing at #{collision}"
           end
@@ -308,20 +339,27 @@ module OpenC3
       end
 
       old_start = @start
-      set_input(start: start, stop: stop, kind: kind, data: data, events: @events)
-      @updated_at = Time.now.to_nsec_from_epoch
-      if !overlap
+      old_uuid = @uuid
+      unless overlap
         # If we don't allow overlap we need to validate the time
-        collision = validate_time(old_start)
+        collision = validate_time(start, stop, ignore_score: old_start)
         unless collision.nil?
           raise ActivityOverlapError.new "failed to update #{old_start}, no activities can overlap, collision: #{collision}"
         end
       end
+      set_input(start: start, stop: stop, kind: kind, data: data, events: @events)
+      @updated_at = Time.now.to_nsec_from_epoch
 
       add_event(status: 'updated')
-      Store.multi do |multi|
-        multi.zremrangebyscore(@primary_key, old_start, old_start)
-        multi.zadd(@primary_key, @start, JSON.generate(self.as_json(:allow_nan => true)))
+      json = Store.zrangebyscore(@primary_key, old_start, old_start)
+      parsed = json.map { |value| JSON.parse(value, :allow_nan => true, :create_additions => true) }
+      parsed.each_with_index do |value, index|
+        if value['uuid'] == old_uuid
+          Store.multi do |multi|
+            multi.zrem(@primary_key, json[index])
+            multi.zadd(@primary_key, @start, JSON.generate(self.as_json(:allow_nan => true)))
+          end
+        end
       end
       notify(kind: 'updated', extra: old_start)
       return @start
@@ -339,9 +377,16 @@ module OpenC3
       event['message'] = message unless message.nil?
       @fulfillment = fulfillment.nil? ? @fulfillment : fulfillment
       @events << event
-      Store.multi do |multi|
-        multi.zremrangebyscore(@primary_key, @start, @start)
-        multi.zadd(@primary_key, @start, JSON.generate(self.as_json(:allow_nan => true)))
+
+      json = Store.zrangebyscore(@primary_key, @start, @start)
+      parsed = json.map { |value| JSON.parse(value, :allow_nan => true, :create_additions => true) }
+      parsed.each_with_index do |value, index|
+        if value['uuid'] == @uuid
+          Store.multi do |multi|
+            multi.zrem(@primary_key, json[index])
+            multi.zadd(@primary_key, @start, JSON.generate(self.as_json(:allow_nan => true)))
+          end
+        end
       end
       notify(kind: 'event')
     end
@@ -356,24 +401,6 @@ module OpenC3
       @events << event
     end
 
-    # destroy the activity from the redis database
-    def destroy(recurring: false)
-      # Delete all recurring activities
-      if recurring and @recurring['end'] and @recurring['uuid']
-        uuid = @recurring['uuid']
-        array = Store.zrangebyscore("#{scope}#{PRIMARY_KEY}__#{@name}", @recurring['start'], @recurring['end'])
-        array.each do |value|
-          model = ActivityModel.from_json(value, name: @name, scope: @scope)
-          if model.recurring['uuid'] == uuid
-            Store.zremrangebyscore(@primary_key, model.start, model.start)
-          end
-        end
-      else
-        Store.zremrangebyscore(@primary_key, @start, @start)
-      end
-      notify(kind: 'deleted')
-    end
-
     # update the redis stream / timeline topic that something has changed
     def notify(kind:, extra: nil)
       notification = {
@@ -395,12 +422,14 @@ module OpenC3
       {
         'name' => @name,
         'updated_at' => @updated_at,
-        'fulfillment' => @fulfillment,
         'start' => @start,
         'stop' => @stop,
         'kind' => @kind,
-        'events' => @events,
         'data' => @data.as_json(*a),
+        'scope' => @scope,
+        'fulfillment' => @fulfillment,
+        'uuid' => @uuid,
+        'events' => @events,
         'recurring' => @recurring.as_json(*a)
       }
     end

data/lib/openc3/models/auth_model.rb

@@ -21,15 +21,22 @@
 # if purchased from OpenC3, Inc.
 
 require 'digest'
+require 'securerandom'
 require 'openc3/utilities/store'
 
 module OpenC3
   class AuthModel
     PRIMARY_KEY = 'OPENC3__TOKEN'
+    SESSIONS_KEY = 'OPENC3__SESSIONS'
 
     TOKEN_CACHE_TIMEOUT = 5
+    SESSION_CACHE_TIMEOUT = 5
     @@token_cache = nil
     @@token_cache_time = nil
+    @@session_cache = nil
+    @@session_cache_time = nil
+
+    MIN_TOKEN_LENGTH = 8
 
     def self.set?(key = PRIMARY_KEY)
       Store.exists(key) == 1
@@ -38,14 +45,23 @@ module OpenC3
     def self.verify(token)
       return false if token.nil? or token.empty?
 
+      time = Time.now
+      return true if @@session_cache and (time - @@session_cache_time) < SESSION_CACHE_TIMEOUT and @@session_cache[token]
       token_hash = hash(token)
-      return true if @@token_cache and (Time.now - @@token_cache_time) < TOKEN_CACHE_TIMEOUT and @@token_cache == token_hash
+      return true if @@token_cache and (time - @@token_cache_time) < TOKEN_CACHE_TIMEOUT and @@token_cache == token_hash
+
+      # Check sessions
+      @@session_cache = Store.hgetall(SESSIONS_KEY)
+      @@session_cache_time = time
+      return true if @@session_cache[token]
 
+      # Check Direct password
       @@token_cache = Store.get(PRIMARY_KEY)
-      @@token_cache_time = Time.now
+      @@token_cache_time = time
       return true if @@token_cache == token_hash
 
       # Handle a service password - Generally only used by ScriptRunner
+      # TODO: Replace this with temporary service tokens
       service_password = ENV['OPENC3_SERVICE_PASSWORD']
       return true if service_password and service_password == token
 
@@ -54,6 +70,7 @@ module OpenC3
 
     def self.set(token, old_token, key = PRIMARY_KEY)
       raise "token must not be nil or empty" if token.nil? or token.empty?
+      raise "token must be at least 8 characters" if token.length < MIN_TOKEN_LENGTH
 
       if set?(key)
         raise "old_token must not be nil or empty" if old_token.nil? or old_token.empty?
@@ -62,6 +79,18 @@ module OpenC3
       Store.set(key, hash(token))
     end
 
+    def self.generate_session
+      token = SecureRandom.urlsafe_base64(nil, false)
+      Store.hset(SESSIONS_KEY, token, Time.now.iso8601)
+      return token
+    end
+
+    def self.logout
+      Store.del(SESSIONS_KEY)
+      @@sessions_cache = nil
+      @@sessions_cache_time = nil
+    end
+
     def self.hash(token)
       Digest::SHA2.hexdigest token
     end

data/lib/openc3/models/cvt_model.rb

@@ -100,15 +100,21 @@ module OpenC3
       result, types = self._handle_item_override(target_name, packet_name, item_name, type: type, cache_timeout: cache_timeout, scope: scope)
       return result if result
       hash = get(target_name: target_name, packet_name: packet_name, cache_timeout: cache_timeout, scope: scope)
-      hash.values_at(*types).each do |result|
-        if result
+      hash.values_at(*types).each do |cvt_value|
+        if cvt_value
           if type == :FORMATTED or type == :WITH_UNITS
-            return result.to_s
+            return cvt_value.to_s
           end
-          return result
+          return cvt_value
         end
       end
-      return nil
+      # RECEIVED_COUNT is a special case where it is 0 if it doesn't exist
+      # This allows scripts to check against the value to see if the packet was ever received
+      if item_name == "RECEIVED_COUNT"
+        return 0
+      else
+        return nil
+      end
     end
 
     # Return all item values and limit state from the CVT

data/lib/openc3/models/gem_model.rb

@@ -90,16 +90,16 @@ module OpenC3
       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
+        # Look for local gems only first, this avoids lengthy 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
+      rescue Gem::Exception => e
         # 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}"
+    rescue => e
+      message = "Gem file #{gem_file_path} error installing to #{ENV['GEM_HOME']}\n#{e.formatted}"
       Logger.error message
-      raise err
+      raise e
     end
 
     def self.destroy(name, log_and_raise_needed_errors: true)
@@ -114,9 +114,9 @@ module OpenC3
       else
         begin
           Gem::Uninstaller.new(gem_name, {:version => version, :force => true}).uninstall
-        rescue => err
-          Logger.error "Gem file #{name} error uninstalling\n#{err.formatted}"
-          raise err
+        rescue => e
+          Logger.error "Gem file #{name} error uninstalling\n#{e.formatted}"
+          raise e
         end
       end
     end

data/lib/openc3/models/plugin_model.rb

@@ -69,7 +69,7 @@ module OpenC3
     end
 
     # Called by the PluginsController to parse the plugin variables
-    # Doesn't actaully create the plugin during the phase
+    # Doesn't actually create the plugin during the phase
     def self.install_phase1(gem_file_path, existing_variables: nil, existing_plugin_txt_lines: nil, process_existing: false, scope:, validate_only: false)
       gem_name = File.basename(gem_file_path).split("__")[0]
 
@@ -140,8 +140,8 @@ module OpenC3
     end
 
     # Called by the PluginsController to create the plugin
-    # Because this uses ERB it must be run in a seperate process from the API to
-    # prevent corruption and single require problems in the current proces
+    # Because this uses ERB it must be run in a separate process from the API to
+    # prevent corruption and single require problems in the current process
     def self.install_phase2(plugin_hash, scope:, gem_file_path: nil, validate_only: false)
       # Register plugin to aid in uninstall if install fails
       plugin_hash.delete("existing_plugin_txt_lines")

data/lib/openc3/models/reducer_model.rb

@@ -17,14 +17,14 @@
 # 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/store'
 
 module OpenC3
   # Tracks the files which are being stored in buckets for data reduction purposes.
-  # Files are stored in a Redis set by spliting their filenames and storing in
+  # Files are stored in a Redis set by splitting their filenames and storing in
   # a set named SCOPE__TARGET__reducer__TYPE, e.g. DEFAULT__INST__reducer__decom
   # Where TYPE can be 'decom', 'minute', or 'hour'. 'day' is not necessary because
   # day is the final reduction state. As files are reduced they are removed from

data/lib/openc3/models/scope_model.rb

@@ -110,7 +110,7 @@ module OpenC3
     end
 
     def create(update: false, force: false, queued: false)
-      # Ensure there are no "." in the scope name - prevents gems accidently becoming scope names
+      # Ensure there are no "." in the scope name - prevents gems accidentally becoming scope names
       raise "Invalid scope name: #{@name}" if @name !~ /^[a-zA-Z0-9_-]+$/
       @name = @name.upcase
       @scope = @name # Ensure @scope matches @name

data/lib/openc3/models/sorted_model.rb

@@ -34,15 +34,15 @@ module OpenC3
   class SortedOverlapError < SortedError; end
 
   class SortedModel < Model
-    SORTED_TYPE = 'sorted'.freeze # To be overriden by base class
-    PRIMARY_KEY = '__SORTED'.freeze # To be overriden by base class
+    SORTED_TYPE = 'sorted'.freeze # To be overridden by base class
+    PRIMARY_KEY = '__SORTED'.freeze # To be overridden by base class
 
-    # MUST be overriden by any subclasses
+    # MUST be overridden by any subclasses
     def self.pk(scope)
       return "#{scope}#{PRIMARY_KEY}"
     end
 
-    # MUST be overriden by any subclasses
+    # MUST be overridden by any subclasses
     def self.notify(scope:, kind:, start:, stop: nil)
       # Do nothing by default
     end

data/lib/openc3/models/target_model.rb

@@ -109,7 +109,7 @@ module OpenC3
         modified_targets = Bucket.getClient().list_files(bucket: ENV['OPENC3_CONFIG_BUCKET'], path: "DEFAULT/targets_modified/", only_directories: true)
         modified_targets.each do |target_name|
           # A target could have been deleted without removing the modified files
-          # Thus we have to check for the existance of the target_name key
+          # Thus we have to check for the existence of the target_name key
           if targets.has_key?(target_name)
             targets[target_name]['modified'] = true
           end
@@ -250,7 +250,7 @@ module OpenC3
         (items - found_items).each do |item|
           not_found << "'#{target_name} #{packet_name} #{item}'"
         end
-        # 'does not exist' not gramatically correct but we use it in every other exception
+        # 'does not exist' not grammatically correct but we use it in every other exception
         raise "Item(s) #{not_found.join(', ')} does not exist"
       end
       found
@@ -1121,7 +1121,7 @@ module OpenC3
             end
           end
           # If there are any topics (packets) left over that haven't been
-          # explictly handled above, spawn another microservice
+          # explicitly handled above, spawn another microservice
           if all_topics.length > 0
             instance = nil
             instance = deploy_count unless deploy_count == 0

data/lib/openc3/models/tool_config_model.rb

@@ -25,7 +25,7 @@ require 'openc3/utilities/local_mode'
 module OpenC3
   class ToolConfigModel
     def self.config_tool_names(scope: $openc3_scope)
-      cursor, keys = Store.scan(0, match: "#{scope}__config__*", type: 'hash', count: 100)
+      _, keys = Store.scan(0, match: "#{scope}__config__*", type: 'hash', count: 100)
       # Just return the tool name that is used in the other APIs
       return keys.map! { |key| key.split('__')[2] }.sort
     end

data/lib/openc3/models/tool_model.rb

@@ -96,7 +96,7 @@ module OpenC3
     def self.set_position(name:, position:, scope:)
       moving = from_json(get(name: name, scope: scope), scope: scope)
       old_pos = moving.position
-      new_pos = Integer(position)
+      new_pos = position
       direction = :down
       if (old_pos == new_pos)
         return # we're not doing anything
@@ -225,7 +225,7 @@ module OpenC3
         @shown = ConfigParser.handle_true_false(parameters[0])
       when 'POSITION'
         parser.verify_num_parameters(1, 1, "POSITION <value>")
-        @position = parameters[0].to_i
+        @position = parameters[0].to_f
       when 'DISABLE_ERB'
         # 0 to unlimited parameters
         @disable_erb ||= []
@@ -274,8 +274,8 @@ module OpenC3
           ConfigTopic.write({ kind: 'deleted', type: 'tool', name: @folder_name, plugin: @plugin }, scope: @scope)
         end
       end
-    rescue Exception => error
-      Logger.error("Error undeploying tool model #{@name} in scope #{@scope} due to #{error}")
+    rescue Exception => e
+      Logger.error("Error undeploying tool model #{@name} in scope #{@scope} due to #{e}")
     end
 
     ##################################################