nova 0.0.2

data/lib/nova/starbound/server.rb

@@ -0,0 +1,182 @@
+require 'socket'
+
+module Nova
+  module Starbound
+
+    # A Starbound server.
+    #
+    # @todo Default proc.
+    class Server
+
+      # The options passed to the server on initialization.
+      #
+      # @return [Hash]
+      attr_reader :options
+
+      # The default options.
+      DEFAULT_OPTIONS = {
+        :type  => :tcp,
+        :host  => "127.0.0.1",
+        :port  => 2010,
+        :path  => "/tmp/sock"
+      }
+
+      # Whether or not to run.  Once this is set to false, the server
+      # stops listening for clients.
+      #
+      # @return [Boolean]
+      attr_accessor :run
+
+      # The list of active threads that are running.
+      #
+      # @return [Array<Thread>]
+      attr_reader :thread_list
+
+      # Initialize the server with the given options.  If the options
+      # has a +:protocol+ key, it is removed from the options and set
+      # as the protocol options.
+      #
+      # @param options [Hash]
+      # @option options [Symbol] :type the type of server.  Can be any
+      #   of +:tcp+ or +:unix+.  Defaults to +:tcp+.
+      # @option options [String] :host the host to bind to.  Defaults
+      #   to +"127.0.0.1"+.  Only used if +:type+ is +:tcp+.
+      # @option options [Numeric] :port the port to bind to.  Defaults
+      #   to +2010+.  Only used if +:type+ is +:tcp+.
+      # @option options [String] :path the path to the unix socket.
+      #   Only used if +:type+ is +:unix+.
+      def initialize(options = {})
+        @options = DEFAULT_OPTIONS.merge options
+        @protocol_options = (options.delete(:protocol) || {}).dup
+        @run = true
+        @thread_list = []
+      end
+
+      # How to handle the client.  Accepts a block, which is used in
+      # {#listen} when a client connects.  If no block is given, the
+      # a block is returned.
+      #
+      # @yieldparam protocol [Protocol] the protocol instance that is
+      #   used to handle the client.  By the time it is yielded, the
+      #   client has already done a handshake with the server.
+      # @return [Proc]
+      def with_client(&block)
+        if block_given?
+          @with_client = block
+        else
+          @with_client ||= proc {}
+        end
+      end
+
+      # Reads a ruby file in the instance of this server, so that it
+      # can build a {#with_client} block for it.
+      #
+      # @param file [String] the file to read from.
+      def read_client_file(file)
+        return unless file && File.exists?(file)
+
+        instance_eval File.open(file, "r").read, file, 1
+      end
+
+      # Listen for clients.  Calls {#handle_client} when a client is
+      # found.
+      #
+      # @return [void]
+      def listen
+        Nova.logger.info { "Server started." }
+        while run
+          next unless IO.select [server], nil, nil, 1
+          thread_list << Thread.start(server.accept) do |client|
+            Nova.logger.info { "Client accepted." }
+
+            handle_client client
+
+            thread_list.delete(Thread.current)
+            Nova.logger.info { "Client disconnected." }
+          end
+        end
+      end
+
+      # Shuts down the server.
+      #
+      # @return [void]
+      def shutdown
+        puts "shutting down"
+        @run = false
+        thread_list.each do |thread|
+          thread.raise ExitError
+        end
+      end
+
+      # Returns the server type that this server should run as,
+      # already instantized.
+      #
+      # @return [Object]
+      def server
+        @_server ||= case options.fetch(:type, :tcp)
+        when :tcp
+          TCPServer.new options.fetch(:host, "127.0.0.1"),
+            options.fetch(:port, 2010)
+        when :unix
+          UNIXServer.new options.fetch(:path)
+        when :pipe
+          FakeServer.new options.fetch(:pipe)
+        end
+      end
+
+      private
+
+      # Handles a client after they connect. Creates a {Protocol},
+      # initiates the handshake, and calls {#with_client} to handle
+      # the protocol afterwards.
+      #
+      # @param client [IO] the client to handle.
+      # @return [void]
+      def handle_client(client)
+      protocol = Protocol.new(
+        @protocol_options.merge(:type => :server))
+
+      protocol.socket = client
+      protocol.handshake
+
+      with_client.call(protocol)
+
+      protocol.close(false)
+
+      rescue ExitError => e
+        Nova.logger.error { "Closing while client is connected.  Notifying..." }
+        if protocol
+          protocol.close(:shutdown)
+        else
+          client.close unless client.closed?
+        end
+      rescue RemoteCloseError
+      rescue ProtocolError => e
+        Nova.logger.error { "Client failed: #{e.message} #{e.backtrace.join("\n")}" }
+        client.close unless client.closed?
+      ensure
+        protocol.close(false)
+      end
+
+      # A fake server that wraps a pipe.
+      class FakeServer
+
+        # Initialize the fake server with the pipe.
+        def initialize(pipe)
+          @pipe = pipe
+        end
+
+        # Does nothing.
+        def listen(_); end
+
+        # Returns the pipe.
+        #
+        # @return [Object]
+        def accept
+          @pipe
+        end
+      end
+
+    end
+  end
+end

data/lib/nova/version.rb

@@ -0,0 +1,5 @@
+module Nova
+
+  # The version of Nova.
+  VERSION = "0.0.2".freeze
+end

data/spec/constructor_spec.rb

@@ -0,0 +1,20 @@
+describe Nova::Constructor do
+
+  it "should create stars from types" do
+    d = described_class.new(non_existant_star: :some_name) {}
+
+    expect {
+      d.modify_or_create
+    }.to raise_error(Nova::NoStarError)
+
+    d = described_class.new(star: :some_name) do
+      def some_method; 5; end
+    end
+
+    klass = d.modify_or_create
+    expect(klass.as).to be :some_name
+    expect(klass.instance_methods).to include(:some_method)
+    expect(klass.new.some_method).to be 5
+  end
+
+end

data/spec/local_spec.rb

@@ -0,0 +1,26 @@
+=begin
+
+require 'nova/remote/local'
+
+describe Nova::Remote::Local do
+
+  before :each do
+    Nova::Star.remote = Nova::Remote::Local
+  end
+
+  context "platforms" do
+
+    it "should determine platforms" do
+      expect(Nova::Star.new.platform).to have_at_least(3).items
+    end
+  end
+
+  context "commands" do
+    it "should execute the command" do
+      star = Nova::Star.new
+      expect(star.line("echo", "hello").pass.stdout).to eq("hello\n")
+    end
+  end
+end
+
+=end

data/spec/nova_spec.rb

@@ -0,0 +1,7 @@
+describe Nova do
+
+  it "has a logger" do
+    expect(Nova.logger).to be_a Logger
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+require 'coveralls'
+
+Coveralls.wear!
+
+module NovaHelper
+
+  def self.build_packet(type = 0, body = "hello world", data = { :packet_id => 1, :nonce => "" })
+    Nova::Starbound::Protocol::Packet.build(type, body, data)
+  end
+
+  def self.packet_from_socket(sock)
+    Nova::Starbound::Protocol::Packet.from_socket(sock)
+  end
+
+  def self.build_response(type, body, pack)
+    Nova::Starbound::Protocol::Packet.build_response(type, body, pack, :nonce => "")
+  end
+
+end

data/spec/star/some_type.rb

@@ -0,0 +1,27 @@
+class SomeType < Nova::Star
+  star_type :some_type
+
+  metadata do
+    require_options :hello
+  end
+
+  feature :some_feature do
+    on :some_event do; end
+
+    on :enable do
+      tag :enable
+
+      3
+    end
+
+    on :disable do
+      tag :disable
+
+      4
+    end
+  end
+
+  on :foo do; 1; end
+
+  on :bar, requires: :an_option do; 2; end
+end

data/spec/star_spec.rb

@@ -0,0 +1,107 @@
+require_relative 'star/some_type'
+
+describe Nova::Star do
+
+  before :each do
+    Nova::Star.remote = Nova::Remote::Fake
+  end
+
+  context "management" do
+    it "handles types" do
+      expect(Nova::Star.types).to eq(star: Nova::Star, some_type: SomeType)
+    end
+
+    it "has pretty inspect" do
+      expect(Nova::Star.inspect).to eq("Nova::Star")
+      expect(SomeType.inspect).to eq("Nova::Star/SomeType")
+    end
+
+    it "has a default remote" do
+      expect(SomeType.remote).to be(Nova::Remote::Fake)
+    end
+  end
+
+  context "options manager" do
+    it "validates options" do
+      expect {
+        star = SomeType.new
+        star.options = {}
+      }.to raise_error(Nova::InvalidOptionsError)
+    end
+  end
+
+  context "event manager" do
+    it "manages events" do
+      event = Nova::Common::EventHandler::Event
+      [SomeType, SomeType.new].each do |type|
+        expect(type.events).to be_instance_of Set
+        expect(type.has_event?(:foo)).to be_instance_of event
+        expect(type.has_event?(:not_foo)).to be_nil
+        expect(type.has_event?(:bar)).to be_instance_of event
+
+        expect(type.has_event_with_options?(:foo)).to be_instance_of event
+        expect(type.has_event_with_options?(:bar)).to be_nil
+        expect(type.has_event_with_options?(:bar, an_option: true)).to be_instance_of event
+      end
+    end
+
+    it "runs events" do
+      star = SomeType.new
+      context = double(:context)
+      star.bind! context
+
+      expect(star.run!(:foo)).to be 1
+
+      expect {
+        star.run!(:bar)
+      }.to raise_error(Nova::NoEventError)
+      expect(star.run(:bar)).to be_instance_of Nova::NoEventError
+      expect(star.run!(:bar, an_option: true)).to be 2
+
+      expect {
+        star.run! :not_an_event
+      }.to raise_error(Nova::NoEventError)
+      expect(star.run(:not_an_event)).to be_instance_of Nova::NoEventError
+    end
+  end
+
+  context "features" do
+    it "supports defined features" do
+      expect(SomeType.supports?(:some_feature)).to be true
+      expect(SomeType.supports?(:another_feature)).to be false
+    end
+
+    it "gives fake features" do
+      star = SomeType.new
+      expect(star.feature(:some_feature)).to_not be_fake
+      expect(star.feature(:another_feature)).to be_fake
+
+      expect(star.supports?(:some_feature)).to be true
+      expect(star.supports?(:another_feature)).to be false
+    end
+
+    it "runs enable and disable events" do
+      star = SomeType.new
+      context = stub(:context)
+      context.should_receive(:tag).with(:enable)
+      expect(star.feature(:some_feature).bind(context).enable!).to be 3
+
+      context = stub(:context)
+      context.should_receive(:tag).with(:disable)
+      expect(star.feature(:some_feature).bind(context).disable!).to be 4
+    end
+  end
+
+  context "platforms" do
+    it "displays correct platforms" do
+      expect(SomeType.new.remote.platform.types).to eq([])
+    end
+  end
+
+  context "commands" do
+    it "gives a command line" do
+      star = SomeType.new
+      expect(star.remote.command.line("something", "arguments")).to be_instance_of Command::Runner
+    end
+  end
+end

data/spec/starbound/encryptor_spec.rb

@@ -0,0 +1,33 @@
+describe Nova::Starbound::Encryptor do
+
+  it "is not available" do
+    expect(described_class).to_not be_available
+
+    expect {
+      subject
+    }.to raise_error NotImplementedError
+  end
+
+  it "is not plaintext" do
+    expect(described_class).to_not be_plaintext
+  end
+
+  it "sorts the encryptors" do
+    expect(described_class.sorted_encryptors).to have(3).items
+    expect(described_class.sorted_encryptors.first.preference).to be > described_class.sorted_encryptors.last.preference
+  end
+
+  context "encrypting" do
+    before(:each) { described_class.stub(:available?).and_return(true) }
+
+    it "raises errors" do
+      [:encrypt, :decrypt, :private_key!, :public_key,
+        :other_public_key=].each do |m|
+
+        expect(subject).to respond_to m
+
+        expect { subject.send(m) }.to raise_error NotImplementedError
+      end
+    end
+  end
+end

data/spec/starbound/openssl_encryptor_spec.rb

@@ -0,0 +1,80 @@
+describe Nova::Starbound::Encryptors::OpenSSL do
+
+  it "is available" do
+    expect(described_class).to be_available
+  end
+
+  context "handling keys" do
+    subject { described_class.new }
+    its(:private_key!) { should be_instance_of ::OpenSSL::PKey::RSA }
+
+    it "has a public key" do
+      subject.private_key! # initialize the private key
+      expect(subject.public_key).to be_a String
+    end
+  end
+
+  before :each do
+    @packet = NovaHelper.build_packet
+  end
+
+  it "encrypts a packet successfully" do
+
+    subject.private_key!
+    public_key = subject.public_key
+
+    secret = ::OpenSSL::Random.random_bytes(4096 / 16)
+    encrypted_secret = ::OpenSSL::PKey::RSA.new(public_key).public_encrypt(secret)
+
+    subject.other_public_key = encrypted_secret
+
+    expect(subject.options[:shared_secret]).to eq secret
+    encrypted = nil
+
+    expect {
+      encrypted = subject.encrypt(@packet)
+    }.to_not raise_error
+
+    expect(encrypted).to be_instance_of Nova::Starbound::Protocol::Packet
+    expect(encrypted.body.bytesize).to eq encrypted[:size]
+  end
+
+  it "decrypts a packet successfully" do
+
+    subject.private_key!
+
+    public_key = ::OpenSSL::PKey::RSA.new(4096)
+    subject.other_public_key = public_key.public_key.to_der
+    encrypted_secret = subject.public_key
+
+    secret = public_key.private_decrypt(encrypted_secret)
+    expect(secret).to eq subject.options[:shared_secret]
+
+    encrypted = subject.encrypt(@packet)
+    decrypted = nil
+
+    expect {
+      decrypted = subject.decrypt(encrypted)
+    }.to_not raise_error
+
+    expect(decrypted.body).to eq @packet.body
+  end
+
+  it "raises an error on non-matching hashes" do
+    subject.private_key!
+    public_key = subject.public_key
+
+    secret = ::OpenSSL::Random.random_bytes(4096 / 16)
+    encrypted_secret = ::OpenSSL::PKey::RSA.new(public_key).public_encrypt(secret)
+
+    subject.other_public_key = encrypted_secret
+
+    encrypted = subject.encrypt(@packet)
+    encrypted.body.replace("\x00" * encrypted.size)
+
+    expect {
+      subject.decrypt(encrypted)
+    }.to raise_error(Nova::Starbound::EncryptorError)
+  end
+
+end