vm_shepherd 1.11.0 → 1.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 763cd128f7302c5fb7250c56c5fb6f2902659a7b
-  data.tar.gz: aac10b49759fcb9b8c5b385e8f9a3bb4fc6b32d6
+  metadata.gz: 158b8027d9711d2346b03702c5a3302d9f723f35
+  data.tar.gz: ad05a0ea0e8928fd0bbbae0db8c833ef0edd08ee
 SHA512:
-  metadata.gz: b67e18537b886374536aaf33ec441b389c81ffeb283fcaff7ddff1c53899db708f9fceebc9b22ea90a70d29b810b56f04f6486d7689d17721cea9a8304247075
-  data.tar.gz: 7e0e37f43205234107f6350dde7dcbf3d6c409b4b25357fd486710b95504563cd7e3d825f7e5ab6365a8981b0913d9a99d21c1a5e4748b8c19a0ae72377ac1b1
+  metadata.gz: ebc04c69df9a355dd6cd9424463f591142ac1d74414677df1c3ddf8965564afa02a1d8176afb73bc92fd8083a3935c546cdcf50273cd5c5e244b9584a8f9e324
+  data.tar.gz: 9031ac449813be9d4f4986a00d345cd03edc2c73603ad727790e12063ee6940a805867f77d7cc435e2ad80e6b77e81407123bb101cdebab11108a0649d21cddb

data/lib/vm_shepherd.rb

@@ -9,8 +9,8 @@ require 'vm_shepherd/vcloud/vapp_config'
 require 'vm_shepherd/vsphere_manager'
 
 module VmShepherd
-  AWS_IAAS_TYPE = 'aws'.freeze
+  AWS_IAAS_TYPE       = 'aws'.freeze
   OPENSTACK_IAAS_TYPE = 'openstack'.freeze
-  VCLOUD_IAAS_TYPE = 'vcloud'.freeze
-  VSPHERE_IAAS_TYPE = 'vsphere'.freeze
+  VCLOUD_IAAS_TYPE    = 'vcloud'.freeze
+  VSPHERE_IAAS_TYPE   = 'vsphere'.freeze
 end

data/lib/vm_shepherd/aws_manager.rb

@@ -6,24 +6,24 @@ module VmShepherd
     include VmShepherd::RetryHelper
 
     OPS_MANAGER_INSTANCE_TYPE = 'm3.medium'
-    DO_NOT_TERMINATE_TAG_KEY = 'do_not_terminate'
-    ELB_SECURITY_GROUP_NAME = 'ELB Security Group'
+    DO_NOT_TERMINATE_TAG_KEY  = 'do_not_terminate'
+    ELB_SECURITY_GROUP_NAME   = 'ELB Security Group'
 
-    CREATE_IN_PROGRESS = 'CREATE_IN_PROGRESS'
-    CREATE_COMPLETE = 'CREATE_COMPLETE'
+    CREATE_IN_PROGRESS   = 'CREATE_IN_PROGRESS'
+    CREATE_COMPLETE      = 'CREATE_COMPLETE'
     ROLLBACK_IN_PROGRESS = 'ROLLBACK_IN_PROGRESS'
-    ROLLBACK_COMPLETE = 'ROLLBACK_COMPLETE'
-    DELETE_IN_PROGRESS = 'DELETE_IN_PROGRESS'
-    DELETE_COMPLETE = 'DELETE_COMPLETE'
+    ROLLBACK_COMPLETE    = 'ROLLBACK_COMPLETE'
+    DELETE_IN_PROGRESS   = 'DELETE_IN_PROGRESS'
+    DELETE_COMPLETE      = 'DELETE_COMPLETE'
 
     def initialize(env_config:, logger:)
       AWS.config(
-        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),
       )
       @env_config = env_config
-      @logger = logger
+      @logger     = logger
     end
 
     def prepare_environment(cloudformation_template_file)
@@ -63,11 +63,11 @@ module VmShepherd
         retry_until do
           begin
             AWS.ec2.instances.create(
-              image_id: image_id,
-              key_name: env_config.fetch(:outputs).fetch(:ssh_key_name),
+              image_id:           image_id,
+              key_name:           env_config.fetch(:outputs).fetch(:ssh_key_name),
               security_group_ids: [env_config.fetch(:outputs).fetch(:security_group)],
-              subnet: env_config.fetch(:outputs).fetch(:public_subnet_id),
-              instance_type: OPS_MANAGER_INSTANCE_TYPE
+              subnet:             env_config.fetch(:outputs).fetch(:public_subnet_id),
+              instance_type:      OPS_MANAGER_INSTANCE_TYPE
             )
           rescue AWS::EC2::Errors::InvalidIPAddress::InUse
             false
@@ -92,6 +92,9 @@ module VmShepherd
       else
         logger.info('Creating an Elastic IP and assigning it to the instance')
         elastic_ip = AWS.ec2.elastic_ips.create(vpc: true)
+        retry_until do
+          elastic_ip.exists?
+        end
       end
       instance.associate_elastic_ip(elastic_ip)
       instance.add_tag('Name', value: vm_config.fetch(:vm_name))
@@ -124,7 +127,7 @@ module VmShepherd
       AWS.ec2.instances.each do |instance|
         if instance.tags.to_h['Name'] == vm_config.fetch(:vm_name)
           vm_ip_address = vm_config.fetch(:vm_ip_address, nil)
-          elastic_ip = instance.elastic_ip unless vm_ip_address
+          elastic_ip    = instance.elastic_ip unless vm_ip_address
           if elastic_ip
             elastic_ip.disassociate
             elastic_ip.delete
@@ -147,7 +150,7 @@ module VmShepherd
 
     def clear_subnet(subnet_id)
       logger.info("Clearing contents of subnet: #{subnet_id}")
-      subnet = AWS.ec2.subnets[subnet_id]
+      subnet  = AWS.ec2.subnets[subnet_id]
       volumes = []
       subnet.instances.each do |instance|
         instance.attachments.each do |_, attachment|
@@ -173,7 +176,7 @@ module VmShepherd
 
     def delete_elb(elb_name)
       if (elb = AWS::ELB.new.load_balancers.find { |lb| lb.name == elb_name })
-        sg = elb.security_groups.first
+        sg             = elb.security_groups.first
         net_interfaces = AWS.ec2.network_interfaces.select do |ni|
           begin
             ni.security_groups.map(&:id).include? sg.id
@@ -193,17 +196,17 @@ module VmShepherd
     end
 
     def create_elb(stack, elb_config)
-      elb = AWS::ELB.new
+      elb        = AWS::ELB.new
       elb_params = {
         load_balancer_name: elb_config[:name],
-        listeners: [],
-        subnets: [subnet_id(stack, elb_config)],
-        security_groups: [create_security_group(stack, elb_config).security_group_id]
+        listeners:          [],
+        subnets:            [subnet_id(stack, elb_config)],
+        security_groups:    [create_security_group(stack, elb_config).security_group_id]
       }
 
       elb_config[:port_mappings].each do |port_mapping|
         elb_params[:listeners] << {
-          protocol: 'TCP', load_balancer_port: port_mapping[0],
+          protocol:          'TCP', load_balancer_port: port_mapping[0],
           instance_protocol: 'TCP', instance_port: port_mapping[1]
         }
       end
@@ -213,11 +216,11 @@ module VmShepherd
     end
 
     def create_security_group(stack, elb_config)
-      vpc_id = vpc_id(stack, elb_config)
+      vpc_id    = vpc_id(stack, elb_config)
       sg_params = {
-        group_name: [stack.name, elb_config[:name]].join('_'),
+        group_name:  [stack.name, elb_config[:name]].join('_'),
         description: 'ELB Security Group',
-        vpc_id: vpc_id,
+        vpc_id:      vpc_id,
       }
 
       logger.info('Creating a Security Group for the ELB')
@@ -231,7 +234,7 @@ module VmShepherd
     end
 
     def delete_stack(stack_name)
-      cfm = AWS::CloudFormation.new
+      cfm   = AWS::CloudFormation.new
       stack = cfm.stacks[stack_name]
       logger.info('deleting CloudFormation stack')
       stack.delete

data/lib/vm_shepherd/openstack_manager.rb

@@ -8,41 +8,41 @@ module VmShepherd
     def initialize(auth_url:, username:, api_key:, tenant:)
       @auth_url = auth_url
       @username = username
-      @api_key = api_key
-      @tenant = tenant
+      @api_key  = api_key
+      @tenant   = tenant
     end
 
     def deploy(raw_file_path, vm_options)
       say "Uploading the image #{raw_file_path}"
       image = image_service.images.create(
-        name: vm_options[:name],
-        size: File.size(raw_file_path),
-        disk_format: 'raw',
+        name:             vm_options[:name],
+        size:             File.size(raw_file_path),
+        disk_format:      'raw',
         container_format: 'bare',
-        location: raw_file_path,
+        location:         raw_file_path,
       )
       say 'Finished uploading the image'
 
-      flavor = find_flavor(vm_options[:flavor_name])
-      network = network_service.networks.find { |net| net.name == vm_options[:network_name] }
+      flavor          = find_flavor(vm_options[:flavor_name])
+      network         = network_service.networks.find { |net| net.name == vm_options[:network_name] }
       security_groups = vm_options[:security_group_names]
 
       say('Launching an instance')
       server = service.servers.create(
-        name: vm_options[:name],
-        flavor_ref: flavor.id,
-        image_ref: image.id,
-        key_name: vm_options[:key_name],
+        name:            vm_options[:name],
+        flavor_ref:      flavor.id,
+        image_ref:       image.id,
+        key_name:        vm_options[:key_name],
         security_groups: security_groups,
-        nics: [
-          {net_id: network.id, v4_fixed_ip: vm_options[:private_ip]}
-        ],
+        nics:            [
+                           {net_id: network.id, v4_fixed_ip: vm_options[:private_ip]}
+                         ],
       )
       server.wait_for { ready? }
       say('Finished launching an instance')
 
       say('Assigning a Public IP to the instance')
-      ip = service.addresses.find { |address| address.instance_id.nil? && address.ip == vm_options[:public_ip] }
+      ip        = service.addresses.find { |address| address.instance_id.nil? && address.ip == vm_options[:public_ip] }
       ip.server = server
       say('Finished assigning a Public IP to the instance')
     end
@@ -114,42 +114,42 @@ module VmShepherd
 
     def service
       @service ||= Fog::Compute.new(
-        provider: 'openstack',
+        provider:           'openstack',
         openstack_auth_url: auth_url,
         openstack_username: username,
-        openstack_tenant: tenant,
-        openstack_api_key: api_key,
+        openstack_tenant:   tenant,
+        openstack_api_key:  api_key,
       )
     end
 
     def image_service
       @image_service ||= Fog::Image.new(
-        provider: 'openstack',
-        openstack_auth_url: auth_url,
-        openstack_username: username,
-        openstack_tenant: tenant,
-        openstack_api_key: api_key,
+        provider:                'openstack',
+        openstack_auth_url:      auth_url,
+        openstack_username:      username,
+        openstack_tenant:        tenant,
+        openstack_api_key:       api_key,
         openstack_endpoint_type: 'publicURL',
       )
     end
 
     def network_service
       @network_service ||= Fog::Network.new(
-        provider: 'openstack',
+        provider:           'openstack',
         openstack_auth_url: auth_url,
         openstack_username: username,
-        openstack_tenant: tenant,
-        openstack_api_key: api_key,
+        openstack_tenant:   tenant,
+        openstack_api_key:  api_key,
       )
     end
 
     def storage_service
       @network_service ||= Fog::Storage.new(
-        provider: 'openstack',
+        provider:           'openstack',
         openstack_auth_url: auth_url,
         openstack_username: username,
-        openstack_tenant: tenant,
-        openstack_api_key: api_key,
+        openstack_tenant:   tenant,
+        openstack_api_key:  api_key,
       )
     end
 

data/lib/vm_shepherd/retry_helper.rb

@@ -3,11 +3,11 @@ module VmShepherd
     class RetryLimitExceeded < StandardError
     end
 
-    RETRY_LIMIT = 10
+    RETRY_LIMIT    = 10
     RETRY_INTERVAL = 60
 
     def retry_until(retry_limit: RETRY_LIMIT, &block)
-      tries = 0
+      tries             = 0
       condition_reached = false
       loop do
         tries += 1

data/lib/vm_shepherd/shepherd.rb

@@ -20,10 +20,10 @@ module VmShepherd
           when VmShepherd::VCLOUD_IAAS_TYPE then
             VmShepherd::VcloudManager.new(
               {
-                url: vm_shepherd_config.creds.url,
+                url:          vm_shepherd_config.creds.url,
                 organization: vm_shepherd_config.creds.organization,
-                user: vm_shepherd_config.creds.user,
-                password: vm_shepherd_config.creds.password,
+                user:         vm_shepherd_config.creds.user,
+                password:     vm_shepherd_config.creds.password,
               },
               vm_shepherd_config.vdc.name,
               stdout_logger
@@ -41,18 +41,18 @@ module VmShepherd
             ).deploy(
               path,
               {
-                ip: vm_shepherd_config.vm.ip,
-                gateway: vm_shepherd_config.vm.gateway,
-                netmask: vm_shepherd_config.vm.netmask,
-                dns: vm_shepherd_config.vm.dns,
+                ip:          vm_shepherd_config.vm.ip,
+                gateway:     vm_shepherd_config.vm.gateway,
+                netmask:     vm_shepherd_config.vm.netmask,
+                dns:         vm_shepherd_config.vm.dns,
                 ntp_servers: vm_shepherd_config.vm.ntp_servers,
               },
               {
-                cluster: vm_shepherd_config.vsphere.cluster,
+                cluster:       vm_shepherd_config.vsphere.cluster,
                 resource_pool: vm_shepherd_config.vsphere.resource_pool,
-                datastore: vm_shepherd_config.vsphere.datastore,
-                network: vm_shepherd_config.vsphere.network,
-                folder: vm_shepherd_config.vsphere.folder,
+                datastore:     vm_shepherd_config.vsphere.datastore,
+                network:       vm_shepherd_config.vsphere.network,
+                folder:        vm_shepherd_config.vsphere.folder,
               }
             )
           when VmShepherd::AWS_IAAS_TYPE then
@@ -72,10 +72,10 @@ module VmShepherd
           vm_shepherd_configs(settings).each do |vm_shepherd_config|
             VmShepherd::VcloudManager.new(
               {
-                url: vm_shepherd_config.creds.url,
+                url:          vm_shepherd_config.creds.url,
                 organization: vm_shepherd_config.creds.organization,
-                user: vm_shepherd_config.creds.user,
-                password: vm_shepherd_config.creds.password,
+                user:         vm_shepherd_config.creds.user,
+                password:     vm_shepherd_config.creds.password,
               },
               vm_shepherd_config.vdc.name,
               stdout_logger
@@ -109,10 +109,10 @@ module VmShepherd
           when VmShepherd::VCLOUD_IAAS_TYPE then
             VmShepherd::VcloudManager.new(
               {
-                url: vm_shepherd_config.creds.url,
+                url:          vm_shepherd_config.creds.url,
                 organization: vm_shepherd_config.creds.organization,
-                user: vm_shepherd_config.creds.user,
-                password: vm_shepherd_config.creds.password,
+                user:         vm_shepherd_config.creds.user,
+                password:     vm_shepherd_config.creds.password,
               },
               vm_shepherd_config.vdc.name,
               stdout_logger
@@ -142,10 +142,10 @@ module VmShepherd
           vm_shepherd_configs(settings).each do |vm_shepherd_config|
             VmShepherd::VcloudManager.new(
               {
-                url: vm_shepherd_config.creds.url,
+                url:          vm_shepherd_config.creds.url,
                 organization: vm_shepherd_config.creds.organization,
-                user: vm_shepherd_config.creds.user,
-                password: vm_shepherd_config.creds.password,
+                user:         vm_shepherd_config.creds.user,
+                password:     vm_shepherd_config.creds.password,
               },
               vm_shepherd_config.vdc.name,
               stdout_logger,
@@ -161,8 +161,8 @@ module VmShepherd
               stdout_logger,
             ).clean_environment(
               datacenter_folders_to_clean: vm_shepherd_config.cleanup.datacenter_folders_to_clean,
-              datastores: vm_shepherd_config.cleanup.datastores,
-              datastore_folders_to_clean: vm_shepherd_config.cleanup.datastore_folders_to_clean,
+              datastores:                  vm_shepherd_config.cleanup.datastores,
+              datastore_folders_to_clean:  vm_shepherd_config.cleanup.datastore_folders_to_clean,
             )
           end
         when VmShepherd::AWS_IAAS_TYPE then
@@ -185,12 +185,12 @@ module VmShepherd
     def vcloud_deploy_options(vm_shepherd_config)
       vm = vm_shepherd_config.vapp
       VmShepherd::Vcloud::VappConfig.new(
-        name: vm.ops_manager_name,
-        ip: vm.ip,
+        name:    vm.ops_manager_name,
+        ip:      vm.ip,
         gateway: vm.gateway,
         netmask: vm.netmask,
-        dns: vm.dns,
-        ntp: vm.ntp,
+        dns:     vm.dns,
+        ntp:     vm.ntp,
         catalog: vm_shepherd_config.vdc.catalog,
         network: vm_shepherd_config.vdc.network,
       )
@@ -200,15 +200,15 @@ module VmShepherd
       @ami_manager ||=
         VmShepherd::AwsManager.new(
           env_config: {
-            stack_name: settings.vm_shepherd.env_config.stack_name,
-            aws_access_key: settings.vm_shepherd.env_config.aws_access_key,
-            aws_secret_key: settings.vm_shepherd.env_config.aws_secret_key,
-            region: settings.vm_shepherd.env_config.region,
-            json_file: settings.vm_shepherd.env_config.json_file,
-            parameters: settings.vm_shepherd.env_config.parameters_as_a_hash,
-            outputs: settings.vm_shepherd.env_config.outputs.to_h,
-          }.merge(ami_elb_config),
-          logger: stdout_logger,
+                        stack_name:     settings.vm_shepherd.env_config.stack_name,
+                        aws_access_key: settings.vm_shepherd.env_config.aws_access_key,
+                        aws_secret_key: settings.vm_shepherd.env_config.aws_secret_key,
+                        region:         settings.vm_shepherd.env_config.region,
+                        json_file:      settings.vm_shepherd.env_config.json_file,
+                        parameters:     settings.vm_shepherd.env_config.parameters_as_a_hash,
+                        outputs:        settings.vm_shepherd.env_config.outputs.to_h,
+                      }.merge(ami_elb_config),
+          logger:     stdout_logger,
         )
     end
 
@@ -232,20 +232,20 @@ module VmShepherd
       OpenstackManager.new(
         auth_url: vm_shepherd_config.creds.auth_url,
         username: vm_shepherd_config.creds.username,
-        api_key: vm_shepherd_config.creds.api_key,
-        tenant: vm_shepherd_config.creds.tenant,
+        api_key:  vm_shepherd_config.creds.api_key,
+        tenant:   vm_shepherd_config.creds.tenant,
       )
     end
 
     def openstack_vm_options(vm_shepherd_config)
       {
-        name: vm_shepherd_config.vm.name,
-        flavor_name: vm_shepherd_config.vm.flavor_name,
-        network_name: vm_shepherd_config.vm.network_name,
-        key_name: vm_shepherd_config.vm.key_name,
+        name:                 vm_shepherd_config.vm.name,
+        flavor_name:          vm_shepherd_config.vm.flavor_name,
+        network_name:         vm_shepherd_config.vm.network_name,
+        key_name:             vm_shepherd_config.vm.key_name,
         security_group_names: vm_shepherd_config.vm.security_group_names,
-        public_ip: vm_shepherd_config.vm.public_ip,
-        private_ip: vm_shepherd_config.vm.private_ip,
+        public_ip:            vm_shepherd_config.vm.public_ip,
+        private_ip:           vm_shepherd_config.vm.private_ip,
       }
     end
 

data/lib/vm_shepherd/vcloud/deployer.rb

@@ -8,11 +8,11 @@ module VmShepherd
         catalog.upload_vapp_template(vdc_name, vapp_config.name, ovf_dir)
 
         # instantiate template
-        network_config = VCloudSdk::NetworkConfig.new(vapp_config.network, 'Network 1')
-        vapp = catalog.instantiate_vapp_template(vapp_config.name, vdc_name, vapp_config.name, nil, nil, network_config)
+        network_config                = VCloudSdk::NetworkConfig.new(vapp_config.network, 'Network 1')
+        vapp                          = catalog.instantiate_vapp_template(vapp_config.name, vdc_name, vapp_config.name, nil, nil, network_config)
 
         # reconfigure vm
-        vm = vapp.find_vm_by_name(vapp_config.name)
+        vm                            = vapp.find_vm_by_name(vapp_config.name)
         vm.product_section_properties = vapp_config.build_properties
 
         # power on vapp