dev-lxc 2.0.3 → 2.1.0

data/lib/dev-lxc/cluster.rb

@@ -8,38 +8,46 @@ module DevLXC
 
     def initialize(cluster_config)
       FileUtils.mkdir_p('/var/dev-lxc') unless Dir.exist?('/var/dev-lxc')
-      validate_cluster_config(cluster_config)
 
       @config = Hash.new { |hash, key| hash[key] = {} }
       @server_configs = Hash.new
 
-      %w(adhoc analytics chef-backend chef-server compliance nodes supermarket).each do |server_type|
+      %w(adhoc analytics automate build-nodes chef-backend chef-server compliance nodes supermarket).each do |server_type|
         if cluster_config[server_type]
-          @config[server_type][:mounts] = cluster_config[server_type]["mounts"]
-          @config[server_type][:mounts] ||= cluster_config["mounts"]
-          @config[server_type][:mounts] ||= Array.new
-          @config[server_type][:mounts] << "/var/dev-lxc var/dev-lxc"
-          @config[server_type][:ssh_keys] = cluster_config[server_type]["ssh-keys"]
-          @config[server_type][:ssh_keys] ||= cluster_config["ssh-keys"]
-          @config[server_type][:base_container_name] = cluster_config[server_type]["base_container"]
-          @config[server_type][:base_container_name] ||= cluster_config["base_container"]
+          mounts = ["/var/dev-lxc var/dev-lxc"]
+          if cluster_config[server_type]["mounts"]
+            mounts.concat(cluster_config[server_type]["mounts"])
+          elsif cluster_config["mounts"]
+            mounts.concat(cluster_config["mounts"])
+          end
+          ssh_keys = cluster_config[server_type]["ssh-keys"]
+          ssh_keys ||= cluster_config["ssh-keys"]
+          base_container_name = cluster_config[server_type]["base_container"]
+          base_container_name ||= cluster_config["base_container"]
+
+          if cluster_config[server_type]["servers"]
+            cluster_config[server_type]["servers"].each do |server_name, server_config|
+              server_config ||= Hash.new
+              products = server_config['products']
+              products ||= Hash.new
+              mounts = ["/var/dev-lxc var/dev-lxc"] + server_config["mounts"] if server_config["mounts"]
+              ssh_keys = server_config["ssh-keys"] if server_config["ssh-keys"]
+              base_container_name = server_config["base_container"] if server_config["base_container"]
+              @server_configs[server_name] = {
+                server_type: server_type,
+                products: products,
+                ipaddress: server_config['ipaddress'],
+                additional_fqdn: nil,
+                mounts: mounts,
+                ssh_keys: ssh_keys,
+                base_container_name: base_container_name
+              }
+              # gather configuration from only the first "automate", "compliance" or "supermarket" server
+              break if %w(automate compliance supermarket).include?(server_type)
+            end
+          end
 
           case server_type
-          when "adhoc"
-            if cluster_config[server_type]["servers"]
-              cluster_config[server_type]["servers"].each do |server_name, server_config|
-                products = server_config['products']
-                products ||= Hash.new
-                @server_configs[server_name] = {
-                  server_type: server_type,
-                  products: products,
-                  ipaddress: server_config['ipaddress'],
-                  additional_fqdn: nil,
-                  mounts: @config[server_type][:mounts],
-                  ssh_keys: @config[server_type][:ssh_keys]
-                }
-              end
-            end
           when "analytics"
             @config[server_type][:topology] = cluster_config[server_type]["topology"]
             @config[server_type][:topology] ||= 'standalone'
@@ -48,10 +56,8 @@ module DevLXC
 
             if cluster_config[server_type]["servers"]
               cluster_config[server_type]["servers"].each do |server_name, server_config|
+                server_config ||= Hash.new
                 additional_fqdn = nil
-                products = server_config['products']
-                products ||= Hash.new
-                @server_configs[server_name] = server_config
                 case @config[server_type][:topology]
                 when 'standalone'
                   @config[server_type][:bootstrap_backend] = server_name if server_config["role"].nil?
@@ -63,18 +69,17 @@ module DevLXC
                     @config[server_type][:frontends] << server_name
                   end
                 end
-                @server_configs[server_name] = {
-                  server_type: server_type,
-                  products: products,
-                  ipaddress: server_config['ipaddress'],
-                  additional_fqdn: additional_fqdn,
-                  mounts: @config[server_type][:mounts],
-                  ssh_keys: @config[server_type][:ssh_keys]
-                }
+                @server_configs[server_name].merge!({
+                  additional_fqdn: additional_fqdn
+                })
               end
             end
           when "chef-backend"
             @config[server_type][:fqdn] = cluster_config[server_type]["api_fqdn"]
+            @config[server_type][:users] = cluster_config[server_type]["users"]
+            @config[server_type][:users] ||= Array.new
+            @config[server_type][:orgs] = cluster_config[server_type]["orgs"]
+            @config[server_type][:orgs] ||= Hash.new
             @config[server_type][:backends] = Array.new
             @config[server_type][:frontends] = Array.new
 
@@ -85,9 +90,8 @@ module DevLXC
               @config[server_type][:backends] << @config[server_type][:leader_backend]
               @config[server_type][:frontends] << @config[server_type][:bootstrap_frontend]
               servers.each do |server_name, server_config|
+                server_config ||= Hash.new
                 additional_fqdn = nil
-                products = server_config['products']
-                products ||= Hash.new
                 case server_config["role"]
                 when "backend"
                   @config[server_type][:backends] << server_name unless server_name == @config[server_type][:leader_backend]
@@ -95,30 +99,28 @@ module DevLXC
                   additional_fqdn = @config[server_type][:fqdn]
                   @config[server_type][:frontends] << server_name unless server_name == @config[server_type][:bootstrap_frontend]
                 end
-                @server_configs[server_name] = {
-                  server_type: server_type,
-                  products: products,
-                  ipaddress: server_config['ipaddress'],
+                @server_configs[server_name].merge!({
                   additional_fqdn: additional_fqdn,
-                  mounts: @config[server_type][:mounts],
-                  ssh_keys: @config[server_type][:ssh_keys],
                   chef_server_type: 'chef-server'
-                }
+                })
               end
             end
           when "chef-server"
             @config[server_type][:topology] = cluster_config[server_type]["topology"]
             @config[server_type][:topology] ||= 'standalone'
             @config[server_type][:fqdn] = cluster_config[server_type]["api_fqdn"]
+            @config[server_type][:users] = cluster_config[server_type]["users"]
+            @config[server_type][:users] ||= Array.new
+            @config[server_type][:orgs] = cluster_config[server_type]["orgs"]
+            @config[server_type][:orgs] ||= Hash.new
             @config[server_type][:frontends] = Array.new
 
             if cluster_config[server_type]["servers"]
               cluster_config[server_type]["servers"].each do |server_name, server_config|
+                server_config ||= Hash.new
                 additional_fqdn = nil
-                products = server_config['products']
-                products ||= Hash.new
-                chef_server_type = 'private-chef' if products.has_key?('private-chef')
-                chef_server_type = 'chef-server' if products.has_key?('chef-server')
+                chef_server_type = 'private-chef' if @server_configs[server_name][:products].has_key?('private-chef')
+                chef_server_type = 'chef-server' if @server_configs[server_name][:products].has_key?('chef-server')
                 case @config[server_type][:topology]
                 when 'standalone'
                   @config[server_type][:bootstrap_backend] = server_name if server_config["role"].nil?
@@ -130,75 +132,77 @@ module DevLXC
                     @config[server_type][:frontends] << server_name
                   end
                 end
-                @server_configs[server_name] = {
-                  server_type: server_type,
-                  products: products,
-                  ipaddress: server_config['ipaddress'],
+                @server_configs[server_name].merge!({
                   additional_fqdn: additional_fqdn,
-                  mounts: @config[server_type][:mounts],
-                  ssh_keys: @config[server_type][:ssh_keys],
                   chef_server_type: chef_server_type
-                }
+                })
               end
             end
-          when "compliance", "supermarket"
+          when "supermarket"
             unless cluster_config[server_type]["servers"].first.nil?
               (server_name, server_config) = cluster_config[server_type]["servers"].first
               @config[server_type][:fqdn] = server_name
-              products = server_config['products']
-              products ||= Hash.new
-              @server_configs[server_name] = {
-                server_type: server_type,
-                products: products,
-                ipaddress: server_config['ipaddress'],
-                additional_fqdn: nil,
-                mounts: @config[server_type][:mounts],
-                ssh_keys: @config[server_type][:ssh_keys]
-              }
+            end
+          when "automate"
+            unless cluster_config[server_type]["servers"].first.nil?
+              (server_name, server_config) = cluster_config[server_type]["servers"].first
+              server_config ||= Hash.new
+              @server_configs[server_name].merge!({
+                license_path: server_config['license_path'],
+                chef_org: server_config['chef_org'],
+                enterprise_name: server_config['enterprise_name']
+              })
             end
           when "nodes"
+            chef_server_url = cluster_config[server_type]['chef_server_url']
+            validation_client_name = cluster_config[server_type]['validation_client_name']
+            validation_key = cluster_config[server_type]['validation_key']
             if cluster_config[server_type]["servers"]
               cluster_config[server_type]["servers"].each do |server_name, server_config|
-                products = server_config['products']
-                products ||= Hash.new
-                @server_configs[server_name] = {
-                  server_type: server_type,
-                  products: products,
-                  ipaddress: server_config['ipaddress'],
-                  additional_fqdn: nil,
-                  mounts: @config[server_type][:mounts],
-                  ssh_keys: @config[server_type][:ssh_keys],
-                  chef_server_url: server_config['chef_server_url'],
-                  validation_client_name: server_config['validation_client_name'],
-                  validation_key: server_config['validation_key']
-                }
+                server_config ||= Hash.new
+                chef_server_url = server_config['chef_server_url'] if server_config['chef_server_url']
+                validation_client_name = server_config['validation_client_name'] if server_config['validation_client_name']
+                validation_key = server_config['validation_key'] if server_config['validation_key']
+                @server_configs[server_name].merge!({
+                  chef_server_url: chef_server_url,
+                  validation_client_name: validation_client_name,
+                  validation_key: validation_key
+                })
               end
             end
           end
         end
       end
+      validate_cluster_config
     end
 
-    def validate_cluster_config(cluster_config)
-      hostnames = Array.new
-      mounts = Array.new
+    def validate_cluster_config
       base_container_names = Array.new
+      mounts = Array.new
       ssh_keys = Array.new
+      hostnames = Array.new
 
-      base_container_names << cluster_config['base_container'] unless cluster_config['base_container'].nil?
-      mounts.concat(cluster_config['mounts']) unless cluster_config['mounts'].nil?
-      ssh_keys.concat(cluster_config['ssh-keys']) unless cluster_config['ssh-keys'].nil?
-
-      %w(adhoc analytics chef-backend chef-server compliance nodes supermarket).each do |server_type|
-        unless cluster_config[server_type].nil?
-          base_container_names << cluster_config[server_type]['base_container'] unless cluster_config[server_type]['base_container'].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?
-          ssh_keys.concat(cluster_config[server_type]['ssh-keys']) unless cluster_config[server_type]['ssh-keys'].nil?
+      @config.map { |server_type, config| hostnames.push(config[:fqdn]) }
+
+      @server_configs.each do |server_name, server_config|
+        base_container_names.push(server_config[:base_container_name]).uniq! if server_config[:base_container_name]
+        mounts.concat(server_config[:mounts]).uniq! if server_config[:mounts]
+        ssh_keys.concat(server_config[:ssh_keys]).uniq! if server_config[:ssh_keys]
+        hostnames.push(server_name)
+        case server_config[:server_type]
+        when "automate"
+          if server_config[:license_path] && !File.exists?(server_config[:license_path])
+            puts "ERROR: Automate license #{server_config[:license_path]} does not exist."
+            exit 1
+          end
+        when "nodes"
+          if server_config[:validation_key] && !File.exists?(server_config[:validation_key])
+            puts "ERROR: Validation key #{server_config[:validation_key]} does not exist."
+            exit 1
+          end
         end
       end
+
       unless base_container_names.empty?
         base_container_names.each do |base_container_name|
           unless ::DevLXC::Container.new(base_container_name).defined?
@@ -233,6 +237,15 @@ module DevLXC
       end
     end
 
+    def show_config
+      require 'pp'
+      puts "Cluster config:"
+      pp @config
+      puts
+      puts "Server configs:"
+      pp @server_configs
+    end
+
     def get_server(server_name)
       ipaddress = @server_configs[server_name][:ipaddress]
       additional_fqdn = @server_configs[server_name][:additional_fqdn]
@@ -246,7 +259,7 @@ module DevLXC
 
       # the order of this list of server_types matters
       # it determines the order in which actions are applied to each server_type
-      %w(chef-backend chef-server analytics compliance supermarket nodes adhoc).each do |server_type|
+      %w(chef-backend chef-server analytics compliance supermarket automate build-nodes nodes adhoc).each do |server_type|
         unless @config[server_type].empty?
           case server_type
           when "chef-backend"
@@ -264,11 +277,12 @@ module DevLXC
             @config[server_type][:frontends].each do |frontend_name|
               servers << get_server(frontend_name)
             end
-          when "adhoc", "compliance", "nodes", "supermarket"
-            server_configs = @server_configs.select { |server_name, server_config| server_config[:server_type] == server_type }
-            server_configs.each_key { |server_name| servers << get_server(server_name) }
           end
         end
+        if %w(adhoc automate build-nodes compliance nodes supermarket).include?(server_type)
+          server_configs = @server_configs.select { |server_name, server_config| server_config[:server_type] == server_type }
+          server_configs.each_key { |server_name| servers << get_server(server_name) }
+        end
       end
       servers.select { |s| s.name =~ /#{server_name_regex}/ }
     end
@@ -325,7 +339,7 @@ module DevLXC
           end
         end
         if @server_configs[server.name][:server_type] == 'nodes'
-          if @server_configs[server.name][:chef_server_url].nil? && @server_configs[server.name][:validation_client_name].nil? & @server_configs[server.name][:validation_key].nil?
+          if @server_configs[server.name][:chef_server_url] && @server_configs[server.name][:validation_client_name] && @server_configs[server.name][:validation_key].nil?
             if @config['chef-server'][:bootstrap_backend] && !get_server(@config['chef-server'][:bootstrap_backend]).container.defined? && servers.select { |s| s.name == @config['chef-server'][:bootstrap_backend] }.empty?
               puts "ERROR: '#{server.name}' requires '#{@config['chef-server'][:bootstrap_backend]}' to be configured first."
               abort_up = true
@@ -335,6 +349,43 @@ module DevLXC
             end
           end
         end
+        if @server_configs[server.name][:server_type] == 'automate'
+          if @config['chef-server'][:bootstrap_backend].nil?
+            puts "ERROR: '#{server.name}' requires a Chef Server bootstrap backend to be configured first."
+            abort_up = true
+          elsif !get_server(@config['chef-server'][:bootstrap_backend]).container.defined? && servers.select { |s| s.name == @config['chef-server'][:bootstrap_backend] }.empty?
+            puts "ERROR: '#{server.name}' requires '#{@config['chef-server'][:bootstrap_backend]}' to be configured first."
+            abort_up = true
+          end
+        end
+        if @server_configs[server.name][:server_type] == 'build-nodes'
+          if @config['chef-server'][:bootstrap_backend].nil?
+            puts "ERROR: '#{server.name}' requires a Chef Server bootstrap backend to be configured first."
+            abort_up = true
+          elsif !get_server(@config['chef-server'][:bootstrap_backend]).container.running? && servers.select { |s| s.name == @config['chef-server'][:bootstrap_backend] }.empty?
+            puts "ERROR: '#{server.name}' requires '#{@config['chef-server'][:bootstrap_backend]}' to be running first."
+            abort_up = true
+          end
+          if @config['chef-server'][:topology] == 'tier'
+            if @config[server_type][:frontends].empty?
+              puts "ERROR: '#{server.name}' requires at least one Chef Server frontend to be configured first."
+              abort_up = true
+            elsif (@config['chef-server'][:frontends].select { |s| get_server(s).container.running? }.length + servers.select { |s| @config['chef-server'][:frontends].include?(s.name) }.length) < 1
+              puts "ERROR: '#{server.name}' requires at least one Chef Server frontend to be running first."
+              abort_up = true
+            end
+          end
+          automate_server_name = @server_configs.select {|name, config| config[:server_type] == 'automate'}.keys.first
+          if automate_server_name
+            if !get_server(automate_server_name).container.running? && servers.select { |s| s.name == automate_server_name }.empty?
+              puts "ERROR: '#{server.name}' requires '#{automate_server_name}' to be running first."
+              abort_up = true
+            end
+          else
+            puts "ERROR: '#{server.name}' requires an Automate Server to be configured first."
+            abort_up = true
+          end
+        end
       end
       exit 1 if abort_up
       prep_product_cache(servers)
@@ -386,7 +437,7 @@ module DevLXC
 
     def clone_from_base_container(server)
       server_type = @server_configs[server.name][:server_type]
-      base_container = DevLXC::Container.new(@config[server_type][:base_container_name])
+      base_container = DevLXC::Container.new(@server_configs[server.name][:base_container_name])
       puts "Cloning base container '#{base_container.name}' into container '#{server.name}'"
       base_container.clone(server.name, {:flags => LXC::LXC_CLONE_SNAPSHOT})
       server.container.load_config
@@ -399,7 +450,7 @@ module DevLXC
 
     def get_product_url(server, product_name, product_options)
       server_type = @server_configs[server.name][:server_type]
-      base_container = DevLXC::Container.new(@config[server_type][:base_container_name])
+      base_container = DevLXC::Container.new(@server_configs[server.name][:base_container_name])
       mixlib_install_platform_detection_path = "#{base_container.config_item('lxc.rootfs')}/mixlib-install-platform-detection"
       IO.write(mixlib_install_platform_detection_path, Mixlib::Install::Generator::Bourne.detect_platform_sh)
       platform_results = `chroot #{base_container.config_item('lxc.rootfs')} bash mixlib-install-platform-detection`
@@ -431,13 +482,13 @@ module DevLXC
       artifact.url
     end
 
-    def prep_product_cache(servers)
+    def prep_product_cache(servers, force=false)
       all_required_products = Hash.new
       servers.each do |server|
         products = @server_configs[server.name][:products]
         @server_configs[server.name][:required_products] = Hash.new
-        if !server.snapshot_list.select { |sn| sn[2].start_with?("dev-lxc build: products installed") }.empty?
-          puts "Skipping product cache preparation for container '#{server.name}' because it has a 'products installed' snapshot"
+        if !force && !server.snapshot_list.select { |sn| sn[2].start_with?("dev-lxc build: products installed") }.empty?
+          # Skipping product cache preparation for container because it has a 'products installed' snapshot
           next
         end
         products.each do |product_name, product_options|
@@ -480,7 +531,11 @@ module DevLXC
         server.start
       end
       @server_configs[server.name][:required_products].each do |product_name, package_source|
-        server.install_package(package_source)
+        if @server_configs[server.name][:server_type] == "automate" && product_name == "chefdk"
+          IO.write("#{server.container.config_item('lxc.rootfs')}/root/build_node_chefdk_package_path", "#{package_source}\n")
+        else
+          server.install_package(package_source)
+        end
       end
       server.stop
       server.snapshot("dev-lxc build: products installed")
@@ -493,66 +548,147 @@ module DevLXC
       required_products = @server_configs[server.name][:required_products].keys if @server_configs[server.name][:required_products]
       required_products ||= Array.new
       server_type = @server_configs[server.name][:server_type]
+      dot_chef_path = "/root/chef-repo/.chef"
       case server_type
       when 'adhoc'
         # Allow adhoc servers time to generate SSH Server Host Keys
         sleep 5
       when 'analytics'
         configure_analytics(server) if required_products.include?('analytics')
+      when 'build-nodes'
+        configure_build_node(server)
       when 'chef-backend'
         configure_chef_backend(server) if required_products.include?('chef-backend')
         if required_products.include?('chef-server')
           configure_chef_frontend(server)
-          create_users(server) if server.name == @config['chef-backend'][:bootstrap_frontend]
+          if server.name == @config['chef-backend'][:bootstrap_frontend]
+            create_users_orgs_knife_configs(server, dot_chef_path)
+          end
         end
         configure_manage(server) if required_products.include?('manage')
       when 'chef-server'
         if required_products.include?('chef-server') || required_products.include?('private-chef')
           configure_chef_server(server)
-          create_users(server) if server.name == @config['chef-server'][:bootstrap_backend]
+          if server.name == @config['chef-server'][:bootstrap_backend]
+            create_users_orgs_knife_configs(server, dot_chef_path)
+
+            automate_server_name = @server_configs.select {|name, config| config[:server_type] == 'automate'}.keys.first
+            if automate_server_name
+              automate_user = "delivery"
+              automate_chef_org = @server_configs[automate_server_name][:chef_org]
+              create_user(server, automate_user, dot_chef_path)
+              create_org(server, automate_chef_org, dot_chef_path)
+              org_add_user(server, automate_chef_org, automate_user, true, dot_chef_path)
+            end
+          end
         end
         configure_reporting(server) if required_products.include?('reporting')
         configure_push_jobs_server(server) if required_products.include?('push-jobs-server')
         configure_manage(server) if required_products.include?('manage')
       when 'compliance'
         configure_compliance(server) if required_products.include?('compliance')
+      when 'automate'
+        configure_automate(server) if required_products.include?('delivery')
       when 'nodes'
-        configure_chef_client(server) if required_products.include?('chef') || required_products.include?('chefdk')
+        # Allow servers time to generate SSH Server Host Keys
+        sleep 5
+        configure_chef_client(server, dot_chef_path) if required_products.include?('chef') || required_products.include?('chefdk')
       when 'supermarket'
         configure_supermarket(server) if required_products.include?('supermarket')
       end
     end
 
-    def configure_chef_client(server)
-      if @server_configs[server.name][:chef_server_url] || @server_configs[server.name][:validation_client_name] || @server_configs[server.name][:validation_key]
-        chef_server_url = @server_configs[server.name][:chef_server_url]
-        validation_client_name = @server_configs[server.name][:validation_client_name]
-        validation_key = @server_configs[server.name][:validation_key]
-      elsif @config['chef-server'][:bootstrap_backend] && get_server(@config['chef-server'][:bootstrap_backend]).container.defined?
-        chef_server_url = "https://#{@config['chef-server'][:fqdn]}/organizations/demo"
-        validation_client_name = 'demo-validator'
-        validation_key = "#{get_server(@config['chef-server'][:bootstrap_backend]).container.config_item('lxc.rootfs')}/root/chef-repo/.chef/demo-validator.pem"
-      elsif @config['chef-backend'][:bootstrap_frontend] && get_server(@config['chef-backend'][:bootstrap_frontend]).container.defined?
-        chef_server_url = "https://#{@config['chef-backend'][:fqdn]}/organizations/demo"
-        validation_client_name = 'demo-validator'
-        validation_key = "#{get_server(@config['chef-backend'][:bootstrap_frontend]).container.config_item('lxc.rootfs')}/root/chef-repo/.chef/demo-validator.pem"
+    def configure_automate(server)
+      license_path = @server_configs[server.name][:license_path]
+      chef_org = @server_configs[server.name][:chef_org]
+      enterprise_name = @server_configs[server.name][:enterprise_name]
+      chef_server_url = @config['chef-server'][:fqdn]
+      supermarket_fqdn = @config['supermarket'][:fqdn]
+
+      FileUtils.cp(license_path, "#{server.container.config_item('lxc.rootfs')}/root/automate.license")
+
+      chef_server = get_server(@config['chef-server'][:bootstrap_backend])
+      automate_chef_user_key = "#{chef_server.container.config_item('lxc.rootfs')}/root/chef-repo/.chef/delivery.pem"
+      FileUtils.cp(automate_chef_user_key, "#{server.container.config_item('lxc.rootfs')}/root/automate_chef_user_key.pem")
+
+      setup_cmd = "setup"
+      setup_cmd += " --license /root/automate.license"
+      setup_cmd += " --fqdn #{server.name}"
+      setup_cmd += " --key /root/automate_chef_user_key.pem"
+      setup_cmd += " --server-url https://#{chef_server_url}/organizations/#{chef_org}"
+      setup_cmd += " --supermarket-fqdn #{supermarket_fqdn}" if supermarket_fqdn
+      setup_cmd += " --enterprise #{enterprise_name}"
+      setup_cmd += " --no-build-node"
+      setup_cmd += " --configure"
+      run_ctl(server, "delivery", setup_cmd)
+    end
+
+    def print_automate_credentials
+      automate_server_name = @server_configs.select {|name, config| config[:server_type] == 'automate'}.keys.first
+      if automate_server_name
+        automate_server = get_server(automate_server_name)
+        automate_credentials_files = Dir.glob("#{automate_server.container.config_item('lxc.rootfs')}/etc/delivery/*-credentials")
+        automate_credentials_files.each_with_index do |automate_credentials_file, index|
+          puts IO.read(automate_credentials_file)
+          puts if index + 1 < automate_credentials_files.length
+        end
+      else
+        puts "WARNING: An Automate server is not defined."
+        exit 1
       end
+    end
 
-      puts "Configuring Chef Client in container '#{server.name}' for Chef Server '#{chef_server_url}'"
+    def configure_build_node(server)
+      automate_server_name = @server_configs.select {|name, config| config[:server_type] == 'automate'}.keys.first
+      if automate_server_name
+        automate_server = get_server(automate_server_name)
+        if File.exist?("#{automate_server.container.config_item('lxc.rootfs')}/root/build_node_chefdk_package_path")
+          build_node_chefdk_package_path = IO.read("#{automate_server.container.config_item('lxc.rootfs')}/root/build_node_chefdk_package_path").chomp
+          install_build_node_cmd = "install-build-node"
+          install_build_node_cmd += " --fqdn #{server.name}"
+          install_build_node_cmd += " --username dev-lxc"
+          install_build_node_cmd += " --password dev-lxc"
+          install_build_node_cmd += " --installer #{build_node_chefdk_package_path}"
+          run_ctl(automate_server, "delivery", install_build_node_cmd)
+        end
+      end
+    end
+
+    def configure_chef_client(server, dot_chef_path)
+      puts "Configuring Chef Client in container '#{server.name}'"
 
       FileUtils.mkdir_p("#{server.container.config_item('lxc.rootfs')}/etc/chef")
 
+      chef_server_url = @server_configs[server.name][:chef_server_url]
+      validation_client_name = @server_configs[server.name][:validation_client_name]
+      validation_key = @server_configs[server.name][:validation_key]
+      if validation_key.nil?
+        chef_server_name = @config['chef-server'][:bootstrap_backend]
+        chef_server_name ||= @config['chef-backend'][:bootstrap_frontend]
+        if chef_server_name
+          chef_server = get_server(chef_server_name)
+          if chef_server.container.defined?
+            validator_pem_files = Dir.glob("#{chef_server.container.config_item('lxc.rootfs')}#{dot_chef_path}/*-validator.pem")
+            FileUtils.cp(validator_pem_files, "#{server.container.config_item('lxc.rootfs')}/etc/chef/") unless validator_pem_files.empty?
+          end
+        end
+      end
+
       client_rb = %Q(chef_server_url '#{chef_server_url}'
 validation_client_name '#{validation_client_name}'
+validation_key '/etc/chef/#{validation_client_name}.pem'
 ssl_verify_mode :verify_none
 )
-      IO.write("#{server.container.config_item('lxc.rootfs')}/etc/chef/client.rb", client_rb)
 
-      if validation_key && File.exist?(validation_key)
-        FileUtils.cp(validation_key, "#{server.container.config_item('lxc.rootfs')}/etc/chef/validation.pem")
-      else
-        puts "WARNING: The validation key '#{validation_key}' does not exist."
+      automate_server_name = @server_configs.select {|name, config| config[:server_type] == 'automate'}.keys.first
+      if automate_server_name
+        client_rb += %Q(
+data_collector.server_url "https://#{automate_server_name}/data-collector/v0/"
+data_collector.token "93a49a4f2482c64126f7b6015e6b0f30284287ee4054ff8807fb63d9cbd1c506"
+)
       end
+
+      IO.write("#{server.container.config_item('lxc.rootfs')}/etc/chef/client.rb", client_rb)
     end
 
     def configure_chef_backend(server)
@@ -683,23 +819,46 @@ ssl_verify_mode :verify_none
       server.run_command("#{component}-ctl #{subcommand}")
     end
 
-    def create_users(server)
-      puts "Creating org, user, keys and knife.rb in /root/chef-repo/.chef"
-      FileUtils.mkdir_p("#{server.container.config_item('lxc.rootfs')}/root/chef-repo/.chef")
-
-      chef_server_root = "https://127.0.0.1"
-      chef_server_url = "https://127.0.0.1/organizations/demo"
-      admin_username = "mary-admin"
-      username = "joe-user"
-      validator_name = "demo-validator"
-
-      FileUtils.cp( "#{server.container.config_item('lxc.rootfs')}/etc/opscode/pivotal.pem", "#{server.container.config_item('lxc.rootfs')}/root/chef-repo/.chef" )
+    def create_users_orgs_knife_configs(server, dot_chef_path)
+      server_type = @server_configs[server.name][:server_type]
+      # give time for all services to come up completely
+      sleep 10
+      if @server_configs[server.name][:chef_server_type] == 'private-chef'
+        # give more time for all services to come up completely
+        sleep 50
+        server.run_command("/opt/opscode/embedded/bin/gem install knife-opc --no-ri --no-rdoc -v 0.3.1")
+      end
+      chef_server_dot_chef_path = "#{server.container.config_item('lxc.rootfs')}#{dot_chef_path}"
+      FileUtils.mkdir_p(chef_server_dot_chef_path)
+      FileUtils.cp( "#{server.container.config_item('lxc.rootfs')}/etc/opscode/pivotal.pem", chef_server_dot_chef_path )
+      create_pivotal_knife_config('127.0.0.1', chef_server_dot_chef_path)
+      create_knife_config('127.0.0.1', chef_server_dot_chef_path)
+      @config[server_type][:users].each do |username|
+        create_user(server, username, dot_chef_path)
+      end
+      @config[server_type][:orgs].each do |orgname, org_users|
+        create_org(server, orgname, dot_chef_path)
+        if org_users
+          if org_users['admins']
+            org_users['admins'].each do |username|
+              org_add_user(server, orgname, username, true, dot_chef_path)
+            end
+          end
+          if org_users['non-admins']
+            org_users['non-admins'].each do |username|
+              org_add_user(server, orgname, username, false, dot_chef_path)
+            end
+          end
+        end
+      end
+    end
 
+    def create_pivotal_knife_config(fqdn, dot_chef_path)
       pivotal_rb = %Q(
 current_dir = File.dirname(__FILE__)
 
-chef_server_root "#{chef_server_root}"
-chef_server_url "#{chef_server_root}"
+chef_server_root "https://#{fqdn}"
+chef_server_url "https://#{fqdn}"
 
 node_name "pivotal"
 client_key "\#{current_dir}/pivotal.pem"
@@ -709,107 +868,106 @@ knife[:chef_repo_path] = Dir.pwd
 
 ssl_verify_mode :verify_none
 )
-      IO.write("#{server.container.config_item('lxc.rootfs')}/root/chef-repo/.chef/pivotal.rb", pivotal_rb)
+      IO.write("#{dot_chef_path}/pivotal.rb", pivotal_rb)
+    end
 
+    def create_knife_config(fqdn, dot_chef_path)
       knife_rb = %Q(
-current_dir = File.dirname(__FILE__)
+username = "CHANGEME"
+orgname = "CHANGEME"
 
-chef_server_url "#{chef_server_url}"
+if [username, orgname].include?("CHANGEME")
+  puts "ERROR: Please set 'username' and 'orgname' to proper values in knife.rb"
+  exit!
+end
 
-node_name "#{admin_username}"
-client_key "\#{current_dir}/#{admin_username}.pem"
-)
+current_dir = File.dirname(__FILE__)
 
-      knife_rb += %Q(
-#node_name "#{username}"
-#client_key "\#{current_dir}/#{username}.pem"
-) unless username.nil?
+chef_server_url "https://#{fqdn}/organizations/\#{orgname}"
 
-      knife_rb += %Q(
-validation_client_name "#{validator_name}"
-validation_key "\#{current_dir}/#{validator_name}.pem"
+node_name username
+client_key "\#{current_dir}/\#{username}.pem"
+
+validation_client_name "\#{orgname}-validator"
+validation_key "\#{current_dir}/\#{orgname}-validator.pem"
 
 cookbook_path Dir.pwd + "/cookbooks"
 knife[:chef_repo_path] = Dir.pwd
 
 ssl_verify_mode :verify_none
 )
-      IO.write("#{server.container.config_item('lxc.rootfs')}/root/chef-repo/.chef/knife.rb", knife_rb)
+      IO.write("#{dot_chef_path}/knife.rb", knife_rb)
+    end
 
+    def create_user(server, username, dot_chef_path)
+      create_user_string = "#{username} #{username} #{username} #{username}@noreply.com #{username} --filename #{dot_chef_path}/#{username}.pem"
       case @server_configs[server.name][:chef_server_type]
       when 'private-chef'
-        # give time for all services to come up completely
-        sleep 60
-        server.run_command("/opt/opscode/embedded/bin/gem install knife-opc --no-ri --no-rdoc -v 0.3.1")
-        server.run_command("/opt/opscode/embedded/bin/knife opc org create demo demo --filename /root/chef-repo/.chef/demo-validator.pem -c /root/chef-repo/.chef/pivotal.rb")
-        server.run_command("/opt/opscode/embedded/bin/knife opc user create mary-admin mary admin mary-admin@noreply.com mary-admin --filename /root/chef-repo/.chef/mary-admin.pem -c /root/chef-repo/.chef/pivotal.rb")
-        server.run_command("/opt/opscode/embedded/bin/knife opc org user add demo mary-admin --admin -c /root/chef-repo/.chef/pivotal.rb")
-        server.run_command("/opt/opscode/embedded/bin/knife opc user create joe-user joe user joe-user@noreply.com joe-user --filename /root/chef-repo/.chef/joe-user.pem -c /root/chef-repo/.chef/pivotal.rb")
-        server.run_command("/opt/opscode/embedded/bin/knife opc org user add demo joe-user -c /root/chef-repo/.chef/pivotal.rb")
+        server.run_command("/opt/opscode/embedded/bin/knife opc user create #{create_user_string} -c #{dot_chef_path}/pivotal.rb")
+      when 'chef-server'
+        run_ctl(server, "chef-server", "user-create #{create_user_string}")
+      end
+    end
+
+    def create_org(server, orgname, dot_chef_path)
+      create_org_string = "#{orgname} #{orgname} --filename #{dot_chef_path}/#{orgname}-validator.pem"
+      case @server_configs[server.name][:chef_server_type]
+      when 'private-chef'
+        server.run_command("/opt/opscode/embedded/bin/knife opc org create #{create_org_string} -c #{dot_chef_path}/pivotal.rb")
+      when 'chef-server'
+        run_ctl(server, "chef-server", "org-create #{create_org_string}")
+      end
+    end
+
+    def org_add_user(server, orgname, username, admin, dot_chef_path)
+      org_add_user_string = "#{orgname} #{username}"
+      org_add_user_string += " --admin" if admin
+      case @server_configs[server.name][:chef_server_type]
+      when 'private-chef'
+        server.run_command("/opt/opscode/embedded/bin/knife opc org user add #{org_add_user_string} -c #{dot_chef_path}/pivotal.rb")
       when 'chef-server'
-        # give time for all services to come up completely
-        sleep 10
-        run_ctl(server, "chef-server", "org-create demo demo --filename /root/chef-repo/.chef/demo-validator.pem")
-        run_ctl(server, "chef-server", "user-create mary-admin mary admin mary-admin@noreply.com mary-admin --filename /root/chef-repo/.chef/mary-admin.pem")
-        run_ctl(server, "chef-server", "org-user-add demo mary-admin --admin")
-        run_ctl(server, "chef-server", "user-create joe-user joe user joe-user@noreply.com joe-user --filename /root/chef-repo/.chef/joe-user.pem")
-        run_ctl(server, "chef-server", "org-user-add demo joe-user")
+        run_ctl(server, "chef-server", "org-user-add #{org_add_user_string}")
       end
     end
 
     def chef_repo(force=false, pivotal=false)
-      if @config['chef-server'][:bootstrap_backend].nil?
-        puts "ERROR: A bootstrap backend Chef Server is not defined in the cluster's config. Please define it first."
+      chef_server_dot_chef_path = "/root/chef-repo/.chef"
+      dot_chef_path = "./chef-repo/.chef"
+
+      if @config['chef-server'][:bootstrap_backend]
+        chef_server = get_server(@config['chef-server'][:bootstrap_backend])
+        chef_server_fqdn = @config['chef-server'][:fqdn]
+      elsif @config['chef-backend'][:bootstrap_frontend]
+        chef_server = get_server(@config['chef-backend'][:bootstrap_frontend])
+        chef_server_fqdn = @config['chef-backend'][:fqdn]
+      else
+        puts "ERROR: A Chef Server is not defined in the cluster's config. Please define it first."
         exit 1
       end
-      chef_server = get_server(@config['chef-server'][:bootstrap_backend])
-      if ! chef_server.container.defined?
+      unless chef_server.container.defined?
         puts "ERROR: The '#{chef_server.name}' Chef Server does not exist."
         exit 1
       end
 
       puts "Creating chef-repo with pem files and knife.rb in the current directory"
-      FileUtils.mkdir_p("./chef-repo/.chef")
+      FileUtils.mkdir_p(dot_chef_path)
 
-      pem_files = Dir.glob("#{chef_server.container.config_item('lxc.rootfs')}/root/chef-repo/.chef/*.pem")
-      if pem_files.empty?
-        puts "The pem files can not be copied because they do not exist in '#{chef_server.name}' Chef Server's `/root/chef-repo/.chef` directory"
-      else
-        pem_files.delete_if { |pem_file| pem_file.end_with?("/pivotal.pem") } unless pivotal
-        FileUtils.cp( pem_files, "./chef-repo/.chef" )
-      end
-
-      chef_server_root = "https://#{@config['chef-server'][:fqdn]}"
-      chef_server_url = "https://#{@config['chef-server'][:fqdn]}/organizations/demo"
-      validator_name = "demo-validator"
+      pem_files = Dir.glob("#{chef_server.container.config_item('lxc.rootfs')}#{chef_server_dot_chef_path}/*.pem")
+      pem_files.delete_if { |pem_file| pem_file.end_with?("/pivotal.pem") } unless pivotal
+      FileUtils.cp(pem_files, dot_chef_path) unless pem_files.empty?
 
       if pivotal
-        if File.exists?("./chef-repo/.chef/pivotal.rb") && ! force
-          puts "Skipping pivotal.rb because it already exists in `./chef-repo/.chef`"
+        if File.exists?("#{dot_chef_path}/pivotal.rb") && ! force
+          puts "Skipping pivotal.rb because it already exists in `#{dot_chef_path}`"
         else
-          pivotal_rb_path = "#{chef_server.container.config_item('lxc.rootfs')}/root/chef-repo/.chef/pivotal.rb"
-          if File.exists?(pivotal_rb_path)
-            pivotal_rb = IO.read(pivotal_rb_path)
-            pivotal_rb.sub!(/^chef_server_root .*/, "chef_server_root \"#{chef_server_root}\"")
-            pivotal_rb.sub!(/^chef_server_url .*/, "chef_server_url \"#{chef_server_root}\"")
-            IO.write("./chef-repo/.chef/pivotal.rb", pivotal_rb)
-          else
-            puts "The pivotal.rb file can not be copied because it does not exist in '#{chef_server.name}' Chef Server's `/root/chef-repo/.chef` directory"
-          end
+          create_pivotal_knife_config(chef_server_fqdn, dot_chef_path)
         end
       end
 
       if File.exists?("./chef-repo/.chef/knife.rb") && ! force
-        puts "Skipping knife.rb because it already exists in `./chef-repo/.chef`"
+        puts "Skipping knife.rb because it already exists in `#{dot_chef_path}`"
       else
-        knife_rb_path = "#{chef_server.container.config_item('lxc.rootfs')}/root/chef-repo/.chef/knife.rb"
-        if File.exists?(knife_rb_path)
-          knife_rb = IO.read(knife_rb_path)
-          knife_rb.sub!(/^chef_server_url .*/, "chef_server_url \"#{chef_server_url}\"")
-          IO.write("./chef-repo/.chef/knife.rb", knife_rb)
-        else
-          puts "The knife.rb file can not be copied because it does not exist in '#{chef_server.name}' Chef Server's `/root/chef-repo/.chef` directory"
-        end
+        create_knife_config(chef_server_fqdn, dot_chef_path)
       end
     end
 
@@ -851,6 +1009,13 @@ oc_id['applications'] ||= {}
 oc_id['applications']['supermarket'] = {
   'redirect_uri' => 'https://#{@config['supermarket'][:fqdn]}/auth/chef_oauth2/callback'
 }
+)
+      end
+      automate_server_name = @server_configs.select {|name, config| config[:server_type] == 'automate'}.keys.first
+      if automate_server_name
+        chef_server_config += %Q(
+data_collector['root_url'] = "https://#{automate_server_name}/data-collector/v0/"
+data_collector['token'] = "93a49a4f2482c64126f7b6015e6b0f30284287ee4054ff8807fb63d9cbd1c506"
 )
       end
       return chef_server_config