chef_backup 0.0.1.dev.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1bec5855a4a67f6d47efbf80b1b13be09338de3d
+  data.tar.gz: c02131b03380815d3a79c281da26fb8fe51f7f7f
+SHA512:
+  metadata.gz: 34616288ba8212f0e86fb3e5b26ad75bd6a912c9de52123ea954179c1a52ced09ed5f4f00368bf2c17b4ddb32642ba0f78e76a0da0071510bf8851bc0af93a1f
+  data.tar.gz: 02e5d4f0bc8868228c9f329702adfe8099c7f866e7f2e82760a65cd153a487c861e950184eddc938e578db894eb41ac6fcb6a84e7498641a7cbc7a0bb0e26f32

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+*.sw*

data/.kitchen.yml

@@ -0,0 +1,30 @@
+driver:
+  name: vagrant
+  forward_agent: true
+  customize:
+    cpus: 2
+    memory: 2048
+  synced_folders:
+    - ['.', '/home/vagrant/chef_backup']
+    - ['../../opscode/chef_packages/', '/home/vagrant/chef_packages']
+
+provisioner:
+  name: chef_zero
+  require_chef_omnibus: 11.16.4
+
+platforms:
+  - name: ubuntu-14.04
+    run_list: apt::default
+  - name: ubuntu-12.04
+    run_list: apt::default
+  - name: ubuntu-11.04
+    run_list: apt::default
+  - name: ubuntu-10.04
+    run_list: apt::default
+  - name: centos-5.10
+  - name: centos-6.5
+
+suites:
+  - name: default
+    attributes:
+    run_list:

data/.rubocop.yml

@@ -0,0 +1,17 @@
+Style/ClassAndModuleChildren:
+  Enabled: false
+Style/GuardClause:
+  Enabled: false
+Metrics/ClassLength:
+  Max: 200
+Metrics/CyclomaticComplexity:
+  Max: 10
+Metrics/PerceivedComplexity:
+  Max: 10
+Metrics/MethodLength:
+  Max: 40
+Metrics/AbcSize:
+  Max: 25
+AllCops:
+  Exclude:
+    - 'Guardfile'

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - "2.1.5"
+  - "2.2.0"
+notifications:
+  email: false

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ec_backup.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,22 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rsspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separetly)
+#  * 'just' rspec: 'rspec'
+guard :rspec, cmd: 'bundle exec rspec -f doc --color', all_after_pass: true do
+  watch(%r{^spec/.+/.+_spec\.rb$})
+  watch(%r{^spec/.+/.+/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$}) { |m| "spec/unit/#{m[1]}_spec.rb" }
+  watch(%r{^lib/chef_backup/(.+)\.rb$}) { |m| "spec/unit/#{m[1]}_spec.rb" }
+  watch(%r{^lib/chef_backup/(.+)/(.+)\.rb$})  { |m| "spec/unit/#{m[1]}/#{m[2]}_spec.rb" }
+  watch(%r{^lib/chef_backup/(.+)/(.+)/(.+)\.rb$})  { |m| "spec/unit/#{m[1]}/#{m[2]}/#{m[3]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+
+notification :tmux

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2014 Chef Software, Inc
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,33 @@
+# ChefBackup
+[![Build Status](https://travis-ci.org/ryancragun/chef_backup.svg?branch=master)](https://travis-ci.org/ryancragun/chef_backup)
+
+A gem that backs up and restores Chef servers.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'chef_backup'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install chef_backup
+
+## Usage
+
+```shell
+chef-server-ctl backup
+chef-server-ctl restore some_backup.tgz
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/ryancragun/chef_backup/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,44 @@
+#!/usr/bin/env rake
+
+require 'rake'
+require 'rspec'
+require 'rspec/core'
+require 'rspec/core/rake_task'
+require 'bundler'
+require 'bundler/gem_tasks'
+require 'rubocop/rake_task'
+
+desc 'Default task to run spec suite'
+task default: %w(spec rubocop)
+
+desc 'Run spec suite'
+RSpec::Core::RakeTask.new(:spec) do |task|
+  task.pattern = FileList['spec/**/*_spec.rb']
+end
+
+desc 'Run RSpec with code coverage'
+task :coverage do
+  ENV['COVERAGE'] = 'true'
+  Rake::Task['spec'].execute
+end
+
+desc 'Run Rubocop style checks'
+RuboCop::RakeTask.new do |cop|
+  cop.fail_on_error = true
+end
+
+desc 'console'
+task :console do
+  require 'pry'
+  require 'chef_backup'
+  require 'json'
+  f = File.expand_path('../spec/fixtures/chef-server-running.json', __FILE__)
+  running_config = JSON.parse(File.read(f))
+  @runner = ChefBackup::Runner.new(
+    running_config.merge('restore_param' => '/tmp/backup.tgz')
+  )
+  ARGV.clear
+  Pry.config.history.should_save = true
+  Pry.config.history.should_load = true
+  Pry.start
+end

data/chef_backup.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'chef_backup/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'chef_backup'
+  spec.version       = ChefBackup::VERSION
+  spec.authors       = ['Ryan Cragun']
+  spec.email         = ['me@ryan.ec']
+  spec.summary       = 'A library to backup an Enterprise Chef server'
+  spec.description   = spec.summary
+  spec.homepage      = 'https://github.com/ryancragun/chef_backup'
+  spec.license       = 'Apachev2'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(/^bin/) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(/^(test|spec|features)/)
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'di-ruby-lvm'
+  spec.add_dependency 'mixlib-shellout'
+  spec.add_dependency 'highline'
+  spec.add_dependency 'chef'
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'guard-rspec'
+  spec.add_development_dependency 'pry-rescue'
+  spec.add_development_dependency 'rubocop', '0.28'
+  spec.add_development_dependency 'simplecov'
+end

data/lib/chef_backup.rb

@@ -0,0 +1,12 @@
+# Copyright:: Copyright (c) 2014 Chef, Inc.
+#
+# All Rights Reserved
+
+require 'chef_backup/version'
+require 'chef_backup/exceptions'
+require 'chef_backup/config'
+require 'chef_backup/logger'
+require 'chef_backup/data_map'
+require 'chef_backup/helpers'
+require 'chef_backup/runner'
+require 'chef_backup/strategy'

data/lib/chef_backup/config.rb

@@ -0,0 +1,57 @@
+require 'fileutils'
+require 'json'
+require 'forwardable'
+
+module ChefBackup
+  # ChefBackup Global Config
+  class Config
+    extend Forwardable
+
+    DEFAULT_CONFIG = {
+      'backup' => {
+        'always_dump_db' => true,
+        'strategy' => 'none',
+        'export_dir' => '/var/opt/chef-backup'
+      }
+    }.freeze
+
+    class << self
+      def config
+        @config ||= new
+      end
+
+      def config=(hash)
+        @config = new(hash)
+      end
+
+      def [](key)
+        config[key]
+      end
+
+      def []=(key, value)
+        config[key] = value
+      end
+
+      #
+      # @param file [String] path to a JSON configration file
+      #
+      def from_json_file(file)
+        path = File.expand_path(file)
+        @config = new(JSON.parse(File.read(path))) if File.exist?(path)
+      end
+    end
+
+    #
+    # @param config [Hash] a Hash of the private-chef-running.json
+    #
+    def initialize(config = {})
+      config['private_chef'] ||= {}
+      config['private_chef']['backup'] ||= {}
+      config['private_chef']['backup'] =
+        DEFAULT_CONFIG['backup'].merge(config['private_chef']['backup'])
+      @config = config
+    end
+
+    def_delegators :@config, :[], :[]=
+  end
+end

data/lib/chef_backup/data_map.rb

@@ -0,0 +1,44 @@
+require 'time'
+
+module ChefBackup
+  # DataMap class to store data about the data we're backing up
+  class DataMap
+    class << self
+      def data_map
+        @data_map ||= new
+      end
+
+      attr_writer :data_map
+    end
+
+    attr_accessor :strategy, :backup_time, :configs, :services
+
+    def initialize
+      @services = {}
+      @configs = {}
+      yield self if block_given?
+
+      @backup_time ||= Time.now.iso8601
+      @strategy ||= 'none'
+    end
+
+    def add_service(service, data_dir)
+      @services[service] ||= {}
+      @services[service]['data_dir'] = data_dir
+    end
+
+    def add_config(config, path)
+      @configs[config] ||= {}
+      @configs[config]['data_dir'] = path
+    end
+
+    def manifest
+      {
+        'strategy' => strategy,
+        'backup_time' => backup_time,
+        'services' => services,
+        'configs' => configs
+      }
+    end
+  end
+end

data/lib/chef_backup/exceptions.rb

@@ -0,0 +1,12 @@
+module ChefBackup
+  module Exceptions
+    # ChefBackup Exceptions
+    class ChefBackupException < StandardError; end
+    class InvalidTarball < ChefBackupException; end
+    class InvalidSnapshot < ChefBackupException; end
+    class InvalidDatabaseDump < ChefBackupException; end
+    class InvalidManifest < ChefBackupException; end
+    class InvalidStrategy < ChefBackupException; end
+    class NotImplementedError < ChefBackupException; end
+  end
+end

data/lib/chef_backup/helpers.rb

@@ -0,0 +1,159 @@
+require 'fileutils'
+require 'mixlib/shellout'
+require 'chef_backup/config'
+require 'chef_backup/logger'
+
+# rubocop:disable IndentationWidth
+module ChefBackup
+# Common helper methods that are usefull in many classes
+module Helpers
+  # rubocop:enable IndentationWidth
+
+  SERVER_ADD_ONS = %w(
+    opscode-manage
+    opscode-reporting
+    opscode-push-jobs-server
+    opscode-analytics
+    chef-ha
+    chef-sync
+  ).freeze
+
+  def private_chef
+    config['private_chef']
+  end
+
+  def config
+    ChefBackup::Config
+  end
+
+  def log(message, level = :info)
+    ChefBackup::Logger.logger.log(message, level)
+  end
+
+  #
+  # @param file [String] A path to a file on disk
+  # @param exception [Exception] An exception to raise if file is not present
+  # @param message [String] Exception message to raise
+  #
+  # @return [TrueClass, FalseClass]
+  #
+  def ensure_file!(file, exception, message)
+    File.exist?(file) ? true : fail(exception, message)
+  end
+
+  def shell_out(*command)
+    cmd = Mixlib::ShellOut.new(*command)
+    cmd.live_stream ||= $stdout.tty? ? $stdout : nil
+    cmd.run_command
+    cmd
+  end
+
+  def shell_out!(*command)
+    cmd = shell_out(*command)
+    cmd.error!
+    cmd
+  end
+
+  def all_services
+    Dir['/opt/opscode/sv/*'].map { |f| File.basename(f) }.sort
+  end
+
+  def enabled_services
+    all_services.select { |sv| service_enabled?(sv) }
+  end
+
+  def disabled_services
+    all_services.select { |sv| !service_enabled?(sv) }
+  end
+
+  def service_enabled?(service)
+    File.symlink?("/opt/opscode/service/#{service}")
+  end
+
+  def stop_service(service)
+    res = shell_out("chef-server-ctl stop #{service}")
+    res
+  end
+
+  def start_service(service)
+    res = shell_out("chef-server-ctl start #{service}")
+    res
+  end
+
+  def stop_chef_server(params = {})
+    log 'Bringing down the Chef Server'
+    services = enabled_services
+    services -= params[:except].map(&:to_s) if params.key?(:except)
+    services.each { |sv| stop_service(sv) }
+  end
+
+  def start_chef_server
+    log 'Bringing up the Chef Server'
+    enabled_services.each { |sv| start_service(sv) }
+  end
+
+  def enabled_addons
+    SERVER_ADD_ONS.select { |service| addon?(service) }
+  end
+
+  def addon?(service)
+    File.directory?("/etc/#{service}")
+  end
+
+  def pg_dump?
+    if frontend? # don't dump postgres on frontends
+      false
+    elsif private_chef['backup']['always_dump_db'] == true # defaults to true
+      true
+    elsif strategy !~ /lvm|ebs/ && backend? # backup non-block device backends
+      true
+    else
+      false # if we made it here then we're on lvm/ebs and overrode defaults
+    end
+  end
+
+  def strategy
+    private_chef['backup']['strategy']
+  end
+
+  def frontend?
+    private_chef['role'] == 'frontend'
+  end
+
+  def backend?
+    private_chef['role'] =~  /backend|standalone/
+  end
+
+  def online?
+    private_chef['backup']['mode'] == 'online'
+  end
+
+  def tmp_dir
+    @tmp_dir ||= begin
+      dir = safe_key { config['tmp_dir'] } ||
+            safe_key { private_chef['backup']['tmp_dir'] }
+      if dir
+        FileUtils.mkdir_p(dir) unless File.directory?(dir)
+        dir
+      else
+        Dir.mktmpdir('chef_backup')
+      end
+    end
+  end
+
+  def cleanup
+    log "Cleaning up #{tmp_dir}"
+    FileUtils.rm_r(tmp_dir)
+  rescue Errno::ENOENT
+    true
+  end
+
+  private
+
+  def safe_key
+    yield
+  rescue NameError
+    nil
+  end
+end
+end