cosmos 3.0.1 → 3.1.0

data/lib/cosmos/streams/tcpip_client_stream.rb

@@ -1,77 +1,77 @@
-# encoding: ascii-8bit
-
-# Copyright 2014 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 General Public License
-# as published by the Free Software Foundation; version 3 with
-# attribution addendums as found in the LICENSE.txt
-
-require 'socket'
-require 'thread' # For Mutex
-require 'timeout' # For Timeout::Error
-require 'cosmos/streams/tcpip_socket_stream'
-require 'cosmos/config/config_parser'
-
-module Cosmos
-
-  # 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)
-      @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 error.message =~ /getaddrinfo/
-          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)
-        write_socket.connect(write_addr)
-      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)
-          read_socket.connect(read_addr)
-        else
-          read_socket = write_socket
-        end
-      end
-
-      super(write_socket, read_socket, write_timeout, read_timeout)
-    end
-
-  end # class TcpipClientStream
-
-end # module Cosmos
+# encoding: ascii-8bit
+
+# Copyright 2014 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 General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'socket'
+require 'thread' # For Mutex
+require 'timeout' # For Timeout::Error
+require 'cosmos/streams/tcpip_socket_stream'
+require 'cosmos/config/config_parser'
+
+module Cosmos
+
+  # 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)
+      @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 error.message =~ /getaddrinfo/
+          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)
+        write_socket.connect(write_addr)
+      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)
+          read_socket.connect(read_addr)
+        else
+          read_socket = write_socket
+        end
+      end
+
+      super(write_socket, read_socket, write_timeout, read_timeout)
+    end
+
+  end # class TcpipClientStream
+
+end # module Cosmos

data/lib/cosmos/streams/tcpip_socket_stream.rb

@@ -1,139 +1,139 @@
-# encoding: ascii-8bit
-
-# Copyright 2014 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 General Public License
-# as published by the Free Software Foundation; version 3 with
-# attribution addendums as found in the LICENSE.txt
-
-require 'socket'
-require 'thread' # For Mutex
-require 'timeout' # For Timeout::Error
-require 'cosmos/streams/stream'
-require 'cosmos/config/config_parser'
-
-module Cosmos
-
-  # Data {Stream} which reads and writes from Tcpip Sockets.
-  class TcpipSocketStream < Stream
-    attr_reader :write_socket
-
-    # @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
-      @connected = true
-
-      # Mutex on write is needed to protect from commands coming in from more
-      # than one tool
-      @write_mutex = Mutex.new
-    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 there is only one stream procesor
-      # reading
-      begin
-        data = @read_socket.recv_nonblock(65535)
-        @raw_logger_pair.read_logger.write(data) if @raw_logger_pair
-      rescue Errno::EAGAIN, Errno::EWOULDBLOCK
-        # Wait for the socket to be ready for reading or for the timeout
-        begin
-          result = IO.fast_select([@read_socket], 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 result
-            retry
-          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
-        data = ''
-      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 there is only one stream procesor
-      # reading
-      begin
-        data = @read_socket.recv_nonblock(65535)
-        @raw_logger_pair.read_logger.write(data) if @raw_logger_pair
-      rescue Errno::EAGAIN, Errno::EWOULDBLOCK, Errno::ECONNRESET, Errno::ECONNABORTED
-        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)
-            @raw_logger_pair.write_logger.write(data_to_send[0..(bytes_sent - 1)]) if @raw_logger_pair and bytes_sent > 0
-          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
-
-    # @return [Boolean] Whether the sockets are connected
-    def connected?
-      @connected
-    end
-
-    # Disconnect by closing the sockets
-    def disconnect
-      if @connected
-        @write_socket.close if @write_socket and !@write_socket.closed?
-        @read_socket.close if @read_socket and !@read_socket.closed?
-        @connected = false
-      end
-    end
-
-  end # class TcpipSocketStream
-
-end # module Cosmos
+# encoding: ascii-8bit
+
+# Copyright 2014 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 General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'socket'
+require 'thread' # For Mutex
+require 'timeout' # For Timeout::Error
+require 'cosmos/streams/stream'
+require 'cosmos/config/config_parser'
+
+module Cosmos
+
+  # Data {Stream} which reads and writes from Tcpip Sockets.
+  class TcpipSocketStream < Stream
+    attr_reader :write_socket
+
+    # @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
+      @connected = true
+
+      # Mutex on write is needed to protect from commands coming in from more
+      # than one tool
+      @write_mutex = Mutex.new
+    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 there is only one stream procesor
+      # reading
+      begin
+        data = @read_socket.recv_nonblock(65535)
+        @raw_logger_pair.read_logger.write(data) if @raw_logger_pair
+      rescue Errno::EAGAIN, Errno::EWOULDBLOCK
+        # Wait for the socket to be ready for reading or for the timeout
+        begin
+          result = IO.fast_select([@read_socket], 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 result
+            retry
+          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
+        data = ''
+      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 there is only one stream procesor
+      # reading
+      begin
+        data = @read_socket.recv_nonblock(65535)
+        @raw_logger_pair.read_logger.write(data) if @raw_logger_pair
+      rescue Errno::EAGAIN, Errno::EWOULDBLOCK, Errno::ECONNRESET, Errno::ECONNABORTED
+        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)
+            @raw_logger_pair.write_logger.write(data_to_send[0..(bytes_sent - 1)]) if @raw_logger_pair and bytes_sent > 0
+          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
+
+    # @return [Boolean] Whether the sockets are connected
+    def connected?
+      @connected
+    end
+
+    # Disconnect by closing the sockets
+    def disconnect
+      if @connected
+        @write_socket.close if @write_socket and !@write_socket.closed?
+        @read_socket.close if @read_socket and !@read_socket.closed?
+        @connected = false
+      end
+    end
+
+  end # class TcpipSocketStream
+
+end # module Cosmos

data/lib/cosmos/streams/template_stream_protocol.rb

@@ -1,140 +1,140 @@
-# encoding: ascii-8bit
-
-# Copyright 2014 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 General Public License
-# as published by the Free Software Foundation; version 3 with
-# attribution addendums as found in the LICENSE.txt
-
-require 'cosmos/config/config_parser'
-require 'cosmos/streams/stream_protocol'
-require 'cosmos/streams/terminated_stream_protocol'
-require 'thread' # For Queue
-
-module Cosmos
-
-  class TemplateStreamProtocol < TerminatedStreamProtocol
-    def initialize(write_termination_characters,
-      read_termination_characters,
-      ignore_lines = 0,
-      initial_read_delay = nil,
-      response_lines = 1,
-      strip_read_termination = true,
-      discard_leading_bytes = 0,
-      sync_pattern = nil,
-      fill_sync_pattern = false)
-      super(write_termination_characters,
-            read_termination_characters,
-            strip_read_termination,
-            discard_leading_bytes,
-            sync_pattern,
-            fill_sync_pattern)
-      @response_template = nil
-      @response_packet = nil
-      @read_queue = Queue.new
-      @ignore_lines = ignore_lines.to_i
-      @response_lines = response_lines.to_i
-      @initial_read_delay = ConfigParser.handle_nil(initial_read_delay)
-      @initial_read_delay = @initial_read_delay.to_f if @initial_read_delay
-    end
-
-    def connect(stream)
-      # Empty the read queue
-      begin
-        @read_queue.pop(true) while @read_queue.length > 0
-      rescue
-      end
-
-      super(stream)
-
-      if @initial_read_delay
-        sleep(@initial_read_delay)
-        loop do
-          break if @stream.read_nonblock.length <= 0
-        end
-      end
-    end
-
-    def disconnect
-      super()
-      @read_queue << nil # Unblock the read queue in the interface thread
-    end
-
-    def read(use_queue = true)
-      if use_queue
-        return @read_queue.pop
-      else
-        return super()
-      end
-    end
-
-    # See StreamProtocol#pre_write_packet
-    def pre_write_packet(packet)
-      # First grab the response template and response packet (if there is one)
-      begin
-        @response_template = packet.read("RSP_TEMPLATE").strip
-        @response_packet = packet.read("RSP_PACKET").strip
-      rescue
-        # If there is no response template we set to nil
-        @response_template = nil
-        @response_packet = nil
-      end
-
-      # Grab the command template because that is all we eventually send
-      template = packet.read("CMD_TEMPLATE")
-      # Create a new empty packet to call super on
-      raw_packet = Packet.new(nil, nil)
-      raw_packet.buffer = template
-      # Call super to allow the super classes to massage the packet data
-      data = super(raw_packet)
-      # Scan the template for variables in brackets <VARIABLE>
-      # Read these values from the packet and substitute them in the template
-      template.scan(/<(.*?)>/).each do |variable|
-        data.gsub!("<#{variable[0]}>", packet.read(variable[0], :RAW).to_s)
-      end
-      data
-    end
-
-    def post_write_data(packet, data)
-      if @response_template && @response_packet
-        @ignore_lines.times do
-          read(false)
-        end
-        response_string = ''
-        @response_lines.times do
-          response = read(false)
-          raise "No response received" unless response
-          response_string << response.buffer
-        end
-
-        # Grab the response packet specified in the command
-        result_packet = System.telemetry.packet(@interface.target_names[0], @response_packet).clone
-        result_packet.received_time = nil
-
-        # Convert the response template into a Regexp
-        response_item_names = []
-        response_template = @response_template.clone
-        response_template_items = @response_template.scan(/<.*?>/)
-        response_template_items.each do |item|
-          response_item_names << item[1..-2]
-          response_template.gsub!(item, "(.*)")
-        end
-        response_regexp = Regexp.new(response_template)
-
-        # Scan the response for the variables in brackets <VARIABLE>
-        # Write the packet value with each of the values received
-        response_values = response_string.scan(response_regexp)[0]
-        raise "Unexpected response received: #{response_string}" if response_values.length != response_item_names.length
-        response_values.each_with_index do |value, i|
-          result_packet.write(response_item_names[i], value)
-        end
-
-        @read_queue << result_packet
-      end
-    end
-
-  end # class TemplateStreamProtocol
-
-end # module Cosmos
+# encoding: ascii-8bit
+
+# Copyright 2014 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 General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'cosmos/config/config_parser'
+require 'cosmos/streams/stream_protocol'
+require 'cosmos/streams/terminated_stream_protocol'
+require 'thread' # For Queue
+
+module Cosmos
+
+  class TemplateStreamProtocol < TerminatedStreamProtocol
+    def initialize(write_termination_characters,
+      read_termination_characters,
+      ignore_lines = 0,
+      initial_read_delay = nil,
+      response_lines = 1,
+      strip_read_termination = true,
+      discard_leading_bytes = 0,
+      sync_pattern = nil,
+      fill_sync_pattern = false)
+      super(write_termination_characters,
+            read_termination_characters,
+            strip_read_termination,
+            discard_leading_bytes,
+            sync_pattern,
+            fill_sync_pattern)
+      @response_template = nil
+      @response_packet = nil
+      @read_queue = Queue.new
+      @ignore_lines = ignore_lines.to_i
+      @response_lines = response_lines.to_i
+      @initial_read_delay = ConfigParser.handle_nil(initial_read_delay)
+      @initial_read_delay = @initial_read_delay.to_f if @initial_read_delay
+    end
+
+    def connect(stream)
+      # Empty the read queue
+      begin
+        @read_queue.pop(true) while @read_queue.length > 0
+      rescue
+      end
+
+      super(stream)
+
+      if @initial_read_delay
+        sleep(@initial_read_delay)
+        loop do
+          break if @stream.read_nonblock.length <= 0
+        end
+      end
+    end
+
+    def disconnect
+      super()
+      @read_queue << nil # Unblock the read queue in the interface thread
+    end
+
+    def read(use_queue = true)
+      if use_queue
+        return @read_queue.pop
+      else
+        return super()
+      end
+    end
+
+    # See StreamProtocol#pre_write_packet
+    def pre_write_packet(packet)
+      # First grab the response template and response packet (if there is one)
+      begin
+        @response_template = packet.read("RSP_TEMPLATE").strip
+        @response_packet = packet.read("RSP_PACKET").strip
+      rescue
+        # If there is no response template we set to nil
+        @response_template = nil
+        @response_packet = nil
+      end
+
+      # Grab the command template because that is all we eventually send
+      template = packet.read("CMD_TEMPLATE")
+      # Create a new empty packet to call super on
+      raw_packet = Packet.new(nil, nil)
+      raw_packet.buffer = template
+      # Call super to allow the super classes to massage the packet data
+      data = super(raw_packet)
+      # Scan the template for variables in brackets <VARIABLE>
+      # Read these values from the packet and substitute them in the template
+      template.scan(/<(.*?)>/).each do |variable|
+        data.gsub!("<#{variable[0]}>", packet.read(variable[0], :RAW).to_s)
+      end
+      data
+    end
+
+    def post_write_data(packet, data)
+      if @response_template && @response_packet
+        @ignore_lines.times do
+          read(false)
+        end
+        response_string = ''
+        @response_lines.times do
+          response = read(false)
+          raise "No response received" unless response
+          response_string << response.buffer
+        end
+
+        # Grab the response packet specified in the command
+        result_packet = System.telemetry.packet(@interface.target_names[0], @response_packet).clone
+        result_packet.received_time = nil
+
+        # Convert the response template into a Regexp
+        response_item_names = []
+        response_template = @response_template.clone
+        response_template_items = @response_template.scan(/<.*?>/)
+        response_template_items.each do |item|
+          response_item_names << item[1..-2]
+          response_template.gsub!(item, "(.*)")
+        end
+        response_regexp = Regexp.new(response_template)
+
+        # Scan the response for the variables in brackets <VARIABLE>
+        # Write the packet value with each of the values received
+        response_values = response_string.scan(response_regexp)[0]
+        raise "Unexpected response received: #{response_string}" if response_values.length != response_item_names.length
+        response_values.each_with_index do |value, i|
+          result_packet.write(response_item_names[i], value)
+        end
+
+        @read_queue << result_packet
+      end
+    end
+
+  end # class TemplateStreamProtocol
+
+end # module Cosmos