rivet 1.4.0 → 2.0.0

data/lib/rivet/launch_config.rb

@@ -1,30 +1,39 @@
+# encoding: UTF-8
+
 module Rivet
   class LaunchConfig
 
-    LC_ATTRIBUTES = %w(key_name image_id instance_type security_groups iam_instance_profile bootstrap)
-
-    LC_ATTRIBUTES.each do |a|
-      attr_reader a.to_sym
-    end
-
-    attr_reader :id_prefix
-
-    def initialize(spec,id_prefix = 'rivet_')
+    ATTRIBUTES = [
+      :bootstrap,
+      :iam_instance_profile,
+      :image_id,
+      :instance_type,
+      :key_name,
+      :security_groups,
+      :associate_public_ip_address,
+      :detailed_instance_monitoring,
+      :block_device_mappings,
+      :kernel_id,
+      :ramdisk_id,
+      :spot_price
+    ].each { |a| attr_reader a }
+
+    attr_reader :id_prefix, :config
+
+    def initialize(config, id_prefix = 'rivet_')
+      @config    = config
       @id_prefix = id_prefix
 
-      LC_ATTRIBUTES.each do |a|
-
-        if respond_to? "normalize_#{a}".to_sym
-          spec[a] = self.send("normalize_#{a.to_sym}", spec[a])
+      ATTRIBUTES.each do |a|
+        if config.respond_to?(a)
+          Rivet::Log.debug "Setting LaunchConfig @#{a} to #{config.send(a)}"
+          instance_variable_set("@#{a}", config.send(a))
         end
-
-        Rivet::Log.debug("Setting LaunchConfig @#{a} to #{spec[a]}")
-        instance_variable_set("@#{a}", spec[a])
       end
     end
 
     def user_data
-      @user_data ||= Bootstrap.new(bootstrap).user_data
+      @user_data ||= Bootstrap.new(@config).user_data
     end
 
     def identity
@@ -37,16 +46,22 @@ module Rivet
       lc_collection = AWS::AutoScaling.new.launch_configurations
 
       if lc_collection[identity].exists?
-        Rivet::Log.info("Launch configuration #{identity} already exists in AWS")
+        Rivet::Log.info "Launch configuration #{identity} already exists in AWS"
       else
         options = {}
-        options[:key_pair]              = key_name              unless key_name.nil?
-        options[:security_groups]       = security_groups       unless security_groups.nil?
-        options[:user_data]             = user_data             unless user_data.nil?
-        options[:iam_instance_profile]  = iam_instance_profile  unless iam_instance_profile.nil?
-
-        Rivet::Log.info("Saving launch configuration #{identity} to AWS")
-        Rivet::Log.debug("Launch Config options:\n #{options.inspect}")
+        options[:key_pair]                      = key_name                      unless key_name.nil?
+        options[:security_groups]               = security_groups               unless security_groups.nil?
+        options[:user_data]                     = user_data                     unless user_data.nil?
+        options[:iam_instance_profile]          = iam_instance_profile          unless iam_instance_profile.nil?
+        options[:associate_public_ip_address]   = associate_public_ip_address   unless associate_public_ip_address.nil?
+        options[:detailed_instance_monitoring]  = detailed_instance_monitoring  unless detailed_instance_monitoring.nil?
+        options[:block_device_mappings]         = block_device_mappings         unless block_device_mappings.nil?
+        options[:kernel_id]                     = kernel_id                     unless kernel_id.nil?
+        options[:ramdisk_id]                    = ramdisk_id                    unless ramdisk_id.nil?
+        options[:spot_price]                    = spot_price                    unless spot_price.nil?
+
+        Rivet::Log.info "Saving launch configuration #{identity} to AWS"
+        Rivet::Log.debug "Launch Config options:\n #{options.inspect}"
         lc_collection.create(identity, image_id, instance_type, options)
       end
     end
@@ -54,10 +69,11 @@ module Rivet
     protected
 
     def build_identity_string
-      identity = LC_ATTRIBUTES.inject('') do |accum, attribute|
-        if attribute != 'bootstrap'
-          attr_value = self.send(attribute.to_sym) ? self.send(attribute.to_sym) : "\0"
-          attr_value = attr_value.join("\t") if attr_value.respond_to? :join
+      identity = ATTRIBUTES.inject('') do |accum, attribute|
+        if attribute != :bootstrap
+          attr_value = self.send(attribute) ? self.send(attribute) : "\0"
+          attr_value = attr_value.join("\t")  if attr_value.respond_to? :join
+          attr_value = attr_value.to_s        if !!attr_value == attr_value
           accum << attribute.to_s
           accum << Base64.encode64(attr_value)
         else
@@ -66,7 +82,6 @@ module Rivet
         end
         accum
       end
-      Rivet::Log.debug("Pre SHA1 identity string is #{identity}")
       identity
     end
 
@@ -74,9 +89,5 @@ module Rivet
       @id_prefix + Digest::SHA1.hexdigest(build_identity_string)
     end
 
-    def normalize_security_groups(groups)
-      groups.nil? ? groups : groups.sort
-    end
-
   end
 end

data/lib/rivet/logger.rb

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+
 module Rivet
 
   module Log
@@ -34,7 +36,7 @@ module Rivet
       def initialize
         @dev = Logger::LogDevice.new(STDOUT)
         super @dev
-        @progname = "Rivet"
+        @progname = 'Rivet'
         @formatter = proc do |sev, datetime, name, msg|
           "[#{name}] [#{datetime}] [#{sev}]: #{msg}\n"
         end

data/lib/rivet/open_state.rb

@@ -0,0 +1,44 @@
+# encoding: UTF-8
+
+module Rivet
+  class OpenState
+    attr_reader :generated_attributes
+    attr_accessor :required_fields
+
+    def initialize
+      @generated_attributes = []
+    end
+
+    def install_get_or_set(name)
+      @generated_attributes << name
+      define_singleton_method(name) do |*args|
+        if args.size < 1
+          instance_variable_get("@#{name}")
+        else
+          instance_variable_set("@#{name}", args[0])
+        end
+      end
+    end
+
+    def validate
+      required_fields.each_pair do |method, default_value|
+        unless respond_to?(method)
+          if default_value.nil?
+            fail "Required field #{method} missing!"
+          else
+            send(method, default_value)
+          end
+        end
+      end
+    end
+
+    def method_missing(m, *args, &block)
+      if args.size < 1
+        super
+      else
+        install_get_or_set(m)
+        send(m, args[0])
+      end
+    end
+  end
+end

data/lib/rivet/utils.rb

@@ -1,58 +1,23 @@
+# encoding: UTF-8
+
 module Rivet
   module Utils
-
     def self.die(level = 'fatal', message)
       Rivet::Log.write(level, message)
       exit
     end
 
-    # This returns the merged definition given a group
-
-    def self.get_definition(group, directory)
-      defaults = consume_defaults(directory)
-      group_def = load_definition(group, directory)
-
-      if defaults && group_def
-        group_def = defaults.deep_merge(group_def)
-      end
-    group_def ? group_def : false
+    def self.list_groups(directory)
+      config_file_names = Dir.glob(File.join(directory,'*.rb'))
+      config_file_names.map! {|f| File.basename(f,'.rb')}
+      config_file_names.sort!
+      Rivet::Log.info "Available groups in #{directory}:"
+      config_file_names.each { |n| Rivet::Log.info n }
     end
 
-    # Gobbles up the defaults file from YML, returns the hash or false if empty
-
-    def self.consume_defaults(autoscale_dir)
-      defaults_file = File.join(autoscale_dir, 'defaults.yml')
-      if File.exists? defaults_file
-        parsed = begin
-          Rivet::Log.debug("Consuming defaults from #{defaults_file}")
-          YAML.load(File.open(defaults_file))
-        rescue ArgumentError => e
-          Rivet::Log.fatal("Could not parse YAML from #{defaults_file}: #{e.message}")
-        end
-        parsed
-      else
-        false
-      end
+    def self.get_config(name, directory)
+      dsl_file = File.join(directory, "#{name}.rb")
+      Rivet::Config.from_file(dsl_file, directory) if File.exists?(dsl_file)
     end
-
-    # This loads the given definition from it's YML file, returns the hash or
-    # false if empty
-
-    def self.load_definition(name, directory)
-      definition_dir = File.join(directory,name)
-      conf_file      = File.join(definition_dir, 'conf.yml')
-      if Dir.exists?(definition_dir) && File.exists?(conf_file)
-        Rivet::Log.debug("Loading definition for #{name} from #{conf_file}")
-        parsed = begin
-          YAML.load(File.open(conf_file))
-        rescue
-          Rivet::Log.fatal("Could not parse YAML from #{conf_file}: #{e.message}")
-        end
-        parsed ? parsed : { }
-      else
-        false
-      end
-    end
-
   end
 end

data/lib/rivet/version.rb

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+
 module Rivet
-  VERSION = '1.4.0'
+  VERSION = '2.0.0'
 end

data/lib/rivet.rb

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+
 require 'aws-sdk'
 require 'base64'
 require 'digest/sha1'
@@ -5,14 +7,18 @@ require 'erb'
 require 'json'
 require 'logger'
 require 'optparse'
+require 'ostruct'
 require 'singleton'
-require 'yaml'
 
-require_relative 'rivet/deep_merge'
-require_relative 'rivet/logger'
-require_relative 'rivet/utils'
-require_relative 'rivet/aws_utils'
-require_relative 'rivet/launch_config'
 require_relative 'rivet/autoscale'
+require_relative 'rivet/aws_autoscale_wrapper'
+require_relative 'rivet/aws_utils'
 require_relative 'rivet/bootstrap'
 require_relative 'rivet/client'
+require_relative 'rivet/open_state'
+require_relative 'rivet/config'
+require_relative 'rivet/config_proxy'
+require_relative 'rivet/deep_merge'
+require_relative 'rivet/launch_config'
+require_relative 'rivet/logger'
+require_relative 'rivet/utils'

data/rivet.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
   spec.email       = ['brian.bianco@gmail.com']
   spec.homepage    = 'http://www.github.com/brianbianco/rivet'
   spec.summary     = %q{A tool for managing autoscaling groups}
-  spec.description = %q{Rivet allows you to define autoscaling groups and launch configurations as YAML and can SYNC that to AWS}
+  spec.description = %q{Rivet allows you to define autoscaling groups and launch configurations as configuration and SYNC that to AWS}
 
   spec.required_ruby_version     = '>= 1.9.1'
   spec.required_rubygems_version = '>= 1.3.6'

data/spec/aws_autoscale_wrapper_spec.rb

@@ -0,0 +1,123 @@
+# encoding: UTF-8
+require_relative './spec_setup'
+
+include SpecHelpers
+
+describe 'rivet aws autoscale wrapper' do
+  let(:normalized_values) do
+    {
+      :launch_configuration => 'unit_test_lc',
+      :load_balancers       => %w(balancer1 balancer2),
+      :availability_zones   => %w(unit-test-1a unit-test-1b),
+      :tags                 => [
+        { :propagate_at_launch => true, :key => 'Name', :value => 'Unit Test' },
+        { :propagate_at_launch => false, :key => 'Sandwich', :value => 'Ham' }
+      ],
+      :subnets              => %w(subnet-0000000a subnet-0000000b),
+      :termination_policies => %w(policy1 policy2)
+    }
+  end
+
+  let(:aws_mock) do
+    subnet_mock1 = double('Aws EC2 subnet')
+    subnet_mock1.stub(:id).and_return('subnet-0000000b')
+    subnet_mock2 = double('Aws EC2 subnet')
+    subnet_mock2.stub(:id).and_return('subnet-0000000a')
+
+    mock = double('Aws Autoscaling Group')
+    mock.stub(:health_check_type).and_return(:ec2)
+    mock.stub(:desired_capacity).and_return(1)
+    mock.stub(:max_size).and_return(2)
+    mock.stub(:min_size).and_return(0)
+    mock.stub(:launch_configuration_name).and_return('unit_test_lc')
+    mock.stub(:load_balancer_names).and_return(%w(balancer2 balancer1))
+    mock.stub(:availability_zone_names).and_return(%w(unit-test-1b unit-test-1a))
+    mock.stub(:subnets).and_return([subnet_mock1, subnet_mock2])
+    mock.stub(:termination_policies).and_return(%w(policy2 policy1))
+    mock.stub(:default_cooldown).and_return(100)
+    mock.stub(:health_check_grace_period).and_return(300)
+    mock.stub(:placement_group).and_return('donkey')
+    mock.stub(:name).and_return('unit_test_scaling_group')
+    mock.stub(:tags).and_return([
+      { :resource_id => 'snickers', :propagate_at_launch => true, :key => 'Name', :value => 'Unit Test' },
+      { :resource_type => 'yogurt', :propagate_at_launch => false, :key => 'Sandwich', :value => 'Ham' }
+    ])
+    mock.stub(:exists?).and_return(true)
+    mock
+  end
+
+  let(:groups_mock) do
+    groups_mock = double('groups_mock')
+    groups_mock.stub(:groups).and_return(group_mock)
+    groups_mock
+  end
+
+  let(:group_mock) do
+    group_mock = double('group_mock')
+    group_mock.stub(:[]).with(/unit_test_scaling_group/).and_return(aws_mock)
+    group_mock
+  end
+
+  let(:wrapper) { Rivet::AwsAutoscaleWrapper.new('unit_test_scaling_group') }
+
+  before do
+    AWS::AutoScaling.stub(:new).and_return(groups_mock)
+  end
+
+  describe '#normalize_launch_configuration' do
+    it 'returns launch configuration name' do
+      wrapper.normalize_launch_configuration.should == 'unit_test_lc'
+    end
+  end
+
+  describe '#normalize_load_balancers' do
+    it 'returns a normalized array of load balancers' do
+      wrapper.normalize_load_balancers.should == %w(balancer1 balancer2)
+    end
+  end
+
+  describe '#normalize_availability_zones' do
+    it 'returns a normalized array of availability zones' do
+      wrapper.normalize_availability_zones.should == %w(unit-test-1a unit-test-1b)
+    end
+  end
+
+  describe '#normalize_tags' do
+    it 'returns a normalized array of tags' do
+      tags = [{ :propagate_at_launch => true, :key => 'Name', :value => 'Unit Test' },
+              { :propagate_at_launch => false, :key => 'Sandwich', :value => 'Ham' }]
+      wrapper.normalize_tags.should == tags
+    end
+  end
+
+  describe '#normalize_subnets' do
+    it 'returns a normalized array of subnets' do
+      wrapper.normalize_subnets.should == %w(subnet-0000000a subnet-0000000b)
+    end
+  end
+
+  describe '#normalize_termination_policies' do
+    it 'returns a normalized array of termination policies' do
+      wrapper.normalize_termination_policies.should == %w(policy1 policy2)
+    end
+  end
+
+  describe '#normalize_tag' do
+    it 'returns a normalized tag' do
+      tag = { :resource_id => 'yoda', :resource_type => 'chewie',
+              :propagate_at_launch => true, :key => 'place', :value => 'alderaan' }
+
+      normalized_tag = { :propagate_at_launch => true, :key => 'place', :value => 'alderaan' }
+
+      wrapper.send(:normalize_tag, tag).should == normalized_tag
+    end
+  end
+
+  describe '#new' do
+    it 'should normalize values if normalize methods exist' do
+      normalized_values.each_pair do |attr, value|
+        wrapper.send(attr).should == value
+      end
+    end
+  end
+end

data/spec/bootstrap_spec.rb

@@ -0,0 +1,38 @@
+# encoding: UTF-8
+require_relative './spec_setup'
+
+include SpecHelpers
+
+describe 'rivet bootstrap' do
+  let(:config) { generate_config_mock(double('config_mock'), DSL_VALUES) }
+  let(:bootstrap) { Rivet::Bootstrap.new(config) }
+  let(:blank_config) do
+    blank_config_mock = double('blank_config_mock')
+    blank_config_mock.stub(:bootstrap).and_return
+    generate_config_mock(blank_config_mock, {})
+  end
+  let(:blank_bootstrap) { Rivet::Bootstrap.new(blank_config) }
+
+  tempdir_context 'with all necessary files in place' do
+    before do
+      FileUtils.mkdir_p AUTOSCALE_DIR
+      File.open(TEMPLATE_FILE, 'w') { |f| f.write(SpecHelpers::BOOTSTRAP_TEMPLATE) }
+    end
+
+    context 'with a tempate file specified' do
+      describe '#user_data' do
+        it 'returns a string of the rendered template' do
+          bootstrap.user_data.should include('bar')
+        end
+      end
+    end
+
+    context 'without a template specified' do
+      describe '#user_data' do
+        it 'returns a blank string' do
+          blank_bootstrap.user_data.should be_empty
+        end
+      end
+    end
+  end
+end

data/spec/config_proxy_spec.rb

@@ -0,0 +1,34 @@
+# encoding: UTF-8
+require_relative './spec_setup'
+
+include SpecHelpers
+
+describe 'Rivet Config Proxy' do
+  let(:config) do
+    config_mock = double('config_mock')
+    config_mock.stub(:normalize_unit_test).and_return('normalized ham sandwich')
+    config_mock.stub(:unit_test).and_return('ham sandwich')
+    config_mock.stub(:goat).and_return('bah')
+    config_mock
+  end
+
+  let(:config_proxy) { Rivet::ConfigProxy.new(config) }
+
+  describe '#send' do
+    it 'it calls normalize for a method if it iss available' do
+      config_proxy.send(:unit_test).should == 'normalized ham sandwich'
+    end
+    it 'it passes on a message sent to it if no normalize method exists' do
+      config_proxy.send(:goat).should == 'bah'
+    end
+  end
+
+  describe 'it calls normalize for a method if it is available' do
+    it 'it calls normalize for a method if it is available' do
+      config_proxy.unit_test.should == 'normalized ham sandwich'
+    end
+    it 'it passes on a message sent to it if no normalize method exists' do
+      config_proxy.goat.should == 'bah'
+    end
+  end
+end

data/spec/config_spec.rb

@@ -0,0 +1,168 @@
+# encoding: UTF-8
+require_relative './spec_setup'
+
+include SpecHelpers
+
+
+describe 'rivet config' do
+  let(:default_config) { Rivet::Config.new('default_unit_test_config') }
+  let(:config) { Rivet::Config.new('unit_test_config') { eval(DSL_CONFIG_CONTENT) } }
+
+  context 'without DSL content' do
+    describe '#new' do
+      it 'returns a Rivet::Config object' do
+        default_config.should be_an_instance_of Rivet::Config
+      end
+    end
+
+    describe '#name' do
+      it 'returns the name' do
+        default_config.name.should == 'default_unit_test_config'
+      end
+    end
+
+    describe '#bootstrap' do
+      before do
+        default_config.bootstrap.unit_test 'goat simulator'
+      end
+
+      it 'should allow you to set an arbitrary bootstrap value' do
+        default_config.bootstrap.unit_test.should == 'goat simulator'
+      end
+    end
+
+    describe '#path' do
+      context 'with no arguments' do
+        it 'returns the default . path' do
+          default_config.path.should == '.'
+        end
+      end
+      context 'with an argument' do
+        it 'returns the set path joined with the argument' do
+          default_config.path('test').should == './test'
+        end
+      end
+    end
+
+    describe '#normalize_availability_zones' do
+      before do
+        default_config.region 'us-west-2'
+        default_config.availability_zones %w(c a b)
+      end
+
+      it 'should return a sorted array of zones with the region prepended' do
+        default_config.normalize_availability_zones.should == %w(us-west-2a us-west-2b us-west-2c)
+      end
+    end
+
+    describe '#normalize_security_groups' do
+      before do
+        default_config.security_groups %w(group2 group1 group3)
+      end
+
+      it 'should return a sorted array of security groups' do
+        default_config.normalize_security_groups.should == %w(group1 group2 group3)
+      end
+    end
+
+    describe '#normalize_load_balancers' do
+      before do
+        default_config.load_balancers %w(balancer2 balancer1)
+      end
+
+      it 'should return a sorted array of load balancers' do
+        default_config.normalize_load_balancers.should == %w(balancer1 balancer2)
+      end
+    end
+
+    describe '#normalize_subnets' do
+      before do
+        default_config.subnets %w(192.168.1.2 192.168.1.3 192.168.1.1)
+      end
+
+      it 'should return a sorted array of subnets' do
+        default_config.normalize_subnets.should == %w(192.168.1.1 192.168.1.2 192.168.1.3) 
+      end
+    end
+
+    describe '#normalize_tags' do
+      before do
+        default_config.tags [
+          { key: 'Name', value: 'unit test' },
+          { key: 'Other', value: 'sasquatch', propagate_at_launch: false }
+        ]
+      end
+
+      it 'should return a normalized array of hashes' do
+        expected_result = [
+          { propagate_at_launch: true, key: 'Name', value: 'unit test' },
+          { propagate_at_launch: false, key: 'Other', value: 'sasquatch' }
+        ]
+        default_config.normalize_tags.should == expected_result
+      end
+    end
+  end
+
+  context 'with DSL content' do
+
+    describe '#new' do
+      it 'returns a Rivet::Config object' do
+        config.should be_an_instance_of Rivet::Config
+      end
+    end
+
+    describe '#name' do
+      it 'returns the name' do
+        config.name.should == 'unit_test_config'
+      end
+    end
+
+    describe 'generated attributes' do
+      it 'should contain all the attributes defined in the DSL CONTENT' do
+        DSL_VALUES.each_pair do |k, v|
+          # bootstrap is an attribute of the Config class, not a generated one
+          unless k == :bootstrap
+            config.generated_attributes.should include(k)
+          end
+        end
+      end
+
+      it 'should have all values properly set according to the DSL CONTENT' do
+        DSL_VALUES.each_pair do |k, v|
+          unless k == :bootstrap
+            config.send(k).should == eval(v)
+          end
+        end
+        DSL_VALUES[:bootstrap].each_pair do |k, v|
+          config.bootstrap.send(k).should == eval(v)
+        end
+      end
+    end
+  end
+
+  tempdir_context 'with DSL content inside of a file on disk' do
+    let(:config_from_file) { Rivet::Config.from_file(File.join('.', 'unit_test.rb')) }
+
+    before do
+      File.open('unit_test.rb', 'w') { |f| f.write(DSL_CONFIG_CONTENT) }
+    end
+
+    describe '::from_file' do
+      it 'returns an instance of Rivet::Config' do
+        config_from_file.should be_an_instance_of Rivet::Config
+      end
+
+      it 'should have all values properly set according to the DSL CONTENT' do
+        DSL_VALUES.each_pair do |k, v|
+          unless k == :bootstrap
+            config_from_file.send(k).should == eval(v)
+          end
+        end
+        DSL_VALUES[:bootstrap].each_pair do |k, v|
+          config_from_file.bootstrap.send(k).should == eval(v)
+        end
+      end
+    end
+  end
+
+end