knife-azure 1.0.2 → 1.1.0

data/lib/azure/host.rb

@@ -21,30 +21,69 @@ class Azure
     def initialize(connection)
       @connection=connection
     end
+
+    # 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 @hosted_services || force_load
+        @hosted_services = begin
+          hosted_services = Hash.new
+          responseXML = @connection.query_azure('hostedservices')
+          servicesXML = responseXML.css('HostedServices HostedService')
+          servicesXML.each do |serviceXML|
+            host = Host.new(@connection).parse(serviceXML)
+            hosted_services[host.name] = host
+          end
+          hosted_services
+        end
+      end
+      @hosted_services
+    end
+
     def all
-      hosted_services = Array.new
-      responseXML = @connection.query_azure('hostedservices')
-      servicesXML = responseXML.css('HostedServices HostedService')
-      servicesXML.each do |serviceXML|
-        host = Host.new(@connection)
-        hosted_services << host.parse(serviceXML)
+      self.load.values
+    end
+
+    # first look up local cache if we have already loaded list.
+    def exists?(name)
+      return @hosted_services.key?(name) if @hosted_services
+      self.exists_on_cloud?(name)
+    end
+
+    # Look up on cloud and not local cache
+    def exists_on_cloud?(name)
+      ret_val = @connection.query_azure("hostedservices/#{name}")
+      if ret_val.nil? || ret_val.css('Error Code').length > 0
+        Chef::Log.warn 'Unable to find hosted(cloud) service:' + ret_val.at_css('Error Code').content + ' : ' + ret_val.at_css('Error Message').content if ret_val
+        false
+      else
+        true
       end
-      hosted_services
     end
-    def exists(name)
-      hostExists = false
-      self.all.each do |host|
-        next unless host.name == name
-        hostExists = true
+
+    # first look up local cache if we have already loaded list.
+    def find(name)
+      return @hosted_services[name] if @hosted_services && @hosted_services.key?(name)
+      self.fetch_from_cloud(name)
+    end
+
+    # Look up hosted service on cloud and not local cache
+    def fetch_from_cloud(name)
+      ret_val = @connection.query_azure("hostedservices/#{name}")
+      if ret_val.nil? || ret_val.css('Error Code').length > 0
+        Chef::Log.warn 'Unable to find hosted(cloud) service:' + ret_val.at_css('Error Code').content + ' : ' + ret_val.at_css('Error Message').content if ret_val
+        nil
+      else
+        Host.new(@connection).parse(ret_val)
       end
-      hostExists
     end
+
     def create(params)
       host = Host.new(@connection)
       host.create(params)
     end
     def delete(name)
-      if self.exists name
+      if self.exists?(name)
           servicecall = "hostedservices/" + name
         @connection.query_azure(servicecall, "delete") 
       end
@@ -58,8 +97,11 @@ class Azure
     attr_accessor :connection, :name, :url, :label
     attr_accessor :dateCreated, :description, :location
     attr_accessor :dateModified, :status
+
     def initialize(connection)
       @connection = connection
+      @deploys_loaded = false
+      @deploys = Hash.new
     end
     def parse(serviceXML)
       @name = xml_content(serviceXML, 'ServiceName')
@@ -75,10 +117,10 @@ class Azure
     def create(params)
       builder = Nokogiri::XML::Builder.new do |xml|
         xml.CreateHostedService('xmlns'=>'http://schemas.microsoft.com/windowsazure') {
-          xml.ServiceName params[:hosted_service_name]
-          xml.Label Base64.encode64(params[:hosted_service_name])
-          xml.Description params[:hosted_service_description] || 'Explicitly created hosted service'
-          xml.Location params[:service_location] || 'West US'
+          xml.ServiceName params[:azure_dns_name]
+          xml.Label Base64.encode64(params[:azure_dns_name])
+          xml.Description 'Explicitly created hosted service'
+          xml.Location params[:azure_service_location] || 'West US'
         }
       end
       @connection.query_azure("hostedservices", "post", builder.to_xml)
@@ -86,5 +128,42 @@ class Azure
     def details
       response = @connection.query_azure('hostedservices/' + @name + '?embed-detail=true')
     end
+
+    # Deployments within this hostedservice
+    def add_deploy(deploy)
+      @deploys[deploy.name] = deploy
+    end
+
+    def delete_role(role)
+      deploys.each { |d| d.delete_role_if_present(role) }
+    end
+
+    def deploys
+      # check if we have deploys loaded, else load.
+      if (@deploys.length == 0) && !@deploys_loaded
+        deploy = Deploy.new(@connection)
+        deploy.retrieve(@name)
+        @deploys[deploy.name] = deploy
+        @deploys_loaded = true
+      end
+      @deploys.values
+    end
+
+    def roles
+      roles = []
+      deploys.each do |deploy|
+        roles.concat(deploy.roles) if deploy.roles
+      end
+      roles
+    end
+
+    def find_role(role_name, deploy_name = nil)
+      return @deploys[deploy_name].find_role(role_name) if deploy_name && deploys
+      # else lookup all deploys within hostedservice
+      deploys.each do |deploy|
+        role = deploy.find_role(role_name)
+        return role if role
+      end
+    end
   end
 end

data/lib/azure/image.rb

@@ -21,23 +21,29 @@ class Azure
     def initialize(connection)
       @connection=connection
     end
-    def all
-      images = Array.new
-      response = @connection.query_azure('images')
-      osimages = response.css('OSImage')
-      osimages.each do |image|
-        item = Image.new(image)
-        images << item
+    def load
+      @images ||= begin
+        images = Hash.new
+        response = @connection.query_azure('images')
+        osimages = response.css('OSImage')
+        osimages.each do |image|
+          item = Image.new(image)
+          images[item.name] = item
+        end
+        images
       end
-      images
     end
-    def exists(name)
-      imageExists = false
-      self.all.each do |host|
-        next unless host.name == name
-        imageExists = true
-      end
-      imageExists
+
+    def all
+      self.load.values
+    end
+
+    def exists?(name)
+      self.all.key?(name)
+    end
+
+    def find(name)
+      self.load[name]
     end
   end
 end

data/lib/azure/rest.rb

@@ -24,23 +24,10 @@ module AzureAPI
   class Rest
     def initialize(params)
       @subscription_id = params[:azure_subscription_id]
-      @pem_file = File.read find_pem(params[:azure_mgmt_cert])
-      @host_name = params[:azure_host_name]
+      @pem_file = params[:azure_mgmt_cert]
+      @host_name = params[:azure_api_host_name]
       @verify_ssl = params[:verify_ssl_cert]
     end
-    def find_pem(name)
-      config_dir = Chef::Knife.chef_config_dir
-      if File.exist? name
-        pem_file = name
-      elsif config_dir && File.exist?(File.join(config_dir, name))
-        pem_file = File.join(config_dir, name)
-      elsif File.exist?(File.join(ENV['HOME'], '.chef', name))
-        pem_file = File.join(ENV['HOME'], '.chef', name)
-      else
-        raise 'Unable to find certificate pem file - ' + name
-      end
-      pem_file
-    end
     def query_azure(service_name, verb = 'get', body = '')
       request_url = "https://#{@host_name}/#{@subscription_id}/services/#{service_name}"
       print '.'
@@ -69,8 +56,12 @@ module AzureAPI
         http.verify_mode = OpenSSL::SSL::VERIFY_NONE
       end
       http.use_ssl = true
-      http.cert = OpenSSL::X509::Certificate.new(@pem_file)
-      http.key = OpenSSL::PKey::RSA.new(@pem_file)
+      begin
+        http.cert = OpenSSL::X509::Certificate.new(@pem_file)
+      rescue OpenSSL::X509::CertificateError => err
+        raise "Invalid Azure Certificate pem file. Error: #{err}"
+      end
+        http.key = OpenSSL::PKey::RSA.new(@pem_file)
       http
     end
     def request_setup(uri, verb, body)
@@ -95,7 +86,7 @@ module AzureAPI
       puts response.code
       puts "=== response.inspect ==="
       puts response.inspect
-      puts "=== all of the headers ===" 
+      puts "=== all of the headers ==="
       puts response.each_header { |h, j| puts h.inspect + ' : ' + j.inspect}
     end
   end

data/lib/azure/role.rb

@@ -15,14 +15,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-
+require 'securerandom'
 class Azure
   class Roles
+    include AzureUtility
     attr_accessor :connection, :roles
     def initialize(connection)
       @connection = connection
       @roles = nil
     end
+    # do not use this unless you want a list of all roles(vms) in your subscription
     def all
       @roles = Array.new
       @connection.deploys.all.each do |deploy|
@@ -32,51 +34,121 @@ class Azure
       end
       @roles
     end
-    def find(name)
-      if @roles == nil
-        all
+
+    def find_roles_within_hostedservice(hostedservicename)
+      host = @connection.hosts.find(hostedservicename)
+      (host) ? host.roles : nil # nil says invalid hosted service
+    end
+
+    def find_in_hosted_service(role_name, hostedservicename)
+      host = @connection.hosts.find(hostedservicename)
+      return nil if host.nil?
+      host.find_role(role_name)
+    end
+
+    def find(role_name, params= nil)
+      if params && params[:azure_dns_name]
+        return find_in_hosted_service(role_name, params[:azure_dns_name])
       end
+
+      all if @roles == nil
+
+      # TODO - optimize this lookup
       @roles.each do |role|
-        if(role.name == name)
-          return role 
+        if(role.name == role_name)
+          return role
         end
       end
-      nil   
+      nil
     end
-    def alone_on_host(name)
-      found_role = find(name)
-      @roles.each do |role|
-        if (role.name != found_role.name && 
-            role.deployname == found_role.deployname && 
-            role.hostedservicename == found_role.hostedservicename)
-          return false;
-        end
+
+    def alone_on_hostedservice(found_role)
+      roles = find_roles_within_hostedservice(found_role.hostedservicename)
+      if roles && roles.length > 1
+        return false
       end
-      true
+      return true
     end
-    def exists(name)
+
+    def exists?(name)
       find(name) != nil
     end
-    def delete(name)
+
+    def delete(name, params)
       role = find(name)
       if role != nil
-        if alone_on_host(name)
+        if alone_on_hostedservice(role)
           servicecall = "hostedservices/#{role.hostedservicename}/deployments" +
           "/#{role.deployname}"
         else
           servicecall = "hostedservices/#{role.hostedservicename}/deployments" +
           "/#{role.deployname}/roles/#{role.name}"
         end
-        @connection.query_azure(servicecall, "delete") 
+
+        roleXML = nil
+
+        unless params[:preserve_azure_os_disk]
+            roleXML = @connection.query_azure(servicecall, "get")
+        end
+
+        @connection.query_azure(servicecall, "delete")
+        # delete role from local cache as well.
+        @connection.hosts.find(role.hostedservicename).delete_role(role)
+        @roles.delete(role) if @roles
+
+        unless params[:preserve_azure_dns_name]
+          unless params[:azure_dns_name].nil?
+            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")
+            end
+          end
+        end
+
+        unless params[:preserve_azure_os_disk]
+          osdisk = roleXML.css(roleXML, 'OSVirtualHardDisk')
+          disk_name = xml_content(osdisk, 'DiskName')
+          servicecall = "disks/#{disk_name}"
+          storage_account = @connection.query_azure(servicecall, "get")
+
+          # OS Disk can only be deleted if it is detached from the VM.
+          # So Iteratively check for disk detachment from the VM while waiting for 5 minutes ,
+          # exit otherwise after 12 attempts.
+          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
+          @connection.query_azure(servicecall, "delete")
+
+          if params[:delete_azure_storage_account]
+            storage_account_name = xml_content(storage_account, "MediaLink")
+            storage_account_name = storage_account_name.gsub("http://", "").gsub(/.blob(.*)$/, "")
+
+            begin
+              @connection.query_azure("storageservices/#{storage_account_name}", "delete")
+            rescue Exception => ex
+              ui.warn("#{ex.message}")
+              ui.warn("#{ex.backtrace.join("\n")}")
+            end
+
+          end
+
+        end
+
+
       end
-      #@connection.disks.clear_unattached
     end
+
   end
+
   class Role
     include AzureUtility
-    attr_accessor :connection, :name, :status, :size, :ipaddress
-    attr_accessor :sshport, :sshipaddress, :hostedservicename, :deployname
+    attr_accessor :connection, :name, :status, :size, :ipaddress, :publicipaddress
+    attr_accessor :sshport, :hostedservicename, :deployname
+    attr_accessor :winrmport
     attr_accessor :hostname, :tcpports, :udpports
+
     def initialize(connection)
       @connection = connection
     end
@@ -90,11 +162,14 @@ class Azure
       @deployname = deployname
       @tcpports = Array.new
       @udpports = Array.new
+
       endpoints = roleXML.css('InstanceEndpoint')
+      @publicipaddress = xml_content(endpoints[0], 'Vip') if !endpoints.empty?
       endpoints.each do |endpoint|
         if xml_content(endpoint, 'Name').downcase == 'ssh'
           @sshport = xml_content(endpoint, 'PublicPort')
-          @sshipaddress = xml_content(endpoint, 'Vip')
+        elsif xml_content(endpoint, 'Name').downcase == 'winrm'
+          @winrmport = xml_content(endpoint, 'PublicPort')
         else
           hash = Hash.new
           hash['Name'] = xml_content(endpoint, 'Name')
@@ -115,34 +190,72 @@ class Azure
           'xmlns'=>'http://schemas.microsoft.com/windowsazure',
           'xmlns:i'=>'http://www.w3.org/2001/XMLSchema-instance'
         ) {
-          xml.RoleName {xml.text params[:role_name]}
+          xml.RoleName {xml.text params[:azure_vm_name]}
           xml.OsVersion('i:nil' => 'true')
           xml.RoleType 'PersistentVMRole'
           xml.ConfigurationSets {
-            xml.ConfigurationSet('i:type' => 'LinuxProvisioningConfigurationSet') {
-            xml.ConfigurationSetType 'LinuxProvisioningConfiguration'
-            xml.HostName params[:host_name] 
-            xml.UserName params[:ssh_user]
-            xml.UserPassword params[:ssh_password]
-            xml.DisableSshPasswordAuthentication 'false'
-          }
+            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]
+                       xml.Path '/home/' + params[:ssh_user] + '/.ssh/authorized_keys'
+                     }
+                   }
+                }
+              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'
+
+              }
+            end
+
           xml.ConfigurationSet('i:type' => 'NetworkConfigurationSet') {
             xml.ConfigurationSetType 'NetworkConfiguration'
             xml.InputEndpoints {
-              xml.InputEndpoint {
-              xml.LocalPort '22' 
-              xml.Name 'SSH'
-              xml.Protocol 'TCP'
-            }
+              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.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(':')
                 xml.InputEndpoint {
                   xml.LocalPort ports[0]
-                  xml.Name 'tcpport_' + ports[0] + '_' + params[:host_name]
+                  xml.Name 'tcpport_' + ports[0] + '_' + params[:azure_vm_name]
                   if ports.length > 1
                     xml.Port ports[1]
-                  end 
+                  else
+                    xml.Port ports[0]
+                  end
                   xml.Protocol 'TCP'
                 }
               end
@@ -152,10 +265,12 @@ class Azure
                 ports = endpoint.split(':')
                 xml.InputEndpoint {
                   xml.LocalPort ports[0]
-                  xml.Name 'udpport_' + ports[0] + '_' + params[:host_name]
+                  xml.Name 'udpport_' + ports[0] + '_' + params[:azure_vm_name]
                   if ports.length > 1
                     xml.Port ports[1]
-                  end 
+                  else
+                    xml.Port ports[0]
+                  end
                   xml.Protocol 'UDP'
                 }
               end
@@ -163,20 +278,22 @@ class Azure
             }
           }
           }
-          xml.Label Base64.encode64(params[:role_name]).strip
+          xml.Label Base64.encode64(params[:azure_vm_name]).strip
           xml.OSVirtualHardDisk {
-            xml.MediaLink 'http://' + params[:storage_account] + '.blob.core.windows.net/vhds/' + (params[:os_disk_name] || Time.now.strftime('disk_%Y_%m_%d_%H_%M')) + '.vhd'
-            xml.SourceImageName params[:source_image]
+            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]
           }
-          xml.RoleSize params[:role_size]
+          xml.RoleSize params[:azure_vm_size]
         }
-      end 
+      end
       builder.doc
     end
     def create(params, roleXML)
-      servicecall = "hostedservices/#{params[:hosted_service_name]}/deployments" +
+      servicecall = "hostedservices/#{params[:azure_dns_name]}/deployments" +
       "/#{params['deploy_name']}/roles"
-      @connection.query_azure(servicecall, "post", roleXML.to_xml) 
+      @connection.query_azure(servicecall, "post", roleXML.to_xml)
     end
   end
 end