knife-azure 2.0.11 → 3.0.4

data/lib/chef/knife/azurerm_server_delete.rb

@@ -2,7 +2,7 @@
 # Author:: Barry Davis (barryd@jetstreamsoftware.com)
 # Author:: Adam Jacob (<adam@chef.io>)
 # Author:: Seth Chisamore (<schisamo@chef.io>)
-# Copyright:: Copyright 2010-2019, Chef Software Inc.
+# Copyright:: Copyright (c) Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -18,7 +18,7 @@
 # limitations under the License.
 #
 
-require_relative "azurerm_base"
+require_relative "helpers/azurerm_base"
 
 class Chef
   class Knife
@@ -30,7 +30,7 @@ class Chef
         # These two are needed for the '--purge' deletion case
         require "chef/node"
         require "chef/api_client"
-        include Knife::AzurermBase.load_deps
+        include Knife::AzurermBase
       end
 
       banner "knife azurerm server delete SERVER [SERVER] (options)"
@@ -51,7 +51,7 @@ class Chef
         long: "--delete-resource-group",
         boolean: true,
         default: false,
-        description: "Deletes corresponding resource group along with Vitual Machine."
+        description: "Deletes corresponding resource group along with Virtual Machine."
 
       # Extracted from Chef::Knife.delete_object, because it has a
       # confirmation step built in... By specifying the '--purge'
@@ -74,10 +74,10 @@ class Chef
         validate_arm_keys!(:azure_resource_group_name)
         @vm_name = @name_args[0]
 
-        if locate_config_value(:delete_resource_group)
+        if config[:delete_resource_group]
           delete_resource_group
         else
-          service.delete_server(locate_config_value(:azure_resource_group_name), @vm_name)
+          service.delete_server(config[:azure_resource_group_name], @vm_name)
         end
 
         if config[:purge]
@@ -90,18 +90,18 @@ class Chef
       end
 
       def delete_resource_group
-        resource_group_name = locate_config_value(:azure_resource_group_name)
+        resource_group_name = config[:azure_resource_group_name]
         ui.warn "Deleting resource group will delete all the virtual_machines inside it."
         begin
           ui.confirm("Do you really want to delete resource group")
         rescue SystemExit   # Need to handle this as confirming with N/n raises SystemExit exception
           server = nil      # Cleanup is implicitly performed in other cloud plugins
           ui.warn "Resource group not deleted. Proceeding for server delete ..."
-          service.delete_server(locate_config_value(:azure_resource_group_name), @vm_name)
+          service.delete_server(config[:azure_resource_group_name], @vm_name)
           exit
         end
         ui.info "Deleting Resource Group " + resource_group_name + " and Virtual Machine " + @vm_name + " .."
-        service.delete_resource_group(locate_config_value(:azure_resource_group_name))
+        service.delete_resource_group(config[:azure_resource_group_name])
         ui.warn "Deleted resource_group_name #{resource_group_name} and #{@vm_name}"
       end
 

data/lib/chef/knife/azurerm_server_list.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Adam Jacob (<adam@chef.io>)
-# Copyright:: Copyright 2010-2019, Chef Software Inc.
+# Copyright:: Copyright (c) Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,7 +16,7 @@
 # limitations under the License.
 #
 
-require_relative "azurerm_base"
+require_relative "helpers/azurerm_base"
 
 class Chef
   class Knife
@@ -27,7 +27,7 @@ class Chef
       banner "knife azurerm server list (options)"
 
       deps do
-        include Knife::AzurermBase.load_deps
+        include Knife::AzurermBase
       end
 
       def run
@@ -36,7 +36,7 @@ class Chef
         get_azure_cli_version
         validate_arm_keys!
         begin
-          service.list_servers(locate_config_value(:azure_resource_group_name))
+          service.list_servers(config[:azure_resource_group_name])
         rescue => error
           service.common_arm_rescue_block(error)
         end

data/lib/chef/knife/azurerm_server_show.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Meera Navale (meera.navale@msystechnologies.com)
-# Copyright:: Copyright 2010-2019, Chef Software Inc.
+# Copyright:: Copyright (c) Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,7 +16,7 @@
 # limitations under the License.
 #
 
-require_relative "azurerm_base"
+require_relative "helpers/azurerm_base"
 
 class Chef
   class Knife
@@ -27,7 +27,7 @@ class Chef
       banner "knife azurerm server show SERVER (options)"
 
       deps do
-        include Knife::AzurermBase.load_deps
+        include Knife::AzurermBase
       end
 
       def run
@@ -36,7 +36,7 @@ class Chef
         get_azure_cli_version
         validate_arm_keys!(:azure_resource_group_name)
         begin
-          service.show_server(@name_args[0], locate_config_value(:azure_resource_group_name))
+          service.show_server(@name_args[0], config[:azure_resource_group_name])
         rescue => error
           service.common_arm_rescue_block(error)
         end

data/lib/chef/knife/bootstrap/bootstrapper.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Aliasgar Batterywala (aliasgar.batterywala@clogeny.com)
-# Copyright:: Copyright 2010-2019, Chef Software Inc.
+# Copyright:: Copyright (c) Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,6 +16,8 @@
 # limitations under the License.
 #
 
+require_relative "../../../azure/resource_management/ARM_interface"
+
 class Chef
   class Knife
     class Bootstrap
@@ -39,13 +41,13 @@ class Chef
 
         # get latest version
         def get_chef_extension_version(chef_extension_name = nil)
-          if locate_config_value(:azure_chef_extension_version)
-            Chef::Config[:knife][:azure_chef_extension_version]
+          if config[:azure_chef_extension_version]
+            config[:azure_chef_extension_version]
           else
             chef_extension_name ||= get_chef_extension_name
             if @service.instance_of? Azure::ResourceManagement::ARMInterface
               service.get_latest_chef_extension_version(
-                azure_service_location: locate_config_value(:azure_service_location),
+                azure_service_location: config[:azure_service_location],
                 chef_extension_publisher: get_chef_extension_publisher,
                 chef_extension: chef_extension_name
               )
@@ -57,7 +59,7 @@ class Chef
         end
 
         def ohai_hints
-          hint_values = locate_config_value(:ohai_hints)
+          hint_values = config[:ohai_hints]
           if hint_values.casecmp("default") == 0
             default_hint_options
           else
@@ -67,47 +69,39 @@ class Chef
 
         def get_chef_extension_public_params
           pub_config = {}
-          if locate_config_value(:azure_extension_client_config)
-            pub_config[:client_rb] = File.read(File.expand_path(locate_config_value(:azure_extension_client_config)))
+          if config[:azure_extension_client_config]
+            pub_config[:client_rb] = File.read(File.expand_path(config[:azure_extension_client_config]))
           else
             pub_config[:client_rb] = "chef_server_url \t #{Chef::Config[:chef_server_url].to_json}\nvalidation_client_name\t#{Chef::Config[:validation_client_name].to_json}"
           end
 
-          pub_config[:runlist] = locate_config_value(:run_list).empty? ? "" : locate_config_value(:run_list).join(",").to_json
-          pub_config[:custom_json_attr] = locate_config_value(:json_attributes) || {}
-          pub_config[:extendedLogs] = locate_config_value(:extended_logs) ? "true" : "false"
-          pub_config[:hints] = ohai_hints if @service.instance_of?(Azure::ResourceManagement::ARMInterface) && !locate_config_value(:ohai_hints).nil?
-          pub_config[:chef_daemon_interval] = locate_config_value(:chef_daemon_interval) if locate_config_value(:chef_daemon_interval)
-          pub_config[:daemon] = locate_config_value(:daemon) if locate_config_value(:daemon)
+          pub_config[:runlist] = config[:run_list].empty? ? "" : config[:run_list].join(",").to_json
+          pub_config[:custom_json_attr] = config[:json_attributes] || {}
+          pub_config[:extendedLogs] = config[:extended_logs] ? "true" : "false"
+          pub_config[:hints] = ohai_hints if @service.instance_of?(Azure::ResourceManagement::ARMInterface) && !config[:ohai_hints].nil?
+          pub_config[:chef_daemon_interval] = config[:chef_daemon_interval] if config[:chef_daemon_interval]
+          pub_config[:daemon] = config[:daemon] if config[:daemon]
 
           # bootstrap attributes
           pub_config[:bootstrap_options] = {}
-          pub_config[:bootstrap_options][:environment] = locate_config_value(:environment) if locate_config_value(:environment)
-          pub_config[:bootstrap_options][:chef_node_name] = locate_config_value(:chef_node_name) if locate_config_value(:chef_node_name)
+          pub_config[:bootstrap_options][:environment] = config[:environment] if config[:environment]
+          pub_config[:bootstrap_options][:chef_node_name] = config[:chef_node_name] if config[:chef_node_name]
           pub_config[:bootstrap_options][:chef_server_url] = Chef::Config[:chef_server_url] if Chef::Config[:chef_server_url]
           pub_config[:bootstrap_options][:validation_client_name] = Chef::Config[:validation_client_name] if Chef::Config[:validation_client_name]
-          pub_config[:bootstrap_options][:node_verify_api_cert] = locate_config_value(:node_verify_api_cert) ? "true" : "false" if config.key?(:node_verify_api_cert)
-          pub_config[:bootstrap_options][:bootstrap_version] = locate_config_value(:bootstrap_version) if locate_config_value(:bootstrap_version)
-          pub_config[:bootstrap_options][:node_ssl_verify_mode] = locate_config_value(:node_ssl_verify_mode) if locate_config_value(:node_ssl_verify_mode)
-          pub_config[:bootstrap_options][:bootstrap_proxy] = locate_config_value(:bootstrap_proxy) if locate_config_value(:bootstrap_proxy)
+          pub_config[:bootstrap_options][:node_verify_api_cert] = config[:node_verify_api_cert] ? "true" : "false" if config.key?(:node_verify_api_cert)
+          pub_config[:bootstrap_options][:bootstrap_version] = config[:bootstrap_version] if config[:bootstrap_version]
+          pub_config[:bootstrap_options][:node_ssl_verify_mode] = config[:node_ssl_verify_mode] if config[:node_ssl_verify_mode]
+          pub_config[:bootstrap_options][:bootstrap_proxy] = config[:bootstrap_proxy] if config[:bootstrap_proxy]
           pub_config
         end
 
         def load_correct_secret
-          knife_secret_file = Chef::Config[:knife][:encrypted_data_bag_secret_file]
-          knife_secret = Chef::Config[:knife][:encrypted_data_bag_secret]
-          cli_secret_file = config[:encrypted_data_bag_secret_file]
-          cli_secret = config[:encrypted_data_bag_secret]
-
-          # The value set in knife.rb gets set in config object too
-          # That's why setting cli objects to nil if the values are specified in knife.rb
-          cli_secret_file = nil if cli_secret_file == knife_secret_file
-          cli_secret = nil if cli_secret == knife_secret
+          secret_file = config[:encrypted_data_bag_secret_file]
+          secret = config[:encrypted_data_bag_secret]
 
-          cli_secret_file = Chef::EncryptedDataBagItem.load_secret(cli_secret_file) unless cli_secret_file.nil?
-          knife_secret_file = Chef::EncryptedDataBagItem.load_secret(knife_secret_file) unless knife_secret_file.nil?
+          secret_file = Chef::EncryptedDataBagItem.load_secret(secret_file) unless secret_file.nil?
 
-          cli_secret_file || cli_secret || knife_secret_file || knife_secret
+          secret_file || secret
         end
 
         def create_node_and_client_pem
@@ -115,7 +109,7 @@ class Chef
             require "chef/knife/bootstrap/client_builder"
             Chef::Knife::Bootstrap::ClientBuilder.new(
               chef_config: Chef::Config,
-              knife_config: config,
+              config: config,
               ui: ui
             )
           end
@@ -153,9 +147,9 @@ class Chef
           end
 
           # SSL cert bootstrap support
-          if locate_config_value(:cert_path)
-            if File.exist?(File.expand_path(locate_config_value(:cert_path)))
-              pri_config[:chef_server_crt] = File.read(File.expand_path(locate_config_value(:cert_path)))
+          if config[:cert_path]
+            if File.exist?(File.expand_path(config[:cert_path]))
+              pri_config[:chef_server_crt] = File.read(File.expand_path(config[:cert_path]))
             else
               ui.error("Specified SSL certificate does not exist.")
               exit 1

data/lib/chef/knife/bootstrap/common_bootstrap_options.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Aliasgar Batterywala (aliasgar.batterywala@clogeny.com)
-# Copyright:: Copyright 2010-2019, Chef Software Inc.
+# Copyright:: Copyright (c) Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -46,8 +46,7 @@ class Chef
               short: "-m LOCATION",
               long: "--azure-service-location LOCATION",
               description: "Required if not using an Affinity Group. Specifies the geographic location - the name of the data center location that is valid for your subscription.
-                            Eg: West US, East US, East Asia, Southeast Asia, North Europe, West Europe",
-              proc: Proc.new { |lo| Chef::Config[:knife][:azure_service_location] = lo }
+                            Eg: West US, East US, East Asia, Southeast Asia, North Europe, West Europe"
 
             option :azure_storage_account,
               short: "-a NAME",
@@ -69,8 +68,7 @@ class Chef
               long: "--azure-vm-size SIZE",
               description: "Optional. Size of virtual machine. Default is Standard_A1_v2.
                             Eg: Standard_A1_v2, Standard_F2, Standard_G1 etc.",
-              default: "Standard_A1_v2",
-              proc: Proc.new { |si| Chef::Config[:knife][:azure_vm_size] = si }
+              default: "Standard_A1_v2"
 
             deprecated_option :bootstrap_protocol,
               replacement: :connection_protocol,

data/lib/chef/knife/bootstrap_azure.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Aliasgar Batterywala (aliasgar.batterywala@clogeny.com)
-# Copyright:: Copyright 2010-2019, Chef Software Inc.
+# Copyright:: Copyright (c) Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,7 +16,7 @@
 # limitations under the License.
 #
 
-require_relative "azure_base"
+require_relative "helpers/azure_base"
 require "chef/knife/bootstrap"
 require_relative "bootstrap/common_bootstrap_options"
 require_relative "bootstrap/bootstrapper"
@@ -52,7 +52,7 @@ class Chef
       def plugin_create_instance!
         if @name_args.length == 1
           service.add_extension(@name_args[0], set_ext_params)
-          if locate_config_value(:extended_logs)
+          if config[:extended_logs]
             print "\n\nWaiting for the Chef Extension to become available/ready"
             wait_until_extension_available(Time.now, 10)
             print "\n\nWaiting for the first chef-client run"
@@ -89,20 +89,20 @@ class Chef
           ui.info "Looking for the server #{@name_args[0]}..."
           server = service.find_server(
             name: @name_args[0],
-            azure_dns_name: locate_config_value(:azure_dns_name)
+            azure_dns_name: config[:azure_dns_name]
           )
 
           ## if azure_dns_name value not passed by user then set it using the hostedservicename attribute from the retrieved server's object ##
-          config[:azure_dns_name] = server.hostedservicename if locate_config_value(:azure_dns_name).nil? && (server.instance_of? Azure::Role)
+          config[:azure_dns_name] = server.hostedservicename if config[:azure_dns_name].nil? && (server.instance_of? Azure::Role)
           unless server.instance_of? Azure::Role
             if server.nil?
-              if !locate_config_value(:azure_dns_name).nil?
-                raise "Hosted service #{locate_config_value(:azure_dns_name)} does not exist."
+              if !config[:azure_dns_name].nil?
+                raise "Hosted service #{config[:azure_dns_name]} does not exist."
               else
                 raise "Server #{@name_args[0]} does not exist."
               end
             else
-              raise "Server #{@name_args[0]} does not exist under the hosted service #{locate_config_value(:azure_dns_name)}."
+              raise "Server #{@name_args[0]} does not exist under the hosted service #{config[:azure_dns_name]}."
             end
           end
 
@@ -122,7 +122,7 @@ class Chef
             raise "OS type #{server.os_type} is not supported."
           end
 
-          ext_params[:azure_dns_name] = server.hostedservicename || locate_config_value(:azure_dns_name)
+          ext_params[:azure_dns_name] = server.hostedservicename || config[:azure_dns_name]
           ext_params[:deploy_name] = server.deployname
           ext_params[:role_xml] = server.role_xml
           ext_params[:azure_vm_name] = @name_args[0]
@@ -139,10 +139,10 @@ class Chef
         ext_params
       end
 
-      def wait_until_extension_available(extension_deploy_start_time, extension_availaibility_wait_timeout)
-        extension_availaibility_wait_time = ((Time.now - extension_deploy_start_time) / 60).round
-        if extension_availaibility_wait_time <= extension_availaibility_wait_timeout
-          ## extension availaibility wait time has not exceeded the maximum threshold set for the wait timeout ##
+      def wait_until_extension_available(extension_deploy_start_time, extension_availability_wait_timeout)
+        extension_availability_wait_time = ((Time.now - extension_deploy_start_time) / 60).round
+        if extension_availability_wait_time <= extension_availability_wait_timeout
+          ## extension availability wait time has not exceeded the maximum threshold set for the wait timeout ##
           my_role = nil
           sleep_and_wait = false
           deployment = fetch_deployment
@@ -178,12 +178,12 @@ class Chef
             sleep 30
             wait_until_extension_available(
               extension_deploy_start_time,
-              extension_availaibility_wait_timeout
+              extension_availability_wait_timeout
             )
           end
         else
-          ## extension availaibility wait time exceeded maximum threshold set for the wait timeout ##
-          raise "\nUnable to fetch chef-client run logs as Chef Extension seems to be unavailable even after #{extension_availaibility_wait_timeout} minutes of its deployment.\n"
+          ## extension availability wait time exceeded maximum threshold set for the wait timeout ##
+          raise "\nUnable to fetch chef-client run logs as Chef Extension seems to be unavailable even after #{extension_availability_wait_timeout} minutes of its deployment.\n"
         end
       end
     end

data/lib/chef/knife/bootstrap_azurerm.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Nimisha Sharad (nimisha.sharad@clogeny.com)
-# Copyright:: Copyright 2010-2019, Chef Software Inc.
+# Copyright:: Copyright (c) Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,7 +16,7 @@
 # limitations under the License.
 #
 
-require_relative "azurerm_base"
+require_relative "helpers/azurerm_base"
 require "chef/knife/bootstrap"
 require_relative "bootstrap/common_bootstrap_options"
 require_relative "bootstrap/bootstrapper"
@@ -30,7 +30,7 @@ class Chef
 
       deps do
         require "time"
-        include Knife::AzurermBase.load_deps
+        include Knife::AzurermBase
       end
 
       banner "knife bootstrap azurerm SERVER (options)"
@@ -87,7 +87,7 @@ class Chef
       #### run() execution ends ####
 
       def set_ext_params
-        server = service.find_server(locate_config_value(:azure_resource_group_name), name_args[0])
+        server = service.find_server(config[:azure_resource_group_name], name_args[0])
 
         if server
           if service.extension_already_installed?(server)
@@ -107,16 +107,16 @@ class Chef
               raise "OS type #{server.storage_profile.os_disk.os_type} is not supported."
             end
 
-            ext_params[:azure_resource_group_name] = locate_config_value(:azure_resource_group_name)
+            ext_params[:azure_resource_group_name] = config[:azure_resource_group_name]
             ext_params[:azure_vm_name] = @name_args[0]
-            ext_params[:azure_service_location] = locate_config_value(:azure_service_location)
+            ext_params[:azure_service_location] = config[:azure_service_location]
             ext_params[:chef_extension_publisher] = get_chef_extension_publisher
             ext_params[:chef_extension_version] = get_chef_extension_version(ext_params[:chef_extension])
             ext_params[:chef_extension_public_param] = get_chef_extension_public_params
             ext_params[:chef_extension_private_param] = get_chef_extension_private_params
           end
         else
-          raise "The given server '#{@name_args[0]}' does not exist under resource group '#{locate_config_value(:azure_resource_group_name)}'"
+          raise "The given server '#{@name_args[0]}' does not exist under resource group '#{config[:azure_resource_group_name]}'"
         end
 
         ext_params

data/lib/chef/knife/{azure_base.rb → helpers/azure_base.rb}

@@ -1,6 +1,6 @@
 # Author:: Barry Davis (barryd@jetstreamsoftware.com)
 # Author:: Seth Chisamore (<schisamo@chef.io>)
-# Copyright:: Copyright 2010-2019, Chef Software Inc.
+# Copyright:: Copyright (c) Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -29,26 +29,23 @@ class Chef
           deps do
             require "readline"
             require "chef/json_compat"
-            require_relative "../../azure/service_management/ASM_interface"
+            require_relative "../../../azure/service_management/ASM_interface"
           end
 
           option :azure_subscription_id,
             short: "-S ID",
             long: "--azure-subscription-id ID",
-            description: "Your Azure subscription ID",
-            proc: proc { |key| Chef::Config[:knife][:azure_subscription_id] = key }
+            description: "Your Azure subscription ID"
 
           option :azure_mgmt_cert,
             short: "-p FILENAME",
             long: "--azure-mgmt-cert FILENAME",
-            description: "Your Azure PEM file name",
-            proc: proc { |key| Chef::Config[:knife][:azure_mgmt_cert] = key }
+            description: "Your Azure PEM file name"
 
           option :azure_api_host_name,
             short: "-H HOSTNAME",
             long: "--azure-api-host-name HOSTNAME",
-            description: "Your Azure host name",
-            proc: proc { |key| Chef::Config[:knife][:azure_api_host_name] = key }
+            description: "Your Azure host name"
 
           option :verify_ssl_cert,
             long: "--verify-ssl-cert",
@@ -58,40 +55,34 @@ class Chef
 
           option :azure_publish_settings_file,
             long: "--azure-publish-settings-file FILENAME",
-            description: "Your Azure Publish Settings File",
-            proc: proc { |key| Chef::Config[:knife][:azure_publish_settings_file] = key }
+            description: "Your Azure Publish Settings File"
         end
       end
 
       def is_image_windows?
         images = service.list_images
-        target_image = images.select { |i| i.name == locate_config_value(:azure_source_image) }
+        target_image = images.select { |i| i.name == config[:azure_source_image] }
         if target_image[0].nil?
           ui.error('Invalid image. Use the command "knife azure image list" to verify the image name')
           exit 1
         else
-          return target_image[0].os == "Windows"
+          target_image[0].os == "Windows"
         end
       end
 
       def service
         @service ||= begin
                       service = Azure::ServiceManagement::ASMInterface.new(
-                        azure_subscription_id: locate_config_value(:azure_subscription_id),
-                        azure_mgmt_cert: locate_config_value(:azure_mgmt_cert),
-                        azure_api_host_name: locate_config_value(:azure_api_host_name),
-                        verify_ssl_cert: locate_config_value(:verify_ssl_cert)
+                        azure_subscription_id: config[:azure_subscription_id],
+                        azure_mgmt_cert: config[:azure_mgmt_cert],
+                        azure_api_host_name: config[:azure_api_host_name],
+                        verify_ssl_cert: config[:verify_ssl_cert]
                       )
                     end
         @service.ui = ui
         @service
       end
 
-      def locate_config_value(key)
-        key = key.to_sym
-        config[key] || Chef::Config[:knife][key]
-      end
-
       def msg_pair(label, value, color = :cyan)
         if value && !value.to_s.empty?
           puts "#{ui.color(label, color)}: #{value}"
@@ -103,16 +94,16 @@ class Chef
         msg_pair("DNS Name", server.hostedservicename + ".cloudapp.net")
         msg_pair("VM Name", server.name)
         msg_pair("Size", server.size)
-        msg_pair("Azure Source Image", locate_config_value(:azure_source_image))
-        msg_pair("Azure Service Location", locate_config_value(:azure_service_location))
+        msg_pair("Azure Source Image", config[:azure_source_image])
+        msg_pair("Azure Service Location", config[:azure_service_location])
         msg_pair("Public Ip Address", server.publicipaddress)
         msg_pair("Private Ip Address", server.ipaddress)
         msg_pair("SSH Port", server.sshport) unless server.sshport.nil?
         msg_pair("WinRM Port", server.winrmport) unless server.winrmport.nil?
         msg_pair("TCP Ports", server.tcpports) unless server.tcpports.nil? || server.tcpports.empty?
         msg_pair("UDP Ports", server.udpports) unless server.udpports.nil? || server.udpports.empty?
-        msg_pair("Environment", locate_config_value(:environment) || "_default")
-        msg_pair("Runlist", locate_config_value(:run_list)) unless locate_config_value(:run_list).empty?
+        msg_pair("Environment", config[:environment] || "_default")
+        msg_pair("Runlist", config[:run_list]) unless config[:run_list].empty?
         puts "\n"
       end
 
@@ -121,61 +112,61 @@ class Chef
       end
 
       # validate command pre-requisites (cli options)
-      # (locate_config_value(:connection_password).length <= 6 && locate_config_value(:connection_password).length >= 72)
+      # (config[:connection_password].length <= 6 && config[:connection_password].length >= 72)
       def validate_params!
-        if locate_config_value(:connection_password) && !locate_config_value(:connection_password).length.between?(6, 72)
+        if config[:connection_password] && !config[:connection_password].length.between?(6, 72)
           ui.error("The supplied connection password must be 6-72 characters long and meet password complexity requirements")
           exit 1
         end
 
-        if locate_config_value(:azure_connect_to_existing_dns) && locate_config_value(:azure_vm_name).nil?
+        if config[:azure_connect_to_existing_dns] && config[:azure_vm_name].nil?
           ui.error("Specify the VM name using --azure-vm-name option, since you are connecting to existing dns")
           exit 1
         end
 
-        unless !!locate_config_value(:azure_service_location) ^ !!locate_config_value(:azure_affinity_group)
+        unless !!config[:azure_service_location] ^ !!config[:azure_affinity_group]
           ui.error("Specify either --azure-service-location or --azure-affinity-group")
           exit 1
         end
 
-        unless service.valid_image?(locate_config_value(:azure_source_image))
-          ui.error("Image '#{locate_config_value(:azure_source_image)}' is invalid")
+        unless service.valid_image?(config[:azure_source_image])
+          ui.error("Image '#{config[:azure_source_image]}' is invalid")
           exit 1
         end
 
         # Validate join domain requirements.
-        if locate_config_value(:azure_domain_name) || locate_config_value(:azure_domain_user)
-          if locate_config_value(:azure_domain_user).nil? || locate_config_value(:azure_domain_passwd).nil?
+        if config[:azure_domain_name] || config[:azure_domain_user]
+          if config[:azure_domain_user].nil? || config[:azure_domain_passwd].nil?
             ui.error("Must specify both --azure-domain-user and --azure-domain-passwd.")
             exit 1
           end
         end
 
-        if locate_config_value(:winrm_ssl) && locate_config_value(:thumbprint).nil? && locate_config_value(:winrm_no_verify_cert).nil?
+        if config[:winrm_ssl] && config[:thumbprint].nil? && config[:winrm_no_verify_cert].nil?
           ui.error("The SSL transport was specified without the --thumbprint option. Specify a thumbprint, or alternatively set the --winrm-no-verify-cert option to skip verification.")
           exit 1
         end
 
-        if locate_config_value(:extended_logs) && locate_config_value(:connection_protocol) != "cloud-api"
+        if config[:extended_logs] && config[:connection_protocol] != "cloud-api"
           ui.error("--extended-logs option only works with --bootstrap-protocol cloud-api")
           exit 1
         end
 
-        if locate_config_value(:connection_protocol) == "cloud-api" && locate_config_value(:azure_vm_name).nil? && locate_config_value(:azure_dns_name).nil?
+        if config[:connection_protocol] == "cloud-api" && config[:azure_vm_name].nil? && config[:azure_dns_name].nil?
           ui.error("Specifying the DNS name using --azure-dns-name or VM name using --azure-vm-name option is required with --bootstrap-protocol cloud-api")
           exit 1
         end
 
-        if locate_config_value(:daemon)
+        if config[:daemon]
           unless is_image_windows?
             raise ArgumentError, "The daemon option is only supported for Windows nodes."
           end
 
-          unless  locate_config_value(:connection_protocol) == "cloud-api"
+          unless  config[:connection_protocol] == "cloud-api"
             raise ArgumentError, "The --daemon option requires the use of --bootstrap-protocol cloud-api"
           end
 
-          unless %w{none service task}.include?(locate_config_value(:daemon).downcase)
+          unless %w{none service task}.include?(config[:daemon].downcase)
             raise ArgumentError, "Invalid value for --daemon option. Valid values are 'none', 'service' and 'task'."
           end
         end
@@ -185,7 +176,7 @@ class Chef
       def validate!(keys)
         errors = []
         keys.each do |k|
-          if locate_config_value(k).nil?
+          if config[k].nil?
             errors << "You did not provide a valid '#{pretty_key(k)}' value. Please set knife[:#{k}] in your knife.rb or pass as an option."
           end
         end
@@ -197,13 +188,13 @@ class Chef
         mandatory_keys = %i{azure_subscription_id azure_mgmt_cert azure_api_host_name}
         keys.concat(mandatory_keys)
 
-        unless locate_config_value(:azure_mgmt_cert).nil?
-          config[:azure_mgmt_cert] = File.read find_file(locate_config_value(:azure_mgmt_cert))
+        unless config[:azure_mgmt_cert].nil?
+          config[:azure_mgmt_cert] = File.read find_file(config[:azure_mgmt_cert])
         end
 
-        if !locate_config_value(:azure_publish_settings_file).nil?
-          parse_publish_settings_file(locate_config_value(:azure_publish_settings_file))
-        elsif locate_config_value(:azure_subscription_id).nil? && locate_config_value(:azure_mgmt_cert).nil? && locate_config_value(:azure_api_host_name).nil?
+        if !config[:azure_publish_settings_file].nil?
+          parse_publish_settings_file(config[:azure_publish_settings_file])
+        elsif config[:azure_subscription_id].nil? && config[:azure_mgmt_cert].nil? && config[:azure_api_host_name].nil?
           azureprofile_file = get_azure_profile_file_path
           if File.exist?(File.expand_path(azureprofile_file))
             errors = parse_azure_profile(azureprofile_file, errors)
@@ -224,15 +215,15 @@ class Chef
           # check given PublishSettings XML file format.Currently PublishSettings file have two different XML format
           if profile.attribute("SchemaVersion").nil?
             management_cert = OpenSSL::PKCS12.new(Base64.decode64(profile.attribute("ManagementCertificate").value))
-            Chef::Config[:knife][:azure_api_host_name] = URI(profile.attribute("Url").value).host
+            config[:azure_api_host_name] = URI(profile.attribute("Url").value).host
           elsif profile.attribute("SchemaVersion").value == "2.0"
             management_cert = OpenSSL::PKCS12.new(Base64.decode64(subscription.attribute("ManagementCertificate").value))
-            Chef::Config[:knife][:azure_api_host_name] = URI(subscription.attribute("ServiceManagementUrl").value).host
+            config[:azure_api_host_name] = URI(subscription.attribute("ServiceManagementUrl").value).host
           else
             ui.error("Publish settings file Schema not supported - " + filename)
           end
-          Chef::Config[:knife][:azure_mgmt_cert] = management_cert.certificate.to_pem + management_cert.key.to_pem
-          Chef::Config[:knife][:azure_subscription_id] = doc.at_css("Subscription").attribute("Id").value
+          config[:azure_mgmt_cert] = management_cert.certificate.to_pem + management_cert.key.to_pem
+          config[:azure_subscription_id] = doc.at_css("Subscription").attribute("Id").value
         rescue
           ui.error("Incorrect publish settings file - " + filename)
           exit 1
@@ -252,11 +243,11 @@ class Chef
         default_subscription = get_default_subscription(azure_profile)
         if default_subscription.key?("id") && default_subscription.key?("managementCertificate") && default_subscription.key?("managementEndpointUrl")
 
-          Chef::Config[:knife][:azure_subscription_id] = default_subscription["id"]
+          config[:azure_subscription_id] = default_subscription["id"]
           mgmt_key = OpenSSL::PKey::RSA.new(default_subscription["managementCertificate"]["key"]).to_pem
           mgmt_cert = OpenSSL::X509::Certificate.new(default_subscription["managementCertificate"]["cert"]).to_pem
-          Chef::Config[:knife][:azure_mgmt_cert] = mgmt_key + mgmt_cert
-          Chef::Config[:knife][:azure_api_host_name] = URI(default_subscription["managementEndpointUrl"]).host
+          config[:azure_mgmt_cert] = mgmt_key + mgmt_cert
+          config[:azure_api_host_name] = URI(default_subscription["managementEndpointUrl"]).host
         else
           errors << "Check if values set for 'id', 'managementCertificate', 'managementEndpointUrl' in -> #{filename} for 'defaultSubscription'. \n  OR "
         end
@@ -300,10 +291,8 @@ class Chef
       end
 
       def fetch_deployment
-        deployment_name = service.deployment_name(locate_config_value(:azure_dns_name))
-        deployment = service.deployment("hostedservices/#{locate_config_value(:azure_dns_name)}/deployments/#{deployment_name}")
-
-        deployment
+        deployment_name = service.deployment_name(config[:azure_dns_name])
+        service.deployment("hostedservices/#{config[:azure_dns_name]}/deployments/#{deployment_name}")
       end
 
       def fetch_role
@@ -312,7 +301,7 @@ class Chef
         if deployment.at_css("Deployment Name") != nil
           role_list_xml = deployment.css("RoleInstanceList RoleInstance")
           role_list_xml.each do |role|
-            if role.at_css("RoleName").text == (locate_config_value(:azure_vm_name) || @name_args[0])
+            if role.at_css("RoleName").text == (config[:azure_vm_name] || @name_args[0])
               return role
             end
           end
@@ -391,11 +380,11 @@ class Chef
             end
           else
             ## Chef Extension could not be found ##
-            ui.error("Unable to find Chef extension under role #{locate_config_value(:azure_vm_name) || @name_args[0]}.")
+            ui.error("Unable to find Chef extension under role #{config[:azure_vm_name] || @name_args[0]}.")
           end
         else
           ## server could not be found ##
-          ui.error("chef-client run logs could not be fetched since role #{locate_config_value(:azure_vm_name) || @name_args[0]} could not be found.")
+          ui.error("chef-client run logs could not be fetched since role #{config[:azure_vm_name] || @name_args[0]} could not be found.")
         end
       end
     end