foreman_gridscale 1.0.0

data/README.md

@@ -0,0 +1,89 @@
+# ForemanGridscale
+
+*Plugin to enable management of gridscale instances from within foreman*
+
+## Requirements
+Foreman gridscale has the following requirements:
+
+* Foreman 1.15+
+* A working internet connection
+
+## Installation
+
+1. Extract the supplied archive on the server which has Foreman installed on it. Make sure to do this in a directory which can be accessed by the user running Foreman.
+
+2. In the foreman/bundler.d directory (usually found in /usr/share/), create or edit the file Gemfile.local.rb and add the following lines to it:
+
+    ```ruby
+    gem 'fog-gridscale', :path => 'path to fog-gridscale directory'
+    gem 'foreman_gridscale', :path => 'path to foreman-gridscale directory'
+    ```
+
+3. Next run the following command: 
+
+    ```
+    $ cd /usr/share/foreman && sudo -u foreman /usr/bin/foreman-ruby /usr/bin/bundle install
+    ```
+
+4. Then restart Foreman with:
+    ```
+    $ touch /usr/share/foreman/tmp/restart.txt
+    ```
+
+See [how to install Foreman plugins](http://projects.theforeman.org/projects/foreman/wiki/How_to_Install_a_Plugin) to learn more about plugins.
+
+
+## How to Use
+### Configuration
+
+Go to **Infrastructure > Compute Resources** and click on "New Compute Resource".
+
+Choose **gridscale** as the provider, and fill in all the fields. You need your API token and user uuid with read and write access, which can be created in the [gridscale API section](https://my.gridscale.io/APIs/). 
+
+That's it. You're now ready to create and manage servers in your new gridscale compute resource.
+
+You should see something like this on the [Compute Resource](https://theforeman.org/manuals/1.19/index.html#5.2ComputeResources) page:
+
+### Host Creation
+1. Go to host > create host and choose gridscale as a deployment target. The virtual machine tab with all of the parameter fields to create a server will appear
+2. If you already set up your compute profile, you can choose it and it will automatically set up the virtual machine parameters. you can also overwrite them
+3. On the virtual machine tab, fill in the fields with the desired number cores, memory, and capacity of the storage. You can also attach a gridscale or private template to your storage
+4. Fill the operating system tab
+5. In the interface tab, click the edit button in actions column, and pick the gridscale network interface you wish to connect your machine to. You can also add multiple network interfaces by clicking the add interface button below the interface table. click OK once you have finished
+6. Click submit button to finish the Host creation
+
+### Compute Profile
+1. Click infrastructure > compute profile
+2. Click create compute profile button on the top right side of the screen
+3. Fill in the name field, and click the submit button
+4. Click on the compute resource link that you want to associate with your compute profile
+5. Fill out the compute profile attributes and click the submit button
+6. You are now ready to use your compute profile
+
+### Host Management
+Click Host > All Host. You will be able to see all of the hosts that were created through foreman in the tables. The Power column shows the power status of the server. The host’s details can be seen by clicking the link in its name.
+    
+**Powering off/on**
+1. Choose the host by checking the box in the first column of the table (you can select all of the hosts by checking the box in the header)
+2. Click the action button, and choose change power state
+3. Select the desired power state from the dropdown power list
+4. Click submit
+
+**Delete Host**
+1. Choose the host by checking the box in the first column of the table (you can select all of the hosts by checking the box on the header)
+2. Click the action button, and choose delete host (you can also delete them individually by clicking the dropdown list in the actions column)
+3. Click submit and confirm the action
+
+
+###Host management through the compute resource page
+Go to Infrastructure > Compute resource and select the compute resource for gridscale. go to the virtual machine tab. The virtual machine tab displays all of the servers in the gridscale panel.
+
+##Known Issues
+* When creating a host, multiple network interfaces can be set to bootable. The gridscale platform does not support this, which is why only one of the interfaces will actually be set to bootable if this is the case
+* When creating a compute profile, the chosen network interface configuration is not saved
+* The Virtual Machines overview of a compute resource can take a long time to load
+* The data shown in the VM tab of a host is not complete. More input about which information is useful is needed
+* Opening the console of a host in Foreman has not been implemented, but a link to gridscale is supplied
+* Acpi power off fails to shut down a system which did not boot
+* MAC, IP4 and IP6 information is in the VM tab, not Interface
+

data/Rakefile

@@ -0,0 +1,47 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ForemanGridscale'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path('../test/dummy/Rakefile', __FILE__)
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test
+
+begin
+  require 'rubocop/rake_task'
+  RuboCop::RakeTask.new
+rescue => _
+  puts 'Rubocop not loaded.'
+end
+
+task :default do
+  Rake::Task['rubocop'].execute
+end

data/app/helpers/gridscale_images_helper.rb

@@ -0,0 +1,128 @@
+module GridscaleImagesHelper
+  def gridscale_server_field(f)
+    images = @compute_resource.available_servers
+    images.each { |image| image.name = image.id if image.name.nil? }
+    select_f f, :uuid, images.to_a.sort_by(&:full_name),
+             :id, :full_name, {}, :label => _('Image')
+  end
+
+  def select_ipv4(f, compute_resource)
+    addresses = Array.new
+    compute_resource.ips.each do |ip|
+       if ip.relations['servers'].empty? and ip.relations['loadbalancers'].empty? and ip.family ==4
+         addresses << ip
+       end
+     end
+    if addresses.empty?
+      "No IPs available"
+    else
+      select_f(f,
+               :ipv4_uuid,
+               addresses,
+               :object_uuid,
+               :ip,
+               { :include_blank => true },
+               { :label => 'IP Address 4'})
+    end
+  end
+
+  def select_ipv6(f, compute_resource)
+    addresses = Array.new
+    compute_resource.ips.each do |ip|
+      if ip.relations['servers'].empty? and ip.relations['loadbalancers'].empty? and ip.family ==6
+        addresses << ip
+      end
+    end
+    if addresses.empty?
+      "No IPs available"
+    else
+      select_f(f,
+               :ipv6_uuid,
+               addresses,
+               :object_uuid,
+               :ip,
+               { :include_blank => true },
+               { :label => 'IP Address 6'})
+    end
+  end
+
+  def select_network(f, compute_resource)
+    networks_list = Array.new
+    compute_resource.networks.each do |network|
+      networks_list << network
+    end
+
+    select_f(f,
+             :network_uuid,
+             networks_list,
+             :object_uuid,
+             :name,
+             { :include_blank => true },
+             { :label => 'Network'})
+
+  end
+
+
+
+  def select_storage(f, compute_resource)
+
+    storages_list = Array.new
+
+    compute_resource.storages.each do |storage|
+      if storage.relations['servers'].empty?
+        storages_list << storage
+      end
+    end
+
+    if storages_list.empty?
+      "No storage available"
+    else
+      select_f(f,
+               :storage_uuid,
+               storages_list,
+               :object_uuid,
+               :name,
+               { :include_blank => true },
+               { :label => 'available storage'})
+    end
+  end
+
+  def select_template(f, compute_resource)
+    template_list = Array.new
+    compute_resource.templates.each do |template|
+      template_list << template
+    end
+
+    select_f(f,
+             :template_uuid,
+             template_list,
+             :object_uuid,
+             :name,
+             { :include_blank => true },
+             { :label => 'Template'})
+
+  end
+
+  def select_sshkey(f, compute_resource)
+    template_list = Array.new
+    compute_resource.sshkeys.each do |template|
+      template_list << template
+    end
+
+    select_f(f,
+             :sshkey_uuid,
+             template_list,
+             :object_uuid,
+             :name,
+             { :include_blank => true },
+             { :label => 'SSH Key'})
+
+  end
+
+  def gridscale_image_field(f)
+    images = @compute_resource.available_templates
+    images.each { |image| image.name = image.object_uuid if image.name.nil? }
+    select_f f, :object_uuid, images.to_a,
+             :object_uuid, :name, {}, :label => _('Image')
+  end
+end

data/app/models/concerns/fog_extensions/gridscale/server.rb

@@ -0,0 +1,63 @@
+module FogExtensions
+  module Gridscale
+    module Server
+      extend ActiveSupport::Concern
+
+      attr_accessor :object_uuid, :mac, :server_uuid, :interfaces_attributes, :ipv4_address, :ipv6_address
+
+      def state
+        requires :status
+        @state ||= status
+      end
+
+      def to_s
+        name
+      end
+
+      def reset
+        reboot
+      end
+
+      def vm_description
+        format(_('%{cpus} CPUs and %{ram} memory'), :cpus => cores, :ram => memory)
+      end
+
+      def ip_addresses
+        [ipv4_address, ipv6_address].flatten.select(&:present?)
+
+      end
+
+      def ip4_add_in
+        x = nil
+        if interfaces_attributes != nil
+          interfaces_attributes.each do |key, value|
+
+            if value["ipv4_uuid"] !=nil && value["ipv4_uuid"] != ""
+              x = service.ips.get(value["ipv4_uuid"])
+            end
+          end
+        end
+        x.ip
+      end
+
+      def ip6_add_in
+        x = nil
+        if interfaces_attributes != nil
+          interfaces_attributes.each do |key, value|
+
+            if value["ipv6_uuid"] !=nil && value["ipv6_uuid"] != ""
+              x = service.ips.get(value["ipv6_uuid"])
+            end
+          end
+        end
+        x.ip
+      end
+
+      def mac_addr
+        :mac
+      end
+
+
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module ForemanGridscale
+  module Concerns
+    module HostManagedExtensions
+      extend ActiveSupport::Concern
+
+      included do
+        # Rails 4 does not provide dynamic finders for delegated methods and
+        # the SSH orchestrate compute method uses them.
+        def self.find_by_ip(ip)
+          nic = Nic::Base.find_by_ip(ip)
+          nic.host if nic.present?
+        end
+      end
+    end
+  end
+end

data/app/models/foreman_gridscale/gridscale.rb

@@ -0,0 +1,196 @@
+module ForemanGridscale
+  class Gridscale < ComputeResource
+    alias_attribute  :api_token, :password
+    alias_attribute  :user_uuid, :user
+    alias_attribute  :object_uuid, :uuid
+
+    has_one :key_pair, :foreign_key => :compute_resource_id, :dependent => :destroy
+    delegate  :to => :client
+
+    validates :api_token, :user_uuid, :presence => true
+    before_create :test_connection
+
+
+    def api_token
+      attrs[:api_token]
+    end
+
+    def user_uuid
+      attrs[:user_uuid]
+    end
+
+    def api_token=(api_token)
+      attrs[:api_token] = api_token
+    end
+
+    def user_uuid=(user_uuid)
+      attrs[:user_uuid] = user_uuid
+    end
+
+    def to_label
+      "#{name} (#{provider_friendly_name})"
+    end
+
+    def provided_attributes
+      super.merge({})
+    end
+
+    def get_ip(ipaddr_uuid)
+      client.ips.get(ipaddr_uuid).ip
+    end
+
+    def capabilities
+      [:build, :images]
+    end
+
+    def associated_host(vm)
+      associate_by('ip', [vm.ipv4_address])
+    end
+
+    def create_vm(args = {})
+      args['cores'] = args['cores'].to_i
+      args['memory'] = args['memory'].to_i
+      args['storage'] = args['storage'].to_i
+
+      super(args)
+    rescue Fog::Errors::Error => e
+      logger.error "Unhandled gridscale error: #{e.status}:#{e.message}\n " + e.backtrace.join("\n ")
+      raise e
+    end
+
+    def new_interface(attr = {})
+      client.interfaces.new attr
+    end
+
+    def power_check(uuid)
+      client.server_power_get(uuid).body['power']
+    end
+
+    def power_off(uuid)
+      client.server_power_off(uuid)  if power_check(uuid)
+    end
+
+    def destroy_vm(uuid)
+      attached_storage = []
+
+      client.servers.get(uuid).relations['storages'].each do |storage|
+        attached_storage << storage['object_uuid']
+      end
+
+      if power_check(uuid)
+        client.server_power_off(uuid)
+      end
+      sleep(1) until  client.servers.get(uuid).status != "in-provisioning"
+      find_vm_by_uuid(uuid).destroy
+
+      attached_storage.each do |storage_uuid|
+        client.storages.destroy(storage_uuid)
+      end
+    rescue ActiveRecord::RecordNotFound
+      # if the VM does not exists, we don't really care.
+      true
+    end
+
+    def save_vm(uuid, attr)
+      vm = find_vm_by_uuid(uuid)
+      vm.attributes.merge!(attr.symbolize_keys).deep_symbolize_keys
+      update_interfaces(vm, attr[:interfaces_attributes])
+      vm.save
+    end
+
+    def ips
+      client.ips
+    end
+
+    def interfaces
+      client.interfaces rescue []
+    end
+
+    def networks
+      client.networks rescue []
+    end
+
+    def network
+      client.networks.get(network_uuid)
+    end
+
+    def storages
+      client.storages
+    end
+
+    def templates
+      client.templates
+    end
+
+    def sshkeys
+      client.sshkeys
+    end
+
+    def available_templates
+      images = []
+      collection = client.templates
+      begin
+        images += collection.to_a
+      end until !collection.next_page
+      images
+    end
+
+    def self.model_name
+      ComputeResource.model_name
+    end
+
+    def find_vm_by_uuid(uuid)
+      client.servers.get(uuid)
+    rescue Fog::Compute::Gridscale::Error
+      raise(ActiveRecord::RecordNotFound)
+    end
+
+    def test_connection(options = {})
+      super
+      errors[:token].empty? && errors[:uuid].empty? && networks.count
+    rescue Excon::Errors::Unauthorized => e
+      errors[:base] << e.response.body
+    rescue Fog::Errors::Error => e
+      errors[:base] << e.message
+    end
+
+    def default_region_name
+      @default_region_name ||= 'de/fra'
+    rescue Excon::Errors::Unauthorized => e
+      errors[:base] << e.response.body
+    end
+
+    def self.provider_friendly_name
+      'gridscale'
+    end
+
+    def user_data_supported?
+      true
+    end
+
+    private
+
+    def client
+      @client ||= Fog::Compute.new(
+        :provider => 'gridscale',
+        :api_token => api_token,
+        :user_uuid => user_uuid
+      )
+    end
+
+    def vm_instance_defaults
+      super.merge(
+        :location_uuid => '45ed677b-3702-4b36-be2a-a2eab9827950'
+      )
+    end
+
+    def default_iface_name(interfaces)
+      nic_name_num = 1
+      name_blacklist = interfaces.map{ |i| i[:name]}.reject{|n| n.blank?}
+      nic_name_num += 1 while name_blacklist.include?("nic#{nic_name_num}")
+      "nic#{nic_name_num}"
+    end
+
+
+  end
+end