knife-azure 1.0.2 → 1.1.0

data/lib/azure/storageaccount.rb

@@ -21,24 +21,45 @@ class Azure
     def initialize(connection)
       @connection=connection
     end
-    def all
-      storage_accounts = Array.new
-      responseXML = @connection.query_azure('storageservices')
-      servicesXML = responseXML.css('StorageServices StorageService')
-      servicesXML.each do |serviceXML|
-        storage_account = StorageAccount.new(@connection)
-        storage_accounts << storage_account.parse(serviceXML)
+    # force_load should be true when there is something in local cache and we want to reload
+    # first call is always load.
+    def load(force_load = false)
+      if not @azure_storage_accounts || force_load
+        @azure_storage_accounts = begin
+          azure_storage_accounts = Hash.new
+          responseXML = @connection.query_azure('storageservices')
+          servicesXML = responseXML.css('StorageServices StorageService')
+          servicesXML.each do |serviceXML|
+            storage = StorageAccount.new(@connection).parse(serviceXML)
+            azure_storage_accounts[storage.name] = storage
+          end
+          azure_storage_accounts
+        end
       end
-      storage_accounts
+      @azure_storage_accounts
     end
-    def exists(name)
-      storageExists = false
-      self.all.each do |storage|
-        next unless storage.name == name
-        storageExists = true
+
+    def all
+      self.load.values
+    end
+
+    # first look up local cache if we have already loaded list.
+    def exists?(name)
+      return @azure_storage_accounts.key?(name) if @azure_storage_accounts
+      self.exists_on_cloud?(name)
+    end
+
+    # Look up on cloud and not local cache
+    def exists_on_cloud?(name)
+      ret_val = @connection.query_azure("storageservices/#{name}")
+      if ret_val.nil? || ret_val.css('Error Code').length > 0
+        Chef::Log.warn 'Unable to find storage account:' + ret_val.at_css('Error Code').content + ' : ' + ret_val.at_css('Error Message').content if ret_val
+        false
+      else
+        true
       end
-      storageExists
     end
+
     def create(params)
       storage = StorageAccount.new(@connection)
       storage.create(params)
@@ -74,11 +95,11 @@ class Azure
     def create(params)
       builder = Nokogiri::XML::Builder.new do |xml|
         xml.CreateStorageServiceInput('xmlns'=>'http://schemas.microsoft.com/windowsazure') {
-          xml.ServiceName params[:storage_account]
-          xml.Label Base64.encode64(params[:storage_account])
-          xml.Description params[:storage_account_description] || 'Explicitly created storage service'
+          xml.ServiceName params[:azure_storage_account]
+          xml.Label Base64.encode64(params[:azure_storage_account])
+          xml.Description params[:azure_storage_account_description] || 'Explicitly created storage service'
           # Location defaults to 'West US'
-          xml.Location params[:service_location] || 'West US'
+          xml.Location params[:azure_service_location] || 'West US'
         }
       end
       @connection.query_azure("storageservices", "post", builder.to_xml)

data/lib/chef/knife/azure_base.rb

@@ -47,27 +47,41 @@ class Chef
             :description => "Your Azure PEM file name",
             :proc => Proc.new { |key| Chef::Config[:knife][:azure_mgmt_cert] = key }
 
-          option :azure_host_name,
+          option :azure_api_host_name,
             :short => "-H HOSTNAME",
-            :long => "--azure-host-name HOSTNAME",
+            :long => "--azure-api-host-name HOSTNAME",
             :description => "Your Azure host name",
-            :proc => Proc.new { |key| Chef::Config[:knife][:azure_host_name] = key },
-            :default => "management.core.windows.net"
+            :proc => Proc.new { |key| Chef::Config[:knife][:azure_api_host_name] = key }
 
           option :verify_ssl_cert,
             :long => "--verify-ssl-cert",
             :description => "Verify SSL Certificates for communication over HTTPS",
             :boolean => true,
             :default => false
+
+          option :azure_publish_settings_file,
+            :long => "--azure-publish-settings-file FILENAME",
+            :description => "Your Azure Publish Settings File",
+            :proc => Proc.new { |key| Chef::Config[:knife][:azure_publish_settings_file] = key }
         end
       end
 
+      def is_image_windows?
+        images = connection.images
+        target_image = images.all.select { |i| i.name == locate_config_value(:azure_source_image) }
+        unless target_image[0].nil?
+          return target_image[0].os == 'Windows'
+        else
+          ui.error("Invalid image. Use the command \"knife azure image list\" to verify the image name")
+          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_host_name => locate_config_value(:azure_host_name),
+                            :azure_api_host_name => locate_config_value(:azure_api_host_name),
                             :verify_ssl_cert => locate_config_value(:verify_ssl_cert)
                           )
                         end
@@ -84,21 +98,67 @@ class Chef
         end
       end
 
-      def validate!(keys=[:azure_subscription_id, :azure_mgmt_cert, :azure_host_name])
+      def validate!(keys=[:azure_subscription_id, :azure_mgmt_cert, :azure_api_host_name])
         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."
+            errors << "You did not provide a valid '#{pretty_key}' value. Please set knife[:#{k}] in your knife.rb or pass as an option."
           end
         end
-
         if errors.each{|e| ui.error(e)}.any?
           exit 1
         end
       end
 
+      def parse_publish_settings_file(filename)
+        require 'nokogiri'
+        require 'base64'
+        require 'openssl'
+        require 'uri'
+        begin
+          doc = Nokogiri::XML(File.open(find_file(filename)))
+          profile = doc.at_css("PublishProfile")
+          subscription = profile.at_css("Subscription")
+          #check given PublishSettings XML file format.Currently PublishSettings file have two different XML format
+          if profile.attribute("SchemaVersion").nil?
+            management_cert = OpenSSL::PKCS12.new(Base64.decode64(profile.attribute("ManagementCertificate").value))
+            Chef::Config[:knife][:azure_api_host_name] = URI(profile.attribute("Url").value).host
+          elsif profile.attribute("SchemaVersion").value == "2.0"
+            management_cert = OpenSSL::PKCS12.new(Base64.decode64(subscription.attribute("ManagementCertificate").value))
+            Chef::Config[:knife][:azure_api_host_name] = URI(subscription.attribute("ServiceManagementUrl").value).host
+          else
+            ui.error("Publish settings file Schema not supported - " + filename)
+          end
+          Chef::Config[:knife][:azure_mgmt_cert] = management_cert.certificate.to_pem + management_cert.key.to_pem
+          Chef::Config[:knife][:azure_subscription_id] = doc.at_css("Subscription").attribute("Id").value
+        rescue
+          ui.error("Incorrect publish settings file - " + filename)
+          exit 1
+        end
+      end
+
+      def find_file(name)
+        config_dir = Chef::Knife.chef_config_dir
+        if File.exist? name
+          file = name
+        elsif config_dir && File.exist?(File.join(config_dir, name))
+          file = File.join(config_dir, name)
+        elsif File.exist?(File.join(ENV['HOME'], '.chef', name))
+          file = File.join(ENV['HOME'], '.chef', name)
+        else
+          ui.error('Unable to find file - ' + name)
+          exit 1
+        end
+        file
+      end
+
     end
   end
 end

data/lib/chef/knife/azure_image_list.rb

@@ -29,6 +29,12 @@ class Chef
 
       banner "knife azure image list (options)"
 
+      option :show_all_fields,
+        :long => "--full",
+        :default => false,
+        :boolean => true,
+        :description => "Show all the fields of the images"
+
       def h
         @highline ||= HighLine.new
       end
@@ -38,23 +44,18 @@ class Chef
 
         validate!
 
-        image_list = [
-          ui.color('Name', :bold),
-          ui.color('Category', :bold),
-          ui.color('Label', :bold),
-          ui.color('OS', :bold),
-        ]
+        image_labels = !locate_config_value(:show_all_fields) ? ['Name', 'OS'] : ['Name', 'Category', 'Label', 'OS'] 
+        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|
-          if image.os == 'Linux'
-            image_list << image.name.to_s
-            image_list << image.category.to_s
-            image_list << image.label.to_s
-            image_list << image.os.to_s
-          end
+         image_items.each {|item| image_list << image.send(item).to_s }
         end
+
         puts "\n"
-        puts h.list(image_list, :columns_across, 4)
+        puts h.list(image_list, :uneven_columns_across, !locate_config_value(:show_all_fields) ? 2 : 4) 
+
       end
     end
   end

data/lib/chef/knife/azure_server_create.rb

@@ -18,25 +18,40 @@
 # limitations under the License.
 #
 
-require File.expand_path('../azure_base', __FILE__)
-
+require 'chef/knife/azure_base'
+require 'chef/knife/winrm_base'
 class Chef
   class Knife
     class AzureServerCreate < Knife
 
       include Knife::AzureBase
+      include Knife::WinrmBase
 
       deps do
         require 'readline'
         require 'chef/json_compat'
         require 'chef/knife/bootstrap'
+        require 'chef/knife/bootstrap_windows_ssh'
+        require 'chef/knife/core/windows_bootstrap_context'
         Chef::Knife::Bootstrap.load_deps
       end
 
+      def load_winrm_deps
+        require 'winrm'
+        require 'em-winrm'
+        require 'chef/knife/winrm'
+        require 'chef/knife/bootstrap_windows_winrm'
+      end
+
       banner "knife azure server create (options)"
 
       attr_accessor :initial_sleep_delay
 
+      option :bootstrap_protocol,
+        :long => "--bootstrap-protocol protocol",
+        :description => "Protocol to bootstrap windows servers. options: winrm/ssh",
+        :default => "winrm"
+
       option :chef_node_name,
         :short => "-N NAME",
         :long => "--node-name NAME",
@@ -52,10 +67,10 @@ class Chef
         :long => "--ssh-password PASSWORD",
         :description => "The ssh password"
 
-      option :identity_file,
-        :short => "-i IDENTITY_FILE",
-        :long => "--identity-file IDENTITY_FILE",
-        :description => "The SSH identity file used for authentication"
+      option :ssh_port,
+        :long => "--ssh-port PORT",
+        :description => "The ssh port. Default is 22.",
+        :default => '22'
 
       option :prerelease,
         :long => "--prerelease",
@@ -86,55 +101,57 @@ class Chef
         :proc => lambda { |o| o.split(/[\s,]+/) },
         :default => []
 
-      option :no_host_key_verify,
-        :long => "--no-host-key-verify",
-        :description => "Disable host key verification",
+      option :host_key_verify,
+        :long => "--[no-]host-key-verify",
+        :description => "Verify host key, enabled by default.",
         :boolean => true,
-        :default => false
-
-      option :hosted_service_name,
-        :short => "-s NAME",
-        :long => "--hosted-service-name NAME",
-        :description => "specifies the name for the hosted service"
-
-      option :hosted_service_description,
-        :short => "-D DESCRIPTION",
-        :long => "--hosted_service_description DESCRIPTION",
-        :description => "Description for the hosted service"
+        :default => true
 
-      option :storage_account,
+      option :azure_storage_account,
         :short => "-a NAME",
-        :long => "--storage-account NAME",
-        :description => "specifies the name for the hosted service"
-
-      option :role_name,
-        :short => "-R name",
-        :long => "--role-name NAME",
-        :description => "specifies the name for the virtual machine"
-
-      option :host_name,
-        :long => "--host-name NAME",
-        :description => "specifies the host name for the virtual machine"
-
-      option :service_location,
+        :long => "--azure-storage-account NAME",
+        :description => "Required for advanced server-create option.
+                                      A name for the storage account that is unique within Windows Azure. Storage account names must be
+                                      between 3 and 24 characters in length and use numbers and lower-case letters only.
+                                      This name is the DNS prefix name and can be used to access blobs, queues, and tables in the storage account.
+                                      For example: http://ServiceName.blob.core.windows.net/mycontainer/"
+
+      option :azure_vm_name,
+        :long => "--azure-vm-name NAME",
+        :description => "Required for advanced server-create option.
+                                      Specifies the name for the virtual machine. The name must be unique within the deployment."
+
+      option :azure_service_location,
         :short => "-m LOCATION",
-        :long => "--service-location LOCATION",
-        :description => "specify the Geographic location for the virtual machine and services"
-
-      option :os_disk_name,
+        :long => "--azure-service-location LOCATION",
+        :description => "Required. 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"
+
+      option :azure_dns_name,
+        :short => "-d DNS_NAME",
+        :long => "--azure-dns-name DNS_NAME",
+        :description => "Required. The DNS prefix name that can be used to access the cloud service which is unique within Windows Azure.
+                                      If you want to add new VM to an existing service/deployment, specify an exiting dns-name,
+                                      along with --azure-connect-to-existing-dns option.
+                                      Otherwise a new deployment is created. For example, if the DNS of cloud service is MyService you could access the cloud service
+                                      by calling: http://DNS_NAME.cloudapp.net"
+
+      option :azure_os_disk_name,
         :short => "-o DISKNAME",
-        :long => "--os-disk-name DISKNAME",
-        :description => "unique name for specifying os disk (optional)"
+        :long => "--azure-os-disk-name DISKNAME",
+        :description => "Optional. Specifies the friendly name of the disk containing the guest OS image in the image repository."
 
-      option :source_image,
+      option :azure_source_image,
         :short => "-I IMAGE",
-        :long => "--source-image IMAGE",
-        :description => "disk image name to use to create virtual machine"
+        :long => "--azure-source-image IMAGE",
+        :description => "Required. Specifies the name of the disk image to use to create the virtual machine.
+                                      Do a \"knife azure image list\" to see a list of available images."
 
-      option :role_size,
+      option :azure_vm_size,
         :short => "-z SIZE",
-        :long => "--role-size SIZE",
-        :description => "size of virtual machine (ExtraSmall, Small, Medium, Large, ExtraLarge)"
+        :long => "--azure-vm-size SIZE",
+        :description => "Optional. Size of virtual machine (ExtraSmall, Small, Medium, Large, ExtraLarge)",
+        :default => 'Small'
 
       option :tcp_endpoints,
         :short => "-t PORT_LIST",
@@ -146,6 +163,29 @@ class Chef
         :long => "--udp-endpoints PORT_LIST",
         :description => "Comma separated list of UDP local and public ports to open i.e. '80:80,433:5000'"
 
+      option :azure_connect_to_existing_dns,
+        :short => "-c",
+        :long => "--azure-connect-to-existing-dns",
+        :boolean => true,
+        :default => false,
+        :description => "Set this flag to add the new VM to an existing deployment/service. Must give the name of the existing
+                                        DNS correctly in the --dns-name option"
+      option :identity_file,
+        :long => "--identity-file FILENAME",
+        :description => "SSH identity file for authentication, optional. It is the RSA private key path. Specify either ssh-password or identity-file"
+
+      option :identity_file_passphrase,
+        :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
+        }
 
       def strip_non_ascii(string)
         string.gsub(/[^0-9a-z ]/i, '')
@@ -155,6 +195,28 @@ class Chef
         (0...len).map{65.+(rand(25)).chr}.join
       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
+      end
+
       def tcp_test_ssh(fqdn, sshport)
         tcp_socket = TCPSocket.new(fqdn, sshport)
         readable = IO.select([tcp_socket], nil, nil, 5)
@@ -175,7 +237,6 @@ class Chef
       rescue Errno::ECONNREFUSED
         sleep 2
         false
-        # This happens on EC2 quite often
       rescue Errno::EHOSTUNREACH
         sleep 2
         false
@@ -183,32 +244,6 @@ class Chef
         tcp_socket && tcp_socket.close
       end
 
-      def parameter_test
-        details = Array.new
-        details << ui.color('name', :bold, :blue)
-        details << ui.color('Chef::Config', :bold, :blue)
-        details << ui.color('config', :bold, :blue)
-        details << ui.color('winner is', :bold, :blue)
-        [
-          :azure_subscription_id, 
-          :azure_mgmt_cert, 
-          :azure_host_name,
-          :role_name, 
-          :host_name, 
-          :ssh_user, 
-          :ssh_password, 
-          :service_location, 
-          :source_image, 
-          :role_size
-        ].each do |key|
-          key = key.to_sym
-          details << key.to_s
-          details << Chef::Config[:knife][key].to_s
-          details << config[key].to_s
-          details << locate_config_value(key)
-        end 
-        puts ui.list(details, :columns_across, 4)
-      end
       def run
         $stdout.sync = true
         storage = nil
@@ -217,31 +252,55 @@ class Chef
         validate!
 
         Chef::Log.info("creating...")
-      
-        if not locate_config_value(:hosted_service_name)
-          config[:hosted_service_name] = [strip_non_ascii(locate_config_value(:role_name)), random_string].join
+
+        if not locate_config_value(:azure_vm_name)
+          config[:azure_vm_name] = locate_config_value(:azure_dns_name)
         end
 
-        #If Storage Account is not specified, check if the geographic location has one to re-use 
-        if not locate_config_value(:storage_account)
+        #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(:service_location) }
+          storage = storage_accts.find { |storage_acct| storage_acct.location.to_s == locate_config_value(:azure_service_location) }
           if not storage
-            config[:storage_account] = [strip_non_ascii(locate_config_value(:role_name)), random_string].join.downcase
+            config[:azure_storage_account] = [strip_non_ascii(locate_config_value(:azure_vm_name)), random_string].join.downcase
           else
-            config[:storage_account] = storage.name.to_s
+            config[:azure_storage_account] = storage.name.to_s
           end
         end
+
         server = connection.deploys.create(create_server_def)
+        fqdn = server.publicipaddress
 
         puts("\n")
+        if is_image_windows?
+          if locate_config_value(:bootstrap_protocol) == 'ssh'
+            port = server.sshport
+            print "\n#{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 "\n#{ui.color("Waiting for winrm on #{fqdn}:#{port}", :magenta)}"
+
+            print(".") until tcp_test_winrm(fqdn,port) {
+              sleep @initial_sleep_delay ||= 10
+              puts("done")
+           }
 
-        unless server && server.sshipaddress && server.sshport
-          Chef::Log.fatal("server not created")
+          end
+          sleep 15
+          bootstrap_for_windows_node(server,fqdn, port).run
+        else
+          unless server && server.publicipaddress && server.sshport
+            Chef::Log.fatal("server not created")
           exit 1
         end
 
-        fqdn = server.sshipaddress
         port = server.sshport
 
         print "\n#{ui.color("Waiting for sshd on #{fqdn}:#{port}", :magenta)}"
@@ -252,10 +311,69 @@ class Chef
         }
 
         sleep 15
+          bootstrap_for_node(server,fqdn,port).run
+        end
+      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
 
-        bootstrap_for_node(server,fqdn,port).run
+        Chef::Config[:knife][:hints] ||= {}
+        Chef::Config[:knife][:hints]["azure"] ||= cloud_attributes
 
-        puts "\n"
+      end
+
+      def bootstrap_common_params(bootstrap, server)
+
+        bootstrap.config[:run_list] = config[:run_list]
+        bootstrap.config[:prerelease] = config[:prerelease]
+        bootstrap.config[:bootstrap_version] = locate_config_value(:bootstrap_version)
+        bootstrap.config[:distro] = locate_config_value(:distro)
+        bootstrap.config[:template_file] = locate_config_value(:template_file)
+        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_port] = port
+
+        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[: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] = config[:encrypted_data_bag_secret]
+        bootstrap.config[:encrypted_data_bag_secret_file] = config[:encrypted_data_bag_secret_file]
+        bootstrap_common_params(bootstrap, server)
       end
 
       def bootstrap_for_node(server,fqdn,port)
@@ -271,45 +389,90 @@ class Chef
         bootstrap.config[:bootstrap_version] = locate_config_value(:bootstrap_version)
         bootstrap.config[:distro] = locate_config_value(:distro)
         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[:template_file] = config[:template_file]
         bootstrap.config[:environment] = locate_config_value(:environment)
         # may be needed for vpc_mode
-        bootstrap.config[:no_host_key_verify] = config[:no_host_key_verify]
+        bootstrap.config[:host_key_verify] = config[:host_key_verify]
+
+        # Load cloud attributes.
+        load_cloud_attributes_in_hints(server)
+
         bootstrap
       end
 
       def validate!
         super([
-              :azure_subscription_id, 
-              :azure_mgmt_cert, 
-              :azure_host_name,
-              :role_name, 
-              :host_name, 
-              :ssh_user, 
-              :ssh_password, 
-              :service_location, 
-              :source_image, 
-              :role_size
+              :azure_subscription_id,
+              :azure_mgmt_cert,
+              :azure_api_host_name,
+              :azure_dns_name,
+              :azure_service_location,
+              :azure_source_image,
+              :azure_vm_size,
         ])
+        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
       end
 
       def create_server_def
         server_def = {
-          :hosted_service_name => locate_config_value(:hosted_service_name), 
-          :storage_account => locate_config_value(:storage_account),
-          :role_name => locate_config_value(:role_name), 
-          :host_name => locate_config_value(:host_name), 
-          :ssh_user => locate_config_value(:ssh_user),
-          :ssh_password => locate_config_value(:ssh_password), 
-          :service_location => locate_config_value(:service_location), 
-          :os_disk_name => locate_config_value(:os_disk_name), 
-          :source_image => locate_config_value(:source_image), 
-          :role_size => locate_config_value(:role_size),
+          :azure_storage_account => locate_config_value(:azure_storage_account),
+          :azure_dns_name => locate_config_value(:azure_dns_name),
+          :azure_vm_name => locate_config_value(:azure_vm_name),
+          :azure_service_location => locate_config_value(:azure_service_location),
+          :azure_os_disk_name => locate_config_value(:azure_os_disk_name),
+          :azure_source_image => locate_config_value(:azure_source_image),
+          :azure_vm_size => locate_config_value(:azure_vm_size),
           :tcp_endpoints => locate_config_value(:tcp_endpoints),
-          :udp_endpoints => locate_config_value(:udp_endpoints)
+          :udp_endpoints => locate_config_value(:udp_endpoints),
+          :bootstrap_proto => locate_config_value(:bootstrap_protocol),
+          :azure_connect_to_existing_dns => locate_config_value(:azure_connect_to_existing_dns)
         }
+        # 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
+          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
+          end
+        end
+        server_def[:port] = port
+
+        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")
+          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[: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
       end
     end
   end
 end
+