nirvdrum-rubber 1.1.7

data/generators/vulcanize/templates/base/script/cron-runner

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+# For running jobs through cron - only prints output if there is an error
+#
+# author mconway
+# since 8/12/07
+
+RAILS_ROOT = File.expand_path("..", File.dirname(__FILE__))
+log = "#{RAILS_ROOT}/log/cron-runner-#{Time.now.tv_sec}.log"
+begin
+  ident = File.basename(ARGV[-1]).gsub(/\W+/, "_")
+  log = "#{RAILS_ROOT}/log/cron-runner-#{ident}.log"
+rescue
+end
+
+Dir.chdir(RAILS_ROOT)
+args = %W{-e -l #{log} -- script/runner} + ARGV
+system "script/cron-sh", *args

data/generators/vulcanize/templates/base/script/cron-sh

@@ -0,0 +1,67 @@
+#!/usr/bin/env ruby
+
+# For running shell commands through cron - only prints output if there is an error
+#
+# author mconway
+# since 8/12/07
+
+require 'optparse'
+require 'ostruct'
+require 'rubygems'
+require 'open4'
+
+options = OpenStruct.new
+options.logfile = "/tmp/cron-sh-#{Time.now.tv_sec}.log"
+options.echoerr = false
+options.echoout = false
+
+opts = OptionParser.new do |opts|
+  opts.banner = "Usage: cron-sh [options] <shell command>"
+  opts.separator "Runs the given command, sending all stdout/stderr to a logfile, but echoing"
+  opts.separator "the entire file if the command exits with an error"
+  opts.separator ""
+  opts.separator "Specific options:"
+
+  opts.on("-l", "--log logfile", "Log to given file instead of a default") do |val|
+    options.logfile = val
+  end
+
+  opts.on("-o", "--[no-]echoout", "Log _and_ echo stdout") do |val|
+    options.echoout = true
+  end
+
+  opts.on("-e", "--[no-]echoerr", "Log _and_ echo stderr") do |val|
+    options.echoerr = true
+  end
+
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+end
+
+cmd = opts.parse(ARGV)
+
+status = Open4::popen4(*cmd) do |pid, stdin, stdout, stderr|
+  File.open(options.logfile, "w") do | fh |
+    threads = []
+    threads <<  Thread.new(stdout) do |stdout|
+       stdout.each { |line| $stdout.puts line if options.echoout; fh.print line; fh.flush }
+    end
+    threads <<  Thread.new(stderr) do |stderr|
+       stderr.each { |line| $stderr.puts line if options.echoerr; fh.print line; fh.flush }
+    end
+    threads.each { |t| t.join }
+  end
+end
+
+result = status.exitstatus
+if result != 0
+  puts ""
+  puts "*** Process exited with non-zero error code, full output follows"
+  puts "*** Command was: #{cmd.join(' ')}"
+  puts ""
+  puts IO.read(options.logfile)
+end
+
+exit(result)

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

@@ -0,0 +1 @@
+description: The core configuration needed by all others

data/generators/vulcanize/templates/complete_mongrel_mysql/config/rubber/role/haproxy/haproxy-mongrel.conf

@@ -0,0 +1,23 @@
+<%
+  @path = "/etc/haproxy/haproxy.cfg"
+  @additive = ["# start haproxy mongrel", "# end haproxy mongrel"]
+%>
+
+listen mongrel_proxy 0.0.0.0:<%= rubber_env.haproxy_listen_port %>
+  <%
+    # Since we do "fair" load balancing to the mongrels, we don't want to share mongrels
+    # between haproxy instances otherwise we still end up with requests getting queued behind
+    # slow ones.
+    mongrel_hosts = rubber_instances.for_role('mongrel').collect { |i| i.name }
+    haproxy_hosts = rubber_instances.for_role('haproxy').collect { |i| i.name }
+    ports = (rubber_env.mongrel_base_port.to_i ... rubber_env.mongrel_base_port.to_i + rubber_env.mongrel_count.to_i).to_a
+    host_count = haproxy_hosts.size
+    host_mod = haproxy_hosts.sort.index(rubber_env.host) rescue 0
+    ports = ports.find_all {|x| x % host_count == host_mod}
+  %>
+  <% mongrel_hosts.each do |server| %>
+    <% ports.each do |port| %>
+      server <%= server %>_<%= port %> <%= server %>:<%= port %> maxconn 1 check
+    <% end %>
+  <% end %>
+

data/generators/vulcanize/templates/complete_mongrel_mysql/config/rubber/role/nginx/nginx-mongrel.conf

@@ -0,0 +1,113 @@
+<%
+  @path = "/etc/nginx/rubber/mongrel.conf"
+%>
+
+upstream haproxy_mongrel
+{
+  <% rubber_instances.for_role('haproxy').each do |ic| %>
+    server <%= ic.name %>:<%= rubber_env.haproxy_listen_port %>;
+  <% end %>
+}
+
+
+<% %w[http https].each do |protocol| %>
+
+  # This server is setup to serve www over <%= protocol %>.
+  server
+  {
+    <% if protocol == 'https' %>
+      listen               <%= rubber_env.web_ssl_port %>;
+      ssl                  on;
+      ssl_certificate    /etc/ssl/certs/ssl-cert-snakeoil.pem;
+      ssl_certificate_key /etc/ssl/private/ssl-cert-snakeoil.key;
+      # ssl_certificate      <%= RUBBER_ROOT %>/config/snapmylife.com.crt;
+      # ssl_certificate_key  <%= RUBBER_ROOT %>/config/snapmylife.com.key;
+    <% else %>
+      listen <%= rubber_env.web_port %>;
+    <% end %>
+
+    client_max_body_size 10M;
+
+    server_name <%= rubber_env.domain %>;
+
+    if ( $host = www.<%= rubber_env.domain %>)
+    {
+      rewrite ^\/(.*)$ http://<%= rubber_env.domain %>/$1 permanent;
+    }
+
+    root <%= RUBBER_ROOT + "/public" %>;
+
+    # this rewrites all the requests to the maintenance.html
+    # page if it exists in the doc root. This is for capistrano's
+    # disable web task
+    if (-f $document_root/system/maintenance.html)
+    {
+      rewrite  ^(.*)$  /system/maintenance.html last;
+      break;
+    }
+
+    location /
+    {
+      <%# nginx -> rails is http, so this tells rails the source protocol was https %>
+      <%= 'proxy_set_header X_FORWARDED_PROTO https;' if protocol == 'https' %>
+    
+      # needed to forward user's IP address to rails
+      proxy_set_header  X-Forwarded-For $proxy_add_x_forwarded_for;
+
+      # needed for HTTPS
+      proxy_set_header Host $http_host;
+      proxy_redirect false;
+      proxy_max_temp_file_size 0;
+
+
+      # If the file exists as a static file serve it directly without
+      # running all the other rewrite tests on it
+      if (-f $request_filename)
+      {
+        break;
+      }
+
+      # check for index.html for directory index
+      # if its there on the filesystem then rewite
+      # the url to add /index.html to the end of it
+      # and then break to send it to the next config rules.
+      if (-f $request_filename/index.html)
+      {
+        rewrite (.*) $1/index.html break;
+      }
+
+      # this is the meat of the rails page caching config
+      # it adds .html to the end of the url and then checks
+      # the filesystem for that file. If it exists, then we
+      # rewite the url to have explicit .html on the end
+      # and then send it on its way to the next config rule.
+      # if there is no file on the fs then it sets all the
+      # necessary headers and proxies to our upstream mongrels
+      if (-f $request_filename.html)
+      {
+        rewrite (.*) $1.html break;
+      }
+
+      if (!-f $request_filename)
+      {
+        proxy_pass http://haproxy_mongrel;
+        break;
+      }
+    }
+
+    # catch errors from proxy so we can display our error page
+    proxy_intercept_errors on;
+
+    error_page   500 502 503 504  /500.html;
+    location = /500.html
+    {
+      root <%= RUBBER_ROOT + "/public" %>;
+    }
+    error_page 404  /404.html;
+    location = /404.html
+    {
+      root <%= RUBBER_ROOT + "/public" %>;
+    }
+  }
+
+<% end %>

data/generators/vulcanize/templates/complete_mongrel_mysql/config/rubber/rubber-complete.yml

@@ -0,0 +1,41 @@
+
+role_dependencies:
+  web: [nginx, haproxy]
+  app: [mongrel]
+  web_tools: [nginx]
+
+haproxy_listen_port: 9000
+web_port: 80
+web_ssl_port: 443
+web_tools_port: 8080
+web_tools_ssl_port: 8443
+
+security_groups:
+  web:
+    description: "To open up port #{web_port}/#{web_ssl_port} for http server on web role"
+    rules:
+      - protocol: tcp
+        from_port: "#{web_port}"
+        to_port: "#{web_port}"
+        source_ips: [0.0.0.0/0]
+      - protocol: tcp
+        from_port: "#{web_ssl_port}"
+        to_port: "#{web_ssl_port}"
+        source_ips: [0.0.0.0/0]
+  web_tools:
+    description: "To open up port #{web_tools_port}/#{web_tools_ssl_port} for internal/tools http server"
+    rules:
+      - protocol: tcp
+        from_port: "#{web_tools_port}"
+        to_port: "#{web_tools_port}"
+        source_ips: [0.0.0.0/0]
+      - protocol: tcp
+        from_port: "#{web_tools_ssl_port}"
+        to_port: "#{web_tools_ssl_port}"
+        source_ips: [0.0.0.0/0]
+
+roles:
+  web:
+    assigned_security_groups: [web]
+  web_tools:
+    assigned_security_groups: [web_tools]

data/generators/vulcanize/templates/complete_mongrel_mysql/templates.yml

@@ -0,0 +1,6 @@
+description: A fairly complete and scalable mysql deployment setup
+dependent_templates:
+  - minimal_mysql
+  - monit
+  - munin
+  - memcached

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

@@ -0,0 +1,21 @@
+<%
+  @path = "/etc/haproxy/haproxy.cfg"
+  @additive = ["# start haproxy passenger", "# end haproxy passenger"]
+%>
+
+<%
+  backend_hosts = rubber_instances.for_role('passenger').collect { |i| i.name }
+%>
+
+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/complete_passenger_mysql/config/rubber/rubber-complete.yml

@@ -0,0 +1,40 @@
+
+role_dependencies:
+  web: [haproxy]
+  app: [passenger]
+  web_tools: [apache]
+
+web_port: 80
+web_ssl_port: 443
+web_tools_port: 8080
+web_tools_ssl_port: 8443
+
+security_groups:
+  web:
+    description: "To open up port #{web_port}/#{web_ssl_port} for http server on web role"
+    rules:
+      - protocol: tcp
+        from_port: "#{web_port}"
+        to_port: "#{web_port}"
+        source_ips: [0.0.0.0/0]
+      - protocol: tcp
+        from_port: "#{web_ssl_port}"
+        to_port: "#{web_ssl_port}"
+        source_ips: [0.0.0.0/0]
+  web_tools:
+    description: "To open up port #{web_tools_port}/#{web_tools_ssl_port} for internal/tools http server"
+    rules:
+      - protocol: tcp
+        from_port: "#{web_tools_port}"
+        to_port: "#{web_tools_port}"
+        source_ips: [0.0.0.0/0]
+      - protocol: tcp
+        from_port: "#{web_tools_ssl_port}"
+        to_port: "#{web_tools_ssl_port}"
+        source_ips: [0.0.0.0/0]
+
+roles:
+  web:
+    assigned_security_groups: [web]
+  web_tools:
+    assigned_security_groups: [web_tools]

data/generators/vulcanize/templates/complete_passenger_mysql/templates.yml

@@ -0,0 +1,10 @@
+description: A fairly complete and scalable mysql deployment setup
+dependent_templates:
+  - base
+  - mysql
+  - haproxy
+  - apache
+  - passenger
+  - monit
+  - munin
+  - memcached

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

@@ -0,0 +1,72 @@
+
+namespace :rubber do
+  namespace :cruise do
+  
+    rubber.allow_optional_tasks(self)
+    
+    # want ssh keys to be generated before we try and print it out
+    after "custom_install_base", "rubber:cruise:custom_install"
+
+    task :custom_install, :roles => :cruise do
+      rubber.sudo_script 'install_cruise', <<-ENDSCRIPT
+        export CRUISE_HOME="#{rubber_env.cruise_dir}"
+        
+        if [[ ! -d $CRUISE_HOME ]]; then
+            git clone git://github.com/sml/cruisecontrol.rb.git $CRUISE_HOME
+        fi
+      ENDSCRIPT
+      
+      logger.info("\n#######################################################################\n\n")
+      logger.info("This machine needs access to your source repository for cruise control")
+      logger.info("run 'cap rubber:cruise:setup_project' once access has been granted")
+      logger.info("then run 'cap rubber:cruise:start' to start the cruise web server")
+      logger.info("ssh public key:\n#{capture('cat ~/.ssh/id_dsa.pub')}")
+      logger.info("\n#######################################################################\n\n")
+   end
+    
+    task :setup_project, :roles => :cruise do
+      rubber.sudo_script 'setup_project', <<-ENDSCRIPT
+      
+        export CRUISE_HOME="#{rubber_env.cruise_dir}"
+        export CRUISE_DATA_ROOT="#{rubber_env.cruise_data_dir}"
+        export CRUISE_PROJECT_ROOT="#{rubber_env.cruise_project_dir}"
+        
+        if [[ ! -d $CRUISE_HOME ]]; then
+            git clone git://github.com/sml/cruisecontrol.rb.git #{rubber_env.cruise_dir}
+        fi
+        
+        if [[ ! -d $CRUISE_PROJECT_ROOT ]]; then
+          if [[ -z "#{rubber_env.cruise_repository}" ]]; then
+            echo "cruise_repository must be set in rubber env"
+            exit 1
+          fi
+          
+          cd $CRUISE_HOME
+          echo "Adding project repository to cruise: #{rubber_env.cruise_repository}"
+          ./cruise add #{rubber_env.app_name} #{rubber_env.cruise_repository}
+          mkdir -p $CRUISE_PROJECT_ROOT/log            
+          cd $CRUISE_PROJECT_ROOT && rake db:create RAILS_ENV=test
+        fi
+        
+      ENDSCRIPT
+    end
+    
+
+    desc "Start cruise control daemon"
+    task :start, :roles => :cruise do
+      run "/etc/init.d/cruise start"
+    end
+    
+    desc "Stop cruise control daemon"
+    task :stop, :roles => :cruise, :on_error => :continue do
+      run "/etc/init.d/cruise stop"
+    end
+    
+    desc "Restart cruise control daemon"
+    task :restart, :roles => :cruise do
+      stop
+      start
+    end
+      
+  end
+end

data/generators/vulcanize/templates/cruise/config/rubber/role/cruise/cruise

@@ -0,0 +1,40 @@
+<%
+  @path = "/etc/init.d/cruise"
+  @perms = 0755
+%>#!/usr/bin/env ruby
+
+require "fileutils"
+include FileUtils
+
+require "rubygems"
+
+begin
+  gem 'mongrel'
+rescue => e
+  puts "Error: daemon mode of CC.rb requires mongrel installed"
+  exit 1
+end
+
+def cruise_path
+  '<%= rubber_env.cruise_dir %>'
+end
+
+command = ARGV.shift
+
+case command
+when 'start'
+  cd cruise_path
+  system "./cruise start -d"
+  exit 0
+when 'stop'
+  system "mongrel_rails stop -P #{cruise_path}/tmp/pids/mongrel.pid"
+  Dir["#{cruise_path}/tmp/pids/builders/*.pid"].each do |pid_file|
+    pid = File.open(pid_file){|f| f.read }
+    system "kill -9 #{pid}"
+    rm pid_file
+  end
+  exit 0
+else
+  p "Usage: /etc/init.d/cruise start|stop"
+  exit 1
+end