astrails-safe 0.1.6 → 0.1.7

data/examples/unit/gzip_example.rb

@@ -0,0 +1,64 @@
+require File.expand_path(File.dirname(__FILE__) + '/../example_helper')
+
+describe Astrails::Safe::Gzip do
+
+  def def_backup
+    {
+      :compressed => false,
+      :command => "command",
+      :extension => ".foo",
+      :filename => "qweqwe"
+    }
+  end
+
+  after(:each) { Astrails::Safe::TmpFile.cleanup }
+
+  def gzip(config = {}, backup = def_backup)
+    Astrails::Safe::Gzip.new(
+      @config = Astrails::Safe::Config::Node.new(nil, config),
+      @backup = Astrails::Safe::Backup.new(backup)
+    )
+  end
+
+  describe :preocess do
+
+    describe "when not yet compressed" do
+      before(:each) { @gzip = gzip }
+
+      it "should add .gz extension" do
+        mock(@backup.extension) << '.gz'
+        @gzip.process
+      end
+
+      it "should add |gzip pipe" do
+        mock(@backup.command) << '|gzip'
+        @gzip.process
+      end
+
+      it "should set compressed" do
+        mock(@backup).compressed = true
+        @gzip.process
+      end
+    end
+
+    describe "when already compressed" do
+
+      before(:each) { @gzip = gzip({}, :compressed => true) }
+
+      it "should not touch extension" do
+        dont_allow(@backup.extension).<< anything
+        @gzip.process
+      end
+
+      it "should not touch command" do
+        dont_allow(@backup.command).<< anything
+        @gzip.process
+      end
+
+      it "should not touch compressed" do
+        dont_allow(@backup).compressed = anything
+        @gzip.process
+      end
+    end
+  end
+end

data/examples/unit/local_example.rb

@@ -0,0 +1,82 @@
+require File.expand_path(File.dirname(__FILE__) + '/../example_helper')
+
+describe Astrails::Safe::Local do
+  def def_config
+    {
+      :local => {
+        :path => "/:kind~:id~:timestamp"
+      }
+    }
+  end
+
+  def def_backup
+    {
+      :kind => "mysqldump",
+      :id => "blog",
+      :timestamp => "NoW",
+      :compressed => true,
+      :command => "command",
+      :extension => ".foo.gz",
+      :filename => "qweqwe"
+    }
+  end
+
+  def local(config = def_config, backup = def_backup)
+    Astrails::Safe::Local.new(
+      @config = Astrails::Safe::Config::Node.new(nil, config),
+      @backup = Astrails::Safe::Backup.new(backup)
+    )
+  end
+
+  describe :active? do
+    it "should be true" do
+      local.should be_active
+    end
+  end
+
+  describe :prefix do
+    it "should raise RuntimeError when no path" do
+      lambda {
+        local({}).send :prefix
+      }.should raise_error(RuntimeError, "missing :local/:path")
+    end
+
+    it "should use local/path" do
+      local.send(:prefix).should == "/mysqldump~blog~NoW"
+    end
+  end
+
+  describe :save do
+    before(:each) do
+      @local = local
+      stub(@local).system
+      stub(@local).path {"file-path"}
+      stub(FileUtils).mkdir_p
+    end
+
+    it "should call system to save the file" do
+      mock(@local).system("command>file-path")
+      @local.send(:save)
+    end
+
+    it "should create directory" do
+      mock(FileUtils).mkdir_p("/mysqldump~blog~NoW")
+      @local.send(:save)
+    end
+
+    it "should set backup.path" do
+      mock(@backup).path = "file-path"
+      @local.send(:save)
+    end
+
+    describe "dry run" do
+      it "should not create directory"
+      it "should not call system"
+      it "should set backup.path"
+    end
+  end
+
+  describe :cleanup do
+    it "should have test"
+  end
+end

data/examples/unit/mysqldump_example.rb

@@ -0,0 +1,83 @@
+require File.expand_path(File.dirname(__FILE__) + '/../example_helper')
+
+describe Astrails::Safe::Mysqldump do
+
+  def def_config
+    {
+      :options => "OPTS",
+      :user => "User",
+      :password => "pwd",
+      :host => "localhost",
+      :port => 7777,
+      :socket => "socket",
+      :skip_tables => [:bar, :baz]
+    }
+  end
+
+  def mysqldump(id = :foo, config = def_config)
+    Astrails::Safe::Mysqldump.new(id, Astrails::Safe::Config::Node.new(nil, config))
+  end
+
+  before(:each) do
+    stub(Time).now.stub!.strftime {"NOW"}
+  end
+
+  after(:each) { Astrails::Safe::TmpFile.cleanup }
+
+  describe :backup do
+    before(:each) do
+      @mysql = mysqldump
+      stub(@mysql).mysql_password_file {"/tmp/pwd"}
+    end
+
+    {
+      :id => "foo",
+      :kind => "mysqldump",
+      :extension => ".sql",
+      :filename => "mysqldump-foo.NOW",
+      :command => "mysqldump --defaults-extra-file=/tmp/pwd OPTS --ignore-table=foo.bar --ignore-table=foo.baz foo",
+    }.each do |k, v|
+      it "should set #{k} to #{v}" do
+        @mysql.backup.send(k).should == v
+      end
+    end
+
+  end
+
+  describe :mysql_skip_tables do
+    it "should return nil if no skip_tables" do
+      config = def_config.dup
+      config.delete(:skip_tables)
+      m = mysqldump(:foo, Astrails::Safe::Config::Node.new(nil, config))
+      stub(m).timestamp {"NOW"}
+      m.send(:mysql_skip_tables).should be_nil
+      m.backup.command.should_not match(/ignore-table/)
+    end
+
+    it "should return '' if skip_tables empty" do
+      config = def_config.dup
+      config[:skip_tables] = []
+      m = mysqldump(:foo, Astrails::Safe::Config::Node.new(nil, config))
+      stub(m).timestamp {"NOW"}
+      m.send(:mysql_skip_tables).should == ""
+      m.backup.command.should_not match(/ignore-table/)
+    end
+
+  end
+
+  describe :mysql_password_file do
+    it "should create passwords file" do
+      m = mysqldump
+      file = m.send(:mysql_password_file)
+      File.exists?(file).should == true
+      File.read(file).should == <<-PWD
+[mysqldump]
+user = User
+password = pwd
+socket = socket
+host = localhost
+port = 7777
+      PWD
+    end
+  end
+end

data/examples/unit/pgdump_example.rb

@@ -0,0 +1,45 @@
+require File.expand_path(File.dirname(__FILE__) + '/../example_helper')
+
+describe Astrails::Safe::Pgdump do
+
+  def def_config
+    {
+      :options => "OPTS",
+      :user => "User",
+      :password => "pwd",
+      :host => "localhost",
+      :port => 7777,
+      :skip_tables => [:bar, :baz]
+    }
+  end
+
+  def pgdump(id = :foo, config = def_config)
+    Astrails::Safe::Pgdump.new(id, Astrails::Safe::Config::Node.new(nil, config))
+  end
+
+  before(:each) do
+    stub(Time).now.stub!.strftime {"NOW"}
+  end
+
+  after(:each) { Astrails::Safe::TmpFile.cleanup }
+
+  describe :backup do
+    before(:each) do
+      @pg = pgdump
+    end
+
+    {
+      :id => "foo",
+      :kind => "pgdump",
+      :extension => ".sql",
+      :filename => "pgdump-foo.NOW",
+      :command => "pg_dump OPTS --username='User' --host='localhost' --port='7777' foo",
+    }.each do |k, v|
+      it "should set #{k} to #{v}" do
+        @pg.backup.send(k).should == v
+      end
+    end
+
+  end
+
+end

data/examples/unit/s3_example.rb

@@ -0,0 +1,28 @@
+require File.expand_path(File.dirname(__FILE__) + '/../example_helper')
+
+describe Astrails::Safe::S3 do
+
+  describe :active do
+    it "should be true when all params are set"
+    it "should be false if bucket is missing"
+    it "should be false if key is missing"
+    it "should be false if secret is missing"
+  end
+
+  describe :prefix do
+    it "should use s3/path 1st"
+    it "should use local/path 2nd"
+    it "should use constant 3rd"
+  end
+
+  describe :save do
+    it "should establish s3 connection"
+    it "should RuntimeError if no local file (i.e. :local didn't run)"
+    it "should open local file"
+    it "should upload file"
+  end
+
+  describe :cleanup do
+    it "should have some tests"
+  end
+end

data/examples/unit/svndump_example.rb

@@ -0,0 +1,39 @@
+require File.expand_path(File.dirname(__FILE__) + '/../example_helper')
+
+describe Astrails::Safe::Svndump do
+  def def_config
+    {
+      :options => "OPTS",
+      :repo_path => "bar/baz"
+    }
+  end
+
+  def svndump(id = :foo, config = def_config)
+    Astrails::Safe::Svndump.new(id, Astrails::Safe::Config::Node.new(nil, config))
+  end
+
+  before(:each) do
+    stub(Time).now.stub!.strftime {"NOW"}
+  end
+
+  after(:each) { Astrails::Safe::TmpFile.cleanup }
+
+  describe :backup do
+    before(:each) do
+      @svn = svndump
+    end
+
+    {
+      :id => "foo",
+      :kind => "svndump",
+      :extension => ".svn",
+      :filename => "svndump-foo.NOW",
+      :command => "svnadmin dump OPTS bar/baz",
+    }.each do |k, v|
+      it "should set #{k} to #{v}" do
+        @svn.backup.send(k).should == v
+      end
+    end
+
+  end
+end

data/lib/astrails/safe.rb

@@ -1,4 +1,9 @@
+require "aws/s3"
+require 'fileutils'
+
+require 'tempfile'
 require 'extensions/mktmpdir'
+
 require 'astrails/safe/tmp_file'
 
 require 'astrails/safe/config/node'
@@ -6,9 +11,15 @@ require 'astrails/safe/config/builder'
 
 require 'astrails/safe/stream'
 
+require 'astrails/safe/backup'
+
+require 'astrails/safe/backup'
+
 require 'astrails/safe/source'
 require 'astrails/safe/mysqldump'
+require 'astrails/safe/pgdump'
 require 'astrails/safe/archive'
+require 'astrails/safe/svndump'
 
 require 'astrails/safe/pipe'
 require 'astrails/safe/gpg'
@@ -23,19 +34,25 @@ module Astrails
   module Safe
     ROOT = File.join(File.dirname(__FILE__), "..", "..")
 
-    def timestamp
-      @timestamp ||= Time.now.strftime("%y%m%d-%H%M")
-    end
-
     def safe(&block)
       config = Config::Node.new(&block)
       #config.dump
 
-      Astrails::Safe::Mysqldump.run(config[:mysqldump, :databases])
-      Astrails::Safe::Archive.run(config[:tar, :archives])
+
+      [[Astrails::Safe::Mysqldump, [:mysqldump, :databases]],
+       [Astrails::Safe::Pgdump, [:pgdump, :databases]],
+       [Astrails::Safe::Archive, [:tar, :archives]],
+       [Astrails::Safe::Svndump, [:svndump, :repos]]
+      ].each do |klass, path|
+        if collection = config[*path]
+          collection.each do |name, config|
+            klass.new(name, config).backup.run(config, :gpg, :gzip, :local, :s3)
+          end
+        end
+      end
 
       Astrails::Safe::TmpFile.cleanup
     end
+    module_function :safe
   end
 end
-

data/lib/astrails/safe/archive.rb

@@ -16,9 +16,9 @@ module Astrails
 
       def tar_files
         raise RuntimeError, "missing files for tar" unless @config[:files]
-        [*@config[:files]] * " "
+        [*@config[:files]].map {|s| s.strip} * " "
       end
 
     end
   end
-end
+end

data/lib/astrails/safe/backup.rb

@@ -0,0 +1,20 @@
+module Astrails
+  module Safe
+    class Backup
+      attr_accessor :id, :kind, :filename, :extension, :command, :compressed, :timestamp, :path
+      def initialize(opts = {})
+        opts.each do |k, v|
+          self.send("#{k}=", v)
+        end
+      end
+
+      def run(config, *mods)
+        mods.each do |mod|
+          mod = mod.to_s
+          mod[0] = mod[0..0].upcase
+          Astrails::Safe.const_get(mod).new(config, self).process
+        end
+      end
+    end
+  end
+end

data/lib/astrails/safe/config/builder.rb

@@ -2,9 +2,9 @@ module Astrails
   module Safe
     module Config
       class Builder
-        COLLECTIONS = %w/database archive/
-        ITEMS = %w/s3 key secret bucket path gpg password keep local mysqldump options
-        user host port socket skip_tables tar files exclude filename/
+        COLLECTIONS = %w/database archive repo/
+        ITEMS = %w/s3 key secret bucket path gpg password keep local mysqldump pgdump options
+        user host port socket skip_tables tar files exclude filename svndump repo_path/
         NAMES = COLLECTIONS + ITEMS
         def initialize(node)
           @node = node
@@ -27,13 +27,13 @@ module Astrails
 
           # do we have data hash?
           if data = args.shift
-            die "#{sym}: hash expected: #{data.inspect}" unless data.is_a?(Hash)
+            raise "#{sym}: hash expected: #{data.inspect}" unless data.is_a?(Hash)
           end
 
           #puts "#{sym}: args=#{args.inspect}, id_or_value=#{id_or_value}, data=#{data.inspect}, block=#{block.inspect}"
 
-          die "#{sym}: unexpected: #{args.inspect}" unless args.empty?
-          die "#{sym}: missing arguments" unless id_or_value || data || block
+          raise "#{sym}: unexpected: #{args.inspect}" unless args.empty?
+          raise "#{sym}: missing arguments" unless id_or_value || data || block
 
           if COLLECTIONS.include?(sym.to_s) && id_or_value
             data ||= {}