Class: Cosmos::Interface

Inherits:
Object show all
Includes:
Api
Defined in:
lib/cosmos/interfaces/interface.rb

Overview

Defines all the attributes and methods common to all interface classes used by COSMOS.

Constant Summary

Constants included from Api

Api::SETTINGS_KEY, Api::SUBSCRIPTION_DELIMITER

Constants included from ApiShared

ApiShared::DEFAULT_TLM_POLLING_RATE

Constants included from Extract

Extract::SCANNING_REGULAR_EXPRESSION

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Api

#_get_cnt, #_limits_group, #_validate_tlm_type, #build_cmd_output_string, #cmd, #cmd_implementation, #cmd_no_checks, #cmd_no_hazardous_check, #cmd_no_range_check, #cmd_raw, #cmd_raw_no_checks, #cmd_raw_no_hazardous_check, #cmd_raw_no_range_check, #connect_interface, #connect_router, #delete_config, #disable_limits, #disable_limits_group, #disconnect_interface, #disconnect_router, #enable_limits, #enable_limits_group, #get_all_cmd_info, #get_all_cmd_tlm_info, #get_all_commands, #get_all_commands_list, #get_all_interface_info, #get_all_router_info, #get_all_settings, #get_all_target_info, #get_all_telemetry, #get_all_telemetry_list, #get_all_tlm_info, #get_cmd_buffer, #get_cmd_cnt, #get_cmd_hazardous, #get_cmd_time, #get_cmd_value, #get_command, #get_interface, #get_interface_names, #get_item, #get_limits, #get_limits_events, #get_limits_groups, #get_limits_set, #get_limits_sets, #get_oldest_logfile, #get_out_of_limits, #get_overall_limits_state, #get_packet_derived_items, #get_packets, #get_parameter, #get_router, #get_router_names, #get_saved_config, #get_setting, #get_settings, #get_stale, #get_target, #get_target_list, #get_telemetry, #get_tlm_buffer, #get_tlm_cnt, #get_tlm_packet, #get_tlm_values, #inject_tlm, #limits_enabled?, #list_configs, #list_settings, #load_config, #normalize_tlm, #save_config, #save_setting, #send_raw, #set_limits, #set_limits_set, #set_tlm, #set_tlm_process_args, #start_raw_logging_interface, #start_raw_logging_router, #stop_raw_logging_interface, #stop_raw_logging_router, #subscribe_packets, #tlm, #tlm_formatted, #tlm_process_args, #tlm_raw, #tlm_variable, #tlm_with_units

Constructor Details

#initialize ⇒ Interface

Initialize default attribute values



129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
 
# File 'lib/cosmos/interfaces/interface.rb', line 129

def initialize
  @name = self.class.to_s.split("::")[-1] # Remove namespacing if present
  @state = 'DISCONNECTED'
  @target_names = []
  @connect_on_startup = true
  @auto_reconnect = true
  @reconnect_delay = 5.0
  @disable_disconnect = false
  @packet_log_writer_pairs = []
  @stored_packet_log_writer_pairs = []
  # TODO: How should this get the log directory
  @raw_logger_pair = RawLoggerPair.new(@name, 'outputs/logs')
  @routers = []
  @cmd_routers = []
  @read_count = 0
  @write_count = 0
  @bytes_read = 0
  @bytes_written = 0
  @num_clients = 0
  @read_queue_size = 0
  @write_queue_size = 0
  @write_mutex = Mutex.new
  @read_allowed = true
  @write_allowed = true
  @write_raw_allowed = true
  @options = {}
  @read_protocols = []
  @write_protocols = []
  @protocol_info = []
  @override_tlm = nil
  @read_raw_data = ''
  @written_raw_data = ''
  @read_raw_data_time = nil
  @written_raw_data_time = nil
  @config_params = []
  @interfaces = []
end

Instance Attribute Details

#auto_reconnect ⇒ Boolean

Returns Flag indicating if the interface should automatically reconnect after losing connection.

Returns:

  • (Boolean) —

    Flag indicating if the interface should automatically reconnect after losing connection



44
45
46
 
# File 'lib/cosmos/interfaces/interface.rb', line 44

def auto_reconnect
  @auto_reconnect
end

#bytes_read ⇒ Integer

Returns The number of bytes read from this interface.

Returns:

  • (Integer) —

    The number of bytes read from this interface



77
78
79
 
# File 'lib/cosmos/interfaces/interface.rb', line 77

def bytes_read
  @bytes_read
end

#bytes_written ⇒ Integer

Returns The number of bytes written to this interface.

Returns:

  • (Integer) —

    The number of bytes written to this interface



80
81
82
 
# File 'lib/cosmos/interfaces/interface.rb', line 80

def bytes_written
  @bytes_written
end

#cmd_routers ⇒ Array<Routers>

Returns Array of cmd routers that mirror packets sent from the interface.

Returns:

  • (Array<Routers>) —

    Array of cmd routers that mirror packets sent from the interface



68
69
70
 
# File 'lib/cosmos/interfaces/interface.rb', line 68

def cmd_routers
  @cmd_routers
end

#config_params ⇒ Array

Returns Config params from the INTERFACE config line.

Returns:

  • (Array) —

    Config params from the INTERFACE config line



122
123
124
 
# File 'lib/cosmos/interfaces/interface.rb', line 122

def config_params
  @config_params
end

#connect_on_startup ⇒ Boolean

Returns Flag indicating if the interface should be connected to on startup.

Returns:

  • (Boolean) —

    Flag indicating if the interface should be connected to on startup



40
41
42
 
# File 'lib/cosmos/interfaces/interface.rb', line 40

def connect_on_startup
  @connect_on_startup
end

#disable_disconnect ⇒ Boolean

Returns Flag indicating if the user is allowed to disconnect this interface.

Returns:

  • (Boolean) —

    Flag indicating if the user is allowed to disconnect this interface



51
52
53
 
# File 'lib/cosmos/interfaces/interface.rb', line 51

def disable_disconnect
  @disable_disconnect
end

#interfaces ⇒ Array<Interface>

Returns Array of interfaces to route packets to (when used as a BridgeRouter).

Returns:

  • (Array<Interface>) —

    Array of interfaces to route packets to (when used as a BridgeRouter)



126
127
128
 
# File 'lib/cosmos/interfaces/interface.rb', line 126

def interfaces
  @interfaces
end

#name ⇒ String

Returns Name of the interface.

Returns:

  • (String) —

    Name of the interface



30
31
32
 
# File 'lib/cosmos/interfaces/interface.rb', line 30

def name
  @name
end

#num_clients ⇒ Integer

Returns The number of active clients (when used as a Router).

Returns:

  • (Integer) —

    The number of active clients (when used as a Router)



84
85
86
 
# File 'lib/cosmos/interfaces/interface.rb', line 84

def num_clients
  @num_clients
end

#options ⇒ Hash<option name, option values>

Returns Hash of options supplied to interface/router.

Returns:

  • (Hash<option name, option values>) —

    Hash of options supplied to interface/router



95
96
97
 
# File 'lib/cosmos/interfaces/interface.rb', line 95

def options
  @options
end

#override_tlm ⇒ Hash or nil

Returns Hash of overridden telemetry points.

Returns:

  • (Hash or nil) —

    Hash of overridden telemetry points



107
108
109
 
# File 'lib/cosmos/interfaces/interface.rb', line 107

def override_tlm
  @override_tlm
end

#packet_log_writer_pairs ⇒ Array

Returns Array of packet logger classes for this interface.

Returns:

  • (Array) —

    Array of packet logger classes for this interface



54
55
56
 
# File 'lib/cosmos/interfaces/interface.rb', line 54

def packet_log_writer_pairs
  @packet_log_writer_pairs
end

#protocol_info ⇒ Array<[Protocol Class, Protocol Args, Protocol kind (:READ, :WRITE, :READ_WRITE)>] Info to recreate protocols

Returns Array<[Protocol Class, Protocol Args, Protocol kind (:READ, :WRITE, :READ_WRITE)>] Info to recreate protocols.

Returns:

  • (Array<[Protocol Class, Protocol Args, Protocol kind (:READ, :WRITE, :READ_WRITE)>] Info to recreate protocols) —

    Array<[Protocol Class, Protocol Args, Protocol kind (:READ, :WRITE, :READ_WRITE)>] Info to recreate protocols



104
105
106
 
# File 'lib/cosmos/interfaces/interface.rb', line 104

def protocol_info
  @protocol_info
end

#raw_logger_pair ⇒ RawLoggerPair

Returns RawLoggerPair instance or nil.

Returns:



60
61
62
 
# File 'lib/cosmos/interfaces/interface.rb', line 60

def raw_logger_pair
  @raw_logger_pair
end

#read_count ⇒ Integer

Returns The number of packets read from this interface.

Returns:

  • (Integer) —

    The number of packets read from this interface



71
72
73
 
# File 'lib/cosmos/interfaces/interface.rb', line 71

def read_count
  @read_count
end

#read_protocols ⇒ Array<Protocol>

Returns Array of protocols for reading.

Returns:



98
99
100
 
# File 'lib/cosmos/interfaces/interface.rb', line 98

def read_protocols
  @read_protocols
end

#read_queue_size ⇒ Integer

Returns The number of packets in the read queue (when used as a Router).

Returns:

  • (Integer) —

    The number of packets in the read queue (when used as a Router)



88
89
90
 
# File 'lib/cosmos/interfaces/interface.rb', line 88

def read_queue_size
  @read_queue_size
end

#read_raw_data ⇒ String

Returns Most recently read raw data.

Returns:

  • (String) —

    Most recently read raw data



110
111
112
 
# File 'lib/cosmos/interfaces/interface.rb', line 110

def read_raw_data
  @read_raw_data
end

#read_raw_data_time ⇒ Time

Returns Most recent read raw data time.

Returns:

  • (Time) —

    Most recent read raw data time



116
117
118
 
# File 'lib/cosmos/interfaces/interface.rb', line 116

def read_raw_data_time
  @read_raw_data_time
end

#reconnect_delay ⇒ Integer[ Delay between reconnect attempts

Returns Integer[ Delay between reconnect attempts.

Returns:

  • (Integer[ Delay between reconnect attempts) —

    Integer[ Delay between reconnect attempts



47
48
49
 
# File 'lib/cosmos/interfaces/interface.rb', line 47

def reconnect_delay
  @reconnect_delay
end

#routers ⇒ Array<Routers>

Returns Array of routers that receive packets read from the interface.

Returns:

  • (Array<Routers>) —

    Array of routers that receive packets read from the interface



64
65
66
 
# File 'lib/cosmos/interfaces/interface.rb', line 64

def routers
  @routers
end

#state ⇒ String

Returns State of the interface: CONNECTED, ATTEMPTING, DISCONNECTED.

Returns:

  • (String) —

    State of the interface: CONNECTED, ATTEMPTING, DISCONNECTED



33
34
35
 
# File 'lib/cosmos/interfaces/interface.rb', line 33

def state
  @state
end

#stored_packet_log_writer_pairs ⇒ Array

Returns Array of stored packet log writers.

Returns:

  • (Array) —

    Array of stored packet log writers



57
58
59
 
# File 'lib/cosmos/interfaces/interface.rb', line 57

def stored_packet_log_writer_pairs
  @stored_packet_log_writer_pairs
end

#target_names ⇒ Array<String>

Returns Array of target names associated with this interface.

Returns:

  • (Array<String>) —

    Array of target names associated with this interface



36
37
38
 
# File 'lib/cosmos/interfaces/interface.rb', line 36

def target_names
  @target_names
end

#write_count ⇒ Integer

Returns The number of packets written to this interface.

Returns:

  • (Integer) —

    The number of packets written to this interface



74
75
76
 
# File 'lib/cosmos/interfaces/interface.rb', line 74

def write_count
  @write_count
end

#write_protocols ⇒ Array<Protocol>

Returns Array of protocols for writing.

Returns:



101
102
103
 
# File 'lib/cosmos/interfaces/interface.rb', line 101

def write_protocols
  @write_protocols
end

#write_queue_size ⇒ Integer

Returns The number of packets in the write queue (when used as a Router).

Returns:

  • (Integer) —

    The number of packets in the write queue (when used as a Router)



92
93
94
 
# File 'lib/cosmos/interfaces/interface.rb', line 92

def write_queue_size
  @write_queue_size
end

#written_raw_data ⇒ String

Returns Most recently written raw data.

Returns:

  • (String) —

    Most recently written raw data



113
114
115
 
# File 'lib/cosmos/interfaces/interface.rb', line 113

def written_raw_data
  @written_raw_data
end

#written_raw_data_time ⇒ Time

Returns Most recent written raw data time.

Returns:

  • (Time) —

    Most recent written raw data time



119
120
121
 
# File 'lib/cosmos/interfaces/interface.rb', line 119

def written_raw_data_time
  @written_raw_data_time
end

Instance Method Details

#_normalize_tlm(target_name, packet_name, item_name) ⇒ Object 



482
483
484
485
486
487
488
489
 
# File 'lib/cosmos/interfaces/interface.rb', line 482

def _normalize_tlm(target_name, packet_name, item_name)
  @override_tlm ||= {}
  pkt = @override_tlm[target_name]
  if pkt
    items = @override_tlm[target_name][packet_name]
    items.delete(item_name) if items
  end
end

#_override(target_name, packet_name, item_name, value, type) ⇒ Object 



491
492
493
494
495
496
 
# File 'lib/cosmos/interfaces/interface.rb', line 491

def _override(target_name, packet_name, item_name, value, type)
  @override_tlm ||= {}
  @override_tlm[target_name] ||= {}
  @override_tlm[target_name][packet_name] ||= {}
  @override_tlm[target_name][packet_name][item_name] = [value, type]
end

#_override_tlm(target_name, packet_name, item_name, value) ⇒ Object 



474
475
476
 
# File 'lib/cosmos/interfaces/interface.rb', line 474

def _override_tlm(target_name, packet_name, item_name, value)
  _override(target_name, packet_name, item_name, value, :CONVERTED)
end

#_override_tlm_raw(target_name, packet_name, item_name, value) ⇒ Object 



478
479
480
 
# File 'lib/cosmos/interfaces/interface.rb', line 478

def _override_tlm_raw(target_name, packet_name, item_name, value)
  _override(target_name, packet_name, item_name, value, :RAW)
end

#_write ⇒ Object

Wrap all writes in a mutex and handle errors



315
316
317
318
319
320
321
322
323
324
325
 
# File 'lib/cosmos/interfaces/interface.rb', line 315

def _write
  if @write_mutex.owned?
    yield
  else
    @write_mutex.synchronize { yield }
  end
rescue Exception => err
  Logger.error("#{@name}: Error writing to interface")
  disconnect()
  raise err
end

#add_protocol(protocol_class, protocol_args, read_write) ⇒ Object 



456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
 
# File 'lib/cosmos/interfaces/interface.rb', line 456

def add_protocol(protocol_class, protocol_args, read_write)
  protocol_args = protocol_args.clone
  protocol = protocol_class.new(*protocol_args)
  case read_write
  when :READ
    @read_protocols << protocol
  when :WRITE
    @write_protocols.unshift(protocol)
  when :READ_WRITE
    @read_protocols << protocol
    @write_protocols.unshift(protocol)
  else
    raise "Unknown protocol descriptor: #{read_write}. Must be :READ, :WRITE, or :READ_WRITE."
  end
  @protocol_info << [protocol_class, protocol_args, read_write]
  protocol.interface = self
end

#as_json ⇒ Object 



327
328
329
330
331
332
333
334
335
336
337
338
339
 
# File 'lib/cosmos/interfaces/interface.rb', line 327

def as_json
  config = {}
  config['name'] = @name
  config['state'] = @state
  config['clients'] = @num_clients
  config['txsize'] = @write_queue_size
  config['rxsize'] = @read_queue_size
  config['txbytes'] = @bytes_written
  config['rxbytes'] = @bytes_read
  config['txcnt'] = @write_count
  config['rxcnt'] = @read_count
  config
end

#connect ⇒ Object

Connects the interface to its target(s). Must be implemented by a subclass.



169
170
171
 
# File 'lib/cosmos/interfaces/interface.rb', line 169

def connect
  (@read_protocols | @write_protocols).each { |protocol| protocol.connect_reset }
end

#connected? ⇒ Boolean

Indicates if the interface is connected to its target(s) or not. Must be implemented by a subclass.

Returns:

  • (Boolean) 


175
176
177
 
# File 'lib/cosmos/interfaces/interface.rb', line 175

def connected?
  raise "connected? not defined by Interface"
end

#convert_data_to_packet(data) ⇒ Packet

Called to convert the read data into a COSMOS Packet object

Parameters:

  • data (String) —

    Raw packet data

Returns:

  • (Packet) —

    COSMOS Packet with buffer filled with data



416
417
418
 
# File 'lib/cosmos/interfaces/interface.rb', line 416

def convert_data_to_packet(data)
  Packet.new(nil, nil, :BIG_ENDIAN, nil, data)
end

#convert_packet_to_data(packet) ⇒ Object

Called to convert a packet into the data to send

Parameters:

  • packet (Packet) —

    Packet to extract data from

Returns:

  • data



424
425
426
 
# File 'lib/cosmos/interfaces/interface.rb', line 424

def convert_packet_to_data(packet)
  packet.buffer(true) # Copy buffer so logged command isn't modified
end

#copy_to(other_interface) ⇒ Object

Copy settings from this interface to another interface. All instance variables are copied except for num_clients, read_queue_size, and write_queue_size since these are all specific to the operation of the interface rather than its instantiation.

Parameters:

  • other_interface (Interface) —

    The other interface to copy to



378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
 
# File 'lib/cosmos/interfaces/interface.rb', line 378

def copy_to(other_interface)
  other_interface.name = self.name.clone
  other_interface.target_names = self.target_names.clone
  other_interface.connect_on_startup = self.connect_on_startup
  other_interface.auto_reconnect = self.auto_reconnect
  other_interface.reconnect_delay = self.reconnect_delay
  other_interface.disable_disconnect = self.disable_disconnect
  other_interface.packet_log_writer_pairs = self.packet_log_writer_pairs.clone
  other_interface.routers = self.routers.clone
  other_interface.cmd_routers = self.cmd_routers.clone
  other_interface.read_count = self.read_count
  other_interface.write_count = self.write_count
  other_interface.bytes_read = self.bytes_read
  other_interface.bytes_written = self.bytes_written
  other_interface.raw_logger_pair = self.raw_logger_pair.clone if @raw_logger_pair
  # num_clients is per interface so don't copy
  # read_queue_size is the number of packets in the queue so don't copy
  # write_queue_size is the number of packets in the queue so don't copy
  other_interface.options = self.options.clone
  other_interface.protocol_info = []
  self.protocol_info.each do |protocol_class, protocol_args, read_write|
    other_interface.add_protocol(protocol_class, protocol_args, read_write)
  end
  other_interface.override_tlm = nil
  other_interface.override_tlm = self.override_tlm.clone if self.override_tlm
end

#disconnect ⇒ Object

Disconnects the interface from its target(s). Must be implemented by a subclass.



181
182
183
 
# File 'lib/cosmos/interfaces/interface.rb', line 181

def disconnect
  (@read_protocols | @write_protocols).each { |protocol| protocol.disconnect_reset }
end

#read ⇒ Packet

Retrieves the next packet from the interface.

Returns:

  • (Packet) —

    Packet constructed from the data. Packet will be unidentified (nil target and packet names)



196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
 
# File 'lib/cosmos/interfaces/interface.rb', line 196

def read
  raise "Interface not connected for read: #{@name}" unless connected?
  raise "Interface not readable: #{@name}" unless read_allowed?

  first = true
  loop do
    # Protocols may have cached data for a packet, so initially just inject a blank string
    # Otherwise we can hold off outputing other packets where all the data has already
    # been received
    if !first or @read_protocols.length <= 0
      # Read data for a packet
      data = read_interface()
      unless data
        Logger.info("#{@name}: read_interface requested disconnect")
        return nil
      end
    else
      data = ''
      first = false
    end

    @read_protocols.each do |protocol|
      data = protocol.read_data(data)
      if data == :DISCONNECT
        Logger.info("#{@name}: Protocol #{protocol.class} read_data requested disconnect")
        return nil
      end
      break if data == :STOP
    end
    next if data == :STOP

    packet = convert_data_to_packet(data)

    # Potentially modify packet
    @read_protocols.each do |protocol|
      packet = protocol.read_packet(packet)
      if packet == :DISCONNECT
        Logger.info("#{@name}: Protocol #{protocol.class} read_packet requested disconnect")
        return nil
      end
      break if packet == :STOP
    end
    next if packet == :STOP

    # Return packet
    @read_count += 1
    Logger.warn("#{@name}: Interface unexpectedly requested disconnect") unless packet
    return packet
  end
rescue Exception => err
  Logger.error("#{@name}: Error reading from interface")
  disconnect()
  raise err
end

#read_allowed? ⇒ Boolean

Returns Whether reading is allowed.

Returns:

  • (Boolean) —

    Whether reading is allowed



342
343
344
 
# File 'lib/cosmos/interfaces/interface.rb', line 342

def read_allowed?
  @read_allowed
end

#read_interface ⇒ Object 



185
186
187
 
# File 'lib/cosmos/interfaces/interface.rb', line 185

def read_interface
  raise "read_interface not defined by Interface"
end

#read_interface_base(data) ⇒ String

Called to read data and manipulate it until enough data is returned. The definition of ‘enough data’ changes depending on the protocol used which is why this method exists. This method is also used to perform operations on the data before it can be interpreted as packet data such as decryption. After this method is called the post_read_data method is called. Subclasses must implement this method.

Returns:

  • (String) —

    Raw packet data



436
437
438
439
440
441
 
# File 'lib/cosmos/interfaces/interface.rb', line 436

def read_interface_base(data)
  @read_raw_data_time = Time.now
  @read_raw_data = data.clone
  @bytes_read += data.length
  @raw_logger_pair.read_logger.write(data) if @raw_logger_pair
end

#set_option(option_name, option_values) ⇒ Object

Set an interface or router specific option

Parameters:

  • option_name —

    name of the option

  • option_values —

    array of option values



408
409
410
 
# File 'lib/cosmos/interfaces/interface.rb', line 408

def set_option(option_name, option_values)
  @options[option_name.upcase] = option_values.clone
end

#start_raw_logging ⇒ Object

Start raw logging for this interface



357
358
359
 
# File 'lib/cosmos/interfaces/interface.rb', line 357

def start_raw_logging
  @raw_logger_pair.start if @raw_logger_pair
end

#stop_raw_logging ⇒ Object

Stop raw logging for this interface



362
363
364
 
# File 'lib/cosmos/interfaces/interface.rb', line 362

def stop_raw_logging
  @raw_logger_pair.stop if @raw_logger_pair
end

#write(packet) ⇒ Object

Method to send a packet on the interface.

Parameters:

  • packet (Packet) —

    The Packet to send out the interface



253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
 
# File 'lib/cosmos/interfaces/interface.rb', line 253

def write(packet)
  raise "Interface not connected for write: #{@name}" unless connected?
  raise "Interface not writable: #{@name}" unless write_allowed?

  _write do
    @write_count += 1

    # Potentially modify packet
    @write_protocols.each do |protocol|
      packet = protocol.write_packet(packet)
      if packet == :DISCONNECT
        Logger.info("#{@name}: Protocol #{protocol.class} write_packet requested disconnect")
        disconnect()
        return
      end
      return if packet == :STOP
    end

    data = convert_packet_to_data(packet)

    # Potentially modify packet data
    @write_protocols.each do |protocol|
      data = protocol.write_data(data)
      if data == :DISCONNECT
        Logger.info("#{@name}: Protocol #{protocol.class} write_data requested disconnect")
        disconnect()
        return
      end
      return if data == :STOP
    end

    # Actually write out data if not handled by protocol
    write_interface(data)

    # Potentially block and wait for response
    @write_protocols.each do |protocol|
      packet, data = protocol.post_write_interface(packet, data)
      if packet == :DISCONNECT
        Logger.info("#{@name}: Protocol #{protocol.class} post_write_packet requested disconnect")
        disconnect()
        return
      end
      return if packet == :STOP
    end
  end

  return nil
end

#write_allowed? ⇒ Boolean

Returns Whether writing is allowed.

Returns:

  • (Boolean) —

    Whether writing is allowed



347
348
349
 
# File 'lib/cosmos/interfaces/interface.rb', line 347

def write_allowed?
  @write_allowed
end

#write_interface ⇒ Object 



189
190
191
 
# File 'lib/cosmos/interfaces/interface.rb', line 189

def write_interface
  raise "write_interface not defined by Interface"
end

#write_interface_base(data) ⇒ String

Called to write data to the underlying interface. Subclasses must implement this method and call super to count the raw bytes and allow raw logging.

Parameters:

  • data (String) —

    Raw packet data

Returns:

  • (String) —

    The exact data written



449
450
451
452
453
454
 
# File 'lib/cosmos/interfaces/interface.rb', line 449

def write_interface_base(data)
  @written_raw_data_time = Time.now
  @written_raw_data = data.clone
  @bytes_written += data.length
  @raw_logger_pair.write_logger.write(data) if @raw_logger_pair
end

#write_raw(data) ⇒ Object

Writes preformatted data onto the interface. Malformed data may cause problems.

Parameters:

  • data (String) —

    The raw data to send out the interface



305
306
307
308
309
310
311
312
 
# File 'lib/cosmos/interfaces/interface.rb', line 305

def write_raw(data)
  raise "Interface not connected for write_raw: #{@name}" unless connected?
  raise "Interface not write-rawable: #{@name}" unless write_raw_allowed?

  _write do
    write_interface(data)
  end
end

#write_raw_allowed? ⇒ Boolean

Returns Whether writing raw data over the interface is allowed.

Returns:

  • (Boolean) —

    Whether writing raw data over the interface is allowed



352
353
354
 
# File 'lib/cosmos/interfaces/interface.rb', line 352

def write_raw_allowed?
  @write_raw_allowed
end