ey_cloud_server 1.4.47 → 1.4.49

data/lib/ey_backup/engines/postgresql_engine.rb

@@ -6,7 +6,7 @@ module EY
       def dump(database_name, basename)
         file = basename + '.dump'
 
-        command = "PGPASSWORD='#{password}' pg_dump -h #{host} --format=c -Upostgres #{database_name}"
+        command = "PGPASSWORD='#{password}' pg_dump -h #{host} --create --format=c -Upostgres #{database_name} 2> /tmp/eybackup.$$.dumperr"
 
         if gpg?
           command << " | " << GPGEncryptor.command_for(key_id)
@@ -15,17 +15,13 @@ module EY
 
         command << " > #{file}"
 
-        run(command)
+        run(command, database_name)
 
         file
       end
 
       def load(database_name, file)
-        if database_exists?(database_name)
-          cycle_database(database_name)
-        else
-          create_database(database_name)
-        end
+        cycle_database(database_name)
 
         command = "cat #{file}"
 
@@ -33,33 +29,85 @@ module EY
           raise "Cannot load a GPG backup"
         end
 
-        command << " | PGPASSWORD='#{password}' pg_restore -h #{host} --format=c -Upostgres -d #{database_name}"
-
-        run(command)
-      end
+        command << " | PGPASSWORD='#{password}' pg_restore -h #{host} --clean --format=c -Upostgres -d #{database_name}"
 
-      def database_exists?(database_name)
-        runs?("PGPASSWORD='#{password}' psql -l -h #{host} | grep '#{database_name}'")
+        run(command, database_name)
       end
 
-      def drop_database(database_name)
+      def check_connections(database_name)
         stdout = StringIO.new()
-        active_connections = spawn(%Q{PGPASSWORD='#{password}' psql -U postgres -t -c "select count(*) from pg_stat_activity where datname='#{database_name}';"}, stdout)
+        active_connections = spawn(%Q{PGPASSWORD='#{password}' psql -U postgres -h #{host} -t -c "select count(*) from pg_stat_activity where datname='#{database_name}';"}, stdout)
         
         if stdout.string.to_i > 0
-          EY::Backup.logger.fatal(%Q{ERROR: Target database has active connections. For more information, see "Restore or load a database" in docs.engineyard.com})
+          res = ''
+          unless force
+            puts "There are currently #{stdout.string.to_i} connections on database: '#{database_name}'; can I kill these to continue (Y/n):"
+            Timeout::timeout(30){
+              res = gets.strip
+            }
+          end
+          
+          if res.upcase == 'Y' or force
+            cancel_connections(database_name)
+          else
+            EY::Backup.logger.fatal(%Q{ERROR: Target database has active connections. For more information, see "Restore or load a database" in docs.engineyard.com})
+          end
         end
-        
-        spawn("PGPASSWORD='#{password}' dropdb -h #{host} -U#{username} #{database_name}")
+      end
+      
+      def cancel_connections(database_name)
+        spawn(%Q{psql -U postgres -h #{host} -c"SELECT pg_terminate_backend(pg_stat_activity.pid)
+          FROM pg_stat_activity
+          WHERE pg_stat_activity.datname = '#{database_name}';"})
+      end
+      
+      def drop_database(database_name)
+        spawn("PGPASSWORD='#{password}' dropdb -h #{host} -Upostgres #{database_name}")
       end
 
       def create_database(database_name)
         spawn("PGPASSWORD='#{password}' createdb -U#{username} -h #{host} #{database_name}")
       end
-
+      
+      def check_if_replica
+        stdout = StringIO.new()
+        spawn(%Q{PGPASSWORD='#{password}' psql -U postgres -h #{host} -t -c "select pg_is_in_recovery()"| head -n 1}, stdout)
+        unless stdout.string.chomp =~ /^\W*f$/
+          EY::Backup.logger.fatal(%Q{ERROR: Target host: '#{host}' is currently a replica in recovery mode; restore operations need to be processed against the master.})
+        end
+      end
+      
+      def create_command(database_name)
+        stdout = StringIO.new()
+        
+        spawn(%Q{PGPASSWORD='#{password}' psql -U postgres -h #{host} -t -c "SELECT 'CREATE DATABASE ' || datname ||
+          ' WITH OWNER ' || pg_user.usename ||
+          CASE (select pg_encoding_to_char(encoding) from pg_database where datname='template1') 
+          WHEN pg_encoding_to_char(encoding) 
+            THEN ''
+            ELSE ' template=template0'
+          END ||
+          ' ENCODING ''' || pg_encoding_to_char(encoding) ||
+          ''' LC_COLLATE ''' || datcollate||
+          ''' LC_CTYPE ''' || datctype || 
+          ''' CONNECTION LIMIT ' || datconnlimit || ';'
+        FROM pg_database
+        INNER JOIN pg_user
+          ON pg_user.usesysid = pg_database.datdba
+        WHERE datname = '#{database_name}'"
+        }, stdout)
+        stdout.string
+      end
+      
       def cycle_database(database_name)
-        drop_database(database_name)
-        create_database(database_name)
+        create_cmd = create_command(database_name).chomp
+        if create_cmd == ''
+          create_database(database_name)
+        else
+          check_connections(database_name)
+          drop_database(database_name)
+          spawn(%Q{PGPASSWORD='#{password}' psql -U postgres -h #{host} -t -c "#{create_cmd}"})
+        end
       end
 
       def suffix

data/lib/ey_backup/logger.rb

@@ -2,15 +2,13 @@ module EY
   module Backup
     class Logger
       extend Forwardable
+      require 'shellwords'
 
       attr_accessor :stdout, :stderr
 
       alias_method  :fatal, :abort
       public :fatal
 
-      def_delegator :stderr, :puts, :error
-      def_delegator :stderr, :puts, :warn
-      def_delegator :stdout, :puts, :info
       def_delegator :stdout, :puts, :puts
 
       def self.quiet
@@ -19,18 +17,70 @@ module EY
 
       def initialize(stdout = $stdout, stderr = $stderr)
         @stdout, @stderr = stdout, stderr
+        @verbose = false
+      end
+
+      def push_dashboard_alert(message, alert_level, db = nil)
+        message.gsub!("\n", '\n')
+        type="process-dbbackup"
+        type = type + " #{db}" unless db.nil?
+        full_txt= "Severity: #{alert_level}\n" \
+                + "Time: #{Time.now.to_i}\n" \
+                + "Type: #{type}\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)
+        verbose "Sending dashboard alert"
+        system(alert_command)
+      end
+
+      def info(msg)
+        puts "#{Time.now} #{msg}" 
+      end
+
+      def verbose(msg)
+        info(msg) if @verbose
+      end
+
+      def set_verbose()
+        @verbose = true
       end
 
       def say(msg, newline = true)
         newline ? info(msg) : stdout.print(msg)
       end
+
+      def okay(msg, db = nil)
+        stderr.puts("#{Time.now} OKAY: #{msg}")
+        # push_dashboard_alert(msg, "OKAY", db), we don't push OKAY alerts, we push a summary alert instead.
+      end
+
+      def warn(msg, db = nil)
+        stderr.puts("#{Time.now} WARNING: #{msg}")
+        push_dashboard_alert(msg, "WARNING", db)
+      end
+
+      def error(msg, db = nil)
+        stderr.puts("#{Time.now} ERROR: #{msg}")
+        push_dashboard_alert("#{msg}. Details at /var/log/eybackup.log.", "FAILURE", db)
+      end
+            
+      def exception(type, msg)
+        self.error(msg)
+      end
+      
+      def debug(msg)
+        stderr.puts("#{Time.now} DEBUG: #{msg}")
+      end
+
     end
 
     module Logging
       extend Forwardable
 
       def_delegator EY::Backup, :logger
-      def_delegators :logger, :fatal, :error, :warn, :info, :puts, :say
+      def_delegators :logger, :fatal, :error, :warn, :okay, :info, :verbose, :debug, :puts, :say
     end
   end
 end

data/lib/ey_backup/spawner.rb

@@ -18,15 +18,41 @@ module EY
         end
       end
 
-      def run(command)
-        unless runs?(command)
-          raise "Failed to run #{command.inspect}"
+      def run(command, db = nil)
+        unless runs?(command, db)
+          raise "Failed to run backup command."
         end
       end
 
-      def runs?(command)
-        pid, *_ = Open4.popen4(command)
+      def runs?(command, db)
+        # This is to detect failures anywhere in the pipeline.
+        wrapper = <<-EOT
+          status=0
+          set -o pipefail
+          #{command}
+          status=$?
+
+          if [ $status -gt 0 ]; then exit 1; fi
+        EOT
+
+        verbose "Running command: #{command}" 
+        pid, *_ = Open4.popen4(wrapper)
         pid, status = Process::waitpid2(pid)
+        
+        if ! status.success?
+          dumperr = File.read("/tmp/eybackup.#{pid}.dumperr")
+          error("DB dump failed. The error returned was: #{dumperr}", db)
+        end
+
+        # Clean up:
+        # This whole error output thing is hideous.
+        # We need the errors, but as we're dealing with a pipeline we
+        # need to capture them separately rather than send them as
+        # input to the next process. We construct the backup command
+        # in the backup engine but only know the pid of the resulting
+        # backup here. Ugh.
+        system("rm /tmp/eybackup.#{pid}.dumperr") if File.exists?("/tmp/eybackup.#{pid}.dumperr")
+
         status.success?
       end
 

data/lib/ey_cloud_server.rb

@@ -6,4 +6,3 @@ module EY
 end
 
 require 'ey_cloud_server/version'
-require 'ey_cloud_server/mysql_start'

data/lib/ey_cloud_server/version.rb

@@ -1,5 +1,5 @@
 module EY
   module CloudServer
-    VERSION = '1.4.47'
+    VERSION = '1.4.49'
   end
 end

data/spec/config.yml

@@ -0,0 +1,11 @@
+---
+tmp_dir: 
+data_json: 
+mysql_user: root
+mysql_password:
+mysql_host: localhost
+postgresql_user: postgres
+postgresql_password: ketchup
+postgresql_host: localhost
+aws_secret_id: 'AKIAIDNXVLT3THIWYMNQ'
+aws_secret_key: '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'

data/spec/ey_backup/mysql_backups_spec.rb

@@ -23,6 +23,7 @@ describe "MySQL Backups" do
   end
 
   it "makes GPG encrypted backups" do
+    import_gpg
     EY::Backup.run(["-c", backup_config_file, '-k', Helpers::PUBLIC_KEY_ID])
 
     EY::Backup.run(["-c", backup_config_file, "-l", @db_name])
@@ -89,29 +90,29 @@ describe "MySQL Backups" do
   it 'manually restores an encrypted backup' do
     run_sql("CREATE TABLE `foo` (`id` int(11) NOT NULL auto_increment, PRIMARY KEY(`id`));", @db_name).should be_true
     run_sql("CREATE TABLE `bar` (`id` int(11) NOT NULL auto_increment, PRIMARY KEY(`id`));", @db_name).should be_true
-
+  
     import_gpg
-
+  
     EY::Backup.run(["-c", backup_config_file, '-k', Helpers::PUBLIC_KEY_ID])
-
+  
     run_sql("DROP TABLE `bar`;", @db_name).should be_true
     run_sql("SELECT * FROM `bar`;", @db_name).should be_false
-
+  
     reset_logger
-
+  
     EY::Backup.run(["-c", backup_config_file, "-l", @db_name])
-
+  
     stdout.should include("1 backup(s) found")
-
+  
     EY::Backup.run(["-c", backup_config_file, "--download", "0:#{@db_name}"])
     file = Dir["#{EY::Backup.tmp_dir}/*#{@db_name}*"].first
     stdout = StringIO.new
     EY::Backup::Spawner.spawn("gpg --no-default-keyring --keyring #{Helpers::PUBLIC_KEY_PATH} --secret-keyring #{Helpers::PRIVATE_KEY_PATH} --decrypt", stdout, file)
-
+  
     stdout.rewind
-
+  
     run_sql_pipe(stdout, @db_name)
-
+  
     run_sql("SELECT * FROM `foo`;", @db_name).should be_true
     run_sql("SELECT * FROM `bar`;", @db_name).should be_true
     FileUtils.rm(file)

data/spec/ey_backup/postgres_backups_spec.rb

@@ -24,11 +24,11 @@ describe "Postgres Backups" do
 
   it "makes GPG encrypted backups" do
     import_gpg
-
+ 
     EY::Backup.run(["-c", backup_config_file, '-e', 'postgresql', '-k', Helpers::PUBLIC_KEY_ID])
-
+ 
     EY::Backup.run(["-c", backup_config_file, '-e', 'postgresql', "-l", @db_name])
-
+ 
     stdout.should match(/0:#{@db_name}/)
   end
 
@@ -56,19 +56,19 @@ describe "Postgres Backups" do
   it "restores split backups" do
     run_psql("CREATE TABLE foo (id integer NOT NULL);", @db_name).should be_true
     run_psql("CREATE TABLE bar (id integer NOT NULL);", @db_name).should be_true
-
+  
     EY::Backup.run(["-c", backup_config_file, "-e", "postgresql", "-s", "100"])
     EY::Backup.run(["-c", backup_config_file, "-e", "postgresql", "-l", @db_name]).first.parts.should > 1
-
+  
     run_psql("DROP TABLE bar;", @db_name).should be_true
     run_psql("SELECT * FROM bar;", @db_name).should be_false
-
+  
     EY::Backup.run(["-c", backup_config_file, "-l", @db_name, '-e', 'postgresql'])
-
+  
     stdout.should include("1 backup(s) found")
-
+  
     EY::Backup.run(["-c", backup_config_file, "-r", "0:#{@db_name}", '-e', 'postgresql'])
-
+  
     run_psql("SELECT * FROM foo;", @db_name).should be_true
     run_psql("SELECT * FROM bar;", @db_name).should be_true
   end

data/spec/helpers.rb

@@ -4,7 +4,7 @@ module Helpers
   PUBLIC_KEY_ID = '4D5AA1CE74A97ADB'
 
   def run_before
-    public_key, private_key = read_keys
+    read_keys
 
     FakeWeb.clean_registry
     FakeWeb.passthrough_uri(:any, %r{^https?://s3.amazonaws.com/})
@@ -28,7 +28,7 @@ module Helpers
   end
 
   def stub_configs
-    # print "in stub_configs: #{YAML::dump(@database_config)}, #{YAML::dump(spec_config)}\n"
+    #print "in stub_configs: #{YAML::dump(@database_config)}, #{YAML::dump(spec_config)}\n"
     config = @database_config || spec_config
     config = config.merge({ :tmp_dir => tmp_dir })
     # print "in stub_configs2: #{YAML::dump(config)}\n"
@@ -59,7 +59,7 @@ module Helpers
     FileUtils.rm_f(backup_config_file)
     filenames = Dir.glob("#{tmp_dir}/*")
     if filenames.any?
-      raise "failed to remove #{filenames.join(' ')}"
+      raise "failed to remove #{filenames.join(', ')}"
     end
   end
 
@@ -82,7 +82,7 @@ module Helpers
   end
 
   def mysql_password_option
-    mysql_password.blank? ? "" : "-p#{mysql_password}"
+    mysql_password.nil? ? "" : "-p#{mysql_password}"
   end
 
   def generate_database_name(type)
@@ -156,7 +156,7 @@ module Helpers
     stdin.flush
     stdin.close
 
-    ignored, status = Process::waitpid2 pid
+    _, status = Process::waitpid2 pid
 
     status
   end
@@ -166,7 +166,7 @@ module Helpers
   end
 
   def tmp_dir
-    if spec_config['tmp_dir'].blank?
+    if spec_config['tmp_dir'].nil?
       File.dirname(__FILE__) + "/tmp/"
     else
       spec_config['tmp_dir'] || File.dirname("./tmp/")
@@ -174,11 +174,11 @@ module Helpers
   end
 
   def mysql_user
-    spec_config['mysql_user'] || raise("No mysql user provided")
+    spec_config['mysql_user'] || "root"
   end
 
   def postgresql_user
-    spec_config['postgresql_user'] || raise("No postgresql user provided")
+    spec_config['postgresql_user'] || "postgres"
   end
 
   def mysql_password
@@ -190,11 +190,11 @@ module Helpers
   end
 
   def mysql_host
-    spec_config['mysql_host'] || 'localhost'
+    spec_config['mysql_host'] || '127.0.0.1'
   end
 
   def postgresql_host
-    spec_config['postgresql_host'] || 'localhost'
+    spec_config['postgresql_host'] || '127.0.0.1'
   end
 
   def created_mysql_dbs
@@ -215,8 +215,14 @@ module Helpers
 
   def self.load_spec_config
     filename = File.dirname(__FILE__) + '/config.yml'
+
     if File.exist?(filename)
       @spec_config = YAML.load_file(filename)
+    elsif Fog.mocking?
+      @spec_config = {
+        'aws_secret_id'  => SecureRandom.base64(10),
+        'aws_secret_key' => SecureRandom.base64(20),
+      }
     else
       abort "Please setup your spec/config.yml file"
     end