knife-azure 1.1.4 → 1.2.0

data/lib/azure/storageaccount.rb

@@ -18,6 +18,7 @@
 
 class Azure
   class StorageAccounts
+    include AzureUtility
     def initialize(connection)
       @connection=connection
     end
@@ -52,8 +53,9 @@ class Azure
     # Look up on cloud and not local cache
     def exists_on_cloud?(name)
       ret_val = @connection.query_azure("storageservices/#{name}")
-      if ret_val.nil? || ret_val.css('Error Code').length > 0
-        Chef::Log.warn 'Unable to find storage account:' + ret_val.at_css('Error Code').content + ' : ' + ret_val.at_css('Error Message').content if ret_val
+      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 storage account:' + error_message + ' : ' + error_message if ret_val
         false
       else
         true

data/lib/azure/utility.rb

@@ -25,5 +25,17 @@ module AzureUtility
     end
     content
   end
+
+  def error_from_response_xml(response_xml)
+    error_code_and_message = ['','']
+    error_node = response_xml.at_css('Error')
+
+    if error_node
+      error_code_and_message[0] = xml_content(error_node, 'Code')
+      error_code_and_message[1] = xml_content(error_node, 'Message')
+    end
+
+    error_code_and_message
+  end
 end
 

data/lib/azure/vnet.rb

@@ -0,0 +1,89 @@
+#
+# Author:: Jeff Mendoza (jeffmendoza@live.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 Vnets
+    def initialize(connection)
+      @connection = connection
+    end
+
+    def load
+      @vnets ||= begin
+        @vnets = {}
+        response = @connection.query_azure('networking/virtualnetwork')
+        response.css('VirtualNetworkSite').each do |vnet|
+          item = Vnet.new(@connection).parse(vnet)
+          @vnets[item.name] = item
+        end
+        @vnets
+      end
+    end
+
+    def all
+      load.values
+    end
+
+    def exists?(name)
+      load.key?(name)
+    end
+
+    def find(name)
+      load[name]
+    end
+
+    def create(params)
+      ag = Vnet.new(@connection)
+      ag.create(params)
+    end
+  end
+end
+
+class Azure
+  class Vnet
+    attr_accessor :name, :affinity_group, :state
+
+    def initialize(connection)
+      @connection = connection
+    end
+
+    def parse(image)
+      @name = image.at_css('Name').content
+      @affinity_group = 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
+      @connection.query_azure('networking/media', 'put', response.to_xml)
+    end
+  end
+end

data/lib/chef/knife/azure_ag_create.rb

@@ -0,0 +1,76 @@
+#
+# Author:: Jeff Mendoza (jeffmendoza@live.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 AzureAgCreate < Knife
+      include Knife::AzureBase
+
+      banner 'knife azure ag create (options)'
+
+      option :azure_affinity_group,
+        :short => '-a GROUP',
+        :long => '--azure-affinity-group GROUP',
+        :description => 'Specifies new affinity group name.'
+
+      option :azure_ag_desc,
+        :long => '--azure-ag-desc DESC',
+        :description => 'Optional. Description for new affinity group.'
+
+      option :azure_service_location,
+        :short => '-m LOCATION',
+        :long => '--azure-service-location LOCATION',
+        :description => 'Specifies the geographic location - the name of '\
+                        'the data center location that is valid for your '\
+                        'subscription. Eg: West US, East US, '\
+                        'East Asia, Southeast Asia, North Europe, West Europe'
+
+      def run
+        $stdout.sync = true
+
+        Chef::Log.info('validating...')
+        validate!([:azure_subscription_id,
+                   :azure_mgmt_cert,
+                   :azure_api_host_name,
+                   :azure_affinity_group,
+                   :azure_service_location])
+
+        params = {
+          azure_ag_name: locate_config_value(:azure_affinity_group),
+          azure_ag_desc: locate_config_value(:azure_ag_desc),
+          azure_location: locate_config_value(:azure_service_location),
+        }
+
+        rsp = connection.ags.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_ag_list.rb

@@ -0,0 +1,51 @@
+#
+# Author:: Jeff Mendoza (jeffmendoza@live.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 AzureAgList < Knife
+      include Knife::AzureBase
+
+      deps { require 'highline' }
+
+      banner 'knife azure ag list (options)'
+
+      def hl
+        @highline ||= HighLine.new
+      end
+
+      def run
+        $stdout.sync = true
+
+        validate!
+
+        cols = %w{Name Location Description}
+
+        the_list = cols.map { |col| ui.color(col, :bold) }
+        connection.ags.all.each do |ag|
+          cols.each { |attr| the_list << ag.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_base.rb

@@ -103,7 +103,16 @@ class Chef
         msg_pair('DNS Name', server.hostedservicename + ".cloudapp.net")
         msg_pair('VM Name', server.name)
         msg_pair('Size', server.size)
+        msg_pair('Azure Source Image', locate_config_value(:azure_source_image))
+        msg_pair('Azure Service Location', locate_config_value(:azure_service_location))
         msg_pair('Public Ip Address', server.publicipaddress)
+        msg_pair('Private Ip Address', server.ipaddress)
+        msg_pair('SSH Port', server.sshport) unless server.sshport.nil?
+        msg_pair('WinRM Port', server.winrmport) unless server.winrmport.nil?
+        msg_pair('TCP Ports', server.tcpports) unless server.tcpports.nil? or server.tcpports.empty?
+        msg_pair('UDP Ports', server.udpports) unless server.udpports.nil? or server.udpports.empty?
+        msg_pair('Environment', locate_config_value(:environment) || '_default')
+        msg_pair('Runlist', locate_config_value(:run_list)) unless locate_config_value(:run_list).empty?
         puts "\n"
       end
 

data/lib/chef/knife/azure_server_create.rb

@@ -215,41 +215,68 @@ class Chef
         (0...len).map{65.+(rand(25)).chr}.join
       end
 
-      def wait_until_virtual_machine_ready(total_wait_time_in_minutes = 15, retry_interval_in_seconds = 30)
-          print "\n#{ui.color('Waiting for virtual machine to be ready.', :magenta)}"
-          total_wait_time_in_seconds = total_wait_time_in_minutes * 60
-          max_polling_attempts = total_wait_time_in_seconds / retry_interval_in_seconds
-
-          wait_start_time = Time.now
-
-          vm_ready = check_if_virtual_machine_ready()
-          polling_attempts = 1
-          until vm_ready || polling_attempts >= max_polling_attempts
-            print '.'
-            sleep retry_interval_in_seconds
-            vm_ready = check_if_virtual_machine_ready()
-            polling_attempts += 1
+      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)
+          if vm_status != :vm_status_ready
+            wait_for_virtual_machine_state(:vm_status_ready, 15, retry_interval_in_seconds)
           end
-          if vm_ready
-            elapsed_time_in_minutes = ((Time.now - wait_start_time) / 60).round(2)
-            puts("vm ready after #{elapsed_time_in_minutes} minutes.")
+        rescue Exception => e
+          Chef::Log.error("#{e.to_s}")
+          raise 'Verify connectivity to Azure and subscription resource limit compliance (e.g. maximum CPU core limits) and try again.'
+        end
+      end
+
+      def wait_for_virtual_machine_state(vm_status_goal, total_wait_time_in_minutes, retry_interval_in_seconds)
+        vm_status_ordering = {:vm_status_not_detected => 0, :vm_status_provisioning => 1, :vm_status_ready => 2}
+        vm_status_description = {:vm_status_not_detected => 'any', :vm_status_provisioning => 'provisioning', :vm_status_ready => 'ready'}
+
+        print ui.color("Waiting for virtual machine to reach status '#{vm_status_description[vm_status_goal]}'", :magenta)
+
+        total_wait_time_in_seconds = total_wait_time_in_minutes * 60
+        max_polling_attempts = total_wait_time_in_seconds / retry_interval_in_seconds
+        polling_attempts = 0
+
+        wait_start_time = Time.now
+
+        begin
+          vm_status = get_virtual_machine_status()
+          vm_ready = vm_status_ordering[vm_status] >= vm_status_ordering[vm_status_goal]
+          print '.'
+          sleep retry_interval_in_seconds if !vm_ready
+          polling_attempts += 1
+        end until vm_ready || polling_attempts >= max_polling_attempts
+
+        if ! vm_ready
+          raise Chef::Exceptions::CommandTimeout, "Virtual machine state '#{vm_status_description[vm_status_goal]}' not reached after #{total_wait_time_in_minutes} minutes."
+        end
+
+        elapsed_time_in_minutes = ((Time.now - wait_start_time) / 60).round(2)
+        print ui.color("vm state '#{vm_status_description[vm_status_goal]}' reached after #{elapsed_time_in_minutes} minutes.\n", :cyan)
+        vm_status
+      end
+
+      def get_virtual_machine_status()
+        role = get_role_server()
+        unless role.nil?
+          Chef::Log.debug("Role status is #{role.status.to_s}")
+          if  "ReadyRole".eql? role.status.to_s
+            return :vm_status_ready
+          elsif "Provisioning".eql? role.status.to_s
+            return :vm_status_provisioning
           else
-            raise "Virtual machine not ready after #{total_wait_time_in_minutes} minutes."
+            return :vm_status_not_detected
           end
+        end
+        return :vm_status_not_detected
       end
 
-      def check_if_virtual_machine_ready()
+      def get_role_server()
         deploy = connection.deploys.queryDeploy(locate_config_value(:azure_dns_name))
-        role = deploy.find_role(locate_config_value(:azure_vm_name))
-        if role.nil?
-          raise "Could not find role - status unknown."
-        end
-        Chef::Log.debug("Role status is #{role.status.to_s}")
-        if  "ReadyRole".eql? role.status.to_s
-          return true
-        else
-          return false
-        end
+        deploy.find_role(locate_config_value(:azure_vm_name))
       end
 
       def tcp_test_winrm(ip_addr, port)
@@ -335,11 +362,14 @@ class Chef
         end
 
         begin
-          server = connection.deploys.create(create_server_def)
-          fqdn = server.publicipaddress
+          connection.deploys.create(create_server_def)
           wait_until_virtual_machine_ready()
+          server = get_role_server()
+          fqdn = server.publicipaddress
         rescue Exception => e
           Chef::Log.error("Failed to create the server -- exception being rescued: #{e.to_s}")
+          backtrace_message = "#{e.class}: #{e}\n#{e.backtrace.join("\n")}"
+          Chef::Log.debug("#{backtrace_message}")
           cleanup_and_exit(remove_hosted_service_on_failure, remove_storage_service_on_failure)
         end
 

data/lib/chef/knife/azure_server_delete.rb

@@ -71,6 +71,12 @@ class Chef
       option :azure_dns_name,
         :long => "--azure-dns-name NAME",
         :description => "specifies the DNS name (also known as hosted service name)"
+ 
+      option :wait,
+        :long => "--wait",
+        :boolean => true,
+        :default => false,        
+        :description => "Wait for server deletion. Default is false"
 
       # Extracted from Chef::Knife.delete_object, because it has a
       # confirmation step built in... By specifying the '--purge'
@@ -127,7 +133,8 @@ class Chef
                                                      :preserve_azure_vhd => locate_config_value(:preserve_azure_vhd),
                                                      :preserve_azure_dns_name => locate_config_value(:preserve_azure_dns_name),
                                                      :azure_dns_name => server.hostedservicename,
-                                                     :delete_azure_storage_account => locate_config_value(:delete_azure_storage_account) })
+                                                     :delete_azure_storage_account => locate_config_value(:delete_azure_storage_account),
+                                                     :wait => locate_config_value(:wait) })
 
             puts "\n"
             ui.warn("Deleted server #{server.name}")

data/lib/chef/knife/{azure_server_describe.rb → azure_server_show.rb}

@@ -22,11 +22,11 @@ require File.expand_path('../azure_base', __FILE__)
 
 class Chef
   class Knife
-    class AzureServerDescribe < Knife
+    class AzureServerShow < Knife
 
       include Knife::AzureBase
 
-      banner "knife azure server describe ROLE [ROLE]"
+      banner "knife azure server show SERVER [SERVER]"
 
       def run
         $stdout.sync = true
@@ -38,27 +38,35 @@ class Chef
           puts ''
           if (role)
             details = Array.new
-            details << ui.color('Role name', :bold, :blue)
+            details << ui.color('Role name', :bold, :cyan)
             details << role.name
-            details << ui.color('Status', :bold, :blue)
+            details << ui.color('Status', :bold, :cyan)
             details << role.status
-            details << ui.color('Size', :bold, :blue)
+            details << ui.color('Size', :bold, :cyan)
             details << role.size
-            details << ui.color('Hosted service name', :bold, :blue)
+            details << ui.color('Hosted service name', :bold, :cyan)
             details << role.hostedservicename
-            details << ui.color('Deployment name', :bold, :blue)
+            details << ui.color('Deployment name', :bold, :cyan)
             details << role.deployname
-            details << ui.color('Host name', :bold, :blue)
+            details << ui.color('Host name', :bold, :cyan)
             details << role.hostname
-            details << ui.color('SSH', :bold, :blue)
-            details << role.sshipaddress + ':' + role.sshport
+            unless role.sshport.nil?
+              details << ui.color('SSH port', :bold, :cyan)
+              details << role.sshport
+            end
+            unless role.winrmport.nil?
+              details << ui.color('WinRM port', :bold, :cyan)
+              details << role.winrmport
+            end
+            details << ui.color('Public IP', :bold, :cyan)
+            details << role.publicipaddress
             puts ui.list(details, :columns_across, 2)
             if role.tcpports.length > 0 || role.udpports.length > 0
               details.clear
-              details << ui.color('Ports open', :bold, :blue)
-              details << ui.color('Local port', :bold, :blue)
-              details << ui.color('IP', :bold, :blue)
-              details << ui.color('Public port', :bold, :blue)
+              details << ui.color('Ports open', :bold, :cyan)
+              details << ui.color('Local port', :bold, :cyan)
+              details << ui.color('IP', :bold, :cyan)
+              details << ui.color('Public port', :bold, :cyan)
               if role.tcpports.length > 0
                 role.tcpports.each do |port|
                   details << 'tcp'