chef_backup 0.0.1.dev.2 → 0.1.1

data/lib/chef_backup/logger.rb

@@ -1,4 +1,4 @@
-require 'highline'
+require "highline"
 
 module ChefBackup
   # Basic Logging Class
@@ -15,7 +15,7 @@ module ChefBackup
     attr_accessor :stdout
 
     def initialize(logfile = nil)
-      $stdout = logfile ? File.open(logfile, 'ab') : $stdout
+      $stdout = logfile ? File.open(logfile, "ab") : $stdout
       @highline = HighLine.new($stdin, $stdout)
     end
 

data/lib/chef_backup/mash.rb

@@ -0,0 +1,226 @@
+# Copyright 2009-2016, Dan Kubb
+
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# ---
+# ---
+
+# Some portions of blank.rb and mash.rb are verbatim copies of software
+# licensed under the MIT license. That license is included below:
+
+# Copyright 2005-2016, David Heinemeier Hansson
+
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# This class has dubious semantics and we only have it so that people can write
+# params[:key] instead of params['key'].
+class Mash < Hash
+
+  # @param constructor<Object>
+  #   The default value for the mash. Defaults to an empty hash.
+  #
+  # @details [Alternatives]
+  #   If constructor is a Hash, a new mash will be created based on the keys of
+  #   the hash and no default value will be set.
+  def initialize(constructor = {})
+    if constructor.is_a?(Hash)
+      super()
+      update(constructor)
+    else
+      super(constructor)
+    end
+  end
+
+  # @param orig<Object> Mash being copied
+  #
+  # @return [Object] A new copied Mash
+  def initialize_copy(orig)
+    super
+    # Handle nested values
+    each do |k, v|
+      if v.kind_of?(Mash) || v.is_a?(Array)
+        self[k] = v.dup
+      end
+    end
+    self
+  end
+
+  # @param key<Object> The default value for the mash. Defaults to nil.
+  #
+  # @details [Alternatives]
+  #   If key is a Symbol and it is a key in the mash, then the default value will
+  #   be set to the value matching the key.
+  def default(key = nil)
+    if key.is_a?(Symbol) && include?(key = key.to_s)
+      self[key]
+    else
+      super
+    end
+  end
+
+  alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+  alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+  # @param key<Object> The key to set.
+  # @param value<Object>
+  #   The value to set the key to.
+  #
+  # @see Mash#convert_key
+  # @see Mash#convert_value
+  def []=(key, value)
+    regular_writer(convert_key(key), convert_value(value))
+  end
+
+  # @param other_hash<Hash>
+  #   A hash to update values in the mash with. The keys and the values will be
+  #   converted to Mash format.
+  #
+  # @return [Mash] The updated mash.
+  def update(other_hash)
+    other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
+    self
+  end
+
+  alias_method :merge!, :update
+
+  # @param key<Object> The key to check for. This will be run through convert_key.
+  #
+  # @return [Boolean] True if the key exists in the mash.
+  def key?(key)
+    super(convert_key(key))
+  end
+
+  # def include? def has_key? def member?
+  alias_method :include?, :key?
+  alias_method :has_key?, :key?
+  alias_method :member?, :key?
+
+  # @param key<Object> The key to fetch. This will be run through convert_key.
+  # @param *extras<Array> Default value.
+  #
+  # @return [Object] The value at key or the default value.
+  def fetch(key, *extras)
+    super(convert_key(key), *extras)
+  end
+
+  # @param *indices<Array>
+  #   The keys to retrieve values for. These will be run through +convert_key+.
+  #
+  # @return [Array] The values at each of the provided keys
+  def values_at(*indices)
+    indices.collect { |key| self[convert_key(key)] }
+  end
+
+  # @param hash<Hash> The hash to merge with the mash.
+  #
+  # @return [Mash] A new mash with the hash values merged in.
+  def merge(hash)
+    self.dup.update(hash)
+  end
+
+  # @param key<Object>
+  #   The key to delete from the mash.\
+  def delete(key)
+    super(convert_key(key))
+  end
+
+  # @param *rejected<Array[(String, Symbol)] The mash keys to exclude.
+  #
+  # @return [Mash] A new mash without the selected keys.
+  #
+  # @example
+  #   { :one => 1, :two => 2, :three => 3 }.except(:one)
+  #     #=> { "two" => 2, "three" => 3 }
+  def except(*keys)
+    super(*keys.map { |k| convert_key(k) })
+  end
+
+  # Used to provide the same interface as Hash.
+  #
+  # @return [Mash] This mash unchanged.
+  def stringify_keys!; self end
+
+  # @return [Hash] The mash as a Hash with symbolized keys.
+  def symbolize_keys
+    h = Hash.new(default)
+    each { |key, val| h[key.to_sym] = val }
+    h
+  end
+
+  # @return [Hash] The mash as a Hash with string keys.
+  def to_hash
+    Hash.new(default).merge(self)
+  end
+
+  # @return [Mash] Convert a Hash into a Mash
+  # The input Hash's default value is maintained
+  def self.from_hash(hash)
+    mash = Mash.new(hash)
+    mash.default = hash.default
+    mash
+  end
+
+  protected
+
+  # @param key<Object> The key to convert.
+  #
+  # @param [Object]
+  #   The converted key. If the key was a symbol, it will be converted to a
+  #   string.
+  #
+  # @api private
+  def convert_key(key)
+    key.kind_of?(Symbol) ? key.to_s : key
+  end
+
+  # @param value<Object> The value to convert.
+  #
+  # @return [Object]
+  #   The converted value. A Hash or an Array of hashes, will be converted to
+  #   their Mash equivalents.
+  #
+  # @api private
+  def convert_value(value)
+    if value.class == Hash
+      Mash.from_hash(value)
+    elsif value.is_a?(Array)
+      value.collect { |e| convert_value(e) }
+    else
+      value
+    end
+  end
+end

data/lib/chef_backup/runner.rb

@@ -1,5 +1,5 @@
-require 'fileutils'
-require 'pathname'
+require "fileutils"
+require "pathname"
 
 module ChefBackup
   # ChefBackup::Runner class initializes the strategy and runs the action
@@ -7,8 +7,6 @@ module ChefBackup
     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
@@ -17,7 +15,7 @@ module ChefBackup
     #
     def initialize(running_config)
       ChefBackup::Config.config = running_config
-      ChefBackup::Logger.logger(private_chef['backup']['logfile'] || nil)
+      ChefBackup::Logger.logger(service_config["backup"]["logfile"] || nil)
     end
 
     #
@@ -28,6 +26,13 @@ module ChefBackup
       @backup.backup
     end
 
+    #
+    # @return [ChefBackup::Config]
+    #
+    def config
+      ChefBackup::Config.config
+    end
+
     #
     # @return [TrueClass, FalseClass] Execute Chef Server restore
     #
@@ -40,7 +45,7 @@ module ChefBackup
     # @return [String] String name of the configured backup strategy
     #
     def backup_strategy
-      config['private_chef']['backup']['strategy']
+      service_config["backup"]["strategy"]
     end
 
     #
@@ -48,7 +53,7 @@ module ChefBackup
     #   or a path to a tarball
     #
     def restore_param
-      config['restore_param']
+      config["restore_param"]
     end
 
     #
@@ -58,11 +63,11 @@ module ChefBackup
       @restore_strategy ||= begin
         if tarball?
           unpack_tarball
-          manifest['strategy']
+          manifest["strategy"]
         elsif ebs_snapshot?
-          'ebs'
+          "ebs"
         else
-          fail InvalidStrategy, "#{restore_param} is not a valid backup"
+          raise InvalidStrategy, "#{restore_param} is not a valid backup"
         end
       end
     end
@@ -72,7 +77,7 @@ module ChefBackup
     #
     def tarball?
       file = Pathname.new(File.expand_path(restore_param))
-      file.exist? && file.extname == '.tgz'
+      file.exist? && file.extname == ".tgz"
     end
 
     #
@@ -97,7 +102,7 @@ module ChefBackup
     #
     def backup_name
       if tarball?
-        Pathname.new(restore_param).basename.sub_ext('').to_s
+        Pathname.new(restore_param).basename.sub_ext("").to_s
       elsif ebs_snapshot?
         restore_param
       end
@@ -110,7 +115,7 @@ module ChefBackup
     # @return [String] A path to the restore directory
     #
     def restore_directory
-      config['restore_dir'] ||= begin
+      config["restore_dir"] ||= begin
         dir_name = File.join(tmp_dir, backup_name)
         if File.directory?(dir_name)
           # clean restore directory if it exists
@@ -128,7 +133,7 @@ module ChefBackup
     def manifest
       @manifest ||= begin
         file = "#{restore_directory}/manifest.json"
-        ensure_file!(file, InvalidTarball, 'No manifest found in tarball')
+        ensure_file!(file, InvalidTarball, "No manifest found in tarball")
         JSON.parse(File.read(file))
       end
     end

data/lib/chef_backup/strategy.rb

@@ -2,16 +2,16 @@
 #
 # 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'
+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

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

@@ -2,6 +2,5 @@
 #   - Verify that backup executable exists and is runnable
 #   - exec script
 class ChefBackup::Strategy::CustomBackup < ChefBackup::Strategy::TarBackup
-  def backup
-  end
+  def backup; end
 end

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

@@ -17,12 +17,9 @@ class ChefBackup::Strategy::EbsBackup < ChefBackup::Strategy::TarBackup
     cleanup
   end
 
-  def verify_ebs
-  end
+  def verify_ebs; end
 
-  def take_ebs_snapshot
-  end
+  def take_ebs_snapshot; end
 
-  def copy_opscode_config
-  end
+  def copy_opscode_config; end
 end

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

@@ -34,9 +34,7 @@ class ChefBackup::Strategy::LvmBackup < ChefBackup::Strategy::TarBackup
     # warn if vg space is low
   end
 
-  def take_lvm_snapshot
-  end
+  def take_lvm_snapshot; end
 
-  def mount_lvm_snapshot
-  end
+  def mount_lvm_snapshot; end
 end

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

@@ -21,9 +21,7 @@ class ChefBackup::Strategy::ObjectBackup < ChefBackup::Strategy::TarBackup
     cleanup
   end
 
-  def verify_object
-  end
+  def verify_object; end
 
-  def knife_ec_backup
-  end
+  def knife_ec_backup; end
 end

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

@@ -1,6 +1,7 @@
 require 'fileutils'
 require 'json'
 require 'time'
+require 'highline/import'
 
 # rubocop:disable IndentationWidth
 module ChefBackup
@@ -26,8 +27,8 @@ class TarBackup
   def export_dir
     @export_dir ||= begin
       dir =
-        if private_chef['backup']['export_dir']
-          private_chef['backup']['export_dir']
+        if service_config['backup']['export_dir']
+          service_config['backup']['export_dir']
         else
           msg = ["backup['export_dir'] has not been set.",
                  'defaulting to: /var/opt/chef-backups'].join(' ')
@@ -46,33 +47,65 @@ class TarBackup
   #
   def dump_db
     return true unless pg_dump?
-    pg_user = private_chef['postgresql']['username']
+    if external_pg?
+      log('Cannot backup external postgresql', :warn)
+      return false
+    end
+    pg_user = service_config['postgresql']['username']
     sql_file = "#{tmp_dir}/chef_backup-#{backup_time}.sql"
-    cmd = ['/opt/opscode/embedded/bin/chpst',
+    cmd = [chpst,
            "-u #{pg_user}",
-           '/opt/opscode/embedded/bin/pg_dumpall',
-           "> #{sql_file}"
-          ].join(' ')
+           pg_dumpall,
+           "> #{sql_file}"].join(' ')
     log "Dumping Postgresql database to #{sql_file}"
-    shell_out!(cmd)
+    shell_out!(cmd, env: ["PGOPTIONS=#{pg_options}"])
     data_map.services['postgresql']['pg_dump_success'] = true
     data_map.services['postgresql']['username'] = pg_user
     true
   end
 
+  def chpst
+    "#{base_install_dir}/embedded/bin/chpst"
+  end
+
+  def pg_dumpall
+    "#{base_install_dir}/embedded/bin/pg_dumpall"
+  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'])
+    unless config_only?
+      stateful_services.each do |service|
+        next unless service_config.key?(service)
+        data_map.add_service(service, service_config[service]['data_dir'])
+      end
     end
 
     config_directories.each do |config|
       data_map.add_config(config, "/etc/#{config}")
     end
 
+    populate_versions
+
     # Don't forget the upgrades!
-    if private_chef.key?('upgrades')
-      data_map.add_service('upgrades', private_chef['upgrades']['dir'])
+    if service_config.key?('upgrades')
+      data_map.add_service('upgrades', service_config['upgrades']['dir'])
+    end
+
+    add_ha_services
+  end
+
+  def populate_versions
+    project_names.each do |project|
+      path = File.join(addon_install_dir(project), '/version-manifest.json')
+      data_map.add_version(project, version_from_manifest_file(path))
+    end
+  end
+
+  def add_ha_services
+    if ha? && !config_only?
+      data_map.add_service('keepalived', service_config['keepalived']['dir'])
+      data_map.add_ha_info('provider', service_config['ha']['provider'])
+      data_map.add_ha_info('path', service_config['ha']['path'])
     end
   end
 
@@ -87,22 +120,29 @@ class TarBackup
     end
   end
 
+  DEFAULT_STATEFUL_SERVICES = %w[rabbitmq
+                                 opscode-solr4
+                                 elasticsearch
+                                 redis_lb
+                                 postgresql
+                                 bookshelf].freeze
+
   def stateful_services
-    if private_chef.key?('drbd') && private_chef['drbd']['enable'] == true
+    if service_config.key?('drbd') && service_config['drbd']['enable'] == true
       ['drbd']
     else
-      %w(
-        rabbitmq
-        opscode-solr4
-        redis_lb
-        postgresql
-        bookshelf
-      )
+      DEFAULT_STATEFUL_SERVICES.select do |service|
+        service_enabled?(service)
+      end
     end
   end
 
   def config_directories
-    %w(opscode) + enabled_addons
+    [project_name] + enabled_addons.keys
+  end
+
+  def project_names
+    ([project_name] + enabled_addons.keys).uniq
   end
 
   # The data_map is a working record of all of the data that is backed up.
@@ -110,30 +150,38 @@ class TarBackup
     @data_map ||= ChefBackup::DataMap.new do |data|
       data.backup_time = backup_time
       data.strategy = strategy
+      data.topology = topology
     end
   end
 
   def not_implemented
     msg = "#{caller[0].split[1]} is not implemented for this strategy"
-    fail NotImplementedError, msg
+    raise NotImplementedError, msg
   end
 
   def backup
-    log 'Starting Chef Server backup'
+    log "Starting Chef Server backup #{config_only? ? '(config only)' : ''}"
     populate_data_map
-    if backend?
-      stop_chef_server(except: [:keepalived, :postgresql]) unless online?
-      dump_db
-      stop_service(:postgresql) unless online?
+    stopped = false
+    if backend? && !config_only?
+      if !online?
+        ask_to_go_offline unless offline_permission_granted?
+        stop_chef_server(except: %i[keepalived postgresql])
+        dump_db
+        stop_service(:postgresql)
+        stopped = true
+      else
+        dump_db
+      end
     end
     write_manifest
     create_tarball
-    start_chef_server if backend? && !online?
+    start_chef_server if stopped
     export_tarball
     cleanup
     log 'Backup Complete!'
   rescue => e
-    log "Something wen't terribly wrong, aborting backup", :error
+    log "Something went terribly wrong, aborting backup", :error
     log e.message, :error
     cleanup
     start_chef_server
@@ -143,27 +191,60 @@ class TarBackup
   def create_tarball
     log 'Creating backup tarball'
     cmd = [
-      "tar -czf #{tmp_dir}/chef-backup-#{backup_time}.tgz",
+      "tar -czf #{tmp_dir}/#{export_filename}",
       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 = 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}/"
+    cmd = "rsync -chaz #{tmp_dir}/#{export_filename} #{export_dir}/"
 
-    res = shell_out(cmd)
+    res = shell_out!(cmd)
     res
   end
 
+  def export_filename
+    postfix = if config_only?
+                '-config'
+              else
+                ''
+              end
+    "chef-backup#{postfix}-#{backup_time}.tgz"
+  end
+
+  def service_enabled?(service)
+    service_config[service] && service_config[service]['enable'] && !service_config[service]['external']
+  end
+
+  def external_pg?
+    service_config['postgresql']['external']
+  end
+
   def pg_dump?
     # defaults to true
-    private_chef['backup']['always_dump_db']
+    service_config['backup']['always_dump_db']
+  end
+
+  def offline_permission_granted?
+    service_config['backup']['agree_to_go_offline']
+  end
+
+  def config_only?
+    service_config['backup']['config_only']
+  end
+
+  def ask_to_go_offline
+    msg = 'WARNING:  Offline backup mode must stop your Chef server before '
+    msg << 'continuing.  You can skip this message by passing a "--yes" '
+    msg << 'argument. Do you wish to proceed? (y/N):'
+
+    exit(1) unless ask(msg) =~ /^y/i
   end
 end
 end