aerosol 1.8.0 → 1.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8800e253ba3945d047a0186145a0aa58bc2d1ea2374ca6cc3e8f9e102a8ad510
-  data.tar.gz: 9748857dd6d759985cf7e1071364474dbb013b2eff7eae3c86616e0eebcc1879
+  metadata.gz: 5c51be45f1098f15a79cbab049755110bf351bed1661bb5b28504ab34c613f01
+  data.tar.gz: 235972faf898d0cc796cdf0b7de74f05a6c3aa396dc13b9f0f8909fb1229cecb
 SHA512:
-  metadata.gz: 143084a0ffcd6ed83e36bea8a106e88776cc146adacc7d55b3976f52fd0ce80d6e0c7543311c5d82110900ce927cca5ca29bb4a06903131497d88ae7ed02a7f6
-  data.tar.gz: 4ea6f13e4f3464f04ab05bd33d504f586c5206cbf13bfbdeed63411ad2a2170b812631d8185c18981a8c46dfc55d5f18d189a59826b04129aca4c14d034148a3
+  metadata.gz: 5aa215e96061f829d5042d72c56495f0059cb716b12b89386ca84e7b5568b6993d39a18d07e216c90de2af96ba742d5ea588c733e0303d275ffdb16bfb7f8965
+  data.tar.gz: 890ced1dce45bcf8ab1de6d60834f78bd881490efd9d7473ada54ac92359a691c53f031959c9cb7e08fb1745c7d9ada0abb84b00913d83e5166cb661c252fdbd

data/lib/aerosol.rb

@@ -13,6 +13,7 @@ module Aerosol
   require 'aerosol/util'
   require 'aerosol/aws_model'
   require 'aerosol/launch_configuration'
+  require 'aerosol/launch_template'
   require 'aerosol/auto_scaling'
   require 'aerosol/instance'
   require 'aerosol/connection'
@@ -61,6 +62,7 @@ module Aerosol
       :auto_scalings => Aerosol::AutoScaling.instances,
       :deploys => Aerosol::Deploy.instances,
       :launch_configurations => Aerosol::LaunchConfiguration.instances,
+      :launch_templates => Aerosol::LaunchTemplate.instances,
       :sshs => Aerosol::Connection.instances,
       :envs => Aerosol::Env.instances
     }
@@ -70,6 +72,7 @@ module Aerosol
     :auto_scaling => Aerosol::AutoScaling,
     :deploy => Aerosol::Deploy,
     :launch_configuration => Aerosol::LaunchConfiguration,
+    :launch_template => Aerosol::LaunchTemplate,
     :ssh => Aerosol::Connection,
     :env => Aerosol::Env
   }.each do |method, klass|
@@ -82,15 +85,15 @@ module Aerosol
     end
   end
 
-  [:auto_scalings, :deploys, :launch_configurations, :sshs, :envs].each do |method|
+  [:auto_scalings, :deploys, :launch_configurations, :launch_templates, :sshs, :envs].each do |method|
     define_method(method) do
       inst[method]
     end
   end
 
   module_function :inst, :load_inst, :setup, :load_file, :load_file=,
-                  :auto_scaling,  :launch_configuration,  :deploy,  :ssh, :git_sha,
-                  :auto_scalings, :launch_configurations, :deploys, :sshs,
+                  :auto_scaling,  :launch_configuration, :launch_template,  :deploy,  :ssh, :git_sha,
+                  :auto_scalings, :launch_configurations, :launch_templates, :deploys, :sshs,
                   :namespace, :env, :envs, :region
 end
 

data/lib/aerosol/auto_scaling.rb

@@ -7,6 +7,7 @@ class Aerosol::AutoScaling
                 :desired_capacity, :health_check_grace_period, :health_check_type, :load_balancer_names,
                 :placement_group, :tags, :created_time, :vpc_zone_identifier, :target_group_arns
   aws_class_attribute :launch_configuration, Aerosol::LaunchConfiguration
+  aws_class_attribute :launch_template, Aerosol::LaunchTemplate
   primary_key :auto_scaling_group_name
 
   def initialize(options={}, &block)
@@ -38,21 +39,30 @@ class Aerosol::AutoScaling
   end
 
   def create!
-    ensure_present! :launch_configuration, :max_size, :min_size
+    ensure_present! :max_size, :min_size
     raise 'availability_zones or vpc_zone_identifier must be set' if [availability_zones, vpc_zone_identifier].none?
+    raise 'launch_configuration or launch_template must be set' if [launch_configuration, launch_template].none?
 
     info "creating auto scaling group"
-    launch_configuration.create
+    launch_details = create_launch_details
+
     info self.inspect
 
     conn.create_auto_scaling_group({
       auto_scaling_group_name: auto_scaling_group_name,
       availability_zones: [*availability_zones],
-      launch_configuration_name: launch_configuration.launch_configuration_name,
       max_size: max_size,
       min_size: min_size
-    }.merge(create_options))
-    sleep 10
+    }
+      .merge(create_options)
+      .merge(launch_details)
+    )
+
+    conn.wait_until(:group_in_service, auto_scaling_group_names: [auto_scaling_group_name]) do |waiter|
+      waiter.before_wait do |attempt_count, _response|
+        info "Wait count #{attempt_count} of #{waiter.max_attempts} for #{auto_scaling_group_name} to be in service"
+      end
+    end
   end
 
   def destroy!
@@ -147,6 +157,22 @@ private
     Aerosol::AWS.auto_scaling
   end
 
+  def create_launch_details
+    if launch_configuration
+      launch_configuration.create
+      { launch_configuration_name: launch_configuration.launch_configuration_name }
+    elsif launch_template
+      launch_template.create
+      {
+        launch_template:
+        {
+          launch_template_name: launch_template.launch_template_name,
+          version: '$Latest'
+        }
+      }
+    end
+  end
+
   def create_options
     {
       default_cooldown: default_cooldown,

data/lib/aerosol/launch_template.rb

@@ -0,0 +1,133 @@
+class Aerosol::LaunchTemplate
+  include Aerosol::AWSModel
+  include Dockly::Util::Logger::Mixin
+
+  logger_prefix '[aerosol launch_template]'
+  aws_attribute :launch_template_name, :image_id, :instance_type, :security_groups, :user_data,
+                :iam_instance_profile, :kernel_id, :key_name, :spot_price, :created_time,
+                :network_interfaces, :block_device_mappings, :ebs_optimized
+  dsl_attribute :meta_data
+
+  primary_key :launch_template_name
+  default_value(:security_groups) { [] }
+  default_value(:meta_data) { {} }
+
+  def launch_template_name(arg = nil)
+    if arg
+      raise "You cannot set the launch_template_name directly" unless from_aws
+      @launch_template_name = arg
+    else
+      @launch_template_name || default_identifier
+    end
+  end
+
+  def exists?
+    info "launch_template: needed?: #{launch_template_name}: " +
+         "checking for launch template: #{launch_template_name}"
+    exists = super
+    info "launch template: needed?: #{launch_template_name}: " +
+         "#{exists ? 'found' : 'did not find'} launch template: #{launch_template_name}"
+    exists
+  end
+
+  def security_group(group)
+    security_groups << group
+  end
+
+  def create!
+    ensure_present! :image_id, :instance_type
+
+    info "creating launch template"
+    conn.create_launch_template(
+      launch_template_name: launch_template_name,
+      launch_template_data: {
+        image_id: image_id,
+        instance_type: instance_type,
+        monitoring: {
+          enabled: true
+        },
+      }.merge(create_options)
+    )
+    info self.inspect
+  end
+
+  def destroy!
+    info self.to_s
+    raise StandardError.new('No launch_template_name found') unless launch_template_name
+    conn.delete_launch_template(launch_template_name: launch_template_name)
+  end
+
+  def all_instances
+    Aerosol::Instance.all.select { |instance|
+      !instance.launch_template.nil? &&
+        (instance.launch_template.launch_template == launch_template_name)
+    }.each(&:description)
+  end
+
+  def self.request_all_for_token(next_token)
+    options = next_token.nil? ? {} : { next_token: next_token }
+    Aerosol::AWS.compute.describe_launch_templates(options)
+  end
+
+  def self.request_all
+    next_token = nil
+    lts = []
+
+    begin
+      new_lts = request_all_for_token(next_token)
+      lts.concat(new_lts.launch_templates)
+      next_token = new_lts.next_token
+    end until next_token.nil?
+
+    lts
+  end
+
+  def to_s
+    %{Aerosol::LaunchTemplate { \
+"launch_template_name" => "#{launch_template_name}", \
+"image_id" => "#{image_id}", \
+"instance_type" => "#{instance_type}", \
+"security_group_ids" => #{security_groups.to_s}, \
+"user_data" => "#{user_data}", \
+"iam_instance_profile" => "#{iam_instance_profile}", \
+"kernel_id" => "#{kernel_id}", \
+"key_name" => "#{key_name}", \
+"spot_price" => "#{spot_price}", \
+"created_time" => "#{created_time}", \
+"block_device_mappings" => #{block_device_mappings}", \
+"ebs_optimized" => #{ebs_optimized} \
+}}
+  end
+
+  def corrected_user_data
+    realized_user_data = user_data.is_a?(Proc) ? user_data.call : user_data
+
+    Base64.encode64(Aerosol::Util.strip_heredoc(realized_user_data || ''))
+  end
+
+private
+  def create_options
+    instance_market_options = {
+      market_type: 'spot',
+      spot_options: {
+        max_price: spot_price
+      }
+    } if spot_price
+
+    {
+      iam_instance_profile: { name: iam_instance_profile },
+      kernel_id: kernel_id,
+      key_name: key_name,
+      security_group_ids: security_groups,
+      instance_market_options: instance_market_options,
+      user_data: corrected_user_data,
+      network_interfaces: network_interfaces,
+      block_device_mappings: block_device_mappings,
+      ebs_optimized: ebs_optimized,
+    }.reject { |k, v| v.nil? }
+  end
+
+  def conn
+    Aerosol::AWS.compute
+  end
+end

data/lib/aerosol/version.rb

@@ -1,5 +1,5 @@
 # Copyright Swipely, Inc.  All rights reserved.
 
 module Aerosol
-  VERSION = '1.8.0'
+  VERSION = '1.9.0'
 end

data/spec/aerosol/launch_template_spec.rb

@@ -0,0 +1,402 @@
+require 'spec_helper'
+
+describe Aerosol::LaunchTemplate do
+  subject do
+    described_class.new do
+      name :my_launch_template
+      image_id 'ami-123'
+      instance_type 'super-cool-instance-type'
+      user_data <<-END_OF_STRING
+        #!/bin/bash
+        rm -rf /
+      END_OF_STRING
+    end
+  end
+  before { subject.stub(:sleep) }
+
+  describe "#launch_template_name" do
+    context "with no namespace set" do
+      let(:identifier) { "my_launch_template-#{Aerosol::Util.git_sha}" }
+      it "returns a normal identifier" do
+        expect(subject.launch_template_name).to eq(identifier)
+      end
+    end
+
+    context "with a namespace set" do
+      let(:namespace) { "test" }
+      let(:identifier) { "#{namespace}-my_launch_template-#{Aerosol::Util.git_sha}" }
+
+      before { Aerosol.namespace namespace }
+      after { Aerosol.instance_variable_set(:"@namespace", nil) }
+
+      it "returns a namespaced identifier" do
+        expect(subject.launch_template_name).to eq(identifier)
+      end
+    end
+  end
+
+  describe '#security_group' do
+    subject { described_class.new!(:name => 'conf-conf-conf') }
+
+    it 'adds the argument to the list of security groups' do
+      expect { subject.security_group 'my group' }
+          .to change { subject.security_groups.length }
+          .by 1
+    end
+
+    it 'does not the default security group' do
+      expect { subject.security_group 'other test' }
+          .to_not change { described_class.default_values[:security_groups] }
+    end
+  end
+
+  describe '#create!' do
+    context 'when some required fields are nil' do
+      before { subject.instance_variable_set(:@image_id, nil) }
+
+      it 'raises an error' do
+        expect { subject.create! }.to raise_error
+      end
+    end
+
+    context 'when everything is present' do
+      context 'and the launch template already exists' do
+        it 'raises an error' do
+          Aerosol::AWS.compute.stub_responses(
+            :create_launch_template,
+            Aws::EC2::Errors::AlreadyExists
+          )
+          expect { subject.create! }.to raise_error
+        end
+      end
+
+      context 'and the launch template does not exist yet' do
+        after { subject.destroy! rescue nil }
+
+        it 'creates the launch template group' do
+          Aerosol::AWS.compute.stub_responses(:create_launch_template, [])
+          expect { subject.create! }.to_not raise_error
+        end
+      end
+    end
+  end
+
+  describe '#destroy!' do
+    context 'when the launch_template_name is nil' do
+
+      it 'raises an error' do
+        allow(subject).to receive(:launch_template_name).and_return(nil)
+        Aerosol::AWS.compute.stub_responses(:delete_launch_template, [])
+        expect { subject.destroy! }.to raise_error
+      end
+    end
+
+    context 'when the launch_template_name is present' do
+      context 'but the launch template does not exist' do
+        it 'raises an error' do
+          Aerosol::AWS.compute.stub_responses(
+            :delete_launch_template,
+            Aws::EC2::Errors::ValidationError
+          )
+          expect { subject.destroy! }.to raise_error
+        end
+      end
+
+      context 'and the launch template exists' do
+        it 'deletes the launch template' do
+          Aerosol::AWS.compute.stub_responses(:delete_launch_template, [])
+          expect { subject.destroy! }.to_not raise_error
+        end
+      end
+    end
+  end
+
+  describe '#create' do
+    context 'when the launch_template_name is nil' do
+      subject do
+        described_class.new! do
+          name :random_test_name
+          image_id 'test-ami-who-even-cares-really'
+          instance_type 'm1.large'
+        end
+      end
+
+      it 'raises an error' do
+        allow(subject).to receive(:launch_template_name).and_return(nil)
+        Aerosol::AWS.compute.stub_responses(:create_launch_template, [])
+        Aerosol::AWS.compute.stub_responses(:describe_launch_templates, {
+          launch_templates: [], next_token: nil
+        })
+        expect { subject.create }.to raise_error
+      end
+    end
+
+    context 'when the launch_template_name is present' do
+      subject do
+        described_class.new! do
+          name :random_test_name_2
+          image_id 'test-ami-who-even-cares-really'
+          instance_type 'm1.large'
+        end
+      end
+
+      context 'but the launch template already exists' do
+        it 'does not call #create!' do
+          Aerosol::AWS.compute.stub_responses(:describe_launch_templates, {
+            launch_templates: [{
+              launch_template_name: subject.launch_template_name,
+            }],
+            next_token: nil
+          })
+          expect(subject).to_not receive(:create!)
+          subject.create
+        end
+      end
+
+      context 'and the launch template does not yet exist' do
+        it 'creates it' do
+          Aerosol::AWS.compute.stub_responses(:describe_launch_templates, {
+            launch_templates: [],
+            next_token: nil
+          })
+          subject.should_receive(:create!)
+          subject.create
+        end
+      end
+    end
+  end
+
+  describe '#destroy' do
+    subject do
+      described_class.new! do
+        name :random_test_name_3
+        image_id 'awesome-ami'
+        instance_type 'm1.large'
+      end
+    end
+
+    context 'when the launch_template_name is nil' do
+      it 'raises an error' do
+        allow(subject).to receive(:launch_template_name).and_return(nil)
+        Aerosol::AWS.compute.stub_responses(:describe_launch_templates, {
+          launch_templates: [],
+          next_token: nil
+        })
+        expect { subject.create }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'when the launch_template_name is present' do
+      context 'and the launch template already exists' do
+
+        it 'calls #destroy!' do
+          Aerosol::AWS.compute.stub_responses(:describe_launch_templates, {
+            launch_templates: [{
+              launch_template_name: subject.launch_template_name
+            }],
+            next_token: nil
+          })
+          subject.should_receive(:destroy!)
+          subject.destroy
+        end
+      end
+
+      context 'but the launch template does not yet exist' do
+        it 'does not call #destroy!' do
+          Aerosol::AWS.compute.stub_responses(:describe_launch_templates, {
+            launch_templates: [],
+            next_token: nil
+          })
+          subject.should_not_receive(:destroy!)
+          subject.destroy
+        end
+      end
+    end
+  end
+
+  describe '.exists?' do
+    subject { described_class }
+    let(:instance) do
+      subject.new! do
+        name :exists_test_name
+        image_id 'ami123'
+        instance_type 'm1.large'
+        stub(:sleep)
+      end
+    end
+
+    context 'when the argument exists' do
+      it 'returns true' do
+        Aerosol::AWS.compute.stub_responses(:describe_launch_templates, {
+          launch_templates: [{
+            launch_template_name: instance.launch_template_name,
+          }],
+          next_token: nil
+        })
+        subject.exists?(instance.launch_template_name).should be_true
+      end
+    end
+
+    context 'when the argument does not exist' do
+      let(:instance) { described_class.new!   }
+
+      it 'returns false' do
+        Aerosol::AWS.compute.stub_responses(:describe_launch_templates, {
+          launch_templates: [],
+          next_token: nil
+        })
+        subject.exists?(instance.launch_template_name).should be_false
+      end
+    end
+  end
+
+  describe '.request_all' do
+    describe 'repeats until no NextToken' do
+      it 'should include both autoscaling groups lists' do
+        Aerosol::AWS.compute.stub_responses(:describe_launch_templates, [
+          {
+            launch_templates: [
+              { launch_template_name: '1' },
+              { launch_template_name: '4' }
+            ],
+            next_token: 'yes'
+          },
+          {
+            launch_templates: [
+              { launch_template_name: '2' },
+              { launch_template_name: '3' }
+            ],
+            next_token: nil
+          }
+        ])
+        expect(Aerosol::LaunchTemplate.request_all.map(&:launch_template_name)).to eq(['1','4','2','3'])
+      end
+    end
+  end
+
+  describe '.all' do
+    subject { described_class }
+
+    context 'when there are no launch templates' do
+      before do
+        Aerosol::AWS.compute.stub_responses(:describe_launch_templates, [
+          { launch_templates: [], next_token: nil }
+        ])
+      end
+      its(:all) { should be_empty }
+    end
+
+    context 'when there are launch templates' do
+      let(:insts) {
+        [
+          { launch_template_name: 'test' },
+          { launch_template_name: 'test2' }
+        ]
+      }
+
+      it 'returns each of them' do
+        Aerosol::AWS.compute.stub_responses(:describe_launch_templates, {
+          launch_templates: insts,
+          next_token: nil
+        })
+        subject.all.map(&:launch_template_name).should == %w[test test2]
+      end
+    end
+  end
+
+  describe '.from_hash' do
+    context 'when the launch template has not been initialized' do
+      subject { described_class.from_hash(hash) }
+      let(:hash) do
+        {
+          launch_template_name: '~test-launch-config~',
+          image_id: 'ami-123',
+          instance_type: 'm1.large',
+          security_groups: [],
+          user_data: 'echo hi',
+          iam_instance_profile: nil,
+          kernel_id: 'kernel-id',
+          key_name: 'key-name',
+          spot_price: '0.04',
+        }
+      end
+
+      it 'creates a new launch template with the specified values' do
+        subject.launch_template_name.should == '~test-launch-config~'
+        subject.image_id.should == 'ami-123'
+        subject.instance_type.should == 'm1.large'
+        subject.security_groups.should be_empty
+        subject.user_data.should == 'echo hi'
+        subject.iam_instance_profile.should be_nil
+        subject.kernel_id.should == 'kernel-id'
+        subject.spot_price.should == '0.04'
+        subject.from_aws = true
+      end
+
+      it 'generates a name' do
+        subject.name.to_s.should start_with 'LaunchTemplate_'
+      end
+    end
+
+    context 'when the launch template has already been initialized' do
+      let(:old_hash) do
+        {
+          launch_template_name: 'this-aws-id-abc-123',
+          image_id: 'ami-456',
+        }
+      end
+      let(:new_hash) { old_hash.merge(instance_type: 'm1.large') }
+      let!(:existing) { described_class.from_hash(old_hash) }
+      let(:new) { described_class.from_hash(new_hash) }
+
+      it 'makes a new instance' do
+        expect { new }.to change { described_class.instances.length }.by(1)
+        new.launch_template_name.should == 'this-aws-id-abc-123'
+        new.image_id.should == 'ami-456'
+      end
+    end
+  end
+
+  describe '#corrected_user_data' do
+    let(:encoded_user_data_string) { Base64.encode64('test') }
+
+    context 'when the user_data is a String' do
+      subject do
+        described_class.new do
+          name :corrected_user_data
+          user_data 'test'
+        end
+      end
+
+      it 'correctly encodes to base64' do
+        expect(subject.corrected_user_data).to eq(encoded_user_data_string)
+      end
+    end
+
+    context 'when the user_data is a Proc' do
+      subject do
+        described_class.new do
+          name :corrected_user_data_2
+          user_data { 'test' }
+        end
+      end
+
+      it 'correctly encodes to base64' do
+        expect(subject.corrected_user_data).to eq(encoded_user_data_string)
+      end
+    end
+  end
+
+  describe '#meta_data' do
+    subject do
+      described_class.new do
+        name :my_launch_template
+        meta_data('Test' => '1')
+      end
+    end
+
+    it 'returns the hash' do
+      expect(subject.meta_data['Test']).to eq('1')
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aerosol
 version: !ruby/object:Gem::Version
-  version: 1.8.0
+  version: 1.9.0
 platform: ruby
 authors:
 - Swipely, Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-01-29 00:00:00.000000000 Z
+date: 2021-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -280,6 +280,7 @@ files:
 - lib/aerosol/env.rb
 - lib/aerosol/instance.rb
 - lib/aerosol/launch_configuration.rb
+- lib/aerosol/launch_template.rb
 - lib/aerosol/rake_task.rb
 - lib/aerosol/runner.rb
 - lib/aerosol/util.rb
@@ -292,6 +293,7 @@ files:
 - spec/aerosol/env_spec.rb
 - spec/aerosol/instance_spec.rb
 - spec/aerosol/launch_configuration_spec.rb
+- spec/aerosol/launch_template_spec.rb
 - spec/aerosol/rake_task_spec.rb
 - spec/aerosol/runner_spec.rb
 - spec/aerosol_spec.rb
@@ -329,6 +331,7 @@ test_files:
 - spec/aerosol/env_spec.rb
 - spec/aerosol/instance_spec.rb
 - spec/aerosol/launch_configuration_spec.rb
+- spec/aerosol/launch_template_spec.rb
 - spec/aerosol/rake_task_spec.rb
 - spec/aerosol/runner_spec.rb
 - spec/aerosol_spec.rb