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

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



121
122
123
124
125
126
127
128
129
 
# File 'lib/openc3/system/system.rb', line 121

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)
  @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

.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



107
108
109
110
111
112
113
114
115
 
# File 'lib/openc3/system/system.rb', line 107

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
    @@instance ||= self.new(target_names, target_config_dir)
    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



64
65
66
67
68
69
 
# File 'lib/openc3/system/system.rb', line 64

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 



71
72
73
 
# File 'lib/openc3/system/system.rb', line 71

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

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



75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
 
# File 'lib/openc3/system/system.rb', line 75

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
    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 



131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
 
# File 'lib/openc3/system/system.rb', line 131

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