puppetlabs/vmpooler-provider-ec2
2
0
Fork 0
mirror of https://github.com/puppetlabs/vmpooler-provider-ec2.git synced 2026-01-26 02:28:40 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

Added aws dependency and renamed directories

Browse source 
rename gce to aws

rename gce to aws

rename gce to aws

create_vm method implimented

create_vm method connected to ec2

setup tags properly, and retireve then in get_vm

begin disk and snapshop, but we dont have perms

add specs for get_vm and vms_in_pool

add spec for create_vm

add spec for destroy_vm

update readme
add a new class lib/vmpooler/aws_setup.rb to do the provisioning of nodes
adding spec tests
adding net:ssh lib for the provisioning of nodes

adding option to provision vm once ready

fix aws_setup

setup of nodes once running
This commit is contained in:
Tanisha Payne 2022-06-09 15:29:54 -04:00 • committed by Samuel Beaulieu
parent 78946ca2b9
commit c3c1a8e1e5
No known key found for this signature in database
GPG key ID: 12030F74136D0F34
21 changed files with 2650 additions and 1 deletions
Download patch file Download diff file Expand all files Collapse all files

110
spec/ec2_helper.rb Normal file
View file

@ -0,0 +1,110 @@
# frozen_string_literal: true
# this file is used to Mock the GCE objects, for example the main ComputeService object
MockResult = Struct.new(
# https://googleapis.dev/ruby/google-api-client/latest/Google/Apis/ComputeV1/Operation.html
:client_operation_id, :creation_timestamp, :description, :end_time, :error, :http_error_message,
:http_error_status_code, :id, :insert_time, :kind, :name, :operation_type, :progress, :region,
:self_link, :start_time, :status, :status_message, :target_id, :target_link, :user, :warnings, :zone,
keyword_init: true
)
MockOperationError = [].freeze
MockOperationErrorError = Struct.new(
# https://googleapis.dev/ruby/google-api-client/latest/Google/Apis/ComputeV1/Operation/Error/Error.html
:code, :location, :message,
keyword_init: true
)
MockInstance = Struct.new(
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/EC2/Instance.html
:instance_type, :launch_time, :private_ip_address, :state, :tags, :zone,
keyword_init: true
)
MockTag = Struct.new(
:key, :value,
keyword_init: true
)
MockInstanceList = Struct.new(
# https://googleapis.dev/ruby/google-api-client/latest/Google/Apis/ComputeV1/InstanceList.html
:id, :items, :kind, :next_page_token, :self_link, :warning,
keyword_init: true
)
MockDiskList = Struct.new(
# https://googleapis.dev/ruby/google-api-client/latest/Google/Apis/ComputeV1/DiskList.html
:id, :items, :kind, :next_page_token, :self_link, :warning,
keyword_init: true
)
MockDisk = Struct.new(
# https://googleapis.dev/ruby/google-api-client/latest/Google/Apis/ComputeV1/Disk.html
:creation_timestamp, :description, :disk_encryption_key, :guest_os_features, :id, :kind, :label_fingerprint, :labels,
:last_attach_timestamp, :last_detach_timestamp, :license_codes, :licenses, :name, :options,
:physical_block_size_bytes, :region, :replica_zones, :resource_policies, :self_link, :size_gb, :source_disk,
:source_disk_id, :source_image, :source_image_encryption_key, :source_image_id, :source_snapshot,
:source_snapshot_encryption_key, :source_snapshot_id, :status, :type, :users, :zone,
keyword_init: true
)
MockSnapshotList = Struct.new(
# https://googleapis.dev/ruby/google-api-client/latest/Google/Apis/ComputeV1/DiskList.html
:id, :items, :kind, :next_page_token, :self_link, :warning,
keyword_init: true
)
MockSnapshot = Struct.new(
# https://googleapis.dev/ruby/google-api-client/latest/Google/Apis/ComputeV1/Snapshot.html
:auto_created, :chain_name, :creation_timestamp, :description, :disk_size_gb, :download_bytes, :id, :kind,
:label_fingerprint, :labels, :license_codes, :licenses, :name, :self_link, :snapshot_encryption_key, :source_disk,
:source_disk_encryption_key, :source_disk_id, :status, :storage_bytes, :storage_bytes_status, :storage_locations,
keyword_init: true
)
MockAttachedDisk = Struct.new(
# https://googleapis.dev/ruby/google-api-client/latest/Google/Apis/ComputeV1/AttachedDisk.html
:auto_delete, :boot, :device_name, :disk_encryption_key, :disk_size_gb, :guest_os_features, :index,
:initialize_params, :interface, :kind, :licenses, :mode, :shielded_instance_initial_state, :source, :type,
keyword_init: true
)
# --------------------
# Main ComputeService Object
# --------------------
MockComputeServiceConnection = Struct.new(
# https://googleapis.dev/ruby/google-api-client/latest/Google/Apis/ComputeV1/ComputeService.html
:key, :quota_user, :user_ip
) do
# Onlly methods we use are listed here
def get_instance
MockInstance.new
end
# Alias to serviceContent.propertyCollector
def insert_instance
MockResult.new
end
end
# -------------------------------------------------------------------------------------------------------------
# Mocking Methods
# -------------------------------------------------------------------------------------------------------------
# def mock_RbVmomi_VIM_ClusterComputeResource(options = {})
# options[:name] = 'Cluster' + rand(65536).to_s if options[:name].nil?
#
# mock = MockClusterComputeResource.new()
#
# mock.name = options[:name]
# # All cluster compute resources have a root Resource Pool
# mock.resourcePool = mock_RbVmomi_VIM_ResourcePool({:name => options[:name]})
#
# allow(mock).to receive(:is_a?) do |expected_type|
# expected_type == RbVmomi::VIM::ClusterComputeResource
# end
#
# mock
# end

153
spec/helpers.rb Normal file
View file

@ -0,0 +1,153 @@
# frozen_string_literal: true
require 'mock_redis'
def redis
@redis ||= MockRedis.new
@redis
end
# Mock an object which represents a Logger. This stops the proliferation
# of allow(logger).to .... expectations in tests.
class MockLogger
def log(_level, string); end
end
def expect_json(ok = true, http = 200)
expect(last_response.header['Content-Type']).to eq('application/json')
if ok == true
expect(JSON.parse(last_response.body)['ok']).to eq(true)
else
expect(JSON.parse(last_response.body)['ok']).to eq(false)
end
expect(last_response.status).to eq(http)
end
def create_token(token, user, timestamp)
redis.hset("vmpooler__token__#{token}", 'user', user)
redis.hset("vmpooler__token__#{token}", 'created', timestamp)
end
def get_token_data(token)
redis.hgetall("vmpooler__token__#{token}")
end
def token_exists?(_token)
result = get_token_data
result && !result.empty?
end
def create_ready_vm(template, name, redis, token = nil)
create_vm(name, redis, token)
redis.sadd("vmpooler__ready__#{template}", name)
redis.hset("vmpooler__vm__#{name}", 'template', template)
end
def create_running_vm(template, name, redis, token = nil, user = nil)
create_vm(name, redis, token, user)
redis.sadd("vmpooler__running__#{template}", name)
redis.hset("vmpooler__vm__#{name}", 'template', template)
redis.hset("vmpooler__vm__#{name}", 'checkout', Time.now)
redis.hset("vmpooler__vm__#{name}", 'host', 'host1')
end
def create_pending_vm(template, name, redis, token = nil)
create_vm(name, redis, token)
redis.sadd("vmpooler__pending__#{template}", name)
redis.hset("vmpooler__vm__#{name}", 'template', template)
end
def create_vm(name, redis, token = nil, user = nil)
redis.hset("vmpooler__vm__#{name}", 'checkout', Time.now)
redis.hset("vmpooler__vm__#{name}", 'clone', Time.now)
redis.hset("vmpooler__vm__#{name}", 'token:token', token) if token
redis.hset("vmpooler__vm__#{name}", 'token:user', user) if user
end
def create_completed_vm(name, pool, redis, active = false)
redis.sadd("vmpooler__completed__#{pool}", name)
redis.hset("vmpooler__vm__#{name}", 'checkout', Time.now)
redis.hset("vmpooler__active__#{pool}", name, Time.now) if active
end
def create_discovered_vm(name, pool, redis)
redis.sadd("vmpooler__discovered__#{pool}", name)
end
def create_migrating_vm(name, pool, redis)
redis.hset("vmpooler__vm__#{name}", 'checkout', Time.now)
redis.sadd("vmpooler__migrating__#{pool}", name)
end
def create_tag(vm, tag_name, tag_value, redis)
redis.hset("vmpooler__vm__#{vm}", "tag:#{tag_name}", tag_value)
end
def add_vm_to_migration_set(name, redis)
redis.sadd('vmpooler__migration', name)
end
def fetch_vm(vm)
redis.hgetall("vmpooler__vm__#{vm}")
end
def set_vm_data(vm, key, value, redis)
redis.hset("vmpooler__vm__#{vm}", key, value)
end
def snapshot_revert_vm(vm, snapshot = '12345678901234567890123456789012', redis)
redis.sadd('vmpooler__tasks__snapshot-revert', "#{vm}:#{snapshot}")
redis.hset("vmpooler__vm__#{vm}", "snapshot:#{snapshot}", '1')
end
def snapshot_vm(vm, snapshot = '12345678901234567890123456789012', redis)
redis.sadd('vmpooler__tasks__snapshot', "#{vm}:#{snapshot}")
redis.hset("vmpooler__vm__#{vm}", "snapshot:#{snapshot}", '1')
end
def disk_task_vm(vm, disk_size = '10', redis)
redis.sadd('vmpooler__tasks__disk', "#{vm}:#{disk_size}")
end
def has_vm_snapshot?(vm, redis)
redis.smembers('vmpooler__tasks__snapshot').any? do |snapshot|
instance, _sha = snapshot.split(':')
vm == instance
end
end
def vm_reverted_to_snapshot?(vm, redis, snapshot = nil)
redis.smembers('vmpooler__tasks__snapshot-revert').any? do |action|
instance, sha = action.split(':')
instance == vm and (snapshot ? (sha == snapshot) : true)
end
end
def pool_has_ready_vm?(pool, vm, redis)
!!redis.sismember("vmpooler__ready__#{pool}", vm)
end
def create_ondemand_request_for_test(request_id, score, platforms_string, redis, user = nil, token = nil)
redis.zadd('vmpooler__provisioning__request', score, request_id)
redis.hset("vmpooler__odrequest__#{request_id}", 'requested', platforms_string)
redis.hset("vmpooler__odrequest__#{request_id}", 'token:token', token) if token
redis.hset("vmpooler__odrequest__#{request_id}", 'token:user', user) if user
end
def set_ondemand_request_status(request_id, status, redis)
redis.hset("vmpooler__odrequest__#{request_id}", 'status', status)
end
def create_ondemand_vm(vmname, request_id, pool, pool_alias, redis)
redis.sadd("vmpooler__#{request_id}__#{pool_alias}__#{pool}", vmname)
end
def create_ondemand_creationtask(request_string, score, redis)
redis.zadd('vmpooler__odcreate__task', score, request_string)
end
def create_ondemand_processing(request_id, score, redis)
redis.zadd('vmpooler__provisioning__processing', score, request_id)
end

19
spec/spec_helper.rb Normal file
View file

@ -0,0 +1,19 @@
# frozen_string_literal: true
require 'simplecov'
SimpleCov.start do
add_filter '/spec/'
end
require 'helpers'
require 'rspec'
require 'vmpooler'
require 'redis'
require 'vmpooler/metrics'
def project_root_dir
File.dirname(File.dirname(__FILE__))
end
def fixtures_dir
File.join(project_root_dir, 'spec', 'fixtures')
end

309
spec/unit/providers/aws_spec.rb Normal file
View file

@ -0,0 +1,309 @@
require 'spec_helper'
require 'mock_redis'
require 'ec2_helper'
require 'vmpooler/providers/aws'
RSpec::Matchers.define :relocation_spec_with_host do |value|
match { |actual| actual[:spec].host == value }
end
describe 'Vmpooler::PoolManager::Provider::Aws' do
let(:logger) { MockLogger.new }
let(:metrics) { Vmpooler::Metrics::DummyStatsd.new }
let(:poolname) { 'debian-9' }
let(:provider_options) { { 'param' => 'value' } }
let(:zone) { 'us-west-2b' }
let(:region) { 'us-west-2'}
let(:config) { YAML.load(<<~EOT
---
:config:
max_tries: 3
retry_factor: 10
:providers:
:aws:
connection_pool_timeout: 1
zone: '#{zone}'
region: '#{region}'
:pools:
- name: '#{poolname}'
alias: [ 'mockpool' ]
amisize: 'a1.large'
template: 'ami-03c1b544a7566b3e5'
size: 5
timeout: 10
ready_ttl: 1440
provider: 'aws'
provision: true
EOT
)
}
let(:vmname) { 'vm17' }
let(:connection) { MockComputeServiceConnection.new }
let(:redis_connection_pool) do
Vmpooler::PoolManager::GenericConnectionPool.new(
metrics: metrics,
connpool_type: 'redis_connection_pool',
connpool_provider: 'testprovider',
size: 1,
timeout: 5
) { MockRedis.new }
end
subject { Vmpooler::PoolManager::Provider::Aws.new(config, logger, metrics, redis_connection_pool, 'aws', provider_options) }
describe '#manual tests live' do
context 'in itsysops' do
before(:each) { allow(subject).to receive(:dns).and_call_original }
let(:vmname) { "instance-46" }
let(:poolname) { "ubuntu-2004-arm64" }
skip 'gets a vm' do
# result = subject.create_vm(poolname, vmname)
subject.provision_node_aws("ip-10-227-4-27.amz-dev.puppet.net", poolname)
# subject.create_snapshot(poolname, vmname, "foo")
#subject.create_disk(poolname, vmname, 10)
# a = subject.destroy_vm(poolname, vmname)
# b = subject.get_vm(poolname, vmname)
puts "done"
# subject.dns_teardown({'name' => vmname})
# subject.dns_setup({'name' => vmname, 'ip' => '1.2.3.5'})
end
end
end
describe '#vms_in_pool' do
let(:pool_config) { config[:pools][0] }
before(:each) do
allow(subject).to receive(:connect_to_aws).and_return(connection)
end
context 'Given an empty pool folder' do
it 'should return an empty array' do
allow(connection).to receive(:instances).and_return([nil])
result = subject.vms_in_pool(poolname)
expect(result).to eq([])
end
end
context 'Given a pool with many VMs' do
let(:expected_vm_list) do
[
{ 'name' => 'vm1' },
{ 'name' => 'vm2' },
{ 'name' => 'vm3' }
]
end
before(:each) do
instance_list = []
expected_vm_list.each do |vm_hash|
tags = [MockTag.new(key: "vm_name", value: vm_hash['name'])]
mock_vm = MockInstance.new(tags: tags)
instance_list << mock_vm
end
expect(connection).to receive(:instances).and_return(instance_list)
end
it 'should list all VMs in the VM folder for the pool' do
result = subject.vms_in_pool(poolname)
expect(result).to eq(expected_vm_list)
end
end
end
describe '#get_vm' do
before(:each) do
allow(subject).to receive(:connect_to_aws).and_return(connection)
end
context 'when VM does not exist' do
it 'should return nil' do
allow(connection).to receive(:instances).and_return([nil])
expect(subject.get_vm(poolname, vmname)).to be_nil
end
end
context 'when VM exists but is missing information' do
before(:each) do
tags = [MockTag.new(key: "vm_name", value: vmname)]
allow(connection).to receive(:instances).and_return([MockInstance.new(tags: tags)])
end
it 'should return a hash' do
expect(subject.get_vm(poolname, vmname)).to be_kind_of(Hash)
end
it 'should return the VM name' do
result = subject.get_vm(poolname, vmname)
expect(result['name']).to eq(vmname)
end
%w[boottime image_size status private_ip_address].each do |testcase|
it "should return nil for #{testcase}" do
result = subject.get_vm(poolname, vmname)
expect(result[testcase]).to be_nil
end
end
end
context 'when VM exists and contains all information' do
let(:vm_hostname) { "#{vmname}.demo.local" }
let(:boot_time) { Time.now }
let(:vm_object) do
state = Struct.new(:name)
runningstate = state.new "running"
MockInstance.new(
launch_time: boot_time,
state: runningstate,
instance_type: "a1.large",
private_ip_address: "1.1.1.1",
tags: [
MockTag.new(key: "vm_name", value: vmname),
MockTag.new(key: "pool", value: poolname)
]
)
end
let(:pool_info) { config[:pools][0] }
before(:each) do
allow(connection).to receive(:instances).and_return([vm_object])
end
it 'should return a hash' do
expect(subject.get_vm(poolname, vmname)).to be_kind_of(Hash)
end
it 'should return the VM name' do
result = subject.get_vm(poolname, vmname)
expect(result['name']).to eq(vmname)
end
it 'should return the template name' do
result = subject.get_vm(poolname, vmname)
expect(result['template']).to eq(pool_info['template'])
end
it 'should return the pool name' do
result = subject.get_vm(poolname, vmname)
expect(result['poolname']).to eq(pool_info['name'])
end
it 'should return the boot time' do
result = subject.get_vm(poolname, vmname)
expect(result['boottime']).to eq(boot_time)
end
it 'should return the status' do
result = subject.get_vm(poolname, vmname)
expect(result['status']).to eq("running")
end
it 'should return the status' do
result = subject.get_vm(poolname, vmname)
expect(result['image_size']).to eq("a1.large")
end
end
end
describe '#create_vm' do
before(:each) do
allow(subject).to receive(:connect_to_aws).and_return(connection)
end
context 'Given an invalid pool name' do
it 'should raise an error' do
expect { subject.create_vm('missing_pool', vmname) }.to raise_error(/missing_pool does not exist/)
end
end
context 'Given a vmname that already exists' do
before(:each) do
allow(subject).to receive(:get_vm).and_return({
'name' => "foobar",
'template' => "abc",
'status' => "running"
})
end
it 'should raise an error' do
expect { subject.create_vm(poolname, vmname) }.to raise_error(/Instance creation not attempted, .* already exists/)
end
end
context 'Given a successful creation' do
let(:client) { double }
before(:each) do
allow(subject).to receive(:get_vm).and_return(nil,{
'name' => vmname,
'template' => "abc",
'status' => "running"
})
result = Struct.new(:instance_id)
batch_instance = result.new(instance_id: "abcfoo")
allow(connection).to receive(:create_instances).and_return([batch_instance])
allow(connection).to receive(:client).and_return(client)
allow(client).to receive(:wait_until)
end
it 'should return a hash' do
result = subject.create_vm(poolname, vmname)
expect(result.is_a?(Hash)).to be true
end
it 'should have the new VM name' do
result = subject.create_vm(poolname, vmname)
expect(result['name']).to eq(vmname)
end
end
end
describe '#destroy_vm' do
before(:each) do
allow(subject).to receive(:connect_to_aws).and_return(connection)
end
context 'Given a missing VM name' do
let(:client) { double }
before(:each) do
allow(connection).to receive(:instances).and_return([nil])
allow(connection).to receive(:client).and_return(client)
allow(client).to receive(:wait_until)
end
it 'should return true' do
expect(subject.destroy_vm(poolname, 'missing_vm')).to be true
end
end
context 'Given a running VM' do
let(:instance) { double("instance") }
let(:client) { double }
before(:each) do
allow(connection).to receive(:instances).and_return([instance])
expect(instance).to receive(:terminate)
allow(connection).to receive(:client).and_return(client)
allow(client).to receive(:wait_until)
allow(instance).to receive(:id)
end
it 'should return true' do
expect(subject.destroy_vm(poolname, vmname)).to be true
end
end
end
end

767
spec/unit/providers/gce_spec.rb Normal file
View file

@ -0,0 +1,767 @@
require 'spec_helper'
require 'mock_redis'
require 'vmpooler/providers/gce'
RSpec::Matchers.define :relocation_spec_with_host do |value|
match { |actual| actual[:spec].host == value }
end
describe 'Vmpooler::PoolManager::Provider::Gce' do
let(:logger) { MockLogger.new }
let(:metrics) { Vmpooler::Metrics::DummyStatsd.new }
let(:poolname) { 'debian-9' }
let(:provider_options) { { 'param' => 'value' } }
let(:project) { 'vmpooler-test' }
let(:zone) { 'us-west1-b' }
let(:config) { YAML.load(<<~EOT
---
:config:
max_tries: 3
retry_factor: 10
:providers:
:gce:
connection_pool_timeout: 1
project: '#{project}'
zone: '#{zone}'
network_name: global/networks/default
:pools:
- name: '#{poolname}'
alias: [ 'mockpool' ]
template: 'projects/debian-cloud/global/images/family/debian-9'
size: 5
timeout: 10
ready_ttl: 1440
provider: 'gce'
machine_type: 'zones/#{zone}/machineTypes/e2-micro'
EOT
)
}
let(:vmname) { 'vm17' }
let(:connection) { MockComputeServiceConnection.new }
let(:redis_connection_pool) do
Vmpooler::PoolManager::GenericConnectionPool.new(
metrics: metrics,
connpool_type: 'redis_connection_pool',
connpool_provider: 'testprovider',
size: 1,
timeout: 5
) { MockRedis.new }
end
subject { Vmpooler::PoolManager::Provider::Gce.new(config, logger, metrics, redis_connection_pool, 'gce', provider_options) }
before(:each) { allow(subject).to receive(:dns).and_return(MockDNS.new()) }
describe '#name' do
it 'should be gce' do
expect(subject.name).to eq('gce')
end
end
describe '#manual tests live' do
context 'in itsysops' do
before(:each) { allow(subject).to receive(:dns).and_call_original }
let(:vmname) { "instance-24" }
let(:project) { 'vmpooler-test' }
let(:config) { YAML.load(<<~EOT
---
:config:
max_tries: 3
retry_factor: 10
:providers:
:gce:
connection_pool_timeout: 1
project: '#{project}'
zone: '#{zone}'
network_name: 'projects/itsysopsnetworking/global/networks/shared1'
dns_zone_resource_name: 'test-vmpooler-puppet-net'
domain: 'test.vmpooler.puppet.net'
:pools:
- name: '#{poolname}'
alias: [ 'mockpool' ]
template: 'projects/debian-cloud/global/images/family/debian-9'
size: 5
timeout: 10
ready_ttl: 1440
provider: 'gce'
subnetwork_name: 'projects/itsysopsnetworking/regions/us-west1/subnetworks/vmpooler-test'
machine_type: 'zones/#{zone}/machineTypes/e2-micro'
EOT
) }
skip 'gets a vm' do
result = subject.create_vm(poolname, vmname)
#result = subject.destroy_vm(poolname, vmname)
subject.get_vm(poolname, vmname)
#subject.dns_teardown({'name' => vmname})
# subject.dns_setup({'name' => vmname, 'ip' => '1.2.3.5'})
end
end
end
describe '#vms_in_pool' do
let(:pool_config) { config[:pools][0] }
before(:each) do
allow(subject).to receive(:connect_to_gce).and_return(connection)
end
context 'Given an empty pool folder' do
it 'should return an empty array' do
instance_list = MockInstanceList.new(items: nil)
allow(connection).to receive(:list_instances).and_return(instance_list)
result = subject.vms_in_pool(poolname)
expect(result).to eq([])
end
end
context 'Given a pool folder with many VMs' do
let(:expected_vm_list) do
[
{ 'name' => 'vm1' },
{ 'name' => 'vm2' },
{ 'name' => 'vm3' }
]
end
before(:each) do
instance_list = MockInstanceList.new(items: [])
expected_vm_list.each do |vm_hash|
mock_vm = MockInstance.new(name: vm_hash['name'])
instance_list.items << mock_vm
end
expect(connection).to receive(:list_instances).and_return(instance_list)
end
it 'should list all VMs in the VM folder for the pool' do
result = subject.vms_in_pool(poolname)
expect(result).to eq(expected_vm_list)
end
end
end
describe '#get_vm' do
before(:each) do
allow(subject).to receive(:connect_to_gce).and_return(connection)
end
context 'when VM does not exist' do
it 'should return nil' do
allow(connection).to receive(:get_instance).and_raise(create_google_client_error(404, "The resource 'projects/#{project}/zones/#{zone}/instances/#{vmname}' was not found"))
expect(subject.get_vm(poolname, vmname)).to be_nil
end
end
context 'when VM exists but is missing information' do
before(:each) do
allow(connection).to receive(:get_instance).and_return(MockInstance.new(name: vmname))
end
it 'should return a hash' do
expect(subject.get_vm(poolname, vmname)).to be_kind_of(Hash)
end
it 'should return the VM name' do
result = subject.get_vm(poolname, vmname)
expect(result['name']).to eq(vmname)
end
%w[hostname boottime zone status].each do |testcase|
it "should return nil for #{testcase}" do
result = subject.get_vm(poolname, vmname)
expect(result[testcase]).to be_nil
end
end
end
context 'when VM exists and contains all information' do
let(:vm_hostname) { "#{vmname}.demo.local" }
let(:boot_time) { Time.now }
let(:vm_object) do
MockInstance.new(
name: vmname,
hostname: vm_hostname,
labels: { 'pool' => poolname },
creation_timestamp: boot_time,
status: 'RUNNING',
zone: zone,
machine_type: "zones/#{zone}/machineTypes/e2-micro"
)
end
let(:pool_info) { config[:pools][0] }
before(:each) do
allow(connection).to receive(:get_instance).and_return(vm_object)
end
it 'should return a hash' do
expect(subject.get_vm(poolname, vmname)).to be_kind_of(Hash)
end
it 'should return the VM name' do
result = subject.get_vm(poolname, vmname)
expect(result['name']).to eq(vmname)
end
it 'should return the VM hostname' do
result = subject.get_vm(poolname, vmname)
expect(result['hostname']).to eq(vm_hostname)
end
it 'should return the template name' do
result = subject.get_vm(poolname, vmname)
expect(result['template']).to eq(pool_info['template'])
end
it 'should return the pool name' do
result = subject.get_vm(poolname, vmname)
expect(result['poolname']).to eq(pool_info['name'])
end
it 'should return the boot time' do
result = subject.get_vm(poolname, vmname)
expect(result['boottime']).to eq(boot_time)
end
end
end
describe '#create_vm' do
before(:each) do
allow(subject).to receive(:connect_to_gce).and_return(connection)
end
context 'Given an invalid pool name' do
it 'should raise an error' do
expect { subject.create_vm('missing_pool', vmname) }.to raise_error(/missing_pool does not exist/)
end
end
context 'Given a template VM that does not exist' do
before(:each) do
config[:pools][0]['template'] = 'Templates/missing_template'
# result = MockResult.new
# result.status = "PENDING"
# errors = MockOperationError
# errors << MockOperationErrorError.new(code: "foo", message: "it's missing")
# result.error = errors
allow(connection).to receive(:insert_instance).and_raise(create_google_client_error(404, 'The resource \'Templates/missing_template\' was not found'))
end
it 'should raise an error' do
expect { subject.create_vm(poolname, vmname) }.to raise_error(Google::Apis::ClientError)
end
end
context 'Given a successful creation' do
before(:each) do
result = MockResult.new
result.status = 'DONE'
allow(connection).to receive(:insert_instance).and_return(result)
end
it 'should return a hash' do
allow(connection).to receive(:get_instance).and_return(MockInstance.new)
result = subject.create_vm(poolname, vmname)
expect(result.is_a?(Hash)).to be true
end
it 'should have the new VM name' do
instance = MockInstance.new(name: vmname)
allow(connection).to receive(:get_instance).and_return(instance)
result = subject.create_vm(poolname, vmname)
expect(result['name']).to eq(vmname)
end
end
end
describe '#destroy_vm' do
before(:each) do
allow(subject).to receive(:connect_to_gce).and_return(connection)
end
context 'Given a missing VM name' do
before(:each) do
allow(connection).to receive(:get_instance).and_raise(create_google_client_error(404, "The resource 'projects/#{project}/zones/#{zone}/instances/#{vmname}' was not found"))
disk_list = MockDiskList.new(items: nil)
allow(connection).to receive(:list_disks).and_return(disk_list)
allow(subject).to receive(:find_all_snapshots).and_return(nil)
end
it 'should return true' do
expect(connection.should_receive(:delete_instance).never)
expect(subject.destroy_vm(poolname, 'missing_vm')).to be true
end
end
context 'Given a running VM' do
before(:each) do
instance = MockInstance.new(name: vmname)
allow(connection).to receive(:get_instance).and_return(instance)
result = MockResult.new
result.status = 'DONE'
allow(subject).to receive(:wait_for_operation).and_return(result)
allow(connection).to receive(:delete_instance).and_return(result)
end
it 'should return true' do
# no dangling disks
disk_list = MockDiskList.new(items: nil)
allow(connection).to receive(:list_disks).and_return(disk_list)
# no dangling snapshots
allow(subject).to receive(:find_all_snapshots).and_return(nil)
expect(subject.destroy_vm(poolname, vmname)).to be true
end
it 'should delete any dangling disks' do
disk = MockDisk.new(name: vmname)
disk_list = MockDiskList.new(items: [disk])
allow(connection).to receive(:list_disks).and_return(disk_list)
# no dangling snapshots
allow(subject).to receive(:find_all_snapshots).and_return(nil)
expect(connection).to receive(:delete_disk).with(project, zone, disk.name)
subject.destroy_vm(poolname, vmname)
end
it 'should delete any dangling snapshots' do
# no dangling disks
disk_list = MockDiskList.new(items: nil)
allow(connection).to receive(:list_disks).and_return(disk_list)
snapshot = MockSnapshot.new(name: "snapshotname-#{vmname}")
allow(subject).to receive(:find_all_snapshots).and_return([snapshot])
expect(connection).to receive(:delete_snapshot).with(project, snapshot.name)
subject.destroy_vm(poolname, vmname)
end
end
end
describe '#vm_ready?' do
let(:domain) { nil }
context 'When a VM is ready' do
before(:each) do
expect(subject).to receive(:open_socket).with(vmname, domain)
end
it 'should return true' do
expect(subject.vm_ready?(poolname, vmname)).to be true
end
end
context 'When an error occurs connecting to the VM' do
before(:each) do
expect(subject).to receive(:open_socket).and_raise(RuntimeError, 'MockError')
end
it 'should return false' do
expect(subject.vm_ready?(poolname, vmname)).to be false
end
end
end
describe '#create_disk' do
let(:disk_size) { 10 }
before(:each) do
allow(subject).to receive(:connect_to_gce).and_return(connection)
end
context 'Given an invalid pool name' do
it 'should raise an error' do
expect { subject.create_disk('missing_pool', vmname, disk_size) }.to raise_error(/missing_pool does not exist/)
end
end
context 'when VM does not exist' do
before(:each) do
expect(connection).to receive(:get_instance).and_raise(create_google_client_error(404, "The resource 'projects/#{project}/zones/#{zone}/instances/#{vmname}' was not found"))
end
it 'should raise an error' do
expect { subject.create_disk(poolname, vmname, disk_size) }.to raise_error(/VM #{vmname} .+ does not exist/)
end
end
context 'when adding the disk raises an error' do
before(:each) do
disk = MockDisk.new(name: vmname)
instance = MockInstance.new(name: vmname, disks: [disk])
allow(connection).to receive(:get_instance).and_return(instance)
expect(connection).to receive(:insert_disk).and_raise(RuntimeError, 'Mock Disk Error')
end
it 'should raise an error' do
expect { subject.create_disk(poolname, vmname, disk_size) }.to raise_error(/Mock Disk Error/)
end
end
context 'when adding the disk succeeds' do
before(:each) do
disk = MockDisk.new(name: vmname)
instance = MockInstance.new(name: vmname, disks: [disk])
allow(connection).to receive(:get_instance).and_return(instance)
result = MockResult.new
result.status = 'DONE'
allow(connection).to receive(:insert_disk).and_return(result)
allow(subject).to receive(:wait_for_operation).and_return(result)
new_disk = MockDisk.new(name: "#{vmname}-disk1", self_link: "/foo/bar/baz/#{vmname}-disk1")
allow(connection).to receive(:get_disk).and_return(new_disk)
allow(connection).to receive(:attach_disk).and_return(result)
end
it 'should return true' do
expect(subject.create_disk(poolname, vmname, disk_size)).to be true
end
end
end
describe '#create_snapshot' do
let(:snapshot_name) { 'snapshot' }
before(:each) do
allow(subject).to receive(:connect_to_gce).and_return(connection)
end
context 'when VM does not exist' do
before(:each) do
allow(connection).to receive(:get_instance).and_raise(create_google_client_error(404, "The resource 'projects/#{project}/zones/#{zone}/instances/#{vmname}' was not found"))
end
it 'should raise an error' do
expect { subject.create_snapshot(poolname, vmname, snapshot_name) }.to raise_error(/VM #{vmname} .+ does not exist/)
end
end
context 'when snapshot already exists' do
it 'should raise an error' do
disk = MockDisk.new(name: vmname)
instance = MockInstance.new(name: vmname, disks: [disk])
allow(connection).to receive(:get_instance).and_return(instance)
snapshots = [MockSnapshot.new(name: snapshot_name)]
allow(subject).to receive(:find_snapshot).and_return(snapshots)
expect { subject.create_snapshot(poolname, vmname, snapshot_name) }.to raise_error(/Snapshot #{snapshot_name} .+ already exists /)
end
end
context 'when snapshot raises an error' do
before(:each) do
attached_disk = MockAttachedDisk.new(device_name: vmname, source: "foo/bar/baz/#{vmname}")
instance = MockInstance.new(name: vmname, disks: [attached_disk])
allow(connection).to receive(:get_instance).and_return(instance)
snapshots = nil
allow(subject).to receive(:find_snapshot).and_return(snapshots)
allow(connection).to receive(:create_disk_snapshot).and_raise(RuntimeError, 'Mock Snapshot Error')
end
it 'should raise an error' do
expect { subject.create_snapshot(poolname, vmname, snapshot_name) }.to raise_error(/Mock Snapshot Error/)
end
end
context 'when snapshot succeeds' do
before(:each) do
attached_disk = MockAttachedDisk.new(device_name: vmname, source: "foo/bar/baz/#{vmname}")
instance = MockInstance.new(name: vmname, disks: [attached_disk])
allow(connection).to receive(:get_instance).and_return(instance)
snapshots = nil
allow(subject).to receive(:find_snapshot).and_return(snapshots)
result = MockResult.new
result.status = 'DONE'
allow(connection).to receive(:create_disk_snapshot).and_return(result)
end
it 'should return true' do
expect(subject.create_snapshot(poolname, vmname, snapshot_name)).to be true
end
it 'should snapshot each attached disk' do
attached_disk = MockAttachedDisk.new(device_name: vmname, source: "foo/bar/baz/#{vmname}")
attached_disk2 = MockAttachedDisk.new(device_name: vmname, source: "foo/bar/baz/#{vmname}-disk1")
instance = MockInstance.new(name: vmname, disks: [attached_disk, attached_disk2])
allow(connection).to receive(:get_instance).and_return(instance)
expect(connection.should_receive(:create_disk_snapshot).twice)
subject.create_snapshot(poolname, vmname, snapshot_name)
end
end
end
describe '#revert_snapshot' do
let(:snapshot_name) { 'snapshot' }
before(:each) do
allow(subject).to receive(:connect_to_gce).and_return(connection)
end
context 'when VM does not exist' do
before(:each) do
allow(connection).to receive(:get_instance).and_raise(create_google_client_error(404, "The resource 'projects/#{project}/zones/#{zone}/instances/#{vmname}' was not found"))
end
it 'should raise an error' do
expect { subject.revert_snapshot(poolname, vmname, snapshot_name) }.to raise_error(/VM #{vmname} .+ does not exist/)
end
end
context 'when snapshot does not exist' do
it 'should raise an error' do
attached_disk = MockAttachedDisk.new(device_name: vmname, source: "foo/bar/baz/#{vmname}")
instance = MockInstance.new(name: vmname, disks: [attached_disk])
allow(connection).to receive(:get_instance).and_return(instance)
snapshots = nil
allow(subject).to receive(:find_snapshot).and_return(snapshots)
expect { subject.revert_snapshot(poolname, vmname, snapshot_name) }.to raise_error(/Snapshot #{snapshot_name} .+ does not exist /)
end
end
context 'when instance does not have attached disks' do
it 'should skip detaching/deleting disk' do
instance = MockInstance.new(name: vmname, disks: nil)
allow(connection).to receive(:get_instance).and_return(instance)
snapshots = []
allow(subject).to receive(:find_snapshot).and_return(snapshots)
allow(connection).to receive(:stop_instance)
allow(subject).to receive(:wait_for_operation)
allow(connection).to receive(:start_instance)
expect(subject).not_to receive(:detach_disk)
expect(subject).not_to receive(:delete_disk)
subject.revert_snapshot(poolname, vmname, snapshot_name)
end
end
context 'when revert to snapshot raises an error' do
before(:each) do
attached_disk = MockAttachedDisk.new(device_name: vmname, source: "foo/bar/baz/#{vmname}")
instance = MockInstance.new(name: vmname, disks: [attached_disk])
allow(connection).to receive(:get_instance).and_return(instance)
snapshots = [MockSnapshot.new(name: snapshot_name)]
allow(subject).to receive(:find_snapshot).and_return(snapshots)
allow(connection).to receive(:stop_instance)
allow(subject).to receive(:wait_for_operation)
expect(connection).to receive(:detach_disk).and_raise(RuntimeError, 'Mock Snapshot Error')
end
it 'should raise an error' do
expect { subject.revert_snapshot(poolname, vmname, snapshot_name) }.to raise_error(/Mock Snapshot Error/)
end
end
context 'when revert to snapshot succeeds' do
before(:each) do
attached_disk = MockAttachedDisk.new(device_name: vmname, source: "foo/bar/baz/#{vmname}")
instance = MockInstance.new(name: vmname, disks: [attached_disk])
allow(connection).to receive(:get_instance).and_return(instance)
snapshots = [MockSnapshot.new(name: snapshot_name, self_link: "foo/bar/baz/snapshot/#{snapshot_name}", labels: { 'diskname' => vmname })]
allow(subject).to receive(:find_snapshot).and_return(snapshots)
allow(connection).to receive(:stop_instance)
allow(subject).to receive(:wait_for_operation)
allow(connection).to receive(:detach_disk)
allow(connection).to receive(:delete_disk)
new_disk = MockDisk.new(name: vmname, self_link: "foo/bar/baz/disk/#{vmname}")
allow(connection).to receive(:insert_disk)
allow(connection).to receive(:get_disk).and_return(new_disk)
allow(connection).to receive(:attach_disk)
allow(connection).to receive(:start_instance)
end
it 'should return true' do
expect(subject.revert_snapshot(poolname, vmname, snapshot_name)).to be true
end
end
end
describe '#purge_unconfigured_resources' do
let(:empty_list) { [] }
before(:each) do
allow(subject).to receive(:connect_to_gce).and_return(connection)
end
context 'with empty allowlist' do
before(:each) do
allow(subject).to receive(:wait_for_zone_operation)
end
it 'should attempt to delete unconfigured instances when they dont have a label' do
instance_list = MockInstanceList.new(items: [MockInstance.new(name: 'foo')])
disk_list = MockDiskList.new(items: nil)
snapshot_list = MockSnapshotList.new(items: nil)
# the instance_list is filtered in the real code, and should only return non-configured VMs based on labels
# that do not match a real pool name
allow(connection).to receive(:list_instances).and_return(instance_list)
allow(connection).to receive(:list_disks).and_return(disk_list)
allow(connection).to receive(:list_snapshots).and_return(snapshot_list)
expect(connection).to receive(:delete_instance)
subject.purge_unconfigured_resources(nil)
end
it 'should attempt to delete unconfigured instances when they have a label that is not a configured pool' do
instance_list = MockInstanceList.new(items: [MockInstance.new(name: 'foo', labels: { 'pool' => 'foobar' })])
disk_list = MockDiskList.new(items: nil)
snapshot_list = MockSnapshotList.new(items: nil)
allow(connection).to receive(:list_instances).and_return(instance_list)
allow(connection).to receive(:list_disks).and_return(disk_list)
allow(connection).to receive(:list_snapshots).and_return(snapshot_list)
expect(connection).to receive(:delete_instance)
subject.purge_unconfigured_resources(nil)
end
it 'should attempt to delete unconfigured disks and snapshots when they do not have a label' do
instance_list = MockInstanceList.new(items: nil)
disk_list = MockDiskList.new(items: [MockDisk.new(name: 'diskfoo')])
snapshot_list = MockSnapshotList.new(items: [MockSnapshot.new(name: 'snapfoo')])
allow(connection).to receive(:list_instances).and_return(instance_list)
allow(connection).to receive(:list_disks).and_return(disk_list)
allow(connection).to receive(:list_snapshots).and_return(snapshot_list)
expect(connection).to receive(:delete_disk)
expect(connection).to receive(:delete_snapshot)
subject.purge_unconfigured_resources(nil)
end
end
context 'with allowlist containing a pool name' do
before(:each) do
allow(subject).to receive(:wait_for_zone_operation)
$allowlist = ['allowed']
end
it 'should attempt to delete unconfigured instances when they dont have the allowlist label' do
instance_list = MockInstanceList.new(items: [MockInstance.new(name: 'foo', labels: { 'pool' => 'not_this' })])
disk_list = MockDiskList.new(items: nil)
snapshot_list = MockSnapshotList.new(items: nil)
allow(connection).to receive(:list_instances).and_return(instance_list)
allow(connection).to receive(:list_disks).and_return(disk_list)
allow(connection).to receive(:list_snapshots).and_return(snapshot_list)
expect(connection).to receive(:delete_instance)
subject.purge_unconfigured_resources($allowlist)
end
it 'should ignore unconfigured instances when they have a label that is allowed' do
instance_list = MockInstanceList.new(items: [MockInstance.new(name: 'foo', labels: { 'pool' => 'allowed' })])
disk_list = MockDiskList.new(items: nil)
snapshot_list = MockSnapshotList.new(items: nil)
allow(connection).to receive(:list_instances).and_return(instance_list)
allow(connection).to receive(:list_disks).and_return(disk_list)
allow(connection).to receive(:list_snapshots).and_return(snapshot_list)
expect(connection).not_to receive(:delete_instance)
subject.purge_unconfigured_resources($allowlist)
end
it 'should ignore unconfigured disks and snapshots when they have a label that is allowed' do
instance_list = MockInstanceList.new(items: nil)
disk_list = MockDiskList.new(items: [MockDisk.new(name: 'diskfoo', labels: { 'pool' => 'allowed' })])
snapshot_list = MockSnapshotList.new(items: [MockSnapshot.new(name: 'snapfoo', labels: { 'pool' => 'allowed' })])
allow(connection).to receive(:list_instances).and_return(instance_list)
allow(connection).to receive(:list_disks).and_return(disk_list)
allow(connection).to receive(:list_snapshots).and_return(snapshot_list)
expect(connection).not_to receive(:delete_disk)
expect(connection).not_to receive(:delete_snapshot)
subject.purge_unconfigured_resources($allowlist)
end
it 'should ignore unconfigured item when they have the empty label that is allowed, which means we allow the pool label to not be set' do
$allowlist = ['allowed', '']
instance_list = MockInstanceList.new(items: [MockInstance.new(name: 'foo', labels: { 'some' => 'not_important' })])
disk_list = MockDiskList.new(items: [MockDisk.new(name: 'diskfoo', labels: { 'other' => 'thing' })])
snapshot_list = MockSnapshotList.new(items: [MockSnapshot.new(name: 'snapfoo')])
allow(connection).to receive(:list_instances).and_return(instance_list)
allow(connection).to receive(:list_disks).and_return(disk_list)
allow(connection).to receive(:list_snapshots).and_return(snapshot_list)
expect(connection).not_to receive(:delete_instance)
expect(connection).not_to receive(:delete_disk)
expect(connection).not_to receive(:delete_snapshot)
subject.purge_unconfigured_resources($allowlist)
end
end
context 'with allowlist containing a pool name and the empty string' do
before(:each) do
allow(subject).to receive(:wait_for_zone_operation)
$allowlist = ['allowed', '']
end
it 'should attempt to delete unconfigured instances when they dont have the allowlist label' do
instance_list = MockInstanceList.new(items: [MockInstance.new(name: 'foo', labels: { 'pool' => 'not_this' })])
disk_list = MockDiskList.new(items: nil)
snapshot_list = MockSnapshotList.new(items: nil)
allow(connection).to receive(:list_instances).and_return(instance_list)
allow(connection).to receive(:list_disks).and_return(disk_list)
allow(connection).to receive(:list_snapshots).and_return(snapshot_list)
expect(connection).to receive(:delete_instance)
subject.purge_unconfigured_resources($allowlist)
end
it 'should ignore unconfigured disks and snapshots when they have a label that is allowed' do
instance_list = MockInstanceList.new(items: nil)
disk_list = MockDiskList.new(items: [MockDisk.new(name: 'diskfoo', labels: { 'pool' => 'allowed' })])
snapshot_list = MockSnapshotList.new(items: [MockSnapshot.new(name: 'snapfoo', labels: { 'pool' => 'allowed' })])
allow(connection).to receive(:list_instances).and_return(instance_list)
allow(connection).to receive(:list_disks).and_return(disk_list)
allow(connection).to receive(:list_snapshots).and_return(snapshot_list)
expect(connection).not_to receive(:delete_disk)
expect(connection).not_to receive(:delete_snapshot)
subject.purge_unconfigured_resources($allowlist)
end
it 'should ignore unconfigured item when they have the empty label that is allowed, which means we allow the pool label to not be set' do
instance_list = MockInstanceList.new(items: [MockInstance.new(name: 'foo', labels: { 'some' => 'not_important' })])
disk_list = MockDiskList.new(items: [MockDisk.new(name: 'diskfoo', labels: { 'other' => 'thing' })])
snapshot_list = MockSnapshotList.new(items: [MockSnapshot.new(name: 'snapfoo')])
allow(connection).to receive(:list_instances).and_return(instance_list)
allow(connection).to receive(:list_disks).and_return(disk_list)
allow(connection).to receive(:list_snapshots).and_return(snapshot_list)
expect(connection).not_to receive(:delete_instance)
expect(connection).not_to receive(:delete_disk)
expect(connection).not_to receive(:delete_snapshot)
subject.purge_unconfigured_resources($allowlist)
end
end
context 'with allowlist containing a a fully qualified label that is not pool' do
before(:each) do
allow(subject).to receive(:wait_for_zone_operation)
$allowlist = ['user=Bob']
end
it 'should attempt to delete unconfigured instances when they dont have the allowlist label' do
instance_list = MockInstanceList.new(items: [MockInstance.new(name: 'foo', labels: { 'pool' => 'not_this' })])
disk_list = MockDiskList.new(items: nil)
snapshot_list = MockSnapshotList.new(items: nil)
allow(connection).to receive(:list_instances).and_return(instance_list)
allow(connection).to receive(:list_disks).and_return(disk_list)
allow(connection).to receive(:list_snapshots).and_return(snapshot_list)
expect(connection).to receive(:delete_instance)
subject.purge_unconfigured_resources($allowlist)
end
it 'should ignore unconfigured item when they match the fully qualified label' do
instance_list = MockInstanceList.new(items: [MockInstance.new(name: 'foo', labels: { 'some' => 'not_important', 'user' => 'bob' })])
disk_list = MockDiskList.new(items: [MockDisk.new(name: 'diskfoo', labels: { 'other' => 'thing', 'user' => 'bob' })])
snapshot_list = MockSnapshotList.new(items: [MockSnapshot.new(name: 'snapfoo', labels: { 'user' => 'bob' })])
allow(connection).to receive(:list_instances).and_return(instance_list)
allow(connection).to receive(:list_disks).and_return(disk_list)
allow(connection).to receive(:list_snapshots).and_return(snapshot_list)
expect(connection).not_to receive(:delete_instance)
expect(connection).not_to receive(:delete_disk)
expect(connection).not_to receive(:delete_snapshot)
subject.purge_unconfigured_resources($allowlist)
end
end
it 'should raise any errors' do
expect(subject).to receive(:provided_pools).and_throw('mockerror')
expect { subject.purge_unconfigured_resources(nil) }.to raise_error(/mockerror/)
end
end
describe '#get_current_user' do
it 'should downcase and replace invalid chars with dashes' do
redis_connection_pool.with_metrics do |redis|
redis.hset("vmpooler__vm__#{vmname}", 'token:user', 'BOBBY.PUPPET')
expect(subject.get_current_user(vmname)).to eq('bobby-puppet')
end
end
it 'returns "" for nil values' do
redis_connection_pool.with_metrics do |_redis|
expect(subject.get_current_user(vmname)).to eq('')
end
end
end
end

9
spec/vmpooler-provider-aws/vmpooler_provider_aws_spec.rb Normal file
View file

@ -0,0 +1,9 @@
require 'rspec'
describe 'VmpoolerProviderAws' do
context 'when creating class ' do
it 'sets a version' do
expect(VmpoolerProviderAws::VERSION).not_to be_nil
end
end
end