backupgem 0.0.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 :delivery, :method => :scp       # could be set in global
+
+# settings for backup servers are global unless specified otherwise
+# rotate settings are global unless specified herer
+
+
+
+
+

data/lib/backup/actor.rb

@@ -0,0 +1,196 @@
+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? 
+        # 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
+
+    # 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)
+        sh "mkdir #{tmpdir}"
+        sh "mkdir #{new_orig}"
+        cmd = opts[:copy] ? "cp -r" : "mv"
+        sh "#{cmd} #{orig}/* #{new_orig}/"
+        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|
+        sh "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/cli.rb

@@ -0,0 +1,105 @@
+require 'optparse'
+require 'backup'
+
+module Backup
+  # The CLI class encapsulates the behavior of backup when it is invoked
+  # as a command-line utility.
+  class CLI
+    # Invoke capistrano using the ARGV array as the option parameters. 
+    def self.execute!
+      new.execute!
+    end
+
+    # The array of (unparsed) command-line options
+    attr_reader :args
+
+    # The hash of (parsed) command-line options
+    attr_reader :options
+ 
+    # Docs for creating a new instance go here
+    def initialize(args = ARGV)
+      @args = args
+      @options = { :recipes => [], :actions  => [], 
+                      :vars => {}, # :pre_vars => {}, 
+                    :global => nil  }
+
+      OptionParser.new do |opts|
+        opts.banner = "Usage: #{$0} [options] [args]"
+
+        opts.separator ""
+        opts.separator "Recipe Options -----------------------"
+        opts.separator ""
+
+        opts.on("-r", "--recipe RECIPE",
+          "A recipe file to load. Multiple recipes may",
+          "be specified, and are loaded in the given order."
+        ) { |value| @options[:recipes] << value }
+
+        opts.on("-s", "--set NAME=VALUE",
+          "Specify a variable and it's value to set. This",
+          "will be set after loading all recipe files."
+        ) do |pair|
+          name, value = pair.split(/=/, 2)
+          @options[:vars][name.to_sym] = value
+        end
+
+        opts.on("-g", "--global RECIPE",
+          "Specify a specific file to load as the global file",
+          "for the recipes. By default the recipes load the",
+          "file +global.rb+ in the same directory." 
+        ) { |value| @options[:recipes] << value }
+
+        if args.empty?
+          puts opts
+          exit
+        else
+          opts.parse!(args)
+        end
+
+        check_options!
+
+      end
+
+    end
+
+    # Begin running Backup based on the configured options.
+    def execute!
+      #if !@options[:recipes].empty? # put backk
+        execute_recipes!
+      # elsif @options[:apply_to]
+      #  execute_apply_to!
+      #end
+    end
+
+
+    private
+      def check_options!
+        # performa sanity check
+      end
+
+      # Load the recipes specified by the options, and execute the actions
+      # specified.
+      def execute_recipes!
+        config = Backup::Configuration.new
+        #config.logger.level = options[:verbose]
+        #options[:pre_vars].each { |name, value| config.set(name, value) }
+        options[:vars].each { |name, value| config.set(name, value) }
+
+        # load the standard recipe definition
+        config.load "standard"
+        options[:recipes].each do |recipe| 
+          global = options[:global] || File.dirname(recipe) + "/global.rb"
+          config.load global if File.exists? global    # cache this?
+        end
+        options[:recipes].each { |recipe| config.load(recipe) }
+        #options[:vars].each { |name, value| config.set(name, value) }
+
+        actor = config.actor
+        actor.start_process! # eventually make more options, like the ability
+                             # to run each action individually
+        #options[:actions].each { |action| actor.send action }
+      end
+
+  end    
+end
+

data/lib/backup/configuration.rb

@@ -0,0 +1,138 @@
+require 'backup/actor'
+require 'backup/rotator'
+
+module Backup
+  # Represents a specific Backup configuration. A Configuration instance
+  # may be used to load multiple recipe files, define and describe tasks,
+  # define roles, create an actor, and set configuration variables.
+  class Configuration
+    # The actor created for this configuration instance.
+    attr_reader :actor
+
+    # The logger instance defined for this configuration.
+    attr_reader :logger
+
+    # The load paths used for locating recipe files.
+    attr_reader :load_paths
+
+    # The hash of variables currently known by the configuration
+    attr_reader :variables
+
+    def initialize(actor_class=Actor) #:nodoc:
+      @actor = actor_class.new(self)
+      #@logger = Logger.new
+      @load_paths = [".", File.join(File.dirname(__FILE__), "recipes")]
+      @variables = {}
+    end
+
+    # Set a variable to the given value.
+    def set(variable, value=nil, &block)
+      # if the variable is uppercase, then we add it as a constant to the
+      # actor. This is to allow uppercase "variables" to be set and referenced
+      # in recipes.
+      if variable.to_s[0].between?(?A, ?Z)
+        klass = @actor.metaclass
+        klass.send(:remove_const, variable) if klass.const_defined?(variable)
+        klass.const_set(variable, value)
+      end
+
+      value = block if value.nil? && block_given?
+      @variables[variable] = value
+    end
+
+    alias :[]= :set
+
+    def [](variable)
+      # TODO have it raise if it doesn exist
+      @variables[variable]
+    end
+
+    # Require another file. This is identical to the standard require method,
+    # with the exception that it sets the reciever as the "current" configuration
+    # so that third-party task bundles can include themselves relative to
+    # that configuration.
+    def require(*args) #:nodoc:
+      original, Backup.configuration = Backup.configuration, self
+      super
+    ensure
+      # restore the original, so that require's can be nested
+      Backup.configuration = original
+    end
+
+    # Disclaimer: This method written by Jamis Buck. Taken directly from his
+    # excellent code Capistrano.
+    #
+    # Load a configuration file or string into this configuration.
+    #
+    # Usage:
+    #
+    #   load("recipe"):
+    #     Look for and load the contents of 'recipe.rb' into this
+    #     configuration.
+    #
+    #   load(:file => "recipe"):
+    #     same as above
+    #
+    #   load(:string => "set :scm, :subversion"):
+    #     Load the given string as a configuration specification.
+    #
+    #   load { ... }
+    #     Load the block in the context of the configuration.
+    def load(*args, &block)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      args.each { |arg| load options.merge(:file => arg) }
+      return unless args.empty?
+
+      if block
+        raise "loading a block requires 0 parameters" unless args.empty?
+        load(options.merge(:proc => block))
+
+      elsif options[:file]
+        file = options[:file]
+        unless file[0] == ?/
+          load_paths.each do |path|
+            if File.file?(File.join(path, file))
+              file = File.join(path, file)
+              break
+            elsif File.file?(File.join(path, file) + ".rb")
+              file = File.join(path, file + ".rb")
+              break
+            end
+          end
+        end
+        load :string => File.read(file), :name => options[:name] || file
+
+      elsif options[:string]
+        #logger.trace "loading configuration #{options[:name] || "<eval>"}"
+        instance_eval(options[:string], options[:name] || "<eval>")
+
+      elsif options[:proc]
+        #logger.trace "loading configuration #{options[:proc].inspect}"
+        instance_eval(&options[:proc])
+
+      else
+        raise ArgumentError, "don't know how to load #{options.inspect}"
+      end
+    end
+
+    # Describe the next task to be defined. The given text will be attached to
+    # the next task that is defined and used as its description.
+    def desc(text)
+      @next_description = text
+    end
+
+    # Define a new task. If a description is active (see #desc), it is added to
+    # the options under the <tt>:desc</tt> key. This method ultimately
+    # delegates to Actor#define_task.
+    def action(name, options={}, &block)
+      # raise ArgumentError, "expected a block or method" unless block or options[:method]  # ?? 
+      if @next_description
+        options = options.merge(:desc => @next_description)
+        @next_description = nil
+      end
+
+      actor.define_action(name, options, &block)
+    end
+
+  end
+end

data/lib/backup/date_parser.rb

@@ -0,0 +1,37 @@
+module Backup
+  class DateParser
+
+    def self.date_from(what)
+      DateParser.new.date_from(what)
+    end
+
+    # the test is going to be whatever is returned here .include? the day of
+    # today. so if we want to do something every day than this needs to return
+    # something that will lincde the righ daY:W
+    def date_from(what) 
+      if what.kind_of?(Symbol)
+        return Runt::DIWeek.new( Time.num_from_day(what) ) if day_of_week?(what) 
+        return Runt::REDay.new(0,0,24,01) if what == :daily
+        if what.to_s =~ /^last_/
+          what.to_s =~ /^last_(\w+)_of_the_month$/
+          day = $1
+          return Runt::DIMonth.new(Runt::Last, Time.num_from_day(day.intern))
+        end
+      end
+      raise "#{what} is not a valid time" unless what.respond_to?(:include?)
+      what
+    end
+
+    private
+      def day_of_week?(word)
+        days_of_week.include?(word.to_s.downcase[0..2])
+      end
+
+      def days_of_week
+        %w{mon tue wed thu fri sat sun}
+      end
+
+  end
+end
+
+

data/lib/backup/extensions.rb

@@ -0,0 +1,17 @@
+class Time
+  def days_since_epoch
+    self.to_i / 60 / 60 / 24
+  end
+
+  def self.num_from_day(day)
+    days = { :sun => 0,
+             :mon => 1,
+             :tue => 2,
+             :wed => 3,
+             :thu => 4,
+             :fri => 5,
+             :sat => 6}
+    days[day]
+  end
+
+end