fhcap-cli 0.4.2 → 0.4.3

data/lib/fhcap/tasks/chef/cookbook/update_metadata.rb

@@ -45,7 +45,7 @@ module Fhcap
             meta_hash = meta.to_hash().merge({cookbook: name})
 
             template_filepath = File.join(Fhcap.source_root, 'templates', 'chef', 'cookbook', 'metadata.erb')
-            eruby = Erubis::Eruby.new(File.read(template_filepath))
+            eruby = ::Erubis::Eruby.new(File.read(template_filepath))
             result = eruby.result(meta_hash)
             thor.create_file(metadata_filepath, result, {force: true})
           end

data/lib/fhcap/tasks/chef/environments/destroy.rb

@@ -1,33 +1,33 @@
-require 'fhcap/tasks/chef/chef_task_base'
+require 'fhcap/tasks/chef/chef_server_task'
 
 module Fhcap
   module Tasks
     module Chef
       module Environments
-        class Destroy < ChefTaskBase
+        class Destroy < ChefServerTask
 
-          attr_reader :name, :chef_server
+          attr_reader :name
 
           def initialize(options)
             super
             @name = options[:name]
-            @repo = options[:repo]
-            @chef_server = options[:chef_server]
           end
 
           def run
             thor.say "Chef::Environments::Destroy #{@name}", :yellow
 
-            if @chef_server
-              if thor.yes? "Remove all environments and config from the chef server (#{@chef_server})?"
-                run_knife_cmd("environment delete #{@name} -y", @chef_server)
-                run_knife_cmd("data bag delete environments #{@name} -y", @chef_server)
+            if chef_server
+              if thor.yes? "Remove all environments and config from the chef server (#{chef_server})?"
+                with_chef_server do
+                  run_knife_cmd("environment delete #{@name} -y", chef_server)
+                  run_knife_cmd("data bag delete environments #{@name} -y", chef_server)
+                end
               end
             end
 
             thor.remove_file find_data_bag_item('environments', @name)
             thor.remove_file find_environment(@name)
-            thor.remove_file find_repo_item(repo_clusters_dir(@repo), "#{@name}_passwords.json").first
+            thor.remove_file find_repo_item(repo_clusters_dir(chef_repo), "#{@name}_passwords.json").first
           end
 
         end

data/lib/fhcap/tasks/chef/provisioning/chef_provisioning_task.rb

@@ -15,7 +15,9 @@ module Fhcap
 
           def run
             thor.say "Chef::Provisioning::Task name = #{@name}, run_list = #{@run_list}", :yellow
-            do_chef_run(run_list)
+            with_chef_server do
+              do_chef_run(run_list)
+            end
           end
 
         end

data/lib/fhcap/tasks/chef/provisioning/chef_provisioning_task_base.rb

@@ -1,13 +1,14 @@
-require 'fhcap/tasks/chef/chef_task_base'
+require 'fhcap/tasks/chef/chef_server_task'
+require 'fhcap/tasks/chef/cookbook/archive'
 require 'fhcap/chef-dk/chef_runner'
 
 module Fhcap
   module Tasks
     module Chef
       module Provisioning
-        class ChefProvisioningTaskBase < ChefTaskBase
+        class ChefProvisioningTaskBase < ChefServerTask
 
-          attr_reader :name, :cluster_config, :cluster_filepath, :chef_server
+          attr_reader :name, :cluster_config, :cluster_filepath
 
           def initialize(options)
             super
@@ -16,17 +17,23 @@ module Fhcap
             if @cluster_filepath
               @cluster_config = JSON.parse(IO.read(@cluster_filepath), {:symbolize_names => true})
               @cluster_config.merge!({
-                                         local_repo_path: repo_dir(@cluster_config[:repo]),
-                                         local_repo_clusters_dir: repo_clusters_dir(@cluster_config[:repo]),
-                                         chef_server_config: chef_server_config_hash_for(@cluster_config[:chef_server]),
+                                         local_repo_path: repo_dir(@chef_repo),
+                                         local_repo_clusters_dir: repo_clusters_dir(@chef_repo),
+                                         chef_server_config: chef_server_config_hash_for(@chef_server),
                                          provider_credentials:  provider_credentials(@cluster_config[:provider_id])
                                      })
-              @chef_server = @cluster_config[:chef_server]
             else
               exit_with_error("Unknown cluster #{@name}")
             end
           end
 
+          def seed_cookbooks
+            archive_task = Chef::Cookbook::Archive.new(@options.dup.merge({:'skip-repo-checkout' => true}))
+            archive_task.run
+            @cluster_config[:local_cookbook_archive] = archive_task.archive
+            do_chef_run("provision::seed_cookbooks")
+          end
+
           def do_chef_run(run_list)
             cookbook_path = File.join(Fhcap.source_root, 'lib', 'cookbooks')
             private_key_paths = [File.join(cluster_config[:local_repo_path], cluster_config[:local_repo_clusters_dir], 'key_pairs')]

data/lib/fhcap/tasks/chef/provisioning/create.rb

@@ -8,9 +8,18 @@ module Fhcap
 
           def run
             thor.say "Chef::Provisioning::Create #{@name}", :yellow
-            do_chef_run("provision::cluster_create")
-            do_chef_run("provision::reset_rabbitmq")
-            do_chef_run("provision::restart_services")
+            with_chef_server do
+              do_chef_run("provision::cluster_create")
+
+              knife_download(repo_dir(chef_repo), chef_server, ['/nodes']) if local_chef_server?
+
+              unless options[:'skip-provision']
+                seed_cookbooks if local_chef_server?
+                do_chef_run("provision::cluster_provision")
+                do_chef_run("provision::reset_rabbitmq")
+                do_chef_run("provision::restart_services")
+              end
+            end
           end
 
         end

data/lib/fhcap/tasks/chef/provisioning/destroy.rb

@@ -1,4 +1,5 @@
 require 'fhcap/tasks/chef/provisioning/chef_provisioning_task_base'
+require 'fileutils'
 
 module Fhcap
   module Tasks
@@ -9,8 +10,10 @@ module Fhcap
           def run
             thor.say "Chef::Provisioning::Destroy #{@name}", :yellow
             if thor.yes? "Destroy cluster #{@name}? (y/n)"
-              run_list = "provision::cluster_destroy"
-              do_chef_run(run_list)
+              with_chef_server do
+                run_list = "provision::cluster_destroy"
+                do_chef_run(run_list)
+              end
             end
           end
 

data/lib/fhcap/tasks/chef/provisioning/provision.rb

@@ -8,8 +8,10 @@ module Fhcap
 
           def run
             thor.say "Chef::Provisioning::Provision #{@name}", :yellow
-            run_list = "provision::cluster_provision"
-            do_chef_run(run_list)
+            with_chef_server do
+              seed_cookbooks if local_chef_server?
+              do_chef_run("provision::cluster_provision")
+            end
           end
 
         end

data/lib/fhcap/tasks/chef/server/bootstrap.rb

@@ -1,161 +1,86 @@
-require 'fhcap/tasks/chef/chef_task_base'
+require 'fhcap/tasks/chef/chef_server_task'
 require 'chef/knife/diff'
+require 'chef/knife/cookbook_upload'
 
 module Fhcap
   module Tasks
     module Chef
       module Server
-        class Bootstrap < ChefTaskBase
+        class Bootstrap < ChefServerTask
 
           attr_reader :environments
 
           def initialize(options)
             super
             @environments = options[:environments]
-            @chef_server = options[:chef_server]
-            @diff_strategy = options[:'diff-strategy'] || 'knife'
             @skip_roles = options[:'skip-roles']
+            @skip_nodes = options[:'skip-roles'] || !local_chef_server?
             @skip_data_bags = options[:'skip-data-bags']
             @skip_environments = options[:'skip-environments']
             @skip_cookbooks = options[:'skip-cookbooks']
           end
 
           def run
-            thor.say "Chef::Server::Bootstrap: environments = #{environments}", :yellow
-
-            chef_server_environments = {}
-            environments.each do |environment|
-              chef_server = select_chef_server(environment, @chef_server)
-              chef_server_environments[chef_server] = chef_server_environments[chef_server] || []
-              chef_server_environments[chef_server] << environment
-            end
-
-            chef_server_environments.each do |server, environments|
-              sync_roles({:environments => environments, :server => server}) unless @skip_roles
-              sync_data_bags({:environments => environments, :server => server}) unless @skip_data_bags
-              sync_environments({:environments => environments, :server => server}) unless @skip_environments
-              sync_cookbooks({:environments => environments, :server => server}) unless @skip_cookbooks
+            thor.say "Chef::Server::Bootstrap: environments = #{environments}, server = #{chef_server}", :yellow
+            with_chef_server do
+              repos.each do |repo|
+                repo_path = repo_dir(repo)
+
+                upload_patterns = []
+                upload_patterns << '/roles' unless @skip_roles
+                upload_patterns << '/nodes' unless @skip_nodes
+                upload_patterns |= environments.collect { |env| ["/environments/#{env}*", "/data_bags/environments/#{env}*"] } unless @skip_environments
+                upload_patterns |= data_bag_pattern_for(repo_path, environments) unless @skip_data_bags
+                upload_patterns.flatten!
+
+                knife_upload(repo_path, chef_server, upload_patterns)
+              end
+              knife_upload_cookbooks(chef_server)
             end
           end
 
           private
 
-          def sync_roles(options)
-            sync_items('roles', options) do |local_repo, sync_items|
-              sync_items.each do |item|
-                unless item =~ /roles\/dev*/
-                  run_knife_cmd("role from file #{File.join(local_repo, item)}", options[:server])
-                end
-              end
-            end
-          end
-
-          def sync_data_bags(options, bag_created_cache=[])
-            requires_resync = false
-            sync_items('data_bags', options) do |local_repo, sync_items|
-              sync_items.each do |item|
-                if include_data_bag_item?(item, options)
-                  tmp, bag, bag_item = item.split('/')
-                  if bag
-                    unless bag_created_cache.include? bag
-                      output = run_knife_cmd("data bag create #{bag}", options[:server])
-                      requires_resync = requires_resync || output =~ /Created/
-                      bag_created_cache << bag
-                    end
-                    if bag_item
-                      run_knife_cmd("data bag from file #{bag} #{File.join(local_repo, item)}", options[:server])
-                    end
-                  end
+          def data_bag_pattern_for(repo_path, environments)
+            pattern = []
+            data_bags_path = File.join(repo_path, 'data_bags')
+            if Dir.exists? data_bags_path
+              Dir[File.join(data_bags_path, '*')].map { |a| File.basename(a) }.each do |name|
+                if include_data_bag?(name, environments)
+                  pattern << "/data_bags/#{name}"
                 end
               end
             end
-            sync_data_bags(options, bag_created_cache) if requires_resync
+            pattern
           end
 
-          def include_data_bag_item?(item, options)
+          def include_data_bag?(name, environments)
             include = true
-            environments = options[:environments]
-            if environments
-              if item =~ /nagios_/
-                #As usual nagios requires the most work Argghh
-                nagios_data_bag_name = item.split('/')[1]
-                #Default nagios data bags will only be 2 in length, check everything else
-                if nagios_data_bag_name.split('_').length > 2
-                  allowed = ['fheng', 'production']
-                  allowed |= environments
-                  allowed |= environments.collect { |env| env.gsub('-', '_') } # Prod data bags are named incorrectly for some reason
-                  include = allowed.any? { |val| nagios_data_bag_name =~ /#{val}/ }
-                end
-              elsif item =~ /environments\//
-                include = environments.any? { |val| item =~ /#{val}/ }
+            if name =~ /nagios_/
+              #Default nagios data bags will only be 2 in length, check everything else
+              if name.split('_').length > 2
+                allowed = ['fheng', 'production']
+                allowed |= environments
+                allowed |= environments.collect { |env| env.gsub('-', '_') } # Prod data bags are named incorrectly for some reason
+                include = allowed.any? { |val| name =~ /#{val}/ }
               end
+            elsif name =~ /environments/
+              include = false
             end
             include
           end
 
-          def sync_environments(options)
-            environments = options[:environments]
-            if environments
-              sync_items('environments', options) do |local_repo, sync_items|
-                sync_items.each do |item|
-                  if environments.any? { |val| item =~ /#{val}/ }
-                    run_knife_cmd("environment from file #{File.join(local_repo, item)}", options[:server])
-                  end
-                end
-              end
-            else
-              #thor.say "No environments specified!!"
-            end
-          end
-
-          def sync_cookbooks(options)
-            #sync_items('cookbooks', options) do |local_repo, sync_items|
-            #  modified_cookbooks = sync_items.collect do |cookbook|
-            #    cookbook.split('/')[1]
-            #  end.uniq
-            #  run_knife_cmd("cookbook upload #{modified_cookbooks.join(' ')} --force", options[:server]) unless modified_cookbooks.empty?
-            #end
-            run_knife_cmd("cookbook upload -a --force", options[:server], !verbose)
-          end
-
-          def sync_items(item, options)
-            repo_paths.each do |local_repo|
-              #thor.say "Syncing #{item} in #{local_repo} based on #{@diff_strategy} diff", :yellow
-              if @diff_strategy == 'git'
-                item = %w{cookbooks site-cookbooks wrapper-cookbooks} if item == 'cookbooks'
-                yield local_repo, git_diff(item, local_repo)
-              else
-                yield local_repo, knife_diff(item, local_repo, options[:server])
-              end
-            end
-            #thor.say "All #{item} synced successfully!"
-          end
-
-          def git_diff(item, local_repo)
-            result = ''
-            Dir.chdir local_repo do
-              paths = item.is_a?(Array) ? item : [item]
-              paths.each do |path|
-                if Dir.exists? File.join(local_repo, path)
-                  result += `git diff --name-only origin/master -- #{path}`
-                end
-              end
-            end
-            result.split
-          end
-
-          def knife_diff(item, local_repo, server)
-            result = ''
-            if Dir.exists? File.join(local_repo, item)
-              thor.inside local_repo do
-                cmd = "knife diff #{item} --chef-repo-path #{local_repo} --repo-mode static --name-only --diff-filter=[AM] --config #{knife_config_file_for(server)}"
-                result = thor.run(cmd, :capture => true)
-                thor.say result if verbose
-              end
-            else
-              #thor.say "No #{item} in #{local_repo}"
+          def knife_upload_cookbooks(server)
+            knife_config_file = knife_config_file_for(server)
+            thor.say " * uploading cookbooks from #{knife_config_file} ..."
+            suppress_stdout(!options[:verbose], !options[:verbose]) do
+              ::Chef::Knife::CookbookUpload.load_deps
+              knife_command = ::Chef::Knife::CookbookUpload.new
+              knife_command.config[:config_file] = knife_config_file
+              knife_command.configure_chef
+              knife_command.config[:all] = true
+              knife_command.run
             end
-            result.split
           end
 
         end

data/lib/fhcap/tasks/chef/server/info.rb

@@ -1,27 +1,28 @@
-require 'fhcap/tasks/chef/chef_task_base'
+require 'fhcap/tasks/chef/chef_server_task'
 
 module Fhcap
   module Tasks
     module Chef
       module Server
-        class Info < ChefTaskBase
+        class Info < ChefServerTask
 
-          attr_reader :environments, :node_names, :roles, :chef_server, :urls
+          attr_reader :environments, :node_names, :roles, :urls
 
           def initialize(options)
             super
             @environments = options[:environments]
             @node_names = options[:nodes]
             @roles = options[:roles]
-            @chef_server = options[:chef_server]
             @urls = {}
           end
 
           def run
             thor.say "Chef::Server::Info: environments = #{environments}", :yellow
-            environments.each do |env|
-              ip_addresses(env) unless options[:only] && options[:only] != 'ips'
-              management_dashboards(env) unless options[:only] && options[:only] != 'urls'
+            with_chef_server do
+              environments.each do |env|
+                ip_addresses(env) unless options[:only] && options[:only] != 'ips'
+                management_dashboards(env) unless options[:only] && options[:only] != 'urls'
+              end
             end
           end
 

data/lib/fhcap/tasks/chef/server/provision.rb

@@ -1,10 +1,10 @@
-require 'fhcap/tasks/chef/chef_task_base'
+require 'fhcap/tasks/chef/chef_server_task'
 
 module Fhcap
   module Tasks
     module Chef
       module Server
-        class Provision < ChefTaskBase
+        class Provision < ChefServerTask
 
           attr_reader :environments, :node_names, :roles
 
@@ -13,27 +13,27 @@ module Fhcap
             @environments = options[:environments]
             @node_names = options[:nodes]
             @roles = options[:roles]
-            @chef_server = options[:chef_server]
           end
 
           def run
             thor.say "Chef::Server::Provision: environments = #{environments}", :yellow
 
-            chef_server_environments = {}
-            environments.each do |environment|
-              chef_server = select_chef_server(environment, @chef_server)
-              chef_server_environments[chef_server] = chef_server_environments[chef_server] || []
-              chef_server_environments[chef_server] << environment
-            end
-
-            chef_server_environments.each do |server, environments|
+            with_chef_server do
+              chef_server_environments = {}
               environments.each do |environment|
-                query = ["chef_environment:#{environment}"]
-                query << "AND name:#{node_names}" if node_names
-                query << "AND roles:#{roles}" if roles
-                query = query.join(' ')
-                cmd = "sudo chef-client"
-                run_knife_ssh_cmd(query, cmd, server, options)
+                chef_server_environments[chef_server] = chef_server_environments[chef_server] || []
+                chef_server_environments[chef_server] << environment
+              end
+
+              chef_server_environments.each do |server, environments|
+                environments.each do |environment|
+                  query = ["chef_environment:#{environment}"]
+                  query << "AND name:#{node_names}" if node_names
+                  query << "AND roles:#{roles}" if roles
+                  query = query.join(' ')
+                  cmd = "sudo chef-client"
+                  run_knife_ssh_cmd(query, cmd, server, options)
+                end
               end
             end
           end

data/lib/fhcap/tasks/cluster/chef_provisioning_task.rb

@@ -0,0 +1,16 @@
+require 'fhcap/tasks/cluster/cluster_task_base'
+require 'fhcap/tasks/chef/provisioning/chef_provisioning_task'
+
+module Fhcap
+  module Tasks
+    module Cluster
+      class ChefProvisioningTask < ClusterTaskBase
+
+        def run
+          Tasks::Chef::Provisioning::ChefProvisioningTask.new(@options.dup.merge(chef_task_options)).run
+        end
+
+      end
+    end
+  end
+end

data/lib/fhcap/tasks/cluster/cluster_task_base.rb

@@ -23,6 +23,14 @@ module Fhcap
           end
         end
 
+        def chef_task_options
+          {
+           :'chef-server' => cluster_config[:chef_server],
+           :'chef-repo' => cluster_config[:repo],
+           :repos => ['fhcap', cluster_config[:repo]].uniq
+          }
+        end
+
         def template_as_object(template_file, config)
           template = File.read(template_file)
           eruby = Erubis::Eruby.new(template)

data/lib/fhcap/tasks/cluster/create.rb

@@ -5,7 +5,7 @@ require 'fhcap/tasks/chef/environments/promote_cookbooks'
 require 'fhcap/tasks/chef/environments/create'
 require 'fhcap/tasks/chef/server/bootstrap'
 require 'fhcap/tasks/repo/checkout'
-require "fhcap/tasks/misc/create_dns_record"
+require "fhcap/tasks/dns/create_record"
 
 module Fhcap
   module Tasks
@@ -30,6 +30,7 @@ module Fhcap
           @skip_server_bootstrap = options[:'skip-server-bootstrap']
           @skip_dns_record = options[:'skip-dns-record']
           @skip_create = options[:'skip-create']
+          @skip_provision = options[:'skip-provision']
 
           @cluster_config = {
               id: @name,
@@ -66,10 +67,10 @@ module Fhcap
           Chef::Environments::PromoteCookbooks.new(@options.dup.merge({:environments => cluster_environments})).run unless @skip_cookbook_promote
 
           #Bootstrap Server
-          Chef::Server::Bootstrap.new(@options.dup.merge({:environments => cluster_environments, :chef_server => @cluster_config[:chef_server]})).run unless @skip_server_bootstrap
+          Chef::Server::Bootstrap.new(@options.dup.merge(chef_task_options.merge({:environments => cluster_environments}))).run unless @skip_server_bootstrap
 
           #Provisioning create
-          Chef::Provisioning::Create.new(options).run unless @skip_create
+          Chef::Provisioning::Create.new(@options.dup.merge(chef_task_options)).run unless @skip_create
 
           create_dns_record unless @skip_dns_record
         end
@@ -188,7 +189,7 @@ module Fhcap
                           hosted_zone_id: elb.canonical_hosted_zone_name_id
                       }
                   }
-                  Misc::CreateDNSRecord.new(@options.dup.merge(dns_record_cfg)).run
+                  Dns::CreateRecord.new(@options.dup.merge(dns_record_cfg)).run
                 rescue Aws::ElasticLoadBalancing::Errors::LoadBalancerNotFound => e
                   thor.say_status 'error', "LoadBalancer #{lb} not found, unable to create DNS Entry", :red
                 rescue Aws::ElasticLoadBalancing::Errors::ServiceError => e
@@ -216,7 +217,7 @@ module Fhcap
                     domain: "*.#{env_cfg[:domain]}",
                     ipaddress: lb_node['cloud.public_ipv4']
                 }
-                Misc::CreateDNSRecord.new(@options.dup.merge(dns_record_cfg)).run
+                Dns::CreateRecord.new(@options.dup.merge(dns_record_cfg)).run
               else
                 thor.say "Found lb node '#{lb_node['name']}', but was unable to retrieve it's IP!!}"
               end

data/lib/fhcap/tasks/cluster/destroy.rb

@@ -1,6 +1,7 @@
 require 'fhcap/tasks/cluster/cluster_task_base'
 require 'fhcap/tasks/chef/provisioning/destroy'
 require 'fhcap/tasks/chef/environments/destroy'
+require 'fhcap/tasks/dns/delete_record'
 
 module Fhcap
   module Tasks
@@ -8,20 +9,30 @@ module Fhcap
       class Destroy < ClusterTaskBase
 
         def initialize(options)
-          super(options, false)
+          super
           @skip_destroy = options[:'skip-destroy']
         end
 
         def run
           thor.say "Cluster::Destroy: name = #{@name}", :yellow
-          Chef::Provisioning::Destroy.new(options).run unless @skip_destroy
+          Chef::Provisioning::Destroy.new(@options.dup.merge(chef_task_options)).run unless @skip_destroy
 
-          if thor.yes? "Delete all local repo files?"
+          if thor.yes? "Delete all local repo files? (y/n)"
             cluster_environments.each do |env_name, cfg|
-              Chef::Environments::Destroy.new(@options.dup.merge({:name => env_name, :chef_server => @cluster_config[:chef_server], :repo => @cluster_config[:repo]})).run
+              Chef::Environments::Destroy.new(@options.dup.merge({:name => env_name}.merge(chef_task_options))).run
             end
             thor.remove_file find_cluster(@name)
           end
+
+          if thor.yes? "Delete all DNS entries? (y/n)"
+            @cluster_config[:environments].each do |env_name, cfg|
+              if cfg[:domain]
+                domain = ['*', cfg[:domain]].join('.')
+                Dns::DeleteRecord.new(@options.dup.merge({:domain => domain})).run
+              end
+            end
+          end
+
         end
 
       end

data/lib/fhcap/tasks/cluster/destroy_environment.rb

@@ -19,7 +19,7 @@ module Fhcap
           cluster_config[:environments].delete environment_name.to_sym
           thor.create_file(cluster_file, JSON.pretty_generate(cluster_config), force: true)
 
-          Chef::Environments::Destroy.new(@options.dup.merge({:name => environment_name, :chef_server => cluster_config[:chef_server]})).run
+          Chef::Environments::Destroy.new(@options.dup.merge({:name => environment_name}.merge(chef_task_options))).run
         end
 
       end

data/lib/fhcap/tasks/cluster/info.rb

@@ -26,7 +26,7 @@ module Fhcap
 
         def run
           thor.say "Cluster::Info: name = #{@name}", :yellow
-          info_task = Chef::Server::Info.new(@options.dup.merge({:environments => cluster_environments, :chef_server => cluster_config[:chef_server]}))
+          info_task = Chef::Server::Info.new(@options.dup.merge({:environments => cluster_environments}.merge(chef_task_options)))
           info_task.run
           cluster_environments.each do |env|
             passwords(env) unless options[:only] && options[:only] != 'passwords'

data/lib/fhcap/tasks/cluster/provision.rb

@@ -28,12 +28,12 @@ module Fhcap
           thor.say "Cluster::Provision: name = #{name}, strategy = #{strategy}", :yellow
           checkout_repos unless @skip_repo_checkout
           Chef::Environments::PromoteCookbooks.new(@options.dup.merge({:environments => cluster_environments})).run unless @skip_cookbook_promote
-          Chef::Server::Bootstrap.new(@options.dup.merge({:environments => cluster_environments, :chef_server => cluster_config[:chef_server]})).run unless @skip_server_bootstrap
+          Chef::Server::Bootstrap.new(@options.dup.merge({:environments => cluster_environments}.merge(chef_task_options))).run unless @skip_server_bootstrap
           unless @skip_provision
             if strategy == 'chef'
-              Chef::Provisioning::Provision.new(@options).run
+              Chef::Provisioning::Provision.new(@options.dup.merge(chef_task_options)).run
             elsif strategy == 'knife'
-              Chef::Server::Provision.new(@options.dup.merge({:environments => cluster_environments, :chef_server => cluster_config[:chef_server]})).run
+              Chef::Server::Provision.new(@options.dup.merge({:environments => cluster_environments}.merge(chef_task_options))).run
             else
               thor.say_status :error, "Unsupported provision strategy #{strategy}"
             end

data/lib/fhcap/tasks/cluster/status.rb

@@ -8,7 +8,7 @@ module Fhcap
 
         def run
           thor.say "Cluster::Status: name = #{@name}", :yellow
-          Tasks::Chef::Provisioning::ChefProvisioningTask.new(@options.dup.merge({:'run-list' => 'recipe[provision::cluster_status]'})).run
+          Tasks::Chef::Provisioning::ChefProvisioningTask.new(@options.dup.merge({:'run-list' => 'recipe[provision::cluster_status]'}.merge(chef_task_options))).run
         end
 
       end