knife-azure 1.6.0.rc.0 → 1.6.0

data/lib/chef/knife/azure_server_delete.rb

@@ -71,11 +71,11 @@ 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,        
+        :default => false,
         :description => "Wait for server deletion. Default is false"
 
       # Extracted from Chef::Knife.delete_object, because it has a
@@ -103,46 +103,24 @@ class Chef
       end
 
       def run
-
-        validate!
+        validate_asm_keys!
         validate_disk_and_storage
         @name_args.each do |name|
-
           begin
-            server = connection.roles.find(name, params = { :azure_dns_name => locate_config_value(:azure_dns_name) })
-
-            if not server
-              ui.warn("Server #{name} does not exist")
-              return
-            end
-            puts "\n"
-            msg_pair('DNS Name', server.hostedservicename + ".cloudapp.net")
-            msg_pair('VM Name', server.name)
-            msg_pair('Size', server.size)
-            msg_pair('Public Ip Address', server.publicipaddress)
-            puts "\n"
-
-            begin
-              confirm("Do you really want to delete this server")
-            rescue SystemExit   # Need to handle this as confirming with N/n raises SystemExit exception
-              server = nil      # Cleanup is implicitly performed in other cloud plugins
-              exit!
-            end
-
-            connection.roles.delete(name, params = { :preserve_azure_os_disk => locate_config_value(:preserve_azure_os_disk),
-                                                     :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),
-                                                     :wait => locate_config_value(:wait) })
-
-            puts "\n"
-            ui.warn("Deleted server #{server.name}")
+            service.delete_server( { name: name, preserve_azure_os_disk: locate_config_value(:preserve_azure_os_disk),
+                                    preserve_azure_vhd: locate_config_value(:preserve_azure_vhd),
+                                    preserve_azure_dns_name: locate_config_value(:preserve_azure_dns_name),
+                                    delete_azure_storage_account: locate_config_value(:delete_azure_storage_account),
+                                     wait: locate_config_value(:wait) } )
 
             if config[:purge]
-              thing_to_delete = config[:chef_node_name] || name
-              destroy_item(Chef::Node, thing_to_delete, "node")
-              destroy_item(Chef::ApiClient, thing_to_delete, "client")
+              node_to_delete = config[:chef_node_name] || name
+              if node_to_delete
+                destroy_item(Chef::Node, node_to_delete, 'node')
+                destroy_item(Chef::ApiClient, node_to_delete, 'client')
+              else
+                ui.warn("Node name to purge not provided. Corresponding client node will remain on Chef Server.")
+              end
             else
               ui.warn("Corresponding node and client for the #{name} server were not deleted and remain registered with the Chef Server")
             end
@@ -153,7 +131,6 @@ class Chef
           end
         end
       end
-
     end
   end
 end

data/lib/chef/knife/azure_server_list.rb

@@ -30,33 +30,8 @@ class Chef
 
       def run
         $stdout.sync = true
-
-        validate!
-
-        server_labels = ['DNS Name', 'VM Name', 'Status', 'IP Address', 'SSH Port', 'WinRM Port' ]
-        server_list =  server_labels.map {|label| ui.color(label, :bold)}
-        items = connection.roles.all
-
-        items.each do |server|
-          server_list << server.hostedservicename.to_s+".cloudapp.net"  # Info about the DNS name at http://msdn.microsoft.com/en-us/library/ee460806.aspx
-          server_list << server.name.to_s
-          server_list << begin
-                           state = server.status.to_s.downcase
-                           case state
-                           when 'shutting-down','terminated','stopping','stopped'
-                             ui.color(state, :red)
-                           when 'pending'
-                             ui.color(state, :yellow)
-                           else
-                             ui.color('ready', :green)
-                           end
-                         end
-          server_list << server.publicipaddress.to_s
-          server_list << server.sshport.to_s
-          server_list << server.winrmport.to_s
-        end
-        puts ''
-        puts ui.list(server_list, :uneven_columns_across, 6)
+        validate_asm_keys!
+        service.list_servers
       end
     end
   end

data/lib/chef/knife/azure_server_show.rb

@@ -26,72 +26,16 @@ class Chef
 
       include Knife::AzureBase
 
-      banner "knife azure server show SERVER [SERVER]"
+      banner "knife azure server show SERVER [SERVER]"  
 
       def run
         $stdout.sync = true
-
-        validate!
-
+        validate_asm_keys!
         @name_args.each do |name|
-          role = connection.roles.find name
-          puts ''
-          if (role)
-            details = Array.new
-            details << ui.color('Role name', :bold, :cyan)
-            details << role.name
-            details << ui.color('Status', :bold, :cyan)
-            details << role.status
-            details << ui.color('Size', :bold, :cyan)
-            details << role.size
-            details << ui.color('Hosted service name', :bold, :cyan)
-            details << role.hostedservicename
-            details << ui.color('Deployment name', :bold, :cyan)
-            details << role.deployname
-            details << ui.color('Host name', :bold, :cyan)
-            details << role.hostname
-            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
-            unless role.thumbprint.empty?
-              details << ui.color('Thumbprint', :bold, :cyan)
-              details << role.thumbprint
-            end
-            puts ui.list(details, :columns_across, 2)
-            if role.tcpports.length > 0 || role.udpports.length > 0
-              details.clear
-              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'
-                  details << port['LocalPort']
-                  details << port['Vip']
-                  details << port['PublicPort']
-                end
-              end
-              if role.udpports.length > 0
-                role.udpports.each do |port|
-                  details << 'udp'
-                  details << port['LocalPort']
-                  details << port['Vip']
-                  details << port['PublicPort']
-                end
-              end
-              puts ui.list(details, :columns_across, 4)
-            end
-          end
+          service.show_server name
         end
       end
+
     end
   end
 end

data/lib/chef/knife/azure_vnet_create.rb

@@ -51,12 +51,7 @@ class Chef
         $stdout.sync = true
 
         Chef::Log.info('validating...')
-        validate!([:azure_subscription_id,
-                   :azure_mgmt_cert,
-                   :azure_api_host_name,
-                   :azure_network_name,
-                   :azure_affinity_group,
-                   :azure_address_space])
+        validate_asm_keys!(:azure_network_name, :azure_affinity_group, :azure_address_space)
 
         params = {
           azure_vnet_name: locate_config_value(:azure_network_name),
@@ -65,7 +60,7 @@ class Chef
           azure_subnet_name: locate_config_value(:azure_subnet_name) || "Subnet-#{Random.rand(10)}"
         }
 
-        rsp = connection.vnets.create(params)
+        rsp = service.create_vnet(params)
         print "\n"
         if rsp.at_css('Status').nil?
           if rsp.at_css('Code').nil? || rsp.at_css('Message').nil?

data/lib/chef/knife/azure_vnet_list.rb

@@ -27,25 +27,10 @@ class Chef
 
       banner 'knife azure vnet list (options)'
 
-      def hl
-        @highline ||= HighLine.new
-      end
-
       def run
         $stdout.sync = true
-
-        validate!
-
-        cols = ['Name', 'Affinity Group', 'State']
-        the_list = cols.map { |col| ui.color(col, :bold) }
-        connection.vnets.all.each do |vnet|
-          %w(name affinity_group state).each do |attr|
-            the_list << vnet.send(attr).to_s
-          end
-        end
-
-        puts "\n"
-        puts hl.list(the_list, :uneven_columns_across, cols.size)
+        validate_asm_keys!
+        service.list_vnets
       end
     end
   end

data/lib/chef/knife/azurerm_base.rb

@@ -0,0 +1,228 @@
+
+# Author:: Aliasgar Batterywala (aliasgar.batterywala@clogeny.com)
+#
+# Copyright:: Copyright (c) 2016 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 'chef/knife'
+require 'azure/resource_management/ARM_interface'
+require 'mixlib/shellout'
+require 'time'
+
+class Chef
+  class Knife
+    module AzurermBase
+
+      if Chef::Platform.windows?
+        require 'azure/resource_management/windows_credentials'
+        include Azure::ARM::WindowsCredentials
+      end
+
+      def self.included(includer)
+        includer.class_eval do
+
+          deps do
+            require 'readline'
+            require 'chef/json_compat'
+          end
+
+          option :azure_resource_group_name,
+            :short => "-r RESOURCE_GROUP_NAME",
+            :long => "--azure-resource-group-name RESOURCE_GROUP_NAME",
+            :description => "The Resource Group name."
+
+        end
+      end
+
+      def service
+        details = authentication_details()
+        details.update(:azure_subscription_id => locate_config_value(:azure_subscription_id))
+        @service ||= begin
+                      service = Azure::ResourceManagement::ARMInterface.new(details)
+                    end
+        @service.ui = ui
+        @service
+      end
+
+      def locate_config_value(key)
+        key = key.to_sym
+        config[key] || Chef::Config[:knife][key]  || default_config[key]
+      end
+
+      # validates ARM mandatory keys
+      def validate_arm_keys!(*keys)
+        Chef::Log.warn('Azurerm subcommands are experimental and of alpha quality. Not suitable for production use. Please use ASM subcommands for production.')
+        parse_publish_settings_file(locate_config_value(:azure_publish_settings_file)) if(locate_config_value(:azure_publish_settings_file) != nil)
+        keys.push(:azure_subscription_id)
+
+        if(locate_config_value(:azure_tenant_id).nil? || locate_config_value(:azure_client_id).nil? || locate_config_value(:azure_client_secret).nil?)
+          validate_azure_login
+        else
+           keys.concat([:azure_tenant_id, :azure_client_id, :azure_client_secret])
+        end
+
+        errors = []
+        keys.each do |k|
+          if locate_config_value(k).nil?
+            errors << "You did not provide a valid '#{pretty_key(k)}' value. Please set knife[:#{k}] in your knife.rb."
+          end
+        end
+        if errors.each{|e| ui.error(e)}.any?
+          exit 1
+        end
+      end
+
+      def authentication_details
+        if(!locate_config_value(:azure_tenant_id).nil? && !locate_config_value(:azure_client_id).nil? && !locate_config_value(:azure_client_secret).nil?)
+          return {:azure_tenant_id => locate_config_value(:azure_tenant_id), :azure_client_id => locate_config_value(:azure_client_id), :azure_client_secret => locate_config_value(:azure_client_secret)}
+        elsif Chef::Platform.windows?
+          token_details = token_details_for_windows()
+        else
+          token_details = token_details_for_linux()
+        end
+        check_token_validity(token_details)
+        return token_details
+      end
+
+      def token_details_for_linux
+        home_dir = File.expand_path('~')
+        file = File.read(home_dir + '/.azure/accessTokens.json')
+        file = eval(file)
+        token_details = {:tokentype => file[-1][:tokenType], :user => file[-1][:userId], :token => file[-1][:accessToken], :clientid => file[-1][:_clientId], :expiry_time => file[-1][:expiresOn], :refreshtoken => file[-1][:refreshToken]}
+        return token_details
+      end
+
+      def check_token_validity(token_details)
+        time_difference = Time.parse(token_details[:expiry_time]) - Time.now.utc
+        if time_difference <= 0
+          raise "Token has expired, please run any azure command like azure vm list to get new token from refresh token else run azure login command"
+        end
+      end
+
+      def validate_azure_login
+        err_string = "Please run XPLAT's 'azure login' command OR specify azure_tenant_id, azure_subscription_id, azure_client_id, azure_client_secret in your knife.rb"
+        if Chef::Platform.windows?
+          # cmdkey command is used for accessing windows credential manager
+          xplat_creds_cmd = Mixlib::ShellOut.new("cmdkey /list | findstr AzureXplatCli")
+          result = xplat_creds_cmd.run_command
+          if result.stdout.nil? || result.stdout.empty?
+            raise err_string
+          end
+        else
+          home_dir = File.expand_path('~')
+          if !File.exists?(home_dir + "/.azure/accessTokens.json") || File.size?(home_dir + '/.azure/accessTokens.json') <= 2
+            raise err_string
+          end
+        end
+      end
+
+      def parse_publish_settings_file(filename)
+        require 'nokogiri'
+        require 'base64'
+        require 'openssl'
+        require 'uri'
+        begin
+          doc = Nokogiri::XML(File.open(find_file(filename)))
+          profile = doc.at_css("PublishProfile")
+          subscription = profile.at_css("Subscription")
+          #check given PublishSettings XML file format.Currently PublishSettings file have two different XML format
+          if profile.attribute("SchemaVersion").nil?
+            management_cert = OpenSSL::PKCS12.new(Base64.decode64(profile.attribute("ManagementCertificate").value))
+            Chef::Config[:knife][:azure_api_host_name] = URI(profile.attribute("Url").value).host
+          elsif profile.attribute("SchemaVersion").value == "2.0"
+            management_cert = OpenSSL::PKCS12.new(Base64.decode64(subscription.attribute("ManagementCertificate").value))
+            Chef::Config[:knife][:azure_api_host_name] = URI(subscription.attribute("ServiceManagementUrl").value).host
+          else
+            ui.error("Publish settings file Schema not supported - " + filename)
+          end
+          Chef::Config[:knife][:azure_mgmt_cert] = management_cert.certificate.to_pem + management_cert.key.to_pem
+          Chef::Config[:knife][:azure_subscription_id] = doc.at_css("Subscription").attribute("Id").value
+        rescue=> error
+          puts "#{error.class} and #{error.message}"
+          exit 1
+        end
+      end
+
+      def find_file(name)
+        config_dir = Chef::Knife.chef_config_dir
+        if File.exist? name
+          file = name
+        elsif config_dir && File.exist?(File.join(config_dir, name))
+          file = File.join(config_dir, name)
+        elsif File.exist?(File.join(ENV['HOME'], '.chef', name))
+          file = File.join(ENV['HOME'], '.chef', name)
+        else
+          ui.error('Unable to find file - ' + name)
+          exit 1
+        end
+        file
+      end
+
+      def pretty_key(key)
+        key.to_s.gsub(/_/, ' ').gsub(/\w+/){ |w| (w =~ /(ssh)|(aws)/i) ? w.upcase  : w.capitalize }
+      end
+
+      def is_image_windows?
+        locate_config_value(:azure_image_reference_offer) =~ /WindowsServer.*/
+      end
+
+      def msg_pair(label, value, color=:cyan)
+        if value && !value.to_s.empty?
+          puts "#{ui.color(label, color)}: #{value}"
+        end
+      end
+
+      def msg_server_summary(server)
+        puts "\n\n"
+        if server.provisioningstate == 'Succeeded'
+          Chef::Log.info("Server creation went successfull.")
+          puts "\nServer Details are:\n"
+
+          msg_pair('Server ID', server.id)
+          msg_pair('Server Name', server.name)
+          msg_pair('Server Public IP Address', server.publicipaddress)
+          if is_image_windows?
+            msg_pair('Server RDP Port', server.rdpport)
+          else
+            msg_pair('Server SSH Port', server.sshport)
+          end
+          msg_pair('Server Location', server.locationname)
+          msg_pair('Server OS Type', server.ostype)
+          msg_pair('Server Provisioning State', server.provisioningstate)
+        else
+          Chef::Log.info("Server Creation Failed.")
+        end
+
+        puts "\n\n"
+
+        if server.resources.provisioning_state == 'Succeeded'
+          Chef::Log.info("Server Extension creation went successfull.")
+          puts "\nServer Extension Details are:\n"
+
+          msg_pair('Server Extension ID', server.resources.id)
+          msg_pair('Server Extension Name', server.resources.name)
+          msg_pair('Server Extension Publisher', server.resources.publisher)
+          msg_pair('Server Extension Type', server.resources.type)
+          msg_pair('Server Extension Type Handler Version', server.resources.type_handler_version)
+          msg_pair('Server Extension Provisioning State', server.resources.provisioning_state)
+        else
+          Chef::Log.info("Server Extension Creation Failed.")
+        end
+        puts "\n"
+      end
+    end
+  end
+end