nova 0.0.2

data/lib/nova/common/star_management.rb

@@ -0,0 +1,164 @@
+module Nova
+  module Common
+
+    # Manages types of stars.  Adds a +star_type+ method to subclasses
+    # to add it to the type list.
+    module StarManagement
+
+      # Class methods.
+      module ClassMethods
+
+        # All of the types of stars.  Should be a key-value pair, with
+        # the key being the name, and the value being the class.
+        #
+        # @return [Hash{Symbol => Class}]
+        def types
+          @@types ||= {}
+        end
+
+        # When the star is subclassed, add the subclass
+        # automatically to the star type list, unless it doesn't
+        # have a proper name.
+        #
+        # @api private
+        def inherited(klass)
+          return unless klass.name
+
+          type = klass.name.gsub(/([A-Z])/) { |a| "_#{a.downcase}" }.gsub("::", "/")[1..-1].intern
+          klass.star_type(type)
+        end
+
+        # Adds the Star to the type list.
+        #
+        # @param name [Symbol] the name of the star.
+        # @return [self]
+        def star_type(name)
+          types.delete_if { |_, v| v == self }
+          types[name] = self
+          self.type   = name
+          stars[name] = {}
+          self
+        end
+
+        # All of the stars that have been defined.  These are
+        # different from star types because they contain information
+        # such as events.
+        #
+        # @return [Hash{Symbol => Class}]
+        def stars
+          @@stars ||= {}
+        end
+
+        # An accessor for {#stars}.
+        #
+        # @param star_name [Symbol]
+        # @return [Hash, Class]
+        def [](star_name)
+          stars[star_name]
+        end
+
+        # Cleans up the inspect a little bit.
+        #
+        # @return [String]
+        def inspect
+          @_inspect ||=
+            ancestors.take_while { |x| x <= Star }.map(&:name).reverse.join("/").gsub(/\/\z/, "." + as.to_s)
+        end
+
+        # Just a way to write it; syntaxic sugar.  It returns what
+        # was passed.
+        #
+        # @example
+        #   Nova::Star/Type.something
+        # @param other_class [Class]
+        # @return [Class] other_class.
+        def /(other_class)
+          other_class
+        end
+
+        # The remote to use, by default, for stars.
+        #
+        # @!parse attr_reader :remote
+        # @return [Module]
+        def remote
+          @remote ||= Remote::Fake
+        end
+
+        attr_writer :remote
+
+        # The name of the star.
+        #
+        # @return [Symbol]
+        attr_accessor :as
+
+        # The type of the star.
+        #
+        # @return [Symbol]
+        attr_accessor :type
+
+        # Retrieves the star with the given name.
+        #
+        # @example
+        #   Nova::Star/Type.klass
+        # @return [Class]
+        def method_missing(method, *args, &block)
+          if (stars.key?(method) || stars[type].key?(method)) && args.length == 0
+            stars[method] || stars[type][method]
+          else
+            super
+          end
+        end
+      end
+
+      # Instance methods.
+      module InstanceMethods
+
+        # Checks for the correct platforms in initialization.  If
+        # it's not on the right platform, raises an error.
+        #
+        # @raise [NoPlatformError] if it's not available on the
+        #   platform.
+        def initialize(remote = nil)
+          @remote = (remote || self.remote).new
+          super(@remote)
+        end
+
+        # Cleans up the inspect a little bit.
+        #
+        # @return [String]
+        def inspect
+          @_inspect ||= begin
+            "#<" <<
+              self.class.inspect <<
+              (":0x%014x" % object_id) <<
+            ">"
+          end
+        end
+
+        # The remote this star is using.  Can be set locally, but
+        # uses the global remote by default.
+        #
+        # @see ClassMethods#remote
+        # @!parse attr_reader :remote
+        # @return [Module]
+        def remote
+          @remote || self.class.remote
+        end
+
+        attr_writer :remote
+
+      end
+
+      # Called when {StarManagement} is included.  Extends what included
+      # it by {ClassMethods}, and includes {InstanceMethods}.
+      #
+      # @param receiver [Object]
+      # @return [void]
+      # @api private
+      def self.included(receiver)
+        receiver.send :include, InstanceMethods
+        receiver.extend         ClassMethods
+      end
+    end
+  end
+end

data/lib/nova/constructor.rb

@@ -0,0 +1,84 @@
+module Nova
+
+  # Creates a star from a {Nova.create} call.
+  class Constructor
+
+    # Initialize the constructor.
+    #
+    # @param options [Hash] the definition of the star.  It should
+    #   be a single key-value pair, with the first key being the
+    #   type of star, and the first value being the name of the
+    #   star.
+    # @yield for the construction of the new Star.
+    # @example
+    #   Constructor.new(some_star: :another_star) do
+    #     on :some_event do; end
+    #   end.create # => Nova::Star/SomeStar.another_star
+    def initialize(options, &block)
+      @options = options
+      @block = block
+    end
+
+    # Modifies an already existing star if it exists, or creates it
+    # if it doesn't.
+    #
+    # @raise [NoStarError] when the star type couldn't be found.
+    # @return [Class] a subclass of the star type.
+    def modify_or_create
+      star_type = Star.types[data[:type]]
+
+      raise NoStarError,
+        "Could not find star type #{data[:type]}." unless star_type
+
+      if Star.stars[data[:type]][data[:as]]
+        handle_existing
+      else
+        handle_new star_type
+      end
+    end
+
+
+    # Returns information about the star, like the type, the required
+    # platforms, and what it's named.
+    #
+    # @return [Hash<Symbol, Object>]
+    def data
+      @_data ||= {
+        :as   => @options.values.first,
+        :type => @options.keys.first
+      }
+    end
+
+    private
+
+    # Handles an existing star.  Executes the block in the instance of
+    # the star, adds the definition's required_platforms to the stars,
+    # and then returns the star.
+    #
+    # @return [Class]
+    def handle_existing
+      star = Star.stars[data[:type]][data[:as]]
+
+      star.class_exec &@block
+
+      star
+    end
+
+    # Handles defining a new star.  Creates a class as a subclass of
+    # the star, sets its name and type, and executes the block in the
+    # instance of the star.  Adds the required_platform to the star,
+    # sets the star to {Star.stars}, and returns the new star.
+    #
+    # @param star_type [Class] the type of star it is.
+    # @return [Class]
+    def handle_new(star_type)
+      new_star = Class.new(star_type)
+      new_star.as   = data[:as]
+      new_star.type = data[:type]
+      new_star.class_exec &@block
+
+      Star.stars[data[:type]][data[:as]] = new_star
+    end
+
+  end
+end

data/lib/nova/exceptions.rb

@@ -0,0 +1,16 @@
+module Nova
+
+  # Raised when an Event cannot be found.
+  class NoEventError < StandardError; end
+
+  # Raised when options were passed that were not valid.
+  class InvalidOptionsError < StandardError; end
+
+  # Raised when a Star is tried to be created from a non-existant
+  # star type.
+  class NoStarError < StandardError; end
+
+  # Raised when a Star is tried to be instantized on a non-compliant
+  # platform.
+  class NoPlatformError < StandardError; end
+end

data/lib/nova/project.rb

@@ -0,0 +1,199 @@
+require 'yaml'
+
+module Nova
+
+  # A Nova project, containing the galaxy and configuration
+  # settings for that project.
+  class Project
+
+    # The default paths to load from.
+    DEFAULT_PATHS = [File.absolute_path("../../../galaxy", __FILE__)]
+
+    # Whether or not the given directory is deemable as a Nova
+    # project.
+    #
+    # @param dir [String] the directory to test.
+    # @return [Boolean]
+    def self.valid?(dir)
+      Dir.new(dir).each.include?("nova.yml")
+    end
+
+    # The directory the project is based in.
+    #
+    # @return [Directory]
+    attr_reader :directory
+
+    # The load paths for this project.
+    #
+    # @return [Array<String>]
+    attr_reader :load_paths
+
+    # The options that were loaded from the config for this project.
+    #
+    # @return [Hash]
+    attr_reader :options
+
+    # Initializes the project.  Loads the configuration file by
+    # default.
+    #
+    # @param dir [String] the path to the directory for the project.
+    # @param load_config [Boolean] whether or not to load the
+    #   configuration file.
+    def initialize(dir, load_config = true)
+      @directory = Dir.new(dir)
+      @load_paths = DEFAULT_PATHS.dup
+      @options   = {}
+
+      if load_config
+        load_config!
+      end
+    end
+
+
+    # Loads the configuration file.
+    #
+    # @return [Hash] the data.
+    def load_config!
+      return unless options.empty?
+
+      data = ::YAML.load_file(File.open("#{directory.path}/nova.yml", "r"))
+      load_paths.push(*data.fetch("load_paths", []))
+
+      load_paths.map! do |path|
+        File.absolute_path(path, directory.path)
+      end
+
+      @options = data
+    end
+
+    # Requires all of the star files that is in the project.
+    #
+    # @return [void]
+    def require_files
+      @load_paths.each do |path|
+        Dir["#{path}/**/*"].each do |f|
+          require f
+        end
+      end
+    end
+
+    # Runs the servers defined in the options.
+    #
+    # @note If do_fork is false, only the first server in the config
+    #   file will actually be created.
+    # @param do_fork [Boolean] whether or not to actually fork the
+    #   process when creating servers.
+    # @param which [Array<String>] which servers to run.  Defaults to
+    #   all of them.
+    # @return [void]
+    def run_servers(do_fork = true, which = [])
+      each_server(which) do |server, name|
+        puts name
+
+        if File.exists?(server[:files][:pid])
+          Nova.logger.warn {
+            "PID file #{server[:files][:pid]} already exists. " +
+            "Ignoring server definition."
+          }
+          next
+        end
+
+        if do_fork
+          process_id = fork
+        end
+
+        if process_id
+          File.open(server[:files][:pid], "w") { |f| f.write process_id }
+          Process.detach(process_id)
+        else
+          return build_server(server, do_fork)
+        end
+      end
+    end
+
+    # Takes down running servers.
+    #
+    # @param which [Array<String>] which servers to take down.
+    #   Defaults to all of them.
+    # @return [void]
+    def shoot(which = [])
+      each_server do |server, name|
+        if File.exists?(server[:files][:pid])
+          pid = File.open(server[:files][:pid], "r") { |f| f.read }.to_i
+
+          puts "Sending INT to #{pid}..."
+
+          Process.kill :INT, pid rescue Errno::ESRCH
+
+          File.delete(server[:files][:pid]) rescue Errno::ENOENT
+
+          puts "OK!"
+        end
+      end
+    end
+
+    private
+
+    # Loops over all of the defined servers, yielding the server
+    # definition and the index for that server.
+    #
+    # @yieldparam server [Hash<Symbol, Object>] the server data
+    # @yieldparam server_name [String] the name of the server.
+    # @yieldparam index [Numeric] the index of the server in the
+    #   definition file.
+    # @return [void]
+    def each_server(only = [])
+      server_list = [options["servers"], options["server"]].flatten.compact
+
+      server_list.each_with_index do |srv, i|
+        srv_name = srv.fetch(:name, "server#{i}")
+        srv[:files] ||= {}
+
+        files = {}
+        {:log => :log, :pid => :pid, :client => :rb}.each do |f, n|
+          files[f] = File.absolute_path(
+            srv[:files].fetch(f, "./#{srv_name}.#{n}"),
+            directory.path
+          )
+        end
+        srv[:files] = files
+
+        next unless only.empty? or only.include?(srv_name)
+
+        yield srv, srv_name, i
+      end
+    end
+
+    # Creates a server, with the given server options.
+    #
+    # @param server [Hash<Symbol, Object>] the server information to
+    #   base the server instance off of.
+    # @param redirect [Boolean] whether or not to redirect the
+    #   {Nova.logger} and the stdin, stdout, and stderr for the
+    #   server.
+    # @return [void]
+    def build_server(server, redirect = true)
+      if redirect
+        Nova.logger = Logger.new(server[:files][:log], 10, 1_024_000)
+        $stdin = $stdout = $stderr = File.open("/dev/null", "a")
+      end
+
+      begin
+        s = Nova::Starbound::Server.new(server)
+        s.read_client_file server[:files][:client]
+
+        trap :INT do
+          s.shutdown
+          File.delete(server[:files][:pid]) rescue Errno::ENOENT
+        end
+
+        return s.listen
+      rescue => e
+        Nova.logger.fatal { "#{e}: #{e.message}; #{e.backtrace[0]}" }
+        File.delete(server[:files][:pid]) rescue Errno::ENOENT
+        exit
+      end
+    end
+
+  end
+end