rubber 1.3.2 → 1.5.0

data/lib/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/lib/generators/vulcanize/templates/base/config/rubber/rubber-dns.yml

@@ -0,0 +1,78 @@
+# OPTIONAL: The dns provider to use.  Need to exist in dns_providers below
+# dns_provider: nettica
+
+# OPTIONAL: The configuration for each dns provider (nettica|zerigo|dyndns)
+#          This lets rubber update a dynamic dns service with the instance alias and ip
+#
+dns_providers:
+  nettica:
+    user: joe
+    password: sekret
+    type: A
+    ttl: 300
+  zerigo:
+    email: foo@bar.com
+    token: hexxy
+    type: A
+    ttl: 300
+  dyndns:
+    user: joe
+    password: sekret
+    update_url: https://members.dyndns.org/nic/update?hostname=%host%&myip=%ip%'
+
+# OPTIONAL: Lets you configure your dns service, for example to add other CNAMES
+#           or setup dns round robin, etc.  Run "cap rubber:setup_dns_records"
+#           to apply them as rubber only sets up instance aliases as part of
+#           the standard lifecycle
+#
+#  dns_records:
+#    # simple A record
+#    - host: bar
+#      data: 1.1.1.1
+#
+#    # more detailed A record
+#    - host: bar
+#      domain: otherdomain.com
+#      data: 1.1.1.1
+#      type: A
+#      ttl: 300
+#
+#    # tld A record
+#    - host: ''
+#      data: 1.1.1.1
+#      type: A
+#
+#    # simple CNAME record
+#    - host: otherbar
+#      domain: foo.com
+#      data: bar.foo.com
+#      type: CNAME
+#      ttl: 300
+#
+#    # 2 of the same A records is a round robin dns
+#    - host: rr
+#      domain: foo.com
+#      data: 1.1.1.1
+#      type: A
+#      ttl: 300
+#    - host: rr
+#      domain: foo.com
+#      data: 1.1.1.2
+#      type: A
+#      ttl: 300
+#
+#    # A record, grabbing ip from instance config
+#    - host: baz
+#      domain: foo.com
+#      data: "#{rubber_instances.for_role('web').first.external_ip}"
+#      type: A
+#      ttl: 300
+#
+#    # MX record
+#    - host: ''
+#      domain: foo.com
+#      data: mail.foo.com
+#      type: MX
+#      ttl: 300
+#      priority: 10
+

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

@@ -0,0 +1,25 @@
+
+# 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: 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-head
+
+# 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/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