knife-azure 1.8.7 → 1.9.0

data/lib/azure/service_management/ag.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Jeff Mendoza (jeffmendoza@live.com)
-# Copyright:: Copyright (c) 2013 Opscode, Inc.
+# Copyright:: Copyright 2013-2018 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -25,13 +25,13 @@ module Azure
     def load
       @ags ||= begin
         @ags = {}
-        response = @connection.query_azure('affinitygroups',
-                                           'get',
-                                           '',
-                                           '',
+        response = @connection.query_azure("affinitygroups",
+                                           "get",
+                                           "",
+                                           "",
                                            true,
                                            false)
-        response.css('AffinityGroup').each do |ag|
+        response.css("AffinityGroup").each do |ag|
           item = AG.new(@connection).parse(ag)
           @ags[item.name] = item
         end
@@ -67,18 +67,18 @@ module Azure
     end
 
     def parse(image)
-      @name = image.at_css('Name').content
-      @label = image.at_css('Label').content
-      @description = image.at_css('Description').content if
-        image.at_css('Description')
-      @location = image.at_css('Location').content if image.at_css('Location')
+      @name = image.at_css("Name").content
+      @label = image.at_css("Label").content
+      @description = image.at_css("Description").content if
+        image.at_css("Description")
+      @location = image.at_css("Location").content if image.at_css("Location")
       self
     end
 
     def create(params)
-      builder = Nokogiri::XML::Builder.new(encoding: 'utf-8') do |xml|
+      builder = Nokogiri::XML::Builder.new(encoding: "utf-8") do |xml|
         xml.CreateAffinityGroup(
-          xmlns: 'http://schemas.microsoft.com/windowsazure'
+          xmlns: "http://schemas.microsoft.com/windowsazure"
         ) do
           xml.Name params[:azure_ag_name]
           xml.Label Base64.strict_encode64(params[:azure_ag_name])
@@ -88,10 +88,10 @@ module Azure
           xml.Location params[:azure_location]
         end
       end
-      @connection.query_azure('affinitygroups',
-                              'post',
+      @connection.query_azure("affinitygroups",
+                              "post",
                               builder.to_xml,
-                              '',
+                              "",
                               true,
                               false)
     end

data/lib/azure/service_management/certificate.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Mukta Aphale (mukta.aphale@clogeny.com)
-# Copyright:: Copyright (c) 2010-2011 Opscode, Inc.
+# Copyright:: Copyright 2010-2018 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -19,7 +19,7 @@
 module Azure
   class Certificates
     def initialize(connection)
-      @connection=connection
+      @connection = connection
     end
 
     def create(params)
@@ -33,7 +33,7 @@ module Azure
     end
 
     def create_ssl_certificate(azure_dns_name)
-      cert_params = { output_file: 'winrm', key_length: 2048, cert_validity: 24,
+      cert_params = { output_file: "winrm", key_length: 2048, cert_validity: 24,
                       azure_dns_name: azure_dns_name }
       certificate = Certificate.new(@connection)
       thumbprint = certificate.create_ssl_certificate(cert_params)
@@ -58,15 +58,15 @@ module Azure
     def create(params)
       # If RSA private key has been specified, then generate an x 509 certificate from the
       # public part of the key
-      @cert_data = generate_public_key_certificate_data({:ssh_key => params[:identity_file],
-                                             :ssh_key_passphrase => params[:identity_file_passphrase]})
-      add_certificate @cert_data, 'knifeazure', 'pfx', params[:azure_dns_name]
+      @cert_data = generate_public_key_certificate_data({ :ssh_key => params[:identity_file],
+                                                          :ssh_key_passphrase => params[:identity_file_passphrase] })
+      add_certificate @cert_data, "knifeazure", "pfx", params[:azure_dns_name]
 
       # Return the fingerprint to be used while adding role
       @fingerprint
     end
 
-    def generate_public_key_certificate_data (params)
+    def generate_public_key_certificate_data(params)
       # Generate OpenSSL RSA key from the mentioned ssh key path (and passphrase)
       key = OpenSSL::PKey::RSA.new(File.read(params[:ssh_key]), params[:ssh_key_passphrase])
       # Generate X 509 certificate
@@ -81,28 +81,28 @@ module Azure
       ef = OpenSSL::X509::ExtensionFactory.new
       ef.subject_certificate = ca
       ef.issuer_certificate = ca
-      ca.add_extension(ef.create_extension("basicConstraints","CA:TRUE",true))
-      ca.add_extension(ef.create_extension("keyUsage","keyCertSign, cRLSign", true))
-      ca.add_extension(ef.create_extension("subjectKeyIdentifier","hash",false))
-      ca.add_extension(ef.create_extension("authorityKeyIdentifier","keyid:always",false))
+      ca.add_extension(ef.create_extension("basicConstraints", "CA:TRUE", true))
+      ca.add_extension(ef.create_extension("keyUsage", "keyCertSign, cRLSign", true))
+      ca.add_extension(ef.create_extension("subjectKeyIdentifier", "hash", false))
+      ca.add_extension(ef.create_extension("authorityKeyIdentifier", "keyid:always", false))
       ca.sign(key, OpenSSL::Digest::SHA256.new)
       # Generate the SHA1 fingerprint of the der format of the X 509 certificate
-      @fingerprint =  OpenSSL::Digest::SHA1.new(ca.to_der)
+      @fingerprint = OpenSSL::Digest::SHA1.new(ca.to_der)
       # Create the pfx format of the certificate
-      pfx = OpenSSL::PKCS12.create('knifeazure', 'knife-azure-pfx',  key,  ca)
+      pfx = OpenSSL::PKCS12.create("knifeazure", "knife-azure-pfx", key, ca)
       # 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
+    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
-       }
+        xml.CertificateFile("xmlns" => "http://schemas.microsoft.com/windowsazure") do
+          xml.Data certificate_data
+          xml.CertificateFormat certificate_format
+          xml.Password certificate_password
+        end
       end
       # Windows Azure API call
       @connection.query_azure("hostedservices/#{dns_name}/certificates", "post", builder.to_xml)
@@ -125,8 +125,8 @@ module Azure
     end
 
     ########   SSL certificate generation for knife-azure ssl bootstrap ######
-    def create_ssl_certificate cert_params
-      file_path = cert_params[:output_file].sub(/\.(\w+)$/,'')
+    def create_ssl_certificate(cert_params)
+      file_path = cert_params[:output_file].sub(/\.(\w+)$/, "")
       path = prompt_for_file_path
       file_path = File.join(path, file_path) unless path.empty?
       cert_params[:domain] = prompt_for_domain
@@ -134,21 +134,21 @@ module Azure
       rsa_key = generate_keypair cert_params[:key_length]
       cert = generate_certificate(rsa_key, cert_params)
       write_certificate_to_file cert, file_path, rsa_key, cert_params
-      puts "*"*70
+      puts "*" * 70
       puts "Generated Certificates:"
       puts "- #{file_path}.pfx - PKCS12 format keypair. Contains both the public and private keys, usually used on the server."
       puts "- #{file_path}.b64 - Base64 encoded PKCS12 keypair. Contains both the public and private keys, for upload to the Azure REST API."
       puts "- #{file_path}.pem - Base64 encoded public certificate only. Required by the client to connect to the server."
       puts "Certificate Thumbprint: #{@thumbprint.to_s.upcase}"
-      puts "*"*70
+      puts "*" * 70
 
       Chef::Config[:knife][:ca_trust_file] = file_path + ".pem" if Chef::Config[:knife][:ca_trust_file].nil?
       cert_data = File.read (file_path + ".b64")
-      add_certificate cert_data, @winrm_cert_passphrase, 'pfx', cert_params[:azure_dns_name]
+      add_certificate cert_data, @winrm_cert_passphrase, "pfx", cert_params[:azure_dns_name]
       @thumbprint
     end
 
-    def generate_keypair key_length
+    def generate_keypair(key_length)
       OpenSSL::PKey::RSA.new(key_length.to_i)
     end
 
@@ -166,7 +166,7 @@ module Azure
     end
 
     def prompt_for_file_path
-      file_path = ''
+      file_path = ""
       counter = 0
       begin
         print "Invalid location! \n" unless file_path.empty?
@@ -183,7 +183,7 @@ module Azure
     def prompt_for_domain
       counter = 0
       begin
-        print 'Enter the domain (mandatory):'
+        print "Enter the domain (mandatory):"
         domain = STDIN.gets
         domain = domain.strip
         counter += 1
@@ -211,15 +211,15 @@ module Azure
       ef = OpenSSL::X509::ExtensionFactory.new
       ef.subject_certificate = cert
       ef.issuer_certificate = cert
-      cert.add_extension(ef.create_extension("subjectKeyIdentifier","hash",false))
-      cert.add_extension(ef.create_extension("authorityKeyIdentifier","keyid:always",false))
+      cert.add_extension(ef.create_extension("subjectKeyIdentifier", "hash", false))
+      cert.add_extension(ef.create_extension("authorityKeyIdentifier", "keyid:always", false))
       cert.add_extension(ef.create_extension("extendedKeyUsage", "1.3.6.1.5.5.7.3.1", false))
       cert.sign(rsa_key, OpenSSL::Digest::SHA1.new)
       @thumbprint = OpenSSL::Digest::SHA1.new(cert.to_der)
       cert
     end
 
-    def write_certificate_to_file cert, file_path, rsa_key, cert_params
+    def write_certificate_to_file(cert, file_path, rsa_key, cert_params)
       File.open(file_path + ".pem", "wb") { |f| f.print cert.to_pem }
       @winrm_cert_passphrase = prompt_for_passphrase unless @winrm_cert_passphrase
       pfx = OpenSSL::PKCS12.create("#{cert_params[:winrm_cert_passphrase]}", "winrmcert", rsa_key, cert)
@@ -229,6 +229,5 @@ module Azure
 
     ##########   SSL certificate generation ends ###########
 
-
   end
 end

data/lib/azure/service_management/connection.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Barry Davis (barryd@jetstreamsoftware.com)
-# Copyright:: Copyright (c) 2010-2011 Opscode, Inc.
+# Copyright:: Copyright 2010-2018 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,17 +16,17 @@
 # limitations under the License.
 #
 
-require 'azure/service_management/image'
-require 'azure/service_management/role'
-require 'azure/service_management/deploy'
-require 'azure/service_management/host'
-require 'azure/service_management/loadbalancer'
-require 'azure/service_management/vnet'
-require 'azure/service_management/utility'
-require 'azure/service_management/ag'
-require 'azure/service_management/storageaccount'
-require 'azure/service_management/certificate'
-require 'azure/service_management/disk'
+require "azure/service_management/image"
+require "azure/service_management/role"
+require "azure/service_management/deploy"
+require "azure/service_management/host"
+require "azure/service_management/loadbalancer"
+require "azure/service_management/vnet"
+require "azure/service_management/utility"
+require "azure/service_management/ag"
+require "azure/service_management/storageaccount"
+require "azure/service_management/certificate"
+require "azure/service_management/disk"
 
 module Azure
   class ServiceManagement
@@ -37,7 +37,7 @@ module Azure
       def initialize(rest)
         @images = Images.new(self)
         @roles = Roles.new(self)
-        @deploys  = Deploys.new(self)
+        @deploys = Deploys.new(self)
         @hosts = Hosts.new(self)
         @rest = rest
         @lbs = Loadbalancer.new(self)
@@ -49,19 +49,19 @@ module Azure
       end
 
       def query_azure(service_name,
-                      verb = 'get',
-                      body = '',
-                      params = '',
+                      verb = "get",
+                      body = "",
+                      params = "",
                       wait = true,
                       services = true,
                       content_type = nil)
-        Chef::Log.info 'calling ' + verb + ' ' + service_name + (wait ? " synchronously" : " asynchronously")
-        Chef::Log.debug body unless body == ''
+        Chef::Log.info "calling " + verb + " " + service_name + (wait ? " synchronously" : " asynchronously")
+        Chef::Log.debug body unless body == ""
         response = @rest.query_azure(service_name, verb, body, params, services, content_type)
         if response.code.to_i == 200
           ret_val = Nokogiri::XML response.body
         elsif !wait && response.code.to_i == 202
-          Chef::Log.debug 'Request accepted in asynchronous mode'
+          Chef::Log.debug "Request accepted in asynchronous mode"
           ret_val = Nokogiri::XML response.body
         elsif response.code.to_i >= 201 && response.code.to_i <= 299
           ret_val = wait_for_completion()
@@ -70,29 +70,29 @@ module Azure
             ret_val = Nokogiri::XML response.body
             Chef::Log.debug ret_val.to_xml
             error_code, error_message = error_from_response_xml(ret_val)
-            Chef::Log.debug error_code + ' : ' + error_message if error_code.length > 0
+            Chef::Log.debug error_code + " : " + error_message if error_code.length > 0
           else
-            Chef::Log.warn 'http error: ' + response.code
+            Chef::Log.warn "http error: " + response.code
           end
         end
         ret_val
       end
 
-      def wait_for_completion()
-        status = 'InProgress'
-        Chef::Log.info 'Waiting while status returns InProgress'
-        while status == 'InProgress'
+      def wait_for_completion
+        status = "InProgress"
+        Chef::Log.info "Waiting while status returns InProgress"
+        while status == "InProgress"
           response = @rest.query_for_completion()
           ret_val = Nokogiri::XML response.body
-          status = xml_content(ret_val,'Status')
-          if status == 'InProgress'
-            print '.'
+          status = xml_content(ret_val, "Status")
+          if status == "InProgress"
+            print "."
             sleep(0.5)
-          elsif status == 'Succeeded'
-            Chef::Log.debug 'not InProgress : ' + ret_val.to_xml
+          elsif status == "Succeeded"
+            Chef::Log.debug "not InProgress : " + ret_val.to_xml
           else
             error_code, error_message = error_from_response_xml(ret_val)
-            Chef::Log.debug status + error_code + ' : ' + error_message if error_code.length > 0
+            Chef::Log.debug status + error_code + " : " + error_message if error_code.length > 0
           end
         end
         ret_val

data/lib/azure/service_management/deploy.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Barry Davis (barryd@jetstreamsoftware.com)
-# Copyright:: Copyright (c) 2010-2011 Opscode, Inc.
+# Copyright:: Copyright 2010-2018 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -20,8 +20,9 @@ module Azure
   class Deploys
     include AzureUtility
     def initialize(connection)
-      @connection=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)
@@ -44,7 +45,7 @@ module Azure
     end
 
     def all
-      self.load
+      load
     end
 
     # TODO - Current knife-azure plug-in seems to have assumption that single hostedservice
@@ -61,14 +62,14 @@ module Azure
     def create(params)
       if params[:azure_connect_to_existing_dns]
         unless @connection.hosts.exists?(params[:azure_dns_name])
-          Chef::Log.fatal 'The specified Azure DNS Name does not exist.'
+          Chef::Log.fatal "The specified Azure DNS Name does not exist."
           exit 1
         end
       else
         ret_val = @connection.hosts.create(params)
         error_code, error_message = error_from_response_xml(ret_val)
         if error_code.length > 0
-          Chef::Log.fatal 'Unable to create DNS:' + error_code + ' : ' + error_message
+          Chef::Log.fatal "Unable to create DNS:" + error_code + " : " + error_message
           exit 1
         end
       end
@@ -80,19 +81,19 @@ module Azure
       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]
-      elsif(params[:winrm_transport] == "ssl")
+        @connection.certificates.add cert_data, params[:cert_password], "pfx", params[:azure_dns_name]
+      elsif params[:winrm_transport] == "ssl"
         #TODO: generate certificates for ssl listener
       end
 
-      params['deploy_name'] = get_deploy_name_for_hostedservice(params[:azure_dns_name])
+      params["deploy_name"] = get_deploy_name_for_hostedservice(params[:azure_dns_name])
 
-      if params['deploy_name'] != nil
+      if !params["deploy_name"].nil?
         role = Role.new(@connection)
         roleXML = role.setup(params)
         ret_val = role.create(params, roleXML)
       else
-        params['deploy_name'] = params[:azure_dns_name]
+        params["deploy_name"] = params[:azure_dns_name]
         deploy = Deploy.new(@connection)
         deployXML = deploy.setup(params)
         ret_val = deploy.create(params, deployXML)
@@ -100,7 +101,7 @@ module Azure
       error_code, error_message = error_from_response_xml(ret_val)
       if error_code.length > 0
         Chef::Log.debug(ret_val.to_s)
-        raise Chef::Log.fatal 'Unable to create role:' + error_code + ' : ' + error_message
+        raise Chef::Log.fatal "Unable to create role:" + error_code + " : " + error_message
       end
       @connection.roles.find_in_hosted_service(params[:azure_vm_name], params[:azure_dns_name])
     end
@@ -109,9 +110,9 @@ module Azure
     end
 
     def queryDeploy(hostedservicename)
-        deploy = Deploy.new(@connection)
-        deploy.retrieve(hostedservicename)
-        deploy
+      deploy = Deploy.new(@connection)
+      deploy.retrieve(hostedservicename)
+      deploy
     end
   end
 
@@ -122,32 +123,33 @@ module Azure
     def initialize(connection)
       @connection = connection
     end
+
     def retrieve(hostedservicename)
       @hostedservicename = hostedservicename
       deployXML = @connection.query_azure("hostedservices/#{hostedservicename}/deploymentslots/Production")
-      if deployXML.at_css('Deployment Name') != nil
-        @name = xml_content(deployXML, 'Deployment Name')
-        @status = xml_content(deployXML,'Deployment Status')
-        @url = xml_content(deployXML, 'Deployment Url')
+      if deployXML.at_css("Deployment Name") != nil
+        @name = xml_content(deployXML, "Deployment Name")
+        @status = xml_content(deployXML, "Deployment Status")
+        @url = xml_content(deployXML, "Deployment Url")
         @roles = Hash.new
-        rolesXML = deployXML.css('Deployment RoleInstanceList RoleInstance')
-        rolesListXML = deployXML.css('Deployment RoleList Role')
-        rolesXML.zip(rolesListXML).each do |roleXML,roleListXML|
+        rolesXML = deployXML.css("Deployment RoleInstanceList RoleInstance")
+        rolesListXML = deployXML.css("Deployment RoleList Role")
+        rolesXML.zip(rolesListXML).each do |roleXML, roleListXML|
           role = Role.new(@connection)
           role.parse(roleXML, hostedservicename, @name)
           if role.publicipaddress.to_s.empty?
-            role.publicipaddress = xml_content(deployXML, 'VirtualIPs VirtualIP Address')
+            role.publicipaddress = xml_content(deployXML, "VirtualIPs VirtualIP Address")
           end
           role.parse_role_list_xml(roleListXML)
           @roles[role.name] = role
         end
         @input_endpoints = Array.new
-        endpointsXML = deployXML.css('InputEndpoint')
+        endpointsXML = deployXML.css("InputEndpoint")
         endpointsXML.each do |endpointXML|
           @input_endpoints << parse_endpoint(endpointXML)
         end
         @loadbalancers = Hash.new
-        lbsXML = deployXML.css('Deployment LoadBalancers LoadBalancer')
+        lbsXML = deployXML.css("Deployment LoadBalancers LoadBalancer")
         lbsXML.each do |lbXML|
           loadbalancer = Loadbalancer.new(@connection)
           loadbalancer.parse(lbXML, hostedservicename)
@@ -162,19 +164,19 @@ module Azure
       #roleXML = Nokogiri::XML role.setup(params)
       builder = Nokogiri::XML::Builder.new do |xml|
         xml.Deployment(
-          'xmlns'=>'http://schemas.microsoft.com/windowsazure',
-          'xmlns:i'=>'http://www.w3.org/2001/XMLSchema-instance'
-        ) {
-          xml.Name params['deploy_name']
-          xml.DeploymentSlot 'Production'
-          xml.Label Base64.encode64(params['deploy_name']).strip
-          xml.RoleList { xml.Role('i:type'=>'PersistentVMRole') }
+          "xmlns" => "http://schemas.microsoft.com/windowsazure",
+          "xmlns:i" => "http://www.w3.org/2001/XMLSchema-instance"
+        ) do
+          xml.Name params["deploy_name"]
+          xml.DeploymentSlot "Production"
+          xml.Label Base64.encode64(params["deploy_name"]).strip
+          xml.RoleList { xml.Role("i:type" => "PersistentVMRole") }
           if params[:azure_network_name]
             xml.VirtualNetworkName params[:azure_network_name]
           end
-        }
+        end
       end
-      builder.doc.at_css('Role') << roleXML.at_css('PersistentVMRole').children.to_s
+      builder.doc.at_css("Role") << roleXML.at_css("PersistentVMRole").children.to_s
       builder.doc
     end
 
@@ -191,14 +193,14 @@ module Azure
         hash[key] = xml_content(inputendpoint_xml, key, nil)
       end
       # Protocol could be in there twice... If we have two, pick the second one as the first is for the probe.
-      if inputendpoint_xml.css('Protocol').count > 1
-        hash['Protocol'] = inputendpoint_xml.css('Protocol')[1].content
+      if inputendpoint_xml.css("Protocol").count > 1
+        hash["Protocol"] = inputendpoint_xml.css("Protocol")[1].content
       end
-      probe = inputendpoint_xml.css('LoadBalancerProbe')
+      probe = inputendpoint_xml.css("LoadBalancerProbe")
       if probe
-        hash['LoadBalancerProbe'] = Hash.new
+        hash["LoadBalancerProbe"] = Hash.new
         %w{Path Port Protocol IntervalInSeconds TimeoutInSeconds}.each do |key|
-          hash['LoadBalancerProbe'][key] = xml_content(probe, key, nil)
+          hash["LoadBalancerProbe"][key] = xml_content(probe, key, nil)
         end
       end
       hash