knife-azure 1.3.0 → 1.4.0.rc.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NWQxYTRjNmM1YmEwZmU2M2E1Y2M3NGU2YzkzNzIyNTE4OTFkMzQwOQ==
+    NDRlZjIwNmQwNWU1NzVlYzA4NGI3MzNjZTJlNmZkMmNlZmEwZDZiNg==
   data.tar.gz: !binary |-
-    MGFhNjQxYTFmZjVjMjFkODZiZGI4NDY2ZGFjOWYyMDFlNTNkOTI0ZA==
+    MDgxYzQ2YTU2NGFlZDA0ZmE3MmM0M2UzM2NkNzFlZGZkNWU3MzQyYg==
 SHA512:
   metadata.gz: !binary |-
-    MmZmM2Q0ZTIwODUxZTRiN2FlNmY5ZjFlZmUxMGFlZDFkMjhiODhhYjBkYmY0
-    MGVlYzA5NjdkNmZhMTY0ZDY2N2E1ODU3M2M4NzAwYjFiMDlmY2Q2ZDM1YjQ0
-    MzlkNjBjOWZiNGUxNTg1ZGE4ZDRmODcxNzRjODMyNTYyODcwOTQ=
+    MGIxZTg3ZDEzN2ZlNmIzMzhlYTRhZjdlYjY5OTVkMzRkZDNjMWYzZDBiZjFh
+    NzlhNjRlMTE3ZTQwMGUwYjQxNTc4NDY3ZDNhZDVkZThjMmFlODgwNGZiYWM0
+    MDY0YWRiMmQ5OTYwNjBmZGE3YWY3ZGU2OGFmMWRmZGNjOGM5YWE=
   data.tar.gz: !binary |-
-    NTZhYmViMTFhNDk1N2RiZTE0OTk2NzIzZDU3YjQ4YTQ0NGRlZTc3MjhmNTdm
-    NTVjMDZlOTNjMjJmYTYxZTcyNGU4MzVhY2UxMTUyYjgyOTc4YmViZjdiY2Yx
-    OTgxZGJkYmRlZDhlZTdhODliNGQ4ZGZhMTY0NzhiOWYyM2JlZTE=
+    NTlkMTM2Mjc3NDQ3ZmNmNmZlOGQwYzk2MGJhM2EyYWIxMjljYzNiMzIxMWU2
+    NTY0NDE3MTk2MjBhOGVmZTA5MzY0YWZiMWJjY2E0MmJmNTBiY2IyMzNmZDlm
+    ZjQ4YWQxYTAxMDZlMWYwYjhiYTdmMGFhZTEwNTcxZjMzZWY2MzY=

data/README.md

@@ -48,7 +48,7 @@ location in your knife.rb:
       $ knife azure server list
   
       # Create and bootstrap an Ubuntu VM over ssh
-      $ knife azure server create -N MyNewNode --azure-vm-size Medium --I 8fcc3d_Ubuntu-12_04-amd64-30GB -m 'West US' --ssh-user myuser --identity-file ~/.ssh/myprivatekey_rsa
+      $ knife azure server create -N MyNewNode --azure-vm-size Medium -I b39f27a8b8c64d52b05eac6a62ebad85__Ubuntu-14_04_1-LTS-amd64-server-20140927-en-us-30GB -m 'West US' --ssh-user myuser --identity-file ~/.ssh/myprivatekey_rsa
   
       # Create and bootstrap a Windows VM over winrm
       $ knife azure server create --azure-dns-name MyNewServerName --azure-vm-size Medium --azure-source-image 8fcc3d_Win2012-amd64-30GB --azure-service-location 'West US' --winrm-user myuser --winrm-password 'mypassword' --bootstrap-protocol winrm --distro 'windows-chef-client-msi'
@@ -182,8 +182,8 @@ These options may also be configured from knife.rb, as in this example:
     knife[:identity_file]='/path/to/RSA/private/key'
     knife[:azure_storage_account]='auxpreview104'
     knife[:azure_os_disk_name]='disk107'
-    knife[:tcp_endpoints]='66'
-    knife[:udp_endpoints]='77,88,99'
+    knife[:tcp-endpoints]='80:80,3389:5678'
+    knife[:udp-endpoints]='123:123'
 
 #### Options for Bootstrapping a Windows Node in Azure
 

data/lib/azure/certificate.rb

@@ -25,6 +25,10 @@ class Azure
       certificate = Certificate.new(@connection)
       certificate.create(params)
     end
+    def add(certificate_data, certificate_password, certificate_format, dns_name)
+      certificate = Certificate.new(@connection)
+      certificate.add_certificate certificate_data, certificate_password, certificate_format, dns_name
+    end
   end
 end
 
@@ -41,17 +45,7 @@ class Azure
       # public part of the key
       @cert_data = generate_public_key_certificate_data({:ssh_key => params[:identity_file],
                                              :ssh_key_passphrase => params[:identity_file_passphrase]})
-      # Generate XML to call the API
-      # Add certificate to the hosted service
-      builder = Nokogiri::XML::Builder.new do |xml|
-        xml.CertificateFile('xmlns'=>'http://schemas.microsoft.com/windowsazure') {
-          xml.Data @cert_data
-          xml.CertificateFormat 'pfx'
-          xml.Password 'knifeazure'
-        }
-      end
-      # Windows Azure API call
-      @connection.query_azure("hostedservices/#{params[:azure_dns_name]}/certificates", "post", builder.to_xml)
+      add_certificate @cert_data, 'knifeazure', 'pfx', params[:azure_dns_name]
       # Return the fingerprint to be used while adding role
       @fingerprint
     end
@@ -83,5 +77,20 @@ class Azure
       # Encode the pfx format - upload this certificate
       Base64.strict_encode64(pfx.to_der)
     end
+
+    def add_certificate certificate_data, certificate_password, certificate_format, dns_name
+       # Generate XML to call the API
+       # Add certificate to the hosted service
+       builder = Nokogiri::XML::Builder.new do |xml|
+         xml.CertificateFile('xmlns'=>'http://schemas.microsoft.com/windowsazure') {
+         xml.Data certificate_data
+         xml.CertificateFormat certificate_format
+         xml.Password certificate_password
+         }
+       end
+       # Windows Azure API call
+       @connection.query_azure("hostedservices/#{dns_name}/certificates", "post", builder.to_xml)
+    end
+
   end
 end

data/lib/azure/deploy.rb

@@ -78,6 +78,10 @@ class Azure
       if params[:identity_file]
         params[:fingerprint] = @connection.certificates.create(params)
       end
+      if params[:cert_path]
+        cert_data = File.read (params[:cert_path])
+        @connection.certificates.add cert_data, params[:cert_password], 'pfx', params[:azure_dns_name]
+      end
       params['deploy_name'] = get_deploy_name_for_hostedservice(params[:azure_dns_name])
 
       if params['deploy_name'] != nil
@@ -99,7 +103,7 @@ class Azure
     end
     def delete(rolename)
     end
-    
+
     def queryDeploy(hostedservicename)
         deploy = Deploy.new(@connection)
         deploy.retrieve(hostedservicename)

data/lib/azure/image.rb

@@ -23,23 +23,51 @@ class Azure
     end
     def load
       @images ||= begin
-        images = Hash.new
+        osimages = self.get_images("OSImage")   #get OSImages
+        vmimages = self.get_images("VMImage")   #get VMImages
+
+        all_images = osimages.merge(vmimages)
+      end
+    end
+
+    def all
+      self.load.values
+    end
+
+    # img_type = OSImages or VMImage
+    def get_images(img_type)
+      images = Hash.new
+
+      if(img_type == "OSImage")
         response = @connection.query_azure('images')
-        osimages = response.css('OSImage')
+      elsif(img_type == "VMImage")
+        response = @connection.query_azure('vmimages')
+      end
+
+      unless response.to_s.empty?
+        osimages = response.css(img_type)
+
         osimages.each do |image|
           item = Image.new(image)
           images[item.name] = item
         end
-        images
       end
+
+      images
     end
 
-    def all
-      self.load.values
+    def is_os_image(image_name)
+      os_images = self.get_images("OSImage").values
+      os_images.detect {|img| img.name == image_name} ? true : false
+    end
+
+    def is_vm_image(image_name)
+      vm_images = self.get_images("VMImage").values
+      vm_images.detect {|img| img.name == image_name} ? true : false
     end
 
     def exists?(name)
-      self.all.key?(name)
+      self.all.detect {|img| img.name == name} ? true : false
     end
 
     def find(name)

data/lib/azure/rest.rb

@@ -97,7 +97,7 @@ module AzureAPI
         request = Net::HTTP::Put.new(uri.request_uri)
       end
       text = verb == 'put'
-      request["x-ms-version"] = "2013-08-01"
+      request["x-ms-version"] = "2014-04-01"
       request["content-type"] = text ? "text/plain" : "application/xml"
       request["accept"] = "application/xml"
       request["accept-charset"] = "utf-8"

data/lib/azure/role.rb

@@ -16,6 +16,7 @@
 # limitations under the License.
 #
 require 'securerandom'
+
 class Azure
   class Roles
     include AzureUtility
@@ -100,7 +101,7 @@ class Azure
       if alone_on_hostedservice(role)
         if !params[:preserve_azure_dns_name] && compmedia
           servicecall = "hostedservices/#{role.hostedservicename}"
-        else 
+        else
           servicecall = "hostedservices/#{role.hostedservicename}/deployments/#{role.deployname}"
         end
       else
@@ -127,7 +128,7 @@ class Azure
         for attempt in 0..12
            break if @connection.query_azure(servicecall, "get").search("AttachedTo").text == ""
            if attempt == 12 then puts "The associated disk could not be deleted due to time out." else sleep 25 end
-        end    
+        end
         unless params[:preserve_azure_vhd]
           @connection.query_azure(servicecall, 'delete', '', 'comp=media', wait=params[:wait])
         else
@@ -142,7 +143,7 @@ class Azure
           roles_using_same_service = find_roles_within_hostedservice(params[:azure_dns_name])
           if roles_using_same_service.size <= 1
             servicecall = "hostedservices/" + params[:azure_dns_name]
-            @connection.query_azure(servicecall, "delete")        
+            @connection.query_azure(servicecall, "delete")
           end
         end
       end
@@ -219,122 +220,176 @@ class Azure
           xml.RoleName {xml.text params[:azure_vm_name]}
           xml.OsVersion('i:nil' => 'true')
           xml.RoleType 'PersistentVMRole'
+          xml.VMImageName params[:azure_source_image] if params[:is_vm_image]
+
           xml.ConfigurationSets {
             if params[:os_type] == 'Linux'
-
               xml.ConfigurationSet('i:type' => 'LinuxProvisioningConfigurationSet') {
-              xml.ConfigurationSetType 'LinuxProvisioningConfiguration'
-              xml.HostName params[:azure_vm_name]
-              xml.UserName params[:ssh_user]
-              unless params[:identity_file].nil?
-                xml.DisableSshPasswordAuthentication 'true'
-                xml.SSH {
-                   xml.PublicKeys {
-                     xml.PublicKey {
-                       xml.Fingerprint params[:fingerprint].to_s.upcase
-                       xml.Path '/home/' + params[:ssh_user] + '/.ssh/authorized_keys'
+                xml.ConfigurationSetType 'LinuxProvisioningConfiguration'
+                xml.HostName params[:azure_vm_name]
+                xml.UserName params[:ssh_user]
+                unless params[:identity_file].nil?
+                  xml.DisableSshPasswordAuthentication 'true'
+                  xml.SSH {
+                     xml.PublicKeys {
+                       xml.PublicKey {
+                         xml.Fingerprint params[:fingerprint].to_s.upcase
+                         xml.Path '/home/' + params[:ssh_user] + '/.ssh/authorized_keys'
+                       }
                      }
-                   }
-                }
-              else
-                xml.UserPassword params[:ssh_password]
-                xml.DisableSshPasswordAuthentication 'false'
-              end
+                  }
+                else
+                  xml.UserPassword params[:ssh_password]
+                  xml.DisableSshPasswordAuthentication 'false'
+                end
               }
             elsif params[:os_type] == 'Windows'
               xml.ConfigurationSet('i:type' => 'WindowsProvisioningConfigurationSet') {
-              xml.ConfigurationSetType 'WindowsProvisioningConfiguration'
-              xml.ComputerName params[:azure_vm_name]
-              xml.AdminPassword params[:admin_password]
-              xml.ResetPasswordOnFirstLogon 'false'
-              xml.EnableAutomaticUpdates 'false'
-              xml.AdminUsername params[:winrm_user]
-              if params[:bootstrap_proto].downcase == 'winrm'
-                xml.WinRM {
-                  xml.Listeners {
-                    xml.Listener {
-                      xml.Protocol 'Http'
+                xml.ConfigurationSetType 'WindowsProvisioningConfiguration'
+                xml.ComputerName params[:azure_vm_name]
+                xml.AdminPassword params[:admin_password]
+                xml.ResetPasswordOnFirstLogon 'false'
+                xml.EnableAutomaticUpdates 'false'
+                  if params[:bootstrap_proto].downcase == 'winrm'
+                    if params[:ssl_cert_fingerprint]
+                      xml.StoredCertificateSettings {
+                        xml.CertificateSetting {
+                          xml.StoreLocation "LocalMachine"
+                          xml.StoreName "My"
+                          xml.Thumbprint params[:ssl_cert_fingerprint]
+                        }
+                      }
+                    end
+                    xml.WinRM {
+                      xml.Listeners {
+                       if params[:ssl_cert_fingerprint]
+                        xml.Listener {
+                          xml.CertificateThumbprint params[:ssl_cert_fingerprint]
+                          xml.Protocol 'Https'
+                        }
+                        else
+                        xml.Listener {
+                          xml.Protocol 'Http'
+                        }
+                        end
+                      }
                     }
-                  }
-                }
-              end
+                  end
+                xml.AdminUsername params[:winrm_user]
               }
             end
 
-          xml.ConfigurationSet('i:type' => 'NetworkConfigurationSet') {
-            xml.ConfigurationSetType 'NetworkConfiguration'
-            xml.InputEndpoints {
-              if params[:bootstrap_proto].downcase == 'ssh'
-                xml.InputEndpoint {
-                xml.LocalPort '22'
-                xml.Name 'SSH'
-                xml.Port params[:port]
-                xml.Protocol 'TCP'
-              }
-              elsif params[:bootstrap_proto].downcase == 'winrm' and params[:os_type] == 'Windows'
-                xml.InputEndpoint {
+            xml.ConfigurationSet('i:type' => 'NetworkConfigurationSet') {
+              xml.ConfigurationSetType 'NetworkConfiguration'
+              xml.InputEndpoints {
+
+                if params[:os_type] == 'Windows' and (params[:bootstrap_proto].downcase == 'winrm' or params[:bootstrap_proto].downcase == 'cloud-api')
+                  xml.InputEndpoint {
                   xml.LocalPort '5985'
                   xml.Name 'WinRM'
                   xml.Port params[:port]
                   xml.Protocol 'TCP'
                 }
-              end
-
-            if params[:tcp_endpoints]
-              params[:tcp_endpoints].split(',').each do |endpoint|
-                ports = endpoint.split(':')
-                if !(ports.length > 1 && ports[1] == params[:port] || ports.length == 1 && ports[0] == params[:port])
+                else
                   xml.InputEndpoint {
-                    xml.LocalPort ports[0]
-                    xml.Name 'tcpport_' + ports[0] + '_' + params[:azure_vm_name]
-                    if ports.length > 1
-                      xml.Port ports[1]
+                  xml.LocalPort '22'
+                  xml.Name 'SSH'
+                  xml.Port params[:port]
+                  xml.Protocol 'TCP'
+                }
+                end
+
+                if params[:tcp_endpoints]
+                  params[:tcp_endpoints].split(',').each do |endpoint|
+                    ports = endpoint.split(':')
+                    if !(ports.length > 1 && ports[1] == params[:port] || ports.length == 1 && ports[0] == params[:port])
+                      xml.InputEndpoint {
+                        xml.LocalPort ports[0]
+                        xml.Name 'tcpport_' + ports[0] + '_' + params[:azure_vm_name]
+                        if ports.length > 1
+                          xml.Port ports[1]
+                        else
+                          xml.Port ports[0]
+                        end
+                        xml.Protocol 'TCP'
+                      }
                     else
-                      xml.Port ports[0]
+                      warn_message = ports.length > 1 ? "#{ports.join(':')} because this ports are" : "#{ports[0]} because this port is"
+                      puts("Skipping tcp-endpoints: #{warn_message} already in use by ssh/winrm endpoint in current VM.")
                     end
-                    xml.Protocol 'TCP'
-                  }
-                else
-                  warn_message = ports.length > 1 ? "#{ports.join(':')} because this ports are" : "#{ports[0]} because this port is"
-                  puts("Skipping tcp-endpoints: #{warn_message} already in use by ssh/winrm endpoint in current VM.")
+                  end
                 end
-              end
-            end
 
-            if params[:udp_endpoints]
-              params[:udp_endpoints].split(',').each do |endpoint|
-                ports = endpoint.split(':')
-                xml.InputEndpoint {
-                  xml.LocalPort ports[0]
-                  xml.Name 'udpport_' + ports[0] + '_' + params[:azure_vm_name]
-                  if ports.length > 1
-                    xml.Port ports[1]
-                  else
-                    xml.Port ports[0]
+                if params[:udp_endpoints]
+                  params[:udp_endpoints].split(',').each do |endpoint|
+                    ports = endpoint.split(':')
+                    xml.InputEndpoint {
+                      xml.LocalPort ports[0]
+                      xml.Name 'udpport_' + ports[0] + '_' + params[:azure_vm_name]
+                      if ports.length > 1
+                        xml.Port ports[1]
+                      else
+                        xml.Port ports[0]
+                      end
+                      xml.Protocol 'UDP'
+                    }
                   end
-                  xml.Protocol 'UDP'
+                end
+              }
+              if params[:azure_subnet_name]
+                xml.SubnetNames {
+                  xml.SubnetName params[:azure_subnet_name]
                 }
               end
-            end
             }
-            if params[:azure_subnet_name]
-              xml.SubnetNames {
-                xml.SubnetName params[:azure_subnet_name]
-              }
-            end
-          }
           }
+
           if params[:azure_availability_set]
             xml.AvailabilitySetName params[:azure_availability_set]
           end
+          # Azure resource extension support
+          if params[:bootstrap_proto] == 'cloud-api'
+            xml.ResourceExtensionReferences {
+              xml.ResourceExtensionReference {
+                xml.ReferenceName params[:chef_extension]
+                xml.Publisher params[:chef_extension_publisher]
+                xml.Name params[:chef_extension]
+                xml.Version params[:chef_extension_version]
+                xml.ResourceExtensionParameterValues {
+                  if params[:chef_extension_public_param]
+                    xml.ResourceExtensionParameterValue {
+                      xml.Key "PublicParams"
+                      xml.Value params[:chef_extension_public_param]
+                      xml.Type "Public"
+                    }
+                  end
+                  if params[:chef_extension_private_param]
+                    xml.ResourceExtensionParameterValue {
+                      xml.Key "PrivateParams"
+                      xml.Value params[:chef_extension_private_param]
+                      xml.Type "Private"
+                    }
+                  end
+                }
+                xml.State "Enable"
+              }
+            }
+          end
+
           xml.Label Base64.encode64(params[:azure_vm_name]).strip
-          xml.OSVirtualHardDisk {
-            disk_name = params[:azure_os_disk_name] || "disk_" + SecureRandom.uuid
-            xml.DiskName disk_name
-            xml.MediaLink 'http://' + params[:azure_storage_account] + '.blob.core.windows.net/vhds/' + disk_name + '.vhd'
-            xml.SourceImageName params[:azure_source_image]
-          }
+
+          #OSVirtualHardDisk not required in case azure_source_image is a VMImage
+          unless(params[:is_vm_image])
+            xml.OSVirtualHardDisk {
+              disk_name = params[:azure_os_disk_name] || "disk_" + SecureRandom.uuid
+              xml.DiskName disk_name
+              xml.MediaLink 'http://' + params[:azure_storage_account] + '.blob.core.windows.net/vhds/' + disk_name + '.vhd'
+              xml.SourceImageName params[:azure_source_image]
+            }
+          end
+
           xml.RoleSize params[:azure_vm_size]
+          xml.ProvisionGuestAgent true if params[:bootstrap_proto] == 'cloud-api'
         }
       end
       builder.doc

data/lib/chef/knife/azure_image_list.rb

@@ -44,8 +44,8 @@ class Chef
 
         validate!
 
-        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)}          
+        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 }
@@ -54,7 +54,7 @@ class Chef
         end
 
         puts "\n"
-        puts h.list(image_list, :uneven_columns_across, !locate_config_value(:show_all_fields) ? 3 : 5) 
+        puts h.list(image_list, :uneven_columns_across, !locate_config_value(:show_all_fields) ? 3 : 5)
 
       end
     end

data/lib/chef/knife/azure_server_create.rb

@@ -40,7 +40,6 @@ class Chef
 
       def load_winrm_deps
         require 'winrm'
-        require 'em-winrm'
         require 'chef/knife/winrm'
         require 'chef/knife/bootstrap_windows_winrm'
       end
@@ -51,7 +50,7 @@ class Chef
 
       option :bootstrap_protocol,
         :long => "--bootstrap-protocol protocol",
-        :description => "Protocol to bootstrap windows servers. options: winrm/ssh",
+        :description => "Protocol to bootstrap windows servers. options: 'winrm' or 'ssh' or 'cloud-api'.",
         :default => "winrm"
 
       option :chef_node_name,
@@ -62,7 +61,8 @@ class Chef
       option :ssh_user,
         :short => "-x USERNAME",
         :long => "--ssh-user USERNAME",
-        :description => "The ssh username"
+        :description => "The ssh username",
+        :default => "root"
 
       option :ssh_password,
         :short => "-P PASSWORD",
@@ -167,12 +167,12 @@ class Chef
       option :tcp_endpoints,
         :short => "-t PORT_LIST",
         :long => "--tcp-endpoints PORT_LIST",
-        :description => "Comma separated list of TCP local and public ports to open i.e. '80:80,433:5000'"
+        :description => "Comma-separated list of TCP local and public ports to open e.g. '80:80,433:5000'"
 
       option :udp_endpoints,
         :short => "-u PORT_LIST",
         :long => "--udp-endpoints PORT_LIST",
-        :description => "Comma separated list of UDP local and public ports to open i.e. '80:80,433:5000'"
+        :description => "Comma-separated list of UDP local and public ports to open e.g. '80:80,433:5000'"
 
       option :azure_connect_to_existing_dns,
         :short => "-c",
@@ -213,6 +213,18 @@ class Chef
         :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"
+
+      option :cert_passphrase,
+        :long => "--cert-passphrase PASSWORD",
+        :description => "SSL Certificate Password"
+
+      option :cert_path,
+        :long => "--cert-path PATH",
+        :description => "SSL Certificate Path"
+
       def strip_non_ascii(string)
         string.gsub(/[^0-9a-z ]/i, '')
       end
@@ -222,6 +234,7 @@ class Chef
       end
 
       def wait_until_virtual_machine_ready(retry_interval_in_seconds = 30)
+
         vm_status = nil
         puts
 
@@ -230,6 +243,24 @@ class Chef
           if vm_status != :vm_status_ready
             wait_for_virtual_machine_state(:vm_status_ready, 15, retry_interval_in_seconds)
           end
+
+          msg_server_summary(get_role_server())
+
+          if locate_config_value(:bootstrap_protocol) == "cloud-api"
+            extension_status = wait_for_resource_extension_state(:wagent_provisioning, 5, retry_interval_in_seconds)
+
+            if extension_status != :extension_installing
+              extension_status = wait_for_resource_extension_state(:extension_installing, 5, retry_interval_in_seconds)
+            end
+
+            if extension_status != :extension_provisioning
+              extension_status = wait_for_resource_extension_state(:extension_provisioning, 10, retry_interval_in_seconds)
+            end
+
+            if extension_status != :extension_ready
+              wait_for_resource_extension_state(:extension_ready, 5, retry_interval_in_seconds)
+            end
+          end
         rescue Exception => e
           Chef::Log.error("#{e.to_s}")
           raise 'Verify connectivity to Azure and subscription resource limit compliance (e.g. maximum CPU core limits) and try again.'
@@ -265,6 +296,37 @@ class Chef
         vm_status
       end
 
+      def wait_for_resource_extension_state(extension_status_goal, total_wait_time_in_minutes, retry_interval_in_seconds)
+
+        extension_status_ordering = {:extension_status_not_detected => 0, :wagent_provisioning => 1, :extension_installing => 2, :extension_provisioning => 3, :extension_ready => 4}
+
+        status_description = {:extension_status_not_detected => 'any', :wagent_provisioning => 'wagent provisioning', :extension_installing => "installing", :extension_provisioning => "provisioning", :extension_ready => "ready" }
+
+        print ui.color("Waiting for Resource Extension to reach status '#{status_description[extension_status_goal]}'", :magenta)
+
+        max_polling_attempts = (total_wait_time_in_minutes * 60) / retry_interval_in_seconds
+        polling_attempts = 0
+
+        wait_start_time = Time.now
+
+        begin
+          extension_status = get_extension_status()
+          extension_ready = extension_status_ordering[extension_status[:status]] >= extension_status_ordering[extension_status_goal]
+          print '.'
+          sleep retry_interval_in_seconds if !extension_ready
+          polling_attempts += 1
+        end until extension_ready || polling_attempts >= max_polling_attempts
+
+        if ! extension_ready
+          raise Chef::Exceptions::CommandTimeout, "Resource extension state '#{status_description[extension_status_goal]}' not reached after #{total_wait_time_in_minutes} minutes. #{extension_status[:message]}"
+        end
+
+        elapsed_time_in_minutes = ((Time.now - wait_start_time) / 60).round(2)
+        print ui.color("Resource extension state '#{status_description[extension_status_goal]}' reached after #{elapsed_time_in_minutes} minutes.\n", :cyan)
+
+        extension_status[:status]
+      end
+
       def get_virtual_machine_status()
         role = get_role_server()
         unless role.nil?
@@ -280,6 +342,53 @@ class Chef
         return :vm_status_not_detected
       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}")
+        extension_status = Hash.new
+
+        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)
+              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"
+                extn_status = role.at_css("ResourceExtensionStatusList Status").text
+
+                Chef::Log.debug("Resource extension status is #{extn_status}")
+
+                if extn_status == "Installing"
+                  extension_status[:status] = :extension_installing
+                  extension_status[:message] = role.at_css("ResourceExtensionStatusList FormattedMessage Message").text
+                elsif extn_status == "NotReady"
+                  extension_status[:status] = :extension_provisioning
+                  extension_status[:message] = role.at_css("ResourceExtensionStatusList FormattedMessage Message").text
+                elsif extn_status == "Ready"
+                  extension_status[:status] = :extension_ready
+                  extension_status[:message] = role.at_css("ResourceExtensionStatusList FormattedMessage Message").text
+                else
+                  extension_status[:status] = :extension_status_not_detected
+                end
+              # This fix is for linux waagent issue: api unable to deserialize the waagent status.
+              elsif role.at_css("GuestAgentStatus Status").text == "NotReady" and waagent_status_msg == lnx_waagent_fail_msg
+                extension_status[:status] = :extension_ready
+              else
+                extension_status[:status] = :wagent_provisioning
+                extension_status[:message] = role.at_css("GuestAgentStatus Message").text
+              end
+            else
+              extension_status[:status] = :extension_status_not_detected
+            end
+          end
+        else
+          extension_status[:status] = :extension_status_not_detected
+        end
+
+        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))
@@ -341,6 +450,8 @@ class Chef
         Chef::Log.info("validating...")
         validate!
 
+        ssh_override_winrm if %w(ssh cloud-api).include?(locate_config_value(:bootstrap_protocol)) and !is_image_windows?
+
         Chef::Log.info("creating...")
 
         config[:azure_dns_name] = get_dns_name(locate_config_value(:azure_dns_name))
@@ -352,7 +463,7 @@ class Chef
         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
@@ -369,14 +480,13 @@ class Chef
             remove_storage_service_on_failure = nil
           else
             remove_storage_service_on_failure = locate_config_value(:azure_storage_account)
-          end   
+          end
         end
 
         begin
           connection.deploys.create(create_server_def)
           wait_until_virtual_machine_ready()
           server = get_role_server()
-          fqdn = server.publicipaddress
         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")}"
@@ -386,6 +496,12 @@ class Chef
 
         msg_server_summary(server)
 
+        bootstrap_exec(server) unless locate_config_value(:bootstrap_protocol) == 'cloud-api'
+      end
+
+      def bootstrap_exec(server)
+        fqdn = server.publicipaddress
+
         if is_image_windows?
           # Set distro to windows-chef-client-msi
           config[:distro] = "windows-chef-client-msi" if (config[:distro].nil? || config[:distro] == "chef-full")
@@ -409,7 +525,7 @@ class Chef
               puts("done")
             }
           end
-        
+
           puts("\n")
           bootstrap_for_windows_node(server,fqdn, port).run
         else
@@ -461,7 +577,6 @@ class Chef
         bootstrap
       end
 
-
       def bootstrap_for_windows_node(server, fqdn, port)
         if locate_config_value(:bootstrap_protocol) == 'winrm'
 
@@ -523,15 +638,31 @@ class Chef
               :azure_source_image,
               :azure_vm_size,
         ])
+
+        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
+        end
+
+        if locate_config_value(:ssh_password) and (locate_config_value(:ssh_password).length <= 6 and locate_config_value(:ssh_password).length >= 72)
+          ui.error("The supplied password must be 6-72 characters long and meet password complexity requirements")
+          exit 1
+        end
+
         if locate_config_value(:azure_connect_to_existing_dns) && locate_config_value(:azure_vm_name).nil?
           ui.error("Specify the VM name using --azure-vm-name option, since you are connecting to existing dns")
           exit 1
         end
         if locate_config_value(:azure_service_location) && locate_config_value(:azure_affinity_group)
-          ui.error("Cannot specify both --azure_service_location and --azure_affinity_group, use one or the other.")
+          ui.error("Cannot specify both --azure-service-location and --azure-affinity-group, use one or the other.")
           exit 1
         elsif locate_config_value(:azure_service_location).nil? && locate_config_value(:azure_affinity_group).nil?
-          ui.error("Must specify either --azure_service_location or --azure_affinity_group.")
+          ui.error("Must specify either --azure-service-location or --azure-affinity-group.")
+          exit 1
+        end
+
+        if !(connection.images.exists?(locate_config_value(:azure_source_image)))
+          ui.error("Image provided is invalid")
           exit 1
         end
       end
@@ -553,58 +684,101 @@ class Chef
           :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)
+          :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)
         }
         # If user is connecting a new VM to an existing dns, then
         # the VM needs to have a unique public port. Logic below takes care of this.
         if !is_image_windows? or locate_config_value(:bootstrap_protocol) == 'ssh'
           port = locate_config_value(:ssh_port) || '22'
           if locate_config_value(:azure_connect_to_existing_dns) && (port == '22')
-             port = Random.rand(64000) + 1000
+            port = Random.rand(64000) + 1000
           end
         else
           port = locate_config_value(:winrm_port) || '5985'
           if locate_config_value(:azure_connect_to_existing_dns) && (port == '5985')
-              port = Random.rand(64000) + 1000
+            port = Random.rand(64000) + 1000
           end
         end
+
         server_def[:port] = port
 
+        if locate_config_value(:bootstrap_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
+          server_def[:chef_extension_public_param] = get_chef_extension_public_params
+          server_def[:chef_extension_private_param] = get_chef_extension_private_params
+        else
+          if is_image_windows?
+            if not locate_config_value(:winrm_password) or not locate_config_value(:bootstrap_protocol)
+              ui.error("WinRM Password and Bootstrapping Protocol are compulsory parameters")
+              exit 1
+            end
+            # 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(:winrm_user).nil? || locate_config_value(:winrm_user).downcase =~ /admin*/
+              ui.error("WinRM User is compulsory parameter and it cannot be named 'admin*'")
+              exit 1
+            end
+          else
+            if not locate_config_value(:ssh_user)
+              ui.error("SSH User is compulsory parameter")
+              exit 1
+            end
+            unless locate_config_value(:ssh_password) or locate_config_value(:identity_file)
+              ui.error("Specify either SSH Key or SSH Password")
+              exit 1
+            end
+          end
+        end
         if is_image_windows?
           server_def[:os_type] = 'Windows'
-          if not locate_config_value(:winrm_password) or not locate_config_value(:bootstrap_protocol)
-            ui.error("WinRM Password and Bootstrapping Protocol are compulsory parameters")
-            exit 1
-          end
-          # 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(:winrm_user).nil? || locate_config_value(:winrm_user).downcase =~ /admin*/
-            ui.error("WinRM User is compulsory parameter and it cannot be named 'admin*'")
-            exit
-          end
           server_def[:admin_password] = locate_config_value(:winrm_password)
           server_def[:bootstrap_proto] = locate_config_value(:bootstrap_protocol)
         else
           server_def[:os_type] = 'Linux'
-          server_def[:bootstrap_proto] = 'ssh'
-          if not locate_config_value(:ssh_user)
-            ui.error("SSH User is compulsory parameter")
-            exit 1
-          end
-          unless locate_config_value(:ssh_password) or locate_config_value(:identity_file)
-              ui.error("Specify either SSH Key or SSH Password")
-              exit 1
-          end
-
+          server_def[:bootstrap_proto] =  locate_config_value(:bootstrap_protocol) || 'ssh'
           server_def[:ssh_user] = locate_config_value(:ssh_user)
           server_def[:ssh_password] = locate_config_value(:ssh_password)
           server_def[:identity_file] = locate_config_value(:identity_file)
           server_def[:identity_file_passphrase] = locate_config_value(:identity_file_passphrase)
         end
+
+        server_def[:is_vm_image] = connection.images.is_vm_image(locate_config_value(:azure_source_image))
         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
+        extensions = @connection.query_azure("resourceextensions/#{get_chef_extension_publisher}/#{get_chef_extension_name}")
+        extensions.css("Version").max.text.to_f
+      end
+
+      def get_chef_extension_public_params
+        pub_config = Hash.new
+        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}"
+        pub_config[:runlist] = locate_config_value(:run_list).empty? ? "" : locate_config_value(:run_list).join(",").to_json
+        Base64.encode64(pub_config.to_json)
+      end
+
+      def get_chef_extension_private_params
+        pri_config = Hash.new
+        pri_config[:validation_key] = File.read(Chef::Config[:validation_key])
+        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...")
 
@@ -619,8 +793,32 @@ class Chef
         end
         exit 1
       end
-      
+
       private
+
+      def ssh_override_winrm
+        # unchanged ssh_user and changed winrm_user, override ssh_user
+        if locate_config_value(:ssh_user).eql?(options[:ssh_user][:default]) &&
+            !locate_config_value(:winrm_user).eql?(options[:winrm_user][:default])
+          config[:ssh_user] = locate_config_value(:winrm_user)
+        end
+        # unchanged ssh_port and changed winrm_port, override ssh_port
+        if locate_config_value(:ssh_port).eql?(options[:ssh_port][:default]) &&
+            !locate_config_value(:winrm_port).eql?(options[:winrm_port][:default])
+          config[:ssh_port] = locate_config_value(:winrm_port)
+        end
+        # unset ssh_password and set winrm_password, override ssh_password
+        if locate_config_value(:ssh_password).nil? &&
+            !locate_config_value(:winrm_password).nil?
+          config[:ssh_password] = locate_config_value(:winrm_password)
+        end
+        # unset identity_file and set kerberos_keytab_file, override identity_file
+        if locate_config_value(:identity_file).nil? &&
+            !locate_config_value(:kerberos_keytab_file).nil?
+          config[:identity_file] = locate_config_value(:kerberos_keytab_file)
+        end
+      end
+
       # This is related to Windows VM's specifically and computer name
       # length limits for legacy computer accounts
       MAX_VM_NAME_CHARACTERS = 15
@@ -631,10 +829,9 @@ class Chef
         if locate_config_value(:azure_vm_name).nil?
           azure_dns_name = prefix + SecureRandom.hex(( MAX_VM_NAME_CHARACTERS - prefix.length)/2)
         else
-          azure_dns_name = prefix + locate_config_value(:azure_vm_name)
+          azure_dns_name = locate_config_value(:azure_vm_name)
         end
       end
-
     end
   end
 end

data/lib/knife-azure/version.rb

@@ -1,6 +1,6 @@
 module Knife
   module Azure
-    VERSION = "1.3.0"
+    VERSION = "1.4.0.rc.0"
     MAJOR, MINOR, TINY = VERSION.split('.')
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: knife-azure
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.4.0.rc.0
 platform: ruby
 authors:
 - Barry Davis
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-31 00:00:00.000000000 Z
+date: 2014-12-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -31,14 +31,14 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.5.14
+        version: 0.8.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.5.14
+        version: 0.8.2
 - !ruby/object:Gem::Dependency
   name: chef
   requirement: !ruby/object:Gem::Requirement
@@ -81,6 +81,20 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: 0.2.9
+- !ruby/object:Gem::Dependency
+  name: knife-cloud
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
 description: A plugin to the Chef knife tool for creating instances on the Microsoft
   Azure platform
 email: oss@getchef.com