kellerkind 0.1.1

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,17 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+gem 'virtus', "~> 0.5.5"
+gem "minitar", "~> 0.5.4"
+gem "trollop"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rspec", "~> 2.13.0"
+  gem "rdoc", "~> 3.12"
+  gem "bundler", "~> 1.3.5"
+  gem "jeweler", "~> 1.8.4"
+end

data/Gemfile.lock

@@ -0,0 +1,73 @@
+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/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Daniel Schmidt
+
+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,45 @@
+# kellerkind
+
+Kellerkind is just a Ruby script that runs mongodump and tars the resulting dump.
+
+It should be used with its cli but it's also possible to use it with its API.
+
+## Usage
+
+Install it as gem:
+
+```
+gem install kellerkind
+```
+
+Run from the command line:
+
+```
+kellerkind --help
+```
+
+to the arguments you could specify.
+
+**Example**
+
+```
+kellerkind --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.
+
+## 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.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+## Copyright
+
+Copyright (c) 2013 Daniel Schmidt. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "kellerkind"
+  gem.homepage = "http://github.com/dsci/kellerkind"
+  gem.license = "MIT"
+  gem.summary = %Q{Mongodb archiving tool.}
+  gem.description = %Q{Dumps mongodb databases and archives them.}
+  gem.email = "dsci@code79.net"
+  gem.authors = ["Daniel Schmidt"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "kellerkind #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/bin/kellerkind

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$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! }
+}
+
+opts = Trollop::options do
+  banner <<-EOS
+    Mongodb archiving tool.
+
+    Dumps mongodb databases and archives them. Nothing more. Neat, isn't it?
+  EOS
+
+  opt :mongo_db,        "mongo database to dump",         :type => :string
+  opt :mongo_host,      "mongo host to connect to",       :type => :string,
+                                                          :default => "localhost"
+  opt :mongo_username,  "mongo username",                 :type => :string
+  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 :remove_dump,     "remove dump after compression?", :type => :boolean,
+                                                          :default => true
+end
+
+REQUIRED_ARGS.each_pair do |key,value|
+  Trollop::die key, value unless opts[key]
+end
+
+Kellerkind::Runner.exec(opts)
+

data/kellerkind.gemspec

@@ -0,0 +1,85 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "kellerkind"
+  s.version = "0.1.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Daniel Schmidt"]
+  s.date = "2013-07-05"
+  s.description = "Dumps mongodb databases and archives them."
+  s.email = "dsci@code79.net"
+  s.executables = ["kellerkind"]
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "bin/kellerkind",
+    "kellerkind.gemspec",
+    "lib/kellerkind.rb",
+    "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/system/compress.rb",
+    "lib/kellerkind/system/die.rb",
+    "lib/kellerkind/system/lock.rb",
+    "lib/kellerkind/system/runner.rb",
+    "spec/fixtures/mongodb.js",
+    "spec/kellerkind/database/mongo_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"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.25"
+  s.summary = "Mongodb archiving tool."
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<virtus>, ["~> 0.5.5"])
+      s.add_runtime_dependency(%q<minitar>, ["~> 0.5.4"])
+      s.add_runtime_dependency(%q<trollop>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.13.0"])
+      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.3.5"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.8.4"])
+    else
+      s.add_dependency(%q<virtus>, ["~> 0.5.5"])
+      s.add_dependency(%q<minitar>, ["~> 0.5.4"])
+      s.add_dependency(%q<trollop>, [">= 0"])
+      s.add_dependency(%q<rspec>, ["~> 2.13.0"])
+      s.add_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_dependency(%q<bundler>, ["~> 1.3.5"])
+      s.add_dependency(%q<jeweler>, ["~> 1.8.4"])
+    end
+  else
+    s.add_dependency(%q<virtus>, ["~> 0.5.5"])
+    s.add_dependency(%q<minitar>, ["~> 0.5.4"])
+    s.add_dependency(%q<trollop>, [">= 0"])
+    s.add_dependency(%q<rspec>, ["~> 2.13.0"])
+    s.add_dependency(%q<rdoc>, ["~> 3.12"])
+    s.add_dependency(%q<bundler>, ["~> 1.3.5"])
+    s.add_dependency(%q<jeweler>, ["~> 1.8.4"])
+  end
+end
+

data/lib/kellerkind/core/configuration.rb

@@ -0,0 +1,64 @@
+module 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.
+    #
+    # Returns name of executable as String.
+    def db_dump_cmd
+      "mongodump"
+    end
+
+
+    # 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")
+    end
+
+    # Public: Gets the direct path to kellerkind lock file
+    def lock_path
+      File.join(lock_dir,"Kellerkind.lock")
+    end
+
+    # Internal: Gets message for action when dumping was started.
+    def start_dumping
+      %Q{Start dumping ...}
+    end
+
+    # Internal: Gets message for action when a dump is about to remove.
+    def remove_dump
+      %Q{Remove raw dump. To disable that use --remove-dump false}
+    end
+
+    # Internal: Gets message for action when compressing was started.
+    def start_compressing
+      %Q{Start compressing of dump ... }
+    end
+
+    # Internal: Gets message for action when compressing is finished.
+    def finished_compressing
+      %Q{Compressing done ...}
+    end
+
+    # Internal: Gets message for action when all is done.
+    #
+    # database - Name of the database from which a dump is created.
+    def finished_dumping(database)
+      %Q{ -- Dumping of #{database} done ...}
+    end
+
+  end
+end

data/lib/kellerkind/core/ext.rb

@@ -0,0 +1,8 @@
+Object.class_eval do
+
+  def in?(list)
+    raise ArgumentError unless list.respond_to?(:include?)
+    list.include?(self)
+  end
+
+end

data/lib/kellerkind/core/set.rb

@@ -0,0 +1,16 @@
+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/database/mongo.rb

@@ -0,0 +1,59 @@
+module Kellerkind
+
+  # Public: Dumps a MongoDb database.
+  #
+  # For more see mongodump --help
+  class Mongo < Set
+
+    # MongoDb database (required)
+    attribute :db,        String
+    # MongoDb host
+    attribute :host,      String
+    # MongoDb user
+    attribute :username,  String
+    # MongoDb user password
+    attribute :password,  String
+    # MongoDb server host
+    attribute :port,      String
+    # File path location for dump
+    attribute :out,       String
+
+    def initialize(options={})
+      init_instance(options) unless options.empty?
+    end
+
+
+    # Public: Dumps the database by using a stream to the underlying
+    # 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? }
+      return "" if usable_line_args.empty?
+      return usable_line_args.collect do |key,value|
+        "--#{key} #{value}"
+      end.join(" ")
+    end
+
+    private
+
+    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

@@ -0,0 +1,9 @@
+%w{ core/ext.rb
+    core/configuration
+    core/set
+    system/lock
+    system/compress
+    system/die
+    database/mongo
+    system/runner
+  }.each{ |code| require_relative code }

data/lib/kellerkind/system/compress.rb

@@ -0,0 +1,59 @@
+require 'zlib'
+require 'archive/tar/minitar'
+
+module Kellerkind
+
+  # 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
+    # Database name which equals the dumps directory name
+    attribute :database_name, String
+
+
+    # Public: Initialises compressing of the dumps directory.
+    def gzip
+      traverse_and_gzip
+    end
+
+
+    # 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))
+    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
+      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)
+    end
+
+  end
+end

data/lib/kellerkind/system/die.rb

@@ -0,0 +1,9 @@
+module Kellerkind
+  module Die
+
+    def die(abort_message, options={})
+      abort(abort_message)
+    end
+
+  end
+end

data/lib/kellerkind/system/lock.rb

@@ -0,0 +1,19 @@
+module Kellerkind
+  module Lock
+    extend self
+
+    def lock_process
+      unless File.exists?(Kellerkind::Config.lock_dir)
+        FileUtils.mkdir(Kellerkind::Config.lock_dir)
+      end
+      FileUtils.touch(Kellerkind::Config.lock_path)
+    end
+
+    def unlock_process
+      if File.exists?(Kellerkind::Config.lock_path)
+        FileUtils.rm(Kellerkind::Config.lock_path)
+      end
+    end
+
+  end
+end

data/lib/kellerkind/system/runner.rb

@@ -0,0 +1,56 @@
+module Kellerkind
+  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
+
+    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)
+    end
+
+    private
+
+    def self.lock_process
+      Kellerkind::Lock.lock_process
+    end
+
+    def self.unlock_process
+      Kellerkind::Lock.unlock_process
+    end
+  end
+end

data/lib/kellerkind.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'bundler/setup'
+
+Bundler.require
+
+require_relative 'kellerkind/dependencies'
+
+<<-DOC
+File.open('test.tar', 'wb') { |tar| Minitar.pack(File.join("/Users/Demo/tmp/"), tar) }
+DOC
+
+Kellerkind::Mongo.new

data/spec/fixtures/mongodb.js

@@ -0,0 +1,8 @@
+var databaseName  = "kellerkindTest";
+var kellerkindDb  = db.getSiblingDB(databaseName);
+var data          = {
+                      "title" : "10 Uhr zwanzig"
+                    }
+
+kellerkindDb.tests.insert(obj);
+

data/spec/kellerkind/database/mongo_spec.rb

@@ -0,0 +1,145 @@
+require 'spec_helper'
+
+describe Kellerkind::Mongo do
+
+  it{ should respond_to(:db) }
+  it{ should respond_to(:host) }
+  it{ should respond_to(:username) }
+  it{ should respond_to(:password) }
+  it{ should respond_to(:port) }
+  it{ should respond_to(:out) }
+
+  describe "instance methoods" do
+
+    let(:attributes) do
+      {
+        :mongo_db         => "test",
+        :mongo_host       => "localhost",
+        :mongo_username   => "rspec_user",
+        :mongo_password   => "no_pwd",
+        :mongo_port       => "27017"
+      }
+    end
+
+    it{ should respond_to(:dump_database) }
+    it{ should respond_to(:dump_argument_list)}
+
+    describe "#initialize" do
+
+      context "with a hash of attributes" do
+
+        context "that uses the proper prefix" do
+
+          subject{ Kellerkind::Mongo.new(attributes) }
+
+          it "then initializes the instance with the attributes values" do
+            subject.db.should eq attributes[:mongo_db]
+            subject.host.should eq attributes[:mongo_host]
+            subject.username.should eq attributes[:mongo_username]
+            subject.password.should eq attributes[:mongo_password]
+            subject.port.should eq attributes[:mongo_port]
+
+            subject.dump_database
+          end
+
+        end
+
+        context "that uses not the proper prefix" do
+          let(:inproper_attributes) do
+            attributes.delete(:mongo_db)
+            attributes[:super_database] = "testa"
+            attributes
+          end
+
+          subject{ Kellerkind::Mongo.new(inproper_attributes) }
+
+          it "then initializes the instance without these attributes" do
+            subject.db.should be nil
+          end
+
+        end
+
+      end
+
+    end
+
+    describe "#dump_argument_list" do
+
+      context "and arguments given" do
+
+        let(:mongo){ Kellerkind::Mongo.new(attributes) }
+
+        subject{ mongo.dump_argument_list }
+
+        context "then returns a parameter list including the instances attributes" do
+
+          it{ should match(/--db #{attributes[:mongo_db]}{1,}/) }
+          it{ should match(/--password #{attributes[:mongo_password]}{1,}/) }
+          it{ should match(/--host #{attributes[:mongo_host]}{1,}/) }
+          it{ should match(/--port #{attributes[:mongo_port]}{1,}/)}
+          it{ should match(/--username #{attributes[:mongo_username]}{1,}/)}
+
+          it{ should_not match(/--host #{attributes[:mongo_host]}{2,*}/)}
+          it{ should_not match(/--db #{attributes[:mongo_db]}{2,*}/) }
+          it{ should_not match(/--password #{attributes[:mongo_password]}{2,*}/) }
+          it{ should_not match(/--host #{attributes[:mongo_host]}{2,*}/) }
+          it{ should_not match(/--port #{attributes[:mongo_port]}{2,*}/)}
+          it{ should_not match(/--user_name #{attributes[:mongo_username]}{2,*}/)}
+
+        end
+
+      end
+
+      context "and no arguments given" do
+
+        let(:mongo){ Kellerkind::Mongo.new }
+
+        subject{ mongo.dump_argument_list }
+
+        it "then returns an empty string" do
+          subject.should be_empty
+        end
+
+      end
+
+    end
+
+    describe "#dump_database" do
+      let(:out_dir) do
+        File.expand_path(File.join(File.dirname(__FILE__),"..", "tmp"))
+      end
+      let(:dump_attributes) do
+        {
+          :mongo_db   => "kellerkindTest",
+          :mongo_port => "27017",
+          :mongo_host => "localhost",
+          :mongo_out  => out_dir
+        }
+      end
+
+      before do
+        js_path = File.expand_path(File.join(__FILE__,'..','..','fixtures'))
+        system("`which mongo` #{js_path}/mongodb.js")
+      end
+
+      after do
+        if File.exists?(out_dir)
+          FileUtils.rm_rf(out_dir)
+        end
+      end
+
+      subject{ Kellerkind::Mongo.new(dump_attributes) }
+
+      it "dumps database content into --out" do
+        subject.dump_database
+        File.exists?("#{out_dir}/kellerkindTest").should be true
+        File.exists?("#{out_dir}/kellerkindTest/tests.bson").should be true
+        File.exists?("#{out_dir}/kellerkindTest/tests.metadata.json").should be true
+        File.exists?("#{out_dir}/kellerkindTest/system.indexes.bson").should be true
+      end
+
+    end
+
+  end
+
+end

data/spec/kellerkind/system/compress_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe Kellerkind::Compress do
+
+  it{ should respond_to(:path) }
+  it{ should respond_to(:database_name) }
+
+  describe "instance methods" do
+    let(:out_dir) do
+      File.expand_path(File.join(File.dirname(__FILE__),"..", "tmp"))
+    end
+    let(:attributes) do
+      {
+        :database_name   => "test",
+        :path            => out_dir
+      }
+    end
+
+    it{ should respond_to(:gzip) }
+
+    context "with a hash of attributes" 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]
+      end
+    end
+
+    describe "#gzip" do
+      let(:test_dump) do
+        File.join(out_dir, attributes[:database_name])
+      end
+
+      let(:compress) do
+        Kellerkind::Compress.new(:path => out_dir, :database_name => "test")
+      end
+
+      before do
+        FileUtils.mkdir_p(test_dump)
+        FileUtils.touch(File.join(test_dump, "foo.txt"))
+        compress.gzip
+      end
+
+      after do
+        Dir["#{out_dir}/*.tar.gz"].each{ |tar| FileUtils.rm(tar) }
+        FileUtils.rm_rf(test_dump)
+      end
+
+      it "tars and gzip the given database dump" do
+        Dir["#{out_dir}/#{compress.database_name}_*.tar.gz"].should have(1).item
+      end
+
+    end
+
+  end
+
+end

data/spec/kellerkind/system/lock_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe "Locking and unlocking process" do
+  let(:tmp_path) do
+    File.expand_path(File.join(File.dirname(__FILE__),"..", "tmp"))
+  end
+
+  let(:lock_file){ File.join(tmp_path,"Kellerkind.lock") }
+
+  before do
+    Kellerkind::Config.stub!(:lock_dir).and_return(tmp_path)
+  end
+
+  describe "#lock_process" do
+
+    after do
+      FileUtils.rm(lock_file)
+    end
+
+    it "creates a file do mark the process as locked" do
+      Kellerkind::Lock.lock_process
+      File.exists?(lock_file).should be true
+    end
+
+  end
+
+  describe "#unlock_process" do
+
+    before do
+      FileUtils.touch(lock_file)
+    end
+
+    it "removes the lock file to mark the process as runnable" do
+      Kellerkind::Lock.unlock_process
+      File.exists?(lock_file).should be false
+    end
+
+  end
+end

data/spec/kellerkind_spec.rb

@@ -0,0 +1,7 @@
+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

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'kellerkind'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end

metadata

@@ -0,0 +1,190 @@
+--- !ruby/object:Gem::Specification
+name: kellerkind
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+  prerelease: 
+platform: ruby
+authors:
+- Daniel Schmidt
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: virtus
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.5.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.5.5
+- !ruby/object:Gem::Dependency
+  name: minitar
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.5.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.5.4
+- !ruby/object:Gem::Dependency
+  name: trollop
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.5
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.4
+description: Dumps mongodb databases and archives them.
+email: dsci@code79.net
+executables:
+- kellerkind
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- .document
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- bin/kellerkind
+- kellerkind.gemspec
+- lib/kellerkind.rb
+- 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/system/compress.rb
+- lib/kellerkind/system/die.rb
+- lib/kellerkind/system/lock.rb
+- lib/kellerkind/system/runner.rb
+- spec/fixtures/mongodb.js
+- spec/kellerkind/database/mongo_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:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 3218703124372926278
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Mongodb archiving tool.
+test_files: []