vm_shepherd 1.0.3 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 219c652eba8784d7e3d73dca6d47434251d457cf
-  data.tar.gz: d93a9bed83c27bbd86d75f39bcecd8ce11d88549
+  metadata.gz: 316f95673f45c873990de6c9a8313e9f7c30c14d
+  data.tar.gz: a5cacb70390f6f42dfbac300b298cf720eaaaf96
 SHA512:
-  metadata.gz: 50eb9bb8a26e7f8f7d566fb70c63746a04b90c5b341a498139c5d2e7edeb73ebd1dba1f09799dfc498d78b131517ab7f7f88a64d27ec871e0e6b739d7d16f7a6
-  data.tar.gz: 599c01489ea1bcc65321c8f331402028f5e1e63cd9573fa1b67084031293c1f8ae596013c11629207694649e8319113a60fa86c6a600c924a8a5f454bf1f6a3e
+  metadata.gz: 21c6f2e27bf812d8349adabb9c91a2f360b29c94a17a359ede7c099d927af52ce80e78ae39f071f47bd07a64ccded8b52ab060be96cf608daf38da7e5050e607
+  data.tar.gz: c43837145203de571a44d3617e5b295036a78b2d956112ea9a5c42c34fd49e35fad534f34f6bddb09a5f7b4a2637992dcd8a655343fde52540c000e06d7894d2

data/lib/vm_shepherd/aws_manager.rb

@@ -11,67 +11,120 @@ module VmShepherd
     RETRY_INTERVAL = 5
     DO_NOT_TERMINATE_TAG_KEY = 'do_not_terminate'
 
-    def initialize(aws_options)
+    def initialize(env_config)
       AWS.config(
-        access_key_id: aws_options.fetch(:aws_access_key),
-        secret_access_key: aws_options.fetch(:aws_secret_key),
+        access_key_id: env_config.fetch(:aws_access_key),
+        secret_access_key: env_config.fetch(:aws_secret_key),
         region: AWS_REGION
       )
-      @aws_options = aws_options
+      @env_config = env_config
     end
 
-    def deploy(ami_file_path)
+    def prepare_environment(cloudformation_template_file)
+      template = File.read(cloudformation_template_file)
+
+      cfm = AWS::CloudFormation.new
+      stack = cfm.stacks.create(env_config.fetch(:stack_name), template, :parameters => env_config.fetch(:parameters), capabilities: ['CAPABILITY_IAM'])
+
+      retry_until(retry_limit: 360) do
+        status = stack.status
+        case status
+          when 'CREATE_COMPLETE'
+            true
+          when 'CREATE_IN_PROGRESS'
+            false
+          when 'ROLLBACK_IN_PROGRESS'
+            false
+          else
+            stack.delete if status == 'ROLLBACK_COMPLETE'
+            raise "Unexpected status for stack #{env_config.fetch(:stack_name)} : #{status}"
+        end
+      end
+    end
+
+    def deploy(ami_file_path:, vm_config:)
       image_id = File.read(ami_file_path).strip
 
       instance =
-        retry_ignoring_error_until(AWS::EC2::Errors::InvalidIPAddress::InUse) do
-          AWS.ec2.instances.create(
-            image_id: image_id,
-            key_name: aws_options.fetch(:ssh_key_name),
-            security_group_ids: [aws_options.fetch(:security_group_id)],
-            subnet: aws_options.fetch(:public_subnet_id),
-            instance_type: OPS_MANAGER_INSTANCE_TYPE
-          )
+        retry_until do
+          begin
+            AWS.ec2.instances.create(
+              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
+            )
+          rescue AWS::EC2::Errors::InvalidIPAddress::InUse
+            false
+          end
         end
 
-      retry_ignoring_error_until(AWS::EC2::Errors::InvalidInstanceID::NotFound) do
-        instance.status == :running
+      retry_until do
+        begin
+          instance.status == :running
+        rescue AWS::EC2::Errors::InvalidInstanceID::NotFound
+          false
+        end
       end
 
-      instance.associate_elastic_ip(aws_options.fetch(:elastic_ip_id))
-      instance.add_tag('Name', value: aws_options.fetch(:vm_name))
+      elastic_ip = AWS.ec2.elastic_ips.create(vpc: true)
+      instance.associate_elastic_ip(elastic_ip.allocation_id)
+      instance.add_tag('Name', value: vm_config.fetch(:vm_name))
     end
 
     def clean_environment
-      subnets = [
-        AWS.ec2.subnets[aws_options.fetch(:public_subnet_id)],
-        AWS.ec2.subnets[aws_options.fetch(:private_subnet_id)]
-      ]
+      subnets = []
+      subnets << AWS.ec2.subnets[env_config.fetch(:outputs).fetch(:public_subnet_id)] if env_config.fetch(:outputs).fetch(:public_subnet_id)
+      subnets << AWS.ec2.subnets[env_config.fetch(:outputs).fetch(:private_subnet_id)] if env_config.fetch(:outputs).fetch(:private_subnet_id)
 
       volumes = []
       subnets.each do |subnet|
         subnet.instances.each do |instance|
-          unless instance.tags.to_h.fetch(DO_NOT_TERMINATE_TAG_KEY, false)
-            instance.attachments.each do |_, attachment|
-              volumes.push(attachment.volume) unless attachment.delete_on_termination
-            end
-            instance.terminate
+          instance.attachments.each do |_, attachment|
+            volumes.push(attachment.volume) unless attachment.delete_on_termination
           end
+          instance.terminate
         end
       end
       destroy_volumes(volumes)
+
+      cfm = AWS::CloudFormation.new
+      stack = cfm.stacks[env_config.fetch(:stack_name)]
+      stack.delete
+      retry_until(retry_limit: 360) do
+        begin
+          status = stack.status
+          case status
+            when 'DELETE_COMPLETE'
+              true
+            when 'DELETE_IN_PROGRESS'
+              false
+            else
+              raise "Unexpected status for stack #{env_config.fetch(:stack_name)} : #{status}"
+          end
+        rescue AWS::CloudFormation::Errors::ValidationError
+          raise if stack.exists?
+          true
+        end
+      end if stack
     end
 
-    def destroy
-      AWS.ec2.elastic_ips.each do |elastic_ip|
-        if elastic_ip.allocation_id == aws_options.fetch(:elastic_ip_id)
-          elastic_ip.instance.terminate if elastic_ip.instance
+    def destroy(vm_config)
+      AWS.ec2.instances.each do |instance|
+        if instance.tags.to_h['Name'] == vm_config.fetch(:vm_name)
+          elastic_ip = instance.elastic_ip
+          if elastic_ip
+            elastic_ip.disassociate
+            elastic_ip.delete
+          end
+          instance.terminate
         end
       end
     end
 
     private
-    attr_reader :aws_options
+    attr_reader :env_config
 
     def destroy_volumes(volumes)
       volumes.each do |volume|
@@ -84,19 +137,15 @@ module VmShepherd
       end
     end
 
-    def retry_ignoring_error_until(exception_class, &block)
+    def retry_until(retry_limit: RETRY_LIMIT, &block)
       tries = 0
       condition_reached = false
       loop do
-        begin
-          tries += 1
-          raise(RetryLimitExceeded) if tries > RETRY_LIMIT
-          condition_reached = block.call
-          sleep RETRY_INTERVAL
-        rescue exception_class
-          retry
-        end
+        tries += 1
+        raise(RetryLimitExceeded) if tries > retry_limit
+        condition_reached = block.call
         break if condition_reached
+        sleep RETRY_INTERVAL
       end
       condition_reached
     end

data/lib/vm_shepherd/openstack_manager.rb

@@ -99,6 +99,9 @@ module VmShepherd
       end
     end
 
+    def prepare_environment
+    end
+
     def service
       @service ||= Fog::Compute.new(
         provider: 'openstack',

data/lib/vm_shepherd/shepherd.rb

@@ -1,6 +1,7 @@
 module VmShepherd
   class Shepherd
-    class InvalidIaas < StandardError; end
+    class InvalidIaas < StandardError;
+    end
 
     def initialize(settings:)
       @settings = settings
@@ -54,13 +55,49 @@ module VmShepherd
               }
             )
           when VmShepherd::AWS_IAAS_TYPE then
-            ami_manager(vm_shepherd_config).deploy(path)
+            ami_manager.deploy(ami_file_path: path, vm_config: vm_shepherd_config.to_h)
           when VmShepherd::OPENSTACK_IAAS_TYPE then
             openstack_vm_manager(vm_shepherd_config).deploy(path, openstack_vm_options(vm_shepherd_config))
         end
       end
     end
 
+    def prepare_environment
+      unless valid_iaas_types.include?(settings.iaas_type)
+        fail(InvalidIaas, "Unknown IaaS type: #{settings.iaas_type.inspect}")
+      end
+      case settings.iaas_type
+        when VmShepherd::VCLOUD_IAAS_TYPE then
+          vm_shepherd_configs(settings).each do |vm_shepherd_config|
+            VmShepherd::VcloudManager.new(
+              {
+                url: vm_shepherd_config.creds.url,
+                organization: vm_shepherd_config.creds.organization,
+                user: vm_shepherd_config.creds.user,
+                password: vm_shepherd_config.creds.password,
+              },
+              vm_shepherd_config.vdc.name,
+              error_logger
+            ).prepare_environment
+          end
+        when VmShepherd::VSPHERE_IAAS_TYPE then
+          vm_shepherd_configs(settings).each do |vm_shepherd_config|
+            VmShepherd::VsphereManager.new(
+              vm_shepherd_config.vcenter_creds.ip,
+              vm_shepherd_config.vcenter_creds.username,
+              vm_shepherd_config.vcenter_creds.password,
+              vm_shepherd_config.vsphere.datacenter,
+            ).prepare_environment
+          end
+        when VmShepherd::AWS_IAAS_TYPE then
+          ami_manager.prepare_environment(settings.vm_shepherd.env_config.json_file)
+        when VmShepherd::OPENSTACK_IAAS_TYPE then
+          vm_shepherd_configs(settings).each do |vm_shepherd_config|
+            openstack_vm_manager(vm_shepherd_config).prepare_environment
+          end
+      end
+    end
+
     def destroy
       unless valid_iaas_types.include?(settings.iaas_type)
         fail(InvalidIaas, "Unknown IaaS type: #{settings.iaas_type.inspect}")
@@ -86,7 +123,7 @@ module VmShepherd
               vm_shepherd_config.vsphere.datacenter,
             ).destroy(vm_shepherd_config.vm.ip, vm_shepherd_config.vsphere.resource_pool)
           when VmShepherd::AWS_IAAS_TYPE then
-            ami_manager(vm_shepherd_config).destroy
+            ami_manager.destroy(vm_shepherd_config.to_h)
           when VmShepherd::OPENSTACK_IAAS_TYPE then
             openstack_vm_manager(vm_shepherd_config).destroy(openstack_vm_options(vm_shepherd_config))
         end
@@ -97,9 +134,9 @@ module VmShepherd
       unless valid_iaas_types.include?(settings.iaas_type)
         fail(InvalidIaas, "Unknown IaaS type: #{settings.iaas_type.inspect}")
       end
-      vm_shepherd_configs(settings).each do |vm_shepherd_config|
-        case settings.iaas_type
-          when VmShepherd::VCLOUD_IAAS_TYPE then
+      case settings.iaas_type
+        when VmShepherd::VCLOUD_IAAS_TYPE then
+          vm_shepherd_configs(settings).each do |vm_shepherd_config|
             VmShepherd::VcloudManager.new(
               {
                 url: vm_shepherd_config.creds.url,
@@ -110,7 +147,9 @@ module VmShepherd
               vm_shepherd_config.vdc.name,
               error_logger,
             ).clean_environment(vm_shepherd_config.vapp.product_names || [], vm_shepherd_config.vapp.product_catalog)
-          when VmShepherd::VSPHERE_IAAS_TYPE then
+          end
+        when VmShepherd::VSPHERE_IAAS_TYPE then
+          vm_shepherd_configs(settings).each do |vm_shepherd_config|
             VmShepherd::VsphereManager.new(
               vm_shepherd_config.vcenter_creds.ip,
               vm_shepherd_config.vcenter_creds.username,
@@ -121,11 +160,13 @@ module VmShepherd
               datastores: vm_shepherd_config.cleanup.datastores,
               datastore_folders_to_clean: vm_shepherd_config.cleanup.datastore_folders_to_clean,
             )
-          when VmShepherd::AWS_IAAS_TYPE then
-            ami_manager(vm_shepherd_config).clean_environment
-          when VmShepherd::OPENSTACK_IAAS_TYPE then
+          end
+        when VmShepherd::AWS_IAAS_TYPE then
+          ami_manager.clean_environment
+        when VmShepherd::OPENSTACK_IAAS_TYPE then
+          vm_shepherd_configs(settings).each do |vm_shepherd_config|
             openstack_vm_manager(vm_shepherd_config).clean_environment
-        end
+          end
       end
     end
 
@@ -153,16 +194,16 @@ module VmShepherd
       }
     end
 
-    def ami_manager(vm_shepherd_config)
-      VmShepherd::AwsManager.new(
-        aws_access_key: vm_shepherd_config.aws_access_key,
-        aws_secret_key: vm_shepherd_config.aws_secret_key,
-        ssh_key_name: vm_shepherd_config.ssh_key_name,
-        security_group_id: vm_shepherd_config.security_group,
-        public_subnet_id: vm_shepherd_config.public_subnet_id,
-        private_subnet_id: vm_shepherd_config.private_subnet_id,
-        elastic_ip_id: vm_shepherd_config.elastic_ip_id,
-        vm_name: vm_shepherd_config.vm_name,
+    def ami_manager
+      @ami_manager ||= VmShepherd::AwsManager.new(
+        {
+          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,
+          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
+        }
       )
     end
 
@@ -188,7 +229,7 @@ module VmShepherd
     end
 
     def vm_shepherd_configs(settings)
-      settings.vm_shepherd_configs || []
+      settings.vm_shepherd.vm_configs || []
     end
 
     def valid_iaas_types

data/lib/vm_shepherd/vcloud_manager.rb

@@ -24,6 +24,9 @@ module VmShepherd
       FileUtils.remove_entry_secure(tmpdir, force: true)
     end
 
+    def prepare_environment
+    end
+
     def destroy(vapp_names, catalog)
       delete_vapps(vapp_names)
       delete_catalog(catalog)

data/lib/vm_shepherd/version.rb

@@ -1,3 +1,3 @@
 module VmShepherd
-  VERSION = '1.0.3'.freeze
+  VERSION = '1.1.0'.freeze
 end

data/lib/vm_shepherd/vsphere_manager.rb

@@ -56,6 +56,9 @@ module VmShepherd
       end
     end
 
+    def prepare_environment
+    end
+
     def destroy(ip_address, resource_pool_name)
       vms = connection.serviceContent.searchIndex.FindAllByIp(ip: ip_address, vmSearch: true)
       vms = vms.select { |vm| resource_pool_name == vm.resourcePool.name } if resource_pool_name
@@ -120,20 +123,26 @@ module VmShepherd
     end
 
     def delete_folder_and_vms(folder_name)
-      return unless (folder = datacenter.vmFolder.traverse(folder_name))
+      3.times do |attempt|
+        break unless (folder = datacenter.vmFolder.traverse(folder_name))
 
-      find_vms(folder).each { |vm| power_off_vm(vm) }
+        find_vms(folder).each { |vm| power_off_vm(vm) }
 
-      logger.info("BEGIN folder.destroy_task folder=#{folder_name}")
-      folder.Destroy_Task.wait_for_completion
-      logger.info("END   folder.destroy_task folder=#{folder_name}")
-
-      fail("#{folder_name.inspect} already exists") unless datacenter.vmFolder.traverse(folder_name).nil?
-    rescue RbVmomi::Fault => e
-      logger.info("ERROR folder.destroy_task folder=#{folder_name} #{e.inspect}")
-      raise
+        begin
+          logger.info("BEGIN folder.destroy_task folder=#{folder_name} attempt ##{attempt}")
+          folder.Destroy_Task.wait_for_completion
+          logger.info("END   folder.destroy_task folder=#{folder_name}")
+          fail("#{folder_name.inspect} already exists") unless datacenter.vmFolder.traverse(folder_name).nil?
+        rescue RbVmomi::Fault => e
+          logger.info("ERROR folder.destroy_task folder=#{folder_name} #{e.inspect}")
+          sleep 10
+          # give up if it's the 3rd attempt
+          raise if attempt == 2
+        end
+      end
     end
 
+
     def find_vms(folder)
       vms = folder.childEntity.grep(RbVmomi::VIM::VirtualMachine)
       vms << folder.childEntity.grep(RbVmomi::VIM::Folder).map { |child| find_vms(child) }

data/spec/fixtures/shepherd/aws.yml

@@ -1,19 +1,18 @@
 iaas_type: aws
 
-vm_shepherd_configs:
-- aws_access_key: aws-access-key
-  aws_secret_key: aws-secret-key
-  ssh_key_name: ssh-key-name
-  security_group: security-group-id
-  public_subnet_id: public-subnet-id
-  private_subnet_id: private-subnet-id
-  elastic_ip_id: elastic-ip-id
-  vm_name: vm-name
-- aws_access_key: aws-access-key-2
-  aws_secret_key: aws-secret-key-2
-  ssh_key_name: ssh-key-name-2
-  security_group: security-group-id-2
-  public_subnet_id: public-subnet-id-2
-  private_subnet_id: private-subnet-id-2
-  elastic_ip_id: elastic-ip-id-2
-  vm_name: vm-name-2
+vm_shepherd:
+  env_config:
+    stack_name: aws-stack-name
+    aws_access_key: aws-access-key
+    aws_secret_key: aws-secret-key
+    json_file: cloudformation.json
+    parameters:
+      key_pair_name: key_pair_name
+    outputs:
+      ssh_key_name: ssh-key-name
+      security_group: security-group-id
+      public_subnet_id: public-subnet-id
+      private_subnet_id: private-subnet-id
+  vm_configs:
+  - vm_name: vm-name
+  - vm_name: vm-name-2

data/spec/fixtures/shepherd/openstack.yml

@@ -1,36 +1,37 @@
 iaas_type: openstack
-vm_shepherd_configs:
-- creds:
-    auth_url: 'http://example.com/version/tokens'
-    username: 'username'
-    api_key: 'api-key'
-    tenant: 'tenant'
-  vm:
-    name: 'some-vm-name'
-    flavor_parameters:
-      min_disk_size: 150
-    network_name: 'some-network'
-    key_name: 'some-key'
-    security_group_names:
-      - 'security-group-A'
-      - 'security-group-B'
-      - 'security-group-C'
-    public_ip: 198.11.195.5
-    private_ip: 192.168.100.100
-- creds:
-    auth_url: 'http://example.com/version/tokens-2'
-    username: 'username-2'
-    api_key: 'api-key-2'
-    tenant: 'tenant-2'
-  vm:
-    name: 'some-vm-name-2'
-    flavor_parameters:
-      min_disk_size: 152
-    network_name: 'some-network-2'
-    key_name: 'some-key-2'
-    security_group_names:
-      - 'security-group-A-2'
-      - 'security-group-B-2'
-      - 'security-group-C-2'
-    public_ip: 198.11.195.5-2
-    private_ip: 192.168.100.100-2
+vm_shepherd:
+  vm_configs:
+  - creds:
+      auth_url: 'http://example.com/version/tokens'
+      username: 'username'
+      api_key: 'api-key'
+      tenant: 'tenant'
+    vm:
+      name: 'some-vm-name'
+      flavor_parameters:
+        min_disk_size: 150
+      network_name: 'some-network'
+      key_name: 'some-key'
+      security_group_names:
+        - 'security-group-A'
+        - 'security-group-B'
+        - 'security-group-C'
+      public_ip: 198.11.195.5
+      private_ip: 192.168.100.100
+  - creds:
+      auth_url: 'http://example.com/version/tokens-2'
+      username: 'username-2'
+      api_key: 'api-key-2'
+      tenant: 'tenant-2'
+    vm:
+      name: 'some-vm-name-2'
+      flavor_parameters:
+        min_disk_size: 152
+      network_name: 'some-network-2'
+      key_name: 'some-key-2'
+      security_group_names:
+        - 'security-group-A-2'
+        - 'security-group-B-2'
+        - 'security-group-C-2'
+      public_ip: 198.11.195.5-2
+      private_ip: 192.168.100.100-2