gameoverseer 0.1.2 → 0.1.3

data/lib/gameoverseer/encryption_handler/encryption_handler.rb

@@ -0,0 +1,40 @@
+module GameOverseer
+  class EncryptionHandler
+
+    def initialize(key_size: 128, keypair_size: 2048)
+      EncryptionHandler.instance = self
+      generate_server_keypair(keypair_size)
+    end
+
+    def generate_server_keypair(keypair_size)
+      @server_keypair = OpenSSL::PKey::RSA.generate(keypair_size)
+    end
+
+    def encrypt_keypair(client_id, string)
+    end
+
+    def decrypt_keypair(string)
+    end
+
+    def encrypt(client_id, string)
+    end
+
+    def decrypt(client_id, string)
+    end
+
+    def set_client_keypair(client_id, public_key_pem)
+    end
+
+    def set_client_key(client_id)
+      ClientManager.instance.update(client_id, '_aes_key', 'In progress, not ready.')
+    end
+
+    def self.instance
+      @instance
+    end
+
+    def self.instance=(_instance)
+      @instance = _instance
+    end
+  end
+end

data/lib/gameoverseer/input_handler/input_handler.rb

@@ -1,30 +1,36 @@
-module GameOverseer
-  class InputHandler
-    def self.process_data(data, client_id)
-      @data = data
-      @client_id = client_id
-      forward_to_channel_manager if data_valid?
-    end
-
-    def self.data_valid?
-      if @data["channel"]
-        if @data["mode"]
-          true
-        end
-      end
-    end
-
-    def self.forward_to_channel_manager
-      count = 0
-      begin
-        channel_manager = GameOverseer::ChannelManager.instance
-        channel_manager.send_to_service(@data, @client_id)
-      rescue NoMethodError => e
-        GameOverseer::Console.log("InputHandler> #{e.to_s}")
-        raise if count >=2
-        count+=1
-        retry unless count >= 2
-      end
-    end
-  end
-end
+module GameOverseer
+  class InputHandler
+
+    # @param client_id [Integer]
+    # @param data [Hash]
+    def self.process_data(client_id, data)
+      @data = data
+      @client_id = client_id
+      forward_to_channel_manager if data_valid?
+    end
+
+    # Checks if hash contains 'channel' and 'mode'
+    # @return [Boolean]
+    def self.data_valid?
+      if @data["channel"]
+        if @data["mode"]
+          true
+        end
+      end
+    end
+
+    # Sends data and client_id to {ChannelManager}
+    def self.forward_to_channel_manager
+      count = 0
+      begin
+        channel_manager = GameOverseer::ChannelManager.instance
+        channel_manager.send_to_service(@client_id, @data)
+      rescue NoMethodError => e
+        GameOverseer::Console.log("InputHandler> #{e.to_s}")
+        raise if count >=2
+        count+=1
+        retry unless count >= 2
+      end
+    end
+  end
+end

data/lib/gameoverseer/messages/message_manager.rb

@@ -1,36 +1,42 @@
-module GameOverseer
-  class MessageManager
-    MESSAGES = []
-    BROADCASTS = []
-
-    def initialize
-      MessageManager.instance = self
-    end
-
-    def message(client_id, string, reliable = false, channel = ChannelManager::CHAT)
-      GameOverseer::ENetServer.instance.transmit(client_id, string, reliable, channel)
-      GameOverseer::Console.log("MessageManager> #{string}-#{client_id}")
-    end
-
-    def broadcast(string, reliable = false, channel = ChannelManager::CHAT)
-      GameOverseer::ENetServer.instance.broadcast(string, reliable, channel)
-      GameOverseer::Console.log("MessageManager> #{string}-#{channel}")
-    end
-
-    def messages
-      MESSAGES
-    end
-
-    def broadcasts
-      BROADCASTS
-    end
-
-    def self.instance
-      @instance
-    end
-
-    def self.instance=_instance
-      @instance = _instance
-    end
-  end
-end
+module GameOverseer
+
+  # Handles sending messages to clients on behalf of services
+  class MessageManager
+    MESSAGES = []
+    BROADCASTS = []
+
+    def initialize
+      MessageManager.instance = self
+    end
+
+    # Send a message to a specific client
+    # @param client_id [Integer] ID of client
+    # @param string [String] message to send
+    # @param reliable [Boolean] whether or not packet delivery is reliable
+    # @param channel [Integer] What channel to send on
+    def message(client_id, string, reliable = false, channel = ChannelManager::CHAT)
+      GameOverseer::ENetServer.instance.transmit(client_id, string, reliable, channel)
+      GameOverseer::Console.log("MessageManager> #{string}-#{client_id}")
+    end
+
+
+    # Send a message to all connected clients
+    # @param string [String] message to send
+    # @param reliable [Boolean] whether or not packet delivery is reliable
+    # @param channel [Integer] What channel to send on
+    def broadcast(string, reliable = false, channel = ChannelManager::CHAT)
+      GameOverseer::ENetServer.instance.broadcast(string, reliable, channel)
+      GameOverseer::Console.log("MessageManager> #{string}-#{channel}")
+    end
+
+    # @return [MessageManager]
+    def self.instance
+      @instance
+    end
+
+    # @param _instance [MessageManager]
+    def self.instance=_instance
+      @instance = _instance
+    end
+  end
+end

data/lib/gameoverseer/packet_handler/packet_handler.rb

@@ -0,0 +1,35 @@
+module GameOverseer
+  class PacketHandler
+
+    def initialize
+      PacketHandler.instance = self
+    end
+
+    def pre_processor(packet, sending)
+      data = nil
+      if sending
+        data = MultiJson.dump(packet)
+      else
+        data = MultiJson.load(packet)
+      end
+
+      return data
+    end
+
+    def receive(client_id, packet)
+      _packet = pre_processor(packet, false)
+    end
+
+    def transmit(client_id, data)
+      _packet = pre_processor(data, true)
+    end
+
+    def self.instance
+      @instance
+    end
+
+    def self.instance=(_instance)
+      @instance = _instance
+    end
+  end
+end

data/lib/gameoverseer/server/renet_server.rb

@@ -1,84 +1,126 @@
-module GameOverseer
-  class ENetServer
-    include Celluloid
-
-    def initialize(host, port)
-      GameOverseer::Console.log("Server> Started on: #{host}:#{port}.")
-      GameOverseer::Services.enable
-      GameOverseer::ENetServer.instance = self
-
-      @message_manager = GameOverseer::MessageManager.instance
-      @channel_manager = GameOverseer::ChannelManager.instance
-      @client_manager = GameOverseer::ClientManager.instance
-
-      @server = ENet::Server.new(port, 4, 4, 0, 0) # Port, max clients, channels, download bandwidth, upload bandwith
-      @server.use_compression(true)
-
-      @server.on_connection(method(:on_connect))
-      @server.on_packet_receive(method(:on_packet))
-      @server.on_disconnection(method(:on_disconnect))
-
-      async.run
-    end
-
-    def run
-      loop do
-        @server.update(1000)
-      end
-    end
-
-    def on_packet(client_id, data, channel)
-      p "Packet: #{client_id}-#{data}-#{channel}"
-      handle_connection(client_id, data, channel)
-    end
-
-    def on_connect(client_id, ip_address)
-      p "Connect: #{client_id}-#{ip_address}"
-      @client_manager.add(client_id, ip_address)
-    end
-
-    def on_disconnect(client_id)
-      p "Disconnect: #{client_id}"
-      @client_manager.remove(client_id)
-    end
-
-    # send message to a specific client
-    def transmit(client_id, message, reliable = false, channel = ChannelManager::CHAT)
-      @server.send_packet(client_id, message, reliable, channel)
-    end
-
-    # send message to all connected clients
-    def broadcast(message, reliable = false, channel = ChannelManager::CHAT)
-      @server.broadcast_packet(message, reliable, channel)
-    end
-
-    def process_data(data, client_id)
-      GameOverseer::InputHandler.process_data(data, client_id)
-    end
-
-    def handle_connection(client_id, data, channel)
-      begin
-        data = MultiJson.load(data)
-        process_data(data, client_id)
-      rescue MultiJson::ParseError => e
-        transmit(client_id, " \"channel\": \"__UNDEFINED__\", \"mode\": \"__UNDEFINED__\", \"data\": {\"code\": 400, \"message\": \"Invalid JSON received.\"}}", true, ChannelManager::FAULT)
-        GameOverseer::Console.log("Server> Parse error: '#{e.to_s}'. Bad data: '#{data}' received from client.")
-      end
-    end
-
-    def self.instance
-      @instance
-    end
-
-    def self.instance=(_instance)
-      @instance = _instance
-    end
-  end
-
-  class ENetServerRunner
-    attr_reader :supervisor
-    def start(host, port)
-      @supervisor = GameOverseer::ENetServer.new(host, port)
-    end
-  end
-end
+module GameOverseer
+
+  # GameOverseers' connection to the world
+  #
+  # This server uses the renet library, which is C bindings for the Enet networking library
+  class ENetServer
+    # @param host [String] host or ip for the server to run on
+    # @param port [Integer] port for the server to run on
+    # @param max_clients [Integer] max number of clients that can be connected at one time
+    # @param channels [Integer] number of channels (See Enet documentation)
+    # @param download_bandwidth [Integer] max bandwidth for downloading per-second (0 is unlimited)
+    # @param upload_bandwidth [Integer] max bandwidth for uploading per-second (0 is unlimited)
+    # @return [Thread]
+    def initialize(host, port, packet_handler, encryption_handler, max_clients = 4, channels = 4, download_bandwidth = 0, upload_bandwidth = 0)
+      GameOverseer::Console.log("Server> Started on: #{host}:#{port}.")
+      GameOverseer::Services.enable
+      GameOverseer::ENetServer.instance = self
+
+      @message_manager = GameOverseer::MessageManager.instance
+      @channel_manager = GameOverseer::ChannelManager.instance
+      @client_manager = GameOverseer::ClientManager.instance
+      @packet_handler = packet_handler.new
+      @encryption_handler = encryption_handler.instance if encryption_handler
+
+      @server = ENet::Server.new(port, max_clients, channels, download_bandwidth, upload_bandwidth) # Port, max clients, channels, download bandwidth, upload bandwith
+      @server.use_compression(true)
+      @terminate = false
+
+      @server.on_connection(method(:on_connect))
+      @server.on_packet_receive(method(:on_packet))
+      @server.on_disconnection(method(:on_disconnect))
+
+      run
+    end
+
+    # Runs the server in a Thread,, in a loop, calling update on the server.
+    #
+    # @return [Thread]
+    def run
+      Thread.new {
+        loop do
+          @server.update(1000)
+          break if @terminate
+        end
+      }
+    end
+
+    # Called when a packet is received
+    # @param client_id [Integer] ID of client
+    # @param data [String] data client sent
+    # @param channel [Integer] channel that this was sent to
+    def on_packet(client_id, data, channel)
+      handle_connection(client_id, data, channel)
+    end
+
+    # callled when a client connects
+    # @param client_id [Integer] ID of client
+    # @param ip_address [String] address of client
+    def on_connect(client_id, ip_address)
+      @client_manager.add(client_id, ip_address)
+    end
+
+    # callled when a client disconnects
+    # @param client_id [Integer] ID of client
+    def on_disconnect(client_id)
+      @client_manager.remove(client_id)
+    end
+
+    # send message to a specific client
+    # @param client_id [Integer] ID of client
+    # @param message [String] message to be sent to client
+    # @param reliable [Boolean] whether or not the packet is guaranteed to be received by the client
+    # @param channel [Integer] what channel to send on
+    def transmit(client_id, message, reliable = false, channel = ChannelManager::CHAT)
+      @server.send_packet(client_id, message, reliable, channel)
+    end
+
+    # send message to all connected clients
+    # @param message [String] message to be sent to clients
+    # @param reliable [Boolean] whether or not the packet is guaranteed to be received by the clients
+    # @param channel [Integer] what channel to send on
+    def broadcast(message, reliable = false, channel = ChannelManager::CHAT)
+      @server.broadcast_packet(message, reliable, channel)
+    end
+
+    # send data to the InputHandler for processing
+    # @param data [Hash]
+    # @param client_id [Integer] ID of client that sent the data
+    def process_data(client_id, data)
+      GameOverseer::InputHandler.process_data(client_id, data)
+    end
+
+    # Handles received packets from clients and sends them through the {PacketHandler} for pre-processing, then sends it on to {#process_data}
+    # @param client_id [Integer]
+    # @param data [String] data received from client
+    # @param channel [Integer] channel that this packet was sent along
+    def handle_connection(client_id, data, channel)
+      _data = @packet_handler.receive(client_id, data)
+      if _data
+        process_data(client_id, _data)
+      else
+        # TODO: Better error handling :D
+        transmit(client_id, '{"channel":"_error", "mode":"_error", "data":{"code":400, "message":"something went wrong, likely bad data!"}}', true, ChannelManager::FAULT)
+      end
+    end
+
+    def terminate
+      @terminate = true
+    end
+
+    def self.instance
+      @instance
+    end
+
+    def self.instance=(_instance)
+      @instance = _instance
+    end
+  end
+
+  class ENetServerRunner
+    attr_reader :supervisor
+    def start(host, port, packet_handler = PacketHandler, encryption_handler = nil)
+      @supervisor = GameOverseer::ENetServer.new(host, port, packet_handler, encryption_handler)
+    end
+  end
+end

data/lib/gameoverseer/services/service.rb

@@ -1,90 +1,111 @@
-module GameOverseer
-  class Service
-    attr_accessor :client_id
-    attr_reader :safe_methods
-
-    def self.inherited(subclass)
-      Services.register(subclass)
-      GameOverseer::Console.log "Service> added '#{subclass}' to Services::List."
-    end
-
-    def initialize
-      if defined?(self.setup)
-        @client_id = 0
-        @safe_methods = []
-        setup
-      end
-    end
-
-    # Called before 'enable' there should be no active code here, only setup variables.
-    def setup
-    end
-
-    # Called when services are first initialized, put active code here.
-    def enable
-    end
-
-    # Called when a message is recieved for this channel.
-    def process(data)
-    end
-
-    def version
-      # Please use the sematic versioning system,
-      # http://semver.org
-      #
-      # e.g.
-      # "1.5.9"
-      # (Major.Minor.Patch)
-      "0.0.0-default"
-    end
-
-    # Sets methods that are safe for `data_to_method` to call
-    def set_safe_methods(array)
-      raise "argument must be an array or strings or symbols" unless array.is_a?(Array)
-      @safe_methods = array
-    end
-
-    protected
-    def channel_manager
-      ChannelManager.instance
-    end
-
-    def message_manager
-      MessageManager.instance
-    end
-
-    def client_manager
-      ClientManager.instance
-    end
-
-    def data_to_method(data)
-      @safe_methods.each do |method|
-        if data['mode'] == method.to_s
-          self.send(data['mode'], data)
-        end
-      end
-    end
-
-    # Calls Proc immediately then every milliseconds, async.
-    def every(milliseconds, &block)
-      Thread.new do
-        loop do
-          block.call
-          sleep(milliseconds/1000.0)
-        end
-      end
-    end
-
-    # Calls Proc after milliseconds have passed, async.
-    def after(milliseconds, &block)
-      Thread.new do
-        sleep(milliseconds/1000.0)
-        block.call
-      end
-    end
-
-    def log(string, color = Gosu::Color::RED)
-      GameOverseer::Console.log_with_color(string, color)
-    end
-  end
-end
+module GameOverseer
+
+  # Services are at the heart on GameOverseer
+  #
+  # Subclass this class to implement a service
+  class Service
+    attr_accessor :client_id
+    attr_reader :safe_methods
+
+    # Adds the class that subclassed this class to a list for activation later
+    # @param subclass [Service]
+    def self.inherited(subclass)
+      Services.register(subclass)
+      GameOverseer::Console.log "Service> added '#{subclass}' to Services::List."
+    end
+
+    # This method should not be overridden, you should instead implement {#setup} with no arguments
+    def initialize
+      if defined?(self.setup)
+        @client_id = 0
+        @safe_methods = []
+        setup
+        enable
+      end
+    end
+
+    # Called before {#enable} there should be no active code here, only setup variables.
+    def setup
+    end
+
+    # Called when services are first initialized, put active code here, in a thread.
+    def enable
+    end
+
+    # Called when a message is recieved for this channel.
+    # @param data [Hash] The data from the packet
+    def process(data)
+    end
+
+    def version
+      # Please use the sematic versioning system,
+      # http://semver.org
+      #
+      # e.g.
+      # "1.5.9"
+      # (Major.Minor.Patch)
+      "0.0.0-default"
+    end
+
+    # Sets methods that are safe for {#data_to_method} to call
+    # @param array [Array] Array of strings or symbols that match a method in the service class
+    def set_safe_methods(array)
+      raise "argument must be an array of strings or symbols" unless array.is_a?(Array)
+      @safe_methods = array
+    end
+
+    # @return [ChannelManager] Active instance of ChannelManager
+    def channel_manager
+      ChannelManager.instance
+    end
+
+    # @return [MessageManager] Instance of MessageManager
+    def message_manager
+      MessageManager.instance
+    end
+
+    # @return [ClientManager] Current instance of ClientManager
+    def client_manager
+      ClientManager.instance
+    end
+
+    # Uses the 'mode' from a packet to call the method of the same name
+    # @param data [Hash] data from packet
+    def data_to_method(data)
+      @safe_methods.each do |method|
+        if data['mode'] == method.to_s
+          self.send(data['mode'], data)
+        end
+      end
+    end
+
+    # Calls Proc immediately then every milliseconds, async.
+    # @param milliseconds [Integer][Float] Time to wait before calling the block
+    # @param block [Proc]
+    def every(milliseconds, &block)
+      Thread.new do
+        loop do
+          block.call
+          sleep(milliseconds/1000.0)
+        end
+      end
+    end
+
+    # Calls Proc after milliseconds have passed, async.
+    # @param milliseconds [Integer][Float] Time to wait before calling the block
+    # @param block [Proc]
+    def after(milliseconds, &block)
+      Thread.new do
+        sleep(milliseconds/1000.0)
+        block.call
+      end
+    end
+
+    # String to be logged
+    # @param string [String] text to log
+    # @param color [Gosu::Color] color of text in console
+    def log(string, color = Gosu::Color::RED)
+      GameOverseer::Console.log_with_color(string, color)
+    end
+  end
+end