dev-lxc 0.6.4 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 292b5df53d047927c96eb8d73e13739b17c57c99
-  data.tar.gz: 3e696698a4ab38c75ef4cd428637b8ed95d21a6d
+  metadata.gz: a9b7bd69da896ea6a750b5f4ac463fcf23de242e
+  data.tar.gz: 638d5b30c5c74a4983f763614141cb63d4218931
 SHA512:
-  metadata.gz: 5f7bba6ca362e9f8de32c9702ebb9eca1af73f78f4049c63e39f1dd865423fb059f69ea9e4e67414d473fb35d181c9327a40e59fe38b80c5ced151abb2a24a15
-  data.tar.gz: 916d5ce93646952a3e69f858471a4dc837b01c3acc16a2e89b4d1c64f593fb2fc08fe2439620be12ab2c804aebb7353260df932711b0845ab194b9a98f853856
+  metadata.gz: 107c68008b67e58ac0deca62b502e696dee71d3cfd5984c8a60a2bad3034ba75e821d67a41e9bd5d24efb3c02dc6f313fb105c0ebfa7cca11611aec8386fb7d9
+  data.tar.gz: df9768afa06905a197c75a95c8df997152445f52db38f51b51278d3fb540337719407525f9dc9483eb0049297f67b894fe9fd79cee4d191c24583cfce6d6ed97

data/README.md

@@ -1,14 +1,17 @@
 # dev-lxc
 
-A tool for creating Chef Server clusters with a Chef Analytics server using LXC containers.
+A tool for creating Chef Server clusters and Chef Analytics clusters using LXC containers.
 
 Using [ruby-lxc](https://github.com/lxc/ruby-lxc) it builds a standalone Chef Server or
 tier Chef Server cluster composed of a backend and multiple frontends with round-robin
-DNS resolution. It will also optionally build a standalone or tier Chef Analytics server
-and connect it with the Chef Server.
+DNS resolution. It can also build a standalone or tier Chef Analytics server and connect
+it with the Chef Server.
 
-The dev-lxc tool is well suited as a tool for support related work, customized
-cluster builds for demo purposes, as well as general experimentation and exploration.
+dev-lxc also has commands to manipulate Chef node containers. For example, dev-lxc can bootstrap a
+container by installing Chef Client, configuring it for a Chef Server and running a specified run_list.
+
+The dev-lxc tool is well suited as a tool for support related work, customized cluster builds
+for demo purposes, as well as general experimentation and exploration of Chef products
 
 ### Features
 
@@ -59,6 +62,23 @@ If you aren't familiar with using containers please read this introduction.
 	Be sure that you configure the `mounts` and `packages` lists in `dev-lxc.yml` to match your
 	particular environment.
 
+    The package paths in dev-lxc's example configs assume that the packages are stored in the
+	following directory structure in the dev-lxc-platform VM. I recommend creating that
+	directory structure in the physical workstation and configuring dev-lxc-platform's `.knife.yml`
+	to mount the structure into `/dev-shared` in the dev-lxc-platform VM.
+
+```
+/dev-shared/chef-packages/
+├── analytics
+├── cs
+├── ec
+├── manage
+├── osc
+├── push-jobs-server
+├── reporting
+└── sync
+```
+
 ## Update dev-lxc gem
 
 Run `gem update dev-lxc` inside the Vagrant VM platform to ensure you have the latest version.
@@ -130,27 +150,9 @@ dev-lxc init tier > dev-lxc.yml
 List of each servers' images created during the build process.
 
 ```
-dev-lxc list_images
-```
-
-#### Start cluster
-
-Starting the cluster the first time takes awhile since it has a lot to build.
-
-The tool automatically creates images at appropriate times so future creation of the
-cluster's servers is very quick.
-
-```
-dev-lxc up
+dev-lxc list-images
 ```
 
-A test org, user, knife.rb and keys are automatically created in
-the bootstrap backend server in `/root/chef-repo/.chef` for testing purposes.
-
-The `knife-opc` plugin is installed in the embedded ruby environment of the
-Private Chef and Enterprise Chef server to facilitate the creation of the test
-org and user.
-
 #### Cluster status
 
 Run the following command to see the status of the cluster.
@@ -172,12 +174,69 @@ Analytics:   https://analytics.lxc
 analytics-fe1.lxc     running         10.0.3.207
 ```
 
+#### cluster-view, tks, tls commands
+
+The dev-lxc-platform comes with some commands that create and manage helpful
+tmux/byobu sessions to more easily see the state of a cluster.
+
+Running the `cluster-view` command in the same directory as a `dev-lxc.yml` file
+creates a tmux/byobu session with the same name as the cluster's directory.
+`cluster-view` can also be run with the parent directory of a `dev-lxc.yml` file
+as the first argument and `cluster-view` will change to that directory before
+creating the tmux/byobu session.
+
+The session's first window is named "cluster".
+
+The left side is for running dev-lxc commands.
+
+The right side is made up of three vertically stacked panes with each pane's content
+updating every 0.5 seconds.
+
+* Top - system's memory usage provided by `free -h`
+* Middle - cluster's status provided by `dev-lxc status`
+* Bottom - list of the cluster's images provided by `dev-lxc list-images`
+
+The session's second window is named "shell". It opens in the same directory as the
+cluster's `dev-lxc.yml` file.
+
+The `tls` and `tks` commands are really aliases.
+
+`tls` is an alias for `tmux list-sessions` and is used to see what tmux/byobu sessions
+are running.
+
+`tks` is an alias for `tmux kill-session -t` and is used to kill tmux/byobu sessions.
+When specifying the session to be killed you only need as many characters of the session
+name that are required to make the name unique among the list of running sessions.
+
+I recommend switching to a different running tmux/byobu session before killing the current
+tmux/byobu session. Otherwise you will need to reattach to the remaining tmux/byobu session.
+Use the keyboard shortcuts Alt-Up/Down to easily switch between tmux/byobu sessions.
+
+#### Start cluster
+
+Starting the cluster the first time takes awhile since it has a lot to build.
+
+The tool automatically creates images at appropriate times so future creation of the
+cluster's servers is very quick.
+
+```
+dev-lxc up
+```
+
+A test org, user, knife.rb and keys are automatically created in
+the bootstrap backend server in `/root/chef-repo/.chef` for testing purposes.
+
+The `knife-opc` plugin is installed in the embedded ruby environment of the
+Private Chef and Enterprise Chef server to facilitate the creation of the test
+org and user.
+
 #### Create chef-repo
 
 Create a local chef-repo with appropriate knife.rb and pem files.
 
-Also create a `./bootstrap-node` script to simplify creating and
-bootstrapping nodes in the `dev-lxc-platform`.
+Use the `-p` option to also get pivotal.pem and pivotal.rb files.
+
+Use the `-f` option to overwrite existing knife.rb and pivotal.rb files.
 
 ```
 dev-lxc chef-repo
@@ -222,11 +281,19 @@ emacs $(dev-lxc abspath chef /etc/opscode/chef-server.rb)
 
 #### Run arbitrary commands in each server
 
-After modifying the chef-server.rb you could use the run_command subcommand to tell the backend and
+After modifying the chef-server.rb you could use the run-command subcommand to tell the backend and
 frontend servers to run `chef-server-ctl reconfigure`.
 
 ```
-dev-lxc run_command chef 'chef-server-ctl reconfigure'
+dev-lxc run-command chef 'chef-server-ctl reconfigure'
+```
+
+#### Attach the terminal to a server
+
+Attach the terminal to a server in the cluster that matches the REGEX pattern given.
+
+```
+dev-lxc attach chef-be
 ```
 
 #### Make a snapshot of the servers
@@ -254,6 +321,15 @@ images if you want to build them from scratch.
 dev-lxc destroy -c -u -s
 ```
 
+#### Global status of all dev-lxc images and servers
+
+Use the `global-status` command to see the status of all dev-lxc images and servers stored in dev-lxc's
+default LXC config_path `/var/lib/dev-lxc`.
+
+```
+dev-lxc global-status
+```
+
 #### Use commands against specific servers
 You can also run most of these commands against a set of servers by specifying a regular expression
 that matches a set of server names.
@@ -266,7 +342,73 @@ For example, to only start the Chef Servers named `chef-be.lxc` and `chef-fe1.lx
 you can run the following command.
 
 ```
-dev-lxc up 'chef'
+dev-lxc up chef
+```
+
+### Managing Node Containers
+
+#### Manually Create a Platform Image
+
+Platform images can be used for purposes other than building clusters. For example, they can
+be used as Chef nodes for testing purposes.
+
+You can see a menu of platform images this tool can create by using the following command.
+
+```
+dev-lxc create
+```
+
+The initial creation of platform images can take awhile so let's go ahead and start creating
+an Ubuntu 14.04 image now.
+
+```
+dev-lxc create p-ubuntu-1404
+```
+
+#### Install Chef Client in a Container
+
+Use the `-v` option to specify a particular version of Chef Client.
+
+Use `-v latest` or leave out the `-v` option to install the latest version of Chef Client.
+
+For example, install the latest 11.x version of Chef Client.
+
+```
+dev-lxc install-chef-client test-node.lxc -v 11
+```
+
+#### Configure Chef Client in a Container
+
+Use the `-s`, `-u`, `-k` options to set `chef_server_url`, `validation_client_name` and
+`validation_key` in a container's `/etc/chef/client.rb` and copy the validator's key to
+`/etc/chef/validation.pem`.
+
+Or leave the options empty and it will default to using values from the cluster defined
+in `dev-lxc.yml`.
+
+```
+dev-lxc config-chef-client test-node.lxc
+```
+
+#### Bootstrap Chef Client in a Container
+
+Specifying a `BASE_CONTAINER_NAME` will clone the base container into a new container
+and bootstrap it. If no `BASE_CONTAINER_NAME` is given then the container to be bootstrapped
+needs to already exist.
+
+Use the `-v` option to specify a particular version of Chef Client.
+
+Use the `-s`, `-u`, `-k` options to set `chef_server_url`, `validation_client_name` and
+`validation_key` in a container's `/etc/chef/client.rb` and copy the validator's key to
+`/etc/chef/validation.pem`.
+
+Or leave the options empty and it will default to using values from the cluster defined
+in `dev-lxc.yml`.
+
+Use the `-r` option to specify the run_list for chef-client to use.
+
+```
+dev-lxc bootstrap-container test-node.lxc -r my_run_list
 ```
 
 ### Using the dev-lxc library
@@ -282,7 +424,7 @@ DevLXC::CLI::DevLXC.start
 ARGV = [ 'status' ]        # show status of all servers
 DevLXC::CLI::DevLXC.start
 
-ARGV = [ 'run_command', 'uptime' ]   # run `uptime` in all servers
+ARGV = [ 'run-command', 'uptime' ]   # run `uptime` in all servers
 DevLXC::CLI::DevLXC.start
 
 ARGV = [ 'destroy' ]       # destroy all servers
@@ -302,6 +444,7 @@ server.start               # start chef-fe1.lxc
 server.status              # show status of chef-fe1.lxc
 server.run_command("chef-server-ctl reconfigure")  # run command in chef-fe1.lxc
 server.stop                # stop chef-fe1.lxc
+server.destroy             # destroy chef-fe1.lxc
 ```
 
 ## Cluster Config Files
@@ -471,6 +614,12 @@ Images are then cloned using the btrfs filesystem to very quickly provide a ligh
 of the image. This clone is either used to build the next image in the build process or the final
 container that will actually be run.
 
+By default, the cluster's images and final server containers are all stored in `/var/lib/dev-lxc`
+so they don't clutter the containers stored in the default LXC config_path `/var/lib/lxc`.
+
+The cluster's LXC config_path can be configured by setting `lxc_config_path` at the top of the
+`dev-lxc.yml` file to the desired directory.
+
 There are four image categories.
 
 1. Platform
@@ -555,24 +704,6 @@ Of course, you can also just use the standard LXC commands to destroy any contai
 lxc-destroy -n [NAME]
 ```
 
-### Manually Create a Platform Image
-
-Platform images can be used for purposes other than building clusters. For example, they can
-be used as Chef nodes for testing purposes.
-
-You can see a menu of platform images this tool can create by using the following command.
-
-```
-dev-lxc create
-```
-
-The initial creation of platform images can take awhile so let's go ahead and start creating
-an Ubuntu 14.04 image now.
-
-```
-dev-lxc create p-ubuntu-1404
-```
-
 ## Contributing
 
 1. Fork it

data/bin/dev-lxc

@@ -1,6 +1,9 @@
 #!/usr/bin/env ruby
 require 'dev-lxc/cli'
 
-raise "Must run as root" unless Process.uid == 0
+unless Process.uid == 0
+  puts "ERROR: Must run as root"
+  exit 1
+end
 
 DevLXC::CLI::DevLXC.start

data/lib/dev-lxc/cli.rb

@@ -6,24 +6,28 @@ module DevLXC::CLI
   class DevLXC < Thor
 
     no_commands{
-      def get_cluster(config_option)
-        config = options[:config]
-        config ||= "dev-lxc.yml"
-        if ! File.exists?(config)
-          puts "ERROR: Cluster config file `config` does not exist."
+      def get_cluster(config_file=nil)
+        config_file ||= "dev-lxc.yml"
+        if ! File.exists?(config_file)
+          puts "ERROR: Cluster config file '#{config_file}' does not exist."
           puts "       Create a `./dev-lxc.yml` file or specify the path using `--config`."
           exit 1
         end
-        ::DevLXC::Cluster.new(YAML.load(IO.read(config)))
+        ::DevLXC::Cluster.new(YAML.load(IO.read(config_file)))
       end
 
       def match_server_name_regex(server_name_regex)
         get_cluster(options[:config]).servers.select { |s| s.server.name =~ /#{server_name_regex}/ }
       end
+
+      def print_elapsed_time(elapsed_time)
+        printf "dev-lxc is finished. (%im %.2fs)\n", elapsed_time / 60, elapsed_time % 60
+      end
     }
 
     desc "create [PLATFORM_IMAGE_NAME]", "Create a platform image"
     def create(platform_image_name=nil)
+      start_time = Time.now
       platform_image_names = %w(p-ubuntu-1204 p-ubuntu-1404 p-centos-5 p-centos-6)
       if platform_image_name.nil? || ! platform_image_names.include?(platform_image_name)
         platform_image_names_with_index = platform_image_names.map.with_index{ |a, i| [i+1, *a]}
@@ -32,6 +36,80 @@ module DevLXC::CLI
         platform_image_name = platform_image_names[selection.to_i - 1]
       end
       ::DevLXC.create_platform_image(platform_image_name)
+      puts
+      print_elapsed_time(Time.now - start_time)
+    end
+
+    desc "install-chef-client [CONTAINER_NAME]", "Install Chef Client in container"
+    option :version, :aliases => "-v", :desc => "Specify the version of Chef Client to install"
+    def install_chef_client(container_name)
+      start_time = Time.now
+      container = ::DevLXC::Container.new(container_name)
+      container.install_chef_client(options[:version])
+      puts
+      print_elapsed_time(Time.now - start_time)
+    end
+
+    desc "configure-chef-client [CONTAINER_NAME]", "Configure Chef Client in container"
+    option :chef_server_url, :aliases => "-s", :desc => "Specify the URL of the Chef Server"
+    option :validation_client_name, :aliases => "-u", :desc => "Specify the name of the validation client"
+    option :validation_key, :aliases => "-k", :desc => "Specify the path to the validation key"
+    option :config, :desc => "Specify a cluster's YAML config file. `./dev-lxc.yml` will be used by default"
+    def configure_chef_client(container_name)
+      start_time = Time.now
+      chef_server_url = options[:chef_server_url]
+      validation_client_name = options[:validation_client_name]
+      validation_key = options[:validation_key]
+      if chef_server_url.nil? && validation_client_name.nil? && validation_key.nil?
+        cluster = get_cluster(options[:config])
+        chef_server_bootstrap_backend = ::DevLXC::Container.new(cluster.chef_server_bootstrap_backend, cluster.lxc_config_path)
+        unless chef_server_bootstrap_backend.defined?
+          puts "ERROR: Can not copy validation key because Chef Server '#{chef_server_bootstrap_backend.name}' is not created."
+          exit 1
+        end
+        chef_server_url = "https://#{cluster.api_fqdn}/organizations/ponyville"
+        validation_client_name = 'ponyville-validator'
+        validation_key = "#{chef_server_bootstrap_backend.config_item('lxc.rootfs')}/root/chef-repo/.chef/ponyville-validator.pem"
+      elsif chef_server_url.nil? || validation_client_name.nil? || validation_key.nil?
+        puts "ERROR: All of the --chef-server-url, --validation-client-name and --validation-key options must be set or left unset. Do not set only some of these options."
+        exit 1
+      end
+      container = ::DevLXC::Container.new(container_name)
+      container.configure_chef_client(chef_server_url, validation_client_name, validation_key)
+      puts
+      print_elapsed_time(Time.now - start_time)
+    end
+
+    desc "bootstrap-container [BASE_CONTAINER_NAME] [CONTAINER_NAME]", "Bootstrap Chef Client in container"
+    option :version, :aliases => "-v", :desc => "Specify the version of Chef Client to install"
+    option :run_list, :aliases => "-r", :desc => "Specify the Chef Client run_list"
+    option :chef_server_url, :aliases => "-s", :desc => "Specify the URL of the Chef Server"
+    option :validation_client_name, :aliases => "-u", :desc => "Specify the name of the validation client"
+    option :validation_key, :aliases => "-k", :desc => "Specify the path to the validation key"
+    option :config, :desc => "Specify a cluster's YAML config file. `./dev-lxc.yml` will be used by default"
+    def bootstrap_container(base_container_name=nil, container_name)
+      start_time = Time.now
+      chef_server_url = options[:chef_server_url]
+      validation_client_name = options[:validation_client_name]
+      validation_key = options[:validation_key]
+      if chef_server_url.nil? && validation_client_name.nil? && validation_key.nil?
+        cluster = get_cluster(options[:config])
+        chef_server_bootstrap_backend = ::DevLXC::Container.new(cluster.chef_server_bootstrap_backend, cluster.lxc_config_path)
+        unless chef_server_bootstrap_backend.defined?
+          puts "ERROR: Can not copy validation key because Chef Server '#{chef_server_bootstrap_backend.name}' is not created."
+          exit 1
+        end
+        chef_server_url = "https://#{cluster.api_fqdn}/organizations/ponyville"
+        validation_client_name = 'ponyville-validator'
+        validation_key = "#{chef_server_bootstrap_backend.config_item('lxc.rootfs')}/root/chef-repo/.chef/ponyville-validator.pem"
+      elsif chef_server_url.nil? || validation_client_name.nil? || validation_key.nil?
+        puts "ERROR: All of the --chef-server-url, --validation-client-name and --validation-key options must be set or left unset. Do not set only some of these options."
+        exit 1
+      end
+      container = ::DevLXC::Container.new(container_name)
+      container.bootstrap_container(base_container_name, options[:version], options[:run_list], chef_server_url, validation_client_name, validation_key)
+      puts
+      print_elapsed_time(Time.now - start_time)
     end
 
     desc "init [TOPOLOGY] [UNIQUE_STRING]", "Provide a cluster config file with optional uniqueness in server names and FQDNs"
@@ -58,13 +136,24 @@ module DevLXC::CLI
       puts config
     end
 
+    desc "global-status", "Show status of all dev-lxc images and servers"
+    def global_status
+      containers = Array.new
+      LXC::list_containers({config_path: '/var/lib/dev-lxc'}).map { |c| containers << ::DevLXC::Container.new(c, '/var/lib/dev-lxc').status }
+      max_container_name_length = containers.max_by { |c| c['name'].length }['name'].length unless containers.empty?
+      containers.each { |c| printf "%#{max_container_name_length}s     %-15s %s\n", c['name'], c['state'], c['ip_addresses'] }
+    end
+
     desc "status [SERVER_NAME_REGEX]", "Show status of servers"
     option :config, :desc => "Specify a cluster's YAML config file. `./dev-lxc.yml` will be used by default"
     def status(server_name_regex=nil)
       cluster = get_cluster(options[:config])
       puts "Chef Server: https://#{cluster.api_fqdn}\n\n"
       puts "Analytics:   https://#{cluster.analytics_fqdn}\n\n" if cluster.analytics_fqdn
-      match_server_name_regex(server_name_regex).each { |s| s.status }
+      servers = Array.new
+      match_server_name_regex(server_name_regex).map { |s| servers << s.server.status }
+      max_server_name_length = servers.max_by { |s| s['name'].length }['name'].length unless servers.empty?
+      servers.each { |s| printf "%#{max_server_name_length}s     %-15s %s\n", s['name'], s['state'], s['ip_addresses'] }
     end
 
     desc "abspath [SERVER_NAME_REGEX] [ROOTFS_PATH]", "Returns the absolute path to a file in each server"
@@ -75,6 +164,34 @@ module DevLXC::CLI
       puts abspath.compact.join(" ")
     end
 
+    desc "attach [SERVER_NAME_REGEX]", "Attach the terminal to a single server"
+    option :config, :desc => "Specify a cluster's YAML config file. `./dev-lxc.yml` will be used by default"
+    def attach(server_name_regex)
+      servers = match_server_name_regex(server_name_regex)
+      if servers.length > 1
+        puts "ERROR: The following servers matched '#{server_name_regex}'"
+        servers.map { |s| puts "       #{s.server.name}" }
+        puts "       Please specify a single server to attach to"
+        exit 1
+      elsif servers.empty?
+        puts "ERROR: No servers matched '#{server_name_regex}'"
+        puts "       Please specify a single server to attach to"
+        exit 1
+      end
+      server = servers.first.server
+      unless server.defined? && server.running?
+        puts "ERROR: Server '#{server.name}' is not running"
+        exit 1
+      end
+      attach_opts = {
+        wait: true,
+        env_policy: LXC::LXC_ATTACH_CLEAR_ENV,
+        extra_env_vars: ["LANG=en_US.UTF-8", "TERM=linux", "HOME=#{ENV['HOME']}"]
+      }
+      shell = ENV['SHELL']
+      server.attach(attach_opts) { system(shell) }
+    end
+
     desc "chef-repo", "Creates a `bootstrap-node` script and chef-repo in the current directory using files from the cluster's backend /root/chef-repo"
     option :config, :desc => "Specify a cluster's YAML config file. `./dev-lxc.yml` will be used by default"
     option :force, :aliases => "-f", :type => :boolean, :desc => "Overwrite any existing knife.rb or pivotal.rb files"
@@ -83,80 +200,90 @@ module DevLXC::CLI
       get_cluster(options[:config]).chef_repo(options[:force], options[:pivotal])
     end
 
-    desc "list_images [SERVER_NAME_REGEX]", "List of each servers' images created during the build process"
+    desc "list-images [SERVER_NAME_REGEX]", "List of each servers' images created during the build process"
     option :config, :desc => "Specify a cluster's YAML config file. `./dev-lxc.yml` will be used by default"
     def list_images(server_name_regex=nil)
+      lxc_config_path = get_cluster(options[:config]).lxc_config_path
       images = Hash.new { |h,k| h[k] = Hash.new { |h,k| h[k] = Array.new } }
       match_server_name_regex(server_name_regex).each do |s|
         images[s.platform_image_name][s.shared_image_name] << s.server.name
       end
       images.each_with_index do |(platform_name, shared), images_index|
         shared.each_with_index do |(shared_name, final), shared_index|
-          printf "Platform: %21s  %s\n", (LXC::Container.new(platform_name).defined? ? "Created" : "Not Created"), platform_name
+          printf "Platform: %25s  %s\n", (LXC::Container.new(platform_name, lxc_config_path).defined? ? "Created" : "Not Created"), platform_name
           puts "|"
-          printf "\\_ Shared: %20s  %s\n", (LXC::Container.new(shared_name).defined? ? "Created" : "Not Created"), shared_name
+          printf "\\_ Shared: %24s  %s\n", (LXC::Container.new(shared_name, lxc_config_path).defined? ? "Created" : "Not Created"), shared_name
           final.each_with_index do |final_name, final_index|
             puts "   |"
             unique_name = "u-#{final_name}"
-            printf "   \\_ Unique: %17s  %s\n", (LXC::Container.new(unique_name).defined? ? "Created" : "Not Created"), unique_name
+            printf "   \\_ Unique: %21s  %s\n", (LXC::Container.new(unique_name, lxc_config_path).defined? ? "Created" : "Not Created"), unique_name
 
             shared_connector = (final_index + 1 < final.length ? "|" : " ")
 
             custom_name = "c-#{final_name}"
-            if LXC::Container.new(custom_name).defined?
-              printf "   #{shared_connector}  \\_ Custom: %14s  %s\n", "Created", custom_name
+            if LXC::Container.new(custom_name, lxc_config_path).defined?
+              printf "   #{shared_connector}  \\_ Custom: %18s  %s\n", "Created", custom_name
               custom_spacing = "   "
-              final_width = 12
+              final_width = 9
             else
-              final_width = 15
+              final_width = 12
             end
-            printf "   #{shared_connector}  #{custom_spacing}\\_ Final: %#{final_width}s    %s\n", (LXC::Container.new(final_name).defined? ? "Created" : "Not Created"), final_name
+            printf "   #{shared_connector}  #{custom_spacing}\\_ Final Server: %#{final_width}s    %s\n", (LXC::Container.new(final_name, lxc_config_path).defined? ? "Created" : "Not Created"), final_name
           end
           puts if (shared_index + 1 < shared.length) || (images_index + 1 < images.length)
         end
       end
     end
 
-    desc "run_command [SERVER_NAME_REGEX] [COMMAND]", "Runs a command in each server"
+    desc "run-command [SERVER_NAME_REGEX] [COMMAND]", "Runs a command in each server"
     option :config, :desc => "Specify a cluster's YAML config file. `./dev-lxc.yml` will be used by default"
     def run_command(server_name_regex=nil, command)
-      match_server_name_regex(server_name_regex).each { |s| s.run_command(command) }
+      start_time = Time.now
+      match_server_name_regex(server_name_regex).each { |s| s.run_command(command); puts }
+      print_elapsed_time(Time.now - start_time)
     end
 
     desc "up [SERVER_NAME_REGEX]", "Start servers - This is the default if no subcommand is given"
     option :config, :desc => "Specify a cluster's YAML config file. `./dev-lxc.yml` will be used by default"
     def up(server_name_regex=nil)
-      match_server_name_regex(server_name_regex).each { |s| s.start }
+      start_time = Time.now
+      match_server_name_regex(server_name_regex).each { |s| s.start; puts }
+      print_elapsed_time(Time.now - start_time)
     end
 
     desc "halt [SERVER_NAME_REGEX]", "Stop servers"
     option :config, :desc => "Specify a cluster's YAML config file. `./dev-lxc.yml` will be used by default"
     def halt(server_name_regex=nil)
-      match_server_name_regex(server_name_regex).reverse_each { |s| s.stop }
+      start_time = Time.now
+      match_server_name_regex(server_name_regex).reverse_each { |s| s.stop; puts }
+      print_elapsed_time(Time.now - start_time)
     end
 
     desc "snapshot [SERVER_NAME_REGEX]", "Create a snapshot of servers"
     option :config, :desc => "Specify a cluster's YAML config file. `./dev-lxc.yml` will be used by default"
     option :force, :aliases => "-f", :type => :boolean, :desc => "Overwrite existing custom images"
     def snapshot(server_name_regex=nil)
+      start_time = Time.now
       non_stopped_servers = Array.new
       existing_custom_images = Array.new
+      lxc_config_path = get_cluster(options[:config]).lxc_config_path
       match_server_name_regex(server_name_regex).each do |s|
         non_stopped_servers << s.server.name if s.server.state != :stopped
-        existing_custom_images << s.server.name if LXC::Container.new("c-#{s.server.name}").defined?
+        existing_custom_images << s.server.name if LXC::Container.new("c-#{s.server.name}", lxc_config_path).defined?
       end
       unless non_stopped_servers.empty?
-        puts "WARNING: Aborting snapshot because the following servers are not stopped"
+        puts "ERROR: Aborting snapshot because the following servers are not stopped"
         puts non_stopped_servers
         exit 1
       end
       unless existing_custom_images.empty? || options[:force]
-        puts "WARNING: The following servers already have a custom image"
+        puts "ERROR: The following servers already have a custom image"
         puts "         Use the `--force` or `-f` option to overwrite existing custom images"
         puts existing_custom_images
         exit 1
       end
-      match_server_name_regex(server_name_regex).each { |s| s.snapshot(options[:force]) }
+      match_server_name_regex(server_name_regex).each { |s| s.snapshot(options[:force]); puts }
+      print_elapsed_time(Time.now - start_time)
     end
 
     desc "destroy [SERVER_NAME_REGEX]", "Destroy servers"
@@ -166,13 +293,16 @@ module DevLXC::CLI
     option :shared, :aliases => "-s", :type => :boolean, :desc => "Also destroy the shared images"
     option :platform, :aliases => "-p", :type => :boolean, :desc => "Also destroy the platform images"
     def destroy(server_name_regex=nil)
+      start_time = Time.now
       match_server_name_regex(server_name_regex).reverse_each do |s|
         s.destroy
         s.destroy_image(:custom) if options[:custom]
         s.destroy_image(:unique) if options[:unique]
         s.destroy_image(:shared) if options[:shared]
         s.destroy_image(:platform) if options[:platform]
+        puts
       end
+      print_elapsed_time(Time.now - start_time)
     end
 
   end

data/lib/dev-lxc/cluster.rb

@@ -2,11 +2,14 @@ require "dev-lxc/server"
 
 module DevLXC
   class Cluster
-    attr_reader :api_fqdn, :analytics_fqdn, :chef_server_bootstrap_backend, :analytics_bootstrap_backend
+    attr_reader :api_fqdn, :analytics_fqdn, :chef_server_bootstrap_backend, :analytics_bootstrap_backend, :lxc_config_path
 
     def initialize(cluster_config)
       @cluster_config = cluster_config
 
+      @lxc_config_path = @cluster_config["lxc_config_path"]
+      @lxc_config_path ||= "/var/lib/dev-lxc"
+
       if @cluster_config["chef-server"]
         @chef_server_topology = @cluster_config["chef-server"]["topology"]
         @api_fqdn = @cluster_config["chef-server"]["api_fqdn"]
@@ -60,12 +63,12 @@ module DevLXC
 
     def chef_repo(force=false, pivotal=false)
       if @chef_server_bootstrap_backend.nil?
-        puts "A bootstrap backend Chef Server is not defined in the cluster's config. Please define it first."
+        puts "ERROR: A bootstrap backend Chef Server is not defined in the cluster's config. Please define it first."
         exit 1
       end
       chef_server = Server.new(@chef_server_bootstrap_backend, 'chef-server', @cluster_config)
       if ! chef_server.server.defined?
-        puts "The '#{chef_server.server.name}' Chef Server does not exist. Please create it first."
+        puts "ERROR: The '#{chef_server.server.name}' Chef Server does not exist. Please create it first."
         exit 1
       end
 
@@ -117,28 +120,6 @@ module DevLXC
           puts "The knife.rb file can not be copied because it does not exist in '#{chef_server.server.name}' Chef Server's `/root/chef-repo/.chef` directory"
         end
       end
-
-      bootstrap_node = %Q(#!/bin/bash
-
-if [[ -z $1 ]]; then
-  echo "Please provide the name of the node to be bootstrapped"
-  return 1
-fi
-
-xc-start $1
-
-xc-chef-config -s #{chef_server_url} \\
-               -u #{validator_name} \\
-               -k ./chef-repo/.chef/#{validator_name}.pem
-
-if [[ -n $2 ]]; then
-  xc-attach chef-client -r $2
-else
-  xc-attach chef-client
-fi
-)
-      IO.write("./bootstrap-node", bootstrap_node)
-      FileUtils.chmod("u+x", "./bootstrap-node")
     end
 
     def chef_server_config

data/lib/dev-lxc/container.rb

@@ -1,31 +1,46 @@
 module DevLXC
   class Container < LXC::Container
+    def status
+      if self.defined?
+        state = self.state
+        ip_addresses = self.ip_addresses.join(" ") if self.state == :running
+      else
+        state = "not_created"
+      end
+      { 'name' => self.name, 'state' => state, 'ip_addresses' => ip_addresses }
+    end
+
     def start
-      raise "Container #{self.name} does not exist." unless self.defined?
-      puts "Starting container #{self.name}"
+      unless self.defined?
+        puts "ERROR: Container '#{self.name}' does not exist."
+        exit 1
+      end
+      puts "Starting container '#{self.name}'"
       super
       wait(:running, 3)
-      puts "Waiting for #{self.name} container's network"
+      puts "Waiting for '#{self.name}' container's network"
       ips = nil
       30.times do
         ips = self.ip_addresses
         break unless ips.empty?
         sleep 1
       end
-      raise "Container #{self.name} network is not available." if ips.empty?
+      if ips.empty?
+        puts "ERROR: Container '#{self.name}' network is not available."
+        exit 1
+      end
     end
 
     def stop
-      puts "Stopping container #{self.name}"
+      puts "Stopping container '#{self.name}'"
       super
       wait("STOPPED", 3)
     end
 
     def destroy
-      return unless self.defined?
       stop if running?
-      puts "Destroying container #{self.name}"
-      super
+      puts "Destroying container '#{self.name}'"
+      super if self.defined?
     end
 
     def sync_mounts(mounts)
@@ -36,7 +51,10 @@ module DevLXC
         self.set_config_item("lxc.mount.entry", preserved_mounts)
       end
       mounts.each do |mount|
-        raise "Mount source #{mount.split.first} does not exist." unless File.exists?(mount.split.first)
+        unless File.exists?(mount.split.first)
+          puts "ERROR: Mount source #{mount.split.first} does not exist."
+          exit 1
+        end
         if ! preserved_mounts.nil? && preserved_mounts.any? { |m| m.start_with?("#{mount} ") }
           puts "Skipping mount entry #{mount}, it already exists"
           next
@@ -49,15 +67,22 @@ module DevLXC
     end
 
     def run_command(command)
-      raise "Container #{self.name} must be running first" unless running?
-      attach({:wait => true, :stdin => STDIN, :stdout => STDOUT, :stderr => STDERR}) do
+      unless running?
+        puts "ERROR: Container '#{self.name}' must be running first"
+        exit 1
+      end
+      attach_opts = { wait: true, env_policy: LXC::LXC_ATTACH_CLEAR_ENV, extra_env_vars: ['HOME=/root'] }
+      attach(attach_opts) do
         LXC.run_command(command)
       end
     end
 
     def install_package(package_path)
-      raise "File #{package_path} does not exist in container #{self.name}" unless run_command("test -e #{package_path}") == 0
-      puts "Installing #{package_path} in container #{self.name}"
+      unless run_command("test -e #{package_path}") == 0
+        puts "ERROR: File #{package_path} does not exist in container '#{self.name}'"
+        exit 1
+      end
+      puts "Installing #{package_path} in container '#{self.name}'"
       case File.extname(package_path)
       when ".deb"
         install_command = "dpkg -D10 -i #{package_path}"
@@ -66,5 +91,110 @@ module DevLXC
       end
       run_command(install_command)
     end
+
+    def install_chef_client(version=nil)
+      unless self.defined?
+        puts "ERROR: Container '#{self.name}' does not exist."
+        exit 1
+      end
+      unless running?
+        puts "ERROR: Container '#{self.name}' is not running"
+        exit 1
+      end
+      if self.ip_addresses.empty?
+        puts "ERROR: Container '#{self.name}' network is not available."
+        exit 1
+      end
+
+      require 'tempfile'
+
+      installed_version = nil
+      file = Tempfile.new('installed_chef_client_version')
+      begin
+        attach_opts = { wait: true, env_policy: LXC::LXC_ATTACH_CLEAR_ENV, extra_env_vars: ['HOME=/root'], stdout: file }
+        attach(attach_opts) do
+          puts `chef-client -v`
+        end
+        file.rewind
+        installed_version = Regexp.last_match[1] if file.read.match(/chef:\s*(\d+\.\d+\.\d+)/i)
+      ensure
+        file.close
+        file.unlink
+      end
+      if installed_version.nil? || ( ! version.nil? && ! installed_version.start_with?(version) )
+        require "net/https"
+        require "uri"
+
+        uri = URI.parse("https://www.chef.io/chef/install.sh")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+
+        request = Net::HTTP::Get.new(uri.request_uri)
+
+        response = http.request(request)
+
+        file = Tempfile.new('install_sh', "#{config_item('lxc.rootfs')}/tmp")
+        file.write(response.body)
+        begin
+          version = 'latest' if version.nil?
+          install_command = "bash /tmp/#{File.basename(file.path)} -v #{version}"
+          run_command(install_command)
+        ensure
+          file.close
+          file.unlink
+        end
+      else
+        puts "Chef #{installed_version} is already installed."
+      end
+    end
+
+    def configure_chef_client(chef_server_url, validation_client_name, validation_key)
+      unless self.defined?
+        puts "ERROR: Container '#{self.name}' does not exist."
+        exit 1
+      end
+
+      puts "Configuring Chef Client in container '#{self.name}' for Chef Server '#{chef_server_url}'"
+
+      FileUtils.mkdir_p("#{config_item('lxc.rootfs')}/etc/chef")
+
+      client_rb = %Q(chef_server_url '#{chef_server_url}'
+validation_client_name '#{validation_client_name}'
+ssl_verify_mode :verify_none
+)
+      IO.write("#{config_item('lxc.rootfs')}/etc/chef/client.rb", client_rb)
+
+      begin
+        FileUtils.cp(validation_key, "#{config_item('lxc.rootfs')}/etc/chef/validation.pem")
+      rescue Errno::ENOENT
+        puts "ERROR: The validation key '#{validation_key}' does not exist."
+      end
+    end
+
+    def bootstrap_container(base_container_name=nil, version=nil, run_list=nil, chef_server_url, validation_client_name, validation_key)
+      puts "Bootstrapping container '#{self.name}' for Chef Server '#{chef_server_url}'"
+      if base_container_name
+        if self.defined?
+          puts "WARN: Skipping cloning. Container '#{self.name}' already exists"
+        else
+          puts "Cloning base container '#{base_container_name}' into container '#{self.name}'"
+          base_container = DevLXC::Container.new(base_container_name)
+          unless base_container.defined?
+            puts "ERROR: Base container '#{base_container_name} does not exist"
+            exit 1
+          end
+          base_container.clone(self.name, {:flags => LXC::LXC_CLONE_SNAPSHOT})
+          self.load_config
+        end
+      end
+      self.start unless self.running?
+      self.install_chef_client(version)
+      self.configure_chef_client(chef_server_url, validation_client_name, validation_key)
+
+      chef_client_command = "chef-client"
+      chef_client_command += " -r #{run_list}" if run_list
+      self.run_command(chef_client_command)
+    end
+
   end
 end

data/lib/dev-lxc/server.rb

@@ -7,10 +7,12 @@ module DevLXC
 
     def initialize(name, server_type, cluster_config)
       unless cluster_config[server_type]["servers"].keys.include?(name)
-        raise "Server #{name} is not defined in the cluster config"
+        puts "ERROR: Server '#{name}' is not defined in the cluster config"
+        exit 1
       end
       @server_type = server_type
       cluster = DevLXC::Cluster.new(cluster_config)
+      @lxc_config_path = cluster.lxc_config_path
       @api_fqdn = cluster.api_fqdn
       @analytics_fqdn = cluster.analytics_fqdn
       @chef_server_bootstrap_backend = cluster.chef_server_bootstrap_backend
@@ -18,7 +20,7 @@ module DevLXC
       @chef_server_config = cluster.chef_server_config
       @analytics_config = cluster.analytics_config
 
-      @server = DevLXC::Container.new(name)
+      @server = DevLXC::Container.new(name, @lxc_config_path)
       @config = cluster_config[@server_type]["servers"][@server.name]
       @ipaddress = @config["ipaddress"]
       @role = @config["role"] ? @config["role"] : cluster_config[@server_type]['topology']
@@ -55,26 +57,16 @@ module DevLXC
       end
     end
 
-    def status
-      if @server.defined?
-        state = @server.state
-        ip_addresses = @server.ip_addresses.join(" ") if @server.state == :running
-      else
-        state = "not_created"
-      end
-      printf "%25s     %-15s %s\n", @server.name, state, ip_addresses
-    end
-
     def abspath(rootfs_path)
       "#{@server.config_item('lxc.rootfs')}#{rootfs_path}" if @server.defined?
     end
 
     def run_command(command)
       if @server.running?
-        puts "Running '#{command}' in #{@server.name}"
+        puts "Running '#{command}' in '#{@server.name}'"
         @server.run_command(command)
       else
-        puts "#{@server.name} is not running"
+        puts "'#{@server.name}' is not running"
       end
     end
 
@@ -109,7 +101,7 @@ module DevLXC
         puts "WARNING: Skipping snapshot of '#{@server.name}' because it is not stopped"
         return
       end
-      custom_image = DevLXC::Container.new("c-#{@server.name}")
+      custom_image = DevLXC::Container.new("c-#{@server.name}", @lxc_config_path)
       if custom_image.defined?
         if force
           custom_image.destroy
@@ -118,7 +110,7 @@ module DevLXC
           return
         end
       end
-      puts "Creating snapshot of container #{@server.name} in custom image #{custom_image.name}"
+      puts "Creating snapshot of container '#{@server.name}' in custom image '#{custom_image.name}'"
       @server.clone("#{custom_image.name}", {:flags => LXC::LXC_CLONE_SNAPSHOT|LXC::LXC_CLONE_KEEPMACADDR})
     end
 
@@ -140,47 +132,51 @@ module DevLXC
     def destroy_image(type)
       case type
       when :custom
-        DevLXC::Container.new("c-#{@server.name}").destroy
+        DevLXC::Container.new("c-#{@server.name}", @lxc_config_path).destroy
       when :unique
-        DevLXC::Container.new("u-#{@server.name}").destroy
+        DevLXC::Container.new("u-#{@server.name}", @lxc_config_path).destroy
       when :shared
-        DevLXC::Container.new(@shared_image_name).destroy
+        DevLXC::Container.new(@shared_image_name, @lxc_config_path).destroy
       when :platform
-        DevLXC::Container.new(@platform_image_name).destroy
+        DevLXC::Container.new(@platform_image_name, @lxc_config_path).destroy
       end
     end
 
     def create
       if @server.defined?
-        puts "Using existing container #{@server.name}"
+        puts "Using existing container '#{@server.name}'"
         return
       end
-      custom_image = DevLXC::Container.new("c-#{@server.name}")
-      unique_image = DevLXC::Container.new("u-#{@server.name}")
+      custom_image = DevLXC::Container.new("c-#{@server.name}", @lxc_config_path)
+      unique_image = DevLXC::Container.new("u-#{@server.name}", @lxc_config_path)
       if custom_image.defined?
-        puts "Cloning custom image #{custom_image.name} into container #{@server.name}"
+        puts "Cloning custom image '#{custom_image.name}' into container '#{@server.name}'"
         custom_image.clone(@server.name, {:flags => LXC::LXC_CLONE_SNAPSHOT|LXC::LXC_CLONE_KEEPMACADDR})
-        @server = DevLXC::Container.new(@server.name)
+        @server = DevLXC::Container.new(@server.name, @lxc_config_path)
         return
       elsif unique_image.defined?
-        puts "Cloning unique image #{unique_image.name} into container #{@server.name}"
+        puts "Cloning unique image '#{unique_image.name}' into container '#{@server.name}'"
         unique_image.clone(@server.name, {:flags => LXC::LXC_CLONE_SNAPSHOT|LXC::LXC_CLONE_KEEPMACADDR})
-        @server = DevLXC::Container.new(@server.name)
+        @server = DevLXC::Container.new(@server.name, @lxc_config_path)
         return
       else
-        puts "Creating container #{@server.name}"
-        unless @server.name == @chef_server_bootstrap_backend || DevLXC::Container.new(@chef_server_bootstrap_backend).defined?
-          raise "The bootstrap backend server must be created first."
+        puts "Creating container '#{@server.name}'"
+        unless @server.name == @chef_server_bootstrap_backend || DevLXC::Container.new(@chef_server_bootstrap_backend, @lxc_config_path).defined?
+          puts "ERROR: The bootstrap backend server '#{@chef_server_bootstrap_backend}' must be created first."
+          exit 1
         end
         shared_image = create_shared_image
-        puts "Cloning shared image #{shared_image.name} into container #{@server.name}"
+        puts "Cloning shared image '#{shared_image.name}' into container '#{@server.name}'"
         shared_image.clone(@server.name, {:flags => LXC::LXC_CLONE_SNAPSHOT})
-        @server = DevLXC::Container.new(@server.name)
+        @server = DevLXC::Container.new(@server.name, @lxc_config_path)
         puts "Adding lxc.hook.post-stop hook"
         @server.set_config_item("lxc.hook.post-stop", "/usr/local/share/lxc/hooks/post-stop-dhcp-release")
         @server.save_config
         hwaddr = @server.config_item("lxc.network.0.hwaddr")
-        raise "#{@server.name} needs to have an lxc.network.hwaddr entry" if hwaddr.empty?
+        if hwaddr.empty?
+          puts "ERROR: '#{@server.name}' needs to have an lxc.network.hwaddr entry"
+          exit 1
+        end
         DevLXC.assign_ip_address(@ipaddress, @server.name, hwaddr)
         unless @role == 'backend'
           case @server_type
@@ -214,21 +210,21 @@ module DevLXC
           end
         end
         @server.stop
-        puts "Cloning container #{@server.name} into unique image #{unique_image.name}"
+        puts "Cloning container '#{@server.name}' into unique image '#{unique_image.name}'"
         @server.clone("#{unique_image.name}", {:flags => LXC::LXC_CLONE_SNAPSHOT|LXC::LXC_CLONE_KEEPMACADDR})
       end
     end
 
     def create_shared_image
-      shared_image = DevLXC::Container.new(@shared_image_name)
+      shared_image = DevLXC::Container.new(@shared_image_name, @lxc_config_path)
       if shared_image.defined?
-        puts "Using existing shared image #{shared_image.name}"
+        puts "Using existing shared image '#{shared_image.name}'"
         return shared_image
       end
-      platform_image = DevLXC.create_platform_image(@platform_image_name)
-      puts "Cloning platform image #{platform_image.name} into shared image #{shared_image.name}"
+      platform_image = DevLXC.create_platform_image(@platform_image_name, @lxc_config_path)
+      puts "Cloning platform image '#{platform_image.name}' into shared image '#{shared_image.name}'"
       platform_image.clone(shared_image.name, {:flags => LXC::LXC_CLONE_SNAPSHOT})
-      shared_image = DevLXC::Container.new(shared_image.name)
+      shared_image = DevLXC::Container.new(shared_image.name, @lxc_config_path)
 
       # Disable certain sysctl.d files in Ubuntu 10.04, they cause `start procps` to fail
       # Enterprise Chef server's postgresql recipe expects to be able to `start procps`
@@ -275,8 +271,8 @@ module DevLXC
           IO.write("#{@server.config_item('lxc.rootfs')}/etc/opscode/chef-server.rb", @chef_server_config)
         end
       when "frontend"
-        puts "Copying /etc/opscode from bootstrap backend"
-        FileUtils.cp_r("#{LXC::Container.new(@chef_server_bootstrap_backend).config_item('lxc.rootfs')}/etc/opscode",
+        puts "Copying /etc/opscode from bootstrap backend '#{@chef_server_bootstrap_backend}'"
+        FileUtils.cp_r("#{LXC::Container.new(@chef_server_bootstrap_backend, @lxc_config_path).config_item('lxc.rootfs')}/etc/opscode",
                        "#{@server.config_item('lxc.rootfs')}/etc")
       end
       run_ctl(@server_ctl, "reconfigure")
@@ -284,8 +280,8 @@ module DevLXC
 
     def configure_reporting
       if @role == 'frontend'
-        puts "Copying /etc/opscode-reporting from bootstrap backend"
-        FileUtils.cp_r("#{LXC::Container.new(@chef_server_bootstrap_backend).config_item('lxc.rootfs')}/etc/opscode-reporting",
+        puts "Copying /etc/opscode-reporting from bootstrap backend '#{@chef_server_bootstrap_backend}'"
+        FileUtils.cp_r("#{LXC::Container.new(@chef_server_bootstrap_backend, @lxc_config_path).config_item('lxc.rootfs')}/etc/opscode-reporting",
                        "#{@server.config_item('lxc.rootfs')}/etc")
       end
       run_ctl(@server_ctl, "reconfigure")
@@ -333,21 +329,21 @@ module DevLXC
     def configure_analytics
       case @role
       when "standalone", "backend"
-        puts "Copying /etc/opscode-analytics from Chef Server bootstrap backend"
-        FileUtils.cp_r("#{LXC::Container.new(@chef_server_bootstrap_backend).config_item('lxc.rootfs')}/etc/opscode-analytics",
+        puts "Copying /etc/opscode-analytics from Chef Server bootstrap backend '#{@chef_server_bootstrap_backend}'"
+        FileUtils.cp_r("#{LXC::Container.new(@chef_server_bootstrap_backend, @lxc_config_path).config_item('lxc.rootfs')}/etc/opscode-analytics",
                        "#{@server.config_item('lxc.rootfs')}/etc")
 
         IO.write("#{@server.config_item('lxc.rootfs')}/etc/opscode-analytics/opscode-analytics.rb", @analytics_config)
       when "frontend"
-        puts "Copying /etc/opscode-analytics from Analytics bootstrap backend"
-        FileUtils.cp_r("#{LXC::Container.new(@analytics_bootstrap_backend).config_item('lxc.rootfs')}/etc/opscode-analytics",
+        puts "Copying /etc/opscode-analytics from Analytics bootstrap backend '#{@analytics_bootstrap_backend}'"
+        FileUtils.cp_r("#{LXC::Container.new(@analytics_bootstrap_backend, @lxc_config_path).config_item('lxc.rootfs')}/etc/opscode-analytics",
                        "#{@server.config_item('lxc.rootfs')}/etc")
       end
       run_ctl("opscode-analytics", "reconfigure")
     end
 
     def run_ctl(component, subcommand)
-      puts "Running `#{component}-ctl #{subcommand}` in #{@server.name}"
+      puts "Running `#{component}-ctl #{subcommand}` in '#{@server.name}'"
       @server.run_command("#{component}-ctl #{subcommand}")
     end
 

data/lib/dev-lxc/version.rb

@@ -1,3 +1,3 @@
 module DevLXC
-  VERSION = "0.6.4"
+  VERSION = "1.0.0"
 end

data/lib/dev-lxc.rb

@@ -6,13 +6,13 @@ require "dev-lxc/server"
 require "dev-lxc/cluster"
 
 module DevLXC
-  def self.create_platform_image(platform_image_name)
-    platform_image = DevLXC::Container.new(platform_image_name)
+  def self.create_platform_image(platform_image_name, lxc_config_path='/var/lib/lxc')
+    platform_image = DevLXC::Container.new(platform_image_name, lxc_config_path)
     if platform_image.defined?
-      puts "Using existing platform image #{platform_image.name}"
+      puts "Using existing platform image '#{platform_image.name}'"
       return platform_image
     end
-    puts "Creating platform image #{platform_image.name}"
+    puts "Creating platform image '#{platform_image.name}'"
     case platform_image.name
     when "p-ubuntu-1004"
       platform_image.create("download", "btrfs", {}, 0, ["-d", "ubuntu", "-r", "lucid", "-a", "amd64"])
@@ -29,11 +29,11 @@ module DevLXC
       platform_image.set_config_item("lxc.mount.auto", "proc:rw sys:rw")
     end
     hwaddr = '00:16:3e:' + Digest::SHA1.hexdigest(Time.now.to_s).slice(0..5).unpack('a2a2a2').join(':')
-    puts "Setting #{platform_image.name} platform image's lxc.network.0.hwaddr to #{hwaddr}"
+    puts "Setting '#{platform_image.name}' platform image's lxc.network.0.hwaddr to #{hwaddr}"
     platform_image.set_config_item("lxc.network.0.hwaddr", hwaddr)
     platform_image.save_config
     platform_image.start
-    puts "Installing packages in platform image #{platform_image.name}"
+    puts "Installing packages in platform image '#{platform_image.name}'"
     case platform_image.name
     when "p-ubuntu-1004"
       # Disable certain sysctl.d files in Ubuntu 10.04, they cause `start procps` to fail
@@ -59,7 +59,7 @@ module DevLXC
   end
 
   def self.assign_ip_address(ipaddress, container_name, hwaddr)
-    puts "Assigning IP address #{ipaddress} to #{container_name} container's lxc.network.hwaddr #{hwaddr}"
+    puts "Assigning IP address #{ipaddress} to '#{container_name}' container's lxc.network.hwaddr #{hwaddr}"
     search_file_delete_line("/etc/lxc/dhcp-hosts.conf", /(^#{hwaddr}|,#{ipaddress}$)/)
     append_line_to_file("/etc/lxc/dhcp-hosts.conf", "#{hwaddr},#{ipaddress}\n")
     reload_dnsmasq

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dev-lxc
 version: !ruby/object:Gem::Version
-  version: 0.6.4
+  version: 1.0.0
 platform: ruby
 authors:
 - Jeremiah Snapp
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-30 00:00:00.000000000 Z
+date: 2015-04-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler