knife-azure 1.5.2 → 1.6.0.rc.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 611f6298817cb44acba68217bb0f4cb494ce8ec5
-  data.tar.gz: 6ae5e4ece790fef2169048b65cc8cce43b6d1a33
+  metadata.gz: 0d3c8d33de70a5a13ab8266a296901adc92470ce
+  data.tar.gz: e96796e88386edfea3100daf1248d025eaff0610
 SHA512:
-  metadata.gz: 00339f1a2006e09aa8f293d41bca859e9bf69e2010b8bd0ed671ca3bd46b16c9aaad83d1dd69c473777a7d70fc5000eff2b77b374ba5865016ce9e4ebc698735
-  data.tar.gz: 4147e95dc4f060bae0f3ad6924e9cd26a81041e6167547b8f7741fd3c571447d72a278316c868bc4cd2be6273e2878e5fc187cc1f4cfb40064d9036ae64b983a
+  metadata.gz: 83df38d52600057e3b877bb03c46a28da6614c166a0286f66dd3bb0ac0d657e3f68875cffb2c917e438f20581e5e9cbcf174e0d5673b2ba6ac73386a4ab0e652
+  data.tar.gz: aae9e02a525a0f023632a5335b509a95fb7a8f8ad4d2c9fc436f587f9b8b76620310ec330288deb8ab0dbecd077416ad13217163bb234287cbe313aa8e3b210a

data/README.md

@@ -7,14 +7,14 @@ delete, and enumerate
 resources to be managed by Chef.
 
 ## Installation
-Be sure you are running the latest version of Chef, which can be installed
+Be sure you are running the latest version of Chef DK, which can be installed
 via:
 
-    gem install chef
+    https://downloads.chef.io/chef-dk/
 
 This plugin is distributed as a Ruby Gem. To install it, run:
 
-    gem install knife-azure
+    chef gem install knife-azure
 
 Depending on your system's configuration, you may need to run this command
 with root/administrator privileges.
@@ -272,8 +272,20 @@ In general, systems bootstrapped via `cloud-api` do not require incoming or outg
                 --bootstrap-protocol 'cloud-api'
                 --delete-chef-extension-config
 
+We have also added cloud-api support for Centos now, for this you just need to select centos image in above example.
+
 `--delete-chef-extension-config` determines if Chef configuration files should be removed when Azure removes the Chef resource extension from the VM or not. This option is only valid for the 'cloud-api' bootstrap protocol. The default value is false. This is useful when `update` and `uninstall` commands are run for the extension on the VM created.
 
+#### Azure Server Create with Domain Join
+Following options are used for creating server with domain join
+
+    :azure_domain_name      Specifies the domain name to join. If the domains name is not specified, --azure-domain-user must specify the user principal name (UPN) format (user@fully-qualified-DNS-domain) or the fully-qualified-DNS-domain\\username format
+    :azure_domain_user      Specifies the username who has access to join the domain.Supported format: username(if domain is already specified in --azure-domain-name option),fully-qualified-DNS-domain\username, user@fully-qualified-DNS-domain
+    :azure_domain_passwd    Specifies the password for domain user who has access to join the domain
+
+    Command:
+    knife azure server create -I a699494373c04fc0bc8f2bb1389d6106__Windows-Server-2012-Datacenter-20151022-en.us-127GB.vhd --azure-vm-size Medium  -x 'azure' -P 'admin@123' --azure-domain-passwd 'admin@123' --azure-domain-user 'some.domain.com\user' --azure-domain-name 'some.domain.com' -c '~\chef-repo\.chef\knife.rb' --azure-network-name 'mynetwork' --azure-subnet-name 'subnet1' --azure-service-location 'West US'
+
 
 ### Azure Server Delete Subcommand
 Deletes an existing server in the currently configured Azure account. By

data/lib/azure/role.rb

@@ -305,6 +305,7 @@ class Azure
     end
 
     def setup(params)
+      azure_user_domain_name = params[:azure_user_domain_name] || params[:azure_domain_name]
       builder = Nokogiri::XML::Builder.new do |xml|
         xml.PersistentVMRole(
           'xmlns'=>'http://schemas.microsoft.com/windowsazure',
@@ -345,7 +346,7 @@ class Azure
                 if params[:azure_domain_name]
                   xml.DomainJoin {
                     xml.Credentials {
-                      xml.Domain params[:azure_domain_name]
+                      xml.Domain azure_user_domain_name
                      xml.Username params[:azure_domain_user]
                     xml.Password params[:azure_domain_passwd]
                    }

data/lib/azure/vnet.rb

@@ -104,15 +104,31 @@ class Azure
         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)
+        if add || !vnet.at_css('AddressSpace')    ## create a new AddressSpace block in XML if VNet or AddressSpace block does not already exist
+          addr_space = Nokogiri::XML::Node.new('AddressSpace', response)
+        else    ## retrieve object of existing AddressSpace if VNet or AddressSpace already exist
+          addr_space = vnet.at_css('AddressSpace')
+        end
         addr_prefix = Nokogiri::XML::Node.new('AddressPrefix', response)
         addr_prefix.content = params[:azure_address_space]
+        if add || !vnet.at_css('Subnets')   ## create a new Subnets block in XML if VNet or Subnets block does not already exist
+          subnets = Nokogiri::XML::Node.new('Subnets', response)
+        else    ## retrieve object of existing Subnets if VNet or Subnets already exist
+          subnets = vnet.at_css('Subnets')
+        end
+        saddr_prefix = Nokogiri::XML::Node.new('AddressPrefix', response)
+        saddr_prefix.content = params[:azure_address_space]
+        subnet = Nokogiri::XML::Node.new('Subnet', response)
+        subnet['name'] = params[:azure_subnet_name]
+        subnet.children = saddr_prefix
+        subnets.children = subnet
+        vnet.add_child(subnets) if add || !vnet.at_css('Subnets')
         addr_space.children = addr_prefix
-        vnet.children = addr_space
+        vnet.add_child(addr_space) if add || !vnet.at_css('AddressSpace')
         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
-end
+end

data/lib/chef/knife/azure_server_create.rb

@@ -139,6 +139,11 @@ class Chef
         :description => "Verify the SSL cert for HTTPS requests to the Chef server API.",
         :boolean     => true
 
+      option :bootstrap_proxy,
+            :long => "--bootstrap-proxy PROXY_URL",
+            :description => "The proxy server for the node being bootstrapped",
+            :proc => Proc.new { |p| Chef::Config[:knife][:bootstrap_proxy] = p }
+
       option :bootstrap_no_proxy,
         :long => "--bootstrap-no-proxy [NO_PROXY_URL|NO_PROXY_IP]",
         :description => "Do not proxy locations for the node being bootstrapped; this option is used internally by Opscode",
@@ -349,12 +354,18 @@ class Chef
 
       option :azure_domain_user,
         :long => "--azure-domain-user DOMAIN_USER_NAME",
-        :description => "Optional. Specifies the username who has access to join the domain."
+        :description => 'Optional. Specifies the username who has access to join the domain.
+          Supported format: username(if domain is already specified in --azure-domain-name option),
+          fully-qualified-DNS-domain\username, user@fully-qualified-DNS-domain'
 
       option :azure_domain_passwd,
         :long => "--azure-domain-passwd DOMAIN_PASSWD",
         :description => "Optional. Specifies the password for domain user who has access to join the domain."
 
+      option :azure_extension_client_config,
+        :long => "--azure-extension-client-config CLIENT_PATH",
+        :description => "Optional. Path to a client.rb file for use by the bootstrapped node. Only honored when --bootstrap-protocol is set to `cloud-api`."
+
       def strip_non_ascii(string)
         string.gsub(/[^0-9a-z ]/i, '')
       end
@@ -873,22 +884,6 @@ class Chef
           :winrm_max_timeout => locate_config_value(:winrm_max_timeout).to_i * 60 * 1000, #converting minutes to milliseconds
           :winrm_max_memoryPerShell => locate_config_value(:winrm_max_memory_per_shell)
         }
-        # 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? && locate_config_value(:bootstrap_protocol) == 'winrm'
-          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
-        elsif locate_config_value(:bootstrap_protocol) == 'ssh'
-          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
-        end
-        server_def[:port] = port
 
         if locate_config_value(:bootstrap_protocol) == 'cloud-api'
           server_def[:chef_extension] = get_chef_extension_name
@@ -925,6 +920,7 @@ class Chef
             end
           end
         end
+
         if is_image_windows?
           server_def[:os_type] = 'Windows'
           server_def[:admin_password] = locate_config_value(:winrm_password)
@@ -938,24 +934,37 @@ class Chef
           server_def[:identity_file_passphrase] = locate_config_value(:identity_file_passphrase)
         end
 
+        azure_connect_to_existing_dns = locate_config_value(:azure_connect_to_existing_dns)
+        if is_image_windows? && server_def[:bootstrap_proto] == 'winrm'
+          port = locate_config_value(:winrm_port) || '5985'
+          port = locate_config_value(:winrm_port) || Random.rand(64000) + 1000 if azure_connect_to_existing_dns
+        elsif server_def[:bootstrap_proto] == 'ssh'
+          port = locate_config_value(:ssh_port) || '22'
+          port = locate_config_value(:ssh_port) || Random.rand(64000) + 1000 if azure_connect_to_existing_dns
+        end
+
+        server_def[:port] = port
+
         server_def[:is_vm_image] = connection.images.is_vm_image(locate_config_value(:azure_source_image))
+        server_def[:azure_domain_name] = locate_config_value(:azure_domain_name) if locate_config_value(:azure_domain_name)
 
-        if locate_config_value(:azure_domain_name)
-          server_def[:azure_domain_name] = locate_config_value(:azure_domain_name)
-          server_def[:azure_domain_user] = locate_config_value(:azure_domain_user)
-        elsif locate_config_value(:azure_domain_user)
+        if locate_config_value(:azure_domain_user)
           # extract domain name since it should be part of username
           case locate_config_value(:azure_domain_user)
           when /(\S+)\\(.+)/  # format - fully-qualified-DNS-domain\username
-            server_def[:azure_domain_name] = $1
+            server_def[:azure_domain_name] = $1 if locate_config_value(:azure_domain_name).nil?
+            server_def[:azure_user_domain_name] = $1
             server_def[:azure_domain_user] = $2
           when /(.+)@(\S+)/  # format - user@fully-qualified-DNS-domain
-            server_def[:azure_domain_name] = $2
+            server_def[:azure_domain_name] = $2 if locate_config_value(:azure_domain_name).nil?
+            server_def[:azure_user_domain_name] = $2
             server_def[:azure_domain_user] = $1
           else
-            # Format error.
-            ui.error("Format error for --azure-domain-user option. Supported format are user principal name (UPN) format (user@fully-qualified-DNS-domain) or the fully-qualified-DNS-domain\\username format")
-            exit 1
+            if locate_config_value(:azure_domain_name).nil?
+              ui.error('--azure-domain-name should be specified if --azure-domain-user is not in one of the following formats: fully-qualified-DNS-domain\username, user@fully-qualified-DNS-domain')
+              exit 1
+            end
+            server_def[:azure_domain_user] = locate_config_value(:azure_domain_user)
           end
         end
         server_def[:azure_domain_passwd] = locate_config_value(:azure_domain_passwd)
@@ -983,7 +992,12 @@ class Chef
 
       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}"
+        if(locate_config_value(:azure_extension_client_config))
+          pub_config[:client_rb] = File.read(locate_config_value(:azure_extension_client_config))
+        else
+          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}"
+        end
+
         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"
         pub_config[:deleteChefConfig] = locate_config_value(:delete_chef_extension_config) ? "true" : "false"
@@ -997,6 +1011,9 @@ class Chef
         pub_config[:bootstrap_options][:chef_server_url] = Chef::Config[:chef_server_url] if Chef::Config[:chef_server_url]
         pub_config[:bootstrap_options][:validation_client_name] = Chef::Config[:validation_client_name] if Chef::Config[:validation_client_name]
         pub_config[:bootstrap_options][:node_verify_api_cert] = locate_config_value(:node_verify_api_cert) ? "true" : "false" if config.key?(:node_verify_api_cert)
+        pub_config[:bootstrap_options][:bootstrap_version] = locate_config_value(:bootstrap_version) if locate_config_value(:bootstrap_version)
+        pub_config[:bootstrap_options][:node_ssl_verify_mode] = locate_config_value(:node_ssl_verify_mode) if locate_config_value(:node_ssl_verify_mode)
+        pub_config[:bootstrap_options][:bootstrap_proxy] = locate_config_value(:bootstrap_proxy) if locate_config_value(:bootstrap_proxy)
         Base64.encode64(pub_config.to_json)
       end
 
@@ -1023,6 +1040,16 @@ class Chef
         else
           pri_config[:validation_key] = File.read(Chef::Config[:validation_key])
         end
+
+        # SSL cert bootstrap support
+        if locate_config_value(:cert_path)
+          if File.exist?(File.expand_path(locate_config_value(:cert_path)))
+            pri_config[:chef_server_crt] = File.read(locate_config_value(:cert_path))
+          else
+            ui.error('Specified SSL certificate does not exist.')
+            exit 1
+          end
+        end
         Base64.encode64(pri_config.to_json)
       end
 

data/lib/knife-azure/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: knife-azure
 version: !ruby/object:Gem::Version
-  version: 1.5.2
+  version: 1.6.0.rc.0
 platform: ruby
 authors:
 - Barry Davis
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-06 00:00:00.000000000 Z
+date: 2015-11-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri