openc3 5.0.6

data/lib/openc3/streams/tcpip_client_stream.rb

@@ -0,0 +1,116 @@
+# 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 'thread' # For Mutex
+require 'timeout' # For Timeout::Error
+require 'openc3/streams/tcpip_socket_stream'
+require 'openc3/config/config_parser'
+
+module OpenC3
+  # Data {Stream} which reads and writes to TCPIP sockets. This class creates
+  # the actual sockets based on the constructor parameters. The rest of the
+  # interface is implemented by the super class {TcpipSocketStream}.
+  class TcpipClientStream < TcpipSocketStream
+    # @param hostname [String] The host to connect to
+    # @param write_port [Integer|nil] The port to write. Pass nil to make this
+    #   a read only stream.
+    # @param read_port [Integer|nil] The port to read. Pass nil to make this
+    #   a write only stream.
+    # @param write_timeout (see TcpipSocketStream#initialize)
+    # @param read_timeout (see TcpipSocketStream#initialize)
+    def initialize(hostname, write_port, read_port, write_timeout, read_timeout, connect_timeout = 5.0)
+      @hostname = hostname
+      if @hostname.to_s.upcase == 'LOCALHOST'
+        @hostname = '127.0.0.1'
+      end
+      @write_port = ConfigParser.handle_nil(write_port)
+      @write_port = Integer(write_port) if @write_port
+      @read_port  = ConfigParser.handle_nil(read_port)
+      @read_port  = Integer(read_port) if @read_port
+
+      @write_addr = nil
+      @read_addr = nil
+      begin
+        @write_addr = Socket.pack_sockaddr_in(@write_port, @hostname) if @write_port
+        @read_addr = Socket.pack_sockaddr_in(@read_port, @hostname) if @read_port
+      rescue => error
+        if /getaddrinfo/.match?(error.message)
+          raise "Invalid hostname: #{@hostname}"
+        else
+          raise error
+        end
+      end
+
+      write_socket = nil
+      if @write_addr
+        write_socket = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+        write_socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+      end
+
+      read_socket = nil
+      if @read_addr
+        if @write_port != @read_port
+          read_socket = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+          read_socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+        else
+          read_socket = write_socket
+        end
+      end
+
+      @connect_timeout = ConfigParser.handle_nil(connect_timeout)
+      @connect_timeout = @connect_timeout.to_f if @connect_timeout
+
+      super(write_socket, read_socket, write_timeout, read_timeout)
+    end
+
+    # Connect the socket(s)
+    def connect
+      connect_nonblock(@write_socket, @write_addr) if @write_socket
+      connect_nonblock(@read_socket, @read_addr) if @read_socket and @read_socket != @write_socket
+      super()
+    end
+
+    protected
+
+    def connect_nonblock(socket, addr)
+      socket.connect_nonblock(addr)
+    rescue IO::WaitWritable
+      begin
+        _, sockets, _ = IO.select(nil, [socket], nil, @connect_timeout) # wait 3-way handshake completion
+      rescue IOError, Errno::ENOTSOCK
+        raise "Connect canceled"
+      end
+      if sockets and !sockets.empty?
+        begin
+          socket.connect_nonblock(addr) # check connection failure
+        rescue IOError, Errno::ENOTSOCK
+          raise "Connect canceled"
+        rescue Errno::EINPROGRESS
+          retry
+        rescue Errno::EISCONN, Errno::EALREADY
+        end
+      else
+        raise "Connect timeout"
+      end
+    rescue IOError, Errno::ENOTSOCK
+      raise "Connect canceled"
+    end
+  end # class TcpipClientStream
+end

data/lib/openc3/streams/tcpip_socket_stream.rb

@@ -0,0 +1,195 @@
+# 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 'thread' # For Mutex
+require 'timeout' # For Timeout::Error
+require 'openc3/streams/stream'
+require 'openc3/config/config_parser'
+
+module OpenC3
+  # Data {Stream} which reads and writes from Tcpip Sockets.
+  class TcpipSocketStream < Stream
+    attr_reader :write_socket
+
+    FAST_READ = (RUBY_VERSION > "2.1")
+
+    # @param write_socket [Socket] Socket to write
+    # @param read_socket [Socket] Socket to read
+    # @param write_timeout [Float|nil] Number of seconds to wait for the write
+    #   to complete or nil to block until the socket is ready to write.
+    # @param read_timeout [Float|nil] Number of seconds to wait for the read
+    #   to complete or nil to block until the socket is ready to read.
+    def initialize(write_socket, read_socket, write_timeout, read_timeout)
+      super()
+
+      @write_socket  = write_socket
+      @read_socket   = read_socket
+      @write_timeout = ConfigParser.handle_nil(write_timeout)
+      @write_timeout = @write_timeout.to_f if @write_timeout
+      @read_timeout  = ConfigParser.handle_nil(read_timeout)
+      @read_timeout  = @read_timeout.to_f if @read_timeout
+
+      # Mutex on write is needed to protect from commands coming in from more
+      # than one tool
+      @write_mutex = Mutex.new
+      @pipe_reader, @pipe_writer = IO.pipe
+      @connected = false
+    end
+
+    # @return [String] Returns a binary string of data from the socket
+    def read
+      raise "Attempt to read from write only stream" unless @read_socket
+
+      # No read mutex is needed because reads happen serially
+      if FAST_READ
+        begin
+          while true # Loop until we get some data
+            data = @read_socket.read_nonblock(65535, exception: false)
+            raise EOFError, 'end of file reached' unless data
+
+            if data == :wait_readable
+              # Wait for the socket to be ready for reading or for the timeout
+              begin
+                result = IO.fast_select([@read_socket, @pipe_reader], nil, nil, @read_timeout)
+                # If select returns something it means the socket is now available for
+                # reading so retry the read. If it returns nil it means we timed out.
+                # If the pipe is present that means we closed the socket
+                if result
+                  if result.include?(@pipe_reader)
+                    raise IOError
+                  else
+                    next
+                  end
+                else
+                  raise Timeout::Error, "Read Timeout"
+                end
+              rescue IOError, Errno::ENOTSOCK
+                # These can happen with the socket being closed while waiting on select
+                data = ''
+              end
+            end
+            break
+          end
+        rescue Errno::ECONNRESET, Errno::ECONNABORTED, IOError, Errno::ENOTSOCK
+          data = ''
+        end
+      else
+        begin
+          data = @read_socket.read_nonblock(65535)
+        rescue IO::WaitReadable
+          # Wait for the socket to be ready for reading or for the timeout
+          begin
+            result = IO.fast_select([@read_socket, @pipe_reader], nil, nil, @read_timeout)
+
+            # If select returns something it means the socket is now available for
+            # reading so retry the read. If it returns nil it means we timed out.
+            # If the pipe is present that means we closed the socket
+            if result
+              if result.include?(@pipe_reader)
+                raise IOError
+              else
+                retry
+              end
+            else
+              raise Timeout::Error, "Read Timeout"
+            end
+          rescue IOError, Errno::ENOTSOCK
+            # These can happen with the socket being closed while waiting on select
+            data = ''
+          end
+        rescue Errno::ECONNRESET, Errno::ECONNABORTED, IOError, Errno::ENOTSOCK
+          data = ''
+        end
+      end
+
+      data
+    end
+
+    # @return [String] Returns a binary string of data from the socket. Always returns immediately
+    def read_nonblock
+      # No read mutex is needed because reads happen serially
+      begin
+        if FAST_READ
+          data = @read_socket.read_nonblock(65535, exception: false)
+          raise EOFError, 'end of file reached' unless data
+
+          data = '' if data == :wait_readable
+        else
+          data = @read_socket.read_nonblock(65535)
+        end
+      rescue Errno::EAGAIN, Errno::EWOULDBLOCK, Errno::ECONNRESET, Errno::ECONNABORTED, IOError
+        data = ''
+      end
+
+      data
+    end
+
+    # @param data [String] A binary string of data to write to the socket
+    def write(data)
+      raise "Attempt to write to read only stream" unless @write_socket
+
+      @write_mutex.synchronize do
+        num_bytes_to_send = data.length
+        total_bytes_sent = 0
+        bytes_sent = 0
+        data_to_send = data
+
+        loop do
+          begin
+            bytes_sent = @write_socket.write_nonblock(data_to_send)
+          rescue Errno::EAGAIN, Errno::EWOULDBLOCK
+            # Wait for the socket to be ready for writing or for the timeout
+            result = IO.fast_select(nil, [@write_socket], nil, @write_timeout)
+            # If select returns something it means the socket is now available for
+            # writing so retry the write. If it returns nil it means we timed out.
+            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
+    end
+
+    # Connect the stream
+    def connect
+      # If called directly this class is acting as a server and does not need to connect the sockets
+      @connected = true
+    end
+
+    # @return [Boolean] Whether the sockets are connected
+    def connected?
+      @connected
+    end
+
+    # Disconnect by closing the sockets
+    def disconnect
+      OpenC3.close_socket(@write_socket)
+      OpenC3.close_socket(@read_socket)
+      @pipe_writer.write('.')
+      @connected = false
+    end
+  end # class TcpipSocketStream
+end

data/lib/openc3/system/system.rb

@@ -0,0 +1,127 @@
+# 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/config/config_parser'
+require 'openc3/packets/packet_config'
+require 'openc3/packets/commands'
+# TODO: System requires telemetry and Telemetry require system ... circular reference
+require 'openc3/packets/telemetry'
+require 'openc3/packets/limits'
+require 'openc3/system/target'
+require 'openc3/utilities/s3'
+require 'openc3/utilities/zip'
+require 'openc3/models/scope_model'
+require 'thread'
+require 'fileutils'
+
+module OpenC3
+  class System
+    # @return [Hash<String,Target>] Hash of all the known targets
+    instance_attr_reader :targets
+
+    # @return [PacketConfig] Access to the packet configuration
+    instance_attr_reader :packet_config
+
+    # @return [Commands] Access to the command definition
+    instance_attr_reader :commands
+
+    # @return [Telemetry] Access to the telemetry definition
+    instance_attr_reader :telemetry
+
+    # @return [Limits] Access to the limits definition
+    instance_attr_reader :limits
+
+    # Variable that holds the singleton instance
+    @@instance = nil
+
+    # Mutex used to ensure that only one instance of System is created
+    @@instance_mutex = Mutex.new
+
+    # @return [Symbol] The current limits_set of the system returned from Redis
+    def self.limits_set
+      ScopeModel.limits_set(scope: $openc3_scope)
+    end
+
+    def self.setup_targets(target_names, base_dir, scope:)
+      FileUtils.mkdir_p("#{base_dir}/targets")
+      rubys3_client = Aws::S3::Client.new
+      target_names.each do |target_name|
+        # Retrieve bucket/targets/target_name/target_id.zip
+        response_target = "#{base_dir}/targets/#{target_name}_current.zip"
+        FileUtils.mkdir_p(File.dirname(response_target))
+        s3_key = "#{scope}/target_archives/#{target_name}/#{target_name}_current.zip"
+        Logger.info("Retrieving #{s3_key} from targets bucket")
+        rubys3_client.get_object(bucket: "config", key: s3_key, response_target: response_target)
+        Zip::File.open(response_target) 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
+
+    # Get the singleton instance of System
+    #
+    # @param target_names [Array of target_names]
+    # @param target_config_dir Directory where target config folders are
+    # @return [System] The System singleton
+    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
+
+    # Create a new System object.
+    #
+    # @param target_names [Array of target names]
+    # @param target_config_dir Directory where target config folders are
+    def initialize(target_names, 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
+
+    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
+      target.cmd_tlm_files.each do |cmd_tlm_file|
+        @packet_config.process_file(cmd_tlm_file, target.name)
+      rescue Exception => err
+        Logger.error "Problem processing #{cmd_tlm_file}: #{err}."
+        raise err
+      end
+    end
+  end
+end