rubber 1.15.0 → 2.0.0.pre1

data/generators/vulcanize/templates/munin/script/munin/example_simple.rb

@@ -1,24 +0,0 @@
-#!/usr/bin/env ruby
-#
-# Example munin plugin.
-# See munin plugin docs http://munin.projects.linpro.no/wiki/Documentation#Plugins
-#
-# Scripts added to RUBBER_ROOT/script/munin automatically
-# get installed as munin plugins by rubber
-
-# remove this line to enable
-exit 0
-
-# Print config info need by munin for generating graphs
-if ARGV[0] == "config"
-  puts 'graph_title Example Stats'
-  puts 'graph_vlabel random 1-100'
-  puts 'graph_category Examples'
-  puts 'graph_scale no'
-  puts 'rand.label random'
-
-  exit 0
-end
-
-# print graph data values
-puts "rand.value #{rand(100)}"

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

@@ -1,169 +0,0 @@
-
-namespace :rubber do
-  
-  namespace :mysql do
-    
-    rubber.allow_optional_tasks(self)
-    
-    after "rubber:create", "rubber:mysql:validate_db_roles"
-
-    task :validate_db_roles do
-      db_instances = rubber_instances.for_role("mysql_slave")
-      db_instances.each do |instance|
-        if instance.role_names.find {|n| n == 'mysql_master'}
-          fatal "Cannot have a mysql slave and master on the same instance, please removing slave role for #{instance.name}"
-        end
-      end
-    end
-
-    after "rubber:bootstrap", "rubber:mysql:bootstrap"
-  
-    
-    # Bootstrap the production database config.  Db bootstrap is special - the
-    # user could be requiring the rails env inside some of their config
-    # templates, which creates a catch 22 situation with the db, so we try and
-    # bootstrap the db separate from the rest of the config
-    task :bootstrap, :roles => [:mysql_master, :mysql_slave] do
-      
-      # Conditionaly bootstrap for each node/role only if that node has not
-      # been boostrapped for that role before
-      
-      master_instances = rubber_instances.for_role("mysql_master") & rubber_instances.filtered  
-      master_instances.each do |ic|
-        task_name = "_bootstrap_mysql_master_#{ic.full_name}".to_sym()
-        task task_name, :hosts => ic.full_name do
-          env = rubber_cfg.environment.bind("mysql_master", ic.name)
-          exists = capture("echo $(ls #{env.db_data_dir}/ 2> /dev/null)")
-          if exists.strip.size == 0
-            common_bootstrap("mysql_master")
-            
-            pass = "identified by '#{env.db_pass}'" if env.db_pass
-            rubber.sudo_script "create_master_db", <<-ENDSCRIPT
-              mysql -u root -e "create database #{env.db_name};"
-              mysql -u root -e "grant all on *.* to '#{env.db_user}'@'%' #{pass};"
-              mysql -u root -e "grant select on *.* to '#{env.db_slave_user}'@'%' #{pass};"
-              mysql -u root -e "grant replication slave on *.* to '#{env.db_replicator_user}'@'%' #{pass};"
-              mysql -u root -e "flush privileges;"
-            ENDSCRIPT
-          end
-        end
-        send task_name
-      end
-    
-      slave_instances = rubber_instances.for_role("mysql_slave") & rubber_instances.filtered  
-      slave_instances.each do |ic|
-        task_name = "_bootstrap_mysql_slave_#{ic.full_name}".to_sym()
-        task task_name, :hosts => ic.full_name do
-          env = rubber_cfg.environment.bind("mysql_slave", ic.name)
-          exists = capture("echo $(ls #{env.db_data_dir}/ 2> /dev/null)")
-          if exists.strip.size == 0
-            common_bootstrap("mysql_slave")
-
-            master = rubber_instances.for_role("mysql_master").first
-
-            # Doing a mysqldump locks the db, so ideally we'd do it against a slave replica thats
-            # not serving traffic (mysql_util role), but if thats not available try a regular
-            # slave (mysql_slave role), and finally default dumping from master (mysql_master role)
-            # TODO: handle simultaneous creating of multi slaves/utils
-            slaves = rubber_instances.for_role("mysql_slave")
-            slaves.delete(ic) # don't want to try and dump from self
-            source = slaves.find {|sc| sc.role_names.include?("mysql_util")}
-            source = slaves.first unless source
-            source = master unless source
-
-            pass = "identified by '#{env.db_pass}'" if env.db_pass
-            master_pass = ", master_password='#{env.db_pass}'" if env.db_pass
-            master_host = master.full_name
-            source_host = source.full_name
-
-            if source == master
-              logger.info "Creating slave from a dump of master #{source_host}"
-              rubber.sudo_script "create_slave_db_from_master", <<-ENDSCRIPT
-                mysql -u root -e "change master to master_host='#{master_host}', master_user='#{env.db_replicator_user}' #{master_pass}"
-                mysqldump -u #{env.db_user} #{env.db_pass.nil? ? '' : '--password=' + env.db_pass} -h #{source_host} --all-databases --master-data=1 | mysql -u root
-              ENDSCRIPT
-            else
-              logger.info "Creating slave from a dump of slave #{source_host}"
-              rsudo "mysql -u #{env.db_user} --password #{env.db_pass} -h #{source_host} -e \"stop slave;\""
-              slave_status = capture("mysql -u #{env.db_user} #{pass} -h #{source_host} -e \"show slave status\\G\"")
-              slave_config = Hash[*slave_status.scan(/([^\s:]+): ([^\s]*)/).flatten]
-              log_file = slave_config['Master_Log_File']
-              log_pos = slave_config['Read_Master_Log_Pos']
-              rubber.sudo_script "create_slave_db_from_slave", <<-ENDSCRIPT
-                mysqldump -u #{env.db_user} #{env.db_pass.nil? ? '' : '--password=' + env.db_pass} -h #{source_host} --all-databases --master-data=1 | mysql -u root
-                mysql -u root -e "change master to master_host='#{master_host}', master_user='#{env.db_replicator_user}', master_log_file='#{log_file}', master_log_pos=#{log_pos} #{master_pass}"
-                mysql -u #{env.db_user} --password #{env.db_pass} -h #{source_host} -e "start slave;"
-              ENDSCRIPT
-            end
-
-            # this doesn't work without agent forwarding which sudo breaks, as well as not having your
-            # ec2 private key ssh-added on workstation
-            # sudo "scp -o \"StrictHostKeyChecking=no\" #{source_host}:/etc/mysql/debian.cnf /etc/mysql"
-
-            rsudo "mysql -u root -e \"flush privileges;\""
-            rsudo "mysql -u root -e \"start slave;\""
-          end
-        end
-        send task_name
-      end
-      
-    end
-  
-    # TODO: Make the setup/update happen just once per host
-    def common_bootstrap(role)
-      # mysql package install starts mysql, so stop it
-      rsudo "service mysql stop" rescue nil
-      
-      # After everything installed on machines, we need the source tree
-      # on hosts in order to run rubber:config for bootstrapping the db
-      rubber.update_code_for_bootstrap
-      
-      # Gen just the conf for the given mysql role
-      rubber.run_config(:RUBBER_ENV => RUBBER_ENV, :FILE => "role/#{role}|role/db/", :FORCE => true, :deploy_path => release_path)
-
-      # reconfigure mysql so that it sets up data dir in /mnt with correct files
-      sudo_script 'reconfigure-mysql', <<-ENDSCRIPT
-        server_package=`dpkg -l | grep mysql-server-[0-9] | awk '{print $2}'`
-        dpkg-reconfigure --frontend=noninteractive $server_package
-      ENDSCRIPT
-      sleep 5
-    end
-    
-    before "rubber:munin:custom_install", "rubber:mysql:custom_install_munin"
-
-    desc <<-DESC
-      Installs some extra munin graphs
-    DESC
-    task :custom_install_munin, :roles => [:mysql_master, :mysql_slave] do
-      rubber.sudo_script 'install_munin_mysql', <<-ENDSCRIPT
-        if [ ! -f /usr/share/munin/plugins/mysql_ ]; then
-          wget --no-check-certificate -qN -O /usr/share/munin/plugins/mysql_ https://github.com/kjellm/munin-mysql/raw/master/mysql_
-          wget --no-check-certificate -qN -O /etc/munin/plugin-conf.d/mysql_.conf https://github.com/kjellm/munin-mysql/raw/master/mysql_.conf
-        fi
-      ENDSCRIPT
-    end
-
-    desc <<-DESC
-      Starts the mysql daemons
-    DESC
-    task :start, :roles => [:mysql_master, :mysql_slave] do
-      rsudo "service mysql start"
-    end
-    
-    desc <<-DESC
-      Stops the mysql daemons
-    DESC
-    task :stop, :roles => [:mysql_master, :mysql_slave] do
-      rsudo "service mysql stop"
-    end
-  
-    desc <<-DESC
-      Restarts the mysql daemons
-    DESC
-    task :restart, :roles => [:mysql_master, :mysql_slave] do
-      rsudo "service mysql restart"
-    end
-  
-  end
-
-end

data/generators/vulcanize/templates/mysql/config/rubber/role/db/crontab

@@ -1,14 +0,0 @@
-<%
-  @read_cmd = 'crontab -l'
-  @write_cmd = 'crontab -'
-  @additive = ["# rubber-mysql-start", "# rubber-mysql-end"]
-%>
-
-<%
-  # Backup db every 3 hours to secondary db if available, else primary db
-  backup_db_host = rubber_instances.for_role('db', {}).first rescue nil
-  backup_db_host ||= rubber_instances.for_role('db', 'primary' => true).first
-  if backup_db_host.name == rubber_env.host
-%>
-0 */3 * * * BACKUP_DIR=/mnt/db_backups DBUSER=<%= rubber_env.db_user %> DBPASS=<%= rubber_env.db_pass %> DBNAME=<%= rubber_env.db_name %> DBHOST=<%= backup_db_host.full_name %> <%= RUBBER_ROOT %>/script/cron-rake rubber:backup_db
-<% end %>

data/generators/vulcanize/templates/mysql/config/rubber/role/db/monit-mysql.cnf

@@ -1,10 +0,0 @@
-<%
-  @path = '/etc/monit/monit.d/monit-mysql.conf'
-%>
-
-check process mysql with pidfile /var/run/mysqld/mysqld.pid
-   group mysql-<%= RUBBER_ENV %>
-   start program = "/usr/bin/env service mysql restart"
-   stop program = "/usr/bin/env service mysql stop"
-   if failed host 127.0.0.1 port 3306 protocol mysql then alert
-   if 5 restarts within 5 cycles then timeout

data/generators/vulcanize/templates/mysql_cluster/config/rubber/common/mysql_cluster_migrations.rb

@@ -1,13 +0,0 @@
-<%
-  @path = "#{RUBBER_ROOT}/config/initializers/mysql_cluster_migrations.rb"
-%>
-
-# mysql adapter in rails hardcodes engine to be innodb, so if we want all
-# rails tables to be clustered, we need to override this behavior
-#
-class ActiveRecord::ConnectionAdapters::MysqlAdapter
-  def create_table(table_name, options = {}) #:nodoc:
-    super(table_name, options.reverse_merge(:options => "ENGINE=ndbcluster"))
-  end
-end
-

data/generators/vulcanize/templates/mysql_cluster/config/rubber/role/mysql_sql/monit-mysql_cluster_sql.cnf

@@ -1,10 +0,0 @@
-<%
-  @path = '/etc/monit/monit.d/monit-mysql_cluster_sql.conf'
-%>
-
-check process mysql_cluster_sql with pidfile /var/lib/mysql/<%= rubber_env.full_host %>.pid
-   group mysql_cluster_sql-<%= RUBBER_ENV %>
-   start program = "/usr/bin/env service mysql start"
-   stop program = "/usr/bin/env service mysql stop"
-   if failed host 127.0.0.1 port 3306 protocol mysql then alert
-   if 5 restarts within 5 cycles then timeout

data/generators/vulcanize/templates/mysql_cluster/config/rubber/rubber-mysql_cluster.yml

@@ -1,32 +0,0 @@
-# MySQL user accounts and privileges are not automatically propagated between different MySQL servers accessing the same MySQL Cluster. Therefore, you must make sure that these are copied between the SQL nodes yourself.
-
-# REQUIRED: The credentials for creating/accessong your app's database
-#
-db_user: "#{app_name}"
-db_pass:
-db_name: "#{app_name}_#{RUBBER_ENV}"
-
-# REQUIRED: The command to use to do a full backup of your database using
-#           "rake rubber:backup_db"
-db_backup_cmd: "nice mysqldump -h %host% -u %user% --password=%pass% %name% | gzip -c > %backup_file%"
-# REQUIRED: The command to use to restore the database using
-#           "rake rubber:restore_db_s3"
-#           This command will receive the data generated by db_backup_cmd via
-#           its standard input
-db_restore_cmd: "zcat - | mysql -h %host% -u %user% --password=%pass% %name%"
-
-
-# REQUIRED: The directory the data nodes store the db data in
-#
-db_data_dir: /mnt/mysql_cluster_data
-
-packages: [mysql-client, libmysql-ruby]
-
-
-roles:
-  mysql_sql:
-    packages: [mysql-server]
-  mysql_mgm:
-    packages: [mysql-server]
-  mysql_data:
-    packages: [mysql-server]

data/generators/vulcanize/templates/mysql_proxy/config/rubber/common/database.yml

@@ -1,16 +0,0 @@
-<%
-  @path = "#{RUBBER_ROOT}/config/database.yml"
-%>
-
-# Sets up rails to talk to mysql-proxy load balancer running on localhost,
-# which then then balances requests between sql nodes in the cluster
-<%= RUBBER_ENV %>:
-  adapter: <%= YAML::load(File.open("#{RUBBER_ROOT}/config/database.yml"))["production"]["adapter"] %>
-  encoding: utf8
-  database: <%= rubber_env.db_name %>
-  username: <%= rubber_env.db_user %>
-  password: <%= rubber_env.db_pass %>
-  host: 127.0.0.1
-  port: 4040
-
-

data/generators/vulcanize/templates/mysql_proxy/config/rubber/common/monit-mysql_proxy.cnf

@@ -1,10 +0,0 @@
-<%
-  @path = '/etc/monit/monit.d/monit-mysql_proxy.conf'
-%>
-
-check process mysql_proxy with pidfile /var/run/mysql-proxy.pid
-   group mysql_proxy-<%= RUBBER_ENV %>
-   start program = "/usr/bin/env service mysql-proxy start"
-   stop program = "/usr/bin/env service mysql-proxy stop"
-   if failed host 127.0.0.1 port 4040 protocol mysql then alert
-   if 5 restarts within 5 cycles then timeout

data/generators/vulcanize/templates/nginx/config/rubber/role/web_tools/nginx-tools.conf

@@ -1,55 +0,0 @@
-<%
-  @path = "/etc/nginx/rubber/tools.conf"
-%>
-
-
-# This server is setup to serve http.
-server
-{
-  listen <%= rubber_env.web_tools_port %>;
-  server_name <%= rubber_env.full_host %>;
-  root /var/www;
-
-  rewrite (.*) https://$host:<%= rubber_env.web_tools_ssl_port %>$1 break;
-}
-
-# This server is setup to serve https.
-server
-{
-  listen <%= rubber_env.web_tools_ssl_port %>;
-  server_name <%= rubber_env.full_host %>;
-
-  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;
-
-  auth_basic            "Rubber Admin Tools";
-  auth_basic_user_file  <%= RUBBER_ROOT %>/config/<%= rubber_env.app_name %>.auth;
-
-  client_max_body_size 10M;
-  root /var/www;
-
-
-  location /
-  {
-    # 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;
-    }
-  }
-
-  include /etc/nginx/rubber/tools/*.conf;
-}

data/generators/vulcanize/templates/passenger/config/rubber/role/passenger/passenger.conf

@@ -1,41 +0,0 @@
-<%
-  @path = '/etc/apache2/mods-available/passenger.conf'
-  @post = 'cd /etc/apache2/mods-enabled && ln -fs ../mods-available/passenger.conf'
-%>
-LoadModule passenger_module <%= rubber_env.passenger_lib %>
-PassengerRoot <%= rubber_env.passenger_root %>
-PassengerRuby <%= rubber_env.passenger_ruby %>
-PassengerUseGlobalQueue on
-
-# max number of rails instances per appserver
-PassengerMaxPoolSize <%= rubber_env.max_app_connections %>
-
-# min number of rails instances per appserver (by setting this as the max, we make sure we only wait for workers to spawn on the first request)
-PassengerMinInstances <%= rubber_env.max_app_connections %>
-
-# Use PassengerMaxPoolSize for limit as we only have 1 app
-PassengerMaxInstancesPerApp 0
-
-# For performances sake, never shutdown rails instances when idle
-PassengerPoolIdleTime 0
-
-# For performances sake, never shutdown a rails instance after N requests
-PassengerMaxRequests 0
-
-# Passenger checks stuff like restart.txt on every request when this is 0
-PassengerStatThrottleRate <%= RUBBER_ENV == 'production' ? '60' : '0' %>
-
-# Turning this on breaks mod_rewrite
-PassengerHighPerformance off
-
-# Cache framework code per application
-RailsSpawnMethod smart-lv2
-
-# For performances sake, don't ever unload framework spawner
-RailsFrameworkSpawnerIdleTime 0
-
-# For performances sake, don't ever unload app spawner
-RailsAppSpawnerIdleTime 0
-
-# Don't show the friendly error pages in production because it could leak information the public shouldn't see.
-PassengerFriendlyErrorPages <%= RUBBER_ENV == 'production' ? 'off' : 'on' %>

data/generators/vulcanize/templates/passenger/config/rubber/rubber-passenger.yml

@@ -1,15 +0,0 @@
-passenger_version: 3.0.9
-passenger_root: "#{rvm_gem_home}/gems/passenger-#{passenger_version}"
-passenger_ruby: "#{rvm_prefix}/wrappers/#{`bash -l -c 'rvm strings #{rvm_ruby}'`.strip}/ruby"
-passenger_lib: "#{passenger_root}/ext/apache2/mod_passenger.so"
-passenger_listen_port: 7000
-passenger_listen_ssl_port: 7001
-max_app_connections: 20
-
-role_dependencies:
-  passenger: [apache]
-
-roles:
-  passenger:
-    packages: [apache2-mpm-prefork, apache2-prefork-dev, libcurl4-openssl-dev]
-    gems: [fastthread, rack, [passenger, "#{passenger_version}"]]

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

@@ -1,86 +0,0 @@
-
-namespace :rubber do
-
-  namespace :passenger_nginx do
-  
-    rubber.allow_optional_tasks(self)
-  
-    after "rubber:install_gems", "rubber:passenger_nginx:custom_install"
-    
-    task :custom_install, :roles => :passenger_nginx do
-      rubber.sudo_script 'install_passenger_nginx', <<-ENDSCRIPT
-        # Check if there is an nginx with the required version and passenger built in.
-        if [ -x /usr/sbin/nginx ]
-          then echo 'Found nginx on system'
-          pax=$(/usr/sbin/nginx -V 2>&1 | awk '/nginx\\/#{rubber_env.nginx_version}/{a++}/passenger-#{rubber_env.passenger_version}/{b++} END {print a&&b}')
-          if [ $pax -eq 1 ]
-            then echo 'Nginx/Passenger version matches'
-            exit 0
-          fi
-        fi
-        # Lets install
-        echo 'Installing / Upgrading nginx #{rubber_env.nginx_version}'
-        TMPDIR=`mktemp -d` || exit 1
-        cd $TMPDIR
-        echo 'Downloading'
-        wget -qN http://sysoev.ru/nginx/nginx-#{rubber_env.nginx_version}.tar.gz
-        echo 'Unpacking'
-        tar xf nginx-#{rubber_env.nginx_version}.tar.gz
-        passenger-install-nginx-module --auto --prefix=/opt/nginx --nginx-source-dir=$TMPDIR/nginx-#{rubber_env.nginx_version} --extra-configure-flags="--conf-path=/etc/nginx/nginx.conf --error-log-path=/var/log/nginx/error.log --http-log-path=/var/log/nginx/access.log --lock-path=/var/lock/nginx.lock --pid-path=/var/run/nginx.pid --sbin-path=/usr/sbin/nginx"
-      ENDSCRIPT
-    end
-
-    after "rubber:setup_app_permissions", "rubber:passenger_nginx:setup_passenger_permissions"
-
-    task :setup_passenger_permissions, :roles => :passenger_nginx do
-      rsudo "chown #{rubber_env.app_user}:#{rubber_env.app_user} #{current_path}/config/environment.rb"
-    end
-    
-    on :load do
-      rubber.serial_task self, :serial_restart, :roles => :passenger_nginx do
-        rsudo "service nginx restart"
-      end
-      rubber.serial_task self, :serial_reload, :roles => :passenger_nginx do
-        rsudo "if ! ps ax | grep -v grep | grep -c nginx &> /dev/null; then service nginx start; else service nginx reload; fi"
-      end
-    end
-
-    before "deploy:stop", "rubber:passenger_nginx:stop"
-    after "deploy:start", "rubber:passenger_nginx:start"
-    after "deploy:restart", "rubber:passenger_nginx:reload"
-    
-    desc "Stops the nginx web server"
-    task :stop, :roles => :passenger_nginx do
-      rsudo "service nginx stop; exit 0"
-    end
-    
-    desc "Starts the nginx web server"
-    task :start, :roles => :passenger_nginx do
-      rsudo "service nginx start"
-    end
-    
-    desc "Restarts the nginx web server"
-    task :restart, :roles => :passenger_nginx do
-      serial_restart
-    end
-  
-    desc "Reloads the nginx web server"
-    task :reload, :roles => :passenger_nginx do
-      serial_reload
-    end
-    
-    
-    deploy.task :restart, :roles => :passenger_nginx do
-    end
-    
-    deploy.task :reload, :roles => :passenger_nginx do
-    end
-    
-    deploy.task :stop, :roles => :passenger_nginx do
-    end
-    
-    deploy.task :start, :roles => :passenger_nginx do
-    end
-    
-  end
-end