rubber 1.0.2 → 1.1.0

data/VERSION

@@ -1 +1 @@
-1.0.2
+1.1.0

data/generators/vulcanize/templates/apache/config/rubber/rubber-apache.yml

@@ -2,6 +2,5 @@
 roles:
   apache:
     packages: [apache2]
-roles:
   web_tools:
     packages: [libapache2-mod-proxy-html]

data/generators/vulcanize/templates/base/config/rubber/deploy-setup.rb

@@ -20,26 +20,9 @@ namespace :rubber do
       if ent_ruby_hosts.size > 0
 
         task :_install_enterprise_ruby, :hosts => ent_ruby_hosts do
-
-          # preferences to pick up specific Ruby packages from brightbox
-          prefs = <<-DATA
-            Package: *
-            Pin: release l=brightbox
-            Pin-Priority: 1001
-
-            Package: ruby1.8-elisp
-            Pin: release l=Ubuntu
-            Pin-Priority: 1001
-          DATA
-
-          prefs.gsub!(/^ */, '') # remove leading whitespace
-          put(prefs, '/etc/apt/preferences')
-
-          rubber.sudo_script 'install_enterprise_ruby', <<-ENDSCRIPT
-            wget http://apt.brightbox.net/release.asc -O - | apt-key add -
-            echo "deb http://apt.brightbox.net/ hardy rubyee" > /etc/apt/sources.list.d/brightbox-rubyee.list
-          ENDSCRIPT
-
+          custom_package('http://rubyforge.org/frs/download.php/64479',
+                         'ruby-enterprise', '1.8.7-20090928',
+                         '! `ruby --version 2> /dev/null` =~ "Ruby Enterprise Edition 20090928"')
         end
 
         _install_enterprise_ruby

data/generators/vulcanize/templates/base/config/rubber/rubber-dns.yml

@@ -0,0 +1,79 @@
+# OPTIONAL: The dns provider to use.  Need to exist in dns_providers below
+# dns_provider: nettica
+
+# OPTIONAL: The configuration for each dns provider (nettica|zerigo|dyndns)
+#          This lets rubber update a dynamic dns service with the instance alias and ip
+#
+dns_providers:
+  nettica:
+    user: joe
+    password: sekret
+    type: A
+    ttl: 300
+  zerigo:
+    customer_id: 1234
+    email: foo@bar.com
+    token: hexxy
+    type: A
+    ttl: 300
+  dyndns:
+    user: joe
+    password: sekret
+    update_url: https://members.dyndns.org/nic/update?hostname=%host%&myip=%ip%'
+
+# OPTIONAL: Lets you configure your dns service, for example to add other CNAMES
+#           or setup dns round robin, etc.  Run "cap rubber:setup_dns_records"
+#           to apply them as rubber only sets up instance aliases as part of
+#           the standard lifecycle
+#
+#  dns_records:
+#    # simple A record
+#    - host: bar
+#      data: 1.1.1.1
+#
+#    # more detailed A record
+#    - host: bar
+#      domain: otherdomain.com
+#      data: 1.1.1.1
+#      type: A
+#      ttl: 300
+#
+#    # tld A record
+#    - host: ''
+#      data: 1.1.1.1
+#      type: A
+#
+#    # simple CNAME record
+#    - host: otherbar
+#      domain: foo.com
+#      data: bar.foo.com
+#      type: CNAME
+#      ttl: 300
+#
+#    # 2 of the same A records is a round robin dns
+#    - host: rr
+#      domain: foo.com
+#      data: 1.1.1.1
+#      type: A
+#      ttl: 300
+#    - host: rr
+#      domain: foo.com
+#      data: 1.1.1.2
+#      type: A
+#      ttl: 300
+#
+#    # A record, grabbing ip from instance config
+#    - host: baz
+#      domain: foo.com
+#      data: "#{rubber_instances.for_role('web').first.external_ip}"
+#      type: A
+#      ttl: 300
+#
+#    # MX record
+#    - host: ''
+#      domain: foo.com
+#      data: mail.foo.com
+#      type: MX
+#      ttl: 300
+#      priority: 10
+

data/generators/vulcanize/templates/base/config/rubber/rubber.yml

@@ -32,28 +32,10 @@ timezone: US/Eastern
 #
 domain: foo.com
 
-# OPTIONAL: The configuration for each dns provider (nettica|zerigo|dyndns)
-#          This lets rubber updatea dynamic dns service with the instance alias and ip
-#
-dns_providers:
-  nettica:
-    user: joe
-    password: sekret
-    record_type: A
-    ttl: 300
-  zerigo:
-    customer_id: 1234
-    email: foo@bar.com
-    token: hexxy
-    record_type: A
-    ttl: 300
-  dyndns:
-    user: joe
-    password: sekret
-    update_url: https://members.dyndns.org/nic/update?hostname=%host%&myip=%ip%'
-
-# OPTIONAL: The dns provider to use
-# dns_provider: nettica
+# OPTIONAL: See rubber-dns.yml for dns configuration
+# This lets rubber update a dynamic dns service with the instance alias
+# and ip when they are created.  It also allows setting up arbitrary
+# dns records (CNAME, MX, Round Robin DNS, etc)
 
 # OPTIONAL: Additional rubber file to pull config from if it exists.  This file will
 # also be pushed to remote host at RUBBER_ROOT/config/rubber/rubber-secret.yml
@@ -144,12 +126,12 @@ use_enterprise_ruby: false
 packages: [postfix, build-essential, ruby-full, ruby1.8-dev, rake, irb]
 
 # OPTIONAL: gem sources to setup for rubygems
-gemsources: ["http://gems.rubyforge.org/", "http://gems.github.com"]
+gemsources: ["http://gemcutter.org", "http://gems.rubyforge.org/", "http://gems.github.com"]
 
 # OPTIONAL: The gems to install on all instances
 # You can install a specific version of a gem by using a sub-array of gem, version
 # For example, gem: [[rails, 2.2.2], open4, aws-s3]
-gems: [wr0ngway-rubber, rails, open4, aws-s3]
+gems: [rubber, rails, open4, aws-s3]
 
 # OPTIONAL: A string prepended to shell command strings that cause multi
 # statement shell commands to fail fast.  You may need to comment this out

data/generators/vulcanize/templates/complete_passenger_mysql/config/rubber/role/haproxy/haproxy-passenger.conf

@@ -8,12 +8,14 @@
 %>
 
 listen passenger_proxy 0.0.0.0:<%= rubber_env.web_port %>
+  option forwardfor
   <% backend_hosts.each do |server| %>
     server <%= server %> <%= server %>:<%= rubber_env.passenger_listen_port %> maxconn <%= rubber_env.max_app_connections %> check
   <% end %>
 
 listen passenger_proxy 0.0.0.0:<%= rubber_env.web_ssl_port %>
   mode tcp
+  option forwardfor
   <% backend_hosts.each do |server| %>
     server <%= server %> <%= server %>:<%= rubber_env.passenger_listen_ssl_port %> maxconn <%= rubber_env.max_app_connections %> check
   <% end %>

data/generators/vulcanize/templates/passenger/config/rubber/deploy-passenger.rb

@@ -9,7 +9,7 @@ namespace :rubber do
     
     task :custom_install, :roles => :passenger do
       rubber.sudo_script 'install_passenger', <<-ENDSCRIPT
-        if [[ -z `ls /usr/lib/ruby/gems/*/gems/passenger-#{rubber_env.passenger_version}/ext/apache2/mod_passenger.so 2> /dev/null` ]]; then
+        if [[ -z `ls /usr/local/lib/ruby/gems/*/gems/passenger-#{rubber_env.passenger_version}/ext/apache2/mod_passenger.so 2> /dev/null` ]]; then
           echo -en "\n\n\n\n" | passenger-install-apache2-module
         fi
       ENDSCRIPT

data/generators/vulcanize/templates/passenger/config/rubber/role/passenger/passenger.conf

@@ -2,9 +2,9 @@
   @path = '/etc/apache2/mods-available/passenger.conf'
   @post = 'cd /etc/apache2/mods-enabled && ln -fs ../mods-available/passenger.conf'
 %>
-LoadModule passenger_module /usr/lib/ruby/gems/1.8/gems/passenger-<%= rubber_env.passenger_version %>/ext/apache2/mod_passenger.so
-PassengerRoot /usr/lib/ruby/gems/1.8/gems/passenger-<%= rubber_env.passenger_version %>
-PassengerRuby /usr/bin/ruby
+LoadModule passenger_module /usr/local/lib/ruby/gems/1.8/gems/passenger-<%= rubber_env.passenger_version %>/ext/apache2/mod_passenger.so
+PassengerRoot /usr/local/lib/ruby/gems/1.8/gems/passenger-<%= rubber_env.passenger_version %>
+PassengerRuby /usr/local/bin/ruby
 PassengerUseGlobalQueue on
 
 PassengerMaxPoolSize <%= rubber_env.max_app_connections %>

data/lib/rubber/cloud/aws.rb

@@ -255,6 +255,7 @@ module Rubber
 
       def destroy_image(image_id)
         image = describe_images(image_id).first
+        raise "Could not find image: #{image_id}, aborting destroy_image"
         image_location = image[:location]
         bucket = image_location.split('/').first
         image_name = image_location.split('/').last.gsub(/\.manifest\.xml$/, '')

data/lib/rubber/dns/base.rb

@@ -3,65 +3,80 @@ module Rubber
 
     class Base
 
-      attr_reader :env
+      attr_reader :env, :provider_env, :provider_name
 
-      def initialize(env)
+      def initialize(env, provider_name)
         @env = env
+        @provider_name = provider_name
+        @provider_env = @env.dns_providers[provider_name]
       end
 
       def update(host, ip)
         if up_to_date(host, ip)
           puts "IP has not changed for #{host}, not updating dynamic DNS"
         else
-          if ! host_exists?(host)
+          if find_host_records(:host => host).size == 0
             puts "Creating dynamic DNS: #{host} => #{ip}"
-            create_host_record(host, ip)
+            create_host_record(:host => host, :data => ip)
           else
             puts "Updating dynamic DNS: #{host} => #{ip}"
-            update_host_record(host, ip)
+            update_host_record({:host => host}, {:host => host, :data => ip})
           end
         end
       end
 
       def destroy(host)
-        if host_exists?(host)
+        if find_host_records(:host => host).size != 0
           puts "Destroying dynamic DNS record: #{host}"
-          destroy_host_record(host)
+          destroy_host_record(:host => host)
         end
       end
 
-      def hostname(host)
-        "#{host}.#{@env.domain}"
-      end
-
       def up_to_date(host, ip)
-        # This queries dns server directly instead of using hosts file
-        current_ip = nil
-        Resolv::DNS.open(:nameserver => [nameserver], :search => [], :ndots => 1) do |dns|
-          current_ip = dns.getaddress(hostname(host)).to_s rescue nil
-        end
-        return ip == current_ip
+        find_host_records(:host => host).any? {|host| host[:data] == ip}
       end
 
-      def nameserver()
-        raise "nameserver not implemented"
+      def create_host_record(opts = {})
+        raise "create_host_record not implemented"
       end
 
-      def host_exists?(host)
-        raise "host_exists? not implemented"
+      def find_host_records(opts = {})
+        raise "find_host_records not implemented"
       end
 
-      def create_host_record(host, ip)
-        raise "create_host_record not implemented"
+      def update_host_record(old_opts={}, new_opts={})
+        raise "update_host_record not implemented"
       end
 
-      def destroy_host_record(host)
+      def destroy_host_record(opts = {})
         raise "destroy_host_record not implemented"
       end
 
-      def update_host_record(host, ip)
-        raise "update_host_record not implemented"
+      def host_records_equal?(lhs_opts = {}, rhs_opts = {})
+        lhs = setup_opts(lhs_opts)
+        rhs = setup_opts(rhs_opts)
+        [lhs, rhs].each {|h| h.delete(:id); h.delete(:priority) if h[:priority] == 0}
+        lhs == rhs
+      end
+
+      def setup_opts(opts, required=[])
+        default_opts = {:domain => @env.domain,
+                        :type => @provider_env['type'] || @provider_env.record_type || 'A',
+                        :ttl => @provider_env.ttl || 300}
+        
+        if opts.delete(:no_defaults)
+          actual_opts = Rubber::Util::symbolize_keys(opts)
+        else
+          actual_opts = default_opts.merge(Rubber::Util::symbolize_keys(opts))
+        end
+
+        required.each do |r|
+          raise "Missing required options: #{r}" unless actual_opts[r]
+        end
+
+        return actual_opts
       end
+      
 
     end
 

data/lib/rubber/dns/dyndns.rb

@@ -4,10 +4,9 @@ module Rubber
     class Dyndns < Base
 
       def initialize(env)
-        super(env)
-        @dyndns_env = env.dns_providers.dyndns
-        @user, @pass = @dyndns_env.user, @dyndns_env.password
-        @update_url = @dyndns_env.update_url || 'https://members.dyndns.org/nic/update?hostname=%host%&myip=%ip%'
+        super(env, 'dyndns')
+        @user, @pass = provider_env.user, provider_env.password
+        @update_url = provider_env.update_url || 'https://members.dyndns.org/nic/update?hostname=%host%&myip=%ip%'
         @update_url = @update_url.gsub(/%([^%]+)%/, '#{\1}')
       end
 
@@ -15,10 +14,22 @@ module Rubber
         "ns1.mydyndns.org"
       end
 
-      def host_exists?(host)
+      def up_to_date(host, ip)
+        # This queries dns server directly instead of using hosts file
+        current_ip = nil
+        Resolv::DNS.open(:nameserver => [nameserver], :search => [], :ndots => 1) do |dns|
+          current_ip = dns.getaddress("#{host}.#{provider_env.domain}").to_s rescue nil
+        end
+        return ip == current_ip
+      end
+      
+      def find_host_records(opts={})
+        opts = setup_opts(opts, [:host, :domain])
+        hostname = "#{opts[:host]}.#{opts[:domain]}"
         begin
           Resolv::DNS.open(:nameserver => [nameserver], :search => [], :ndots => 1) do |dns|
-            dns.getresource(hostname(host), Resolv::DNS::Resource::IN::A)
+            r = dns.getresource(hostname, Resolv::DNS::Resource::IN::A)
+            result = [{:host =>host, :data => r.address}]
           end
         rescue
           raise "Domain needs to exist in dyndns as an A record before record can be updated"
@@ -26,16 +37,20 @@ module Rubber
         return true
       end
 
-      def create_host_record(host, ip)
+      def create_host_record(opts={})
         puts "WARNING: No create record available for dyndns, you need to do so manually"
       end
 
-      def destroy_host_record(host)
+      def destroy_host_record(opts={})
         puts "WARNING: No destroy record available for dyndns, you need to do so manually"
       end
 
-      def update_host_record(host, ip)
-        host = hostname(host)
+      def update_host_record(old_opts={}, new_opts={})
+        old_opts = setup_opts(opts, [:host, :domain])
+        new_opts = setup_opts(opts, [:data])
+        
+        host = hostname(old_opts[:host])
+        ip = new_opts[:data]
         update_url = eval('%Q{' + @update_url + '}')
 
         # This header is required by dyndns.org

data/lib/rubber/dns/nettica.rb

@@ -5,15 +5,8 @@ module Rubber
     class Nettica < Base
 
       def initialize(env)
-        super(env)
-        @nettica_env = @env.dns_providers.nettica
-        @client = ::Nettica::Client.new(@nettica_env.user, @nettica_env.password)
-        @ttl = (@nettica_env.ttl || 300).to_i
-        @record_type = @nettica_env.record_type || "A"
-      end
-
-      def nameserver
-        "dns1.nettica.com"
+        super(env, "nettica")
+        @client = ::Nettica::Client.new(provider_env.user, provider_env.password)
       end
 
       def check_status(response)
@@ -33,40 +26,91 @@ module Rubber
         return response
       end
 
-      def host_exists?(host)
-        domain_info = check_status @client.list_domain(env.domain)
-        raise "Domain needs to exist in nettica before records can be updated" unless domain_info.record
-        return domain_info.record.any? { |r| r.hostName == host }
+      def find_host_records(opts = {})
+        opts = setup_opts(opts, [:host, :domain])
+
+        result = []
+        hn = opts[:host]
+        ht = opts[:type]
+        hd = opts[:data]
+
+        domain_info = find_or_create_zone(opts[:domain])
+
+        domain_info.record.each do |h|
+          keep = true
+          if hn && h.hostName != hn && hn != '*'
+            keep = false
+          end
+          if ht && h.recordType != ht && ht != '*'
+            keep = false
+          end
+          if hd && h.data != hd
+            keep = false
+          end
+          result << record_to_opts(h) if keep
+        end
+
+        return result
       end
 
-      def create_host_record(host, ip)
-        new = @client.create_domain_record(env.domain, host, @record_type, ip, @ttl, 0)
-        check_status @client.add_record(new)
+      def create_host_record(opts = {})
+        opts = setup_opts(opts, [:host, :data, :domain, :type, :ttl])
+        find_or_create_zone(opts[:domain])
+        record = opts_to_record(opts)
+        check_status @client.add_record(record)
       end
 
-      def destroy_host_record(host)
-        old_record = check_status(@client.list_domain(env.domain)).record.find {|r| r.hostName == host }
-        old = @client.create_domain_record(env.domain, host, old_record.recordType, old_record.data, old_record.tTL, old_record.priority)
-        check_status @client.delete_record(old)
+      def destroy_host_record(opts = {})
+        find_host_records(opts).each do |h|
+          record = opts_to_record(h)
+          check_status @client.delete_record(record)
+        end
       end
 
-      def update_host_record(host, ip)
-        old_record = check_status(@client.list_domain(env.domain)).record.find {|r| r.hostName == host }
-        update_record(host, ip, old_record)
+      def update_host_record(old_opts = {}, new_opts = {})
+        old_opts = setup_opts(old_opts, [:host, :domain])
+        new_opts = setup_opts(new_opts.merge(:no_defaults =>true), [])
+        find_host_records(old_opts).each do |h|
+          old_record = opts_to_record(h)
+          new_record = opts_to_record(h.merge(new_opts))
+          check_status @client.update_record(old_record, new_record)
+        end
       end
 
-      # update the top level domain record which has an empty hostName
-      def update_domain_record(ip)
-        old_record = check_status(@client.list_domain(env.domain)).record.find {|r| r.hostName == '' and r.recordType == 'A' and r.data =~ /\A\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\z/}
-        update_record('', ip, old_record)
+      private
+
+      def find_or_create_zone(domain)
+        domain_info = @client.list_domain(domain)
+        if domain_info.record
+          check_status domain_info
+        else
+          check_status @client.create_zone(domain)
+          domain_info = check_status @client.list_domain(domain)
+          raise "Could not create zone in nettica: #{domain}" unless domain_info.record
+        end
+        return domain_info
       end
 
-      def update_record(host, ip, old_record)
-        old = @client.create_domain_record(env.domain, host, old_record.recordType, old_record.data, old_record.tTL, old_record.priority)
-        new = @client.create_domain_record(env.domain, host, @record_type, ip, @ttl, 0)
-        check_status @client.update_record(old, new)
+      def opts_to_record(opts)
+        record = @client.create_domain_record(opts[:domain],
+                                              opts[:host],
+                                              opts[:type],
+                                              opts[:data],
+                                              opts[:ttl],
+                                              opts[:priority] || 0)
+        return record
       end
 
+      def record_to_opts(record)
+        opts = {}
+        opts[:host] = record.hostName || ''
+        opts[:domain] = record.domainName
+        opts[:type] = record.recordType
+        opts[:data] = record.data if record.data
+        opts[:ttl] = record.tTL if record.tTL
+        opts[:priority] = record.priority if record.priority
+        return opts
+      end
     end
 
   end

data/lib/rubber/dns/zerigo.rb

@@ -9,6 +9,11 @@ module Rubber
       include HTTParty
       format :xml
 
+      @@zones = {}
+      def self.get_zone(domain, provider_env)
+       @@zones[domain] ||= Zone.new(provider_env.customer_id, provider_env.email, provider_env.token, domain)
+      end
+
       def initialize(customer_id, email, token, domain)
         self.class.basic_auth email, token
         self.class.base_uri "https://ns.zerigo.com/accounts/#{customer_id}"
@@ -26,31 +31,49 @@ module Rubber
         return response
       end
 
-      def hosts
-        hosts = check_status self.class.get("/zones/#{@zone['id']}/hosts.xml")
-        return hosts['hosts']
+      def create_host(opts)
+        host = opts_to_host(opts, new_host())
+        check_status self.class.post("/zones/#{@zone['id']}/hosts.xml", :body => {:host => host})
       end
 
-      def host(hostname)
-        hosts = check_status self.class.get("/zones/#{@zone['id']}/hosts.xml?fqdn=#{hostname}.#{@domain}")
-        return (hosts['hosts'] || []).first
-      end
+      def find_host_records(opts={})
+        result = []
+        hn = opts[:host]
+        ht = opts[:type]
+        hd = opts[:data]
+        has_host = hn && hn != '*'
 
-      def new_host
-        check_status(self.class.get("/zones/#{@zone['id']}/hosts/new.xml"))['host']
-      end
+        url = "/zones/#{@zone['id']}/hosts.xml"
+        if has_host
+          url << "?fqdn="
+          url << "#{hn}." if hn.strip.size > 0
+          url << "#{@domain}"
+        end
+        hosts = self.class.get(url)
 
-      def create_host(host)
-        check_status self.class.post("/zones/#{@zone['id']}/hosts.xml", :body => {:host => host})
+        # returns 404 on not found, so don't check status
+        hosts = check_status hosts unless has_host
+
+        hosts['hosts'].each do |h|
+          keep = true
+          if ht && h['host_type'] != ht && ht != '*'
+            keep = false
+          end
+          if hd && h['data'] != hd
+            keep = false
+          end
+          result << host_to_opts(h) if keep
+        end if hosts['hosts']
+
+        return result
       end
 
-      def update_host(host)
-        host_id = host['id']
+      def update_host(host_id, opts)
+        host = opts_to_host(opts, new_host())
         check_status self.class.put("/zones/#{@zone['id']}/hosts/#{host_id}.xml", :body => {:host => host})
       end
 
-      def delete_host(hostname)
-        host_id = host(hostname)['id']
+      def delete_host(host_id)
         check_status self.class.delete("/zones/#{@zone['id']}/hosts/#{host_id}.xml")
       end
 
@@ -62,67 +85,87 @@ module Rubber
           zones = check_status self.class.get('/zones.xml')
           @zone = zones["zones"].find {|z| z["domain"] == @domain }
         end
+        if ! @zone
+          zone = new_zone()
+          zone['domain'] = @domain
+          zones = check_status self.class.post('/zones.xml', :body => {:zone => zone})
+          @zone = zones['zone']
+        end
       end
 
-      def data
+      def zone_record
         return @zone
       end
 
-      protected
+      private
 
-      def zones()
-        check_status self.class.get('/zones.xml')
+      def new_host
+        check_status(self.class.get("/zones/#{@zone['id']}/hosts/new.xml"))['host']
+      end
+
+      def new_zone
+        check_status(self.class.get("/zones/new.xml"))['zone']
+      end
+
+      def opts_to_host(opts, host={})
+        host['hostname'] = opts[:host]
+        host['host_type'] =  opts[:type]
+        host['data'] = opts[:data] if opts[:data]
+        host['ttl'] = opts[:ttl] if opts[:ttl]
+        host['priority'] = opts[:priority] if opts[:priority]
+        return host
       end
 
-      def zone(domain_name)
-        zone =  zones
-        return zone
+      def host_to_opts(host)
+        opts = {}
+        opts[:id] = host['id'] 
+        opts[:domain] = @domain
+        opts[:host] = host['hostname'] || ''
+        opts[:type] = host['host_type']
+        opts[:data] = host['data'] if host['data']
+        opts[:ttl] = host['ttl'] if host['ttl']
+        opts[:priority] = host['priority'] if host['priority']
+        return opts
       end
-      
     end
     
     class Zerigo < Base
 
       def initialize(env)
-        super(env)
-        @zerigo_env = env.dns_providers.zerigo
-        @ttl = (@zerigo_env.ttl || 300).to_i
-        @record_type = @zerigo_env.record_type || "A"
-        @zone = Zone.new(@zerigo_env.customer_id, @zerigo_env.email, @zerigo_env.token, env.domain)
+        super(env, "zerigo")
       end
 
-      def nameserver
-        "a.ns.zerigo.net"
-      end
+      def find_host_records(opts = {})
+        opts = setup_opts(opts, [:host, :domain])
+        zone = Zone.get_zone(opts[:domain], provider_env)
 
-      def host_exists?(host)
-        @zone.host(host)
+        zone.find_host_records(opts)
       end
 
-      def create_host_record(hostname, ip)
-        host = @zone.new_host()
-        host['host-type'] =  @record_type
-        host['ttl'] = @ttl
-        host['hostname'] = hostname
-        host['data'] = ip
-        @zone.create_host(host)
-      end
+      def create_host_record(opts = {})
+        opts = setup_opts(opts, [:host, :data, :domain, :type, :ttl])
+        zone = Zone.get_zone(opts[:domain], provider_env)
 
-      def destroy_host_record(host)
-        @zone.delete_host(host)
+        zone.create_host(opts)
       end
 
-      def update_host_record(host, ip)
-        old = @zone.host(host)
-        old['data'] = ip
-        @zone.update_host(old)
+      def destroy_host_record(opts = {})
+        opts = setup_opts(opts, [:host, :domain])
+        zone = Zone.get_zone(opts[:domain], provider_env)
+
+        find_host_records(opts).each do |h|
+          zone.delete_host(h[:id])
+        end
       end
 
-      # update the top level domain record which has an empty hostName
-      def update_domain_record(ip)
-        old = @zone.hosts.find {|h| h['hostname'].nil? }
-        old['data'] = ip
-        @zone.update_host(old)
+      def update_host_record(old_opts={}, new_opts={})
+        old_opts = setup_opts(old_opts, [:host, :domain])
+        new_opts = setup_opts(new_opts.merge(:no_defaults =>true), [])
+        zone = Zone.get_zone(old_opts[:domain], provider_env)
+
+        find_host_records(old_opts).each do |h|
+          zone.update_host(h[:id], h.merge(new_opts))
+        end
       end
 
     end

data/lib/rubber/environment.rb

@@ -32,6 +32,8 @@ module Rubber
         roles_dir = File.join(@config_root, "role")
         roles = Dir.entries(roles_dir)
         roles.delete_if {|d| d =~ /(^\..*)/}
+        roles += @items['roles'].keys
+        return roles.compact.uniq
       end
 
       def current_host
@@ -41,7 +43,7 @@ module Rubber
       def current_full_host
         Socket::gethostname
       end
-
+      
       def bind(roles = nil, host = nil)
         BoundEnv.new(@items, roles, host)
       end
@@ -95,6 +97,7 @@ module Rubber
         end
 
         def expand_string(val)
+          rubber_instances = Rubber::Configuration::rubber_instances
           while val =~ /\#\{[^\}]+\}/
             val = eval('%Q{' + val + '}', binding)
           end

data/lib/rubber/recipes/rubber/setup.rb

@@ -61,6 +61,83 @@ namespace :rubber do
     end
   end
 
+  desc <<-DESC
+    Sets up the additional dns records supplied in the dns_records config in rubber.yml
+  DESC
+  required_task :setup_dns_records do
+    records = rubber_env.dns_records
+    if records && rubber_env.dns_provider
+      provider = Rubber::Dns::get_provider(rubber_env.dns_provider, rubber_env)
+
+      # collect the round robin records (those with the same host/domain/type)
+      rr_records = []
+      records.each_with_index do |record, i|
+        m = records.find_all {|r| record['host'] == r['host'] && record['domain'] == r['domain'] && record['type'] == r['type']}
+        m = m.sort {|a,b| a.object_id <=> b.object_id}
+        rr_records << m if m.size > 1 && ! rr_records.include?(m)
+      end
+
+      # simple records are those that aren't round robin ones
+      simple_records = records - rr_records.flatten
+      
+      # for each simple record, create or update as necessary
+      simple_records.each do |record|
+        matching = provider.find_host_records(:host => record['host'], :domain =>record['domain'], :type => record['type'])
+        if matching.size > 1
+          msg =  "Multiple records in dns provider, but not in rubber.yml\n"
+          msg << "Round robin records need to be in both, or neither.\n"
+          msg << "Please fix manually:\n"
+          msg << matching.pretty_inspect
+          fatal(msg)
+        end
+
+        record = provider.setup_opts(record)
+        if matching.size == 1
+          match = matching.first
+          if  provider.host_records_equal?(record, match)
+            logger.info "Simple dns record already up to date: #{record[:host]}.#{record[:domain]}:#{record[:type]} => #{record[:data]}"
+          else
+            logger.info "Updating simple dns record: #{record[:host]}.#{record[:domain]}:#{record[:type]} => #{record[:data]}"
+            provider.update_host_record(match, record)
+          end
+        else
+          logger.info "Creating simple dns record: #{record[:host]}.#{record[:domain]}:#{record[:type]} => #{record[:data]}"
+          provider.create_host_record(record)
+        end
+      end
+
+      # group round robin records
+      rr_records.each do |rr_group|
+        host = rr_group.first['host']
+        domain = rr_group.first['domain']
+        type = rr_group.first['type']
+        matching = provider.find_host_records(:host => host, :domain => domain, :type => type)
+
+        # remove from consideration the local records that are the same as remote ones
+        matching.clone.each do |r|
+          rr_group.delete_if {|rg| provider.host_records_equal?(r, rg) }
+          matching.delete_if {|rg| provider.host_records_equal?(r, rg) }
+        end
+        if rr_group.size == 0 && matching.size == 0
+          logger.info "Round robin dns records already up to date: #{host}.#{domain}:#{type}"
+        end
+
+        # create the local records that don't exist remotely
+        rr_group.each do |r|
+          r = provider.setup_opts(r)
+          logger.info "Creating round robin dns record: #{r[:host]}.#{r[:domain]}:#{r[:type]} => #{r[:data]}"
+          provider.create_host_record(r)
+        end
+        
+        # remove the remote records that don't exist locally
+        matching.each do |r|
+          logger.info "Removing round robin dns record: #{r[:host]}.#{r[:domain]}:#{r[:type]} => #{r[:data]}"
+          provider.destroy_host_record(r)
+        end
+      end
+    end
+  end
+
   desc <<-DESC
     Sets up aliases for instance hostnames based on contents of instance.yml.
     Generates /etc/hosts for remote machines and sets hostname on remote instances
@@ -144,11 +221,33 @@ namespace :rubber do
   desc <<-DESC
     Install ruby gems defined in the rails environment.rb
   DESC
-  after "deploy:symlink", "rubber:install_rails_gems" if Rubber::Util.is_rails?
+  after "rubber:config", "rubber:install_rails_gems" if Rubber::Util.is_rails?
   task :install_rails_gems do
     sudo "sh -c 'cd #{current_path} && RAILS_ENV=#{RUBBER_ENV} rake gems:install'"
   end
 
+  desc <<-DESC
+    Convenience task for installing your defined set of ruby gems locally.
+  DESC
+  required_task :install_local_gems do
+    fatal("install_local_gems can only be run in development") if RUBBER_ENV != 'development'
+    env = rubber_cfg.environment.bind(rubber_cfg.environment.known_roles)
+    gems = env['gems']
+    expanded_gem_list = []
+    gems.each do |gem_spec|
+      if gem_spec.is_a?(Array)
+        expanded_gem_list << "#{gem_spec[0]}:#{gem_spec[1]}"
+      else
+        expanded_gem_list << gem_spec
+      end
+    end
+    expanded_gem_list = expanded_gem_list.join(' ')
+
+    logger.info "Installing gems:#{expanded_gem_list}"
+    open("/tmp/gem_helper", "w") {|f| f.write(gem_helper_script)}
+    system "sh /tmp/gem_helper install #{expanded_gem_list}"
+  end
+
   desc <<-DESC
     Setup ruby gems sources. Set 'gemsources' in rubber.yml to \
     be an array of URI strings.
@@ -280,11 +379,61 @@ namespace :rubber do
     end
   end
 
+  # Rubygems always installs even if the gem is already installed
+  # When providing versions, rubygems fails unless versions are provided for all gems
+  # This helper script works around these issues by installing gems only if they
+  # aren't already installed, and separates versioned/unversioned into two separate
+  # calls to rubygems
+  #
+  set :gem_helper_script, <<-'ENDSCRIPT'
+    ruby - $@ <<-'EOF'
+
+    gem_cmd = ARGV[0]
+    gems = ARGV[1..-1]
+    cmd = "gem #{gem_cmd} --no-rdoc --no-ri"
+
+    to_install = {}
+    to_install_ver = {}
+    # gem list passed in, possibly with versions, as "gem1 gem2:1.2 gem3"
+    gems.each do |gem_spec|
+      parts = gem_spec.split(':')
+      if parts[1]
+        to_install_ver[parts[0]] = parts[1]
+      else
+        to_install[parts[0]] = true
+      end
+    end
+
+    installed = {}
+    `gem list --local`.each do |line|
+        parts = line.scan(/(.*) \((.*)\)/).first
+        next unless parts && parts.size == 2
+        installed[parts[0]] = parts[1].split(",")
+    end
+
+    to_install.delete_if {|g, v| installed.has_key?(g) } if gem_cmd == 'install'
+    to_install_ver.delete_if {|g, v| installed.has_key?(g) && installed[g].include?(v) }
+
+    # rubygems can only do asingle versioned gem at a time so we need
+    # to do the two groups separately
+    # install versioned ones first so unversioned don't pull in a newer version
+    to_install_ver.each do |g, v|
+      system "#{cmd} #{g} -v #{v}"
+      fail "Unable to install versioned gem #{g}:#{v}" if $?.exitstatus > 0
+    end
+    if to_install.size > 0
+      gem_list = to_install.keys.join(' ')
+      system "#{cmd} #{gem_list}"
+      fail "Unable to install gems" if $?.exitstatus > 0
+    end
+
+    'EOF'
+  ENDSCRIPT
+
   # Helper for installing gems,allows one to respond to prompts
   def gem_helper(update=false)
     cmd = update ? "update" : "install"
 
-
     opts = get_host_options('gems') do |gem_list|
       expanded_gem_list = []
       gem_list.each do |gem_spec|
@@ -298,56 +447,7 @@ namespace :rubber do
     end
     
     if opts.size > 0
-      # Rubygems always installs even if the gem is already installed
-      # When providing versions, rubygems fails unless versions are provided for all gems
-      # This helper script works around these issues by installing gems only if they
-      # aren't already installed, and separates versioned/unversioned into two separate
-      # calls to rubygems
-      script = prepare_script 'gem_helper', <<-'ENDSCRIPT'
-        ruby - $@ <<-'EOF'
-
-        gem_cmd = ARGV[0]
-        gems = ARGV[1..-1]
-        cmd = "gem #{gem_cmd} --no-rdoc --no-ri"
-
-        to_install = {}
-        to_install_ver = {}
-        # gem list passed in, possibly with versions, as "gem1 gem2:1.2 gem3"
-        gems.each do |gem_spec|
-          parts = gem_spec.split(':')
-          if parts[1]
-            to_install_ver[parts[0]] = parts[1]
-          else
-            to_install[parts[0]] = true
-          end
-        end
-
-        installed = {}
-        `gem list --local`.each do |line|
-            parts = line.scan(/(.*) \((.*)\)/).first
-            next unless parts && parts.size == 2
-            installed[parts[0]] = parts[1].split(",")
-        end
-
-        to_install.delete_if {|g, v| installed.has_key?(g) } if gem_cmd == 'install'
-        to_install_ver.delete_if {|g, v| installed.has_key?(g) && installed[g].include?(v) } 
-
-        # rubygems can only do asingle versioned gem at a time so we need
-        # to do the two groups separately
-        # install versioned ones first so unversioned don't pull in a newer version
-        to_install_ver.each do |g, v|
-          system "#{cmd} #{g} -v #{v}"
-          fail "Unable to install versioned gem #{g}:#{v}" if $?.exitstatus > 0
-        end
-        if to_install.size > 0
-          gem_list = to_install.keys.join(' ')
-          system "#{cmd} #{gem_list}"
-          fail "Unable to install gems" if $?.exitstatus > 0
-        end
-
-        'EOF'
-      ENDSCRIPT
-
+      script = prepare_script('gem_helper', gem_helper_script)
       sudo "sh #{script} #{cmd} $CAPISTRANO:VAR$", opts do |ch, str, data|
         handle_gem_prompt(ch, data, str)
       end

data/lib/rubber/tasks/rubber.rb

@@ -98,11 +98,70 @@ namespace :rubber do
     end
   end
 
+
+  desc <<-DESC
+    Backup database to given backup directory
+    The following arguments affect behavior:
+    BACKUP_DIR (required):  Directory where backups will be stored
+    BACKUP_NAME (required): What to name the backup
+    BACKUP_CMD (required):  Command used to backup
+    BACKUP_AGE (3):         Delete rotated logs older than this many days in the past
+  DESC
+  task :backup do
+    dir = get_env('BACKUP_DIR', true)
+    name = get_env('BACKUP_NAME', true)
+    cmd = get_env('BACKUP_CMD', true)
+    age = (get_env('BACKUP_AGE') || 3).to_i
+
+    time_stamp = Time.now.strftime("%Y-%m-%d_%H-%M")
+    FileUtils.mkdir_p(dir)
+
+    backup_cmd = cmd.gsub(/%([^%]+)%/, '#{\1}')
+    backup_cmd = eval('%Q{' + backup_cmd + '}')
+
+    puts "Backing up with command:"
+    sh backup_cmd
+    puts "Backup created"
+
+    s3_prefix = "#{name}/"
+    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
+      newest = Dir.entries(dir).sort_by {|f| File.mtime(File.join(dir,f))}.last
+      dest = "#{s3_prefix}#{newest}"
+      puts "Saving backup to S3: #{backup_bucket}:#{dest}"
+      AWS::S3::S3Object.store(dest, open(File.join(dir, newest)), 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
     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
+    BACKUP_AGE (3):        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
@@ -120,15 +179,15 @@ namespace :rubber do
     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
@@ -150,7 +209,7 @@ namespace :rubber do
         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|
@@ -211,7 +270,6 @@ namespace :rubber do
 
   end
 
-
   def get_env(name, required=false)
     value = ENV[name]
     raise("#{name} is required, pass using environment") if required && ! value

data/rails/init.rb

@@ -0,0 +1,9 @@
+# this file just makes it easy to refer to rubber config
+# variables in your apps's config'
+#
+
+require "rubber"
+Rubber::initialize(RAILS_ROOT, RAILS_ENV)
+
+::RUBBER_CONFIG = Rubber::Configuration.rubber_env
+::RUBBER_INSTANCES = Rubber::Configuration.rubber_instances

data/test/environment_test.rb

@@ -115,4 +115,19 @@ class EnvironmentTest < Test::Unit::TestCase
     assert_equal 'val5', e.var2.var9, 'env not retrieving right val'
   end
 
+  def test_instances_in_expansion
+    instance = InstanceItem.new('host1', 'domain.com', [RoleItem.new('role1')], '')
+    instance.external_ip = "1.2.3.4"
+    instances = Instance.new(Tempfile.new('testforinstanceexpansion').path)
+    instances.add(instance)
+
+    File.expects(:exist?).returns(true)
+    YAML.expects(:load_file).returns({'var1' =>'"#{rubber_instances.for_role("role1").first.external_ip}"'})
+    Rubber::Configuration.expects(:rubber_instances).returns(instances)
+    env = Rubber::Configuration::Environment.new(nil)
+    e = env.bind()
+
+    assert_equal "\"1.2.3.4\"", e['var1']    
+  end
+
 end

data/test/test_helper.rb

@@ -2,3 +2,7 @@ $:.unshift "#{File.dirname(__FILE__)}/../lib"
 
 require 'rubber'
 Rubber::initialize(File.dirname(__FILE__), 'test')
+
+require 'rubygems'
+require 'mocha'
+require 'pp'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rubber
 version: !ruby/object:Gem::Version 
-  version: 1.0.2
+  version: 1.1.0
 platform: ruby
 authors: 
 - Matt Conway
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-28 00:00:00 -04:00
+date: 2009-10-06 00:00:00 -04:00
 default_executable: vulcanize
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -105,6 +105,7 @@ files:
 - generators/vulcanize/templates/base/config/rubber/common/crontab
 - generators/vulcanize/templates/base/config/rubber/common/profile.rc
 - generators/vulcanize/templates/base/config/rubber/deploy-setup.rb
+- generators/vulcanize/templates/base/config/rubber/rubber-dns.yml
 - generators/vulcanize/templates/base/config/rubber/rubber.yml
 - generators/vulcanize/templates/base/lib/tasks/rubber.rake
 - generators/vulcanize/templates/base/script/cron-rake
@@ -238,6 +239,7 @@ files:
 - lib/rubber/recipes/rubber/volumes.rb
 - lib/rubber/tasks/rubber.rb
 - lib/rubber/util.rb
+- rails/init.rb
 has_rdoc: true
 homepage: http://github.com/wr0ngway/rubber
 licenses: []