openc3 5.4.2 → 5.5.0.pre.beta0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: openc3
 version: !ruby/object:Gem::Version
-  version: 5.4.2
+  version: 5.5.0.pre.beta0
 platform: ruby
 authors:
 - Ryan Melton
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-04 00:00:00.000000000 Z
+date: 2023-02-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -445,6 +445,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: websocket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: websocket-native
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: dead_end
   requirement: !ruby/object:Gem::Requirement
@@ -669,7 +697,6 @@ files:
 - data/config/_interfaces.yaml
 - data/config/_items.yaml
 - data/config/_params.yaml
-- data/config/cmd_tlm_server.yaml
 - data/config/command.yaml
 - data/config/command_modifiers.yaml
 - data/config/command_telemetry.yaml
@@ -872,6 +899,7 @@ files:
 - lib/openc3/models/timeline_model.rb
 - lib/openc3/models/tool_config_model.rb
 - lib/openc3/models/tool_model.rb
+- lib/openc3/models/traefik_model.rb
 - lib/openc3/models/trigger_group_model.rb
 - lib/openc3/models/trigger_model.rb
 - lib/openc3/models/widget_model.rb
@@ -916,16 +944,17 @@ files:
 - lib/openc3/script/suite_results.rb
 - lib/openc3/script/suite_runner.rb
 - lib/openc3/script/telemetry.rb
+- lib/openc3/script/web_socket_api.rb
 - lib/openc3/streams/serial_stream.rb
 - lib/openc3/streams/stream.rb
 - lib/openc3/streams/tcpip_client_stream.rb
 - lib/openc3/streams/tcpip_socket_stream.rb
+- lib/openc3/streams/web_socket_client_stream.rb
 - lib/openc3/system.rb
 - lib/openc3/system/system.rb
 - lib/openc3/system/system_config.rb
 - lib/openc3/system/target.rb
 - lib/openc3/tools/cmd_tlm_server/api.rb
-- lib/openc3/tools/cmd_tlm_server/cmd_tlm_server_config.rb
 - lib/openc3/tools/cmd_tlm_server/interface_thread.rb
 - lib/openc3/tools/table_manager/table.rb
 - lib/openc3/tools/table_manager/table_config.rb
@@ -1012,9 +1041,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.3.14
 signing_key:

data/data/config/cmd_tlm_server.yaml

@@ -1,136 +0,0 @@
----
-TITLE:
-  summary: Sets the Command and Telemetry Server window title
-  parameters:
-  - name: Text
-    required: true
-    description: Text to put in the title of the Command and Telemetry Server window
-    values: .+
-PACKET_LOG_WRITER:
-  summary: Declare a packet log writer
-  description: Packet log writer is used to declare a packet log writer class and
-    give it a name which can be referenced by an interface. This is required if you
-    want interfaces to have their own dedicated log writers or want to combine
-    various interfaces into a single log file. By default, OpenC3 logs all data
-    on all interfaces into a single command log and a single telemetry log.
-    This keyword can also be used if you want to declare a different log file class
-    to create log files.
-  warning: You should NOT override the default without consulting a OpenC3 expert
-    as this may break the ability to successfully read and write log files.
-  example: |
-    PACKET_LOG_WRITER DEFAULT packet_log_writer.rb # Default
-    # The default logger filename will be <DATE>_openc3tlm.bin and will create a new log every 1MB
-    PACKET_LOG_WRITER DEFAULT packet_log_writer.rb openc3 true nil 1000000
-    # Create a logger named OPENC3_LOG which creates a new log every 5 min (600s)
-    PACKET_LOG_WRITER OPENC3_LOG packet_log_writer.rb openc3 true 600
-  parameters:
-    - name: Log Writer Name
-      required: true
-      description: The name of the log writer as reference by other cmd_tlm_server keywords.
-        This name also appears in the Logging tab on the Command and Telemetry Server.
-      values: .+
-    - name: Filename
-      required: true
-      description: Ruby file to use when instantiating a new log writer
-      values: '.+\.rb'
-    - name: Parameters
-      required: false
-      description: Optional parameters to pass to the log writer class when instantiating it.
-AUTO_INTERFACE_TARGETS:
-  summary: Automatically use each target's cmd_tlm_server.txt file to define the interface
-  description: Look for a cmd_tlm_server.txt file at the top level
-    of each target directory and use this file to configure the interface for that target.
-    This is a good way of keeping the knowledge of how to interface to a target
-    within that target. However, if you use substitute target names (by using DECLARE_TARGET)
-    or use different IP addresses then this will not work and you'll have to use the
-    INTERFACE_TARGET or INTERFACE keyword.
-INTERFACE_TARGET:
-  summary: Load the specified target's cmd_tlm_server.txt configuration file
-  example: |
-    INTERFACE_TARGET OPENC3 # Look in the OPENC3 target directory for cmd_tlm_server.txt
-    INTERFACE_TARGET OPENC3 config.txt # Look in the OPENC3 target directory for config.txt
-  parameters:
-    - name: Target Name
-      required: true
-      description: Name of the target
-      values: .+
-    - name: Configuration File
-      required: false
-      description: Configuration filename which contains the interface configuration.
-        Defaults to 'cmd_tlm_server.txt'.
-      values: .+
-INTERFACE:
-  modifiers:
-    <%= MetaConfigParser.load('interface_modifiers.yaml').to_meta_config_yaml(4) %>
-  summary: Defines a connection to a physical target
-  description: Interfaces are what OpenC3 uses to talk to a particular piece
-    of hardware. Interfaces require a Ruby file which implements all the interface
-    methods necessary to talk to the hardware. OpenC3 defines many built in interfaces
-    or you can define your own as long as it implements the interface protocol.
-  parameters:
-    - name: Interface Name
-      required: true
-      description: Name of the interface. This name will appear in the
-        Interfaces tab of the Server and is also referenced by other keywords.
-        The OpenC3 convention is to name interfaces after their targets with
-        '_INT' appended to the name, e.g. INST_INT for the INST target.
-      values: \D\S*
-    - name: Filename
-      required: true
-      description: Ruby file to use when instantiating the interface.
-      values:
-        <%= MetaConfigParser.load('_interfaces.yaml').to_meta_config_yaml(8) %>
-      documentation: Additional parameters are required. Please see the [Interfaces](/docs/v5/interfaces)
-        documentation for more details.
-ROUTER:
-  modifiers:
-    ROUTE:
-      summary: Map an interface to a router
-      description: Once an interface has been mapped to a router, all its received telemetry
-        will be sent out through the router.
-      parameters:
-        - name: Interface
-          required: true
-          description: Name of the interface
-          values: .+
-    <%= MetaConfigParser.load('interface_modifiers.yaml').to_meta_config_yaml(4) %>
-  summary: Create an interface which reverses cmd/tlm data
-  description: Router creates an interface which receives command packets from
-    their remote targets and send them out their interfaces. They receive telemetry
-    packets from their interfaces and send them to their remote targets. This allows
-    routers to be intermediaries between an external client and an actual device.
-  parameters:
-    - name: Name
-      required: true
-      description: Name of the router
-      values: .+
-    - name: Filename
-      required: true
-      description: Ruby file to use when instantiating the interface.
-      values:
-        <%= MetaConfigParser.load('_interfaces.yaml').to_meta_config_yaml(8) %>
-      documentation: Additional parameters are required. Please see the [Interfaces](/docs/v5/interfaces)
-        documentation for more details.
-COLLECT_METADATA:
-  summary: Prompts the user for meta data when starting the Command and Telemetry Server
-BACKGROUND_TASK:
-  modifiers:
-    STOPPED:
-      summary: Indicate the background task should not be automatically started
-  summary: Create a background task in the Command and Telemetry Server
-  description: The Server instantiates the class which must inherit from BackgroundTask
-    and then calls the call() method which the class must implement. The call() method
-    is only called once so if your background task is supposed to live on while the
-    Server is running, you must implement your code in a loop with a sleep to not
-    use all the CPU.
-  example: BACKGROUND_TASK example_background_task.rb
-  parameters:
-    - name: Filename
-      required: true
-      description: Ruby file which contains the background task implementation.
-        Must inherit from BackgroundTask and implement the call method.
-      values: '.+\.rb'
-    - name: Optional Arguments
-      required: false
-      description: Optional arguments to the background task constructor
-      values: .+

data/lib/openc3/tools/cmd_tlm_server/cmd_tlm_server_config.rb

@@ -1,323 +0,0 @@
-# encoding: ascii-8bit
-
-# Copyright 2022 Ball Aerospace & Technologies Corp.
-# 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.
-
-# Modified by OpenC3, Inc.
-# All changes Copyright 2022, 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/config/config_parser'
-
-module OpenC3
-  # Reads an ascii file that defines the configuration settings used to
-  # configure the Command/Telemetry Server.
-  class CmdTlmServerConfig
-    # @return [Hash<String, Interface>] Interfaces hash
-    attr_accessor :interfaces
-    # @return [Hash<String, Interface>] Routers hash
-    attr_accessor :routers
-    # @return [Hash<String, PacketLogWriterPair>] Packet log writer hash. Each
-    #   pair encapsulates a command and telemetry log writer.
-    attr_accessor :packet_log_writer_pairs
-    # @return [Array<BackgroundTask>] Array of background tasks
-    attr_accessor :background_tasks
-    # @return [String] Command and Telemetry Server title
-    attr_accessor :title
-    # @return [Boolean] Flag indicating if meta data should be collected
-    attr_accessor :metadata
-
-    # Create a default pair of packet log writers and parses the
-    # configuration file.
-    #
-    # @param filename [String] The name of the configuration file to parse
-    def initialize(filename, system_config)
-      @system_config = system_config
-      @interfaces = {}
-      @routers = {}
-      @packet_log_writer_pairs = {}
-      # cmd_log_writer = System.default_packet_log_writer.new(:CMD, *System.default_packet_log_writer_params)
-      # tlm_log_writer = System.default_packet_log_writer.new(:TLM, *System.default_packet_log_writer_params)
-      # @packet_log_writer_pairs['DEFAULT'] = PacketLogWriterPair.new(cmd_log_writer, tlm_log_writer)
-      @background_tasks = []
-      @title = nil
-      @metadata = false
-      process_file(filename)
-    end
-
-    protected
-
-    def get_target_interface_name(target_name)
-      @interfaces.each do |interface_name, interface|
-        return interface_name if interface.target_names.include?(target_name)
-      end
-      nil
-    end
-
-    def setup_interface_or_router
-      current_interface_or_router = OpenStruct.new
-      current_interface_or_router.interfaces = []
-      current_interface_or_router.routers = []
-      current_interface_or_router.target_names = []
-      current_interface_or_router
-    end
-
-    # Processes a file and adds in the configuration defined in the file
-    #
-    # @param filename [String] The name of the configuration file to parse
-    # @param recursive [Boolean] Whether process_file is being called
-    #   recursively
-    def process_file(filename, recursive = false)
-      current_interface_or_router = nil
-      current_type = nil
-      current_interface_log_added = false
-
-      Logger.info "Processing CmdTlmServer configuration in file: #{File.expand_path(filename)}"
-
-      parser = ConfigParser.new("https://openc3.com/docs/v5")
-      parser.parse_file(filename) do |keyword, params|
-        case keyword
-        when 'TITLE'
-          raise parser.error("#{keyword} not allowed in target #{filename}") if recursive
-
-          parser.verify_num_parameters(1, 1, "#{keyword} <Title Text>")
-          @title = params[0]
-
-        when 'PACKET_LOG_WRITER'
-          # usage = "PACKET_LOG_WRITER <Name> <Filename> <Specific Parameters>"
-          # parser.verify_num_parameters(2, nil, usage)
-          # packet_log_writer_name = params[0].upcase
-          # packet_log_writer_class = OpenC3.require_class(params[1])
-
-          # # Verify not overridding a packet log writer that is already associated with an interface
-          # packet_log_writer_pair = @packet_log_writer_pairs[packet_log_writer_name]
-          # if packet_log_writer_pair
-          #   @interfaces.each do |interface_name, interface|
-          #     if interface.packet_log_writer_pairs.include?(packet_log_writer_pair)
-          #       raise parser.error("Redefining Packet Log Writer #{packet_log_writer_name} not allowed after it is associated with an interface")
-          #     end
-          #   end
-          # end
-
-          # if params[2]
-          #   cmd_log_writer = packet_log_writer_class.new(:CMD, *params[2..-1])
-          #   tlm_log_writer = packet_log_writer_class.new(:TLM, *params[2..-1])
-          #   @packet_log_writer_pairs[packet_log_writer_name] = PacketLogWriterPair.new(cmd_log_writer, tlm_log_writer)
-          # else
-          #   cmd_log_writer = packet_log_writer_class.new(:CMD)
-          #   tlm_log_writer = packet_log_writer_class.new(:TLM)
-          #   @packet_log_writer_pairs[packet_log_writer_name] = PacketLogWriterPair.new(cmd_log_writer, tlm_log_writer)
-          # end
-
-        when 'AUTO_INTERFACE_TARGETS'
-          raise parser.error("#{keyword} not allowed in target #{filename}") if recursive
-
-          usage = "#{keyword}"
-          parser.verify_num_parameters(0, 0, usage)
-          @system_config.targets.each do |target_name, target|
-            target_filename = File.join(target.dir, 'cmd_tlm_server.txt')
-            if File.exist?(target_filename)
-              # Skip this target if it's already been assigned an interface
-              next if get_target_interface_name(target.name)
-              raise parser.error("Cannot use #{keyword} with target name substitutions: #{target.name} != #{target.original_name}") if target.name != target.original_name
-
-              process_file(target_filename, true)
-            end
-          end
-
-        when 'INTERFACE_TARGET'
-          raise parser.error("#{keyword} not allowed in target #{filename}") if recursive
-
-          usage = "#{keyword} <Target Name> <Config File (defaults to cmd_tlm_server.txt)>"
-          parser.verify_num_parameters(1, 2, usage)
-          target = @system_config.targets[params[0].upcase]
-          raise parser.error("Unknown target: #{params[0].upcase}") unless target
-
-          interface_name = get_target_interface_name(target.name)
-          raise parser.error("Target #{target.name} already mapped to interface #{interface_name}") if interface_name
-
-          target_filename = params[1]
-          target_filename = 'cmd_tlm_server.txt' unless target_filename
-          target_filename = File.join(target.dir, target_filename)
-          if File.exist?(target_filename)
-            process_file(target_filename, true)
-          else
-            raise parser.error("#{target_filename} does not exist")
-          end
-
-        when 'INTERFACE'
-          usage = "INTERFACE <Name> <Filename> <Specific Parameters>"
-          parser.verify_num_parameters(2, nil, usage)
-          interface_name = params[0].upcase
-          raise parser.error("Interface '#{interface_name}' defined twice") if @interfaces[interface_name]
-
-          # interface_class = OpenC3.require_class(params[1])
-          # if params[2]
-          #   current_interface_or_router = interface_class.new(*params[2..-1])
-          # else
-          #   current_interface_or_router = interface_class.new
-          # end
-          current_interface_or_router = setup_interface_or_router()
-          current_type = :INTERFACE
-          current_interface_log_added = false
-          # current_interface_or_router.packet_log_writer_pairs << @packet_log_writer_pairs['DEFAULT']
-          current_interface_or_router.name = interface_name
-          current_interface_or_router.config_params = params[1..-1]
-          @interfaces[interface_name] = current_interface_or_router
-
-        when 'LOG', 'LOG_STORED', 'DONT_LOG', 'TARGET'
-          raise parser.error("No current interface for #{keyword}") unless current_interface_or_router and current_type == :INTERFACE
-
-          case keyword
-
-          when 'LOG'
-            parser.verify_num_parameters(1, 1, "#{keyword} <Packet Log Writer Name>")
-            # packet_log_writer_pair = @packet_log_writer_pairs[params[0].upcase]
-            # raise parser.error("Unknown packet log writer: #{params[0].upcase}") unless packet_log_writer_pair
-            # current_interface_or_router.packet_log_writer_pairs.delete(@packet_log_writer_pairs['DEFAULT']) unless current_interface_log_added
-            current_interface_log_added = true
-            # current_interface_or_router.packet_log_writer_pairs << packet_log_writer_pair unless current_interface_or_router.packet_log_writer_pairs.include?(packet_log_writer_pair)
-
-          when 'LOG_STORED'
-            parser.verify_num_parameters(1, 1, "#{keyword} <Packet Log Writer Name>")
-            # packet_log_writer_pair = @packet_log_writer_pairs[params[0].upcase]
-            # raise parser.error("Unknown packet log writer: #{params[0].upcase}") unless packet_log_writer_pair
-            # current_interface_or_router.stored_packet_log_writer_pairs << packet_log_writer_pair unless current_interface_or_router.stored_packet_log_writer_pairs.include?(packet_log_writer_pair)
-
-          when 'DONT_LOG'
-            parser.verify_num_parameters(0, 0, "#{keyword}")
-            # current_interface_or_router.packet_log_writer_pairs = []
-
-          when 'TARGET'
-            parser.verify_num_parameters(1, 1, "#{keyword} <Target Name>")
-            target_name = params[0].upcase
-            target = @system_config.targets[target_name]
-            if target
-              interface_name = get_target_interface_name(target.name)
-              raise parser.error("Target #{target.name} already mapped to interface #{interface_name}") if interface_name
-
-              target.interface = current_interface_or_router
-              current_interface_or_router.target_names << target_name
-            else
-              raise parser.error("Unknown target #{target_name} mapped to interface #{current_interface_or_router.name}")
-            end
-
-          end # end case keyword for all keywords that require a current interface
-
-        when 'DONT_CONNECT', 'DONT_RECONNECT', 'RECONNECT_DELAY', 'DISABLE_DISCONNECT', 'LOG_RAW', 'OPTION', 'PROTOCOL'
-          raise parser.error("No current interface or router for #{keyword}") unless current_interface_or_router
-
-          case keyword
-
-          when 'DONT_CONNECT'
-            parser.verify_num_parameters(0, 0, "#{keyword}")
-            current_interface_or_router.connect_on_startup = false
-
-          when 'DONT_RECONNECT'
-            parser.verify_num_parameters(0, 0, "#{keyword}")
-            current_interface_or_router.auto_reconnect = false
-
-          when 'RECONNECT_DELAY'
-            parser.verify_num_parameters(1, 1, "#{keyword} <Delay in Seconds>")
-            current_interface_or_router.reconnect_delay = Float(params[0])
-
-          when 'DISABLE_DISCONNECT'
-            parser.verify_num_parameters(0, 0, "#{keyword}")
-            current_interface_or_router.disable_disconnect = true
-
-          when 'LOG_RAW',
-            parser.verify_num_parameters(0, nil, "#{keyword} <Raw Logger Class File (optional)> <Raw Logger Parameters (optional)>")
-            # current_interface_or_router.raw_logger_pair = RawLoggerPair.new(current_interface_or_router.name, params)
-            # current_interface_or_router.start_raw_logging
-
-          when 'OPTION'
-            parser.verify_num_parameters(2, nil, "#{keyword} <Option Name> <Option Value 1> <Option Value 2 (optional)> <etc>")
-            # current_interface_or_router.set_option(params[0], params[1..-1])
-
-          when 'PROTOCOL'
-            usage = "#{keyword} <READ WRITE READ_WRITE> <protocol filename or classname> <Protocol specific parameters>"
-            parser.verify_num_parameters(2, nil, usage)
-            unless %w(READ WRITE READ_WRITE).include? params[0].upcase
-              raise parser.error("Invalid protocol type: #{params[0]}", usage)
-            end
-
-            begin
-              # klass = OpenC3.require_class(params[1])
-              # current_interface_or_router.add_protocol(klass, params[2..-1], params[0].upcase.intern)
-            rescue LoadError, StandardError => error
-              raise parser.error(error.message, usage)
-            end
-
-          end # end case keyword for all keywords that require a current interface or router
-
-        when 'ROUTER'
-          usage = "ROUTER <Name> <Filename> <Specific Parameters>"
-          parser.verify_num_parameters(2, nil, usage)
-          router_name = params[0].upcase
-          raise parser.error("Router '#{router_name}' defined twice") if @routers[router_name]
-
-          # router_class = OpenC3.require_class(params[1])
-          # if params[2]
-          #  current_interface_or_router = router_class.new(*params[2..-1])
-          # else
-          #  current_interface_or_router = router_class.new
-          # end
-          current_interface_or_router = setup_interface_or_router()
-          current_type = :ROUTER
-          current_interface_or_router.name = router_name
-          @routers[router_name] = current_interface_or_router
-
-        when 'ROUTE'
-          raise parser.error("No current router for #{keyword}") unless current_interface_or_router and current_type == :ROUTER
-
-          usage = "ROUTE <Interface Name>"
-          parser.verify_num_parameters(1, 1, usage)
-          interface_name = params[0].upcase
-          interface = @interfaces[interface_name]
-          raise parser.error("Unknown interface #{interface_name} mapped to router #{current_interface_or_router.name}") unless interface
-
-          unless current_interface_or_router.interfaces.include? interface
-            current_interface_or_router.interfaces << interface
-            interface.routers << current_interface_or_router
-          end
-
-        when 'BACKGROUND_TASK'
-          usage = "#{keyword} <Filename> <Specific Parameters>"
-          parser.verify_num_parameters(1, nil, usage)
-          # background_task = OpenC3.require_class(params[0])
-          if params[1]
-            @background_tasks << params
-          else
-            @background_tasks << params
-          end
-
-        when 'STOPPED'
-          parser.verify_num_parameters(0, 0, "#{keyword}")
-          raise parser.error("No BACKGROUND_TASK defined") if @background_tasks.empty?
-          # @background_tasks[-1].stopped = true
-
-        when 'COLLECT_METADATA'
-          parser.verify_num_parameters(0, 0, "#{keyword}")
-          @metadata = true
-
-        else
-          # blank lines will have a nil keyword and should not raise an exception
-          raise parser.error("Unknown keyword: #{keyword}") unless keyword.nil?
-        end # case
-      end  # loop
-    end
-  end
-end