foreman_xen 0.0.1

data/README.md

@@ -0,0 +1,40 @@
+# Foreman XEN Plugin
+
+This plugin enables provisioning and managing XEN Server in Foreman.
+
+## Installation
+
+Please see the Foreman manual for appropriate instructions:
+
+* [Foreman: How to Install a Plugin](http://theforeman.org/manuals/latest/index.html#6.1InstallaPlugin)
+
+The gem name is "foreman_xen".
+
+## Compatibility
+
+| Foreman Version | Plugin Version |
+| ---------------:| --------------:|
+| >=  1.5         | 0.0.1          |
+
+## Latest code
+
+You can get the develop branch of the plugin by specifying your Gemfile in this way:
+
+    gem 'foreman_xen', :git => "https://github.com/ohadlevy/foreman_xen.git"
+
+# Copyright
+
+Copyright (c) 2014 ooVoo LLC
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end

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

@@ -0,0 +1,51 @@
+module FogExtensions
+  module Xenserver
+    module Server
+
+      def to_s
+        name
+      end
+
+      def nics_attributes=(attrs); end
+
+      def volumes_attributes=(attrs); end
+
+      def memory_min
+        memory_static_min.to_i
+      end
+
+      def memory_max
+        memory_static_max.to_i
+      end
+
+      def memory
+        memory_static_max.to_i
+      end
+
+      def reset
+        reboot
+      end
+
+      def ready?
+        running?
+      end
+
+      def mac
+        vifs.first.mac
+      end
+
+      def state
+        power_state
+      end
+
+      def custom_template_name
+        template_name
+      end
+
+      def builtin_template_name
+        template_name
+      end
+
+    end
+  end
+end

data/app/models/foreman_xen/xenserver.rb

@@ -0,0 +1,288 @@
+module ForemanXen
+  class Xenserver < ComputeResource
+    validates_presence_of :url, :user, :password
+
+    def provided_attributes
+      super.merge(
+        { :uuid => :reference,
+          :mac  => :mac
+        })
+    end
+
+    def capabilities
+      [:build]
+    end
+
+    def find_vm_by_uuid(ref)
+      client.servers.get(ref)
+    rescue Fog::XenServer::RequestFailed => e
+      raise(ActiveRecord::RecordNotFound) if e.message.include?('HANDLE_INVALID')
+      raise(ActiveRecord::RecordNotFound) if e.message.include?('VM.get_record: ["SESSION_INVALID"')
+      raise e
+    end
+
+    # we default to destroy the VM's storage as well.
+    def destroy_vm(ref, args = {})
+      find_vm_by_uuid(ref).destroy
+    rescue ActiveRecord::RecordNotFound
+      true
+    end
+
+    def self.model_name
+      ComputeResource.model_name
+    end
+
+    def max_cpu_count
+      ## 16 is a max number of cpus per vm according to XenServer doc
+      [hypervisor.host_cpus.size, 16].min
+    end
+
+    def max_memory
+      xenServerMaxDoc = 128*1024*1024*1024
+      [hypervisor.metrics.memory_total.to_i, xenServerMaxDoc].min
+    rescue => e
+      logger.debug "unable to figure out free memory, guessing instead due to:#{e}"
+      16*1024*1024*1024
+    end
+
+    def test_connection(options = {})
+      super
+      errors[:url].empty? and hypervisor
+    rescue => e
+      disconnect rescue nil
+      errors[:base] << e.message
+    end
+
+    def new_nic(attr={})
+      client.networks.new attr
+    end
+
+    def new_volume(attr={})
+      client.storage_repositories.new attr
+    end
+
+    def storage_pools
+      client.storage_repositories rescue []
+    end
+
+    def interfaces
+      client.interfaces rescue []
+    end
+
+    def networks
+      client.networks rescue []
+    end
+
+    def templates
+      client.servers.templates rescue []
+    end
+
+    def custom_templates
+      tmps = client.servers.custom_templates.select { |t| !t.is_a_snapshot } rescue []
+      tmps.sort { |a, b| a.name <=> b.name }
+    end
+
+    def builtin_templates
+      tmps = client.servers.builtin_templates.select { |t| !t.is_a_snapshot } rescue []
+      tmps.sort { |a, b| a.name <=> b.name }
+    end
+
+    def new_vm(attr={})
+
+      test_connection
+      return unless errors.empty?
+      opts = vm_instance_defaults.merge(attr.to_hash).symbolize_keys
+
+      [:networks, :volumes].each do |collection|
+        nested_attrs     = opts.delete("#{collection}_attributes".to_sym)
+        opts[collection] = nested_attributes_for(collection, nested_attrs) if nested_attrs
+      end
+      opts.reject! { |_, v| v.nil? }
+      client.servers.new opts
+    end
+
+    def create_vm(args = {})
+      custom_template_name  = args[:custom_template_name]
+      builtin_template_name = args[:builtin_template_name]
+      raise 'you can select at most one template type' if builtin_template_name != '' and custom_template_name != ''
+      begin
+        vm = nil
+        if custom_template_name != ''
+          vm = create_vm_from_custom args
+        else
+          vm = create_vm_from_builtin args
+        end
+        vm.set_attribute('name_description', 'Provisioned by Foreman')
+        cpus = args[:vcpus_max]
+        if vm.vcpus_max.to_i < cpus.to_i
+          vm.set_attribute('VCPUs_max', cpus)
+          vm.set_attribute('VCPUs_at_startup', cpus)
+        else
+          vm.set_attribute('VCPUs_at_startup', cpus)
+          vm.set_attribute('VCPUs_max', cpus)
+        end
+        vm.refresh
+        return vm
+      rescue => e
+        logger.info e
+        logger.info e.backtrace.join("\n")
+        return false
+      end
+    end
+
+    def create_vm_from_custom(args)
+      mem_max = args[:memory_max]
+      mem_min = args[:memory_min]
+
+      raise 'Memory max cannot be lower than Memory min' if mem_min.to_i > mem_max.to_i
+      vm = client.servers.new :name          => args[:name],
+                              :template_name => args[:custom_template_name]
+
+      vm.save :auto_start => false
+
+      vm.provision
+
+      vm.vifs.first.destroy rescue nil
+
+      create_network(vm, args)
+
+      args['xenstore']['vm-data']['ifs']['0']['mac'] = vm.vifs.first.mac
+      xenstore_data                                  = xenstore_hash_flatten(args['xenstore'])
+
+      vm.set_attribute('xenstore_data', xenstore_data)
+      if vm.memory_static_max.to_i < mem_max.to_i
+        vm.set_attribute('memory_static_max', mem_max)
+        vm.set_attribute('memory_dynamic_max', mem_max)
+        vm.set_attribute('memory_dynamic_min', mem_min)
+        vm.set_attribute('memory_static_min', mem_min)
+      else
+        vm.set_attribute('memory_static_min', mem_min)
+        vm.set_attribute('memory_dynamic_min', mem_min)
+        vm.set_attribute('memory_dynamic_max', mem_max)
+        vm.set_attribute('memory_static_max', mem_max)
+      end
+
+      disks = vm.vbds.select { |vbd| vbd.type == 'Disk' }
+      disks.sort! { |a, b| a.userdevice <=> b.userdevice }
+      i = 0
+      disks.each do |vbd|
+        vbd.vdi.set_attribute('name-label', "#{args[:name]}_#{i}")
+        i+=1
+      end
+      vm
+    end
+
+    def create_vm_from_builtin(args)
+
+      host               = client.hosts.first
+      storage_repository = client.storage_repositories.find { |sr| sr.name == "#{args[:VBDs][:print]}" }
+
+      gb   = 1073741824 #1gb in bytes
+      size = args[:VBDs][:physical_size].to_i * gb
+      vdi  = client.vdis.create :name               => "#{args[:name]}-disk1",
+                                :storage_repository => storage_repository,
+                                :description        => "#{args[:name]}-disk_1",
+                                :virtual_size       => size.to_s
+
+      mem_max      = args[:memory_max]
+      mem_min      = args[:memory_min]
+      other_config = {}
+      if args[:builtin_template_name] != ''
+        template     = client.servers.builtin_templates.find { |tmp| tmp.name == args[:builtin_template_name] }
+        other_config = template.other_config
+        other_config.delete 'disks'
+        other_config.delete 'default_template'
+      end
+      vm = client.servers.new :name               => args[:name],
+                              :affinity           => host,
+                              :pv_bootloader      => '',
+                              :hvm_boot_params    => { :order => 'dn' },
+                              :other_config       => other_config,
+                              :memory_static_max  => mem_max,
+                              :memory_static_min  => mem_min,
+                              :memory_dynamic_max => mem_max,
+                              :memory_dynamic_min => mem_min
+
+      vm.save :auto_start => false
+      client.vbds.create :server => vm, :vdi => vdi
+
+      create_network(vm, args)
+
+      vm.provision
+      vm.set_attribute('HVM_boot_policy', 'BIOS order')
+      vm.refresh
+      vm
+    end
+
+    def console(uuid)
+      vm = find_vm_by_uuid(uuid)
+      raise 'VM is not running!' unless vm.ready?
+
+
+      console = vm.service.consoles.find { |c| c.__vm == vm.reference && c.protocol == 'rfb' }
+      raise "No console fore vm #{vm.name}" if console == nil
+
+      session_ref = (vm.service.instance_variable_get :@connection).instance_variable_get :@credentials
+      fullURL     = "#{console.location}&session_id=#{session_ref}"
+      tunnel      = VNCTunnel.new fullURL
+      tunnel.start
+      logger.info 'VNCTunnel started'
+      WsProxy.start(:host => tunnel.host, :host_port => tunnel.port, :password => '').merge(:type => 'vnc', :name => vm.name)
+
+    rescue Error => e
+      logger.warn e
+      raise e
+    end
+
+    def hypervisor
+      client.hosts.first
+    end
+
+    protected
+
+    def client
+      @client ||= ::Fog::Compute.new({ :provider => 'XenServer', :xenserver_url => url, :xenserver_username => user, :xenserver_password => password })
+    end
+
+    def disconnect
+      client.terminate if @client
+      @client = nil
+    end
+
+    def vm_instance_defaults
+      super.merge({})
+    end
+
+
+    private
+
+    def create_network(vm, args)
+      net        = client.networks.find { |n| n.name == args[:VIFs][:print] }
+      net_config = {
+        'MAC_autogenerated'    => 'True',
+        'VM'                   => vm.reference,
+        'network'              => net.reference,
+        'MAC'                  => '',
+        'device'               => '0',
+        'MTU'                  => '0',
+        'other_config'         => {},
+        'qos_algorithm_type'   => 'ratelimit',
+        'qos_algorithm_params' => {}
+      }
+      client.create_vif_custom net_config
+      vm.reload
+    end
+
+    def xenstore_hash_flatten(nested_hash, key=nil, keychain=nil, out_hash={})
+      nested_hash.each do |k, v|
+        if v.is_a? Hash
+          xenstore_hash_flatten(v, k, "#{keychain}#{k}/", out_hash)
+        else
+          out_hash["#{keychain}#{k}"] = v
+        end
+      end
+      out_hash
+      @key = key
+    end
+  end
+end

data/app/views/compute_resources/form/_xenserver.html.erb

@@ -0,0 +1,11 @@
+<%= text_f f, :url, :class => "input-xlarge", :help_block => _("e.g. x.x.x.x") %>
+<%= text_f f, :user %>
+<%= password_f f, :password %>
+
+<% hypervisor = f.object.hypervisor.uuid rescue nil%>
+<% if hypervisor -%>
+  <%= f.hidden_field :uuid, :value => hypervisor %>
+<% end -%>
+<%= link_to_function _("Test Connection"), "testConnection(this)", :class => "btn + #{hypervisor.nil? ? "" : "btn-success"}", :'data-url' => test_connection_compute_resources_path %>
+
+<%= image_tag('/assets/spinner.gif', :id => 'test_connection_indicator', :class => 'hide') %>

data/app/views/compute_resources/show/_xenserver.html.erb

@@ -0,0 +1,4 @@
+<tr>
+  <td><%= _("URL") %></td>
+  <td><%= @compute_resource.url %></td>
+</tr>

data/app/views/compute_resources_vms/form/_network.html.erb

@@ -0,0 +1,16 @@
+<div class="fields">
+  <%
+     nat = compute_resource.networks
+     selected = ""
+     if params && params['host'] && params['host']['compute_attributes']
+       selected = params['host']['compute_attributes']['VIFs']['print']
+     end
+  -%>
+
+  <div id='nat' class=''>
+    <%= selectable_f f, :print, nat.map(&:name),
+                     { :include_blank => nat.any? ? false : _("No networks"),
+                       :selected      => selected },
+                     { :class => "span2", :label => _("Network") } %>
+  </div>
+</div>

data/app/views/compute_resources_vms/form/_templates.html.erb

@@ -0,0 +1,30 @@
+<div class="fields">
+  <%
+     selected_item_c = ''
+     selected_item_b = ''
+     if params && params['host'] && params['host']['compute_attributes']
+       selected_item_c = params['host']['compute_attributes']['custom_template_name']
+       selected_item_b = params['host']['compute_attributes']['builtin_template_name']
+     end
+  %>
+
+  <div id='templates' class=''>
+    <label class="control-label" for="host_compute_attributes_custom_template_name">Custom template</label>
+
+    <div class="controls">
+      <select class="input-xlarge" id="host_compute_attributes_custom_template_name" name="host[compute_attributes][custom_template_name]">
+        <%= options_for_select([[_("No template"), ""]] + compute_resource.custom_templates.map { |t| [t.name, t.name] }, selected_item_c) %>
+      </select>
+    </div>
+
+    <label class="control-label" for="host_compute_attributes_builtin_template_name">Built-in template</label>
+
+    <div class="controls">
+      <select class="input-xlarge" id="host_compute_attributes_builtin_template_name" name="host[compute_attributes][builtin_template_name]">
+        <%= options_for_select([[_("No template"), ""]] + compute_resource.builtin_templates.map { |t| [t.name, t.name] }, selected_item_b) %>
+      </select>
+    </div>
+
+  </div>
+
+</div>