rubber 2.0.5 → 2.0.6

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubber
 version: !ruby/object:Gem::Version
-  version: 2.0.5
+  version: 2.0.6
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-12 00:00:00.000000000 Z
+date: 2012-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: capistrano
@@ -245,9 +245,9 @@ files:
 - lib/rubber/commands/vulcanize.rb
 - lib/rubber/configuration.rb
 - lib/rubber/dns.rb
+- lib/rubber/dns/aws.rb
 - lib/rubber/dns/base.rb
 - lib/rubber/dns/dyndns.rb
-- lib/rubber/dns/fog.rb
 - lib/rubber/dns/nettica.rb
 - lib/rubber/dns/zerigo.rb
 - lib/rubber/environment.rb
@@ -545,6 +545,7 @@ files:
 - templates/resque/config/initializers/resque.rb
 - templates/resque/config/resque-pool.yml
 - templates/resque/config/resque-web.ru
+- templates/resque/config/resque.yml
 - templates/resque/config/rubber/common/resque.yml
 - templates/resque/config/rubber/deploy-resque.rb
 - templates/resque/config/rubber/role/resque_web/resque-web-upstart.conf
@@ -554,6 +555,13 @@ files:
 - templates/resque/lib/tasks/resque.rake
 - templates/resque/templates.rb
 - templates/resque/templates.yml
+- templates/resque_scheduler/config/rubber/common/resque_schedule.yml
+- templates/resque_scheduler/config/rubber/deploy-resque_scheduler.rb
+- templates/resque_scheduler/config/rubber/role/resque_scheduler/resque-scheduler-upstart.conf
+- templates/resque_scheduler/config/rubber/rubber-resque_scheduler.yml
+- templates/resque_scheduler/lib/tasks/resque-scheduler.rake
+- templates/resque_scheduler/templates.rb
+- templates/resque_scheduler/templates.yml
 - templates/sphinx/config/rubber/common/sphinx.yml
 - templates/sphinx/config/rubber/deploy-sphinx.rb
 - templates/sphinx/config/rubber/role/sphinx/crontab
@@ -595,7 +603,9 @@ files:
 - test/cloud/fog_storage_test.rb
 - test/cloud/fog_test.rb
 - test/command_test.rb
-- test/dns/fog_test.rb
+- test/commands/cron_test.rb
+- test/dns/aws_test.rb
+- test/dns/zerigo_test.rb
 - test/environment_test.rb
 - test/fixtures/basic/common/bar.conf
 - test/fixtures/basic/common/foo.conf
@@ -638,7 +648,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3015092347562391362
+      hash: -4247981851858635399
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -647,10 +657,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3015092347562391362
+      hash: -4247981851858635399
 requirements: []
 rubyforge_project: rubber
-rubygems_version: 1.8.21
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: A capistrano plugin for managing multi-instance deployments to the cloud
@@ -661,7 +671,9 @@ test_files:
 - test/cloud/fog_storage_test.rb
 - test/cloud/fog_test.rb
 - test/command_test.rb
-- test/dns/fog_test.rb
+- test/commands/cron_test.rb
+- test/dns/aws_test.rb
+- test/dns/zerigo_test.rb
 - test/environment_test.rb
 - test/fixtures/basic/common/bar.conf
 - test/fixtures/basic/common/foo.conf

data/lib/rubber/dns/fog.rb

@@ -1,219 +0,0 @@
-require 'rubygems'
-require 'fog'
-
-module Rubber
-  module Dns
-
-    class Fog < Base
-
-      attr_accessor :client
-      
-      def initialize(env)
-        super(env)
-        creds = Rubber::Util.symbolize_keys(env.credentials)
-        @client = ::Fog::DNS.new(creds)
-        if creds[:provider] == 'aws'
-          @name_includes_domain = true
-          @name_includes_trailing_period = true
-        end
-      end
-      
-      def normalize_name(name, domain)
-        domain = domain.gsub(/\.$/, "") if @name_includes_trailing_period
-
-        name = name.gsub(/\.$/, "") if @name_includes_trailing_period
-        name = name.gsub(/.?#{domain}$/, "") if @name_includes_domain
-        
-        return name, domain
-      end
-      
-      def denormalize_name(name, domain)
-        if @name_includes_domain
-          if name && name.strip.empty?
-            name = "#{domain}"
-          else
-            name = "#{name}.#{domain}"
-          end
-        end
-        
-        if @name_includes_trailing_period
-          name = "#{name}." 
-          domain = "#{domain}."
-        end
-        
-        return name, domain
-      end
-      
-      def host_to_opts(host)
-        name, domain = normalize_name(host.name || '', host.zone.domain)
-        opts = {}
-        opts[:id] = host.id if host.respond_to?(:id) && host.id
-        opts[:host] = fix_hostname(name)
-        opts[:domain] = domain
-        opts[:type] = host.type
-        opts[:ttl] = host.ttl.to_i if host.ttl
-        opts[:priority] = host.priority if host.respond_to?(:priority) && host.priority
-
-        if host.respond_to?(:alias_target) && ! host.alias_target.nil?
-
-          # Convert from camel-case to snake-case for Route 53 ALIAS records so the match the rubber config format.
-          opts[:data] = {
-            'hosted_zone_id' => host.alias_target['HostedZoneId'],
-            'dns_name' => host.alias_target['DNSName'].split('.')[0..-1].join('.')
-          }
-
-          # Route 53 ALIAS records do not have a TTL, so delete the rubber-supplied default value.
-          opts.delete(:ttl)
-        else
-          opts[:data] = Array(host.value).first if host.value
-        end
-
-        return opts
-      end
-
-      def opts_to_host(opts, host={})
-        name, domain = denormalize_name(opts[:host], opts[:domain])
-
-        host[:name] = name
-        host[:type] =  opts[:type]
-        host[:ttl] = opts[:ttl] if opts[:ttl]
-        host[:priority] = opts[:priority] if opts[:priority]
-
-        if opts[:data]
-          creds = Rubber::Util.symbolize_keys(env.credentials)
-
-          if creds[:provider] == 'aws'
-            # Route 53 requires the priority to be munged with the data value.
-            if opts[:type] =~ /MX/i
-              host[:value] = "#{opts[:priority]} #{opts[:data]}"
-            else
-              # Route 53 allows creation of ALIAS records, which will always be a Hash in the DNS config.  ALIAS records
-              # cannot have a TTL.
-              if opts[:data].is_a?(Hash)
-                host[:alias_target] = opts[:data]
-                host.delete(:ttl)
-              else
-                host[:value] = opts[:data]
-              end
-            end
-          else
-            host[:value] = opts[:data]
-          end
-        end
-
-        return host
-      end
-
-      def find_or_create_zone(domain)
-        zone = @client.zones.all.find {|z| z.domain =~ /^#{domain}\.?/}
-        if ! zone
-          zone = @client.zones.create(:domain => domain)
-        end
-        return zone
-      end
-      
-      def find_hosts(opts = {})
-        opts = setup_opts(opts, [:host, :domain])
-        result = []
-        zone = find_or_create_zone(opts[:domain])
-
-        host_type = opts[:type]
-        host_data = opts[:data]
-
-        fqdn = nil
-        if opts.has_key?(:host) && opts[:host] != '*'
-          hostname = opts[:host]
-          hostname = nil if hostname && hostname.strip.empty?
-
-          fqdn = ""
-          fqdn << "#{hostname}." if hostname
-          fqdn << "#{opts[:domain]}"
-        end
-
-        # TODO: revert this when fog gets fixed
-        # hosts = fqdn ? (zone.records.all(:name => fqdn) rescue []) : zone.records.all
-        hosts = zone.records.all
-        if fqdn
-          hosts = hosts.find_all do |r|
-            attributes = host_to_opts(r)
-
-            # Route 53 encodes the asterisk character ('*') as octal.  Translate it here so rubber is consistent.
-            host, domain = fix_hostname(attributes[:host]), attributes[:domain]
-            
-            fog_fqdn = ""
-            fog_fqdn << "#{host}." if host && ! host.strip.empty?
-            fog_fqdn << "#{domain}"
-            
-            fqdn == fog_fqdn
-          end
-        end
-
-        hosts.each do |h|
-          keep = true
-          attributes = host_to_opts(h)
-
-          if host_type && host_type != '*' && attributes[:type] != host_type
-            keep = false
-          end
-
-          if host_data && attributes[:data] != host_data
-            keep = false
-          end
-          
-          result << h if keep
-        end
-
-        result
-      end
-
-      def find_host_records(opts = {})
-        hosts = find_hosts(opts)
-        result = hosts.collect {|h| host_to_opts(h).merge(:domain => opts[:domain]) }
-        return result
-      end
-
-      def create_host_record(opts = {})
-        opts = setup_opts(opts, [:host, :data, :domain, :type, :ttl])
-        zone = find_or_create_zone(opts[:domain])
-        zone.records.create(opts_to_host(opts))
-      end
-
-      def destroy_host_record(opts = {})
-        opts = setup_opts(opts, [:host, :domain])
-
-        find_hosts(opts).each do |h|
-          h.destroy || raise("Failed to destroy #{h.hostname}")
-        end
-      end
-
-      def update_host_record(old_opts={}, new_opts={})
-        old_opts = setup_opts(old_opts, [:host, :domain])
-        new_opts = setup_opts(new_opts, [:host, :domain, :type, :data])
-
-        find_hosts(old_opts).each do |h|
-          changes = opts_to_host(new_opts)
-          result = nil
-          if h.respond_to?(:modify)
-            result = h.modify(changes)
-          elsif h.respond_to?(:update_host)
-            result = h.update_host(changes)
-          else
-            changes.each do |k, v|
-              h.send("#{k}=", v)
-            end
-            result = h.save
-          end
-
-          result || raise("Failed to update host #{h.hostname}, #{h.errors.full_messages.join(', ')}")
-        end
-      end
-
-      def fix_hostname(host)
-        # Route 53 encodes asterisks in their ASCII octal representation.
-        host.gsub("\\052", "*")
-      end
-
-    end
-
-  end
-end

data/test/dns/fog_test.rb

@@ -1,169 +0,0 @@
-require File.expand_path(File.join(__FILE__, '../..', 'test_helper'))
-require 'rubber/dns/fog'
-
-class FogTest < Test::Unit::TestCase
-
-  @envs = []
-
-  env = {'credentials' =>
-             {'provider' => 'zerigo', 'zerigo_email' => 'xxx', 'zerigo_token' => 'yyy'}}
-  @envs << Rubber::Configuration::Environment::BoundEnv.new(env, nil, nil)
-
-  unless ENV['CI']
-    secret = YAML.load_file(File.expand_path("~/rubber-secret.yml")) rescue {}
-    access_key = secret['cloud_providers']['aws']['access_key']
-    access_secret = secret['cloud_providers']['aws']['secret_access_key']
-    env = {'credentials' =>
-               {'provider' => 'aws', 'aws_access_key_id' => access_key, 'aws_secret_access_key' => access_secret}}
-    # no mocks for aws dns yet
-    @envs << Rubber::Configuration::Environment::BoundEnv.new(env, nil, nil)
-  end
-
-  def all_test_zones(dns=@dns)
-    dns.client.zones.all.find_all {|z| z.domain =~ /rubbertest/ }
-  end
-  
-  def destroy_test_domains
-    all_test_zones(Rubber::Dns::Fog.new(@env)).each do |zone|
-      zone.records.all.each do |record|
-        record.destroy
-      end
-      zone.destroy
-    end
-  end
-  
-  env = @envs.first
-  @envs.each do |env|
-
-    context "fog #{env.credentials.provider} dns" do
-
-      setup do
-        @env = env
-
-        # no mocks for aws dns yet
-        if env.credentials.provider == 'aws'
-          Fog.unmock!
-          destroy_test_domains
-        end
-        
-        @dns = Rubber::Dns::Fog.new(@env)
-      end
-      
-      context "find_or_create" do
-      
-        should "create domain if it doesn't exist" do
-          assert_equal 0, all_test_zones.size
-      
-          zone0 = @dns.find_or_create_zone("rubbertest.com")
-      
-          assert_equal 1, all_test_zones.size
-          zone1 = all_test_zones.find {|z| z.domain =~ /^rubbertest.com/ }
-          assert zone1
-          assert_equal zone0.id, zone1.id
-          assert_equal zone0.domain, zone1.domain
-        end
-      
-        should "match the same domain that was passed" do
-          assert_equal 0, all_test_zones.size
-      
-          zone0 = @dns.find_or_create_zone("abcrubbertest.com")
-          zone1 = @dns.find_or_create_zone("rubbertest.com")
-      
-          assert_equal 2, all_test_zones.size
-      
-          zone2 = all_test_zones.find {|z| z.domain =~ /^rubbertest.com/ }
-          assert zone2
-          assert_equal zone1.id, zone2.id
-          assert_equal zone1.domain, zone2.domain
-        end
-      
-        should "do nothing if domain already exists" do
-          @dns.client.zones.create(:domain => 'rubbertest.com')
-          assert_equal 1, all_test_zones.size
-      
-          zone0 = @dns.find_or_create_zone("rubbertest.com")
-      
-          assert_equal 1, all_test_zones.size
-          zone1 = all_test_zones.find {|z| z.domain =~ /^rubbertest.com/ }
-          assert_equal zone0.id, zone1.id
-          assert_equal zone0.domain, zone1.domain
-        end
-      
-      end
-
-      context "records" do
-      
-        setup do
-          @domain = "rubbertest.com"
-          @zone = @dns.find_or_create_zone(@domain)
-        end
-      
-        should "create_record" do
-          @dns.create_host_record({:host => 'newhost', :domain => @domain, :data => '1.1.1.1', :type => 'A', :ttl => '333'})
-        
-          assert_equal @zone.records.all.size, 1
-          record = @zone.records.first
-          attributes = @dns.host_to_opts(record)
-        
-          assert_equal 'newhost',             attributes[:host]
-          assert_equal @domain,               attributes[:domain]
-          assert_equal '1.1.1.1',             attributes[:data]
-          assert_equal 'A',                   attributes[:type]
-          assert_equal 333,                   attributes[:ttl]
-        end
-        
-        should "destroy_record" do
-          # Create the record we want to test destroying.
-          @dns.create_host_record({:host => 'newhost', :domain => @domain, :data => '1.1.1.1', :type => 'A'})
-          assert_equal 1, @zone.records.all.size
-        
-          @dns.destroy_host_record({:host => 'newhost', :domain => @domain})
-        
-          assert_equal 0, @zone.records.all.size
-        end
-        
-        should "update_record" do
-          params = {:host => 'host1', :domain => @domain, :data => "1.1.1.1"}
-          new = {:host => 'host1', :domain => @domain, :data => "1.1.1.2"}
-        
-          @dns.create_host_record({:host => 'host1', :domain => @domain, :data => '1.1.1.1', :type => 'A'})
-          assert_equal 1, @zone.records.all.size
-        
-          @dns.update_host_record(params, new)
-          assert_equal 1, @zone.records.all.size
-        
-          record = @zone.records.all.first
-          attributes = @dns.host_to_opts(record)
-          assert_equal '1.1.1.2', attributes[:data]
-        end
-        
-        should "find_records" do
-          # Set up some sample records.
-          created = []
-          created << {:host => 'host1', :domain => @domain, :data => '1.1.1.1', :type => 'A'}
-          created << {:host => '', :domain => @domain, :data => '1.1.1.1', :type => 'A'}
-          created.each {|r| @dns.create_host_record(r) }
-        
-          # Search for records through the rubber DNS interface and make sure whe get what we expected.
-        
-          # Wildcard search.
-          records = @dns.find_host_records(:host => '*', :domain => @domain)
-          assert_equal 2, records.size
-        
-          # Blank hostname search.
-          records = @dns.find_host_records(:host => '', :domain => @domain)
-          assert_equal 1, records.size
-          assert_equal '', records.first[:host]
-        
-          # Specific hostname search.
-          records = @dns.find_host_records(:host => 'host1', :domain => @domain)
-          assert_equal 1, records.size
-          assert_equal 'host1', records.first[:host]
-        end
-      
-      end
-
-    end
-
-  end
-end