backupgem 0.0.8 → 0.0.9

data/lib/backup/cli.rb

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

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

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

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

@@ -1,111 +0,0 @@
-#------------------------------------------------------------------------------
-# 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.
-#------------------------------------------------------------------------------
-
-# 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, "/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