knife-azure 1.4.0.rc.0 → 1.4.0.rc.1

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NDRlZjIwNmQwNWU1NzVlYzA4NGI3MzNjZTJlNmZkMmNlZmEwZDZiNg==
+    YzljMjVkNDdjMGI2MWJmMjBlZmU1ZWYxNTY4MDcxY2IxMDI1YzU3YQ==
   data.tar.gz: !binary |-
-    MDgxYzQ2YTU2NGFlZDA0ZmE3MmM0M2UzM2NkNzFlZGZkNWU3MzQyYg==
+    MDg0MDc2ZTcwMTA4MTViYzI0MWVhYTkwZmZjNzUyOGUxMDcxYzI1ZA==
 SHA512:
   metadata.gz: !binary |-
-    MGIxZTg3ZDEzN2ZlNmIzMzhlYTRhZjdlYjY5OTVkMzRkZDNjMWYzZDBiZjFh
-    NzlhNjRlMTE3ZTQwMGUwYjQxNTc4NDY3ZDNhZDVkZThjMmFlODgwNGZiYWM0
-    MDY0YWRiMmQ5OTYwNjBmZGE3YWY3ZGU2OGFmMWRmZGNjOGM5YWE=
+    OWRhN2NiMjQ3ZjRlM2NiMDVhZTYwMjI5MGY3YjIwMmEyMTJjM2E2MGZkZTUw
+    YzU3NDU4ZDY3NjkzYzQwZjFlMmRjYTQyYzRkNWUyMzA3YjUzMjM4NzgwNGQ5
+    ZGZhMjdjYzY2YTZhZDZlYjYyZjgyMzJjNmQ5Zjk0YTQ3M2NkNzY=
   data.tar.gz: !binary |-
-    NTlkMTM2Mjc3NDQ3ZmNmNmZlOGQwYzk2MGJhM2EyYWIxMjljYzNiMzIxMWU2
-    NTY0NDE3MTk2MjBhOGVmZTA5MzY0YWZiMWJjY2E0MmJmNTBiY2IyMzNmZDlm
-    ZjQ4YWQxYTAxMDZlMWYwYjhiYTdmMGFhZTEwNTcxZjMzZWY2MzY=
+    NjQ1NWFiYzZjMTU3ZWU0YmNlY2JmYzM0MDI2ZDdlZWNmZTJkZTcxY2IwYzU4
+    NGY0MzMyNTE5MjZlNmRlMjI4YmM1Y2RkOTNjZWQyMmE0NGYzNTY4YTE3YWNm
+    NDI5ODU3ZTllNWNkM2QwMTcyMGMwNzAyMjk2NWRhMjBiMzdhOWE=

data/README.md

@@ -1,9 +1,9 @@
 # Knife Azure
 
 ## Description
-A [knife] (http://docs.opscode.com/knife.html) plugin to create,
+A [knife] (http://docs.chef.io/knife.html) plugin to create,
 delete, and enumerate
-[Windows Azure] (https://www.windowsazure.com)
+[Microsoft Azure] (https://azure.microsoft.com)
 resources to be managed by Chef.
 
 ## Installation
@@ -46,13 +46,17 @@ location in your knife.rb:
         
       # List all VM's (including those not be managed by Chef)
       $ knife azure server list
-  
+
+      # Create and bootstrap a Windows VM over winrm (winrm is the default for Windows)
+      $ knife azure server create --azure-dns-name MyNewServerName --azure-vm-size Medium -I a699494373c04fc0bc8f2bb1389d6106__Windows-Server-2012-R2-201412.01-en.us-127GB.vhd --azure-service-location 'West US' --winrm-user myuser --winrm-password 'mypassword'
+
       # Create and bootstrap an Ubuntu VM over ssh
       $ 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'
-  
+
+      # Create and bootstrap an Windows VM through the Azure API --
+      # No winrm or ssh transport or Internet access required
+      $ knife azure server create --azure-dns-name MyNewServerName --azure-vm-size Medium -I a699494373c04fc0bc8f2bb1389d6106__Windows-Server-2012-R2-201412.01-en.us-127GB.vhd --azure-service-location 'West US' --winrm-user myuser --winrm-password 'mypassword' --bootstrap-protocol winrm --bootstrap-protocol cloud-api
+
       # Delete a server and purge it from the Chef server
       $ knife azure server delete MyNewNode --purge -y
 
@@ -84,18 +88,18 @@ Outputs a list of all linux images that are available to use for provisioning. Y
 This subcommand provisions a new server in Azure and then performs a Chef bootstrap. The goal of the bootstrap is to get Chef installed on the target system so it can run Chef Client with a Chef Server.
 
 #### Windows Bootstrapping Requirements
-knife-azure depends on knife-windows: https://github.com/opscode/knife-windows
+knife-azure depends on knife-windows: https://github.com/chef/knife-windows
 to bootstrap Windows machines via winrm (Basic, NTLM and Kerberos authentication) or ssh.
 
-The distro/template to be used for bootstrapping is: https://github.com/opscode/knife-windows/blob/master/lib/chef/knife/bootstrap/windows-chef-client-msi.erb
+The distro/template to be used for bootstrapping is: https://github.com/chef/knife-windows/blob/master/lib/chef/knife/bootstrap/windows-chef-client-msi.erb
 
 Windows source images should have the WinRM service enabled and the
 authentication should be set accordingly (Basic, NTLM and Kerberos). Firewall rules should be added accordingly to the source images. Refer to the link to configure this:
-https://github.com/opscode/knife-windows#nodes
+https://github.com/chef/knife-windows#nodes
 
 #### Azure-specific Options
       :azure_dns_name                   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
+                                        service which is unique within Microsoft 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.
@@ -105,7 +109,7 @@ https://github.com/opscode/knife-windows#nodes
       :azure_source_image               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.
-      :azure_storage_account            A name for the storage account that is unique within Windows Azure.
+      :azure_storage_account            A name for the storage account that is unique within Microsoft 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

data/lib/azure/certificate.rb

@@ -29,6 +29,13 @@ class Azure
       certificate = Certificate.new(@connection)
       certificate.add_certificate certificate_data, certificate_password, certificate_format, dns_name
     end
+
+    def create_ssl_certificate(azure_dns_name)
+      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)
+     end
   end
 end
 
@@ -92,5 +99,112 @@ class Azure
        @connection.query_azure("hostedservices/#{dns_name}/certificates", "post", builder.to_xml)
     end
 
+    ########   SSL certificate generation for knife-azure ssl bootstrap ######
+
+    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
+
+      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 "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
+
+      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]
+      @thumbprint
+    end
+
+    def generate_keypair key_length
+      OpenSSL::PKey::RSA.new(key_length.to_i)
+    end
+
+    def prompt_for_passphrase
+      passphrase = ""
+      begin
+        print "Passphrases do not match.  Try again.\n" unless passphrase.empty?
+        print "Enter certificate passphrase (empty for no passphrase):"
+        passphrase = STDIN.gets
+        return passphrase.strip if passphrase == "\n"
+        print "Enter same passphrase again:"
+        confirm_passphrase = STDIN.gets
+      end until passphrase == confirm_passphrase
+      passphrase.strip
+    end
+
+    def prompt_for_file_path
+      file_path = ''
+      counter = 0
+      begin
+        print "Invalid location! \n" unless file_path.empty?
+        print 'Enter the file path for certificates e.g. C:\Windows (empty for current location):'
+        file_path = STDIN.gets
+        stripped_file_path = file_path.strip
+        return stripped_file_path if file_path == "\n"
+        counter += 1
+        exit(1) if counter == 3
+      end until File.directory?(stripped_file_path)
+      stripped_file_path
+    end
+
+    def prompt_for_domain
+      counter = 0
+      begin
+        print 'Enter the domain (mandatory):'
+        domain = STDIN.gets
+        domain = domain.strip
+        counter += 1
+        exit(1) if counter == 3
+      end until !domain.empty?
+      domain
+    end
+
+    def generate_certificate(rsa_key, cert_params)
+      @hostname = "*"
+      if cert_params[:domain]
+        @hostname = "*." + cert_params[:domain]
+      end
+
+      #Create a self-signed X509 certificate from the rsa_key (unencrypted)
+      cert = OpenSSL::X509::Certificate.new
+      cert.version = 2
+      cert.serial = Random.rand(65534) + 1 # 2 digit byte range random number for better security aspect
+
+      cert.subject = OpenSSL::X509::Name.parse "/CN=#{@hostname}"
+      cert.issuer = cert.subject
+      cert.public_key = rsa_key.public_key
+      cert.not_before = Time.now
+      cert.not_after = cert.not_before + 2 * 365 * cert_params[:cert_validity].to_i * 60 * 60 # 2 years validity
+      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("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
+      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)
+      File.open(file_path + ".pfx", "wb") { |f| f.print pfx.to_der }
+      File.open(file_path + ".b64", "wb") { |f| f.print Base64.strict_encode64(pfx.to_der) }
+    end
+
+    ##########   SSL certificate generation ends ###########
+
+
   end
 end

data/lib/azure/deploy.rb

@@ -81,7 +81,11 @@ class Azure
       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")
+        thumbprint = @connection.certificates.create_ssl_certificate params[:azure_dns_name]
+        params[:ssl_cert_fingerprint] = thumbprint.to_s.upcase
       end
+
       params['deploy_name'] = get_deploy_name_for_hostedservice(params[:azure_dns_name])
 
       if params['deploy_name'] != nil

data/lib/azure/vnet.rb

@@ -63,26 +63,55 @@ class Azure
 
     def parse(image)
       @name = image.at_css('Name').content
-      @affinity_group = image.at_css('AffinityGroup').content
+      @affinity_group = image.at_css('AffinityGroup') ? image.at_css('AffinityGroup').content : ""
       @state = image.at_css('State').content
       self
     end
 
     def create(params)
       response = @connection.query_azure('networking/media')
-      vnets = response.css('VirtualNetworkSite')
-      vnet = nil
-      vnets.each { |vn| vnet = vn if vn['name'] == params[:azure_vnet_name] }
-      add = vnet.nil?
-      vnet = Nokogiri::XML::Node.new('VirtualNetworkSite', response) if add
-      vnet['name'] = params[:azure_vnet_name]
-      vnet['AffinityGroup'] = params[:azure_ag_name]
-      addr_space = Nokogiri::XML::Node.new('AddressSpace', response)
-      addr_prefix = Nokogiri::XML::Node.new('AddressPrefix', response)
-      addr_prefix.content = params[:azure_address_space]
-      addr_space.children = addr_prefix
-      vnet.children = addr_space
-      vnets.last.add_next_sibling(vnet) if add
+      if response.at_css("Error") && response.at_css('Code').text == "ResourceNotFound"
+        builder = Nokogiri::XML::Builder.new do |xml|
+          xml.NetworkConfiguration(
+            'xmlns'=>'http://schemas.microsoft.com/ServiceHosting/2011/07/NetworkConfiguration'
+          ) {
+
+            xml.VirtualNetworkConfiguration {
+              xml.VirtualNetworkSites {
+                xml.VirtualNetworkSite('name' => params[:azure_vnet_name], 'AffinityGroup' => params[:azure_ag_name]) {
+                  if params[:azure_address_space]
+                    xml.AddressSpace {
+                      xml.AddressPrefix params[:azure_address_space]
+                    }
+                  end
+                  xml.Subnets{
+                    xml.Subnet('name' => params[:azure_subnet_name]) {
+                      xml.AddressPrefix params[:azure_address_space]
+                    }
+                  }
+                }
+              }
+            }
+          }
+        end
+        puts("Creating New Virtual Network: #{params[:azure_vnet_name]}...")
+        response = builder
+      else
+        vnets = response.css('VirtualNetworkSite')
+        vnet = nil
+        vnets.each { |vn| vnet = vn if vn['name'] == params[:azure_vnet_name] }
+        add = vnet.nil?
+        vnet = Nokogiri::XML::Node.new('VirtualNetworkSite', response) if add
+        vnet['name'] = params[:azure_vnet_name]
+        vnet['AffinityGroup'] = params[:azure_ag_name]
+        addr_space = Nokogiri::XML::Node.new('AddressSpace', response)
+        addr_prefix = Nokogiri::XML::Node.new('AddressPrefix', response)
+        addr_prefix.content = params[:azure_address_space]
+        addr_space.children = addr_prefix
+        vnet.children = addr_space
+        vnets.last.add_next_sibling(vnet) if add
+        puts("Updating existing Virtual Network: #{params[:azure_vnet_name]}...")
+      end
       @connection.query_azure('networking/media', 'put', response.to_xml)
     end
   end

data/lib/chef/knife/azure_server_create.rb

@@ -40,6 +40,7 @@ class Chef
 
       def load_winrm_deps
         require 'winrm'
+        require 'em-winrm'
         require 'chef/knife/winrm'
         require 'chef/knife/bootstrap_windows_winrm'
       end
@@ -71,8 +72,7 @@ class Chef
 
       option :ssh_port,
         :long => "--ssh-port PORT",
-        :description => "The ssh port. Default is 22.",
-        :default => '22'
+        :description => "The ssh port. Default is 22. If --azure-connect-to-existing-dns set then default SSH port is random"
 
       option :prerelease,
         :long => "--prerelease",
@@ -190,6 +190,16 @@ class Chef
         :long => "--azure-subnet-name SUBNET_NAME",
         :description => "Optional. Specifies the subnet of virtual machine"
 
+      option :azure_vm_startup_timeout,
+        :long => "--azure-vm-startup-timeout TIMEOUT",
+        :description => "The number of minutes that knife-azure will wait for the virtual machine to reach the 'provisioning' state. Default is 10.",
+        :default => 10
+
+      option :azure_vm_ready_timeout,
+        :long => "--azure-vm-ready-timeout TIMEOUT",
+        :description => "The number of minutes that knife-azure will wait for the virtual machine state to transition from 'provisioning' to 'ready'. Default is 15.",
+        :default => 15 
+
       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"
@@ -225,6 +235,12 @@ class Chef
         :long => "--cert-path PATH",
         :description => "SSL Certificate Path"
 
+      option :auto_update_client,
+      :long => "--auto-update-client",
+      :boolean => true,
+      :default => false,
+      :description => "Set this flag to enable auto chef client update in azure chef extension. This flag should be used with cloud-api bootstrap protocol only"
+
       def strip_non_ascii(string)
         string.gsub(/[^0-9a-z ]/i, '')
       end
@@ -236,12 +252,15 @@ class Chef
       def wait_until_virtual_machine_ready(retry_interval_in_seconds = 30)
 
         vm_status = nil
+
         puts
 
         begin
-          vm_status = wait_for_virtual_machine_state(:vm_status_provisioning, 5, retry_interval_in_seconds)
+          azure_vm_startup_timeout = locate_config_value(:azure_vm_startup_timeout).to_i
+          azure_vm_ready_timeout = locate_config_value(:azure_vm_ready_timeout).to_i
+          vm_status = wait_for_virtual_machine_state(:vm_status_provisioning, azure_vm_startup_timeout, retry_interval_in_seconds)
           if vm_status != :vm_status_ready
-            wait_for_virtual_machine_state(:vm_status_ready, 15, retry_interval_in_seconds)
+            wait_for_virtual_machine_state(:vm_status_ready, azure_vm_ready_timeout, retry_interval_in_seconds)
           end
 
           msg_server_summary(get_role_server())
@@ -590,7 +609,7 @@ class Chef
             bootstrap.config[:winrm_user] = locate_config_value(:winrm_user) || 'Administrator'
             bootstrap.config[:winrm_password] = locate_config_value(:winrm_password)
             bootstrap.config[:winrm_transport] = locate_config_value(:winrm_transport)
-
+            bootstrap.config[:winrm_authentication_protocol] = locate_config_value(:winrm_authentication_protocol)
             bootstrap.config[:winrm_port] = port
 
         elsif locate_config_value(:bootstrap_protocol) == 'ssh'
@@ -653,6 +672,7 @@ class Chef
           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.")
           exit 1
@@ -661,6 +681,11 @@ class Chef
           exit 1
         end
 
+        if locate_config_value(:winrm_authentication_protocol) && ! %w{basic negotiate kerberos}.include?(locate_config_value(:winrm_authentication_protocol))
+          ui.error("Invalid value for --winrm-authentication-protocol option. Use valid protocol values i.e [basic, negotiate, kerberos]")
+          exit 1
+        end
+
         if !(connection.images.exists?(locate_config_value(:azure_source_image)))
           ui.error("Image provided is invalid")
           exit 1
@@ -687,19 +712,22 @@ class Chef
           :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)
+          :cert_password => locate_config_value(:cert_passphrase),
+          :winrm_transport => locate_config_value(:winrm_transport)
         }
         # 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
+          if locate_config_value(:azure_connect_to_existing_dns)
+            port = locate_config_value(:ssh_port) || Random.rand(64000) + 1000
+          else
+            port = locate_config_value(:ssh_port) || '22'
           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
+          if locate_config_value(:azure_connect_to_existing_dns)
+            port = locate_config_value(:winrm_port) || Random.rand(64000) + 1000
+          else
+            port = locate_config_value(:winrm_port) || '5985'
           end
         end
 
@@ -724,6 +752,11 @@ class Chef
               ui.error("WinRM User is compulsory parameter and it cannot be named 'admin*'")
               exit 1
             end
+            # take cares of when user name contains domain
+            # azure add role api doesn't support '\\' in user name
+            if locate_config_value(:winrm_user) && locate_config_value(:winrm_user).split("\\").length.eql?(2)
+              server_def[:winrm_user] = locate_config_value(:winrm_user).split("\\")[1]
+            end
           else
             if not locate_config_value(:ssh_user)
               ui.error("SSH User is compulsory parameter")
@@ -763,13 +796,14 @@ class Chef
       # 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
+        extensions.css("Version").max.text.split(".").first + ".*"
       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
+        pub_config[:autoUpdateClient] = locate_config_value(:auto_update_client) ? "true" : "false"
         Base64.encode64(pub_config.to_json)
       end
 

data/lib/chef/knife/azure_vnet_create.rb

@@ -42,6 +42,11 @@ class Chef
         :description =>
           'Specifies the address space of the vnet using CIDR notation.'
 
+      option :azure_subnet_name,
+        :long => '--azure-subnet-name CIDR',
+        :description =>
+          'Specifies the Subnet Name.'
+
       def run
         $stdout.sync = true
 
@@ -57,6 +62,7 @@ class Chef
           azure_vnet_name: locate_config_value(:azure_network_name),
           azure_ag_name: locate_config_value(:azure_affinity_group),
           azure_address_space: locate_config_value(:azure_address_space),
+          azure_subnet_name: locate_config_value(:azure_subnet_name) || "Subnet-#{Random.rand(10)}"
         }
 
         rsp = connection.vnets.create(params)

data/lib/knife-azure/version.rb

@@ -1,6 +1,6 @@
 module Knife
   module Azure
-    VERSION = "1.4.0.rc.0"
+    VERSION = "1.4.0.rc.1"
     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.4.0.rc.0
+  version: 1.4.0.rc.1
 platform: ruby
 authors:
 - Barry Davis
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-02 00:00:00.000000000 Z
+date: 2015-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -46,6 +46,9 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 11.8.2
+    - - <
+      - !ruby/object:Gem::Version
+        version: '12'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -53,6 +56,9 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 11.8.2
+    - - <
+      - !ruby/object:Gem::Version
+        version: '12'
 - !ruby/object:Gem::Dependency
   name: mixlib-config
   requirement: !ruby/object:Gem::Requirement