foreman_azure_rm 2.0.6 → 2.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 910b1dd793ab445a40152db2f4613550f39d846cb53603da5a1b80cbd785f832
-  data.tar.gz: ed13a2dd55819f1c12f6c572173108b300c6ac456ec9d788507b68cf171c0260
+  metadata.gz: 04afcc03f8710a4e02d4f540342ff9e1ec9188fc8c83734065eecc6956327341
+  data.tar.gz: 20b3d6cbfd6346270fb9fe335ae0ebde9181751ffd61b6c4bb98868cacf82ab4
 SHA512:
-  metadata.gz: 8876efb62862f4d57684d620a91ee740459187e3e7b64cf35da8d12473fde4189902a8a88ec0bb6aca6c6f3785b79cb1973b12a2d2cf00f7b5ff15aa27a0a7c0
-  data.tar.gz: 79b0e983f67fe039698c1ecb7ae2699435049d26aec02ed2389299492113c26e197e4366aac740bafd5e4b9251a18a7e3912fd65daf43628186c54cf83c78a26
+  metadata.gz: c6dc0580218a0bb8e37c734a669931d1fd6c02d37170b77d50a11afdaaee0c7675ee0cb3897eb8c05aa7e8d58af519a8e1b3e09521b6e1344a78cda1f5e3f456
+  data.tar.gz: 2aea8c30cc2c29bea406c17471bffbf029311616137e964564e236d1b8caee737f8afc644c5b6e52969f4a0eaff59d420bf4a0de7159229b424475e5797da6ba

data/README.md

@@ -4,6 +4,7 @@
 ```foreman_azure_rm``` adds [Microsoft Azure Resource Manager](http://azure.com/) as a compute resource for The Foreman
 
 * Website: [TheForeman.org](http://theforeman.org)
+* ForemanAzureRm: [Plugin manual](https://theforeman.org/plugins/foreman_azure)
 * Support: [Foreman support](http://theforeman.org/support.html)
 
 ## Installation
@@ -12,25 +13,25 @@
 
 Add the following to bundler.d/Gemfile.local.rb in your Foreman installation directory (/usr/share/foreman by default)
 
-```bash
+```console
 $ gem 'foreman_azure_rm'
 ```
 
 Or simply:
 
-```bash
+```console
 $ echo "gem 'foreman_azure_rm'" > /usr/share/foreman/bundler.d/Gemfile.local.rb
 ```
 
 Then run `bundle install` from the same directory
 
 ### Package
-```
+```console
 # yum install tfm-rubygem-foreman_azure_rm
 ```
 
 ### Foreman Installer
-```
+```console
 # foreman-installer --enable-foreman-plugin-azure
 ```
 
@@ -44,7 +45,7 @@ git clone https://github.com/theforeman/foreman_azure_rm.git
 Add the following to bundler.d/Gemfile.local.rb in your Foreman development directory
 
 ```ruby
-$ gem 'foreman_azure_rm', :path => 'path to foreman_azure_rm directory'
+gem 'foreman_azure_rm', :path => 'path to foreman_azure_rm directory'
 ```
 
 Then run `bundle install` from the same directory
@@ -54,10 +55,14 @@ Then run `bundle install` from the same directory
     * VM creation
     * 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)
+    * Provision using custom images
+    * Provision using shared image galleries
+    * Provision using RHEL byos images
+    * Multiple NICs support
+    * Support to add multiple data disks/volumes (standard or premium)
+    * VM Extension with Custom Script and File URIs support
     * Static or dynamic addresses on a per NIC basis
 * Limited extension support
     * Microsoft's custom script extension
@@ -71,21 +76,18 @@ Choose the **Azure Resource Manager provider**, and fill in all the fields. You
 That's it. You're now ready to create and manage Azure resources in your new Azure Resource Manager compute resource. You should see something like this in the Compute Resource page:
 
 
-![](https://i.imgur.com/4ClZhTP.png)
+![](https://i.imgur.com/vsamP4G.png)
 
 
-![](https://i.imgur.com/eFHucdb.png)
+![](https://i.imgur.com/Ag9tH55.png)
 
 
-![](https://i.imgur.com/YjlRQIE.png)
+![](https://i.imgur.com/fNjlFci.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    
+* Azure Gov Cloud Support
+* Support for http_proxy
     
 ## Known Limitations
 * Please note that currently username is expected to be the same on both Virtual Machine tab for Host creation and during Image creation for Compute Resource. The password field for Image creation is optional.

data/app/helpers/azure_compute_resource_helper.rb

@@ -0,0 +1,13 @@
+module AzureComputeResourceHelper
+  def regions_list(azurerm_cr, f)
+    begin
+      regions = azurerm_cr.regions || []
+    rescue StandardError
+      #do nothing
+      regions = []
+    rescue Exception => ex
+      return information_box("Regions could not be loaded due to exception: #{ex}")
+    end
+    selectable_f(f, :url, regions, {}, {:label => _('Azure Region'), :disabled => regions.empty?, :required => true, :help_inline_permanent => load_button_f(f, regions.present?, _("Load Regions")) })
+  end
+end

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

@@ -13,19 +13,7 @@ module ForemanAzureRm
         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
-                            end
-                          else
-                            # ARM best practices stipulate RW caching on the OS disk
-                            ComputeModels::CachingTypes::ReadWrite
-                          end
+        os_disk.caching = disk_caching(os_disk_caching)
         managed_disk_params.storage_account_type = if premium_os_disk == 'true'
                                                      ComputeModels::StorageAccountTypes::PremiumLRS
                                                    else
@@ -33,10 +21,59 @@ module ForemanAzureRm
                                                    end
         os_disk.managed_disk = managed_disk_params
         storage_profile.os_disk = os_disk
-
         storage_profile
       end
 
+      def disk_caching(disk_type_caching)
+        case disk_type_caching
+        when 'None'
+          ComputeModels::CachingTypes::None
+        when 'ReadOnly'
+          ComputeModels::CachingTypes::ReadOnly
+        when 'ReadWrite'
+          ComputeModels::CachingTypes::ReadWrite
+        when nil, ""
+          nil
+        else
+          raise RuntimeError, "Disk caching value must be either 'None', 'ReadOnly' or 'ReadWrite'."
+        end
+      end
+
+      def define_data_disks(vm_name, data_disks)
+        unless data_disks.nil?
+          disks = []
+          disk_count = 0
+          data_disks.each do |disk_num, attrs|
+            managed_data_disk = ComputeModels::ManagedDiskParameters.new
+            disk = ComputeModels::DataDisk.new
+            disk.name = "#{vm_name}-data-disk#{disk_count}"
+            disk.caching  = disk_caching(attrs[:data_disk_caching])
+            disk.disk_size_gb = attrs[:disk_size_gb]
+            disk.create_option = ComputeModels::DiskCreateOption::Empty
+            disk.lun = disk_count + 1
+            disk.managed_disk = managed_data_disk
+            disk_count += 1
+            disks << disk
+          end
+          disks
+        end
+      end
+
+      def marketplace_image_plan(image)
+        image_type, image_id = image.split('://')
+        return nil unless image_type == 'marketplace' && image_id.include?('byos')
+        urn = image_id.split(':')
+        publisher = urn[0]
+        offer     = urn[1]
+        sku       = urn[2]
+        version   = urn[3]
+        image_plan = ComputeModels::PurchasePlan.new
+        image_plan.publisher = publisher.downcase
+        image_plan.name = sku.downcase
+        image_plan.product = offer.downcase
+        image_plan
+      end
+
       def marketplace_image_reference(publisher, offer, sku, version)
         image_reference = ComputeModels::ImageReference.new
         image_reference.publisher = publisher
@@ -46,26 +83,25 @@ module ForemanAzureRm
         image_reference
       end
 
-      def define_image(image_id)
-        # If image UUID begins with / it is a custom managed image
-        # Otherwise it is a marketplace URN
-        unless image_id.start_with?('/')
+      def define_image(rg_name, image)
+        image_type, image_id = image.split('://')
+        case image_type
+        when 'marketplace'
           urn = image_id.split(':')
           publisher = urn[0]
           offer     = urn[1]
           sku       = urn[2]
           version   = urn[3]
-          image_id = nil
-        end
-
-        if image_id.nil?
-          # For marketplace image
           image_reference = marketplace_image_reference(publisher, offer, sku, version)
+        when 'custom'
+          custom_image = sdk.get_custom_image(rg_name, image_id)
+          image_reference = ComputeModels::ImageReference.new
+          image_reference.id = custom_image.id
+        when 'gallery'
+          image_reference = ComputeModels::ImageReference.new
+          image_reference.id = sdk.fetch_gallery_image_id(rg_name, image_id)
         else
-          # For custom managed image
-          image_ref = ComputeModels::ImageReference.new
-          image_ref.id = image_id
-          image_reference = image_ref
+          image_reference = nil
         end
         image_reference
       end
@@ -188,8 +224,10 @@ module ForemanAzureRm
 
       def create_managed_virtual_machine(vm_hash)
         vm_params = initialize_vm(vm_hash)
+        vm_params.plan = marketplace_image_plan(vm_hash[:image_id])
         vm_params.network_profile = define_network_profile(vm_hash[:network_interface_card_ids])
-        vm_params.storage_profile.image_reference = define_image(vm_hash[:image_id])
+        vm_params.storage_profile.image_reference = define_image(vm_hash[:resource_group], vm_hash[:image_id])
+        vm_params.storage_profile.data_disks = define_data_disks(vm_hash[:name], vm_hash[:data_disks])
         sdk.create_or_update_vm(vm_hash[:resource_group], vm_hash[:name], vm_params)
       end
 

data/app/models/foreman_azure_rm/azure_rm.rb

@@ -12,12 +12,14 @@ module ForemanAzureRm
     alias_attribute :region, :url
     alias_attribute :tenant, :uuid
 
-    validates :user, :password, :url, :uuid, :app_ident, :presence => true
+    validates :user, :password, :uuid, :app_ident, :presence => true
 
     has_one :key_pair, :foreign_key => :compute_resource_id, :dependent => :destroy
 
     before_create :test_connection, :setup_key_pair
 
+    validate :ensure_attributes_and_values
+
     class VMContainer
       attr_accessor :virtualmachines
       delegate :each, to: :virtualmachines
@@ -47,6 +49,15 @@ module ForemanAzureRm
       "#{name} (#{provider_friendly_name})"
     end
 
+    def ensure_attributes_and_values
+      validate_region
+    end
+
+    def validate_region
+      return unless regions.present?
+      errors.add(:region, "is not valid, must be lowercase eg. 'eastus'. No special characters allowed.") unless regions.collect(&:second).include?(region)
+    end
+
     def self.model_name
       ComputeResource.model_name
     end
@@ -56,44 +67,35 @@ module ForemanAzureRm
     end
 
     def capabilities
-      [:image]
+      [:image, :new_volume]
     end
 
-    def self.regions
-      [
-          ['West Europe', 'westeurope'],
-          ['Central US', 'centralus'],
-          ['South Central US', 'southcentralus'],
-          ['North Central US', 'northcentralus'],
-          ['West Central US', 'westcentralus'],
-          ['East US', 'eastus'],
-          ['East US 2', 'eastus2'],
-          ['West US', 'westus'],
-          ['West US 2', 'westus2']
-      ]
+    def regions
+      return unless sub_id.present?
+      sdk.list_regions(sub_id).value.map { |loc| [loc.display_name, loc.name] }
     end
 
-    validates :region, inclusion: { in: regions.collect(&:second),
-    message: "%{value} must be lowercase eg. 'eastus'. No special characters allowed." }
-
     def resource_groups
       sdk.rgs
     end
 
     def test_connection(options = {})
-      sdk.rgs.each do |rg|
-        puts "#{rg}"
-      end
-      super(options)
+      super
+      errors[:user].empty? && errors[:password].empty? && errors[:uuid].empty? && errors[:app_ident].empty? && regions
+    rescue StandardError => e
+      errors[:base] << e.message
+    rescue Excon::Error::Socket => e
+      errors[:base] << e.message
     end
 
     def new_vm(args = {})
       return AzureRmCompute.new(sdk: sdk) if args.empty?
       opts = vm_instance_defaults.merge(args.to_h).deep_symbolize_keys
       # convert rails nested_attributes into a plain hash
-      nested_args = opts.delete(:interfaces_attributes)
-      opts[:interfaces] = nested_attributes_for(:interfaces, nested_args) if nested_args
-
+      [:interfaces, :volumes].each do |collection|
+        nested_args = opts.delete("#{collection}_attributes".to_sym)
+        opts[collection] = nested_attributes_for(collection, nested_args) if nested_args
+      end
       opts.reject! { |k, v| v.nil? }
 
       raw_vm = initialize_vm(location:        region,
@@ -112,13 +114,54 @@ module ForemanAzureRm
           ifaces << new_interface(iface_attrs)
         end
       end
-      AzureRmCompute.new(azure_vm: raw_vm ,sdk: sdk, resource_group: opts[:resource_group], nics: ifaces, script_command: opts[:script_command], script_uris: opts[:script_uris])
+
+      vols = opts.fetch(:volumes, []).map { |vols_attrs| new_volume(vols_attrs) } if opts[:volumes].present?
+
+      AzureRmCompute.new(azure_vm: raw_vm ,sdk: sdk, resource_group: opts[:resource_group], nics: ifaces, volumes: vols, script_command: opts[:script_command], script_uris: opts[:script_uris])
     end
 
     def provided_attributes
       super.merge({ :ip => :provisioning_ip_address })
     end
 
+    def image_exists?(image)
+      image_type, image_id = image.split('://')
+      case image_type
+      when 'marketplace'
+        begin
+          urn = image_id.split(':')
+          publisher = urn[0]
+          offer     = urn[1]
+          sku       = urn[2]
+          version   = urn[3]
+          if version == "latest"
+            all_versions = sdk.list_versions(region, publisher, offer, sku).map(&:name)
+            return true if all_versions.any?
+          end
+          sdk.get_marketplace_image(region, publisher, offer, sku, version).present?
+        rescue StandardError => e
+          return false
+        end
+      when 'gallery'
+        gallery_images_list = sdk.list_resources(filter: "resourceType eq 'Microsoft.Compute/galleries/images'")
+        gallery_image = gallery_images_list.detect { |gal_img| gal_img.id.split('/')[-1] == image_id }
+        if gallery_image.present?
+          rg_name = gallery_image.id.split('/')[4]
+          gallery_name = gallery_image.name.split('/')[0]
+          image_versions = sdk.list_gallery_image_versions(rg_name, gallery_name, image_id)
+          target_regions = image_versions.map do |image_version|
+            image_version.publishing_profile.target_regions.map(&:name)
+          end.flatten.uniq.map { |tgt_reg| tgt_reg.gsub(/\s+/, '').downcase }
+          return true if target_regions.include? region
+        end
+      when 'custom'
+        custom_image = sdk.list_custom_images.detect { |custom_img| custom_img.name == image_id && custom_img.location == region }
+        return custom_image.present?
+      else
+        false
+      end
+    end
+
     def available_vnets(attr = {})
       virtual_networks
     end
@@ -151,6 +194,11 @@ module ForemanAzureRm
       true
     end
 
+    def new_volume(attrs = {})
+      args = { :disk_size_gb => 0, :data_disk_caching => "", 'persisted?' => false }.merge(attrs.to_h)
+      OpenStruct.new(args)
+    end
+
     def vm_sizes
       sdk.list_vm_sizes(region)
     end
@@ -161,7 +209,8 @@ module ForemanAzureRm
 
     def vm_instance_defaults
       super.deep_merge(
-        interfaces: [new_interface]
+        interfaces: [new_interface],
+        volumes: [new_volume]
       )
     end
 
@@ -175,6 +224,10 @@ module ForemanAzureRm
       ifaces
     end
 
+    def vm_disks(vm)
+      vm.storage_profile.data_disks
+    end
+
     def vms(attrs = {})
       container = VMContainer.new
       # Load all vms of the region
@@ -239,6 +292,7 @@ module ForemanAzureRm
         image_id:                        args[:image_id],
         os_disk_caching:                 args[:os_disk_caching],
         premium_os_disk:                 args[:premium_os_disk],
+        data_disks:                      args[:volumes_attributes],
         custom_data:                     args[:user_data],
         script_command:                  args[:script_command],
         script_uris:                     args[:script_uris],
@@ -246,7 +300,7 @@ module ForemanAzureRm
       logger.debug "Virtual Machine #{args[:vm_name]} Created Successfully."
       create_vm_extension(region, args)
       # return the vm object using azure_vm
-      AzureRmCompute.new(azure_vm: vm, sdk: sdk, resource_group: args[:resource_group], nics: vm_nics(vm), script_command: user_command, script_uris: args[:script_uris])
+      AzureRmCompute.new(azure_vm: vm, sdk: sdk, resource_group: args[:resource_group], nics: vm_nics(vm), volumes: vm_disks(vm), script_command: user_command, script_uris: args[:script_uris])
     rescue RuntimeError => e
       Foreman::Logging.exception('Unhandled AzureRm error', e)
       destroy_vm vm.id if vm
@@ -273,10 +327,8 @@ module ForemanAzureRm
           end
         end
       end
-      if os_disk.present?
-        sdk.delete_disk(rg_name, os_disk.name)
-      end
-
+      sdk.delete_disk(rg_name, os_disk.name) if os_disk.present?
+      data_disks.each { |data_disk| sdk.delete_disk(rg_name, data_disk.name) } if data_disks.present?
       true
     rescue ActiveRecord::RecordNotFound
       logger.info "Could not find the selected vm."