nova 0.0.2

data/lib/nova/remote.rb

@@ -0,0 +1,10 @@
+module Nova
+  module Remote
+
+    autoload :Common, "nova/remote/common"
+    autoload :Fake, "nova/remote/fake"
+    autoload :Local, "nova/remote/local"
+    autoload :SSH, "nova/remote/ssh"
+
+  end
+end

data/lib/nova/remote/fake.rb

@@ -0,0 +1,51 @@
+require 'nova/remote/fake/commands'
+require 'nova/remote/fake/file_system'
+require 'nova/remote/fake/operating_system'
+require 'nova/remote/fake/platform'
+
+module Nova
+  module Remote
+
+    # This is a fake remote.  It does nothing.  Really.  You can trust
+    # me.
+    class Fake
+
+      # Returns a platform instance.  Caches the instance across
+      # method calls.
+      #
+      # @see Platform
+      # @return [Platform]
+      def platform
+        @_platform ||= Platform.new
+      end
+
+      # Returns a command instance.  Caches the instance across method
+      # calls.
+      #
+      # @see Commands
+      # @return [Commands]
+      def command
+        @_command ||= Commands.new
+      end
+
+      # Returns an operating system instance.  Caches the instance
+      # across method calls.
+      #
+      # @see OperatingSystem
+      # @return [OperatingSystem]
+      def operating_system
+        @_operating_system ||= OperatingSystem.new
+      end
+
+      # Returns a file system instance.  Caches the instance across
+      # method calls.
+      #
+      # @see FileSystem
+      # @return [FileSystem]
+      def file_system
+        @_file_system ||= FileSystem.new
+      end
+
+    end
+  end
+end

data/lib/nova/remote/fake/commands.rb

@@ -0,0 +1,44 @@
+require 'command/runner'
+
+module Nova
+  module Remote
+    class Fake
+
+      # Manages running commands.
+      #
+      # @abstract
+      class Commands
+
+        # Creates a CommandLine with its default runner.
+        #
+        # @abstract
+        # @note Does nothing.  Since we're a fake remote, we'll
+        #   overwrite the backend with a fake one.
+        # @see https://github.com/redjazz96/command-runner
+        # @param command [String] the command to run.
+        # @param arguments [String] the arguments to be passed to the
+        #   command.
+        # @return [Command::Runner] the runner.
+        def line(command, arguments = "", options = {})
+          options.merge! :logger => Nova.logger
+          c = Command::Runner.new(command, arguments, options)
+          c.backend = Command::Runner::Backends::Fake.new
+          c
+        end
+
+        # Checks to see if the command exists.
+        #
+        # @abstract
+        # @note Does nothing.  Always returns false since this is the
+        #   fake remote.
+        # @param command [String] the command to check the existance
+        #   of.
+        # @return [Boolean]
+        def command_exists?(command)
+          false
+        end
+
+      end
+    end
+  end
+end

data/lib/nova/remote/fake/file_system.rb

@@ -0,0 +1,76 @@
+module Nova
+  module Remote
+    class Fake
+
+      # Handles filesystem stuff, like downloading files and
+      # decompressing ifles.
+      class FileSystem
+        # Grabs the file from file and puts it somewhere else.  If
+        # it's a local file (checked by #file_exists?), it just copies
+        # it.  If it's not, it opens a connection to the server to try
+        # to download the file.
+        #
+        # @note Does nothing.
+        # @abstract
+        # @param file [String] the file to download.  Can be a path
+        #   name or URI.
+        # @param options [Hash{Symbol => Object}] the options for
+        #   grabbing the files.
+        # @option options [String] :to the file to save to.  If this
+        #   doesn't exist, it's guessed from the file name.
+        # @option options [Boolean, String] :decompress the file after
+        #   saving it.  If it's a string, the decompressed file is
+        #   extracted there.  Otherwise, it's guessed from the
+        #   filename.
+        # @return [Boolean]
+        def grab_file(file, options = {})
+          false
+        end
+
+        # Checks to see if the file exists on the file system.
+        #
+        # @note Does nothing.
+        # @abstract
+        # @param file [String] the file to check.
+        # @return [Boolean]
+        def file_exists?(file)
+          false
+        end
+
+        # Decompress the given file, to the given directory.
+        #
+        # @note Does nothing.
+        # @abstract
+        # @param file [String] the file to decompress.
+        # @param to [String] the directory to decompress to.
+        # @return [void]
+        def decompress_file(file, to)
+        end
+
+        private
+
+        # Untars the given file.
+        #
+        # @note Does nothing.
+        # @abstract
+        # @return [void]
+        def untar_file(f, to)
+        end
+
+        # Unzips the file.
+        #
+        # @note Does nothing.
+        # @abstract
+        def unzip_file(f, to)
+        end
+
+        # Unrars the given file.
+        #
+        # @note Does nothing.
+        # @abstract
+        def unrar_file(f, to)
+        end
+      end
+    end
+  end
+end

data/lib/nova/remote/fake/operating_system.rb

@@ -0,0 +1,52 @@
+module Nova
+  module Remote
+    class Fake
+
+      # Handles operating system tasks like installing packages or
+      # creating users.
+      #
+      # @abstract
+      class OperatingSystem
+
+        # Creates a user with the given name and options.
+        #
+        # @abstract
+        # @note Does nothing.  As such, it always returns false.
+        # @param name [String, Symbol] the name of the user.
+        # @param options [Hash<Symbol, Object>] the options for the
+        #   user.
+        # @option options [Boolean] :system whether or not the user is
+        #   a system user.  Defaults to +false+.
+        # @option options [Boolean] :nologin whether or not the user
+        #   is able to log in.  Defaults to +false+.
+        # @option options [String] :password the user's password.
+        #   Defaults to +nil+.
+        # @return [Boolean] whether or not the user creation was
+        #   successful.
+        def create_user(name, options = {})
+          false
+        end
+
+        # Installs packages for the corresponding operating system.
+        #
+        # @abstract
+        # @note Does nothing.  As such, it always returns false.
+        # @param packages [Hash<Symbol, Array<String>>] the symbol is
+        #   the name of the OS, the array is the packages to install
+        #   for that OS.
+        # @option packages [Array<String>] :ubuntu the packages to
+        #   install for debian-based OSs (Ubuntu, Debian, Mint).
+        # @option packages [Array<String>] :red_hat the packages to
+        #   install for red hat-based OSs (REHL, Fedora, CentOS).
+        # @option packages [Array<String>] :arch the packages to
+        #   install for arch.
+        # @return [Boolean] whether or not the package installation
+        #   was successful.
+        def install_packages(packages)
+          false
+        end
+
+      end
+    end
+  end
+end

data/lib/nova/remote/fake/platform.rb

@@ -0,0 +1,89 @@
+module Nova
+  module Remote
+    class Fake
+
+      # The platform information.
+      #
+      # @abstract
+      class Platform
+
+        # The list of platforms that this platform matches.
+        #
+        # @abstract
+        # @note Since this is a Fake remote, it defaults to none.
+        # @return [Array<Symbol>] the platform list.
+        def types
+          []
+        end
+
+        # Tries to determine the platform version, but if it can't, it
+        # defaults to nil.
+        #
+        # @abstract
+        # @note Since this is a Fake remote, it defaults to nil.
+        # @return [nil, String]
+        def version
+          nil
+        end
+
+        # True for linux? or osx?
+        # @api public
+        # @see OS#posix?
+        # @return [Boolean]
+        def posix?; false; end
+
+        # True if the OS is based on the linux kernel, false for
+        # windows, OSX, or cygwin.
+        # @api public
+        # @see OS#linux?
+        # @return [Boolean]
+        def linux?; false; end
+
+        # True if the OS is OSX, false for linux, windows, or cygwin.
+        # @see OS#osx?
+        # @api public
+        # @return [Boolean]
+        def osx?; false; end
+
+        # True if the OS is Windows or jruby?, false for linux or
+        # windows.
+        # @api public
+        # @see OS#windows?
+        # @return [Boolean]
+        def windows?; false; end
+
+        # True if the ruby is based on the JRuby implementation.
+        # @api public
+        # @see OS#jruby?
+        # @return [Boolean]
+        def jruby?; false; end
+
+        # True if the ruby is based on the Iron Ruby implementation.
+        # @api public
+        # @see OS#iron_ruby?
+        # @return [Boolean]
+        def iron_ruby?; false; end
+
+        # True if ruby is running with cygwin.
+        # @api public
+        # @see OS#cygwin?
+        # @return [Boolean]
+        def cygwin?; false; end
+
+        # The number of bits the processor can handle.
+        # @api public
+        # @see OS#bits
+        # @return [Numeric]
+        def bits; 32; end
+
+        # Where /dev/null is located on the computer (/dev/null for
+        # anything but Windows, NUL for Windows).
+        # @api public
+        # @see OS#dev_null
+        # @return [String]
+        def dev_null; "/dev/null"; end
+
+      end
+    end
+  end
+end

data/lib/nova/star.rb

@@ -0,0 +1,25 @@
+require 'nova/common'
+require 'nova/remote/fake'
+
+module Nova
+
+  # This binds together all of our default includes.
+  class Star
+
+    include Common::EventHandler
+    include Common::Metadata
+    include Common::StarManagement
+    include Common::Features
+
+    star_type :star
+
+    # @!parse include Common::EventHandler::InstanceMethods
+    # @!parse extend Common::EventHandler::ClassMethods
+    # @!parse include Common::Metadata::InstanceMethods
+    # @!parse extend Common::Metadata::ClassMethods
+    # @!parse include Common::StarManagement::InstanceMethods
+    # @!parse extend Common::StarManagement::ClassMethods
+    # @!parse include Common::Features::InstanceMethods
+    # @!parse extend Common::Features::ClassMethods
+  end
+end

data/lib/nova/starbound.rb

@@ -0,0 +1,14 @@
+module Nova
+
+  # The networking module of Nova.  It's meant to be fast,
+  # secure, and cross-platform compatible.
+  module Starbound
+
+    autoload :Protocol, "nova/starbound/protocol"
+    autoload :Encryptor, "nova/starbound/encryptor"
+    autoload :Encryptors, "nova/starbound/encryptors"
+    autoload :Client, "nova/starbound/client"
+    autoload :Server, "nova/starbound/server"
+
+  end
+end

data/lib/nova/starbound/client.rb

@@ -0,0 +1,59 @@
+require 'socket'
+
+module Nova
+  module Starbound
+
+    # A client for Nova.
+    class Client
+
+      # The options that were passed to the client on initialization.
+      #
+      # @return [Hash]
+      attr_reader :options
+
+      # The underlying protocol that powers this client.
+      #
+      # @return [Protocol]
+      attr_reader :protocol
+
+      # The default options when dealing with this class.
+      DEFAULT_OPTIONS = {
+        :type => :tcp,
+        :host => "127.0.0.1",
+        :port => 2010
+      }
+
+      # Initialize with the given options.
+      #
+      # @param options [Hash]
+      def initialize(options = {})
+        @options = DEFAULT_OPTIONS.merge(options)
+        @protocol_options = (@options.delete(:protocol) || {}).dup
+        @protocol = Protocol.new @protocol_options.merge(:type => :client)
+      end
+
+      # Do the handshake with the server.
+      #
+      # @return [void]
+      def handshake
+        @protocol.socket = socket
+        @protocol.handshake
+      end
+
+      # Create the socket.
+      #
+      # @return [Object]
+      def socket
+        @_socket ||= case options[:type]
+        when :tcp
+          TCPSocket.new(options[:host], options[:port])
+        when :unix
+          UNIXSocket.new(options[:path])
+        when :pipe
+          options[:pipe]
+        end
+      end
+
+    end
+  end
+end

data/lib/nova/starbound/encryptor.rb

@@ -0,0 +1,134 @@
+module Nova
+  module Starbound
+
+    # An encryptor is used to encrypt the data in the exchange for the
+    # starbound protocol.
+    #
+    # @abstract
+    class Encryptor
+
+      # @overload encryptor_name(name)
+      #   Sets the encryptor's name.  Used for negotiation of
+      #   encryption protocols.
+      #
+      #   @param name [String] the name of the encryptor.
+      #   @return [void]
+      # @overload encryptor_name
+      #   Gets the encryptor's name.
+      #
+      #   @return [String]
+      def self.encryptor_name(name = nil)
+        if name
+          @encryptor_name = name
+        else
+          @encryptor_name
+        end
+      end
+
+      # Registers a subclass with the Encryptor class for use with the
+      # protocol.
+      #
+      # @param preference [Numeric] a number that is used to sort the
+      #   encryptors by preference.
+      # @return [void]
+      def self.register!(preference)
+        @preference = preference
+        Encryptor.encryptors.push(self)
+      end
+
+      class << self
+
+        # The preference for this encryptor.  Used to sort the
+        # encryptors.
+        #
+        # @return [Numeric]
+        attr_reader :preference
+      end
+
+      # The encryptors that are defined.
+      #
+      # @return [Array<Encryptor>]
+      def self.encryptors
+        @encryptors ||= []
+      end
+
+      # The encryptors, sorted by preference.
+      #
+      # @return [Array<Encryptor>]
+      def self.sorted_encryptors
+        encryptors.sort do |a, b|
+          b.preference <=> a.preference
+        end
+      end
+
+      # Whether or not this encryptor is available.  Defaults to
+      # false.
+      #
+      # @return [Boolean]
+      def self.available?
+        false
+      end
+
+      # Returns whether or not this is a plaintext encryptor, or one
+      # equivalent.  Defaults to false, so most encryptors shouldn't
+      # have to overwrite this.
+      #
+      # @return [Boolean]
+      def self.plaintext?
+        false
+      end
+
+      # The options.  These are mostly use internally.
+      #
+      # @return [Hash<Symbol, Object>]
+      attr_reader :options
+
+      # Initialize the encryptor.
+      #
+      # @raise [NotImplementedError] if {.available?} returns false.
+      def initialize
+        @options = {}
+
+        unless self.class.available?
+          raise NotImplementedError,
+            "#{self.class.encryptor_name} is not avialable!"
+        end
+      end
+
+      # @!method encrypt(packet)
+      #   Encrypts the given packet with the encryptor.
+      #
+      #   @param packet [Packet] the packet to encrypt.
+      #   @return [Packet] the encrypted packet.
+      # @!method decrypt(packet)
+      #   Decrypts the given packet with the encryptor.
+      #
+      #   @param packet [Packet] the packet to decrypt.
+      #   @return [Packet] the decrypted packet.
+      # @!method private_key!
+      #   Generates the private key for this encryptor.
+      #
+      #   @return [void]
+      # @!method public_key
+      #   Returns the public key to be sent to the other remote.
+      #
+      #   @return [String]
+      # @!method other_public_key=(pub_key)
+      #   Sets the public key of the other remote.
+      #
+      #   @param pub_key [String] the public key of the remote.
+      #   @return [void]
+      [:encrypt, :decrypt, :private_key!, :public_key,
+        :other_public_key=].each do |m|
+
+        define_method(m) do |*args|
+          raise NotImplementedError,
+            "tried to call #{m} on #{self.class.encryptor_name}"
+        end
+      end
+
+    end
+  end
+end
+
+require 'nova/starbound/encryptors'