muck 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 03519690f84db0eeed8308449dfd2bcfb534578a
+  data.tar.gz: ccaabeea5580e22e8571005ed3ec0d3c6d016d26
+SHA512:
+  metadata.gz: 9dc93af8f0d95b9c2f58c0078fd672f3a5597c33cc3effdbd593ca48da97f8c32ac02176ec0a53430a83af6712996856d6089ee8f12c73a95566efeb42b3626e
+  data.tar.gz: 3fab96b321b514c56949f9d3d10f47db9b24bacba46df73028f01fa3ccb719726c5e9981d32af8a6c2746ee90aeb510cff7654232a97de64c2d946192d4091fc

data/Gemfile

@@ -0,0 +1,2 @@
+source "https://rubygems.org"
+gemspec

data/Gemfile.lock

@@ -0,0 +1,19 @@
+PATH
+  remote: .
+  specs:
+    muck (1.0.0)
+      net-ssh (>= 3.2, < 4.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    net-ssh (3.2.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  muck!
+
+BUNDLED WITH
+   1.13.0

data/MIT-LICENCE

@@ -0,0 +1,20 @@
+Copyright 2016 Adam Cooke.
+
+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.

data/README.md

@@ -0,0 +1,122 @@
+# Muck
+
+Muck is a tool which will backup & store MySQL dump files from remote hosts. Through a simple configuration file, you can add hosts & databaes which you wish to be backed up and Muck will connect to those hosts over SSH, grab a dump file using `mysqldump`, gzip it and store it away on its own server.
+
+* Connect to any number of servers and backup any number of databases on each server.
+* Archive backups to ensure you retain historical backups.
+* Tidies up after itself.
+* Secure because we connect over SSH before connecting to the database.
+* Runs as a service or in a cron.
+
+## Requirements
+
+* Ruby 2.3 or higher
+
+## Installation
+
+```
+sudo gem install muck
+```
+
+We recommend taht you create a user which will run your Muck services.
+
+```
+sudo useradd -r -m -d /opt/muck muck
+```
+
+You'll need to make directories for configuration and storage.
+
+```
+sudo -u muck mkdir /opt/muck/config
+sudo -u muck mkdir /opt/muck/storage
+```
+
+Finally, you'll need to generate an SSH key pair which will be used for authenticating your requests to the servers you wish to backup. Password authentication is not supported in Muck.
+
+```
+sudo -u muck ssh-keygen -f /opt/muck/ssh-key
+# Follow the instructions to generate a keypair. Do not add a passphrase.
+```
+
+## Configuration
+
+We recommend storing your muck configuration in `/opt/muck/config`. You should add a single file for each server you wish to backup. This is a full example file which includes all configuration options which are available. Sensible defaults are set too so most options can be skipped. The values in the example below are the current defaults.
+
+```ruby
+server do
+  # The hostname of the server you wish to backup. Used to connect with SSH and
+  # the name of the directory used for storing the backups.
+  hostname "myserver.example.com"
+
+  # How often you wish to take a backup (in minutes)
+  frequency 60
+
+  ssh do
+    # The user that should connect to the server with SSH
+    username 'root'
+    # The SSH port
+    port 22
+    # The path to the SSH key that you will authenticate with
+    key "/opt/muck/ssh-key"
+  end
+
+  storage do
+    # Specifies the directory that backups will be stored for this server. You
+    # can use :hostname to insert the name of the hostname automatically and
+    # :database to insert the database name.
+    path "/opt/muck/data/:hostname/:database"
+    # The number of "master" bacups which should be kept before being archived.
+    keep 50
+  end
+
+  retention do
+    # How many hourly backups do you wish to keep?
+    hourly 24
+    # How many daily backups do you wish to keep?
+    daily 7
+    # How many monthly backups do you wish to keep?
+    monthly 12
+    # How many yearly backups do you wish to keep
+    yearly 8
+  end
+
+  database do
+    # The name of the database
+    name "example"
+    # The hostname (as accessed from the server) to connect to
+    hostname "127.0.0.1"
+    # The username to authenticate to MySQL with
+    username "root"
+    # The password to authenticate to MySQL with
+    password nil
+  end
+
+  # The database block above can be repeated within the context of the server
+  # to backup multiple databases from the same server.
+
+end
+```
+
+## Running Backups
+
+The `muck` command line tool can be used in two ways.
+
+* `muck start` - this will run constantly (and can be backgrounded to turned into a service as appropriate). It will respect the `frequency` option specified for a server and back all servers up whenever they are due for a backup.
+* `muck run` - this will take a backup from all servers & database and exit when complete.
+
+Both ways will send all log output to STDOUT.
+
+## Data
+
+The data directory will populate itself as follows:
+
+* `data/master` - this stores each raw backup as it is downloaded (gzipped)
+* `data/hourly` - this stores the hourly backups
+* `data/daily` - this stores the daily backups
+* `data/monthly` - this stores the monthly backups
+* `data/yearly` - this stores the yearly backups
+* `data/manifest.yml` - this stores a list of each master backup with a timestamp and a size
+
+## Changing the defaults
+
+If you wish to change the global defaults, you can create a file in your config directory which includes a `defaults` block. This is the same as the `server` block shown above however the word `server` on the first line should be replaced with `defaults`. Any values you add to the defaults block will be used instead of the system defaults.

data/bin/muck

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+$:.push File.expand_path("../../lib", __FILE__)
+
+config_file_path = ENV['MUCK_CONFIG_PATH'] || File.expand_path('/opt/muck/config')
+
+require 'muck/config'
+require 'muck/logging'
+
+config = Muck::Config.new(config_file_path)
+
+begin
+  case ARGV[0]
+  when 'run'
+    config.run(:force => true)
+  when 'start'
+    $running = false
+    Signal.trap("INT")  { $exit = true; $running ? nil : exit(0) }
+    Signal.trap("TERM") { $exit = true; $running ? nil : exit(0) }
+    Muck.logger.info "\e[32mStarted Muck\e[0m"
+    loop do
+      $running = true
+      config.run
+      $running = false
+      $exit ? exit(0) : sleep(30)
+    end
+  else
+    puts "usage: #{$0} [command]"
+  end
+rescue Muck::Error => e
+  puts "\e[31mError: #{e.message}\e[0m"
+end

data/lib/muck/archive.rb

@@ -0,0 +1,70 @@
+require 'muck/logging'
+require 'muck/utils'
+require 'fileutils'
+
+module Muck
+  class Archive
+
+    include Muck::Logging
+    include Muck::Utils
+
+    MAPPING = {
+      :hourly => 'YYYY-mm-dd-HH',
+      :daily => "YYYY-mm-dd",
+      :monthly => 'YYYY-mm',
+      :yearly => 'YYYY'
+    }
+
+    def initialize(database, name, maximum)
+      @database = database
+      @name = name
+      @maximum = maximum
+    end
+
+    def export_path
+      File.join(@database.export_path, @name.to_s)
+    end
+
+    def run
+      if last_backup = @database.manifest[:backups].last
+        create_archive(last_backup)
+        tidy
+      else
+        log.info "There is no backup to archive"
+      end
+    end
+
+    def create_archive(backup)
+      logger.info "Archiving #{blue @name} backup for #{blue @database.name} on #{blue @database.server.hostname}"
+      logger.info "Using backup from #{blue backup[:path]}"
+      filename = filename_for(backup[:path])
+      archive_path = File.join(export_path, filename)
+      FileUtils.mkdir_p(File.dirname(archive_path))
+      if system("ln -f #{backup[:path]} #{archive_path}")
+        logger.info "Successfully stored archive at #{green archive_path}"
+      else
+        logger.error red("Couldn't store archive at #{archive_path}")
+      end
+    end
+
+    def tidy
+      files = Dir[File.join(export_path, '*')].sort.reverse.drop(@maximum)
+      files.each do |file|
+        if system("rm #{file}")
+          logger.info "Tidied #{green file}"
+        else
+          logger.error red("Couldn't remove un-retained file at #{file}")
+        end
+      end
+    end
+
+    private
+
+    def filename_for(path)
+      name, extensions = path.split('/').last.split('.', 2)
+      size = MAPPING[@name.to_sym].size
+      name[0,size] + ".#{extensions}"
+    end
+
+  end
+end

data/lib/muck/backup.rb

@@ -0,0 +1,101 @@
+require 'muck/logging'
+require 'muck/utils'
+require 'fileutils'
+
+module Muck
+  class Backup
+
+    include Muck::Logging
+    include Muck::Utils
+
+    def initialize(database)
+      @database = database
+      @time = Time.now
+    end
+
+    def export_path
+      @export_path ||= File.join(@database.export_path, "master", @time.strftime("%Y-%m-%d-%H-%M-%S.sql"))
+    end
+
+    def run
+      logger.info "Backing up #{blue @database.name} from #{blue @database.server.hostname}"
+      take_backup
+      compress
+      store_in_manifest
+      tidy_masters
+    end
+
+    def take_backup
+      logger.info "Connecting to #{blue @database.server.ssh_username}@#{blue @database.server.hostname}:#{blue @database.server.ssh_port}"
+      FileUtils.mkdir_p(File.dirname(self.export_path))
+      file = File.open(export_path, 'w')
+      ssh_session = @database.server.create_ssh_session
+      channel = ssh_session.open_channel do |channel|
+        logger.debug "Running: #{@database.dump_command}"
+        channel.exec(@database.dump_command) do |channel, success|
+          raise Error, "Could not execute dump command" unless success
+          channel.on_data do |c, data|
+            file.write(data)
+          end
+
+          channel.on_extended_data do |c, _, data|
+            logger.debug red(data.gsub(/[\r\n]/, ''))
+          end
+
+          channel.on_request("exit-status") do |_, data|
+            exit_code = data.read_long
+            if exit_code != 0
+              logger.debug "Exit status was #{exit_code}"
+              raise Error, "mysqldump returned an error when executing."
+            end
+          end
+        end
+      end
+      channel.wait
+      ssh_session.close
+      file.close
+      logger.info "Successfully backed up to #{green export_path}"
+    end
+
+    def store_in_manifest
+      if File.exist?(export_path)
+        details = {:timestamp => @time.to_i, :path => export_path, :size => File.size(export_path)}
+        @database.manifest[:backups] << details
+        @database.save_manifest
+      else
+        raise Error, "Couldn't store backup in manifest because it doesn't exist at #{export_path}"
+      end
+    end
+
+    def compress
+      if File.exist?(export_path)
+        if system("gzip #{export_path}")
+          @export_path = @export_path + ".gz"
+          logger.info "Compressed #{blue export_path} with gzip"
+        else
+          logger.warn "Couldn't compress #{export_path} with gzip"
+        end
+      else
+        raise Error, "Couldn't compress backup because it doesn't exist at #{export_path}"
+      end
+    end
+
+    def tidy_masters
+      files = Dir[File.join(@database.export_path, 'master', '*')].sort.reverse.drop(@database.server.masters_to_keep)
+      unless files.empty?
+        logger.info "Tidying master backup files. Keeping #{@database.server.masters_to_keep} back."
+        files.each do |file|
+          if system("rm #{file}")
+            @database.manifest[:backups].delete_if { |b| b[:path] == file }
+            logger.info "-> Removed #{green file}"
+          else
+            logger.error red("-> Couldn't remove unwanted master file at #{file}")
+          end
+        end
+      end
+    ensure
+      @database.save_manifest
+    end
+
+  end
+end

data/lib/muck/config.rb

@@ -0,0 +1,43 @@
+require 'muck/error'
+require 'muck/config_dsl/root_dsl'
+
+module Muck
+  class Config
+
+    def initialize(directory)
+      @directory = directory
+      @defaults = {}
+      @servers = []
+      parse
+    end
+
+    attr_reader :defaults
+    attr_reader :servers
+
+    def run(options = {})
+      servers.each do |server|
+        server.databases.each do |database|
+          if database.backup_now? || options[:force]
+            database.backup
+            database.archive_all
+          end
+        end
+      end
+    end
+
+    private
+
+    def parse
+      unless File.directory?(@directory)
+        raise Muck::Error, "#{@directory} is not a directory"
+      end
+
+      root_dsl = ConfigDSL::RootDSL.new(self)
+      files = Dir[File.join(@directory, "**", "*.rb")]
+      files.each do |file|
+        root_dsl.instance_eval(File.read(file), file)
+      end
+    end
+
+  end
+end

data/lib/muck/config_dsl/database_dsl.rb

@@ -0,0 +1,27 @@
+module Muck
+  module ConfigDSL
+    class DatabaseDSL
+
+      def initialize(hash)
+        @hash = hash
+      end
+
+      def name(name)
+        @hash[:name] = name
+      end
+
+      def hostname(hostname)
+        @hash[:hostname] = hostname
+      end
+
+      def username(username)
+        @hash[:username] = username
+      end
+
+      def password(password)
+        @hash[:password] = password
+      end
+
+    end
+  end
+end

data/lib/muck/config_dsl/retention_dsl.rb

@@ -0,0 +1,27 @@
+module Muck
+  module ConfigDSL
+    class RetentionDSL
+
+      def initialize(hash)
+        @hash = hash
+      end
+
+      def hourly(hourly)
+        @hash[:hourly] = hourly
+      end
+
+      def daily(daily)
+        @hash[:daily] = daily
+      end
+
+      def monthly(monthly)
+        @hash[:monthly] = monthly
+      end
+
+      def yearly(yearly)
+        @hash[:yearly] = yearly
+      end
+
+    end
+  end
+end

data/lib/muck/config_dsl/root_dsl.rb

@@ -0,0 +1,25 @@
+require 'muck/config_dsl/server_dsl'
+require 'muck/server'
+module Muck
+  module ConfigDSL
+    class RootDSL
+
+      def initialize(config)
+        @config = config
+      end
+
+      def server(&block)
+        hash = Hash.new
+        dsl = ServerDSL.new(hash)
+        dsl.instance_eval(&block)
+        @config.servers << Server.new(@config, hash)
+      end
+
+      def defaults(&block)
+        dsl = ServerDSL.new(@config.defaults)
+        dsl.instance_eval(&block)
+      end
+
+    end
+  end
+end

data/lib/muck/config_dsl/server_dsl.rb

@@ -0,0 +1,47 @@
+require 'muck/config_dsl/ssh_dsl'
+require 'muck/config_dsl/storage_dsl'
+require 'muck/config_dsl/retention_dsl'
+require 'muck/config_dsl/database_dsl'
+
+module Muck
+  module ConfigDSL
+    class ServerDSL
+
+      def initialize(hash)
+        @hash = hash
+      end
+
+      def hostname(hostname)
+        @hash[:hostname] = hostname
+      end
+
+      def frequency(frequency)
+        @hash[:frequency] = frequency
+      end
+
+      def ssh(&block)
+        dsl = SSHDSL.new(@hash[:ssh] = Hash.new)
+        dsl.instance_eval(&block)
+      end
+
+      def storage(&block)
+        dsl = StorageDSL.new(@hash[:storage] = Hash.new)
+        dsl.instance_eval(&block)
+      end
+
+      def retention(&block)
+        dsl = RetentionDSL.new(@hash[:retention] = Hash.new)
+        dsl.instance_eval(&block)
+      end
+
+      def database(&block)
+        hash = {}
+        dsl = DatabaseDSL.new(hash)
+        dsl.instance_eval(&block)
+        @hash[:databases] ||= []
+        @hash[:databases] << hash
+      end
+
+    end
+  end
+end

data/lib/muck/config_dsl/ssh_dsl.rb

@@ -0,0 +1,23 @@
+module Muck
+  module ConfigDSL
+    class SSHDSL
+
+      def initialize(hash)
+        @hash = hash
+      end
+
+      def port(port)
+        @hash[:port] = port
+      end
+
+      def key(key)
+        @hash[:key] = key
+      end
+
+      def username(username)
+        @hash[:username] = username
+      end
+
+    end
+  end
+end

data/lib/muck/config_dsl/storage_dsl.rb

@@ -0,0 +1,19 @@
+module Muck
+  module ConfigDSL
+    class StorageDSL
+
+      def initialize(hash)
+        @hash = hash
+      end
+
+      def path(path)
+        @hash[:path] = path
+      end
+
+      def keep(keep)
+        @hash[:keep] = keep
+      end
+
+    end
+  end
+end

data/lib/muck/database.rb

@@ -0,0 +1,77 @@
+require 'muck/archive'
+require 'muck/backup'
+require 'yaml'
+
+module Muck
+  class Database
+
+    def initialize(server, properties)
+      @server = server
+      @properties = properties
+    end
+
+    def name
+      @properties[:name]
+    end
+
+    def hostname
+      @properties[:hostname]
+    end
+
+    def username
+      @properties[:username]
+    end
+
+    def password
+      @properties[:password]
+    end
+
+    def server
+      @server
+    end
+
+    def export_path
+      @export_path ||= server.export_path.gsub(':database', self.name)
+    end
+
+    def archive_all
+      @server.retention.each do |name, maximum|
+        Muck::Archive.new(self, name, maximum).run
+      end
+    end
+
+    def backup
+      Muck::Backup.new(self).run
+    end
+
+    def manifest_path
+      File.join(export_path, 'manifest.yml')
+    end
+
+    def manifest
+      @manifest ||= File.exist?(manifest_path) ? YAML.load_file(manifest_path) : {:backups => []}
+    end
+
+    def save_manifest
+      File.open(manifest_path, 'w') { |f| f.write(manifest.to_yaml) }
+    end
+
+    def dump_command
+      password_opt = password ? "-p#{password}" : ""
+      "mysqldump -q --single-transaction -h #{hostname} -u #{username} #{password_opt} #{name}"
+    end
+
+    def last_backup_at
+      if last_backup = manifest[:backups].last
+        Time.at(last_backup[:timestamp])
+      else
+        nil
+      end
+    end
+
+    def backup_now?
+      last_backup_at.nil? || last_backup_at <= Time.now - (@server.frequency * 60)
+    end
+
+  end
+end

data/lib/muck/error.rb

@@ -0,0 +1,4 @@
+module Muck
+  class Error < StandardError
+  end
+end

data/lib/muck/logging.rb

@@ -0,0 +1,20 @@
+require 'logger'
+
+module Muck
+
+  def self.logger
+    @logger ||= Logger.new(STDOUT)
+  end
+
+  module Logging
+
+    def logger
+      Muck.logger
+    end
+
+    def log(text)
+      logger.info(text)
+    end
+
+  end
+end

data/lib/muck/server.rb

@@ -0,0 +1,68 @@
+require 'muck/database'
+require 'net/ssh'
+
+module Muck
+  class Server
+
+    DEFAULT_RENTENTION = {:hourly => 24, :daily => 7, :monthly => 12, :yearly => 8}
+    DEFAULT_SSH_PROPERTIES = {:username => "root", :port => 22, :key => "/opt/muck/ssh-key"}
+    DEFAULT_DATABASE_PROPERTIES = {:hostname => '127.0.0.1', :username => 'root', :name => 'example', :password => nil}
+
+    def initialize(config, server_hash = {})
+      @config = config
+      @server_hash = server_hash
+    end
+
+    def hostname
+      @server_hash[:hostname]
+    end
+
+    def frequency
+      @server_hash[:frequency] || @config.defaults[:frequency] || 60
+    end
+
+    def export_path
+      if path = (@server_hash.dig(:storage, :path) || @config.defaults.dig(:storage, :path))
+        path.gsub(":hostname", self.hostname)
+      else
+        "/opt/muck/data/#{self.hostname}/:database"
+      end
+    end
+
+    def masters_to_keep
+      @server_hash.dig(:storage, :keep) || @config.defaults.dig(:storage, :keep) || 50
+    end
+
+    def ssh_port
+      ssh_properties[:port]
+    end
+
+    def ssh_username
+      ssh_properties[:username]
+    end
+
+    def ssh_properties
+      DEFAULT_SSH_PROPERTIES.merge(@config.defaults[:ssh] || {}).merge(@server_hash[:ssh] || {})
+    end
+
+    def retention
+      DEFAULT_RENTENTION.merge(@config.defaults[:retention] || {}).merge(@server_hash[:retention] || {})
+    end
+
+    def databases
+      defaults =  DEFAULT_DATABASE_PROPERTIES.merge(@config.defaults[:databases]&.first || {})
+      if @server_hash[:databases].is_a?(Array)
+        @server_hash[:databases].map do |database|
+          Database.new(self, defaults.merge(database))
+        end
+      else
+        []
+      end
+    end
+
+    def create_ssh_session
+      Net::SSH.start(self.hostname, self.ssh_username, :port => self.ssh_port, :keys => ssh_properties[:key] ? [ssh_properties[:key]] : nil)
+    end
+
+  end
+end

data/lib/muck/utils.rb

@@ -0,0 +1,25 @@
+module Muck
+  module Utils
+
+    def red(text)
+      "\e[31m#{text}\e[0m"
+    end
+
+    def green(text)
+      "\e[32m#{text}\e[0m"
+    end
+
+    def yellow(text)
+      "\e[33m#{text}\e[0m"
+    end
+
+    def blue(text)
+      "\e[34m#{text}\e[0m"
+    end
+
+    def pink(text)
+      "\e[35m#{text}\e[0m"
+    end
+
+  end
+end

data/lib/muck/version.rb

@@ -0,0 +1,3 @@
+module Muck
+  VERSION = '1.0.0'
+end

data/muck.gemspec

@@ -0,0 +1,18 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+require "muck/version"
+
+Gem::Specification.new do |s|
+  s.name        = "muck"
+  s.version     = Muck::VERSION
+  s.authors     = ["Adam Cooke"]
+  s.email       = ["adam@atechmedia.com"]
+  s.homepage    = "http://adamcooke.io"
+  s.licenses    = ['MIT']
+  s.summary     = "A tool to handle the backup & storage of remote MySQL databases."
+  s.description = "This tool will automatically backup & store MySQL dump files from remote servers."
+  s.files = Dir["**/*"]
+  s.bindir = "bin"
+  s.executables << 'muck'
+  s.add_dependency "net-ssh", '>= 3.2', '< 4.0'
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: muck
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Adam Cooke
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-09-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: net-ssh
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.2'
+    - - <
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.2'
+    - - <
+      - !ruby/object:Gem::Version
+        version: '4.0'
+description: This tool will automatically backup & store MySQL dump files from remote
+  servers.
+email:
+- adam@atechmedia.com
+executables:
+- muck
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/muck
+- Gemfile
+- Gemfile.lock
+- lib/muck/archive.rb
+- lib/muck/backup.rb
+- lib/muck/config.rb
+- lib/muck/config_dsl/database_dsl.rb
+- lib/muck/config_dsl/retention_dsl.rb
+- lib/muck/config_dsl/root_dsl.rb
+- lib/muck/config_dsl/server_dsl.rb
+- lib/muck/config_dsl/ssh_dsl.rb
+- lib/muck/config_dsl/storage_dsl.rb
+- lib/muck/database.rb
+- lib/muck/error.rb
+- lib/muck/logging.rb
+- lib/muck/server.rb
+- lib/muck/utils.rb
+- lib/muck/version.rb
+- MIT-LICENCE
+- muck.gemspec
+- README.md
+homepage: http://adamcooke.io
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14.1
+signing_key: 
+specification_version: 4
+summary: A tool to handle the backup & storage of remote MySQL databases.
+test_files: []