theforeman/foreman

View on GitHub
app/controllers/api/v2/compute_resources_controller.rb

Summary

Maintainability
C
7 hrs
Test Coverage
module Api
  module V2
    class ComputeResourcesController < V2::BaseController
      include Api::Version2
      include Foreman::Controller::Parameters::ComputeResource

      wrap_parameters ComputeResource, :include => compute_resource_params_filter.accessible_attributes(parameter_filter_context)

      before_action :find_resource, :only => [:show, :update, :destroy, :available_images, :associate,
                                              :available_virtual_machines, :available_clusters, :available_flavors, :available_folders,
                                              :available_networks, :available_vnic_profiles, :available_resource_pools, :available_security_groups, :available_storage_domains,
                                              :available_zones, :available_storage_pods, :storage_domain, :storage_pod, :refresh_cache, :power_vm, :show_vm, :destroy_vm]

      api :GET, "/compute_resources/", N_("List all compute resources")
      param_group :taxonomy_scope, ::Api::V2::BaseController
      param_group :search_and_pagination, ::Api::V2::BaseController
      add_scoped_search_description_for(ComputeResource)

      def index
        @compute_resources = resource_scope_for_index
      end

      api :GET, "/compute_resources/:id/", N_("Show a compute resource")
      param :id, :identifier, :required => true

      def show
      end

      def_param_group :compute_resource do
        param :compute_resource, Hash, :required => true, :action_aware => true do
          param :name, String, :required => true
          param :provider, String, :desc => N_("Providers include %{providers}") # values are defined in apipie initializer
          param :url, String, :desc => N_("URL for %{providers_requiring_url}")
          param :description, String
          param :user, String, :desc => N_("Username for oVirt, EC2, VMware, OpenStack. Access Key for EC2.")
          param :password, String, :desc => N_("Password for oVirt, EC2, VMware, OpenStack. Secret key for EC2")
          param :datacenter, String, :desc => N_("for oVirt, VMware Datacenter")
          param :ovirt_quota, String, :desc => N_("for oVirt only, ID or Name of quota to use")
          param :public_key, String, :desc => N_("for oVirt only")
          param :region, String, :desc => N_("for AzureRm eg. 'eastus' and for EC2 only. Use '%s' for EC2 GovCloud region") % Foreman::Model::EC2::GOV_CLOUD_REGION
          param :tenant, String, :desc => N_("for OpenStack and AzureRm only")
          param :domain, String, :desc => N_("for OpenStack (v3) only")
          param :project_domain_name, String, :desc => N_("for OpenStack (v3) only")
          param :project_domain_id, String, :desc => N_("for OpenStack (v3) only")
          param :server, String, :desc => N_("for VMware")
          param :set_console_password, :bool, :desc => N_("for Libvirt and VMware only")
          param :display_type, %w(VNC SPICE), :desc => N_('for Libvirt and oVirt only')
          param :keyboard_layout, ComputeResource::ALLOWED_KEYBOARD_LAYOUTS, :desc => N_('for oVirt only')
          param :caching_enabled, :bool, :desc => N_('enable caching, for VMware only')
          param_group :taxonomies, ::Api::V2::BaseController
        end
      end

      def change_datacenter_to_uuid(datacenter)
        if @compute_resource.respond_to?(:get_datacenter_uuid) && datacenter.present?
          @compute_resource.test_connection
          @compute_resource.get_datacenter_uuid(datacenter)
        end
      end

      api :POST, "/compute_resources/", N_("Create a compute resource")
      param_group :compute_resource, :as => :create

      def create
        begin
          if compute_resource_params["provider"].downcase == "ovirt" && !Foreman.is_uuid?(compute_resource_params[:datacenter])
            @compute_resource = ComputeResource.new_provider(compute_resource_params.except(:datacenter))
            params[:compute_resource][:datacenter] = change_datacenter_to_uuid(params[:compute_resource][:datacenter])
          end

          @compute_resource = ComputeResource.new_provider(compute_resource_params)
        rescue Foreman::Exception => e
          render_exception(e, :status => :unprocessable_entity)
          return
        end

        process_response @compute_resource.save
      end

      api :PUT, "/compute_resources/:id/", N_("Update a compute resource")
      param :id, String, :required => true
      param_group :compute_resource

      def update
        datacenter = change_datacenter_to_uuid(compute_resource_params[:datacenter])
        update_parameters = datacenter.present? ? compute_resource_params.merge(:datacenter => datacenter) : compute_resource_params
        # update compute attributes as well when datacenter is changed
        if @compute_resource.provider == 'Vmware' && compute_resource_params[:datacenter].present?
          @compute_resource.compute_attributes.map { |ca| ca.vm_attrs['path'].gsub!(@compute_resource.datacenter, compute_resource_params[:datacenter]) }
        end
        process_response @compute_resource.update(update_parameters)
      end

      api :DELETE, "/compute_resources/:id/", N_("Delete a compute resource")
      param :id, :identifier, :required => true

      def destroy
        process_response @compute_resource.destroy
      end

      api :GET, "/compute_resources/:id/available_images/", N_("List available images for a compute resource")
      param :id, :identifier, :required => true
      def available_images
        @available_images = @compute_resource.available_images
      end

      api :GET, "/compute_resources/:id/available_clusters", N_("List available clusters for a compute resource")
      param :id, :identifier, :required => true
      def available_clusters
        @available_clusters = @compute_resource.available_clusters
        @total = @available_clusters&.size
        render :available_clusters, :layout => 'api/v2/layouts/index_layout'
      end

      api :GET, "/compute_resources/:id/available_flavors", N_("List available flavors for a compute resource")
      param :id, :identifier, :required => true
      def available_flavors
        @available_flavors = @compute_resource.available_flavors
        @total = @available_flavors&.size
        render :available_flavors, :layout => 'api/v2/layouts/index_layout'
      end

      api :GET, "/compute_resources/:id/available_folders", N_("List available folders for a compute resource")
      param :id, :identifier, :required => true
      def available_folders
        @available_folders = @compute_resource.available_folders
        @total = @available_folders&.size
        render :available_folders, :layout => 'api/v2/layouts/index_layout'
      end

      api :GET, "/compute_resources/:id/available_zones", N_("List available zone for a compute resource")
      param :id, :identifier, :required => true
      def available_zones
        @available_zones = @compute_resource.available_zones
        @total = @available_zones&.size
        render :available_zones, :layout => 'api/v2/layouts/index_layout'
      end

      api :GET, "/compute_resources/:id/available_networks", N_("List available networks for a compute resource")
      api :GET, "/compute_resources/:id/available_clusters/:cluster_id/available_networks", N_("List available networks for a compute resource cluster")
      param :id, :identifier, :required => true
      param :cluster_id, String
      def available_networks
        @available_networks = @compute_resource.available_networks(cluster_id)
        @total = @available_networks&.size
        render :available_networks, :layout => 'api/v2/layouts/index_layout'
      end

      api :GET, "/compute_resources/:id/available_vnic_profiles", N_("List available vnic profiles for a compute resource, for oVirt only")
      param :id, :identifier, :required => true
      def available_vnic_profiles
        @available_vnic_profiles = @compute_resource.vnic_profiles
        render :available_vnic_profiles, :layout => 'api/v2/layouts/index_layout'
      end

      api :GET, "/compute_resources/:id/available_clusters/:cluster_id/available_resource_pools", N_("List resource pools for a compute resource cluster")
      param :id, :identifier, :required => true
      param :cluster_id, String, :required => true
      def available_resource_pools
        @available_resource_pools = @compute_resource.available_resource_pools({ :cluster_id => cluster_id })
        @total = @available_resource_pools&.size
        render :available_resource_pools, :layout => 'api/v2/layouts/index_layout'
      end

      api :GET, "/compute_resources/:id/storage_domains/:storage_domain_id", N_("List attributes for a given storage domain")
      param :id, :identifier, :required => true
      param :storage_domain_id, String, :required => true
      def storage_domain
        @storage_domain = @compute_resource.storage_domain(params[:storage_domain_id])
      end

      api :GET, "/compute_resources/:id/available_storage_domains", N_("List storage domains for a compute resource")
      api :GET, "/compute_resources/:id/available_storage_domains/:storage_domain", N_("List attributes for a given storage domain"), deprecated: true
      api :GET, "/compute_resources/:id/available_clusters/:cluster_id/available_storage_domains", N_("List storage domains for a compute resource")
      param :id, :identifier, :required => true
      param :cluster_id, String
      param :storage_domain, String, deprecated: true
      def available_storage_domains
        if params[:storage_domain]
          Foreman::Deprecation.api_deprecation_warning("use /compute_resources/:id/storage_domain/:storage_domain_id endpoind instead")
          @available_storage_domains = [@compute_resource.storage_domain(params[:storage_domain])]
        else
          @available_storage_domains = @compute_resource.available_storage_domains(cluster_id)
        end
        @total = @available_storage_domains&.size
        render :available_storage_domains, :layout => 'api/v2/layouts/index_layout'
      end

      api :GET, "/compute_resources/:id/storage_pods/:storage_pod_id", N_("List attributes for a given storage pod")
      param :id, :identifier, :required => true
      param :storage_pod_id, String, :required => true
      def storage_pod
        @storage_pod = @compute_resource.storage_pod(params[:storage_pod_id])
      end

      api :GET, "/compute_resources/:id/available_storage_pods", N_("List storage pods for a compute resource")
      api :GET, "/compute_resources/:id/available_storage_pods/:storage_pod", N_("List attributes for a given storage pod"), deprecated: true
      api :GET, "/compute_resources/:id/available_clusters/:cluster_id/available_storage_pods", N_("List storage pods for a compute resource")
      param :id, :identifier, :required => true
      param :cluster_id, String
      param :storage_pod, String, deprecated: true
      def available_storage_pods
        if params[:storage_pod]
          Foreman::Deprecation.api_deprecation_warning("use /compute_resources/:id/storage_pod/:storage_pod_id endpoind instead")
          @available_storage_pods = [@compute_resource.storage_pod(params[:storage_pod])]
        else
          @available_storage_pods = @compute_resource.available_storage_pods(cluster_id)
        end
        @total = @available_storage_pods&.size
        render :available_storage_pods, :layout => 'api/v2/layouts/index_layout'
      end

      api :GET, "/compute_resources/:id/available_security_groups", N_("List available security groups for a compute resource")
      param :id, :identifier, :required => true
      def available_security_groups
        @available_security_groups = @compute_resource.available_security_groups
        @total = @available_security_groups&.size
        render :available_security_groups, :layout => 'api/v2/layouts/index_layout'
      end

      api :PUT, "/compute_resources/:id/associate/:vm_id", N_("Associate VMs to Hosts")
      param :id, :identifier, :required => true
      param :vm_id, :identifier
      def associate
        if @compute_resource.supports_host_association?
          associator = ComputeResourceHostAssociator.new(@compute_resource)
          if params[:vm_id].nil?
            associator.associate_hosts
          else
            @vm = @compute_resource.find_vm_by_uuid(params[:vm_id])
            associator.associate_hosts([@vm])
          end
          @hosts = associator.hosts
          handle_messages(associator)
        else
          render_message(_('Associating VMs is not supported for this compute resource'), :status => :unprocessable_entity)
        end
      end

      api :PUT, "/compute_resources/:id/refresh_cache/", N_("Refresh Compute Resource Cache")
      param :id, :identifier, :required => true
      def refresh_cache
        if @compute_resource.respond_to?(:refresh_cache)
          if @compute_resource.refresh_cache
            render_message(_('Successfully refreshed the cache.'))
          else
            render_message(_('Failed to refresh the cache.'), :status => :unprocessable_entity)
          end
        else
          raise ::Foreman::Exception.new(N_("Cache refreshing is not supported for %s"), @compute_resource.provider_friendly_name)
        end
      end

      api :GET, "/compute_resources/:id/available_virtual_machines/", N_("List available virtual machines for a compute resource")
      param :id, :identifier, :required => true
      def available_virtual_machines
        @available_virtual_machines = @compute_resource.vms.all
      end

      api :GET, "/compute_resources/:id/available_virtual_machines/:vm_id", N_("Show a virtual machine")
      param :id, :identifier, :required => true
      param :vm_id, :identifier, :required => true
      def show_vm
        begin
          @vm = @compute_resource.find_vm_by_uuid(params[:vm_id])
        rescue
          raise ::Foreman::Exception.new(N_("Virtual machine was not found by id %{vm_id}") % {:vm_id => params[:vm_id]})
        end
        attributes = @vm.attributes.deep_symbolize_keys
        attributes[:provider] = @compute_resource.provider
        if attributes[:provider] == "Vmware"
          attributes[:mac_addresses] = @vm.mac_addresses
          attributes[:mac] = @vm.mac
        end
        render :json => attributes.as_json(:except => [:label_fingerprint, :fingerprint, :parent])
      end

      api :PUT, "/compute_resources/:id/available_virtual_machines/:vm_id/power", N_("Power a Virtual Machine")
      param :id, :identifier, :required => true
      param :vm_id, :identifier, :required => true
      def power_vm
        @vm = @compute_resource.find_vm_by_uuid(params[:vm_id])
        action = @vm.ready? ? :stop : :start
        @vm.send(action)
        render_message(_('%{action} %{vm}') % {:vm => @vm, :action => (action == :stop) ? _('stopping') : _('starting')})
      rescue Foreman::Exception => e
        render_exception(e, :status => :unprocessable_entity)
      end

      api :DELETE, "/compute_resources/:id/available_virtual_machines/:vm_id", N_("Delete a Virtual Machine")
      param :id, :identifier, :required => true
      param :vm_id, :identifier, :required => true
      def destroy_vm
        process_response @compute_resource.destroy_vm params[:vm_id]
      end

      private

      def cluster_id
        params[:cluster_id].present? && CGI.unescape(params[:cluster_id])
      end

      def action_permission
        case params[:action]
          when 'available_images', 'available_virtual_machines', 'available_clusters', 'available_flavors', 'available_folders', 'available_networks', 'available_vnic_profiles', 'available_resource_pools', 'available_security_groups', 'available_storage_domains', 'storage_domain', 'available_zones', 'associate', 'available_storage_pods', 'storage_pod', 'refresh_cache', 'show_vm', 'power_vm', 'destroy_vm'
            :view
          else
            super
        end
      end

      def handle_messages(associator)
        if associator.fail_count > 0
          render_message((n_('%s VM failed while processing: check logs for more details.',
            '%s VMs failed while processing: check logs for more details.',
            associator.fail_count) % associator.fail_count), :status => :unprocessable_entity)
        elsif associator.hosts.empty?
          render_message(_('No VMs matched any host'), :status => :unprocessable_entity)
        else
          render('api/v2/hosts/index', :layout => 'api/v2/layouts/index_layout')
        end
      end
    end
  end
end