kellerkind 0.1.2 → 0.2.1

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 1.9.2
+script: bundle exec rspec spec
+services:
+  - mongodb

data/README.md

@@ -1,6 +1,14 @@
 # kellerkind
 
-Kellerkind is just a Ruby script that runs mongodump and tars the resulting dump.
+[![Build Status](https://travis-ci.org/dsci/kellerkind.png?branch=master)](https://travis-ci.org/dsci/kellerkind)
+
+Kellerkind is a Ruby application that runs several backup actions.
+
+|Type | Status| Cli flag
+|:----|-------:|--------:|
+|MongoDB Dumps | Done | ```--type mongodb```|
+|(Log)File Backup | Done | ```--type files ```|
+
 
 It should be used with its cli but it's also possible to use it with its API.
 
@@ -22,12 +30,30 @@ to the arguments you could specify.
 
 **Example**
 
+*Dumping a Mongo database and compressing the dump*
+
 ```
-kellerkind --mongo-db appDatabase --mongo-host linus.mongohq.com --mongo-port 10010 --mongo-username myUser --mongo-password myCrypticPassword --compress true --out $HOME/tmp/mongodump
+kellerkind --type mongodb --mongo-db appDatabase --mongo-host linus.mongohq.com --mongo-port 10010 --mongo-username myUser --mongo-password myCrypticPassword --compress true --out $HOME/tmp/mongodump
 ```
 
 Dumps a database hosted at MongoHQ to <code>$HOME/tmp/mongodump</code> and create a tar file of this dump.
 
+*Backing up several log files*
+
+```
+kellerkind --type log --files $HOME/rails/my_app/log/production.log $HOME/logs/unicorn.stdout.log --out $HOME/tmp/log_backups --verbose true
+```
+
+Backups and compresses ```$HOME/rails/my_app/log/production.log``` and ```$HOME/logs/unicorn.stdout.log``` to ```$HOME/tmp/log_backups```, deletes the original files and recreates them as blank files.
+
+## Tests
+
+Run
+
+```
+rspec spec/
+```
+
 ## Contributing to kellerkind
 
 * Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.

data/VERSION

@@ -1 +1 @@
-0.1.2
+0.2.1

data/bin/kellerkind

@@ -5,15 +5,23 @@ $LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
 require 'kellerkind'
 
 REQUIRED_ARGS = {
-    :mongo_db => %Q{You must specify a mongo database! },
-    :out      => %Q{You must specify a path the dump should saved to! }
-}
+    :mongodb => {
+      :mongo_db => %Q{You must specify a mongo database! },
+      :out      => %Q{You must specify a path the dump should saved to! }
+    },
+    :log  => {
+      :files => %Q{You must specifiy at least one file! }
+    }
+
+  }
+
 
 opts = Trollop::options do
   banner <<-EOS
-    Mongodb archiving tool.
+    Archiving tool.
 
-    Dumps mongodb databases and archives them. Nothing more. Neat, isn't it?
+    Dumps mongodb databases and archives them. Compresses files and archives
+    them. Nothing more. Neat, isn't it?
   EOS
 
   opt :mongo_db,        "mongo database to dump",         :type => :string
@@ -23,15 +31,38 @@ opts = Trollop::options do
   opt :mongo_password,  "mongo password",                 :type => :string
   opt :mongo_port,      "mongo server port",              :type => :string,
                                                           :default => "27017"
-  opt :out,             "path to dump to",                :type => :string
-  opt :compress,        "use gzip compression?",          :type => :boolean,
-                                                          :default => false
+  opt :out,             "path output directory",                :type => :string
+
+  opt :compress,        "use gzip compression? (files are always gzipped)",
+      :type => :boolean,
+      :default => false
+
   opt :remove_dump,     "remove dump after compression?", :type => :boolean,
                                                           :default => true
+  opt :files,           "files to compress",   :type => :strings
+
+  opt :type,            "the type kellerkind should handles: [mongodbd, log]",
+      :type => :string,
+      :default => "mongodb"
+
+  opt :recreate,        "Recreate files after moving and compressing (only effects :files type)",
+      :type     => :boolean,
+      :default  => true
+
+  opt :verbose,         "Verbose output",
+      :type     => :boolean,
+      :default  => false
 end
 
 REQUIRED_ARGS.each_pair do |key,value|
-  Trollop::die key, value unless opts[key]
+  type        = key
+  type_config = value
+  used_type   = opts[:type]
+  if used_type.eql?(type.to_s)
+    type_config.each_pair do |type_key, type_value|
+      Trollop::die type_key, type_value unless opts[type_key]
+    end
+  end
 end
 
 Kellerkind::Runner.exec(opts)

data/kellerkind.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "kellerkind"
-  s.version = "0.1.2"
+  s.version = "0.2.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Daniel Schmidt"]
-  s.date = "2013-07-08"
+  s.date = "2013-11-18"
   s.description = "Dumps mongodb databases and archives them."
   s.email = "dsci@code79.net"
   s.executables = ["kellerkind"]
@@ -20,8 +20,8 @@ Gem::Specification.new do |s|
   s.files = [
     ".document",
     ".rspec",
+    ".travis.yml",
     "Gemfile",
-    "Gemfile.lock",
     "LICENSE.txt",
     "README.md",
     "Rakefile",
@@ -32,18 +32,24 @@ Gem::Specification.new do |s|
     "lib/kellerkind/core/configuration.rb",
     "lib/kellerkind/core/ext.rb",
     "lib/kellerkind/core/set.rb",
-    "lib/kellerkind/database/mongo.rb",
     "lib/kellerkind/dependencies.rb",
+    "lib/kellerkind/modules/implementations/log_file.rb",
+    "lib/kellerkind/modules/implementations/mongo.rb",
+    "lib/kellerkind/modules/log.rb",
+    "lib/kellerkind/modules/modules.rb",
+    "lib/kellerkind/modules/mongodb.rb",
     "lib/kellerkind/system/compress.rb",
     "lib/kellerkind/system/die.rb",
     "lib/kellerkind/system/lock.rb",
+    "lib/kellerkind/system/process.rb",
     "lib/kellerkind/system/runner.rb",
     "spec/fixtures/mongodb.js",
-    "spec/kellerkind/database/mongo_spec.rb",
+    "spec/kellerkind/modules/implementations/log_file_spec.rb",
+    "spec/kellerkind/modules/implementations/mongo_spec.rb",
+    "spec/kellerkind/modules/mongodb_spec.rb",
     "spec/kellerkind/system/compress_spec.rb",
     "spec/kellerkind/system/lock_spec.rb",
     "spec/kellerkind/tmp/.gitkeep",
-    "spec/kellerkind_spec.rb",
     "spec/spec_helper.rb"
   ]
   s.homepage = "http://github.com/dsci/kellerkind"

data/lib/kellerkind/core/configuration.rb

@@ -1,28 +1,28 @@
 module Kellerkind
-
-  # Public: Various methods useful for configure Kellerkind.
+
+  # Public: Various methods useful for configure Kellerkind.
   module Config
     extend self
 
-
+
     # Public: Gets the prefix that is use in the cli for database options.
-    #
+    #
     # Returns a regular expression.
     def db_prefix
       /mongo_/
     end
 
-
+
     # Public: Gets the name of the command line executable to use for
-    # dumping.
-    #
+    # dumping.
+    #
     # Returns name of executable as String.
     def db_dump_cmd
       "mongodump"
     end
 
-
-    # Public: Gets the path to the lock dir to mark process running.
+
+    # Public: Gets the path to the lock dir to mark process running.
     # Note that just one kellerkind process is runnable.
     def lock_dir
       File.join(Dir.home, "tmp")
@@ -60,5 +60,17 @@ module Kellerkind
       %Q{ -- Dumping of #{database} done ...}
     end
 
+    # Internal: Sets if Kellerkind should be talkative or not.
+    #
+    # flag - Boolean, true if Kellerkind should generate output, false if not.
+    def verbose_output=(flag)
+      @verbose_output = flag
+    end
+
+    # Internal: Checks if Kellerkind should be verbose or not.
+    def verbose?
+      @verbose_output
+    end
+
   end
-end
+end

data/lib/kellerkind/core/set.rb

@@ -1,16 +1,5 @@
 module Kellerkind
   class Set
     include Virtus
-
-    protected
-
-    def init_instance(options)
-      options.each_pair do |key,value|
-        instance_attr = key.to_s.split(Kellerkind::Config.db_prefix).last
-        if instance_attr.to_sym.in?(attributes.keys)
-          self.send("#{instance_attr}=", value)
-        end
-      end
-    end
   end
 end

data/lib/kellerkind/dependencies.rb

@@ -4,6 +4,7 @@
     system/lock
     system/compress
     system/die
-    database/mongo
+    system/process
+    modules/modules
     system/runner
   }.each{ |code| require_relative code }

data/lib/kellerkind/modules/implementations/log_file.rb

@@ -0,0 +1,44 @@
+require 'pathname'
+
+module Kellerkind
+
+  # Public: Compresses/Backups a bunch of files.
+  # All methods are module methods and should be called on the Math module.
+  #
+  class LogFile < Set
+
+    # A list of files (at least one)
+    attribute :files,     Array
+    # File path location for compressed backups
+    attribute :out,       String
+    # Indicator if list of files should be recreated after compressing as
+    # blank file.
+    attribute :recreate,  Boolean
+
+    # Public: Compresses the backup, removes the files and (optional) recreates
+    # them as blank files.
+    def archive
+      files.each do |path|
+        path_obj  = Pathname.new(path)
+        path_name = path_obj.dirname.to_s
+        compress  = Kellerkind::Compress.new(:target_path => out,
+                                             :source_path => path,
+                                             :tarball_prefix => path_obj.basename.to_s)
+        compress.find_at_source_path = true
+        if File.exists?(path)
+          Kellerkind::Process.verbose(:start_compressing)
+          compress.gzip
+          if File.exists?("#{path_name}/#{compress.tarball_name}")
+            Kellerkind::Process.verbose(:finished_compressing)
+            FileUtils.mv("#{path_name}/#{compress.tarball_name}",
+                       "#{out}/#{compress.tarball_name}")
+            FileUtils.rm_rf(path)
+            FileUtils.touch(path) if self.recreate
+          end
+        end
+      end
+    end
+
+  end
+
+end

data/lib/kellerkind/{database → modules/implementations}/mongo.rb

@@ -1,6 +1,6 @@
 module Kellerkind
-
-  # Public: Dumps a MongoDb database.
+
+  # Public: Dumps a MongoDb database.
   #
   # For more see mongodump --help
   class Mongo < Set
@@ -22,20 +22,20 @@ module Kellerkind
       init_instance(options) unless options.empty?
     end
 
-
+
     # Public: Dumps the database by using a stream to the underlying
-    # operation system.
-    #
+    # operation system.
+    #
     def dump_database
       cmd = %Q{`which #{Kellerkind::Config.db_dump_cmd}` #{dump_argument_list}}
       out = IO.popen(cmd)
       out.readlines.join(" ")
     end
 
-
+
     # Public: Builds an argument list for mongodump by taking only values
     # existing in #attributes
-    #
+    #
     # Returns the argument list string.
     def dump_argument_list
       usable_line_args = attributes.select{|k,v| not v.nil? }

data/lib/kellerkind/modules/log.rb

@@ -0,0 +1,25 @@
+module Kellerkind
+
+  # Public: (Log)File Kellerkind module that compresses a bunch of files,
+  # removes and recreates blank files of them.
+  class Log
+
+    # Public: Starts compressing a bunch of logfiles, removes and recreates
+    # blank files of them - if --recreate is true.
+    #
+    # options={} - An options Hash to refine log file process.
+    #              :paths     - A list fo file paths that should be compressed
+    #                           and moved.
+    #              :out       - The path the files should be moved to
+    #              :recreate  - Indictator if the files should be renewed as
+    #                           blank file after compressing.
+    #
+    # Returns the duplicated String.
+    def self.exec(options={})
+      Kellerkind::Process.locked?
+      Kellerkind::Process.lock
+      LogFile.new(options).archive
+      Kellerkind::Process.unlock
+    end
+  end
+end

data/lib/kellerkind/modules/modules.rb

@@ -0,0 +1,3 @@
+Dir[File.expand_path(File.join(File.dirname(__FILE__), '**','*.rb'))].each do |file|
+  require file unless file.match(/modules.rb/)
+end

data/lib/kellerkind/modules/mongodb.rb

@@ -0,0 +1,46 @@
+module Kellerkind
+
+  # Public: MongoDB Kellerkind module that dumps a MongoDB database and
+  # compresses it into a tarball (if --compress is true).
+  class Mongodb
+
+    # Public: Starts dumping and compressing the MongoDB database specified in
+    # options.
+    #
+    # options - A Hash to refine the dumping and compressing process
+    #           :out - The target directory the (compressed) dump is saved to
+    #           :mongo_db - The MongoDB database
+    #           :compress - Compress the dump [true|false]
+    #           :remove_dump - Remove the dump after compressing it
+    #
+    def self.exec(options)
+      Kellerkind::Process.locked?
+      Kellerkind::Process.lock
+      mongo = Mongo.new(options)
+      Kellerkind::Process.verbose(:start_dumping)
+      mongo.dump_database
+      if options[:compress]
+        compress = Compress.new(:source_path => options[:out],
+                                :target_path => options[:out],
+                                :tarball_prefix =>options[:mongo_db])
+        if File.exists?(File.join(options[:out], options[:mongo_db]))
+          Kellerkind::Process.verbose(:start_compressing)
+          compress.gzip
+          if compress.succeeded?
+            Kellerkind::Process.verbose(:finished_compressing)
+            if options[:remove_dump]
+              Kellerkind::Process.verbose(:remove_dump)
+              FileUtils.rm_rf(File.join(options[:out],mongo.db))
+            end
+          end
+        else
+          Kellerkind::Process.unlock
+          die(DUMP_NOT_SUCCEEDED_WARNING)
+        end
+      end
+
+      Kellerkind::Process.unlock
+      Kellerkind::Process.verbose(:finished_dumping, mongo.db)
+    end
+  end
+end

data/lib/kellerkind/system/compress.rb

@@ -2,57 +2,83 @@ require 'zlib'
 require 'archive/tar/minitar'
 
 module Kellerkind
-
-  # Public: Compresses a mongodb dump directory by using Gzip and tar.
+
+  # Public: Compresses a mongodb dump directory by using Gzip and tar.
   class Compress < Set
 
     include Archive::Tar
 
     # Path where dump is located (parent direcotry of the dump)
-    attribute :path,          String
+#    attribute :path,          String
     # Database name which equals the dumps directory name
-    attribute :database_name, String
+ #   attribute :database_name, String
+
+    attribute :target_path,     String
+    attribute :source_path,     String
+    attribute :tarball_prefix,  String
+
+    # Public: Duplicate some text an arbitrary number of times.
+    #
+    # Returns the duplicated String.
+    def find_at_source_path
+      @find_at_source_path ||= false
+    end
 
-
-    # Public: Initialises compressing of the dumps directory.
+    # Public: Duplicate some text an arbitrary number of times.
+    #
+    # flag -
+    #
+    # Returns the duplicated String.
+    def find_at_source_path=(flag)
+      @find_at_source_path = flag
+    end
+
+    # Public: Initialises compressing of the dumps directory.
     def gzip
       traverse_and_gzip
     end
 
-
-    # Public: Checks if tar file exists.
-    #
+    # Public: Checks if tar file exists.
+    #
     # If tar file exists we assume compressing succeeds
     #
     # Returns true if file exists otherwise false.
     def succeeded?
-      File.exists?(File.join(self.path, @actual_tar_name))
+      File.exists?(File.join(self.target_path, @actual_tar_name))
+    end
+
+    def tarball_name
+      "#{self.tarball_prefix}_#{Time.now.to_i}.tar.gz"
     end
 
     private
 
     def traverse_and_gzip
-      Dir.chdir(self.path) do
-        Find.find(self.database_name).each do |file|
-          if File.directory?(file)
-            tgz = Zlib::GzipWriter.new(db_dump_gz_file)
-            Minitar.pack(file, tgz)
-          end
-        end
+      Find.find(self.source_path).each do |file|
+        tgz = Zlib::GzipWriter.new(db_dump_gz_file)
+        Minitar.pack(file, tgz)
       end
     end
 
-    def tarball_name
-      "#{self.database_name}_#{Time.now.to_i}.tar.gz"
-    end
-
     def db_dump_gz_file
       File.open(tar_location, 'wb')
     end
 
     def tar_location
       @actual_tar_name = tarball_name
-      File.join(self.path, @actual_tar_name)
+      File.join(define_lookup_path, @actual_tar_name)
+    end
+
+    def define_lookup_path
+      if find_at_source_path
+        if File.directory?(self.source_path)
+          self.source_path
+        else
+          File.dirname(self.source_path)
+        end
+      else
+        self.target_path
+      end
     end
 
   end

data/lib/kellerkind/system/process.rb

@@ -0,0 +1,70 @@
+module Kellerkind
+  module Process
+    extend Die
+
+    class Output
+      def self.outputs
+        {
+          :start_dumping => lambda do
+            puts Kellerkind::Config.start_dumping
+          end,
+          :start_compressing => lambda do
+            puts Kellerkind::Config.start_compressing
+          end,
+          :finished_compressing => lambda do
+            puts Kellerkind::Config.finished_compressing
+          end,
+          :remove_dump => lambda do
+            puts Kellerkind::Config.remove_dump
+          end,
+          :finished_dumping => lambda do |db_name|
+            puts Kellerkind::Config.finished_dumping(db_name)
+          end
+        }
+      end
+
+      def self.respond_to?(meth_name)
+        outputs.has_key?(meth_name) || super
+      end
+
+      def self.method_missing(meth_name, *args, &block)
+        if outputs.has_key?(meth_name)
+          output = outputs[meth_name]
+          if Kellerkind::Config.verbose?
+            output.call(*args) if output.arity == 1
+            output.call unless output.arity == 1
+          end
+        else
+          super
+        end
+      end
+
+    end
+
+    PROCESS_LOCKED_WARNING = <<-WARNING
+      kellerkind.lock find! Make sure that there isn't another kellerkind process running!
+    WARNING
+
+    DUMP_NOT_SUCCEEDED_WARNING = <<-WARNING
+      No dump found. It seems dumping failed.
+    WARNING
+
+    def self.lock
+      Kellerkind::Lock.lock_process
+    end
+
+    def self.unlock
+      Kellerkind::Lock.unlock_process
+    end
+
+    def self.locked?
+      die(PROCESS_LOCKED_WARNING) if File.exists?(Kellerkind::Config.lock_path)
+    end
+
+    def self.verbose(*args)
+      kind = args.shift
+      Kellerkind::Process::Output.send(kind, *args)
+    end
+
+  end
+end

data/lib/kellerkind/system/runner.rb

@@ -1,56 +1,29 @@
 module Kellerkind
+
+  # Public: Runs the Kellerkind modules depending of the --type commandline
+  # argument.
   class Runner
     extend Die
 
-    PROCESS_LOCKED_WARNING = <<-WARNING
-      kellerkind.lock find! Make sure that there isn't another kellerkind process running!
-    WARNING
-
-    DUMP_NOT_SUCCEEDED_WARNING = <<-WARNING
-      No dump found. It seems dumping failed.
-    WARNING
-
+    # Public: Executes a Kellerkind module.
+    #
+    # options={} - An optins Hash to define the behaviour of the Kellerkind
+    # modules. That is - in fact - the command line arguments.
+    #
     def self.exec(options={})
-      process_locked?
-      lock_process
-      mongo = Mongo.new(options)
-      puts Kellerkind::Config.start_dumping
-      mongo.dump_database
-      if options[:compress]
-        compress = Compress.new(:path => options[:out],
-                                :database_name =>options[:mongo_db])
-        if File.exists?(File.join(options[:out], options[:mongo_db]))
-          puts Kellerkind::Config.start_compressing
-          compress.gzip
-          if compress.succeeded?
-            puts Kellerkind::Config.finished_compressing
-            if options[:remove_dump]
-              puts Kellerkind::Config.remove_dump
-              FileUtils.rm_rf(File.join(options[:out],mongo.db))
-            end
-          end
-        else
-          unlock_process
-          die(DUMP_NOT_SUCCEEDED_WARNING)
-        end
-      end
-
-      unlock_process
-      puts Kellerkind::Config.finished_dumping(mongo.db)
-    end
-
-    def self.process_locked?
-      die(PROCESS_LOCKED_WARNING) if File.exists?(Kellerkind::Config.lock_path)
+      Kellerkind::Config.verbose_output = options.delete(:verbose)
+      handle_type(options)
     end
 
     private
 
-    def self.lock_process
-      Kellerkind::Lock.lock_process
+    def self.handle_type(options={})
+      module_name = options[:type].capitalize
+      Module.const_get("Kellerkind").const_get("#{module_name}").exec(options)
+    rescue NameError => name_error
+      raise name_error
+      die("No module named '#{module_name}' registered.")
     end
 
-    def self.unlock_process
-      Kellerkind::Lock.unlock_process
-    end
   end
-end
+end

data/spec/fixtures/mongodb.js

@@ -4,5 +4,5 @@ var data          = {
                       "title" : "10 Uhr zwanzig"
                     }
 
-kellerkindDb.tests.insert(obj);
+kellerkindDb.tests.insert(data);
 

data/spec/kellerkind/modules/implementations/log_file_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe Kellerkind::LogFile do
+  let(:out_dir) do
+    File.expand_path(File.join(File.dirname(__FILE__),"..", '..',"tmp"))
+  end
+
+  it { should respond_to(:files) }
+  it { should respond_to(:out) }
+  it { should respond_to(:recreate) }
+
+
+  describe "instance methods" do
+
+    let(:attributes) do
+      {
+        :files    => ["$HOME/tmp/kellerkind.lock"],
+        :out      => out_dir,
+        :recreate => true
+      }
+    end
+
+    it{ should respond_to(:archive) }
+
+    describe "#initialize" do
+
+      context "with a hash of attributes" do
+
+        context "that uses the proper prefix" do
+
+          subject{ Kellerkind::LogFile.new(attributes) }
+
+          it "then initializes the instance with the attribute values" do
+            subject.files.should eq attributes[:files]
+            subject.out.should eq attributes[:out]
+            subject.recreate.should eq attributes[:recreate]
+          end
+
+        end
+
+      end
+    end
+
+    describe "#archive" do
+      let(:rel_path) do
+        path = File.join(__FILE__,'..','..','..','..','fixtures')
+        File.expand_path(path)
+      end
+
+      let(:sample_file){ "#{rel_path}/sample.log" }
+
+      before do
+        FileUtils.touch(sample_file)
+        attributes[:files] = [sample_file]
+      end
+
+      after do
+        Dir["#{out_dir}/*.tar.gz"].each{ |tar| FileUtils.rm(tar) }
+        if File.exist?(sample_file)
+          FileUtils.rm(sample_file)
+        end
+      end
+
+      context ":recreate given and true" do
+
+        subject{ Kellerkind::LogFile.new(attributes) }
+
+        it "moves and compresses the files" do
+          subject.archive
+          Dir["#{out_dir}/sample.log_*.tar.gz"].should have(1).item
+        end
+
+        it "files are newly created" do
+          File.exist?(sample_file).should be true
+        end
+      end
+
+      context ":recreate given and false" do
+
+        before do
+          attributes[:recreate] = false
+        end
+
+        subject{ Kellerkind::LogFile.new(attributes) }
+
+        it "files are removed" do
+          subject.archive
+          File.exist?(sample_file).should be false
+        end
+      end
+    end
+
+  end
+
+end

data/spec/kellerkind/{database → modules/implementations}/mongo_spec.rb

@@ -118,7 +118,8 @@ describe Kellerkind::Mongo do
       end
 
       before do
-        js_path = File.expand_path(File.join(__FILE__,'..','..','fixtures'))
+        rel_path  = File.join(__FILE__,'..','..','..','..','fixtures')
+        js_path   = File.expand_path(rel_path)
         system("`which mongo` #{js_path}/mongodb.js")
       end
 

data/spec/kellerkind/modules/mongodb_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Kellerkind::Mongodb do
+
+  describe "class methods" do
+
+    describe "#exec" do
+
+      let(:dbname){ "kellerkindTest"}
+      let(:out_dir) do
+        File.expand_path(File.join(File.dirname(__FILE__),"..", "tmp"))
+      end
+      before do
+        rel_path  = File.join(__FILE__,'..','..','..','fixtures')
+        js_path   = File.expand_path(rel_path)
+        system("`which mongo` #{js_path}/mongodb.js")
+        Kellerkind::Process.unlock
+      end
+
+      after do
+        Dir["#{out_dir}/#{dbname}*.tar.gz"].each{ |tar| FileUtils.rm(tar) }
+      end
+
+      let(:attributes) do
+        {
+          :mongo_db     => dbname,
+          :mongo_host   => "localhost",
+          :mongo_port   => "27017",
+          :out          => out_dir,
+          :remove_dump  => true,
+          :compress     => true
+        }
+      end
+
+      it "dumps a database" do
+        Kellerkind::Mongodb.exec(attributes)
+        Dir["#{out_dir}/#{dbname}_*.tar.gz"].should have(1).item
+      end
+
+    end
+
+  end
+end

data/spec/kellerkind/system/compress_spec.rb

@@ -2,8 +2,9 @@ require 'spec_helper'
 
 describe Kellerkind::Compress do
 
-  it{ should respond_to(:path) }
-  it{ should respond_to(:database_name) }
+  it{ should respond_to(:source_path) }
+  it{ should respond_to(:target_path) }
+  it{ should respond_to(:tarball_prefix)}
 
   describe "instance methods" do
     let(:out_dir) do
@@ -11,8 +12,8 @@ describe Kellerkind::Compress do
     end
     let(:attributes) do
       {
-        :database_name   => "test",
-        :path            => out_dir
+        :tarball_prefix   => "test",
+        :target_path      => out_dir
       }
     end
 
@@ -22,18 +23,20 @@ describe Kellerkind::Compress do
       subject{ Kellerkind::Compress.new(attributes) }
 
       it "then initializes the instance with the attributes values" do
-        subject.database_name.should eq attributes[:database_name]
-        subject.path.should eq attributes[:path]
+        subject.target_path.should eq attributes[:target_path]
+        subject.tarball_prefix.should eq attributes[:tarball_prefix]
       end
     end
 
     describe "#gzip" do
       let(:test_dump) do
-        File.join(out_dir, attributes[:database_name])
+        File.join(out_dir, "kellerkindTest")
       end
 
       let(:compress) do
-        Kellerkind::Compress.new(:path => out_dir, :database_name => "test")
+        Kellerkind::Compress.new(:target_path     => out_dir,
+                                 :source_path     => test_dump,
+                                 :tarball_prefix  => "test")
       end
 
       before do
@@ -48,7 +51,7 @@ describe Kellerkind::Compress do
       end
 
       it "tars and gzip the given database dump" do
-        Dir["#{out_dir}/#{compress.database_name}_*.tar.gz"].should have(1).item
+        Dir["#{out_dir}/#{compress.tarball_prefix}_*.tar.gz"].should have(1).item
       end
 
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kellerkind
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-08 00:00:00.000000000 Z
+date: 2013-11-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: virtus
@@ -134,8 +134,8 @@ extra_rdoc_files:
 files:
 - .document
 - .rspec
+- .travis.yml
 - Gemfile
-- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -146,18 +146,24 @@ files:
 - lib/kellerkind/core/configuration.rb
 - lib/kellerkind/core/ext.rb
 - lib/kellerkind/core/set.rb
-- lib/kellerkind/database/mongo.rb
 - lib/kellerkind/dependencies.rb
+- lib/kellerkind/modules/implementations/log_file.rb
+- lib/kellerkind/modules/implementations/mongo.rb
+- lib/kellerkind/modules/log.rb
+- lib/kellerkind/modules/modules.rb
+- lib/kellerkind/modules/mongodb.rb
 - lib/kellerkind/system/compress.rb
 - lib/kellerkind/system/die.rb
 - lib/kellerkind/system/lock.rb
+- lib/kellerkind/system/process.rb
 - lib/kellerkind/system/runner.rb
 - spec/fixtures/mongodb.js
-- spec/kellerkind/database/mongo_spec.rb
+- spec/kellerkind/modules/implementations/log_file_spec.rb
+- spec/kellerkind/modules/implementations/mongo_spec.rb
+- spec/kellerkind/modules/mongodb_spec.rb
 - spec/kellerkind/system/compress_spec.rb
 - spec/kellerkind/system/lock_spec.rb
 - spec/kellerkind/tmp/.gitkeep
-- spec/kellerkind_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/dsci/kellerkind
 licenses:
@@ -174,7 +180,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -477172816083607682
+      hash: 2107316409361176975
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:

data/Gemfile.lock

@@ -1,73 +0,0 @@
-GEM
-  remote: http://rubygems.org/
-  specs:
-    addressable (2.3.5)
-    backports (3.3.3)
-    builder (3.2.2)
-    descendants_tracker (0.0.1)
-    diff-lcs (1.2.4)
-    faraday (0.8.7)
-      multipart-post (~> 1.1)
-    git (1.2.5)
-    github_api (0.10.1)
-      addressable
-      faraday (~> 0.8.1)
-      hashie (>= 1.2)
-      multi_json (~> 1.4)
-      nokogiri (~> 1.5.2)
-      oauth2
-    hashie (2.0.5)
-    highline (1.6.19)
-    httpauth (0.2.0)
-    jeweler (1.8.6)
-      builder
-      bundler (~> 1.0)
-      git (>= 1.2.5)
-      github_api (= 0.10.1)
-      highline (>= 1.6.15)
-      nokogiri (= 1.5.10)
-      rake
-      rdoc
-    json (1.8.0)
-    jwt (0.1.8)
-      multi_json (>= 1.5)
-    minitar (0.5.4)
-    multi_json (1.7.7)
-    multi_xml (0.5.4)
-    multipart-post (1.2.0)
-    nokogiri (1.5.10)
-    oauth2 (0.9.2)
-      faraday (~> 0.8)
-      httpauth (~> 0.2)
-      jwt (~> 0.1.4)
-      multi_json (~> 1.0)
-      multi_xml (~> 0.5)
-      rack (~> 1.2)
-    rack (1.5.2)
-    rake (10.1.0)
-    rdoc (3.12.2)
-      json (~> 1.4)
-    rspec (2.13.0)
-      rspec-core (~> 2.13.0)
-      rspec-expectations (~> 2.13.0)
-      rspec-mocks (~> 2.13.0)
-    rspec-core (2.13.1)
-    rspec-expectations (2.13.0)
-      diff-lcs (>= 1.1.3, < 2.0)
-    rspec-mocks (2.13.1)
-    trollop (2.0)
-    virtus (0.5.5)
-      backports (~> 3.3)
-      descendants_tracker (~> 0.0.1)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  bundler (~> 1.3.5)
-  jeweler (~> 1.8.4)
-  minitar (~> 0.5.4)
-  rdoc (~> 3.12)
-  rspec (~> 2.13.0)
-  trollop
-  virtus (~> 0.5.5)

data/spec/kellerkind_spec.rb

@@ -1,7 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe "Kellerkind" do
-  it "fails" do
-    fail "hey buddy, you should probably rename this file and start specing for real"
-  end
-end