nova 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 98f99f8e3d4e94b3634e3881015900048f2d1565
+  data.tar.gz: 16f716c8f300fa1ed9d2ff472f0ca0e1ee6e97cc
+SHA512:
+  metadata.gz: e53c896e97cda1f47557f7cfa670af707175f2e13bddde1dbc9e3a0ca87daaf15f85ba15bbe943a7251cbbd73a9f7e9bb519fdfadeb833665989b03241480997
+  data.tar.gz: 4d46a1cfbc412411ffa75ed218c3cd4e907e6fdc8b63008fe7b3c78f15c0815fd7e1df5f81dcc16726c3bc9bc05f417e4f1509fc5277b16c40e190e62187b454

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2013 Jeremy Rodi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Nova
+[![Build Status](https://travis-ci.org/redjazz96/nova.png?branch=master)](https://travis-ci.org/redjazz96/nova) [![Code Climate](https://codeclimate.com/github/redjazz96/nova.png)](https://codeclimate.com/github/redjazz96/nova) [![Coverage Status](https://coveralls.io/repos/redjazz96/nova/badge.png?branch=master)](https://coveralls.io/r/redjazz96/nova?branch=master) [![Gem Version](https://badge.fury.io/rb/nova.png)](http://badge.fury.io/rb/nova)
+
+![A Very Pretty Nova](http://i.imgur.com/48AoWKo.jpg)
+*Image credit to NASA*
+
+## What is Nova?
+Nova is a way to set up software on computers in a definite and consistant process.
+Its goals are to be cross-platform compatible, easy to use and understand, and
+powerful.
+
+## Great! How do I get started?
+It's not ready yet. It's still early in development, and there are a few things that need
+tweaking. As of right now, it's 100% documented, and completely written in Ruby.
+I have marked things that need to be done with a `@todo` tag. Go check it out if you want.
+There are a few things I plan on adding to Nova before I release it.
+
+## Terminology
+I came up with Nova as a name because I couldn't think of anything better. Turns out, it actually
+fits. The code to set up a piece of software is called a `Star`, a server with stars is called a
+`Cluster`, and (if applicable) the server to manage Clusters is called a `Nucleus` (or
+`Axis`, I haven't made up my mind which).
+
+## License
+Nova is licensed under the MIT License, which can be found [here](LICENSE).
+
+@TODO: note benefit of installing posix-spawn when using local remote.
+
+(note: in order to work with libsodium, the location of the library needs to be added to `LD_LIBRARY_PATH`)

data/bin/nova

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'thor'
+require 'nova'
+require 'nova/cli'
+
+Nova::CLI.start

data/lib/generator/template/new_install/galaxy/some_star.rb

@@ -0,0 +1,3 @@
+Nova star: :some_star do
+  # do something here
+end

data/lib/generator/template/new_install/supernova.yml

@@ -0,0 +1,16 @@
+load_paths:
+  - ./galaxy
+
+# If this is an array, every time we run +Nova server up+, multiple
+# instances are created, each matching the values here.
+servers:
+  - :name: tcp_server
+    :type: :tcp
+    :host: 0.0.0.0
+    :port: 2010
+  - :name: unix_server
+    :type: :unix
+    :path: "./Nova.sock"
+    :protocol:
+      :allow_plaintext: true
+

data/lib/nova.rb

@@ -0,0 +1,49 @@
+require 'logger'
+
+require 'nova/version'
+require 'nova/project'
+require 'nova/constructor'
+require 'nova/exceptions'
+require 'nova/remote'
+require 'nova/star'
+
+require 'nova/starbound'
+
+# A Game management software.  Also note that a method named
+# +Nova+ is available under the top-level namespace, which acts
+# as an alias for {Nova.create}.
+#
+# @api public
+module Nova
+
+  # The Nova logger.  By default outputs to STDOUT.
+  #
+  # @return {Logger}
+  def self.logger
+    @logger ||= Logger.new(STDOUT)
+  end
+
+  attr_writer :logger
+
+  # This creates a star with a given block, unless it already exists;
+  # if it does, it just modifies that star.
+  #
+  # @param options [Hash{Symbol => Symbol}] the first key value pair
+  #   is used to determine the star type and star name, while the
+  #   rest is ignored.
+  # @yield [] to create the star.
+  # @return [Class] the new star.
+  def self.create(options, &block)
+    Constructor.new(options, &block).modify_or_create
+  end
+end
+
+# Creates or modifies a star, with the given options and block.
+#
+# @see Nova.create
+# @param (see Nova.create)
+# @yield (see Nova.create)
+# @return [Class] the new star.
+def Nova(options, &block)
+  Nova.create(options, &block)
+end

data/lib/nova/cli.rb

@@ -0,0 +1,62 @@
+require 'nova/commands/server'
+module Nova
+
+  # Handles the command line interface.  Uses thor to do that.
+  class CLI < ::Thor
+
+    include Thor::Actions
+
+    class_option :path, :type => :string, :default => "."
+
+    # The source thor should use for managing files.
+    #
+    # @api private
+    # @return [String]
+    def self.source_root
+      File.absolute_path("../../generator/template", __FILE__)
+    end
+
+    desc "install PATH", "Installs a Galaxy into the given path."
+    # Installs a galaxy into the given path.  Just copies the files
+    # and folders in lib/generator/template/new_install into the
+    # given folder.
+    #
+    # @return [void]
+    def install(to)
+       directory("new_install", to)
+    end
+
+    desc "list", "List all of the available stars."
+    # Lists all of the stars that the project has available to it.
+    # Requires the --path parameter or to be in a project folder.
+    #
+    # @return [void]
+    def list
+      project.require_files
+
+      Star.stars.each do |key, value|
+        shell.say("#{key}:", :green, :bold)
+
+        value.each do |k, v|
+          shell.say "\t#{k}"
+        end
+      end
+    end
+
+    desc "server SUBCOMMAND [...ARGS]", "Manage Nova servers."
+    subcommand "server", Commands::Server
+
+    private
+
+    # Returns the project instance for the folder.
+    #
+    # @see Project
+    # @return [Project]
+    def project
+      @_project ||= Project.new(options[:path])
+    end
+  end
+end
+
+# Subcommands and other stuff to be used with thor.
+module Nova::Commands; end

data/lib/nova/commands/server.rb

@@ -0,0 +1,71 @@
+module Nova
+  module Commands
+
+    # Handles server operations for projects.
+    class Server < ::Thor
+
+      desc "up", "Runs the servers."
+      method_option :foreground, :type => :boolean,
+        :desc => "Run the process in the foreground.",
+        :default => false
+      method_option :which, :type => :array, :banner => "<servers>",
+        :desc => "Which servers to run.  Empty means all.",
+        :default => []
+      long_desc <<-DESC
+      Runs servers defined in Nova.yml.  If the forgeground
+      option is specified, the process is run in the foreground.
+      Otherwise, it's ran as a daemon.  If the which parameter is
+      specified, it only runs the servers that were specified.
+
+      Options that can be defined for servers include:
+
+        :name    :: the name of the server.  Used to name the pid
+                    files and the log files.
+
+        :type    :: the type of server.  Can be :tcp or :unix.  If
+                    it's :tcp, options :ip and :port can be defined
+                    and will be used.  If it's :unix, the option :path
+                    can be defined for the path to the socket.
+                    Defaults to :tcp.
+
+        :host    :: the IP address to bind to.  Only applicable if
+                    :type is :tcp.  Defaults to 127.0.0.1.
+
+        :port    :: the port to bind to.  Only applicable if :type is
+                    :tcp.  Defaults to 2010.
+
+        :path    :: the path to the UNIX socket.  Only applicable if
+                    :type is :unix.  Defaults to /tmp/sock.
+
+        :protocol:: protocol options, used for settings in the
+                    protocol. only current option is :allow_plaintext,
+                    which prevents the server from raising an
+                    exception if the  protocol negotiates a plaintext
+                    encryption (insecure).
+      DESC
+      # Runs the servers.  Run +Nova server help up+ for
+      # information on this command.
+      #
+      # @see Project
+      # @see Project#run_servers
+      # @return [void]
+      def up
+        Project.new(parent_options[:path]).run_servers(
+          !options[:foreground], options[:which])
+      end
+
+      desc "down", "Takes down running servers."
+      method_option :which , :type => :array, :banner => "<servers>",
+        :desc => "Which servers to remove.  Empty means all.",
+        :default => []
+      # Handles taking down servers.
+      #
+      # @see Project
+      # @see Project#shoot
+      # @return [void]
+      def down
+        Project.new(parent_options[:path]).shoot(options[:which])
+      end
+    end
+  end
+end

data/lib/nova/common.rb

@@ -0,0 +1,17 @@
+require 'nova/common/event_handler'
+require 'nova/common/star_management'
+require 'nova/common/metadata'
+require 'nova/common/features'
+
+module Nova
+
+  # This defines the methods that are common to all remotes, as in,
+  # platform independent, in the truest sense of the word.
+  module Common
+
+    # The possible platforms that can exist.
+    POSSIBLE_PLATFORMS = [:posix, :linux, :osx, :windows, :ubuntu,
+      :red_hat, :arch].freeze
+
+  end
+end

data/lib/nova/common/event_handler.rb

@@ -0,0 +1,165 @@
+require 'set'
+
+require 'nova/common/event_handler/event'
+
+module Nova
+  module Common
+    # Handles events sent to the receiver to be processed.
+    module EventHandler
+
+      # Class methods.
+      module ClassMethods
+
+        # A list of all of the events defined in the class.
+        #
+        # @return [Set<EventHandler::Event>]
+        def events
+          @_events ||= Set.new
+        end
+
+        # Creates an event, adds it to the list, and returns it.
+        #
+        # @param event [Symbol] the name of the event.
+        # @param options [Hash] the options for the event, when creating
+        #   it.
+        # @yieldparam options [Hash] the options for the event when ran.
+        #   The contents of the options hash is defined at the time when
+        #   ran.
+        # @option (see Event#initialize)
+        # @return [Event] the event.
+        def on(event, options = {})
+          events << Event.new(event, options, Proc.new)
+        end
+
+        alias_method :to, :on
+
+        # Checks to see if an event with the given name exists.
+        #
+        # @note Even if the event with the given name may exist,
+        #   the event may still not exist if the options don't match.
+        #   If you want to make sure that the event will respond to
+        #   the name and options, check {#has_event_with_options?}.
+        # @param name [Symbol] the name of the event.
+        # @return [nil, Event]
+        def has_event?(name)
+          events.dup.keep_if { |e| e.name == name }.to_a.first
+        end
+
+        # Checks to see if an event can respond to the given name and
+        # options.
+        #
+        # @param name [Symbol] the name of the event.
+        # @param options [Hash] the options for the event.
+        # @return [nil, Event]
+        def has_event_with_options?(name, options = {})
+          event = Event.new(name, options)
+          event.type = :search
+          events.dup.keep_if { |e| e.match? Star.new, event }.to_a.first
+        end
+      end
+
+      # Instance methods.
+      module InstanceMethods
+
+        include ClassMethods
+
+        # Automatically binds the {Star} to itself on initialization.
+        def initialize(*)
+          bind remote.new
+          super()
+        end
+
+        # Returns the event list.
+        #
+        # @see ClassMethods#events
+        # @return [Set<EventHandler::Event>]
+        def events
+          @_events ||= self.class.events.dup
+        end
+
+        # Checks to see if an event can respond to the given name and
+        # options.
+        #
+        # @param (see ClassMethods#has_event_with_options?)
+        # @return (see ClassMethods#has_event_with_options?)
+        def has_event_with_options?(name, options = {})
+          event = Event.new(name, options)
+          event.type = :search
+          events.dup.keep_if { |e| e.match? self, event }.to_a.first
+        end
+
+        # Runs an event, with the given name and options.
+        #
+        # @raise [NoEventError] when it can't find the event.
+        # @param name [Symbol] the name of the event.
+        # @param options [Hash] the options to pass to the
+        #   event.
+        # @return [Object] the result of the event.
+        def run!(name, options = {})
+          matched = has_event_with_options? name, options
+
+          if matched
+            matched.run(bind, options)
+          else
+            raise NoEventError, "Could not find event #{name}."
+          end
+        end
+
+        # Calls {#run!}, but if it raises a [NoEventError] it returns it
+        # instead of raising it.
+        #
+        # @see #run!
+        # @param (see #run!)
+        # @return [Object, NoEventError] the result of the event, or the
+        # exception.
+        def run(name, options = {})
+          run! name, options
+
+        rescue NoEventError => e
+          e
+        end
+
+
+        # Binds this event handler to a given object, running all events in
+        # the context of that object.
+        #
+        # @param bind [Object] the object to bind to.
+        # @return [self]
+        def bind!(bind)
+          @bind = bind
+          self
+        end
+
+        # @overload bind(bind)
+        #   Binds a copy of this object to a given object, running
+        #   all events in the context of that object.
+        #
+        #   @param bind [Object] the object to bind to.
+        #   @return [Feature]
+        # @overload bind
+        #   Returns the current bind.  Creates an empty object if
+        #   it doesn't exist.
+        #
+        #   @return [Object]
+        def bind(bind = nil)
+          if bind
+            dup.bind!(bind)
+          else
+            @bind ||= Object.new
+          end
+        end
+      end
+
+      # Called when {EventHandler} is included.  Extends what included
+      # it by {ClassMethods}, and includes {InstanceMethods}.
+      #
+      # @param receiver [Object]
+      # @return [void]
+      # @api private
+      def self.included(receiver)
+        receiver.extend         ClassMethods
+        receiver.send :include, InstanceMethods
+      end
+    end
+  end
+end