nirvdrum-rubber 1.1.7 → 2.0.0.rails3.beta6

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

@@ -0,0 +1,235 @@
+# 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: See rubber-dns.yml for dns configuration
+# This lets rubber update a dynamic dns service with the instance alias
+# and ip when they are created.  It also allows setting up arbitrary
+# dns records (CNAME, MX, Round Robin DNS, etc)
+
+# 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 10.04 Lucid	base install	32-bit	ami-2d4aa444
+    # Ubuntu 10.04 Lucid	base install	64-bit	ami-fd4aa494
+    #
+    image_id: ami-2d4aa444
+    # m1.small or m1.large or m1.xlarge
+    image_type: m1.small
+
+    # OPTIONAL: EC2 spot instance request support.
+    #
+    # Enables the creation of spot instance requests.  Rubber will wait synchronously until the request is fulfilled,
+    # at which point it will begin initializing the instance, unless spot_instance_request_timeout is set.
+    # spot_instance: true
+    #
+    # The maximum price you would like to pay for your spot instance.
+    # spot_price: "0.085"
+    #
+    # If a spot instance request can't be fulfilled in 3 minutes, fallback to on-demand instance creation.  If not set,
+    # the default is infinite.
+    # spot_instance_request_timeout: 180
+
+# 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: 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, git-core, ec2-ami-tools]
+
+# OPTIONAL: gem sources to setup for rubygems
+# gemsources: ["http://rubygems.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: [rubber, rails, open4, aws-s3]
+# The above is the correct line once rails3 has been released
+gems: [open4, aws-s3, tzinfo, builder, i18n, memcache-client, rack, rake, rack-test, erubis, mail, text-format, thor, bundler, [rack-mount, 0.4], [rails, 3.0.0.beta3], [rubber, "#{Rubber.version}"]]
+
+# 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/lib/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/lib/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/lib/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} -- rails runner} + ARGV
+system "script/cron-sh", *args

data/lib/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/lib/generators/vulcanize/templates/base/templates.rb

@@ -0,0 +1 @@
+gem "rubber", Rubber.version if Rubber::Util::is_bundler? && ! Rubber::Util::rubber_as_plugin?

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

@@ -0,0 +1,6 @@
+description: The core configuration needed by all others
+
+# only include Rakefile when generating for non-rails apps, as we use rails
+# rake loading mechanism for including rakefile in rails apps
+optional:
+  Rakefile: "!rails?"

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

@@ -0,0 +1,88 @@
+
+namespace :rubber do
+
+  namespace :cassandra do
+  
+    rubber.allow_optional_tasks(self)
+  
+    after "rubber:install_packages", "rubber:cassandra:install"
+    
+    task :install, :roles => :cassandra do
+      rubber.sudo_script 'install_cassandra', <<-ENDSCRIPT
+        if [[ ! -d "#{rubber_env.cassandra_dir}" ]]; then
+          wget -qNP /tmp #{rubber_env.cassandra_pkg_url}
+          tar -C #{rubber_env.cassandra_prefix} -zxf /tmp/apache-cassandra-#{rubber_env.cassandra_version}-bin.tar.gz
+          wget -nNO #{rubber_env.cassandra_dir}/jmxterm.jar http://downloads.sourceforge.net/project/cyclops-group/jmxterm/1.0-alpha-4/jmxterm-1.0-alpha-4-uber.jar
+        fi
+      ENDSCRIPT
+    end
+
+    after "rubber:bootstrap", "rubber:cassandra:bootstrap"
+
+    task :bootstrap, :roles => :cassandra do
+      instances = rubber_instances.for_role("cassandra") & rubber_instances.filtered
+      instances.each do |ic|
+        task_name = "_bootstrap_cassandra_#{ic.full_name}".to_sym()
+        task task_name, :hosts => ic.full_name do
+          env = rubber_cfg.environment.bind("cassandra", ic.name)
+          exists = capture("echo $(ls #{env.cassandra_data_dir}/ 2> /dev/null)")
+          if exists.strip.size == 0
+            # After everything installed on machines, we need the source tree
+            # on hosts in order to run rubber:config for bootstrapping the db
+            deploy.update_code
+
+            # Gen just the conf for cassandra
+            rubber.run_config(:RUBBER_ENV => RUBBER_ENV, :FILE => "role/cassandra", :FORCE => true, :deploy_path => release_path)
+
+            cassandra_start
+            
+            # temporary hack to load initial schema from cassandra.yaml until
+            # something better available.  Subsequent schema changes should be
+            # done using thrift system_* api
+            # http://wiki.apache.org/cassandra/FAQ#no_keyspaces
+            # http://wiki.apache.org/cassandra/LiveSchemaUpdates
+            if instances.size == 1
+              rubber.sudo_script "install_cassandra_schema", <<-ENDSCRIPT
+                echo run -b org.apache.cassandra.service:type=StorageService loadSchemaFromYAML |\
+                  java -jar #{rubber_env.cassandra_dir}/jmxterm.jar -n -l #{ic.full_name}:#{rubber_env.cassandra_jmx_port}
+              ENDSCRIPT
+            end
+          end
+        end
+        send task_name
+      end
+    end
+    
+    on :load do
+      rubber.serial_task self, :serial_restart, :roles => :cassandra do
+        cassandra_stop
+        cassandra_start
+      end
+
+      rubber.serial_task self, :serial_reload, :roles => :cassandra do
+      end
+    end
+
+    def cassandra_stop
+      rsudo "pid=`cat #{rubber_env.cassandra_pid_file}` && kill $pid; while ps $pid &> /dev/null; do sleep 1; done"
+    end
+
+    def cassandra_start
+      rsudo "nohup #{rubber_env.cassandra_dir}/bin/cassandra -p #{rubber_env.cassandra_pid_file} &> #{rubber_env.cassandra_log_dir}/startup.log"
+    end
+
+    task :restart, :roles => :cassandra do
+      rubber.cassandra.stop
+      rubber.cassandra.start
+    end
+    
+    task :stop, :roles => :cassandra do
+      cassandra_stop
+    end
+    
+    task :start, :roles => :cassandra do
+      cassandra_start
+    end
+    
+  end
+end

data/lib/generators/vulcanize/templates/cassandra/config/rubber/role/cassandra/cassandra.in.sh

@@ -0,0 +1,58 @@
+<%
+  @path = "#{rubber_env.cassandra_dir}/bin/cassandra.in.sh"
+%>
+
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+cassandra_home=`dirname $0`/..
+
+# The directory where Cassandra's configs live (required)
+CASSANDRA_CONF=$cassandra_home/conf
+
+# This can be the path to a jar file, or a directory containing the
+# compiled classes. NOTE: This isn't needed by the startup script,
+# it's just used here in constructing the classpath.
+cassandra_bin=$cassandra_home/build/classes
+#cassandra_bin=$cassandra_home/build/cassandra.jar
+
+# JAVA_HOME can optionally be set here
+#JAVA_HOME=/usr/local/jdk6
+
+# The java classpath (required)
+CLASSPATH=$CASSANDRA_CONF:$cassandra_bin
+
+for jar in $cassandra_home/lib/*.jar; do
+    CLASSPATH=$CLASSPATH:$jar
+done
+
+# Arguments to pass to the JVM
+JVM_OPTS=" \
+        -ea \
+        -Xms128M \
+        -Xmx1G \
+        -XX:TargetSurvivorRatio=90 \
+        -XX:+AggressiveOpts \
+        -XX:+UseParNewGC \
+        -XX:+UseConcMarkSweepGC \
+        -XX:+CMSParallelRemarkEnabled \
+        -XX:+HeapDumpOnOutOfMemoryError \
+        -XX:SurvivorRatio=128 \
+        -XX:MaxTenuringThreshold=0 \
+        -Dcom.sun.management.jmxremote.port=<%= rubber_env.cassandra_jmx_port %> \
+        -Dcom.sun.management.jmxremote.ssl=false \
+        -Dcom.sun.management.jmxremote.authenticate=false"