nova 0.0.2

data/lib/nova/starbound/protocol/packet.rb

@@ -0,0 +1,267 @@
+require 'packed_struct'
+
+module Nova
+  module Starbound
+    class Protocol
+
+      # Handles serialization and deserialization of packets.
+      class Packet
+
+        extend PackedStruct
+
+        struct_layout :packet do
+          little uint32 size
+          little uint32 packet_id
+          little int packet_type
+          little string nonce[24]
+
+          string body[size]
+          null
+        end
+
+        struct_layout :response do
+          little uint32 size
+          little uint32 packet_response_id
+          little int packet_response_type
+          little int packet_type
+          little string nonce[24]
+
+          string body[size]
+          null
+        end
+
+        struct_layout :enc_type do
+          little int index
+        end
+
+        # A list of the types of packets in existance, and their
+        # packet_type codes.
+        Type = {
+          :nul => 0x00,
+
+          # handshake
+          :protocol_version   => 0x01,
+          :encryption_options => 0x02,
+          :public_key         => 0x03,
+
+          # other stuff
+          :standard_error     => 0x04,
+          :close              => 0x05,
+
+          # content
+          :echo               => 0x06
+        }.freeze
+
+        # Used internally to check the types of packets when
+        # unpacking.
+        Structs = {
+          :packet   => 0x00,
+          :response => 0x01
+        }.freeze
+
+        # For checking why the protocol was closed.
+        CloseReasons = {
+          :none     => 0x00,
+          :shutdown => 0x01
+        }.freeze
+
+        # Provides access to the {Type} constant.
+        #
+        # @return [Hash]
+        def self.types
+          Type
+        end
+
+        # Builds a packet from a given body.
+        #
+        # @param type [Symbol] the type of packet it is.  See {Type}.
+        # @param body [String] the body of the packet.
+        # @param others [Hash] the data to pass to the struct.  See
+        #   the packet struct definition to see what keys are allowed.
+        # @return [Packet] the packet data.
+        def self.build(type, body, others = {})
+          packet_data = {
+            :packet_type => Packet.types[type],
+            :body        => body,
+            :size        => body.bytesize
+          }.merge(others)
+
+          # Packet.struct[:packet].pack(packet_data)
+          Packet.new(:packet, packet_data)
+        end
+
+        # Builds a response from a given body.  Doesn't increment the
+        # packet id, as a response doesn't have a packet id.
+        #
+        # @param type [Symbol] the type of packet.  See {Type}.
+        # @param body [String] the body of the packet.
+        # @param packet_data [Hash<Symbol, Numeric>] the packet data
+        #   that this is a response to.
+        # @param others [Hash] the data to pass to the struct.  See
+        #   the response struct definition to see what keys are
+        #   allowed.
+        # @option packet_data [Numeric] :packet_id the packet id this
+        #   response is a response to.
+        # @option packet_data [Numeric] :packet_type the packet type
+        #   this response is a response to.
+        # @return [Packet] the packet data.
+        def self.build_response(type, body, packet_data = {}, others = {})
+          response_data = {
+            :packet_response_id   => packet_data[:packet_id] ||
+              packet_data[:packet_response_id],
+            :packet_response_type => packet_data[:packet_type],
+            :packet_type          => Packet.types[type],
+            :body                 => body,
+            :size                 => body.bytesize
+          }.merge(others)
+
+          # Packet.struct[:response].pack(response_data)
+          Packet.new(:response, response_data)
+        end
+
+        # Unpacks a struct from a socket.
+        #
+        # @param sock [#read, #seek] the socket to read from.
+        # @raise [NoStructError] if it can't determine the struct
+        #   type.
+        # @return [Packet]
+        def self.from_socket(sock)
+          # we're gonna read one byte to see what type of packet it
+          # is, a response or a regular packet.
+          struct_type_num = sock.read(1)
+
+          struct_type = Structs.key(
+            struct_type_num.unpack("c").first)
+
+          unless struct_type
+            raise NoStructError,
+              "Undefined struct type #{struct_type_num.inspect}"
+          end
+
+          data = Packet.struct[struct_type].unpack_from_socket(sock)
+          Packet.new(struct_type, data)
+        end
+
+        # The type of struct this packet is.  See {Structs}.
+        #
+        # @return [Symbol]
+        attr_reader :struct
+
+        # The data in this packet.
+        #
+        # @see []
+        # @return [Hash]
+        attr_reader :data
+
+        # Initialize the packet.
+        #
+        # @param struct [Symbol] the type of struct.
+        # @param data [Hash] the packet data.
+        def initialize(struct, data)
+          @struct = struct
+          @data = data
+        end
+
+        # Turn this packet into a string.
+        #
+        # @return [String]
+        def to_s
+          @_cache ||= [Structs[@struct]].pack("c") +
+            Packet.struct[@struct].pack(@data)
+        end
+
+        alias_method :to_str, :to_s
+
+        # Pretty inspect.
+        #
+        # @return [String]
+        def inspect
+          "#<#{self.class.name}:#{@struct}:#{@data}>"
+        end
+
+        # Forwards to the data key :packet_id, or if that doesn't
+        # exist, +:packet_response_id+.
+        #
+        # @return [Numeric]
+        def id
+          @data[:packet_id] || @data[:packet_response_id]
+        end
+
+        # The type of packet this is.  Checks {Packet.types} before
+        # returning just the number.
+        #
+        # @return [Symbol, Numeric]
+        def type
+          Packet.types.key(@data[:packet_type]) || @data[:packet_type]
+        end
+
+        # Sets the body and the size for this packet.
+        #
+        # @param body [String] the new body.
+        # @return [void]
+        def body=(body)
+          data[:body] = body
+          data[:size] = body.bytesize
+        end
+
+        # Checks this packet for the expected type.
+        #
+        # @raise [UnacceptablePacketError] if the type doesn't match.
+        def expect(type)
+          if self.type != type
+            raise UnacceptablePacketError,
+              "Expected packet to be of type #{type}, " +
+              "got #{self.type} instead"
+          end
+        end
+
+        # Copies the data over to the new packet.  This is used when
+        # #clone or #dup is copied on the instance.
+        #
+        # @api private
+        # @return [void]
+        def initialize_copy(other)
+          other.data = self.data.clone
+        end
+
+        # Forwards requests on this packet of unkown methds to the
+        # data hash.
+        #
+        # @return [Object]
+        def method_missing(method, *args, &block)
+          if @data.respond_to?(method)
+            @data.public_send(method, *args, &block)
+          elsif @data.key?(method)
+            @data[method]
+          elsif @data.key?(key = :"packet_#{method}")
+            @data[key]
+          else
+            super
+          end
+        end
+
+        # Defined so ruby knows we're doing #method_missing magic.
+        #
+        # @param method [Symbol] the method to check for.
+        # @param include_all [Boolean] whether or not to include
+        #   private and protected methods.
+        # @return [Boolean]
+        def respond_to_missing?(method, include_all = false)
+          @data.respond_to?(method, include_all) || @data.key?(method)
+        end
+
+        protected
+
+        # Sets the data to the given argument.
+        #
+        # @api private
+        # @param data [Hash] the data to set to.
+        # @return [void]
+        def data=(data)
+          @data = data
+        end
+
+      end
+    end
+  end
+end

data/lib/nova/starbound/protocol/socket.rb

@@ -0,0 +1,231 @@
+require 'thread'
+
+module Nova
+  module Starbound
+    class Protocol
+
+      # Handles sending data on the socket.
+      module Socket
+
+        # The socket to write data to.
+        #
+        # @return [#read, #write]
+        attr_accessor :socket
+
+        # The queue that holds messages.
+        #
+        # @return [Queue]
+        attr_reader :queue
+
+        # The current packet id.
+        #
+        # @return [Numeric]
+        attr_reader :current_packet_id
+
+        # Sends out a regular packet with the given type and body.
+        #
+        # @param packet_type [Symbol] the packet type of this packet.
+        #   See {Packet::Type} for a list of packet types.
+        # @param body [String] the body of the packet.
+        # @param others [Hash] other data to pass to the packet.
+        # @return [Packet] the sent packet.
+        def send(packet_type, body, others = {})
+          others = others.merge(:packet_id => current_packet_id)
+          @current_packet_id += 1
+          write_packet Packet.build(packet_type, body, others)
+        end
+
+        # Sends out a response packet with the given type and body.
+        #
+        # @param packet [Packet] the packet to respond to.
+        # @param type [Symbol] the packet tpye of this packet.  See
+        #   {Packet::Type} for a list of packet types.
+        # @param body [String] the body of this packet.
+        # @param others [Hash] the other data to pass to the packet.
+        # @return [Packet] the sent packet.
+        def respond_to(packet, type, body, others = {})
+          write_packet Packet.build_response(type, body, packet,
+            others)
+        end
+
+        # Writes the given packet to the socket, after handling the
+        # encryption of the packet.
+        #
+        # @return [Packet] the sent packet.
+        def write_packet(packet)
+          new_packet = encryption_provider.encrypt(packet)
+
+          socket.write new_packet
+          socket.flush
+
+          new_packet
+        end
+
+        # Waits for a packet and returns it.  If it's threaded, or if
+        # there's data in the queue, it
+        # waits for a message in the queue and pops off the top one.
+        # If it's not, it just reads from the socket.
+        #
+        # @raise [RemoteClosedError] if it recieves a +:close+ packet.
+        # @param read_check [Boolean] whether or not to check the read
+        #   list for the packet.
+        # @return [Packet]
+        def read(read_check = true)
+          pack = if @read.length > 0 && read_check
+            @read.pop
+          elsif threaded?
+            queue.pop
+          else
+            wait_for_socket
+          end
+
+          if pack && pack.type == :close
+            raise RemoteClosedError
+          end
+
+          pack
+        end
+
+        # Returns whether or not this instance of the protocol uses
+        # threads to handle reading.
+        #
+        # @return [Boolean]
+        def threaded?
+          @threaded
+        end
+
+        # Whether or not this is actually running.
+        #
+        # @return [Boolean]
+        def run?
+          @run
+        end
+
+        # Initializes the socket.
+        def initialize
+          @threaded = @options.fetch(:threaded, true)
+          @run = true
+          @queue = Queue.new
+          @read  = []
+          @current_packet_id = 0
+        end
+
+        # The thread that is filling the queue with packet data.  If
+        # it doesn't exist, it creates one, if this is threaded.
+        #
+        # @return [nil, Thread] nil if this is not threaded, Thread
+        #   otherwise.
+        def thread
+          return unless threaded?
+
+          @_thread ||= Thread.start do
+            while run?
+              packet = wait_for_socket
+
+              queue << packet
+            end
+          end
+        end
+
+        # Stores callbacks for when packets arrive.
+        #
+        # @param data [Hash<(Symbol, Symbol)>] should consist of only
+        #   one key-value pair, with the key being the struct that
+        #   represents the packet, and the type being the type of
+        #   packet.
+        # @yieldparam packet [Packet] the packet.
+        def on(data, &block)
+          struct = data.keys.first
+          type   = data.values.first
+
+          callbacks[type].push :struct => struct,
+            :type => type, :block => block
+        end
+
+        # The callbacks that have been defined on this protocol.
+        #
+        # @return [Hash<Symbol, Object>] the symbol is the type of
+        #   packet.
+        def callbacks
+          @_callbacks ||= Hash.new { |h, k| h[k] = [] }
+        end
+
+        # Runs a callback.
+        #
+        # @param struct [Symbol] the struct that the callback is for.
+        # @param type [Symbol] the type of callback this is for.
+        # @return [Array<Object>] all of the results from running the
+        #   callbacks.
+        def run_callback(struct, type, *args)
+          callbacks[type].select { |c|
+            c[:struct] == struct }.map do |c|
+            c[:block].call(*args)
+          end
+        end
+
+        # Keep looping until we stop running.  Reads packets
+        # continuously until we do stop.
+        #
+        # @return [void]
+        def loop
+          while run?
+            read
+          end
+        end
+
+        # Finds the response to the given packet.
+        #
+        # @param packet [Packet]
+        # @return [nil, Packet] nil if it was told to stop running
+        #   before it could find a response.
+        def response_to(packet)
+          response = nil
+
+          while response.nil? && run?
+            temp = read(false)
+
+            if temp.struct == :response && temp.response_id == packet.id
+              response = temp
+            end
+          end
+
+          response
+        end
+
+        # Closes down the socket.
+        #
+        # @return [void]
+        def close
+          @run = false
+
+          socket.close
+        end
+
+        private
+
+        # Blocks the thread until data is available, or this is
+        # signaled to stop running.
+        #
+        # @return [nil, Packet] nil when it was told to stop running
+        #   before data was given, Packet otherwise.
+        def wait_for_socket
+          packet = nil
+
+          while packet.nil? && run?
+
+            out = IO.select [socket], nil, nil, 0.1
+            next unless out
+
+            packet = encryption_provider.decrypt(
+              Packet.from_socket(socket))
+
+            run_callback packet.struct, packet.type, packet
+          end
+
+          packet
+        end
+
+      end
+    end
+  end
+end