foreman_google 0.0.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cfa941ac3f2b5a130802d66a7bf5966b42facf344f5020d63ebd3371e79c403f
-  data.tar.gz: b6d0a39fb9d62e91532a2bfdc157cf79d4ca785826804889055125540d963b04
+  metadata.gz: ea94c8410bd480a5d037871dfdbcc479c4a6b241ae0c02ab47f506f4b52215e4
+  data.tar.gz: a0f2fc8d3b5eac53bde9bbf0cf263feccc2e15e142ba5a0acb27383ad8b77872
 SHA512:
-  metadata.gz: 4d7a4a449407e4af774f68722b53310c00712a9240c52e1f9e81bad216cbe9989b28e4bdd93d52c93dd52afdce7bf956cbcd5c221ef5f73c65aeeb57d4fd5ea9
-  data.tar.gz: '008c0c232479d20066e04f6a4066d418120f93c97c26aaaad33a274581f8ecbdeed2acc568f5ae04c211314fb33ab04de58ab6767d6935789d7e1ff311a781ab'
+  metadata.gz: 1bbfeec72844bb5dbb055c912552c5929e0ac758d09ff53065d24b29ae2bfc3ae830724fcf79fc9a9f3d1302041dd315775935ca739e4b8caf5916233846cd62
+  data.tar.gz: 885348d92eb06c1cc78c14d98b9826e6591683dd1ae561c42ad8d91ec2d1859db6d2b4b4509d908b16d63e8eca0f6eacf861908b764fcb40d9caa396e89cb69a

data/README.md

@@ -3,13 +3,25 @@
 Foreman plugin for Google Compute Engine.
 
 ## Installation
-
-See [How_to_Install_a_Plugin](http://projects.theforeman.org/projects/foreman/wiki/How_to_Install_a_Plugin)
+```shell
+foreman-installer --enable-foreman-plugin-google
+```
+Or see [Plugins documentation](https://www.theforeman.org/plugins/#2.Installation)
 for how to install Foreman plugins
 
 ## Usage
-
-*TODO: Usage here*
+* Create an account and project at [console.cloud.google.com](https://console.cloud.google.com)
+* In _API & Services > Credentials_ create new service account (role: `Editor`) 
+* On account detail page go to _Keys_ and create new `JSON` key 
+* In Foreman, go to _Infrastructure > Compute Resources_ and create Compute Resource
+```
+name: <your-name>
+provider: Google
+Google Project ID: <your-project-id>
+Client Email: service account's email
+Certificate Path: JSON file
+Zone: select the zone you want
+```
 
 ## Contributing
 

data/app/controllers/concerns/foreman/controller/parameters/compute_resource_extension.rb

@@ -0,0 +1,21 @@
+module Foreman
+  module Controller
+    module Parameters
+      module ComputeResourceExtension
+        extend ActiveSupport::Concern
+
+        class_methods do
+          def compute_resource_params_filter
+            super.tap do |filter|
+              filter.permit :email,
+                :key_pair,
+                :key_path,
+                :project,
+                :zone
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/foreman_google/api/v2/apipie_extensions.rb

@@ -0,0 +1,16 @@
+module ForemanGoogle
+  module Api
+    module V2
+      module ApipieExtensions
+        extend Apipie::DSL::Concern
+
+        update_api(:create, :update) do
+          param :compute_resource, Hash do
+            param :key_path, String, desc: N_('Certificate path, for GCE only')
+            param :zone, String, desc: N_('Zone, for GCE only')
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/foreman_google/api/v2/compute_resources_extensions.rb

@@ -0,0 +1,22 @@
+module ForemanGoogle
+  module Api
+    module V2
+      module ComputeResourcesExtensions
+        extend ActiveSupport::Concern
+
+        # rubocop:disable Rails/LexicallyScopedActionFilter
+        included do
+          before_action :read_key, only: [:create]
+        end
+        # rubocop:enable Rails/LexicallyScopedActionFilter
+
+        private
+
+        def read_key
+          return unless compute_resource_params['provider'] == 'GCE'
+          params[:compute_resource][:password] = File.read(params['compute_resource'].delete('key_path'))
+        end
+      end
+    end
+  end
+end

data/app/lib/foreman_google/google_compute_adapter.rb

@@ -0,0 +1,178 @@
+require 'google-cloud-compute'
+
+# rubocop:disable Rails/SkipsModelValidations, Metrics/ClassLength
+module ForemanGoogle
+  class GoogleComputeAdapter
+    def initialize(auth_json_string:)
+      @auth_json = JSON.parse(auth_json_string)
+    end
+
+    def project_id
+      @auth_json['project_id']
+    end
+
+    # ------ RESOURCES ------
+
+    def insert_instance(zone, attrs = {})
+      response = resource_client('instances').insert(project: project_id, zone: zone, instance_resource: attrs)
+      operation_attrs = { zone: zone, operation: response.operation.id.to_s }
+
+      wait_for do
+        get('zone_operations', operation_attrs).status == :DONE
+      end
+
+      e = get('zone_operations', operation_attrs).error
+
+      return response unless e
+
+      raise ::Google::Cloud::Error, e.errors.first.message
+    end
+
+    # Returns an Google::Instance identified by instance_identity within given zone.
+    # @param zone [String] eighter full url or just zone name
+    # @param instance_identity [String] eighter an instance name or its id
+    def instance(zone, instance_identity)
+      get('instances', instance: instance_identity, zone: zone)
+    end
+
+    def instances(zone, **attrs)
+      list('instances', zone: zone, **attrs)
+    end
+
+    def zones
+      list('zones')
+    end
+
+    def networks
+      list('networks')
+    end
+
+    def machine_types(zone)
+      list('machine_types', zone: zone)
+    end
+
+    def start(zone, instance_identity)
+      manage_instance(:start, zone: zone, instance: instance_identity)
+    end
+
+    def stop(zone, instance_identity)
+      manage_instance(:stop, zone: zone, instance: instance_identity)
+    end
+
+    def delete_instance(zone, instance_identity)
+      manage_instance(:delete, zone: zone, instance: instance_identity)
+    end
+
+    # Setting filter to '(deprecated.state != "DEPRECATED") AND (deprecated.state != "OBSOLETE")'
+    # doesn't work and returns empty array, no idea what is happening there
+    def images(filter: nil)
+      projects = [project_id] + all_projects
+      all_images = projects.map { |project| list_images(project, filter: filter) }
+      all_images.flatten.reject(&:deprecated)
+    end
+
+    def image(uuid)
+      images.find { |img| img.id == uuid }
+    end
+
+    def insert_disk(zone, disk_attrs = {})
+      insert('disks', zone, disk_resource: disk_attrs)
+    end
+
+    def disk(zone, name)
+      get('disks', disk: name, zone: zone)
+    end
+
+    def delete_disk(zone, disk_name)
+      delete('disks', zone, disk: disk_name)
+    end
+
+    def set_disk_auto_delete(zone, instance_identity)
+      instance = instance(zone, instance_identity)
+      instance.disks.each do |disk|
+        manage_instance :set_disk_auto_delete, zone: zone,
+                        device_name: disk.device_name,
+                        instance: instance_identity,
+                        auto_delete: true
+      end
+    end
+
+    def serial_port_output(zone, instance_identity)
+      manage_instance(:get_serial_port_output, zone: zone, instance: instance_identity)
+    end
+
+    def wait_for
+      timeout = 60
+      duration = 0
+      start = Time.zone.now
+
+      loop do
+        break if yield
+
+        raise "The specified wait_for timeout (#{timeout} seconds) was exceeded" if duration > timeout
+
+        sleep(1)
+        duration = Time.zone.now - start
+      end
+
+      { duration: duration }
+    end
+
+    private
+
+    def list(resource_name, **opts)
+      response = resource_client(resource_name).list(project: project_id, **opts).response
+      response.items
+    rescue ::Google::Cloud::Error => e
+      raise Foreman::WrappedException.new(e, 'Cannot list Google resource %s', resource_name)
+    end
+
+    def get(resource_name, **opts)
+      resource_client(resource_name).get(project: project_id, **opts)
+    rescue Google::Cloud::NotFoundError => e
+      Foreman::Logging.exception("Could not fetch Google instance [#{opts[:instance]}]", e)
+      raise ActiveRecord::RecordNotFound
+    rescue ::Google::Cloud::Error => e
+      raise Foreman::WrappedException.new(e, 'Could not fetch Google resource %s', resource_name)
+    end
+
+    def insert(resource_name, zone, **opts)
+      resource_client(resource_name).insert(project: project_id, zone: zone, **opts)
+    rescue ::Google::Cloud::Error => e
+      raise Foreman::WrappedException.new(e, 'Could not create Google resource %s', resource_name)
+    end
+
+    def delete(resource_name, zone, **opts)
+      resource_client(resource_name).delete(project: project_id, zone: zone, **opts)
+    rescue ::Google::Cloud::Error => e
+      raise Foreman::WrappedException.new(e, 'Could not delete Google resource %s', resource_name)
+    end
+
+    def list_images(project, **opts)
+      resource_name = 'images'
+      response = resource_client(resource_name).list(project: project, **opts).response
+      response.items
+    rescue ::Google::Cloud::Error => e
+      raise Foreman::WrappedException.new(e, 'Cannot list Google resource %s', resource_name)
+    end
+
+    def manage_instance(action, **opts)
+      resource_client('instances').send(action, project: project_id, **opts)
+    rescue ::Google::Cloud::Error => e
+      raise Foreman::WrappedException.new(e, 'Could not %s Google resource %s', action.to_s, resource_name)
+    end
+
+    def resource_client(resource_name)
+      ::Google::Cloud::Compute.public_send(resource_name) do |config|
+        config.credentials = @auth_json
+      end
+    end
+
+    def all_projects
+      %w[centos-cloud cos-cloud coreos-cloud debian-cloud opensuse-cloud
+         rhel-cloud rhel-sap-cloud suse-cloud suse-sap-cloud
+         ubuntu-os-cloud windows-cloud windows-sql-cloud].freeze
+    end
+  end
+end
+# rubocop:enable Rails/SkipsModelValidations, Metrics/ClassLength

data/app/lib/google_cloud_compute/compute_attributes.rb

@@ -0,0 +1,98 @@
+module GoogleCloudCompute
+  class ComputeAttributes
+    def initialize(client)
+      @client = client
+    end
+
+    def for_new(args)
+      name = parameterize_name(args[:name])
+      network = args[:network] || 'default'
+      associate_external_ip = ActiveModel::Type::Boolean.new.cast(args[:associate_external_ip])
+
+      { name: name, hostname: name,
+        machine_type: args[:machine_type],
+        network: network, associate_external_ip: associate_external_ip,
+        network_interfaces: construct_network(network, associate_external_ip, args[:network_interfaces] || []),
+        image_id: args[:image_id],
+        volumes: construct_volumes(name, args[:image_id], args[:volumes]),
+        metadata: construct_metadata(args) }
+    end
+
+    def for_create(instance)
+      {
+        name: instance.name,
+        machine_type: "zones/#{instance.zone}/machineTypes/#{instance.machine_type}",
+        disks: instance.volumes.map.with_index { |vol, i| { source: "zones/#{instance.zone}/disks/#{vol.device_name}", boot: i.zero? } },
+        network_interfaces: instance.network_interfaces,
+        metadata: instance.metadata,
+      }
+    end
+
+    def for_instance(instance)
+      {
+        name: instance.name, hostname: instance.name,
+        creation_timestamp: instance.creation_timestamp.to_datetime,
+        zone_name: instance.zone.split('/').last,
+        machine_type: instance.machine_type,
+        network: instance.network_interfaces[0].network.split('/').last,
+        network_interfaces: instance.network_interfaces,
+        volumes: instance.disks, metadata: instance.metadata
+      }
+    end
+
+    private
+
+    def parameterize_name(name)
+      name&.parameterize || "foreman-#{Time.now.to_i}"
+    end
+
+    def construct_network(network_name, associate_external_ip, network_interfaces)
+      # handle network_interface for external ip
+      # assign  ephemeral external IP address using associate_external_ip
+      if associate_external_ip
+        network_interfaces = [{ network: 'global/networks/default' }] if network_interfaces.empty?
+        access_config = { name: 'External NAT', type: 'ONE_TO_ONE_NAT' }
+
+        # Note - no support for external_ip from foreman
+        # access_config[:nat_ip] = external_ip if external_ip
+        network_interfaces[0][:access_configs] = [access_config]
+        return network_interfaces
+      end
+
+      network = "https://compute.googleapis.com/compute/v1/projects/#{@client.project_id}/global/networks/#{network_name}"
+      [{ network: network }]
+    end
+
+    def load_image(image_id)
+      return unless image_id
+
+      @client.image(image_id.to_i)
+    end
+
+    def construct_volumes(vm_name, image_id, volumes = [])
+      return [Google::Cloud::Compute::V1::AttachedDisk.new(disk_size_gb: 20)] if volumes.empty?
+
+      image = load_image(image_id)
+
+      attached_disks = volumes.map.with_index do |vol_attrs, i|
+        name = "#{vm_name}-disk#{i + 1}"
+        size = (vol_attrs[:size_gb] || vol_attrs[:disk_size_gb]).to_i
+
+        Google::Cloud::Compute::V1::AttachedDisk.new(device_name: name, disk_size_gb: size)
+      end
+
+      attached_disks.first.source = image&.self_link if image&.self_link
+      attached_disks
+    end
+
+    # Note - GCE only supports cloud-init for Container Optimized images and
+    # for custom images with cloud-init setup
+    def construct_metadata(args)
+      ssh_keys = { key: 'ssh-keys', value: "#{args[:username]}:#{args[:public_key]}" }
+
+      return { items: [ssh_keys] } if args[:user_data].blank?
+
+      { items: [ssh_keys, { key: 'user-data', value: args[:user_data] }] }
+    end
+  end
+end

data/app/lib/google_cloud_compute/compute_collection.rb

@@ -0,0 +1,23 @@
+module GoogleCloudCompute
+  class ComputeCollection
+    include Enumerable
+
+    def initialize(client, zone, attrs)
+      instances = client.instances(zone, attrs)
+      @virtual_machines = instances.map do |vm|
+        ForemanGoogle::GoogleCompute.new client: client,
+          zone: zone,
+          identity: vm.id,
+          instance: vm
+      end
+    end
+
+    def each(&block)
+      @virtual_machines.each(&block)
+    end
+
+    def all(_opts = {})
+      @virtual_machines
+    end
+  end
+end

data/app/lib/google_extensions/attached_disk.rb

@@ -0,0 +1,22 @@
+module GoogleExtensions
+  module AttachedDisk
+    def persisted?
+    end
+
+    def id
+    end
+
+    def _delete
+    end
+
+    def insert_attrs
+      attrs = { name: device_name, size_gb: disk_size_gb }
+      attrs[:source_image] = source if source.present?
+      attrs
+    end
+
+    def size_gb
+      disk_size_gb
+    end
+  end
+end

data/app/models/concerns/foreman_google/host_managed_extensions.rb

@@ -0,0 +1,11 @@
+module ForemanGoogle
+  module HostManagedExtensions
+    def ip_addresses
+      vm&.ip_addresses || []
+    end
+
+    def vm_ip_address
+      vm&.vm_ip_address
+    end
+  end
+end

data/app/models/foreman_google/gce.rb

@@ -1,42 +1,33 @@
 require 'foreman_google/google_compute_adapter'
 
+# rubocop:disable Rails/InverseOf, Metrics/ClassLength
 module ForemanGoogle
   class GCE < ::ComputeResource
-    def self.available?
-      true
-    end
-
-    def self.provider_friendly_name
-      'Google'
-    end
+    has_one :key_pair, foreign_key: :compute_resource_id, dependent: :destroy
+    before_create :setup_key_pair
+    validates :password, :zone, presence: true
 
-    def user_data_supported?
+    def self.available?
       true
     end
 
-    def test_connection(options = {})
-    end
-
     def to_label
+      "#{name} (#{zone}-#{provider_friendly_name})"
     end
 
     def capabilities
       %i[image new_volume]
     end
 
+    def provided_attributes
+      super.merge({ ip: :vm_ip_address })
+    end
+
     def zones
       client.zones.map(&:name)
     end
     alias_method :available_zones, :zones
 
-    def zone
-      url
-    end
-
-    def zone=(zone)
-      self.url = zone
-    end
-
     def networks
       client.networks.map(&:name)
     end
@@ -50,17 +41,12 @@ module ForemanGoogle
     end
     alias_method :available_flavors, :machine_types
 
-    def disks
+    def zone
+      url
     end
 
-    # def interfaces_attrs_name
-    #   super # :interfaces
-    # end
-
-    # This should return interface compatible with Fog::Server
-    # implemented by ForemanGoogle::Compute
-    def find_vm_by_uuid(uuid)
-      GoogleCompute.new(client: client, zone: zone, identity: uuid.to_s)
+    def zone=(zone)
+      self.url = zone
     end
 
     def new_vm(args = {})
@@ -73,35 +59,85 @@ module ForemanGoogle
       GoogleCompute.new(client: client, zone: zone, args: vm_args)
     end
 
+    def create_vm(args = {})
+      ssh_args = { username: find_os_image(args[:image_id])&.username, public_key: key_pair.public }
+      vm = new_vm(args.merge(ssh_args))
+
+      vm.create_volumes
+      vm.create_instance
+      vm.set_disk_auto_delete
+
+      find_vm_by_uuid vm.hostname
+    rescue ::Google::Cloud::Error => e
+      vm.destroy_volumes
+      raise Foreman::WrappedException.new(e, 'Cannot insert instance!')
+    end
+
+    def find_vm_by_uuid(uuid)
+      GoogleCompute.new(client: client, zone: zone, identity: uuid.to_s)
+    end
+
     def destroy_vm(uuid)
+      client.set_disk_auto_delete(zone, uuid)
+      client.delete_instance(zone, uuid)
+    rescue ActiveRecord::RecordNotFound
+      # if the VM does not exists, we don't really care.
+      true
     end
 
-    def create_volumes(args)
+    def available_images(filter: filter_for_images)
+      client.images(filter: filter)
     end
 
-    def create_vm(args = {})
-      new_vm(args)
-      create_volumes(args)
-      # TBD
+    def filter_for_images
+      @filter_for_images ||= nil
     end
 
-    def vm_options(args)
+    def self.model_name
+      ComputeResource.model_name
     end
 
-    def new_volume(attrs = {})
+    def setup_key_pair
+      require 'sshkey'
+
+      key = ::SSHKey.generate
+      build_key_pair name: "foreman-#{id}#{Foreman.uuid}", secret: key.private_key, public: key.ssh_public_key
+    end
+
+    def self.provider_friendly_name
+      'Google'
     end
 
-    def normalize_vm_attrs(vm_attrs)
+    def user_data_supported?
+      true
+    end
+
+    def new_volume(attrs = {})
+      default_attrs = { disk_size_gb: 20 }
+      Google::Cloud::Compute::V1::AttachedDisk.new(**attrs.merge(default_attrs))
     end
 
     def console(uuid)
+      vm = find_vm_by_uuid(uuid)
+
+      if vm.ready?
+        {
+          'output' => vm.serial_port_output, 'timestamp' => Time.now.utc,
+          :type => 'log', :name => vm.name
+        }
+      else
+        raise ::Foreman::Exception,
+          N_('console is not available at this time because the instance is powered off')
+      end
     end
 
     def associated_host(vm)
+      associate_by('ip', [vm.public_ip_address, vm.private_ip_address])
     end
 
-    def available_images(filter: nil)
-      client.images(filter: filter)
+    def vms(attrs = {})
+      filtered_attrs = attrs.except(:eager_loading)
+      GoogleCloudCompute::ComputeCollection.new(client, zone, filtered_attrs)
     end
 
     # ----# Google specific #-----
@@ -110,10 +146,38 @@ module ForemanGoogle
       client.project_id
     end
 
+    def vm_ready(vm)
+      vm.wait_for do
+        vm.reload
+        vm.ready?
+      end
+    end
+
     private
 
     def client
       @client ||= ForemanGoogle::GoogleComputeAdapter.new(auth_json_string: password)
     end
+
+    def set_vm_volumes_attributes(vm, vm_attrs)
+      return vm_attrs unless vm.respond_to?(:volumes)
+
+      vm_attrs[:volumes_attributes] = Hash[vm.volumes.each_with_index.map { |volume, idx| [idx.to_s, volume.to_h] }]
+
+      vm_attrs
+    end
+
+    def find_os_image(uuid)
+      os_image = images.find_by(uuid: uuid)
+      gce_image = client.image(uuid.to_i)
+
+      raise ::Foreman::Exception, N_('Missing an image for operating system!') if os_image.nil?
+      if gce_image.nil?
+        raise ::Foreman::Exception, N_("GCE image [#{uuid.to_i}] for #{os_image.name} image not found in the cloud!")
+      end
+
+      os_image
+    end
   end
 end
+# rubocop:enable Rails/InverseOf, Metrics/ClassLength