backupgem 0.0.9 → 0.0.11

data/lib/backup/cli.rb

@@ -0,0 +1,144 @@
+require 'optparse'
+require 'backup'
+require 'yaml'
+
+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]"
+
+        opts.separator ""
+        opts.separator "Recipe Options -----------------------"
+        opts.separator ""
+
+        opts.on("-r", "--recipe RECIPE ",
+          "A recipe file to load. Multiple recipes is DEPRECATED and not fully functional."
+        ) { |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 }
+
+        opts.on("-q", "--quiet",
+              "suppresses much of the output of backup, except",
+              "for error messages") { verbose(false) }
+
+        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!
+        # perform a 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_with_index do |recipe,i|
+          config.load(recipe) 
+          $state = setup_saved_state(recipe, config) 
+          warn "DEPRICATED: Using multiple recipes with one command is deprecated for the time being. Just run a different command if you want to do two recipes at the same time" if i > 0
+
+        end
+
+        #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
+
+      
+      # Setup the persistant state using madeline
+      def setup_saved_state(recipe, config)
+        if defined? ::NO_NUMERIC_ROTATION
+            if :numeric == config[:rotation_mode]
+              puts "Missing Gem: :numeric :rotation mode is not valid unless you have madeleine installed. try: 'gem install madeleine'"
+              exit 1
+            end
+            return nil
+        end
+
+        saved_state_folder = config[:saved_state_folder] || File.join(config[:backup_path], ".backupgem_#{File.basename(recipe)}_state")
+
+        state = SnapshotMadeleine.new(saved_state_folder, YAML) do
+          StateRecorder.new
+        end
+        state.system.saved_state_folder = saved_state_folder
+        state
+      end
+
+  end    
+end
+
+at_exit { 
+
+  if !defined?(::NO_NUMERIC_ROTATION) && defined?($state)
+    $state.take_snapshot
+    $state.system.cleanup_snapshots
+  end
+}
+

data/lib/backup/configuration.rb

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

data/lib/backup/recipes/standard.rb

@@ -0,0 +1,113 @@
+#------------------------------------------------------------------------------
+# Backup Global Settings
+# @author: Nate Murray <nate@natemurray.com>
+#   @date: Mon Aug 28 07:28:22 PDT 2006
+# 
+# The settings contained in this file will be global for all tasks and can be
+# overridden locally.
+#------------------------------------------------------------------------------
+# require 'tmpdir'
+
+# Sepcify sever settings
+set :servers,           %w{ localhost }
+set :action_order,      %w{ content compress encrypt deliver rotate cleanup }
+
+# Name of the SSH user
+set :ssh_user,          ENV['USER']
+
+# default port
+set :port,          22 # todo, change to ssh_port
+
+# Path to your SSH key
+set :identity_key,      ENV['HOME'] + "/.ssh/id_rsa"
+
+# Set global actions
+action :compress, :method => :tar_bz2 
+action :deliver,  :method => :mv      # action :deliver,  :method => :scp    
+action :rotate,   :method => :via_mv  # action :rotate,   :method => :via_ssh
+# action :encrypt,  :method => :gpg
+
+# Specify a directory that backup can use as a temporary directory
+# set :tmp_dir, Dir.tmpdir
+set :tmp_dir, "/tmp"
+
+# Options to be passed to gpg when encrypting
+set :encrypt, false
+set :gpg_encrypt_options, ""
+
+# These settings specify the rotation variables
+# Rotation method. Currently the only method is gfs, grandfather-father-son. 
+# Read more about that below
+set :rotation_method,  :gfs
+
+# rotation mode - temporal or numeric. For instance
+# temporal mode would continue to be the default and work with
+# :son_promoted_on. The promotions are based on days. This works well for 1 backup per day.
+# numeric works by promoting after every number of creations. This is better for multiple backups per day.
+# numeric mode uses :sons_promoted_after
+set :rotation_mode, :temporal
+
+# :mon-sun
+# :last_day_of_the_month # whatever son_promoted on son was, but the last of the month
+# everything else you can define with a Runt object
+# set :son_created_on,     :every_day - if you dont want a son created dont run the program
+# a backup is created every time the program is run
+
+set :son_promoted_on,    :fri
+set :father_promoted_on, :last_fri_of_the_month
+
+# more complex
+# mon_wed_fri = Runt::DIWeek.new(Runt::Mon) | 
+#               Runt::DIWeek.new(Runt::Wed) | 
+#               Runt::DIWeek.new(Runt::Fri)
+# set :son_promoted_on, mon_wed_fri
+
+set :sons_to_keep,         14
+set :fathers_to_keep,       6
+set :grandfathers_to_keep,  6   # 6 months, by default
+
+# These options are only used if :rotation_mode is :numeric.
+# This is better if you are doing multiple backups per day.
+# This setting says that every 14th son will be promoted to a father. 
+set :sons_promoted_after,         14
+set :fathers_promoted_after,       6
+
+# -------------------------
+# Standard Actions
+# -------------------------
+action(:tar_bz2) do
+  name = c[:tmp_dir] + "/" + File.basename(last_result) + ".tar.bz2"
+  v = "v" if verbose
+  sh "tar -c#{v}jf #{name} #{last_result}"
+  name
+end
+
+action(:scp) do
+  # what should the default scp task be?
+  # scp the local file to the foreign directory. same name.
+  c[:servers].each do |server|
+    host = server =~ /localhost/ ? "" : "#{server}:"
+    sh "scp #{last_result} #{c[:ssh_user]}@#{host}#{c[:backup_path]}/"
+  end
+  c[:backup_path] + "/" + File.basename(last_result)  
+end
+
+action(:mv) do
+  move last_result, c[:backup_path]  # has to be move (not mv) to avoid infinite
+                                     # recursion
+  c[:backup_path] + "/" + File.basename(last_result)
+end
+
+action(:s3) do
+  s3 = S3Actor.new(c)
+  s3.put last_result
+end
+
+action(:encrypt) do
+  result = last_result
+  if c[:encrypt]
+    sh "gpg #{c[:gpg_encrypt_options]} --encrypt #{last_result}"
+    result = last_result + ".gpg" # ?
+  end
+  result
+end