toft 0.0.2

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,57 @@
+PATH
+  remote: .
+  specs:
+    toft (0.0.1)
+      net-ssh
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    archive-tar-minitar (0.5.2)
+    builder (3.0.0)
+    cucumber (1.1.0)
+      builder (>= 2.1.2)
+      diff-lcs (>= 1.1.2)
+      gherkin (~> 2.5.0)
+      json (>= 1.4.6)
+      term-ansicolor (>= 1.0.6)
+    diff-lcs (1.1.3)
+    erubis (2.7.0)
+    ffi (1.0.9)
+    gherkin (2.5.1)
+      json (>= 1.4.6)
+    i18n (0.6.0)
+    json (1.5.4)
+    net-scp (1.0.4)
+      net-ssh (>= 1.99.1)
+    net-ssh (2.1.4)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.4)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+    term-ansicolor (1.0.6)
+    thor (0.14.6)
+    vagrant (0.8.7)
+      archive-tar-minitar (= 0.5.2)
+      erubis (~> 2.7.0)
+      i18n (~> 0.6.0)
+      json (~> 1.5.1)
+      net-scp (~> 1.0.4)
+      net-ssh (~> 2.1.4)
+      thor (~> 0.14.6)
+      virtualbox (~> 0.9.1)
+    virtualbox (0.9.2)
+      ffi (~> 1.0.9)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  cucumber
+  rspec
+  toft!
+  vagrant (>= 0.8.7)

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/features/checker.feature

@@ -0,0 +1,14 @@
+Feature: Checkers provided by Toft to help you verify system state
+
+Scenario: Dir checker
+	Given I have a clean running node "n1" with ip "192.168.20.2"
+	Then Node "n1" should have "directory" "/tmp" owned by user "root" and group "root" with permission "1777"
+	Then Node "n1" should have not file or directory "/non-exist-dir"
+	Then Node "n1" should have file or directory "tmp"
+	
+Scenario: File checker
+	Given I have a clean running node "n1" with ip "192.168.20.2"
+	When Running ssh command "if getent passwd n1; then userdel n1; fi; useradd -m n1" on "n1" should succeed
+	And Running ssh command "sudo -u n1 touch /tmp/a" on "n1" should succeed
+	Then Node "n1" should have file or directory "/tmp/a"
+	And Node "n1" should have "regular empty file" "/tmp/a" owned by user "n1" and group "n1" with permission "644"	

data/features/chef.feature

@@ -0,0 +1,52 @@
+Feature: Chef support
+
+Scenario: Run chef recipe on nodes 
+	Given I have a clean running node "n1" with ip "192.168.20.2"
+	When I run "recipe[test]" on node "n1"
+	Then Node "n1" should have file or directory "/tmp/stub/dir"
+
+Scenario: Run chef recipe with attributes
+	Given I have a clean running node "n1" with ip "192.168.20.2"
+	When I run "recipe[test::attribute]" on node "n1" and overwrite attributes with:
+		|key|value|
+		|one|one|
+		|two.one|two_one|
+		|two.two|two_two|
+		|three|three|
+	Then Node "n1" should have file or directory "/tmp/stub/one"
+	Then Node "n1" should have file or directory "/tmp/stub/two_one"
+	Then Node "n1" should have file or directory "/tmp/stub/two_two"
+	Then Node "n1" should have file or directory "/tmp/stub/three"
+	
+Scenario: Run multiple chef recipes
+	Given I have a clean running node "n1" with ip "192.168.20.2"
+	When I run recipes on node "n1":
+		|recipe|
+		|recipe[test::role]|
+		|recipe[test]|
+	Then Node "n1" should have file or directory "/tmp/stub/dir"
+	Then Node "n1" should have file or directory "/tmp/stub/role"
+
+Scenario: Run chef role
+	Given I have a clean running node "n1" with ip "192.168.20.2"
+	When I run "role[test]" on node "n1"
+	Then Node "n1" should have file or directory "/tmp/stub/role"
+
+Scenario: Toft should not deal with empty cookbook and role path
+	Given I have a clean running node "n1" with ip "192.168.20.2"
+	When I set the role path to empty
+	Then Running chef "recipe[test]" on node "n1" should succeed
+	When I set the cookbook path to empty
+	Then Running chef "recipe[test]" on node "n1" should fail
+
+Scenario: Run non-exist recipe
+
+Scenario: Run non-exist role
+
+
+
+
+
+
+
+

data/features/command.feature

@@ -0,0 +1,19 @@
+Feature: Run ssh command on node
+
+Scenario: Run command on node successfully
+	Given I have a clean running node "n1" with ip "192.168.20.2"
+	Then Running ssh command "" on "n1" should fail
+	And Running ssh command "ps" on "n1" should succeed
+	And Running ssh command "non-exist-command" on "n1" should fail
+	And Running ssh command "netstat -nr" on "n1" should succeed
+	
+Scenario: Test rm
+	Given I have a clean running node "n1" with ip "192.168.20.2"
+	Then Rm "" on "n1" should fail
+	And Rm "tmp/*" on "n1" should fail
+	And Rm "/tmp/*" on "n1" should succeed
+	
+Scenario: Check ssh command result
+	Given I have a clean running node "n1" with ip "192.168.20.2"
+	Then the result of running ssh command "ps" on "n1" should contain "sshd"
+	

data/features/node.feature

@@ -0,0 +1,21 @@
+Feature: Node management
+
+Scenario: Start or stop node
+	Given I have a clean running node "n1" with ip "192.168.20.2"
+	Then the node "n1" should be running
+	When I stop node "n1"
+	Then the node "n1" should be stopped
+	When I start node "n1"
+	Then the node "n1" should be running
+
+Scenario: Create or destroy node 
+	Given I have a clean running node "n1" with ip "192.168.20.2"
+	Then There should be 1 nodes in the environment
+	When I add another node "n2" with ip "192.168.20.3"
+	Then There should be 2 nodes in the environment
+	When I destroy node "n2"
+	Then There should be 1 nodes in the environment
+	When Node "n1" is destroyed
+	Then There should be 0 nodes in the environment	
+	
+	

data/features/step_definitions/checker.rb

@@ -0,0 +1,15 @@
+Then /^Node "([^"]*)" should have not file or directory "([^"]*)"$/ do |node, dirpath|
+  find(node).file(dirpath).should_not be_exist
+end
+
+Then /^Node "([^"]*)" should have file or directory "([^"]*)"$/ do |node, dirpath|
+  find(node).file(dirpath).should be_exist
+end
+
+Then /^Node "([^"]*)" should have "([^"]*)" "([^"]*)" owned by user "([^"]*)" and group "([^"]*)" with permission "([^"]*)"$/ do |node, type, dirpath, user, group, mode|
+  file = find(node).file(dirpath)
+  file.filetype.should == type
+  file.owner.should == user
+  file.group.should == group
+  file.mode.should == mode
+end

data/features/step_definitions/chef.rb

@@ -0,0 +1,35 @@
+When /^I run "([^"]*)" on node "([^"]*)"$/ do |run_list, node|
+  find(node).run_chef run_list
+end
+
+When /^I run recipes on node "([^"]*)":$/ do |node, recipes_table|
+  recipes = []
+  recipes_table.hashes.each do |row|
+    recipes << row[:recipe]
+  end
+  find(node).run_chef recipes  
+end
+
+When /^I run "([^"]*)" on node "([^"]*)" and overwrite attributes with:$/ do |run_list, node, table|
+  find(node).run_chef run_list, Toft::ChefAttributes.new(table)
+end
+
+When /^I set the role path to empty$/ do
+  Toft.role_path = ""
+  @n1.rm "/tmp/*"
+end
+
+Then /^Running chef "([^"]*)" on node "([^"]*)" should succeed$/ do |run_list, node|
+  result = false
+  lambda { result = find(node).run_chef(run_list) }.should_not raise_error
+  result.should be_true
+end
+
+When /^I set the cookbook path to empty$/ do
+  Toft.cookbook_path = ""
+  @n1.rm "/tmp/*"  
+end
+
+Then /^Running chef "([^"]*)" on node "([^"]*)" should fail$/ do |run_list, node|
+  lambda { find(node).run_chef(run_list) }.should raise_error
+end

data/features/step_definitions/command.rb

@@ -0,0 +1,21 @@
+Then /^Running ssh command "([^"]*)" on "([^"]*)" should succeed$/ do |cmd, node|
+  find(node).run_ssh(cmd).should be_true
+end
+
+Then /^Running ssh command "([^"]*)" on "([^"]*)" should fail$/ do |cmd, node|
+  lambda { find(node).run_ssh(cmd) }.should raise_error
+end
+
+Then /^Rm "([^"]*)" on "([^"]*)" should fail$/ do |dir, node|
+  lambda { find(node).rm(dir) }.should raise_error  
+end
+
+Then /^Rm "([^"]*)" on "([^"]*)" should succeed$/ do |dir, node|
+  lambda { find(node).rm(dir) }.should_not raise_error  
+end
+
+Then /^the result of running ssh command "([^"]*)" on "([^"]*)" should contain "([^"]*)"$/ do |cmd, node, s|
+  find(node).run_ssh(cmd) do |output|
+    output.should include(s)
+  end
+end

data/features/step_definitions/node.rb

@@ -0,0 +1,38 @@
+Given /^I have a clean running node "([^"]*)" with ip "([^"]*)"$/ do |node, ip|
+  create_node node, ip
+  @n1.start
+  @n1.rm "/tmp/stub"
+end
+
+When /^I add another node "([^"]*)" with ip "([^"]*)"$/ do |node, ip|
+  create_node node, ip  
+end
+
+When /^I destroy node "([^"]*)"$/ do |node|
+  destroy_node node
+end
+
+When /^Node "([^"]*)" is destroyed$/ do |node|
+  find(node).destroy
+end
+
+Then /^There should be ([^"]*) nodes in the environment$/ do |count|
+  node_count.should == count.to_i
+end
+
+Then /^the node "([^"]*)" should be stopped$/ do |node|
+  find(node).should_not be_running
+end
+
+When /^I start node "([^"]*)"$/ do |node|
+  find(node).start
+end
+
+When /^I stop node "([^"]*)"$/ do |node|
+  find(node).stop
+end
+
+Then /^the node "([^"]*)" should be running$/ do |node|
+  find(node).should be_running
+end
+

data/features/support/env.rb

@@ -0,0 +1,19 @@
+$:.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'rspec/expectations'
+require 'toft'
+
+Toft.cookbook_path = File.dirname(__FILE__) + '/../../fixtures/chef/cookbooks'
+Toft.role_path = File.dirname(__FILE__) + '/../../fixtures/chef/roles'
+
+World(Toft)
+
+include Toft
+n1 = create_node "n1", "192.168.20.2"
+
+Before do
+  @n1 = n1
+end
+
+at_exit do
+  n1.destroy
+end

data/fixtures/chef/cookbooks/test/attributes/default.rb

@@ -0,0 +1,4 @@
+default[:one] = "test"
+default[:three] = "test"
+default[:two][:one] = "test"
+default[:two][:two] = "test"

data/fixtures/chef/cookbooks/test/recipes/attribute.rb

@@ -0,0 +1,19 @@
+directory "/tmp/stub/#{node.one}" do
+  action :create
+  recursive true
+end
+
+directory "/tmp/stub/#{node.two.two}" do
+  action :create
+  recursive true
+end
+
+directory "/tmp/stub/#{node.two.one}" do
+  action :create
+  recursive true
+end
+
+directory "/tmp/stub/#{node.three}" do
+  action :create
+  recursive true
+end

data/fixtures/chef/cookbooks/test/recipes/default.rb

@@ -0,0 +1,4 @@
+directory "/tmp/stub/dir" do
+  action :create
+  recursive true
+end

data/fixtures/chef/cookbooks/test/recipes/role.rb

@@ -0,0 +1,4 @@
+directory "/tmp/stub/role" do
+  action :create
+  recursive true
+end

data/fixtures/chef/roles/test.rb

@@ -0,0 +1,3 @@
+name 'test'
+description 'Test!'
+run_list "recipe[test::role]"

data/lib/toft/chef/chef_attributes.rb

@@ -0,0 +1,29 @@
+require 'json'
+
+module Toft
+  class ChefAttributes
+    attr_reader :attributes
+    
+    def initialize(cuke_ast_table)
+      @attributes = {}
+      cuke_ast_table.hashes.each do |row|
+        add_attribute row[:key], row[:value]
+      end
+    end
+    
+    def add_attribute(key, value)
+      stat = "attributes"
+      head = attributes
+      key.split(".").each do |k|
+        head[k] ||= Hash.new
+        head = head[k]
+        stat += "[\"#{k}\"]"
+      end
+      eval "#{stat}=\"#{value}\""
+    end
+    
+    def to_json
+      attributes.to_json
+    end
+  end
+end

data/lib/toft/chef/chef_runner.rb

@@ -0,0 +1,64 @@
+require 'toft/chef/chef_attributes'
+require 'fileutils'
+
+module Toft
+  module Chef
+    class ChefRunner
+      include FileUtils
+      
+      DEST_CHEF_TMP = "/tmp/toft-chef-tmp"
+      DEST_COOKBOOK_PATH = "#{DEST_CHEF_TMP}/cookbooks"
+      DEST_ROLE_PATH = "#{DEST_CHEF_TMP}/roles"
+      DEST_CHEF_SOLO_PATH = "#{DEST_CHEF_TMP}/solo.rb" 
+      DEST_CHEF_JSON_PATH = "#{DEST_CHEF_TMP}/solo.json" 
+
+      def initialize(root_dir, &command_runner)
+        @root_dir = root_dir
+        @command_runner = command_runner
+      end
+
+      def run(run_list, chef_attributes)
+        copy_chef_material
+        generate_solo_rb
+        generate_json ([] << run_list).flatten, chef_attributes
+        @command_runner.call "chef-solo -c #{DEST_CHEF_SOLO_PATH} -j #{DEST_CHEF_JSON_PATH}"
+      end
+
+      private 
+      def copy_chef_material
+        rm_rf "#{@root_dir}#{DEST_CHEF_TMP}"  
+        mkdir_p "#{@root_dir}#{DEST_CHEF_TMP}"
+        cp_r Toft.cookbook_path, "#{@root_dir}#{DEST_COOKBOOK_PATH}"
+        cp_r Toft.role_path, "#{@root_dir}#{DEST_ROLE_PATH}" unless roles_missing?
+      end
+
+      def roles_missing?
+        Toft.role_path.blank?
+      end
+
+      def generate_solo_rb
+        solo = <<-EOF
+file_cache_path "/tmp/chef-file-cache"
+cookbook_path ["#{DEST_COOKBOOK_PATH}"]
+        EOF
+        solo += "role_path [\"#{DEST_ROLE_PATH}\"]" unless roles_missing?
+
+        File.open("#{@root_dir}#{DEST_CHEF_SOLO_PATH}", 'w') do |f|
+          f.write(solo);
+        end
+      end
+
+      def generate_json(run_list, chef_attributes)
+        run_list = {"run_list" => run_list}
+        run_list.merge!(chef_attributes.attributes) unless chef_attributes.nil?
+        File.open("#{@root_dir}#{DEST_CHEF_JSON_PATH}", 'w') do |f|
+          f.write(run_list.to_json);
+        end
+      end
+
+      def cmd(cmd)
+        raise "Command execution failed: [#{cmd}]" unless system cmd
+      end
+    end
+  end
+end

data/lib/toft/file_checker.rb

@@ -0,0 +1,42 @@
+module Toft
+  class FileChecker
+    def initialize(rootfs, path)
+      @rootfs = rootfs
+      @path = path
+    end
+        
+    def exist?
+      test("-e")
+    end
+    
+    def directory?
+      filetype == "directory"
+    end
+    
+    def filetype
+      stat("%F")
+    end
+    
+    def owner
+      stat("%U")
+    end
+
+    def group
+      stat("%G")
+    end
+    
+    def mode
+      stat("%a")
+    end
+    
+    private 
+    def stat(format)
+      `chroot #{@rootfs} stat -c #{format} #{@path}`.rstrip      
+    end
+    
+    def test(op)
+      system("chroot #{@rootfs} test #{op} #{@path}")
+      $? == 0 ? true : false
+    end
+  end
+end

data/lib/toft/node.rb

@@ -0,0 +1,140 @@
+require 'observer'
+require 'net/ssh'
+require 'ping'
+require 'toft/file_checker'
+
+module Toft
+  class Node
+    PRIVATE_KEY = <<-EOF
+-----BEGIN RSA PRIVATE KEY-----
+MIIEpAIBAAKCAQEAwoLge1y9wEcy2WC7CDGXuFFDt+9Zvh+QulfDIbZkpYF7YBw6
+O3mYTUpucwnqMhnd9jini8bsQghJF3wwxdWmtmurcHAEhN6ZljXZwUu2rojh+D+4
+PnkOAMPb+w3REmyFYBxfzQ4gBBRXZgKWDTN6Al9hYRFTVSsZJCKJFK+GsWBSc5ie
+l6IuUnfCbTwvORWVV6g7nGQ5x0JTnApG0qNFDprFkBsLbvHlB6A3lBtHQfJ7W/cZ
+QXi3LXawD4bhWAl/CHxZHXGpJM7+tREz2yhOoPcHUwwv0xHqe/wBxmJmq84kZ8Co
+lTi9Y5xNXKDiS6svMDgt3ShpkWcvQ+LE3PhUVQIDAQABAoIBAQCEvfZemeLw9mXw
+TYA2TknhQqw5OYIAKuCFGuGS/ztea6f75iejcQ8MKDCKF4kZGegNYYqN7HpNcgQX
+n+xVBsJYGdCM0hVza8pa5XMu4/HO2KGF3k5pbAmvYfqdMUeuEBtRhOuoL+yPfCZM
++pTWe3vXZKo7KSy6ocftjhgI4uTD5OtUHZe+Q61K8Ng5723kk4KcbZo4LHEvj4C2
+nnplt9uxiS04qTPuJohxiwE1pbSybaH5Kndfvzmh1A1q/HKCZNhQKK/jhgvDBtBu
+hiDfPtKdEeSTbFm11ckJBE1HPdAXoppxwDHQzcq82+vNJdB2P2TsMPklPRb6FuDa
+dCQ0B5IBAoGBAPUlki+Q6yC4snhJ7r0ipIiMimB+Q6UlrE6ayyc3s/akjvTaqs2z
+tcZTPUVVLjs0WIRIYwOWMcNmMZoi2s8nGsDiljmd1+smWHPK8A9X8pSUH6Z5k7sS
+fzno3ytRXohyR2UB6iuUoT3F0VEnaaDjLlNk77DYusAmMsrm8W5PkMHVAoGBAMsf
+aocc8yrwC7Wa0xfeNreK4F3OayqP6xAu0aSXqj1gtJ6HTTgY2g4jqtnV40NVXwHK
+7zA4ie5IfmQ/672Te+9ifeWYNqv8faHDJwZFbZ2LwPW/lm5i4Ezn9KMmpLTz+6yj
+f1bS+Y0NYyxfs1nn7Lx/kvuJVdIV+Ktma+ZHGAiBAoGAHo6NV0KAHHcJP/cvPAIa
+ci7afMagVfCJNs8SrZPC6eZ/L0QmcDeLW+o6Q+8nMRgIRIzlUqghEdMmMalQjuu3
+6P0Vbp8fL996vQw5uh/jS+Pewhh7cqEOnMBLORIOb4GXJp8DemUvaAzFV5FLGFPZ
+DWoSen+5X4QjZqk8xNxEFfUCgYB+xR6xMMo69BH6x6QTc2Zm6s/Y++k6aRPlx7Kj
+rNxc7iwL/Jme9zOwO2Z4CduKvI9NCSB60e6Tvr7TRmmUqaVh4/B7CKKmeDDYcnm6
+mj4tY3mMZoQ2ZJNkrCesY4PMQ7HBL1FcGNQSylYo7Zl79Rl1E5HiVvYu5fOK1aNl
+1t0TAQKBgQCaN91JXWJFXc1rJsDy365SKrX00Nt8rZolFQy2UhhERoCxD0uwbOYm
+sfWYRr79L2BZkyRHmuxCD24SvHibDev+T0Jh6leXjnrwd/dj3P0tH8+ctET5SXsD
+CQWv13UgQjiHgQILXSb7xdzpWK1wpDoqIEWQugRyPQDeZhPWVbB4Lg==
+-----END RSA PRIVATE KEY-----    
+    EOF
+    
+    include Observable
+
+    def initialize(hostname, ip)
+      @hostname = hostname
+      @ip = ip
+      unless exists?
+        conf_file = generate_lxc_config
+        system "lxc-create -n #{hostname} -f #{conf_file} -t lucid-chef" 
+      end
+      @chef_runner = Toft::Chef::ChefRunner.new("#{rootfs}") do |chef_command|
+        run_ssh chef_command
+      end
+    end
+
+    def exists?
+      `lxc-ls` =~ /#{@hostname}/
+    end
+
+    def start
+      `lxc-start -n #{@hostname} -d`
+      `lxc-wait -n #{@hostname} -s RUNNING`
+      wait_ssh_ready
+    end
+
+    def stop
+      `lxc-stop -n #{@hostname}`
+      `lxc-wait -n #{@hostname} -s STOPPED`
+    end
+
+    def destroy
+      stop
+      `lxc-destroy -n #{@hostname}`
+      changed
+      notify_observers(@hostname)
+    end
+
+    def running?
+      `lxc-info -n #{@hostname}` =~ /RUNNING/
+    end
+
+    def run_ssh(command)
+      raise ArgumentError, "Trying to run empty command on node #{@hostname}", caller if command.blank?
+      output = ""
+      Net::SSH.start(@ip, "root", :key_data => [PRIVATE_KEY]) do |ssh|
+        ssh.exec! command do |ch, stream, data|
+          if stream == :stderr
+            raise RuntimeError, data, caller
+          else
+            output += data
+          end
+        end
+      end
+      puts output
+      yield output if block_given?
+      return true
+    end
+
+    def rm(dir)
+      raise ArgumentError, "Illegal dir path: [#{dir}]", caller if dir.blank? || dir[0] != ?/
+      system "rm -rf #{rootfs}#{dir}"
+    end
+
+    def run_chef(run_list, chef_attributes = nil)
+      @chef_runner.run run_list, chef_attributes
+    end
+
+    def file(path)
+      FileChecker.new(rootfs, path)
+    end
+
+    private
+    def rootfs
+      "/var/lib/lxc/#{@hostname}/rootfs"
+    end
+
+    def wait_ssh_ready
+      while true
+        netstat = `lxc-netstat --name #{@hostname} -ta`        
+        break if netstat =~ /ssh/
+      end
+      while true
+        break if Ping.pingecho @ip, 0.1
+        sleep 0.5
+      end
+      puts "SSH connection on #{@ip} is ready..."
+    end
+
+    def generate_lxc_config
+      conf = <<-EOF
+lxc.network.type = veth
+lxc.network.flags = up
+lxc.network.link = br0
+lxc.network.name = eth0
+lxc.network.ipv4 = #{@ip}/24
+      EOF
+      conf_file = "/tmp/#{@hostname}-conf"
+      File.open(conf_file, 'w') do |f|
+        f.write(conf);
+      end
+      return conf_file
+    end
+  end
+end

data/lib/toft/node_controller.rb

@@ -0,0 +1,32 @@
+require 'toft/node'
+
+module Toft
+  class NodeController    
+    attr_reader :nodes
+    
+    def initialize
+      @nodes = {}
+    end
+    
+    def create_node(hostname, ip)
+      node = Node.new(hostname, ip)
+      node.add_observer self
+      @nodes[hostname] = node
+    end
+    
+    def update(hostname)
+      @nodes.delete hostname
+    end
+    
+    def destroy_node(hostname)
+      @nodes[hostname].destroy
+    end
+    
+    @@instance = NodeController.new
+    class << self
+      def instance
+        @@instance
+      end
+    end
+  end
+end

data/lib/toft/version.rb

@@ -0,0 +1,3 @@
+module Toft
+  VERSION = "0.0.2"
+end