nirvdrum-rubber 1.1.7 → 2.0.0.rails3.beta6

data/lib/generators/vulcanize/vulcanize_generator.rb

@@ -0,0 +1,157 @@
+require 'find'
+require 'yaml'
+
+if defined?(Rails) && Rails::VERSION::MAJOR == 2
+  require 'fileutils'
+  require 'commands/generate'
+
+  class VulcanizeGenerator < Rails::Generator::NamedBase
+
+    TEMPLATE_ROOT = File.dirname(__FILE__) + "/templates" unless defined?(TEMPLATE_ROOT)
+    TEMPLATE_FILE = "templates.yml" unless defined?(TEMPLATE_FILE)
+
+    def manifest
+      record do |m|
+        templates = [file_name] + actions
+        templates.each do |t|
+          apply_template(m, t)
+        end
+      end
+    end
+
+    def apply_template(m, name)
+      sp = source_path("#{name}/")
+      unless File.directory?(sp)
+        raise Rails::Generator::UsageError.new("Invalid template #{name}, use one of #{valid_templates.join(', ')}")
+      end
+
+      templ_conf = load_template_config(sp)
+      deps = templ_conf['dependent_templates'] || []
+      deps.each do |dep|
+        apply_template(m, dep)
+      end
+
+      Find.find(sp) do |f|
+        Find.prune if File.basename(f) =~ /^(CVS|\.svn)$/
+        Find.prune if f == "#{sp}#{TEMPLATE_FILE}"
+
+        rel = f.gsub(/#{source_root}\//, '')
+        dest_rel = rel.gsub(/^#{name}\//, '')
+        m.directory(dest_rel) if File.directory?(f)
+        if File.file?(f)
+          # force scripts to be executable
+          opts = (File.read(f) =~ /^#!/) ? {:chmod => 0755} : {}
+          m.file(rel, dest_rel, opts)
+        end
+
+      end
+    end
+
+    protected
+      def valid_templates
+        valid = Dir.entries(TEMPLATE_ROOT).delete_if {|e| e =~ /(^\.)|svn|CVS/ }
+      end
+
+      def load_template_config(template_dir)
+        templ_file = "#{template_dir}/templates.yml"
+        templ_conf = YAML.load(File.read(templ_file)) rescue {}
+        return templ_conf
+      end
+
+      def banner
+        usage = "Usage: #{$0} vulcanize template_name ...\n"
+        usage << "where template_name is one of:\n\n"
+        valid_templates.each do |t|
+          templ_conf = load_template_config("#{TEMPLATE_ROOT}/#{t}")
+          desc = templ_conf['description']
+          usage << "    #{t}: #{desc}\n"
+        end
+        return usage
+      end
+  end
+
+else
+  require 'rails/generators'
+
+  class VulcanizeGenerator < Rails::Generators::NamedBase
+
+    def self.source_root
+      File.join(File.dirname(__FILE__), 'templates')
+    end
+
+    def copy_template_files
+      @template_dependencies = find_dependencies(file_name)
+      ([file_name] + @template_dependencies).each do |template|
+        apply_template(template)
+      end
+    end
+
+    protected
+
+    # helper to test for rails for optional templates
+    def rails?
+      Rubber::Util::is_rails?
+    end
+
+    def find_dependencies(name)
+      template_dir = File.join(self.class.source_root, name, '')
+      unless File.directory?(template_dir)
+        raise Rails::Generators::Error.new("Invalid template #{name}, use one of #{valid_templates.join(', ')}")
+      end
+
+      template_conf = load_template_config(template_dir)
+      template_dependencies = template_conf['dependent_templates'] || []
+
+      template_dependencies.clone.each do |dep|
+        template_dependencies.concat(find_dependencies(dep))
+      end
+
+      return template_dependencies.uniq
+    end
+
+    def apply_template(name)
+      template_dir = File.join(self.class.source_root, name, '')
+      unless File.directory?(template_dir)
+        raise Rails::Generators::Error.new("Invalid template #{name}, use one of #{valid_templates.join(', ')}")
+      end
+
+      template_conf = load_template_config(template_dir)
+
+      extra_generator_steps_file = File.join(template_dir, 'templates.rb')
+      if File.exist? extra_generator_steps_file
+        eval File.read(extra_generator_steps_file), binding, extra_generator_steps_file
+      end
+
+      Find.find(template_dir) do |f|
+        Find.prune if f == File.join(template_dir, 'templates.yml')  # don't copy over templates.yml
+        Find.prune if f == extra_generator_steps_file # don't copy over templates.rb
+
+        template_rel = f.gsub(/#{template_dir}/, '')
+        source_rel = f.gsub(/#{self.class.source_root}\//, '')
+        dest_rel   = source_rel.gsub(/^#{name}\//, '')
+
+        # Only include optional files when their conditions eval to true
+        optional = template_conf['optional'][template_rel] rescue nil
+        Find.prune if optional && ! eval(optional)
+
+        if File.directory?(f)
+          empty_directory(dest_rel)
+        else
+          copy_file(source_rel, dest_rel)
+          src_mode = File.stat(f).mode
+          dest_mode = File.stat(File.join(destination_root, dest_rel)).mode
+          chmod(dest_rel, src_mode) if src_mode != dest_mode
+        end
+      end
+    end
+
+    def valid_templates
+      valid = Dir.entries(self.class.source_root).delete_if {|e| e =~  /(^\.)|svn|CVS/ }
+    end
+
+    def load_template_config(template_dir)
+      YAML.load(File.read(File.join(template_dir, 'templates.yml'))) rescue {}
+    end
+  end
+
+end

data/lib/rubber/cloud/aws.rb

@@ -22,7 +22,7 @@ module Rubber
       end
 
       def create_spot_instance_request(spot_price, ami, ami_type, security_groups, availability_zone)
-        response = @ec2.create_spot_instances_request(:spot_price => spot_price, :image_id => ami, :key_name => @aws_env.key_name, :instance_type => ami_type, :security_group => security_groups, :availability_zone => availability_zone)
+        response = @ec2.request_spot_instances(:spot_price => spot_price, :image_id => ami, :key_name => @aws_env.key_name, :instance_type => ami_type, :security_group => security_groups, :availability_zone => availability_zone)
         request_id = response.spotInstanceRequestSet.item[0].spotInstanceRequestId
         return request_id
       end
@@ -42,6 +42,7 @@ module Rubber
             instance[:internal_host] = item.privateDnsName
             instance[:state] = item.instanceState.name
             instance[:zone] = item.placement.availabilityZone
+            instance[:platform] = item.platform || 'linux'
             instances << instance
           end
         end if response.reservationSet
@@ -223,7 +224,9 @@ module Rubber
         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/
+          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
@@ -234,7 +237,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
@@ -277,7 +282,7 @@ module Rubber
       end
 
       def destroy_spot_instance_request(request_id)
-        @ec2.destroy_spot_instance_requests :spot_instance_request_id => request_id
+        @ec2.cancel_spot_instance_requests :spot_instance_request_id => request_id
       end
 
       def describe_load_balancers(name=nil)

data/lib/rubber/dns/zerigo.rb

@@ -1,170 +1,105 @@
 require 'rubygems'
-require 'httparty'
+require 'zerigo_dns'
 
 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 }
+        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
-        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 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

@@ -22,7 +22,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 +145,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
@@ -113,7 +113,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
+          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 +130,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,22 +176,28 @@ module Rubber
       attr_accessor :additive
       # Lets one dynamically determine if a given file gets skipped during transformation
       attr_accessor :skip
+      # 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
 
+      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
 

data/lib/rubber/instance.rb

@@ -10,7 +10,7 @@ module Rubber
       include Enumerable
 
       def initialize(file)
-        LOGGER.debug{"Reading rubber instances from #{file}"}
+        Rubber.logger.debug{"Reading rubber instances from #{file}"}
         @file = file
         @items = {}
         @artifacts = {'volumes' => {}, 'static_ips' => {}}
@@ -82,6 +82,7 @@ module Rubber
       attr_accessor :internal_host, :internal_ip
       attr_accessor :static_ip, :volumes, :partitions
       attr_accessor :spot_instance_request_id
+      attr_accessor :platform
 
       def initialize(name, domain, roles, instance_id, security_group_list=[])
         @name = name
@@ -98,6 +99,15 @@ module Rubber
       def role_names()
         roles.collect {|r| r.name}
       end
+
+      def platform
+        # Deal with old instance configurations that don't have a platform value persisted.
+        @platform || 'linux'
+      end
+
+      def windows?
+        platform == 'windows'
+      end
     end
 
     # The configuration for a single role contained in the list

data/lib/rubber/railtie.rb

@@ -0,0 +1,14 @@
+require 'rubber'
+require 'rails'
+
+module Rubber
+
+  class Railtie < Rails::Railtie
+
+    initializer "rubber.configure_rails_initialization" do
+      Rubber::initialize(Rails.root, Rails.env)
+    end
+
+  end
+
+end

data/lib/rubber/recipes/rubber/deploy.rb

@@ -59,8 +59,8 @@ namespace :rubber do
     Sets permissions of files in application directory to be owned by app_user.
   DESC
   task :setup_app_permissions do
-    run "find #{shared_path} -name cached-copy -prune -o -print | xargs chown #{rubber_env.app_user}:#{rubber_env.app_user}"
-    run "chown -R #{rubber_env.app_user}:#{rubber_env.app_user} #{current_path}/tmp"
+    rsudo "find #{shared_path} -name cached-copy -prune -o -print | xargs chown #{rubber_env.app_user}:#{rubber_env.app_user}"
+    rsudo "chown -R #{rubber_env.app_user}:#{rubber_env.app_user} #{current_path}/tmp"
   end
 
   def run_config(options={})
@@ -84,7 +84,7 @@ namespace :rubber do
       put(File.read(secret), File.join(path, base, File.basename(secret)), :mode => "+r")
     end
 
-    sudo "sh -c 'cd #{path} && #{extra_env} rake rubber:config'"
+    rsudo "cd #{path} && #{extra_env} rake rubber:config"
   end
 
 end

data/lib/rubber/recipes/rubber/instances.rb

@@ -225,8 +225,12 @@ namespace :rubber do
         instance_item.external_ip = instance[:external_ip]
         instance_item.internal_host = instance[:internal_host]
         instance_item.zone = instance[:zone]
+        instance_item.platform = instance[:platform]
         rubber_instances.save()
 
+        # turn back on root ssh access if we are using root as the capistrano user for connecting
+        enable_root_ssh(instance_item.external_ip, fetch(:initial_ssh_user, 'ubuntu')) if user == 'root'
+
         # setup amazon elastic ips if configured to do so
         setup_static_ips
 
@@ -241,7 +245,14 @@ namespace :rubber do
         # so that we can update all aliases
 
         task :_get_ip, :hosts => instance_item.external_ip do
-          instance_item.internal_ip = capture(print_ip_command).strip
+          # There's no good way to get the internal IP for a Windows host, so just set it to the external
+          # and let the router handle mapping to the internal network.
+          if instance_item.windows?
+            instance_item.internal_ip = instance_item.external_ip
+          else
+            instance_item.internal_ip = capture(print_ip_command).strip
+          end
+
           rubber_instances.save()
         end