knife-azure 1.6.0.rc.0 → 1.6.0

data/lib/azure/{storageaccount.rb → service_management/storageaccount.rb}

@@ -16,7 +16,7 @@
 # limitations under the License.
 #
 
-class Azure
+module Azure
   class StorageAccounts
     include AzureUtility
     def initialize(connection)
@@ -82,7 +82,7 @@ class Azure
   end
 end
 
-class Azure
+module Azure
   class StorageAccount
     include AzureUtility
     attr_accessor :name, :location

data/lib/azure/{vnet.rb → service_management/vnet.rb}

@@ -16,7 +16,7 @@
 # limitations under the License.
 #
 
-class Azure
+module Azure
   class Vnets
     def initialize(connection)
       @connection = connection
@@ -53,7 +53,7 @@ class Azure
   end
 end
 
-class Azure
+module Azure
   class Vnet
     attr_accessor :name, :affinity_group, :state
 

data/lib/chef/knife/azure_ag_create.rb

@@ -46,11 +46,8 @@ class Chef
         $stdout.sync = true
 
         Chef::Log.info('validating...')
-        validate!([:azure_subscription_id,
-                   :azure_mgmt_cert,
-                   :azure_api_host_name,
-                   :azure_affinity_group,
-                   :azure_service_location])
+        validate_asm_keys!(:azure_affinity_group,
+                   :azure_service_location)
 
         params = {
           azure_ag_name: locate_config_value(:azure_affinity_group),
@@ -58,7 +55,7 @@ class Chef
           azure_location: locate_config_value(:azure_service_location),
         }
 
-        rsp = connection.ags.create(params)
+        rsp = service.create_affinity_group(params)
         print "\n"
         if rsp.at_css('Status').nil?
           if rsp.at_css('Code').nil? || rsp.at_css('Message').nil?

data/lib/chef/knife/azure_ag_list.rb

@@ -27,24 +27,10 @@ class Chef
 
       banner 'knife azure ag list (options)'
 
-      def hl
-        @highline ||= HighLine.new
-      end
-
       def run
         $stdout.sync = true
-
-        validate!
-
-        cols = %w{Name Location Description}
-
-        the_list = cols.map { |col| ui.color(col, :bold) }
-        connection.ags.all.each do |ag|
-          cols.each { |attr| the_list << ag.send(attr.downcase).to_s }
-        end
-
-        puts "\n"
-        puts hl.list(the_list, :uneven_columns_across, cols.size)
+        validate_asm_keys!
+        service.list_affinity_groups
       end
     end
   end

data/lib/chef/knife/azure_base.rb

@@ -18,7 +18,7 @@
 #
 
 require 'chef/knife'
-require File.expand_path('../../../azure/connection', __FILE__)
+require 'azure/service_management/ASM_interface'
 
 class Chef
   class Knife
@@ -67,8 +67,8 @@ class Chef
       end
 
       def is_image_windows?
-        images = connection.images
-        target_image = images.all.select { |i| i.name == locate_config_value(:azure_source_image) }
+        images = service.list_images
+        target_image = images.select { |i| i.name == locate_config_value(:azure_source_image) }
         unless target_image[0].nil?
           return target_image[0].os == 'Windows'
         else
@@ -76,15 +76,18 @@ class Chef
           exit 1
         end
       end
-      def connection
-        @connection ||= begin
-                          connection = Azure::Connection.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)
-                          )
-                        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)
+                      )
+                    end
+        @service.ui = ui
+        @service
       end
 
       def locate_config_value(key)
@@ -116,18 +119,20 @@ class Chef
         puts "\n"
       end
 
-      def validate!(keys=[:azure_subscription_id, :azure_mgmt_cert, :azure_api_host_name])
+      def pretty_key(key)
+        key.to_s.gsub(/_/, ' ').gsub(/\w+/){ |w| (w =~ /(ssh)|(aws)/i) ? w.upcase  : w.capitalize }
+      end
+
+      # validate command pre-requisites (cli options)
+      def validate_params!
+      end
+
+      # validates keys
+      def validate!(keys)
         errors = []
-        if(locate_config_value(:azure_mgmt_cert) != nil)
-          config[:azure_mgmt_cert] = File.read find_file(locate_config_value(:azure_mgmt_cert))
-        end
-        if(locate_config_value(:azure_publish_settings_file) != nil)
-          parse_publish_settings_file(locate_config_value(:azure_publish_settings_file))
-        end
         keys.each do |k|
-          pretty_key = k.to_s.gsub(/_/, ' ').gsub(/\w+/){ |w| (w =~ /(ssh)|(aws)/i) ? w.upcase  : w.capitalize }
           if locate_config_value(k).nil?
-            errors << "You did not provide a valid '#{pretty_key}' value. Please set knife[:#{k}] in your knife.rb or pass as an option."
+            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
         if errors.each{|e| ui.error(e)}.any?
@@ -135,6 +140,26 @@ class Chef
         end
       end
 
+      # validate ASM mandatory keys
+      def validate_asm_keys!(*keys)
+        mandatory_keys = [:azure_subscription_id, :azure_mgmt_cert, :azure_api_host_name]
+        keys.concat(mandatory_keys)
+
+        if(locate_config_value(:azure_mgmt_cert) != nil)
+          config[:azure_mgmt_cert] = File.read find_file(locate_config_value(: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?
+          azureprofile_file = get_azure_profile_file_path
+          if File.exist?(File.expand_path(azureprofile_file))
+            errors = parse_azure_profile(azureprofile_file, errors)
+          end
+        end
+        validate!(keys)
+      end
+
       def parse_publish_settings_file(filename)
         require 'nokogiri'
         require 'base64'
@@ -162,6 +187,49 @@ class Chef
         end
       end
 
+      def get_azure_profile_file_path
+        '~/.azure/azureProfile.json'
+      end
+
+      def parse_azure_profile(filename, errors)
+        require 'openssl'
+        require 'uri'
+        azure_profile = File.read(File.expand_path(filename))
+        azure_profile = JSON.parse(azure_profile)
+        default_subscription = get_default_subscription(azure_profile)
+        if default_subscription.has_key?('id') && default_subscription.has_key?('managementCertificate') && default_subscription.has_key?('managementEndpointUrl')
+
+          Chef::Config[:knife][: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
+        else
+          errors << "Check if values set for 'id', 'managementCertificate', 'managementEndpointUrl' in -> #{filename} for 'defaultSubscription'. \n  OR "
+        end
+        errors
+      end
+
+      def get_default_subscription(azure_profile)
+        first_subscription_as_default = nil
+        azure_profile['subscriptions'].each do |subscription|
+          if subscription['isDefault']
+            Chef::Log.info("Default subscription \'#{subscription['name']}\'' selected.")
+            return subscription
+          end
+
+          first_subscription_as_default ||= subscription
+        end
+
+        if first_subscription_as_default
+          Chef::Log.info("First subscription \'#{subscription['name']}\' selected as default.")
+        else
+          Chef::Log.info('No subscriptions found.')
+          exit 1
+        end
+        first_subscription_as_default
+      end
+
       def find_file(name)
         config_dir = Chef::Knife.chef_config_dir
         if File.exist? name
@@ -176,7 +244,6 @@ class Chef
         end
         file
       end
-
     end
   end
 end

data/lib/chef/knife/azure_image_list.rb

@@ -18,7 +18,6 @@
 # limitations under the License.
 #
 
-require 'highline'
 require File.expand_path('../azure_base', __FILE__)
 
 class Chef
@@ -35,18 +34,15 @@ class Chef
         :boolean => true,
         :description => "Show all the fields of the images"
 
-      def h
-        @highline ||= HighLine.new
-      end
 
       def run
         $stdout.sync = true
 
-        validate!
+        validate_asm_keys!
+        items = service.list_images
 
         image_labels = !locate_config_value(:show_all_fields) ? ['Name', 'OS', 'Location'] : ['Name', 'Category', 'Label', 'OS', 'Location']
         image_list =  image_labels.map {|label| ui.color(label, :bold)}
-        items = connection.images.all
 
         image_items = image_labels.map {|item| item.downcase }
         items.each do |image|
@@ -54,7 +50,7 @@ class Chef
         end
 
         puts "\n"
-        puts h.list(image_list, :uneven_columns_across, !locate_config_value(:show_all_fields) ? 3 : 5)
+        puts ui.list(image_list, :uneven_columns_across, !locate_config_value(:show_all_fields) ? 3 : 5)
 
       end
     end

data/lib/chef/knife/azure_internal-lb_create.rb

@@ -47,10 +47,7 @@ class Chef
         $stdout.sync = true
 
         Chef::Log.info('validating...')
-        validate!([:azure_subscription_id,
-                   :azure_mgmt_cert,
-                   :azure_api_host_name,
-                   :azure_load_balancer])
+        validate_asm_keys!(:azure_load_balancer)
 
         params = {
           azure_load_balancer: locate_config_value(:azure_load_balancer),
@@ -59,7 +56,7 @@ class Chef
           azure_dns_name: locate_config_value(:azure_dns_name)
         }
 
-        rsp = connection.lbs.create(params)
+        rsp = service.create_internal_lb(params)
         print "\n"
         if rsp.at_css('Status').nil?
           if rsp.at_css('Code').nil? || rsp.at_css('Message').nil?

data/lib/chef/knife/azure_internal-lb_list.rb

@@ -27,24 +27,10 @@ class Chef
 
       banner 'knife azure internal lb list (options)'
 
-      def hl
-        @highline ||= HighLine.new
-      end
-
       def run
         $stdout.sync = true
-
-        validate!
-
-        cols = %w{Name Service Subnet VIP}
-
-        the_list = cols.map { |col| ui.color(col, :bold) }
-        connection.lbs.all.each do |lb|
-          cols.each { |attr| the_list << lb.send(attr.downcase).to_s }
-        end
-
-        puts "\n"
-        puts hl.list(the_list, :uneven_columns_across, cols.size)
+        validate_asm_keys!
+        service.list_internal_lb
       end
     end
   end

data/lib/chef/knife/azure_server_create.rb

@@ -20,8 +20,9 @@
 
 require 'chef/knife/azure_base'
 require 'chef/knife/winrm_base'
-require 'chef/knife/bootstrap_windows_base'
 require 'securerandom'
+require 'chef/knife/bootstrap/bootstrap_options'
+require 'chef/knife/bootstrap/bootstrapper'
 
 class Chef
   class Knife
@@ -29,7 +30,8 @@ class Chef
 
       include Knife::AzureBase
       include Knife::WinrmBase
-      include Knife::BootstrapWindowsBase
+      include Knife::Bootstrap::BootstrapOptions
+      include Knife::Bootstrap::Bootstrapper
 
       deps do
         require 'readline'
@@ -40,32 +42,16 @@ class Chef
         Chef::Knife::Bootstrap.load_deps
       end
 
-      def load_winrm_deps
-        require 'winrm'
-        require 'chef/knife/winrm'
-        require 'chef/knife/bootstrap_windows_winrm'
-      end
-
       banner "knife azure server create (options)"
 
       attr_accessor :initial_sleep_delay
 
-      option :forward_agent,
-        :short => "-A",
-        :long => "--forward-agent",
-        :description =>  "Enable SSH agent forwarding",
-        :boolean => true
 
       option :bootstrap_protocol,
         :long => "--bootstrap-protocol protocol",
         :description => "Protocol to bootstrap windows servers. options: 'winrm' or 'ssh' or 'cloud-api'.",
         :default => "winrm"
 
-      option :chef_node_name,
-        :short => "-N NAME",
-        :long => "--node-name NAME",
-        :description => "The Chef node name for your new node"
-
       option :ssh_user,
         :short => "-x USERNAME",
         :long => "--ssh-user USERNAME",
@@ -81,49 +67,6 @@ class Chef
         :long => "--ssh-port PORT",
         :description => "The ssh port. Default is 22. If --azure-connect-to-existing-dns set then default SSH port is random"
 
-      option :prerelease,
-        :long => "--prerelease",
-        :description => "Install the pre-release chef gems"
-
-      option :bootstrap_version,
-        :long => "--bootstrap-version VERSION",
-        :description => "The version of Chef to install",
-        :proc => Proc.new { |v| Chef::Config[:knife][:bootstrap_version] = v }
-
-      option :distro,
-        :short => "-d DISTRO",
-        :long => "--distro DISTRO",
-        :description => "Bootstrap a distro using a template. [DEPRECATED] Use --bootstrap-template option instead.",
-        :proc        => Proc.new { |v|
-          Chef::Log.warn("[DEPRECATED] -d / --distro option is deprecated. Use --bootstrap-template option instead.")
-          v
-        }
-
-      option :template_file,
-        :long => "--template-file TEMPLATE",
-        :description => "Full path to location of template to use. [DEPRECATED] Use -t / --bootstrap-template option instead.",
-        :proc        => Proc.new { |v|
-          Chef::Log.warn("[DEPRECATED] --template-file option is deprecated. Use -t / --bootstrap-template option instead.")
-          v
-        }
-
-      option :bootstrap_template,
-        :long => "--bootstrap-template TEMPLATE",
-        :description => "Bootstrap Chef using a built-in or custom template. Set to the full path of an erb template or use one of the built-in templates."
-
-      option :run_list,
-        :short => "-r RUN_LIST",
-        :long => "--run-list RUN_LIST",
-        :description => "Comma separated list of roles/recipes to apply",
-        :proc => lambda { |o| o.split(/[\s,]+/) },
-        :default => []
-
-      option :host_key_verify,
-        :long => "--[no-]host-key-verify",
-        :description => "Verify host key, enabled by default.",
-        :boolean => true,
-        :default => true
-
       option :node_ssl_verify_mode,
         :long        => "--node-ssl-verify-mode [peer|none]",
         :description => "Whether or not to verify the SSL cert for all HTTPS requests.",
@@ -139,60 +82,6 @@ class Chef
         :description => "Verify the SSL cert for HTTPS requests to the Chef server API.",
         :boolean     => true
 
-      option :bootstrap_proxy,
-            :long => "--bootstrap-proxy PROXY_URL",
-            :description => "The proxy server for the node being bootstrapped",
-            :proc => Proc.new { |p| Chef::Config[:knife][:bootstrap_proxy] = p }
-
-      option :bootstrap_no_proxy,
-        :long => "--bootstrap-no-proxy [NO_PROXY_URL|NO_PROXY_IP]",
-        :description => "Do not proxy locations for the node being bootstrapped; this option is used internally by Opscode",
-        :proc => Proc.new { |np| Chef::Config[:knife][:bootstrap_no_proxy] = np }
-
-      option :bootstrap_url,
-        :long        => "--bootstrap-url URL",
-        :description => "URL to a custom installation script",
-        :proc        => Proc.new { |u| Chef::Config[:knife][:bootstrap_url] = u }
-
-      option :bootstrap_install_command,
-        :long        => "--bootstrap-install-command COMMANDS",
-        :description => "Custom command to install chef-client",
-        :proc        => Proc.new { |ic| Chef::Config[:knife][:bootstrap_install_command] = ic }
-
-      option :bootstrap_wget_options,
-        :long        => "--bootstrap-wget-options OPTIONS",
-        :description => "Add options to wget when installing chef-client",
-        :proc        => Proc.new { |wo| Chef::Config[:knife][:bootstrap_wget_options] = wo }
-
-      option :bootstrap_curl_options,
-        :long        => "--bootstrap-curl-options OPTIONS",
-        :description => "Add options to curl when install chef-client",
-        :proc        => Proc.new { |co| Chef::Config[:knife][:bootstrap_curl_options] = co }
-
-      option :bootstrap_vault_file,
-        :long        => '--bootstrap-vault-file VAULT_FILE',
-        :description => 'A JSON file with a list of vault(s) and item(s) to be updated'
-
-      option :bootstrap_vault_json,
-        :long        => '--bootstrap-vault-json VAULT_JSON',
-        :description => 'A JSON string with the vault(s) and item(s) to be updated'
-
-      option :bootstrap_vault_item,
-        :long        => '--bootstrap-vault-item VAULT_ITEM',
-        :description => 'A single vault and item to update as "vault:item"',
-        :proc        => Proc.new { |i|
-          (vault, item) = i.split(/:/)
-          Chef::Config[:knife][:bootstrap_vault_item] ||= {}
-          Chef::Config[:knife][:bootstrap_vault_item][vault] ||= []
-          Chef::Config[:knife][:bootstrap_vault_item][vault].push(item)
-          Chef::Config[:knife][:bootstrap_vault_item]
-        }
-
-      option :use_sudo_password,
-        :long => "--use-sudo-password",
-        :description => "Execute the bootstrap via sudo with password",
-        :boolean => false
-
       option :azure_storage_account,
         :short => "-a NAME",
         :long => "--azure-storage-account NAME",
@@ -211,7 +100,8 @@ 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"
+                                      Eg: West US, East US, East Asia, Southeast Asia, North Europe, West Europe",
+        :proc        => Proc.new { |lo| Chef::Config[:knife][:azure_service_location] = lo }
 
       option :azure_affinity_group,
         :short => "-a GROUP",
@@ -242,7 +132,8 @@ class Chef
         :short => "-z SIZE",
         :long => "--azure-vm-size SIZE",
         :description => "Optional. Size of virtual machine (ExtraSmall, Small, Medium, Large, ExtraLarge)",
-        :default => 'Small'
+        :default => 'Small',
+        :proc => Proc.new { |si| Chef::Config[:knife][:azure_vm_size] = si }
 
       option :azure_availability_set,
              :long => "--azure-availability-set NAME",
@@ -297,21 +188,6 @@ class Chef
         :long => "--identity-file-passphrase PASSWORD",
         :description => "SSH key passphrase. Optional, specify if passphrase for identity-file exists"
 
-      option :hint,
-        :long => "--hint HINT_NAME[=HINT_FILE]",
-        :description => "Specify Ohai Hint to be set on the bootstrap target.  Use multiple --hint options to specify multiple hints.",
-        :proc => Proc.new { |h|
-           Chef::Config[:knife][:hints] ||= {}
-           name, path = h.split("=")
-           Chef::Config[:knife][:hints][name] = path ? JSON.parse(::File.read(path)) : Hash.new
-        }
-
-      option :json_attributes,
-        :short => "-j JSON",
-        :long => "--json-attributes JSON",
-        :description => "A JSON string to be added to the first run of chef-client",
-        :proc => lambda { |o| JSON.parse(o) }
-
       option :thumbprint,
         :long => "--thumbprint THUMBPRINT",
         :description => "The thumprint of the ssl certificate"
@@ -324,12 +200,6 @@ class Chef
         :long => "--cert-path PATH",
         :description => "SSL Certificate Path"
 
-      option :auto_update_client,
-      :long => "--auto-update-client",
-      :boolean => true,
-      :default => false,
-      :description => "Set this flag to enable auto chef client update in azure chef extension. This flag should be used with cloud-api bootstrap protocol only"
-
       option :winrm_max_timeout,
         :long => "--winrm-max-timeout MINUTES",
         :description => "Set winrm maximum command timeout in minutes, useful for long bootstraps"
@@ -338,12 +208,6 @@ class Chef
         :long => "--winrm-max-memory-per-shell",
         :description => "Set winrm max memory per shell in MB"
 
-      option :delete_chef_extension_config,
-        :long => "--delete-chef-extension-config",
-        :boolean => true,
-        :default => false,
-        :description => "Determines whether Chef configuration files removed when Azure removes the Chef resource extension from the VM. This option is only valid for the 'cloud-api' bootstrap protocol. The default is false."
-
       option :azure_domain_name,
         :long => "--azure-domain-name DOMAIN_NAME",
         :description => "Optional. Specifies the domain name to join. If the domains name is not specified, --azure-domain-user must specify the user principal name (UPN) format (user@fully-qualified-DNS-domain) or the fully-qualified-DNS-domain\\username format"
@@ -366,20 +230,9 @@ class Chef
         :long => "--azure-extension-client-config CLIENT_PATH",
         :description => "Optional. Path to a client.rb file for use by the bootstrapped node. Only honored when --bootstrap-protocol is set to `cloud-api`."
 
-      def strip_non_ascii(string)
-        string.gsub(/[^0-9a-z ]/i, '')
-      end
-
-      def random_string(len=10)
-        (0...len).map{65.+(rand(25)).chr}.join
-      end
-
       def wait_until_virtual_machine_ready(retry_interval_in_seconds = 30)
-
         vm_status = nil
 
-        puts
-
         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
@@ -393,7 +246,7 @@ class Chef
             end
           end
 
-          msg_server_summary(get_role_server())
+          msg_server_summary(service.get_role_server(locate_config_value(:azure_dns_name), locate_config_value(:azure_vm_name)))
 
           if locate_config_value(:bootstrap_protocol) == "cloud-api"
             extension_status = wait_for_resource_extension_state(:wagent_provisioning, 5, retry_interval_in_seconds)
@@ -477,7 +330,7 @@ class Chef
       end
 
       def get_virtual_machine_status()
-        role = get_role_server()
+        role = service.get_role_server(locate_config_value(:azure_dns_name), locate_config_value(:azure_vm_name))
         unless role.nil?
           Chef::Log.debug("Role status is #{role.status.to_s}")
           if  "ReadyRole".eql? role.status.to_s
@@ -492,8 +345,8 @@ class Chef
       end
 
       def get_extension_status()
-        deployment_name = connection.deploys.get_deploy_name_for_hostedservice(locate_config_value(:azure_dns_name))
-        deployment = connection.query_azure("hostedservices/#{locate_config_value(:azure_dns_name)}/deployments/#{deployment_name}")
+        deployment_name = service.deployment_name(locate_config_value(:azure_dns_name))
+        deployment = service.deployment("hostedservices/#{locate_config_value(:azure_dns_name)}/deployments/#{deployment_name}")
         extension_status = Hash.new
 
         if deployment.at_css('Deployment Name') != nil
@@ -538,279 +391,130 @@ class Chef
         return extension_status
       end
 
-      def get_role_server
-        deploy = connection.deploys.queryDeploy(locate_config_value(:azure_dns_name))
-        deploy.find_role(locate_config_value(:azure_vm_name))
+      def fetch_role
+        deployment_name = service.deployment_name(locate_config_value(:azure_dns_name))
+        deployment = service.deployment("hostedservices/#{locate_config_value(:azure_dns_name)}/deployments/#{deployment_name}")
+
+        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)
+              return role
+            end
+          end
+        end
+        return nil
+      end
+
+      def fetch_extension(role)
+        ext_list_xml = role.css("ResourceExtensionStatusList ResourceExtensionStatus")
+        ext_list_xml.each do |ext|
+          if ext.at_css("HandlerName").text == "Chef.Bootstrap.WindowsAzure.LinuxChefClient" || ext.at_css("HandlerName").text == "Chef.Bootstrap.WindowsAzure.ChefClient"
+            return ext
+          end
+        end
+        return nil
       end
 
-      def tcp_test_winrm(ip_addr, port)
-        hostname = ip_addr
-        socket = TCPSocket.new(hostname, port)
-        return true
-        rescue SocketError
-          sleep 2
-          false
-        rescue Errno::ETIMEDOUT
-          false
-        rescue Errno::EPERM
-          false
-        rescue Errno::ECONNREFUSED
-          sleep 2
-          false
-        rescue Errno::EHOSTUNREACH
-          sleep 2
-          false
-        rescue Errno::ENETUNREACH
-          sleep 2
-          false
+      def fetch_substatus(extension)
+        return nil if extension.at_css("ExtensionSettingStatus SubStatusList SubStatus").nil?
+        substatus_list_xml = extension.css("ExtensionSettingStatus SubStatusList SubStatus")
+        substatus_list_xml.each do |substatus|
+          if substatus.at_css("Name").text == "Chef Client run logs"
+            return substatus
+          end
+        end
+        return nil
       end
 
-      def tcp_test_ssh(fqdn, sshport)
-        tcp_socket = TCPSocket.new(fqdn, sshport)
-        readable = IO.select([tcp_socket], nil, nil, 5)
-        if readable
-          Chef::Log.debug("sshd accepting connections on #{fqdn}, banner is #{tcp_socket.gets}")
-          yield
-          true
+      def fetch_chef_client_logs(fetch_process_start_time, fetch_process_wait_timeout)
+        ## fetch server details ##
+        role = fetch_role
+        if role != nil
+          ## fetch Chef Extension details deployed on the server ##
+          ext = fetch_extension(role)
+          if ext != nil
+            ## fetch substatus field which contains the chef-client run logs ##
+            substatus = fetch_substatus(ext)
+            if substatus != nil
+              ## chef-client run logs becomes available ##
+              name = substatus.at_css("Name").text
+              status = substatus.at_css("Status").text
+              message = substatus.at_css("Message").text
+
+              ## printing the logs ##
+              puts "\n\n******** Please find the chef-client run details below ********\n\n"
+              print "----> chef-client run status: "
+              case status
+              when "Success"
+                ## chef-client run succeeded ##
+                color = :green
+              when "Error"
+                ## chef-client run failed ##
+                color = :red
+              when "Transitioning"
+                ## chef-client run did not complete within maximum timeout of 30 minutes ##
+                ## fetch whatever logs available under the chef-client.log file ##
+                color = :yellow
+              end
+              puts "#{ui.color(status, color, :bold)}"
+              puts "----> chef-client run logs: "
+              puts "\n#{message}\n"  ## message field of substatus contains the chef-client run logs ##
+            else
+              ## unavailability of the substatus field indicates that chef-client run is not completed yet on the server ##
+              fetch_process_wait_time = ((Time.now - fetch_process_start_time) / 60).round
+              if fetch_process_wait_time <= fetch_process_wait_timeout  ## wait for maximum 30 minutes until chef-client run logs becomes available ##
+                print "#{ui.color('.', :bold)}"
+                sleep 30
+                fetch_chef_client_logs(fetch_process_start_time, fetch_process_wait_timeout)
+              else
+                ## wait time exceeded 30 minutes timeout ##
+                ui.error "\nchef-client run logs could not be fetched since fetch process exceeded wait timeout of #{fetch_process_wait_timeout} minutes.\n"
+              end
+            end
+          else
+            ## Chef Extension could not be found ##
+            ui.error("Unable to find Chef extension under role #{locate_config_value(:azure_vm_name)}.")
+          end
         else
-          false
+          ## server could not be found ##
+          ui.error("chef-client run logs could not be fetched since role #{locate_config_value(:azure_vm_name)} could not be found.")
         end
-      rescue SocketError
-        sleep 2
-        false
-      rescue Errno::ETIMEDOUT
-        false
-      rescue Errno::EPERM
-        false
-      rescue Errno::ECONNREFUSED
-        sleep 2
-        false
-      rescue Errno::EHOSTUNREACH
-        sleep 2
-        false
-      ensure
-        tcp_socket && tcp_socket.close
       end
 
       def run
         $stdout.sync = true
+
         storage = nil
 
         Chef::Log.info("validating...")
-        validate!
+        validate_asm_keys!(:azure_source_image)
 
-        if (locate_config_value(:auto_update_client) ||  locate_config_value(:delete_chef_extension_config))  &&  (locate_config_value(:bootstrap_protocol) != 'cloud-api')
-          ui.error("--auto-update-client option works with --bootstrap-protocol cloud-api") if locate_config_value(:auto_update_client)
-          ui.error("--delete-chef-extension-config option works with --bootstrap-protocol cloud-api") if locate_config_value(:delete_chef_extension_config)
-          exit 1
-        end
+        validate_params!
 
-        ssh_override_winrm if %w(ssh cloud-api).include?(locate_config_value(:bootstrap_protocol)) and !is_image_windows?
+        ssh_override_winrm if !is_image_windows?
 
         Chef::Log.info("creating...")
 
         config[:azure_dns_name] = get_dns_name(locate_config_value(:azure_dns_name))
+
         if not locate_config_value(:azure_vm_name)
           config[:azure_vm_name] = locate_config_value(:azure_dns_name)
         end
 
-        remove_hosted_service_on_failure = locate_config_value(:azure_dns_name)
-        if connection.hosts.exists?(locate_config_value(:azure_dns_name))
-          remove_hosted_service_on_failure = nil
-        end
-
-        #If Storage Account is not specified, check if the geographic location has one to re-use
-        if not locate_config_value(:azure_storage_account)
-          storage_accts = connection.storageaccounts.all
-          storage = storage_accts.find { |storage_acct| storage_acct.location.to_s == locate_config_value(:azure_service_location) }
-          if not storage
-            config[:azure_storage_account] = [strip_non_ascii(locate_config_value(:azure_vm_name)), random_string].join.downcase
-            remove_storage_service_on_failure = config[:azure_storage_account]
-          else
-            remove_storage_service_on_failure = nil
-            config[:azure_storage_account] = storage.name.to_s
-          end
-        else
-          if connection.storageaccounts.exists?(locate_config_value(:azure_storage_account))
-            remove_storage_service_on_failure = nil
-          else
-            remove_storage_service_on_failure = locate_config_value(:azure_storage_account)
-          end
+        service.create_server(create_server_def)
+        wait_until_virtual_machine_ready()
+        if locate_config_value(:bootstrap_protocol) == 'cloud-api' && locate_config_value(:extended_logs)
+          print "\n\nWaiting for the first chef-client run"
+          fetch_chef_client_logs(Time.now, 30)
         end
-
-        begin
-          connection.deploys.create(create_server_def)
-          wait_until_virtual_machine_ready()
-          server = get_role_server()
-        rescue Exception => e
-          Chef::Log.error("Failed to create the server -- exception being rescued: #{e.to_s}")
-          backtrace_message = "#{e.class}: #{e}\n#{e.backtrace.join("\n")}"
-          Chef::Log.debug("#{backtrace_message}")
-          cleanup_and_exit(remove_hosted_service_on_failure, remove_storage_service_on_failure)
-        end
-
+        server = service.get_role_server(locate_config_value(:azure_dns_name), locate_config_value(:azure_vm_name))
         msg_server_summary(server)
 
         bootstrap_exec(server) unless locate_config_value(:bootstrap_protocol) == 'cloud-api'
       end
 
-      def default_bootstrap_template
-        is_image_windows? ? 'windows-chef-client-msi' : 'chef-full'
-      end
-
-      def bootstrap_exec(server)
-        fqdn = server.publicipaddress
-
-        if is_image_windows?
-          if locate_config_value(:bootstrap_protocol) == 'ssh'
-            port = server.sshport
-            print "#{ui.color("Waiting for sshd on #{fqdn}:#{port}", :magenta)}"
-
-            print(".") until tcp_test_ssh(fqdn,port) {
-              sleep @initial_sleep_delay ||= 10
-              puts("done")
-            }
-
-          elsif locate_config_value(:bootstrap_protocol) == 'winrm'
-            port = server.winrmport
-
-            print "#{ui.color("Waiting for winrm on #{fqdn}:#{port}", :magenta)}"
-
-            print(".") until tcp_test_winrm(fqdn,port) {
-              sleep @initial_sleep_delay ||= 10
-              puts("done")
-            }
-          end
-
-          puts("\n")
-          bootstrap_for_windows_node(server,fqdn, port).run
-        else
-          unless server && server.publicipaddress && server.sshport
-            Chef::Log.fatal("server not created")
-            exit 1
-          end
-
-          port = server.sshport
-
-          print ui.color("Waiting for sshd on #{fqdn}:#{port}", :magenta)
-
-          print(".") until tcp_test_ssh(fqdn,port) {
-            sleep @initial_sleep_delay ||= 10
-            puts("done")
-          }
-
-          puts("\n")
-          bootstrap_for_node(server,fqdn,port).run
-        end
-
-        msg_server_summary(server)
-      end
-
-      def load_cloud_attributes_in_hints(server)
-        # Modify global configuration state to ensure hint gets set by knife-bootstrap
-        # Query azure and load necessary attributes.
-        cloud_attributes = {}
-        cloud_attributes["public_ip"] = server.publicipaddress
-        cloud_attributes["vm_name"] = server.name
-        cloud_attributes["public_fqdn"] = server.hostedservicename.to_s + ".cloudapp.net"
-        cloud_attributes["public_ssh_port"] = server.sshport if server.sshport
-        cloud_attributes["public_winrm_port"] = server.winrmport if server.winrmport
-
-        Chef::Config[:knife][:hints] ||= {}
-        Chef::Config[:knife][:hints]["azure"] ||= cloud_attributes
-
-      end
-
-      def bootstrap_common_params(bootstrap, server)
-
-        bootstrap.config[:run_list] = config[:run_list]
-        bootstrap.config[:prerelease] = config[:prerelease]
-        bootstrap.config[:first_boot_attributes] = locate_config_value(:json_attributes) || {}
-        bootstrap.config[:bootstrap_version] = locate_config_value(:bootstrap_version)
-        bootstrap.config[:distro] = locate_config_value(:distro) || default_bootstrap_template
-        # setting bootstrap_template value to template_file for backward
-        bootstrap.config[:template_file] = locate_config_value(:template_file) || locate_config_value(:bootstrap_template)
-        bootstrap.config[:node_ssl_verify_mode] = locate_config_value(:node_ssl_verify_mode)
-        bootstrap.config[:node_verify_api_cert] = locate_config_value(:node_verify_api_cert)
-        bootstrap.config[:bootstrap_no_proxy] = locate_config_value(:bootstrap_no_proxy)
-        bootstrap.config[:bootstrap_url] = locate_config_value(:bootstrap_url)
-        bootstrap.config[:bootstrap_vault_file] = locate_config_value(:bootstrap_vault_file)
-        bootstrap.config[:bootstrap_vault_json] = locate_config_value(:bootstrap_vault_json)
-        bootstrap.config[:bootstrap_vault_item] = locate_config_value(:bootstrap_vault_item)
-
-        load_cloud_attributes_in_hints(server)
-        bootstrap
-      end
-
-      def bootstrap_for_windows_node(server, fqdn, port)
-        if locate_config_value(:bootstrap_protocol) == 'winrm'
-
-            load_winrm_deps
-            if not Chef::Platform.windows?
-              require 'gssapi'
-            end
-
-            bootstrap = Chef::Knife::BootstrapWindowsWinrm.new
-
-            bootstrap.config[:winrm_user] = locate_config_value(:winrm_user) || 'Administrator'
-            bootstrap.config[:winrm_password] = locate_config_value(:winrm_password)
-            bootstrap.config[:winrm_transport] = locate_config_value(:winrm_transport)
-            bootstrap.config[:winrm_authentication_protocol] = locate_config_value(:winrm_authentication_protocol)
-            bootstrap.config[:winrm_port] = port
-            bootstrap.config[:auth_timeout] = locate_config_value(:auth_timeout)
-            # Todo: we should skip cert generate in case when winrm_ssl_verify_mode=verify_none
-            bootstrap.config[:winrm_ssl_verify_mode] = locate_config_value(:winrm_ssl_verify_mode)
-        elsif locate_config_value(:bootstrap_protocol) == 'ssh'
-            bootstrap = Chef::Knife::BootstrapWindowsSsh.new
-            bootstrap.config[:ssh_user] = locate_config_value(:ssh_user)
-            bootstrap.config[:ssh_password] = locate_config_value(:ssh_password)
-            bootstrap.config[:forward_agent] = locate_config_value(:forward_agent)
-            bootstrap.config[:ssh_port] = port
-            bootstrap.config[:identity_file] = locate_config_value(:identity_file)
-            bootstrap.config[:host_key_verify] = locate_config_value(:host_key_verify)
-        else
-            ui.error("Unsupported Bootstrapping Protocol. Supported : winrm, ssh")
-            exit 1
-        end
-        bootstrap.name_args = [fqdn]
-        bootstrap.config[:chef_node_name] = config[:chef_node_name] || server.name
-        bootstrap.config[:encrypted_data_bag_secret] = locate_config_value(:encrypted_data_bag_secret)
-        bootstrap.config[:encrypted_data_bag_secret_file] = locate_config_value(:encrypted_data_bag_secret_file)
-        bootstrap.config[:msi_url] = locate_config_value(:msi_url)
-        bootstrap.config[:install_as_service] = locate_config_value(:install_as_service)
-        bootstrap_common_params(bootstrap, server)
-      end
-
-      def bootstrap_for_node(server,fqdn,port)
-        bootstrap = Chef::Knife::Bootstrap.new
-        bootstrap.name_args = [fqdn]
-        bootstrap.config[:ssh_user] = locate_config_value(:ssh_user)
-        bootstrap.config[:ssh_password] = locate_config_value(:ssh_password)
-        bootstrap.config[:ssh_port] = port
-        bootstrap.config[:identity_file] = locate_config_value(:identity_file)
-        bootstrap.config[:chef_node_name] = locate_config_value(:chef_node_name) || server.name
-        bootstrap.config[:use_sudo] = true unless locate_config_value(:ssh_user) == 'root'
-        bootstrap.config[:use_sudo_password] = true if bootstrap.config[:use_sudo]
-        bootstrap.config[:environment] = locate_config_value(:environment)
-        # may be needed for vpc_mode
-        bootstrap.config[:host_key_verify] = config[:host_key_verify]
-        bootstrap.config[:secret] = locate_config_value(:secret)
-        bootstrap.config[:secret_file] = locate_config_value(:secret_file)
-        bootstrap.config[:bootstrap_install_command] = locate_config_value(:bootstrap_install_command)
-        bootstrap.config[:bootstrap_wget_options] = locate_config_value(:bootstrap_wget_options)
-        bootstrap.config[:bootstrap_curl_options] = locate_config_value(:bootstrap_curl_options)
-        bootstrap_common_params(bootstrap, server)
-      end
-
-      def validate!
-        super([
-              :azure_subscription_id,
-              :azure_mgmt_cert,
-              :azure_api_host_name,
-              :azure_source_image,
-              :azure_vm_size,
-        ])
-
+      def validate_params!
         if locate_config_value(:winrm_password) and (locate_config_value(:winrm_password).length <= 6 and locate_config_value(:winrm_password).length >= 72)
           ui.error("The supplied password must be 6-72 characters long and meet password complexity requirements")
           exit 1
@@ -839,7 +543,7 @@ class Chef
           exit 1
         end
 
-        if !(connection.images.exists?(locate_config_value(:azure_source_image)))
+        if !(service.valid_image?(locate_config_value(:azure_source_image)))
           ui.error("Image provided is invalid")
           exit 1
         end
@@ -856,6 +560,18 @@ class Chef
           ui.error("The SSL transport was specified without the --thumbprint option. Specify a thumbprint, or alternatively set the --winrm-ssl-verify-mode option to 'verify_none' to skip verification.")
           exit 1
         end
+
+        if (locate_config_value(:auto_update_client) ||  locate_config_value(:delete_chef_extension_config) || locate_config_value(:uninstall_chef_client))  &&  (locate_config_value(:bootstrap_protocol) != 'cloud-api')
+          ui.error("--auto-update-client option works with --bootstrap-protocol cloud-api") if locate_config_value(:auto_update_client)
+          ui.error("--delete-chef-extension-config option works with --bootstrap-protocol cloud-api") if locate_config_value(:delete_chef_extension_config)
+          ui.error("--uninstall-chef-client option works with --bootstrap-protocol cloud-api") if locate_config_value(:uninstall_chef_client)
+          exit 1
+        end
+
+        if locate_config_value(:extended_logs) && locate_config_value(:bootstrap_protocol) != 'cloud-api'
+          ui.error("--extended-logs option works with --bootstrap-protocol cloud-api")
+          exit 1
+        end
       end
 
       def create_server_def
@@ -945,7 +661,7 @@ class Chef
 
         server_def[:port] = port
 
-        server_def[:is_vm_image] = connection.images.is_vm_image(locate_config_value(:azure_source_image))
+        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)
 
         if locate_config_value(:azure_domain_user)
@@ -969,103 +685,8 @@ class Chef
         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
-      end
-
-      def get_chef_extension_name
-        extension_name = is_image_windows? ? "ChefClient" : "LinuxChefClient"
-      end
-
-      def get_chef_extension_publisher
-        publisher = "Chef.Bootstrap.WindowsAzure"
-      end
-
-      # get latest version
-      def get_chef_extension_version
-        if locate_config_value(:azure_chef_extension_version)
-          Chef::Config[:knife][:azure_chef_extension_version]
-        else
-          extensions = @connection.query_azure("resourceextensions/#{get_chef_extension_publisher}/#{get_chef_extension_name}")
-          extensions.css("Version").max.text.split(".").first + ".*"
-        end
-      end
-
-      def get_chef_extension_public_params
-        pub_config = Hash.new
-        if(locate_config_value(:azure_extension_client_config))
-          pub_config[:client_rb] = File.read(locate_config_value(: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[:autoUpdateClient] = locate_config_value(:auto_update_client) ? "true" : "false"
-        pub_config[:deleteChefConfig] = locate_config_value(:delete_chef_extension_config) ? "true" : "false"
-        pub_config[:custom_json_attr] = locate_config_value(:json_attributes) || {}
-
-        # 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] = config[:chef_node_name] if config[:chef_node_name]
-        pub_config[:bootstrap_options][:encrypted_data_bag_secret] = locate_config_value(:encrypted_data_bag_secret) if locate_config_value(:encrypted_data_bag_secret)
-        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)
-        Base64.encode64(pub_config.to_json)
-      end
-
-      def get_chef_extension_private_params
-        pri_config = Hash.new
 
-        # validator less bootstrap support for bootstrap protocol cloud-api
-        if (Chef::Config[:validation_key] && !File.exist?(File.expand_path(Chef::Config[:validation_key])))
-
-          if Chef::VERSION.split('.').first.to_i == 11
-            ui.error('Unable to find validation key. Please verify your configuration file for validation_key config value.')
-            exit 1
-          end
-
-          client_builder = Chef::Knife::Bootstrap::ClientBuilder.new(
-            chef_config: Chef::Config,
-            knife_config: config,
-            ui: ui,
-          )
-
-          client_builder.run
-          key_path = client_builder.client_path
-          pri_config[:client_pem] = File.read(key_path)
-        else
-          pri_config[:validation_key] = File.read(Chef::Config[:validation_key])
-        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(locate_config_value(:cert_path))
-          else
-            ui.error('Specified SSL certificate does not exist.')
-            exit 1
-          end
-        end
-        Base64.encode64(pri_config.to_json)
-      end
-
-      def cleanup_and_exit(remove_hosted_service_on_failure, remove_storage_service_on_failure)
-        ui.warn("Cleaning up resources...")
-
-        if remove_hosted_service_on_failure
-          ret_val = connection.hosts.delete(remove_hosted_service_on_failure)
-          ret_val.content.empty? ? ui.warn("Deleted created DNS: #{remove_hosted_service_on_failure}.") : ui.warn("Deletion failed for created DNS:#{remove_hosted_service_on_failure}. " + ret_val.text)
-        end
-
-        if remove_storage_service_on_failure
-          ret_val = connection.storageaccounts.delete(remove_storage_service_on_failure)
-          ret_val.content.empty? ? ui.warn("Deleted created Storage Account: #{remove_storage_service_on_failure}.") : ui.warn("Deletion failed for created Storage Account: #{remove_storage_service_on_failure}. " + ret_val.text)
-        end
-        exit 1
+        server_def
       end
 
       private