souffle 0.0.1 → 0.0.2

data/lib/souffle/redis_client.rb

@@ -0,0 +1,8 @@
+require 'souffle/redis_mixin'
+
+class Souffle::Redis
+  extend Souffle::RedisMixin
+
+  # Force initialization of the redis client (@redis).
+  init
+end

data/lib/souffle/redis_mixin.rb

@@ -0,0 +1,40 @@
+require 'eventmachine'
+require 'redis'
+
+# A singleton mixin adapter similar to mixlib/log.
+# 
+# @example
+# 
+#   require 'souffle/redis_mixin'
+# 
+#   class MyRedis
+#     extend Souffle::RedisMixin
+#   end
+# 
+#   MyRedis.set('awesome', 'cool')
+#   MyRedis.get('awesome')
+# 
+module Souffle::RedisMixin
+  attr_reader :redis
+
+  # Initializes the redis client (uses synchrony if Eventmachine is running).
+  def init(*opts)
+    if EM.reactor_running?
+      @redis ||= Redis.new({ :driver => :synchrony }.merge(*opts))
+    else
+      @redis ||= Redis.new(*opts)
+    end
+  end
+
+  # The singleton redis object, initializes if it doesn't exist.
+  def redis
+    @redis || init
+  end
+
+  # Pass any other method calls to the underlying redis object created with
+  # init. If this method is hit before the call to Souffle::RedisMixin.init
+  # has been made, it will call Souffle::RedisMixin.init() with no arguments.
+  def method_missing(method_symbol, *args, &blk)
+    redis.send(method_symbol, *args, &blk)
+  end
+end

data/lib/souffle/server.rb

@@ -1,14 +1,48 @@
-module Souffle
-  # The souffle server and management daemon.
-  class Server
+require 'thin'
+require 'eventmachine'
+require 'em-synchrony'
+require 'souffle/http'
 
-    # Creates a new souffle server.
-    def initialize
+# The souffle server and management daemon.
+class Souffle::Server
+
+  # Creates a new souffle server.
+  def initialize
+  end
+
+  # Runs the server.
+  def run
+    if Souffle::Config[:server]
+      EM.synchrony do
+        @app = Rack::Builder.new do
+          use Rack::Lint
+          use Rack::ShowExceptions
+          run Rack::Cascade.new([Souffle::Http])
+        end.to_app
+
+        Rack::Handler.get(:thin).run(@app, rack_options)
+      end
     end
+  end
+
+  # Gets the rack options from the configuration.
+  # 
+  # @return [ Hash ] The rack options from Souffle::Config.
+  def rack_options
+    opts = Hash.new
+    Souffle::Config.configuration.each do |k,v|
+      if /^rack/ =~ k.to_s
+        param = k.to_s.gsub('rack_', '')
 
-    # Runs the server.
-    def run
+        case param
+        when "environment"
+          opts[param.to_sym] = v
+        else
+          opts[param.capitalize.to_sym] = v
+        end
+      end
     end
-    
+    opts
   end
+  
 end

data/lib/souffle/ssh_monkey.rb

@@ -0,0 +1,8 @@
+require 'em-ssh'
+
+# Monkeypatching connect on ssh so it doesn't spam the log.
+class Net::SSH::Authentication::KeyManager
+  def use_agent?
+    false
+  end
+end

data/lib/souffle/state.rb

@@ -0,0 +1,16 @@
+require 'souffle/redis_client'
+
+class Souffle::State
+  class << self
+
+    # The Souffle::State prefix for Redis.
+    def prefix
+      "souffle_state_"
+    end
+
+    # Returns the current system states.
+    def status
+      Souffle::Redis.get("#{Souffle::State.prefix}status")
+    end
+  end
+end

data/lib/souffle/system.rb

@@ -1,51 +1,153 @@
-module Souffle
-  # A system description with nodes and the statemachine to manage them.
-  class System
-    attr_reader :nodes, :root, :provider
-
-    state_machine :state, :initial => :uninitialized do
-      before_transition :uninitialized => any - :uninitialized,
-        :do => :initialize_provider
-
-      around_transition do |system, transition, block|
-        start = Time.now
-        block.call
-        system.time_used += Time.now - start
-      end
-    end
+require 'set'
 
-    # Creates a new souffle system, defaulting to using Vagrant as a provider.
-    # 
-    # @param [ String ] provider The provider to use for the given system.
-    def initialize(provider="Vagrant")
-      initialize_provider(provider)
-      super() # NOTE: This is here to initialize state_machine.
+# A system description with nodes and the statemachine to manage them.
+class Souffle::System
+  attr_reader :nodes
+  attr_accessor :options, :provisioner
+
+  # Creates a new souffle system.
+  def initialize
+    @nodes = []
+    @options = {}
+  end
+
+  # Adds a node to the system tree.
+  # 
+  # @param [ Souffle::Node ] node The node to add into the tree.
+  def add(node)
+    node.system = self
+    @nodes << node
+  end
+
+  # Checks node dependencies and rebalances them accordingly.
+  # 
+  # If a node has no dependencies, it's a root node!
+  # If a node has depdendencies, setup the node's parents.
+  def rebalance_nodes
+    clear_node_heirarchy
+    dependent_nodes.each { |n| setup_node_parents(n) }
+  end
+
+  # Clears all parents and children from nodes to prepare to rebalancing.
+  def clear_node_heirarchy
+    @nodes.each { |n| n.parents = []; n.children = [] }
+  end
+
+  # Finds all of a nodes parent dependencies and setup the parents.
+  # 
+  # @param [ Souffle::Node ] node The node to check and configure.
+  def setup_node_parents(node)
+    optimal_deps = optimized_node_dependencies(node)
+    optimal_deps.each { |n, node_deps| n.add_child(node) }
+  end
+
+  # Gets all of the node dependencies on the system.
+  # 
+  # @param [ Souffle::Node ] node The node to retrieve dependencies for.
+  # 
+  # @return [ Array ] The tuple of [ node, dependency_list ] for the node.
+  def dependencies_on_system(node)
+    node_dependencies = []
+    nodes_except(node).each do |n|
+      is_dependant, dep_list = node.depends_on?(n)
+      node_dependencies << [n, dep_list] if is_dependant
     end
+    node_dependencies
+  end
 
-    def initialize_provider(provider)
-      @provider = Souffle::Provider.const_get(provider.to_sym).new
-    rescue
-      raise Souffle::Exceptions::InvalidProvider,
-        "The provider Souffle::Provider::#{provider} does not exist."
+  # Returns a dependency to node list mapping.
+  # 
+  # @return [ Hash ] The mapping of depdencies to nodes.
+  def dependency_mapping(node)
+    mapping = {}
+    dependencies_on_system(node).each do |n, deps|
+      deps.each do |dep|
+        mapping[dep] ||= []; mapping[dep] << n
+      end
     end
+    mapping
+  end
 
-    # Proxy to the provider setup routine.
-    def setup_provider
-      @provider.setup
+  # The optimized the node dependencies for the system.
+  # 
+  # @param [ Souffle::Node ] node The node that you want to optimize.
+  def optimized_node_dependencies(node)
+    deps = Set.new
+    dependency_mapping(node).each do |dep, nodes|
+      deps << nodes.sort_by { |n| n.weight }.first
     end
+    deps.to_a
+  end
+
+  # Returns the list of all nodes except the given node.
+  # 
+  # @return [ Array ] The list of all nodes except the given node.
+  def nodes_except(node)
+    @nodes.select { |n| n != node }
+  end
+
+  # Returns the list of all root nodes.
+  # 
+  # @note We use dependencies here to validate whether a node is root here
+  # because the parents are only determined after a rebalance is run.
+  # 
+  # @return [ Array ] The list of all root nodes. (Nodes without parents).
+  def roots
+    @nodes.select { |n| n.dependencies.empty? }
+  end
+
+  # Returns the list of all dependent nodes.
+  # 
+  # @return [ Array ] The list of all dependant nodes.
+  def dependent_nodes
+    @nodes.select { |n| n.dependencies.any? }
+  end
 
-    # Adds the root node to the system.
+  # Tries to fetch an option parameter otherwise it grabs it from config.
+  # 
+  # @param [ Symbol ] opt The option to try and fetch.
+  # 
+  # @return [ String ] The option return value.
+  def try_opt(opt)
+    options.fetch(opt, Souffle::Config[opt])
+  rescue
+    nil
+  end
+
+  class << self
+    # Creates a new system from a given hash.
     # 
-    # @param [ Souffle::Node ] node The node to become to root node.
-    def root=(node)
-      @root = node
+    # @param [ Hash ] system_hash The hash representation of the system.
+    def from_hash(system_hash)
+      guarentee_valid_hash(system_hash)
+      system_hash[:options] ||= {}
+
+      sys = Souffle::System.new
+      system_hash[:nodes].each do |n|
+        n[:options] ||= Hash.new
+        
+        node = Souffle::Node.new
+        node.name = n[:name]
+        Array(n[:run_list]).each { |rl| node.run_list << rl }
+        Array(n[:dependencies]).each { |dep| node.dependencies << dep }
+        node.options = system_hash[:options].merge(n[:options])
+        node.options[:attributes] ||= Hash.new
+        sys.add(node)
+      end
+      sys
     end
 
-    # Adds a node to the system tree.
+    private
+
+    # Guarentee that the system hash that was passed in is valid.
     # 
-    # @param [ Souffle::Node ] node The node to add into the tree.
-    def add(node)
+    # @param [ Hash ] system_hash The hash representation of the system.
+    def guarentee_valid_hash(system_hash)
+      if system_hash.nil? or !system_hash.has_key?(:nodes)
+        raise Souffle::Exceptions::InvalidSystemHash,
+          "The system hash must have a nodes key with a list of nodes."
+      end
     end
-
   end
+
 end

data/lib/souffle/template.rb

@@ -0,0 +1,30 @@
+require 'erb'
+require 'tilt'
+
+# Template wrapper around the Tilt Template Abstraction Library.
+class Souffle::Template
+  
+  # Creates a new template.
+  # 
+  # @param [ String ] template The name of the template to render.
+  def initialize(template)
+    @template = Tilt.new(
+      File.expand_path("#{Souffle::Template.template_path}/#{template}"))
+  end
+
+  # Renders the template with the given binding.
+  # 
+  # @param [ Object ] binding The binding object for the template.
+  # 
+  # @return [ String ] The rendered template.
+  def render(binding)
+    @template.render(binding)
+  end
+
+  # Helper pointing to the default templates path.
+  # 
+  # @return [ String ] The path to the Souffle templates.
+  def self.template_path
+    File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
+  end
+end

data/lib/souffle/templates/Vagrantfile.erb

@@ -0,0 +1,41 @@
+# This file is generated by Souffle (<%= version %>)
+
+require 'mixlib/config'
+require 'yajl'
+
+class SouffleCfg
+  extend Mixlib::Config
+
+  def self.from_file(filename, parser="ruby")
+    send("from_file_#{parser}".to_sym, filename)
+  end
+
+  def self.from_file_ruby(filename)
+    self.instance_eval(IO.read(filename), filename, 1)
+  end
+
+  def self.from_file_json(filename)
+    self.from_stream_json(IO.read(filename))
+  end
+
+  def self.from_stream_json(input)
+    parser = Yajl::Parser.new(:symbolize_keys => true)
+    configuration.merge!(parser.parse(input))
+  end
+
+  nodes = []
+end
+
+cfg = File.join(File.dirname(__FILE__), 'souffle.json')
+SouffleCfg.from_file(cfg, "json") if File.exists? cfg
+
+SouffleCfg[:nodes] = Array(SouffleCfg[:nodes])
+
+Vagrant::Config.run do |config|
+  SouffleCfg[:nodes].each do |node|
+    config.vm_box = config[:vm_box]
+
+    node.vm.provision :chef_solo do |chef|
+    end
+  end
+end

data/lib/souffle/version.rb

@@ -0,0 +1,6 @@
+# An orchestrator for setting up isolated chef-managed systems.
+module Souffle
+  # The current souffle version.
+  VERSION = "0.0.2"
+end
+

data/spec/config_spec.rb

@@ -1,6 +1,26 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe "Souffle::Config" do
+  after(:each) do
+    Souffle::Config.configure { |c| c.delete(:random_something) }
+    Souffle::Config[:aws_access_key] = ""
+    Souffle::Config[:aws_access_secret] = ""
+  end
+
+  it "should have default values for aws, rack and vagrant" do
+    %w{ log_level log_location provider
+      user group umask aws_access_key aws_access_secret
+      rack_host rack_port rack_environment vagrant_dir }.each do |cfg|
+        cfg = cfg.to_sym
+        Souffle::Config.configuration.keys.include?(cfg).should eql(true)
+      end
+  end
+
+  it "should have a proper default vagrant directory" do
+    vagrant_dir = "#{ENV['HOME']}/vagrant/vms"
+    Souffle::Config[:vagrant_dir].should eql(vagrant_dir)
+  end
+
   it "should be able to read from a ruby config file" do
     config = File.join(File.dirname(__FILE__), 'config', 'example.rb')
     Souffle::Config.from_file(config)

data/spec/log_spec.rb

@@ -0,0 +1,24 @@
+require 'stringio'
+require 'tempfile'
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Souffle::Log" do
+  before(:each) do
+    Souffle::Log.reset!
+  end
+
+  it "should ave the ability to write directly to the log" do
+    io = StringIO.new
+    Souffle::Log.init(io)
+    Souffle::Log << "Example Log"
+    io.string.should eql("Example Log")
+  end
+
+  it "should have the ability to write to a specific log level" do
+    io = StringIO.new
+    Souffle::Log.init(io)
+    Souffle::Log.level(:info)
+    Souffle::Log.info "Awesome"
+    (/INFO: Awesome/ =~ io.string).should_not eql(nil)
+  end
+end