backupgemsteven 0.1.2

data/doc/styles.css

@@ -0,0 +1,157 @@
+/* Layout */
+html,body{margin:0;padding:0}
+body{font: 100% arial,sans-serif}
+p{margin:0 10px 10px}
+a{color: #981793;}
+div#header h1{height:80px;line-height:80px;margin:0;
+  padding-left:10px;background: #EEE;color: #79B30B}
+div#content p{line-height:1.4}
+div#navigation{background:#B9CAFF}
+div#extra{background:#FF8539}
+div#footer{background: #333;color: #FFF}
+div#footer p{margin:0;padding:5px 10px}
+div#wrapper{float:right;width:100%;margin-left:-205px}
+div#content{margin-left:205px}
+
+div#navigation {
+  float:left;
+  width:200px;
+  margin-right: 5px;
+}
+
+div#extra{float:left;clear:left;width:200px}
+div#footer{clear:both;width:100%}
+
+
+/* Styles */
+body {
+    background-color: white;
+    color: #222;
+    font-family: Georgia, Times, serif;
+    line-height: 110%;
+}
+
+/* Code styling */
+.example {
+    border: solid 1px #C9B;
+    background-color: #FFF5F9;
+    padding: 3px;
+    margin: 5px 40px 5px 22px;
+}
+
+pre {
+    background-color: #FFFEF9;
+    color: #936;
+    padding: 5px;
+    margin: 0px;
+    line-height: 170%;
+}
+
+blockquote code, p code, li code {
+    color: #936;
+    font-style: normal;
+    background-color: #FFFEF9;
+    padding: 2px;
+    line-height: 170%;
+    font-size: 12pt;
+}
+
+p code, li code {
+  line-height: 100%;
+  padding: 0px;
+  font-size: 130%;
+}
+
+blockquote code {
+    padding: 5px;
+    font-size: .9em;
+}
+
+div#content li {
+  margin-bottom: 5px;
+}
+
+div.longlist li  {
+  padding-bottom: 8px;
+}
+
+.last_updated {
+  margin-left: 60%;
+  text-align: right;
+  font-size:80%;
+}
+
+
+/* syntax highlighting */
+.keyword {
+    font-weight: bold;
+}
+.comment {
+    color: #555;
+}
+.string, .number {
+    color: #396;
+}
+.string {
+    background-color: #E9F5F5;
+}
+.regex {
+    background-color: #E9F1F5;
+    color: #435;
+}
+.ident {
+    color: #369;
+}
+.symbol {
+    color: #000;
+}
+.constant, .class {
+    color: #630;
+    font-weight: bold;
+}
+
+/* tables */
+table {
+  margin: 1em 1em 1em 0;
+  background: #f9f9f9;
+  border: 1px #aaaaaa solid;
+  border-collapse: collapse;
+}
+
+th, td {
+  border: 1px #aaaaaa solid;
+  padding: 0.2em;
+}
+
+th {
+  background: #f2f2f2;
+  text-align: center;
+}
+
+/* navigation */
+div#navigation a, div#extra a {
+  color: #08052B;
+  text-decoration: none;
+}
+
+div#navigation a:hover, div#extra a:hover {
+  text-decoration: underline;
+}
+
+div#navigation ol, div#extra ul {
+  margin-left: 6px;
+  padding-left: 20px;
+}
+
+div#navigation ol ol {
+  padding-left: 20px;
+}
+
+div#navigation ol ol li a, ol ol li {
+  color: #424E75;
+  font-size: 90%;
+}
+
+.rightad {
+  float: right;
+}

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,23 @@
+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 'right_aws'
+  require 'backup/s3_helpers'
+rescue LoadError
+  # If RightAWS is not installed, no worries, we just
+  # wont have access to s3 methods.
+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