openc3 6.6.0 → 6.8.0

data/lib/openc3/models/queue_model.rb

@@ -0,0 +1,232 @@
+# encoding: ascii-8bit
+
+# Copyright 2025 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/models/model'
+require 'openc3/models/microservice_model'
+require 'openc3/topics/queue_topic'
+require 'openc3/utilities/logger'
+
+module OpenC3
+  class QueueError < StandardError; end
+
+  class QueueModel < Model
+    PRIMARY_KEY = 'openc3__queue'.freeze
+
+    @@class_mutex = Mutex.new
+
+    # NOTE: The following three class methods are used by the ModelController
+    # and are reimplemented to enable various Model class methods to work
+    def self.get(name:, scope:)
+      super("#{scope}__#{PRIMARY_KEY}", name: name)
+    end
+
+    def self.names(scope:)
+      super("#{scope}__#{PRIMARY_KEY}")
+    end
+
+    def self.all(scope:)
+      super("#{scope}__#{PRIMARY_KEY}")
+    end
+    # END NOTE
+
+    def self.queue_command(name, command:, username:, scope:)
+      model = get_model(name: name, scope: scope)
+      raise QueueError, "Queue '#{name}' not found in scope '#{scope}'" unless model
+
+      if model.state != 'DISABLE'
+        result = Store.zrevrange("#{scope}:#{name}", 0, 0, with_scores: true)
+        if result.empty?
+          index = 1.0
+        else
+          index = result[0][1].to_f + 1
+        end
+        Store.zadd("#{scope}:#{name}", index, { username: username, value: command, timestamp: Time.now.to_nsec_from_epoch }.to_json)
+        model.notify(kind: 'command')
+      else
+        raise QueueError, "Queue '#{name}' is disabled. Command '#{command}' not queued."
+      end
+    end
+
+    attr_accessor :name, :state
+
+    def initialize(name:, scope:, state: 'HOLD', updated_at: nil)
+      super("#{scope}__#{PRIMARY_KEY}", name: name, updated_at: updated_at, scope: scope)
+      @microservice_name = "#{scope}__QUEUE__#{name}"
+      if %w(HOLD RELEASE DISABLE).include?(state)
+        @state = state
+      else
+        @state = 'HOLD'
+      end
+    end
+
+    def create(update: false, force: false, queued: false)
+      super(update: update, force: force, queued: queued)
+      if update
+        notify(kind: 'updated')
+      else
+        deploy()
+        notify(kind: 'created')
+      end
+    end
+
+    # @return [Hash] generated from the QueueModel
+    def as_json(*a)
+      return {
+        'name' => @name,
+        'scope' => @scope,
+        'state' => @state,
+        'updated_at' => @updated_at
+      }
+    end
+
+    # @return [] update the redis stream / queue topic that something has changed
+    def notify(kind:)
+      notification = {
+        'kind' => kind,
+        'data' => JSON.generate(as_json(:allow_nan => true)),
+      }
+      QueueTopic.write_notification(notification, scope: @scope)
+    end
+
+    def insert_command(index, command_data)
+      if @state == 'DISABLE'
+        raise QueueError, "Queue '#{@name}' is disabled. Command '#{command_data['value']}' not queued."
+      end
+
+      unless index
+        result = Store.zrevrange("#{@scope}:#{@name}", 0, 0, with_scores: true)
+        if result.empty?
+          index = 1.0
+        else
+          index = result[0][1].to_f + 1
+        end
+      end
+      Store.zadd("#{@scope}:#{@name}", index, command_data.to_json)
+      notify(kind: 'command')
+    end
+
+    def update_command(index:, command:, username:)
+      if @state == 'DISABLE'
+        raise QueueError, "Queue '#{@name}' is disabled. Command at index #{index} not updated."
+      end
+
+      # Check if command exists at the given index
+      existing = Store.zrangebyscore("#{@scope}:#{@name}", index, index)
+      if existing.empty?
+        raise QueueError, "No command found at index #{index} in queue '#{@name}'"
+      end
+
+      # Remove the existing command and add the new one at the same index
+      Store.zremrangebyscore("#{@scope}:#{@name}", index, index)
+      command_data = { username: username, value: command, timestamp: Time.now.to_nsec_from_epoch }
+      Store.zadd("#{@scope}:#{@name}", index, command_data.to_json)
+      notify(kind: 'command')
+    end
+
+    def remove_command(index = nil)
+      if @state == 'DISABLE'
+        raise QueueError, "Queue '#{@name}' is disabled. Command not removed."
+      end
+
+      if index
+        # Remove specific index
+        result = Store.zrangebyscore("#{@scope}:#{@name}", index, index)
+        if result.empty?
+          return nil
+        else
+          Store.zremrangebyscore("#{@scope}:#{@name}", index, index)
+          command_data = JSON.parse(result[0])
+          command_data['index'] = index.to_f
+          notify(kind: 'command')
+          return command_data
+        end
+      else
+        # Remove first element (lowest score)
+        result = Store.zrange("#{@scope}:#{@name}", 0, 0, with_scores: true)
+        if result.empty?
+          return nil
+        else
+          score = result[0][1]
+          Store.zremrangebyscore("#{@scope}:#{@name}", score, score)
+          command_data = JSON.parse(result[0][0])
+          command_data['index'] = score.to_f
+          notify(kind: 'command')
+          return command_data
+        end
+      end
+    end
+
+    def list
+      return Store.zrange("#{@scope}:#{@name}", 0, -1, with_scores: true).map do |item|
+        result = JSON.parse(item[0])
+        result['index'] = item[1].to_f
+        result
+      end
+    end
+
+    def create_microservice(topics:)
+      # queue Microservice
+      microservice = MicroserviceModel.new(
+        name: @microservice_name,
+        folder_name: nil,
+        cmd: ['ruby', 'queue_microservice.rb', @microservice_name],
+        work_dir: '/openc3/lib/openc3/microservices',
+        options: [
+          ["QUEUE_STATE", @state],
+        ],
+        topics: topics,
+        target_names: [],
+        plugin: nil,
+        scope: @scope
+      )
+      microservice.create
+    end
+
+    def deploy
+      topics = ["#{@scope}__#{QueueTopic::PRIMARY_KEY}"]
+      if MicroserviceModel.get_model(name: @microservice_name, scope: @scope).nil?
+        create_microservice(topics: topics)
+      end
+    end
+
+    def undeploy
+      model = MicroserviceModel.get_model(name: @microservice_name, scope: @scope)
+      if model
+        # Let the frontend know that the microservice is shutting down
+        # Custom event which matches the 'deployed' event in QueueMicroservice
+        notification = {
+          'kind' => 'undeployed',
+          # name and updated_at fields are required for Event formatting
+          'data' => JSON.generate({
+            'name' => @microservice_name,
+            'updated_at' => Time.now.to_nsec_from_epoch,
+          }),
+        }
+        QueueTopic.write_notification(notification, scope: @scope)
+        model.destroy
+      end
+    end
+
+    # Delete the model from the Store
+    def destroy
+      undeploy()
+      Store.zremrangebyrank("#{@scope}:#{@name}", 0, -1)
+      super()
+    end
+  end
+end

data/lib/openc3/models/target_model.rb

@@ -1088,6 +1088,25 @@ module OpenC3
       Logger.info "Configured microservice #{microservice_name}"
     end
 
+    def deploy_tsdb_microservice(gem_path, variables, topics, instance = nil, parent = nil)
+      microservice_name = "#{@scope}__TSDB#{instance}__#{@name}"
+      microservice = MicroserviceModel.new(
+        name: microservice_name,
+        folder_name: @folder_name,
+        cmd: ["python", "quest_microservice.py", microservice_name],
+        work_dir: "/openc3/python/openc3/microservices",
+        topics: topics,
+        plugin: @plugin,
+        parent: nil,
+        needs_dependencies: @needs_dependencies,
+        shard: @shard,
+        scope: @scope
+      )
+      microservice.create
+      microservice.deploy(gem_path, variables)
+      Logger.info "Configured microservice #{microservice_name}"
+    end
+
     def deploy_reducer_microservice(gem_path, variables, topics, instance = nil, parent = nil)
       microservice_name = "#{@scope}__REDUCER#{instance}__#{@name}"
       microservice = MicroserviceModel.new(
@@ -1250,6 +1269,13 @@ module OpenC3
           deploy_decom_microservice(system.targets[@name], gem_path, variables, topics, instance, parent)
         end
 
+        # TSDB Microservice
+        if ENV['OPENC3_TSDB_HOSTNAME'] and ENV['OPENC3_TSDB_QUERY_PORT'] and ENV['OPENC3_TSDB_INGEST_PORT'] and ENV['OPENC3_TSDB_USERNAME'] and ENV['OPENC3_TSDB_PASSWORD']
+          deploy_target_microservices('TSDB', decom_topic_list, "#{@scope}__DECOM__{#{@name}}") do |topics, instance, parent|
+            deploy_tsdb_microservice(gem_path, variables, topics, instance, parent)
+          end
+        end
+
         # Reducer Microservice
         unless @reducer_disable
           # TODO: Does Reducer even need a topic list?

data/lib/openc3/models/tool_model.rb

@@ -184,7 +184,7 @@ module OpenC3
         end
       end
 
-      if @url and !@url.start_with?('/') and !@url.start_with?('http')
+      if @url and !@url.start_with?('/') and @url !~ URI::regexp
         raise "URL must be a full URL (http://domain.com/path) or a relative path (/path)"
       end
 

data/lib/openc3/packets/packet.rb

@@ -334,7 +334,7 @@ module OpenC3
       synchronize() do
         begin
           internal_buffer_equals(buffer)
-        rescue RuntimeError => e
+        rescue RuntimeError
           Logger.instance.error "#{@target_name} #{@packet_name} received with actual packet length of #{buffer.length} but defined length of #{@defined_length}"
         end
         @read_conversion_cache.clear if @read_conversion_cache
@@ -1315,7 +1315,7 @@ module OpenC3
 
         begin
           current_value = read(item.name, :RAW)
-          
+
           case current_value
           when Array
             # For arrays, create a new array of zeros with the same size
@@ -1325,7 +1325,7 @@ module OpenC3
               when :FLOAT
                 obfuscated_value = Array.new(current_value.size, 0.0)
               when :STRING, :BLOCK
-                obfuscated_value = Array.new(current_value.size) { |i| 
+                obfuscated_value = Array.new(current_value.size) { |i|
                   "\x00" * current_value[i].length if current_value[i]
                 }
             else

data/lib/openc3/packets/parsers/state_parser.rb

@@ -80,7 +80,13 @@ module OpenC3
       if data_type == :STRING || data_type == :BLOCK
         @parser.parameters[1]
       else
-        @parser.parameters[1].convert_to_value
+        value = @parser.parameters[1].convert_to_value
+        # Check if the value is a string, which indicates an error in parsing
+        # except for 'ANY' which is a valid state value
+        if value.is_a?(String) and value != "ANY"
+          raise @parser.error("Invalid state value #{value} for data type #{data_type}.", @usage)
+        end
+        return value
       end
     end
 

data/lib/openc3/packets/structure.rb

@@ -603,7 +603,7 @@ module OpenC3
       if item.variable_bit_size
         # Bit size is determined by length field
         length_value = self.read(item.variable_bit_size['length_item_name'], :CONVERTED)
-        if item.data_type == :INT or item.data_type == :UINT and not item.original_array_size
+        if (item.data_type == :INT or item.data_type == :UINT) and not item.original_array_size
           case length_value
           when 0
             return 6
@@ -641,7 +641,14 @@ module OpenC3
             # Calculate the actual current size of this variable length item
             new_bit_size = calculate_total_bit_size(item)
 
-            if item.original_bit_size != new_bit_size
+            if item.original_array_size
+              # Array size has changed from original - so we need to adjust everything after this item
+              # This includes items that may have the same bit_offset as the variable length item because it
+              # started out at zero bit_size
+              if item.original_array_size != new_bit_size
+                adjustment += (new_bit_size - item.original_array_size)
+              end
+            elsif item.original_bit_size != new_bit_size
               # Bit size has changed from original - so we need to adjust everything after this item
               # This includes items that may have the same bit_offset as the variable length item because it
               # started out at zero bit_size

data/lib/openc3/script/calendar.rb

@@ -25,7 +25,7 @@ module OpenC3
 
     def list_timelines(scope: $openc3_scope)
       response = $api_server.request('get', "/openc3-api/timeline", scope: scope)
-      return _handle_response(response, 'Failed to list timelines')
+      return _cal_handle_response(response, 'Failed to list timelines')
     end
 
     def create_timeline(name, color: nil, scope: $openc3_scope)
@@ -33,19 +33,19 @@ module OpenC3
       data['name'] = name
       data['color'] = color if color
       response = $api_server.request('post', "/openc3-api/timeline", data: data, json: true, scope: scope)
-      return _handle_response(response, 'Failed to create timeline')
+      return _cal_handle_response(response, 'Failed to create timeline')
     end
 
     def get_timeline(name, scope: $openc3_scope)
       response = $api_server.request('get', "/openc3-api/timeline/#{name}", scope: scope)
-      return _handle_response(response, 'Failed to get timeline')
+      return _cal_handle_response(response, 'Failed to get timeline')
     end
 
     def set_timeline_color(name, color, scope: $openc3_scope)
       post_data = {}
       post_data['color'] = color
       response = $api_server.request('post', "/openc3-api/timeline/#{name}/color", data: post_data, json: true, scope: scope)
-      return _handle_response(response, 'Failed to set timeline color')
+      return _cal_handle_response(response, 'Failed to set timeline color')
     end
 
     def delete_timeline(name, force: false, scope: $openc3_scope)
@@ -54,7 +54,7 @@ module OpenC3
         url += "?force=true"
       end
       response = $api_server.request('delete', url, scope: scope)
-      return _handle_response(response, 'Failed to delete timeline')
+      return _cal_handle_response(response, 'Failed to delete timeline')
     end
 
     def create_timeline_activity(name, kind:, start:, stop:, data: {}, scope: $openc3_scope)
@@ -69,12 +69,12 @@ module OpenC3
       post_data['kind'] = kind
       post_data['data'] = data
       response = $api_server.request('post', "/openc3-api/timeline/#{name}/activities", data: post_data, json: true, scope: scope)
-      return _handle_response(response, 'Failed to create timeline activity')
+      return _cal_handle_response(response, 'Failed to create timeline activity')
     end
 
     def get_timeline_activity(name, start, uuid, scope: $openc3_scope)
       response = $api_server.request('get', "/openc3-api/timeline/#{name}/activity/#{start}/#{uuid}", scope: scope)
-      return _handle_response(response, 'Failed to get timeline activity')
+      return _cal_handle_response(response, 'Failed to get timeline activity')
     end
 
     def get_timeline_activities(name, start: nil, stop: nil, limit: nil, scope: $openc3_scope)
@@ -86,16 +86,16 @@ module OpenC3
         url += "?limit=#{limit}"
       end
       response = $api_server.request('get', url, scope: scope)
-      return _handle_response(response, 'Failed to get timeline activities')
+      return _cal_handle_response(response, 'Failed to get timeline activities')
     end
 
     def delete_timeline_activity(name, start, uuid, scope: $openc3_scope)
       response = $api_server.request('delete', "/openc3-api/timeline/#{name}/activity/#{start}/#{uuid}", scope: scope)
-      return _handle_response(response, 'Failed to delete timeline activity')
+      return _cal_handle_response(response, 'Failed to delete timeline activity')
     end
 
     # Helper method to handle the response
-    def _handle_response(response, error_message)
+    def _cal_handle_response(response, error_message)
       return nil if response.nil?
       if response.status >= 400
         result = JSON.parse(response.body, :allow_nan => true, :create_additions => true)

data/lib/openc3/script/commands.rb

@@ -115,14 +115,14 @@ module OpenC3
         end
       end
       _log_cmd(command, raw, no_range, no_hazardous)
-   end
+    end
 
     # Send the command and log the results
     # This method signature has to include the keyword params present in cmd_api.rb _cmd_implementation()
     # except for range_check, hazardous_check, and raw as they are part of the cmd name
     # manual is always false since this is called from script and that is the default
     # NOTE: This is a helper method and should not be called directly
-    def _cmd(cmd, cmd_no_hazardous, *args, timeout: nil, log_message: nil, validate: true, scope: $openc3_scope, token: $openc3_token, **kwargs)
+    def _cmd(cmd, cmd_no_hazardous, *args, timeout: nil, log_message: nil, validate: true, queue: nil, scope: $openc3_scope, token: $openc3_token, **kwargs)
       extract_string_kwargs_to_args(args, kwargs)
       raw = cmd.include?('raw')
       no_range = cmd.include?('no_range') || cmd.include?('no_checks')
@@ -132,7 +132,7 @@ module OpenC3
       else
         begin
           begin
-            command = $api_server.method_missing(cmd, *args, timeout: timeout, log_message: log_message, validate: validate, scope: scope, token: token)
+            command = $api_server.method_missing(cmd, *args, timeout: timeout, log_message: log_message, validate: validate, queue: queue, scope: scope, token: token)
             if log_message.nil? or log_message
               _log_cmd(command, raw, no_range, no_hazardous)
             end
@@ -140,7 +140,7 @@ module OpenC3
             # This opens a prompt at which point they can cancel and stop the script
             # or say Yes and send the command. Thus we don't care about the return value.
             prompt_for_hazardous(e.target_name, e.cmd_name, e.hazardous_description)
-            command = $api_server.method_missing(cmd_no_hazardous, *args, timeout: timeout, log_message: log_message, validate: validate, scope: scope, token: token)
+            command = $api_server.method_missing(cmd_no_hazardous, *args, timeout: timeout, log_message: log_message, validate: validate, queue: queue, scope: scope, token: token)
             if log_message.nil? or log_message
               _log_cmd(command, raw, no_range, no_hazardous)
             end

data/lib/openc3/script/queue.rb

@@ -0,0 +1,80 @@
+# encoding: ascii-8bit
+
+# Copyright 2025 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/script/extract'
+
+module OpenC3
+  module Script
+    include Extract
+
+    private
+
+    # Helper method that makes the request and parses the response
+    def _make_request(action:, verb:, uri:, scope:, data: nil)
+      response = $api_server.request(verb, uri, data: data, json: data.nil? ? false : true, scope: scope)
+      if response.nil?
+        raise "Failed to #{action}. No response from server."
+      elsif response.status != 200 and response.status != 201
+        result = JSON.parse(response.body, :allow_nan => true, :create_additions => true)
+        raise "Failed to #{action} due to #{result['message']}"
+      end
+      return JSON.parse(response.body, :allow_nan => true, :create_additions => true)
+    end
+
+    def queue_all(scope: $openc3_scope)
+      return _make_request(action: 'index queue', verb: 'get', uri: "/openc3-api/queues", scope: scope)
+    end
+
+    def queue_get(name, scope: $openc3_scope)
+      return _make_request(action: 'get queue', verb: 'get', uri: "/openc3-api/queues/#{name}", scope: scope)
+    end
+
+    def queue_list(name, scope: $openc3_scope)
+      return _make_request(action: 'list queue', verb: 'get', uri: "/openc3-api/queues/#{name}/list", scope: scope)
+    end
+
+    def queue_create(name, state: 'HOLD', scope: $openc3_scope)
+      data = {}
+      data['state'] = state
+      return _make_request(action: 'create queue', verb: 'post', uri: "/openc3-api/queues/#{name}", data: data, scope: scope)
+    end
+
+    def queue_hold(name, scope: $openc3_scope)
+      return _make_request(action: 'hold queue', verb: 'post', uri: "/openc3-api/queues/#{name}/hold", scope: scope)
+    end
+
+    def queue_release(name, scope: $openc3_scope)
+      return _make_request(action: 'release queue', verb: 'post', uri: "/openc3-api/queues/#{name}/release", scope: scope)
+    end
+
+    def queue_disable(name, scope: $openc3_scope)
+      return _make_request(action: 'disable queue', verb: 'post', uri: "/openc3-api/queues/#{name}/disable", scope: scope)
+    end
+
+    def queue_exec(name, index: nil, scope: $openc3_scope)
+      data = {}
+      data['index'] = index if index
+      return _make_request(action: 'exec command', verb: 'post', uri: "/openc3-api/queues/#{name}/exec_command", data: data, scope: scope)
+    end
+
+    def queue_delete(name, scope: $openc3_scope)
+      return _make_request(action: 'delete queue', verb: 'delete', uri: "/openc3-api/queues/#{name}", scope: scope)
+    end
+    alias queue_destroy queue_delete
+  end
+end

data/lib/openc3/script/script.rb

@@ -34,6 +34,7 @@ require 'openc3/script/limits'
 require 'openc3/script/metadata'
 require 'openc3/script/packages'
 require 'openc3/script/plugins'
+require 'openc3/script/queue'
 require 'openc3/script/screen'
 require 'openc3/script/script_runner'
 require 'openc3/script/storage'

data/lib/openc3/script/script_runner.rb

@@ -71,7 +71,7 @@ module OpenC3
       end
     end
 
-    def script_run(filename, disconnect: false, environment: nil, scope: $openc3_scope)
+    def script_run(filename, disconnect: false, environment: nil, suite_runner: nil, scope: $openc3_scope)
       if disconnect
         endpoint = "/script-api/scripts/#{filename}/run/disconnect"
       else
@@ -87,8 +87,13 @@ module OpenC3
       else
         env_data = []
       end
+      data = { environment: env_data }
+      if suite_runner
+        # TODO 7.0: Should suiteRunner be snake case?
+        data['suiteRunner'] = suite_runner
+      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)
+      response = $script_runner_api_server.request('post', endpoint, json: true, data: data, scope: scope)
       if response.nil? || response.status != 200
         _script_response_error(response, "Failed to run #{filename}", scope: scope)
       else

data/lib/openc3/script/tables.rb

@@ -24,7 +24,7 @@ module OpenC3
       post_data = {}
       post_data['definition'] = definition
       response = $api_server.request('post', '/openc3-api/tables/generate', json: true, data: post_data, scope: scope)
-      return _handle_response(response, 'Failed to create binary')
+      return _tables_handle_response(response, 'Failed to create binary')
     end
 
     def table_create_report(filename, definition, table_name: nil, scope: $openc3_scope)
@@ -33,11 +33,11 @@ module OpenC3
       post_data['definition'] = definition
       post_data['table_name'] = table_name if table_name
       response = $api_server.request('post', '/openc3-api/tables/report', json: true, data: post_data, scope: scope)
-      return _handle_response(response, 'Failed to create report')
+      return _tables_handle_response(response, 'Failed to create report')
     end
 
     # Helper method to handle the response
-    def _handle_response(response, error_message)
+    def _tables_handle_response(response, error_message)
       return nil if response.nil?
       if response.status >= 400
         result = JSON.parse(response.body, :allow_nan => true, :create_additions => true)

data/lib/openc3/script/web_socket_api.rb

@@ -306,6 +306,17 @@ module OpenC3
     end
   end
 
+  # Queue WebSocket
+  class QueueEventsWebSocketApi < CmdTlmWebSocketApi
+    def initialize(history_count: 0, url: nil, write_timeout: 10.0, read_timeout: 10.0, connect_timeout: 5.0, authentication: nil, scope: $openc3_scope)
+      @identifier = {
+        channel: "QueueEventsChannel",
+        history_count: history_count
+      }
+      super(url: url, write_timeout: write_timeout, read_timeout: read_timeout, connect_timeout: connect_timeout, authentication: authentication, scope: scope)
+    end
+  end
+
   # Streaming API WebSocket
   class StreamingWebSocketApi < CmdTlmWebSocketApi
     def initialize(url: nil, write_timeout: 10.0, read_timeout: 10.0, connect_timeout: 5.0, authentication: nil, scope: $openc3_scope)

data/lib/openc3/topics/queue_topic.rb

@@ -0,0 +1,29 @@
+# encoding: ascii-8bit
+
+# Copyright 2025 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/topics/topic'
+
+module OpenC3
+  class QueueTopic < Topic
+    PRIMARY_KEY = "openc3_queue"
+
+    def self.write_notification(notification, scope:)
+      Topic.write_topic("#{scope}__#{PRIMARY_KEY}", notification, '*', 1000)
+    end
+  end
+end

data/lib/openc3/utilities/authorization.rb

@@ -50,7 +50,7 @@ rescue LoadError
       end
 
       def user_info(_token)
-        {} # EE does stuff here
+        {} # Enterprise does stuff here
       end
     end
   end

data/lib/openc3/utilities/cosmos_rails_formatter.rb

@@ -29,7 +29,7 @@ module OpenC3
             user = {}
           end
           username = user['username']
-          # Core username (EE has the actual username)
+          # Core username (Enterprise has the actual username)
           username ||= 'anonymous'
         end
       end