$ bundle exec rails c
>> ManageIQ::Providers::AwesomeCloud
=> ManageIQ::Providers::AwesomeCloud
>> ManageIQ::Providers::AwesomeCloud::CloudManager
=> ManageIQ::Providers::AwesomeCloud::CloudManager (call 'ManageIQ::Providers::AwesomeCloud::CloudManager.connection' to establish a connection)

>> ems = ManageIQ::Providers::AwesomeCloud::CloudManager.create!(:name => "My Awesome Cloud", :zone => Zone.default_zone)

>> ems = ManageIQ::Providers::AwesomeCloud::CloudManager.first
>> ems.update!(:provider_region => "us-east-1")
>> ems.update_authentication(:default => {:userid => "MY-ACCESS-KEY", :password => "MY-SECRET-KEY"})

class ManageIQ::Providers::AwesomeCloud::CloudManager < ManageIQ::Providers::CloudManager
  def self.raw_connect(region, access_key, secret_key, service = "Compute")
    require "awesome_cloud"

    AwesomeCloud::Client.new(:access_key => access_key, :secret_key => secret_key, :region => region, :service => service)
  end

  def self.verify_credentials(args)
    # NOTE this args hash has a very specific format that we'll get to next
    region = args["provider_region"]
    default_endpoint = args.dig("authentications", "default")
    access_key, secret_key = default_endpoint&.values_at("userid", "password")

    validate_connection(raw_connect(region, access_key, secret_key))
  end

  # NOTE: You want to use the same method for validating credentials at the
  # class-level and instance-level.  This prevents any potential issues were
  # adding a new provider (class-level) might pass verification but after adding
  # it (instance-lavel) it fails.
  def self.validate_connection(connection)
    # Perform a simple and fast operation that verifies the credentials are correct
    !!connection.list_regions
  end

  def connect(type: "default", service: "Compute")
    access_key, secret_key = auth_user_pwd(type)
    self.class.raw_connect(provider_region, access_key, secret_key, service)
  end

  def verify_credentials(type = "default", options = {})
    with_provider_connection(:type => type) do |connection|
      self.class.validate_connection(connection)
    rescue AwesomeCloud::Error => err
      raise MiqException::MiqInvalidCredentialsError, "Invalid credentials: #{err}"
    end
  end
end

>> ems = ManageIQ::Providers::AwesomeCloud::CloudManager.first
>> ems.authentication_check
=> [true, ""]
>> ems.connect(:service => "Compute").list_regions

class ManageIQ::Providers::AwesomeCloud::CloudManager < ManageIQ::Providers::CloudManager
  supports :create
  supports :regions

  def self.params_for_create
    {
      :fields => [
        {
          :component    => "select",
          :id           => "provider_region",
          :name         => "provider_region",
          :label        => _("Region"),
          :isRequired   => true,
          :validate     => [{:type => "required"}],
          :includeEmpty => true,
          :options      => provider_region_options
        },
        {
          :component => 'sub-form',
          :name      => 'endpoints-subform',
          :id        => 'endpoints-subform',
          :title     => _("Endpoints"),
          :fields    => [
            {
              :component              => 'validate-provider-credentials',
              :id                     => 'authentications.default.valid',
              :name                   => 'authentications.default.valid',
              :skipSubmit             => true,
              :isRequired             => true,
              :validationDependencies => %w[type zone_id provider_region uid_ems],
              :fields                 => [
                {
                  :component  => "text-field",
                  :id         => "authentications.default.userid",
                  :name       => "authentications.default.userid",
                  :label      => _("Access Key"),
                  :isRequired => true,
                  :validate   => [{:type => "required"}]
                },
                {
                  :component      => "password-field",
                  :rows           => 10,
                  :id             => "authentications.default.password",
                  :name           => "authentications.default.password",
                  :label          => _("Secret Key"),
                  :type           => "password",
                  :isRequired     => true,
                  :validate       => [{:type => "required"}]
                },
              ]
            }
          ]
        }
      ]
    }
  end

  private_class_method def self.provider_region_options
    ManageIQ::Providers::AwesomeCloud::Regions.all.map { |region| {:label => region[:name], :value => region[:name]} }
  end

  validates :provider_region, :inclusion => {:in => ManageIQ::Providers::AwesomeCloud::Regions.names}

module ManageIQ
  module Providers::AwesomeCloud
    class Regions < ManageIQ::Providers::Regions
    end
  end
end

class ManageIQ::Providers::AwesomeCloud::Inventory::Persister < ManageIQ::Providers::Inventory::Persister
  # This should already be here from the generator, you just need one empty subclass
  # for each child-manager type that your provider has (e.g. NetworkManager and/or StorageManager).
  require_nested :CloudManager

  # Add the list of inventory collections that you want to use here
  # In the future if you want to add more inventory like disks or networks you would
  # add them to the list here.
  def initialize_inventory_collections
    add_cloud_collection(:flavors)
    add_cloud_collection(:miq_templates)
    add_cloud_collection(:vms)
  end
end

class ManageIQ::Providers::AwesomeCloud::Inventory::Collector < ManageIQ::Providers::Inventory::Collector
  require_nested :CloudManager

  def images
    compute_client.get_images
  end

  def instances
    compute_client.get_instances
  end

  def instance_types
    compute_client.get_instance_types
  end

  private

  def compute_client
    @compute_client ||= manager.connect(:service => "Compute")
  end
end

class ManageIQ::Providers::AwesomeCloud::Inventory::Parser < ManageIQ::Providers::Inventory::Parser
  require_nested :CloudManager

  def parse
    instance_types
    images
    instances
  end

  def instance_types
    # Calling collector.instance_types here is what actually issues the API call.
    collector.instance_types.each do |instance_type|
      # At this point "instance_type" will be whatever is returned by your SDK.
      # It could be a hash or it could be an object like `AwesomeCloud::Compute::InstanceType`

      # persister.flavors.build will create an InventoryObject (fancy hash) with all of the
      # attributes that you pass in here, and automatically add it to the `persister.flavors`
      # inventory collection
      persister.flavors.build(
        # MIQ uses "ems_ref" as the unique reference for an inventory item
        # in a provider.  Whatever you use must be guaranteed to not have a duplicate
        # in the same provider instance as this value is also used to lookup related
        # inventory from other collections.
        :ems_ref => instance_type.id,
        :name    => instance_type.name,
        :cpus    => instance_type.n_cpus,
        :memory  => instance_type.ram
      )
    end
  end

  def images
    collector.images.each do |image|
      persister.miq_templates.build(
        :ems_ref         => image.id,
        # The uid_ems field if you see it typically indicates a field that can be used
        # to identify an inventory item across provider instances.  Most of the time
        # for cloud providers this is the same as the ems_ref but not always.
        # If your ems_ref looks like an integer ID then it probably isn't unique.
        # If it looks like a UUID then it probably is.
        :uid_ems         => image.id,
        :name            => image.name,
        :location        => "unknown",
        :raw_power_state => "never",
        :template        => true,
        :vendor          => "awesome_cloud"
      )
    end
  end

  def instances
    collector.instances.each do |instance|
      persister_vm = persister.vms.build(
        :ems_ref         => instance.id,
        :uid_ems         => instance.id,
        :name            => instance.name,
        :location        => instance.availability_zone,
        :raw_power_state => instance.power_state,
        :vendor          => "awesome_cloud",
        # This is where things get interesting.  A "Lazy Reference" is our way of
        # declaring a relationship to another table.  The result of this lazy_find
        # after save_inventory has completed will be a foreign-key to that table
        #
        # It is critically important that you use this instead of either:
        # 1. Direct database query like: Flavor.find_by(:ems_ref => instance.flavor)
        #   because this won't work with flavors that are being created in this refresh
        # 2. Using data set in the parser like: persitser.flavors.data.detect { |f| f[:ems_ref] == instance.flavor }
        #   because this introduces an ordered dependency (flavors have to be parsed
        #   before instances) and it is possible to introduce a dependency cycle and
        #   also makes future targeted refresh much harder (where the flavors might not be
        #   present in the collected data).
        :flavor          => persister.flavors.lazy_find(instance.flavor)
      )
    end
  end
end

>> ems = ManageIQ::Providers::AwesomeCloud::CloudManager.first
>> ems.refresh
# Lots of queries
>> ems.vms.count
=> 1
>> ems.vms.first
=> #<ManageIQ::Providers::AwesomeCloud::CloudManager::Vm id: 131, vendor: "awesome_cloud", format: nil, version: nil, name: "my-first-vm", description: nil, location: "5ae243b0-a45f-4043-b59b-ddbcfd98896a",...
>> ems.vms.first.flavor.ems_ref
=> "579405c1-8867-4e78-94fd-72ff575e8d0a"