vm_shepherd 1.11.0 → 1.11.1

data/lib/vm_shepherd/vcloud/destroyer.rb

@@ -2,7 +2,7 @@ module VmShepherd
   module Vcloud
     class Destroyer
       def initialize(client:, vdc_name:)
-        @client = client
+        @client   = client
         @vdc_name = vdc_name
       end
 

data/lib/vm_shepherd/vcloud/vapp_config.rb

@@ -5,12 +5,12 @@ module VmShepherd
       attr_reader :name, :gateway, :dns, :ntp, :ip, :netmask, :catalog, :network
 
       def initialize(name:, ip:, gateway:, netmask:, dns:, ntp:, catalog:, network:)
-        @name = name
-        @ip = ip
+        @name    = name
+        @ip      = ip
         @gateway = gateway
         @netmask = netmask
-        @dns = dns
-        @ntp = ntp
+        @dns     = dns
+        @ntp     = ntp
         @catalog = catalog
         @network = network
       end
@@ -18,58 +18,58 @@ module VmShepherd
       def build_properties
         [
           {
-            'type' => 'string',
-            'key' => 'gateway',
-            'value' => gateway,
-            'password' => 'false',
+            'type'             => 'string',
+            'key'              => 'gateway',
+            'value'            => gateway,
+            'password'         => 'false',
             'userConfigurable' => 'true',
-            'Label' => 'Default Gateway',
-            'Description' => 'The default gateway address for the VM network. Leave blank if DHCP is desired.'
+            'Label'            => 'Default Gateway',
+            'Description'      => 'The default gateway address for the VM network. Leave blank if DHCP is desired.'
           },
           {
-            'type' => 'string',
-            'key' => 'DNS',
-            'value' => dns,
-            'password' => 'false',
+            'type'             => 'string',
+            'key'              => 'DNS',
+            'value'            => dns,
+            'password'         => 'false',
             'userConfigurable' => 'true',
-            'Label' => 'DNS',
-            'Description' => 'The domain name servers for the VM (comma separated). Leave blank if DHCP is desired.',
+            'Label'            => 'DNS',
+            'Description'      => 'The domain name servers for the VM (comma separated). Leave blank if DHCP is desired.',
           },
           {
-            'type' => 'string',
-            'key' => 'ntp_servers',
-            'value' => ntp,
-            'password' => 'false',
+            'type'             => 'string',
+            'key'              => 'ntp_servers',
+            'value'            => ntp,
+            'password'         => 'false',
             'userConfigurable' => 'true',
-            'Label' => 'NTP Servers',
-            'Description' => 'Comma-delimited list of NTP servers'
+            'Label'            => 'NTP Servers',
+            'Description'      => 'Comma-delimited list of NTP servers'
           },
           {
-            'type' => 'string',
-            'key' => 'admin_password',
-            'value' => 'tempest',
-            'password' => 'true',
+            'type'             => 'string',
+            'key'              => 'admin_password',
+            'value'            => 'tempest',
+            'password'         => 'true',
             'userConfigurable' => 'true',
-            'Label' => 'Admin Password',
-            'Description' => 'This password is used to SSH into the VM. The username is "tempest".',
+            'Label'            => 'Admin Password',
+            'Description'      => 'This password is used to SSH into the VM. The username is "tempest".',
           },
           {
-            'type' => 'string',
-            'key' => 'ip0',
-            'value' => ip,
-            'password' => 'false',
+            'type'             => 'string',
+            'key'              => 'ip0',
+            'value'            => ip,
+            'password'         => 'false',
             'userConfigurable' => 'true',
-            'Label' => 'IP Address',
-            'Description' => 'The IP address for the VM. Leave blank if DHCP is desired.',
+            'Label'            => 'IP Address',
+            'Description'      => 'The IP address for the VM. Leave blank if DHCP is desired.',
           },
           {
-            'type' => 'string',
-            'key' => 'netmask0',
-            'value' => netmask,
-            'password' => 'false',
+            'type'             => 'string',
+            'key'              => 'netmask0',
+            'value'            => netmask,
+            'password'         => 'false',
             'userConfigurable' => 'true',
-            'Label' => 'Netmask',
-            'Description' => 'The netmask for the VM network. Leave blank if DHCP is desired.'
+            'Label'            => 'Netmask',
+            'Description'      => 'The netmask for the VM network. Leave blank if DHCP is desired.'
           }
         ]
       end

data/lib/vm_shepherd/vcloud_manager.rb

@@ -6,8 +6,8 @@ module VmShepherd
   class VcloudManager
     def initialize(login_info, vdc_name, logger)
       @login_info = login_info
-      @vdc_name = vdc_name
-      @logger = logger
+      @vdc_name   = vdc_name
+      @logger     = logger
     end
 
     def deploy(vapp_template_tar_path, vapp_config)
@@ -18,10 +18,10 @@ module VmShepherd
       untar_vapp_template_tar(File.expand_path(vapp_template_tar_path), tmpdir)
 
       VmShepherd::Vcloud::Deployer.deploy_and_power_on_vapp(
-        client: client,
-        ovf_dir: tmpdir,
+        client:      client,
+        ovf_dir:     tmpdir,
         vapp_config: vapp_config,
-        vdc_name: @vdc_name,
+        vdc_name:    @vdc_name,
       )
     rescue => e
       logger.error(e.http_body) if e.respond_to?(:http_body)

data/lib/vm_shepherd/version.rb

@@ -1,3 +1,3 @@
 module VmShepherd
-  VERSION = '1.11.0'.freeze
+  VERSION = '1.11.1'.freeze
 end

data/lib/vm_shepherd/vsphere_manager.rb

@@ -3,16 +3,16 @@ require 'rbvmomi'
 
 module VmShepherd
   class VsphereManager
-    TEMPLATE_PREFIX = 'tpl'.freeze
-    VALID_FOLDER_REGEX = /\A([\w-]{1,80}\/)*[\w-]{1,80}\/?\z/
+    TEMPLATE_PREFIX         = 'tpl'.freeze
+    VALID_FOLDER_REGEX      = /\A([\w-]{1,80}\/)*[\w-]{1,80}\/?\z/
     VALID_DISK_FOLDER_REGEX = /\A[\w-]{1,80}\z/
 
     def initialize(host, username, password, datacenter_name, logger)
-      @host = host
-      @username = username
-      @password = password
+      @host            = host
+      @username        = username
+      @password        = password
       @datacenter_name = datacenter_name
-      @logger = logger
+      @logger          = logger
     end
 
     def deploy(ova_path, vm_config, vsphere_config)
@@ -43,7 +43,7 @@ module VmShepherd
 
             file_manager.DeleteDatastoreFile_Task(
               datacenter: datacenter,
-              name: "[#{datastore}] #{folder_name}"
+              name:       "[#{datastore}] #{folder_name}"
             ).wait_for_completion
 
             logger.info("END   datastore_folder.destroy_task folder=#{folder_name}")
@@ -114,7 +114,7 @@ module VmShepherd
     def boot_vm(ovf_file_path, vm_config, vsphere_config)
       datacenter.vmFolder.traverse(vsphere_config[:folder], RbVmomi::VIM::Folder, true)
       template = deploy_ovf_template(ovf_file_path, vsphere_config)
-      vm = create_vm_from_template(template, vsphere_config)
+      vm       = create_vm_from_template(template, vsphere_config)
 
       reconfigure_vm(vm, vm_config)
       power_on_vm(vm)
@@ -168,13 +168,13 @@ module VmShepherd
       template_name = [TEMPLATE_PREFIX, Time.new.strftime('%F-%H-%M'), cluster(vsphere_config).name].join('-')
       logger.info("BEGIN deploy_ovf ovf_file=#{ovf_file_path} template_name=#{template_name}")
       connection.serviceContent.ovfManager.deployOVF(
-        uri: ovf_file_path,
-        vmName: template_name,
-        vmFolder: target_folder(vsphere_config),
-        host: find_deploy_host(vsphere_config),
-        resourcePool: resource_pool(vsphere_config),
-        datastore: datastore(vsphere_config),
-        networkMappings: create_network_mappings(ovf_file_path, vsphere_config),
+        uri:              ovf_file_path,
+        vmName:           template_name,
+        vmFolder:         target_folder(vsphere_config),
+        host:             find_deploy_host(vsphere_config),
+        resourcePool:     resource_pool(vsphere_config),
+        datastore:        datastore(vsphere_config),
+        networkMappings:  create_network_mappings(ovf_file_path, vsphere_config),
         propertyMappings: {},
       ).tap do |ovf_template|
         ovf_template.add_delta_disk_layer_on_all_disks
@@ -185,7 +185,7 @@ module VmShepherd
     def find_deploy_host(vsphere_config)
       property_collector = connection.serviceContent.propertyCollector
 
-      hosts = cluster(vsphere_config).host
+      hosts                   = cluster(vsphere_config).host
       host_properties_by_host =
         property_collector.collectMultiple(
           hosts,
@@ -206,16 +206,16 @@ module VmShepherd
       logger.info("BEGIN clone_vm_task tempalte=#{template.name}")
       template.CloneVM_Task(
         folder: target_folder(vsphere_config),
-        name: "#{template.name}-vm",
-        spec: {
+        name:   "#{template.name}-vm",
+        spec:   {
           location: {
-            pool: resource_pool(vsphere_config),
-            datastore: datastore(vsphere_config),
+            pool:         resource_pool(vsphere_config),
+            datastore:    datastore(vsphere_config),
             diskMoveType: :moveChildMostDiskBacking,
           },
-          powerOn: false,
+          powerOn:  false,
           template: false,
-          config: {numCPUs: 2, memoryMB: 2048},
+          config:   {numCPUs: 2, memoryMB: 2048},
         }
       ).wait_for_completion.tap {
         logger.info("END   clone_vm_task tempalte=#{template.name}")
@@ -237,7 +237,7 @@ module VmShepherd
       vm_config_spec =
         RbVmomi::VIM::VmConfigSpec.new.tap do |vcs|
           vcs.ovfEnvironmentTransport = ['com.vmware.guestInfo']
-          vcs.property = create_vapp_property_specs(vm_config)
+          vcs.property                = create_vapp_property_specs(vm_config)
         end
       logger.info("END  VmConfigSpec creation: #{vm_config_spec.inspect}")
 
@@ -250,10 +250,10 @@ module VmShepherd
 
     def create_vapp_property_specs(vm_config)
       ip_configuration = {
-        'ip0' => vm_config[:ip],
-        'netmask0' => vm_config[:netmask],
-        'gateway' => vm_config[:gateway],
-        'DNS' => vm_config[:dns],
+        'ip0'         => vm_config[:ip],
+        'netmask0'    => vm_config[:netmask],
+        'gateway'     => vm_config[:gateway],
+        'DNS'         => vm_config[:dns],
         'ntp_servers' => vm_config[:ntp_servers],
       }
 
@@ -264,8 +264,8 @@ module VmShepherd
       ip_configuration.each_with_index do |(key, value), i|
         vapp_property_specs << RbVmomi::VIM::VAppPropertySpec.new.tap do |spec|
           spec.operation = 'edit'
-          spec.info = RbVmomi::VIM::VAppPropertyInfo.new.tap do |p|
-            p.key = i
+          spec.info      = RbVmomi::VIM::VAppPropertyInfo.new.tap do |p|
+            p.key   = i
             p.label = key
             p.value = value
           end
@@ -274,8 +274,8 @@ module VmShepherd
 
       vapp_property_specs << RbVmomi::VIM::VAppPropertySpec.new.tap do |spec|
         spec.operation = 'edit'
-        spec.info = RbVmomi::VIM::VAppPropertyInfo.new.tap do |p|
-          p.key = ip_configuration.length
+        spec.info      = RbVmomi::VIM::VAppPropertyInfo.new.tap do |p|
+          p.key   = ip_configuration.length
           p.label = 'admin_password'
           p.value = vm_config[:vm_password]
         end
@@ -300,10 +300,10 @@ module VmShepherd
 
     def connection
       RbVmomi::VIM.connect(
-        host: host,
-        user: username,
+        host:     host,
+        user:     username,
         password: password,
-        ssl: true,
+        ssl:      true,
         insecure: true,
       )
     end

data/spec/vm_shepherd/aws_manager_spec.rb

@@ -16,20 +16,20 @@ module VmShepherd
 
     let(:env_config) do
       {
-        stack_name: 'aws-stack-name',
+        stack_name:     'aws-stack-name',
         aws_access_key: 'aws-access-key',
         aws_secret_key: 'aws-secret-key',
-        region: 'us-east-1',
-        json_file: 'cloudformation.json',
-        parameters: {
+        region:         'us-east-1',
+        json_file:      'cloudformation.json',
+        parameters:     {
           'some_parameter' => 'some-answer',
         },
-        outputs: {
-          ssh_key_name: 'ssh-key-name',
-          security_group: 'security-group-id',
-          public_subnet_id: 'public-subnet-id',
-          private_subnet_id: 'private-subnet-id',
-        }.merge(extra_outputs),
+        outputs:        {
+                          ssh_key_name:      'ssh-key-name',
+                          security_group:    'security-group-id',
+                          public_subnet_id:  'public-subnet-id',
+                          private_subnet_id: 'private-subnet-id',
+                        }.merge(extra_outputs),
       }.merge(extra_configs)
     end
 
@@ -47,9 +47,9 @@ module VmShepherd
 
     before do
       expect(AWS).to receive(:config).with(
-          access_key_id: env_config.fetch(:aws_access_key),
+          access_key_id:     env_config.fetch(:aws_access_key),
           secret_access_key: env_config.fetch(:aws_secret_key),
-          region: env_config.fetch(:region),
+          region:            env_config.fetch(:region),
         )
 
       allow(AWS).to receive(:ec2).and_return(ec2)
@@ -75,7 +75,7 @@ module VmShepherd
           expect(stack_collection).to receive(:create).with(
               'aws-stack-name',
               '{}',
-              parameters: {
+              parameters:   {
                 'some_parameter' => 'some-answer',
               },
               capabilities: ['CAPABILITY_IAM']
@@ -110,18 +110,18 @@ module VmShepherd
           {
             elbs: [
                     {
-                      name: 'elb-1-name',
-                      port_mappings: [[1111, 11]],
+                      name:              'elb-1-name',
+                      port_mappings:     [[1111, 11]],
                       stack_output_keys: {
-                        vpc_id: 'vpc_id',
+                        vpc_id:    'vpc_id',
                         subnet_id: 'private_subnet',
                       },
                     },
                     {
-                      name: 'elb-2-name',
-                      port_mappings: [[2222, 22]],
+                      name:              'elb-2-name',
+                      port_mappings:     [[2222, 22]],
                       stack_output_keys: {
-                        vpc_id: 'vpc_id',
+                        vpc_id:    'vpc_id',
                         subnet_id: 'private_subnet',
                       },
                     }
@@ -130,10 +130,10 @@ module VmShepherd
         end
         let(:stack) do
           instance_double(AWS::CloudFormation::Stack,
-            name: 'fake-stack-name',
+            name:          'fake-stack-name',
             creation_time: Time.utc(2015, 5, 29),
-            status: 'CREATE_COMPLETE',
-            outputs: stack_outputs
+            status:        'CREATE_COMPLETE',
+            outputs:       stack_outputs
           )
         end
         let(:stack_outputs) do
@@ -172,17 +172,17 @@ module VmShepherd
 
         it 'creates and attaches a security group for the ELBs' do
           elb_1_security_group_args = {
-            group_name: 'fake-stack-name_elb-1-name',
+            group_name:  'fake-stack-name_elb-1-name',
             description: 'ELB Security Group',
-            vpc_id: 'fake-vpc-id',
+            vpc_id:      'fake-vpc-id',
           }
           expect(ec2_client).to receive(:create_security_group).with(elb_1_security_group_args).and_return(create_security_group_response_1)
           expect(elb_1_security_group).to receive(:authorize_ingress).with(:tcp, 1111, '0.0.0.0/0')
 
           elb_2_security_group_args = {
-            group_name: 'fake-stack-name_elb-2-name',
+            group_name:  'fake-stack-name_elb-2-name',
             description: 'ELB Security Group',
-            vpc_id: 'fake-vpc-id',
+            vpc_id:      'fake-vpc-id',
           }
           expect(ec2_client).to receive(:create_security_group).with(elb_2_security_group_args).and_return(create_security_group_response_2)
           expect(elb_2_security_group).to receive(:authorize_ingress).with(:tcp, 2222, '0.0.0.0/0')
@@ -193,16 +193,16 @@ module VmShepherd
         it 'attaches an elb with the name of the stack for the ELBs' do
           elb_1_params = {
             load_balancer_name: 'elb-1-name',
-            listeners: [{protocol: 'TCP', load_balancer_port: 1111, instance_protocol: 'TCP', instance_port: 11}],
-            subnets: ['fake-subnet-id'],
-            security_groups: ['elb-1-security-group-id']
+            listeners:          [{protocol: 'TCP', load_balancer_port: 1111, instance_protocol: 'TCP', instance_port: 11}],
+            subnets:            ['fake-subnet-id'],
+            security_groups:    ['elb-1-security-group-id']
           }
           expect(elb_client).to receive(:create_load_balancer).with(elb_1_params)
           elb_2_params = {
             load_balancer_name: 'elb-2-name',
-            listeners: [{protocol: 'TCP', load_balancer_port: 2222, instance_protocol: 'TCP', instance_port: 22}],
-            subnets:   ['fake-subnet-id'],
-            security_groups: ['elb-2-security-group-id']
+            listeners:          [{protocol: 'TCP', load_balancer_port: 2222, instance_protocol: 'TCP', instance_port: 22}],
+            subnets:            ['fake-subnet-id'],
+            security_groups:    ['elb-2-security-group-id']
           }
           expect(elb_client).to receive(:create_load_balancer).with(elb_2_params)
 
@@ -220,15 +220,16 @@ module VmShepherd
       before do
         allow(ec2).to receive(:instances).and_return(instances)
         allow(ec2).to receive(:elastic_ips).and_return(elastic_ips)
+        allow(elastic_ip).to receive(:exists?).and_return(true)
       end
 
       it 'creates an instance using AWS SDK v1' do
         expect(ec2).to receive_message_chain(:instances, :create).with(
-            image_id: ami_id,
-            key_name: 'ssh-key-name',
+            image_id:           ami_id,
+            key_name:           'ssh-key-name',
             security_group_ids: ['security-group-id'],
-            subnet: 'public-subnet-id',
-            instance_type: 'm3.medium').and_return(instance)
+            subnet:             'public-subnet-id',
+            instance_type:      'm3.medium').and_return(instance)
 
         ami_manager.deploy(ami_file_path: ami_file_path, vm_config: vm_config)
       end
@@ -271,9 +272,25 @@ module VmShepherd
       end
 
       context 'vm configuration does not contain an elastic IP' do
+        before do
+          allow(ec2).to receive_message_chain(:elastic_ips, :create).and_return(elastic_ip)
+        end
+
+        it 'waits for the Elastic IP to be created' do
+          expect(elastic_ip).to receive(:exists?).exactly(AwsManager::RETRY_LIMIT - 1).times.and_return(false)
+          expect(elastic_ip).to receive(:exists?).exactly(1).times.and_return(true)
+
+          ami_manager.deploy(ami_file_path: ami_file_path, vm_config: vm_config)
+        end
+
+        it 'fails if the Elastic IP is not created in time' do
+          expect(elastic_ip).to receive(:exists?).exactly(AwsManager::RETRY_LIMIT).times.and_return(false)
+
+          expect { ami_manager.deploy(ami_file_path: ami_file_path, vm_config: vm_config) }.to raise_error(AwsManager::RetryLimitExceeded)
+        end
+
         it 'creates and attaches an elastic IP' do
-          expect(ec2).to receive_message_chain(:elastic_ips, :create).with(
-            vpc: true).and_return(elastic_ip)
+          expect(ec2).to receive_message_chain(:elastic_ips, :create).with(vpc: true).and_return(elastic_ip)
 
           expect(instance).to receive(:associate_elastic_ip).with(elastic_ip)
 
@@ -284,7 +301,7 @@ module VmShepherd
       context 'vm configuration contains an elastic IP' do
         let(:vm_config) do
           {
-            vm_name: 'some-vm-name',
+            vm_name:       'some-vm-name',
             vm_ip_address: 'some-ip-address'
           }
         end
@@ -424,18 +441,18 @@ module VmShepherd
           {
             elbs: [
                     {
-                      name: 'elb-1-name',
-                      port_mappings: [[1111, 11]],
+                      name:              'elb-1-name',
+                      port_mappings:     [[1111, 11]],
                       stack_output_keys: {
-                        vpc_id: 'vpc_id',
+                        vpc_id:    'vpc_id',
                         subnet_id: 'private_subnet',
                       },
                     },
                     {
-                      name: 'elb-2-name',
-                      port_mappings: [[2222, 22]],
+                      name:              'elb-2-name',
+                      port_mappings:     [[2222, 22]],
                       stack_output_keys: {
-                        vpc_id: 'vpc_id',
+                        vpc_id:    'vpc_id',
                         subnet_id: 'private_subnet',
                       },
                     }
@@ -446,16 +463,16 @@ module VmShepherd
         let(:elb) { instance_double(AWS::ELB, load_balancers: [load_balancer_1_to_delete, load_balancer_2_to_delete, other_load_balancer]) }
         let(:load_balancer_1_to_delete) do
           instance_double(AWS::ELB::LoadBalancer,
-            name: 'elb-1-name',
+            name:            'elb-1-name',
             security_groups: [elb_1_security_group],
-            exists?: false,
+            exists?:         false,
           )
         end
         let(:load_balancer_2_to_delete) do
           instance_double(AWS::ELB::LoadBalancer,
-            name: 'elb-2-name',
+            name:            'elb-2-name',
             security_groups: [elb_2_security_group],
-            exists?: false,
+            exists?:         false,
           )
         end
         let(:other_load_balancer) { instance_double(AWS::ELB::LoadBalancer, name: 'other-elb-name') }
@@ -464,25 +481,25 @@ module VmShepherd
         let(:network_interface_1_elb_1) do
           instance_double(AWS::EC2::NetworkInterface,
             security_groups: [elb_1_security_group],
-            exists?: false,
+            exists?:         false,
           )
         end
         let(:network_interface_2_elb_1) do
           instance_double(AWS::EC2::NetworkInterface,
             security_groups: [elb_1_security_group],
-            exists?: false,
+            exists?:         false,
           )
         end
         let(:network_interface_1_elb_2) do
           instance_double(AWS::EC2::NetworkInterface,
             security_groups: [elb_2_security_group],
-            exists?: false,
+            exists?:         false,
           )
         end
         let(:network_interface_2_elb_2) do
           instance_double(AWS::EC2::NetworkInterface,
             security_groups: [elb_2_security_group],
-            exists?: false,
+            exists?:         false,
           )
         end
 
@@ -596,7 +613,7 @@ module VmShepherd
       context 'when there is an s3 bucket configuration' do
         let(:bucket_1) { instance_double(AWS::S3::Bucket) }
         let(:bucket_2) { instance_double(AWS::S3::Bucket) }
-        let(:extra_outputs) { { s3_bucket_names: [bucket_name_1, bucket_name_2] } }
+        let(:extra_outputs) { {s3_bucket_names: [bucket_name_1, bucket_name_2]} }
         let(:bucket_name_1) { 'bucket-name-1' }
         let(:bucket_name_2) { 'bucket-name-2' }
 
@@ -646,7 +663,7 @@ module VmShepherd
 
         context 'and the bucket name is empty' do
           let(:bucket_name_3) { '' }
-          let(:extra_outputs) { { s3_bucket_names: [bucket_name_3, bucket_name_1, bucket_name_2] } }
+          let(:extra_outputs) { {s3_bucket_names: [bucket_name_3, bucket_name_1, bucket_name_2]} }
 
           before do
             allow(bucket_1).to receive(:exists?).and_return(true)
@@ -663,7 +680,7 @@ module VmShepherd
 
         context 'and the bucket name is null' do
           let(:bucket_name_3) { nil }
-          let(:extra_outputs) { { s3_bucket_names: [bucket_name_3, bucket_name_1, bucket_name_2] } }
+          let(:extra_outputs) { {s3_bucket_names: [bucket_name_3, bucket_name_1, bucket_name_2]} }
 
           before do
             allow(bucket_1).to receive(:exists?).and_return(true)
@@ -725,7 +742,7 @@ module VmShepherd
         let(:elastic_ip) { instance_double(AWS::EC2::ElasticIp) }
         let(:vm_config) do
           {
-            vm_name: 'some-vm-name',
+            vm_name:       'some-vm-name',
             vm_ip_address: 'some-ip-address'
           }
         end