aerosol 1.7.0 → 1.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: bcb31cfba1584cdce2dfa12015e9fa229b0cc399
-  data.tar.gz: 827738fea59874eb7bf54961a7d3ff9327d9c6be
+SHA256:
+  metadata.gz: 6d4984e8f3a4ad49c8fcf43ee3f8a46afc0a8ff5a03bc17e0e2a7c5ae51d5ff9
+  data.tar.gz: 6a02a6faf80b6a0bc3ccb317df748dac95d994f4a0fb146724ed844240727451
 SHA512:
-  metadata.gz: 8a1de687a21e221f2a221a132cc570254f6637fe2c51ba1686baa460dc6eff70a1b454034bc907d05d2bfc253eb663a1640351d3f4b49dcd9be8eac3abe84cd6
-  data.tar.gz: 4a566f867c011016eefabd719c27d289eacf737edbc553f88e1a80359d4272c0c80d8ce8bb3d561328a9b648eab62a0f9e1fb061c4b240dcaedf3cef05e0175b
+  metadata.gz: ddb94dbd6f44e8cb419d6051fc0e5855a8bc5bb9ce45de11e35da6600831d0a8f8928990d0429aa6f415b80a91381c4c198a5c1d8a2a341f7ea47992b2417178
+  data.tar.gz: 5f2488d1ec6336cb2a4a3aea9dadd7ab030b788bfb72fffb8723369857e875ccba832d88ecba070098c750d208de76c74ac5ee9c80cb4879f497e9f829435e0a

data/.travis.yml

@@ -2,10 +2,9 @@ sudo: false
 dist: trusty
 language: ruby
 rvm:
-    - 1.9.3
-    - 2.0
     - 2.1
     - 2.2
+    - 2.7
 cache: bundler
-before_install: gem install bundler
+before_install: gem install bundler -v 1.17.3
 script: CI=true bundle exec rake

data/aerosol.gemspec

@@ -18,7 +18,10 @@ Gem::Specification.new do |gem|
   gem.add_dependency 'activerecord', '>= 3.2.0'
   gem.add_dependency 'clamp', '~> 0.6'
   gem.add_dependency 'excon'
-  gem.add_dependency 'aws-sdk', '~> 2.0'
+  gem.add_dependency 'aws-sdk-core', '~> 3'
+  gem.add_dependency 'aws-sdk-s3', '~> 1'
+  gem.add_dependency 'aws-sdk-ec2', '~> 1'
+  gem.add_dependency 'aws-sdk-autoscaling', '~> 1'
   gem.add_dependency 'minigit', '~> 0.0.4'
   gem.add_dependency 'net-ssh'
   gem.add_dependency 'net-ssh-gateway'

data/lib/aerosol.rb

@@ -1,5 +1,8 @@
 require 'yaml'
-require 'aws-sdk'
+require 'aws-sdk-autoscaling'
+require 'aws-sdk-core'
+require 'aws-sdk-s3'
+require 'aws-sdk-ec2'
 require 'dockly/util'
 require 'base64'
 
@@ -10,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'
@@ -58,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
     }
@@ -67,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|
@@ -79,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,12 @@ 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,
+    proc { |argument| argument.fetch(:launch_template, {})[:launch_template_name] }
+  )
+
   primary_key :auto_scaling_group_name
 
   def initialize(options={}, &block)
@@ -38,21 +44,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' unless launch_details
 
     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!
@@ -60,9 +75,9 @@ class Aerosol::AutoScaling
     conn.delete_auto_scaling_group(auto_scaling_group_name: auto_scaling_group_name, force_delete: true)
     begin
       (0..2).each { break if deleting?; sleep 1 }
-      launch_configuration.destroy
+      launch_details.destroy
     rescue => ex
-      info "Launch Config: #{launch_configuration} for #{auto_scaling_group_name} was not deleted."
+      info "Launch Details: #{launch_details} for #{auto_scaling_group_name} were not deleted."
       info ex.message
     end
   end
@@ -78,7 +93,11 @@ class Aerosol::AutoScaling
   def all_instances
     conn.describe_auto_scaling_groups(auto_scaling_group_names: [*auto_scaling_group_name])
         .auto_scaling_groups.first
-        .instances.map { |instance| Aerosol::Instance.from_hash(instance) }
+        .instances.map { |instance| Aerosol::Instance.from_hash(instance.to_hash) }
+  end
+
+  def launch_details
+    launch_configuration || launch_template
   end
 
   def tag(val)
@@ -147,6 +166,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/aws_model.rb

@@ -47,13 +47,15 @@ module Aerosol::AWSModel
       aws_attributes.merge(attrs)
     end
 
-    def aws_class_attribute(name, klass)
+    def aws_class_attribute(name, klass, primary_key_proc = nil)
       unless klass.ancestors.include?(Aerosol::AWSModel) || (klass == self)
         raise '.aws_class_attribute requires a Aerosol::AWSModel that is not the current class.'
       end
 
+      primary_key_proc ||= proc { |hash| hash[klass.primary_key] }
+
       dsl_class_attribute(name, klass)
-      aws_class_attributes.merge!({ name => klass })
+      aws_class_attributes.merge!({ name => [klass, primary_key_proc] })
     end
 
     def exists?(key)
@@ -67,9 +69,9 @@ module Aerosol::AWSModel
 
     def from_hash(hash)
       raise 'To use .from_hash, you must specify a primary_key' if primary_key.nil?
-      refs = Hash[aws_class_attributes.map do |name, klass|
+      refs = Hash[aws_class_attributes.map do |name, (klass, primary_key_proc)|
         value = klass.instances.values.find do |inst|
-          inst.send(klass.primary_key).to_s == hash[klass.primary_key].to_s unless inst.send(klass.primary_key).nil?
+          inst.send(klass.primary_key).to_s == primary_key_proc.call(hash).to_s unless inst.send(klass.primary_key).nil?
         end
         [name, value]
       end].reject { |k, v| v.nil? }

data/lib/aerosol/instance.rb

@@ -5,6 +5,11 @@ class Aerosol::Instance
 
   aws_attribute :availability_zone, :health_status, :instance_id, :lifecycle_state
   aws_class_attribute :launch_configuration, Aerosol::LaunchConfiguration
+  aws_class_attribute(
+    :launch_template,
+    Aerosol::LaunchTemplate,
+    proc { |argument| argument.fetch(:launch_template, {})[:launch_template_name] }
+  )
   primary_key :instance_id
 
   def live?

data/lib/aerosol/launch_configuration.rb

@@ -5,7 +5,7 @@ class Aerosol::LaunchConfiguration
   logger_prefix '[aerosol launch_configuration]'
   aws_attribute :launch_configuration_name, :image_id, :instance_type, :security_groups, :user_data,
                 :iam_instance_profile, :kernel_id, :key_name, :spot_price, :created_time,
-                :associate_public_ip_address, :block_device_mappings
+                :associate_public_ip_address, :block_device_mappings, :ebs_optimized
   dsl_attribute :meta_data
 
   primary_key :launch_configuration_name
@@ -89,7 +89,8 @@ class Aerosol::LaunchConfiguration
 "key_name" => "#{key_name}", \
 "spot_price" => "#{spot_price}", \
 "created_time" => "#{created_time}", \
-"block_device_mappings" => #{block_device_mappings}" \
+"block_device_mappings" => #{block_device_mappings}", \
+"ebs_optimized" => #{ebs_optimized} \
 }}
   end
 
@@ -109,7 +110,8 @@ private
       spot_price: spot_price,
       user_data: corrected_user_data,
       associate_public_ip_address: associate_public_ip_address,
-      block_device_mappings: block_device_mappings
+      block_device_mappings: block_device_mappings,
+      ebs_optimized: ebs_optimized
     }.reject { |k, v| v.nil? }
   end
 

data/lib/aerosol/launch_template.rb

@@ -0,0 +1,127 @@
+class Aerosol::LaunchTemplate
+  include Aerosol::AWSModel
+  include Dockly::Util::Logger::Mixin
+
+  logger_prefix '[aerosol launch_template]'
+  aws_attribute :launch_template_name, :launch_template_id, :latest_version_number,
+                :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 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_name == 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}", \
+"launch_template_id" => "#{launch_template_id}", \
+"latest_version_number" => "#{latest_version_number}", \
+"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/runner.rb

@@ -229,7 +229,7 @@ class Aerosol::Runner
 
   def old_instances
     require_deploy!
-    old_auto_scaling_groups.map(&:launch_configuration).compact.map(&:all_instances).flatten.compact
+    old_auto_scaling_groups.map(&:launch_details).compact.map(&:all_instances).flatten.compact
   end
 
   def old_auto_scaling_groups
@@ -243,6 +243,7 @@ class Aerosol::Runner
   def select_auto_scaling_groups(&block)
     require_deploy!
     Aerosol::LaunchConfiguration.all # load all of the launch configurations first
+    Aerosol::LaunchTemplate.all
     Aerosol::AutoScaling.all.select { |asg|
       (asg.tags['Deploy'].to_s == auto_scaling.tags['Deploy']) &&
         (block.nil? ? true : block.call(asg))
@@ -251,11 +252,13 @@ class Aerosol::Runner
 
   def new_instances
     require_deploy!
-    while launch_configuration.all_instances.length < auto_scaling.min_size
+
+    while launch_details.all_instances.length < auto_scaling.min_size
       info "Waiting for instances to come up"
       sleep 10
     end
-    launch_configuration.all_instances
+
+    launch_details.all_instances
   end
 
   def with_deploy(name)
@@ -280,7 +283,7 @@ class Aerosol::Runner
            :live_check, :db_config_path, :instance_live_grace_period,
            :app_port, :continue_if_stop_app_fails, :stop_app_retries,
            :is_alive?, :log_files, :tail_logs, :to => :deploy
-  delegate :launch_configuration, :to => :auto_scaling
+  delegate :launch_details, :to => :auto_scaling
 
 private
 

data/lib/aerosol/version.rb

@@ -1,5 +1,5 @@
 # Copyright Swipely, Inc.  All rights reserved.
 
 module Aerosol
-  VERSION = '1.7.0'
+  VERSION = '1.9.2'
 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

data/spec/aerosol/runner_spec.rb

@@ -253,6 +253,57 @@ describe Aerosol::Runner do
   end
 
   describe '#new_instances' do
+    context 'With a launch template' do
+      let!(:lt) do
+        Aerosol::LaunchTemplate.new! do
+          name :lt
+          image_id 'fake-ami-how-scandalous'
+          instance_type 'm1.large'
+        end
+      end
+      let!(:asg_lt) do
+        Aerosol::AutoScaling.new! do
+          name :asg_lt
+          availability_zones 'us-east-1'
+          min_size 0
+          max_size 3
+          launch_template :lt
+          stub(:sleep)
+        end
+      end
+      let!(:instance1) do
+        Aerosol::Instance.from_hash(
+          {
+            instance_id: 'z0',
+            launch_template: { launch_template_name: lt.launch_template_name }
+          }
+        )
+      end
+      let!(:instance2) do
+        double(
+          :launch_template => double(:launch_template_name => 'lc7-8891022'),
+          :launch_configuration => nil
+        )
+      end
+      let!(:instance3) do
+        double(
+          :launch_template => nil,
+          :launch_configuration => double(:launch_configuration_name => 'lc0-8891022')
+        )
+      end
+
+      before do
+        Aerosol::Instance.stub(:all).and_return([instance1, instance2, instance3])
+      end
+
+      it 'returns each instance that is a member of the current launch template' do
+        deploy = Aerosol::Deploy.new!(name: :lt_deploy, auto_scaling: :asg_lt)
+        subject.with_deploy(:lt_deploy) do
+          subject.new_instances.should == [instance1]
+        end
+      end
+    end
+
     let!(:lc7) do
       Aerosol::LaunchConfiguration.new! do
         name :lc7

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aerosol
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 1.9.2
 platform: ruby
 authors:
 - Swipely, Inc.
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-10-06 00:00:00.000000000 Z
+date: 2021-04-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -53,19 +53,61 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: aws-sdk
+  name: aws-sdk-core
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-s3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-ec2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-autoscaling
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
 - !ruby/object:Gem::Dependency
   name: minigit
   requirement: !ruby/object:Gem::Requirement
@@ -238,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
@@ -250,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
@@ -259,7 +303,7 @@ homepage: https://github.com/swipely/aerosol
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -274,9 +318,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.6
-signing_key: 
+rubygems_version: 3.0.3
+signing_key:
 specification_version: 4
 summary: Instance-based deploys made easy
 test_files:
@@ -288,9 +331,9 @@ 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
 - spec/spec_helper.rb
 - spec/support/vcr.rb
-has_rdoc: