souffle 0.0.1 → 0.0.2

data/spec/{runlist_parser_spec.rb → node/runlist_parser_spec.rb}

@@ -1,4 +1,4 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 describe "Souffle::Node::RunListParser" do
   it "should be able to check whether a hash name is a valid word" do

data/spec/{runlist_spec.rb → node/runlist_spec.rb}

@@ -1,4 +1,4 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 describe "Souffle::Node::RunList" do
   it "should be able to add a runlist item onto the runlist" do

data/spec/node_spec.rb

@@ -32,21 +32,28 @@ describe "Souffle::Node" do
   end
 
   it "should be able to describe a single node" do
-    @node.run_list << "recipe[chef_server::rubygems_install]"
-    @node.run_list << "role[dns_server]"
+    rlist = [
+      "recipe[chef_server::rubygems_install]",
+      "role[dns_server]" ]
+    rlist.each { |rl| @node.run_list << rl }
+    @node.run_list.each do |rl_item|
+      rlist.include?(rl_item.to_s).should eql(true)
+    end
   end
 
   it "should be able to test whether or not a node depends on another" do
     @node.run_list << "role[dns_server]"
     node2 = Souffle::Node.new
     node2.dependencies << "role[dns_server]"
-    node2.depends_on?(@node).should eql(true)
+    node2.depends_on?(@node).should eql(
+      [ true, [Souffle::Node::RunListItem.new("role[dns_server]")] ]
+    )
   end
 
   it "should not depend on another node when there are no dependencies" do
     @node.run_list << "role[dns_server]"
     node2 = Souffle::Node.new
-    node2.depends_on?(@node).should eql(false)
+    node2.depends_on?(@node).should eql([ false, [] ])
   end
 
   it "should be able to add child nodes" do
@@ -55,9 +62,15 @@ describe "Souffle::Node" do
     @node.children.should eql([child])
   end
 
+  it "should not duplicate a child node that's added" do
+    child = Souffle::Node.new
+    @node.add_child(child)
+    @node.add_child(child)
+    @node.children.should eql([child])
+  end
+
   it "should raise and error on adding an invalid child" do
-    child = []
-    lambda { node.add_child(child) }.should raise_error
+    lambda { node.add_child([]) }.should raise_error
   end
 
   it "should be able to iterate across children" do
@@ -81,7 +94,29 @@ describe "Souffle::Node" do
     @node.should eql(node2)
   end
 
-  it "should have an initial state of `:uninitialized`" do
-    @node.state_name.should eql(:uninitialized)
+  it "should have a depency weight of 1 with no parents" do
+    @node.weight.should eql(1)
+  end
+
+  it "should have a dependency weight of at least 2 with a parent" do
+    parent = Souffle::Node.new
+    parent.add_child(@node)
+    (@node.weight >= 2).should eql(true)
+  end
+
+  it "should have a name and be able to set it" do
+    @node.name = "AwesomeName"
+    @node.name.should eql("AwesomeName")
+  end
+
+  it "should be able to get node options with try_opt" do
+    @node.options[:example_opt] = "sporkmejohhny"
+    @node.try_opt(:example_opt).should eql("sporkmejohhny")
+  end
+
+  it "should pass-thru to config options when they do not exist" do
+    Souffle::Config[:example_passthru] = "blehk"
+    @node.try_opt(:example_passthru).should eql("blehk")
+    Souffle::Config.configuration.delete(:example_passthru)
   end
 end

data/spec/provider_spec.rb

@@ -0,0 +1,56 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Souffle::Provider::Base" do
+  before(:each) do
+    @provider = Souffle::Provider::Base.new
+  end
+
+  after(:each) do
+    @provider = nil
+  end
+
+  it "should have Base as a default name" do
+    @provider.name.should eql("Base")
+  end
+
+  it "should raise errors on non-overridden create_system" do
+    n = Souffle::Node.new
+    lambda { @provider.create_system(n) }.should raise_error
+  end
+
+  it "should raise errors on non-overridden create_node" do
+    n = Souffle::Node.new
+    lambda { @provider.create_node(n) }.should raise_error
+  end
+
+  it "should raise errors on non-overridden create_raid" do
+    lambda { @provider.create_raid }.should raise_error
+  end
+
+  it "should have an ssh_key_path that matches the provider name" do
+    @provider.send(:ssh_key_path).should eql(
+      "/etc/souffle/ssh/#{@provider.name.downcase}")
+  end
+
+  it "should have a relative ssh key helpers" do
+    base_path = "/etc/souffle/ssh/base"
+    @provider.send(:ssh_key, "mykey").should eql("#{base_path}/mykey")
+  end
+
+  it "should be able to generate chef-solo json for a node." do
+    node = Souffle::Node.new
+    node.name = "TheBestOne"
+    rlist = [ "recipe[chef_server::rubygems_install]", "role[dns_server]" ]
+    rlist.each { |rl| node.run_list << rl }
+
+    runlist = {
+      "domain" => "souffle",
+      "run_list" => [
+        "recipe[chef_server::rubygems_install]",
+        "role[dns_server]"
+      ]
+    }
+
+    JSON.parse(@provider.generate_chef_json(node)).should eql(runlist)
+  end
+end

data/spec/providers/aws_provider_spec.rb

@@ -0,0 +1,114 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Souffle::Provider::AWS" do
+  include Helpers
+  
+  before(:each) do
+    get_config
+    @provider = Souffle::Provider::AWS.new
+  end
+
+  after(:each) do
+    @provider = nil
+  end
+
+  # Note:
+  #   All of the AWS routines will only run if you are provided a
+  #   valid aws_access_key and aws_access_secret.
+
+  it "should be able to see whether the configuration has vpc setup" do
+    aws_vpc_id = "vpc-124ae13"
+    aws_subnet_id = "subnet-24f6a87f"
+    node = Souffle::Node.new
+
+    Souffle::Config[:aws_vpc_id] = aws_vpc_id
+    Souffle::Config[:aws_subnet_id] = aws_subnet_id
+
+    @provider.using_vpc?(node).should eql(true)
+  end
+
+  it "should not use vpc when the keys are missing" do
+    aws_vpc_id = "vpc-124ae13"
+    aws_subnet_id = "subnet-24f6a87f"
+    node = Souffle::Node.new
+
+    Souffle::Config[:aws_vpc_id] = aws_vpc_id
+    Souffle::Config[:aws_subnet_id] = nil
+    @provider.using_vpc?(node).should eql(false)
+
+    Souffle::Config[:aws_vpc_id] = nil
+    Souffle::Config[:aws_subnet_id] = aws_subnet_id
+    @provider.using_vpc?(node).should eql(false)
+
+    Souffle::Config[:aws_vpc_id] = nil
+    Souffle::Config[:aws_subnet_id] = nil
+    @provider.using_vpc?(node).should eql(false)
+  end
+
+  it "should be able to generate a unique tag" do
+    tag1 = @provider.generate_tag
+    tag2 = @provider.generate_tag
+    tag1.should_not eql(tag2)
+  end
+
+  it "should be able to generate a unique tag with a prefix" do
+    @provider.generate_tag("example").include?("example").should eql(true)
+  end
+
+  it "should return a list of instance ids for a list of nodes" do
+    node1 = Souffle::Node.new
+    node2 = Souffle::Node.new
+    node3 = Souffle::Node.new
+
+    node1.options[:aws_instance_id] = "1a"
+    node2.options[:aws_instance_id] = "2b"
+    node3.options[:aws_instance_id] = "3c"
+
+    nodelist = [node1, node2, node3]
+    @provider.instance_id_list(nodelist).should eql(["1a", "2b", "3c"])
+  end
+end
+
+describe "Souffle::Provider::AWS (live)", :live => true do
+  include Helpers
+  
+  before(:each) do
+    get_config
+    @provider = Souffle::Provider::AWS.new
+  end
+
+  after(:each) do
+    @provider = nil
+  end
+
+  it "should be able to launch and provision an entire system" do
+    EM.run do
+      system = Souffle::System.new
+
+      masternode = Souffle::Node.new
+      masternode.name = "MasterNode"
+      masternode.run_list << "recipe[git]"
+      masternode.options[:aws_ebs_size] = 1
+      masternode.options[:volume_count] = 2
+
+      child_node1 = Souffle::Node.new
+      child_node1.name = "child node 1"
+      child_node1.options[:aws_ebs_size] = 2
+      child_node1.options[:volume_count] = 2
+
+      child_node2 = Souffle::Node.new
+      child_node2.name = "child node 2"
+      child_node2.options[:aws_ebs_size] = 3
+      child_node2.options[:volume_count] = 2
+
+      system.add(masternode)
+      system.add(child_node1)
+      system.add(child_node2)
+      @provider.create_system(system)
+
+      EM::Timer.new(300) do
+        EM.stop
+      end
+    end
+  end
+end

data/spec/providers/vagrant_provider_spec.rb

@@ -0,0 +1,22 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Souffle::Provider::Vagrant" do
+  include Helpers
+  
+  before(:each) do
+    get_config
+    @provider = Souffle::Provider::Vagrant.new
+  end
+
+  after(:each) do
+    @provider = nil
+    Souffle::Config[:vagrant_dir] = "/#{ENV['HOME']}/vagrant/vms"
+  end
+
+  it "should have setup initialize the access key and secret" do
+    example_vagrant_dir = "/path/to/vagrant/vms"
+    Souffle::Config[:vagrant_dir] = "/path/to/vagrant/vms"
+    @provider = Souffle::Provider::Vagrant.new
+    @provider.vagrant_dir.should eql(example_vagrant_dir)
+  end
+end

data/spec/provisioner_spec.rb

@@ -0,0 +1,47 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Souffle::Provisioner" do
+  include Helpers
+  
+  before(:each) do
+    get_config
+    Souffle::Config[:provider] = "Vagrant"
+    @provisioner = Souffle::Provisioner.new
+  end
+
+  after(:each) do
+    @provisioner = nil
+  end
+
+  it "should be able to initialize a Vagrant provider" do
+    @provisioner.provider.name.should eql("Vagrant")
+  end
+
+  it "should be raise an error on an invalid provider" do
+    Souffle::Config[:provider] = "CompletelyInvalidProvider"
+    d = lambda { Souffle::Provisioner.new }
+    d.should raise_error
+  end
+
+  it "should be able to initialize an AWS provider" do
+    Souffle::Config[:provider] = "AWS"
+    @provisioner = Souffle::Provisioner.new
+    @provisioner.provider.name.should eql("AWS")
+  end
+
+  it "should be able to setup an Vagrant provider" do
+    Souffle::Config[:provider] = "Vagrant"
+    @provisioner = Souffle::Provisioner.new
+  end
+
+  it "should be able to setup an AWS provider" do
+    Souffle::Config[:provider] = "AWS"
+    @provisioner = Souffle::Provisioner.new
+  end
+
+  it "raises an InvalidProvider error when the provider doesn't exist" do
+    Souffle::Config[:provider] = "UnholyProviderOfBadness"
+    d = lambda { Souffle::Provisioner.new }
+    d.should raise_error
+  end
+end

data/spec/spec_helper.rb

@@ -28,5 +28,13 @@ require 'souffle'
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
 
 RSpec.configure do |config|
+  if ENV['AWS_LIVE'].to_s != "true"
+    config.filter_run_excluding :live => true
+  end
+end
 
+module Helpers
+  def get_config
+    Souffle::Config.from_file("/etc/souffle/souffle.rb")
+  end
 end

data/spec/system_spec.rb

@@ -1,4 +1,5 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'set'
 
 describe "Souffle::System" do
   before(:each) do
@@ -9,27 +10,255 @@ describe "Souffle::System" do
     @system = nil
   end
 
-  it "should be able to setup a Vagrant provider" do
-    @system.provider.name.should eql("Vagrant")
+  it "should be able to find all of the nodes with no parents" do
+    node1 = Souffle::Node.new
+    node2 = Souffle::Node.new
+    node3 = Souffle::Node.new
+    node4 = Souffle::Node.new
+
+    node1.dependencies << "role[awesomeone]"
+    node2.dependencies << "recipe[bleh]"
+
+    @system.add(node1)
+    @system.add(node2)
+    @system.add(node3)
+    @system.add(node4)
+
+    @system.roots.to_set.should eql(Set.new([node3, node4]))
   end
 
-  it "should be able to setup an AWS provider" do
-    @system = Souffle::System.new("AWS")
-    @system.provider.name.should eql("AWS")
+  it "should be able to add a root node" do
+    node = Souffle::Node.new
+    @system.add(node)
+    @system.roots.should eql([node])
   end
 
-  it "should raise an InvalidProvider error when the provider doesn't exist" do
-    d = lambda { @system = Souffle::System.new("UnholyProviderOfBadness") }
-    d.should raise_error
+  it "should be able to determine dependant nodes" do
+    node1 = Souffle::Node.new
+    node2 = Souffle::Node.new
+
+    node1.run_list     << "role[some_silly_role]"
+    node2.dependencies << "role[some_silly_role]"
+
+    @system.add(node1)
+    @system.add(node2)
+
+    @system.rebalance_nodes
+    @system.dependent_nodes.should eql([node2])
   end
 
-  it "should be able to add a root node" do
+  it "should be able to clear all nodes parent and child heirarchy" do
+    node1  = Souffle::Node.new
+    node2 = Souffle::Node.new
+
+    node1.run_list     << "role[some_silly_role]"
+    node2.dependencies << "role[some_silly_role]"
+
+    @system.add(node1)
+    @system.add(node2)
+    @system.rebalance_nodes
+
+    node1.children.include?(node2).should eql(true)
+    node2.parents.include?(node1).should eql(true)
+
+    @system.clear_node_heirarchy
+    node1.children.should eql([])
+    node2.parents.should eql([])
+  end
+
+  it "should be able to get the node dependencies on a system" do
+    node1  = Souffle::Node.new
+    node2 = Souffle::Node.new
+    node3 = Souffle::Node.new
+
+    node1.dependencies << "role[example_role]"
+    node1.dependencies << "recipe[the_best_one]"
+
+    node2.run_list << "role[example_role]"
+    node3.run_list << "recipe[the_best_one]"
+
+    @system.add(node1)
+    @system.add(node2)
+    @system.add(node3)
+
+    @system.dependencies_on_system(node1).should eql(
+      [ [node2, [Souffle::Node::RunListItem.new("role[example_role]")] ],
+        [node3, [Souffle::Node::RunListItem.new("recipe[the_best_one]")] ]
+      ] )
+  end
+
+  it "should be able to optimize a rebalanced system of nodes" do
+    target = Souffle::Node.new
+    heavy1 = Souffle::Node.new
+    heavy2 = Souffle::Node.new
+    root_node = Souffle::Node.new
+    light_node = Souffle::Node.new
+
+    target.dependencies << "role[example_role]"
+    target.dependencies << "recipe[the_best_one]"
+
+    heavy1.run_list << "role[example_role]"
+    heavy2.run_list << "recipe[the_best_one]"
+    heavy1.dependencies << "recipe[heavy]"
+    heavy2.dependencies << "recipe[heavy]"
+
+    root_node.run_list << "recipe[heavy]"
+
+    light_node.run_list << "role[example_role]"
+    light_node.run_list << "recipe[the_best_one]"
+
+    @system.add(target)
+    @system.add(heavy1)
+    @system.add(heavy2)
+    @system.add(root_node)
+    @system.add(light_node)
+
+    @system.rebalance_nodes
+    @system.optimized_node_dependencies(target).should eql([light_node])
+  end
+
+    it "should have children nodes that can identify the system" do
+    target = Souffle::Node.new
+    heavy1 = Souffle::Node.new
+    heavy2 = Souffle::Node.new
+    root_node = Souffle::Node.new
+    light_node = Souffle::Node.new
+
+    target.dependencies << "role[example_role]"
+    target.dependencies << "recipe[the_best_one]"
+
+    heavy1.run_list << "role[example_role]"
+    heavy2.run_list << "recipe[the_best_one]"
+    heavy1.dependencies << "recipe[heavy]"
+    heavy2.dependencies << "recipe[heavy]"
+
+    root_node.run_list << "recipe[heavy]"
+
+    light_node.run_list << "role[example_role]"
+    light_node.run_list << "recipe[the_best_one]"
+
+    @system.add(target)
+    @system.add(heavy1)
+    @system.add(heavy2)
+    @system.add(root_node)
+    @system.add(light_node)
+
+    @system.rebalance_nodes
+    @system.nodes.each { |n| n.system.should eql(@system) }
+  end
+
+  it "should raise an exception on an incorrect system hash" do
+    sys = {}
+    lambda { Souffle::System.from_hash(sys) }.should raise_error
+  end
+
+  it "should be able to get system options with try_opt" do
+    @system.options[:example_opt] = "sporkmejohhny"
+    @system.try_opt(:example_opt).should eql("sporkmejohhny")
+  end
+
+  it "should pass-thru to config options when they do not exist" do
+    Souffle::Config[:example_passthru] = "blehk"
+    @system.try_opt(:example_passthru).should eql("blehk")
+    Souffle::Config.configuration.delete(:example_passthru)
+  end
+
+  it "should let child nodes get system opts with pass-thru" do
     node = Souffle::Node.new
-    @system.root = node
-    @system.root.should eql(node)
+    @system.add(node)
+    @system.options[:example_opt] = "sporkmejohhny"
+    @system.nodes.first.try_opt(:example_opt).should eql("sporkmejohhny")
+  end
+
+  it "should pass-thru to config options when they do not exist" do
+    Souffle::Config[:example_passthru] = "blehk"
+    @system.try_opt(:example_passthru).should eql("blehk")
+    Souffle::Config.configuration.delete(:example_passthru)
+  end
+
+  it "should be able to generate a system from a hash" do
+    sys = {
+      :nodes => [
+        { :name => "parent_node",
+          :run_list => ["role[somerole]"],
+          :dependencies => [] },
+        { :name => "lone_node",
+          :run_list => ["role[bestone]"],
+          :dependencies => [] },
+        { :name => "child_node",
+          :run_list => ["recipe[base]"],
+          :dependencies => ["role[somerole]"] }
+      ]
+    }
+
+    new_sys = Souffle::System.from_hash(sys)
+    new_sys.rebalance_nodes
+
+    parent = new_sys.nodes.select { |n| n.name == "parent_node" }.first
+    parent.children.first.name.should eql("child_node")
+    new_sys.roots.size.should eql(2)
+    new_sys.dependent_nodes.size.should eql(1)
   end
 
-  it "should have an initial state of `:uninitialized`" do
-    @system.state_name.should eql(:uninitialized)
+  it "should be able to generate system options and merge from a hash" do
+    sys = {
+      :options => { :type => "chef" },
+      :nodes => [
+        { :name => "parent_node",
+          :options => { :type => "chef-solo" },
+          :run_list => ["role[somerole]"],
+          :dependencies => [] },
+        { :name => "lone_node",
+          :run_list => ["role[bestone]"],
+          :dependencies => [] },
+        { :name => "child_node",
+          :run_list => ["recipe[base]"],
+          :dependencies => ["role[somerole]"] }
+      ]
+    }
+
+    new_sys = Souffle::System.from_hash(sys)
+    new_sys.rebalance_nodes
+
+    parent = new_sys.nodes.select { |n| n.name == "parent_node" }.first
+    parent.children.first.name.should eql("child_node")
+    parent.options.should eql({ :attributes => {}, :type => "chef-solo" })
+    parent.children.first.options.should eql({
+      :attributes => {}, :type => "chef" })
+    
+    new_sys.roots.size.should eql(2)
+    new_sys.dependent_nodes.size.should eql(1)
+  end
+
+  it "should have the same system in a hash format as it does in dsl" do
+    sys = {
+      :nodes => [
+        { :name => "MasterNode",
+          :run_list => [  "recipe[gem]",
+                          "recipe[git]" ],
+          :options  => {
+            :gem => { :source => "http://gem.test.com" },
+            :aws_ebs_size => 10,
+            :volume_count => 2
+          }
+        }
+      ]
+    }
+
+    sys2 = Souffle::System.new
+    masternode = Souffle::Node.new
+    masternode.name = "MasterNode"
+    masternode.run_list << "recipe[gem]"
+    masternode.run_list << "recipe[git]"
+    masternode.options[:gem] = { :source => "http://gem.test.com" }
+    masternode.options[:aws_ebs_size] = 10
+    masternode.options[:volume_count] = 2
+    sys2.add(masternode)
+
+    new_sys = Souffle::System.from_hash(sys)
+
+    parent = new_sys.nodes.select { |n| n.name == "MasterNode" }.first
+    parent.run_list.should eql(masternode.run_list)
+    parent.options.should eql(masternode.options)
   end
 end