dev-lxc 1.7.0 → 2.0.0

data/dev-lxc.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |spec|
   spec.version       = DevLXC::VERSION
   spec.authors       = ["Jeremiah Snapp"]
   spec.email         = ["jeremiah@getchef.com"]
-  spec.description   = %q{A tool for creating Chef server clusters using LXC containers}
+  spec.description   = %q{A tool for building Chef server clusters using LXC containers}
   spec.summary       = spec.description
   spec.licenses	     = "Apache2"
   spec.homepage      = "https://github.com/jeremiahsnapp/dev-lxc"
@@ -20,6 +20,7 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake", "~> 0"
+  spec.add_runtime_dependency "mixlib-install", "~> 0"
   spec.add_runtime_dependency "thor", "~> 0"
   spec.add_runtime_dependency "ruby-lxc", "~> 1.2.0"
 end

data/lib/dev-lxc/cli.rb

@@ -6,59 +6,6 @@ module DevLXC::CLI
   class DevLXC < Thor
 
     no_commands{
-      def validate_cluster_config(cluster_config)
-        hostnames = Array.new
-        mounts = Array.new
-        packages = Array.new
-        ssh_keys = Array.new
-
-        mounts.concat(cluster_config['mounts']) unless cluster_config['mounts'].nil?
-        ssh_keys.concat(cluster_config['ssh-keys']) unless cluster_config['ssh-keys'].nil?
-
-        %w(chef-server analytics compliance supermarket adhoc).each do |server_type|
-          unless cluster_config[server_type].nil?
-            hostnames << cluster_config[server_type]['api_fqdn'] unless cluster_config[server_type]['api_fqdn'].nil?
-            hostnames << cluster_config[server_type]['analytics_fqdn'] unless cluster_config[server_type]['analytics_fqdn'].nil?
-            hostnames.concat(cluster_config[server_type]['servers'].keys) unless cluster_config[server_type]['servers'].nil?
-            mounts.concat(cluster_config[server_type]['mounts']) unless cluster_config[server_type]['mounts'].nil?
-            packages.concat(cluster_config[server_type]['packages'].values) unless cluster_config[server_type]['packages'].nil?
-            ssh_keys.concat(cluster_config[server_type]['ssh-keys']) unless cluster_config[server_type]['ssh-keys'].nil?
-          end
-        end
-        unless hostnames.empty?
-          hostnames.each do |hostname|
-            unless hostname.end_with?(".lxc")
-              puts "ERROR: Hostname #{hostname} does not end with '.lxc'."
-              exit 1
-            end
-          end
-        end
-        unless mounts.empty?
-          mounts.each do |mount|
-            unless File.exists?(mount.split.first)
-              puts "ERROR: Mount source #{mount.split.first} does not exist."
-              exit 1
-            end
-          end
-        end
-        unless packages.empty?
-          packages.each do |package|
-            unless File.exists?(package)
-              puts "ERROR: Package #{package} does not exist."
-              exit 1
-            end
-          end
-        end
-        unless ssh_keys.empty?
-          ssh_keys.each do |ssh_key|
-            unless File.exists?(ssh_key)
-              puts "ERROR: SSH key #{ssh_key} does not exist."
-              exit 1
-            end
-          end
-        end
-      end
-
       def get_cluster(config_file=nil)
         config_file ||= "dev-lxc.yml"
         if ! File.exists?(config_file)
@@ -67,162 +14,57 @@ module DevLXC::CLI
           exit 1
         end
         cluster_config = YAML.load(IO.read(config_file))
-        validate_cluster_config(cluster_config)
         ::DevLXC::Cluster.new(cluster_config)
       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"
+    desc "create-base-container [BASE_CONTAINER_NAME]", "Create a base container"
     option :options, :aliases => "-o", :desc => "Specify additional options for the lxc create"
-    def create(platform_image_name=nil)
+    def create_base_container(base_container_name=nil)
       start_time = Time.now
-      platform_image_names = %w(p-ubuntu-1204 p-ubuntu-1404 p-ubuntu-1604 p-centos-5 p-centos-6 p-centos-7)
-      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]}
-        print_table platform_image_names_with_index
-        selection = ask("Which platform image do you want to create?", :limited_to => platform_image_names_with_index.map{|c| c[0].to_s})
-        platform_image_name = platform_image_names[selection.to_i - 1]
+      base_container_names = %w(b-ubuntu-1204 b-ubuntu-1404 b-ubuntu-1604 b-centos-5 b-centos-6 b-centos-7)
+      if base_container_name.nil? || ! base_container_names.include?(base_container_name)
+        base_container_names_with_index = base_container_names.map.with_index{ |a, i| [i+1, *a]}
+        print_table base_container_names_with_index
+        selection = ask("Which base container do you want to create?", :limited_to => base_container_names_with_index.map{|c| c[0].to_s})
+        base_container_name = base_container_names[selection.to_i - 1]
       end
-      ::DevLXC.create_platform_image(platform_image_name, options[:options])
-      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])
+      ::DevLXC.create_base_container(base_container_name, options[:options])
       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/demo"
-        validation_client_name = 'demo-validator'
-        validation_key = "#{chef_server_bootstrap_backend.config_item('lxc.rootfs')}/root/chef-repo/.chef/demo-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/demo"
-        validation_client_name = 'demo-validator'
-        validation_key = "#{chef_server_bootstrap_backend.config_item('lxc.rootfs')}/root/chef-repo/.chef/demo-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 [UNIQUE_STRING]", "Provide a cluster config file with optional uniqueness in server names and FQDNs"
-    option :open_source, :type => :boolean, :desc => "Standalone Old Open Source Chef Server"
-    option :tiered_chef, :type => :boolean, :desc => "Tiered Chef Server"
+    desc "init", "Provide a cluster config file"
     option :chef, :type => :boolean, :desc => "Standalone Chef Server"
+    option :chef_tier, :type => :boolean, :desc => "Chef Server using Tier topology with one backend"
+    option :chef_backend, :type => :boolean, :desc => "Chef Server using Chef Backend HA topology with three backends"
+    option :nodes, :type => :boolean, :desc => "Node Servers"
     option :analytics, :type => :boolean, :desc => "Analytics Server"
     option :compliance, :type => :boolean, :desc => "Compliance Server"
     option :supermarket, :type => :boolean, :desc => "Supermarket Server"
     option :adhoc, :type => :boolean, :desc => "Adhoc Servers"
-    def init(unique_string=nil)
-      header = %Q(## platform_image can be one of the following:
-## p-centos-5, p-centos-6, p-centos-7, p-ubuntu-1204, p-ubuntu-1404 or p-ubuntu-1604
-platform_image: p-ubuntu-1404
-
-## platform_image_options can be set to provide additional arguments to the LXC create command
-## reference arg examples: https://github.com/lxc/lxc/blob/lxc-2.0.0/templates/lxc-download.in#L200-L207
-#platform_image_options: --no-validate
+    option :append, :aliases => "-a", :type => :boolean, :desc => "Do not generate the global config header"
+    option :filename, :aliases => "-f", :desc => "Write generated content to FILE rather than standard output."
+    def init
+      header = %Q(# base_container must be the name of an existing container
+base_container: b-ubuntu-1404
 
-## list any host directories you want mounted into the servers
-mounts:
-  - /root/dev root/dev
+# list any host directories you want mounted into the servers
+#mounts:
+#  - /root/dev root/dev
 
-## list any SSH public keys you want added to /home/dev-lxc/.ssh/authorized_keys
+# list any SSH public keys you want added to /home/dev-lxc/.ssh/authorized_keys
 #ssh-keys:
 #  - /root/dev/clusters/id_rsa.pub
 
-## DHCP reserved (static) IPs must be selected from the IP range 10.0.3.150 - 254
-)
-
-      chef_packages_path = "/root/dev/chef-packages"
-      open_source_package = "server: #{chef_packages_path}/osc/chef-server_11.1.6-1_amd64.deb"
-      chef_server_package = "server: #{chef_packages_path}/cs/chef-server-core_12.6.0-1_amd64.deb"
-      manage_package = "manage: #{chef_packages_path}/manage/chef-manage_2.3.0-1_amd64.deb"
-      reporting_package = "reporting: #{chef_packages_path}/reporting/opscode-reporting_1.5.6-1_amd64.deb"
-      push_jobs_server_package = "push-jobs-server: #{chef_packages_path}/push-jobs-server/opscode-push-jobs-server_1.1.6-1_amd64.deb"
-      analytics_package = "analytics: #{chef_packages_path}/analytics/opscode-analytics_1.4.0-1_amd64.deb"
-      compliance_package = "compliance: #{chef_packages_path}/compliance/chef-compliance_1.1.9-1_amd64.deb"
-      supermarket_package = "supermarket: #{chef_packages_path}/supermarket/supermarket_2.5.2-1_amd64.deb"
-
-      open_source_config = %Q(
-chef-server:
-  packages:
-    #{open_source_package}
-  api_fqdn: chef.lxc
-  topology: open-source
-  servers:
-    osc-chef.lxc:
-      ipaddress: 10.0.3.200
+# DHCP reserved (static) IPs must be selected from the IP range 10.0.3.150 - 254
 )
-      tiered_chef_config = %Q(
+      chef_tier_config = %Q(
 chef-server:
-  packages:
-    #{chef_server_package}
-    #{manage_package}
-    #{reporting_package}
-    #{push_jobs_server_package}
   topology: tier
   api_fqdn: chef.lxc
   servers:
@@ -230,44 +72,53 @@ chef-server:
       ipaddress: 10.0.3.201
       role: backend
       bootstrap: true
+      products:
+        chef-server:
+        push-jobs-server:
+        reporting:
     chef-fe1.lxc:
       ipaddress: 10.0.3.202
       role: frontend
+      products:
+        chef-server:
+        manage:
+        push-jobs-server:
+        reporting:
 )
       chef_config = %Q(
 chef-server:
-  packages:
-    #{chef_server_package}
-    #{manage_package}
-    #{reporting_package}
-    #{push_jobs_server_package}
   servers:
     chef.lxc:
       ipaddress: 10.0.3.203
+      products:
+        chef-server:
+        manage:
+        push-jobs-server:
+        reporting:
 )
       analytics_config = %Q(
 analytics:
-  packages:
-    #{analytics_package}
   servers:
     analytics.lxc:
       ipaddress: 10.0.3.204
+      products:
+        analytics:
 )
       compliance_config = %Q(
 compliance:
-  packages:
-    #{compliance_package}
   servers:
     compliance.lxc:
       ipaddress: 10.0.3.205
+      products:
+        compliance:
 )
       supermarket_config = %Q(
 supermarket:
-  packages:
-    #{supermarket_package}
   servers:
     supermarket.lxc:
       ipaddress: 10.0.3.206
+      products:
+        supermarket:
 )
       adhoc_config = %Q(
 adhoc:
@@ -275,67 +126,95 @@ adhoc:
     adhoc.lxc:
       ipaddress: 10.0.3.207
 )
-      config = header
-      config += open_source_config if options[:open_source]
+      chef_backend_config = %Q(
+chef-backend:
+  api_fqdn: chef.lxc
+  servers:
+    chef-backend1.lxc:
+      ipaddress: 10.0.3.208
+      role: backend
+      leader: true
+      products:
+        chef-backend:
+          channel: current
+    chef-backend2.lxc:
+      ipaddress: 10.0.3.209
+      role: backend
+      products:
+        chef-backend:
+          channel: current
+    chef-backend3.lxc:
+      ipaddress: 10.0.3.210
+      role: backend
+      products:
+        chef-backend:
+          channel: current
+    chef-frontend1.lxc:
+      ipaddress: 10.0.3.211
+      role: frontend
+      bootstrap: true
+      products:
+        chef-server:
+        manage:
+)
+      nodes_config = %Q(
+nodes:
+  servers:
+    node-1.lxc:
+      products:
+        chef:
+)
+      config = ""
+      config += header unless options[:append]
       config += chef_config if options[:chef]
-      config += tiered_chef_config if options[:tiered_chef]
+      config += chef_tier_config if options[:chef_tier]
       config += analytics_config if options[:analytics]
       config += compliance_config if options[:compliance]
       config += supermarket_config if options[:supermarket]
       config += adhoc_config if options[:adhoc]
-      unless unique_string.nil?
-        config_hash = YAML.load(config.gsub(/^#/, ''))
-        config.gsub!(/api_fqdn:\s+#{config_hash['api_fqdn']}/, "api_fqdn: #{unique_string}#{config_hash['api_fqdn']}")
-        config.gsub!(/analytics_fqdn:\s+#{config_hash['analytics_fqdn']}/, "analytics_fqdn: #{unique_string}#{config_hash['analytics_fqdn']}")
-        %w(chef-server analytics compliance supermarket adhoc).each do |server_type|
-          if config_hash[server_type]
-            config_hash[server_type]['servers'].keys.each do |server_name|
-              config.gsub!(/ #{server_name}:/, " #{unique_string}#{server_name}:")
-            end
-          end
-        end
+      config += chef_backend_config if options[:chef_backend]
+      config += nodes_config if options[:nodes]
+      if options[:filename]
+        mode = options[:append] ? 'a' : 'w'
+        IO.write(options[:filename], config, mode: mode)
+      else
+        puts config
       end
-      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 FQDN: #{cluster.api_fqdn}\n" if cluster.api_fqdn
-      puts "Analytics FQDN:   #{cluster.analytics_fqdn}\n" if cluster.analytics_fqdn
-      puts "Compliance FQDN:  #{cluster.compliance_fqdn}\n" if cluster.compliance_fqdn
-      puts "Supermarket FQDN: #{cluster.supermarket_fqdn}\n" if cluster.supermarket_fqdn
-      puts
+      if cluster.config['chef-server'][:topology] == "tier" && cluster.config['chef-server'][:fqdn]
+        printf "Chef Server FQDN: %s\n\n", cluster.config['chef-server'][:fqdn]
+      end
+      if cluster.config['chef-backend'][:fqdn]
+        printf "Chef Server FQDN: %s\n\n", cluster.config['chef-backend'][:fqdn]
+      end
+      if cluster.config['analytics'][:topology] == "tier" && cluster.config['analytics'][:fqdn]
+        printf "Analytics FQDN: %s\n\n", cluster.config['analytics'][:fqdn]
+      end
       servers = Array.new
-      match_server_name_regex(server_name_regex).map { |s| servers << s.server.status }
+      cluster.get_sorted_servers(server_name_regex).map { |s| servers << s.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 "realpath [SERVER_NAME_REGEX] [ROOTFS_PATH]", "Returns the real path to a file in each server"
-    option :config, :desc => "Specify a cluster's YAML config file. `./dev-lxc.yml` will be used by default"
-    def realpath(server_name_regex=nil, rootfs_path)
-      realpath = Array.new
-      match_server_name_regex(server_name_regex).map { |s| realpath << s.realpath(rootfs_path) }
-      puts realpath.compact
+      servers.each_with_index do |s, server_index|
+        printf "%-#{max_server_name_length}s     %-15s %s\n", s['name'], s['state'].upcase, s['ip_addresses']
+        server = cluster.get_server(s['name'])
+        server.snapshot_list.each do |snapname, snaptime, snap_comment|
+          printf "  |_ %s %s %s\n", snapname, snaptime, snap_comment
+        end
+        puts if server_index + 1 < servers.length
+      end
     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)
+      servers = get_cluster(options[:config]).get_sorted_servers(server_name_regex)
       if servers.length > 1
         puts "ERROR: The following servers matched '#{server_name_regex}'"
-        servers.map { |s| puts "       #{s.server.name}" }
+        servers.map { |s| puts "       #{s.name}" }
         puts "       Please specify a single server to attach to"
         exit 1
       elsif servers.empty?
@@ -343,9 +222,9 @@ adhoc:
         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"
+      container = servers.first.container
+      if !container.defined? || !container.running?
+        puts "ERROR: Server '#{container.name}' is not running"
         exit 1
       end
       attach_opts = {
@@ -354,7 +233,7 @@ adhoc:
         extra_env_vars: ["LANG=en_US.UTF-8", "TERM=linux", "HOME=#{ENV['HOME']}"]
       }
       shell = ENV['SHELL']
-      server.attach(attach_opts) { system(shell) }
+      container.attach(attach_opts) { system(shell) }
     end
 
     desc "chef-repo", "Creates a chef-repo in the current directory using files from the cluster's backend /root/chef-repo"
@@ -365,48 +244,11 @@ adhoc:
       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"
-    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: %27s  %s\n", (LXC::Container.new(platform_name, lxc_config_path).defined? ? "Created" : "Not Created"), platform_name
-          unless shared_name.empty?
-            puts "|"
-            printf "\\_ Shared: %26s  %s\n", (LXC::Container.new(shared_name, lxc_config_path).defined? ? "Created" : "Not Created"), shared_name
-          end
-          final.each_with_index do |final_name, final_index|
-            puts "   |"
-            unique_name = "u-#{final_name}"
-            printf "   \\_ Unique: %23s  %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, lxc_config_path).defined?
-              printf "   #{shared_connector}  \\_ Custom: %20s  %s\n", "Created", custom_name
-              custom_spacing = "   "
-              final_width = 11
-            else
-              final_width = 14
-            end
-            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"
     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)
       start_time = Time.now
-      match_server_name_regex(server_name_regex).each { |s| s.run_command(command); puts }
+      get_cluster(options[:config]).get_sorted_servers(server_name_regex).each { |s| s.run_command(command); puts }
       print_elapsed_time(Time.now - start_time)
     end
 
@@ -414,7 +256,8 @@ adhoc:
     option :config, :desc => "Specify a cluster's YAML config file. `./dev-lxc.yml` will be used by default"
     def up(server_name_regex=nil)
       start_time = Time.now
-      match_server_name_regex(server_name_regex).each { |s| s.start; puts }
+      get_cluster(options[:config]).up(server_name_regex)
+      puts
       print_elapsed_time(Time.now - start_time)
     end
 
@@ -422,53 +265,75 @@ adhoc:
     option :config, :desc => "Specify a cluster's YAML config file. `./dev-lxc.yml` will be used by default"
     def halt(server_name_regex=nil)
       start_time = Time.now
-      match_server_name_regex(server_name_regex).reverse_each { |s| s.stop; puts }
+      get_cluster(options[:config]).get_sorted_servers(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"
+    desc "snapshot [SERVER_NAME_REGEX]", "Manage a cluster's snapshots"
+    option :comment, :aliases => "-c", :desc => "Add snapshot comment"
     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"
+    option :destroy, :aliases => "-d", :desc => "Destroy snapshot - use ALL to destroy all snapshots"
+    option :list, :aliases => "-l", :type => :boolean, :desc => "List snapshots"
+    option :restore, :aliases => "-r", :desc => "Restore snapshots"
     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}", lxc_config_path).defined?
-      end
-      unless non_stopped_servers.empty?
-        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 "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
+      servers = get_cluster(options[:config]).get_sorted_servers(server_name_regex)
+      if options[:list]
+        servers.each_with_index do |s, server_index|
+          puts s.name
+          s.snapshot_list.each do |snapname, snaptime, snap_comment|
+            printf "  |_ %s %s %s\n", snapname, snaptime, snap_comment
+          end
+          puts if server_index + 1 < servers.length
+        end
+        return
+      elsif options[:destroy]
+        snapname = options[:destroy] == 'destroy' ? "LAST" : options[:destroy]
+        servers.each { |s| s.snapshot_destroy(snapname); puts }
+      elsif options[:restore]
+        running_servers = Array.new
+        servers.each do |s|
+          running_servers << s.name if s.container.running?
+        end
+        unless running_servers.empty?
+          puts "ERROR: Aborting snapshot restore because the following servers are running"
+          puts running_servers
+          exit 1
+        end
+        snapname = options[:restore] == 'restore' ? "LAST" : options[:restore]
+        servers.each { |s| s.snapshot_restore(snapname); puts }
+      else
+        running_servers = Array.new
+        servers.each do |s|
+          running_servers << s.name if s.container.running?
+        end
+        unless running_servers.empty?
+          puts "ERROR: Aborting snapshot because the following servers are running"
+          puts running_servers
+          exit 1
+        end
+        servers.each { |s| s.snapshot(options[:comment]); puts }
       end
-      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"
     option :config, :desc => "Specify a cluster's YAML config file. `./dev-lxc.yml` will be used by default"
-    option :custom, :aliases => "-c", :type => :boolean, :desc => "Also destroy the custom images"
-    option :unique, :aliases => "-u", :type => :boolean, :desc => "Also destroy the unique images"
-    option :shared, :aliases => "-s", :type => :boolean, :desc => "Also destroy the shared images"
-    option :platform, :aliases => "-p", :type => :boolean, :desc => "Also destroy the platform images"
+    option :force, :aliases => "-f", :type => :boolean, :desc => "Destroy servers without confirmation"
     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
+      servers = get_cluster(options[:config]).get_sorted_servers(server_name_regex)
+      if servers.empty?
+        puts "No matching server names were found"
+        exit
+      end
+      unless options[:force]
+        confirmation_string = String.new
+        servers.reverse_each { |s| confirmation_string += "#{s.name}\n" }
+        confirmation_string += "Are you sure you want to destroy these servers? (y/N)\n"
+        return unless yes?(confirmation_string)
       end
+      start_time = Time.now
+      servers.reverse_each { |s| s.destroy; puts }
       print_elapsed_time(Time.now - start_time)
     end