beaker-hostgenerator 0.1.0

data/lib/beaker-hostgenerator/error.rb

@@ -0,0 +1,6 @@
+module BeakerHostGenerator
+  module Errors
+    class Error < RuntimeError ; end
+    class InvalidNodeSpecError < BeakerHostGenerator::Errors::Error ; end
+  end
+end

data/lib/beaker-hostgenerator/generator.rb

@@ -0,0 +1,143 @@
+require 'beaker-hostgenerator/util'
+require 'beaker-hostgenerator/data'
+require 'beaker-hostgenerator/error'
+require 'beaker-hostgenerator/roles'
+
+require 'yaml'
+
+module BeakerHostGenerator
+  class Generator
+    include BeakerHostGenerator::Data
+    include BeakerHostGenerator::Errors
+    include BeakerHostGenerator::Utils
+
+    BASE_HOST_CONFIG = {
+      'pe_dir' => BeakerHostGenerator::Utils.pe_dir(PE_VERSION, PE_FAMILY),
+      'pe_ver' => PE_VERSION,
+      'pe_upgrade_dir' => BeakerHostGenerator::Utils.pe_dir(PE_UPGRADE_VERSION, PE_UPGRADE_FAMILY),
+      'pe_upgrade_ver' => PE_UPGRADE_VERSION,
+    }
+    attr_reader :options
+
+    def initialize options
+      @options = options
+    end
+
+    def self.create( options )
+      hypervisor_type = options[:hypervisor]
+
+      hclass = case hypervisor_type
+               when /vmpooler/
+                 BeakerHostGenerator::Vmpooler
+               when /vagrant/
+                 BeakerHostGenerator::Vagrant
+               else
+                 raise "Invalid hypervisor #{type}"
+               end
+
+      return hclass.new(options)
+    end
+
+    def generate tokens
+      nodeid = Hash.new(1)
+      ostype = nil
+
+      tokens.each do |token|
+        if is_ostype_token?(token)
+          if nodeid[ostype] == 1 and ostype != nil
+            raise "Error: no nodes generated for #{ostype}"
+          end
+          ostype = token
+          next
+        end
+
+        node_info = __parse_node_info_token(token)
+
+        node_info['ostype'] = ostype
+        node_info['nodeid'] = nodeid[ostype]
+
+        host_name, host_config = generate_node(node_info, BASE_HOST_CONFIG)
+
+        if PE_USE_WIN32 && ostype =~ /windows/ && node_info['bits'] == "64"
+          host_config['ruby_arch'] = 'x86'
+          host_config['install_32'] = true
+        end
+
+        if not @options[:disable_default_role]
+          host_config['roles'] = ['agent']
+        else
+          host_config['roles'] = []
+        end
+
+        host_config['roles'].concat __generate_host_roles(node_info)
+        host_config['roles'].uniq!
+
+        if not @options[:disable_role_config]
+          host_config['roles'].each do |role|
+            host_config.deep_merge! __get_role_config(role)
+          end
+        end
+
+        @config['HOSTS'][host_name] = host_config
+        nodeid[ostype] += 1
+      end
+
+      return @config.to_yaml
+    end
+
+    def __get_role_config role
+      begin
+        r = BeakerHostGenerator::Roles.new
+        m = r.method(role)
+      rescue NameError
+        return {}
+      end
+
+      return m.call
+    end
+
+    def __parse_node_info_token token
+      node_info = NODE_REGEX.match(token)
+
+      if node_info
+        node_info = Hash[ node_info.names.zip( node_info.captures ) ]
+      else
+        raise InvalidNodeSpecError.new, "Invalid node_info token: #{token}"
+      end
+
+      if node_info['arbitrary_roles']
+        node_info['arbitrary_roles'] = node_info['arbitrary_roles'].split(',') || ''
+      else
+        # Default to empty list to avoid having to check for nil elsewhere
+        node_info['arbitrary_roles'] = []
+      end
+
+      return node_info
+    end
+
+    def __generate_host_roles node_info
+      roles = []
+
+      node_info['roles'].each_char do |c|
+        roles << ROLES[c]
+      end
+
+      node_info['arbitrary_roles'].each do |role|
+        roles << role
+      end
+
+      return roles
+    end
+
+    def is_ostype_token?
+      raise "Method 'is_ostype_token?' not implemented!"
+    end
+
+    def generate_node
+      raise "Method 'generate_node' not implemented!"
+    end
+
+  end
+end
+
+require 'beaker-hostgenerator/generator/vmpooler'

data/lib/beaker-hostgenerator/generator/vmpooler.rb

@@ -0,0 +1,57 @@
+require 'beaker-hostgenerator/generator'
+require 'beaker-hostgenerator/data/vmpooler'
+require 'beaker-hostgenerator/data'
+require 'deep_merge'
+
+module BeakerHostGenerator
+  class Vmpooler < BeakerHostGenerator::Generator
+    include BeakerHostGenerator::Data
+    include BeakerHostGenerator::Data::Vmpooler
+
+    def initialize(options)
+      @config = {}
+      @config.deep_merge! BASE_CONFIG
+      @config.deep_merge! VMPOOLER_CONFIG
+      super(options)
+    end
+
+    def generate_node node_info, base_config
+      host_config = {}
+      host_config.deep_merge! base_config
+
+      # set hypervisor
+      host_config['hypervisor'] = 'vmpooler'
+
+      # generate node definition
+      ostype = node_info['ostype']
+      nodeid = node_info['nodeid']
+      bits = node_info['bits']
+
+      platform = "#{ostype}-#{bits}"
+      name = "#{platform}-#{nodeid}"
+
+      host_config.deep_merge! OSINFO[platform]
+
+      # Some vmpooler/vsphere platforms have special requirements. We munge the
+      # node host_config here if that is necessary.
+      fixup_node host_config
+
+      return name, host_config
+    end
+
+    def is_ostype_token? token
+      OSINFO.each do |key,value|
+
+        ostype = key.split('-')[0]
+
+        if ostype == token
+          return true
+        end
+
+      end
+
+      return false
+    end
+
+  end
+end

data/lib/beaker-hostgenerator/roles.rb

@@ -0,0 +1,22 @@
+require 'beaker-hostgenerator/data'
+require 'beaker-hostgenerator/data/vmpooler'
+require 'deep_merge'
+
+module BeakerHostGenerator
+  class Roles
+
+    def initialize
+    end
+
+    def compile_master
+      return {
+        'frictionless_options' => {
+          'main' => {
+            'dns_alt_names' => 'puppet',
+            'environmentpath' => '/etc/puppetlabs/puppet/environments',
+          }
+        }
+      }
+    end
+  end
+end

data/lib/beaker-hostgenerator/util.rb

@@ -0,0 +1,64 @@
+require 'beaker-hostgenerator/data'
+require 'beaker-hostgenerator/data/vmpooler'
+require 'deep_merge'
+
+module BeakerHostGenerator
+  module Utils
+    include BeakerHostGenerator::Data
+    include BeakerHostGenerator::Data::Vmpooler
+
+    def pe_dir(version, family)
+      # If our version is the same as our family, we're installing a
+      # released version. Use the archive path. Otherwise, we want to use
+      # the development build path.
+      if version && family
+        if version == family
+          return "http://enterprise.delivery.puppetlabs.net/archives/releases/#{family}/"
+        else
+          return "http://enterprise.delivery.puppetlabs.net/#{family}/ci-ready"
+        end
+      end
+    end
+
+    def fixup_node(cfg)
+      # PE 2.8 doesn't exist for EL 4. We use 2.0 instead.
+      if cfg['platform'] =~ /el-4/ and PE_VERSION =~ /2\.8/
+        cfg['pe_ver'] = "2.0.3"
+      end
+    end
+
+    def dump_hosts(hosts, path)
+      config = {}
+      config.deep_merge! BASE_CONFIG
+      config.deep_merge! VMPOOLER_CONFIG
+
+      hosts.each do |host|
+        config['HOSTS'][host.node_name] = {
+          'roles' => host['roles'],
+          'hypervisor' => "#{host['hypervisor']}",
+          'platform' => "#{host['platform']}",
+        }
+      end
+
+      File.open(path, 'w') do |file|
+        file.write(config.to_yaml)
+      end
+    end
+
+    def get_platforms(hypervisor_type='vmpooler')
+      case hypervisor_type
+      when /vmpooler/
+        osinfo = BeakerHostGenerator::Data::Vmpooler::OSINFO
+      else
+        raise "Invalid hypervisor #{hypervisor_type}"
+      end
+      return osinfo
+    end
+
+    def get_roles
+      return BeakerHostGenerator::Data::ROLES
+    end
+
+    module_function :dump_hosts, :get_platforms, :get_roles, :pe_dir
+  end
+end

data/lib/beaker-hostgenerator/version.rb

@@ -0,0 +1,5 @@
+module BeakerHostGenerator
+  module Version
+    STRING = '0.1.0'
+  end
+end

data/spec/beaker-hostgenerator/generator_spec.rb

@@ -0,0 +1,98 @@
+require 'beaker-hostgenerator'
+require 'spec_helper'
+
+module BeakerHostGenerator
+      describe Generator do
+        let(:options) {
+          {
+            list_platforms_and_roles: false,
+            disable_default_role: false,
+            disable_role_config: false,
+            hypervisor: 'vmpooler',
+          }
+        }
+        let(:generator) { BeakerHostGenerator::Generator.new(options) }
+
+        describe '__generate_host_roles' do
+          it 'Generates a list of roles' do
+            {
+              {
+                "roles" => "aulcdfm",
+                "arbitrary_roles" => [],
+              } => [
+                'agent',
+                'ca',
+                'classifier',
+                'dashboard',
+                'database',
+                'frictionless',
+                'master',
+                ],
+              {
+                "roles" => "a",
+                "arbitrary_roles" => ["meow","hello","compile_master"],
+              } => [
+                'agent',
+                'meow',
+                'hello',
+                'compile_master',
+                ],
+              {
+                "roles" => "",
+                "arbitrary_roles" => ["compile_master"],
+              } => [
+                'compile_master'
+                ],
+              {
+                "roles" => "",
+                "arbitrary_roles" => [],
+              } => [],
+            }.each do |node_info, roles|
+              expect( generator.__generate_host_roles(node_info) ).to eq( roles )
+            end
+          end
+        end
+
+        describe '__parse_node_info_token' do
+
+          it 'Raises InvalidNodeSpecError for invalid tokens.' do
+            expect{ generator.__parse_node_info_token("64compile_master") }.to \
+              raise_error(BeakerHostGenerator::Errors::InvalidNodeSpecError)
+          end
+
+          it 'Supports no roles in the spec.' do
+            node_info = generator.__parse_node_info_token("64")
+            expect( node_info ).to eq({
+              "roles" => "",
+              "arbitrary_roles" => [],
+              "bits" => "64",
+            })
+          end
+
+          it 'Supports the use of arbitrary roles.' do
+            node_info = generator.__parse_node_info_token("64compile_master,ca,blah.mad")
+            expect( node_info ).to eq({
+              "roles" => "mad",
+              "arbitrary_roles" => ["compile_master", "ca", "blah"],
+              "bits" => "64",
+            })
+          end
+
+          context 'When using arbitrary roles'do
+            it 'Fails without a role-type delimiter (a period)' do
+              expect{ generator.__parse_node_info_token("64compile_master,ca,blah") }.to \
+                raise_error(BeakerHostGenerator::Errors::InvalidNodeSpecError)
+            end
+            it 'It supports no static roles.' do
+              node_info = generator.__parse_node_info_token("64compile_master,ca,blah.")
+              expect( node_info ).to eq({
+                "roles" => "",
+                "arbitrary_roles" => ["compile_master", "ca", "blah"],
+                "bits" => "64",
+              })
+            end
+          end
+        end
+
+      end
+end

data/spec/helpers.rb

@@ -0,0 +1,109 @@
+module TestFileHelpers
+  def create_files file_array
+    file_array.each do |f|
+      FileUtils.mkdir_p File.dirname(f)
+      FileUtils.touch f
+    end
+  end
+
+  def fog_file_contents
+    { :default => { :aws_access_key_id => "IMANACCESSKEY",
+                    :aws_secret_access_key => "supersekritkey",
+                    :aix_hypervisor_server => "aix_hypervisor.labs.net",
+                    :aix_hypervisor_username => "aixer",
+                    :aix_hypervisor_keyfile => "/Users/user/.ssh/id_rsa-acceptance",
+                    :solaris_hypervisor_server => "solaris_hypervisor.labs.net",
+                    :solaris_hypervisor_username => "harness",
+                    :solaris_hypervisor_keyfile => "/Users/user/.ssh/id_rsa-old.private",
+                    :solaris_hypervisor_vmpath => "rpoooool/zs",
+                    :solaris_hypervisor_snappaths => ["rpoooool/USER/z0"],
+                    :vsphere_server => "vsphere.labs.net",
+                    :vsphere_username => "vsphere@labs.com",
+                    :vsphere_password => "supersekritpassword"} }
+  end
+
+end
+
+module HostHelpers
+  HOST_DEFAULTS = { :platform => 'unix',
+                    :snapshot => 'pe',
+                    :box => 'box_name',
+                    :roles => ['agent'],
+                    :snapshot => 'snap',
+                    :ip => 'default.ip.address',
+                    :box => 'default_box_name',
+                    :box_url => 'http://default.box.url',
+  }
+
+  HOST_NAME     = "vm%d"
+  HOST_SNAPSHOT = "snapshot%d"
+  HOST_IP       = "ip.address.for.%s"
+  HOST_BOX      = "%s_of_my_box"
+  HOST_BOX_URL  = "http://address.for.my.box.%s"
+  HOST_TEMPLATE = "%s_has_a_template"
+
+  def logger
+    double( 'logger' ).as_null_object
+  end
+
+  def make_opts
+    opts = StringifyHash.new
+    opts.merge( { :logger => logger,
+                                               :host_config => 'sample.config',
+                                               :type => nil,
+                                               :pooling_api => 'http://vcloud.delivery.puppetlabs.net/',
+                                               :datastore => 'instance0',
+                                               :folder => 'Delivery/Quality Assurance/Staging/Dynamic',
+                                               :resourcepool => 'delivery/Quality Assurance/Staging/Dynamic',
+                                               :gce_project => 'beaker-compute',
+                                               :gce_keyfile => '/path/to/keyfile.p12',
+                                               :gce_password => 'notasecret',
+                                               :gce_email => '12345678910@developer.gserviceaccount.com' } )
+  end
+
+  def generate_result (name, opts )
+    result = double( 'result' )
+    stdout = opts.has_key?(:stdout) ? opts[:stdout] : name
+    stderr = opts.has_key?(:stderr) ? opts[:stderr] : name
+    exit_code = opts.has_key?(:exit_code) ? opts[:exit_code] :  0
+    exit_code = [exit_code].flatten
+    allow( result ).to receive( :stdout ).and_return( stdout )
+    allow( result ).to receive( :stderr ).and_return( stderr )
+    allow( result ).to receive( :exit_code ).and_return( *exit_code )
+    result
+  end
+
+  def make_host_opts name, opts
+    make_opts.merge( { 'HOSTS' => { name => opts } } ).merge( opts )
+  end
+
+  def make_host name, host_hash
+    host_hash = StringifyHash.new.merge(HOST_DEFAULTS.merge(host_hash))
+
+    host = make_opts.merge(host_hash)
+
+    allow(host).to receive( :name ).and_return( name )
+    allow(host).to receive( :to_s ).and_return( name )
+    allow(host).to receive( :exec ).and_return( generate_result( name, host_hash ) )
+    host
+  end
+
+  def make_hosts preset_opts = {}, amt = 3
+    hosts = []
+    (1..amt).each do |num|
+      name = HOST_NAME % num
+      opts = { :snapshot => HOST_SNAPSHOT % num,
+               :ip => HOST_IP % name,
+               :template => HOST_TEMPLATE % name,
+               :box => HOST_BOX % name,
+               :box_url => HOST_BOX_URL % name }.merge( preset_opts )
+      hosts << make_host(name, opts)
+    end
+    hosts
+  end
+
+  def make_instance instance_data = {}
+    OpenStruct.new instance_data
+  end
+
+end