knife-azure 2.0.11 → 3.0.4

data/lib/chef/knife/azure_server_create.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 "azure_base"
+require_relative "helpers/azure_base"
 require "chef/knife/bootstrap"
 require "chef/knife/bootstrap/client_builder"
 require_relative "bootstrap/common_bootstrap_options"
@@ -196,7 +196,7 @@ class Chef
 
         config[:connection_port] = server_def[:port]
         config[:connection_protocol] = server_def[:connection_protocol]
-        config[:chef_node_name] = locate_config_value(:chef_node_name) || server_name
+        config[:chef_node_name] = config[:chef_node_name] || server_name
       rescue => error
         ui.error("Something went wrong. Please use -VV option for more details.")
         Chef::Log.debug(error.backtrace.join("\n").to_s)
@@ -216,7 +216,7 @@ class Chef
       alias host_descriptor server_name
 
       def plugin_finalize
-        if locate_config_value(:connection_protocol) == "cloud-api" && locate_config_value(:extended_logs)
+        if config[:connection_protocol] == "cloud-api" && config[:extended_logs]
           print "\nWaiting for the first chef-client run"
           fetch_chef_client_logs(Time.now, 30)
         end
@@ -228,8 +228,8 @@ class Chef
       def wait_until_virtual_machine_ready(retry_interval_in_seconds = 30)
         vm_status = nil
         begin
-          azure_vm_startup_timeout = locate_config_value(:azure_vm_startup_timeout).to_i
-          azure_vm_ready_timeout = locate_config_value(:azure_vm_ready_timeout).to_i
+          azure_vm_startup_timeout = config[:azure_vm_startup_timeout].to_i
+          azure_vm_ready_timeout = config[:azure_vm_ready_timeout].to_i
           vm_status = wait_for_virtual_machine_state(:vm_status_provisioning, azure_vm_startup_timeout, retry_interval_in_seconds)
           if vm_status != :vm_status_ready
             begin
@@ -242,7 +242,7 @@ class Chef
 
           msg_server_summary(@server)
 
-          if locate_config_value(:connection_protocol) == "cloud-api"
+          if config[:connection_protocol] == "cloud-api"
             extension_status = wait_for_resource_extension_state(:wagent_provisioning, 5, retry_interval_in_seconds)
 
             if extension_status != :extension_installing
@@ -323,7 +323,7 @@ class Chef
       end
 
       def get_virtual_machine_status
-        @server = service.get_role_server(locate_config_value(:azure_dns_name), locate_config_value(:azure_vm_name))
+        @server = service.get_role_server(config[:azure_dns_name], config[:azure_vm_name])
         if @server.nil?
           :vm_status_not_detected
         else
@@ -340,14 +340,14 @@ class Chef
       end
 
       def get_extension_status
-        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_name = service.deployment_name(config[:azure_dns_name])
+        deployment = service.deployment("hostedservices/#{config[:azure_dns_name]}/deployments/#{deployment_name}")
         extension_status = {}
 
         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)
+            if role.at_css("RoleName").text == config[:azure_vm_name]
               lnx_waagent_fail_msg = "Failed to deserialize the status reported by the Guest Agent"
               waagent_status_msg = role.at_css("GuestAgentStatus FormattedMessage Message").text
               if role.at_css("GuestAgentStatus Status").text == "Ready"
@@ -384,32 +384,32 @@ class Chef
 
       def create_server_def
         server_def = {
-          azure_storage_account: locate_config_value(:azure_storage_account),
-          azure_api_host_name: locate_config_value(:azure_api_host_name),
-          azure_dns_name: locate_config_value(:azure_dns_name),
-          azure_vm_name: locate_config_value(:azure_vm_name),
-          azure_service_location: locate_config_value(:azure_service_location),
-          azure_os_disk_name: locate_config_value(:azure_os_disk_name),
-          azure_source_image: locate_config_value(:azure_source_image),
-          azure_vm_size: locate_config_value(:azure_vm_size),
-          tcp_endpoints: locate_config_value(:tcp_endpoints),
-          udp_endpoints: locate_config_value(:udp_endpoints),
-          connection_protocol: locate_config_value(:connection_protocol),
-          azure_connect_to_existing_dns: locate_config_value(:azure_connect_to_existing_dns),
-          connection_user: locate_config_value(:connection_user),
-          azure_availability_set: locate_config_value(:azure_availability_set),
-          azure_affinity_group: locate_config_value(:azure_affinity_group),
-          azure_network_name: locate_config_value(:azure_network_name),
-          azure_subnet_name: locate_config_value(:azure_subnet_name),
-          ssl_cert_fingerprint: locate_config_value(:thumbprint),
-          cert_path: locate_config_value(:cert_path),
-          cert_password: locate_config_value(:cert_passphrase),
-          winrm_ssl: locate_config_value(:winrm_ssl),
-          winrm_max_timeout: locate_config_value(:winrm_max_timeout).to_i * 60 * 1000, # converting minutes to milliseconds
-          winrm_max_memory_per_shell: locate_config_value(:winrm_max_memory_per_shell),
+          azure_storage_account: config[:azure_storage_account],
+          azure_api_host_name: config[:azure_api_host_name],
+          azure_dns_name: config[:azure_dns_name],
+          azure_vm_name: config[:azure_vm_name],
+          azure_service_location: config[:azure_service_location],
+          azure_os_disk_name: config[:azure_os_disk_name],
+          azure_source_image: config[:azure_source_image],
+          azure_vm_size: config[:azure_vm_size],
+          tcp_endpoints: config[:tcp_endpoints],
+          udp_endpoints: config[:udp_endpoints],
+          connection_protocol: config[:connection_protocol],
+          azure_connect_to_existing_dns: config[:azure_connect_to_existing_dns],
+          connection_user: config[:connection_user],
+          azure_availability_set: config[:azure_availability_set],
+          azure_affinity_group: config[:azure_affinity_group],
+          azure_network_name: config[:azure_network_name],
+          azure_subnet_name: config[:azure_subnet_name],
+          ssl_cert_fingerprint: config[:thumbprint],
+          cert_path: config[:cert_path],
+          cert_password: config[:cert_passphrase],
+          winrm_ssl: config[:winrm_ssl],
+          winrm_max_timeout: config[:winrm_max_timeout].to_i * 60 * 1000, # converting minutes to milliseconds
+          winrm_max_memory_per_shell: config[:winrm_max_memory_per_shell],
         }
 
-        if locate_config_value(:connection_protocol) == "cloud-api"
+        if config[:connection_protocol] == "cloud-api"
           server_def[:chef_extension] = get_chef_extension_name
           server_def[:chef_extension_publisher] = get_chef_extension_publisher
           server_def[:chef_extension_version] = get_chef_extension_version
@@ -420,20 +420,20 @@ class Chef
             # We can specify the AdminUsername after API version 2013-03-01. However, in this API version,
             # the AdminUsername is a required parameter.
             # Also, the user name cannot be Administrator, Admin, Admin1 etc, for enhanced security (provided by Azure)
-            if locate_config_value(:connection_user).nil? || locate_config_value(:connection_user).downcase =~ /admin*/
+            if config[:connection_user].nil? || config[:connection_user].downcase =~ /admin*/
               ui.error("Connection User is compulsory parameter and it cannot be named 'admin*'")
               exit 1
             # take cares of when user name contains domain
             # azure add role api doesn't support '\\' in user name
-            elsif locate_config_value(:connection_user).split('\\').length.eql?(2)
-              server_def[:connection_user] = locate_config_value(:connection_user).split('\\')[1]
+            elsif config[:connection_user].split('\\').length.eql?(2)
+              server_def[:connection_user] = config[:connection_user].split('\\')[1]
             end
           else
-            unless locate_config_value(:connection_user)
+            unless config[:connection_user]
               ui.error("Connection User is compulsory parameter")
               exit 1
             end
-            unless locate_config_value(:connection_password) || locate_config_value(:ssh_identity_file)
+            unless config[:connection_password] || config[:ssh_identity_file]
               ui.error("Specify either SSH Key or SSH Password")
               exit 1
             end
@@ -442,52 +442,52 @@ class Chef
 
         if is_image_windows?
           server_def[:os_type] = "Windows"
-          server_def[:admin_password] = locate_config_value(:connection_password)
-          server_def[:connection_protocol] = locate_config_value(:connection_protocol) || "winrm"
+          server_def[:admin_password] = config[:connection_password]
+          server_def[:connection_protocol] = config[:connection_protocol] || "winrm"
         else
           server_def[:os_type] = "Linux"
-          server_def[:connection_protocol] = locate_config_value(:connection_protocol).nil? || locate_config_value(:connection_protocol) == "winrm" ? "ssh" : locate_config_value(:connection_protocol)
-          server_def[:connection_user] = locate_config_value(:connection_user)
-          server_def[:connection_password] = locate_config_value(:connection_password)
-          server_def[:ssh_identity_file] = locate_config_value(:ssh_identity_file)
-          server_def[:identity_file_passphrase] = locate_config_value(:identity_file_passphrase)
+          server_def[:connection_protocol] = config[:connection_protocol].nil? || config[:connection_protocol] == "winrm" ? "ssh" : config[:connection_protocol]
+          server_def[:connection_user] = config[:connection_user]
+          server_def[:connection_password] = config[:connection_password]
+          server_def[:ssh_identity_file] = config[:ssh_identity_file]
+          server_def[:identity_file_passphrase] = config[:identity_file_passphrase]
         end
 
-        azure_connect_to_existing_dns = locate_config_value(:azure_connect_to_existing_dns)
+        azure_connect_to_existing_dns = config[:azure_connect_to_existing_dns]
         if is_image_windows? && server_def[:connection_protocol] == "winrm"
-          port = locate_config_value(:connection_port) || "5985"
-          port = locate_config_value(:connection_port) || Random.rand(64000) + 1000 if azure_connect_to_existing_dns
+          port = config[:connection_port] || "5985"
+          port = config[:connection_port] || Random.rand(64000) + 1000 if azure_connect_to_existing_dns
         elsif server_def[:connection_protocol] == "ssh"
-          port = locate_config_value(:connection_port) || "22"
-          port = locate_config_value(:connection_port) || Random.rand(64000) + 1000 if azure_connect_to_existing_dns
+          port = config[:connection_port] || "22"
+          port = config[:connection_port] || Random.rand(64000) + 1000 if azure_connect_to_existing_dns
         end
 
         server_def[:port] = port
 
-        server_def[:is_vm_image] = service.vm_image?(locate_config_value(:azure_source_image))
-        server_def[:azure_domain_name] = locate_config_value(:azure_domain_name) if locate_config_value(:azure_domain_name)
+        server_def[:is_vm_image] = service.vm_image?(config[:azure_source_image])
+        server_def[:azure_domain_name] = config[:azure_domain_name] if config[:azure_domain_name]
 
-        if locate_config_value(:azure_domain_user)
+        if config[:azure_domain_user]
           # extract domain name since it should be part of username
-          case locate_config_value(:azure_domain_user)
+          case config[:azure_domain_user]
           when /(\S+)\\(.+)/ # format - fully-qualified-DNS-domain\username
-            server_def[:azure_domain_name] = $1 if locate_config_value(:azure_domain_name).nil?
+            server_def[:azure_domain_name] = $1 if config[:azure_domain_name].nil?
             server_def[:azure_user_domain_name] = $1
             server_def[:azure_domain_user] = $2
           when /(.+)@(\S+)/ # format - user@fully-qualified-DNS-domain
-            server_def[:azure_domain_name] = $2 if locate_config_value(:azure_domain_name).nil?
+            server_def[:azure_domain_name] = $2 if config[:azure_domain_name].nil?
             server_def[:azure_user_domain_name] = $2
             server_def[:azure_domain_user] = $1
           else
-            if locate_config_value(:azure_domain_name).nil?
+            if config[:azure_domain_name].nil?
               ui.error('--azure-domain-name should be specified if --azure-domain-user is not in one of the following formats: fully-qualified-DNS-domain\username, user@fully-qualified-DNS-domain')
               exit 1
             end
-            server_def[:azure_domain_user] = locate_config_value(:azure_domain_user)
+            server_def[:azure_domain_user] = config[:azure_domain_user]
           end
         end
-        server_def[:azure_domain_passwd] = locate_config_value(:azure_domain_passwd)
-        server_def[:azure_domain_ou_dn] = locate_config_value(:azure_domain_ou_dn)
+        server_def[:azure_domain_passwd] = config[:azure_domain_passwd]
+        server_def[:azure_domain_ou_dn] = config[:azure_domain_ou_dn]
 
         server_def
       end
@@ -499,17 +499,17 @@ class Chef
       end
 
       def set_configs
-        unless locate_config_value(:connection_user).nil?
-          config[:connection_user] = locate_config_value(:connection_user)
+        unless config[:connection_user].nil?
+          config[:connection_user] = config[:connection_user]
         end
 
-        unless locate_config_value(:connection_password).nil?
-          config[:connection_password] = locate_config_value(:connection_password)
+        unless config[:connection_password].nil?
+          config[:connection_password] = config[:connection_password]
         end
 
-        config[:azure_dns_name] = get_dns_name(locate_config_value(:azure_dns_name))
-        config[:azure_vm_name] = locate_config_value(:azure_dns_name) unless locate_config_value(:azure_vm_name)
-        config[:chef_node_name] = locate_config_value(:azure_vm_name) unless locate_config_value(:chef_node_name)
+        config[:azure_dns_name] = get_dns_name(config[:azure_dns_name])
+        config[:azure_vm_name] = config[:azure_dns_name] unless config[:azure_vm_name]
+        config[:chef_node_name] = config[:azure_vm_name] unless config[:chef_node_name]
       end
 
       # This is related to Windows VM's specifically and computer name
@@ -520,10 +520,10 @@ class Chef
       def get_dns_name(azure_dns_name, prefix = "az-")
         return azure_dns_name unless azure_dns_name.nil?
 
-        if locate_config_value(:azure_vm_name).nil?
+        if config[:azure_vm_name].nil?
           (prefix + SecureRandom.hex((MAX_VM_NAME_CHARACTERS - prefix.length) / 2))
         else
-          locate_config_value(:azure_vm_name)
+          config[:azure_vm_name]
         end
       end
     end

data/lib/chef/knife/azure_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 "azure_base"
+require_relative "helpers/azure_base"
 
 class Chef
   class Knife
@@ -94,7 +94,7 @@ class Chef
       end
 
       def validate_disk_and_storage
-        if locate_config_value(:preserve_azure_os_disk) && locate_config_value(:delete_azure_storage_account)
+        if config[:preserve_azure_os_disk] && config[:delete_azure_storage_account]
           ui.warn("Cannot delete storage account while keeping OS Disk. Please set any one option.")
           exit
         else
@@ -107,11 +107,11 @@ class Chef
         validate_disk_and_storage
         @name_args.each do |name|
           begin
-            service.delete_server( { name: name, preserve_azure_os_disk: locate_config_value(:preserve_azure_os_disk),
-                                     preserve_azure_vhd: locate_config_value(:preserve_azure_vhd),
-                                     preserve_azure_dns_name: locate_config_value(:preserve_azure_dns_name),
-                                     delete_azure_storage_account: locate_config_value(:delete_azure_storage_account),
-                                     wait: locate_config_value(:wait) } )
+            service.delete_server( { name: name, preserve_azure_os_disk: config[:preserve_azure_os_disk],
+                                     preserve_azure_vhd: config[:preserve_azure_vhd],
+                                     preserve_azure_dns_name: config[:preserve_azure_dns_name],
+                                     delete_azure_storage_account: config[:delete_azure_storage_account],
+                                     wait: config[:wait] } )
 
             if config[:purge]
               node_to_delete = config[:chef_node_name] || name

data/lib/chef/knife/azure_server_list.rb

@@ -2,7 +2,7 @@
 # Author:: Barry Davis (barryd@jetstreamsoftware.com)
 # Author:: Seth Chisamore (<schisamo@chef.io>)
 # 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");
@@ -18,7 +18,7 @@
 # limitations under the License.
 #
 
-require_relative "azure_base"
+require_relative "helpers/azure_base"
 
 class Chef
   class Knife

data/lib/chef/knife/azure_server_show.rb

@@ -2,7 +2,7 @@
 # Author:: Barry Davis (barryd@jetstreamsoftware.com)
 # Author:: Seth Chisamore (<schisamo@chef.io>)
 # 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");
@@ -18,7 +18,7 @@
 # limitations under the License.
 #
 
-require_relative "azure_base"
+require_relative "helpers/azure_base"
 
 class Chef
   class Knife

data/lib/chef/knife/azure_vnet_create.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Jeff Mendoza (jeffmendoza@live.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"
 
 class Chef
   class Knife
@@ -50,10 +50,10 @@ class Chef
         validate_asm_keys!(:azure_network_name, :azure_affinity_group, :azure_address_space)
 
         params = {
-          azure_vnet_name: locate_config_value(:azure_network_name),
-          azure_ag_name: locate_config_value(:azure_affinity_group),
-          azure_address_space: locate_config_value(:azure_address_space),
-          azure_subnet_name: locate_config_value(:azure_subnet_name) || "Subnet-#{Random.rand(10)}",
+          azure_vnet_name: config[:azure_network_name],
+          azure_ag_name: config[:azure_affinity_group],
+          azure_address_space: config[:azure_address_space],
+          azure_subnet_name: config[:azure_subnet_name] || "Subnet-#{Random.rand(10)}",
         }
 
         rsp = service.create_vnet(params)

data/lib/chef/knife/azure_vnet_list.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Jeff Mendoza (jeffmendoza@live.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"
 
 class Chef
   class Knife

data/lib/chef/knife/azurerm_server_create.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 "azurerm_base"
+require_relative "helpers/azurerm_base"
 require "chef/knife/bootstrap"
 require "chef/knife/bootstrap/client_builder"
 require_relative "bootstrap/common_bootstrap_options"
@@ -32,7 +32,7 @@ class Chef
 
       deps do
         require "securerandom"
-        include Knife::AzurermBase.load_deps
+        include Knife::AzurermBase
       end
 
       banner "knife azurerm server create (options)"
@@ -156,55 +156,55 @@ class Chef
 
       def create_server_def
         server_def = {
-          azure_resource_group_name: locate_config_value(:azure_resource_group_name),
-          azure_storage_account: locate_config_value(:azure_storage_account),
-          azure_storage_account_type: locate_config_value(:azure_storage_account_type),
-          azure_vm_name: locate_config_value(:azure_vm_name),
-          azure_service_location: locate_config_value(:azure_service_location),
-          azure_os_disk_name: locate_config_value(:azure_os_disk_name),
-          azure_os_disk_caching: locate_config_value(:azure_os_disk_caching),
-          azure_os_disk_create_option: locate_config_value(:azure_os_disk_create_option),
-          azure_vm_size: locate_config_value(:azure_vm_size),
-          azure_image_reference_publisher: locate_config_value(:azure_image_reference_publisher),
-          azure_image_reference_offer: locate_config_value(:azure_image_reference_offer),
-          azure_image_reference_sku: locate_config_value(:azure_image_reference_sku),
-          azure_image_reference_version: locate_config_value(:azure_image_reference_version),
-          azure_availability_set: locate_config_value(:azure_availability_set),
-          azure_vnet_name: locate_config_value(:azure_vnet_name),
-          azure_vnet_subnet_name: locate_config_value(:azure_vnet_subnet_name),
-          ssl_cert_fingerprint: locate_config_value(:thumbprint),
-          cert_path: locate_config_value(:cert_path),
-          cert_password: locate_config_value(:cert_passphrase),
-          vnet_subnet_address_prefix: locate_config_value(:vnet_subnet_address_prefix),
-          server_count: locate_config_value(:server_count),
+          azure_resource_group_name: config[:azure_resource_group_name],
+          azure_storage_account: config[:azure_storage_account],
+          azure_storage_account_type: config[:azure_storage_account_type],
+          azure_vm_name: config[:azure_vm_name],
+          azure_service_location: config[:azure_service_location],
+          azure_os_disk_name: config[:azure_os_disk_name],
+          azure_os_disk_caching: config[:azure_os_disk_caching],
+          azure_os_disk_create_option: config[:azure_os_disk_create_option],
+          azure_vm_size: config[:azure_vm_size],
+          azure_image_reference_publisher: config[:azure_image_reference_publisher],
+          azure_image_reference_offer: config[:azure_image_reference_offer],
+          azure_image_reference_sku: config[:azure_image_reference_sku],
+          azure_image_reference_version: config[:azure_image_reference_version],
+          azure_availability_set: config[:azure_availability_set],
+          azure_vnet_name: config[:azure_vnet_name],
+          azure_vnet_subnet_name: config[:azure_vnet_subnet_name],
+          ssl_cert_fingerprint: config[:thumbprint],
+          cert_path: config[:cert_path],
+          cert_password: config[:cert_passphrase],
+          vnet_subnet_address_prefix: config[:vnet_subnet_address_prefix],
+          server_count: config[:server_count],
         }
 
-        server_def[:tcp_endpoints] = locate_config_value(:tcp_endpoints) if locate_config_value(:tcp_endpoints)
+        server_def[:tcp_endpoints] = config[:tcp_endpoints] if config[:tcp_endpoints]
 
         # We assign azure_vm_name to chef_node_name If node name is nill because storage account name is combination of hash value and node name.
-        config[:chef_node_name] ||= locate_config_value(:azure_vm_name)
+        config[:chef_node_name] ||= config[:azure_vm_name]
 
-        server_def[:azure_storage_account] = locate_config_value(:azure_vm_name) if server_def[:azure_storage_account].nil?
+        server_def[:azure_storage_account] = config[:azure_vm_name] if server_def[:azure_storage_account].nil?
         server_def[:azure_storage_account] = server_def[:azure_storage_account].gsub(/[!@#$%^&*()_-]/, "")
 
-        server_def[:azure_os_disk_name] = locate_config_value(:azure_vm_name) if server_def[:azure_os_disk_name].nil?
+        server_def[:azure_os_disk_name] = config[:azure_vm_name] if server_def[:azure_os_disk_name].nil?
         server_def[:azure_os_disk_name] = server_def[:azure_os_disk_name].gsub(/[!@#$%^&*()_-]/, "")
 
-        server_def[:azure_vnet_name] = locate_config_value(:azure_vm_name) if server_def[:azure_vnet_name].nil?
-        server_def[:azure_vnet_subnet_name] = locate_config_value(:azure_vm_name) if locate_config_value(:azure_vnet_subnet_name).nil?
+        server_def[:azure_vnet_name] = config[:azure_vm_name] if server_def[:azure_vnet_name].nil?
+        server_def[:azure_vnet_subnet_name] = config[:azure_vm_name] if config[:azure_vnet_subnet_name].nil?
 
         server_def[:chef_extension] = get_chef_extension_name
         server_def[:chef_extension_publisher] = get_chef_extension_publisher
-        server_def[:chef_extension_version] = locate_config_value(:azure_chef_extension_version)
+        server_def[:chef_extension_version] = config[:azure_chef_extension_version]
         server_def[:chef_extension_public_param] = get_chef_extension_public_params
         server_def[:chef_extension_private_param] = get_chef_extension_private_params
         server_def[:auto_upgrade_minor_version] = false
-        server_def[:connection_user] = locate_config_value(:connection_user)
-        server_def[:disablePasswordAuthentication] = if locate_config_value(:ssh_public_key)
-                                                       server_def[:ssh_public_key] = File.read(locate_config_value(:ssh_public_key))
+        server_def[:connection_user] = config[:connection_user]
+        server_def[:disablePasswordAuthentication] = if config[:ssh_public_key]
+                                                       server_def[:ssh_public_key] = File.read(config[:ssh_public_key])
                                                        "true"
                                                      else
-                                                       server_def[:connection_password] = locate_config_value(:connection_password)
+                                                       server_def[:connection_password] = config[:connection_password]
                                                        "false"
                                                      end
 
@@ -229,7 +229,7 @@ class Chef
       end
 
       def validate_ohai_hints
-        hint_values = locate_config_value(:ohai_hints).split(",")
+        hint_values = config[:ohai_hints].split(",")
         hint_values.each do |hint|
           unless is_supported_ohai_hint?(hint)
             raise ArgumentError, "Ohai Hint name #{hint} passed is not supported. Please run the command help to see the list of supported values."
@@ -245,22 +245,22 @@ class Chef
       end
 
       def set_configs
-        unless locate_config_value(:connection_user).nil?
-          config[:connection_user] = locate_config_value(:connection_user)
+        unless config[:connection_user].nil?
+          config[:connection_user] = config[:connection_user]
         end
 
-        unless locate_config_value(:connection_password).nil?
-          config[:connection_password] = locate_config_value(:connection_password)
+        unless config[:connection_password].nil?
+          config[:connection_password] = config[:connection_password]
         end
       end
 
       def set_default_image_reference!
         begin
-          if locate_config_value(:azure_image_os_type)
+          if config[:azure_image_os_type]
             validate_publisher_and_offer
             ## if azure_image_os_type is given (with or without azure-image-reference-sku) and other image reference parameters are not given,
             # set default image reference parameters
-            case locate_config_value(:azure_image_os_type)
+            case config[:azure_image_os_type]
             when "ubuntu"
               set_os_image("Canonical", "UbuntuServer", "14.04.2-LTS")
             when "centos"
@@ -292,15 +292,15 @@ class Chef
       def set_os_image(publisher, img_offer, default_os_version)
         config[:azure_image_reference_publisher] = publisher
         config[:azure_image_reference_offer] = img_offer
-        config[:azure_image_reference_sku] = locate_config_value(:azure_image_reference_sku) ? locate_config_value(:azure_image_reference_sku) : default_os_version
+        config[:azure_image_reference_sku] = config[:azure_image_reference_sku] ? config[:azure_image_reference_sku] : default_os_version
       end
 
       def is_image_os_type?
-        locate_config_value(:azure_image_reference_publisher) && locate_config_value(:azure_image_reference_offer) && locate_config_value(:azure_image_reference_sku) && locate_config_value(:azure_image_reference_version)
+        config[:azure_image_reference_publisher] && config[:azure_image_reference_offer] && config[:azure_image_reference_sku] && config[:azure_image_reference_version]
       end
 
       def validate_publisher_and_offer
-        if locate_config_value(:azure_image_reference_publisher) || locate_config_value(:azure_image_reference_offer)
+        if config[:azure_image_reference_publisher] || config[:azure_image_reference_offer]
           # if azure_image_os_type is given and any of the other image reference parameters like publisher or offer are also given,
           # raise error
           raise ArgumentError, 'Please specify either --azure-image-os-type OR --azure-image-os-type with --azure-image-reference-sku or 4 image reference parameters i.e.