chef_backup 0.0.1.dev.1

data/lib/chef_backup/logger.rb

@@ -0,0 +1,39 @@
+require 'highline'
+
+module ChefBackup
+  # Basic Logging Class
+  class Logger
+    def self.logger(logfile = nil)
+      @logger = nil if @logger && logfile && @logger.stdout != logfile
+      @logger ||= new(logfile)
+    end
+
+    def self.log(msg, level = :info)
+      logger.log(msg, level)
+    end
+
+    attr_accessor :stdout
+
+    def initialize(logfile = nil)
+      @stdout = logfile || $stdout
+      @highline = HighLine.new($stdin, @stdout)
+    end
+
+    def log(msg, level = :info)
+      case level
+      when :warn
+        msg = "WARNING: #{msg}"
+        @stdout.puts(color? ? @highline.color(msg, :yellow) : msg)
+      when :error
+        msg = "ERROR: #{msg}"
+        @stdout.puts(color? ? @highline.color(msg, :red) : msg)
+      else
+        @stdout.puts(msg)
+      end
+    end
+
+    def color?
+      @stdout.tty?
+    end
+  end
+end

data/lib/chef_backup/runner.rb

@@ -0,0 +1,136 @@
+require 'fileutils'
+require 'pathname'
+
+module ChefBackup
+  # ChefBackup::Runner class initializes the strategy and runs the action
+  class Runner
+    include ChefBackup::Helpers
+    include ChefBackup::Exceptions
+
+    attr_reader :restore_param
+
+    #
+    # @param running_config [Hash] A hash of the private-chef-running.json
+    #   or the CLI args for a restore
+    #
+    # @return [ChefBackup::Runner]
+    #
+    def initialize(running_config)
+      ChefBackup::Config.config = running_config
+      ChefBackup::Logger.logger(private_chef['backup']['logfile'] || nil)
+    end
+
+    #
+    # @return [TrueClass, FalseClass] Execute Chef Server backup
+    #
+    def backup
+      @backup ||= ChefBackup::Strategy.backup(backup_strategy)
+      @backup.backup
+    end
+
+    #
+    # @return [TrueClass, FalseClass] Execute Chef Server restore
+    #
+    def restore
+      @restore ||= ChefBackup::Strategy.restore(restore_strategy, restore_param)
+      @restore.restore
+    end
+
+    #
+    # @return [String] String name of the configured backup strategy
+    #
+    def backup_strategy
+      config['private_chef']['backup']['strategy']
+    end
+
+    #
+    # @return [String] String of the restore parameter. eg: EBS snapshot ID
+    #   or a path to a tarball
+    #
+    def restore_param
+      config['restore_param']
+    end
+
+    #
+    # @return [String] A path to backup tarball or EBS snapshot ID
+    #
+    def restore_strategy
+      @restore_strategy ||= begin
+        if tarball?
+          unpack_tarball
+          manifest['strategy']
+        elsif ebs_snapshot?
+          'ebs'
+        else
+          fail InvalidStrategy, "#{restore_param} is not a valid backup"
+        end
+      end
+    end
+
+    #
+    # @return [TrueClass, FalseClass] Is the restore_param is a tarball?
+    #
+    def tarball?
+      file = Pathname.new(File.expand_path(restore_param))
+      file.exist? && file.extname == '.tgz'
+    end
+
+    #
+    # @return [TrueClass, FalseClass] Is the restore_param an EBS Snapshot ID?
+    #
+    def ebs_snapshot?
+      restore_param =~ /^snap-\h{8}$/
+    end
+
+    #
+    # @return [TrueClass, FalseClass] Expands tarball into restore directory
+    #
+    def unpack_tarball
+      file = File.expand_path(restore_param)
+      ensure_file!(file, InvalidTarball, "#{file} not found")
+      log "Expanding tarball: #{file}"
+      shell_out!("tar zxf #{file} -C #{restore_directory}")
+    end
+
+    #
+    # @return [String] The backup name from the restore param
+    #
+    def backup_name
+      if tarball?
+        Pathname.new(restore_param).basename.sub_ext('').to_s
+      elsif ebs_snapshot?
+        restore_param
+      end
+    end
+
+    #
+    # Sets the restore_dir in ChefBackup::Config and ensures the directory
+    # exists and is cleaned.
+    #
+    # @return [String] A path to the restore directory
+    #
+    def restore_directory
+      config['restore_dir'] ||= begin
+        dir_name = File.join(tmp_dir, backup_name)
+        if File.directory?(dir_name)
+          # clean restore directory if it exists
+          FileUtils.rm_r(Dir.glob("#{dir_name}/*"))
+        else
+          FileUtils.mkdir_p(dir_name)
+        end
+        dir_name
+      end
+    end
+
+    #
+    # @return [Hash] A parsed copy of the manifest.json in the backup tarball
+    #
+    def manifest
+      @manifest ||= begin
+        file = "#{restore_directory}/manifest.json"
+        ensure_file!(file, InvalidTarball, 'No manifest found in tarball')
+        JSON.parse(File.read(file))
+      end
+    end
+  end
+end

data/lib/chef_backup/strategy.rb

@@ -0,0 +1,29 @@
+# Copyright:: Copyright (c) 2014 Chef, Inc.
+#
+# All Rights Reserved
+
+require 'chef_backup/strategy/backup/tar'
+require 'chef_backup/strategy/backup/lvm'
+require 'chef_backup/strategy/backup/ebs'
+require 'chef_backup/strategy/backup/object'
+require 'chef_backup/strategy/backup/custom'
+require 'chef_backup/strategy/restore/tar'
+require 'chef_backup/strategy/restore/lvm'
+require 'chef_backup/strategy/restore/ebs'
+require 'chef_backup/strategy/restore/object'
+require 'chef_backup/strategy/restore/custom'
+
+module ChefBackup
+  # ChefBackup::Strategy factory returns an ChefBackup::Strategy object
+  module Strategy
+    class << self
+      def backup(strategy)
+        const_get("#{strategy.capitalize}Backup").new
+      end
+
+      def restore(strategy, param)
+        const_get("#{strategy.capitalize}Restore").new(param)
+      end
+    end
+  end
+end

data/lib/chef_backup/strategy/backup/custom.rb

@@ -0,0 +1,7 @@
+# - custom
+#   - Verify that backup executable exists and is runnable
+#   - exec script
+class ChefBackup::Strategy::CustomBackup < ChefBackup::Strategy::TarBackup
+  def backup
+  end
+end

data/lib/chef_backup/strategy/backup/ebs.rb

@@ -0,0 +1,28 @@
+# ChefBackup::Ebs class.  To be used when/if Enterprise Chef ever supports EBS
+# natively
+class ChefBackup::Strategy::EbsBackup < ChefBackup::Strategy::TarBackup
+  # - ebs
+  #   - Verify AWS credentials exist
+  #   - Create backup manifest
+  #   - Create backup dir on ebs volume
+  #   - Copy /etc/opscode and manifest onto ebs volume
+  #   - Take EBS snapshot
+  def backup
+    ensure_tmp_dir
+    verify_ebs
+    dump_db if pg_dump?
+    create_manifest
+    copy_opscode_config
+    take_ebs_snapshot
+    cleanup
+  end
+
+  def verify_ebs
+  end
+
+  def take_ebs_snapshot
+  end
+
+  def copy_opscode_config
+  end
+end

data/lib/chef_backup/strategy/backup/lvm.rb

@@ -0,0 +1,42 @@
+# ChefBackup::Lvm class.  Class used when Enterprise Chef's stateful services
+# are on an LVM logical volume.  This may allow us to not require a pg_dump,
+# instead relying on pg_crash recovery.  Not doing a pg_dump will greatly
+# speed up backups.
+class ChefBackup::Strategy::LvmBackup < ChefBackup::Strategy::TarBackup
+  #   - verify config
+  #   - Verify lv and vg existence
+  #   - Warn if space is low in vg for an lvm snapshot
+  #   - Ensure backup directory exists
+  #   - Create temp backup dir
+  #   - Do DB dump (if we have to)
+  #   - Create backup manifest
+  #   - Take LVM snapshot
+  #   - Mount LVM snapshot
+  #   - Create a gzipped tarball of all required files
+  #     - db dump (if we have to)
+  #     - /etc/opscode
+  #     - Backup manifest
+  #     - mounted LVM snapshot
+  #   - Cleanup tmp directories
+  def backup
+    ensure_tmp_dir
+    verify_lvm
+    dump_db if pg_dump?
+    create_manifest
+    take_lvm_snapshot
+    mount_lvm_snapshot
+    create_tarball
+    cleanup
+  end
+
+  def verify_lvm
+    # verify lv and vg are available
+    # warn if vg space is low
+  end
+
+  def take_lvm_snapshot
+  end
+
+  def mount_lvm_snapshot
+  end
+end

data/lib/chef_backup/strategy/backup/object.rb

@@ -0,0 +1,29 @@
+# ChefBackup::Object class.  Used to backup all stateful services as an object
+# and stored locally in a filesystem structure in JSON.
+class ChefBackup::Strategy::ObjectBackup < ChefBackup::Strategy::TarBackup
+  # - object
+  #   - Make tmp directory
+  #   - Ensure backup directory exists
+  #   - Warn if backups directory or tmp are low on space
+  #   - knife-ec-backup into temp directory
+  #   - Create backup manifest
+  #   - Create gzipped tarball of all required files
+  #     - knife ec backup dump
+  #     - /etc/opscode
+  #     - Backup manifest
+  #   - Cleanup tmp directories
+  def backup
+    ensure_tmp_dir
+    verify_object
+    knife_ec_backup
+    create_manifest
+    create_tarball
+    cleanup
+  end
+
+  def verify_object
+  end
+
+  def knife_ec_backup
+  end
+end

data/lib/chef_backup/strategy/backup/tar.rb

@@ -0,0 +1,165 @@
+require 'fileutils'
+require 'json'
+require 'time'
+
+# rubocop:disable IndentationWidth
+module ChefBackup
+module Strategy
+# ChefBackup::Tar class.  Used to backup Standalone and Tier Servers that aren't
+# installed on LVM
+class TarBackup
+  # rubocop:enable IndentationWidth
+  include ChefBackup::Helpers
+  include ChefBackup::Exceptions
+
+  attr_reader :backup_time
+
+  def initialize
+    @backup_time = Time.now.strftime('%Y-%m-%d-%H-%M-%S')
+  end
+
+  #
+  # Ensures existence of an export directory for the backup
+  #
+  # @return [String] A path to the export_dir
+  #
+  def export_dir
+    @export_dir ||= begin
+      dir =
+        if private_chef['backup']['export_dir']
+          private_chef['backup']['export_dir']
+        else
+          msg = ["backup['export_dir'] has not been set.",
+                 'defaulting to: /var/opt/chef-backups'].join(' ')
+          log(msg, :warn)
+          '/var/opt/chef-backups'
+        end
+      FileUtils.mkdir_p(dir) unless File.directory?(dir)
+      dir
+    end
+  end
+
+  #
+  # Perform a pg_dump
+  #
+  # @return [TrueClass, FalseClass]
+  #
+  def dump_db
+    return true unless pg_dump?
+    pg_user = private_chef['postgresql']['username']
+    sql_file = "#{tmp_dir}/chef_backup-#{backup_time}.sql"
+    cmd = ['/opt/opscode/embedded/bin/chpst',
+           "-u #{pg_user}",
+           '/opt/opscode/embedded/bin/pg_dumpall',
+           "> #{sql_file}"
+          ].join(' ')
+    log "Dumping Postgresql database to #{sql_file}"
+    shell_out!(cmd)
+    data_map.services['postgresql']['pg_dump_success'] = true
+    data_map.services['postgresql']['username'] = pg_user
+    true
+  end
+
+  def populate_data_map
+    stateful_services.each do |service|
+      next unless private_chef.key?(service)
+      data_map.add_service(service, private_chef[service]['data_dir'])
+    end
+
+    config_directories.each do |config|
+      data_map.add_config(config, "/etc/#{config}")
+    end
+
+    # Don't forget the upgrades!
+    if private_chef.key?('upgrades')
+      data_map.add_service('upgrades', private_chef['upgrades']['dir'])
+    end
+  end
+
+  def manifest
+    data_map.manifest
+  end
+
+  def write_manifest
+    log 'Writing backup manifest'
+    File.open("#{tmp_dir}/manifest.json", 'w') do |file|
+      file.write(JSON.pretty_generate(manifest))
+    end
+  end
+
+  def stateful_services
+    if private_chef.key?('drbd') && private_chef['drbd']['enable'] == true
+      ['drbd']
+    else
+      %w(
+        rabbitmq
+        opscode-solr4
+        redis_lb
+        postgresql
+        bookshelf
+      )
+    end
+  end
+
+  def config_directories
+    %w(opscode) + enabled_addons
+  end
+
+  # The data_map is a working record of all of the data that is backed up.
+  def data_map
+    @data_map ||= ChefBackup::DataMap.new do |data|
+      data.backup_time = backup_time
+      data.strategy = strategy
+    end
+  end
+
+  def not_implemented
+    msg = "#{caller[0].split[1]} is not implemented for this strategy"
+    fail NotImplementedError, msg
+  end
+
+  def backup
+    log 'Starting Chef Server backup'
+    populate_data_map
+    if backend?
+      stop_chef_server(except: [:keepalived, :postgresql]) unless online?
+      dump_db
+      stop_service(:postgresql) unless online?
+    end
+    write_manifest
+    create_tarball
+    start_chef_server if backend? && !online?
+    export_tarball
+    cleanup
+    log 'Backup Complete!'
+  rescue => e
+    log "Something wen't terribly wrong, aborting backup", :error
+    log e.message, :error
+    cleanup
+    start_chef_server
+    raise e
+  end
+
+  def create_tarball
+    log 'Creating backup tarball'
+    cmd = [
+      "tar -czf #{tmp_dir}/chef-backup-#{backup_time}.tgz",
+      data_map.services.map { |_, v| v['data_dir'] }.compact.join(' '),
+      data_map.configs.map { |_, v| v['data_dir'] }.compact.join(' '),
+      Dir["#{tmp_dir}/*"].map { |f| File.basename(f) }.join(' ')
+    ].join(' ').strip
+
+    res = shell_out(cmd, cwd: tmp_dir)
+    res
+  end
+
+  def export_tarball
+    log "Exporting tarball to #{export_dir}"
+    cmd = "rsync -chaz #{tmp_dir}/chef-backup-#{backup_time}.tgz #{export_dir}/"
+
+    res = shell_out(cmd)
+    res
+  end
+end
+end
+end