ey_cloud_server 1.4.54 → 1.5.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZTdlYWY2NzRmNzI0YjA2ODVlNzBhYWM5ZTQyZTIzODJjMjEyMmJjYw==
+    ZmFkNjBkYjY1OTNhZjQwNjMxNjUxMmNmOTRmOWQyZDMxMDJlNTUzYQ==
   data.tar.gz: !binary |-
-    ZDkxZjUxMjA5Njc3MTI3NmViNmEwYmJhMDZlZjgwNTMyNTBkNWIzOQ==
+    YTA0NTBmMTAxYzk5ZmE5YjQ0MzViYjE4NWE2YjRjZGM5YWYxZDNiNQ==
 SHA512:
   metadata.gz: !binary |-
-    YmQ1MDQwODBkMWNlYTFkMmI5NzM0YzdhM2UyYzVkNDQyZmNlODJjOTdkNDc0
-    YWM3ZjliNjFiZDhhMjc2MmFlZTRjMzU5MjUzY2FhNzQ0ZjkyYTUyZDQzMzM2
-    YTQwZjI3MzZmYTZhNTNlYTgzZDg2ZDFiNWNkMzg5ZDZlZDBjMzc=
+    ZmRlZTQ1YThjMWU0N2RkMzVlNmFkNGY3YThmMDJhMzRjZTE4MzU4ZGJjOTAx
+    NzM5MDc4OGZmNTMxNzM1OGI1ZTk4NDgxZjY5MTIwYmZmMTI1NmNjNjc0NmFl
+    OTI3OWFmMjdiZGE0N2QwZmEyNjljYzQ0NTg0MjBmZWI3NTBiOWU=
   data.tar.gz: !binary |-
-    MDQwZWY0MzgzMGI4NTI2MTgyMGQ0ZWQ5MzRlM2EzOTI5ZWFlY2EzMzAxMmRi
-    MTAwNDI3YzI0ODU4YmY3YzliZTcxNmFlNmNjMWM0Y2I3YzYzMDNkODdmODEx
-    ZWM4YTk3NTM3NTM1MGMwZjcxYTc1ODYyM2Q5ZWY5YTRkZTg0YTQ=
+    MTdlZDkwYmQ1ZmNiYTJmY2U0YWMzMmQ2YjZmNzA5NWEzYTVlNTA4ODM1ZGZj
+    ZTBkN2EwZmVlODczYTAxMjYwNzA3OTk3ODcxODlkOTQwZjYwZDNhNjE4Mjk2
+    YThjMTZiNjBmMmY3NTE5Yjg0NjI2YjRkOGQwMDg0YmQ4OTY3ZGM=

data/bin/ey-snapshots

@@ -10,6 +10,7 @@ require File.dirname(__FILE__) + '/../lib/ey-flex'
 begin
   EY::SnapshotMinder.run(ARGV)
 rescue => e
-  EY.notify_snapshot_error(e)
+  puts e.message
+  EY.notify_snapshot_error(e) unless STDOUT.isatty
   raise
 end

data/bin/eybackup

@@ -12,7 +12,9 @@ require File.dirname(__FILE__) + '/../lib/ey-flex'
 begin
   EY::Backup.run(ARGV)
 rescue => e
-  EY.notify_backup_error(e)
-  raise
+  puts e.message
+  puts "******* Trace *******"
+  puts e.inspect
+  EY.notify_backup_error(e) unless STDOUT.isatty
 end
 

data/bin/eyrestore

@@ -0,0 +1,211 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'yaml'
+require 'tempfile'
+require 'timeout'
+
+def opt_parse(argv)
+  options = {}
+  @optparse = OptionParser.new do |opts|
+    opts.banner = "Usage: #{__FILE__} --env <environment name> --database <database_name> --action <action> [options]"
+    opts.separator ''
+    opts.separator "Wrapper for eybackup used for listing, downloading and restoring database backups. The main purpose for this tool is to"
+    opts.separator "simplify the process of accessing backups from one environment in a different environment (e.g. access Production backups"
+    opts.separator "from Staging). This can also be used for restoring backups within the current environment."
+    opts.separator ''
+    opts.on('-h', '--help', 'Displays this Help message') { puts opts; exit}
+
+    opts.separator ''
+    opts.separator 'Common Options:'
+    
+    opts.on('-e', '--env environment_name', "Specifies the source environment name for the backups you will be working with.") { |env| options[:env] = env }
+    opts.on('-d', '--database database_name', "Name of the source database to list backups for.") { |dbname| options[:databases] = [dbname] }
+    actions=['list', 'restore', 'download']
+    opts.on('-a', '--action action_name', "The action you want to perform using the backup #{actions}.") do |action|
+      unless actions.include?(action)
+        puts "Invalid action: '#{action}' must be one of #{actions}\n\n"
+        puts opts
+        exit 1
+      end
+      options[:action] = action
+    end
+    opts.on('-i', '--index BACKUP_INDEX', 'Download/Restore the backup specified by index','BACKUP_INDEX uses the format #{index_number}:#{db_name}',
+        "The string 'last' will automatically reference the most recent available backup.") do |index|
+      options[:index] = index
+    end
+    opts.on('-f', '--force', 'Force mode, skips all confirmation prompts for use with automated restores.') { options[:force] = true }
+    
+    opts.separator ''
+    opts.separator 'Additional Options:'
+    
+    opts.on('-u', '--aws_secret_id key', 'AWS S3 Key') { |key| options[:aws_key_id] = key }
+    opts.on('-p', '--aws_secret_key secret', 'AWS S3 Secret Key') { |secret| options[:aws_secret_key] = secret }
+    opts.on('-b', '--backup_bucket bucket', 'AWS S3 bucket identifier') { |bucket| options[:backup_bucket] = bucket }
+    opts.on('-v', '--verbose', "Enable debug info for this wrapper.") { $verbose = true }
+    opts.on('-c', '--config', "Alternate config file for eyrestore (default ~/.eyrestore.confg.yml)") do |path| 
+      unless File.exists?(path)
+        puts "Invalid config file path '#{path}', no file at that location."
+        exit 1
+      end
+      options[:def_config] = path
+    end
+    opts.separator ''
+    opts.separator 'Examples:'
+    opts.separator '* List backups from an environment named production for a database named todo'
+    opts.separator "    sudo -i #{__FILE__} --env production --database todo --action list"
+    opts.separator ''
+    opts.separator '* Download the most recent backup from an environment named production for a database named todo'
+    opts.separator "    sudo -i #{__FILE__} --env production --database todo --action download --index last"
+    opts.separator ''
+    opts.separator "* Download a backup from an environment named production for a database named todo, prompt with a list of available backups"
+    opts.separator "    sudo -i #{__FILE__} --env production --database todo --action download"
+    opts.separator ''
+    opts.separator '* Restore the most recent backup from an environment named production for a database named todo'
+    opts.separator "    sudo -i #{__FILE__} --env production --database todo --action restore --index last"
+    opts.separator ''
+  end
+  @optparse.parse!
+  options
+end
+
+def debug(msg)
+  puts '[' + Time.now.strftime("%D %T") + ']: DEBUG: ' + msg if $verbose
+end
+
+def find_engine
+  debug("Searching for database engine based on file '/etc/.*.backups.yml'")
+  main_config = Dir['/etc/.*.backups.yml'].first
+  abort "Failed to find eybackup config at '/etc/.*.backups.yml', this needs to run on a database instance." unless main_config
+  debug("Found file '#{main_config}'")
+  File.basename(main_config).split('.')[1]
+end
+
+def extra_validations(options)
+  mandatory = [:databases, :env, :action]
+  mandatory << :index if %w(download restore).include? options[:action]
+  missing = mandatory.select{ |param| options[param].nil? }
+  raise OptionParser::MissingArgument, missing.join(',') unless missing.empty?
+end
+
+def list_backups(engine, db, path)
+  command = "eybackup -e #{engine} -l #{db} -c #{path}"
+  debug("Listing backups with command: #{command}")
+  res = %x{#{command}}
+  last = res.chomp.split("\n").last
+  if last.match(/0 backup\(s\) found/)
+    abort "No Backups Found for that environment and database.\n Tips:\n  - double check the source environment name is correct\n  - you may have a legacy bucket (grep backup_bucket /etc/.*.backups.yml) in the source environment, pass to eyrestore with --backup_bucket"
+  end
+  res
+end
+
+def gets_timeout( prompt, secs )
+  print prompt + "[timeout=#{secs}secs]: "
+  Timeout::timeout( secs ) { gets.chomp }
+rescue Timeout::Error
+  puts "*timeout"
+  ''  # return nil if timeout
+end
+
+def backup_idx(listing, index)
+  if index == 'last'
+    last_backup_idx(listing)
+  else
+    index
+  end
+end
+
+def last_backup_idx(listing)
+  last = listing.chomp.split("\n").last
+  if last.split.first.match(/\d+:\w+/)
+    index = last.split.first
+  else
+    index = last.split[3]
+  end
+end
+
+options = opt_parse(ARGV)
+options[:def_config] = '~/.eyrestore.config.yml' unless options[:def_config]
+
+# auto-detect the type of database running in the given environment
+engine = find_engine
+
+# parse eybackup config file
+config = YAML.load_file("/etc/.#{engine}.backups.yml")
+this_env = config[:env]
+# delete these just in case
+config.delete(:env)
+config.delete(:databases)
+
+# override config from eyrestore config file
+eyrestore = YAML.load_file(options[:def_config]) if File.exists?(options[:def_config])
+config.merge!(eyrestore) unless eyrestore.nil?
+
+# override config from command line options
+config.merge!(options)
+indexdb = config[:index].split(':')[1] if not config[:index].nil? and config[:index].include? ':'
+config[:databases] = [indexdb] if config[:databases].nil? and not indexdb.nil? and indexdb.match(/^\w+$/)
+begin
+  extra_validations(config)
+rescue OptionParser::MissingArgument => e
+  puts e.message
+  puts @optparse
+  exit
+end
+debug("Config Options: '#{config}'")
+
+# create a temporary configuration file from ~/.eyrestore.config.yml
+temp_config = Tempfile.new("eyrestore")
+temp_config.write(config.to_yaml)
+temp_config.rewind
+debug("Generated temporary config file: '#{temp_config.path}'")
+
+db = config[:databases].first
+temp = temp_config.path
+if config[:action] == 'list' or ! config[:index]
+  puts list_backups(engine, db, temp)
+end
+
+# confirm environment overwrite if restoring
+if config[:action] == 'restore' and ! config[:force]
+  response = gets_timeout("You are restoring the backup for '#{db}' from '#{config[:env]}' into '#{this_env}', THIS MAY BE DESTRUCTIVE; are you sure you want to proceed (Y/n) ? ", 30)
+  exit unless response.downcase == 'y'
+end
+
+
+if ['download','restore'].include?(config[:action])  
+  config[:index] = gets_timeout("Enter the backup index to use for #{config[:action]} (e.g. 9:#{db}) ", 30) unless config[:index]
+  config[:index] = backup_idx(list_backups(engine, db, temp), config[:index])
+  # config[:index] = last_backup_idx(list_backups(engine, db, temp)) if config[:index] == 'last'
+  config[:index] = config[:index] + ":#{config[:databases].first}" if config[:index].match(/^\d+$/) and config[:databases] and config[:databases].size == 1
+  abort "Invalid backup index '#{config[:index]}'; proper format is <number>:<dbname>." unless config[:index].match(/^\d+:\w+$/)
+  
+  action = config[:action] == 'restore' ? '-r' : '-d'
+  debug("Set action flag for eybackup to '#{action}' based on action of '#{config[:action]}'")
+  
+  # test eybackup version for force option
+  ey_cloud_server_version = Gem::Version.new(%x{/usr/local/ey_resin/ruby/bin/gem list ey_cloud_server}.split[1].gsub('(','').gsub(')','').gsub(',',''))
+  force = ey_cloud_server_version >= Gem::Version.new('1.4.51') ? '--force' : ''
+  debug("eybackup version '#{ey_cloud_server_version}' so force is set to '#{force}'")
+  
+  command="eybackup -e #{engine} -c #{temp} #{action} #{config[:index]} #{force}"
+  
+  puts "Running '#{config[:action]}' on index '#{config[:index]}'."
+  debug("Running command: #{command}")
+  
+  res=%x{#{command}}
+  puts res
+  
+  last_line = res.split("\n").last
+  if last_line.nil?
+    # No-op, eybackup messaging is adequate.
+  elsif last_line.match(/^Filename/) and config[:action] == 'restore' and not last_line.match(/.gpz$/)
+    puts "Restore complete!"
+  else
+    puts "Download complete!"
+  end
+end
+
+# cleanup temporary config file
+temp_config.close
+temp_config.unlink

data/features/step_definitions/mysql.rb

@@ -1,10 +1,12 @@
 Given \
     /^there is a mysql database \(([^\)]*)\)$/ do |db_key|
   create_mysql_database(db_key)
+  setup_dna({:db_stack_name => "mysql5_5"})
 end
 
 Given \
     /^the "([^\"]*)" mysql database is dropped$/ do |db_key|
   db_name = created_mysql_dbs[db_key]
   drop_mysql_database(db_name)
+  teardown_dna
 end

data/features/support/env.rb

@@ -1,3 +1,6 @@
+require 'simplecov'
+SimpleCov.start
+
 require File.dirname(__FILE__) + "/../../lib/ey-flex"
 require File.dirname(__FILE__) + "/../../lib/ey_backup"
 require 'fakeweb'

data/lib/ey-flex/bucket_minder.rb

@@ -16,6 +16,10 @@ module EY
       @bucket ||= @s3.directories.get(@bucket_name)
     end
 
+    def file
+      bucket
+    end
+    
     def files
       bucket.files
     end
@@ -74,7 +78,13 @@ module EY
     end
 
     def put(filename, contents)
-      files.create(:key => filename, :body => contents)
+      files.create(
+        :key => filename, 
+        :body => contents,
+        :public => false,
+        :multipart_chunk_size => 100*1024*1024, # 100MB
+        'x-amz-server-side-encryption' => 'AES256'
+      )
     end
   end
 end

data/lib/ey-flex.rb

@@ -25,7 +25,7 @@ module EY
   end
 
   def self.enzyme_api
-    @enzyme_api ||= EY::Enzyme::API.new(
+    @enzyme_api ||= EY::Enzyme::API::Client.new(
       enzyme_config[:api],
       enzyme_config[:instance_id],
       enzyme_config[:token],

data/lib/ey_backup/backend.rb

@@ -8,7 +8,6 @@ module EY
 
       def initialize(secret_id, secret_key, region, bucket_name)
         @bucket_minder = EY::BucketMinder.new(secret_id, secret_key, bucket_name, region)
-        @s3            = Fog::Storage.new(:provider => 'AWS', :aws_access_key_id => secret_id, :aws_secret_access_key => secret_key, :region => region)
       end
       attr_reader :bucket_minder
 
@@ -17,13 +16,13 @@ module EY
           begin
             object_name = File.join("#{environment_name}.#{database_name}", "#{File.basename(filename)}")
             info "Starting upload: #{filename}"
-            @s3.put_object(@bucket_minder.bucket_name, object_name, File.open(filename,'r'))
+            @bucket_minder.put(object_name, File.open(filename, 'r'))
             info "Successful upload: #{filename}"
           rescue => e
             retries ||= 5
             retries -= 1
             # remove partial or failed uploads
-            @s3.delete_object(@bucket_minder.bucket_name, object_name) rescue nil
+            @bucket_minder.remove_object(object_name)
             raise e if retries == 0
             warn "retrying upload of #{filename}. Got: #{e.inspect}"
             retry

data/lib/ey_backup/backup_set.rb

@@ -31,26 +31,26 @@ module EY
       end
 
       def self.list(databases)
-        names = databases.map do |db|
-          db.name
-        end
-        info "Listing database backups for #{names.join(', ')}"
-
-        backups = databases.map{ |db| db.backups }.flatten
-
-        puts "#{backups.size} backup(s) found"
-
-        backups.each_with_index do |backup_set, i|
-          puts "#{i}:#{backup_set.database_name} #{backup_set.normalized_name}"
+        all_backups = []
+        databases.each do |db|
+          backups = db.backups
+          all_backups << backups
+          puts "Listing database backups for #{db.name}"
+          puts "#{backups.size} backup(s) found"
+          
+          backups.each_with_index do |backup_set, i|
+            puts "#{i}:#{backup_set.database_name} #{backup_set.normalized_name}"
+          end
+          puts  # just some extra whitespace
         end
-
-        backups
+          
+        all_backups.flatten
       end
 
       def self.download(database, index)
-        fatal "You didn't specify a database name: e.g. 1:rails_production" if database.nil? || index.empty?
+        fatal "You didn't specify a database name: e.g. 1:rails_production" if database.nil? || index < 0
 
-        backup = database.backups[index.to_i]
+        backup = database.backups[index]
 
         fatal "No backup found for database #{database}: requested index: #{index}" unless backup
 
@@ -78,9 +78,9 @@ module EY
       def download!
         @remote_filenames = []
         @keys.each do |key|
-          info "Downloading #{key} to #{@database.base_path}"
           remote_filename = File.join(@database.base_path, normalize(key))
           puts "Filename: #{remote_filename}"
+          info "Downloading #{key} to #{@database.base_path}"
           File.open(remote_filename, 'wb') do |f|
             @database.bucket_minder.stream(key) do |chunk, remaining_size, total_size|
               f.write(chunk)

data/lib/ey_backup/cli.rb

@@ -9,18 +9,50 @@ module EY
 
         config_path = options[:config] || "/etc/.#{options[:engine]}.backups.yml"
 
-        config_for(config_path).merge(options)
+        options = config_for(config_path).merge(options)
+        options = late_options.merge(options)
+        
+        options[:tmp_dir] = '/mnt/tmp' if options[:tmp_dir].nil?
+        options = delayed_engine(File.join(options[:tmp_dir], '/chef/dna.json')).merge(options){|k, v1, v2| v2.nil? ? v1 : v2}
+        abort("Unable to determine database stack from dna; specify the engine with -e") if options[:engine].nil?
+        options
       end
 
       def default_options
         {
           :command => :new_backup,
           :format => "gzip",
-          :engine => 'mysql',
+          :engine => db_stack_name('/etc/chef/dna.json'),
           :verbose => false,
         }
       end
       
+      def late_options
+        {
+          :log_coordinates => false,
+          :skip_analyze => false,
+          :allow_concurrent => false,
+        }
+      end
+      
+      def delayed_engine(path)
+        {
+          :engine => db_stack_name(path),
+        }
+      end
+      
+      def db_stack_name(file)
+
+        if File.exist?(file)
+          case %x{cat #{file} | grep db_stack_name}
+          when /mysql/
+            'mysql'
+          when /postgres/
+            'postgresql'
+          end
+        end
+      end
+      
       def verify_restore
         res = ''
         puts "This will overwrite your database, are you sure you would like to proceed (Y/n)?"
@@ -34,14 +66,16 @@ module EY
         # Build a parser for the command line arguments
         options = {}
 
-        opts = OptionParser.new do |opts|
+        optparse = OptionParser.new do |opts|
           opts.version = EY::CloudServer::VERSION
 
           opts.banner = "\nUsage: eybackup [-flag] [argument]"
-          opts.define_head "  eybackup: manage dump (mysqldump/pg_dump) style backups of your database."
+          opts.define_head "  eybackup: manage logical (mysqldump/pg_dump) style backups of your database.",
+           "  When backing up multiple databases, each database is backed up separately."
           opts.separator '*'*80
 
-          opts.on("-l", "--list-backup DATABASE", "List backups for DATABASE") do |db|
+          opts.on("-l", "--list-backup DATABASE_NAME", "List backups for DATABASE_NAME; ",
+                  "  accepts 'all' to list all databases in the config (/etc/.*.backups.yml)") do |db|
             if db == "all"
               db = nil
             end
@@ -52,7 +86,9 @@ module EY
           opts.on("-e", "--engine DATABASE_ENGINE", "The database engine. ex: mysql, postgresql.") do |engine|
             options[:engine] = engine
           end
-          opts.on("-n", "--new-backup", "Create a new backup (default)") do
+          opts.on("-n", "--new-backup [DATABASE_NAME]", "Create a new backup (default).",
+                  "  Backs up each database in '/etc/.*.backups.yml' if DATABASE_NAME not set.") do |db|
+            options[:db] = db.split(',') unless db.nil? or db == ''
             options[:command] = :new_backup
           end
 
@@ -89,9 +125,11 @@ module EY
                   '  Run `eybackup -l #{db_name}` to get the index.',
                   '  BACKUP_INDEX uses the format #{index_number}:#{db_name}') do |index_and_db|
             options[:command] = :download
-            db, index = split_index(index_and_db)
+            index, db = split_index(index_and_db)
+            index = index.to_i
             options[:index] = index
             options[:db] = db
+            raise OptionParser::InvalidArgument, "Index '#{index_and_db}' is not a valid format (hint: <number>:<dbname>)!" if index.nil? or not index.is_a? Numeric
           end
 
           opts.on("-r", "--restore BACKUP_INDEX", "Download and apply the backup specified by index.",
@@ -99,9 +137,11 @@ module EY
                   '  Run `eybackup -l #{db_name}` to get the index.',
                   '  BACKUP_INDEX uses the format #{index_number}:#{db_name}') do |index_and_db|
             options[:command] = :restore
-            db, index = split_index(index_and_db)
+            index, db = split_index(index_and_db)
+            index = index.to_i
             options[:index] = index
             options[:db] = db
+            raise OptionParser::InvalidArgument, "Index '#{index_and_db}' is not a valid format (hint: <number>:<dbname>)!" if index.nil? or not index.is_a? Numeric
           end
           
           options[:force] = false
@@ -109,16 +149,33 @@ module EY
                   "  For use with automated restore operations (e.g. Staging).") do
             options[:force] = true
           end
+          
+          opts.on("--log_coordinates", "Record MySQL binary log position so backup can be used with replication or Point in Time functions.") do
+            options[:log_coordinates] = true
+          end
+          
+          opts.on("--allow_concurrent", "Allow eybackup process to run concurrently with other eybackup processes.") do
+            options[:allow_concurrent] = true
+          end
+          
+          opts.on("--skip_analyze", "Skip automatic analyze during PostgreSQL Restore operations.") do
+            options[:skip_analyze] = true
+          end
 
         end
 
-        opts.parse!(argv)
+        begin
+          optparse.parse!(argv)
+        rescue => e
+          puts optparse
+          raise
+        end
 
         options
       end
 
       def split_index(index)
-        index.split(':').reverse
+        index.split(':')
       end
 
       def config_for(filename)

data/lib/ey_backup/dumper.rb

@@ -1,3 +1,9 @@
+class String
+   def truncate(limit = 1)
+     self.match(%r{^(.{0,#{limit}})})[1]
+   end
+end
+
 module EY
   module Backup
     class Dumper < Base
@@ -26,15 +32,19 @@ module EY
         
         alert_level=exceptions.empty? ? 'OKAY' : 'FAILURE'
         
-        message.gsub!("\n", '\n')
-        full_txt= "Severity: #{alert_level}\n" \
-                + "Time: #{Time.now.to_i}\n" \
-                + "Type: process-dbbackup summary\n" \
-                + "Plugin: exec\n" \
-                + "raw_message: '#{message}'"
-        full_txt = Shellwords.escape(full_txt)
-        alert_command = %Q(echo #{full_txt} | /engineyard/bin/ey-alert.rb 2>&1)
-        system(alert_command)
+        # we don't provide alert here unless its a failure
+        unless alert_level == 'OKAY'
+          message.gsub!("\n", '\n')
+          message = Shellwords.escape(message).truncate(255)
+          full_txt= "Severity: #{alert_level}\n" \
+                  + "Time: #{Time.now.to_i}\n" \
+                  + "Type: process-dbbackup summary\n" \
+                  + "Plugin: exec\n"
+          full_txt = Shellwords.escape(full_txt)
+          full_txt += "raw_message:\\ \\'#{message}\\'"
+          alert_command = %Q(echo #{full_txt} | /engineyard/bin/ey-alert.rb 2>&1)
+          system(alert_command)
+        end
       end
 
       def initialize(database)
@@ -48,7 +58,7 @@ module EY
         backup_set.split!(split_size)
         backup_set.upload!
 
-        okay("Successful backup: #{@database.name} (#{@database.backup_size})", @database.name)
+        okay(@database.name, @database.backup_size)
         backup_set.cleanup
         backup_set.rm!
         @database.backup_size

data/lib/ey_backup/engine.rb

@@ -3,7 +3,7 @@ module EY
     class Engine < Base
       include Spawner
 
-      attr_reader :username, :password, :host, :key_id, :force
+      attr_reader :username, :password, :host, :key_id, :force, :allow_concurrent, :skip_analyze, :log_coordinates
 
       def self.label
         @label
@@ -26,8 +26,21 @@ module EY
           EY::Backup.logger.fatal("Unknown database engine: #{label}")
       end
 
-      def initialize(username, password, host, key_id, force)
-        @username, @password, @host, @key_id, @force  = username, password, host, key_id, force
+      def initialize(username, password, host, key_id, force, allow_concurrent, skip_analyze, log_coordinates)
+        @username, @password, @host, @key_id, @force, @allow_concurrent, @skip_analyze, @log_coordinates = username, password, host, key_id, force, allow_concurrent, skip_analyze, log_coordinates
+      end
+      
+      def block_concurrent(db = nil)
+        if backup_running?
+          message = "Unable to backup #{db}: already a backup in progress. Use --allow_concurrent to enable concurrent backup runs."
+          error(message, db) unless File.exists?('/etc/engineyard/skip_concurrent_alerts')  # this skips the dashboard alert
+          abort message
+        end
+      end
+      
+      def backup_running?
+        verbose %x{ps aux | grep [e]ybackup | grep rubygems}
+        %x{ps -ef | grep [e]ybackup | grep rubygems | wc -l}.to_i > 1
       end
 
       def gpg?