nogara-rubber 1.7.2

data/lib/generators/vulcanize/templates/resque/templates.rb

@@ -0,0 +1 @@
+gem "resque" if Rubber::Util::is_bundler?

data/lib/generators/vulcanize/templates/resque/templates.yml

@@ -0,0 +1,3 @@
+description: The resque background queue system
+dependent_templates:
+  - redis

data/lib/generators/vulcanize/templates/sphinx/config/rubber/common/sphinx.yml

@@ -0,0 +1,46 @@
+<%
+  @path = "#{RUBBER_ROOT}/config/sphinx.yml"
+%>
+
+# Taken from: http://ts.freelancing-gods.com/rdoc/classes/ThinkingSphinx/Configuration.html
+#
+# Here are the default settings, relative to RUBBER_ROOT where relevant:
+#
+# config file::           config/#{environment}.sphinx.conf
+# searchd log file::      log/searchd.log
+# query log file::        log/searchd.query.log
+# pid file::              log/searchd.#{environment}.pid
+# searchd files::         db/sphinx/#{environment}/
+# address::               127.0.0.1
+# port::                  3312
+# allow star::            false
+# min prefix length::     1
+# min infix length::      1
+# mem limit::             64M
+# max matches::           1000
+# morphology::            stem_en
+# charset type::          utf-8
+# charset table::         nil
+# ignore chars::          nil
+# html strip::            false
+# html remove elements::  ''
+#
+# If you want to change these settings, create a YAML file at
+# config/sphinx.yml with settings for each environment, in a similar
+# fashion to database.yml - using the following keys: config_file,
+# searchd_log_file, query_log_file, pid_file, searchd_file_path, port,
+# allow_star, enable_star, min_prefix_len, min_infix_len, mem_limit,
+# max_matches, # morphology, charset_type, charset_table, ignore_chars,
+# html_strip, # html_remove_elements. I think you've got the idea.
+#
+# Each setting in the YAML file is optional - so only put in the ones you
+# want to change.
+
+<%= RUBBER_ENV %>:
+  address:            <%= rubber_instances.for_role('sphinx').first.full_name rescue 'localhost' %>
+  mem_limit:          <%= RUBBER_ENV == 'production' ? '1024M' : '64M' %>
+  config_file:        sphinx/config/<%= RUBBER_ENV %>.sphinx.conf
+  searchd_file_path:  sphinx/db/<%= RUBBER_ENV %>/
+  pid_file:           <%= RUBBER_ROOT %>/log/searchd.<%= RUBBER_ENV %>.pid
+  searchd_log_file:   <%= RUBBER_ROOT %>/log/searchd.log
+  query_log_file:     <%= RUBBER_ROOT %>/log/searchd.query.log

data/lib/generators/vulcanize/templates/sphinx/config/rubber/deploy-sphinx.rb

@@ -0,0 +1,112 @@
+# installs, starts and stops sphinx
+#
+# Please note that all tasks are executed as runner. So sphinx will run under
+# the same userid as mongrel. This is important to allow delta indexes (mongrel
+# has to send a sighup to searchd).
+#
+# * installation is ubuntu specific
+# * start and stop tasks are using the thinking sphinx plugin
+
+namespace :rubber do
+
+  namespace :sphinx do
+
+    rubber.allow_optional_tasks(self)
+
+    after "rubber:install_packages", "rubber:sphinx:custom_install"
+
+    task :custom_install, :roles => :sphinx do
+      # install sphinx from source
+      ver = "0.9.8.1"
+      rubber.sudo_script 'install_sphinx', <<-ENDSCRIPT
+        # check if already installed
+        if [ -x /usr/local/bin/searchd ]
+          then echo 'Found sphinx searchd on system'
+          if /usr/local/bin/searchd --help | grep 'Sphinx #{ver}'
+            then echo 'Sphinx version matches, no further steps needed'
+            exit 0
+          fi
+        fi
+
+        echo 'Installing / Upgrading sphinx #{ver}'
+        TMPDIR=`mktemp -d` || exit 1
+        cd $TMPDIR
+        echo 'Downloading'
+        wget -qN http://www.sphinxsearch.com/downloads/sphinx-#{ver}.tar.gz
+        echo 'Unpacking'
+        tar xf sphinx-#{ver}.tar.gz
+        cd sphinx-#{ver}
+        ./configure
+        make
+        make install
+        cd ; rm -rf $TMPDIR
+      ENDSCRIPT
+    end
+
+    set :sphinx_root, Proc.new {"#{shared_path}/sphinx"}
+    after "deploy:setup", "rubber:sphinx:setup"
+    after "deploy:symlink", "rubber:sphinx:config_dir"
+
+    before "deploy:stop", "rubber:sphinx:stop"
+    after "deploy:start", "rubber:sphinx:start"
+    after "deploy:restart", "rubber:sphinx:restart"
+    before "deploy:cold" do
+      before "rubber:sphinx:start", "rubber:sphinx:index"
+    end
+    before "rubber:create_staging" do
+      before "rubber:sphinx:start", "rubber:sphinx:index"
+    end
+
+    desc "Do sphinx setup tasks"
+    task :setup, :roles => :sphinx do
+      # Setup links to sphinx config/index as they need to persist between deploys
+      rsudo "mkdir -p #{sphinx_root} #{sphinx_root}/config #{sphinx_root}/db"
+      rsudo "chown -R #{runner}:#{runner} #{sphinx_root}"
+    end
+
+    desc "Setup paths for sphinx runtime"
+    task :config_dir, :roles => :sphinx do
+      rsudo "rm -rf #{current_path}/sphinx"
+      rsudo "ln -sf #{sphinx_root} #{current_path}/sphinx"
+    end
+
+    # runs the given ultrasphinx rake tasks
+    def run_sphinx task
+      rsudo "cd #{current_path} && RAILS_ENV=#{RUBBER_ENV} rake #{task}", :as => runner
+    end
+
+
+    desc "Stops sphinx searchd"
+    task :stop, :roles => :sphinx do
+      run_sphinx 'ts:stop; exit 0'
+    end
+
+    desc "Starts sphinx searchd"
+    task :start, :roles => :sphinx do
+      # rake tasks that load rails env can be slow, so
+      # do multiple here as a performance tweak
+      # config always needs to be run before start as
+      # rubber generates a sphinx config file with new paths
+      run_sphinx 'ts:config ts:start'
+    end
+
+    desc "Restarts sphinx searchd"
+    task :restart, :roles => :sphinx do
+      # rake tasks that load rails env can be slow, so
+      # do multiple here as a performance tweak
+      run_sphinx 'ts:config ts:stop ts:start'
+    end
+
+    desc "Configures sphinx index"
+    task :config, :roles => :sphinx do
+      run_sphinx 'ts:config'
+    end
+
+    desc "Builds sphinx index"
+    task :index, :roles => :sphinx do
+      run_sphinx 'ts:index'
+    end
+
+  end
+
+end

data/lib/generators/vulcanize/templates/sphinx/config/rubber/role/sphinx/crontab

@@ -0,0 +1,11 @@
+<%
+  @read_cmd = 'crontab -l'
+  @write_cmd = 'crontab -'
+  @additive = ["# rubber-sphinx-start", "# rubber-sphinx-end"]
+%>
+
+# incremental index once every 10 minutes
+*/10 * * * * sudo -u <%= rubber_env.app_user %> <%= RUBBER_ROOT %>/script/cron-rake RUBBER_ENV=<%= RUBBER_ENV %> ts:in:delta
+
+# full reindex daily at 4:35
+35 4 * * * sudo -u <%= rubber_env.app_user %> <%= RUBBER_ROOT %>/script/cron-rake RUBBER_ENV=<%= RUBBER_ENV %> ts:index

data/lib/generators/vulcanize/templates/sphinx/config/rubber/role/sphinx/monit-sphinx.conf

@@ -0,0 +1,13 @@
+<%
+  @path = '/etc/monit/monit.d/monit-sphinx.conf'
+
+  PIDFILE = "#{RUBBER_ROOT}/log/searchd.#{RUBBER_ENV}.pid"
+  start_program = "cd #{RUBBER_ROOT} && rake ts:start"
+  stop_program = "cd #{RUBBER_ROOT} && rake ts:stop"
+%>
+
+check process sphinx with pidfile <%= PIDFILE %>
+  group sphinx-<%= RUBBER_ENV %>
+  start program = "/usr/bin/sudo -H -u <%= rubber_env.app_user %> bash -l -c '<%= start_program %>'"
+  stop program = "/usr/bin/sudo -H -u <%= rubber_env.app_user %> bash -l -c '<%= stop_program %>'"
+  if failed host <%= rubber_env.host %> port 3312 with timeout 5 seconds for 5 cycles then restart

data/lib/generators/vulcanize/templates/sphinx/config/rubber/rubber-sphinx.yml

@@ -0,0 +1,6 @@
+gems: []
+
+roles:
+  sphinx:
+    packages: [bzr-builddeb, autotools-dev, dpatch, libpq-dev, autoconf,
+               libtool, automake, gawk, libmysqlclient15-dev]

data/lib/generators/vulcanize/templates/sphinx/templates.yml

@@ -0,0 +1 @@
+description: The sphinx searchd / thinking sphinx module

data/lib/generators/vulcanize/vulcanize_generator.rb

@@ -0,0 +1,184 @@
+require 'find'
+require 'yaml'
+
+# Load and initialize rubber if it hasn't been already.
+# This happens using the generator with Rails 2 and Rubber is not set up as a plugin.
+unless defined?(Rubber)
+  env = ENV['RUBBER_ENV'] ||= 'development'
+  root = '.'
+
+  require 'rubber'
+  Rubber::initialize(root, env)
+end
+
+if Rubber::Util::is_rails2?
+  require 'fileutils'
+  require 'commands/generate'
+
+  class VulcanizeGenerator < Rails::Generator::NamedBase
+    include Rails::Generator::Commands
+
+    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
+
+      @template_dependencies ||= []
+
+      templ_conf = load_template_config(sp)
+      deps = templ_conf['dependent_templates'] || []
+      @template_dependencies.concat(deps)
+      deps.each do |dep|
+        apply_template(m, dep)
+      end
+
+      extra_generator_steps_file = File.join(TEMPLATE_ROOT, name, 'templates.rb')
+
+      Find.find(sp) do |f|
+        Find.prune if File.basename(f) =~ /^(CVS|\.svn)$/
+        Find.prune if f == "#{sp}#{TEMPLATE_FILE}"
+        Find.prune if f == extra_generator_steps_file # don't copy over templates.rb
+
+        rel = f.gsub(/#{source_root}\//, '')
+        dest_rel = rel.gsub(/^#{name}\//, '')
+
+        # Only include optional files when their conditions eval to true
+        template_conf = YAML.load(File.read(TEMPLATE_FILE)) rescue {}
+        optional = template_conf['optional'][dest_rel] rescue nil
+        Find.prune if optional && ! eval(optional)
+
+        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
+
+      if File.exist? extra_generator_steps_file
+        eval File.read(extra_generator_steps_file), binding, extra_generator_steps_file
+      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')
+
+      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
+
+      if File.exist? extra_generator_steps_file
+        eval File.read(extra_generator_steps_file), binding, extra_generator_steps_file
+      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.rb

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