cosmos 3.9.2 → 4.0.0

data/lib/cosmos/interfaces/udp_interface.rb

@@ -1,6 +1,6 @@
 # encoding: ascii-8bit
 
-# Copyright 2014 Ball Aerospace & Technologies Corp.
+# Copyright 2017 Ball Aerospace & Technologies Corp.
 # All Rights Reserved.
 #
 # This program is free software; you can modify and/or redistribute it
@@ -13,10 +13,8 @@ require 'cosmos/io/udp_sockets'
 require 'cosmos/config/config_parser'
 
 module Cosmos
-
   # 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
@@ -29,21 +27,22 @@ module Cosmos
     # @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()
+    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.upcase == 'LOCALHOST'
+        @hostname = '127.0.0.1' if @hostname.casecmp('LOCALHOST')
       end
       @write_dest_port = ConfigParser.handle_nil(write_dest_port)
       @write_dest_port = write_dest_port.to_i if @write_dest_port
@@ -52,7 +51,9 @@ module Cosmos
       @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)
-      @interface_address = '127.0.0.1' if @interface_address and @interface_address.upcase == 'LOCALHOST'
+      if @interface_address && @interface_address.casecmp('LOCALHOST')
+        @interface_address = '127.0.0.1'
+      end
       @ttl = ttl.to_i
       @ttl = 1 if @ttl < 1
       @write_timeout = ConfigParser.handle_nil(write_timeout)
@@ -60,7 +61,9 @@ module Cosmos
       @read_timeout = ConfigParser.handle_nil(read_timeout)
       @read_timeout = @read_timeout.to_f if @read_timeout
       @bind_address = ConfigParser.handle_nil(bind_address)
-      @bind_address = '127.0.0.1' if @bind_address and @bind_address.upcase == 'LOCALHOST'
+      if @bind_address && @bind_address.casecmp('LOCALHOST')
+        @bind_address = '127.0.0.1'
+      end
       @write_socket = nil
       @read_socket = nil
       @read_allowed = false unless @read_port
@@ -72,13 +75,18 @@ module Cosmos
     # the constructor and a new {UdpReadSocket} if the read_port was given in
     # the constructor.
     def connect
-      @write_socket = UdpWriteSocket.new(@hostname,
-                                         @write_dest_port,
-                                         @write_src_port,
-                                         @interface_address,
-                                         @ttl,
-                                         @bind_address) if @write_dest_port
-      @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
+      @read_socket = UdpReadSocket.new(
+        @read_port,
+        @hostname,
+        @interface_address,
+        @bind_address) if @read_port
       @thread_sleeper = nil
     end
 
@@ -105,69 +113,29 @@ module Cosmos
       @thread_sleeper = nil
     end
 
-    # If the read port was given, the read_socket is read and the data returned
-    # in a {Packet}. bytes_read and read_count are updated.
-    #
-    # @return [Packet]
     def read
-      if @read_port
-        begin
-          data = @read_socket.read(@read_timeout)
-          @raw_logger_pair.read_logger.write(data) if @raw_logger_pair
-        rescue IOError
-          # Disconnected
-          return nil
-        end
-
-        @bytes_read += data.length
-        @read_count += 1
-
-        return Packet.new(nil, nil, :BIG_ENDIAN, nil, data)
-      else
-        # Write only interface so stop the thread which calls read
-        @thread_sleeper = Sleeper.new
-        while connected?()
-          @thread_sleeper.sleep(1000000)
-        end
-        return nil
-      end
+      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
 
-    # If the write_dest_port was given, the write_socket is written with the
-    # packet data. bytes_written and write_count are updated.
-    #
-    # @param packet [Packet] Packet buffer to write
-    def write(packet)
-      if @write_dest_port
-        if connected?()
-          write_raw(packet.buffer)
-        else
-          raise "Interface not connected"
-        end
-      else
-        raise "Attempt to write to read only interface"
-      end
+    # Reads from the socket if the read_port is defined
+    def read_interface
+      data = @read_socket.read(@read_timeout)
+      read_interface_base(data)
+      return data
+    rescue IOError # Disconnected
+      return nil
     end
 
-    # If the write_dest_port was given, the write_socket is written with the
-    # data. bytes_written and write_count are updated.
-    #
-    # @param data [String] Raw binary data to write
-    def write_raw(data)
-      if @write_dest_port
-        if connected?()
-          @write_socket.write(data, @write_timeout)
-          @bytes_written += data.length
-          @write_count += 1
-          @raw_logger_pair.write_logger.write(data) if @raw_logger_pair
-        else
-          raise "Interface not connected"
-        end
-      else
-        raise "Attempt to write to read only interface"
-      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 # class UdpInterface
-
-end # module Cosmos
+  end
+end

data/lib/cosmos/io/buffered_file.rb

@@ -1,6 +1,6 @@
 # encoding: ascii-8bit
 
-# Copyright 2014 Ball Aerospace & Technologies Corp.
+# Copyright 2017 Ball Aerospace & Technologies Corp.
 # All Rights Reserved.
 #
 # This program is free software; you can modify and/or redistribute it
@@ -8,4 +8,94 @@
 # as published by the Free Software Foundation; version 3 with
 # attribution addendums as found in the LICENSE.txt
 
-require 'cosmos/ext/buffered_file'
+if RUBY_ENGINE == 'ruby' and !ENV['COSMOS_NO_EXT']
+  require 'cosmos/ext/buffered_file'
+else
+  module Cosmos
+    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/cosmos/io/json_drb.rb

@@ -297,7 +297,7 @@ module Cosmos
           while true
             begin
               request_data = JsonDRb.receive_message(my_socket, data, pipe_reader)
-              start_time = Time.now
+              start_time = Time.now.sys
               @request_count += 1
             rescue Errno::ECONNRESET, Errno::ECONNABORTED, Errno::ENOTSOCK, IOError
               # Socket was closed
@@ -373,7 +373,7 @@ module Cosmos
       response_data = response.to_json(:allow_nan => true)
       STDOUT.puts response_data if JsonDRb.debug?
       JsonDRb.send_data(socket, response_data)
-      end_time = Time.now
+      end_time = Time.now.sys
       request_time = end_time - start_time
       add_request_time(request_time)
     rescue

data/lib/cosmos/io/posix_serial_driver.rb

@@ -23,7 +23,8 @@ module Cosmos
                    parity = :NONE,
                    stop_bits = 1,
                    write_timeout = 10.0,
-                   read_timeout = nil)
+                   read_timeout = nil,
+                   flow_control = :NONE)
 
       # Convert Baud Rate into Termios constant
       begin
@@ -57,6 +58,7 @@ module Cosmos
       cflags |= Termios::CSTOPB if stop_bits == 2
       cflags |= Termios::PARENB if parity
       cflags |= Termios::PADODD if parity == :ODD
+      cflags |= Termios::CRTSCTS if flow_control == :RTSCTS
       tio.iflag = iflags
       tio.oflag = 0
       tio.cflag = cflags

data/lib/cosmos/io/raw_logger.rb

@@ -66,7 +66,7 @@ module Cosmos
       @mutex = Mutex.new
       @file = nil
       @filename = nil
-      @start_time = Time.now
+      @start_time = Time.now.sys
       @logging_enabled = ConfigParser.handle_true_false(logging_enabled)
     end
 
@@ -107,7 +107,7 @@ module Cosmos
     # 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 - @start_time) < 1.0) # Prevent close/open too fast
+      close_file() unless ((Time.now.sys - @start_time) < 1.0) # Prevent close/open too fast
       @mutex.synchronize { @logging_enabled = true }
     end
 
@@ -136,7 +136,7 @@ module Cosmos
           @filename = File.join(@log_directory, File.build_timestamped_filename([@log_name], '.bin'))
           @file = File.new(@filename, 'wb')
         end
-        @start_time = Time.now
+        @start_time = Time.now.sys
         Logger.instance.info "Raw Log File Opened : #{@filename}"
       end
     rescue => err

data/lib/cosmos/io/serial_driver.rb

@@ -8,9 +8,10 @@
 # as published by the Free Software Foundation; version 3 with
 # attribution addendums as found in the LICENSE.txt
 
+require 'cosmos/core_ext/kernel'
 if Kernel.is_windows?
   require 'cosmos/io/win32_serial_driver'
-else
+elsif RUBY_ENGINE == 'ruby'
   require 'cosmos/io/posix_serial_driver'
 end
 
@@ -31,12 +32,14 @@ module Cosmos
     #   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
     def initialize(port_name,
                    baud_rate,
                    parity = :NONE,
                    stop_bits = 1,
                    write_timeout = 10.0,
-                   read_timeout = nil)
+                   read_timeout = nil,
+                   flow_control = :NONE)
       raise(ArgumentError, "Invalid parity: #{parity}") unless VALID_PARITY.include? parity
       if Kernel.is_windows?
         @driver = Win32SerialDriver.new(port_name,
@@ -44,14 +47,20 @@ module Cosmos
                                         parity,
                                         stop_bits,
                                         write_timeout,
-                                        read_timeout)
-      else
+                                        read_timeout,
+                                        0.01,
+                                        1000,
+                                        flow_control)
+      elsif RUBY_ENGINE == 'ruby'
         @driver = PosixSerialDriver.new(port_name,
                                         baud_rate,
                                         parity,
                                         stop_bits,
                                         write_timeout,
-                                        read_timeout)
+                                        read_timeout,
+                                        flow_control)
+      else
+        @driver = nil # JRuby Serial on Linux not currently supported
       end
     end
 

data/lib/cosmos/io/win32_serial_driver.rb

@@ -8,6 +8,7 @@
 # as published by the Free Software Foundation; version 3 with
 # attribution addendums as found in the LICENSE.txt
 
+require 'cosmos/io/serial_driver'
 require 'cosmos/win32/win32'
 require 'timeout' # For Timeout::Error
 
@@ -24,7 +25,8 @@ module Cosmos
                    write_timeout = 10.0,
                    read_timeout = nil,
                    read_polling_period = 0.01,
-                   read_max_length = 1000)
+                   read_max_length = 1000,
+                   flow_control = :NONE)
 
       # Verify Parameters
       port_name = '\\\\.\\' + port_name if port_name =~ /^COM[0-9]{2,3}$/
@@ -62,12 +64,22 @@ module Cosmos
                                   Win32::FILE_ATTRIBUTE_NORMAL)
       @mutex = Mutex.new
 
-      # Configure the Comm Port
+      # Configure the Comm Port - See: https://msdn.microsoft.com/en-us/library/windows/desktop/aa363214(v=vs.85).aspx
       dcb = Win32.get_comm_state(@handle)
       dcb.write('BaudRate', baud_rate)
       dcb.write('ByteSize', 8)
       dcb.write('Parity',   parity)
       dcb.write('StopBits', stop_bits)
+      if flow_control == :RTSCTS
+        # Monitor CTS
+        dcb.write('fOutxCtsFlow', 1)
+
+        # 0x00 - RTS_CONTROL_DISABLE - Disables the RTS line when the device is opened and leaves it disabled.
+        # 0x01 - RTS_CONTROL_ENABLE - Enables the RTS line when the device is opened and leaves it on.
+        # 0x02 - RTS_CONTROL_HANDSHAKE - Enables RTS handshaking. The driver raises the RTS line when the "type-ahead" (input) buffer is less than one-half full and lowers the RTS line when the buffer is more than three-quarters full. If handshaking is enabled, it is an error for the application to adjust the line by using the EscapeCommFunction function.
+        # 0x03 - RTS_CONTROL_TOGGLE - Specifies that the RTS line will be high if bytes are available for transmission. After all buffered bytes have been sent, the RTS line will be low.
+        dcb.write('fRtsControl', 0x03)
+      end
       Win32.set_comm_state(@handle, dcb)
 
       # Configure Timeouts
@@ -97,14 +109,14 @@ module Cosmos
     # (see SerialDriver#write)
     def write(data)
       # Write the data
-      time = Time.now
+      time = Time.now.sys
       bytes_to_write = data.length
       while (bytes_to_write > 0)
         bytes_written = Win32.write_file(@handle, data, data.length)
         raise "Error writing to comm port" if bytes_written <= 0
         bytes_to_write -= bytes_written
         data = data[bytes_written..-1]
-        raise Timeout::Error, "Write Timeout" if @write_timeout and (Time.now - time > @write_timeout) and bytes_to_write > 0
+        raise Timeout::Error, "Write Timeout" if @write_timeout and (Time.now.sys - time > @write_timeout) and bytes_to_write > 0
       end
     end