knife-azure 2.0.17 → 3.0.0

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");
@@ -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");

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");

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");
@@ -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");

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");
@@ -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.

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");
@@ -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");
@@ -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");
@@ -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,