openc3 5.0.6

data/lib/openc3/interfaces/udp_interface.rb

@@ -0,0 +1,169 @@
+# 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/interfaces/interface'
+require 'openc3/io/udp_sockets'
+require 'openc3/config/config_parser'
+
+module OpenC3
+  # Base class for interfaces that send and receive messages over UDP
+  class UdpInterface < Interface
+    # @param hostname [String] Machine to connect to
+    # @param write_dest_port [Integer] Port to write commands to
+    # @param read_port [Integer] Port to read telemetry from
+    # @param write_src_port [Integer] Port to allow replies if needed
+    # @param interface_address [String] If the destination machine represented
+    #   by hostname supports multicast, then interface_address is used to
+    #   configure the outgoing multicast address.
+    # @param ttl [Integer] Time To Live value. The number of intermediate
+    #   routers allowed before dropping the packet.
+    # @param write_timeout [Integer] Seconds to wait before aborting writes
+    # @param read_timeout [Integer] Seconds to wait before aborting reads
+    # @param bind_address [String] Address to bind UDP ports to
+    def initialize(
+      hostname,
+      write_dest_port,
+      read_port,
+      write_src_port = nil,
+      interface_address = nil,
+      ttl = 128, # default for Windows
+      write_timeout = 10.0,
+      read_timeout = nil,
+      bind_address = '0.0.0.0'
+    )
+
+      super()
+      @hostname = ConfigParser.handle_nil(hostname)
+      if @hostname
+        @hostname = @hostname.to_s
+        @hostname = '127.0.0.1' if @hostname.casecmp('LOCALHOST').zero?
+      end
+      @write_dest_port = ConfigParser.handle_nil(write_dest_port)
+      @write_dest_port = write_dest_port.to_i if @write_dest_port
+      @read_port = ConfigParser.handle_nil(read_port)
+      @read_port = read_port.to_i if @read_port
+      @write_src_port = ConfigParser.handle_nil(write_src_port)
+      @write_src_port = @write_src_port.to_i if @write_src_port
+      @interface_address = ConfigParser.handle_nil(interface_address)
+      if @interface_address && @interface_address.casecmp('LOCALHOST').zero?
+        @interface_address = '127.0.0.1'
+      end
+      @ttl = ttl.to_i
+      @ttl = 1 if @ttl < 1
+      @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
+      @bind_address = ConfigParser.handle_nil(bind_address)
+      if @bind_address && @bind_address.casecmp('LOCALHOST').zero?
+        @bind_address = '127.0.0.1'
+      end
+      @write_socket = nil
+      @read_socket = nil
+      @read_allowed = false unless @read_port
+      @write_allowed = false unless @write_dest_port
+      @write_raw_allowed = false unless @write_dest_port
+    end
+
+    # Creates a new {UdpWriteSocket} if the the write_dest_port was given in
+    # the constructor and a new {UdpReadSocket} if the read_port was given in
+    # the constructor.
+    def connect
+      if @read_port and @write_dest_port and @write_src_port and (@read_port == @write_src_port)
+        @read_socket = UdpReadWriteSocket.new(
+          @read_port,
+          @bind_address,
+          @write_dest_port,
+          @hostname,
+          @interface_address,
+          @ttl
+        )
+        @write_socket = @read_socket
+      else
+        @read_socket = UdpReadSocket.new(
+          @read_port,
+          @hostname,
+          @interface_address,
+          @bind_address
+        ) if @read_port
+        @write_socket = UdpWriteSocket.new(
+          @hostname,
+          @write_dest_port,
+          @write_src_port,
+          @interface_address,
+          @ttl,
+          @bind_address
+        ) if @write_dest_port
+      end
+      @thread_sleeper = nil
+    end
+
+    # @return [Boolean] Whether the active ports (read and/or write) have
+    #   created sockets. Since UDP is connectionless, creation of the sockets
+    #   is used to determine connection.
+    def connected?
+      if @write_dest_port && @read_port
+        (@write_socket && @read_socket) ? true : false
+      elsif @write_dest_port
+        @write_socket ? true : false
+      else
+        @read_socket ? true : false
+      end
+    end
+
+    # Close the active ports (read and/or write) and set the sockets to nil.
+    def disconnect
+      if @write_socket != @read_socket
+        OpenC3.close_socket(@write_socket)
+      end
+      OpenC3.close_socket(@read_socket)
+      @write_socket = nil
+      @read_socket = nil
+      @thread_sleeper.cancel if @thread_sleeper
+      @thread_sleeper = nil
+    end
+
+    def read
+      return super() if @read_port
+
+      # Write only interface so stop the thread which calls read
+      @thread_sleeper = Sleeper.new
+      @thread_sleeper.sleep(1_000_000_000) while connected?
+      return nil
+    end
+
+    # Reads from the socket if the read_port is defined
+    def read_interface
+      data = @read_socket.read(@read_timeout)
+      Logger.info "#{@name}: Udp read returned 0 bytes (stream closed)" if data.length <= 0
+      read_interface_base(data)
+      return data
+    rescue IOError # Disconnected
+      return nil
+    end
+
+    # Writes to the socket
+    # @param data [String] Raw packet data
+    def write_interface(data)
+      write_interface_base(data)
+      @write_socket.write(data, @write_timeout)
+      data
+    end
+  end
+end

data/lib/openc3/interfaces.rb

@@ -0,0 +1,44 @@
+# 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
+
+module OpenC3
+  autoload(:Interface, 'openc3/interfaces/interface.rb')
+  autoload(:StreamInterface, 'openc3/interfaces/stream_interface.rb')
+  autoload(:SerialInterface, 'openc3/interfaces/serial_interface.rb')
+  autoload(:SimulatedTargetInterface, 'openc3/interfaces/simulated_target_interface.rb')
+  autoload(:TcpipClientInterface, 'openc3/interfaces/tcpip_client_interface.rb')
+  autoload(:TcpipServerInterface, 'openc3/interfaces/tcpip_server_interface.rb')
+  autoload(:UdpInterface, 'openc3/interfaces/udp_interface.rb')
+  autoload(:LincInterface, 'openc3/interfaces/linc_interface.rb')
+  autoload(:LincHandshakeCommand, 'openc3/interfaces/linc_interface.rb')
+  autoload(:LincHandshake, 'openc3/interfaces/linc_interface.rb')
+  autoload(:DartStatusInterface, 'openc3/interfaces/dart_status_interface.rb')
+
+  autoload(:Protocol, 'openc3/interfaces/protocols/protocol.rb')
+  autoload(:BurstProtocol, 'openc3/interfaces/protocols/burst_protocol.rb')
+  autoload(:FixedProtocol, 'openc3/interfaces/protocols/fixed_protocol.rb')
+  autoload(:LengthProtocol, 'openc3/interfaces/protocols/length_protocol.rb')
+  autoload(:PreidentifiedProtocol, 'openc3/interfaces/protocols/preidentified_protocol.rb')
+  autoload(:TemplateProtocol, 'openc3/interfaces/protocols/template_protocol.rb')
+  autoload(:TerminatedProtocol, 'openc3/interfaces/protocols/terminated_protocol.rb')
+
+  autoload(:OverrideProtocol, 'openc3/interfaces/protocols/override_protocol.rb')
+  autoload(:CrcProtocol, 'openc3/interfaces/protocols/crc_protocol.rb')
+  autoload(:IgnorePacketProtocol, 'openc3/interfaces/protocols/ignore_packet_protocol.rb')
+end

data/lib/openc3/io/buffered_file.rb

@@ -0,0 +1,109 @@
+# 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
+
+if RUBY_ENGINE == 'ruby' and !ENV['OPENC3_NO_EXT']
+  require 'openc3/ext/buffered_file'
+else
+  module OpenC3
+    class BufferedFile < File
+      BUFFER_SIZE = 16 * 1024
+
+      # Initialize the BufferedFile.  Takes the same args as File
+      def initialize(*args)
+        super(*args)
+        @buffer = ''
+        @buffer_index = 0
+      end
+
+      # Read using an internal buffer to avoid system calls
+      def read(read_length)
+        if read_length <= (@buffer.length - @buffer_index)
+          # Return part of the buffer without having to go to the OS
+          result = @buffer[@buffer_index, read_length]
+          @buffer_index += read_length
+          return result
+        elsif read_length > BUFFER_SIZE
+          # Reading more than our buffer
+          if @buffer.length > 0
+            if @buffer_index > 0
+              @buffer.slice!(0..(@buffer_index - 1))
+              @buffer_index = 0
+            end
+            @buffer << super(read_length - @buffer.length).to_s
+            return @buffer.slice!(0..-1)
+          else
+            return super(read_length)
+          end
+        else
+          # Read into the buffer
+          if @buffer_index > 0
+            @buffer.slice!(0..(@buffer_index - 1))
+            @buffer_index = 0
+          end
+          @buffer << super(BUFFER_SIZE - @buffer.length).to_s
+          if @buffer.length <= 0
+            return nil
+          end
+
+          if read_length <= @buffer.length
+            result = @buffer[@buffer_index, read_length]
+            @buffer_index += read_length
+            return result
+          else
+            return @buffer.slice!(0..-1)
+          end
+        end
+      end
+
+      # Get the current file position
+      def pos
+        parent_pos = super()
+        return parent_pos - (@buffer.length - @buffer_index)
+      end
+
+      # Seek to a given file position
+      def seek(*args)
+        case args.length
+        when 1
+          amount = args[0]
+          whence = IO::SEEK_SET
+        when 2
+          amount = args[0]
+          whence = args[1]
+        else
+          # Invalid number of arguments given - let super handle
+          return super(*args)
+        end
+
+        if whence == IO::SEEK_CUR
+          buffer_index = @buffer_index + amount
+          if (buffer_index >= 0) && (buffer_index < @buffer.length)
+            @buffer_index = buffer_index
+            return 0
+          end
+          super(self.pos, IO::SEEK_SET)
+        end
+
+        @buffer.clear
+        @buffer_index = 0
+        return super(*args)
+      end
+    end
+  end
+end

data/lib/openc3/io/io_multiplexer.rb

@@ -0,0 +1,80 @@
+# 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
+
+module OpenC3
+  # Adds IO streams and then defers to the streams when using any of the Ruby
+  # output methods such as print, puts, etc.
+  class IoMultiplexer
+    # Create the empty stream array
+    def initialize
+      @streams = []
+    end
+
+    def write(*args)
+      first = true
+      result = nil
+      @streams.each do |stream|
+        if first
+          result = stream.write(*args)
+          result = self if result == stream
+          first = false
+        else
+          stream.write(*args)
+        end
+      end
+      result
+    end
+
+    # Forwards IO methods to all streams
+    def method_missing(method_name, *args)
+      first = true
+      result = nil
+      @streams.each do |stream|
+        if first
+          # Fortify Access Specifier Manipulation
+          # We're forwarding only public methods to the stream
+          result = stream.public_send(method_name, *args)
+          result = self if result == stream
+          first = false
+        else
+          # Fortify Access Specifier Manipulation
+          # We're forwarding only public methods to the stream
+          stream.public_send(method_name, *args)
+        end
+      end
+      result
+    end
+
+    # Removes STDOUT and STDERR from the array of streams
+    def remove_default_io
+      @streams.delete(STDOUT)
+      @streams.delete(STDERR)
+    end
+
+    # @param stream [IO] The stream to add
+    def add_stream(stream)
+      @streams << stream unless @streams.include?(stream)
+    end
+
+    # @param stream [IO] The stream to remove
+    def remove_stream(stream)
+      @streams.delete(stream)
+    end
+  end # class IoMultiplexer
+end

data/lib/openc3/io/json_api_object.rb

@@ -0,0 +1,208 @@
+# 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'
+require 'openc3/utilities/authentication'
+require 'openc3/io/json_drb'
+
+require 'thread'
+require 'socket'
+require 'json'
+# require 'drb/acl'
+require 'drb/drb'
+require 'uri'
+require 'httpclient'
+
+
+module OpenC3
+
+  class JsonApiError < StandardError; end
+
+  # Used to forward all method calls to the remote server object. Before using
+  # this class ensure the remote service has been started in the server class:
+  #
+  #   json = JsonDrb.new
+  #   json.start_service('127.0.0.1', 7777, self)
+  #
+  # Now the JsonApiObject can be used to call server methods directly:
+  #
+  #   server = JsonApiObject('http://openc3-cmd-tlm-api:2901', 1.0)
+  #   server.cmd(*args)
+  #
+  class JsonApiObject 
+    attr_reader :request_data
+    attr_reader :response_data
+
+    USER_AGENT = 'OpenC3 / v5 (ruby/openc3/lib/io/json_api_object)'.freeze
+
+    # @param url [String] The url of openc3-cmd-tlm-api http://openc3-cmd-tlm-api:2901
+    # @param timeout [Float] The time to wait before disconnecting 1.0
+    # @param authentication [OpenC3Authentication] The authentication object if nill initialize will generate
+    def initialize(url: ENV['OPENC3_API_URL'], timeout: 1.0, authentication: nil)
+      @http = nil
+      @mutex = Mutex.new
+      @request_data = ""
+      @response_data = ""
+      @url = url
+      @log = [nil, nil, nil]
+      @authentication = authentication.nil? ? OpenC3Authentication.new() : authentication
+      @timeout = timeout
+      @shutdown = false
+    end
+
+    # Forwards all method calls to the remote service.
+    #
+    # @param method_params [Array] Array of parameters to pass to the method
+    # @param keyword_params [Hash<Symbol, Variable>] Hash of keyword parameters
+    # @return The result of the method call. 
+    def request(*method_params, **keyword_params)
+      raise JsonApiError, "Shutdown" if @shutdown
+      method = method_params[0]
+      endpoint = method_params[1]
+      @mutex.synchronize do
+        kwargs = _generate_kwargs(keyword_params)
+        @log = [nil, nil, nil]
+        connect() if !@http
+        return _send_request(method: method, endpoint: endpoint, kwargs: kwargs)
+      end
+    end
+
+    # Disconnects from http server
+    def disconnect
+      @http.reset_all() if @http
+      @http = nil
+    end
+
+    # Permanently disconnects from the http server
+    def shutdown
+      @shutdown = true
+      disconnect()
+    end
+
+    private
+
+    def connect
+      begin
+        @http = HTTPClient.new
+        @http.connect_timeout = @timeout
+        @http.receive_timeout = nil # Allow long polling
+      rescue => e
+        raise JsonApiError, e.message
+      end
+    end
+
+    # NOTE: This is a helper method and should not be called directly
+    def _generate_kwargs(keyword_params)
+      kwargs = {}
+      keyword_params.each do |key, value|
+        kwargs[key.intern] = value
+      end
+      kwargs[:scope] = _generate_scope(kwargs)
+      kwargs[:headers] = _generate_headers(kwargs)
+      kwargs[:data] = _generate_data(kwargs)
+      kwargs[:query] = _generate_query(kwargs)
+      return kwargs
+    end
+
+    # NOTE: This is a helper method and should not be called directly
+    def _generate_scope(kwargs)
+      scope = kwargs[:scope]
+      if scope.nil?
+        raise JsonApiError, "no scope keyword found: #{kwargs}"
+      elsif scope.is_a?(String) == false
+        raise JsonApiError, "incorrect type for keyword 'scope' MUST be String: #{scope}"
+      end
+      return scope
+    end
+
+    # NOTE: This is a helper method and should not be called directly
+    def _generate_headers(kwargs)
+      headers = kwargs[:headers]
+      if headers.nil?
+        headers = kwargs[:headers] = {}
+      elsif headers.is_a?(Hash) == false
+        raise JsonApiError, "incorrect type for keyword 'headers' MUST be Hash: #{headers}"
+      end
+      
+      headers['Content-Type'] = 'application/json' if kwargs[:json]
+      return headers.update({
+        'User-Agent' => USER_AGENT,
+        'Authorization' => @authentication.token(),
+      })
+    end
+
+    # NOTE: This is a helper method and should not be called directly
+    def _generate_data(kwargs)
+      data = kwargs[:data]
+      if data.nil?
+        data = kwargs[:data] = {}
+      elsif data.is_a?(Hash) == false and data.is_a?(String) == false
+        raise JsonApiError, "incorrect type for keyword 'data' MUST be Hash or String: #{data}"
+      end
+      return kwargs[:json] ? JSON.generate(kwargs[:data]) : kwargs[:data]
+    end
+
+    # NOTE: This is a helper method and should not be called directly
+    def _generate_query(kwargs)
+      query = kwargs[:query]
+      if query.nil?
+        query = kwargs[:query] = {}
+      elsif query.is_a?(Hash) == false
+        raise JsonApiError, "incorrect type for keyword 'query' MUST be Hash: #{query}"
+      end
+      kwargs[:query].update(:scope => kwargs[:scope]) if kwargs[:scope]
+    end
+
+    # NOTE: This is a helper method and should not be called directly
+    def _send_request(method:, endpoint:, kwargs:)
+      begin
+        uri = URI("#{@url}#{endpoint}")
+        @log[0] = "#{method} Request: #{uri.to_s} #{kwargs}"
+        STDOUT.puts @log[0] if JsonDRb.debug?
+        resp = _http_request(method: method, uri: uri, kwargs: kwargs)
+        @log[1] = "#{method} Response: #{resp.status} #{resp.headers} #{resp.body}"
+        STDOUT.puts @log[1] if JsonDRb.debug?
+        @response_data = resp.body
+        return resp
+      rescue StandardError => e
+        @log[2] = "#{method} Exception: #{e.class}, #{e.message}, #{e.backtrace}"
+        disconnect()
+        error = "Api Exception: #{@log[0]} ::: #{@log[1]} ::: #{@log[2]}"
+        raise error
+      end
+    end
+
+    # NOTE: This is a helper method and should not be called directly
+    def _http_request(method:, uri:, kwargs:)
+      case method
+      when 'get', :get
+        return @http.get(uri, :header => kwargs[:headers], :query => kwargs[:query])
+      when 'post', :post
+        return @http.post(uri, :header => kwargs[:headers], :query => kwargs[:query], :body => kwargs[:data])
+      when 'put', :put
+        return @http.put(uri, :header => kwargs[:headers], :query => kwargs[:query], :body => kwargs[:data])
+      when 'delete', :delete
+        return @http.delete(uri, :header => kwargs[:headers], :query => kwargs[:query])
+      else
+        raise JsonApiError, "no method found: '#{method}'"
+      end
+    end
+
+  end # class JsonApiObject
+end