openc3 5.0.6

data/lib/openc3/io/raw_logger.rb

@@ -0,0 +1,167 @@
+# 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
+
+require 'thread'
+require 'socket' # For gethostname
+require 'openc3/config/config_parser'
+
+module OpenC3
+  # Creates a log file of raw data for either reads or writes. Can automatically
+  # cycle the log based on when the log file reaches a predefined size.
+  class RawLogger
+    # @return [String] The filename of the log
+    attr_reader :filename
+
+    # @return [Queue] Queue for asynchronous logging
+    attr_reader :queue
+
+    # @return [Boolean] Is logging enabled?
+    attr_reader :logging_enabled
+
+    # @return [String] Original name passed to raw logger
+    attr_reader :orig_name
+
+    # The allowable log types
+    LOG_TYPES = [:READ, :WRITE]
+
+    # The cycle time interval. Cycle times are only checked at this level of
+    # granularity.
+    CYCLE_TIME_INTERVAL = 60
+
+    # @param log_name [String] The name of the raw logger.  Typically matches the
+    #    name of the corresponding interface
+    # @param log_type [Symbol] The type of log to create. Must be :READ
+    #   or :WRITE.
+    # @param log_directory [String] The directory to store the log files.
+    # @param logging_enabled [Boolean] Whether to enable raw logging
+    # @param cycle_size [Integer] The size in bytes before creating a new log file.
+    def initialize(
+      log_name,
+      log_type,
+      log_directory,
+      logging_enabled = false,
+      cycle_size = 2000000000
+    )
+      raise "log_type must be :READ or :WRITE" unless LOG_TYPES.include? log_type
+
+      @log_type = log_type
+      @orig_name = log_name
+      @log_name = (log_name.to_s.downcase + '_raw_' + @log_type.to_s.downcase + '_' + self.object_id.to_s).freeze
+      @log_directory = log_directory
+      @cycle_size = ConfigParser.handle_nil(cycle_size)
+      @cycle_size = Integer(@cycle_size) if @cycle_size
+      @mutex = Mutex.new
+      @file = nil
+      @filename = nil
+      @start_time = Time.now.sys
+      @logging_enabled = ConfigParser.handle_true_false(logging_enabled)
+    end
+
+    # Set the raw logger name
+    # @param log_name [String] new name
+    def name=(log_name)
+      @orig_name = log_name
+      @log_name = (log_name.to_s.downcase + '_raw_' + @log_type.to_s.downcase + '_' + self.object_id.to_s).freeze
+    end
+
+    # Write data to the log file.
+    #
+    # If no log file currently exists in the filesystem, a new file will be
+    # created.
+    #
+    # Writing a log file is a critical operation so the entire method is
+    # wrapped with a rescue and handled with handle_critical_exception
+    #
+    # @param data [String] The data to write to the log file
+    def write(data)
+      if @logging_enabled
+        return if !data or data.length <= 0
+
+        need_new_file = false
+        @mutex.synchronize do
+          if !@file or (@cycle_size and (@file.stat.size + data.length) > @cycle_size)
+            need_new_file = true
+          end
+        end
+        start_new_file() if need_new_file
+        @mutex.synchronize { @file.write(data) if @file }
+      end
+    rescue => err
+      Logger.instance.error "Error writing #{@filename} : #{err.formatted}"
+      OpenC3.handle_critical_exception(err)
+    end
+
+    # Starts a new log file by closing the existing log file. New log files are
+    # not created until data is written by {#write} so this does not
+    # immediately create a log file on the filesystem.
+    def start
+      close_file() unless (Time.now.sys - @start_time) < 1.0 # Prevent close/open too fast
+      @mutex.synchronize { @logging_enabled = true }
+    end
+
+    # Stops all logging and closes the current log file.
+    def stop
+      @mutex.synchronize { @logging_enabled = false }
+      close_file()
+    end
+
+    # Create a clone of this object with a new name
+    def clone
+      raw_logger = super()
+      raw_logger.name = raw_logger.orig_name
+      raw_logger
+    end
+
+    protected
+
+    # Starting a new log file is a critical operation so the entire method is
+    # wrapped with a rescue and handled with handle_critical_exception
+    def start_new_file
+      close_file()
+      @mutex.synchronize do
+        @filename = File.join(@log_directory, File.build_timestamped_filename([@log_name], '.bin'))
+        @file = File.new(@filename, 'wb')
+        @start_time = Time.now.sys
+        Logger.instance.info "Raw Log File Opened : #{@filename}"
+      end
+    rescue => err
+      Logger.instance.error "Error opening #{@filename} : #{err.formatted}"
+      @logging_enabled = false
+      OpenC3.handle_critical_exception(err)
+    end
+
+    # Closing a log file isn't critical so we just log an error
+    def close_file
+      @mutex.synchronize do
+        if @file
+          begin
+            @file.close unless @file.closed?
+            File.chmod(0444, @file.path) # Make file read only
+            Logger.instance.info "Raw Log File Closed : #{@filename}"
+          rescue => err
+            Logger.instance.error "Error closing #{@filename} : #{err.formatted}"
+          end
+
+          @file = nil
+          @filename = nil
+        end
+      end
+    end
+  end
+end

data/lib/openc3/io/raw_logger_pair.rb

@@ -0,0 +1,77 @@
+# 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
+
+require 'openc3/io/raw_logger'
+
+module OpenC3
+  # Holds a read/write pair of raw loggers
+  class RawLoggerPair
+    # @return [RawLogger] The read logger
+    attr_accessor :read_logger
+    # @return [RawLogger] The write logger
+    attr_accessor :write_logger
+
+    # @param name [String] name to be added to log filenames
+    # @param log_directory [String] The directory to store the log files
+    # @param params [Array] raw log writer parameters or empty array
+    def initialize(name, log_directory, params = [])
+      if params.empty?
+        raw_logger_class = RawLogger
+      else
+        raw_logger_class = OpenC3.require_class(params[0])
+      end
+      if params[1]
+        @read_logger = raw_logger_class.new(name, :READ, log_directory, *params[1..-1])
+        @write_logger = raw_logger_class.new(name, :WRITE, log_directory, *params[1..-1])
+      else
+        @read_logger = raw_logger_class.new(name, :READ, log_directory)
+        @write_logger = raw_logger_class.new(name, :WRITE, log_directory)
+      end
+    end
+
+    # Change the raw logger name
+    # @param name [String] new name
+    def name=(name)
+      @read_logger.name = name
+      @write_logger.name = name
+    end
+
+    # Start raw logging
+    def start
+      @read_logger.start
+      @write_logger.start
+    end
+
+    # Close any open raw data log files
+    def stop
+      @read_logger.stop
+      @write_logger.stop
+    end
+
+    # Clone the raw logger pair
+    def clone
+      raw_logger_pair = super()
+      raw_logger_pair.read_logger = @read_logger.clone
+      raw_logger_pair.write_logger = @write_logger.clone
+      raw_logger_pair.read_logger.start if @read_logger.logging_enabled
+      raw_logger_pair.write_logger.start if @write_logger.logging_enabled
+      raw_logger_pair
+    end
+  end
+end

data/lib/openc3/io/serial_driver.rb

@@ -0,0 +1,105 @@
+# 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
+
+require 'openc3/core_ext/kernel'
+if Kernel.is_windows?
+  require 'openc3/io/win32_serial_driver'
+elsif RUBY_ENGINE == 'ruby'
+  require 'openc3/io/posix_serial_driver'
+end
+
+module OpenC3
+  # A platform independent serial driver
+  class SerialDriver
+    EVEN = :EVEN
+    ODD  = :ODD
+    NONE = :NONE
+    VALID_PARITY = [EVEN, ODD, NONE]
+
+    # @param port_name [String] Name of the serial port
+    # @param baud_rate [Integer] Serial port baud rate
+    # @param parity [Symbol] Must be one of :EVEN, :ODD or :NONE
+    # @param stop_bits [Integer] Number of stop bits
+    # @param write_timeout [Float|nil] Number of seconds to wait for the write to
+    #   complete or nil to block
+    # @param read_timeout [Float|nil] Number of seconds to wait for the read to
+    #   complete or nil to block
+    # @param flow_control [Symbol] Currently supported :NONE and :RTSCTS (default :NONE)
+    # @param data_bits [Integer] Number of data bits (default 8)
+    def initialize(port_name,
+                   baud_rate,
+                   parity = :NONE,
+                   stop_bits = 1,
+                   write_timeout = 10.0,
+                   read_timeout = nil,
+                   flow_control = :NONE,
+                   data_bits = 8)
+      raise(ArgumentError, "Invalid parity: #{parity}") unless VALID_PARITY.include? parity
+
+      if Kernel.is_windows?
+        @driver = Win32SerialDriver.new(port_name,
+                                        baud_rate,
+                                        parity,
+                                        stop_bits,
+                                        write_timeout,
+                                        read_timeout,
+                                        0.01,
+                                        1000,
+                                        flow_control,
+                                        data_bits)
+      elsif RUBY_ENGINE == 'ruby'
+        @driver = PosixSerialDriver.new(port_name,
+                                        baud_rate,
+                                        parity,
+                                        stop_bits,
+                                        write_timeout,
+                                        read_timeout,
+                                        flow_control,
+                                        data_bits)
+      else
+        @driver = nil # JRuby Serial on Linux not currently supported
+      end
+    end
+
+    # Disconnects the driver from the comm port
+    def close
+      @driver.close
+    end
+
+    # @return [Boolean] Whether the serial port has been closed
+    def closed?
+      @driver.closed?
+    end
+
+    # @param data [String] Binary data to write to the serial port
+    def write(data)
+      @driver.write(data)
+    end
+
+    # @return [String] Binary data read from the serial port
+    def read
+      @driver.read
+    end
+
+    # @return [String] Binary data read from the serial port
+    def read_nonblock
+      @driver.read_nonblock
+    end
+  end # class SerialDriver
+end

data/lib/openc3/io/stderr.rb

@@ -0,0 +1,43 @@
+# 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
+
+require 'openc3/io/io_multiplexer'
+
+module OpenC3
+  # Adds STDERR to the multiplexed streams
+  class Stderr < IoMultiplexer
+    @@instance = nil
+
+    def initialize
+      super()
+      @streams << STDERR
+      @@instance = self
+    end
+
+    # @return [Stderr] Returns a single instance of Stderr
+    def self.instance
+      self.new unless @@instance
+      @@instance
+    end
+
+    def tty?
+      false
+    end
+  end
+end

data/lib/openc3/io/stdout.rb

@@ -0,0 +1,43 @@
+# 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
+
+require 'openc3/io/io_multiplexer'
+
+module OpenC3
+  # Adds STDOUT to the multiplexed streams
+  class Stdout < IoMultiplexer
+    @@instance = nil
+
+    def initialize
+      super()
+      @streams << STDOUT
+      @@instance = self
+    end
+
+    # @return [Stdout] Returns a single instance of Stdout
+    def self.instance
+      self.new unless @@instance
+      @@instance
+    end
+
+    def tty?
+      false
+    end
+  end
+end

data/lib/openc3/io/udp_sockets.rb

@@ -0,0 +1,194 @@
+# 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
+
+require 'socket'
+require 'ipaddr'
+require 'timeout' # for Timeout::Error
+
+# Define needed constants for Windows
+Socket::IP_MULTICAST_IF = 9 unless Socket.const_defined?('IP_MULTICAST_IF')
+Socket::IP_MULTICAST_TTL = 10 unless Socket.const_defined?('IP_MULTICAST_TTL')
+
+module OpenC3
+  class UdpReadWriteSocket
+    # @param bind_port [Integer[ Port to write data out from and receive data on (0 = randomly assigned)
+    # @param bind_address [String] Local address to bind to (0.0.0.0 = All local addresses)
+    # @param external_port [Integer] External port to write to
+    # @param external_address [String] External host to send data to
+    # @param multicast_interface_address [String] Local outgoing interface to send multicast packets from
+    # @param ttl [Integer] Time To Live for outgoing multicast packets
+    # @param read_multicast [Boolean] Whether or not to try to read from the external address as multicast
+    # @param write_multicast [Boolean] Whether or not to write to the external address as multicast
+    def initialize(
+      bind_port = 0,
+      bind_address = "0.0.0.0",
+      external_port = nil,
+      external_address = nil,
+      multicast_interface_address = nil,
+      ttl = 1,
+      read_multicast = true,
+      write_multicast = true
+    )
+
+      @socket = UDPSocket.new
+
+      # Basic setup to reuse address
+      @socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1)
+
+      # Bind to local address and port - This sets recv port, write_src port, recv_address, and write_src_address
+      @socket.bind(bind_address, bind_port) if bind_address and bind_port
+
+      # Default send to the specified address and port
+      @socket.connect(external_address, external_port) if external_address and external_port
+
+      # Handle multicast
+      if UdpReadWriteSocket.multicast?(external_address, external_port)
+        if write_multicast
+          # Basic setup set time to live
+          @socket.setsockopt(Socket::IPPROTO_IP, Socket::IP_MULTICAST_TTL, ttl.to_i)
+
+          # Set outgoing interface
+          @socket.setsockopt(
+            Socket::IPPROTO_IP,
+            Socket::IP_MULTICAST_IF,
+            IPAddr.new(multicast_interface_address).hton
+          ) if multicast_interface_address
+        end
+
+        # Receive messages sent to the multicast address
+        if read_multicast
+          multicast_interface_address = "0.0.0.0" unless multicast_interface_address
+          membership = IPAddr.new(external_address).hton + IPAddr.new(multicast_interface_address).hton
+          @socket.setsockopt(Socket::IPPROTO_IP, Socket::IP_ADD_MEMBERSHIP, membership)
+        end
+      end
+    end
+
+    # @param data [String] Binary data to send
+    # @param write_timeout [Float] Time in seconds to wait for the data to send
+    def write(data, write_timeout = 10.0)
+      num_bytes_to_send = data.length
+      total_bytes_sent  = 0
+      bytes_sent = 0
+      data_to_send = data
+
+      loop do
+        begin
+          bytes_sent = @socket.write_nonblock(data_to_send)
+        rescue Errno::EAGAIN, Errno::EWOULDBLOCK
+          result = IO.fast_select(nil, [@socket], nil, write_timeout)
+          if result
+            retry
+          else
+            raise Timeout::Error, "Write Timeout"
+          end
+        end
+        total_bytes_sent += bytes_sent
+        break if total_bytes_sent >= num_bytes_to_send
+
+        data_to_send = data[total_bytes_sent..-1]
+      end
+    end
+
+    # @param read_timeout [Float] Time in seconds to wait for the read to
+    #   complete
+    def read(read_timeout = nil)
+      data = nil
+      begin
+        data, _ = @socket.recvfrom_nonblock(65536)
+      rescue Errno::EAGAIN, Errno::EWOULDBLOCK
+        result = IO.fast_select([@socket], nil, nil, read_timeout)
+        if result
+          retry
+        else
+          raise Timeout::Error, "Read Timeout"
+        end
+      end
+      data
+    end
+
+    # Defer all methods to the UDPSocket
+    def method_missing(method, *args, &block)
+      @socket.__send__(method, *args, &block)
+    end
+
+    # @param host [String] Machine name or IP address
+    # @param port [String] Port
+    # @return [Boolean] Whether the hostname is multicast
+    def self.multicast?(host, port)
+      return false if host.nil? || port.nil?
+
+      Addrinfo.udp(host, port).ipv4_multicast?
+    end
+  end
+
+  # Creates a UDPSocket and implements a non-blocking write.
+  class UdpWriteSocket < UdpReadWriteSocket
+    # @param dest_address [String] Host to send data to
+    # @param dest_port [Integer] Port to send data to
+    # @param src_port [Integer[ Port to send data out from
+    # @param multicast_interface_address [String] Local outgoing interface to send multicast packets from
+    # @param ttl [Integer] Time To Live for outgoing packets
+    # @param bind_address [String] Local address to bind to (0.0.0.0 = All local addresses)
+    def initialize(
+      dest_address,
+      dest_port,
+      src_port = nil,
+      multicast_interface_address = nil,
+      ttl = 1,
+      bind_address = "0.0.0.0"
+    )
+
+      super(
+        src_port,
+        bind_address,
+        dest_port,
+        dest_address,
+        multicast_interface_address,
+        ttl,
+        false,
+        true)
+    end
+  end
+
+  # Creates a UDPSocket and implements a non-blocking read.
+  class UdpReadSocket < UdpReadWriteSocket
+    # @param recv_port [Integer] Port to receive data on
+    # @param multicast_address [String] Address to add multicast
+    # @param multicast_interface_address [String] Local incoming interface to receive multicast packets on
+    # @param bind_address [String] Local address to bind to (0.0.0.0 = All local addresses)
+    def initialize(
+      recv_port = 0,
+      multicast_address = nil,
+      multicast_interface_address = nil,
+      bind_address = "0.0.0.0"
+    )
+
+      super(
+        recv_port,
+        bind_address,
+        nil,
+        multicast_address,
+        multicast_interface_address,
+        1,
+        true,
+        false)
+    end
+  end
+end