knife-azure 1.5.1.rc.1 → 1.5.1.rc.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b155513dd741133385af7bca60fdd5453f127747
-  data.tar.gz: 7e8bf7e30c23627796a11fc8edd9e6e1f02c4d92
+  metadata.gz: 77a080a603467387d888d6063ecd0ac4602ab8b4
+  data.tar.gz: 91e38b9592db815f0119cc346e0e169713719df4
 SHA512:
-  metadata.gz: 50bb073dc94f302d783ba9ab342456a9a820e1872242279b1572b16e4ef4706a7d4f26bd048a2275704a5d838ba312e3e5268384cd6c85ab6fefd449eae07255
-  data.tar.gz: f8de73b32d14eda508ab58a4322f9a2d06d12e5291c5f0233765f163da9808b3778e37bf3aa3ea0b4e8f59708f4e40a9ad3aae6472ff161ea499f5f0a9607210
+  metadata.gz: c796c6ce3df502f4825a3c516201cac9603854f149dace38cc771c1b7264c41738a7a7eed5356b16c61c6152207c7659b999f5514a04f64636ea2c4fa2e3f392
+  data.tar.gz: 56f16f843a22a121c2fba17567e8baf886978057a7b219fd651d3b8d0408a2bf280c33b09841fdc966880d7f8b3c1d5441e9a717190bc304613149e12bc4f4b0

data/README.md

@@ -189,6 +189,20 @@ These options may also be configured from knife.rb, as in this example:
     knife[:tcp-endpoints]='80:80,3389:5678'
     knife[:udp-endpoints]='123:123'
 
+#### Endpoint configuration
+
+Endpoints are configured using tcp-endpoints and udp-endpoints. This is a string in the form:
+{localPort}:{publicPort}:{load_balancer_set_name}:{load_balancer_probe_path}
+
+Examples:
+
+    knife[:tcp-endpoints]='80'                            # Allow Port 80 inbound
+    knife[:tcp-endpoints]='80:8080'                       # Allow Port 80 inbound and map it to local port 8080
+    knife[:tcp-endpoints]='80:8080:web-set'               # Allow Port 80 and add it to the load balancing set called 'web-set'
+    knife[:tcp-endpoints]='80:8080:web-set:/healthcheck'  # Allow Port 80, add it to the load balancing set, and use an HTTP probe at path "/healthcheck"
+
+Note that the load balancing set will be created if it does not exist. If it exists within another VM in the cloud service, it will re-use those values for the probe.
+
 #### Options for Bootstrapping a Windows Node in Azure
 
     :bootstrap_protocol           Default is winrm for a windows image
@@ -294,6 +308,20 @@ Knife options:
     :azure_service_location     Specifies the geographic location.
     :azure_ag_desc              Optional. Description for new affinity group.
 
+### Azure Internal LB List Subcommand
+Outputs a lit of defined load balancers for all cloud services. Public facing load balancers are not shown here.
+
+### Azure Internal LB Create Subcommand
+Creates a new Internal Load Balancer within a cloud service.
+
+    knife azure internal lb create -n 'my_lb' --azure-lb-static-vip '10.0.0.123' --azure-subnet_name 'Subnet_1' --azure-dns-name 'service_name'
+
+Knife options:
+      :azure_load_balancer      Required. Specifies the name of the Load Balancer.
+      :azure_lb_static_vip      Optional. Allows you to set a static IP for the VIP.
+      :azure_subnet_name        Required ONLY IF azure_lb_static_ip is set. Specifies the subnet that the static IP resides in.
+      :azure_dns_name           Required. The cloud service that this internal Load Balancer will be added to.
+
 ### Azure Vnet List Subcommand
 Outputs a list of defined virtual networks in the azure subscription.
 

data/lib/azure/connection.rb

@@ -25,6 +25,7 @@ require File.expand_path('../disk', __FILE__)
 require File.expand_path('../image', __FILE__)
 require File.expand_path('../certificate', __FILE__)
 require File.expand_path('../ag', __FILE__)
+require File.expand_path('../loadbalancer', __FILE__)
 require File.expand_path('../vnet', __FILE__)
 
 class Azure
@@ -32,7 +33,7 @@ class Azure
     include AzureAPI
     include AzureUtility
     attr_accessor :hosts, :rest, :images, :deploys, :roles,
-                  :disks, :storageaccounts, :certificates, :ags, :vnets
+                  :disks, :storageaccounts, :certificates, :ags, :vnets, :lbs
     def initialize(params={})
       @rest = Rest.new(params)
       @hosts = Hosts.new(self)
@@ -44,6 +45,7 @@ class Azure
       @certificates = Certificates.new(self)
       @ags = AGs.new(self)
       @vnets = Vnets.new(self)
+      @lbs = Loadbalancers.new(self)
     end
 
     def query_azure(service_name,
@@ -67,7 +69,7 @@ class 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.warn 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
         end
@@ -78,7 +80,7 @@ class Azure
       status = 'InProgress'
       Chef::Log.info 'Waiting while status returns InProgress'
       while status == 'InProgress'
-        response = @rest.query_for_completion()       
+        response = @rest.query_for_completion()
         ret_val = Nokogiri::XML response.body
         status = xml_content(ret_val,'Status')
         if status == 'InProgress'
@@ -88,7 +90,7 @@ class Azure
           Chef::Log.debug 'not InProgress : ' + ret_val.to_xml
         else
           error_code, error_message = error_from_response_xml(ret_val)
-          Chef::Log.warn 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/deploy.rb

@@ -116,7 +116,7 @@ class Azure
 
   class Deploy
     include AzureUtility
-    attr_accessor :connection, :name, :status, :url, :hostedservicename
+    attr_accessor :connection, :name, :status, :url, :hostedservicename, :input_endpoints, :loadbalancers
 
     def initialize(connection)
       @connection = connection
@@ -135,8 +135,21 @@ class Azure
           role.parse(roleXML, hostedservicename, @name)
           @roles[role.name] = role
         end
+        @input_endpoints = Array.new
+        endpointsXML = deployXML.css('InputEndpoint')
+        endpointsXML.each do |endpointXML|
+          @input_endpoints << parse_endpoint(endpointXML)
+        end
+        @loadbalancers = Hash.new
+        lbsXML = deployXML.css('Deployment LoadBalancers LoadBalancer')
+        lbsXML.each do |lbXML|
+          loadbalancer = Loadbalancer.new(@connection)
+          loadbalancer.parse(lbXML, hostedservicename)
+          @loadbalancers[loadbalancer.name] = loadbalancer
+        end
       end
     end
+
     def setup(params)
       role = Role.new(@connection)
       roleXML = role.setup(params)
@@ -158,11 +171,33 @@ class Azure
       builder.doc.at_css('Role') << roleXML.at_css('PersistentVMRole').children.to_s
       builder.doc
     end
+
     def create(params, deployXML)
       servicecall = "hostedservices/#{params[:azure_dns_name]}/deployments"
       @connection.query_azure(servicecall, "post", deployXML.to_xml)
     end
 
+    # This parses endpoints from a RoleList-Role-InputEndpoint, NOT a RoleInstanceList-RoleInstance-InstanceEndpoint
+    # Refactor: make this an object rather than a hash..?
+    def parse_endpoint(inputendpoint_xml)
+      hash = Hash.new
+      %w{LoadBalancedEndpointSetName LocalPort Name Port Protocol EnableDirectServerReturn LoadBalancerName IdleTimeoutInMinutes}.each do |key|
+        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
+      end
+      probe = inputendpoint_xml.css('LoadBalancerProbe')
+      if probe
+        hash['LoadBalancerProbe'] = Hash.new
+        %w{Path Port Protocol IntervalInSeconds TimeoutInSeconds}.each do |key|
+          hash['LoadBalancerProbe'][key] = xml_content(probe, key, nil)
+        end
+      end
+      hash
+    end
+
     def roles
       @roles.values if @roles
     end

data/lib/azure/host.rb

@@ -56,7 +56,7 @@ class Azure
       ret_val = @connection.query_azure("hostedservices/#{name}")
       error_code, error_message = error_from_response_xml(ret_val) if ret_val
       if ret_val.nil? || error_code.length > 0
-        Chef::Log.warn('Unable to find hosted(cloud) service:' + error_code + ' : ' + error_message) if ret_val
+        Chef::Log.debug('Unable to find hosted(cloud) service:' + error_code + ' : ' + error_message) if ret_val
         false
       else
         true

data/lib/azure/loadbalancer.rb

@@ -0,0 +1,92 @@
+#
+# Author:: Aiman Alsari (aiman.alsari@gmail.com)
+# Copyright:: Copyright (c) 2013 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+class Azure
+  class Loadbalancers
+
+    def initialize(connection)
+      @connection = connection
+    end
+
+    def load
+      @lbs ||= begin
+        @lbs = Hash.new
+        @connection.deploys.all.each do |deploy|
+          @lbs.merge!(deploy.loadbalancers)
+        end
+        @lbs
+      end
+    end
+
+    def all
+      load.values
+    end
+
+    def exists?(name)
+      load.key?(name)
+    end
+
+    def find(name)
+      load[name]
+    end
+
+    def create(params)
+      lb = Loadbalancer.new(@connection)
+      lb.create(params)
+    end
+  end
+end
+
+class Azure
+  class Loadbalancer
+    include AzureUtility
+    attr_accessor :name, :service, :subnet, :vip
+
+    def initialize(connection)
+      @connection = connection
+    end
+
+    def parse(lbXML, hostedservicename)
+      @name = xml_content(lbXML, 'Name')
+      ip_configXML = lbXML.css('FrontendIpConfiguration')
+      @subnet = xml_content(ip_configXML, 'SubnetName')
+      @vip = xml_content(ip_configXML, 'StaticVirtualNetworkIPAddress')
+      @service = hostedservicename
+      self
+    end
+
+    def create(params)
+      if params[:azure_lb_static_vip] && !params[:azure_subnet_name]
+        Chef::Log.fatal 'Unable to create Loadbalancer, :azure_subnet_name needs to be set if :azure_lb_static_vip is set'
+      end
+      builder = Nokogiri::XML::Builder.new(encoding: 'utf-8') do |xml|
+        xml.LoadBalancer(xmlns: 'http://schemas.microsoft.com/windowsazure') {
+          xml.Name params[:azure_load_balancer]
+          xml.FrontendIpConfiguration {
+            xml.Type 'Private'
+            xml.SubnetName params[:azure_subnet_name] if params[:azure_subnet_name]
+            xml.StaticVirtualNetworkIPAddress params[:azure_lb_static_vip] if params[:azure_lb_static_vip]
+          }
+        }
+      end
+      deploy_name = @connection.deploys.get_deploy_name_for_hostedservice(params[:azure_dns_name])
+      servicecall = "hostedservices/#{params[:azure_dns_name]}/deployments/#{deploy_name}/loadbalancers"
+      @connection.query_azure(servicecall, "post", builder.doc.to_xml)
+    end
+  end
+end

data/lib/azure/rest.rb

@@ -97,7 +97,7 @@ module AzureAPI
         request = Net::HTTP::Put.new(uri.request_uri)
       end
       text = verb == 'put'
-      request["x-ms-version"] = "2014-04-01"
+      request["x-ms-version"] = "2014-05-01"
       request["content-type"] = text ? "text/plain" : "application/xml"
       request["accept"] = "application/xml"
       request["accept-charset"] = "utf-8"

data/lib/azure/role.rb

@@ -176,9 +176,28 @@ class Azure
     attr_accessor :winrmport
     attr_accessor :hostname, :tcpports, :udpports
 
+      TCP_ENDPOINTS_MAPPING = { '3389' => 'Remote Desktop',
+                              '5986' => 'PowerShell',
+                              '22' => 'SSH',
+                              '21' => 'FTP',
+                              '25' => 'SMTP',
+                              '53' => 'DNS',
+                              '80' => 'HTTP',
+                              '110' => 'POP3',
+                              '143' => 'IMAP',
+                              '389' => 'LDAP',
+                              '443' => 'HTTPs',
+                              '587' => 'SMTPS',
+                              '995' => 'POP3S',
+                              '993' => 'IMAPS',
+                              '1433' => 'MSSQL',
+                              '3306' => 'MySQL'
+                              }
+
     def initialize(connection)
       @connection = connection
     end
+
     def parse(roleXML, hostedservicename, deployname)
       @name = xml_content(roleXML, 'RoleName')
       @status = xml_content(roleXML, 'InstanceStatus')
@@ -204,6 +223,7 @@ class Azure
           hash['Vip'] = xml_content(endpoint, 'Vip')
           hash['PublicPort'] = xml_content(endpoint, 'PublicPort')
           hash['LocalPort'] = xml_content(endpoint, 'LocalPort')
+
           if xml_content(endpoint, 'Protocol') == 'tcp'
             @tcpports << hash
           else # == 'udp'
@@ -213,6 +233,72 @@ class Azure
       end
     end
 
+    # Expects endpoint_param_string to be in the form {localport}:{publicport}:{lb_set_name}:{lb_probe_path}
+    # Only localport is mandatory.
+    def parse_endpoint_from_params(protocol, azure_vm_name, endpoint_param_string)
+      fields = endpoint_param_string.split(':').map(&:strip)
+      hash = {}
+      hash['LocalPort'] = fields[0]
+      hash['Port'] = fields[1] || fields[0]
+      hash['LoadBalancerName'] = fields[2] if fields[2] != 'EXTERNAL' # TODO: hackity hack.. Shouldn't use magic words.
+      hash['LoadBalancedEndpointSetName'] = fields[3]
+      hash['Protocol'] = protocol
+      if TCP_ENDPOINTS_MAPPING.include?(hash['Port']) && protocol == 'TCP'
+        hash['Name'] = TCP_ENDPOINTS_MAPPING[hash['Port']]
+      else
+        hash['Name'] = "#{protocol}Endpoint_chef_#{fields[0]}"
+      end
+      if fields[2]
+        hash['LoadBalancerProbe'] = {}
+        hash['LoadBalancerProbe']['Path'] = fields[4]
+        hash['LoadBalancerProbe']['Port'] = fields[0]
+        hash['LoadBalancerProbe']['Protocol'] = fields[4] ? 'HTTP' : protocol
+      end
+      hash
+    end
+
+    def find_deploy(params)
+      @connection.hosts.find(params[:azure_dns_name]).deploys[0] # TODO this relies on the 'production only' bug.
+    end
+
+    def add_endpoints_to_xml(xml, endpoints, params)
+      existing_endpoints = find_deploy(params).input_endpoints
+
+      endpoints.each do |ep|
+
+        if existing_endpoints
+          existing_endpoints.each do |eep|
+            ep = eep if eep['LoadBalancedEndpointSetName'] && ep['LoadBalancedEndpointSetName'] && ( eep['LoadBalancedEndpointSetName'] == ep['LoadBalancedEndpointSetName'] )
+          end
+        end
+
+        if ep['Port'] == params[:port] && ep['Protocol'].downcase == 'tcp'
+          puts("Skipping tcp-endpoints: #{ep['LocalPort']} because this port is already in use by ssh/winrm endpoint in current VM.")
+          next
+        end
+
+        xml.InputEndpoint {
+          xml.LoadBalancedEndpointSetName ep['LoadBalancedEndpointSetName'] if ep['LoadBalancedEndpointSetName']
+          xml.LocalPort ep['LocalPort']
+          xml.Name ep['Name']
+          xml.Port ep['Port']
+          if ep['LoadBalancerProbe']
+            xml.LoadBalancerProbe {
+              xml.Path ep['LoadBalancerProbe']['Path'] if ep['LoadBalancerProbe']['Path']
+              xml.Port ep['LoadBalancerProbe']['Port']
+              xml.Protocol ep['LoadBalancerProbe']['Protocol']
+              xml.IntervalInSeconds ep['LoadBalancerProbe']['IntervalInSeconds'] if ep['LoadBalancerProbe']['IntervalInSeconds']
+              xml.TimeoutInSeconds ep['LoadBalancerProbe']['TimeoutInSeconds'] if ep['LoadBalancerProbe']['TimeoutInSeconds']
+            }
+          end
+          xml.Protocol ep['Protocol']
+          xml.EnableDirectServerReturn ep['EnableDirectServerReturn'] if ep['EnableDirectServerReturn']
+          xml.LoadBalancerName ep['LoadBalancerName'] if ep['LoadBalancerName']
+          xml.IdleTimeoutInMinutes ep['IdleTimeoutInMinutes'] if ep['IdleTimeoutInMinutes']
+        }
+      end
+    end
+
     def fetch_thumbprint
       query_result = connection.query_azure("hostedservices/#{@hostedservicename}/deployments/#{@hostedservicename}/roles/#{@name}")
       query_result.at_css("DefaultWinRmCertificateThumbprint").nil? ? '' : query_result.at_css("DefaultWinRmCertificateThumbprint").text
@@ -227,7 +313,6 @@ class Azure
           xml.RoleName {xml.text params[:azure_vm_name]}
           xml.OsVersion('i:nil' => 'true')
           xml.RoleType 'PersistentVMRole'
-          xml.VMImageName params[:azure_source_image] if params[:is_vm_image]
 
           xml.ConfigurationSets {
             if params[:os_type] == 'Linux'
@@ -257,6 +342,17 @@ class Azure
                 xml.AdminPassword params[:admin_password]
                 xml.ResetPasswordOnFirstLogon 'false'
                 xml.EnableAutomaticUpdates 'false'
+                if params[:azure_domain_name]
+                  xml.DomainJoin {
+                    xml.Credentials {
+                      xml.Domain params[:azure_domain_name]
+                     xml.Username params[:azure_domain_user]
+                    xml.Password params[:azure_domain_passwd]
+                   }
+                   xml.JoinDomain params[:azure_domain_name]
+                   xml.MachineObjectOU params[:azure_domain_ou_dn] if params[:azure_domain_ou_dn]
+                  }
+                end
                   if params[:bootstrap_proto].downcase == 'winrm'
                     if params[:ssl_cert_fingerprint]
                       xml.StoredCertificateSettings {
@@ -269,9 +365,9 @@ class Azure
                     end
                     xml.WinRM {
                       xml.Listeners {
-                       if params[:ssl_cert_fingerprint]
+                       if params[:winrm_transport] == "ssl" || params[:ssl_cert_fingerprint]
                         xml.Listener {
-                          xml.CertificateThumbprint params[:ssl_cert_fingerprint]
+                          xml.CertificateThumbprint params[:ssl_cert_fingerprint] if params[:ssl_cert_fingerprint]
                           xml.Protocol 'Https'
                         }
                         else
@@ -346,6 +442,9 @@ class Azure
               xml.ConfigurationSetType 'NetworkConfiguration'
               xml.InputEndpoints {
 
+                #1. bootstrap_proto = 'winrm' for windows => Set winrm port
+                #2. bootstrap_proto = 'ssh' for windows and linux => Set ssh port
+                #3. bootstrap_proto = 'cloud-api' for windows and linux => Set no port
                 if params[:os_type] == 'Windows' and params[:bootstrap_proto].downcase == 'winrm'
                   xml.InputEndpoint {
                   if params[:winrm_transport] == "ssl"
@@ -357,7 +456,7 @@ class Azure
                   xml.Port params[:port]
                   xml.Protocol 'TCP'
                 }
-                elsif params[:os_type] == 'Linux' and params[:bootstrap_proto].downcase == 'ssh'
+                elsif(params[:bootstrap_proto].downcase == 'ssh')
                   xml.InputEndpoint {
                   xml.LocalPort '22'
                   xml.Name 'SSH'
@@ -365,43 +464,19 @@ class Azure
                   xml.Protocol 'TCP'
                 }
                 end
+                all_endpoints = Array.new
 
                 if params[:tcp_endpoints]
-                  params[:tcp_endpoints].split(',').each do |endpoint|
-                    ports = endpoint.split(':')
-                    if !(ports.length > 1 && ports[1] == params[:port] || ports.length == 1 && ports[0] == params[:port])
-                      xml.InputEndpoint {
-                        xml.LocalPort ports[0]
-                        xml.Name 'tcpport_' + ports[0] + '_' + params[:azure_vm_name]
-                        if ports.length > 1
-                          xml.Port ports[1]
-                        else
-                          xml.Port ports[0]
-                        end
-                        xml.Protocol 'TCP'
-                      }
-                    else
-                      warn_message = ports.length > 1 ? "#{ports.join(':')} because this ports are" : "#{ports[0]} because this port is"
-                      puts("Skipping tcp-endpoints: #{warn_message} already in use by ssh/winrm endpoint in current VM.")
-                    end
+                  params[:tcp_endpoints].split(',').map(&:strip).each do |endpoint|
+                    all_endpoints << parse_endpoint_from_params('TCP', params[:azure_vm_name], endpoint)
                   end
                 end
-
                 if params[:udp_endpoints]
-                  params[:udp_endpoints].split(',').each do |endpoint|
-                    ports = endpoint.split(':')
-                    xml.InputEndpoint {
-                      xml.LocalPort ports[0]
-                      xml.Name 'udpport_' + ports[0] + '_' + params[:azure_vm_name]
-                      if ports.length > 1
-                        xml.Port ports[1]
-                      else
-                        xml.Port ports[0]
-                      end
-                      xml.Protocol 'UDP'
-                    }
+                  params[:udp_endpoints].split(',').map(&:strip).each do |endpoint|
+                    all_endpoints << parse_endpoint_from_params('UDP', params[:azure_vm_name], endpoint)
                   end
                 end
+                add_endpoints_to_xml(xml, all_endpoints, params) if all_endpoints.any?
               }
               if params[:azure_subnet_name]
                 xml.SubnetNames {
@@ -444,6 +519,8 @@ class Azure
             xml.AvailabilitySetName params[:azure_availability_set]
           end
 
+          xml.VMImageName params[:azure_source_image] if params[:is_vm_image]
+
           xml.Label Base64.encode64(params[:azure_vm_name]).strip
 
           #OSVirtualHardDisk not required in case azure_source_image is a VMImage
@@ -451,7 +528,8 @@ class Azure
             xml.OSVirtualHardDisk {
               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'
+              domain_suffix = params[:azure_api_host_name].scan(/core.*/)[0]
+              xml.MediaLink 'http://' + params[:azure_storage_account] + '.blob.' + domain_suffix + '/vhds/' + disk_name + '.vhd'
               xml.SourceImageName params[:azure_source_image]
             }
           end
@@ -462,6 +540,7 @@ class Azure
       end
       builder.doc
     end
+
     def create(params, roleXML)
       servicecall = "hostedservices/#{params[:azure_dns_name]}/deployments" +
       "/#{params['deploy_name']}/roles"

data/lib/chef/knife/azure_internal-lb_create.rb

@@ -0,0 +1,77 @@
+#
+# Author:: Aiman Alsari (aiman.alsari@gmail.com)
+# Copyright:: Copyright (c) 2013 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require File.expand_path('../azure_base', __FILE__)
+
+class Chef
+  class Knife
+    class AzureInternalLbCreate < Knife
+      include Knife::AzureBase
+
+      banner 'knife azure internal lb create (options)'
+
+      option :azure_load_balancer,
+        :short => '-n NAME',
+        :long => '--azure-load-balancer NAME',
+        :description => 'Required. Specifies new load balancer name.'
+
+      option :azure_lb_static_vip,
+        :long => '--azure-lb-static-vip VIP',
+        :description => 'Optional. The Virtual IP that will be used for the load balancer.'
+
+      option :azure_subnet_name,
+        :long => '--azure-subnet-name SUBNET_NAME',
+        :description => 'Required if static VIP is set. Specifies the subnet name '\
+                        'the load balancer is located in.'
+
+      option :azure_dns_name,
+        :long => "--azure-dns-name DNS_NAME",
+        :description => "The DNS prefix name that will be used to add this load balancer to. This must be an existing service/deployment."
+
+      def run
+        $stdout.sync = true
+
+        Chef::Log.info('validating...')
+        validate!([:azure_subscription_id,
+                   :azure_mgmt_cert,
+                   :azure_api_host_name,
+                   :azure_load_balancer])
+
+        params = {
+          azure_load_balancer: locate_config_value(:azure_load_balancer),
+          azure_lb_static_vip: locate_config_value(:azure_lb_static_vip),
+          azure_subnet_name: locate_config_value(:azure_subnet_name),
+          azure_dns_name: locate_config_value(:azure_dns_name)
+        }
+
+        rsp = connection.lbs.create(params)
+        print "\n"
+        if rsp.at_css('Status').nil?
+          if rsp.at_css('Code').nil? || rsp.at_css('Message').nil?
+            puts 'Unknown Error. try -VV'
+          else
+            puts "#{rsp.at_css('Code').content}: "\
+                 "#{rsp.at_css('Message').content}"
+          end
+        else
+          puts "Creation status: #{rsp.at_css('Status').content}"
+        end
+      end
+    end
+  end
+end

data/lib/chef/knife/azure_internal-lb_list.rb

@@ -0,0 +1,51 @@
+#
+# Author:: Aiman Alsari (aiman.alsari@gmail.com)
+# Copyright:: Copyright (c) 2013 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require File.expand_path('../azure_base', __FILE__)
+
+class Chef
+  class Knife
+    class AzureInternalLbList < Knife
+      include Knife::AzureBase
+
+      deps { require 'highline' }
+
+      banner 'knife azure internal lb list (options)'
+
+      def hl
+        @highline ||= HighLine.new
+      end
+
+      def run
+        $stdout.sync = true
+
+        validate!
+
+        cols = %w{Name Service Subnet VIP}
+
+        the_list = cols.map { |col| ui.color(col, :bold) }
+        connection.lbs.all.each do |lb|
+          cols.each { |attr| the_list << lb.send(attr.downcase).to_s }
+        end
+
+        puts "\n"
+        puts hl.list(the_list, :uneven_columns_across, cols.size)
+      end
+    end
+  end
+end

data/lib/chef/knife/azure_server_create.rb

@@ -20,6 +20,7 @@
 
 require 'chef/knife/azure_base'
 require 'chef/knife/winrm_base'
+require 'chef/knife/bootstrap_windows_base'
 require 'securerandom'
 
 class Chef
@@ -28,6 +29,7 @@ class Chef
 
       include Knife::AzureBase
       include Knife::WinrmBase
+      include Knife::BootstrapWindowsBase
 
       deps do
         require 'readline'
@@ -40,7 +42,6 @@ class Chef
 
       def load_winrm_deps
         require 'winrm'
-        require 'em-winrm'
         require 'chef/knife/winrm'
         require 'chef/knife/bootstrap_windows_winrm'
       end
@@ -49,6 +50,12 @@ class Chef
 
       attr_accessor :initial_sleep_delay
 
+      option :forward_agent,
+        :short => "-A",
+        :long => "--forward-agent",
+        :description =>  "Enable SSH agent forwarding",
+        :boolean => true
+
       option :bootstrap_protocol,
         :long => "--bootstrap-protocol protocol",
         :description => "Protocol to bootstrap windows servers. options: 'winrm' or 'ssh' or 'cloud-api'.",
@@ -86,15 +93,23 @@ class Chef
       option :distro,
         :short => "-d DISTRO",
         :long => "--distro DISTRO",
-        :description => "Bootstrap a distro using a template",
-        :proc => Proc.new { |d| Chef::Config[:knife][:distro] = d },
-        :default => "chef-full"
+        :description => "Bootstrap a distro using a template. [DEPRECATED] Use --bootstrap-template option instead.",
+        :proc        => Proc.new { |v|
+          Chef::Log.warn("[DEPRECATED] -d / --distro option is deprecated. Use --bootstrap-template option instead.")
+          v
+        }
 
       option :template_file,
         :long => "--template-file TEMPLATE",
-        :description => "Full path to location of template to use",
-        :proc => Proc.new { |t| Chef::Config[:knife][:template_file] = t },
-        :default => false
+        :description => "Full path to location of template to use. [DEPRECATED] Use -t / --bootstrap-template option instead.",
+        :proc        => Proc.new { |v|
+          Chef::Log.warn("[DEPRECATED] --template-file option is deprecated. Use -t / --bootstrap-template option instead.")
+          v
+        }
+
+      option :bootstrap_template,
+        :long => "--bootstrap-template TEMPLATE",
+        :description => "Bootstrap Chef using a built-in or custom template. Set to the full path of an erb template or use one of the built-in templates."
 
       option :run_list,
         :short => "-r RUN_LIST",
@@ -109,6 +124,70 @@ class Chef
         :boolean => true,
         :default => true
 
+      option :node_ssl_verify_mode,
+        :long        => "--node-ssl-verify-mode [peer|none]",
+        :description => "Whether or not to verify the SSL cert for all HTTPS requests.",
+        :proc        => Proc.new { |v|
+          valid_values = ["none", "peer"]
+          unless valid_values.include?(v)
+            raise "Invalid value '#{v}' for --node-ssl-verify-mode. Valid values are: #{valid_values.join(", ")}"
+          end
+        }
+
+      option :node_verify_api_cert,
+        :long        => "--[no-]node-verify-api-cert",
+        :description => "Verify the SSL cert for HTTPS requests to the Chef server API.",
+        :boolean     => true
+
+      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",
+        :proc => Proc.new { |np| Chef::Config[:knife][:bootstrap_no_proxy] = np }
+
+      option :bootstrap_url,
+        :long        => "--bootstrap-url URL",
+        :description => "URL to a custom installation script",
+        :proc        => Proc.new { |u| Chef::Config[:knife][:bootstrap_url] = u }
+
+      option :bootstrap_install_command,
+        :long        => "--bootstrap-install-command COMMANDS",
+        :description => "Custom command to install chef-client",
+        :proc        => Proc.new { |ic| Chef::Config[:knife][:bootstrap_install_command] = ic }
+
+      option :bootstrap_wget_options,
+        :long        => "--bootstrap-wget-options OPTIONS",
+        :description => "Add options to wget when installing chef-client",
+        :proc        => Proc.new { |wo| Chef::Config[:knife][:bootstrap_wget_options] = wo }
+
+      option :bootstrap_curl_options,
+        :long        => "--bootstrap-curl-options OPTIONS",
+        :description => "Add options to curl when install chef-client",
+        :proc        => Proc.new { |co| Chef::Config[:knife][:bootstrap_curl_options] = co }
+
+      option :bootstrap_vault_file,
+        :long        => '--bootstrap-vault-file VAULT_FILE',
+        :description => 'A JSON file with a list of vault(s) and item(s) to be updated'
+
+      option :bootstrap_vault_json,
+        :long        => '--bootstrap-vault-json VAULT_JSON',
+        :description => 'A JSON string with the vault(s) and item(s) to be updated'
+
+      option :bootstrap_vault_item,
+        :long        => '--bootstrap-vault-item VAULT_ITEM',
+        :description => 'A single vault and item to update as "vault:item"',
+        :proc        => Proc.new { |i|
+          (vault, item) = i.split(/:/)
+          Chef::Config[:knife][:bootstrap_vault_item] ||= {}
+          Chef::Config[:knife][:bootstrap_vault_item][vault] ||= []
+          Chef::Config[:knife][:bootstrap_vault_item][vault].push(item)
+          Chef::Config[:knife][:bootstrap_vault_item]
+        }
+
+      option :use_sudo_password,
+        :long => "--use-sudo-password",
+        :description => "Execute the bootstrap via sudo with password",
+        :boolean => false
+
       option :azure_storage_account,
         :short => "-a NAME",
         :long => "--azure-storage-account NAME",
@@ -248,19 +327,33 @@ class Chef
 
       option :winrm_max_timeout,
         :long => "--winrm-max-timeout MINUTES",
-        :description => "Set winrm max timeout in minutes"
+        :description => "Set winrm maximum command timeout in minutes, useful for long bootstraps"
 
-      option :winrm_max_memoryPerShell,
-        :long => "--winrm-max-memoryPerShell MB",
+      option :winrm_max_memorypershell,
+        :long => "--winrm-max-memory-per-shell",
         :description => "Set winrm max memory per shell in MB"
 
-
       option :delete_chef_extension_config,
         :long => "--delete-chef-extension-config",
         :boolean => true,
         :default => false,
         :description => "Determines whether Chef configuration files removed when Azure removes the Chef resource extension from the VM. This option is only valid for the 'cloud-api' bootstrap protocol. The default is false."
 
+      option :azure_domain_name,
+        :long => "--azure-domain-name DOMAIN_NAME",
+        :description => "Optional. 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"
+
+      option :azure_domain_ou_dn,
+        :long => "--azure-domain-ou-dn DOMAIN_OU_DN",
+        :description => "Optional. Specifies the (LDAP) X 500-distinguished name of the organizational unit (OU) in which the computer account is created. This account is in Active Directory on a domain controller in the domain to which the computer is being joined. Example: OU=HR,dc=opscode,dc=com"
+
+      option :azure_domain_user,
+        :long => "--azure-domain-user DOMAIN_USER_NAME",
+        :description => "Optional. Specifies the username who has access to join the 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."
 
       def strip_non_ascii(string)
         string.gsub(/[^0-9a-z ]/i, '')
@@ -417,7 +510,7 @@ class Chef
                   extension_status[:status] = :extension_status_not_detected
                 end
               # This fix is for linux waagent issue: api unable to deserialize the waagent status.
-              elsif role.at_css("GuestAgentStatus Status").text == "NotReady" and waagent_status_msg == lnx_waagent_fail_msg
+              elsif role.at_css('GuestAgentStatus Status').text == 'NotReady' and waagent_status_msg == lnx_waagent_fail_msg
                 extension_status[:status] = :extension_ready
               else
                 extension_status[:status] = :wagent_provisioning
@@ -434,31 +527,31 @@ class Chef
         return extension_status
       end
 
-      def get_role_server()
+      def get_role_server
         deploy = connection.deploys.queryDeploy(locate_config_value(:azure_dns_name))
         deploy.find_role(locate_config_value(:azure_vm_name))
       end
 
       def tcp_test_winrm(ip_addr, port)
-	    hostname = ip_addr
+        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
+        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)
@@ -550,13 +643,14 @@ class Chef
         bootstrap_exec(server) unless locate_config_value(:bootstrap_protocol) == 'cloud-api'
       end
 
+      def default_bootstrap_template
+        is_image_windows? ? 'windows-chef-client-msi' : 'chef-full'
+      end
+
       def bootstrap_exec(server)
         fqdn = server.publicipaddress
 
         if is_image_windows?
-          # Set distro to windows-chef-client-msi
-          config[:distro] = "windows-chef-client-msi" if (config[:distro].nil? || config[:distro] == "chef-full")
-
           if locate_config_value(:bootstrap_protocol) == 'ssh'
             port = server.sshport
             print "#{ui.color("Waiting for sshd on #{fqdn}:#{port}", :magenta)}"
@@ -587,7 +681,7 @@ class Chef
 
           port = server.sshport
 
-          print "#{ui.color("Waiting for sshd on #{fqdn}:#{port}", :magenta)}"
+          print ui.color("Waiting for sshd on #{fqdn}:#{port}", :magenta)
 
           print(".") until tcp_test_ssh(fqdn,port) {
             sleep @initial_sleep_delay ||= 10
@@ -622,8 +716,17 @@ class Chef
         bootstrap.config[:prerelease] = config[:prerelease]
         bootstrap.config[:first_boot_attributes] = locate_config_value(:json_attributes) || {}
         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)
+        bootstrap.config[:distro] = locate_config_value(:distro) || default_bootstrap_template
+        # setting bootstrap_template value to template_file for backward 
+        bootstrap.config[:template_file] = locate_config_value(:template_file) || locate_config_value(:bootstrap_template)
+        bootstrap.config[:node_ssl_verify_mode] = locate_config_value(:node_ssl_verify_mode)
+        bootstrap.config[:node_verify_api_cert] = locate_config_value(:node_verify_api_cert)
+        bootstrap.config[:bootstrap_no_proxy] = locate_config_value(:bootstrap_no_proxy)
+        bootstrap.config[:bootstrap_url] = locate_config_value(:bootstrap_url)
+        bootstrap.config[:bootstrap_vault_file] = locate_config_value(:bootstrap_vault_file)
+        bootstrap.config[:bootstrap_vault_json] = locate_config_value(:bootstrap_vault_json)
+        bootstrap.config[:bootstrap_vault_item] = locate_config_value(:bootstrap_vault_item)
+
         load_cloud_attributes_in_hints(server)
         bootstrap
       end
@@ -646,11 +749,11 @@ class Chef
             bootstrap.config[:auth_timeout] = locate_config_value(:auth_timeout)
             # Todo: we should skip cert generate in case when winrm_ssl_verify_mode=verify_none
             bootstrap.config[:winrm_ssl_verify_mode] = locate_config_value(:winrm_ssl_verify_mode)
-
         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[:forward_agent] = locate_config_value(:forward_agent)
             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)
@@ -662,6 +765,8 @@ class Chef
         bootstrap.config[:chef_node_name] = config[:chef_node_name] || server.name
         bootstrap.config[:encrypted_data_bag_secret] = locate_config_value(:encrypted_data_bag_secret)
         bootstrap.config[:encrypted_data_bag_secret_file] = locate_config_value(:encrypted_data_bag_secret_file)
+        bootstrap.config[:msi_url] = locate_config_value(:msi_url)
+        bootstrap.config[:install_as_service] = locate_config_value(:install_as_service)
         bootstrap_common_params(bootstrap, server)
       end
 
@@ -680,7 +785,9 @@ class Chef
         bootstrap.config[:host_key_verify] = config[:host_key_verify]
         bootstrap.config[:secret] = locate_config_value(:secret)
         bootstrap.config[:secret_file] = locate_config_value(:secret_file)
-
+        bootstrap.config[:bootstrap_install_command] = locate_config_value(:bootstrap_install_command)
+        bootstrap.config[:bootstrap_wget_options] = locate_config_value(:bootstrap_wget_options)
+        bootstrap.config[:bootstrap_curl_options] = locate_config_value(:bootstrap_curl_options)
         bootstrap_common_params(bootstrap, server)
       end
 
@@ -725,11 +832,25 @@ class Chef
           ui.error("Image provided is invalid")
           exit 1
         end
+
+        # Validate join domain requirements.
+        if locate_config_value(:azure_domain_name) or locate_config_value(:azure_domain_user)
+          if locate_config_value(:azure_domain_user).nil? or locate_config_value(:azure_domain_passwd).nil?
+            ui.error("Must specify both --azure-domain-user and --azure-domain-passwd.")
+            exit 1
+          end
+        end
+
+        if locate_config_value(:winrm_transport) == "ssl" && locate_config_value(:thumbprint).nil? && ( locate_config_value(:winrm_ssl_verify_mode).nil? || locate_config_value(:winrm_ssl_verify_mode) == :verify_peer )
+          ui.error("The SSL transport was specified without the --thumbprint option. Specify a thumbprint, or alternatively set the --winrm-ssl-verify-mode option to 'verify_none' to skip verification.")
+          exit 1
+        end
       end
 
       def create_server_def
         server_def = {
           :azure_storage_account => locate_config_value(:azure_storage_account),
+          :azure_api_host_name => locate_config_value(:azure_api_host_name),
           :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),
@@ -750,7 +871,7 @@ class Chef
           :cert_password => locate_config_value(:cert_passphrase),
           :winrm_transport => locate_config_value(:winrm_transport),
           :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_memoryPerShell)
+          :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.
@@ -767,7 +888,6 @@ class Chef
             port = locate_config_value(:winrm_port) || '5985'
           end
         end
-
         server_def[:port] = port
 
         if locate_config_value(:bootstrap_protocol) == 'cloud-api'
@@ -811,7 +931,7 @@ class Chef
           server_def[:bootstrap_proto] = locate_config_value(:bootstrap_protocol)
         else
           server_def[:os_type] = 'Linux'
-          server_def[:bootstrap_proto] =  locate_config_value(:bootstrap_protocol) || 'ssh'
+          server_def[:bootstrap_proto] = (locate_config_value(:bootstrap_protocol) == 'winrm') ? 'ssh' : locate_config_value(:bootstrap_protocol)
           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)
@@ -819,6 +939,27 @@ class Chef
         end
 
         server_def[:is_vm_image] = connection.images.is_vm_image(locate_config_value(:azure_source_image))
+
+        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)
+          # 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_user] = $2
+          when /(.+)@(\S+)/  # format - user@fully-qualified-DNS-domain
+            server_def[:azure_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
+          end
+        end
+        server_def[:azure_domain_passwd] = locate_config_value(:azure_domain_passwd)
+        server_def[:azure_domain_ou_dn] = locate_config_value(:azure_domain_ou_dn)
         server_def
       end
 
@@ -855,13 +996,33 @@ class Chef
         pub_config[:bootstrap_options][:encrypted_data_bag_secret] = locate_config_value(:encrypted_data_bag_secret) if locate_config_value(:encrypted_data_bag_secret)
         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)
         Base64.encode64(pub_config.to_json)
       end
 
       def get_chef_extension_private_params
         pri_config = Hash.new
-        pri_config[:validation_key] = File.read(Chef::Config[:validation_key])
+
+        # validator less bootstrap support for bootstrap protocol cloud-api
+        if (Chef::Config[:validation_key] && !File.exist?(File.expand_path(Chef::Config[:validation_key])))
+
+          if Chef::VERSION.split('.').first.to_i == 11
+            ui.error('Unable to find validation key. Please verify your configuration file for validation_key config value.')
+            exit 1
+          end
+
+          client_builder = Chef::Knife::Bootstrap::ClientBuilder.new(
+            chef_config: Chef::Config,
+            knife_config: config,
+            ui: ui,
+          )
+
+          client_builder.run
+          key_path = client_builder.client_path
+          pri_config[:client_pem] = File.read(key_path)
+        else
+          pri_config[:validation_key] = File.read(Chef::Config[:validation_key])
+        end
         Base64.encode64(pri_config.to_json)
       end
 
@@ -898,7 +1059,7 @@ class Chef
             !locate_config_value(:winrm_password).nil?
           config[:ssh_password] = locate_config_value(:winrm_password)
         end
-        # unset identity_file and set kerberos_keytab_file, override identity_file
+        # unset identity_file and set _file, override identity_file
         if locate_config_value(:identity_file).nil? &&
             !locate_config_value(:kerberos_keytab_file).nil?
           config[:identity_file] = locate_config_value(:kerberos_keytab_file)

data/lib/knife-azure/version.rb

@@ -1,6 +1,6 @@
 module Knife
   module Azure
-    VERSION = "1.5.1.rc.1"
+    VERSION = "1.5.1.rc.2"
     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.1.rc.1
+  version: 1.5.1.rc.2
 platform: ruby
 authors:
 - Barry Davis
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-03 00:00:00.000000000 Z
+date: 2015-09-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -29,36 +29,36 @@ dependencies:
   name: knife-windows
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.2
+        version: 1.0.0.rc.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.2
+        version: 1.0.0.rc.1
 - !ruby/object:Gem::Dependency
   name: chef
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 11.8.2
-    - - "<"
+        version: '12.0'
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '12'
+        version: 12.2.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 11.8.2
-    - - "<"
+        version: '12.0'
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '12'
+        version: 12.2.1
 - !ruby/object:Gem::Dependency
   name: mixlib-config
   requirement: !ruby/object:Gem::Requirement
@@ -118,6 +118,7 @@ files:
 - lib/azure/disk.rb
 - lib/azure/host.rb
 - lib/azure/image.rb
+- lib/azure/loadbalancer.rb
 - lib/azure/rest.rb
 - lib/azure/role.rb
 - lib/azure/storageaccount.rb
@@ -127,6 +128,8 @@ files:
 - lib/chef/knife/azure_ag_list.rb
 - lib/chef/knife/azure_base.rb
 - lib/chef/knife/azure_image_list.rb
+- lib/chef/knife/azure_internal-lb_create.rb
+- lib/chef/knife/azure_internal-lb_list.rb
 - lib/chef/knife/azure_server_create.rb
 - lib/chef/knife/azure_server_delete.rb
 - lib/chef/knife/azure_server_list.rb