rubber 1.0.2

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

@@ -0,0 +1,241 @@
+# All variables can also be overridden on the role and/or host level by creating
+# a sub level to the config under roles and hosts
+# e.g. to install mysql only on db role, and awstats only on web01:
+#
+# packages: [ruby]
+# roles:
+#   db:
+#     packages: [mysql]
+# hosts:
+#   web01:
+#     packages: [awstats]
+
+# REQUIRED: The name of your application
+app_name: your_app_name
+
+# REQUIRED: The system user to run your app servers as
+app_user: app
+
+# REQUIRED: Notification emails (e.g. monit) get sent to this address
+#
+admin_email: root@localhost
+
+# OPTIONAL: If not set, you won't be able to access web_tools
+# server (munin stats, monit status, etc)
+# web_tools_user: admin
+# web_tools_password: sekret
+
+# REQUIRED: The timezone the server should be in
+timezone: US/Eastern
+
+# REQUIRED: the domain all the instances should be associated with
+#
+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: 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
+#
+# rubber_secret: "#{File.expand_path('~') + '/.ec2' + (RUBBER_ENV == 'production' ? '' : '_dev') + '/rubber-secret.yml' rescue ''}"
+
+# REQUIRED All known cloud providers with the settings needed to configure them
+# There's only one coud provider right now - Amazon Web Services
+# To implement another, clone lib/rubber/cloud/aws.rb
+#
+cloud_providers:
+  aws:
+    # REQUIRED The amazon keys and account ID (digits only, no dashes) used to access the AWS API
+    #
+    access_key: XXX
+    secret_access_key: YYY
+    account: ZZZ
+
+    # REQUIRED:  The name of the amazon keypair and location of its private key
+    #
+    # NOTE: for some reason Capistrano requires you to have both the public and
+    # the private key in the same folder, the public key should have the
+    # extension ".pub".  The easiest (only?) way to get your hand on this is to
+    # create an instance, ssh into it, and copy the file /mnt/openssh_id.pub
+    #
+    key_name: gsg-keypair
+    key_file: "#{Dir[(File.expand_path('~') rescue '/root') + '/.ec2/*' + cloud_providers.aws.key_name].first}"
+
+    # OPTIONAL: Needed for bundling a running instance using rubber:bundle
+    #
+    # pk_file: "#{Dir[(File.expand_path('~') rescue '/root') + '/.ec2/pk-*'].first}"
+    # cert_file: "#{Dir[(File.expand_path('~') rescue '/root') + '/.ec2/cert-*'].first}"
+    # image_bucket: "#{app_name}_images"
+
+    # OPTIONAL: Needed for backing up database to s3
+    # backup_bucket: "#{app_name}_backups"
+
+    # REQUIRED: the ami and instance type for creating instances
+    # The Ubuntu images at http://alestic.com/ work well
+    # Ubuntu 9.04 Jaunty	base install	32-bit	2.6.21.7-2.fc8xen	ami-ed46a784
+    # Ubuntu 9.04 Jaunty	base install	64-bit	2.6.21.7-2.fc8xen	ami-5b46a732
+    #
+    image_id: ami-ed46a784
+    # m1.small or m1.large or m1.xlarge
+    image_type: m1.small
+
+# REQUIRED the cloud provider to use
+#
+cloud_provider: aws
+
+# OPTIONAL: Define security groups
+# Each security group is a name associated with a sequence of maps where the
+# keys are the parameters to the ec2 AuthorizeSecurityGroupIngress API
+# source_security_group_name, source_security_group_owner_id
+# ip_protocol, from_port, to_port, cidr_ip
+#
+security_groups:
+  default:
+    description: The default security group
+    rules:
+      - source_group_name: default
+        source_group_account: "#{cloud_providers.aws.account}"
+      - protocol: tcp
+        from_port: 22
+        to_port: 22
+        source_ips: [0.0.0.0/0]
+
+# OPTIONAL: The default security groups to create instances with
+assigned_security_groups: [default]
+
+# OPTIONAL: Automatically create security groups for each host and role
+# EC2 doesn't allow one to change what groups an instance belongs to after
+# creation, so its good to have some empty ones predefined.
+auto_security_groups: true
+
+# OPTIONAL: Automatically isolate security groups for each appname/environment
+# by mangling their names to be appname_env_groupname
+# This makes it safer to have staging and production coexist on the same EC2
+# account, or even multiple apps
+isolate_security_groups: true
+
+# OPTIONAL: Set if you want to use Ruby Enterprise Edition instead of the standard ubuntu one
+use_enterprise_ruby: false
+
+# OPTIONAL: The packages to install on all instances
+# You can install a specific version of a package by using a sub-array of pkg, version
+# For example, packages: [[rake, 0.7.1], irb]
+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"]
+
+# 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]
+
+# OPTIONAL: A string prepended to shell command strings that cause multi
+# statement shell commands to fail fast.  You may need to comment this out
+# on some platforms, but it works for me on linux/osx with a bash shell
+#
+stop_on_error_cmd: "function error_exit { exit 99; }; trap error_exit ERR"
+
+# OPTIONAL: The default set of roles to use when creating a staging instance
+# with "cap rubber:create_staging".  By default this uses all the known roles,
+# but this is not always desired for staging, so you can specify a different
+# set here
+#
+staging_roles: "web,app,db:primary=true"
+
+
+# OPTIONAL: Lets one assign amazon elastic IPs (static IPs) to your instances
+#           You should typically set this on the role/host level rather than
+#           globally , unless you really do want all instances to have a
+#           static IP
+#
+# use_static_ip: true
+
+# OPTIONAL: Specifies an instance to be created in the given availability zone
+#           Availability zones are sepcified by amazon to be somewhat isolated
+#           from each other so that hardware failures in one zone shouldn't
+#           affect instances in another.  As such, it is good to specify these
+#           for instances that need to be redundant to reduce your chance of
+#           downtime. You should typically set this on the role/host level
+#           rather than globally.  Use rubber describe:zones to see the list
+#           of zones
+# availability_zone: us-east-1a
+
+# OPTIONAL: If you want t use Elastic Block Store (EBS) persistent
+# volumes, add them to host specific overrides and they will get created
+# and assigned to the instance.  On initial creation, the volume will get
+# attached _and_ formatted, but if your host disapears and you recreate
+# it, the volume will only get remounted thereby preserving your data
+#
+# hosts:
+#   my_host:
+#     availability_zone: us-east-1a
+#     volumes:
+#       - size: 100 # size of vol in GBs
+#         zone: us-east-1a # zone to create volume in, needs to match host's zone
+#         device: /dev/sdh # OS device to attach volume to
+#         mount: /mnt/mysql # The directory to mount this volume to
+#         filesystem: ext3 # the filesystem to create on volume
+#       - size: 10 # size of vol in GBs
+#         zone: us-east-1a # zone to create volume in, needs to match host's zone
+#         device: /dev/sdi # OS device to attach volume to
+#         mount: /mnt/logs # The directory to mount this volume to
+#         filesystem: ext3 # the filesystem to create on volume
+#
+#       # volumes without mount/filesystem can be used in raid arrays
+#
+#       - size: 50 # size of vol in GBs
+#         zone: us-east-1a # zone to create volume in, needs to match host's zone
+#         device: /dev/sdx # OS device to attach volume to
+#       - size: 50 # size of vol in GBs
+#         zone: us-east-1a # zone to create volume in, needs to match host's zone
+#         device: /dev/sdy # OS device to attach volume to
+#
+#     # for raid array, you'll need to add mdadm to packages.  Likewise,
+#     # xfsprogs is needed for xfs filesystem support
+#     packages: [xfsprogs, mdadm]
+#     raid_volumes:
+#       - device: /dev/md0 # OS device to to create raid array on
+#         mount: /mnt/fast # The directory to mount this array to
+#         filesystem: xfs # the filesystem to create on array
+#         raid_level: 0 # the raid level to use for the array
+#         source_devices: [/dev/sdx, /dev/sdy] # the source EBS devices we are creating raid array from
+
+# OPTIONAL: You can also define your own variables here for use when
+# transforming config files, and they will be available in your config
+# templates as  <%= rubber_env.var_name %>
+#
+# var_name: var_value
+
+# OPTIONAL: Role specific overrides
+# roles:
+#   somerole:
+#     packages: []
+#   somerole2:
+#     myconfig: someval
+
+# OPTIONAL: Host specific overrides
+# hosts:
+#   somehost:
+#     packages: []

data/generators/vulcanize/templates/base/lib/tasks/rubber.rake

@@ -0,0 +1,15 @@
+# rails tries to load this from generator dir, so skip it.
+if __FILE__ !~ /rubber\/generators\/vulcanize/
+
+  env = ENV['RUBBER_ENV'] ||= (ENV['RAILS_ENV'] || 'development')
+  root = File.dirname(__FILE__) + '/../..'
+
+  # this tries first as a rails plugin then as a gem
+  $:.unshift "#{root}/vendor/plugins/rubber/lib/"
+  require 'rubber'
+
+  Rubber::initialize(root, env)
+
+  require 'rubber/tasks/rubber'
+
+end

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

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+# For running rake 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-rake-#{Time.now.tv_sec}.log"
+begin
+  ident = File.basename(ARGV[-1]).gsub(/\W+/, "_")
+  log = "#{RAILS_ROOT}/log/cron-rake-#{ident}.log"
+rescue
+end
+
+Dir.chdir(RAILS_ROOT)
+args = %W{-l #{log} -- rake --trace} + ARGV
+system "script/cron-sh", *args

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 %>