axtro-rubber 1.2.3 → 1.5.7

data/lib/rubber/cloud/aws.rb

@@ -15,10 +15,8 @@ module Rubber
         AWS::S3::Base.establish_connection!(:access_key_id => @aws_env.access_key, :secret_access_key => @aws_env.secret_access_key)
       end
 
-      def create_instance(ami, ami_type, security_groups, availability_zone, user_data = nil)
-        instance_options = {:image_id => ami, :key_name => @aws_env.key_name, :instance_type => ami_type, :security_group => security_groups, :availability_zone => availability_zone}
-        instance_options[:user_data] = Base64.encode64(user_data) if user_data
-        response = @ec2.run_instances(instance_options)
+      def create_instance(ami, ami_type, security_groups, availability_zone)
+        response = @ec2.run_instances(:image_id => ami, :key_name => @aws_env.key_name, :instance_type => ami_type, :security_group => security_groups, :availability_zone => availability_zone)
         instance_id = response.instancesSet.item[0].instanceId
         return instance_id
       end
@@ -227,12 +225,14 @@ module Rubber
         capistrano.put(File.read(ec2_pk), ec2_pk_dest)
         capistrano.put(File.read(ec2_cert), ec2_cert_dest)
 
-        arch = capistrano.capture "uname -m"
+        arch = capistrano.capture("uname -m").strip
         arch = case arch when /i\d86/ then "i386" else arch end
 
         capistrano.sudo_script "create_bundle", <<-CMD
+          rvm use system
           export RUBYLIB=/usr/lib/site_ruby/
-          nohup ec2-bundle-vol --batch -d /mnt -k #{ec2_pk_dest} -c #{ec2_cert_dest} -u #{@aws_env.account} -p #{image_name} -r #{arch}  &> /tmp/ec2-bundle-vol.log &
+          unset RUBYOPT
+          nohup ec2-bundle-vol --batch -d /mnt -k #{ec2_pk_dest} -c #{ec2_cert_dest} -u #{@aws_env.account} -p #{image_name} -r #{arch} &> /tmp/ec2-bundle-vol.log &
           echo "Creating image from instance volume..."
           while true; do
             if ! ps ax | grep -q "[e]c2-bundle-vol"; then exit; fi
@@ -242,7 +242,9 @@ module Rubber
         CMD
 
         capistrano.sudo_script "register_bundle", <<-CMD
+          rvm use system
           export RUBYLIB=/usr/lib/site_ruby/
+          unset RUBYOPT
           echo "Uploading image to S3..."
           ec2-upload-bundle --batch -b #{@aws_env.image_bucket} -m /mnt/#{image_name}.manifest.xml -a #{@aws_env.access_key} -s #{@aws_env.secret_access_key}
         CMD

data/lib/rubber/dns/dyndns.rb

@@ -29,12 +29,12 @@ module Rubber
         begin
           Resolv::DNS.open(:nameserver => [nameserver], :search => [], :ndots => 1) do |dns|
             r = dns.getresource(hostname, Resolv::DNS::Resource::IN::A)
-            result = [{:host =>host, :data => r.address}]
+            result = [{:host =>opts[:host], :data => r.address}]
           end
         rescue
+          puts "Rescue #{e} #{e.message}"
           raise "Domain needs to exist in dyndns as an A record before record can be updated"
         end
-        return true
       end
 
       def create_host_record(opts={})
@@ -46,13 +46,12 @@ module Rubber
       end
 
       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])
+        old_opts = setup_opts(old_opts, [:host, :domain])
+
+        host = "#{old_opts[:host]}.#{old_opts[:domain]}"
         ip = new_opts[:data]
         update_url = eval('%Q{' + @update_url + '}')
-
+        # puts update_url
         # This header is required by dyndns.org
         headers = {
          "User-Agent" => "Capistrano - Rubber - 0.1"

data/lib/rubber/dns/zerigo.rb

@@ -1,170 +1,111 @@
 require 'rubygems'
-require 'httparty'
+
+begin
+  require 'zerigo_dns'
+rescue LoadError
+  puts "Missing the zerigo_dns gem.  Install with `sudo gem install zerigo_dns`."
+  exit(-1)
+end
 
 module Rubber
   module Dns
 
+    class Zerigo < Base
 
-    class Zone
-      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(env)
+        super(env, "zerigo")
 
-      def initialize(customer_id, email, token, domain)
-        self.class.basic_auth email, token
-        self.class.base_uri "https://ns.zerigo.com/accounts/#{customer_id}"
-        @domain = domain
-        refresh()
+        ::Zerigo::DNS::Base.user = provider_env.email
+        ::Zerigo::DNS::Base.password = provider_env.token
       end
 
-      def check_status(response)
-        code = response.code
-        if code < 200 || code > 299
-          msg = "Failed to access zerigo api (http_status=#{code})"
-          msg += ", check dns_providers.zerigo.customer_id/email/token in rubber.yml" if code == 401
-          raise msg
-        end
-        return response
+      def host_to_opts(host)
+        opts = {}
+        opts[:id] = host.id
+        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
 
-      def create_host(opts)
-        host = opts_to_host(opts, new_host())
-        check_status self.class.post("/zones/#{@zone['id']}/hosts.xml", :body => {:host => host})
+      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 find_host_records(opts={})
+      def find_hosts(opts = {})
+        opts = setup_opts(opts, [:host, :domain])
         result = []
+        zone = ::Zerigo::DNS::Zone.find_or_create(opts[:domain])
+        params = { :zone_id => zone.id }
+
         hn = opts[:host]
         ht = opts[:type]
         hd = opts[:data]
         has_host = hn && hn != '*'
-
-        url = "/zones/#{@zone['id']}/hosts.xml"
         if has_host
-          url << "?fqdn="
+          url = ""
           url << "#{hn}." if hn.strip.size > 0
-          url << "#{@domain}"
+          url << "#{opts[:domain]}"
+          params[:fqdn] = url
         end
-        hosts = self.class.get(url)
-
-        # 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_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(host_id)
-        check_status self.class.delete("/zones/#{@zone['id']}/hosts/#{host_id}.xml")
-      end
-
-      def refresh
-        zone_id = @zone['id'] rescue nil
-        if zone_id
-          @zone = check_status self.class.get("/zones/#{zone_id}.xml")
-        else
-          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']
+        begin
+          hosts = ::Zerigo::DNS::Host.find(:all, :params=> params)
+
+          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 << h if keep
+          end if hosts
+        rescue ActiveResource::ResourceNotFound => e
         end
-      end
-
-      def zone_record
-        return @zone
-      end
-
-      private
-
-      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 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")
+        return result
       end
 
       def find_host_records(opts = {})
-        opts = setup_opts(opts, [:host, :domain])
-        zone = Zone.get_zone(opts[:domain], provider_env)
-
-        zone.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 = Zone.get_zone(opts[:domain], provider_env)
-
-        zone.create_host(opts)
+        zone = ::Zerigo::DNS::Zone.find_or_create(opts[:domain])
+        ::Zerigo::DNS::Host.create(opts_to_host(opts).merge(:zone_id => zone.id))
       end
 
       def destroy_host_record(opts = {})
         opts = setup_opts(opts, [:host, :domain])
-        zone = Zone.get_zone(opts[:domain], provider_env)
+        zone = ::Zerigo::DNS::Zone.find_or_create(opts[:domain])
 
-        find_host_records(opts).each do |h|
-          zone.delete_host(h[:id])
+        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.merge(:no_defaults =>true), [])
-        zone = Zone.get_zone(old_opts[:domain], provider_env)
+        new_opts = setup_opts(new_opts, [:host, :domain, :type, :data])
+        zone = ::Zerigo::DNS::Zone.find_or_create(old_opts[:domain])
 
-        find_host_records(old_opts).each do |h|
-          zone.update_host(h[:id], h.merge(new_opts))
+        find_hosts(old_opts).each do |h|
+          opts_to_host(new_opts).each do |k, v|
+            h.send("#{k}=", v)
+          end
+          h.save || raise("Failed to update host #{h.hostname}, #{h.errors.full_messages.join(', ')}")
         end
       end
 

data/lib/rubber/environment.rb

@@ -14,7 +14,15 @@ module Rubber
 
       def initialize(config_root)
         @config_root = config_root
-        @config_files = ["#{@config_root}/rubber.yml"] + Dir["#{@config_root}/rubber-*.yml"].sort
+        @config_files = ["#{@config_root}/rubber.yml"]
+        @config_files += Dir["#{@config_root}/rubber-*.yml"].sort
+
+        # add a config file for current env only so that you can override
+        #things for specific envs
+        @config_files -= Dir["#{@config_root}/rubber-*-env.yml"]
+        env_yml = "#{@config_root}/rubber-#{Rubber.env}-env.yml"
+        @config_files << env_yml if File.exist?(env_yml)
+        
         @items = {}
         @config_files.each { |file| read_config(file) }
         @config_secret = bind().rubber_secret
@@ -22,7 +30,7 @@ module Rubber
       end
       
       def read_config(file)
-        LOGGER.debug{"Reading rubber configuration from #{file}"}
+        Rubber.logger.debug{"Reading rubber configuration from #{file}"}
         if File.exist?(file)
           @items = Environment.combine(@items, YAML.load_file(file) || {})
         end
@@ -145,14 +153,14 @@ module Rubber
           global = global.clone()
           role_overrides = global.delete("roles") || {}
           host_overrides = global.delete("hosts") || {}
-          roles.to_a.each do |role|
-            role_overrides[role].each do |k, v|
+          Array(roles).each do |role|
+            Array(role_overrides[role]).each do |k, v|
               global[k] = Environment.combine(global[k], v)
-            end if role_overrides[role]
+            end
           end
-          host_overrides[host].each do |k, v|
+          Array(host_overrides[host]).each do |k, v|
             global[k] = Environment.combine(global[k], v)
-          end if host_overrides[host]
+          end
           return global
         end
         

data/lib/rubber/generator.rb

@@ -33,13 +33,13 @@ module Rubber
           Dir[dir].sort.each do |f|
             next if f =~ /\/(CVS|\.svn)\//
             if File.file?(f) && (! pat || pat.match(f))
-              LOGGER.info{"Transforming #{f}"}
+              Rubber.logger.info{"Transforming #{f}"}
               begin
                 transform(IO.read(f), @options)
               rescue Exception => e
                 lines = e.backtrace.grep(/^\(erb\):([0-9]+)/) {|b| Regexp.last_match(1) }
-                LOGGER.error{"Transformation failed for #{f}#{':' + lines.first if lines.first}"}
-                LOGGER.error e.message
+                Rubber.logger.error{"Transformation failed for #{f}#{':' + lines.first if lines.first}"}
+                Rubber.logger.error e.message
                 exit 1
               end
             end
@@ -51,6 +51,7 @@ module Rubber
       # dest_file (if not nil) before returning it
       def transform(src_data, options={})
         config = ConfigDescriptor.new
+        config.generator = self
 
         # for development/test, if we have a fake root, echo any
         # calls to system
@@ -113,7 +114,7 @@ module Rubber
           FileUtils.mkdir_p(File.dirname(config_path)) if config_path
 
           # Write a backup of original
-          open("#{config_path}.bak", 'w') { |f| f.write(orig) } if config_path and !config.no_backup
+          open("#{config_path}.bak", 'w') { |f| f.write(orig) } if config_path && config.backup
 
           # Write out transformed file
           writer = config_path || "|#{config.write_cmd}"
@@ -130,21 +131,23 @@ module Rubber
 
           # Run post transform command if needed
           if config.post
-            if orig == result
-              LOGGER.info("Nothing to do, not running post command")
+            if fake_root
+              Rubber.logger.info("Not running post command as a fake root was given: #{config.post}")
             elsif no_post
-              LOGGER.info("Not running post command as no post specified")
-            elsif fake_root
-              LOGGER.info("Not running post command as a fake root was given: #{config.post}")
+              Rubber.logger.info("Not running post command as no post specified")
             else
-              # this lets us abort a script if a command in the middle of it errors out
-              # stop_on_error_cmd = "function error_exit { exit 99; }; trap error_exit ERR"
-              config.post = "#{stop_on_error_cmd}\n#{config.post}" if stop_on_error_cmd
-
-              LOGGER.info{"Transformation executing post config command: #{config.post}"}
-              LOGGER.info `#{config.post}`
-              if $?.exitstatus != 0
-                raise "Post command failed execution:  #{config.post}"
+              if orig != result || force
+                # this lets us abort a script if a command in the middle of it errors out
+                # stop_on_error_cmd = "function error_exit { exit 99; }; trap error_exit ERR"
+                config.post = "#{stop_on_error_cmd}\n#{config.post}" if stop_on_error_cmd
+
+                Rubber.logger.info{"Transformation executing post config command: #{config.post}"}
+                Rubber.logger.info `#{config.post}`
+                if $?.exitstatus != 0
+                  raise "Post command failed execution:  #{config.post}"
+                end
+              else
+                Rubber.logger.info("Nothing to do, not running post command")
               end
             end
           end
@@ -174,24 +177,31 @@ module Rubber
       attr_accessor :additive
       # Lets one dynamically determine if a given file gets skipped during transformation
       attr_accessor :skip
-      # Lets one dynamically skip the creation of a backup
-      attr_accessor :no_backup
+      # Backup file when transforming, defaults to true, set to false to prevent backup
+      attr_accessor :backup
       # use sudo to write the output file
       # attr_accessor :sudo
       # options passed in through code
       attr_accessor :options
 
+      # allow access to calling generator so can determine stuff like fake_root
+      attr_accessor :generator
+
+      def initialize
+        @backup = true
+      end
+      
       def get_binding
         binding
-    end
+      end
     
-    def rubber_env()
-      Rubber::Configuration.rubber_env
-    end
-  
-    def rubber_instances()
-      Rubber::Configuration.rubber_instances
-    end
+      def rubber_env()
+        Rubber::Configuration.rubber_env
+      end
+
+      def rubber_instances()
+        Rubber::Configuration.rubber_instances
+      end
 
     end