cucumber-chef 2.1.0.rc.1 → 2.1.0.rc.2

data/bin/cc-knife

@@ -14,7 +14,7 @@ if (test_lab = Cucumber::Chef::TestLab.new) && (test_lab.labs_running.count > 0)
 
   knife_rb = Cucumber::Chef.knife_rb
   if File.exists?(knife_rb)
-    command = [knife, ARGV, "--server-url http://#{test_lab.labs_running.first.public_ip_address}:4000", "--config #{knife_rb}", "2>&1"].flatten.compact.join(" ")
+    command = [knife, ARGV, "--server-url http://#{test_lab.ip}:4000", "--config #{knife_rb}", "2>&1"].flatten.compact.join(" ")
     puts(command)
     puts(%x(#{command}))
     exit($?.to_i)

data/bin/cc-push

@@ -13,12 +13,12 @@ end
 
 tag = Cucumber::Chef.tag("cc-push")
 puts(tag)
-Cucumber::Chef.load_config(tag)
+Cucumber::Chef.boot(tag)
 $logger = Cucumber::Chef.logger
 
 if ($test_lab = Cucumber::Chef::TestLab.new) && ($test_lab.labs_running.count > 0)
   gem_name = "cucumber-chef-#{Cucumber::Chef::VERSION}.gem"
-  gem_path = File.join(Cucumber::Chef.root, gem_name)
+  gem_path = File.join(Cucumber::Chef.root_dir, gem_name)
 
   $logger.info { "gem_name == '#{gem_name}'" }
   $logger.info { "gem_path == '#{gem_path}'" }
@@ -27,29 +27,24 @@ if ($test_lab = Cucumber::Chef::TestLab.new) && ($test_lab.labs_running.count >
     puts
     puts("To build cucumber-chef and install the gem in to the test lab, execute:")
     puts
-    puts [ "cd #{Cucumber::Chef.root}", "gem build cucumber-chef.gemspec", "cd #{Dir.pwd}", "bundle exec cc-push" ].join(" ; ")
+    puts [ "cd #{Cucumber::Chef.root_dir}", "gem build cucumber-chef.gemspec", "cd #{Dir.pwd}", "bundle exec cc-push" ].join(" ; ")
     puts
   else
-    local_file = File.join(Cucumber::Chef.root, gem_name)
+    local_file = File.join(Cucumber::Chef.root_dir, gem_name)
     remote_file = File.join("/", "home", $test_lab.ssh.config.user, gem_name)
-    $logger.info { "#{local_file} -> #{$test_lab.ssh.config.user}@#{$test_lab.labs_running.first.public_ip_address}:#{remote_file}" }
+    $logger.info { "#{local_file} -> #{$test_lab.ssh.config.user}@#{$test_lab.ip}:#{remote_file}" }
 
     $test_lab.ssh.upload(local_file, remote_file)
-    FileUtils.rm_f(File.join(Cucumber::Chef.root, "*.gem"))
+    FileUtils.rm_f(File.join(Cucumber::Chef.root_dir, "*.gem"))
 
     run_remote(<<-EOH
 sudo /bin/bash -c '
 cd #{File.dirname(remote_file)}
-
-gem uninstall ztk --all --ignore-dependencies --executables --verbose --backtrace
-gem cleanup ztk --verbose --backtrace
-gem install ztk --verbose --backtrace
-
 ls -la | grep 'cucumber-chef-'
-gem uninstall cucumber-chef --all --ignore-dependencies --executables --verbose --backtrace
+gem uninstall cucumber-chef --all --ignore-dependencies --executables --backtrace
 rm -fv /usr/lib/ruby/gems/1.8/cache/#{gem_name}
-gem cleanup cucumber-chef --verbose --backtrace
-gem install #{gem_name} --local --verbose --backtrace
+gem cleanup cucumber-chef --backtrace
+gem install #{remote_file} --backtrace
 rm -fv /home/#{$test_lab.ssh.config.user}/*.gem'
 EOH
     )

data/bin/cc-server

@@ -13,8 +13,6 @@ if !ENV['BACKGROUND'].nil?
   end
 end
 
-Dir.chdir(File.join("/home", "ubuntu"))
-
 require 'drb/drb'
 require 'drb/acl'
 require 'cucumber-chef'
@@ -29,8 +27,9 @@ class FrontObject
   def initialize
     tag = Cucumber::Chef.tag("cc-server")
     puts("  * #{tag}")
-    Cucumber::Chef.load_config(tag)
+    Cucumber::Chef.boot(tag)
     $logger = Cucumber::Chef.logger
+    Dir.chdir(File.join("/home", Cucumber::Chef.lab_user))
   end
 
   def shutdown

data/bin/cucumber-chef

@@ -35,8 +35,6 @@ class CucumberChef < Thor
       source_dir = File.expand_path(File.join(File.dirname(__FILE__), "..", "lib", "cucumber", "chef", "templates", "cucumber"))
       destination_dir = Cucumber::Chef.locate_parent(".chef")
 
-      @is_rc = Cucumber::Chef.is_rc?
-
       CucumberChef.source_root source_dir
       templates = {
         "readme.erb" => "features/#{project}/README",
@@ -55,12 +53,14 @@ class CucumberChef < Thor
       end
     end
 
-    def load_config
+    def boot
       tag = Cucumber::Chef.tag("cucumber-chef")
       puts(set_color(tag, :green, true))
-      Cucumber::Chef.load_config(tag)
+      Cucumber::Chef.boot(tag)
       $logger = Cucumber::Chef.logger
 
+      @is_rc = Cucumber::Chef.is_rc?
+
       @options.test? and Cucumber::Chef::Config.test
     end
 
@@ -123,17 +123,19 @@ class CucumberChef < Thor
     initalize_config
   end
 
+################################################################################
+# SETUP
 ################################################################################
 
   desc "setup", "Setup cucumber-chef test lab in Amazon EC2"
   method_option :test, :type => :boolean, :desc => "INTERNAL USE ONLY"
   def setup
-    load_config
+    boot
 
     puts
     if (test_lab = Cucumber::Chef::TestLab.new)
-      if (server = test_lab.create)
-        if (provisioner = Cucumber::Chef::Provisioner.new(server))
+      if (provider = test_lab.create)
+        if (provisioner = Cucumber::Chef::Provisioner.new(test_lab))
 
           provisioner.build
 
@@ -143,7 +145,7 @@ class CucumberChef < Thor
           puts("Be sure to log into the chef-server webui and change the default credentials.")
           puts
           puts("  Chef-Server WebUI:")
-          puts("    http://#{server.public_ip_address}:4040/")
+          puts("    http://#{test_lab.ip}:4040/")
           puts("  Username:")
           puts("    admin")
           puts("  Password:")
@@ -165,12 +167,14 @@ class CucumberChef < Thor
     fatal(e.message)
   end
 
+################################################################################
+# TEARDOWN
 ################################################################################
 
   desc "teardown [container]", "Teardown the cucumber-chef test lab in Amazon EC2 or a test lab [container] if specified."
   method_option :test, :type => :boolean, :desc => "INTERNAL USE ONLY"
   def teardown(*args)
-    load_config
+    boot
 
     puts
     if (test_lab = Cucumber::Chef::TestLab.new)
@@ -210,7 +214,7 @@ class CucumberChef < Thor
           test_lab.ssh.exec("nohup sudo pkill -9 -f cc-server")
           test_lab.ssh.exec("nohup sudo BACKGROUND=yes cc-server #{Cucumber::Chef.external_ip}")
           Cucumber::Chef.spinner do
-            ZTK::TCPSocketCheck.new(:host => test_lab.labs_running.first.public_ip_address, :port => 8787, :data => "\n\n").wait
+            ZTK::TCPSocketCheck.new(:host => test_lab.ip, :port => 8787, :data => "\n\n").wait
           end
           test_lab.drb.servers = Hash.new(nil)
           test_lab.drb.server_destroy(container)
@@ -230,12 +234,20 @@ class CucumberChef < Thor
     fatal(e)
   end
 
+################################################################################
+# UP
 ################################################################################
 
-  desc "test", "depreciated"
-  def test
+  desc "up", "Startup the cucumber-chef test lab"
+  def up
+    boot
+
     puts
-    puts(set_color("The test task is depreciated!  You should execute cucumber directly.", :red, true))
+    if (test_lab = Cucumber::Chef::TestLab.new)
+      test_lab.up
+    else
+      puts(set_color("Could not find a cucumber-chef test lab to startup!", :red, true))
+    end
     puts
 
   rescue Cucumber::Chef::Error => e
@@ -243,17 +255,19 @@ class CucumberChef < Thor
     fatal(e)
   end
 
+################################################################################
+# DOWN
 ################################################################################
 
-  desc "up", "Startup the cucumber-chef test lab"
-  def up
-    load_config
+  desc "down", "Shutdown the cucumber-chef test lab"
+  def down
+    boot
 
     puts
     if (test_lab = Cucumber::Chef::TestLab.new)
-      test_lab.start
+      test_lab.down
     else
-      puts(set_color("Could not find a cucumber-chef test lab to startup!", :red, true))
+      puts(set_color("Could not find a cucumber-chef test lab to shutdown!", :red, true))
     end
     puts
 
@@ -262,31 +276,34 @@ class CucumberChef < Thor
     fatal(e)
   end
 
+################################################################################
+# STATUS
 ################################################################################
 
-  desc "down", "Shutdown the cucumber-chef test lab"
-  def down
-    load_config
+  desc "status", "Displays the current status of the test lab."
+  method_option :test, :type => :boolean, :desc => "INTERNAL USE ONLY"
+  def status
+    boot
 
     puts
     if (test_lab = Cucumber::Chef::TestLab.new)
-      test_lab.stop
-    else
-      puts(set_color("Could not find a cucumber-chef test lab to shutdown!", :red, true))
+      test_lab.status
     end
     puts
 
   rescue Cucumber::Chef::Error => e
     $logger.fatal { e.backtrace.join("\n") }
-    fatal(e)
+    fatal(e.message)
   end
 
+################################################################################
+# SSH
 ################################################################################
 
   desc "ssh [container]", "SSH to cucumber-chef test lab or [container] if specified."
   method_option :test, :type => :boolean, :desc => "INTERNAL USE ONLY"
   def ssh(*args)
-    load_config
+    boot
 
     puts
     if (test_lab = Cucumber::Chef::TestLab.new) && (test_lab.labs_running.count > 0)
@@ -309,11 +326,13 @@ class CucumberChef < Thor
     fatal(e)
   end
 
+################################################################################
+# LOG
 ################################################################################
 
   desc "log", "Streams the cucumber-chef local and test lab logs to the terminal."
   def log
-    load_config
+    boot
 
     if ($test_lab = Cucumber::Chef::TestLab.new) && ($test_lab.labs_running.count > 0)
       $tail_thread_remote = Thread.new do
@@ -342,6 +361,8 @@ class CucumberChef < Thor
     end
   end
 
+################################################################################
+# DIAGNOSE
 ################################################################################
 
   desc "diagnose <container>", "Provide diagnostics from the chef-client on the specified container."
@@ -349,7 +370,7 @@ class CucumberChef < Thor
   method_option :log, :type => :boolean, :desc => "output the chef-client 'chef.log'", :aliases => "-l", :default => true
   method_option :lines, :type => :numeric, :desc => "output the last N lines of the chef-client 'chef.log'", :aliases => "-n", :default => 1
   def diagnose(container)
-    load_config
+    boot
 
     puts
     if (test_lab = Cucumber::Chef::TestLab.new) && (test_lab.labs_running.count > 0)
@@ -375,15 +396,41 @@ class CucumberChef < Thor
     fatal(e)
   end
 
+################################################################################
+# DISPLAYCONFIG
 ################################################################################
 
   desc "displayconfig", "Display the current cucumber-chef config."
   method_option :test, :type => :boolean, :desc => "INTERNAL USE ONLY"
   def displayconfig
-    load_config
+    boot
+
+    details = {
+      "root_dir" => Cucumber::Chef.root_dir,
+      "home_dir" => Cucumber::Chef.home_dir,
+      "log_file" => Cucumber::Chef.log_file,
+      "config_rb" => Cucumber::Chef.config_rb,
+      "servers_bin" => Cucumber::Chef.servers_bin,
+      "knife_rb" => Cucumber::Chef.knife_rb,
+      "chef_repo" => Cucumber::Chef.chef_repo,
+      "bootstrap_identity" => Cucumber::Chef.bootstrap_identity,
+      "lab_user" => Cucumber::Chef.lab_user,
+      "lab_user_home_dir" => Cucumber::Chef.lab_user_home_dir,
+      "lab_identity" => Cucumber::Chef.lab_identity,
+      "lxc_user" => Cucumber::Chef.lxc_user,
+      "lxc_user_home_dir" => Cucumber::Chef.lxc_user_home_dir,
+      "lxc_identity" => Cucumber::Chef.lxc_identity
+    }
 
     puts
+
     say(Cucumber::Chef::Config.configuration.to_yaml, :bold)
+
+    max_key_length = details.collect{ |k,v| k.to_s.length }.max
+    details.each do |key,value|
+      puts("%#{max_key_length}s = %s" % [key.downcase, value.inspect])
+    end
+
     puts
 
   rescue Cucumber::Chef::Error => e
@@ -391,11 +438,13 @@ class CucumberChef < Thor
     fatal(e.message)
   end
 
+################################################################################
+# PS
 ################################################################################
 
   desc "ps [ps-options]", "Snapshot of the current cucumber-chef test lab container processes."
   def ps(*args)
-    load_config
+    boot
 
     puts
     if (test_lab = Cucumber::Chef::TestLab.new) && (test_lab.labs_running.count > 0)
@@ -413,23 +462,7 @@ class CucumberChef < Thor
   end
 
 ################################################################################
-
-  desc "info", "Display information about the current test lab."
-  method_option :test, :type => :boolean, :desc => "INTERNAL USE ONLY"
-  def info
-    load_config
-
-    puts
-    if (test_lab = Cucumber::Chef::TestLab.new)
-      test_lab.info
-    end
-    puts
-
-  rescue Cucumber::Chef::Error => e
-    $logger.fatal { e.backtrace.join("\n") }
-    fatal(e.message)
-  end
-
+# CREATE
 ################################################################################
 
   desc "create <project>" , "Create a project template for testing an infrastructure."
@@ -451,6 +484,37 @@ class CucumberChef < Thor
     fatal(e)
   end
 
+################################################################################
+# DEPRECIATED: INFO
+################################################################################
+
+  desc "info", "DEPRECIATED! - You should execute the 'status' task instead."
+  def info
+    puts
+    puts(set_color("The 'info' task is DEPRECIATED!  You should execute the 'status' task instead.", :red, true))
+    puts
+    status
+
+  rescue Cucumber::Chef::Error => e
+    $logger.fatal { e.backtrace.join("\n") }
+    fatal(e)
+  end
+
+################################################################################
+# DEPRECIATED: TEST
+################################################################################
+
+  desc "test", "DEPRECIATED! - You should execute 'cucumber' or 'rspec' directly."
+  def test
+    puts
+    puts(set_color("The test task is DEPRECIATED!  You should execute 'cucumber' or 'rspec' directly.", :red, true))
+    puts
+
+  rescue Cucumber::Chef::Error => e
+    $logger.fatal { e.backtrace.join("\n") }
+    fatal(e)
+  end
+
 ################################################################################
 
 end

data/chef_repo/cookbooks/cucumber-chef/recipes/test_lab.rb

@@ -27,7 +27,7 @@
   package p
 end
 
-%w( root ubuntu ).each do |user|
+[ node.lab_user, node.lxc_user ].flatten.each do |user|
   home_dir = (user == "root" ? "/#{user}" : "/home/#{user}")
 
   directory "create .ssh directory for #{user}" do
@@ -69,6 +69,7 @@ end
     path "#{home_dir}/.ssh/id_rsa"
     owner user
     group user
+    mode "0400"
   end
 
   file "ensure ssh public key ownership for #{user}" do

data/cucumber-chef.gemspec

@@ -34,14 +34,22 @@ Gem::Specification.new do |s|
   s.required_rubygems_version = ">= 1.3.6"
   s.licenses = ["Apache 2.0"]
 
-  s.add_dependency("chef", ">= 0.10.10")
-  s.add_dependency("cucumber", ">= 1.2.0")
+  # Chef
+  s.add_dependency("chef", ">= 0.10.0")
+
+  # Providers
   s.add_dependency("fog", ">= 1.3.1")
-  s.add_dependency("mixlib-config", ">= 1.1.2")
+  s.add_dependency("vagrant", ">= 1.0.5")
+
+  # TDD
+  s.add_dependency("cucumber", ">= 1.2.0")
+  s.add_dependency("rspec", ">= 2.10.0")
+
+  # Support
   s.add_dependency("thor", ">= 0.15.2")
+  s.add_dependency("mixlib-config", ">= 1.1.2")
   s.add_dependency("rake", ">= 0.9.2")
   s.add_dependency("ubuntu_ami", ">= 0.4.0")
-  s.add_dependency("rspec", ">= 2.10.0")
   s.add_dependency("ztk", ">= 0.0.15")
 
   s.add_development_dependency("simplecov", ">= 0.6.4")

data/lib/cucumber/chef/bootstrap.rb

@@ -67,9 +67,10 @@ module Cucumber
           raise BootstrapError, message
         end
 
-        Cucumber::Chef.logger.debug { "prepare(#{@config[:host]})" }
+        Cucumber::Chef.logger.debug { "prepare(#{@config[:host]}:#{@config[:port]})" }
 
         @ssh.config.host_name = @config[:host]
+        @ssh.config.port = @config[:port] if @config[:port]
         @ssh.config.user = @config[:ssh_user]
         @ssh.config.password = @config[:ssh_password]
         @ssh.config.keys = @config[:identity_file]
@@ -79,9 +80,9 @@ module Cucumber
         command = ZTK::Template.render(@config[:template_file], @config[:context])
         command = "sudo #{command}" if @config[:use_sudo]
 
-        Cucumber::Chef.logger.debug { "begin(#{@config[:host]})" }
+        Cucumber::Chef.logger.debug { "begin(#{@config[:host]}:#{@config[:port]})" }
         @ssh.exec(command, :silence => true)
-        Cucumber::Chef.logger.debug { "end(#{@config[:host]})" }
+        Cucumber::Chef.logger.debug { "end(#{@config[:host]}:#{@config[:port]})" }
       end
 
 ################################################################################

data/lib/cucumber/chef/config.rb

@@ -27,11 +27,21 @@ module Cucumber
     class Config
       extend(Mixlib::Config)
 
-      KEYS = %w( mode provider ).map(&:to_sym) unless const_defined?(:KEYS)
-      MODES = %w( user test ).map(&:to_sym) unless const_defined?(:MODES)
-      PROVIDERS = %w( aws vagrant ).map(&:to_sym) unless const_defined?(:PROVIDERS)
-
-      PROVIDER_AWS_KEYS = %w( aws_access_key_id aws_secret_access_key region availability_zone aws_ssh_key_id identity_file ).map(&:to_sym) unless const_defined?(:PROVIDER_AWS_KEYS)
+      unless const_defined?(:KEYS)
+        KEYS = %w(mode provider).map(&:to_sym)
+      end
+      unless const_defined?(:MODES)
+        MODES = %w(user test).map(&:to_sym)
+      end
+      unless const_defined?(:PROVIDERS)
+        PROVIDERS = %w(aws vagrant).map(&:to_sym)
+      end
+      unless const_defined?(:PROVIDER_AWS_KEYS)
+        PROVIDER_AWS_KEYS = %w(aws_access_key_id aws_secret_access_key region availability_zone aws_ssh_key_id identity_file).map(&:to_sym)
+      end
+      unless const_defined?(:PROVIDER_VAGRANT_KEYS)
+        PROVIDER_VAGRANT_KEYS = %w(identity_file).map(&:to_sym)
+      end
 
 ################################################################################
 
@@ -50,7 +60,7 @@ module Cucumber
       end
 
       def self.load
-        config_rb = Cucumber::Chef.locate(:file, ".cucumber-chef", "config.rb")
+        config_rb = Cucumber::Chef.config_rb
         Cucumber::Chef.logger.debug { "Attempting to load cucumber-chef configuration from '%s'." % config_rb }
         self.from_file(config_rb)
         self.verify
@@ -128,9 +138,8 @@ module Cucumber
       end
 
       def self.verify_provider_vagrant
-        message = "Not yet implemented."
-        Cucumber::Chef.logger.fatal { message }
-        raise ConfigError, message
+        # NOOP
+        require 'vagrant'
       end
 
 ################################################################################
@@ -156,18 +165,24 @@ module Cucumber
       mode            :user
       prerelease      (Cucumber::Chef.is_rc? ? true : false)
 
-      provider        :aws
+      provider        :vagrant
       librarian_chef  false
 
-      user            ( ENV['OPSCODE_USER'] || ENV['USER'] )
+      user            (ENV['OPSCODE_USER'] || ENV['USER'])
+
+      artifacts       ({"chef-client-log" => "/var/log/chef/client.log",
+                        "chef-client-stacktrace" => "/var/chef/cache/chef-stacktrace.out"})
 
-      aws             Hash[ :ubuntu_release => "precise",
-                            :aws_instance_arch => "i386",
-                            :aws_instance_disk_store => "ebs",
-                            :aws_instance_type => "m1.small",
-                            :aws_security_group => "cucumber-chef" ]
+      aws             ({:lab_user => "ubuntu",
+                        :lxc_user => "root",
+                        :ubuntu_release => "precise",
+                        :aws_instance_arch => "i386",
+                        :aws_instance_disk_store => "ebs",
+                        :aws_instance_type => "m1.small",
+                        :aws_security_group => "cucumber-chef"})
 
-      vagrant         Hash.new
+      vagrant         ({:lab_user => "vagrant",
+                        :lxc_user => "root"})
 
 ################################################################################
 

data/lib/cucumber/chef/helpers/chef_client.rb

@@ -53,7 +53,6 @@ module Cucumber::Chef::Helpers::ChefClient
 
   def chef_run_client(name,*args)
     chef_config_client(name)
-    artifacts =
     log("removing artifacts #{Cucumber::Chef::Config[:artifacts].values.collect{|z| "$#{z}$" }.join(' ')}")
     (command_run_remote(name, "/bin/rm -fv #{Cucumber::Chef::Config[:artifacts].values.join(' ')}") rescue nil)
 
@@ -109,18 +108,16 @@ module Cucumber::Chef::Helpers::ChefClient
     # this is messy and needs to be refactored into a more configurable
     # solution; but for now this should do the trick
 
-    ssh_private_key_file = Cucumber::Chef.locate(:file, ".cucumber-chef", "id_rsa-#{Cucumber::Chef::Config[:lab_user]}")
-    File.chmod(0400, ssh_private_key_file)
-
     ssh = ZTK::SSH.new
 
-    ssh.config.proxy_host_name = $test_lab.labs_running.first.public_ip_address
-    ssh.config.proxy_user = Cucumber::Chef::Config[:lab_user]
-    ssh.config.proxy_keys = ssh_private_key_file
+    ssh.config.proxy_host_name = $test_lab.ip
+    ssh.config.proxy_port = $test_lab.port
+    ssh.config.proxy_user = Cucumber::Chef.lab_user
+    ssh.config.proxy_keys = Cucumber::Chef.lab_identity
 
     ssh.config.host_name = name
-    ssh.config.user = Cucumber::Chef::Config[:lxc_user]
-    ssh.config.keys = ssh_private_key_file
+    ssh.config.user = Cucumber::Chef.lxc_user
+    ssh.config.keys = Cucumber::Chef.lxc_identity
 
     feature_file = $scenario.file_colon_line.split(":").first
     feature_line = $scenario.file_colon_line.split(":").last

data/lib/cucumber/chef/helpers/command.rb

@@ -24,7 +24,7 @@ module Cucumber::Chef::Helpers::Command
 ################################################################################
 
   def command_run_remote(name, command, expected_exit_code=0)
-    command = %Q(ssh #{name} #{command} 2>&1)
+    command = %Q(ssh -i #{File.join(Cucumber::Chef.lab_user_home_dir, ".ssh", "id_rsa")} #{name} #{command} 2>&1)
     logger.info { "command_run_remote(#{command})" }
     output = %x(#{command})
     if !expected_exit_code.nil? && ($? != expected_exit_code)

data/lib/cucumber/chef/helpers/container.rb

@@ -28,7 +28,7 @@ module Cucumber::Chef::Helpers::Container
       cache_rootfs = container_cache_root(name, distro, release, arch)
       if !File.exists?(cache_rootfs)
         log("$#{name}$ has triggered building the lxc file cache for $#{distro}$")
-        log("this one time process per distro can take up to 10 minutes or longer depending on the test lab hardware")
+        log("this one time process per distro can take up to 10 minutes or longer depending on the test lab")
       end
 
       command_run_local(container_create_command(name, distro, release, arch))
@@ -52,18 +52,11 @@ module Cucumber::Chef::Helpers::Container
         command_run_local(container_create_command(name, distro, release, arch))
       end
 
-      command_run_local("mkdir -p #{container_root(name)}/root/.ssh")
-      command_run_local("chmod 0755 #{container_root(name)}/root/.ssh")
-      command_run_local("cat /root/.ssh/id_rsa.pub | tee -a #{container_root(name)}/root/.ssh/authorized_keys")
-      command_run_local("cat /home/#{Cucumber::Chef::Config[:lab_user]}/.ssh/id_rsa.pub | tee -a #{container_root(name)}/root/.ssh/authorized_keys")
+      command_run_local("mkdir -p #{File.join(container_root(name), Cucumber::Chef.lxc_user_home_dir, ".ssh")}")
+      command_run_local("chmod 0755 #{File.join(container_root(name), Cucumber::Chef.lxc_user_home_dir, ".ssh")}")
+      command_run_local("cat #{File.join(Cucumber::Chef.lab_user_home_dir, ".ssh", "id_rsa.pub")} | tee -a #{File.join(container_root(name), Cucumber::Chef.lxc_user_home_dir, ".ssh", "authorized_keys")}")
 
-      command_run_local("mkdir -p #{container_root(name)}/home/#{Cucumber::Chef::Config[:lab_user]}/.ssh")
-      command_run_local("chmod 0755 #{container_root(name)}/home/#{Cucumber::Chef::Config[:lab_user]}/.ssh")
-      command_run_local("cat /root/.ssh/id_rsa.pub | tee -a #{container_root(name)}/home/#{Cucumber::Chef::Config[:lab_user]}/.ssh/authorized_keys")
-      command_run_local("cat /home/#{Cucumber::Chef::Config[:lab_user]}/.ssh/id_rsa.pub | tee -a #{container_root(name)}/home/#{Cucumber::Chef::Config[:lab_user]}/.ssh/authorized_keys")
-      command_run_local("chown -R #{Cucumber::Chef::Config[:lab_user]}:#{Cucumber::Chef::Config[:lab_user]} #{container_root(name)}/home/#{Cucumber::Chef::Config[:lab_user]}/.ssh")
-
-      command_run_local("rm #{container_root(name)}/etc/motd")
+      command_run_local("rm -f #{container_root(name)}/etc/motd")
       command_run_local("cp /etc/motd #{container_root(name)}/etc/motd")
       command_run_local("echo '    You are now logged in to the #{name} container!\n' >> #{container_root(name)}/etc/motd")
       command_run_local("sed -i 's/localhost #{name}/#{name}.test-lab #{name} localhost/' #{container_root(name)}/etc/hosts")