backupgem 0.0.9 → 0.0.11

data/CHANGELOG

@@ -1,4 +1,8 @@
 = Backup Changelog
+== Version 0.0.11
+* Removed the tmpdir directive because it was screwing up the meta-code
+* Moved the graffle and keynote files to an "extras" directory because it was breaking windows machines
+
 == Version 0.0.8
 * The attached patch will add the 'backup' executable to your bin path using
    the built-in RubyGems method for adding things to bin. Thanks to Anthony

data/Rakefile

@@ -6,13 +6,13 @@ require 'rake/testtask'
 
 spec = Gem::Specification.new do |s|
   s.name = 'backupgem'
-  s.version = '0.0.9'
+  s.version = '0.0.11'
   s.author = "Nate Murray"
   s.email = "nate@natemurray.com"
   s.homepage = "http://tech.natemurray.com/backup"
   s.platform = Gem::Platform::RUBY
   s.summary = "Beginning-to-end solution for backups and rotation."
-  s.files = FileList["{bin,lib,tests,examples,doc}/**/*.{txt,html,css}"].to_a
+  s.files = FileList["{bin,lib,tests,examples,doc}/**/*"].to_a
   s.require_path = "lib"
   s.autorequire = "backupgem"
   s.test_files = FileList["{tests}/**/*test.rb"].to_a

data/bin/commands.sh

@@ -0,0 +1,2 @@
+#!/bin/bash
+./bin/backup --recipe examples/mediawiki.rb

data/examples/global.rb

@@ -0,0 +1,28 @@
+#------------------------------------------------------------------------------
+# Global Settings for Backup 
+# This file sets the global settings for all recipes in the same directory
+# @author: Nate Murray <nate@natemurray.com>
+#------------------------------------------------------------------------------
+
+# This file specifies many, but not all, of the setting you can change for Backup.
+# Any setting that is set to the default is commented out. Uncomment and
+# change any to your liking.
+
+# A single or array of servers to execute the backup tasks on
+# set :servers,             %w{ localhost someotherhost }  # default: localhost
+
+# The directory to place the backup on the backup server
+set :backup_path, "/var/local/backups/mediawiki"
+
+# Name of the SSH user
+# set :ssh_user,            ENV['USER']
+
+# Path to your SSH key
+# set :identity_key,        ENV['HOME'] + "/.ssh/id_rsa"
+
+# Set global actions
+# action :compress, :method => :tar_bz2   # tar_bz2 is the default
+# action :deliver,  :method => :mv        # mv is the default
+# action :encrypt,  :method => :gpg       # gpg is the default
+
+set :tmp_dir, File.dirname(__FILE__) + "/../tmp"

data/examples/mediawiki.rb

@@ -0,0 +1,24 @@
+#------------------------------------------------------------------------------
+# Mediawiki Backup script
+# @author: Nate Murray <nate@natemurray.com>
+#------------------------------------------------------------------------------
+action(:content) do 
+  dump = c[:tmp_dir] + "/test.sql"
+  sh "mysqldump -uroot test > #{dump}"
+  # should something happen here to cleanup the last task? maybe something
+  # should happen to the stack. like if the next task goes through then you
+  # remove he last file from the stack. Ah. if everything goes well you clean
+  # up everything from the stack. 
+  dump
+end
+
+# action :compress, :method => :tar_bz2   # could be set in global
+# action :deliver,  :method => :scp       # could be set in global
+
+# settings for backup servers are global unless specified otherwise
+# rotate settings are global unless specified herer
+
+
+
+
+

data/examples/mediawiki_numeric.rb

@@ -0,0 +1,19 @@
+#------------------------------------------------------------------------------
+# Mediawiki Backup script
+# Uses numeric rotation instead of temporal
+# @author: Nate Murray <nate@natemurray.com>
+#------------------------------------------------------------------------------
+action(:content) do 
+  dump = c[:tmp_dir] + "/test.sql"
+  sh "mysqldump -uroot test > #{dump}"
+  dump
+end
+
+set :rotation_mode,              :numeric # base our rotation on numbers not dates
+set :sons_promoted_after,        3        # upgrade to father after 3 sons 
+set :fathers_promoted_after,     1 
+
+
+
+
+

data/examples/s3.rb

@@ -0,0 +1,35 @@
+#------------------------------------------------------------------------------
+# Example S3 Backup script
+# @author: Jason L. Perry <jasper@ambethia.com>
+#------------------------------------------------------------------------------
+
+# Set the name of the s3 bucket you want to store your backups in.
+# Your Access ID is prepended to this to avoid naming conflicts.
+set :backup_path, "database_backup" 
+
+# You can specify your keys here, or set them as environment variables:
+# AMAZON_ACCESS_KEY_ID
+# AMAZON_SECRET_ACCESS_KEY
+set :aws_access, '123'
+set :aws_secret, 'ABC'
+
+# S3 does not support renaming objects, so rotation data is stored in an
+# index. You can specify a different key for index here, if you need to.
+#
+# set :rotation_object_key, 'backup_rotation_index.yml'
+
+action(:content) do
+  dump = c[:tmp_dir] + "/databases.sql" 
+  sh "mysqldump -uroot --all-databases > #{dump}" 
+  dump
+end
+
+action :deliver,  :method => :s3
+action :rotate,   :method => :via_s3
+
+set :son_promoted_on,    :fri
+set :father_promoted_on, :last_fri_of_the_month
+
+set :sons_to_keep,         7  
+set :fathers_to_keep,      5
+set :grandfathers_to_keep, 12

data/lib/backup.rb

@@ -0,0 +1,24 @@
+require 'rubygems'
+require 'runt'
+require 'date'
+require 'backup/configuration'
+require 'backup/extensions'
+require 'backup/ssh_helpers'
+require 'backup/date_parser'
+require 'backup/state_recorder'
+
+begin
+  require 'aws/s3'
+  require 'backup/s3_helpers'
+rescue LoadError
+  # If AWS::S3 is not installed, no worries, we just
+  # wont have access to s3 methods. It's worth noting
+  # at least version 1.8.4 of ruby is required for s3.
+end
+
+begin
+  require 'madeleine'
+rescue LoadError
+  # If you don't have madeleine then you just cant use numeric rotation mode
+  ::NO_NUMERIC_ROTATION = true
+end

data/lib/backup/actor.rb

@@ -0,0 +1,208 @@
+require 'rake'
+
+module Backup
+  include FileUtils
+  # An Actor is the entity that actually does the work of determining which
+  # servers should be the target of a particular task, and of executing the
+  # task on each of them in parallel. An Actor is never instantiated
+  # directly--rather, you create a new Configuration instance, and access the
+  # new actor via Configuration#actor.
+  class Actor
+    # The configuration instance associated with this actor.
+    attr_reader :configuration
+
+    # Alias for #configuration
+    alias_method :c, :configuration
+
+    # A hash of the tasks known to this actor, keyed by name. The values are
+    # instances of Actor::Action.
+    attr_reader :action
+
+    # A stack of the results of the actions called
+    attr_reader :result_history
+
+    # the rotator instance
+    attr_reader :rotator
+
+    # Returns an Array of Strings specifying dirty files. These files will be
+    # +rm -rf+ when the +cleanup+ task is called.
+    attr_reader :dirty_files
+
+    class Action #:nodoc:
+      attr_reader :name, :actor, :options
+
+      def initialize(name, actor, options)
+        @name, @actor, @options = name, actor, options
+      end
+    end
+
+    def initialize(config) #:nodoc:
+      @configuration = config
+      @action = {}
+      @result_history = []
+      @dirty_files = []
+      @rotator = Backup::Rotator.new(self)
+    end
+
+    # each action in the action_order is part of the chain. so you start by
+    # setting the output as 'nil' then you try to call before_ action, then
+    # store the output, then cal action with the args if action takes the args
+    # you are sending. if it doesnt give an intelligent error message. do this
+    # for all actions. then call after_action with the output if it exists.
+    # each time out are calilng the method with the arguemtns f the method
+    # exists and the method takes the arguments.     
+    def start_process!
+      configuration[:action_order].each do |a|
+        self.send_and_store("before_" + a)
+        self.send_and_store(a)
+        self.send_and_store("after_"  + a)
+      end
+      last_result
+    end
+
+    def send_and_store(name) 
+        store_result self.send(name) if self.respond_to? name 
+    end
+
+    # Define a new task for this actor. The block will be invoked when this
+    # task is called.
+    # todo, this might be more complex if the before and after tasks are going
+    # to be part of the input and output chain
+    def define_action(name, options={}, &block)
+      @action[name] = (options[:action_class] || Action).new(name, self, options)
+
+      if self.respond_to?(name) && !( block_given? || options[:method] )
+        # if it was already defined and we aren't trying to re-define it then
+        # what we are trying to do is define it the same way it is defined now
+        # only with options being sent to it. 
+        metaclass.send(:alias_method, "old_#{name}".intern, name)
+        #self.class.send(:alias_method, "old_#{name}".intern, name)
+        #define_method("#{name.to_s}_new".intern) do
+        define_method(name) do
+          begin
+           result =  self.send("old_#{name}", options)
+          end
+          result
+        end
+        return
+      end
+
+      define_method(name) do
+        #logger.debug "executing task #{name}"
+        begin
+          if block_given?
+            result = instance_eval( &block )
+          elsif options[:method]
+            #result = self.send(options[:method], options[:args])
+            result = self.send(options[:method])
+            # here we need to have a thing where we can send the arguments
+            # define the method 'content' so that would take the other options
+            # if there are options (any hash) just send along that hash. this needs more work
+          end
+        end
+        result
+      end
+
+    end
+
+    def metaclass
+      class << self; self; end
+    end
+
+    # rotate Actions
+    def via_mv;  rotator.rotate_via_mv(last_result);   end
+    def via_ssh; rotator.rotate_via_ssh(last_result);  end
+    def via_ftp; rotator.rotate_via_ftp(last_result);  end
+    def via_s3;  rotator.rotate_via_s3(last_result);   end
+
+    # By default, +:content+ can perform one of three actions
+    # * +:is_file+
+    # * +:is_folder+
+    # + +:is_contents_of+
+    # 
+    # Examples:
+    #   action :content, :is_file        => "/path/to/file"          # content is a single file
+    #   action :content, :is_folder      => "/path/to/folder"        # content is the folder itself
+    #   action :content, :is_contents_of => "/path/to/other/folder"  # files in folder/
+    # 
+    # +:is_file+ and +:is_folder+ are basically the same thing in that they
+    # backup the whole file/folder whereas +:is_contents_of+ backs up the
+    # <em>contents</em> of the given folder.
+    #
+    # Note that +:is_contents_of+ performs a very spcific action: 
+    # * a temporary directory is created
+    # * all of the files are moved (including subdirectories) into the temporary directory
+    # * the archive is created from the temporary directory
+    #
+    # If you wish to copy the files out of the original directory instead of
+    # moving them. Then you may specify the +copy+ option passing a +true+
+    # value like so:
+    #
+    #   action :content, :is_contents_of => "/path/to/other/folder",
+    #                              :copy => true
+    #
+    # This will copy recursively. 
+    #
+    # If this is not your desired behavior then you can easily write your own.
+    # Also, these options only work for local files. If you are getting the
+    # files from a foreign server you will have to write a custom +:content+
+    # method.
+    #
+    def content(opts={})
+      return opts[:is_file]        if opts[:is_file] 
+      return opts[:is_folder]      if opts[:is_folder]
+      if opts[:is_contents_of]
+        orig   = opts[:is_contents_of]
+        tmpdir = c[:tmp_dir] + "/tmp_" + Time.now.strftime("%Y%m%d%H%M%S") +"_#{rand}"
+        new_orig = tmpdir + "/" + File.basename(orig)
+        mkdir_p tmpdir
+        mkdir_p new_orig
+        if opts[:copy]
+          cp_r orig + '/.', new_orig
+        else
+          mv orig + '/.', new_orig
+        end
+        dirty_file new_orig
+        return new_orig
+      end
+      if opts[:is_hg_repository]
+        orig = opts[:is_hg_repository]
+        name = opts[:as] || File.basename(orig)
+        new_orig = c[:tmp_dir] + '/' + name
+        sh "hg clone #{orig} #{new_orig}"
+        dirty_file new_orig
+        return new_orig
+      end
+      raise "Unknown option in :content. Try :is_file, :is_folder " +
+            ":is_contents_of or :is_hg_repository"
+    end
+
+    # Given name of a file in +string+ adds that file to @dirty_files. These
+    # files will be removed when the +cleanup+ task is called.
+    def dirty_file(string)
+      @dirty_files << string
+    end
+
+    # +cleanup+ takes every element from @dirty_files and performs an +rm -rf+ on the value
+    def cleanup(opts={})
+      dirty_files.each do |f|
+        rm_rf f
+      end
+    end
+
+    private
+      def define_method(name, &block)
+        metaclass.send(:define_method, name, &block)
+      end
+
+      def store_result(result)
+        @result_history.push result 
+      end
+
+      def last_result
+        @result_history.last
+      end
+
+  end
+
+end

data/lib/backup/actor.rb.orig

@@ -0,0 +1,200 @@
+require 'rake'
+
+module Backup
+  include FileUtils
+  # An Actor is the entity that actually does the work of determining which
+  # servers should be the target of a particular task, and of executing the
+  # task on each of them in parallel. An Actor is never instantiated
+  # directly--rather, you create a new Configuration instance, and access the
+  # new actor via Configuration#actor.
+  class Actor
+    # The configuration instance associated with this actor.
+    attr_reader :configuration
+
+    # Alias for #configuration
+    alias_method :c, :configuration
+
+    # A hash of the tasks known to this actor, keyed by name. The values are
+    # instances of Actor::Action.
+    attr_reader :action
+
+    # A stack of the results of the actions called
+    attr_reader :result_history
+
+    # the rotator instance
+    attr_reader :rotator
+
+    # Returns an Array of Strings specifying dirty files. These files will be
+    # +rm -rf+ when the +cleanup+ task is called.
+    attr_reader :dirty_files
+
+    class Action #:nodoc:
+      attr_reader :name, :actor, :options
+
+      def initialize(name, actor, options)
+        @name, @actor, @options = name, actor, options
+      end
+    end
+
+    def initialize(config) #:nodoc:
+      @configuration = config
+      @action = {}
+      @result_history = []
+      @dirty_files = []
+      @rotator = Backup::Rotator.new(self)
+    end
+
+    # each action in the action_order is part of the chain. so you start by
+    # setting the output as 'nil' then you try to call before_ action, then
+    # store the output, then cal action with the args if action takes the args
+    # you are sending. if it doesnt give an intelligent error message. do this
+    # for all actions. then call after_action with the output if it exists.
+    # each time out are calilng the method with the arguemtns f the method
+    # exists and the method takes the arguments.     
+    def start_process!
+      configuration[:action_order].each do |a|
+        self.send_and_store("before_" + a)
+        self.send_and_store(a)
+        self.send_and_store("after_"  + a)
+      end
+      last_result
+    end
+
+    def send_and_store(name) 
+        store_result self.send(name) if self.respond_to? name 
+    end
+
+    # Define a new task for this actor. The block will be invoked when this
+    # task is called.
+    # todo, this might be more complex if the before and after tasks are going
+    # to be part of the input and output chain
+    def define_action(name, options={}, &block)
+      @action[name] = (options[:action_class] || Action).new(name, self, options)
+
+      if self.respond_to?(name) && !( block_given? || options[:method] )
+        # if it was already defined and we aren't trying to re-define it then
+        # what we are trying to do is define it the same way it is defined now
+        # only with options being sent to it. 
+        metaclass.send(:alias_method, "old_#{name}".intern, name)
+        #self.class.send(:alias_method, "old_#{name}".intern, name)
+        #define_method("#{name.to_s}_new".intern) do
+        define_method(name) do
+          begin
+           result =  self.send("old_#{name}", options)
+          end
+          result
+        end
+        return
+      end
+
+      define_method(name) do
+        #logger.debug "executing task #{name}"
+        begin
+          if block_given?
+            result = instance_eval( &block )
+          elsif options[:method]
+            #result = self.send(options[:method], options[:args])
+            result = self.send(options[:method])
+            # here we need to have a thing where we can send the arguments
+            # define the method 'content' so that would take the other options
+            # if there are options (any hash) just send along that hash. this needs more work
+          end
+        end
+        result
+      end
+
+    end
+
+    def metaclass
+      class << self; self; end
+    end
+
+    # rotate Actions
+    def via_mv;  rotator.rotate_via_mv(last_result);   end
+    def via_ssh; rotator.rotate_via_ssh(last_result);  end
+    def via_ftp; rotator.rotate_via_ftp(last_result);  end
+    def via_s3;  rotator.rotate_via_s3(last_result);   end
+
+    # By default, +:content+ can perform one of three actions
+    # * +:is_file+
+    # * +:is_folder+
+    # + +:is_contents_of+
+    # 
+    # Examples:
+    #   action :content, :is_file        => "/path/to/file"          # content is a single file
+    #   action :content, :is_folder      => "/path/to/folder"        # content is the folder itself
+    #   action :content, :is_contents_of => "/path/to/other/folder"  # files in folder/
+    # 
+    # +:is_file+ and +:is_folder+ are basically the same thing in that they
+    # backup the whole file/folder whereas +:is_contents_of+ backs up the
+    # <em>contents</em> of the given folder.
+    #
+    # Note that +:is_contents_of+ performs a very spcific action: 
+    # * a temporary directory is created
+    # * all of the files are moved (including subdirectories) into the temporary directory
+    # * the archive is created from the temporary directory
+    #
+    # If you wish to copy the files out of the original directory instead of
+    # moving them. Then you may specify the +copy+ option passing a +true+
+    # value like so:
+    #
+    #   action :content, :is_contents_of => "/path/to/other/folder",
+    #                              :copy => true
+    #
+    # This will copy recursively. 
+    #
+    # If this is not your desired behavior then you can easily write your own.
+    # Also, these options only work for local files. If you are getting the
+    # files from a foreign server you will have to write a custom +:content+
+    # method.
+    #
+    def content(opts={})
+      return opts[:is_file]        if opts[:is_file] 
+      return opts[:is_folder]      if opts[:is_folder]
+      if opts[:is_contents_of]
+        orig   = opts[:is_contents_of]
+        tmpdir = c[:tmp_dir] + "/tmp_" + Time.now.strftime("%Y%m%d%H%M%S") +"_#{rand}"
+        new_orig = tmpdir + "/" + File.basename(orig)
+        mkdir_p tmpdir
+        mkdir_p new_orig
+        if opts[:copy]
+          cp_r orig + '/.', new_orig
+        else
+          mv orig + '/.', new_orig
+        end
+        dirty_file new_orig
+        return new_orig
+      end
+      raise "Unknown option in :content. Try :is_file, :is_folder " +
+            "or :is_contents_of"
+    end
+
+    # Given name of a file in +string+ adds that file to @dirty_files. These
+    # files will be removed when the +cleanup+ task is called.
+    def dirty_file(string)
+      @dirty_files << string
+    end
+
+    # +cleanup+ takes every element from @dirty_files and performs an +rm -rf+ on the value
+    def cleanup(opts={})
+      dirty_files.each do |f|
+        rm_rf f
+      end
+    end
+
+    private
+      def define_method(name, &block)
+        metaclass.send(:define_method, name, &block)
+      end
+
+      def store_result(result)
+        @result_history.push result 
+      end
+
+      def last_result
+        @result_history.last
+      end
+
+  end
+
+end