wr0ngway-rubber 1.0.0

data/lib/rubber/recipes/rubber/volumes.rb

@@ -0,0 +1,264 @@
+namespace :rubber do
+
+  desc <<-DESC
+    Sets up persistent volumes in the cloud
+    All volumes defined in rubber.yml will be created if neccessary, and attached/mounted on their associated instances
+  DESC
+  required_task :setup_volumes do
+    rubber_instances.filtered.each do |ic|
+      env = rubber_cfg.environment.bind(ic.role_names, ic.name)
+      created_vols = []
+      vol_specs = env.volumes || []
+      vol_specs.each do |vol_spec|
+        created_vols << setup_volume(ic, vol_spec)
+      end
+      created_vols.compact!
+
+      created_parts = []
+      partition_specs = env.local_volumes || []
+      partition_specs.each do |partition_spec|
+        created_parts << setup_partition(ic, partition_spec)
+      end
+      created_parts.compact!
+      zero_partitions(ic, created_parts)
+      created_vols += created_parts
+      
+      created_vols = created_vols.compact.uniq
+      raid_specs = env.raid_volumes || []
+      raid_specs.each do |raid_spec|
+        # we want to format if we created the ec2 volumes, or if we don't have any
+        # ec2 volumes and are just creating raid array from ephemeral stores
+        format = raid_spec['source_devices'].all? {|dev| created_vols.include?(dev)}
+        setup_raid_volume(ic, raid_spec, format)
+      end
+    end
+  end
+
+  desc <<-DESC
+    Shows the configured persistent volumes
+  DESC
+  required_task :describe_volumes do
+    results = []
+    format = "%-20s %-15s %-15s %-20s"
+    results << format % %w[Id Status Attached Instance]
+
+    volumes = cloud.describe_volumes()
+    volumes.each do |volume|
+      results << format % [volume[:id], volume[:status], volume[:attachment_status], volume[:attachment_instance_id]]
+    end
+
+    results.each {|r| logger.info r}
+  end
+
+  desc <<-DESC
+    Shows the configured persistent volumes
+  DESC
+  required_task :destroy_volume do
+    volume_id = get_env('VOLUME_ID', "Volume ID", true)
+    destroy_volume(volume_id)
+  end
+
+  def create_volume(size, zone)
+    volumeId = cloud.create_volume(size.to_s, zone)
+    fatal "Failed to create volume" if volumeId.nil?
+    return volumeId
+  end
+
+  def attach_volume(vol_id, instance_id, device)
+    cloud.attach_volume(vol_id, instance_id, device)
+  end
+
+  def setup_volume(ic, vol_spec)
+    created = nil
+    key = "#{ic.name}_#{vol_spec['device']}"
+    artifacts = rubber_instances.artifacts
+    vol_id = artifacts['volumes'][key]
+
+    # first create the volume if we don't have a global record (artifacts) for it
+    if ! vol_id
+      logger.info "Creating volume for #{ic.full_name}:#{vol_spec['device']}"
+      vol_id = create_volume(vol_spec['size'], vol_spec['zone'])
+      artifacts['volumes'][key] = vol_id
+      rubber_instances.save
+      created = vol_spec['device']
+    end
+
+    # then, attach it if we don't have a record (on instance) of attachment
+    ic.volumes ||= []
+    if ! ic.volumes.include?(vol_id)
+      logger.info "Attaching volume #{vol_id} to #{ic.full_name}:#{vol_spec['device']}"
+      attach_volume(vol_id, ic.instance_id, vol_spec['device'])
+      ic.volumes << vol_id
+      rubber_instances.save
+
+      print "Waiting for volume to attach"
+      while true do
+        print "."
+        sleep 2
+        volume = cloud.describe_volumes(vol_id).first
+        break if volume[:status] == "in-use"
+      end
+      print "\n"
+
+      # we don't mount/format at this time if we are doing a RAID array
+      if vol_spec['mount'] && vol_spec['filesystem']
+        # then format/mount/etc if we don't have an entry in hosts file
+        task :_setup_volume, :hosts => ic.external_ip do
+          rubber.run_script 'setup_volume', <<-ENDSCRIPT
+            if ! grep -q '#{vol_spec['mount']}' /etc/fstab; then
+              if mount | grep -q '#{vol_spec['mount']}'; then
+                umount '#{vol_spec['mount']}'
+              fi
+              mv /etc/fstab /etc/fstab.bak
+              cat /etc/fstab.bak | grep -v '#{vol_spec['mount']}' > /etc/fstab
+              echo '#{vol_spec['device']} #{vol_spec['mount']} #{vol_spec['filesystem']} noatime 0 0 # rubber volume #{vol_id}' >> /etc/fstab
+
+              #{('yes | mkfs -t ' + vol_spec['filesystem'] + ' ' + vol_spec['device']) if created}
+              mkdir -p '#{vol_spec['mount']}'
+              mount '#{vol_spec['mount']}'
+            fi
+          ENDSCRIPT
+        end
+        _setup_volume
+      end
+
+    end
+    return created
+  end
+
+  def setup_partition(ic, partition_spec)
+    created = nil
+    part_id = partition_spec['partition_device']
+
+    # Only create the partition if we haven't already done so
+    ic.partitions ||= []
+    if ! ic.partitions.include?(part_id)
+      # then format/mount/etc if we don't have an entry in hosts file
+      task :_setup_partition, :hosts => ic.external_ip do
+        rubber.run_script 'setup_partition', <<-ENDSCRIPT
+          if ! fdisk -l 2>&1 | grep -q '#{partition_spec['partition_device']}'; then
+            if grep -q '#{partition_spec['disk_device']}\\b' /etc/fstab; then
+              umount #{partition_spec['disk_device']}
+              mv /etc/fstab /etc/fstab.bak
+              cat /etc/fstab.bak | grep -v '#{partition_spec['disk_device']}\\b' > /etc/fstab
+            fi
+
+            # partition format is: Start (blank is first available),Size(MB due to -uM),Id(83=linux,82=swap,etc),Bootable
+            echo "#{partition_spec['start']},#{partition_spec['size']},#{partition_spec['type']},#{partition_spec['bootable']}" | sfdisk -L -uM #{partition_spec['disk_device']}
+          fi
+        ENDSCRIPT
+      end
+      _setup_partition
+
+      ic.partitions << part_id
+      rubber_instances.save
+      created = part_id
+
+    end
+
+    return created
+  end
+
+  def zero_partitions(ic, partitions)
+    env = rubber_cfg.environment.bind(ic.role_names, ic.name)
+
+    # don't zero out the ones that we weren't told to
+    partitions.delete_if do |part|
+      spec = env.local_volumes.find {|s| s['partition_device'] == part}
+      ! spec['zero']
+    end
+
+    if partitions.size > 0
+      zero_script = ""
+      partitions.each do |partition|
+        zero_script << "nohup dd if=/dev/zero bs=1M of=#{partition} &> /dev/null &\n"
+      end
+      # then format/mount/etc if we don't have an entry in hosts file
+      task :_zero_partitions, :hosts => ic.external_ip do
+        rubber.run_script 'zero_partitions', <<-ENDSCRIPT
+          # zero out parition for performance (see amazon DevGuide)
+          echo "Zeroing out raid partitions to improve performance, this way take a while"
+          #{zero_script}
+
+          echo "Waiting for partitions to zero out"
+          while true; do
+            if ! ps ax | grep -q "[d]d.*/dev/zero"; then exit; fi
+            echo -n .
+            sleep 1
+          done
+        ENDSCRIPT
+      end
+      _zero_partitions
+    end
+  end
+
+  def setup_raid_volume(ic, raid_spec, create=false)
+    if create
+      mdadm_init = "mdadm --create #{raid_spec['device']} --level #{raid_spec['raid_level']} --raid-devices #{raid_spec['source_devices'].size} #{raid_spec['source_devices'].sort.join(' ')}"
+    else
+      mdadm_init = "mdadm --assemble #{raid_spec['device']} #{raid_spec['source_devices'].sort.join(' ')}"
+    end
+
+    task :_setup_raid_volume, :hosts => ic.external_ip do
+      rubber.run_script 'setup_raid_volume', <<-ENDSCRIPT
+        if ! grep -q '#{raid_spec['device']}' /etc/fstab; then
+          if mount | grep -q '#{raid_spec['mount']}'; then
+            umount '#{raid_spec['mount']}'
+          fi
+          mv /etc/fstab /etc/fstab.bak
+          cat /etc/fstab.bak | grep -v '#{raid_spec['mount']}' > /etc/fstab
+          echo '#{raid_spec['device']} #{raid_spec['mount']} #{raid_spec['filesystem']} noatime 0 0 # rubber raid volume' >> /etc/fstab
+
+          # seems to help devices initialize, otherwise mdadm fails because
+          # device not ready even though ec2 says the volume is attached
+          fdisk -l &> /dev/null
+
+          #{mdadm_init}
+
+          # set reconstruction speed
+          echo $((30*1024)) > /proc/sys/dev/raid/speed_limit_min
+
+          echo 'DEVICE /dev/hd*[0-9] /dev/sd*[0-9]' > /etc/mdadm/mdadm.conf
+          mdadm --detail --scan >> /etc/mdadm/mdadm.conf
+
+          mv /etc/rc.local /etc/rc.local.bak
+          echo "mdadm --assemble --scan" > /etc/rc.local
+          chmod +x /etc/rc.local
+
+          #{('yes | mkfs -t ' + raid_spec['filesystem'] + ' ' + raid_spec['device']) if create}
+          mkdir -p '#{raid_spec['mount']}'
+          mount '#{raid_spec['mount']}'
+        fi
+      ENDSCRIPT
+    end
+    _setup_raid_volume
+  end
+
+  def destroy_volume(volume_id)
+
+    logger.info "Detaching volume #{volume_id}"
+    cloud.detach_volume(volume_id) rescue logger.info("Volume was not attached")
+
+    print "Waiting for volume to detach"
+    while true do
+      print "."
+      sleep 2
+      volume = cloud.describe_volumes(volume_id).first
+      status = volume && volume[:attachment_status]
+      break if !status || status == "detached"
+    end
+    print "\n"
+
+    logger.info "Deleting volume #{volume_id}"
+    cloud.destroy_volume(volume_id)
+
+    logger.info "Removing volume #{volume_id} from rubber instances file"
+    artifacts = rubber_instances.artifacts
+    artifacts['volumes'].delete_if {|k,v| v == volume_id}
+    rubber_instances.each do |ic|
+      ic.volumes.delete(volume_id) if ic.volumes
+    end
+    rubber_instances.save
+  end
+  
+end

data/lib/rubber/recipes/rubber.rb

@@ -0,0 +1,89 @@
+# add this plugins lib dir to load path for capistrano
+$:.unshift "#{File.dirname(__FILE__)}/../lib"
+require 'rubygems'
+require "socket"
+require 'resolv'
+require 'enumerator'
+require 'capistrano/hostcmd'
+require 'pp'
+require 'rubber'
+
+namespace :rubber do
+
+  # advise capistrano's task method so that tasks for non-existant roles don't
+  # fail when roles isn't defined due to using a FILTER for load_roles
+  # If you have a task you need to execute even when there are no
+  # roles, you have to use required_task instead of task - see rubber:create
+  # as an example of this role bootstrapping problem.
+  def allow_optional_tasks(ns)
+    class << ns
+      alias :required_task :task
+      def task(name, options={}, &block)
+        required_task(name, options) do
+          # define empty roles for the case when a task has a role that we don't define anywhere
+          [*options[:roles]].each do |r|
+            roles[r] ||= []
+          end
+          
+          if find_servers_for_task(current_task).empty?
+            logger.info "No servers for task #{name}, skipping"
+            next
+          end
+          block.call
+        end
+      end
+    end
+  end
+
+  allow_optional_tasks(self)
+  on :load, "rubber:init"
+    
+  required_task :init do
+    # Require cap 2.4 since we depend on bugs that have been fixed
+    require 'capistrano/version'
+    if Capistrano::Version::MAJOR < 2 || Capistrano::Version::MINOR < 4
+      fatal "rubber requires capistrano 2.4.0 or greater"
+    end
+    
+    set :rubber_cfg, Rubber::Configuration.get_configuration(RUBBER_ENV)
+    set :rubber_env, rubber_cfg.environment.bind()
+    set :rubber_instances, rubber_cfg.instance
+
+    set :cloud, Rubber::Cloud::get_provider(rubber_env.cloud_provider || "aws", rubber_env, self)
+
+    load_roles() unless rubber_env.disable_auto_roles
+    # NOTE: for some reason Capistrano requires you to have both the public and
+    # the private key in the same folder, the public key should have the
+    # extension ".pub".
+    ssh_options[:keys] = rubber_env.cloud_providers[rubber_env.cloud_provider].key_file
+  end
+
+
+  # Automatically load and define capistrano roles from instance config
+  def load_roles
+    top.roles.clear
+
+    # define empty roles for all known ones so tasks don't fail if a role
+    # doesn't exist due to a filter
+    all_roles = rubber_instances.all_roles
+    all_roles += rubber_cfg.environment.known_roles
+    all_roles.uniq!
+    all_roles.each {|name| top.roles[name.to_sym] = []}
+
+    # define capistrano host => role mapping for all instances
+    rubber_instances.filtered.each do |ic|
+      ic.roles.each do |role|
+        opts = Rubber::Util::symbolize_keys(role.options)
+        msg = "Auto role: #{role.name.to_sym} => #{ic.full_name}"
+        msg << ", #{opts.inspect}" if opts.inspect.size > 0
+        logger.info msg
+        top.role role.name.to_sym, ic.full_name, opts
+      end
+    end
+  end
+
+end
+
+Dir[File.join(File.dirname(__FILE__), 'rubber/*.rb')].each do |rubber_part|
+  load(rubber_part)
+end

data/lib/rubber/tasks/rubber.rb

@@ -0,0 +1,221 @@
+require 'fileutils'
+require 'date'
+require 'time'
+require 'aws/s3'
+require 'rubber'
+
+namespace :rubber do
+
+  def rubber_env()
+    Rubber::Configuration.rubber_env
+  end
+
+  def rubber_instances()
+    Rubber::Configuration.rubber_instances
+  end
+
+  def cloud_provider
+    rubber_env.cloud_providers[rubber_env.cloud_provider]
+  end
+
+  def init_s3()
+    AWS::S3::Base.establish_connection!(:access_key_id => cloud_provider.access_key, :secret_access_key => cloud_provider.secret_access_key)
+  end
+
+  desc "Generate system config files by transforming the files in the config tree"
+  task :config do
+    cfg = Rubber::Configuration.get_configuration(RUBBER_ENV)
+    instance_alias = cfg.environment.current_host
+    instance = cfg.instance[instance_alias]
+    if instance
+      roles = instance.role_names
+      env = cfg.environment.bind(roles, instance_alias)
+      gen = Rubber::Configuration::Generator.new("#{RUBBER_ROOT}/config/rubber", roles, instance_alias)
+    elsif RUBBER_ENV == 'development'
+      roles = cfg.environment.known_roles
+      role_items = roles.collect do |r|
+        Rubber::Configuration::RoleItem.new(r, r == "db" ? {'primary' => true} : {})
+      end
+      env = cfg.environment.bind(roles, instance_alias)
+      domain = env.domain
+      instance = Rubber::Configuration::InstanceItem.new(instance_alias, domain, role_items, 'dummyid', ['dummygroup'])
+      instance.external_host = instance.full_name
+      instance.external_ip = "127.0.0.1"
+      instance.internal_host = instance.full_name
+      instance.internal_ip = "127.0.0.1"
+      cfg.instance.add(instance)
+      gen = Rubber::Configuration::Generator.new("#{RUBBER_ROOT}/config/rubber", roles, instance_alias)
+      gen.fake_root ="#{RUBBER_ROOT}/tmp/rubber"
+    else
+      puts "Instance not found for host: #{instance_alias}"
+      exit 1
+    end
+
+    if ENV['NO_POST']
+      gen.no_post = true
+    end
+    if ENV['FILE']
+      gen.file_pattern = ENV['FILE']
+    end
+    if ENV['FORCE']
+      gen.force = true
+    end
+    gen.stop_on_error_cmd = env.stop_on_error_cmd
+    gen.run
+
+  end
+
+  desc <<-DESC
+    Rotate rails app server logfiles.  Should be run right after midnight.
+    The following arguments affect behavior:
+    LOG_DIR (required): Directory where log files are located
+    LOG_FILE (*.log):   File pattern to match to find logs to rotate
+    LOG_AGE (7):        Delete rotated logs older than this many days in the past
+  DESC
+  task :rotate_logs do
+    log_src_dir = get_env('LOG_DIR', true)
+    log_file_glob = get_env('LOG_FILES') || "*.log"
+    log_file_age = (get_env('LOG_AGE') || 7).to_i
+
+    rotated_date = (Date.today - 1).strftime('%Y%m%d')
+    puts "Rotating logfiles located at: #{log_src_dir}/#{log_file_glob}"
+    Dir["#{log_src_dir}/#{log_file_glob}"].each do |logfile|
+      rotated_file = "#{logfile}.#{rotated_date}"
+      if File.exist?(rotated_file)
+        rotated_file += "_#{Time.now.to_i}"
+      end
+      FileUtils.cp(logfile, rotated_file)
+      File.truncate logfile, 0
+    end
+
+    tdate = Date.today - log_file_age
+    threshold = Time.local(tdate.year, tdate.month, tdate.day)
+    puts "Cleaning rotated log files older than #{log_file_age} days"
+    Dir["#{log_src_dir}/#{log_file_glob}.[0-9]*"].each do |logfile|
+      if File.mtime(logfile) < threshold
+        FileUtils.rm_f(logfile)
+      end
+    end
+  end
+
+  desc <<-DESC
+    Backup database to given backup directory
+    The following arguments affect behavior:
+    BACKUP_DIR (required): Directory where db backups will be stored
+    BACKUP_AGE (7):        Delete rotated logs older than this many days in the past
+    DBUSER (required)      User to connect to the db as
+    DBPASS (optional):     Pass to connect to the db with
+    DBHOST (required):     Host where the db is
+    DBNAME (required):     Database name to backup
+  DESC
+  task :backup_db do
+    dir = get_env('BACKUP_DIR', true)
+    age = (get_env('BACKUP_AGE') || 3).to_i
+    time_stamp = Time.now.strftime("%Y-%m-%d_%H-%M")
+    backup_file = "#{dir}/#{RUBBER_ENV}_dump_#{time_stamp}.sql.gz"
+    FileUtils.mkdir_p(File.dirname(backup_file))
+
+    user = get_env('DBUSER', true)
+    pass = get_env('DBPASS')
+    pass = nil if pass.strip.size == 0
+    host = get_env('DBHOST', true)
+    name = get_env('DBNAME', true)
+    
+    raise "No db_backup_cmd defined in rubber.yml, cannot backup!" unless rubber_env.db_backup_cmd
+    db_backup_cmd = rubber_env.db_backup_cmd.gsub(/%([^%]+)%/, '#{\1}')
+    db_backup_cmd = eval('%Q{' + db_backup_cmd + '}')
+    
+    puts "Backing up database with command:"
+    sh db_backup_cmd
+    puts "Created backup: #{backup_file}"
+    
+    s3_prefix = "db/"
+    backup_bucket = cloud_provider.backup_bucket
+    if backup_bucket
+      init_s3
+      unless AWS::S3::Bucket.list.find { |b| b.name == backup_bucket }
+        AWS::S3::Bucket.create(backup_bucket)
+      end
+      dest = "#{s3_prefix}#{File.basename(backup_file)}"
+      puts "Saving db backup to S3: #{backup_bucket}:#{dest}"
+      AWS::S3::S3Object.store(dest, open(backup_file), backup_bucket)
+    end
+
+    tdate = Date.today - age
+    threshold = Time.local(tdate.year, tdate.month, tdate.day)
+    puts "Cleaning backups older than #{age} days"
+    Dir["#{dir}/*"].each do |file|
+      if File.mtime(file) < threshold
+        puts "Deleting #{file}"
+        FileUtils.rm_f(file)
+      end
+    end
+    
+    if backup_bucket
+      puts "Cleaning S3 backups older than #{age} days from: #{backup_bucket}:#{s3_prefix}"
+      AWS::S3::Bucket.objects(backup_bucket, :prefix => s3_prefix).clone.each do |obj|
+        if Time.parse(obj.about["last-modified"]) < threshold
+          puts "Deleting #{obj.key}"
+          obj.delete
+        end
+      end
+    end
+  end
+
+  desc <<-DESC
+    Restores a database backup from s3.
+    This tries to find the last backup made or the s3 object identified by the
+    key FILENAME
+    The following arguments affect behavior:
+    FILENAME (optional):   key of S3 object to use
+    DBUSER (required)      User to connect to the db as
+    DBPASS (optional):     Pass to connect to the db with
+    DBHOST (required):     Host where the db is
+    DBNAME (required):     Database name to backup
+  DESC
+  task :restore_db_s3 do
+    file = get_env('FILENAME')
+    user = get_env('DBUSER', true)
+    pass = get_env('DBPASS')
+    pass = nil if pass && pass.strip.size == 0
+    host = get_env('DBHOST', true)
+    name = get_env('DBNAME', true)
+    
+    raise "No db_restore_cmd defined in rubber.yml" unless rubber_env.db_restore_cmd
+    db_restore_cmd = rubber_env.db_restore_cmd.gsub(/%([^%]+)%/, '#{\1}')
+    db_restore_cmd = eval('%Q{' + db_restore_cmd + '}')
+
+    # try to fetch a matching file from s3 (if backup_bucket given)
+    backup_bucket = cloud_provider.backup_bucket
+    raise "No backup_bucket defined in rubber.yml" unless backup_bucket
+    if (init_s3 &&
+        AWS::S3::Bucket.list.find { |b| b.name == backup_bucket })
+      s3objects = AWS::S3::Bucket.find(backup_bucket,
+                 :prefix => 'db/') 
+      if file
+        puts "trying to fetch #{file} from s3"
+        data = s3objects.detect { |o| file == o.key }
+      else
+        puts "trying to fetch last modified s3 backup"
+        data = s3objects.max {|a,b| a.about["last-modified"] <=> b.about["last-modified"] }
+      end
+    end
+    raise "could not access backup file via s3" unless data
+
+    puts "piping restore data to command [#{db_restore_cmd}]"
+    IO.popen(db_restore_cmd, mode='w') do |p|
+      data.value do |segment|
+        p.write segment
+      end
+    end
+
+  end
+
+
+  def get_env(name, required=false)
+    value = ENV[name]
+    raise("#{name} is required, pass using environment") if required && ! value
+    return value
+  end
+
+end

data/lib/rubber/util.rb

@@ -0,0 +1,37 @@
+
+
+module Rubber
+  module Util
+
+    def self.symbolize_keys(map)
+      map.inject({}) do |options, (key, value)|
+        options[key.to_sym || key] = value
+        options
+      end
+    end
+    
+    def self.stringify(val)
+      case val
+      when String
+        val
+      when Hash
+        val.inject({}) {|h, a| h[stringify(a[0])] = stringify(a[1]); h}
+      when Enumerable
+        val.collect {|v| stringify(v)}
+      else
+        val.to_s
+      end
+      
+    end
+
+    # Opens the file for writing by root
+    def self.sudo_open(path, perms, &block)
+      open("|sudo tee #{path} > /dev/null", perms, &block)
+    end
+
+    def self.is_rails?
+      File.exist?(File.join(RUBBER_ROOT, 'config', 'environment.rb'))
+    end
+
+  end
+end

data/lib/rubber.rb

@@ -0,0 +1,38 @@
+$:.unshift(File.dirname(__FILE__))
+
+module Rubber
+
+  VERSION = File.read(File.join(File.dirname(__FILE__), '..', 'VERSION')).chomp
+
+  def self.initialize(project_root, project_env)
+    return if defined?(RUBBER_ROOT) && defined?(RUBBER_ENV)
+
+    Object.const_set('RUBBER_ENV', project_env)
+    Object.const_set('RUBBER_ROOT', File.expand_path(project_root))
+
+    # pull in basic rails env.  rubber only needs RAILS_ROOT and RAILS_ENV.
+    # We actually do NOT want the entire rails environment because it
+    # complicates bootstrap (i.e. can't run config to create db because full
+    # rails env needs db to exist as some plugin accesses model or something)
+    rails_boot_file = File.join(RUBBER_ROOT, 'config', 'boot')
+    require(rails_boot_file) if File.exists? rails_boot_file
+
+    if defined?(RAILS_DEFAULT_LOGGER) && RAILS_DEFAULT_LOGGER
+      Object.const_set('LOGGER', RAILS_DEFAULT_LOGGER)
+    else
+      Object.const_set('LOGGER', Logger.new($stdout))
+      LOGGER.level = Logger::INFO
+      LOGGER.formatter = lambda {|severity, time, progname, msg| "Rubber[%s]: %s\n" % [severity, msg.to_s.lstrip]}
+    end
+  end
+
+end
+
+
+require 'rubber/configuration'
+require 'rubber/environment'
+require 'rubber/generator'
+require 'rubber/instance'
+require 'rubber/util'
+require 'rubber/cloud'
+require 'rubber/dns'