vm_shepherd 2.0.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7ee2d52da3a902973a504843ace3b5e3ba0fed26
-  data.tar.gz: ce189c0987c686de0d6b923356d1b315dc14551a
+  metadata.gz: f2ec2812d65de401f4a75e0231500740b2e4a876
+  data.tar.gz: 51537e8fc0e866193160819e8341f151168a7619
 SHA512:
-  metadata.gz: 45b5e0127208360ed18d086bfe233433bcad2c2dd80308cce95b9500ce6f34b9bbc37ea01be4cf90b4c65c8ebe8368b9cc5d632c2cc68ad541c6051bbc231887
-  data.tar.gz: b883adadd20c3441b98cf0873bbb6060df5093725dcb572ad6c0ea1022bc1dc6f6b6adf86fdeddf165158cf8ad9867f777a94109aa2b906a9771f5b936ca3b3a
+  metadata.gz: 9e1b8e82805557390405832ba23f2cbfa803b897deff275f1810963688e3b28964a37860b53a9a7e5c796a6b20ec479d902f5d3cd495bc6cec0c1e6b7b13b6c3
+  data.tar.gz: c31158a2e130412af7b96bcab1d3240fe235ce69686b58a7981ffb6f5b198d0f0b6200e5454b8b3c1634a37ca73cfbd88382e8fb1e01798f5a3b2bd33e1786fa

data/lib/vm_shepherd/aws_manager.rb

@@ -18,9 +18,9 @@ module VmShepherd
 
     def initialize(env_config:, logger:)
       AWS.config(
-        access_key_id:     env_config.fetch(:aws_access_key),
-        secret_access_key: env_config.fetch(:aws_secret_key),
-        region:            env_config.fetch(:region),
+        access_key_id:     env_config.fetch('aws_access_key'),
+        secret_access_key: env_config.fetch('aws_secret_key'),
+        region:            env_config.fetch('region'),
       )
       @env_config = env_config
       @logger     = logger
@@ -31,7 +31,7 @@ module VmShepherd
 
       cfm = AWS::CloudFormation.new
       logger.info('Starting CloudFormation Stack Creation')
-      stack = cfm.stacks.create(env_config.fetch(:stack_name), template, parameters: env_config.fetch(:parameters), capabilities: ['CAPABILITY_IAM'])
+      stack = cfm.stacks.create(env_config.fetch('stack_name'), template, parameters: env_config.fetch('parameters'), capabilities: ['CAPABILITY_IAM'])
 
       logger.info("Waiting for status: #{CREATE_COMPLETE}")
       retry_until(retry_limit: 60, retry_interval: 30) do
@@ -46,11 +46,11 @@ module VmShepherd
             false
           else
             stack.delete if status == ROLLBACK_COMPLETE
-            raise "Unexpected status for stack #{env_config.fetch(:stack_name)} : #{status}"
+            raise "Unexpected status for stack #{env_config.fetch('stack_name')} : #{status}"
         end
       end
 
-      env_config.fetch(:elbs, []).each do |elb_config|
+      env_config.fetch('elbs', []).each do |elb_config|
         create_elb(stack, elb_config)
       end
     end
@@ -64,9 +64,9 @@ module VmShepherd
           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),
+              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
@@ -85,7 +85,7 @@ module VmShepherd
         end
       end
 
-      vm_ip_address = vm_config.fetch(:vm_ip_address, nil)
+      vm_ip_address = vm_config.fetch('vm_ip_address', nil)
       if vm_ip_address
         logger.info('Associating existing IP to the instance')
         elastic_ip = AWS::EC2::ElasticIp.new(vm_ip_address)
@@ -97,20 +97,20 @@ module VmShepherd
         end
       end
       instance.associate_elastic_ip(elastic_ip)
-      instance.add_tag('Name', value: vm_config.fetch(:vm_name))
+      instance.add_tag('Name', value: vm_config.fetch('vm_name'))
     end
 
     def clean_environment
-      [:public_subnet_id, :private_subnet_id].each do |subnet_id|
-        aws_subnet_id = env_config.fetch(:outputs).fetch(subnet_id)
+      ['public_subnet_id', 'private_subnet_id'].each do |subnet_id|
+        aws_subnet_id = env_config.fetch('outputs').fetch(subnet_id)
         clear_subnet(aws_subnet_id) if aws_subnet_id
       end
 
-      env_config.fetch(:elbs, []).each do |elb_config|
-        delete_elb(elb_config[:name])
+      env_config.fetch('elbs', []).each do |elb_config|
+        delete_elb(elb_config['name'])
       end
 
-      bucket_names = env_config.fetch(:outputs, {}).fetch(:s3_bucket_names, []).compact
+      bucket_names = env_config.fetch('outputs', {}).fetch('s3_bucket_names', []).compact
       bucket_names.each do |bucket_name|
         next if bucket_name.empty?
         bucket = AWS::S3.new.buckets[bucket_name]
@@ -120,13 +120,13 @@ module VmShepherd
         end
       end
 
-      delete_stack(env_config.fetch(:stack_name))
+      delete_stack(env_config.fetch('stack_name'))
     end
 
     def destroy(vm_config)
       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)
+        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
           if elastic_ip
             elastic_ip.disassociate
@@ -141,11 +141,11 @@ module VmShepherd
     attr_reader :env_config, :logger
 
     def subnet_id(stack, elb_config)
-      stack.outputs.detect { |o| o.key == elb_config[:stack_output_keys][:subnet_id] }.value
+      stack.outputs.detect { |o| o.key == elb_config.dig('stack_output_keys', 'subnet_id') }.value
     end
 
     def vpc_id(stack, elb_config)
-      stack.outputs.detect { |o| o.key == elb_config[:stack_output_keys][:vpc_id] }.value
+      stack.outputs.detect { |o| o.key == elb_config.dig('stack_output_keys', 'vpc_id') }.value
     end
 
     def clear_subnet(subnet_id)
@@ -198,13 +198,13 @@ module VmShepherd
     def create_elb(stack, elb_config)
       elb        = AWS::ELB.new
       elb_params = {
-        load_balancer_name: elb_config[:name],
+        load_balancer_name: elb_config['name'],
         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_config['port_mappings'].each do |port_mapping|
         elb_params[:listeners] << {
           protocol:          'TCP', load_balancer_port: port_mapping[0],
           instance_protocol: 'TCP', instance_port: port_mapping[1]
@@ -218,7 +218,7 @@ module VmShepherd
     def create_security_group(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,
       }
@@ -227,7 +227,7 @@ module VmShepherd
       security_group_response = AWS.ec2.client.create_security_group(sg_params)
 
       AWS.ec2.security_groups[security_group_response[:group_id]].tap do |security_group|
-        elb_config[:port_mappings].each do |port_mapping|
+        elb_config['port_mappings'].each do |port_mapping|
           security_group.authorize_ingress(:tcp, port_mapping[0], '0.0.0.0/0')
         end
       end
@@ -260,7 +260,7 @@ module VmShepherd
     end
 
     def read_ami_id(ami_file_path)
-      YAML.load_file(ami_file_path)[env_config.fetch(:region)]
+      YAML.load_file(ami_file_path)[env_config.fetch('region')]
     end
   end
 end

data/lib/vm_shepherd/version.rb

@@ -1,3 +1,3 @@
 module VmShepherd
-  VERSION = '2.0.0'.freeze
+  VERSION = '2.0.1'.freeze
 end

data/spec/vm_shepherd/aws_manager_spec.rb

@@ -16,20 +16,20 @@ module VmShepherd
 
     let(:env_config) do
       {
-        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:     {
+        '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'     => {
           '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
 
@@ -38,7 +38,7 @@ module VmShepherd
 
     let(:vm_config) do
       {
-        vm_name: 'some-vm-name',
+        'vm_name' => 'some-vm-name',
       }
     end
     let(:fake_logger) { instance_double(Logger).as_null_object }
@@ -47,10 +47,10 @@ module VmShepherd
 
     before do
       expect(AWS).to receive(:config).with(
-          access_key_id:     env_config.fetch(:aws_access_key),
-          secret_access_key: env_config.fetch(:aws_secret_key),
-          region:            env_config.fetch(:region),
-        )
+        access_key_id:     env_config.fetch('aws_access_key'),
+        secret_access_key: env_config.fetch('aws_secret_key'),
+        region:            env_config.fetch('region'),
+      )
 
       allow(AWS).to receive(:ec2).and_return(ec2)
       allow(ami_manager).to receive(:sleep) # speed up retry logic
@@ -79,13 +79,13 @@ module VmShepherd
 
         it 'creates the stack with the correct parameters' do
           expect(stack_collection).to receive(:create).with(
-              'aws-stack-name',
-              '{}',
-              parameters:   {
-                'some_parameter' => 'some-answer',
-              },
-              capabilities: ['CAPABILITY_IAM']
-            )
+            'aws-stack-name',
+            '{}',
+            parameters:   {
+              'some_parameter' => 'some-answer',
+            },
+            capabilities: ['CAPABILITY_IAM']
+          )
           ami_manager.prepare_environment(cloudformation_template_file.path)
         end
 
@@ -97,7 +97,7 @@ module VmShepherd
 
         it 'stops retrying after 30 times' do
           expect(stack).to receive(:status).and_return('CREATE_IN_PROGRESS').
-              exactly(60).times
+            exactly(60).times
 
           expect { ami_manager.prepare_environment(cloudformation_template_file.path) }.to raise_error(AwsManager::RetryLimitExceeded)
         end
@@ -114,32 +114,32 @@ module VmShepherd
       context 'when the elb setting is present' do
         let(:extra_configs) do
           {
-            elbs: [
-                    {
-                      name:              'elb-1-name',
-                      port_mappings:     [[1111, 11]],
-                      stack_output_keys: {
-                        vpc_id:    'vpc_id',
-                        subnet_id: 'private_subnet',
-                      },
-                    },
-                    {
-                      name:              'elb-2-name',
-                      port_mappings:     [[2222, 22]],
-                      stack_output_keys: {
-                        vpc_id:    'vpc_id',
-                        subnet_id: 'private_subnet',
-                      },
-                    }
-                  ],
+            'elbs' => [
+              {
+                'name'              => 'elb-1-name',
+                'port_mappings'     => [[1111, 11]],
+                'stack_output_keys' => {
+                  'vpc_id'    => 'vpc_id',
+                  'subnet_id' => 'private_subnet',
+                },
+              },
+              {
+                'name'              => 'elb-2-name',
+                'port_mappings'     => [[2222, 22]],
+                'stack_output_keys' => {
+                  'vpc_id'    => 'vpc_id',
+                  'subnet_id' => 'private_subnet',
+                },
+              }
+            ],
           }
         end
         let(:stack) do
           instance_double(AWS::CloudFormation::Stack,
-            name:          'fake-stack-name',
-            creation_time: Time.utc(2015, 5, 29),
-            status:        'CREATE_COMPLETE',
-            outputs:       stack_outputs
+                          name:          'fake-stack-name',
+                          creation_time: Time.utc(2015, 5, 29),
+                          status:        'CREATE_COMPLETE',
+                          outputs:       stack_outputs
           )
         end
         let(:stack_outputs) do
@@ -167,9 +167,9 @@ module VmShepherd
         before do
           allow(ec2).to receive(:client).and_return(ec2_client)
           allow(ec2_client).to receive(:create_security_group).with(hash_including(group_name: 'fake-stack-name_elb-1-name')).
-              and_return(create_security_group_response_1)
+            and_return(create_security_group_response_1)
           allow(ec2_client).to receive(:create_security_group).with(hash_including(group_name: 'fake-stack-name_elb-2-name')).
-              and_return(create_security_group_response_2)
+            and_return(create_security_group_response_2)
           allow(ec2).to receive(:security_groups).and_return(security_groups)
           allow(elb_1_security_group).to receive(:authorize_ingress)
           allow(elb_2_security_group).to receive(:authorize_ingress)
@@ -231,11 +231,11 @@ module VmShepherd
 
       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',
-            security_group_ids: ['security-group-id'],
-            subnet:             'public-subnet-id',
-            instance_type:      'm3.medium').and_return(instance)
+          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)
 
         ami_manager.deploy(ami_file_path: ami_file_path, vm_config: vm_config)
       end
@@ -250,7 +250,7 @@ module VmShepherd
 
         it 'stops retrying after 60 times' do
           expect(instances).to receive(:create).and_raise(AWS::EC2::Errors::InvalidIPAddress::InUse).
-              exactly(AwsManager::RETRY_LIMIT).times
+            exactly(AwsManager::RETRY_LIMIT).times
 
           expect { ami_manager.deploy(ami_file_path: ami_file_path, vm_config: vm_config) }.to raise_error(AwsManager::RetryLimitExceeded)
         end
@@ -264,7 +264,7 @@ module VmShepherd
 
       it 'handles API endpoints not knowing (right away) about the instance created' do
         expect(instance).to receive(:status).and_raise(AWS::EC2::Errors::InvalidInstanceID::NotFound).
-            exactly(AwsManager::RETRY_LIMIT - 1).times
+          exactly(AwsManager::RETRY_LIMIT - 1).times
         expect(instance).to receive(:status).and_return(:running).once
 
         ami_manager.deploy(ami_file_path: ami_file_path, vm_config: vm_config)
@@ -272,7 +272,7 @@ module VmShepherd
 
       it 'stops retrying after 60 times' do
         expect(instance).to receive(:status).and_return(:pending).
-            exactly(AwsManager::RETRY_LIMIT).times
+          exactly(AwsManager::RETRY_LIMIT).times
 
         expect { ami_manager.deploy(ami_file_path: ami_file_path, vm_config: vm_config) }.to raise_error(AwsManager::RetryLimitExceeded)
       end
@@ -307,8 +307,8 @@ module VmShepherd
       context 'vm configuration contains an elastic IP' do
         let(:vm_config) do
           {
-            vm_name:       'some-vm-name',
-            vm_ip_address: 'some-ip-address'
+            'vm_name'       => 'some-vm-name',
+            'vm_ip_address' => 'some-ip-address'
           }
         end
 
@@ -392,13 +392,12 @@ module VmShepherd
 
       it 'stops retrying after 60 times' do
         expect(stack).to receive(:status).and_return('DELETE_IN_PROGRESS').
-            exactly(60).times
+          exactly(60).times
 
         expect { ami_manager.clean_environment }.to raise_error(AwsManager::RetryLimitExceeded)
       end
 
 
-
       it 'aborts if stack reports unexpected status' do
         expect(stack).to receive(:status).and_return('DELETE_IN_PROGRESS', 'UNEXPECTED_STATUS').ordered
         expect {
@@ -439,7 +438,7 @@ module VmShepherd
 
       context 'when a subnet is not provided' do
         before do
-          env_config[:outputs][:private_subnet_id] = nil
+          env_config['outputs']['private_subnet_id'] = nil
         end
 
         it 'only deletes instance 1' do
@@ -453,40 +452,40 @@ module VmShepherd
       context 'when an elb is configured' do
         let(:extra_configs) do
           {
-            elbs: [
-                    {
-                      name:              'elb-1-name',
-                      port_mappings:     [[1111, 11]],
-                      stack_output_keys: {
-                        vpc_id:    'vpc_id',
-                        subnet_id: 'private_subnet',
-                      },
-                    },
-                    {
-                      name:              'elb-2-name',
-                      port_mappings:     [[2222, 22]],
-                      stack_output_keys: {
-                        vpc_id:    'vpc_id',
-                        subnet_id: 'private_subnet',
-                      },
-                    }
-                  ],
+            'elbs' => [
+              {
+                'name'              => 'elb-1-name',
+                'port_mappings'     => [[1111, 11]],
+                'stack_output_keys' => {
+                  'vpc_id'    => 'vpc_id',
+                  'subnet_id' => 'private_subnet',
+                },
+              },
+              {
+                'name'              => 'elb-2-name',
+                'port_mappings'     => [[2222, 22]],
+                'stack_output_keys' => {
+                  'vpc_id'    => 'vpc_id',
+                  'subnet_id' => 'private_subnet',
+                },
+              }
+            ],
           }
         end
 
         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',
-            security_groups: [elb_1_security_group],
-            exists?:         false,
+                          name:            'elb-1-name',
+                          security_groups: [elb_1_security_group],
+                          exists?:         false,
           )
         end
         let(:load_balancer_2_to_delete) do
           instance_double(AWS::ELB::LoadBalancer,
-            name:            'elb-2-name',
-            security_groups: [elb_2_security_group],
-            exists?:         false,
+                          name:            'elb-2-name',
+                          security_groups: [elb_2_security_group],
+                          exists?:         false,
           )
         end
         let(:other_load_balancer) { instance_double(AWS::ELB::LoadBalancer, name: 'other-elb-name') }
@@ -494,39 +493,39 @@ module VmShepherd
         let(:elb_2_security_group) { instance_double(AWS::EC2::SecurityGroup, name: 'elb-2-security-group', id: 'sg-elb-2-id') }
         let(:network_interface_1_elb_1) do
           instance_double(AWS::EC2::NetworkInterface,
-            security_groups: [elb_1_security_group],
-            exists?:         false,
+                          security_groups: [elb_1_security_group],
+                          exists?:         false,
           )
         end
         let(:network_interface_2_elb_1) do
           instance_double(AWS::EC2::NetworkInterface,
-            security_groups: [elb_1_security_group],
-            exists?:         false,
+                          security_groups: [elb_1_security_group],
+                          exists?:         false,
           )
         end
         let(:network_interface_1_elb_2) do
           instance_double(AWS::EC2::NetworkInterface,
-            security_groups: [elb_2_security_group],
-            exists?:         false,
+                          security_groups: [elb_2_security_group],
+                          exists?:         false,
           )
         end
         let(:network_interface_2_elb_2) do
           instance_double(AWS::EC2::NetworkInterface,
-            security_groups: [elb_2_security_group],
-            exists?:         false,
+                          security_groups: [elb_2_security_group],
+                          exists?:         false,
           )
         end
 
         before do
           allow(AWS::ELB).to receive(:new).and_return(elb)
           allow(ec2).to receive(:network_interfaces).and_return(
-              [
-                network_interface_1_elb_1,
-                network_interface_2_elb_1,
-                network_interface_1_elb_2,
-                network_interface_2_elb_2,
-              ]
-            )
+            [
+              network_interface_1_elb_1,
+              network_interface_2_elb_1,
+              network_interface_1_elb_2,
+              network_interface_2_elb_2,
+            ]
+          )
           allow(load_balancer_1_to_delete).to receive(:delete)
           allow(load_balancer_2_to_delete).to receive(:delete)
           allow(elb_1_security_group).to receive(:delete)
@@ -535,7 +534,7 @@ module VmShepherd
 
         it 'waits for the ELBs to be deleted' do
           expect(load_balancer_1_to_delete).to receive(:exists?).and_return(true).
-              exactly(30).times
+            exactly(30).times
           expect(load_balancer_2_to_delete).not_to receive(:exists?)
 
           expect(elb_1_security_group).not_to receive(:delete).ordered
@@ -548,9 +547,9 @@ module VmShepherd
           allow(load_balancer_2_to_delete).to receive(:exists?).and_return(false)
 
           expect(network_interface_1_elb_1).to receive(:exists?).and_return(false).
-              exactly(30).times
+            exactly(30).times
           expect(network_interface_2_elb_1).to receive(:exists?).and_return(true).
-              exactly(30).times
+            exactly(30).times
           expect(network_interface_1_elb_2).not_to receive(:exists?)
           expect(network_interface_2_elb_2).not_to receive(:exists?)
 
@@ -627,7 +626,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' }
 
@@ -677,7 +676,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)
@@ -694,7 +693,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)
@@ -756,8 +755,8 @@ module VmShepherd
         let(:elastic_ip) { instance_double(AWS::EC2::ElasticIp) }
         let(:vm_config) do
           {
-            vm_name:       'some-vm-name',
-            vm_ip_address: 'some-ip-address'
+            'vm_name'       => 'some-vm-name',
+            'vm_ip_address' => 'some-ip-address'
           }
         end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vm_shepherd
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.1
 platform: ruby
 authors:
 - Ops Manager Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-08 00:00:00.000000000 Z
+date: 2016-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-v1