Class: OpenC3::System

Inherits:
Object show all
Defined in:
lib/openc3/system/system.rb,
ext/openc3/ext/telemetry/telemetry.c

Constant Summary collapse

@@instance =

Variable that holds the singleton instance

nil
@@instance_mutex =

Mutex used to ensure that only one instance of System is created

Mutex.new
@@limits_set =

The current limits set

nil
@@post_instance_callbacks =

Callbacks to call once @@instance is created

[]

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(target_names, target_config_dir) ⇒ System

Create a new System object.

Parameters:

  • target_names (Array of target names)
  • target_config_dir —

    Directory where target config folders are



163
164
165
166
167
168
169
170
171
 
# File 'lib/openc3/system/system.rb', line 163

def initialize(target_names, target_config_dir)
  OpenC3.add_to_search_path(target_config_dir, true) if target_config_dir
  @targets = {}
  @packet_config = PacketConfig.new
  @commands = Commands.new(@packet_config)
  @telemetry = Telemetry.new(@packet_config)
  @limits = Limits.new(@packet_config)
  target_names.each { |target_name| add_target(target_name, target_config_dir) }
end

Class Method Details

.add_post_instance_callback(callback) ⇒ Object 



78
79
80
81
82
83
84
 
# File 'lib/openc3/system/system.rb', line 78

def self.add_post_instance_callback(callback)
  if @@instance
    callback.call()
  else
    @@post_instance_callbacks << callback
  end
end

.dynamic_update(dynamic_packets, cmd_or_tlm = :TELEMETRY, affect_ids: false) ⇒ Object

Dynamically add packets to the system instance

Parameters:

  • dynamic_packets (Array of packets)
  • cmd_or_tlm (Symbol) (defaults to: :TELEMETRY) —

    :COMMAND or :TELEMETRY

  • affect_ids (Boolean) (defaults to: false) —

    Whether to affect packet id lookup or not



149
150
151
152
153
154
155
156
157
 
# File 'lib/openc3/system/system.rb', line 149

def self.dynamic_update(dynamic_packets, cmd_or_tlm = :TELEMETRY, affect_ids: false)
  dynamic_packets.each do |packet|
    if cmd_or_tlm == :TELEMETRY
      @@instance.telemetry.dynamic_add_packet(packet, affect_ids: affect_ids)
    else
      @@instance.commands.dynamic_add_packet(packet, affect_ids: affect_ids)
    end
  end
end

.instance(target_names = nil, target_config_dir = nil) ⇒ System

Get the singleton instance of System

Parameters:

  • target_names (Array of target_names) (defaults to: nil)
  • target_config_dir (defaults to: nil) —

    Directory where target config folders are

Returns:

  • (System) —

    The System singleton



130
131
132
133
134
135
136
137
138
139
140
141
142
 
# File 'lib/openc3/system/system.rb', line 130

def self.instance(target_names = nil, target_config_dir = nil)
  return @@instance if @@instance
  raise "System.instance parameters are required on first call" unless target_names and target_config_dir

  @@instance_mutex.synchronize do
    return @@instance if @@instance
    @@instance ||= self.new(target_names, target_config_dir)
    @@post_instance_callbacks.each do |callback|
      callback.call
    end
    return @@instance
  end
end

.limits_set ⇒ Symbol

Returns The current limits_set of the system returned from Redis.

Returns:

  • (Symbol) —

    The current limits_set of the system returned from Redis



67
68
69
70
71
72
 
# File 'lib/openc3/system/system.rb', line 67

def self.limits_set
  unless @@limits_set
    @@limits_set = LimitsEventTopic.current_set(scope: $openc3_scope).to_s.intern
  end
  @@limits_set
end

.limits_set=(value) ⇒ Object 



74
75
76
 
# File 'lib/openc3/system/system.rb', line 74

def self.limits_set=(value)
  @@limits_set = value.to_s.intern
end

.setup_targets(target_names, base_dir, scope:) ⇒ Object 



86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
 
# File 'lib/openc3/system/system.rb', line 86

def self.setup_targets(target_names, base_dir, scope:)
  # Nothing to do if there are no targets
  return if target_names.nil? or target_names.length == 0
  if @@instance.nil?
    FileUtils.mkdir_p("#{base_dir}/targets")
    bucket = Bucket.getClient()
    target_names.each do |target_name|
      # Retrieve bucket/targets/target_name/target_id.zip
      zip_path = "#{base_dir}/targets/#{target_name}_current.zip"
      FileUtils.mkdir_p(File.dirname(zip_path))
      bucket_key = "#{scope}/target_archives/#{target_name}/#{target_name}_current.zip"
      Logger.info("Retrieving #{bucket_key} from targets bucket")
      bucket.get_object(bucket: ENV['OPENC3_CONFIG_BUCKET'], key: bucket_key, path: zip_path)
      Zip::File.open(zip_path) do |zip_file|
        zip_file.each do |entry|
          path = File.join("#{base_dir}/targets", entry.name)
          FileUtils.mkdir_p(File.dirname(path))
          zip_file.extract(entry, path) unless File.exist?(path)
        end
      end

      # Now add any modifications in targets_modified/TARGET/cmd_tlm
      # This adds support for remembering dynamically created packets
      # target.txt must be configured to either use all files in cmd_tlm folder (default)
      # or have a predetermined empty file like dynamic_tlm.txt
      bucket_path = "#{scope}/targets_modified/#{target_name}/cmd_tlm"
      dirs, files = bucket.list_files(bucket: ENV['OPENC3_CONFIG_BUCKET'], path: bucket_path)
      files.each do |file|
        bucket_key = File.join(bucket_path, file['name'])
        local_path = "#{base_dir}/targets/#{target_name}/cmd_tlm/#{file['name']}"
        bucket.get_object(bucket: ENV['OPENC3_CONFIG_BUCKET'], key: bucket_key, path: local_path)
      end
    end

    # Build System from targets
    System.instance(target_names, "#{base_dir}/targets")
  end
end

Instance Method Details

#add_target(target_name, target_config_dir) ⇒ Object 



173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
 
# File 'lib/openc3/system/system.rb', line 173

def add_target(target_name, target_config_dir)
  parser = ConfigParser.new
  folder_name = File.join(target_config_dir, target_name)
  raise parser.error("Target folder must exist '#{folder_name}'.") unless Dir.exist?(folder_name)

  target = Target.new(target_name, target_config_dir)
  @targets[target.name] = target
  errors = [] # Store all errors processing the cmd_tlm files
  target.cmd_tlm_files.each do |cmd_tlm_file|
    @packet_config.process_file(cmd_tlm_file, target.name)
  rescue Exception => error
    errors << "Error processing #{cmd_tlm_file}:\n#{error.message}"
  end
  unless errors.empty?
    raise errors.join("\n")
  end
end

#commands ⇒ Commands

Returns Access to the command definition.

Returns:

  • (Commands) —

    Access to the command definition



46
 
# File 'lib/openc3/system/system.rb', line 46

instance_attr_reader :commands

#limits ⇒ Limits

Returns Access to the limits definition.

Returns:

  • (Limits) —

    Access to the limits definition



52
 
# File 'lib/openc3/system/system.rb', line 52

instance_attr_reader :limits

#packet_config ⇒ PacketConfig

Returns Access to the packet configuration.

Returns:



43
 
# File 'lib/openc3/system/system.rb', line 43

instance_attr_reader :packet_config

#targets ⇒ Hash<String,Target>

Returns Hash of all the known targets.

Returns:



40
 
# File 'lib/openc3/system/system.rb', line 40

instance_attr_reader :targets

#telemetry ⇒ Telemetry

Returns Access to the telemetry definition.

Returns:

  • (Telemetry) —

    Access to the telemetry definition



49
 
# File 'lib/openc3/system/system.rb', line 49

instance_attr_reader :telemetry