lsync 1.2.1

data/lib/lsync/actions/generic/rotate

@@ -0,0 +1,75 @@
+#!/usr/bin/env ruby
+
+# This script takes a given path, and renames it with the given format. 
+# It then ensures that there is a symlink called "latest" that points 
+# to the renamed directory.
+
+require 'pathname'
+require 'fileutils'
+require 'optparse'
+
+OPTIONS = {
+  :Format => "%Y.%m.%d-%H.%M.%S",
+  :Latest => "latest",
+  :UseGMT => true,
+  :Destination => nil
+}
+
+ARGV.options do |o|
+  script_name = File.basename($0)
+
+  o.set_summary_indent('  ')
+  o.banner = "Usage: #{script_name} [options] [directory]"
+  o.define_head "This script is used to rotate directories."
+
+  o.separator ""
+  o.separator "Help and Copyright information"
+
+  o.on("-f format", String, "Set the format of the rotated directory names. See Time$strftime") do |format| 
+    OPTIONS[:Format] = format
+  end
+  
+  o.on("-l latest", String, "Set the name for the latest rotation symlink.") do |latest|
+    OPTIONS[:Latest] = latest
+  end
+
+  o.on("-d destination", String, "Set the directory to move rotated backups.") do |destination|
+    OPTIONS[:Destination] = destination
+  end
+
+  o.on_tail("--copy", "Display copyright information") do
+    puts "#{script_name}. Copyright (c) 2008-2009 Samuel Williams. Released under the GPLv3."
+    puts "See http://www.oriontransfer.co.nz/ for more information."
+
+    exit
+  end
+
+  o.on_tail("-h", "--help", "Show this help message.") do
+    puts o
+    exit
+  end
+end.parse!
+
+time = Time.now
+
+if OPTIONS[:UseUTC]
+  time = time.utc
+end
+
+dir = Pathname.new(ARGV[0] || ".inprogress")
+rotation_dir = Pathname.new(OPTIONS[:Destination] ? OPTIONS[:Destination] : dir.dirname)
+rotated_name = time.strftime(OPTIONS[:Format])
+rotated_dir = rotation_dir + rotated_name
+latest_link = rotation_dir + OPTIONS[:Latest]
+
+# Move rotated dir
+FileUtils.mv(dir, rotated_dir)
+
+# Recreate latest symlink
+if File.symlink?(latest_link)
+  puts "Removing old latest link..."
+  FileUtils.rm(latest_link)
+end
+
+puts "Creating latest symlink to #{rotated_name}"
+FileUtils.ln_s(rotated_name, latest_link)

data/lib/lsync/actions/linux/disk

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+Commands = {
+  "mount" => "mount",
+  "unmount" => "umount"
+}
+
+DevicePaths = [
+  "/dev/disk/by-label",
+  "/dev/disk/by-uuid",
+  "/dev"
+]
+
+action = ARGV[0]
+disk_name = ARGV[1]
+
+mountpoint = File.join('', 'mnt', disk_name)
+
+if (action == 'mountpoint')
+	puts File.join(mountpoint, ARGV[2..-1])
+else
+  puts "#{action.capitalize}ing #{mountpoint}..."
+  system Commands[action], mountpoint
+  
+  if $?.exitstatus != 0 or $?.exitstatus != 3383
+    exit 5
+  end
+end

data/lib/lsync/actions/linux/terminal

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'base64'
+cmd = Base64.decode64(ARGV[0])
+exec cmd
+

data/lib/lsync/backup_error.rb

@@ -0,0 +1,33 @@
+
+module LSync
+  
+  class BackupError < StandardError
+    def initialize(reason, components = {})
+      @reason = reason
+      @components = components
+    end
+    
+    def to_s
+      @reason
+    end
+    
+    attr :reason
+    attr :components
+  end
+  
+  class BackupScriptError < BackupError
+  end
+  
+  class BackupMethodError < BackupError
+  end
+  
+  class ConfigurationError < BackupError
+  end
+  
+  class BackupActionError < BackupError
+    def initialize(server, action, exception)
+      super("Backup action failed: #{action} (#{exception.to_s})", :action => action, :exception => exception)
+    end
+  end
+  
+end

data/lib/lsync/backup_plan.rb

@@ -0,0 +1,249 @@
+
+# A backup plan is a rule-based engine to process individual scripts.
+# Failure and success can be delt with over multiple scripts.
+
+require 'ruleby'
+
+module Ruleby
+  def self.engine(name, &block)
+    e = Core::Engine.new
+    yield e if block_given?
+    return e
+  end
+end
+
+module LSync
+
+  BuiltInCommands = {
+    "ping-host" => "ping -c 4 -t 5 -o"
+  }
+
+  module Facts
+    class Initial
+    end
+
+    class StageSucceeded
+      def initialize(stage)
+        @stage = stage
+        puts "Stage Succeeded: #{@stage.name}"
+      end
+
+      attr :stage
+
+      def name
+        @stage.name
+      end
+    end
+
+    class StageFailed
+      def initialize(stage)
+        @stage = stage
+      end
+
+      attr :stage
+
+      def name
+        @stage.name
+      end
+    end
+
+    class ScriptSucceeded
+      def initialize(stage, script)
+        @stage = stage
+        @script = script
+      end
+
+      attr :stage
+      attr :script
+    end
+
+    class ScriptFailed
+      def initialize(stage, script)
+        @stage = stage
+        @script = script
+      end
+
+      attr :stage
+      attr :script
+    end
+  end
+
+  class BackupPlanRulebook < Ruleby::Rulebook
+    include Facts
+
+    def rules
+      #rule [ScriptSucceeded, :m] do |v|
+      #	script = v[:m].script
+      #  puts "Backup #{script.dump} successful"
+      #end
+
+      rule [ScriptFailed, :m] do |v|
+        script = v[:m].script
+        puts "*** Script #{script} failed"
+      end
+
+      #rule [StageSucceeded, :m] do |v|
+      #	stage = v[:m].stage
+      #  puts "Stage #{stage.name.dump} successful"
+      #end
+    end
+  end
+
+  class StageRulebook < Ruleby::Rulebook
+    include Facts
+
+    def initialize(engine, stage)
+      super(engine)
+      @stage = stage
+    end
+
+    def rules
+      # Does this stage have any rules? (i.e. can it run in any case?)
+      if @stage.rules.size > 0
+        puts "Loading rules for stage #{@stage.name.dump}..."
+        @stage.rules.each do |name, r|
+          puts "\t#{name}..."
+
+          r["when"].each do |s|
+            puts "\t\t#{s.dump}"
+          end
+
+          options = r.dup
+          wh = options.delete("when")
+
+          # Build rule
+          rule("#{@stage.name}_#{name}".to_sym, options, *wh) do |v|
+            @stage.run_scripts
+          end
+        end
+      end
+    end
+
+    # Bring names into the right scope (i.e. Facts)
+    def __eval__(x)
+      eval(x)
+    end
+  end
+
+  class Stage
+    protected
+    RuleConfigKeys = Set.new(["priority", "when"])
+
+    def process_rules config			
+      rules = config.keys_matching(/^rule\.(.*)$/)
+
+      if rules.size > 0
+        # Okay
+      elsif config.key? "when"
+        rules = {
+          "rule.default" => config.delete_if { |k,v| !RuleConfigKeys.include?(k) }
+        }
+      else
+        return {}
+      end
+
+      rules.keys.each do |rule_name|
+        options = {}
+        w = rules[rule_name].delete("when") || []
+        w = [w] if w.is_a? String
+
+        rules[rule_name].each { |k,v| options[k.to_sym] = v }
+        rules[rule_name] = options
+        rules[rule_name]["when"] = w.collect { |s| s.gsub('@', '#') }
+      end
+
+      rules
+    end
+
+    def process_scripts config
+      config["scripts"].collect do |s|
+        s.match(/^([^\s]+)(.*)$/)
+
+        if BuiltInCommands.key? $1
+          BuiltInCommands[$1] + $2
+        else
+          s
+        end
+      end
+    end
+
+    public
+    def initialize(plan, name, config)
+      @plan = plan
+      @name = name
+
+      @scripts = process_scripts(config)
+      @rules = process_rules(config)
+    end
+
+    def run_scripts
+      failed = false
+
+      puts "Running stage #{@name}..."
+      @scripts.each do |script|
+        puts "\tRunning Script #{script}..."
+
+        if system(script)
+          @plan.engine.assert Facts::ScriptSucceeded.new(self, script)
+        else
+          @plan.engine.assert Facts::ScriptFailed.new(self, script)
+          failed = true
+        end
+      end
+
+      if failed
+        @plan.engine.assert Facts::StageFailed.new(self)
+      else
+        @plan.engine.assert Facts::StageSucceeded.new(self)
+      end
+    end
+
+    attr :name
+    attr :scripts
+    attr :rules
+  end
+
+  class BackupPlan
+    def initialize(config, logger = nil)
+      @logger = logger || Logger.new(STDOUT)
+      
+      @config = config.keys_matching(/^scripts\.(.*)$/)
+      @stages = config.keys_matching(/^stage\.(.*)$/) { |c,name| Stage.new(self, name, c) }
+    end
+
+    attr :logger, true
+    attr :config
+
+    def run_backup
+      Ruleby.engine :engine do |e|
+        @engine = e
+
+        puts " Loading Rules ".center(80, "=")
+
+        BackupPlanRulebook.new(e).rules
+
+        @stages.each do |k,s|
+          StageRulebook.new(e, s).rules
+        end
+
+        puts " Processing Rules ".center(80, "=")
+
+        e.assert Facts::Initial.new
+
+        e.match
+        @engine = nil
+      end
+
+      puts " Finished ".center(80, "=")
+    end
+
+    attr :engine
+    attr :config
+    attr :stages
+
+    def self.load_from_file(path)
+      new(YAML::load(File.read(path)))
+    end
+  end
+
+end

data/lib/lsync/backup_script.rb

@@ -0,0 +1,136 @@
+
+# A backup script coordinates "one" backup as a unit.
+
+require 'lsync/action'
+require 'lsync/method'
+require 'lsync/server'
+require 'lsync/directory'
+
+module LSync
+
+  class BackupScript
+    private
+    # Given a name, find out which server config matches it
+    def find_named_server name
+      if @servers.key? name
+        return @servers[name]
+      else
+        hostname = Socket.gethostbyname(name)[0] rescue name
+        return @servers.values.find { |s| s["host"] == hostname }
+      end
+    end
+
+    # Find out the config section for the current server
+    def find_current_server
+      server = nil
+
+      # Find out if the master server is local...
+      if @master.is_local?
+        server = @master
+      else
+        # Find a server config that specifies the local host
+        server = @servers.values.find { |s| s.is_local? }
+      end
+
+      return server
+    end
+
+    def script_logger
+      if @config["log-file"]
+        return Logger.new(@config["log-file"], 'weekly')
+      end
+    end
+
+    public
+    def initialize(config, logger = nil)
+      @config = config
+      
+      @logger = logger || Logger.new(STDOUT)
+
+      @servers = config.keys_matching(/^server\./) { |c,n| Server.new(c) }
+      @directories = config.keys_matching(/^directory\./) { |c,n| Directory.new(c) }
+
+      @master = find_named_server(config["master"])
+
+      if @master == nil
+        raise ConfigurationError.new("Could not determine master server!", :script => self)
+      end
+
+      @method = Method.new(config["method"])
+      @log_buffer = nil
+    end
+
+    attr :logger, true
+    attr :master
+    attr :method
+    attr :servers
+    attr :directories
+    attr :log_buffer
+
+    def run_backup
+      # We buffer the log data so that if there is an error it is available to the notification sub-system
+      @log_buffer = StringIO.new
+      logger = @logger.tee(script_logger, Logger.new(@log_buffer))
+
+      current = find_current_server
+
+      # At this point we must know the current server or we can't continue
+      if current == nil
+        raise BackupScriptError.new("Could not determine current server!", :script => self, :master => @master)
+      end
+
+      if @master.is_local?
+        logger.info "We are the master server..."
+      else
+        logger.info "We are not the master server..."
+        logger.info "Master server is #{@master}..."
+      end
+
+      # Run server pre-scripts.. if these fail then we abort the whole backup
+      begin
+        @method.run_actions(:before, logger)
+        @master.run_actions(:before, logger)
+      rescue AbortBackupException
+        return
+      end
+
+      logger.info "Running backups for server #{current}..."
+
+      @servers.each do |name, s|
+        # S is always a data destination, therefore s can't be @master
+        next if s == @master
+
+        # Skip servers that shouldn't be processed
+        unless @method.should_run?(@master, current, s)
+          logger.info "\t" + "Skipping".rjust(20) + " : #{s}"
+          next
+        end
+
+        # Run pre-scripts for a particular server
+        begin
+          s.run_actions(:before, logger)
+        rescue AbortBackupException
+          next
+        end
+
+        @directories.each do |name, d|
+          logger.info "\t" + ("Processing " + d.to_s).rjust(20) + " : #{s}"
+
+          @method.logger = logger
+          @method.run(@master, s, d)
+        end
+
+        # Run post-scripts for a particular server
+        s.run_actions(:after, logger)
+      end
+
+      @method.run_actions(:after, logger)
+      @master.run_actions(:after, logger)
+    end
+
+    def self.load_from_file(path)
+      new(YAML::load(File.read(path)))
+    end
+  end
+
+end