foreman-architect 0.1.0

data/lib/foreman_vm/volume.rb

@@ -0,0 +1,70 @@
+module ForemanAP
+  # A disk volume attached to a virtual machine.
+  class Volume
+    # The format of the volume. Currently, only :raw is supported.
+    def format
+      case @vol.info.type
+      when 0
+        :raw
+      else
+        raise 'unknown volume type: ' + @sph.info.type
+      end
+    end
+  
+    # Delete the volume.
+    def delete
+      @vol.delete
+      true
+    end
+  
+    def initialize(pool, name)
+      @pool = pool
+      @name = name
+      @vol = pool.lookup_volume_by_name(name)
+    end
+  end
+end
+
+#--
+## Legacy code below here
+
+class ForemanVM
+# Delete the disk volume associated with the VM
+# 
+def delete_volume
+  virsh "vol-delete #{self.fqdn}-disk1 --pool #{@buildspec['storage_pool']}"
+end
+
+# Wipe an existing disk volume to fix the permissions
+# This is sadly needed to get the uid:gid to be qemu:qemu
+# 
+def wipe_volume
+  delete_volume
+
+  # BUG: We would like to do this, but it creates the file owned by root:root
+  #virsh "vol-create-as --pool #{@buildspec['storage_pool']} --name #{fqdn()}-disk1 --capacity 30G --format qcow2 --backing-vol #{@buildspec['_disk_backing_file']} --backing-vol-format qcow2"
+  #
+  # WORKAROUND: use an XML volume definition to set the owner/group
+  #  
+  xml = "<volume>
+  <name>#{fqdn}-disk1</name>
+  <key>/gvol/images/#{fqdn}-disk1</key>
+  <source>
+  </source>
+  <capacity unit='bytes'>32212254720</capacity>
+  <allocation unit='bytes'>197120</allocation>
+  <target>
+    <path>/gvol/images/#{fqdn}-disk1</path>
+    <format type='raw'/>
+    <permissions>
+      <mode>0660</mode>
+      <owner>107</owner>
+      <group>107</group>
+    </permissions>
+  </target>
+</volume>
+"
+  @log.debug "creating volume: #{xml}"
+  virsh("vol-create --pool gvol --file /dev/stdin >/dev/null", xml)
+end
+end

data/lib/foreman_vm/workqueue.rb

@@ -0,0 +1,58 @@
+module ForemanAP
+
+  # Allow jobs to be placed on a workqueue and processed later.
+  class Workqueue
+  
+    require 'rubygems'
+    require 'beaneater'
+    require 'json'
+    require 'pp'
+  
+    def initialize(tube_name = 'foreman-vm')
+      @tube_name = tube_name
+      @beanstalk = Beaneater::Pool.new(['localhost:11300'])
+      @tube = @beanstalk.tubes[tube_name]
+    end
+  
+    # Add an item to the queue
+    def enqueue(item)
+      @tube.put JSON.pretty_generate(item)
+    end
+  
+    # Remove a job from the queue, and return the body
+    def dequeue
+      job = @tube.reserve
+      result = JSON.parse(job.body)
+      job.delete
+      result
+    end
+  
+    # Remove all jobs from the queue
+    def clear
+      @tube.clear
+      true
+    end
+  
+    # Return a list of all jobs
+    #   (TODO: try to avoid leaking beanstalkd details)
+    def jobs
+      buf = "job stats:\n\n"
+      buf += @tube.stats.inspect + "\n\n\n" 
+      buf
+    end
+
+    # Process all jobs
+    def process_all_jobs
+      @beanstalk.jobs.register(@tube_name) do |job|
+        yield JSON.parse(job.body)
+      end
+  
+      @beanstalk.jobs.process!
+    end
+
+    # Check if there is a worker waiting for jobs
+    def worker?
+      @tube.stats.current_watching > 0
+    end
+  end
+end

data/test/architect/architect_test.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+require 'tempfile'
+require 'minitest/autorun'
+require 'minitest'
+require 'yaml'
+
+class ArchitectTest < Minitest::Test
+  require 'architect'
+ 
+  protected
+
+  def architect(config = nil)
+    if config.nil?
+      Architect.new
+    else
+      f = Tempfile.new('architect-test-config.yaml')
+      f.write(config.to_yaml)
+      f.close
+      File.chmod(0600, f.path)
+      Architect.new(conffile: f.path)
+    end
+  end
+end

data/test/architect/product_service.yaml

@@ -0,0 +1,33 @@
+---
+defaults:
+    environment:  staging
+    hostgroup:    staging/generic
+    domain:       brontolabs.local
+    subnet:       staging_200
+    network_interface: vnet0.200
+    cpus:         1
+    memory:       2G
+    disk_capacity: 20G,20G
+    storage_pool: gvol
+    owner:        mark.heily
+instances:
+    - product-stg-001:
+        memory: 2G
+    - product-stg-002:
+        memory: 2G
+    - productapi-stg-001:
+        memory: 2G
+        network_interface: vnet0.202
+        subnet: dmz_202
+    - productapi-stg-002:
+        memory: 2G
+        network_interface: vnet0.202
+        subnet: dmz_202
+    - productdb-stg-001:
+        memory: 4G
+    - productsearch-stg-001:
+        memory: 4G
+        disk_capacity: 20G,40G
+    - productsearch-stg-002:
+        memory: 4G
+        disk_capacity: 20G,40G

data/test/architect/tc_builder_physical.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+#
+# Tests for the PhysicalMachineBuilder class
+#
+
+require_relative 'architect_test'
+
+class TestPhysicalMachineBuilder < ArchitectTest
+  #def test_exists?
+  #  spec = { instance_type: 'physical' }
+  #  architect.builder(spec).exists? spec.keys[0]
+  #end
+end

data/test/architect/tc_config.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+require_relative 'architect_test'
+
+class TestConfig < ArchitectTest
+
+  def test_initialize_from_hash
+    cfg = Architect::Config.new({ 'domain' => 'foo' } )
+    assert_equal 'foo', cfg.domain
+  end
+
+  def test_initialize_from_file
+    f = Tempfile.new('test_register.yaml')
+    f.write({ 'domain' => 'foo', 'plugins' => { 'hello_world' => {} } }.to_yaml)
+    f.close
+    File.chmod(0600, f.path)
+    cfg = Architect::Config.new(f.path)
+    assert_equal 'foo', cfg.domain
+  end
+end

data/test/architect/tc_log.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+require_relative 'architect_test'
+ 
+class TestLog < ArchitectTest
+
+  def test_logger
+    Architect::Log.info 'hi'
+    Architect::Log.warn 'this is a warning'
+    Architect::Log.debug 'this is a debug'
+  end
+
+end

data/test/architect/tc_plugin_ldap_netgroup.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+require 'minitest/autorun'
+
+class TestLDAPNetGroupPlugin < MiniTest::Test
+  require 'architect/plugin/ldap_netgroup'
+
+  def test_name
+    assert_equal 'ldap_netgroup', plugin.name
+  end
+
+  def test_configure
+    @plugin = LDAPNetgroupPlugin.new
+    plugin.configure({
+       host: 'localhost',
+       port: '10389',
+       bind_dn: 'cn=foreman-vm',
+       bind_password: 'password123',
+       base_dn: 'ou=Netgroup,dc=example,dc=com',
+       nis_domain: 'example.com',
+    })
+  end
+
+  def setup
+    @plugin = LDAPNetgroupPlugin.new
+    plugin.configure({
+       host: nil,
+       port: nil,
+       bind_dn: nil,
+       bind_password: nil,
+       base_dn: nil,
+       nis_domain: nil,
+      })
+  end
+
+  private
+
+  attr_accessor :plugin
+end

data/test/architect/tc_plugin_manager.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+require_relative 'architect_test'
+ 
+class TestPluginManager < ArchitectTest
+  require 'architect/plugin_manager'
+
+  MOCK_CONFIG = {
+      'hello_world' => {
+          hello: 'bar',
+          quiet: 'true',
+      }
+  }
+
+  def test_initialize
+    pm = Architect::PluginManager.new(MOCK_CONFIG)
+    refute_nil pm
+    refute_nil pm.plugins.hello_world
+  end
+
+  # Test if the plugin can be configured
+  def test_configure
+    pm = Architect::PluginManager.new(MOCK_CONFIG)
+    pm.plugins.hello_world.configure(MOCK_CONFIG['hello_world'])
+    assert_equal 'bar', pm.plugins.hello_world.config.hello
+  end
+end

data/test/tc_allocator.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+
+require 'minitest/autorun'
+require 'foreman_vm/allocator'
+
+class TestCluster < Minitest::Test
+
+  # A mockup of the class we want to write
+  # 
+  # Goals:
+  #   * Allocate new VMs on the hosts with the most free memory
+  #   * Do not allocate all instances of a VM type
+  #     on the same hypervisor. Example: if there is only one hypervisor
+  #     with a VM named 'web1',  do not create a VM named 'web2' here.
+  #
+  #   * (Stretch goal) Try to spread out VMs across multiple hosts where possible
+  #     
+
+  # Try to add a host
+  def test_add_host
+    alloc = ForemanAP::Allocator.new
+    assert alloc.add_host('host1', 1024, ['guest1', 'guest2'])
+  end
+  
+  # Try to add a guest
+  def test_alloc_guest
+    alloc = ForemanAP::Allocator.new
+    assert(alloc.add_host('host1', 1024, ['guest1', 'guest2']))
+    assert(alloc.add_guest('guest3', 512))
+  end
+
+  # Try to add a guest exceeds free memory of host
+  def test_unable_to_add_guest
+    alloc = ForemanAP::Allocator.new
+    assert(alloc.add_host('host1', 1024, ['guest1', 'guest2']))
+    assert_nil(alloc.add_guest('guest3', 4096))
+  end
+
+  # Verify guest is put on host with most free memory
+  def test_free_memory
+    alloc = ForemanAP::Allocator.new 
+    assert(alloc.add_host('host1', 2048, ['a1', 'a2']))
+    assert(alloc.add_host('host2', 1024, ['a1', 'a2']))
+    assert_equal('host1', alloc.add_guest('b1', 512))
+  end
+
+  # Try to add guest that already exists
+  def test_duplicate_guest
+    alloc = ForemanAP::Allocator.new
+    assert(alloc.add_host('host1', 2048, ['guest1', 'guest2']))
+    assert_nil(alloc.add_guest('guest2', 512))
+  end
+
+  # Ensure VM Instance of similar type is spread out to different hypervisors
+  def test_affinity
+    alloc = ForemanAP::Allocator.new
+    assert(alloc.add_host('host1', 2048, ['guest1', 'guest2']))
+    assert(alloc.add_host('host2', 4096, ['guest1', 'web1']))
+    assert_equal('host1', alloc.add_guest('web2', 512))
+  end
+end

data/test/tc_buildspec.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+require 'minitest/autorun'
+
+class TestBuildspec < MiniTest::Test
+  require 'foreman_vm/buildspec'
+
+  def test_initialize
+    refute ForemanAP::BuildSpec.new.nil?
+  end
+
+  def test_assignment
+    spec = ForemanAP::BuildSpec.new 
+    assert_equal('hostname', spec.name = 'hostname')
+    assert_equal(1, spec.cpus = 1)
+    assert_equal('4G', spec.memory = '4G')
+    assert_equal('20G,40G', spec.disk_capacity = '20G,40G')
+    assert_equal('raw', spec.disk_format = 'raw')
+    assert_equal('default', spec.storage_pool = 'default')
+    assert_equal('acme.com', spec.domain = 'acme.com')
+    assert_equal('vnet0.101', spec.network_interface = 'vnet0.101')
+  end
+
+  #def test_fancy
+  #  spec = ForemanAP::BuildSpec.new
+  #  spec.specify do
+  #     hostname 'foo'
+  #  end
+  #  assert_equal('foo', spec.name)
+  #end
+     
+  # Test the generation of the 'volumes_attributes' Foreman API section
+  def test_volumes_attributes
+    spec = ForemanAP::BuildSpec.new 
+    spec.disk_format = 'raw'
+    spec.disk_capacity = '20G,40G'
+    spec.storage_pool = 'default'
+    assert_equal({
+	'volumes_attributes'=> {
+	   '1'=>{'format_type'=>'raw', 'pool_name'=>'default', 'capacity'=>'40G'},
+           '0'=>{'format_type'=>'raw', 'pool_name'=>'default', 'capacity'=>'20G'}
+	}
+    }, spec.to_foreman_api)
+  end
+end

data/test/tc_cluster.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+require "minitest/autorun"
+ 
+class TestCluster < MiniTest::Test
+  require 'foreman_vm'
+
+  def setup
+    @config = ForemanAP::Config.new
+    @cluster = nil
+  end
+
+  def test_initialize
+   @cluster = ForemanAP::Cluster.new(
+                  @config.hypervisors, 
+                  @config.libvirt_user, 
+                  @config.libvirt_password)
+   assert_not_nil @cluster
+  end
+end

data/test/tc_config.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+require 'minitest/autorun'
+ 
+class TestConfig < MiniTest::Test
+  require 'foreman_vm'
+
+  def test_initialize
+   @config = ForemanAP::Config.new
+   assert_not_nil(@config)
+  end
+end