foreman_azure_rm 1.3.1 → 2.0.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: c1c4e6dbdc0dbe85c19fed181beb16d91aac9909
-  data.tar.gz: 84a125c8cccf9e472805d98b7841b1008d7f095d
+SHA256:
+  metadata.gz: 8cdbc28091795bf21377b298699209cc2a0d06365858d117b9468a466fb0ffe2
+  data.tar.gz: 938f88f1ac6e6f9d9101ce57d2bf187e5c1196fd4abf68c667ae38db5c3270e2
 SHA512:
-  metadata.gz: db1923e2cc13efd600fe2fc3192556491043e656b9a92e3920f4368c0c1d37b53dbdb9f501f89b93dcae541a14c6aac1f95409ad1238bb06ac7f08b4d13caf5b
-  data.tar.gz: 7efdedb724d265fba4664acab40846fd10fee503cd5d52f3d499568ef89763fc3696dc840370796e6923763836651a883c7242059915cb7bcbf4d6c74f40b0cc
+  metadata.gz: c4def716d7fa2719d629c0bb9029a60e079e5578c16a33c9baa624462e3da7cdf634fa8f64070fef86bd4b615f9bccafedb427f073facad2a3e5f021bb74eedc
+  data.tar.gz: e2dbb0b84df8d5d7a62fa87486b858c5ee11cd28dcdf072ada26cbd77036942837f92f699e7738f40378cc839d0fde9cfc113d53c846b5af84af17dec14f78f4

data/README.md

@@ -1,23 +1,51 @@
-# Foreman Azure
+# Foreman AzureRM Plugin
 
 ## Description
-Plugin to add [Microsoft Azure Resource Manager](http://azure.com/) as a compute resource for [The Foreman](http://theforeman.org/)
+```foreman_azure_rm``` adds [Microsoft Azure Resource Manager](http://azure.com/) as a compute resource for The Foreman
+
+* Website: [TheForeman.org](http://theforeman.org)
+* Support: [Foreman support](http://theforeman.org/support.html)
 
 ## Features
-* Managed disks support
 * Support for most typical IaaS operations
     * VM creation
-    * Multiple NICs
-    * Multiple data disks, premium or not
+    * Provisions using Finish and User data templates from Foreman
+    * Supports cloud-config provisioning
+    * Currently supports single NIC
+    * Currently supports single default OS Disk
+    * Currently supports only provisioning of Linux platforms
+    * Provisioning using [Public Images](https://docs.microsoft.com/en-us/azure/virtual-machines/linux/cli-ps-findimage)
     * Static or dynamic addresses on a per NIC basis
 * Limited extension support
     * Microsoft's custom script extension
     * Puppet Lab's Puppet agent extension for Windows
+
+## Configuration
+Go to **Infrastructure > Compute Resources** and click on "New Compute Resource".
+
+Choose the **AzureRM provider**, and fill in all the fields. You need a Subscription ID, Tenant ID, Client ID and a Client Secret which you can generate from your [Microsoft Azure subscription](https://docs.bmc.com/docs/cloudlifecyclemanagement/46/setting-up-a-tenant-id-client-id-and-client-secret-for-azure-resource-manager-provisioning-669202145.html#SettingupaTenantID,ClientID,andClientSecretforAzureResourceManagerprovisioning-SetupTenantIDPrereqPrerequisites)
+
+That's it. You're now ready to create and manage Azure resources in your new AzureRM compute resource. You should see something like this in the Compute Resource page:
+
+
+![](https://i.imgur.com/9J7tPJa.png)
+
+
+![](https://i.imgur.com/eFHucdb.png)
+
+
+![](https://i.imgur.com/RTBlMeE.png)
+
     
 ## Planned Features
+* Multiple NICs support
+* Support to add multiple data disks (standard or premium)
+* Provision using custom images
+* Provision using shared image galleries
 * Improved extension support    
     
 ## Known Limitations
-* Most Azure marketplace images (likely all of them) disallow direct root login, which means SSH provisioning 
-with The Foreman has limited functionality. A workaround is to provide a dummy user data template and do all
-post-provisioning with the custom script extension 
+* Unable to provision using Windows Images
+
+## Links
+* [Issue tracker](https://projects.theforeman.org/projects/azurerm)

data/app/controllers/foreman_azure_rm/concerns/hosts_controller_extensions.rb

@@ -5,9 +5,9 @@ module ForemanAzureRM
       def sizes
         if (azure_rm_resource = Image.unscoped.find_by_uuid(params[:image_id])).present?
           resource = azure_rm_resource.compute_resource
-          render :json => resource.vm_sizes(params[:location_string]).map { |size| size.name }
+          render :json => resource.vm_sizes(params[:region_string]).map { |size| size.name }
         else
-          no_sizes = _('The location you selected has no sizes associated with it')
+          no_sizes = _('The region you selected has no sizes associated with it')
           render :json => "[\"#{no_sizes}\"]"
         end
       end
@@ -16,11 +16,11 @@ module ForemanAzureRM
         azure_rm_image = Image.unscoped.find_by_uuid(params[:image_id])
         if azure_rm_image.present?
           azure_rm_resource = azure_rm_image.compute_resource
-          subnets           = azure_rm_resource.subnets(params[:location])
+          subnets           = azure_rm_resource.subnets(params[:region])
           if subnets.present?
-            render :json => azure_rm_resource.subnets(params[:location])
+            render :json => subnets
           else
-            no_subnets = _('The selected location has no subnets')
+            no_subnets = _('The selected region has no subnets')
             render :json => "[\"#{no_subnets}\"]"
           end
         else
@@ -30,4 +30,4 @@ module ForemanAzureRM
       end
     end
   end
-end
+end

data/app/models/concerns/foreman_azure_rm/vm_extensions/managed_vm.rb

@@ -0,0 +1,216 @@
+# This concern has the methods to be called inside azure_rm.rb
+module ForemanAzureRM
+  module VMExtensions
+    module ManagedVM
+      extend ActiveSupport::Concern
+
+      def define_managed_storage_profile(vm_name, vhd_path, publisher, offer, sku, version,
+                                           os_disk_caching, platform, premium_os_disk)
+        storage_profile = ComputeModels::StorageProfile.new
+        os_disk = ComputeModels::OSDisk.new
+        managed_disk_params = ComputeModels::ManagedDiskParameters.new
+
+        # Create OS disk
+        os_disk.name = "#{vm_name}-osdisk"
+        os_disk.os_type = platform
+        os_disk.create_option = ComputeModels::DiskCreateOptionTypes::FromImage
+        os_disk.caching = if os_disk_caching.present?
+                            case os_disk_caching
+                              when 'None'
+                                ComputeModels::CachingTypes::None
+                              when 'ReadOnly'
+                                ComputeModels::CachingTypes::ReadOnly
+                              when 'ReadWrite'
+                                ComputeModels::CachingTypes::ReadWrite
+                              else
+                                # ARM best practices stipulate RW caching on the OS disk
+                                ComputeModels::CachingTypes::ReadWrite
+                            end
+                          end
+        managed_disk_params.storage_account_type = if premium_os_disk == 'true'
+                                                     ComputeModels::StorageAccountTypes::PremiumLRS
+                                                   else
+                                                     ComputeModels::StorageAccountTypes::StandardLRS
+                                                   end
+        os_disk.managed_disk = managed_disk_params
+        storage_profile.os_disk = os_disk
+
+        # Currently eliminating data disk creation since capability does not exist.
+
+        if vhd_path.nil?
+          # We are using a marketplace image
+          storage_profile.image_reference = image_reference(publisher, offer,
+                                                            sku, version)
+        else
+          # We are using a custom managed image
+          image_ref = ComputeModels::ImageReference.new
+          image_ref.id = vhd_path
+          storage_profile.image_reference = image_ref
+        end
+        storage_profile
+      end
+
+      def image_reference(publisher, offer, sku, version)
+        image_reference = ComputeModels::ImageReference.new
+        image_reference.publisher = publisher
+        image_reference.offer = offer
+        image_reference.sku = sku
+        image_reference.version = version
+        image_reference
+      end
+
+      def define_network_profile(network_interface_card_ids)
+        network_interface_cards = []
+        network_interface_card_ids.each_with_index do |id, index|
+          nic = ComputeModels::NetworkInterfaceReference.new
+          nic.id = id
+          nic.primary = true
+          network_interface_cards << nic
+        end
+        network_profile = ComputeModels::NetworkProfile.new
+        network_profile.network_interfaces = network_interface_cards
+        network_profile
+      end
+
+      def create_nics(args = {})
+        nics               = []
+        formatted_region = args[:azure_vm][:location].gsub(/\s+/, '').downcase
+        args[:interfaces_attributes].each do |nic, attrs|
+          attrs[:pubip_alloc]  = attrs[:bridge]
+          attrs[:privip_alloc] = (attrs[:name] == 'false') ? false : true
+          pip_alloc            = case attrs[:pubip_alloc]
+                                   when 'Static'
+                                     NetworkModels::IPAllocationMethod::Static
+                                   when 'Dynamic'
+                                     NetworkModels::IPAllocationMethod::Dynamic
+                                   when 'None'
+                                     nil
+                                 end
+          priv_ip_alloc        = if attrs[:priv_ip_alloc]
+                                   NetworkModels::IPAllocationMethod::Static
+                                 else
+                                   NetworkModels::IPAllocationMethod::Dynamic
+                                 end
+          if pip_alloc.present?
+            public_ip_params = NetworkModels::PublicIPAddress.new.tap do |ip|
+              ip.location = formatted_region
+              ip.public_ipallocation_method = pip_alloc
+            end
+            pip = sdk.create_or_update_pip(args[:azure_vm][:resource_group],
+                                           "#{args[:azure_vm][:vm_name]}-pip#{nic}",
+                                           public_ip_params)
+          end
+          new_nic = sdk.create_or_update_nic(
+            args[:azure_vm][:resource_group],
+            "#{args[:azure_vm][:vm_name]}-nic#{nic}",
+            NetworkModels::NetworkInterface.new.tap do |interface|
+              interface.location = formatted_region
+              interface.ip_configurations = [
+                NetworkModels::NetworkInterfaceIPConfiguration.new.tap do |nic_conf|
+                  nic_conf.name = "#{args[:azure_vm][:vm_name]}-nic#{nic}"
+                  nic_conf.private_ipallocation_method = priv_ip_alloc
+                  nic_conf.subnet = subnets(args[:azure_vm][:location]).select{ |subnet| subnet.id == attrs[:network] }.first
+                  nic_conf.public_ipaddress = pip.present? ? pip : nil
+                end
+              ]
+            end
+          )
+          nics << new_nic
+        end
+        nics
+      end
+
+      def create_managed_virtual_machine(vm_hash)
+        custom_data = vm_hash[:custom_data]
+        msg = "Creating Virtual Machine #{vm_hash[:name]} in Resource Group #{vm_hash[:resource_group]}."
+        logger.debug msg
+        vm_create_params = ComputeModels::VirtualMachine.new.tap do |vm|
+          vm.location = vm_hash[:location]
+          unless vm_hash[:availability_set_id].nil?
+            sub_resource = MsRestAzure::SubResource.new
+            sub_resource.id = vm_hash[:availability_set_id]
+            vm.availability_set = sub_resource
+          end
+          # If image UUID begins with / it is a custom managed image
+          # Otherwise it is a marketplace URN
+          unless vm_hash[:vhd_path].start_with?('/')
+            urn = vm_hash[:vhd_path].split(':')
+            vm_hash[:publisher] = urn[0]
+            vm_hash[:offer]     = urn[1]
+            vm_hash[:sku]       = urn[2]
+            vm_hash[:version]   = urn[3]
+            vm_hash[:vhd_path] = nil
+          end
+
+          vm.os_profile = ComputeModels::OSProfile.new.tap do |os_profile|
+            os_profile.computer_name  = vm_hash[:name]
+            os_profile.admin_username = vm_hash[:username]
+            os_profile.admin_password = vm_hash[:password]
+
+            # Adding the ssh-key support for authentication
+            os_profile.linux_configuration = ComputeModels::LinuxConfiguration.new.tap do |linux|
+              linux.disable_password_authentication = vm_hash[:disable_password_authentication]
+              linux.ssh = ComputeModels::SshConfiguration.new.tap do |ssh_config|
+                ssh_config.public_keys = [
+                  ComputeModels::SshPublicKey.new.tap do |foreman_key|
+                    foreman_key.key_data = key_pair.public
+                    foreman_key.path = "/home/#{vm_hash[:username]}/.ssh/authorized_keys"
+                  end
+                ]
+                if vm_hash[:ssh_key_data].present?
+                  key_data = vm_hash[:ssh_key_data]
+                  pub_key = ComputeModels::SshPublicKey.new
+                  pub_key.key_data = key_data
+                  pub_key.path = "/home/#{vm_hash[:username]}/.ssh/authorized_keys"
+                  ssh_config.public_keys << pub_key
+                end
+              end
+            end
+            # added custom_data here so that azure's vm gets this
+            os_profile.custom_data    = Base64.strict_encode64(custom_data) unless vm_hash[:custom_data].nil?
+          end
+          vm.storage_profile = define_managed_storage_profile(
+                                                                vm_hash[:name],
+                                                                vm_hash[:vhd_path],
+                                                                vm_hash[:publisher],
+                                                                vm_hash[:offer],
+                                                                vm_hash[:sku],
+                                                                vm_hash[:version],
+                                                                vm_hash[:os_disk_caching],
+                                                                vm_hash[:platform],
+                                                                vm_hash[:premium_os_disk],
+                                                              )
+          vm.hardware_profile = ComputeModels::HardwareProfile.new.tap do |hw_profile|
+            hw_profile.vm_size = vm_hash[:vm_size]
+          end
+          vm.network_profile = define_network_profile(vm_hash[:network_interface_card_ids])
+        end
+
+        response = sdk.create_or_update_vm(vm_hash[:resource_group], vm_hash[:name], vm_create_params)
+        logger.debug "Virtual Machine #{vm_hash[:name]} Created Successfully."
+        response
+      end
+
+      def create_vm_extension(args = {})
+        if args[:azure_vm][:script_command].present? || args[:azure_vm][:script_uris].present?
+          extension = ComputeModels::VirtualMachineExtension.new
+          if args[:azure_vm][:platform] == 'Linux'
+            extension.publisher = 'Microsoft.Azure.Extensions'
+            extension.virtual_machine_extension_type = 'CustomScript'
+            extension.type_handler_version = '2.0'
+          end
+          extension.auto_upgrade_minor_version = true
+          extension.location = args[:azure_vm][:location].gsub(/\s+/, '').downcase
+          extension.settings = {
+                'commandToExecute' => args[:azure_vm][:script_command],
+                'fileUris'         => args[:azure_vm][:script_uris].split(',')
+          }
+          sdk.create_or_update_vm_extensions(args[:azure_vm][:resource_group],
+                                             args[:azure_vm][:vm_name],
+                                             'ForemanCustomScript',
+                                             extension)
+        end
+      end
+    end
+  end
+end

data/app/models/foreman_azure_rm/azure_rm.rb

@@ -1,11 +1,25 @@
+# This Model contains code modified as per azure-sdk
+# and removed dependencies from fog-azure-rm.
+# 
+require 'base64'
+
 module ForemanAzureRM
   class AzureRM < ComputeResource
+
+    include VMExtensions::ManagedVM
     alias_attribute :sub_id, :user
     alias_attribute :secret_key, :password
     alias_attribute :app_ident, :url
     alias_attribute :tenant, :uuid
 
-    before_create :test_connection
+    validates :user, :presence => true
+    validates :password, :presence => true
+    validates :url, :presence => true
+    validates :uuid, :presence => true
+
+    has_one :key_pair, :foreign_key => :compute_resource_id, :dependent => :destroy
+
+    before_create :test_connection, :setup_key_pair
 
     class VMContainer
       attr_accessor :virtualmachines
@@ -19,6 +33,10 @@ module ForemanAzureRM
       end
     end
 
+    def sdk
+      @sdk ||= ForemanAzureRM::AzureSDKAdapter.new(tenant, app_ident, secret_key, sub_id)
+    end
+    
     def to_label
       "#{name} (#{provider_friendly_name})"
     end
@@ -35,8 +53,9 @@ module ForemanAzureRM
       [:image]
     end
 
-    def locations
+    def regions
       [
+          'West Europe',
           'Central US',
           'South Central US',
           'North Central US',
@@ -48,34 +67,41 @@ module ForemanAzureRM
       ]
     end
 
-    def resource_groups
-      rgs      = rg_client.list_resource_groups
-      rg_names = []
-      rgs.each do |rg|
-        rg_names << rg.name
-      end
-      rg_names
-    end
-
-    def available_resource_groups
-      rg_client.list_resource_groups
-    end
-
-    def storage_accts(location = nil)
-      stripped_location = location.gsub(/\s+/, '').downcase
+    def storage_accts(region = nil)
+      stripped_region = region.gsub(/\s+/, '').downcase
       acct_names        = []
-      if location.nil?
-        storage_client.list_storage_accounts.each do |acct|
+      if region.nil?
+        sdk.get_storage_accts.each do |acct|
           acct_names << acct.name
         end
       else
-        (storage_client.list_storage_accounts.select { |acct| acct.location == stripped_location }).each do |acct|
+        (sdk.get_storage_accts.select { |acct| acct.region == stripped_region }).each do |acct|
           acct_names << acct.name
         end
       end
       acct_names
     end
 
+    def resource_groups
+      sdk.rgs
+    end
+
+    def test_connection(options = {})
+      sdk.rgs.each do |rg|
+        puts "#{rg}"
+      end
+      super(options)
+    end
+
+    def new_vm(attr = {})
+      AzureRMCompute.new(sdk: sdk)
+    end
+
+    def stop
+      power_off
+      deallocate
+    end
+
     def provided_attributes
       super.merge({ :ip => :provisioning_ip_address })
     end
@@ -98,226 +124,144 @@ module ForemanAzureRM
       subnets
     end
 
-    # TODO Delete this
-    def networks
-      subnets
-    end
-
-    def virtual_networks(location = nil)
-      if location.nil?
-        azure_network_service.virtual_networks
+    def virtual_networks(region = nil)
+      if region.nil?
+        sdk.vnets
       else
-        stripped_location = location.gsub(/\s+/, '').downcase
-        azure_network_service.virtual_networks.select { |vnet| vnet.location == stripped_location }
+        stripped_region = region.gsub(/\s+/, '').downcase
+        sdk.vnets.select { |vnet| vnet.location == stripped_region }
       end
     end
 
-    def subnets(location = nil)
-      vnets   = virtual_networks(location)
+    def subnets(region = nil)
+      stripped_region = region.gsub(/\s+/, '').downcase
+      vnets   = virtual_networks(stripped_region)
       subnets = []
       vnets.each do |vnet|
-        subnets.concat(azure_network_service.subnets(resource_group:       vnet.resource_group,
-                                                     virtual_network_name: vnet.name).all)
+        subnets.concat(sdk.subnets(vnet.resource_group, vnet.name))
       end
       subnets
     end
 
-    def test_connection(options = {})
-      rg_client.resource_groups.each do |rg|
-        puts "#{rg.name}"
-      end
-      super(options)
+    def new_interface(attr = {})
+      # WIP
+      # calls nic_cards method in adapter
+      # causes compute profiles issue
+      # NetworkModels::NetworkInterface.new
     end
 
-    def new_interface(attr = {})
-      azure_network_service.network_interfaces.new(attr)
+    def vm_sizes(region)
+      sdk.list_vm_sizes(region)
     end
 
-    def new_volume(attr = {})
-      client.managed_disks.new(attr)
+    def vm_instance_defaults
+      ActiveSupport::HashWithIndifferentAccess.new
     end
 
     def vms
       container = VMContainer.new
-      rg_client.resource_groups.each do |rg|
-        client.servers(resource_group: rg.name).each do |vm|
-          container.virtualmachines << vm
+      # Load all vms
+      resource_groups.each do |rg|
+        sdk.list_vms(rg).each do |vm|
+          container.virtualmachines << AzureRMCompute.new(azure_vm: vm, sdk:sdk)
         end
       end
       container
     end
 
-    def vm_sizes(location)
-      client.list_available_sizes(location)
+    def setup_key_pair
+      require 'sshkey'
+      name = "foreman-#{id}#{Foreman.uuid}"
+      key  = ::SSHKey.generate
+      build_key_pair :name => name, :secret => key.private_key, :public => key.ssh_public_key
     end
 
     def find_vm_by_uuid(uuid)
-      # TODO: Find a better way to handle this than loading and sorting through
-      # all VMs, which also requires that names be globally unique, instead of
-      # unique within a resource group
       vm = vms.all.find { |vm| vm.name == uuid }
       raise ActiveRecord::RecordNotFound unless vm.present?
       vm
     end
 
-    def create_nics(args = {})
-      nics               = []
-      formatted_location = args[:location].gsub(/\s+/, '').downcase
-      args[:interfaces_attributes].each do |nic, attrs|
-        attrs[:pubip_alloc]  = attrs[:bridge]
-        attrs[:privip_alloc] = (attrs[:name] == 'false') ? false : true
-        pip_alloc            = case attrs[:pubip_alloc]
-                                 when 'Static'
-                                   Fog::ARM::Network::Models::IPAllocationMethod::Static
-                                 when 'Dynamic'
-                                   Fog::ARM::Network::Models::IPAllocationMethod::Dynamic
-                                 when 'None'
-                                   nil
-                               end
-        priv_ip_alloc        = if attrs[:priv_ip_alloc]
-                                 Fog::ARM::Network::Models::IPAllocationMethod::Static
-                               else
-                                 Fog::ARM::Network::Models::IPAllocationMethod::Dynamic
-                               end
-        if pip_alloc.present?
-          pip = azure_network_service.public_ips.create(
-              name:                        "#{args[:vm_name]}-pip#{nic}",
-              resource_group:              args[:resource_group],
-              location:                    formatted_location,
-              public_ip_allocation_method: pip_alloc
-          )
-        end
-        new_nic = azure_network_service.network_interfaces.create(
-            name:                         "#{args[:vm_name]}-nic#{nic}",
-            resource_group:               args[:resource_group],
-            location:                     formatted_location,
-            subnet_id:                    attrs[:network],
-            public_ip_address_id:         pip.present? ? pip.id : nil,
-            ip_configuration_name:        'ForemanIPConfiguration',
-            private_ip_allocation_method: priv_ip_alloc
-        )
-        nics << new_nic
-      end
-      nics
+    # user data support
+    def user_data_supported?
+      true
     end
 
-    # Preferred behavior is to utilize Fog but Fog Azure RM
-    # does not currently support creating managed VMs
     def create_vm(args = {})
-      args[:vm_name] = args[:name].split('.')[0]
-      nics           = create_nics(args)
-      if args[:ssh_key_data].present?
+      args[:azure_vm][:vm_name] = args[:name].split('.')[0]
+      nics = create_nics(args)
+      if args[:azure_vm][:password].present? && !args[:azure_vm][:ssh_key_data].present?
+        sudoers_cmd = "$echo #{args[:azure_vm][:password]} | sudo -S echo '\"#{args[:azure_vm][:username]}\" ALL=(ALL) NOPASSWD: ALL' > /etc/sudoers.d/waagent"
+        if args[:azure_vm][:script_command].present?
+          # to run the script_cmd given through form
+          # as username
+          args[:azure_vm][:script_command] =  sudoers_cmd + " ; su - \"#{args[:azure_vm][:username]}\" -c \"#{args[:azure_vm][:script_command]}\""
+        else
+          args[:azure_vm][:script_command] =  sudoers_cmd
+        end
+        disable_password_auth = false
+      elsif args[:azure_vm][:ssh_key_data].present? && !args[:azure_vm][:password].present?
         disable_password_auth = true
-        ssh_key_path          = "/home/#{args[:username]}/.ssh/authorized_keys"
       else
         disable_password_auth = false
-        ssh_key_path          = nil
       end
-      vm                       = client.create_managed_virtual_machine(
-          name:                            args[:vm_name],
-          location:                        args[:location],
-          resource_group:                  args[:resource_group],
-          vm_size:                         args[:vm_size],
-          username:                        args[:username],
-          password:                        args[:password],
-          ssh_key_data:                    args[:ssh_key_data],
-          ssh_key_path:                    ssh_key_path,
-          disable_password_authentication: disable_password_auth,
-          network_interface_card_ids:      nics.map(&:id),
-          platform:                        args[:platform],
-          vhd_path:                        args[:image_id],
-          os_disk_caching:                 args[:os_disk_caching],
-          data_disks:                      args[:volumes_attributes],
-          os_disk_size:                    args[:os_disk_size],
-          premium_os_disk:                 args[:premium_os_disk],
+      vm             = create_managed_virtual_machine(
+        name:                            args[:azure_vm][:vm_name],
+        location:                        args[:azure_vm][:location],
+        resource_group:                  args[:azure_vm][:resource_group],
+        vm_size:                         args[:azure_vm][:vm_size],
+        username:                        args[:azure_vm][:username],
+        password:                        args[:azure_vm][:password],
+        ssh_key_data:                    args[:azure_vm][:ssh_key_data],
+        disable_password_authentication: disable_password_auth,
+        network_interface_card_ids:      nics.map(&:id),
+        platform:                        args[:azure_vm][:platform],
+        vhd_path:                        args[:image_id],
+        os_disk_caching:                 args[:azure_vm][:os_disk_caching],
+        premium_os_disk:                 args[:azure_vm][:premium_os_disk],
+        custom_data:                     args[:user_data],
+        script_command:                  args[:azure_vm][:script_command],
+        script_uris:                     args[:azure_vm][:script_uris],
       )
-      vm_hash                  = Fog::Compute::AzureRM::Server.parse(vm)
-      vm_hash[:password]       = args[:password]
-      vm_hash[:platform]       = args[:platform]
-      vm_hash[:puppet_master]  = args[:puppet_master]
-      vm_hash[:script_command] = args[:script_command]
-      vm_hash[:script_uris]    = args[:script_uris]
-      client.create_vm_extension(vm_hash)
-      client.servers.new vm_hash
-        # fog-azure-rm raises all ARM errors as RuntimeError
-    rescue Fog::Errors::Error, RuntimeError => e
+      create_vm_extension(args)
+      # return the vm object using azure_vm
+      return_vm = AzureRMCompute.new(azure_vm: vm, sdk: sdk)
+    rescue RuntimeError => e
       Foreman::Logging.exception('Unhandled Azure RM error', e)
       destroy_vm vm.id if vm
       raise e
     end
 
     def destroy_vm(uuid)
+      #vm.azure_vm because that's the azure object and vm is the wrapper
       vm           = find_vm_by_uuid(uuid)
-      raw_model    = client.get_virtual_machine(vm.resource_group, vm.name)
-      os_disk_name = raw_model.storage_profile.os_disk.name
-      data_disks   = raw_model.storage_profile.data_disks
+      vm_name      = vm.name
+      rg_name      = vm.azure_vm.resource_group
+      os_disk      = vm.azure_vm.storage_profile.os_disk
+      data_disks   = vm.azure_vm.storage_profile.data_disks
       nic_ids      = vm.network_interface_card_ids
-      # In ARM things must be deleted in order
-      vm.destroy
-      nic_ids.each do |id|
-        nic   = azure_network_service.network_interfaces.get(id.split('/')[4],
-                                                             id.split('/')[-1])
-        ip_id = nic.public_ip_address_id
-        nic.destroy
-        if ip_id.present?
-          azure_network_service.public_ips.get(ip_id.split('/')[4],
-                                               ip_id.split('/')[-1]).destroy
+
+      sdk.delete_vm(rg_name, vm_name)
+
+      nic_ids.each do |nic_id|
+        nic = sdk.vm_nic(rg_name, nic_id.split('/')[-1])
+        if nic.present?
+          public_ip = nic.ip_configurations.first.public_ipaddress
+          sdk.delete_nic(rg_name, nic_id.split('/')[-1])
+          if public_ip.present?
+            ip_id = public_ip.id
+            sdk.delete_pip(rg_name, ip_id.split('/')[-1])
+          end
         end
       end
-      client.managed_disks.get(vm.resource_group, os_disk_name).destroy
-      data_disks.each do |disk|
-        client.managed_disks.get(vm.resource_group, disk.name).destroy
+      if os_disk.present?
+        sdk.delete_disk(rg_name, os_disk.name)
       end
 
+      true
     rescue ActiveRecord::RecordNotFound
-      # If the VM does not exist, we don't really care.
+      logger.info "Could not find the selected vm."
       true
     end
-
-    protected
-
-    def client
-      @client ||= Fog::Compute.new(
-          :provider        => 'AzureRM',
-          :tenant_id       => tenant,
-          :client_id       => app_ident,
-          :client_secret   => secret_key,
-          :subscription_id => sub_id,
-          :environment     => 'AzureCloud'
-      )
-    end
-
-    def rg_client
-      # noinspection RubyArgCount
-      @rg_client ||= Fog::Resources::AzureRM.new(
-          tenant_id:       tenant,
-          client_id:       app_ident,
-          client_secret:   secret_key,
-          subscription_id: sub_id,
-          :environment     => 'AzureCloud'
-      )
-    end
-
-    def storage_client
-      @storage_client ||= Fog::Storage.new(
-          :provider        => 'AzureRM',
-          :tenant_id       => tenant,
-          :client_id       => app_ident,
-          :client_secret   => secret_key,
-          :subscription_id => sub_id,
-          :environment     => 'AzureCloud'
-      )
-    end
-
-    def azure_network_service
-      # noinspection RubyArgCount
-      @azure_network_service ||= Fog::Network::AzureRM.new(
-          :tenant_id       => tenant,
-          :client_id       => app_ident,
-          :client_secret   => secret_key,
-          :subscription_id => sub_id,
-          :environment     => 'AzureCloud'
-      )
-    end
   end
-end
+end