rivet 2.0.0 → 3.0.0

data/lib/rivet/{aws_utils.rb → common/aws_utils.rb}

@@ -21,37 +21,38 @@ module Rivet
       end
     end
 
-    def self.config_parser
-      if ENV['AWS_CONFIG_FILE']
-
-        current_profile = nil
-        profile_matcher = /^\[(profile+\s)?(\w+)\]/
-        option_matcher  = /(\w.*)=(\S.*)\s*/
-        aws_config      = {}
+    def self.parse_profile_text(text)
+      current_profile = nil
+      profile_matcher = /^\[(profile+\s)?(\w+)\]/
+      option_matcher  = /(\w.*)\s*=\s*(\S.*)\s*/
+      aws_config      = {}
+
+      text.each_line do |line|
+        if line =~ profile_matcher
+          current_profile = line.match(profile_matcher)[2]
+          aws_config[current_profile] = {} unless aws_config.has_key?(current_profile)
+        end
 
-        File.open(ENV['AWS_CONFIG_FILE'], 'r').each_line do |line|
+        if line =~ option_matcher && !current_profile.nil?
+          results = line.match(option_matcher)
 
-          if line =~ profile_matcher
-            current_profile = line.match(profile_matcher)[2]
-            aws_config[current_profile] = {} unless aws_config.has_key?(current_profile)
+          # Normalize the option name so it can be used with the AWS SDK
+          if results[1] =~ /^\S*aws_/
+            option = results[1].strip.gsub('aws_', '').to_sym
+          else
+            option = results[1].strip.to_sym
           end
 
-          if line =~ option_matcher && !current_profile.nil?
-            results = line.match(option_matcher)
-
-            # Normalize the option name so it can be used with the AWS SDK
-            if results[1] =~ /^\S*aws_/
-              option = results[1].gsub('aws_', '').to_sym
-            else
-              option = results[1].to_sym
-            end
-
-            value = results[2]
-            aws_config[current_profile].merge!({ option => value })
-          end
+          value = results[2].strip
+          aws_config[current_profile].merge!({ option => value })
+        end
+      end
+      aws_config
+    end
 
-          end
-        aws_config
+    def self.config_parser
+      if ENV['AWS_CONFIG_FILE']
+        parse_profile_text(File.read(ENV['AWS_CONFIG_FILE']))
       end
     end
 
@@ -67,11 +68,8 @@ module Rivet
           end
           accum
         end
-
         AWS.config(aws_creds) if aws_creds
-
       end
     end
-
   end
 end

data/lib/rivet/common/base_aws_attributes.rb

@@ -0,0 +1,15 @@
+# encoding: UTF-8
+
+module Rivet
+  BASE_AWS_ATTRIBUTES = [
+    :iam_instance_profile,
+    :block_device_mappings,
+    :image_id,
+    :key_name,
+    :security_groups,
+    :instance_type,
+    :kernel_id,
+    :ramdisk_id,
+    :associate_public_ip_address
+  ].each { |a| attr_reader a }
+end

data/lib/rivet/common/base_config.rb

@@ -0,0 +1,40 @@
+# encoding: UTF-8
+
+module Rivet
+  class BaseConfig < OpenState
+    attr_reader :name
+    attr_accessor :bootstrap
+
+    def self.from_file(dsl_file, load_path='.')
+      name = File.basename(dsl_file, '.rb')
+      data = Proc.new { eval(File.read(dsl_file)) }
+      new(name, load_path, &data)
+    end
+
+    def initialize(name, load_path='.', &block)
+      super()
+      @name = name
+      @path = load_path
+      @bootstrap = OpenState.new
+      instance_eval(&block) if block
+    end
+
+    def path(*args)
+      if args.size < 1
+        @path
+      else
+        File.join(@path, *args)
+      end
+    end
+
+    def normalize_security_groups
+      security_groups.sort
+    end
+
+    protected
+
+    def import(import_path)
+      lambda { eval(File.read(import_path)) }.call
+    end
+  end
+end

data/lib/rivet/{client.rb → common/client.rb}

@@ -2,37 +2,38 @@
 
 module Rivet
   class Client
-    def run(options)
+    def run(client_type,options)
       AwsUtils.set_aws_credentials options.profile
       Rivet::Log.level options.log_level
 
-      Rivet::Log.info "Using autoscale config path #{options.config_path}"
+      Rivet::Log.info "Using #{client_type} config path #{options.config_path}"
 
       unless Dir.exists?(options.config_path)
-        Rivet::Utils.die 'The autoscale config path does not exist'
+        Rivet::Utils.die "The #{client_type} config path does not exist"
       end
 
-      # Get config object for autoscaling group
       config = Rivet::Utils.get_config(
-        options.group,
+        client_type,
+        options.name,
         options.config_path)
 
       unless config
         Rivet::Utils.list_groups(options.config_path)
-        Rivet::Utils.die "The #{options.group} autoscale definition doesn't exist"
+        Rivet::Utils.die "The #{options.name} #{client_type} definition doesn't exist"
       end
 
       config.validate
 
       config = ConfigProxy.new(config)
 
-      Rivet::Log.info "Checking #{options.group} autoscaling definition"
+      Rivet::Log.info "#{options.name} #{client_type} definition"
 
-      autoscale_group = Rivet::Autoscale.new(config)
-      autoscale_group.show_differences
+      asset = Rivet.const_get(client_type.capitalize).new(config)
+      asset.display
 
       if options.sync
-        autoscale_group.sync
+        Rivet::Log.debug "syncing asset #{options.name}"
+        asset.sync
       else
         Rivet::Log.info 'use the -s [--sync] flag to sync changes'
       end

data/lib/rivet/ec2/ec2.rb

@@ -0,0 +1,163 @@
+# encoding: UTF-8
+
+module Rivet
+  class Ec2
+    OPTIONS = [
+      :associate_public_ip_address,
+      :availability_zone,
+      :block_device_mappings,
+      :count,
+      :dedicated_tenancy,
+      :disable_api_termination,
+      :ebs_optimized,
+      :elastic_ips,
+      :iam_instance_profile,
+      :image_id,
+      :instance_initiated_shutdown_behavior,
+      :instance_type,
+      :kernel_id,
+      :key_name,
+      :key_pair,
+      :monitoring_enabled,
+      :network_interfaces,
+      :placement_group,
+      :private_ip_address,
+      :ramdisk_id,
+      :security_group_ids,
+      :security_groups,
+      :subnet,
+      :tags,
+      :user_data
+    ].each { |a| attr_reader a }
+
+    REQUIRED_OPTIONS = [
+      :image_id
+    ]
+
+    attr_reader :name
+
+    def initialize(config)
+      @ec2 = AWS::EC2.new
+      @name = config.name
+      @user_data = Bootstrap.new(config).user_data
+
+      OPTIONS.each do |o|
+        if config.respond_to?(o)
+          instance_variable_set("@#{o}", config.send(o))
+        end
+      end
+    end
+
+    def display(level = 'info')
+      options.each_pair do |attr, values|
+        Rivet::Log.write(level, "  #{attr}: #{values}")
+      end
+    end
+
+    def options
+      options = {}
+
+      OPTIONS.each do |field|
+        local_value = self.send(field)
+        options[field] = local_value unless local_value.nil?
+      end
+
+      REQUIRED_OPTIONS.each do |field|
+        unless options.has_key? field
+          options[field] = self.send(field)
+        end
+      end
+      options
+    end
+
+    def sync
+      # The AWS ruby SDK forces you to apply tags AFTER creation
+      # This option must be removed so the create call doesn't blow up.
+      server_options = options
+      tags_to_add    = server_options.delete :tags
+      eips_to_add    = server_options.delete :elastic_ips
+      enis_to_add    = server_options.delete :network_interfaces
+      instances      = @ec2.instances.create server_options
+
+      # Since create returns either an instance object or an array let us
+      # just go ahead and make that more sane
+      instances = [instances] unless instances.respond_to? :each
+
+      add_tags(instances,tags_to_add)
+      ready_instances = wait_until_running instances
+      add_eips(ready_instances,eips_to_add) if eips_to_add
+      add_network_interfaces(ready_instances,enis_to_add) if enis_to_add
+    end
+
+    protected
+
+    def add_network_interfaces(instances,interfaces)
+      index_to_instances = 0
+      interfaces.each do |i|
+        unless index_to_instances > instances.size
+          attach_interface(instances[index_to_instances],i)
+          index_to_instances + 1
+        end
+      end
+    end
+
+    def attach_interface(instance,interface)
+      eni = AWS::EC2::NetworkInterface.new(interface)
+      if eni.exists?
+        Rivet::Log.info "Attaching #{eni.id} to #{instance.id}"
+        instance.attach_network_interface eni
+      end
+    end
+
+    def add_eips(instances,eips_to_add)
+      index_to_instances = 0
+      eips_to_add.each do |ip|
+        unless index_to_instances > instances.size
+          attach_ip(instances[index_to_instances],ip)
+          index_to_instances + 1
+        end
+      end
+    end
+
+    def attach_ip(instance,ip)
+      eip = AWS::EC2::ElasticIp.new(ip)
+      if eip.exists?
+        Rivet::Log.info "Attaching #{eip} to #{instance.id}"
+        instance.associate_elastic_ip eip
+      end
+    end
+
+    def tag_instance(instance,tags_to_add)
+      tags_to_add.each do |t|
+        @ec2.tags.create(instance, t[:key].to_s, :value => t[:value])
+      end
+    end
+
+    def add_tags(instances,tags_to_add)
+      instances.each do |i|
+        if tags_to_add
+          tag_instance(i,tags_to_add)
+        else
+          Rivet::Log.info "No tags in config, defaulting to Name: #{@name}"
+          tag_instance(i,[{ :key => 'Name', :value => @name }])
+        end
+      end
+    end
+
+    def wait_until_running(instances)
+      Rivet::Log.info "Waiting for instance to start.  This could take a while..."
+      finished = []
+      until instances.size <= 0
+        instances.reject! do |i|
+          unless i.status == :pending
+            Rivet::Log.info "#{i.id} is in #{i.status} state."
+            finished << i
+            true
+          end
+        end
+        sleep 1
+      end
+      finished
+    end
+  end
+end

data/lib/rivet/ec2/ec2_config.rb

@@ -0,0 +1,19 @@
+#encoding: UTF-8
+
+module Rivet
+  class Ec2Config < BaseConfig
+
+    def initialize(name, load_path='.', &block)
+      @required_fields = {
+        :image_id => nil,
+        :region => 'us-east-1',
+        :availability_zone => 'a'
+      }
+      super(name,load_path, &block)
+    end
+
+    def normalize_availability_zone
+      region + availability_zone
+    end
+  end
+end

data/lib/rivet/utils.rb

@@ -4,7 +4,7 @@ module Rivet
   module Utils
     def self.die(level = 'fatal', message)
       Rivet::Log.write(level, message)
-      exit
+      exit 1
     end
 
     def self.list_groups(directory)
@@ -15,9 +15,10 @@ module Rivet
       config_file_names.each { |n| Rivet::Log.info n }
     end
 
-    def self.get_config(name, directory)
+    def self.get_config(client_type, name, directory)
       dsl_file = File.join(directory, "#{name}.rb")
-      Rivet::Config.from_file(dsl_file, directory) if File.exists?(dsl_file)
+      klass = Rivet.const_get("#{client_type.capitalize}Config")
+      klass.from_file(dsl_file, directory) if File.exists?(dsl_file)
     end
   end
 end

data/lib/rivet/version.rb

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

data/lib/rivet.rb

@@ -9,16 +9,21 @@ require 'logger'
 require 'optparse'
 require 'ostruct'
 require 'singleton'
+require 'diff/lcs'
 
-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/common/base_aws_attributes'
+require_relative 'rivet/as/autoscale'
+require_relative 'rivet/as/aws_autoscale_wrapper'
+require_relative 'rivet/common/client'
+require_relative 'rivet/common/aws_utils'
+require_relative 'rivet/common/bootstrap'
+require_relative 'rivet/common/open_state'
+require_relative 'rivet/common/base_config'
+require_relative 'rivet/as/autoscale_config'
+require_relative 'rivet/common/config_proxy'
+require_relative 'rivet/as/launch_config'
+require_relative 'rivet/common/logger'
+require_relative 'rivet/ec2/ec2_config'
+require_relative 'rivet/ec2/ec2'
 require_relative 'rivet/utils'
+require_relative 'rivet/version'

data/rivet.gemspec

@@ -21,10 +21,11 @@ Gem::Specification.new do |spec|
   spec.test_files = spec.files.grep(%r{^spec/})
 
   spec.executables  = %w(rivet)
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.add_dependency "aws-sdk", ">= 1.11.1"
-  spec.add_development_dependency "pry", "~> 0.9.12"
-  spec.add_development_dependency "rake", ">= 10.1.0"
-  spec.add_development_dependency "rspec", "~> 2.14.1"
+  spec.add_dependency 'aws-sdk', '>= 1.11.1'
+  spec.add_dependency 'diff-lcs', '>= 1.2.5'
+  spec.add_development_dependency 'pry', '~> 0.9.12'
+  spec.add_development_dependency 'rake', '>= 10.1.0'
+  spec.add_development_dependency 'rspec', '~> 2.14.1'
 end

data/spec/as/autoscale_config_spec.rb

@@ -0,0 +1,65 @@
+# encoding: UTF-8
+require_relative '../spec_setup'
+require_relative '../shared_examples/a_config'
+
+include SpecHelpers
+
+describe 'rivet autoscale config' do
+  let(:dsl_values) { ASG_DSL_VALUES }
+  let(:default_config) { Rivet::AutoscaleConfig.new('default_unit_test_config') }
+  let(:config) { Rivet::AutoscaleConfig.new('unit_test_config') { eval(ASG_CONFIG_CONTENT) } }
+  let(:config_from_file) { Rivet::AutoscaleConfig.from_file(File.join('.', 'unit_test.rb')) }
+  let(:config_content) { ASG_CONFIG_CONTENT }
+
+  it_behaves_like "a config"
+
+  context 'without DSL content' do
+    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_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: 'Other', value: 'sasquatch', propagate_at_launch: false },
+          { key: 'Name', value: 'unit test' }
+        ]
+      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
+end

data/spec/{aws_autoscale_wrapper_spec.rb → as/aws_autoscale_wrapper_spec.rb}

@@ -1,5 +1,5 @@
 # encoding: UTF-8
-require_relative './spec_setup'
+require_relative '../spec_setup'
 
 include SpecHelpers
 

data/spec/aws_utils_spec.rb

@@ -0,0 +1,44 @@
+# encoding: UTf-8
+require_relative './spec_setup'
+
+include SpecHelpers
+
+describe 'rivet awsutils' do
+  describe 'parse_profile_text' do
+    let(:profile_hash) do
+      {
+        'unit_test_profile1' => {
+          'option1' => 'unit_test_option1',
+          'option2' => 'unit_test_option2'
+        },
+        'unit_test_profile2' => {
+          'option1    ' => 'unit_test_option1',
+          'option2' => 'unit_test_option2     '
+        }
+      }
+    end
+
+    let(:profile_text) do
+      p = String.new
+      profile_hash.each_pair do |profile,options|
+        p << "[profile #{profile}]\n"
+        options.each_pair { |name,value| p << "#{name.chomp} = #{value.chomp}\n" }
+      end
+      p
+    end
+
+    it 'should contain the profile as top level keys' do
+      result = Rivet::AwsUtils.parse_profile_text(profile_text)
+      profile_hash.each_pair { |profile,_| result.should have_key profile }
+    end
+
+    it 'should set all options properly inside the profile hash' do
+      result = Rivet::AwsUtils.parse_profile_text(profile_text)
+      profile_hash.each_pair do |profile,options|
+        options.each_pair do |name, value|
+          result[profile][name.strip.to_sym].should == value.strip
+        end
+      end
+    end
+  end
+end

data/spec/base_config_spec.rb

@@ -0,0 +1,31 @@
+# encoding: UTF-8
+require_relative './spec_setup'
+require_relative './shared_examples/a_config'
+
+include SpecHelpers
+
+describe 'rivet base config' do
+  let(:dsl_values) { COMMON_DSL_VALUES }
+  let(:default_config) { Rivet::BaseConfig.new('default_unit_test_config') }
+  let(:config) { Rivet::BaseConfig.new('unit_test_config') { eval(ASG_CONFIG_CONTENT) } }
+  let(:config_from_file) { Rivet::BaseConfig.from_file(File.join('.', 'unit_test.rb')) }
+  let(:config_content) { ASG_CONFIG_CONTENT }
+
+  it_behaves_like "a config"
+
+  context 'without DSL content' do
+    describe '#new' do
+      it 'returns a Rivet::BaseConfig object' do
+        default_config.should be_an_instance_of Rivet::BaseConfig
+      end
+    end
+  end
+
+  context 'with DSL content' do
+    describe '#new' do
+      it 'returns a Rivet::BaseConfig object' do
+        config.should be_an_instance_of Rivet::BaseConfig
+      end
+    end
+  end
+end

data/spec/bootstrap_spec.rb

@@ -4,7 +4,7 @@ require_relative './spec_setup'
 include SpecHelpers
 
 describe 'rivet bootstrap' do
-  let(:config) { generate_config_mock(double('config_mock'), DSL_VALUES) }
+  let(:config) { generate_config_mock(double('config_mock'), ASG_DSL_VALUES) }
   let(:bootstrap) { Rivet::Bootstrap.new(config) }
   let(:blank_config) do
     blank_config_mock = double('blank_config_mock')

data/spec/ec2/ec2_config_spec.rb

@@ -0,0 +1,29 @@
+# encoding: UTF-8
+require_relative '../spec_setup'
+require_relative '../shared_examples/a_config'
+
+include SpecHelpers
+
+describe 'rivet ec2 config' do
+  let(:dsl_values) { EC2_DSL_VALUES }
+  let(:default_config) { Rivet::Ec2Config.new('default_unit_test_config') }
+  let(:config) { Rivet::Ec2Config.new('unit_test_config') { eval(EC2_CONFIG_CONTENT) } }
+  let(:config_from_file) { Rivet::Ec2Config.from_file(File.join('.', 'unit_test.rb')) }
+  let(:config_content) { EC2_CONFIG_CONTENT }
+
+  it_behaves_like "a config"
+
+  context 'without DSL content' do
+    describe '#normalize_availability_zone' do
+      before do
+        default_config.region 'us-west-2'
+        default_config.availability_zone 'a'
+      end
+
+      it 'should return a valid availability zone string' do
+        default_config.normalize_availability_zone.should == 'us-west-2a'
+      end
+    end
+  end
+end
+

data/spec/launch_config_spec.rb

@@ -4,7 +4,7 @@ require_relative './spec_setup'
 include SpecHelpers
 
 describe 'rivet launch config' do
-  let(:config) { generate_config_mock(double('config_mock'), DSL_VALUES) }
+  let(:config) { generate_config_mock(double('config_mock'), ASG_DSL_VALUES) }
   let(:launch_config) { Rivet::LaunchConfig.new(config) }
 
   context 'with a sane config' do