cosmos 3.0.0

data/lib/cosmos/io/tcpip_server.rb

@@ -0,0 +1,532 @@
+# 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
+
+  # TCP/IP Server which can both read and write on a single port or two
+  # independent ports. A listen thread is setup which waits for client
+  # connections. For each connection to the read port, a thread is spawned that
+  # calls the read method from the stream protocol. This data is then
+  # available by calling the TcpipServer read method. For each connection to the
+  # write port, a thread is spawned that calls the write method from the stream
+  # protocol when data is send to the TcpipServer via the write method.
+  class TcpipServer
+
+    # Callback method to call when a new client connects to the write port.
+    # This method will be called with the StreamProtocol as the only argument.
+    attr_accessor :write_connection_callback
+    # Callback method to call when a new client connects to the read port.
+    # This method will be called with the StreamProtocol as the only argument.
+    attr_accessor :read_connection_callback
+    # The number of bytes read from all connected sockets
+    attr_accessor :bytes_read
+    # The number of bytes written to the TcpipServer. This number does not vary
+    # with the number of clients connected to the write port.
+    attr_accessor :bytes_written
+    # @return [RawLoggerPair] RawLoggerPair instance or nil
+    attr_accessor :raw_logger_pair
+    # @return [String] The ip address to bind to.  Default to ANY (0.0.0.0)
+    attr_accessor :listen_address
+
+    # @param write_port [Integer] The server write port. Clients should connect
+    #   and expect to receive data from this port.
+    # @param read_port [Integer] The server read port. Clients should connect
+    #   and expect to send data to this port.
+    # @param write_timeout [Float|nil] The number of seconds to wait for the
+    #   write to complete. Pass nil to block until the write is complete.
+    # @param read_timeout [Float|nil] The number of seconds to wait for the
+    #   read to complete. Pass nil to block until the read is complete.
+    # @param stream_protocol_type [String] The name of the stream protocol to
+    #   use for both the read and write ports. This name is combined with
+    #   'StreamProtocol' to result in a COSMOS StreamProtocol class.
+    # @param stream_protocol_args [Array] The arguments to pass to the
+    #   StreamProtocol class constructor
+    def initialize(write_port,
+                   read_port,
+                   write_timeout,
+                   read_timeout,
+                   stream_protocol_type,
+                   *stream_protocol_args)
+      @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_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
+
+      stream_protocol_class = stream_protocol_type.to_s.capitalize << 'StreamProtocol'
+      @stream_protocol_class = stream_protocol_class.to_class
+      unless @stream_protocol_class
+        begin
+          require "cosmos/streams/#{stream_protocol_class.class_name_to_filename}"
+          @stream_protocol_class = stream_protocol_class.to_class
+        rescue LoadError => err
+          Logger.instance.error "Unable to require #{stream_protocol_class.class_name_to_filename} due to #{err.message}. Ensure #{stream_protocol_class.class_name_to_filename} is in the COSMOS lib directory."
+          raise "Unable to require #{stream_protocol_class.class_name_to_filename} due to #{err.message}. Ensure #{stream_protocol_class.class_name_to_filename} is in the COSMOS lib directory."
+        end
+      end
+
+      @stream_protocol_args = stream_protocol_args
+
+      @listen_sockets = []
+      @listen_threads = []
+      @read_threads = []
+      @write_stream_protocols = []
+      @read_stream_protocols = []
+      @write_queue = nil
+      @write_queue = Queue.new if @write_port
+      @read_queue = nil
+      @read_queue = Queue.new if @read_port
+      @write_mutex = nil
+      @write_mutex = Mutex.new if @write_port
+      @write_condition_variable = nil
+      @write_condition_variable = ConditionVariable.new if @write_port
+      @write_connection_callback = nil
+      @read_connection_callback = nil
+      @bytes_read = 0
+      @bytes_written = 0
+      @raw_logger_pair = nil
+      @raw_logging_enabled = false
+      @interface = nil
+      @connection_mutex = Mutex.new
+      @listen_address = Socket::INADDR_ANY
+
+      @connected = false
+    end
+
+    # @param interface [Interface] Sets the higher level interface which is
+    #   using this TcpipServer. If the interface defines post_read_data,
+    #   post_read_packet, or pre_write_packet, then these methods will be
+    #   called over any subclass implementations within the stream protocol.
+    def interface=(interface)
+      @interface = interface
+    end
+
+    # Create the read and write port listen threads. Incoming connections will
+    # spawn separate threads to process the reads and writes.
+    def connect
+      if @write_port == @read_port
+        # Handle one socket case
+        start_listen_thread(@read_port, true, true)
+      else
+        if @write_port
+          start_listen_thread(@write_port, true, false)
+        end
+
+        if @read_port
+          start_listen_thread(@read_port, false, true)
+        end
+      end
+
+      if @write_port
+        # Start write thread
+        @write_thread = Thread.new do
+          begin
+            while true
+              write_thread_body()
+            end
+          rescue Exception => err
+            @write_stream_protocols.each do |stream_protocol, hostname, host_ip, port|
+              stream_protocol.disconnect
+              stream_protocol.stream.raw_logger_pair.stop if stream_protocol.stream.raw_logger_pair
+            end
+            @write_stream_protocols.clear
+            Logger.instance.error("Tcpip server write thread unexpectedly died")
+            Logger.instance.error(err.formatted)
+          end
+        end
+      else
+        @write_thread = nil
+      end
+      @connected = true
+    end
+
+    # @return [Boolean] Whether the server is listening for connections
+    def connected?
+      @connected
+    end
+
+    # Shutdowns the listener threads for both the read and write ports as well
+    # as any client connections. As a part of shutting down client connections,
+    # the {StreamProtocol#disconnect} method is called.
+    def disconnect
+      # Shutdown Listen Thread(s)
+      @listen_threads.each do |listen_thread|
+        listen_thread.kill
+      end
+      @listen_threads.clear
+
+      # Shutdown Listen Socket(s)
+      @listen_sockets.each do |listen_socket|
+        listen_socket.close unless listen_socket.closed?
+      end
+      @listen_sockets.clear
+
+      # Shutdown Read Threads
+      @read_threads.each do |thread|
+        thread.kill
+      end
+      @read_threads.clear
+
+      # Shutdown Write Thread
+      if @write_thread
+        @write_thread.kill
+        @write_thread = nil
+      end
+
+      # Shutdown Write Stream Protocols
+      @write_stream_protocols.each do |stream_protocol, hostname, host_ip, port|
+        stream_protocol.disconnect
+        stream_protocol.stream.raw_logger_pair.stop if stream_protocol.stream.raw_logger_pair
+      end
+      @write_stream_protocols.clear
+
+      # Shutdown Read Stream Protocols
+      @read_stream_protocols.each do |stream_protocol, hostname, host_ip, port|
+        stream_protocol.disconnect
+        stream_protocol.stream.raw_logger_pair.stop if stream_protocol.stream.raw_logger_pair
+      end
+      @read_stream_protocols.clear
+
+      @connected = false
+    end
+
+    # @return [Packet] Latest packet read from any of the connected clients.
+    #   Note this method blocks until data is available.
+    def read
+      return nil unless @read_queue
+      packet = @read_queue.pop
+      @bytes_read += packet.buffer.length
+      packet
+    end
+
+    # @param packet [Packet] Packet to write to all clients connected to the
+    #   write port.
+    def write(packet)
+      return unless @write_queue
+      @write_queue << packet.clone
+      @bytes_written += packet.buffer.length
+      @write_condition_variable.broadcast
+    end
+
+    # @param data [String] Data to write to all clients connected to the
+    #   write port.
+    def write_raw(data)
+      return unless @write_queue
+      packet = Packet.new(nil, nil)
+      packet.buffer = data
+      @write_queue << packet
+      @bytes_written += data.length
+      @write_condition_variable.broadcast
+    end
+
+    # @return [Integer] The number of packets waiting on the read queue
+    def read_queue_size
+      if @read_queue
+        @read_queue.size
+      else
+        0
+      end
+    end
+
+    # @return [Integer] The number of packets waiting on the write queue
+    def write_queue_size
+      if @write_queue
+        @write_queue.size
+      else
+        0
+      end
+    end
+
+    # @return [Integer] The number of connected clients
+    def num_clients
+      clients = []
+      @write_stream_protocols.each do |stream_protocol, hostname, host_ip, port|
+        clients << [host_ip, port]
+      end
+      @read_stream_protocols.each do |stream_protocol, hostname, host_ip, port|
+        clients << [host_ip, port]
+      end
+      clients.uniq.length
+    end
+
+    # Start raw logging for this interface
+    def start_raw_logging
+      @raw_logging_enabled = true
+      if @raw_logger_pair
+        @write_stream_protocols.each do |stream_protocol, hostname, host_ip, port|
+          stream_protocol.stream.raw_logger_pair.start if stream_protocol.stream.raw_logger_pair
+        end
+        @read_stream_protocols.each do |stream_protocol, hostname, host_ip, port|
+          stream_protocol.stream.raw_logger_pair.start if stream_protocol.stream.raw_logger_pair
+        end
+      end
+    end
+
+    # Stop raw logging for this interface
+    def stop_raw_logging
+      @raw_logging_enabled = false
+      if @raw_logger_pair
+        @write_stream_protocols.each do |stream_protocol, hostname, host_ip, port|
+          stream_protocol.stream.raw_logger_pair.stop if stream_protocol.stream.raw_logger_pair
+        end
+        @read_stream_protocols.each do |stream_protocol, hostname, host_ip, port|
+          stream_protocol.stream.raw_logger_pair.stop if stream_protocol.stream.raw_logger_pair
+        end
+      end
+    end
+
+    protected
+
+    def start_listen_thread(port, listen_write = false, listen_read = false)
+      # Create a socket to accept connections from clients
+      addr = Socket.pack_sockaddr_in(port, @listen_address)
+      listen_socket = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+      listen_socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1) unless Kernel.is_windows?
+      begin
+        listen_socket.bind(addr)
+      rescue Errno::EADDRINUSE
+        raise "Error binding to port #{port}.\n" +
+              "Either another application is using this port\n" +
+              "or the operating system is being slow cleaning up.\n" +
+              "Make sure all sockets/streams are closed in all applications,\n" +
+              "wait 1 minute and try again."
+      end
+
+      listen_socket.listen(5)
+
+      @listen_sockets << listen_socket
+
+      # Start Listen Thread
+      @listen_threads << Thread.new do
+        begin
+          while true
+            listen_thread_body(listen_socket, listen_write, listen_read)
+          end
+        rescue Exception => err
+          Logger.instance.error("Tcpip server listen thread unexpectedly died")
+          Logger.instance.error(err.formatted)
+        end
+      end
+    end
+
+    def listen_thread_body(listen_socket, listen_write = false, listen_read = false)
+      socket, address = listen_socket.accept()
+      port, host_ip = Socket.unpack_sockaddr_in(address)
+      hostname = ''
+      hostname = Socket.lookup_hostname_from_ip(host_ip) if System.instance.use_dns
+      if System.instance.acl
+        addr = ["AF_INET", 10, "lc630", host_ip.to_s]
+        if not System.instance.acl.allow_addr?(addr)
+          # Reject connection
+          if not socket.closed?
+            socket.close()
+          end
+          Logger.instance.info "Tcpip server rejected connection from #{hostname}(#{host_ip}):#{port}"
+          return
+        end
+      end
+
+      # Configure TCP_NODELAY option
+      socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+
+      # Accept Connection
+      write_socket = nil
+      read_socket = nil
+      write_socket = socket if listen_write
+      read_socket = socket if listen_read
+      stream = TcpipSocketStream.new(write_socket, read_socket, @write_timeout, @read_timeout)
+      if @raw_logger_pair
+        stream.raw_logger_pair = @raw_logger_pair.clone
+        stream.raw_logger_pair.start if @raw_logging_enabled
+      end
+
+      stream_protocol = @stream_protocol_class.new(*@stream_protocol_args)
+      stream_protocol.interface = @interface if @interface
+      stream_protocol.connect(stream)
+
+      if listen_write
+        @write_connection_callback.call(stream_protocol) if @write_connection_callback
+        @connection_mutex.synchronize do
+          @write_stream_protocols << [stream_protocol, hostname, host_ip, port]
+        end
+      end
+      if listen_read
+        @read_connection_callback.call(stream_protocol) if @read_connection_callback
+        @connection_mutex.synchronize do
+          @read_stream_protocols << [stream_protocol, hostname, host_ip, port]
+        end
+
+        # Start read thread
+        @read_threads << Thread.new do
+          index_to_delete = nil
+          begin
+            begin
+              read_thread_body(stream_protocol)
+            rescue Exception => err
+              Logger.instance.error "Tcpip server read thread unexpectedly died"
+              Logger.instance.error err.formatted
+            end
+            Logger.instance.info "Tcpip server lost read connection to #{hostname}(#{host_ip}):#{port}"
+            @read_threads.delete(Thread.current)
+
+            index_to_delete = nil
+            @connection_mutex.synchronize do
+              begin
+                index = 0
+                @read_stream_protocols.each do |read_stream_protocol, _, _, _|
+                  if read_stream_protocol == stream_protocol
+                    index_to_delete = index
+                    read_stream_protocol.disconnect
+                    read_stream_protocol.stream.raw_logger_pair.stop if read_stream_protocol.stream.raw_logger_pair
+                    break
+                  end
+                  index += 1
+                end
+              ensure
+                if index_to_delete
+                  @read_stream_protocols.delete_at(index_to_delete)
+                end
+              end
+            end
+          rescue Exception => err
+            Logger.instance.error "Tcpip server read thread unexpectedly died"
+            Logger.instance.error err.formatted
+          end
+        end
+      end
+
+      Logger.instance.info "Tcpip server accepted connection from #{hostname}(#{host_ip}):#{port}"
+    end
+
+    def write_thread_body
+      # Retrive the next packet to be sent out to clients
+      # Handles disconnected clients even when packets aren't flowing
+      packet = nil
+
+      loop do
+        begin
+          packet = @write_queue.pop(true)
+          break
+        rescue ThreadError
+          # Timeout waiting for send - check for dead clients
+          indexes_to_delete = []
+          index = 0
+
+          @connection_mutex.synchronize do
+            @write_stream_protocols.each do |stream_protocol, hostname, host_ip, port|
+              begin
+                if (@write_port != @read_port)
+                  # Socket should return EWOULDBLOCK if it is still cleanly connected
+                  stream_protocol.stream.write_socket.recvfrom_nonblock(10)
+                elsif (!stream_protocol.stream.write_socket.closed?)
+                  # Let read thread detect disconnect
+                  next
+                end
+
+                # Client has disconnected (or is invalidly sending data on the socket)
+                Logger.instance.info "Tcpip server lost write connection to #{hostname}(#{host_ip}):#{port}"
+                stream_protocol.disconnect
+                stream_protocol.stream.raw_logger_pair.stop if stream_protocol.stream.raw_logger_pair
+                indexes_to_delete.unshift(index) # Put later indexes at front of array
+              rescue Errno::ECONNRESET, Errno::ECONNABORTED
+                # Client has disconnected
+                Logger.instance.info "Tcpip server lost write connection to #{hostname}(#{host_ip}):#{port}"
+                stream_protocol.disconnect
+                stream_protocol.stream.raw_logger_pair.stop if stream_protocol.stream.raw_logger_pair
+                indexes_to_delete.unshift(index) # Put later indexes at front of array
+              rescue Errno::EWOULDBLOCK
+                # Client is still cleanly connected as far as we can tell without writing to the socket
+              ensure
+                index += 1
+              end
+            end
+
+            # Delete any dead sockets
+            indexes_to_delete.each do |index_to_delete|
+              @write_stream_protocols.delete_at(index_to_delete)
+            end
+          end # @connection_mutex.synchronize
+
+          # Sleep until we receive a packet or for 100ms
+          @write_mutex.synchronize do
+            @write_condition_variable.wait(@write_mutex, 0.1)
+          end
+        end
+      end
+
+      packet = write_thread_hook(packet)
+
+      if packet
+        @connection_mutex.synchronize do
+          # Send data to each client - On error drop the client
+          indexes_to_delete = []
+          index = 0
+          @write_stream_protocols.each do |stream_protocol, hostname, host_ip, port|
+            need_disconnect = false
+            begin
+              stream_protocol.write(packet)
+            rescue Errno::EPIPE, Errno::ECONNABORTED, IOError, Errno::ECONNRESET
+              # Client has normally disconnected
+              need_disconnect = true
+            rescue Exception => err
+              if err.message != "Stream not connected for write_raw"
+                Logger.instance.error "Error sending to client: #{err.class} #{err.message}"
+              end
+              need_disconnect = true
+            end
+
+            if need_disconnect
+              Logger.instance.info "Tcpip server lost write connection to #{hostname}(#{host_ip}):#{port}"
+              stream_protocol.disconnect
+              stream_protocol.stream.raw_logger_pair.stop if stream_protocol.stream.raw_logger_pair
+              indexes_to_delete.unshift(index) # Put later indexes at front of array
+            end
+
+            index += 1
+          end
+
+          # Delete any dead sockets
+          indexes_to_delete.each do |index_to_delete|
+            @write_stream_protocols.delete_at(index_to_delete)
+          end
+        end # @connection_mutex.synchronize
+      end
+    end
+
+    def write_thread_hook(packet)
+      return packet # By default just return the packet
+    end
+
+    def read_thread_body(stream_protocol)
+      loop do
+        packet = stream_protocol.read
+        return unless packet
+
+        # Do work on received packet
+        read_thread_hook(packet)
+      end # loop do
+    end
+
+    def read_thread_hook(packet)
+      @read_queue << packet.clone
+    end
+
+  end # class TcpipServerStream
+
+end # module Cosmos

data/lib/cosmos/io/udp_sockets.rb

@@ -0,0 +1,152 @@
+# 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 '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 Cosmos
+
+  # Creates a UDPSocket and implements a non-blocking write.
+  class UdpWriteSocket
+
+    # @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 interface_address [String] Local outgoing interface to send from
+    # @param ttl [Integer] Time To Live for outgoing packets
+    def initialize(dest_address,
+                   dest_port,
+                   src_port = nil,
+                   interface_address = nil,
+                   ttl = 1,
+                   bind_address = "0.0.0.0")
+      @socket = UDPSocket.new
+
+      # Basic setup to reuse address
+      @socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1)
+
+      # Set source port if given
+      @socket.bind(bind_address, src_port) if src_port
+
+      # Default send to the specified address and port
+      @socket.connect(dest_address, dest_port)
+
+      # Handle multicast
+      if UdpWriteSocket.multicast?(dest_address)
+        # 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(interface_address).hton) if interface_address
+      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
+
+    # 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
+    # @return [Boolean] Whether the hostname is multicast
+    def self.multicast?(host)
+      return false if host.nil?
+      # Look up address
+      _, _, _, *address_list = Socket.gethostbyname(host)
+      first_addr_byte = 0
+      address_list.each do |address|
+        if address.length == 4
+          first_addr_byte = address.getbyte(0)
+          break
+        end
+      end
+
+      if (first_addr_byte >= 224) && (first_addr_byte <= 239)
+        true
+      else
+        false
+      end
+    end
+  end
+
+  # Creates a UDPSocket and implements a non-blocking read.
+  class UdpReadSocket
+
+    # @param recv_port [Integer] Port to receive data on
+    # @param multicast_address [String] Address to add multicast
+    def initialize(recv_port = 0, multicast_address = nil, interface_address = nil, bind_address = "0.0.0.0")
+      @socket = UDPSocket.new
+
+      # Basic setup to reuse address
+      @socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1)
+
+      # bind to port
+      @socket.bind(bind_address, recv_port)
+
+      if UdpWriteSocket.multicast?(multicast_address)
+        interface_address = "0.0.0.0" unless interface_address
+        membership = IPAddr.new(multicast_address).hton + IPAddr.new(interface_address).hton
+        @socket.setsockopt(Socket::IPPROTO_IP, Socket::IP_ADD_MEMBERSHIP, membership)
+      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
+  end
+
+end # module Cosmos