axtro-rubber 1.2.3 → 1.5.7

data/generators/vulcanize/templates/base/config/rubber/common/monit-postfix.conf

@@ -3,6 +3,6 @@
 %>
 
 check process postfix with pidfile /var/spool/postfix/pid/master.pid
-  start program  "/etc/init.d/postfix start"
-  stop program  "/etc/init.d/postfix stop"
+  start program  "/usr/bin/env service postfix start"
+  stop program  "/usr/bin/env service postfix stop"
   if 5 restarts within 5 cycles then timeout

data/generators/vulcanize/templates/base/config/rubber/common/rubber.profile

@@ -1,14 +1,13 @@
 <%
   @path = "/etc/profile.d/rubber.sh"
+  current_path = "/mnt/#{rubber_env.app_name}-#{RUBBER_ENV}/current" 
 %>
 
 # convenience to simply running rails console, etc with correct env
 export RUBBER_ENV=<%= RUBBER_ENV %>
 export RAILS_ENV=<%= RUBBER_ENV %>
-alias current="cd <%= RUBBER_ROOT %>"
-
-# make sure we use the right ruby since REE installs into /usr/local
-export PATH=<%= rubber_env.ruby_prefix %>/bin:$PATH
+alias current="cd <%= current_path %>"
+alias release="cd <%= RUBBER_ROOT %>"
 
 # Always use rubygems
 export RUBYOPT="rubygems"

data/generators/vulcanize/templates/base/config/rubber/deploy-setup.rb

@@ -3,63 +3,71 @@ namespace :rubber do
   
     rubber.allow_optional_tasks(self)
 
+    before "rubber:setup_gem_sources", "rubber:base:install_rvm"
+    task :install_rvm do
+      rubber.sudo_script "install_rvm", <<-ENDSCRIPT
+        if [[ `rvm --version 2> /dev/null` == "" ]]; then
+          echo "rvm_prefix=/usr/local" > /etc/rvmrc
+          echo "#{rubber_env.rvm_prepare}" > /etc/profile.d/rvm.sh
 
-    before "rubber:install_packages", "rubber:base:pre_install_ruby"
-    task :pre_install_ruby do
-
-      # figure out which hosts we have specified enterprise ruby for
-      sys_ruby_hosts = []
-      ent_ruby_hosts = []
-      rubber_instances.filtered.each do |ic|
-        env = rubber_cfg.environment.bind(ic.role_names, ic.name)
-        if env.use_enterprise_ruby
-          ent_ruby_hosts << ic.full_name unless ic.windows?
-        end
-      end
-
-      if ent_ruby_hosts.size > 0
-        task :_install_enterprise_ruby, :hosts => ent_ruby_hosts do
-          ver = "1.8.7-2010.01"
-          rubber.run_script "install_ruby-enterprise", <<-ENDSCRIPT
-            if [[ ! `ruby --version 2> /dev/null` =~ "Ruby Enterprise Edition 2010.01" ]]; then
-              arch=`uname -m`
-              if [ "$arch" = "x86_64" ]; then
-                src="http://rubyforge.org/frs/download.php/68720/ruby-enterprise_#{ver}_amd64.deb"
-              else
-                src="http://rubyforge.org/frs/download.php/68718/ruby-enterprise_#{ver}_i386.deb"
-              fi
-              src_file="${src##*/}"
-              wget -qP /tmp ${src}
-              dpkg -i /tmp/${src_file}
-            fi
-          ENDSCRIPT
-        end
-
-        _install_enterprise_ruby
-      end
+          # Copied below from http://rvm.beginrescueend.com/releases/rvm-install-latest
+          #
 
+          if [[ -f /etc/rvmrc ]] ; then source /etc/rvmrc ; fi
+
+          if [[ -f "$HOME/.rvmrc" ]] ; then source "$HOME/.rvmrc" ; fi
+
+          rvm_path="${rvm_path:-$HOME/.rvm}"
+
+          mkdir -p $rvm_path/src/
+
+          builtin cd $rvm_path/src
+
+          stable_version=#{rubber_env.rvm_version}
+
+          echo "rvm-${stable_version}"
+
+          curl -L "http://rvm.beginrescueend.com/releases/rvm-${stable_version}.tar.gz" -o "rvm-${stable_version}.tar.gz"
+
+          tar zxf "rvm-${stable_version}.tar.gz"
+
+          builtin cd "rvm-${stable_version}"
+
+          dos2unix scripts/* >/dev/null 2>&1 || true
+
+          bash ./scripts/install
+
+          #
+          # end rvm install script
+
+        fi
+      ENDSCRIPT
     end
 
-    #  The ubuntu rubygem package is woefully out of date, so install it manually
-    after "rubber:install_packages", "rubber:base:install_rubygems"
-    task :install_rubygems do
-      ver = "1.3.5"
-      src_url = "http://rubyforge.org/frs/download.php/60718/rubygems-#{ver}.tgz"
-      rubber.sudo_script 'install_rubygems', <<-ENDSCRIPT
-        if [[ `gem --version 2>&1` != "#{ver}" ]]; then
-          wget -qNP /tmp #{src_url}
-          tar -C /tmp -xzf /tmp/rubygems-#{ver}.tgz
-          ruby -C /tmp/rubygems-#{ver} setup.rb
-          ln -sf /usr/bin/gem1.8 /usr/bin/gem
-          rm -rf /tmp/rubygems*
-          gem source -l > /dev/null
+    # ensure that the rvm profile script gets sourced by reconnecting
+    after "rubber:base:install_rvm" do
+      teardown_connections_to(sessions.keys)
+    end
+
+    after "rubber:base:install_rvm", "rubber:base:install_rvm_ruby"
+    task :install_rvm_ruby do
+      opts = get_host_options('rvm_ruby')
+      install_rvm_ruby_script = <<-ENDSCRIPT
+        rvm_ver=$1
+        if [[ ! `rvm list default 2> /dev/null` =~ "$rvm_ver" ]]; then
+          rvm install $rvm_ver
+          # need to set default after using once or something in env is broken
+          rvm use $rvm_ver &> /dev/null
+          rvm use $rvm_ver --default
         fi
       ENDSCRIPT
+      opts[:script_args] = '$CAPISTRANO:VAR$'
+      rubber.sudo_script "install_rvm_ruby", install_rvm_ruby_script, opts
     end
-    
+
     after "rubber:install_packages", "rubber:base:configure_git" if scm == "git"
     task :configure_git do
-      rubber.run_script 'configure_git', <<-ENDSCRIPT
+      rubber.sudo_script 'configure_git', <<-ENDSCRIPT
         if [[ "#{repository}" =~ "@" ]]; then
           # Get host key for src machine to prevent ssh from failing
           rm -f ~/.ssh/known_hosts

data/generators/vulcanize/templates/base/config/rubber/deploy-util.rb

@@ -0,0 +1,97 @@
+namespace :rubber do
+  namespace :util do
+  
+    rubber.allow_optional_tasks(self)
+   
+    desc <<-DESC
+      Backup database using rake task rubber:backup_db
+    DESC
+    task :backup do
+      master_instances = rubber_instances.for_role('db', :primary => true)
+      slaves = rubber_instances.for_role('db', {})
+
+      # Select only one instance for backup.  Favor slave database.
+      selected_db_instance = (slaves+master_instances).first
+            
+      task_name = "_backup_db_#{selected_db_instance.full_name}".to_sym()
+      task task_name, :hosts => selected_db_instance.full_name do
+        rsudo "cd #{current_path} && RUBBER_ENV=#{RUBBER_ENV} BACKUP_DIR=/mnt/db_backups DBUSER=#{rubber_env.db_user} DBPASS=#{rubber_env.db_pass} DBNAME=#{rubber_env.db_name} DBHOST=#{selected_db_instance.full_name} rake rubber:backup_db"
+      end
+      send task_name
+    end
+    
+    desc <<-DESC
+      Restore database from s3 using rake task rubber:restore_db_s3
+    DESC
+    task :restore_s3 do
+      master_instances = rubber_instances.for_role('db', :primary => true)
+      slaves = rubber_instances.for_role('db', {})
+
+      for instance in master_instances+slaves
+        task_name = "_restore_db_s3_#{instance.full_name}".to_sym()
+        task task_name, :hosts => instance.full_name do
+          rsudo "cd #{current_path} && RUBBER_ENV=#{RUBBER_ENV} BACKUP_DIR=/mnt/db_backups DBUSER=#{rubber_env.db_user} DBPASS=#{rubber_env.db_pass} DBNAME=#{rubber_env.db_name} DBHOST=#{instance.full_name} rake rubber:restore_db_s3"
+        end
+        send task_name
+      end
+    end    
+    
+    desc <<-DESC
+      Overwrite ec2 production database with export from local production database.
+    DESC
+    task :local_to_ec2 do
+      require 'yaml'      
+      master_instances = rubber_instances.for_role('db', :primary => true)
+      slaves = rubber_instances.for_role('db', {})
+
+      # Select only one instance for backup.  Favor slave database.
+      selected_db_instance = (slaves+master_instances).first
+            
+      task_name = "_load_local_to_#{selected_db_instance.full_name}".to_sym()
+      task task_name, :hosts => selected_db_instance.full_name do
+
+        # Dump Local to tmp folder
+        filename = "#{application}.local.#{Time.now.to_i}.sql.gz" 
+        backup_file = "/tmp/#{filename}" 
+        on_rollback { delete file }
+        FileUtils.mkdir_p(File.dirname(backup_file))
+
+        # Use database.yml to get connection params
+        db = YAML::load(ERB.new(IO.read(File.join(File.dirname(__FILE__), '..','database.yml'))).result)[RUBBER_ENV]
+        user = db['username']
+        pass = db['passsword']
+        pass = nil if pass and pass.strip.size == 0
+        host = db['host']
+        name = db['database']
+        
+        raise "No db_backup_cmd defined in rubber.yml, cannot backup!" unless rubber_env.db_backup_cmd
+        db_backup_cmd = rubber_env.db_backup_cmd.gsub(/%([^%]+)%/, '#{\1}')
+        db_backup_cmd = eval('%Q{' + db_backup_cmd + '}')
+
+        # dbdump (or backup app) needs to be in your path
+        puts "Backing up database with command:"
+        system(db_backup_cmd)
+        puts "Created backup: #{backup_file}"
+
+        # Upload Local to S3
+        cloud_provider = rubber_env.cloud_providers[rubber_env.cloud_provider]
+        s3_prefix = "db/"
+        backup_bucket = cloud_provider.backup_bucket
+        if backup_bucket
+          AWS::S3::Base.establish_connection!(:access_key_id => cloud_provider.access_key, :secret_access_key => cloud_provider.secret_access_key)
+          unless AWS::S3::Bucket.list.find { |b| b.name == backup_bucket }
+            AWS::S3::Bucket.create(backup_bucket)
+          end
+          dest = "#{s3_prefix}#{File.basename(backup_file)}"
+          puts "Saving db dump to S3: #{backup_bucket}:#{dest}"
+          AWS::S3::S3Object.store(dest, open(backup_file), backup_bucket)
+        end
+        
+        send :restore_s3
+
+      end
+      send task_name
+    end    
+
+  end
+end

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

@@ -11,7 +11,6 @@ dns_providers:
     type: A
     ttl: 300
   zerigo:
-    customer_id: 1234
     email: foo@bar.com
     token: hexxy
     type: A

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

@@ -0,0 +1,28 @@
+
+# rvm needs some extra packages to compile/install ruby runtimes
+# curl is required.
+# patch is required (for ree, some ruby head's).
+# For JRuby (if you wish to use it) you will need:
+#   aptitude install curl sun-java6-bin sun-java6-jre sun-java6-jdk
+# For MRI & ree (if you wish to use it) you will need:
+#   aptitude install curl bison build-essential zlib1g-dev libssl-dev libreadline5-dev libxml2-dev git-core
+# For IronRuby (if you wish to use it) you will need:
+#   aptitude install curl mono-2.0-devel
+
+packages: [build-essential, git-core, subversion, curl, autoconf, bison, ruby, zlib1g-dev, libssl-dev, libreadline5-dev, libxml2-dev]
+
+# REQUIRED: the version of rvm itself
+rvm_version: 0.1.38
+
+# REQUIRED: Set to the rvm version string for the ruby version you wish to use
+# Run "rvm list known" to see the list of possible options
+rvm_ruby: 1.9.2
+
+# When rvm is installed as root, and you set the default, it symlinks ruby executables
+# into /usr/local
+ruby_prefix: /usr/local
+
+rvm_prefix: /usr/local/rvm
+  
+# lets us setup global envoronment to use rvm (also needed when running sudo)
+rvm_prepare: "source #{rvm_prefix}/scripts/rvm"

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

@@ -75,10 +75,10 @@ cloud_providers:
 
     # 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-ccf615a5
-    # Ubuntu 9.04 Jaunty	base install	64-bit	2.6.21.7-2.fc8xen	ami-eef61587
+    # Ubuntu 10.04 Lucid	base install	32-bit	ami-2d4aa444
+    # Ubuntu 10.04 Lucid	base install	64-bit	ami-fd4aa494
     #
-    image_id: ami-ccf615a5
+    image_id: ami-2d4aa444
     # m1.small or m1.large or m1.xlarge
     image_type: m1.small
 
@@ -130,25 +130,20 @@ auto_security_groups: true
 # 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
-
-# REE installs into /usr/local, so this lets us setup environment to use it globally
-# instead of system ruby
-ruby_prefix: "#{use_enterprise_ruby ? '/usr/local' : '/usr'}"
-
 # 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, git-core]
+packages: [postfix, build-essential, git-core, ec2-ami-tools]
 
 # OPTIONAL: gem sources to setup for rubygems
-gemsources: ["http://gemcutter.org", "http://gems.rubyforge.org/", "http://gems.github.com"]
+# 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]
+# 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

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

@@ -14,5 +14,5 @@ rescue
 end
 
 Dir.chdir(RAILS_ROOT)
-args = %W{-e -l #{log} -- script/runner} + ARGV
+args = %W{-e -l #{log} -- RAILS_RUNNER} + ARGV
 system "script/cron-sh", *args

data/generators/vulcanize/templates/base/templates.rb

@@ -0,0 +1,9 @@
+gem "rubber", Rubber.version if Rubber::Util::is_bundler? && ! Rubber::Util::rubber_as_plugin?
+
+if Rubber::Util::is_rails2?
+  m.gsub_file('script/cron-runner', /RAILS_RUNNER/, 'script/runner')
+  m.gsub_file('Rakefile', /RAILS_TASKS/, "require 'tasks/rails'")
+else
+  gsub_file('script/cron-runner', /RAILS_RUNNER/, 'rails runner')
+  gsub_file('Rakefile', /RAILS_TASKS/, '')
+end

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

@@ -1 +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/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 -qNO #{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