openc3 5.13.0 → 5.14.1

data/lib/openc3/api/limits_api.rb

@@ -190,10 +190,10 @@ module OpenC3
     #               'TVAC' => [-25, -10, 50, 55] }
     #
     # @return [Hash{String => Array<Number, Number, Number, Number, Number, Number>}]
-    def get_limits(target_name, packet_name, item_name, scope: $openc3_scope, token: $openc3_token)
+    def get_limits(target_name, packet_name, item_name, cache_timeout: nil, scope: $openc3_scope, token: $openc3_token)
       authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
       limits = {}
-      item = _get_item(target_name, packet_name, item_name, scope: scope)
+      item = _get_item(target_name, packet_name, item_name, cache_timeout: cache_timeout, scope: scope)
       item['limits'].each do |key, vals|
         next unless vals.is_a?(Hash)
 
@@ -374,7 +374,7 @@ module OpenC3
     # @param item_name [String] item name
     # @param scope [String] scope
     # @return Hash The requested item based on the packet name
-    def _get_item(target_name, packet_name, item_name, cache_timeout: 0.1, scope:)
+    def _get_item(target_name, packet_name, item_name, cache_timeout: nil, scope:)
       # Determine if this item exists, it will raise appropriate errors if not
       packet_name = CvtModel.determine_latest_packet_for_item(target_name, item_name, cache_timeout: cache_timeout, scope: $openc3_scope) if packet_name == 'LATEST'
       return TargetModel.packet_item(target_name, packet_name, item_name, scope: scope)

data/lib/openc3/api/tlm_api.rb

@@ -69,26 +69,26 @@ 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
     # @return [Object] The telemetry value formatted as requested
-    def tlm(*args, type: :CONVERTED, cache_timeout: 0.1, scope: $openc3_scope, token: $openc3_token)
+    def tlm(*args, type: :CONVERTED, cache_timeout: nil, scope: $openc3_scope, token: $openc3_token)
       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
 
-    def tlm_raw(*args, cache_timeout: 0.1, scope: $openc3_scope, token: $openc3_token)
+    def tlm_raw(*args, cache_timeout: nil, scope: $openc3_scope, token: $openc3_token)
       tlm(*args, type: :RAW, cache_timeout: cache_timeout, scope: scope, token: token)
     end
 
-    def tlm_formatted(*args, cache_timeout: 0.1, scope: $openc3_scope, token: $openc3_token)
+    def tlm_formatted(*args, cache_timeout: nil, scope: $openc3_scope, token: $openc3_token)
       tlm(*args, type: :FORMATTED, cache_timeout: cache_timeout, scope: scope, token: token)
     end
 
-    def tlm_with_units(*args, cache_timeout: 0.1, scope: $openc3_scope, token: $openc3_token)
+    def tlm_with_units(*args, cache_timeout: nil, scope: $openc3_scope, token: $openc3_token)
       tlm(*args, type: :WITH_UNITS, cache_timeout: cache_timeout, scope: scope, token: token)
     end
 
     # @deprecated Use tlm with type:
-    def tlm_variable(*args, cache_timeout: 0.1, scope: $openc3_scope, token: $openc3_token)
+    def tlm_variable(*args, cache_timeout: nil, scope: $openc3_scope, token: $openc3_token)
       tlm(*args[0..-2], type: args[-1].intern, cache_timeout: cache_timeout, scope: scope, token: token)
     end
 
@@ -226,7 +226,7 @@ module OpenC3
     # @return [Array<String, Object, Symbol|nil>] Returns an Array consisting
     #   of [item name, item value, item limits state] where the item limits
     #   state can be one of {OpenC3::Limits::LIMITS_STATES}
-    def get_tlm_packet(*args, stale_time: 30, type: :CONVERTED, cache_timeout: 0.1, scope: $openc3_scope, token: $openc3_token)
+    def get_tlm_packet(*args, stale_time: 30, type: :CONVERTED, cache_timeout: nil, scope: $openc3_scope, token: $openc3_token)
       target_name, packet_name = _extract_target_packet_names('get_tlm_packet', *args)
       authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
       packet = TargetModel.packet(target_name, packet_name, scope: scope)
@@ -248,7 +248,7 @@ module OpenC3
     # @return [Array<Object, Symbol>]
     #   Array consisting of the item value and limits state
     #   given as symbols such as :RED, :YELLOW, :STALE
-    def get_tlm_values(items, stale_time: 30, cache_timeout: 0.1, scope: $openc3_scope, token: $openc3_token)
+    def get_tlm_values(items, stale_time: 30, cache_timeout: nil, scope: $openc3_scope, token: $openc3_token)
       if !items.is_a?(Array) || !items[0].is_a?(String)
         raise ArgumentError, "items must be array of strings: ['TGT__PKT__ITEM__TYPE', ...]"
       end
@@ -466,7 +466,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: nil, scope: $openc3_scope, token: $openc3_token)
       case args.length
       when 1
         target_name, packet_name, item_name = extract_fields_from_tlm_text(args[0])

data/lib/openc3/interfaces/interface.rb

@@ -198,14 +198,16 @@ module OpenC3
             log_dont_log.upcase!
             period = "#{period.to_f}s"
             @scheduler.every period do
-              begin
-                if log_dont_log == 'DONT_LOG'
-                  cmd(cmd_string, log_message: false)
-                else
-                  cmd(cmd_string)
+              if connected?()
+                begin
+                  if log_dont_log == 'DONT_LOG'
+                    cmd(cmd_string, log_message: false)
+                  else
+                    cmd(cmd_string)
+                  end
+                rescue Exception => err
+                  Logger.error("Error sending periodic cmd(#{cmd_string}):\n#{err.formatted}")
                 end
-              rescue Exception => err
-                Logger.error("Error sending periodic cmd(#{cmd_string}):\n#{err.formatted}")
               end
             end
           end

data/lib/openc3/interfaces/protocols/cmd_response_protocol.rb

@@ -0,0 +1,116 @@
+# encoding: ascii-8bit
+
+# Copyright 2024 OpenC3, Inc.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# This file may also be used under the terms of a commercial license
+# if purchased from OpenC3, Inc.
+
+require 'openc3/config/config_parser'
+require 'openc3/interfaces/protocols/protocol'
+require 'thread' # For Queue
+require 'timeout' # For Timeout::Error
+
+module OpenC3
+  # Protocol that waits for a response for any commands with a defined response packet.
+  # The response packet is identified but not defined by the protocol.
+  class CmdResponseProtocol < Protocol
+    # @param response_timeout [Float] Number of seconds to wait before timing out
+    #   when waiting for a response
+    # @param response_polling_period [Float] Number of seconds to wait between polling
+    #   for a response
+    # @param raise_exceptions [String] Whether to raise exceptions when errors
+    #   occur in the protocol like unexpected responses or response timeouts.
+    # @param allow_empty_data [true/false/nil] See Protocol#initialize
+    def initialize(
+      response_timeout = 5.0,
+      response_polling_period = 0.02,
+      raise_exceptions = false,
+      allow_empty_data = nil
+    )
+      super(allow_empty_data)
+      @response_timeout = ConfigParser.handle_nil(response_timeout)
+      @response_timeout = @response_timeout.to_f if @response_timeout
+      @response_polling_period = response_polling_period.to_f
+      @raise_exceptions = ConfigParser.handle_true_false(raise_exceptions)
+      @write_block_queue = Queue.new
+      @response_packet = nil
+    end
+
+    def connect_reset
+      super()
+      @write_block_queue.clear
+    end
+
+    def disconnect_reset
+      super()
+      @write_block_queue << nil # Unblock the write block queue
+    end
+
+    def read_packet(packet)
+      if @response_packet
+        # Grab the response packet specified in the command
+        result_packet = System.telemetry.packet(@response_packet[0], @response_packet[1]).clone
+        result_packet.buffer = packet.buffer
+        result_packet.received_time = nil
+        result_packet.stored = packet.stored
+        result_packet.extra = packet.extra
+
+        # Release the write
+        @write_block_queue << nil
+
+        # This returns the fully identified and defined packet
+        # Received time is handled by the interface microservice
+        return result_packet
+      else
+        return packet
+      end
+    end
+
+    def write_packet(packet)
+      # Setup the response packet (if there is one)
+      # This primes waiting for the response in post_write_interface
+      @response_packet = packet.response
+
+      return packet
+    end
+
+    def post_write_interface(packet, data, extra = nil)
+      if @response_packet
+        if @response_timeout
+          response_timeout_time = Time.now + @response_timeout
+        else
+          response_timeout_time = nil
+        end
+
+        # Block the write until the response is received
+        begin
+          @write_block_queue.pop(true)
+        rescue
+          sleep(@response_polling_period)
+          retry if !response_timeout_time
+          retry if response_timeout_time and Time.now < response_timeout_time
+          handle_error("#{@interface ? @interface.name : ""}: Timeout waiting for response")
+        end
+
+        @response_packet = nil
+      end
+      return super(packet, data, extra)
+    end
+
+    def handle_error(msg)
+      Logger.error(msg)
+      raise msg if @raise_exceptions
+    end
+  end
+end

data/lib/openc3/interfaces/tcpip_client_interface.rb

@@ -67,6 +67,10 @@ module OpenC3
         @write_timeout,
         @read_timeout
       )
+      # Pass down options to the stream
+      @options.each do |option_name, option_values|
+        @stream.set_option(option_name, option_values)
+      end
       super()
     end
   end

data/lib/openc3/interfaces/tcpip_server_interface.rb

@@ -391,6 +391,11 @@ module OpenC3
       read_socket = socket if listen_read
       stream = TcpipSocketStream.new(write_socket, read_socket, @write_timeout, @read_timeout)
 
+      # Pass down options to the stream
+      @options.each do |option_name, option_values|
+        stream.set_option(option_name, option_values)
+      end
+
       interface = StreamInterface.new
       interface.target_names = @target_names
       interface.cmd_target_names = @cmd_target_names

data/lib/openc3/interfaces.rb

@@ -42,7 +42,7 @@ module OpenC3
   autoload(:PreidentifiedProtocol, 'openc3/interfaces/protocols/preidentified_protocol.rb')
   autoload(:TemplateProtocol, 'openc3/interfaces/protocols/template_protocol.rb')
   autoload(:TerminatedProtocol, 'openc3/interfaces/protocols/terminated_protocol.rb')
-
+  autoload(:CmdResponseProtocol, 'openc3/interfaces/protocols/cmd_response_protocol.rb')
   autoload(:CrcProtocol, 'openc3/interfaces/protocols/crc_protocol.rb')
   autoload(:IgnorePacketProtocol, 'openc3/interfaces/protocols/ignore_packet_protocol.rb')
 end

data/lib/openc3/microservices/decom_microservice.rb

@@ -45,6 +45,7 @@ module OpenC3
     end
 
     def run
+      setup_microservice_topic()
       while true
         break if @cancel_thread
 
@@ -52,8 +53,9 @@ module OpenC3
           OpenC3.in_span("read_topics") do
             Topic.read_topics(@topics) do |topic, msg_id, msg_hash, redis|
               break if @cancel_thread
-
-              if topic =~ /__DECOMINTERFACE/
+              if topic == @microservice_topic
+                microservice_cmd(topic, msg_id, msg_hash, redis)
+              elsif topic =~ /__DECOMINTERFACE/
                 if msg_hash.key?('inject_tlm')
                   handle_inject_tlm(msg_hash['inject_tlm'])
                   next
@@ -100,6 +102,7 @@ module OpenC3
           packet.extra = extra
         end
         packet.buffer = msg_hash["buffer"]
+        packet.process # Run processors
         packet.check_limits(System.limits_set) # Process all the limits and call the limits_change_callback (as necessary)
 
         TelemetryDecomTopic.write_packet(packet, scope: @scope)

data/lib/openc3/microservices/interface_microservice.rb

@@ -613,7 +613,16 @@ module OpenC3
 
     def connect
       @logger.info "#{@interface.name}: Connecting ..."
-      @interface.connect
+      begin
+        @interface.connect
+      rescue Exception => error
+        begin
+          @interface.disconnect # Ensure disconnect is called at least once on a partial connect
+        rescue Exception
+          # We want to report any connect errors, not disconnect in this case
+        end
+        raise error
+      end
       @interface.state = 'CONNECTED'
       if @interface_or_router == 'INTERFACE'
         InterfaceStatusModel.set(@interface.as_json(:allow_nan => true), scope: @scope)

data/lib/openc3/microservices/log_microservice.rb

@@ -62,12 +62,17 @@ module OpenC3
 
     def run
       setup_plws()
+      setup_microservice_topic()
       while true
         break if @cancel_thread
 
         Topic.read_topics(@topics) do |topic, msg_id, msg_hash, redis|
           break if @cancel_thread
-          log_data(topic, msg_id, msg_hash, redis)
+          if topic == @microservice_topic
+            microservice_cmd(topic, msg_id, msg_hash, redis)
+          else
+            log_data(topic, msg_id, msg_hash, redis)
+          end
           @count += 1
           @metric.set(name: 'log_total', value: @count, type: 'counter')
         end

data/lib/openc3/microservices/microservice.rb

@@ -116,6 +116,7 @@ module OpenC3
       end
       @logger.info("Microservice initialized with config:\n#{@config}")
       @topics ||= []
+      @microservice_topic = "MICROSERVICE__#{@name}"
 
       # Get configuration for any targets
       @target_names = @config["target_names"]
@@ -210,5 +211,32 @@ module OpenC3
       @logger.info("Shutting down microservice complete: #{@name}")
       @shutdown_complete = true
     end
+
+    def setup_microservice_topic
+      @topics.append(@microservice_topic)
+      Thread.current[:topic_offsets] ||= {}
+      topic_offsets = Thread.current[:topic_offsets]
+      topic_offsets[@microservice_topic] = "0-0" # Always get all available
+    end
+
+    # Returns if the command was handled
+    def microservice_cmd(topic, msg_id, msg_hash, redis)
+      command = msg_hash['command']
+      case command
+      when 'ADD_TOPICS'
+        topics = JSON.parse(msg_hash['topics'])
+        if topics and Array === topics
+          topics.each do |new_topic|
+            @topics << new_topic unless @topics.include?(new_topic)
+          end
+        else
+          raise "Invalid topics given to microservice_cmd: #{topics}"
+        end
+        Topic.trim_topic(topic, msg_id)
+        return true
+      end
+      Topic.trim_topic(topic, msg_id)
+      return false
+    end
   end
 end

data/lib/openc3/models/cvt_model.rb

@@ -52,12 +52,14 @@ module OpenC3
 
     # Get the hash for packet in the CVT
     # Note: Does not apply overrides
-    def self.get(target_name:, packet_name:, cache_timeout: 0.1, scope: $openc3_scope)
+    def self.get(target_name:, packet_name:, cache_timeout: nil, scope: $openc3_scope)
       key = "#{scope}__tlm__#{target_name}"
       tgt_pkt_key = key + "__#{packet_name}"
-      cache_time, hash = @@packet_cache[tgt_pkt_key]
       now = Time.now
-      return hash if hash and (now - cache_time) < cache_timeout
+      if cache_timeout
+        cache_time, hash = @@packet_cache[tgt_pkt_key]
+        return hash if hash and (now - cache_time) < cache_timeout
+      end
       packet = Store.hget(key, packet_name)
       raise "Packet '#{target_name} #{packet_name}' does not exist" unless packet
       hash = JSON.parse(packet, :allow_nan => true, :create_additions => true)
@@ -67,7 +69,7 @@ module OpenC3
 
     # Set an item in the current value table
     def self.set_item(target_name, packet_name, item_name, value, type:, scope: $openc3_scope)
-      hash = get(target_name: target_name, packet_name: packet_name, cache_timeout: 0.0, scope: scope)
+      hash = get(target_name: target_name, packet_name: packet_name, cache_timeout: nil, scope: scope)
       case type
       when :WITH_UNITS
         hash["#{item_name}__U"] = value.to_s # WITH_UNITS should always be a string
@@ -89,10 +91,10 @@ module OpenC3
     end
 
     # Get an item from the current value table
-    def self.get_item(target_name, packet_name, item_name, type:, cache_timeout: 0.1, scope: $openc3_scope)
+    def self.get_item(target_name, packet_name, item_name, type:, cache_timeout: nil, scope: $openc3_scope)
       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, scope: scope)
+      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
           if type == :FORMATTED or type == :WITH_UNITS
@@ -109,7 +111,7 @@ module OpenC3
     # @param items [Array<String>] Items to return. Must be formatted as TGT__PKT__ITEM__TYPE
     # @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, cache_timeout: 0.1, scope: $openc3_scope)
+    def self.get_tlm_values(items, stale_time: 30, cache_timeout: nil, scope: $openc3_scope)
       now = Time.now
       results = []
       lookups = []
@@ -246,7 +248,7 @@ module OpenC3
       end
     end
 
-    def self.determine_latest_packet_for_item(target_name, item_name, cache_timeout: 0.1, scope: $openc3_scope)
+    def self.determine_latest_packet_for_item(target_name, item_name, cache_timeout: nil, scope: $openc3_scope)
       item_map = TargetModel.get_item_to_packet_map(target_name, scope: scope)
       packet_names = item_map[item_name]
       raise "Item '#{target_name} LATEST #{item_name}' does not exist for scope: #{scope}" unless packet_names
@@ -293,10 +295,12 @@ module OpenC3
     end
 
     def self._get_overrides(now, tgt_pkt_key, overrides, target_name, packet_name, cache_timeout:, scope:)
-      cache_time, hash = @@override_cache[tgt_pkt_key]
-      if hash and (now - cache_time) < cache_timeout
-        overrides[tgt_pkt_key] = hash
-        return hash
+      if cache_timeout
+        cache_time, hash = @@override_cache[tgt_pkt_key]
+        if hash and (now - cache_time) < cache_timeout
+          overrides[tgt_pkt_key] = hash
+          return hash
+        end
       end
       override_data = Store.hget("#{scope}__override__#{target_name}", packet_name)
       if override_data

data/lib/openc3/models/gem_model.rb

@@ -39,11 +39,17 @@ module OpenC3
     include Api
 
     def self.names
-      result = Pathname.new("#{ENV['GEM_HOME']}/gems").children.select { |c| c.directory? }.collect { |p| File.basename(p) + '.gem' }
+      if Dir.exist?("#{ENV['GEM_HOME']}/gems")
+        result = Pathname.new("#{ENV['GEM_HOME']}/gems").children.select { |c| c.directory? }.collect { |p| File.basename(p) + '.gem' }
+      else
+        result = []
+      end
       return result.sort
     end
 
     def self.get(name)
+      path = "#{ENV['GEM_HOME']}/cosmoscache/#{name}"
+      return path if File.exist?(path)
       path = "#{ENV['GEM_HOME']}/cache/#{name}"
       return path if File.exist?(path)
       raise "Gem #{name} not found"
@@ -52,8 +58,9 @@ module OpenC3
     def self.put(gem_file_path, gem_install: true, scope:)
       if File.file?(gem_file_path)
         gem_filename = File.basename(gem_file_path)
-        FileUtils.mkdir_p("#{ENV['GEM_HOME']}/cache") unless Dir.exist?("#{ENV['GEM_HOME']}/cache")
-        FileUtils.cp(gem_file_path, "#{ENV['GEM_HOME']}/cache/#{File.basename(gem_file_path)}")
+        # Put into cosmoscache folder that we control
+        FileUtils.mkdir_p("#{ENV['GEM_HOME']}/cosmoscache") unless Dir.exist?("#{ENV['GEM_HOME']}/cosmoscache")
+        FileUtils.cp(gem_file_path, "#{ENV['GEM_HOME']}/cosmoscache/#{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], "package_install", gem_filename, Time.now + 3600.0, scope: scope)
@@ -118,5 +125,15 @@ module OpenC3
       version = File.basename(split_name[-1], '.gem')
       return gem_name, version
     end
+
+    def self.destroy_all_other_versions(name)
+      keep_gem_name, keep_gem_version = GemModel.extract_name_and_version(name)
+      GemModel.names.each do |gem_full_name|
+        gem_name, gem_version = GemModel.extract_name_and_version(gem_full_name)
+        if gem_name == keep_gem_name and gem_version != keep_gem_version
+          GemModel.destroy(gem_full_name)
+        end
+      end
+    end
   end
 end

data/lib/openc3/models/microservice_model.rb

@@ -43,6 +43,7 @@ module OpenC3
     attr_accessor :secrets
     attr_accessor :prefix
     attr_accessor :disable_erb
+    attr_accessor :ignore_changes
 
     # NOTE: The following three class methods are used by the ModelController
     # and are reimplemented to enable various Model class methods to work
@@ -103,6 +104,7 @@ module OpenC3
       secrets: [],
       prefix: nil,
       disable_erb: nil,
+      ignore_changes: nil,
       scope:
     )
       parts = name.split("__")
@@ -128,6 +130,7 @@ module OpenC3
       @secrets = secrets
       @prefix = prefix
       @disable_erb = disable_erb
+      @ignore_changes = ignore_changes
       @bucket = Bucket.getClient()
     end
 
@@ -149,7 +152,8 @@ module OpenC3
         'needs_dependencies' => @needs_dependencies,
         'secrets' => @secrets.as_json(*a),
         'prefix' => @prefix,
-        'disable_erb' => @disable_erb
+        'disable_erb' => @disable_erb,
+        'ignore_changes' => @ignore_changes
       }
     end
 
@@ -185,7 +189,7 @@ module OpenC3
         @topics << parameters[0]
       when 'TARGET_NAME'
         parser.verify_num_parameters(1, 1, "#{keyword} <Target Name>")
-        @target_names << parameters[0]
+        @target_names << parameters[0].upcase
       when 'CMD'
         parser.verify_num_parameters(1, nil, "#{keyword} <Args>")
         @cmd = parameters.dup

data/lib/openc3/models/plugin_model.rb

@@ -158,6 +158,11 @@ module OpenC3
           gem_file_path = OpenC3::GemModel.get(gem_name)
         end
 
+        # Attempt to remove all older versions of this same plugin before install to prevent version conflicts
+        # Especially on downgrades
+        # Leave the same version if it already exists
+        OpenC3::GemModel.destroy_all_other_versions(File.basename(gem_file_path))
+
         # Actually install the gem now (slow)
         OpenC3::GemModel.install(gem_file_path, scope: scope) unless validate_only
 
@@ -337,7 +342,7 @@ module OpenC3
         raise message
       end
     rescue Exception => error
-      Logger.error("Error undeploying plugin model #{@name} in scope #{@scope} due to: #{error}")
+      Logger.error("Error undeploying plugin model #{@name} in scope #{@scope} due to: #{error.formatted}")
     ensure
       # Double check everything is gone
       found = []
@@ -356,7 +361,6 @@ module OpenC3
     # Reinstall
     def restore
       plugin_hash = self.as_json(:allow_nan => true)
-      plugin_hash['name'] = plugin_hash['name'].split("__")[0]
       OpenC3::PluginModel.install_phase2(plugin_hash, scope: @scope)
       @destroyed = false
     end