rivet 1.4.0 → 2.0.0

data/lib/rivet/autoscale.rb

@@ -1,35 +1,46 @@
+# encoding: UTF-8
+
 module Rivet
   class Autoscale
 
-    REQUIRED_FIELDS = [:min_size, :max_size, :launch_configuration, :availability_zones]
-
-    attr_reader :min_size, :max_size, :name, :launch_configuration
-    attr_reader :availability_zones, :tags
-
-    def initialize(name, definition)
-      @name       = name
-      @min_size   = definition['min_size']
-      @max_size   = definition['max_size']
-
-      if definition.has_key? 'tags'
-        definition['tags'].each do |t|
-          unless t.has_key? 'propagate_at_launch'
-            t['propagate_at_launch'] = true
-          end
+    OPTIONS = [
+      :availability_zones,
+      :default_cooldown,
+      :desired_capacity,
+      :health_check_grace_period,
+      :health_check_type,
+      :launch_configuration,
+      :load_balancers,
+      :max_size,
+      :min_size,
+      :placement_group,
+      :subnets,
+      :tags,
+      :termination_policies
+    ].each { |a| attr_reader a }
+
+    REQUIRED_OPTIONS = [
+      :availability_zones,
+      :launch_configuration,
+      :max_size,
+      :min_size
+    ]
+
+    attr_reader :name
+
+    def initialize(config)
+      @name          = config.name
+      @remote_group  = AwsAutoscaleWrapper.new(@name)
+      @launch_config = LaunchConfig.new(config)
+
+      OPTIONS.each do |o|
+        if config.respond_to?(o)
+          instance_variable_set("@#{o}", config.send(o))
         end
-        @tags = definition['tags']
-      else
-        @tags = []
-      end
-      @launch_config = LaunchConfig.new(definition)
-
-      # Normalizing zones to match what the SDK expects, E.G. "<region><zone>"
-      @availability_zones = definition['availability_zones'].map! do |zone|
-        definition['region'] + zone
       end
 
-      # The launch_configuration attr exists for convinence since that is what
-      # the aws SDK refers to the launch configuration name as for autoscaling
+      # The launch_configuration attr exists because that is what
+      # the aws SDK refers to the launch configuration name as.
       @launch_configuration = @launch_config.identity
     end
 
@@ -46,110 +57,87 @@ module Rivet
     end
 
     def show_differences(level = 'info')
-
-      Rivet::Log.write(level, "Remote and local defintions match") unless differences?
-
+      Rivet::Log.write(level, 'Remote and local match') unless differences?
       differences.each_pair do |attr, values|
         Rivet::Log.write(level, "#{attr}:")
-        Rivet::Log.write(level, "  remote: #{values['remote']}")
-        Rivet::Log.write(level, "  local:  #{values['local']}")
+        Rivet::Log.write(level, "  remote: #{values[:remote]}")
+        Rivet::Log.write(level, "  local:  #{values[:local]}")
       end
+     Rivet::Log.write('debug', @launch_config.user_data)
     end
 
     def sync
       if differences?
-        Rivet::Log.info("Syncing autoscale group changes to AWS for #{@name}")
+        Rivet::Log.info "Syncing autoscale group changes to AWS for #{@name}"
         autoscale = AWS::AutoScaling.new
         group = autoscale.groups[@name]
 
         @launch_config.save
         create(options) unless group.exists?
 
-        Rivet::Log.debug("Updating autoscaling group with the follow options")
-        Rivet::Log.debug(options.inspect)
+        Rivet::Log.debug 'Updating autoscaling group with the follow options'
+        Rivet::Log.debug options.inspect
 
+        # It's easier to just delete all the tags if there are changes and apply
+        # new ones, than ferret out exactly which ones should be removed.
+        if differences.has_key? :tags
+          group.delete_all_tags
+        end
         group.update(options)
+
       else
-        Rivet::Log.info("No autoscale differences to sync to AWS for #{@name}.")
+        Rivet::Log.info "No autoscale differences to sync to AWS for #{@name}."
       end
     end
 
     protected
 
-    def get_update_options
-      options = {}
-      differences.each_pair do |attribute, values|
-        options[attribute.to_sym] = values['local']
-      end
-
-      REQUIRED_FIELDS.each do |field|
-        unless options.has_key? field
-          options[field] = self.send(field)
-        end
-      end
-      options
-    end
-
     def get_differences
-      remote = get_remote
       differences = {}
-      [:min_size, :max_size, :launch_configuration, :tags].each do |a|
-        if remote[a.to_s] != self.send(a)
-          differences[a.to_s] = { 'remote' => remote[a.to_s], 'local' => self.send(a) }
-        end
-      end
 
-      if remote['availability_zones'] != availability_zones
-        differences['availability_zones'] = { 'remote' => remote['availability_zones'], 'local' => availability_zones }
-      end if remote.has_key? 'availability_zones'
+      OPTIONS.each do |o|
+        remote_value = @remote_group.send(o)
+        local_value = send(o)
 
+        if (remote_value != local_value)
+          differences[o] = { :local => send(o), :remote => @remote_group.send(o) }
+        end
+      end
       differences
     end
 
-    def get_remote
-      autoscale = AWS::AutoScaling.new
-      remote_group = autoscale.groups[@name]
-      if remote_group.exists?
+    def get_update_options
+      options = {}
 
-        remote_hash = [:min_size, :max_size].inject({}) do |accum, attr|
-          accum[attr.to_s] = remote_group.send attr
-          accum
-        end
+      OPTIONS.each do |field|
+        local_value = self.send(field)
+        options[field] = local_value unless local_value.nil?
+      end
 
-        # {:resource_id=>"venus", :propagate_at_launch=>true, :value=>"Venus", :key=>"Name", :resource_type=>"auto-scaling-group"}
-        remote_hash['tags'] = remote_group.tags.to_a.inject([]) do |tags, current|
-          tags << normalize_tag(current)
+      REQUIRED_OPTIONS.each do |field|
+        unless options.has_key? field
+          options[field] = self.send(field)
         end
-
-        remote_hash['launch_configuration'] = remote_group.launch_configuration_name
-
-        # Normalize their AWS::Core::Data::List to a sorted array
-        remote_hash['availability_zones'] = remote_group.availability_zone_names.to_a.sort
-
-        remote_hash
-      else
-        {}
       end
+      options
     end
 
     def create(options)
+
+      # When creating an autoscaling group passing empty arrays for subnets
+      # or some other fields can cause it to barf.  Remove them first.
+      options.delete_if { |k, v| v.respond_to?(:'empty?') && v.empty? }
+
+      Rivet::Log.debug "Creating Autoscaling group #{@name} with the following options"
+      Rivet::Log.debug options
+
       autoscale = AWS::AutoScaling.new
       if autoscale.groups[@name].exists?
-        raise "Cannot create AutoScaling #{@name} group it already exists!"
+        fail "Cannot create AutoScaling #{@name} group it already exists!"
       else
         autoscale.groups.create(@name, options)
       end
     end
 
-    def normalize_tag(tag)
-      normalized_tag = {}
-      tag.each_pair do |k, v|
-        unless (k == :resource_id || k == :resource_type)
-          normalized_tag[k.to_s] = v
-        end
-      end
-      normalized_tag
-    end
-
   end
 end

data/lib/rivet/aws_autoscale_wrapper.rb

@@ -0,0 +1,82 @@
+# encoding: UTF-8
+
+module Rivet
+  class AwsAutoscaleWrapper
+
+    OPTIONS = [
+      :availability_zones,
+      :default_cooldown,
+      :desired_capacity,
+      :health_check_grace_period,
+      :health_check_type,
+      :launch_configuration,
+      :load_balancers,
+      :max_size,
+      :min_size,
+      :placement_group,
+      :subnets,
+      :tags,
+      :termination_policies
+    ].each { |a| attr_reader a }
+
+    attr_reader :name
+
+    def initialize(name)
+      Rivet::Log.debug "Initializing AWS Autoscale Wrapper for #{name}"
+      @name = name
+      @group = AWS::AutoScaling.new.groups[@name]
+
+      if @group.exists?
+        OPTIONS.each do |o|
+          normalize_method = "normalize_#{o}".to_sym
+          if respond_to?(normalize_method)
+            Rivet::Log.debug "Calling #{normalize_method} in AWS autoscale wrapper"
+            value = send(normalize_method)
+          else
+            value = @group.send(o)
+          end
+          instance_variable_set("@#{o}", value)
+        end
+      end
+
+    end
+
+    def normalize_launch_configuration
+      @group.launch_configuration_name
+    end
+
+    def normalize_load_balancers
+      @group.load_balancer_names.to_a.sort
+    end
+
+    def normalize_availability_zones
+      @group.availability_zone_names.to_a.sort
+    end
+
+    def normalize_tags
+      @group.tags.to_a.inject([]) do |normalized_tags, current|
+        normalized_tags << normalize_tag(current)
+      end
+    end
+
+    def normalize_subnets
+      @group.subnets.empty? ? nil : @group.subnets.map(&:id).sort
+    end
+
+    def normalize_termination_policies
+      @group.termination_policies.to_a.sort
+    end
+
+    protected
+
+    def normalize_tag(tag)
+      normalized_tag = {}
+      tag.each_pair do |k, v|
+        unless (k == :resource_id || k == :resource_type)
+          normalized_tag[k] = v
+        end
+      end
+      normalized_tag
+    end
+  end
+end

data/lib/rivet/aws_utils.rb

@@ -1,9 +1,11 @@
+# encoding: UTF-8
+
 module Rivet
   module AwsUtils
 
     def self.verify_security_groups(groups)
-      return false if groups.nil?
-      Rivet::Log.info("Verifying security groups: #{groups.join(",")}")
+      return false if groups.nil? || groups.all?{|g| g.match(/\Asg-[0-9a-f]{8}\z/) }
+      Rivet::Log.info "Verifying security groups: #{groups.join(",")}"
 
       security_groups_collection = AWS::EC2.new.security_groups
       filtered_groups = []
@@ -13,7 +15,7 @@ module Rivet
 
       groups.each do |g|
         unless filtered_groups.include?(g)
-          Rivet::Log.debug("Creating security group #{g}")
+          Rivet::Log.debug "Creating security group #{g}"
           security_groups_collection.create g
         end
       end
@@ -27,7 +29,7 @@ module Rivet
         option_matcher  = /(\w.*)=(\S.*)\s*/
         aws_config      = {}
 
-        File.open(ENV['AWS_CONFIG_FILE'],"r").each_line do |line|
+        File.open(ENV['AWS_CONFIG_FILE'], 'r').each_line do |line|
 
           if line =~ profile_matcher
             current_profile = line.match(profile_matcher)[2]
@@ -39,13 +41,13 @@ module Rivet
 
             # 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
+              option = results[1].gsub('aws_', '').to_sym
             else
               option = results[1].to_sym
             end
 
             value = results[2]
-            aws_config[current_profile].merge!({ option => value})
+            aws_config[current_profile].merge!({ option => value })
           end
 
           end
@@ -54,12 +56,12 @@ module Rivet
     end
 
     def self.set_aws_credentials(profile)
-      Rivet::Log.info("Settings AWS credentials to #{profile} profile")
+      Rivet::Log.info "Settings AWS credentials to #{profile} profile"
       settings = config_parser
       aws_creds = nil
 
       if settings && settings.has_key?(profile)
-        aws_creds = [:access_key_id,:secret_access_key,:region].inject({})do |accum,option|
+        aws_creds = [:access_key_id, :secret_access_key, :region].inject({})do |accum, option|
           if settings[profile].has_key?(option)
             accum[option] = settings[profile][option]
           end

data/lib/rivet/bootstrap.rb

@@ -1,25 +1,11 @@
+# encoding: UTF-8
+
 module Rivet
   class Bootstrap
-    TEMPLATE_SUB_DIR = "bootstrap"
-
-    attr_reader :gems, :run_list, :template, :environment, :region, :name, :elastic_ip
-    attr_reader :template_path, :chef_command, :chef_organization, :chef_username
-
-    def initialize(bootstrap_definition = {})
-      ivars = [
-        'gems', 'run_list', 'template', 'environment', 'region', 'name', 'elastic_ip',
-        'config_dir', 'chef_command', 'chef_organization', 'chef_username']
-
-      ivars.each do |i|
-        if bootstrap_definition.has_key? i
-          instance_variable_set("@#{i}", bootstrap_definition[i])
-        end
-      end unless bootstrap_definition.nil?
+    attr_reader :config
 
-      @config_dir ||= '.'
-      @template   ||= 'default.erb'
-
-      set_calculated_attrs
+    def initialize(config)
+      @config = config.bootstrap
     end
 
     def user_data
@@ -28,46 +14,15 @@ module Rivet
 
     protected
 
-    def set_calculated_attrs
-      @template_path  = File.join(@config_dir, TEMPLATE_SUB_DIR)
-      @secret_file    = File.join(@config_dir, "encrypted_data_bag_secret_#{@environment}")
-      @validation_key = File.new(File.join(@config_dir, "#{@chef_organization}-validator.pem")).read
-    end
-
     def generate_user_data
-      config_content =  "log_level :info\n"
-      config_content << "log_location STDOUT\n"
-      config_content << "environment '#{environment}'\n"
-      config_content << "chef_server_url 'https://api.opscode.com/organizations/#{chef_organization}'\n"
-      config_content << "validation_client_name '#{chef_organization}-validator'\n"
-
-      knife_content =  "chef_username       = '#{chef_username}'\n"
-      knife_content << "chef_organization   = '#{chef_organization}'\n"
-      knife_content << "\n"
-      knife_content << "environment         '#{environment}'\n"
-      knife_content << "log_level           :info\n"
-      knife_content << "log_location        STDOUT\n"
-      knife_content << "node_name           \"\#{chef_username}\"\n"
-      knife_content << "client_key          \"~/.chef/\#{chef_username}.pem\"\n"
-      knife_content << "chef_server_url     \"https://api.opscode.com/organizations/\#{chef_organization}\"\n"
-      knife_content << "cache_type          'BasicFile'\n"
-      knife_content << "puts \"Using \#{environment} environment...\"\n"
-
-      install_gems = ''
-
-      gems.each do |g|
-        if g.size > 1
-          install_gems << "gem install #{g[0]} -v #{g[1]} --no-rdoc --no-ri\n"
-        else
-          install_gems << "gem install #{g[0]} --no-rdoc --no-ri\n"
-        end
-      end unless gems.nil?
-
-      first_boot = { :run_list => @run_list.flatten }.to_json unless @run_list.nil?
-
-      template = ERB.new File.new(File.join(@template_path, @template)).read
-      template.result(binding)
+      if config.respond_to?(:template)
+        Rivet::Log.debug "Rendering #{config.template}"
+        template = ERB.new(File.read(config.template))
+        template.result(config.instance_eval { binding })
+      else
+        Rivet::Log.debug 'No template provided, Rendering empty user-data'
+        ''
+      end
     end
-
   end
 end

data/lib/rivet/client.rb

@@ -1,35 +1,41 @@
+# encoding: UTF-8
+
 module Rivet
   class Client
-    def initialize
-    end
-
     def run(options)
-      AwsUtils.set_aws_credentials(options[:profile])
-      Rivet::Log.level(options[:log_level])
+      AwsUtils.set_aws_credentials options.profile
+      Rivet::Log.level options.log_level
 
-      unless Dir.exists?(options[:definitions_directory])
-        Rivet::Utils.die("The autoscale definitions directory doesn't exist")
+      Rivet::Log.info "Using autoscale config path #{options.config_path}"
+
+      unless Dir.exists?(options.config_path)
+        Rivet::Utils.die 'The autoscale config path does not exist'
       end
 
-      group_def = Rivet::Utils.get_definition(
-        options[:group],
-        options[:definitions_directory])
+      # Get config object for autoscaling group
+      config = Rivet::Utils.get_config(
+        options.group,
+        options.config_path)
 
-      unless group_def
-        Rivet::Utils.die "The #{options[:group]} definition doesn't exist"
+      unless config
+        Rivet::Utils.list_groups(options.config_path)
+        Rivet::Utils.die "The #{options.group} autoscale definition doesn't exist"
       end
 
-      Rivet::Log.info("Checking #{options[:group]} autoscaling definition")
-      autoscale_def = Rivet::Autoscale.new(options[:group], group_def)
-      autoscale_def.show_differences
+      config.validate
+
+      config = ConfigProxy.new(config)
 
-      if options[:sync]
-        autoscale_def.sync
+      Rivet::Log.info "Checking #{options.group} autoscaling definition"
+
+      autoscale_group = Rivet::Autoscale.new(config)
+      autoscale_group.show_differences
+
+      if options.sync
+        autoscale_group.sync
       else
-        Rivet::Log.info("use the -s [--sync] flag to sync changes")
+        Rivet::Log.info 'use the -s [--sync] flag to sync changes'
       end
-
     end
-
   end
 end

data/lib/rivet/config.rb

@@ -0,0 +1,87 @@
+# encoding: UTF-8
+
+module Rivet
+  class Config < 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
+      @required_fields = {
+        :min_size => nil,
+        :max_size => nil,
+        :availability_zones => nil,
+        :default_cooldown => 300,
+        :desired_capacity => 0,
+        :health_check_grace_period => 0,
+        :health_check_type => :ec2,
+        :load_balancers => [],
+        :tags => [],
+        :termination_policies => ['Default']
+      }
+      instance_eval(&block) if block
+    end
+
+    def path(*args)
+      if args.size < 1
+        @path
+      else
+        File.join(@path, *args)
+      end
+    end
+
+    def normalize_availability_zones
+      availability_zones.map { |zone| region + zone }.sort
+    end
+
+    def normalize_security_groups
+      security_groups.sort
+    end
+
+    def normalize_load_balancers
+      load_balancers.sort
+    end
+
+    def normalize_subnets
+      subnets.sort
+    end
+
+    def normalize_tags
+      normalized_tags = []
+      tags.each do |t|
+        normalized_hash = {}
+
+        if t.has_key? :propagate_at_launch
+          normalized_hash[:propagate_at_launch] = t[:propagate_at_launch]
+        else
+          normalized_hash[:propagate_at_launch] = true
+        end
+
+        [:value, :key].each do |k|
+          if t.has_key? k
+            normalized_hash[k] = t[k]
+          else
+            normalized_hash[k] = nil
+          end
+        end
+        normalized_tags << normalized_hash
+      end
+      normalized_tags
+    end
+
+    protected
+
+    def import(import_path)
+      lambda { eval(File.read(import_path)) }.call
+    end
+  end
+end

data/lib/rivet/config_proxy.rb

@@ -0,0 +1,28 @@
+# encoding: UTF-8
+
+module Rivet
+  class ConfigProxy < BasicObject
+
+    def initialize(config)
+      @config = config
+    end
+
+    def send(m, *args)
+      if @config.respond_to?("normalize_#{m}".to_sym)
+        @config.send("normalize_#{m}".to_sym)
+      else
+        super
+      end
+    end
+
+    def method_missing(m, *args, &block)
+      if @config.respond_to?("normalize_#{m}".to_sym)
+        @config.send("normalize_#{m}".to_sym)
+      elsif @config.respond_to? m
+        @config.send(m, *args, &block)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/rivet/deep_merge.rb

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+
 class Hash
   # Returns a new hash with +self+ and +other_hash+ merged recursively.
   #
@@ -14,7 +16,7 @@ class Hash
 
   # Same as +deep_merge+, but modifies +self+.
   def deep_merge!(other_hash, &block)
-    other_hash.each_pair do |k,v|
+    other_hash.each_pair do |k, v|
       tv = self[k]
       if tv.is_a?(Hash) && v.is_a?(Hash)
         self[k] = tv.deep_merge(v, &block)