chef-provisioning-azure 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2e42ada83026bc0b71619981f7011348cd7cfdbf
-  data.tar.gz: 27ba52487d1b312a1e7f7f1df15d0a2e284ce751
+  metadata.gz: 4dc56508086b8397f5e1e4eab691392011eca2bb
+  data.tar.gz: a77798d891a143c7d2a2d7d30cbd662d09d2e33e
 SHA512:
-  metadata.gz: 637d41bc82b384c8ab6fcf2c29485fdc36b29a36b28e41da47d2fea011bdba5c9e5ee19fdb220aa918f6daa128195f565087dc50e02d80ba8ba074e1474ba442
-  data.tar.gz: 4c4ea2abad65486614993bf7f54acdab970907a26d1dfb4d7f8107c56bce3d64b025de5693fac1e18948bc5e470823aa0a93951cdfbd3b739dc4b6739421d1c5
+  metadata.gz: 7997caedf65e4e61cc99dad763aa33d455aef004fb3f4faacce780b00d9497dd54f462be804132900757f830f6d3d7566c57bf7a1b9ddd48af929b71d8d945d2
+  data.tar.gz: 2b5388bea4b4b3cda7c95b5a7bbf85088c1a522992163f0067d0f0eafdc106829f7e61df20d1d0a04076555f7425215478f110652a5fd415f8ae74878aab4b9f

data/Gemfile

@@ -1,5 +1,7 @@
-source 'https://rubygems.org'
+source "https://rubygems.org"
 gemspec
 
+gem "chef", git: "https://github.com/chef/chef" if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.2.2") # until stable 12.14 is released (won't load new cheffish and such otherwise)
+
 # If you want to customize your local install, you can add stuff to Gemfile.local, which doesn't go to git
 eval(IO.read("#{__FILE__}.local")) if File.exist?("#{__FILE__}.local")

data/README.md

@@ -1,7 +1,7 @@
-[![Gitter](https://badges.gitter.im/Join Chat.svg)](https://gitter.im/chef/chef-provisioning?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
-
 # chef-provisioning-azure
 
+[![Build Status](https://travis-ci.org/chef/chef-provisioning-azure.svg?branch=master)](https://travis-ci.org/chef/chef-provisioning-azure) [![Gem Version](https://badge.fury.io/rb/chef-provisioning-azure.svg)](https://badge.fury.io/rb/chef-provisioning-azure)
+
 This is an implementation of an Microsoft Azure driver for [chef-provisioning](/chef/chef-provisioning) that relies on [azure-sdk-for-ruby](https://github.com/stuartpreston/stuartpreston-azure-sdk-for-ruby) and the Azure Service Management API.
 
 **Please note this driver does not support Azure Resource Manager (ARM) and is therefore only able to create "classic" VM resources that sit behind a cloud service in Azure. A new driver is under development - see [chef-provisioning-azurerm](https://github.com/pendrica/chef-provisioning-azurerm).**
@@ -67,28 +67,30 @@ machine 'toad' do
 end
 ```
 
-Note that images are not kept historically in Azure, therefore to find the latest images for your platform use the command ```azure vm image list``` to ensure the public image you require is available.
+Note that images are not kept historically in Azure, therefore to find the latest images for your platform use the command `azure vm image list` to ensure the public image you require is available.
 
 ## Supported Features
- * Automatic creation and teardown of Cloud Services
- * Public (OS) images and captured User (VM) images
- * Up to date (March 2015) VM sizes including 'D', 'DS', 'G', A10/A11 sizes.
- * Custom TCP/UDP endpoints per VM role
- * Linux VMs, SSH external bootstrap via cloud service endpoint
- * Windows VMs, WinRM bootstrap via cloud service endpoint
+
+- Automatic creation and teardown of Cloud Services
+- Public (OS) images and captured User (VM) images
+- Up to date (March 2015) VM sizes including 'D', 'DS', 'G', A10/A11 sizes.
+- Custom TCP/UDP endpoints per VM role
+- Linux VMs, SSH external bootstrap via cloud service endpoint
+- Windows VMs, WinRM bootstrap via cloud service endpoint
 
 ## Unsupported/will not work
- * Load-balanced sets
- * Availability sets/Fault domains
- * Cloud Service autoscaling
- * Endpoint monitoring
- * Additional disk volumes
- * Affinity groups
- * Direct server return IP addresses
- * Reserved/Static IP addresses
- * Virtual network allocation
- * Bootstrap via internal (private) addresses
- * Non-IaaS Azure services (e.g CDN/TrafficManager, Service Bus, Azure SQL Database, Media Services, Redis Cache)
+
+- Load-balanced sets
+- Availability sets/Fault domains
+- Cloud Service autoscaling
+- Endpoint monitoring
+- Additional disk volumes
+- Affinity groups
+- Direct server return IP addresses
+- Reserved/Static IP addresses
+- Virtual network allocation
+- Bootstrap via internal (private) addresses
+- Non-IaaS Azure services (e.g CDN/TrafficManager, Service Bus, Azure SQL Database, Media Services, Redis Cache)
 
 **This driver is no longer under active development as the creation of resources under Service Management mode in Azure is being deprecated in favour of Azure Resource Manager.**
 
@@ -102,7 +104,6 @@ chef gem install chef-provisioning-azure
 
 ### Setting your credentials (v0.3 and above)
 
- * If you have previously connected to your Azure subscription using the [azure-cli](http://azure.microsoft.com/en-us/documentation/articles/virtual-machines-command-line-tools/) tools and imported your publishSettings (by using ```azure account download``` and ```azure account import <filename.publishSettings>```), **you do not need to do anything else** the driver will read your profile information and certificates from ~/.azure/azureProfile.json
- * Alternatively, we support any of the methods listed in [configuration](docs/configuration.md) to set the driver up with access to your subscription
- * Note that the use of ~/.azure/config to configure the driver is **no longer supported**.
-
+- If you have previously connected to your Azure subscription using the [azure-cli](http://azure.microsoft.com/en-us/documentation/articles/virtual-machines-command-line-tools/) tools and imported your publishSettings (by using `azure account download` and `azure account import <filename.publishSettings>`), **you do not need to do anything else** the driver will read your profile information and certificates from ~/.azure/azureProfile.json
+- Alternatively, we support any of the methods listed in [configuration](docs/configuration.md) to set the driver up with access to your subscription
+- Note that the use of ~/.azure/config to configure the driver is **no longer supported**.

data/chef-provisioning-azure.gemspec

@@ -1,33 +1,34 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__) + '/lib')
-require 'chef/provisioning/azure_driver/version'
+$LOAD_PATH.unshift(File.dirname(__FILE__) + "/lib")
+require "chef/provisioning/azure_driver/version"
 
 Gem::Specification.new do |s|
-  s.name = 'chef-provisioning-azure'
+  s.name = "chef-provisioning-azure"
   s.version = Chef::Provisioning::AzureDriver::VERSION
   s.platform = Gem::Platform::RUBY
-  s.extra_rdoc_files = %w(README.md LICENSE)
-  s.summary = 'Provisioner for creating Microsoft Azure resources using ' \
-    'Chef Provisioning.'
-  s.description = 'This is a driver that works with chef-provisioning that ' \
-    'allows Chef Provisioning to manage objects in Microsoft Azure.'
-  s.author = 'John Ewart'
-  s.email = 'jewart@getchef.com'
-  s.homepage = 'https://github.com/chef/chef-provisioning-azure'
-  s.license = 'Apache-2.0'
+  s.extra_rdoc_files = %w{README.md LICENSE}
+  s.summary = "Provisioner for creating Microsoft Azure resources using " \
+    "Chef Provisioning."
+  s.description = "This is a driver that works with chef-provisioning that " \
+    "allows Chef Provisioning to manage objects in Microsoft Azure."
+  s.author = "John Ewart"
+  s.email = "jewart@chef.io"
+  s.homepage = "https://github.com/chef/chef-provisioning-azure"
+  s.license = "Apache-2.0"
 
-  s.add_dependency 'chef-provisioning', '~> 1.0'
-  s.add_dependency 'stuartpreston-azure-sdk-for-ruby', '~> 0.7'
+  s.add_dependency "chef-provisioning", ">= 1.0", "< 3.0"
+  s.add_dependency "stuartpreston-azure-sdk-for-ruby", "~> 0.7"
 
-  s.add_development_dependency 'chef', '>= 12.0'
-  s.add_development_dependency 'rspec'
-  s.add_development_dependency 'rake'
-  s.add_development_dependency 'yard'
-  s.add_development_dependency 'github_changelog_generator'
+  s.add_development_dependency "chef", ">= 12.0"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "yard"
+  s.add_development_dependency "github_changelog_generator"
+  s.add_development_dependency "chefstyle", "~> 0.4.0"
 
-  s.bindir       = 'bin'
-  s.executables  = %w( )
+  s.bindir       = "bin"
+  s.executables  = %w{ }
 
-  s.require_path = 'lib'
-  s.files = %w(Gemfile Rakefile LICENSE README.md) + Dir.glob('*.gemspec')
-  s.files += Dir.glob('{distro,lib,tasks,spec}/**/*', File::FNM_DOTMATCH).reject { |f| File.directory?(f) }
+  s.require_path = "lib"
+  s.files = %w{Gemfile Rakefile LICENSE README.md} + Dir.glob("*.gemspec")
+  s.files += Dir.glob("{distro,lib,tasks,spec}/**/*", File::FNM_DOTMATCH).reject { |f| File.directory?(f) }
 end

data/lib/chef/provider/azure_cloud_service.rb

@@ -1,4 +1,4 @@
-require 'chef/provisioning/azure_driver/azure_provider'
+require "chef/provisioning/azure_driver/azure_provider"
 
 class Chef
   class Provider

data/lib/chef/provider/azure_sql_server.rb

@@ -1,4 +1,4 @@
-require 'chef/provisioning/azure_driver/azure_provider'
+require "chef/provisioning/azure_driver/azure_provider"
 
 class Chef
   class Provider
@@ -14,11 +14,11 @@ class Chef
                                         "#{new_resource.options[:location]}")
         server = properties.name
 
-        new_resource.options[:firewall_rules].each do | rule |
-          rule_name = URI::encode(rule[:name])
+        new_resource.options[:firewall_rules].each do |rule|
+          rule_name = URI.encode(rule[:name])
           range = {
             :start_ip_address => rule[:start_ip_address],
-            :end_ip_address => rule[:end_ip_address]
+            :end_ip_address => rule[:end_ip_address],
           }
           csql.set_sql_server_firewall_rule(server, rule_name, range)
         end
@@ -29,7 +29,7 @@ class Chef
 
       action :destroy do
         # not supported
-        fail "Destroy not yet implemented on Azure SQL Server using ASM."
+        raise "Destroy not yet implemented on Azure SQL Server using ASM."
       end
     end
   end

data/lib/chef/provider/azure_storage_account.rb

@@ -1,4 +1,4 @@
-require 'chef/provisioning/azure_driver/azure_provider'
+require "chef/provisioning/azure_driver/azure_provider"
 
 class Chef
   class Provider

data/lib/chef/provisioning/azure_driver.rb

@@ -1,3 +1,3 @@
-require 'chef/provisioning'
-require 'chef/provisioning/azure_driver/driver'
-require 'chef/provisioning/azure_driver/resources'
+require "chef/provisioning"
+require "chef/provisioning/azure_driver/driver"
+require "chef/provisioning/azure_driver/resources"

data/lib/chef/provisioning/azure_driver/azure_provider.rb

@@ -1,7 +1,7 @@
-require 'chef/provider/lwrp_base'
-require 'chef/provisioning/azure_driver/azure_resource'
-require 'chef/provisioning/chef_provider_action_handler'
-require 'azure'
+require "chef/provider/lwrp_base"
+require "chef/provisioning/azure_driver/azure_resource"
+require "chef/provisioning/chef_provider_action_handler"
+require "azure"
 
 class Chef
   module Provisioning
@@ -12,7 +12,7 @@ class Chef
         AzureResource = Chef::Provisioning::AzureDriver::AzureResource
 
         def azure_sql_management_endpoint
-          'https://management.database.windows.net:8443'
+          "https://management.database.windows.net:8443"
         end
 
         def action_handler

data/lib/chef/provisioning/azure_driver/azure_resource.rb

@@ -1,5 +1,5 @@
-require 'chef/resource/lwrp_base'
-require 'chef/provisioning/azure_driver/subscriptions'
+require "chef/resource/lwrp_base"
+require "chef/provisioning/azure_driver/subscriptions"
 
 class Chef
   module Provisioning
@@ -14,7 +14,7 @@ class Chef
           end
 
           config = run_context.chef_provisioning.config
-          scheme, account_id = driver.split(':', 2)
+          scheme, account_id = driver.split(":", 2)
 
           if account_id.nil? || account_id.empty?
             subscription = Subscriptions.default_subscription(config)
@@ -43,7 +43,7 @@ class Chef
         attribute :driver
         attribute :chef_server, kind_of: Hash
         attribute :managed_entry_store, kind_of: Chef::Provisioning::ManagedEntryStore,
-                                  lazy_default: proc { Chef::Provisioning::ChefManagedEntryStore.new(chef_server) }
+                                        lazy_default: proc { Chef::Provisioning::ChefManagedEntryStore.new(chef_server) }
         attribute :subscription
       end
     end

data/lib/chef/provisioning/azure_driver/bootstrap_options.rb

@@ -1,25 +1,25 @@
 class Chef
-module Provisioning
-module AzureDriver
-  # Represents available options when bootstrapping a host on Azure
-  # These are used to tell Azure some initial pieces of information
-  # for building a new VM.
-  class BootstrapOptions < Chef::Provisioning::BootstrapOptions
-    # @return [String] The name of the VM
-    attr_accessor :vm_name
+  module Provisioning
+    module AzureDriver
+      # Represents available options when bootstrapping a host on Azure
+      # These are used to tell Azure some initial pieces of information
+      # for building a new VM.
+      class BootstrapOptions < Chef::Provisioning::BootstrapOptions
+        # @return [String] The name of the VM
+        attr_accessor :vm_name
 
-    # @return [String] The VM user
-    attr_accessor :vm_user
+        # @return [String] The VM user
+        attr_accessor :vm_user
 
-    # @return [String] The identifier for the VM image to use
-    attr_accessor :image
+        # @return [String] The identifier for the VM image to use
+        attr_accessor :image
 
-    # @return [String] the password to use
-    attr_accessor :password
+        # @return [String] the password to use
+        attr_accessor :password
 
-    # @return [String] The Azure location to store this in
-    attr_accessor :location
+        # @return [String] The Azure location to store this in
+        attr_accessor :location
+      end
+    end
   end
 end
-end
-end

data/lib/chef/provisioning/azure_driver/constants.rb

@@ -1,34 +1,34 @@
 class Chef
-module Provisioning
-module AzureDriver
-  # A collection of useful Azure-specific constants
-  class Constants
-    # Constants around transport mechanisms available
-    class Transport
-      HTTP = 'http'
-      HTTPS = 'https'
-    end
+  module Provisioning
+    module AzureDriver
+      # A collection of useful Azure-specific constants
+      class Constants
+        # Constants around transport mechanisms available
+        class Transport
+          HTTP = "http"
+          HTTPS = "https"
+        end
 
-    # Constants for describing VM sizes in Azure
-    class MachineSize
-      # Put in machine specs here...
-      EXTRASMALL = 'ExtraSmall'
-      # What is this?
-      SMALL = 'Small'
-      # Are these now A2?
-      MEDIUM = 'Medium'
-      LARGE = 'Large'
-      XLARGE = 'ExtraLarge'
-      A5 = 'A5'
-      A6 = 'A6'
-      A7 = 'A7'
-      BASIC_A0 = 'Basic_A0'
-      BASIC_A1 = 'Basic_A1'
-      BASIC_A2 = 'Basic_A2'
-      BASIC_A3 = 'Basic_A3'
-      BASIC_A4 = 'Basic_A4'
+        # Constants for describing VM sizes in Azure
+        class MachineSize
+          # Put in machine specs here...
+          EXTRASMALL = "ExtraSmall"
+          # What is this?
+          SMALL = "Small"
+          # Are these now A2?
+          MEDIUM = "Medium"
+          LARGE = "Large"
+          XLARGE = "ExtraLarge"
+          A5 = "A5"
+          A6 = "A6"
+          A7 = "A7"
+          BASIC_A0 = "Basic_A0"
+          BASIC_A1 = "Basic_A1"
+          BASIC_A2 = "Basic_A2"
+          BASIC_A3 = "Basic_A3"
+          BASIC_A4 = "Basic_A4"
+        end
+      end
     end
   end
 end
-end
-end

data/lib/chef/provisioning/azure_driver/driver.rb

@@ -1,360 +1,360 @@
-require 'chef/mixin/shell_out'
-require 'chef/provisioning/driver'
-require 'chef/provisioning/convergence_strategy/install_cached'
-require 'chef/provisioning/convergence_strategy/install_sh'
-require 'chef/provisioning/convergence_strategy/install_msi'
-require 'chef/provisioning/convergence_strategy/no_converge'
-require 'chef/provisioning/transport/ssh'
-require 'chef/provisioning/transport/winrm'
-require 'chef/provisioning/machine/windows_machine'
-require 'chef/provisioning/machine/unix_machine'
-require 'chef/provisioning/machine_spec'
-
-require 'chef/provisioning/azure_driver/version'
-require 'chef/provisioning/azure_driver/subscriptions'
-
-require 'yaml'
-require 'azure'
+require "chef/mixin/shell_out"
+require "chef/provisioning/driver"
+require "chef/provisioning/convergence_strategy/install_cached"
+require "chef/provisioning/convergence_strategy/install_sh"
+require "chef/provisioning/convergence_strategy/install_msi"
+require "chef/provisioning/convergence_strategy/no_converge"
+require "chef/provisioning/transport/ssh"
+require "chef/provisioning/transport/winrm"
+require "chef/provisioning/machine/windows_machine"
+require "chef/provisioning/machine/unix_machine"
+require "chef/provisioning/machine_spec"
+
+require "chef/provisioning/azure_driver/version"
+require "chef/provisioning/azure_driver/subscriptions"
+
+require "yaml"
+require "azure"
 
 class Chef
-module Provisioning
-module AzureDriver
-  # Provisions machines using the Azure SDK
-  class Driver < Chef::Provisioning::Driver
-    attr_reader :region
-
-    # Construct an AzureDriver object from a URL - used to parse existing URL
-    # data to hydrate a driver object.
-    # URL scheme:
-    # azure:subscription_id
-    # @return [AzureDriver] A chef-provisioning Azure driver object for the given URL
-    def self.from_url(driver_url, config)
-      Driver.new(driver_url, config)
-    end
-
-    def self.canonicalize_url(driver_url, config)
-      scheme, account_id = driver_url.split(':', 2)
-      if account_id.nil? || account_id.empty?
-        subscription = Subscriptions.default_subscription(config)
-        if !subscription
-          raise "Driver #{driver_url} did not specify a subscription ID, and no default subscription was found.  Have you downloaded the Azure CLI and used `azure account download` and `azure account import` to set up Azure?  Alternately, you can set azure_subscriptions to [ { subscription_id: '...', management_credentials: ... }] in your Chef configuration."
+  module Provisioning
+    module AzureDriver
+      # Provisions machines using the Azure SDK
+      class Driver < Chef::Provisioning::Driver
+        attr_reader :region
+
+        # Construct an AzureDriver object from a URL - used to parse existing URL
+        # data to hydrate a driver object.
+        # URL scheme:
+        # azure:subscription_id
+        # @return [AzureDriver] A chef-provisioning Azure driver object for the given URL
+        def self.from_url(driver_url, config)
+          Driver.new(driver_url, config)
         end
-        config = Cheffish::MergedConfig.new({ azure_subscriptions: subscription }, config)
-      end
-      if subscription
-        [ "#{scheme}:#{subscription[:subscription_id]}", config ]
-      else
-        [ driver_url, config]
-      end
-    end
-
-    def initialize(driver_url, config)
-      super
-      scheme, subscription_id = driver_url.split(':', 2)
-      @subscription = Subscriptions.get_subscription(config, subscription_id)
-      if !subscription
-        raise "Driver #{driver_url} has a subscription ID, but the system has no credentials configured for it!  If you have access to this subscription, you can use `azure account download` and `azure account import` in the Azure CLI to get the credentials, or set azure_subscriptions to [ { subscription_id: '...', management_credentials: ... }] in your Chef configuration."
-      end
-
-      # TODO make this instantiable so we can have multiple drivers ......
-      Azure.configure do |azure|
-        # Configure these 3 properties to use Storage
-        azure.management_certificate = subscription[:management_certificate]
-        azure.subscription_id        = subscription[:subscription_id]
-        azure.management_endpoint    = subscription[:management_endpoint]
-      end
-    end
-
-    attr_reader :subscription
-
-    # -- Machine methods --
-
-    # Allocate a new machine with the Azure API and start it up, without
-    # blocking to wait for it. Creates any needed resources to get a machine
-    # up and running.
-    # @param (see Chef::Provisioning::Driver#allocate_machine)
-    def allocate_machine(action_handler, machine_spec, machine_options)
-      existing_vm = vm_for(machine_spec)
-
-      # We don't need to do anything if the existing VM is found
-      return if existing_vm
-
-      bootstrap_options = machine_options[:bootstrap_options] || {}
-      bootstrap_options[:vm_size] ||= 'Small'
-      bootstrap_options[:cloud_service_name] ||= 'chefprovisioning'
-      bootstrap_options[:storage_account_name] ||=  'chefprovisioning'
-      bootstrap_options[:location] ||=  'West US'
-
-      location = bootstrap_options[:location]
-
-      machine_spec.location = {
-        'driver_url' => driver_url,
-        'driver_version' => Chef::Provisioning::AzureDriver::VERSION,
-        'allocated_at' => Time.now.utc.to_s,
-        'host_node' => action_handler.host_node,
-        'image_id' => machine_options[:image_id],
-        'location' => location,
-        'cloud_service' => bootstrap_options[:cloud_service_name]
-      }
-
-      image_id = machine_options[:image_id] || default_image_for_location(location)
-
-      Chef::Log.debug "Azure bootstrap options: #{bootstrap_options.inspect}"
-
-      params = {
-          vm_name: machine_spec.name,
-          vm_user: bootstrap_options[:vm_user] || default_ssh_username,
-          image: image_id,
-          # This is only until SSH keys are added
-          password: machine_options[:password],
-          location: location,
-          cloud_service_name: bootstrap_options[:cloud_service_name]
-      }
-
-      # If the cloud service exists already, need to add a role to it - otherwise create virtual machine (including cloud service)
-      cloud_service = azure_cloud_service_service.get_cloud_service(bootstrap_options[:cloud_service_name])
-      existing_deployment = azure_vm_service.list_virtual_machines(bootstrap_options[:cloud_service_name]).any?
-
-      if cloud_service and existing_deployment
-        action_handler.report_progress "Cloud Service #{bootstrap_options[:cloud_service_name]} already exists, adding role."
-        action_handler.report_progress "Creating #{machine_spec.name} with image #{image_id} in #{bootstrap_options[:cloud_service_name]}..."
-        vm = azure_vm_service.add_role(params, bootstrap_options)
-      else
-        action_handler.report_progress "Creating #{machine_spec.name} with image #{image_id} in #{location}..."
-        vm = azure_vm_service.create_virtual_machine(params, bootstrap_options)
-      end
-
-      machine_spec.location['vm_name'] = vm.vm_name
-      machine_spec.location['is_windows'] = (true if vm.os_type == 'Windows') || false
-      action_handler.report_progress "Created #{vm.vm_name} in #{location}..."
-    end
-
-    # (see Chef::Provisioning::Driver#ready_machine)
-    def ready_machine(action_handler, machine_spec, machine_options)
-      vm = vm_for(machine_spec)
-      location = machine_spec.location['location']
-
-      if vm.nil?
-        fail "Machine #{machine_spec.name} does not have a VM associated with it, or the VM does not exist."
-      end
 
-      # TODO: Not sure if this is the right thing to check
-      if vm.status != 'ReadyRole'
-        action_handler.report_progress "Readying #{machine_spec.name} in #{location}..."
-        wait_until_ready(action_handler, machine_spec)
-        wait_for_transport(action_handler, machine_spec, machine_options)
-      else
-        action_handler.report_progress "#{machine_spec.name} already ready in #{location}!"
-      end
-
-      machine_for(machine_spec, machine_options, vm)
-    end
+        def self.canonicalize_url(driver_url, config)
+          scheme, account_id = driver_url.split(":", 2)
+          if account_id.nil? || account_id.empty?
+            subscription = Subscriptions.default_subscription(config)
+            if !subscription
+              raise "Driver #{driver_url} did not specify a subscription ID, and no default subscription was found.  Have you downloaded the Azure CLI and used `azure account download` and `azure account import` to set up Azure?  Alternately, you can set azure_subscriptions to [ { subscription_id: '...', management_credentials: ... }] in your Chef configuration."
+            end
+            config = Cheffish::MergedConfig.new({ azure_subscriptions: subscription }, config)
+          end
+          if subscription
+            [ "#{scheme}:#{subscription[:subscription_id]}", config ]
+          else
+            [ driver_url, config]
+          end
+        end
 
-    # (see Chef::Provisioning::Driver#destroy_machine)
-    def destroy_machine(action_handler, machine_spec, machine_options)
-      vm = vm_for(machine_spec)
-      vm_name = machine_spec.name
-      cloud_service = machine_spec.location['cloud_service']
+        def initialize(driver_url, config)
+          super
+          scheme, subscription_id = driver_url.split(":", 2)
+          @subscription = Subscriptions.get_subscription(config, subscription_id)
+          if !subscription
+            raise "Driver #{driver_url} has a subscription ID, but the system has no credentials configured for it!  If you have access to this subscription, you can use `azure account download` and `azure account import` in the Azure CLI to get the credentials, or set azure_subscriptions to [ { subscription_id: '...', management_credentials: ... }] in your Chef configuration."
+          end
+
+          # TODO make this instantiable so we can have multiple drivers ......
+          Azure.configure do |azure|
+            # Configure these 3 properties to use Storage
+            azure.management_certificate = subscription[:management_certificate]
+            azure.subscription_id        = subscription[:subscription_id]
+            azure.management_endpoint    = subscription[:management_endpoint]
+          end
+        end
 
-      # Check if we need to proceed
-      return if vm.nil? || vm_name.nil? || cloud_service.nil?
+        attr_reader :subscription
+
+        # -- Machine methods --
+
+        # Allocate a new machine with the Azure API and start it up, without
+        # blocking to wait for it. Creates any needed resources to get a machine
+        # up and running.
+        # @param (see Chef::Provisioning::Driver#allocate_machine)
+        def allocate_machine(action_handler, machine_spec, machine_options)
+          existing_vm = vm_for(machine_spec)
+
+          # We don't need to do anything if the existing VM is found
+          return if existing_vm
+
+          bootstrap_options = machine_options[:bootstrap_options] || {}
+          bootstrap_options[:vm_size] ||= "Small"
+          bootstrap_options[:cloud_service_name] ||= "chefprovisioning"
+          bootstrap_options[:storage_account_name] ||= "chefprovisioning"
+          bootstrap_options[:location] ||= "West US"
+
+          location = bootstrap_options[:location]
+
+          machine_spec.location = {
+            "driver_url" => driver_url,
+            "driver_version" => Chef::Provisioning::AzureDriver::VERSION,
+            "allocated_at" => Time.now.utc.to_s,
+            "host_node" => action_handler.host_node,
+            "image_id" => machine_options[:image_id],
+            "location" => location,
+            "cloud_service" => bootstrap_options[:cloud_service_name],
+          }
+
+          image_id = machine_options[:image_id] || default_image_for_location(location)
+
+          Chef::Log.debug "Azure bootstrap options: #{bootstrap_options.inspect}"
+
+          params = {
+              vm_name: machine_spec.name,
+              vm_user: bootstrap_options[:vm_user] || default_ssh_username,
+              image: image_id,
+              # This is only until SSH keys are added
+              password: machine_options[:password],
+              location: location,
+              cloud_service_name: bootstrap_options[:cloud_service_name],
+          }
+
+          # If the cloud service exists already, need to add a role to it - otherwise create virtual machine (including cloud service)
+          cloud_service = azure_cloud_service_service.get_cloud_service(bootstrap_options[:cloud_service_name])
+          existing_deployment = azure_vm_service.list_virtual_machines(bootstrap_options[:cloud_service_name]).any?
+
+          if cloud_service && existing_deployment
+            action_handler.report_progress "Cloud Service #{bootstrap_options[:cloud_service_name]} already exists, adding role."
+            action_handler.report_progress "Creating #{machine_spec.name} with image #{image_id} in #{bootstrap_options[:cloud_service_name]}..."
+            vm = azure_vm_service.add_role(params, bootstrap_options)
+          else
+            action_handler.report_progress "Creating #{machine_spec.name} with image #{image_id} in #{location}..."
+            vm = azure_vm_service.create_virtual_machine(params, bootstrap_options)
+          end
+
+          machine_spec.location["vm_name"] = vm.vm_name
+          machine_spec.location["is_windows"] = (true if vm.os_type == "Windows") || false
+          action_handler.report_progress "Created #{vm.vm_name} in #{location}..."
+        end
 
-      # Skip if we don't actually need to do anything
-      return unless action_handler.should_perform_actions
+        # (see Chef::Provisioning::Driver#ready_machine)
+        def ready_machine(action_handler, machine_spec, machine_options)
+          vm = vm_for(machine_spec)
+          location = machine_spec.location["location"]
+
+          if vm.nil?
+            raise "Machine #{machine_spec.name} does not have a VM associated with it, or the VM does not exist."
+          end
+
+          # TODO: Not sure if this is the right thing to check
+          if vm.status != "ReadyRole"
+            action_handler.report_progress "Readying #{machine_spec.name} in #{location}..."
+            wait_until_ready(action_handler, machine_spec)
+            wait_for_transport(action_handler, machine_spec, machine_options)
+          else
+            action_handler.report_progress "#{machine_spec.name} already ready in #{location}!"
+          end
+
+          machine_for(machine_spec, machine_options, vm)
+        end
 
-      # TODO: action_handler.do |block| ?
-      action_handler.report_progress "Destroying VM #{machine_spec.name}!"
-      azure_vm_service.delete_virtual_machine(vm_name, cloud_service)
-      action_handler.report_progress "Destroyed VM #{machine_spec.name}!"
-    end
+        # (see Chef::Provisioning::Driver#destroy_machine)
+        def destroy_machine(action_handler, machine_spec, machine_options)
+          vm = vm_for(machine_spec)
+          vm_name = machine_spec.name
+          cloud_service = machine_spec.location["cloud_service"]
 
-    private
+          # Check if we need to proceed
+          return if vm.nil? || vm_name.nil? || cloud_service.nil?
 
-    def machine_for(machine_spec, machine_options, vm = nil)
-      vm ||= vm_for(machine_spec)
+          # Skip if we don't actually need to do anything
+          return unless action_handler.should_perform_actions
 
-      fail "VM for node #{machine_spec.name} has not been created!" unless vm
+          # TODO: action_handler.do |block| ?
+          action_handler.report_progress "Destroying VM #{machine_spec.name}!"
+          azure_vm_service.delete_virtual_machine(vm_name, cloud_service)
+          action_handler.report_progress "Destroyed VM #{machine_spec.name}!"
+        end
 
-      transport =  transport_for(machine_spec, machine_options, vm)
-      convergence_strategy = convergence_strategy_for(machine_spec, machine_options)
+        private
 
-      if machine_spec.location['is_windows']
-        Chef::Provisioning::Machine::WindowsMachine.new(machine_spec, transport, convergence_strategy)
-      else
-        Chef::Provisioning::Machine::UnixMachine.new(machine_spec, transport, convergence_strategy)
-      end
-    end
+        def machine_for(machine_spec, machine_options, vm = nil)
+          vm ||= vm_for(machine_spec)
 
-    def azure_vm_service
-      @vm_service ||= Azure::VirtualMachineManagementService.new
-    end
+          raise "VM for node #{machine_spec.name} has not been created!" unless vm
 
-    def azure_cloud_service_service
-      @cloud_service_service ||= Azure::CloudServiceManagementService.new
-    end
+          transport =  transport_for(machine_spec, machine_options, vm)
+          convergence_strategy = convergence_strategy_for(machine_spec, machine_options)
 
-    def default_ssh_username
-      'ubuntu'
-    end
+          if machine_spec.location["is_windows"]
+            Chef::Provisioning::Machine::WindowsMachine.new(machine_spec, transport, convergence_strategy)
+          else
+            Chef::Provisioning::Machine::UnixMachine.new(machine_spec, transport, convergence_strategy)
+          end
+        end
 
-    def vm_for(machine_spec)
-      if machine_spec.location && machine_spec.name
-        existing_vms = azure_vm_service.list_virtual_machines
-        existing_vms.select { |vm| vm.vm_name == machine_spec.name }.first
-      else
-        nil
-      end
-    end
+        def azure_vm_service
+          @vm_service ||= Azure::VirtualMachineManagementService.new
+        end
 
-    def transport_for(machine_spec, machine_options, vm)
-      if machine_spec.location['is_windows']
-        create_winrm_transport(machine_spec, machine_options, vm)
-      else
-        create_ssh_transport(machine_spec, machine_options, vm)
-      end
-    end
+        def azure_cloud_service_service
+          @cloud_service_service ||= Azure::CloudServiceManagementService.new
+        end
 
-    def default_image_for_location(location)
-      Chef::Log.debug("Choosing default image for region '#{location}'")
+        def default_ssh_username
+          "ubuntu"
+        end
 
-      case location
-      when 'East US'
-      when 'Southeast Asia'
-      when 'West US'
-        'b39f27a8b8c64d52b05eac6a62ebad85__Ubuntu-14_04_1-LTS-amd64-server-20140927-en-us-30GB'
-      else
-        raise 'Unsupported location!'
-      end
-    end
+        def vm_for(machine_spec)
+          if machine_spec.location && machine_spec.name
+            existing_vms = azure_vm_service.list_virtual_machines
+            existing_vms.select { |vm| vm.vm_name == machine_spec.name }.first
+          else
+            nil
+          end
+        end
 
-    def create_ssh_transport(machine_spec, machine_options, vm)
-      bootstrap_options = machine_options[:bootstrap_options] || {}
-      username = bootstrap_options[:vm_user] || default_ssh_username
-      tcp_endpoint = vm.tcp_endpoints.select { |tcp| tcp[:name] == 'SSH' }.first
-      remote_host = tcp_endpoint[:vip]
+        def transport_for(machine_spec, machine_options, vm)
+          if machine_spec.location["is_windows"]
+            create_winrm_transport(machine_spec, machine_options, vm)
+          else
+            create_ssh_transport(machine_spec, machine_options, vm)
+          end
+        end
 
-      # TODO: not this... replace with SSH key ASAP, only for getting this thing going...
-      ssh_options = {
-        password: machine_options[:password],
-        port: tcp_endpoint[:public_port] # use public port from Cloud Service endpoint
-      }
+        def default_image_for_location(location)
+          Chef::Log.debug("Choosing default image for region '#{location}'")
+
+          case location
+          when "East US"
+          when "Southeast Asia"
+          when "West US"
+            "b39f27a8b8c64d52b05eac6a62ebad85__Ubuntu-14_04_1-LTS-amd64-server-20140927-en-us-30GB"
+          else
+            raise "Unsupported location!"
+          end
+        end
 
-      options = {}
-      options[:prefix] = 'sudo ' if machine_spec.location[:sudo] || username != 'root'
+        def create_ssh_transport(machine_spec, machine_options, vm)
+          bootstrap_options = machine_options[:bootstrap_options] || {}
+          username = bootstrap_options[:vm_user] || default_ssh_username
+          tcp_endpoint = vm.tcp_endpoints.select { |tcp| tcp[:name] == "SSH" }.first
+          remote_host = tcp_endpoint[:vip]
 
-      # Enable pty by default
-      # TODO: why?
-      options[:ssh_pty_enable] = true
-      options[:ssh_gateway] ||= machine_spec.location['ssh_gateway']
+          # TODO: not this... replace with SSH key ASAP, only for getting this thing going...
+          ssh_options = {
+            password: machine_options[:password],
+            port: tcp_endpoint[:public_port] # use public port from Cloud Service endpoint
+          }
 
-      Chef::Provisioning::Transport::SSH.new(remote_host, username, ssh_options, options, config)
-    end
+          options = {}
+          options[:prefix] = "sudo " if machine_spec.location[:sudo] || username != "root"
 
-    def create_winrm_transport(machine_spec, machine_options, instance)
-      winrm_transport_options = machine_options[:bootstrap_options][:winrm_transport]
-      shared_winrm_options = {
-          :user => machine_options[:vm_user] || 'localadmin',
-          :pass => machine_options[:password] # TODO: Replace with encryption
-      }
-
-      if(winrm_transport_options['https'])
-        tcp_endpoint = instance.tcp_endpoints.select { |tcp| tcp[:name] == 'PowerShell' }.first
-        remote_host = tcp_endpoint[:vip]
-        port = tcp_endpoint[:public_port] || default_winrm_https_port
-        endpoint = "https://#{remote_host}:#{port}/wsman"
-        type = :ssl
-        winrm_options = {
-          :disable_sspi => winrm_transport_options['https'][:disable_sspi] || false, # default to Negotiate
-          :basic_auth_only => winrm_transport_options['https'][:basic_auth_only] || false, # disallow Basic auth by default
-          :no_ssl_peer_verification => winrm_transport_options['https'][:no_ssl_peer_verification] || false #disallow MITM potential by default
-        }
-      end
+          # Enable pty by default
+          # TODO: why?
+          options[:ssh_pty_enable] = true
+          options[:ssh_gateway] ||= machine_spec.location["ssh_gateway"]
 
-      if(winrm_transport_options['http'])
-        tcp_endpoint = instance.tcp_endpoints.select { |tcp| tcp[:name] == 'WinRm-Http' }.first
-        remote_host = tcp_endpoint[:vip]
-        port = tcp_endpoint[:public_port] || default_winrm_http_port
-        endpoint = "http://#{remote_host}:#{port}/wsman"
-        type = :plaintext
-        winrm_options = {
-          :disable_sspi => winrm_transport_options['http']['disable_sspi'] || false, # default to Negotiate
-          :basic_auth_only => winrm_transport_options['http']['basic_auth_only'] || false # disallow Basic auth by default
-        }
-      end
+          Chef::Provisioning::Transport::SSH.new(remote_host, username, ssh_options, options, config)
+        end
 
-      merged_winrm_options = winrm_options.merge(shared_winrm_options)
-      Chef::Provisioning::Transport::WinRM.new("#{endpoint}", type, merged_winrm_options, {})
-    end
+        def create_winrm_transport(machine_spec, machine_options, instance)
+          winrm_transport_options = machine_options[:bootstrap_options][:winrm_transport]
+          shared_winrm_options = {
+              :user => machine_options[:bootstrap_options][:vm_user] || default_ssh_username,
+              :pass => machine_options[:password] # TODO: Replace with encryption
+          }
+
+          if winrm_transport_options["https"]
+            tcp_endpoint = instance.tcp_endpoints.select { |tcp| tcp[:name] == "PowerShell" }.first
+            remote_host = tcp_endpoint[:vip]
+            port = tcp_endpoint[:public_port] || default_winrm_https_port
+            endpoint = "https://#{remote_host}:#{port}/wsman"
+            type = :ssl
+            winrm_options = {
+              :disable_sspi => winrm_transport_options["https"][:disable_sspi] || false, # default to Negotiate
+              :basic_auth_only => winrm_transport_options["https"][:basic_auth_only] || false, # disallow Basic auth by default
+              :no_ssl_peer_verification => winrm_transport_options["https"][:no_ssl_peer_verification] || false #disallow MITM potential by default
+            }
+          end
+
+          if winrm_transport_options["http"]
+            tcp_endpoint = instance.tcp_endpoints.select { |tcp| tcp[:name] == "WinRm-Http" }.first
+            remote_host = tcp_endpoint[:vip]
+            port = tcp_endpoint[:public_port] || default_winrm_http_port
+            endpoint = "http://#{remote_host}:#{port}/wsman"
+            type = :plaintext
+            winrm_options = {
+              :disable_sspi => winrm_transport_options["http"]["disable_sspi"] || false, # default to Negotiate
+              :basic_auth_only => winrm_transport_options["http"]["basic_auth_only"] || false # disallow Basic auth by default
+            }
+          end
+
+          merged_winrm_options = winrm_options.merge(shared_winrm_options)
+          Chef::Provisioning::Transport::WinRM.new("#{endpoint}", type, merged_winrm_options, {})
+        end
 
-    def default_winrm_http_port
-      5985
-    end
+        def default_winrm_http_port
+          5985
+        end
 
-    def default_winrm_https_port
-      5986
-    end
+        def default_winrm_https_port
+          5986
+        end
 
-    def convergence_strategy_for(machine_spec, machine_options)
-      convergence_options = machine_options[:convergence_options]
-      # Defaults
-      unless machine_spec.location
-        return Chef::Provisioning::ConvergenceStrategy::NoConverge.new(convergence_options, config)
-      end
+        def convergence_strategy_for(machine_spec, machine_options)
+          convergence_options = machine_options[:convergence_options]
+          # Defaults
+          unless machine_spec.location
+            return Chef::Provisioning::ConvergenceStrategy::NoConverge.new(convergence_options, config)
+          end
+
+          if machine_spec.location["is_windows"]
+            Chef::Provisioning::ConvergenceStrategy::InstallMsi.new(convergence_options, config)
+          elsif machine_options[:cached_installer]
+            Chef::Provisioning::ConvergenceStrategy::InstallCached.new(convergence_options, config)
+          else
+            Chef::Provisioning::ConvergenceStrategy::InstallSh.new(convergence_options, config)
+          end
+        end
 
-      if machine_spec.location['is_windows']
-        Chef::Provisioning::ConvergenceStrategy::InstallMsi.new(convergence_options, config)
-      elsif machine_options[:cached_installer]
-        Chef::Provisioning::ConvergenceStrategy::InstallCached.new(convergence_options, config)
-      else
-        Chef::Provisioning::ConvergenceStrategy::InstallSh.new(convergence_options, config)
-      end
-    end
+        def wait_until_ready(action_handler, machine_spec)
+          vm = vm_for(machine_spec)
 
-    def wait_until_ready(action_handler, machine_spec)
-      vm = vm_for(machine_spec)
+          # If the machine is ready, nothing to do
+          return if vm.status == "ReadyRole"
 
-      # If the machine is ready, nothing to do
-      return if vm.status == 'ReadyRole'
+          # Skip if we don't actually need to do anything
+          return unless action_handler.should_perform_actions
 
-      # Skip if we don't actually need to do anything
-      return unless action_handler.should_perform_actions
+          time_elapsed = 0
+          sleep_time = 10
+          max_wait_time = 120
 
-      time_elapsed = 0
-      sleep_time = 10
-      max_wait_time = 120
+          action_handler.report_progress "waiting for #{machine_spec.name} to be ready ..."
+          while time_elapsed < 120 && vm.status != "ReadyRole"
+            action_handler.report_progress "#{time_elapsed}/#{max_wait_time}s..."
+            sleep(sleep_time)
+            time_elapsed += sleep_time
+            # Azure caches results
+            vm = vm_for(machine_spec)
+          end
+          action_handler.report_progress "#{machine_spec.name} is now ready"
+        end
 
-      action_handler.report_progress "waiting for #{machine_spec.name} to be ready ..."
-      while time_elapsed < 120 && vm.status != 'ReadyRole'
-        action_handler.report_progress "#{time_elapsed}/#{max_wait_time}s..."
-        sleep(sleep_time)
-        time_elapsed += sleep_time
-        # Azure caches results
-        vm = vm_for(machine_spec)
-      end
-      action_handler.report_progress "#{machine_spec.name} is now ready"
-    end
+        def wait_for_transport(action_handler, machine_spec, machine_options)
+          vm = vm_for(machine_spec)
+          transport = transport_for(machine_spec, machine_options, vm)
 
-    def wait_for_transport(action_handler, machine_spec, machine_options)
-      vm = vm_for(machine_spec)
-      transport = transport_for(machine_spec, machine_options, vm)
+          return if transport.available?
+          return unless action_handler.should_perform_actions
 
-      return if transport.available?
-      return unless action_handler.should_perform_actions
+          time_elapsed = 0
+          sleep_time = 10
+          max_wait_time = 120
 
-      time_elapsed = 0
-      sleep_time = 10
-      max_wait_time = 120
+          action_handler.report_progress "Waiting for transport on #{machine_spec.name} ..."
+          while time_elapsed < 120 && !transport.available?
+            action_handler.report_progress "#{time_elapsed}/#{max_wait_time}s..."
+            sleep(sleep_time)
+            time_elapsed += sleep_time
+          end
+          action_handler.report_progress "Transport to #{machine_spec.name} is now up!"
+        end
 
-      action_handler.report_progress "Waiting for transport on #{machine_spec.name} ..."
-      while time_elapsed < 120 && !transport.available?
-        action_handler.report_progress "#{time_elapsed}/#{max_wait_time}s..."
-        sleep(sleep_time)
-        time_elapsed += sleep_time
       end
-      action_handler.report_progress "Transport to #{machine_spec.name} is now up!"
     end
-
   end
 end
-end
-end