openc3 5.12.0 → 5.14.0

data/lib/openc3/utilities/cli_generator.rb

@@ -1,6 +1,6 @@
 # encoding: ascii-8bit
 
-# Copyright 2023 OpenC3, Inc.
+# Copyright 2024 OpenC3, Inc.
 # All Rights Reserved.
 #
 # This program is free software; you can modify and/or redistribute it
@@ -40,20 +40,33 @@ module OpenC3
       if args[0] != 'plugin' and Dir.glob("*.gemspec").empty?
         abort("No gemspec file detected. #{args[0].to_s.downcase} generator should be run within an existing plugin.")
       end
+
+      if args[-1] == '--python'
+        @@language = 'py'
+      else
+        @@language = 'rb'
+      end
     end
 
     def self.process_template(template_dir, the_binding)
       Dir.glob("#{template_dir}/**/*", File::FNM_DOTMATCH).each do |file|
         next if File.basename(file) == '.'
+        if @@language == 'rb'
+          # Ignore python files if we're ruby
+          next if File.extname(file) == '.py'
+        elsif @@language == 'py'
+          # Ignore ruby files if we're python
+          next if File.extname(file) == '.rb'
+        end
         base_name = file.sub("#{template_dir}/", '')
         next if yield base_name
         if File.directory?(file)
-          FileUtils.mkdir(base_name) unless File.exist?(base_name)
+          FileUtils.mkdir_p(base_name)
           next
         end
-        output = ERB.new(File.read(file).comment_erb(), trim_mode: "-").result(the_binding)
-        File.open(base_name, 'w') do |file|
-          file.write output
+        output = ERB.new(File.read(file), trim_mode: "-").result(the_binding)
+        File.open(base_name, 'w') do |base_file|
+          base_file.write output
         end
       end
     end
@@ -82,8 +95,8 @@ module OpenC3
     end
 
     def self.generate_target(args)
-      if args.length != 2
-        abort("Usage: cli generate #{args[0]} <NAME>")
+      if args.length < 2 or args.length > 3
+        abort("Usage: cli generate #{args[0]} <NAME> (--ruby or --python)")
       end
 
       # Create the local variables
@@ -92,17 +105,31 @@ module OpenC3
       if File.exist?(target_path)
         abort("Target #{target_path} already exists!")
       end
-      target_lib_filename = "#{target_name.downcase}.rb"
+      target_lib_filename = "#{target_name.downcase}.#{@@language}"
       target_class = target_lib_filename.filename_to_class_name
       target_object = target_name.downcase
 
       process_template("#{TEMPLATES_DIR}/target", binding) do |filename|
         # Rename the template TARGET to our actual target named after the plugin
         filename.sub!("targets/TARGET", "targets/#{target_name}")
-        filename.sub!("target.rb", target_lib_filename)
+        filename.sub!("target.#{@@language}", target_lib_filename)
         false
       end
 
+      if @@language == 'py'
+        # If we're using Python create a requirements.txt and list it in the gemspec
+        # However, don't write over an existing file they may have already created
+        unless File.exist?("requirements.txt")
+          File.open("requirements.txt", 'w') do |file|
+            file.puts "# Python dependencies"
+          end
+        end
+        gemspec_filename = Dir['*.gemspec'][0]
+        gemspec = File.read(gemspec_filename)
+        gemspec.gsub!('plugin.txt', 'plugin.txt requirements.txt')
+        File.write(gemspec_filename, gemspec)
+      end
+
       # Add this target to plugin.txt
       File.open("plugin.txt", 'a') do |file|
         file.puts <<~DOC
@@ -120,8 +147,8 @@ module OpenC3
     end
 
     def self.generate_microservice(args)
-      if args.length != 2
-        abort("Usage: cli generate #{args[0]} <NAME>")
+      if args.length < 2 or args.length > 3
+        abort("Usage: cli generate #{args[0]} <NAME> (--ruby or --python)")
       end
 
       # Create the local variables
@@ -130,13 +157,13 @@ module OpenC3
       if File.exist?(microservice_path)
         abort("Microservice #{microservice_path} already exists!")
       end
-      microservice_filename = "#{microservice_name.downcase}.rb"
+      microservice_filename = "#{microservice_name.downcase}.#{@@language}"
       microservice_class = microservice_filename.filename_to_class_name
 
       process_template("#{TEMPLATES_DIR}/microservice", binding) do |filename|
         # Rename the template MICROSERVICE to our actual microservice name
         filename.sub!("microservices/TEMPLATE", "microservices/#{microservice_name}")
-        filename.sub!("microservice.rb", microservice_filename)
+        filename.sub!("microservice.#{@@language}", microservice_filename)
         false
       end
 
@@ -252,8 +279,8 @@ module OpenC3
     self.singleton_class.send(:alias_method, :generate_tool_svelte, :generate_tool)
 
     def self.generate_conversion(args)
-      if args.length != 3
-        abort("Usage: cli generate conversion <TARGET> <NAME>")
+      if args.length < 3 or args.length > 4
+        abort("Usage: cli generate conversion <TARGET> <NAME> (--ruby or --python)")
       end
 
       # Create the local variables
@@ -263,7 +290,7 @@ module OpenC3
       end
       conversion_name = "#{args[2].upcase.gsub(/_+|-+/, '_')}_CONVERSION"
       conversion_path = "targets/#{target_name}/lib/"
-      conversion_basename = "#{conversion_name.downcase}.rb"
+      conversion_basename = "#{conversion_name.downcase}.#{@@language}"
       conversion_class = conversion_basename.filename_to_class_name
       conversion_filename = "targets/#{target_name}/lib/#{conversion_basename}"
       if File.exist?(conversion_filename)
@@ -271,7 +298,7 @@ module OpenC3
       end
 
       process_template("#{TEMPLATES_DIR}/conversion", binding) do |filename|
-        filename.sub!("conversion.rb", conversion_filename)
+        filename.sub!("conversion.#{@@language}", conversion_filename)
         false
       end
 
@@ -282,8 +309,8 @@ module OpenC3
     end
 
     def self.generate_limits_response(args)
-      if args.length != 3
-        abort("Usage: cli generate limits_response <TARGET> <NAME>")
+      if args.length < 3 or args.length > 4
+        abort("Usage: cli generate limits_response <TARGET> <NAME> (--ruby or --python)")
       end
 
       # Create the local variables
@@ -293,7 +320,7 @@ module OpenC3
       end
       response_name = "#{args[2].upcase.gsub(/_+|-+/, '_')}_LIMITS_RESPONSE"
       response_path = "targets/#{target_name}/lib/"
-      response_basename = "#{response_name.downcase}.rb"
+      response_basename = "#{response_name.downcase}.#{@@language}"
       response_class = response_basename.filename_to_class_name
       response_filename = "targets/#{target_name}/lib/#{response_basename}"
       if File.exist?(response_filename)
@@ -301,7 +328,7 @@ module OpenC3
       end
 
       process_template("#{TEMPLATES_DIR}/limits_response", binding) do |filename|
-        filename.sub!("response.rb", response_filename)
+        filename.sub!("response.#{@@language}", response_filename)
         false
       end
 

data/lib/openc3/utilities/local_mode.rb

@@ -29,9 +29,7 @@ module OpenC3
     # When updating update local_mode.py, PluginsTab.vue, plugins.spec.ts
     DEFAULT_PLUGINS = [
       'openc3-cosmos-tool-admin',
-      'openc3-cosmos-tool-autonomic',
       'openc3-cosmos-tool-bucketexplorer',
-      'openc3-cosmos-tool-calendar',
       'openc3-cosmos-tool-cmdsender',
       'openc3-cosmos-tool-cmdtlmserver',
       'openc3-cosmos-tool-dataextractor',
@@ -47,6 +45,8 @@ module OpenC3
       'openc3-cosmos-tool-tlmviewer',
       'openc3-cosmos-enterprise-tool-admin',
       'openc3-enterprise-tool-base',
+      'openc3-cosmos-tool-autonomic',
+      'openc3-cosmos-tool-calendar',
       'openc3-tool-base',
     ]
 
@@ -252,7 +252,7 @@ module OpenC3
                     # New install of same plugin - Leave it alone
                   end
                 else
-                  # No exiting instance.json, but we found the same gem
+                  # No existing instance.json, but we found the same gem
                   # This shouldn't happen without users using this wrong
                   # We will update
                   found = true

data/lib/openc3/utilities/logger.rb

@@ -59,11 +59,11 @@ module OpenC3
     # FATAL prints FATAL, ERROR, WARN, INFO, DEBUG messages
     FATAL = ::Logger::FATAL
 
-    DEBUG_SEVERITY_STRING = 'DEBUG'
-    INFO_SEVERITY_STRING = 'INFO'
-    WARN_SEVERITY_STRING = 'WARN'
-    ERROR_SEVERITY_STRING = 'ERROR'
-    FATAL_SEVERITY_STRING = 'FATAL'
+    DEBUG_LEVEL = 'DEBUG'
+    INFO_LEVEL = 'INFO'
+    WARN_LEVEL = 'WARN'
+    ERROR_LEVEL = 'ERROR'
+    FATAL_LEVEL = 'FATAL'
 
     # Types
     LOG = 'log'
@@ -98,27 +98,27 @@ module OpenC3
     # @param block [Proc] Block to call which should return a string to append
     #   to the log message
     def debug(message = nil, scope: @@scope, user: nil, type: LOG, url: nil, &block)
-      log_message(DEBUG_SEVERITY_STRING, message, scope: scope, user: user, type: type, url: url, &block) if @level <= DEBUG
+      log_message(DEBUG_LEVEL, message, scope: scope, user: user, type: type, url: url, &block) if @level <= DEBUG
     end
 
     # (see #debug)
     def info(message = nil, scope: @@scope, user: nil, type: LOG, url: nil, &block)
-      log_message(INFO_SEVERITY_STRING, message, scope: scope, user: user, type: type, url: url, &block) if @level <= INFO
+      log_message(INFO_LEVEL, message, scope: scope, user: user, type: type, url: url, &block) if @level <= INFO
     end
 
     # (see #debug)
     def warn(message = nil, scope: @@scope, user: nil, type: LOG, url: nil, &block)
-      log_message(WARN_SEVERITY_STRING, message, scope: scope, user: user, type: type, url: url, &block) if @level <= WARN
+      log_message(WARN_LEVEL, message, scope: scope, user: user, type: type, url: url, &block) if @level <= WARN
     end
 
     # (see #debug)
     def error(message = nil, scope: @@scope, user: nil, type: LOG, url: nil, &block)
-      log_message(ERROR_SEVERITY_STRING, message, scope: scope, user: user, type: type, url: url, &block) if @level <= ERROR
+      log_message(ERROR_LEVEL, message, scope: scope, user: user, type: type, url: url, &block) if @level <= ERROR
     end
 
     # (see #debug)
     def fatal(message = nil, scope: @@scope, user: nil, type: LOG, url: nil, &block)
-      log_message(FATAL_SEVERITY_STRING, message, scope: scope, user: user, type: type, url: url, &block) if @level <= FATAL
+      log_message(FATAL_LEVEL, message, scope: scope, user: user, type: type, url: url, &block) if @level <= FATAL
     end
 
     # (see #debug)
@@ -174,10 +174,11 @@ module OpenC3
 
     protected
 
-    def log_message(severity_string, message, scope:, user:, type:, url:)
+    def log_message(log_level, message, scope:, user:, type:, url:)
       @@mutex.synchronize do
-        time = Time.now
-        data = { time: time.to_nsec_from_epoch, '@timestamp' => time.xmlschema(3), severity: severity_string }
+        time = Time.now.utc
+        # timestamp iso8601 with 6 decimal places to match the python output format
+        data = { time: time.to_nsec_from_epoch, '@timestamp' => time.iso8601(6), level: log_level }
         data[:microservice_name] = @microservice_name if @microservice_name
         data[:detail] = @detail_string if @detail_string
         data[:user] = user if user # EE: If a user is passed, put its name. Don't include user data if no user was passed.
@@ -185,12 +186,12 @@ module OpenC3
           message = yield
         end
         data[:container_name] = @container_name
-        data[:log] = message
+        data[:message] = message
         data[:type] = type
         data[:url] = url if url
         if @stdout
-          case severity_string
-          when WARN_SEVERITY_STRING, ERROR_SEVERITY_STRING, FATAL_SEVERITY_STRING
+          case log_level
+          when WARN_LEVEL, ERROR_LEVEL, FATAL_LEVEL
             if ENV['OPENC3_LOG_STDERR']
               $stderr.puts data.as_json(:allow_nan => true).to_json(:allow_nan => true)
               $stderr.flush

data/lib/openc3/utilities/process_manager.rb

@@ -96,7 +96,7 @@ module OpenC3
             process.status.output = output
             if process.exit_code != 0
               process.status.state = "Crashed"
-            elsif output.include?('"severity":"ERROR"') || output.include?('"severity":"WARN"')
+            elsif output.include?('"level":"ERROR"') || output.include?('"level":"WARN"')
               process.status.state = "Warning"
             else
               process.status.state = "Complete"

data/lib/openc3/utilities/store_queued.rb

@@ -0,0 +1,126 @@
+# 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/utilities/store'
+
+module OpenC3
+  class StoreQueued
+    # Variable that holds the singleton instance
+    @instance = nil
+
+    # Mutex used to ensure that only one instance is created
+    @@instance_mutex = Mutex.new
+
+    # Get the singleton instance
+    # Sets the update interval to 1 second by default
+    def self.instance(update_interval = 1) # seconds
+      return @instance if @instance
+
+      @@instance_mutex.synchronize do
+        @instance ||= self.new(update_interval)
+        return @instance
+      end
+    end
+
+    # Delegate all unknown class methods to delegate to the instance
+    def self.method_missing(message, *args, **kwargs, &)
+      self.instance.public_send(message, *args, **kwargs, &)
+    end
+
+    def initialize(update_interval)
+      @update_interval = update_interval
+      @store = store_instance()
+      # Queue to hold the store requests
+      @store_queue = Queue.new
+      # Sleeper used to delay update thread
+      @update_sleeper = Sleeper.new
+
+      at_exit() do
+        shutdown()
+      end
+
+      # Thread used to call methods on the store
+      @update_thread = OpenC3.safe_thread(self.class.to_s) do
+        store_thread_body()
+      end
+    end
+
+    def store_thread_body
+      while true
+        start_time = Time.now
+
+        unless @store_queue.empty?
+          # Pipeline the requests to redis to improve performance
+          @store.pipelined do
+            while !@store_queue.empty?
+              action = @store_queue.pop()
+              @store.method_missing(action.message, *action.args, **action.kwargs, &action.block)
+            end
+          end
+        end
+
+        # Only check whether to update at a set interval
+        run_time = Time.now - start_time
+        sleep_time = @update_interval - run_time
+        sleep_time = 0 if sleep_time < 0
+        break if @update_sleeper.sleep(sleep_time)
+      end
+    end
+
+    def shutdown
+      @update_sleeper.cancel if @update_sleeper
+      OpenC3.kill_thread(self, @update_thread) if @update_thread
+      @update_thread = nil
+      # Drain the queue before shutdown
+      unless @store_queue.empty?
+        # Pipeline the requests to redis to improve performance
+        @store.pipelined do
+          while !@store_queue.empty?
+            action = @store_queue.pop()
+            @store.method_missing(action.message, *action.args, **action.kwargs, &action.block)
+          end
+        end
+      end
+    end
+
+    # Record the message for pipelining by the thread
+    def method_missing(message, *args, **kwargs, &block)
+      o = OpenStruct.new
+      o.message = message
+      o.args = args
+      o.kwargs = kwargs
+      o.block = block
+      @store_queue.push(o)
+    end
+
+    # Returns the store we're working with
+    def store_instance
+      Store.instance
+    end
+
+    def graceful_kill
+      # Do nothing
+    end
+  end
+
+  class EphemeralStoreQueued < StoreQueued
+    def store_instance
+      EphemeralStore.instance
+    end
+  end
+end

data/lib/openc3/version.rb

@@ -1,14 +1,14 @@
 # encoding: ascii-8bit
 
-OPENC3_VERSION = '5.12.0'
+OPENC3_VERSION = '5.14.0'
 module OpenC3
   module Version
     MAJOR = '5'
-    MINOR = '12'
+    MINOR = '14'
     PATCH = '0'
     OTHER = ''
-    BUILD = '8f36977eacfebdcdae21f02223be66e69feaa2bf'
+    BUILD = 'dd31e4853fa50ed08ee3100e43e75849617d0a47'
   end
-  VERSION = '5.12.0'
-  GEM_VERSION = '5.12.0'
+  VERSION = '5.14.0'
+  GEM_VERSION = '5.14.0'
 end

data/templates/conversion/conversion.py

@@ -0,0 +1,28 @@
+from openc3.conversions.conversion import Conversion
+
+# Custom conversion class
+# See https://openc3.com/docs/v5/telemetry#read_conversion
+class <%= conversion_class %>(Conversion):
+    def __init__(self):
+        super().__init__()
+        # Should be one of 'INT', 'UINT', 'FLOAT', 'STRING', 'BLOCK'
+        self.converted_type = 'STRING'
+        # Size of the converted type in bits
+        # Use 0 for 'STRING' or 'BLOCK' where the size can be variable
+        self.converted_bit_size = 0
+
+    # @param value [Object] Value based on the item definition. This could be
+    #   a string, integer, float, or array of values.
+    # @param packet [Packet] The packet object where the conversion is defined
+    # @param buffer [String] The raw packet buffer
+    def call(self, value, packet, buffer):
+        # Read values from the packet and do a conversion
+        # Used for DERIVED items that don't have a value
+        # item1 = packet.read("ITEM1") # returns CONVERTED value (default)
+        # item2 = packet.read("ITEM2", 'RAW') # returns RAW value
+        # return (item1 + item2) / 2
+        #
+        # Perform conversion logic directly on value
+        # Used when conversion is applied to a regular (not DERIVED) item
+        # NOTE: You can also use packet.read("ITEM") to get additional values
+        # return value / 2 * packet.read("OTHER_ITEM")

data/templates/conversion/conversion.rb

@@ -1,21 +1,4 @@
 # encoding: ascii-8bit
-
-# Copyright 2023 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/conversions/conversion'
 
 module OpenC3
@@ -37,7 +20,7 @@ module OpenC3
     # @param buffer [String] The raw packet buffer
     def call(value, packet, buffer)
       # Read values from the packet and do a conversion
-      # Used for DERVIVED items that don't have a value
+      # Used for DERIVED items that don't have a value
       # item1 = packet.read("ITEM1") # returns CONVERTED value (default)
       # item2 = packet.read("ITEM2", :RAW) # returns RAW value
       # return (item1 + item2) / 2

data/templates/limits_response/response.py

@@ -0,0 +1,37 @@
+from openc3.packets.limits_response import LimitsResponse
+
+
+class <%= response_class %>(LimitsResponse):
+    # @param packet [Packet] Packet the limits response is assigned to
+    # @param item [PacketItem] PacketItem the limits response is assigned to
+    # @param old_limits_state [Symbol] Previous value of the limit. One of nil,
+    #   "GREEN_HIGH", "GREEN_LOW", "YELLOW", "YELLOW_HIGH", "YELLOW_LOW",
+    #   "RED", "RED_HIGH", "RED_LOW". nil if the previous limit state has not yet
+    #   been established.
+    def call(self, packet, item, old_limits_state):
+        # Take action based on the current limits state
+        # Delete any of the case lines that do not apply or you don't care about
+        match item.limits.state:
+            case "RED_HIGH":
+                # Take action like sending a command:
+                # cmd("TARGET SAFE")
+                pass
+            case "RED_LOW":
+                pass
+            case "YELLOW_LOW":
+                pass
+            case "YELLOW_HIGH":
+                pass
+            # GREEN limits are only available if a telemetry item has them defined
+            # COSMOS refers to these as "operational limits"
+            # See https://openc3.com/docs/v5/telemetry#limits
+            case "GREEN_LOW":
+                pass
+            case "GREEN_HIGH":
+                pass
+            # :RED and :YELLOW limits are triggered for STATES with defined RED and YELLOW states
+            # See https://openc3.com/docs/v5/telemetry#state
+            case "RED":
+                pass
+            case "YELLOW":
+                pass

data/templates/limits_response/response.rb

@@ -1,21 +1,4 @@
 # encoding: ascii-8bit
-
-# Copyright 2022 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/packets/limits_response'
 
 module OpenC3

data/templates/microservice/microservices/TEMPLATE/microservice.py

@@ -0,0 +1,54 @@
+import time
+from openc3.microservices.microservice import Microservice
+from openc3.utilities.sleeper import Sleeper
+from openc3.api import *
+
+
+class <%= microservice_class %>(Microservice):
+    def __init__(self, name):
+        super().__init__(name)
+        for option in self.config['options']:
+            # Update with your own OPTION handling
+            match option[0].upper():
+                case 'PERIOD':
+                    self.period = int(option[1])
+                case _:
+                    self.logger.error(
+                        "Unknown option passed to microservice #{@name}: #{option}"
+                    )
+
+        if not self.period:
+            self.period = 60  # 1 minutes
+        self.sleeper = Sleeper()
+
+    def run(self):
+        while True:
+            start_time = time.time()
+            if self.cancel_thread:
+                break
+
+            # Do your microservice work here
+            self.logger.info("Template Microservice ran")
+            # cmd("INST ABORT")
+
+            # The self.state variable is set to 'RUNNING' by the microservice base class
+            # The self.state is reflected to the user in the MICROSERVICES tab so you can
+            # convey long running actions by changing it, e.g. self.state = 'CALCULATING ...'
+
+            run_time = time.time() - start_time
+            delta = self.period - run_time
+            if delta > 0:
+                # Delay till the next period
+                if self.sleeper.sleep(
+                    delta
+                ):  # returns true and breaks loop on shutdown
+                    break
+            self.count += 1
+
+    def shutdown(self):
+        self.sleeper.cancel()  # Breaks out of run()
+        super().shutdown()
+
+
+if __name__ == "__main__":
+    <%= microservice_class %>.run()

data/templates/microservice/microservices/TEMPLATE/microservice.rb

@@ -1,11 +1,4 @@
 # encoding: ascii-8bit
-
-# Copyright 2023 OpenC3, Inc.
-# All Rights Reserved.
-#
-# This file may also be used under the terms of a commercial license
-# if purchased from OpenC3, Inc.
-
 require 'openc3/microservices/microservice'
 require 'openc3/api/api'
 

data/templates/plugin/.gitignore

@@ -0,0 +1 @@
+node_modules

data/templates/plugin/plugin.gemspec

@@ -1,7 +1,7 @@
 # encoding: ascii-8bit
 
 # Create the overall gemspec
-spec = Gem::Specification.new do |s|
+Gem::Specification.new do |s|
   s.name = '<%= plugin_name %>'
   s.summary = 'OpenC3 <%= plugin_name %> plugin'
   s.description = <<-EOF
@@ -10,7 +10,7 @@ spec = Gem::Specification.new do |s|
   s.license = 'MIT'
   s.authors = ['Anonymous']
   s.email = ['name@domain.com']
-  s.homepage = 'https://github.com/OpenC3/openc3'
+  s.homepage = 'https://github.com/OpenC3/cosmos'
   s.platform = Gem::Platform::RUBY
 
   if ENV['VERSION']

data/templates/target/targets/TARGET/lib/target.py

@@ -0,0 +1,9 @@
+# This class can be used in your scripts like so:
+#   require_utility '<%= target_class.upcase %>/lib/<%= target_lib_filename %>'
+#   <%= target_object %> = <%= target_class %>()
+#   <%= target_object %>.utility()
+# For more information see the OpenC3 scripting guide
+
+class <%= target_class %>:
+    def utility():
+        pass

data/templates/target/targets/TARGET/procedures/procedure.py

@@ -0,0 +1,3 @@
+# Script Runner test script
+cmd("<%= target_name %> EXAMPLE")
+wait_check("<%= target_name %> STATUS BOOL == 'FALSE'", 5)

data/templates/target/targets/TARGET/public/README.txt

@@ -0,0 +1 @@
+Put image files in this directory for use in Telemetry Viewer Canvas Image widgets such as CANVASIMAGE and CANVASIMAGEVALUE.