openc3 5.5.2 → 5.6.0

data/lib/openc3/script/script_runner.rb

@@ -40,7 +40,7 @@ module OpenC3
 
     def script_syntax_check(script, scope: $openc3_scope)
       endpoint = "/script-api/scripts/syntax"
-      response = $script_runner_api_server.request('post', endpoint, :data => script, scope: scope)
+      response = $script_runner_api_server.request('post', endpoint, json: true, data: script, scope: scope)
       if response.nil? || response.code != 200
         _script_response_error(response, "Script syntax check request failed", scope: scope)
       else
@@ -64,13 +64,24 @@ module OpenC3
       end
     end
 
-    def script_run(filename, disconnect: false, scope: $openc3_scope)
+    def script_run(filename, disconnect: false, environment: nil, scope: $openc3_scope)
       if disconnect
         endpoint = "/script-api/scripts/#{filename}/run/disconnect"
       else
         endpoint = "/script-api/scripts/#{filename}/run"
       end
-      response = $script_runner_api_server.request('post', endpoint, scope: scope)
+
+      # Encode the environment hash into an array of key values
+      if environment && !environment.empty?
+        env_data = []
+        environment.map do |key, value|
+          env_data << { "key" => key, "value" => value }
+        end
+      else
+        env_data = []
+      end
+      # NOTE: json: true causes json_api_object to JSON generate and set the Content-Type to json
+      response = $script_runner_api_server.request('post', endpoint, json: true, data: { environment: env_data }, scope: scope)
       if response.nil? || response.code != 200
         _script_response_error(response, "Failed to run #{filename}", scope: scope)
       else
@@ -111,7 +122,7 @@ module OpenC3
 
     def script_instrumented(filename, script, scope: $openc3_scope)
       endpoint = "/script-api/scripts/#{filename}/instrumented"
-      response = $script_runner_api_server.request('post', endpoint, :data => script, scope: scope)
+      response = $script_runner_api_server.request('post', endpoint, json: true, data: script, scope: scope)
       if response.nil? || response.code != 200
         _script_response_error(response, "Script instrumented request failed", scope: scope)
       else
@@ -127,7 +138,7 @@ module OpenC3
 
     def script_create(filename, script, breakpoints = [], scope: $openc3_scope)
       endpoint = "/script-api/scripts/#{filename}"
-      response = $script_runner_api_server.request('post', endpoint, :data => {text: script, breakpoints: breakpoints}, scope: scope)
+      response = $script_runner_api_server.request('post', endpoint, json: true, data: { text: script, breakpoints: breakpoints }, scope: scope)
       if response.nil? || response.code != 200
         _script_response_error(response, "Script create request failed", scope: scope)
       else
@@ -205,7 +216,7 @@ module OpenC3
 
     def running_script_debug(id, debug_code, scope: $openc3_scope)
       endpoint = "/script-api/running-script/#{id}/debug"
-      response = $script_runner_api_server.request('post', endpoint, data: {'args' => debug_code}, scope: scope)
+      response = $script_runner_api_server.request('post', endpoint, json: true, data: {'args' => debug_code}, scope: scope)
       if response.nil? || response.code != 200
         _script_response_error(response, "Running script debug request failed", scope: scope)
       else
@@ -216,9 +227,9 @@ module OpenC3
     def running_script_prompt(id, method_name, answer, prompt_id, password: nil, scope: $openc3_scope)
       endpoint = "/script-api/running-script/#{id}/prompt"
       if password
-        response = $script_runner_api_server.request('post', endpoint, data: {'method' => method_name, 'answer' => answer, 'prompt_id' => prompt_id, 'password' => password}, scope: scope)
+        response = $script_runner_api_server.request('post', endpoint, json: true, data: {'method' => method_name, 'answer' => answer, 'prompt_id' => prompt_id, 'password' => password}, scope: scope)
       else
-        response = $script_runner_api_server.request('post', endpoint, data: {'method' => method_name, 'answer' => answer, 'prompt_id' => prompt_id}, scope: scope)
+        response = $script_runner_api_server.request('post', endpoint, json: true, data: {'method' => method_name, 'answer' => answer, 'prompt_id' => prompt_id}, scope: scope)
       end
       if response.nil? || response.code != 200
         _script_response_error(response, "Running script prompt request failed", scope: scope)

data/lib/openc3/script/suite_results.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.
 
 module OpenC3
@@ -108,7 +108,7 @@ module OpenC3
     end
 
     def header
-      @report << "--- Test Report ---"
+      @report << "--- Script Report ---"
       # @report << ''
       # if @metadata
       #   begin

data/lib/openc3/script/web_socket_api.rb

@@ -401,12 +401,16 @@ module OpenC3
 end
 
 # # Example Use
+# # The following lines are only for outside of the COSMOS Docker or Kubernetes Cluster
+# # Environment variables are already set inside of our containers
+# # START OUTSIDE OF DOCKER ONLY
 # $openc3_scope = 'DEFAULT'
 # ENV['OPENC3_API_HOSTNAME'] = 'localhost'
 # ENV['OPENC3_API_PORT'] = '2900'
 # ENV['OPENC3_SCRIPT_API_HOSTNAME'] = 'localhost'
 # ENV['OPENC3_SCRIPT_API_PORT'] = '2900'
 # ENV['OPENC3_API_PASSWORD'] = 'password'
+# # END OUTSIDE OF DOCKER ONLY
 #
 # OpenC3::StreamingWebSocketApi.new do |api|
 #   api.add(items: ['DECOM__TLM__INST__HEALTH_STATUS__TEMP1__CONVERTED', 'DECOM__TLM__INST__HEALTH_STATUS__TEMP2__CONVERTED'])
@@ -420,4 +424,4 @@ end
 # end
 #
 # # Warning this saves all data to RAM. Do not use for large queries
-# data = OpenC3::StreamingWebSocketApi.read_all(items: ['DECOM__TLM__INST__HEALTH_STATUS__TEMP1__CONVERTED', 'DECOM__TLM__INST__HEALTH_STATUS__TEMP2__CONVERTED'], end_time: Time.now + 30)
+# data = OpenC3::StreamingWebSocketApi.read_all(items: ['DECOM__TLM__INST__HEALTH_STATUS__TEMP1__CONVERTED', 'DECOM__TLM__INST__HEALTH_STATUS__TEMP2__CONVERTED'], start_time: Time.now - 30, end_time: Time.now + 30)

data/lib/openc3/streams/serial_stream.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 'thread' # For Mutex
@@ -38,15 +38,13 @@ module OpenC3
     #   name is typically a device such as '/dev/ttyS0'.
     # @param baud_rate [Integer] The serial port baud rate
     # @param parity [Symbol] Must be :NONE, :EVEN, or :ODD
-    # @param stop_bits [Integer] Number of stop bits. Must be 1 or 2.
-    # @param write_timeout [Integer] Number of seconds to wait for the write to
-    #   complete. Pass nil to create no timeout. The {SerialDriver} will
-    #   continously try to send the data until it has been sent or an error
-    #   occurs.
-    # @param read_timeout [Integer] Number of seconds to wait for the read to
-    #   complete. Pass nil to create no timeout. The {SerialDriver} will
-    #   continously try to read data until it has received data or an error
-    #   occurs.
+    # @param stop_bits [Integer] Stop bits. Must be 1 or 2.
+    # @param write_timeout [Integer] Seconds to wait for the write to complete.
+    #   The {SerialDriver} will continously try to send the data until
+    #   it has been sent or an error occurs.
+    # @param read_timeout [Integer] Seconds to wait for the read to complete.
+    #   Pass nil to block until the read is complete. The {SerialDriver} will
+    #   continously try to read data until it has received data or an error occurs.
     # @param flow_control [Symbol] Currently supported :NONE and :RTSCTS (default :NONE)
     # @param data_bits [Integer] Number of data bits (default 8)
     def initialize(write_port_name,
@@ -67,7 +65,12 @@ module OpenC3
       @parity          = parity
       @stop_bits       = stop_bits.to_i
       @write_timeout   = ConfigParser.handle_nil(write_timeout)
-      @write_timeout   = @write_timeout.to_f if @write_timeout
+      if @write_timeout
+        @write_timeout = @write_timeout.to_f
+      else
+        Logger.instance.warn("Warning: To avoid interface lock, write_timeout can not be nil. Setting to 10 seconds.")
+        @write_timeout = 10.0
+      end
       @read_timeout    = ConfigParser.handle_nil(read_timeout)
       @read_timeout    = @read_timeout.to_f if @read_timeout
       @flow_control    = flow_control.to_s.intern

data/lib/openc3/streams/tcpip_client_stream.rb

@@ -36,8 +36,11 @@ module OpenC3
     #   a read only stream.
     # @param read_port [Integer|nil] The port to read. Pass nil to make this
     #   a write only stream.
-    # @param write_timeout (see TcpipSocketStream#initialize)
-    # @param read_timeout (see TcpipSocketStream#initialize)
+    # @param write_timeout [Float] Seconds to wait before aborting writes
+    # @param read_timeout [Float|nil] Seconds to wait before aborting reads.
+    #   Pass nil to block until the read is complete.
+    # @param connect_timeout [Float|nil] Seconds to wait before aborting connect.
+    #   Pass nil to block until the connection is complete.
     def initialize(hostname, write_port, read_port, write_timeout, read_timeout, connect_timeout = 5.0)
       @hostname = hostname
       if @hostname.to_s.upcase == 'LOCALHOST'

data/lib/openc3/streams/tcpip_socket_stream.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 'socket'
@@ -31,21 +31,23 @@ module OpenC3
   class TcpipSocketStream < Stream
     attr_reader :write_socket
 
-    FAST_READ = (RUBY_VERSION > "2.1")
-
     # @param write_socket [Socket] Socket to write
     # @param read_socket [Socket] Socket to read
-    # @param write_timeout [Float|nil] Number of seconds to wait for the write
-    #   to complete or nil to block until the socket is ready to write.
-    # @param read_timeout [Float|nil] Number of seconds to wait for the read
-    #   to complete or nil to block until the socket is ready to read.
+    # @param write_timeout [Float] Seconds to wait before aborting writes
+    # @param read_timeout [Float|nil] Seconds to wait before aborting reads.
+    #   Pass nil to block until the read is complete.
     def initialize(write_socket, read_socket, write_timeout, read_timeout)
       super()
 
       @write_socket  = write_socket
       @read_socket   = read_socket
       @write_timeout = ConfigParser.handle_nil(write_timeout)
-      @write_timeout = @write_timeout.to_f if @write_timeout
+      if @write_timeout
+        @write_timeout = @write_timeout.to_f
+      else
+        Logger.warn("Warning: To avoid interface lock, write_timeout can not be nil. Setting to 10 seconds.")
+        @write_timeout = 10.0
+      end
       @read_timeout  = ConfigParser.handle_nil(read_timeout)
       @read_timeout  = @read_timeout.to_f if @read_timeout
 
@@ -61,67 +63,37 @@ module OpenC3
       raise "Attempt to read from write only stream" unless @read_socket
 
       # No read mutex is needed because reads happen serially
-      if FAST_READ
-        begin
-          while true # Loop until we get some data
-            data = @read_socket.read_nonblock(65535, exception: false)
-            raise EOFError, 'end of file reached' unless data
-
-            if data == :wait_readable
-              # Wait for the socket to be ready for reading or for the timeout
-              begin
-                result = IO.fast_select([@read_socket, @pipe_reader], nil, nil, @read_timeout)
-                # If select returns something it means the socket is now available for
-                # reading so retry the read. If it returns nil it means we timed out.
-                # If the pipe is present that means we closed the socket
-                if result
-                  if result.include?(@pipe_reader)
-                    raise IOError
-                  else
-                    next
-                  end
+      begin
+        while true # Loop until we get some data
+          data = @read_socket.read_nonblock(65535, exception: false)
+          raise EOFError, 'end of file reached' unless data
+
+          if data == :wait_readable
+            # Wait for the socket to be ready for reading or for the timeout
+            begin
+              result = IO.fast_select([@read_socket, @pipe_reader], nil, nil, @read_timeout)
+              # If select returns something it means the socket is now available for
+              # reading so retry the read. If it returns nil it means we timed out.
+              # If the pipe is present that means we closed the socket
+              if result
+                if result.include?(@pipe_reader)
+                  raise IOError
                 else
-                  raise Timeout::Error, "Read Timeout"
+                  next
                 end
-              rescue IOError, Errno::ENOTSOCK
-                # These can happen with the socket being closed while waiting on select
-                data = ''
-              end
-            end
-            break
-          end
-        rescue Errno::ECONNRESET, Errno::ECONNABORTED, IOError, Errno::ENOTSOCK
-          data = ''
-        end
-      else
-        begin
-          data = @read_socket.read_nonblock(65535)
-        rescue IO::WaitReadable
-          # Wait for the socket to be ready for reading or for the timeout
-          begin
-            result = IO.fast_select([@read_socket, @pipe_reader], nil, nil, @read_timeout)
-
-            # If select returns something it means the socket is now available for
-            # reading so retry the read. If it returns nil it means we timed out.
-            # If the pipe is present that means we closed the socket
-            if result
-              if result.include?(@pipe_reader)
-                raise IOError
               else
-                retry
+                raise Timeout::Error, "Read Timeout"
               end
-            else
-              raise Timeout::Error, "Read Timeout"
+            rescue IOError, Errno::ENOTSOCK
+              # These can happen with the socket being closed while waiting on select
+              data = ''
             end
-          rescue IOError, Errno::ENOTSOCK
-            # These can happen with the socket being closed while waiting on select
-            data = ''
           end
-        rescue Errno::ECONNRESET, Errno::ECONNABORTED, IOError, Errno::ENOTSOCK
-          data = ''
+          break
         end
+      rescue Errno::ECONNRESET, Errno::ECONNABORTED, IOError, Errno::ENOTSOCK
+        data = ''
       end
-
       data
     end
 
@@ -129,18 +101,12 @@ module OpenC3
     def read_nonblock
       # No read mutex is needed because reads happen serially
       begin
-        if FAST_READ
-          data = @read_socket.read_nonblock(65535, exception: false)
-          raise EOFError, 'end of file reached' unless data
-
-          data = '' if data == :wait_readable
-        else
-          data = @read_socket.read_nonblock(65535)
-        end
+        data = @read_socket.read_nonblock(65535, exception: false)
+        raise EOFError, 'end of file reached' unless data
+        data = '' if data == :wait_readable
       rescue Errno::EAGAIN, Errno::EWOULDBLOCK, Errno::ECONNRESET, Errno::ECONNABORTED, IOError
         data = ''
       end
-
       data
     end
 
@@ -194,5 +160,5 @@ module OpenC3
       @pipe_writer.write('.')
       @connected = false
     end
-  end # class TcpipSocketStream
+  end
 end

data/lib/openc3/streams/web_socket_client_stream.rb

@@ -26,9 +26,11 @@ module OpenC3
     attr_accessor :headers
 
     # @param url [String] The host to connect to
-    # @param write_timeout (see TcpipSocketStream#initialize)
-    # @param read_timeout (see TcpipSocketStream#initialize)
-    # @param connect_timeout (see TcpipClientStream#initialize)
+    # @param write_timeout [Float] Seconds to wait before aborting writes
+    # @param read_timeout [Float|nil] Seconds to wait before aborting reads.
+    #   Pass nil to block until the read is complete.
+    # @param connect_timeout [Float|nil] Seconds to wait before aborting connect.
+    #   Pass nil to block until the connection is complete.
     def initialize(url, write_timeout, read_timeout, connect_timeout = 5.0)
       @url = url
       @uri = URI.parse @url

data/lib/openc3/system/system.rb

@@ -20,6 +20,7 @@
 # This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
+require 'openc3/top_level'
 require 'openc3/config/config_parser'
 require 'openc3/packets/packet_config'
 require 'openc3/packets/commands'
@@ -116,6 +117,7 @@ module OpenC3
     # @param target_names [Array of target names]
     # @param target_config_dir Directory where target config folders are
     def initialize(target_names, target_config_dir)
+      OpenC3.add_to_search_path(target_config_dir, true)
       @targets = {}
       @packet_config = PacketConfig.new
       @commands = Commands.new(@packet_config)

data/lib/openc3/topics/interface_topic.rb

@@ -64,11 +64,11 @@ module OpenC3
     end
 
     def self.start_raw_logging(interface_name, scope:)
-      Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'log_raw' => 'true' }, '*', 100)
+      Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'log_stream' => 'true' }, '*', 100)
     end
 
     def self.stop_raw_logging(interface_name, scope:)
-      Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'log_raw' => 'false' }, '*', 100)
+      Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'log_stream' => 'false' }, '*', 100)
     end
 
     def self.shutdown(interface, scope:)
@@ -77,14 +77,14 @@ module OpenC3
       InterfaceTopic.clear_topics(InterfaceTopic.topics(interface, scope: scope))
     end
 
-    def interface_cmd(interface_name, cmd_name, *cmd_params, scope:)
+    def self.interface_cmd(interface_name, cmd_name, *cmd_params, scope:)
       data = {}
       data['cmd_name'] = cmd_name
       data['cmd_params'] = cmd_params
       Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'interface_cmd' => JSON.generate(data, allow_nan: true) }, '*', 100)
     end
 
-    def protocol_cmd(interface_name, cmd_name, *cmd_params, read_write: :READ_WRITE, index: -1, scope:)
+    def self.protocol_cmd(interface_name, cmd_name, *cmd_params, read_write: :READ_WRITE, index: -1, scope:)
       data = {}
       data['cmd_name'] = cmd_name
       data['cmd_params'] = cmd_params
@@ -92,5 +92,14 @@ module OpenC3
       data['index'] = index
       Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'protocol_cmd' => JSON.generate(data, allow_nan: true) }, '*', 100)
     end
+
+    def self.inject_tlm(interface_name, target_name, packet_name, item_hash = nil, type: :CONVERTED, scope:)
+      data = {}
+      data['target_name'] = target_name.to_s.upcase
+      data['packet_name'] = packet_name.to_s.upcase
+      data['item_hash'] = item_hash
+      data['type'] = type
+      Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'inject_tlm' => JSON.generate(data, allow_nan: true) }, '*', 100)
+    end
   end
 end

data/lib/openc3/topics/router_topic.rb

@@ -57,9 +57,9 @@ module OpenC3
         Topic.write_topic(topic, { 'target_name' => packet.target_name, 'cmd_name' => packet.packet_name, 'cmd_buffer' => packet.buffer(false) }, '*', 100)
       elsif target_names.length == 1
         topic = "{#{scope}__CMD}TARGET__#{target_names[0]}"
-        Topic.write_topic(topic, { 'target_name' => packet.target_name, 'cmd_name' => 'UNKNOWN', 'cmd_buffer' => packet.buffer(false) }, '*', 100)
+        Topic.write_topic(topic, { 'target_name' => packet.target_name ? packet.target_name : 'UNKNOWN', 'cmd_name' => 'UNKNOWN', 'cmd_buffer' => packet.buffer(false) }, '*', 100)
       else
-        raise "No route for command: #{packet.target_name} #{packet.packet_name}"
+        raise "No route for command: #{packet.target_name ? packet.target_name : 'UNKNOWN'} #{packet.packet_name ? packet.packet_name : 'UNKNOWN'}"
       end
     end
 
@@ -76,11 +76,11 @@ module OpenC3
     end
 
     def self.start_raw_logging(router_name, scope:)
-      Topic.write_topic("{#{scope}__CMD}ROUTER__#{router_name}", { 'log_raw' => 'true' }, '*', 100)
+      Topic.write_topic("{#{scope}__CMD}ROUTER__#{router_name}", { 'log_stream' => 'true' }, '*', 100)
     end
 
     def self.stop_raw_logging(router_name, scope:)
-      Topic.write_topic("{#{scope}__CMD}ROUTER__#{router_name}", { 'log_raw' => 'false' }, '*', 100)
+      Topic.write_topic("{#{scope}__CMD}ROUTER__#{router_name}", { 'log_stream' => 'false' }, '*', 100)
     end
 
     def self.shutdown(router, scope:)
@@ -89,14 +89,14 @@ module OpenC3
       RouterTopic.clear_topics(RouterTopic.topics(router, scope: scope))
     end
 
-    def router_cmd(router_name, cmd_name, *cmd_params, scope:)
+    def self.router_cmd(router_name, cmd_name, *cmd_params, scope:)
       data = {}
       data['cmd_name'] = cmd_name
       data['cmd_params'] = cmd_params
       Topic.write_topic("{#{scope}__CMD}ROUTER__#{router_name}", { 'router_cmd' => JSON.generate(data, allow_nan: true) }, '*', 100)
     end
 
-    def protocol_cmd(router_name, cmd_name, *cmd_params, read_write: :READ_WRITE, index: -1, scope:)
+    def self.protocol_cmd(router_name, cmd_name, *cmd_params, read_write: :READ_WRITE, index: -1, scope:)
       data = {}
       data['cmd_name'] = cmd_name
       data['cmd_params'] = cmd_params

data/lib/openc3/topics/telemetry_decom_topic.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/topics/topic'
@@ -56,5 +56,14 @@ module OpenC3
         end
       end
     end
+
+    def self.inject_tlm(target_name, packet_name, item_hash = nil, type: :CONVERTED, scope:)
+      data = {}
+      data['target_name'] = target_name.to_s.upcase
+      data['packet_name'] = packet_name.to_s.upcase
+      data['item_hash'] = item_hash
+      data['type'] = type
+      Topic.write_topic("#{scope}__DECOMINTERFACE__{#{target_name}}", { 'inject_tlm' => JSON.generate(data, allow_nan: true) }, '*', 100)
+    end
   end
 end

data/lib/openc3/utilities/bucket_utilities.rb

@@ -60,15 +60,22 @@ module OpenC3
       Thread.new do
         client = Bucket.getClient()
 
-        zipped = compress_file(filename)
-        bucket_key = bucket_key + '.gz'
-        File.open(zipped, 'rb') do |read_file|
-          client.put_object(bucket: ENV['OPENC3_LOGS_BUCKET'], key: bucket_key, body: read_file, metadata: metadata)
+        orig_filename = nil
+        if File.extname(filename) != '.txt'
+          orig_filename = filename
+          filename = compress_file(filename)
+          bucket_key += '.gz'
+        end
+        # We want to open this as a file and pass that to put_object to allow
+        # this to work with really large files. Otherwise the entire file has
+        # to be held in memory!
+        File.open(filename, 'rb') do |file|
+          client.put_object(bucket: ENV['OPENC3_LOGS_BUCKET'], key: bucket_key, body: file, metadata: metadata)
         end
         Logger.debug "wrote #{ENV['OPENC3_LOGS_BUCKET']}/#{bucket_key}"
         ReducerModel.add_file(bucket_key) # Record the new file for data reduction
 
-        File.delete(zipped)
+        File.delete(orig_filename) if orig_filename
         File.delete(filename)
       rescue => err
         Logger.error("Error saving log file to bucket: #{filename}\n#{err.formatted}")

data/lib/openc3/utilities/cli_generator.rb

@@ -18,7 +18,7 @@
 
 module OpenC3
   class CliGenerator
-    GENERATORS = %w(plugin target microservice conversion limits_response)
+    GENERATORS = %w(plugin target microservice widget conversion limits_response)
     TEMPLATES_DIR = "#{File.dirname(__FILE__)}/../../../templates"
 
     # Called by openc3cli with ARGV[1..-1]
@@ -43,11 +43,12 @@ module OpenC3
     end
 
     def self.process_template(template_dir, the_binding)
-      Dir.glob("#{template_dir}/**/*").each do |file|
+      Dir.glob("#{template_dir}/**/*", File::FNM_DOTMATCH).each do |file|
+        next if File.basename(file) == '.'
         base_name = file.sub("#{template_dir}/", '')
-        yield base_name
+        next if yield base_name
         if File.directory?(file)
-          FileUtils.mkdir(base_name)
+          FileUtils.mkdir(base_name) unless File.exist?(base_name)
           next
         end
         output = ERB.new(File.read(file), trim_mode: "-").result(the_binding)
@@ -73,6 +74,7 @@ module OpenC3
 
       process_template("#{TEMPLATES_DIR}/plugin", binding) do |filename|
         filename.sub!("plugin.gemspec", "#{plugin_name}.gemspec")
+        false
       end
 
       puts "Plugin #{plugin_name} successfully generated!"
@@ -98,6 +100,7 @@ module OpenC3
         # 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)
+        false
       end
 
       # Add this target to plugin.txt
@@ -134,6 +137,7 @@ module OpenC3
         # Rename the template MICROSERVICE to our actual microservice name
         filename.sub!("microservices/TEMPLATE", "microservices/#{microservice_name}")
         filename.sub!("microservice.rb", microservice_filename)
+        false
       end
 
       # Add this microservice to plugin.txt
@@ -149,6 +153,52 @@ module OpenC3
       return microservice_name
     end
 
+    def self.generate_widget(args)
+      if args.length != 2
+        abort("Usage: cli generate #{args[0]} <SuperdataWidget>")
+      end
+      # Per https://stackoverflow.com/a/47591707/453280
+      if args[1] !~ /.*Widget$/ or args[1][0...-6] != args[1][0...-6].capitalize
+        abort("Widget name should be Uppercase followed by Widget, e.g. SuperdataWidget. Found '#{args[1]}'.")
+      end
+
+      # Create the local variables
+      widget_name = args[1]
+      widget_filename = "#{widget_name}.vue"
+      widget_path = "src/#{widget_filename}"
+      if File.exist?(widget_path)
+        abort("Widget #{widget_path} already exists!")
+      end
+      skip_package = false
+      if File.exist?('package.json')
+        puts "package.json already exists ... you'll have to manually add this widget to the end of the \"build\" script."
+        skip_package = true
+      end
+
+      process_template("#{TEMPLATES_DIR}/widget", binding) do |filename|
+        if skip_package && filename == 'package.json'
+          true # causes the block to skip processing this file
+        elsif filename.include?('node_modules')
+          true
+        else
+          filename.sub!("Widget.vue", widget_filename)
+          false
+        end
+      end
+
+      # Add this widget to plugin.txt but remove Widget from the name
+      File.open("plugin.txt", 'a') do |file|
+        file.puts <<~DOC
+
+          WIDGET #{widget_name[0...-6]}
+        DOC
+      end
+
+      puts "Widget #{widget_name} successfully generated!"
+      puts "Please be sure #{widget_name} does not overlap an existing widget: https://openc3.com/docs/v5/telemetry-screens"
+      return widget_name
+    end
+
     def self.generate_conversion(args)
       if args.length != 3
         abort("Usage: cli generate conversion <TARGET> <NAME>")
@@ -170,6 +220,7 @@ module OpenC3
 
       process_template("#{TEMPLATES_DIR}/conversion", binding) do |filename|
         filename.sub!("conversion.rb", conversion_filename)
+        false
       end
 
       puts "Conversion #{conversion_filename} successfully generated!"
@@ -199,6 +250,7 @@ module OpenC3
 
       process_template("#{TEMPLATES_DIR}/limits_response", binding) do |filename|
         filename.sub!("response.rb", response_filename)
+        false
       end
 
       puts "Limits response #{response_filename} successfully generated!"