smarbs 0.9.3

data/lib/script.rb

@@ -0,0 +1,217 @@
+require 'types'
+require 'backup'
+require 'smarbs'
+
+class Script
+  
+  def initialize (configdir, argv = [])
+    @halt = false
+    @argv=argv
+    @configfile = nil
+    begin
+      @config_dir = Directory.new(configdir)
+      getconfigfiles
+    rescue RuntimeError
+      puts "Error: " + $!.to_s
+    end
+  end
+  
+  private
+  
+  def getconfigfiles #return an array of config files
+    @configfile_names = @config_dir.files(false)
+    
+    if @configfile_names.size == 0 #create sample configfile
+      @configfile=ConfigFile.new(@config_dir.to_s+"backup1")
+    end
+
+    parse(@argv)
+  end
+  
+  def backup
+    if @status
+      begin
+        require 'gtk2'
+      rescue LoadError
+        raise "Error: No ruby - gtk2 installed, which is needed when using the '--status' option."
+      end
+      
+      datadir=SMARBS::DATADIR
+
+      Gtk.init
+      menu = Gtk::Menu.new
+
+      item3 = Gtk::ImageMenuItem.new(Gtk::Stock::EXECUTE)
+      item3.show
+      item1 = Gtk::CheckMenuItem.new("Shutdown after Backup")      
+      if @config_dir.to_s == "/etc/smarbs/" then
+        item1.show
+      else
+        puts @config_dir.to_s
+      end
+      item2 = Gtk::ImageMenuItem.new(Gtk::Stock::QUIT)
+      item2.show
+
+      menu.append(item3)
+      menu.append(item1)
+      menu.append(item2)      
+
+      icon = Gtk::StatusIcon.new
+      icon.pixbuf=Gdk::Pixbuf.new(datadir + "/icongreen.png")
+      icon.tooltip="Smarbs is ready to back up!";
+      icon.blinking=true
+
+      handler = icon.signal_connect("activate") {item3.signal_emit("activate") }      
+      
+      handler2 = icon.signal_connect('popup-menu') { |w, button, time|
+        menu.popup(nil, nil, button, time)
+      }
+      
+      item3.signal_connect("activate") do
+        icon.blinking=false
+        item2.hide
+        item3.hide
+        icon.tooltip="Smarbs is working...";        
+        if item1.active?
+          icon.pixbuf=Gdk::Pixbuf.new(datadir + "/iconred.png")
+        else
+          icon.pixbuf=Gdk::Pixbuf.new(datadir + "/iconblue.png")
+        end
+        if not item1.visible? then
+          icon.signal_handler_disconnect handler2
+        end
+        icon.signal_handler_disconnect handler
+        Thread.new{start_backup} 
+      end
+     
+      if item1.visible? then
+        item1.signal_connect("toggled") do
+          if item1.active?
+            if not item3.visible? then icon.pixbuf=Gdk::Pixbuf.new(datadir + "/iconred.png") end
+            @halt = true
+          else
+            if not item3.visible? then icon.pixbuf=Gdk::Pixbuf.new(datadir + "/iconblue.png") end
+            @halt = false
+          end      
+        end
+      end
+        
+      item2.signal_connect("activate") { Gtk.main_quit }
+      
+      Gtk.main
+    else
+      start_backup
+    end
+  
+  end
+  
+  def start_backup
+    if @configfile_arguments.size == 0 
+      todo = @configfile_names
+    else 
+      todo = @configfile_arguments
+    end
+    todo.each do |name|
+      Backup.new(@config_dir.to_s + name, @rsync_arguments.join(" "), @verbose)
+    end unless not @configfile.nil? and @configfile.new
+    if @status then
+      Gtk.main_quit
+      if @halt then `halt` end
+    end
+  end
+  
+  def print_help
+    print_version
+    
+    puts "\nsmarbs is a backup script written in ruby capable of doing intelligent and\nautomated backups using rsync."
+    
+    puts "\nUsage: smarbs [OPTION]... [CONFIGFILE]... "
+    puts "Makes backup according to the specified configfile(s),"
+    puts "when no configfile is specified and no information options are invoked,\nall existing configfiles are executed."
+    
+    puts "\nBackup options:"
+    puts "  -v, --verbose              increase verbosity, ignoring the configfile option"
+    puts "      --pass-rsync=OPTIONS   pass OPTIONS to rsync before executing it"
+    puts "                             =>use with caution! usually this is not needed"
+    puts "  -s, --status               only usable when \"gtk2-ruby\" is installed"
+    puts "                             =>shows a gtk tray/status icon with the options"
+    puts "                             \"backup\", \"quit\" and as root a checkbox"
+    puts "                             \"shutdown after backup\""
+    
+    puts "\nInformation options:"
+    puts "(won't work together with backup options)"
+    puts "  -l, --list                 list available configfiles"
+    puts "  -h, --help                 show this help"
+    puts "  -V, --Version              print version number"
+    puts "\nConfigfiles are stored in the directory /etc/smarbs \nor ~/.smarbs, if not executed as root."
+  end
+
+  def print_version
+    puts "smarbs " + SMARBS::VERSION.to_s + " (" + SMARBS::DATE.to_s + ")"
+    puts "Copyright (C) 2006-2009 by Jan Rueegg (rggjan)"
+    puts "<http://smarbs.sourceforge.net/>\n\n"
+  
+    puts 'smarbs comes with ABSOLUTELY NO WARRANTY. This is free software, and you
+are welcome to redistribute it under certain conditions. See the GNU
+General Public Licence for details.'
+  end
+
+  public
+
+  def parse (arguments)
+    if not arguments.nil? then
+      @configfile_arguments = Array.new
+      @rsync_arguments = Array.new
+      infarg = Array.new #Information Arguments (--help or --version)
+      @verbose = false
+      @status = false
+      begin
+        arguments.each do 
+          |argv|
+          case argv
+          when "--version", "-V"
+            infarg.push argv
+          when "--help", "-h", "-?"
+            infarg.push argv
+          when "--list", "-l"
+            infarg.push argv
+          when "--verbose", "-v"
+            @verbose=true
+          when /^--pass-rsync=/
+            @rsync_arguments.push(argv.gsub(/^--pass-rsync=/, ""))
+          when "--status", "-s"
+            @status=true
+          else
+            if not @configfile_names.include? argv then
+              raise "Unknown argument '#{argv}'!\nUse '--help' to see possible options."
+            end
+            @configfile_arguments.push(argv)
+          end
+        end
+    
+        if infarg.size == 0 then
+          backup
+        else
+          if @configfile_arguments.size != 0 or @verbose == true or @rsync_arguments.size != 0 then
+            raise "You cannot backup and use '#{infarg[0]}' at the same time."
+          end
+          infarg.uniq.each do
+            |arg|
+            case arg
+            when "--version", "-V"
+              print_version
+            when "--help", "-h", "-?"
+              print_help
+            when "--list", "-l"
+              puts "Available configfiles:"
+              puts @configfile_names
+            end
+          end
+        end
+  
+      rescue RuntimeError
+        puts $!
+      end         
+    end
+  end
+end

data/lib/smarbs.rb

@@ -0,0 +1,5 @@
+module SMARBS
+  VERSION = "0.9.3"
+  DATE = "16. December 2009"
+  DATADIR = File.expand_path("../data/", __FILE__)
+end

data/lib/syslog.rb

@@ -0,0 +1,98 @@
+#!/usr/bin/env ruby
+
+# Syslog wrapper class
+# might be needed for reasons discussed on 
+# http://dev.animoto.com/articles/ruby-syslog-considered-harmful-or-at-least-undocumented
+#
+# Paavo Pokkinen (C) 2009
+# License: GPL
+#
+# $Id$
+
+require 'syslog'
+
+class SyslogWrapper
+  
+  def initialize()
+    # facility is "user", since there is no "backup" facility
+    # also, if we are running root, perhaps we should log with
+    # "daemon" facility?
+    # 
+    # facilies and priorities are listed here:
+    # http://docstore.mik.ua/orelly/networking/puis/ch10_05.htm
+    @@log = Syslog.open('smarbs', Syslog::LOG_PID, Syslog::LOG_USER)
+    
+    # normally log up to INFO level
+    # for debug, try DEBUG here (if we have any debug messages)
+    @@log.mask = Syslog::LOG_UPTO(Syslog::LOG_INFO)
+  end
+  
+  def finalize()
+    # not sure if closing is really necessary,
+    # nothing bad really happens if we pass this...
+    @@log.close() if @@log
+  end
+  
+  public
+  
+  # logger function, does some input satitation, and logs to syslog
+  def log(msg="", level=1)
+    
+    # Oh yes, we need to sanitaze here. 
+    
+    msg.gsub!(/%/, ' ') # '%' needs to be removed, else there will be runtimeError
+    msg.gsub!(/\n/, ' ')
+    msg.gsub!(/\0/, ' ')
+    
+    # Ideally we would split the msg, and post in multiple parts
+    # but I guess this is enough, we should never have that long lines anyway
+    if msg.length >= 1024
+      msg = msg[0..1023]
+    end
+    
+    # levels are:
+    # * 0: debug
+    # * 1: info
+    # * 2: notice
+    # * 3: warning
+    # * 4: error
+    
+    case level
+      when 1
+	@@log.info(msg) unless msg.empty?
+      when 2
+	@@log.notice(msg) unless msg.empty?
+      when 3
+	@@log.warning(msg) unless msg.empty?
+      when 4
+	@@log.err(msg) unless msg.empty?
+      when 0
+      @@log.debug(msg) unless msg.empty?
+      else
+	# something tries to log with nonexisting level, or with too high level
+	# its probably better to halt the execution than log with wrong level, or not log at all
+	raise RuntimeError.new("Wrong loglevel defined somewhere! This is a bug.")
+    end
+  end
+
+end
+
+if __FILE__ == $0
+  log = SyslogWrapper.new()
+  
+  log.log("testing")
+  log.log("Just a notice.", 2)
+  log.log("Should not print", 0)
+  #log.log("We can't print with too high priority", 5)
+  
+  # Torture test strings, from animoto's blog
+  test1 = (0..255).map{|x|"<#{x.chr}>\n" }.join
+  test2 = (1..3000).map{|x|"<#{(97+(x%26)).chr}>\n" }.join
+  log.log( test1 + test2 + "is this thing still on?")
+  
+  # empty msg, should not print
+  log.log("")
+  
+end
+
+# $Id$

data/lib/types.rb

@@ -0,0 +1,172 @@
+# types.rb contains all the classes that might also be used in other projects,
+# for example to handle files / directories or to represent sizes.
+
+require 'fileutils'
+
+# Can be used to create directories, to get files within a directory or to see
+# if a directory is writable.
+class Directory
+  
+  # Takes a (path)string as input and creates a directory there, if possible.
+  def initialize(directory, *args)
+    @dir = Directory.prepare(directory)
+    if not @dir[-1, 1].to_s == "/"
+      @dir.insert(-1, '/')
+    end
+    if args.include?(:writable)
+      if not Directory.writable?(File.dirname(@dir))
+        raise "#{@dir} is not writable!"
+      end
+    end
+    if not File.directory?(@dir)
+      if not Directory.writable?(File.dirname(@dir))
+        raise "Directory '#{@dir}' is not existing!"
+      else
+        FileUtils.makedirs(@dir)
+        puts "#{@dir} created."
+      end
+    end
+  end
+  
+  public
+  
+  attr_reader(:dir)
+
+  # Checks if input is a valid argument and returns normalized string.
+  def Directory.prepare (input) 
+    raise "Internal Error: Argument not a String" if input.class != String
+    input.strip!
+    raise "No directory specified!" if input.empty?
+    input.insert(0, '/') unless input[0, 1].to_s == "/"
+    return input
+  end
+
+  # Checks if the directory (relative to the root directory) is writable, or, if
+  # not yet existing, creatable.
+  def Directory.writable?(path)
+    Directory.prepare(path)
+    if File.exists?(path) and File.directory?(path)
+      return File.writable?(path)
+    end
+    return writable?(File.dirname(path)) 
+  end  
+      
+  # Compares if the two directories are equal.
+  def == (other_directory)
+    return @dir == other_directory.dir
+  end
+  
+  # Returns the normalized directory path as a string.
+  def to_s
+    @dir
+  end
+  
+  # Returns how much free space there is (on the whole partition, using "df")
+  # as a Float of bytes
+  def free
+    path = to_s
+    `df --block-size=1 #{path}`.split[-3].to_f
+  end
+
+  # Gives back (in bytes) how much space is used for the whole Smarbsbackupdir.
+  #
+  # If ownpartition is true, it will use 'df' instead of 'du' which is much faster.
+  def space(ownpartition = false)
+    path = to_s
+    if ownpartition
+      `df --block-size=1 #{path}`.split[-4].to_f
+    else
+      `du -bcs #{path}`.split[-2].to_f
+    end
+  end
+
+  # Returns an array of files and folders that the Directory contains, excluding "." and "..".
+  # 
+  # When 'all' is 'false', then it excludes files with a "~" at the end and all folders.
+  def files(all=true)
+    if all then
+      return Dir.entries(@dir) - ["."] - [".."]
+    else
+      configfile_names = Array.new
+      Dir.foreach(@dir) do |filename|
+        path = @dir+"/"+filename
+        if File.file?(path) and not path =~ /.*~/ # put every file without ~ at the end into the array
+          configfile_names.push(filename)
+        end
+      end
+      return configfile_names
+    end
+  end
+end
+
+# A class that represents sizes of directories. The main feature is to
+# give back a size in a "human readable" format, like "5 MiB".
+class Size
+  # Takes a size as a string. With no ending it is assumed as a size in bytes.
+  # Otherwise, (for example gvien a "32m") it is interpreted depending on the ending:
+  # g:: GiB
+  # m:: MiB
+  # k:: KiB
+  # Raises an error if an unexpected string is given (like "m32" or "32 MiB").
+  def initialize(string)
+    size = string.to_s.strip.downcase
+    case size
+    when "" then @size=0
+    when /g$/ then @size=$`.to_f * 1024**3
+      raise "Wrong Size format, '" + string + "' not valid!" unless $`.to_f.to_s == $` or $`.to_i.to_s == $`
+    when /m$/ then @size=$`.to_f * 1024**2
+      raise "Wrong Size format, '" + string + "' not valid!" unless $`.to_f.to_s == $` or $`.to_i.to_s == $`
+    when /k$/ then @size=$`.to_f * 1024
+      raise "Wrong Size format, '" + string + "' not valid!" unless $`.to_f.to_s == $` or $`.to_i.to_s == $`
+    else
+      @size=size.to_f
+      raise "Wrong Size format, '" + string + "' not valid!" unless size.to_f.to_s == size or size.to_i.to_s == size
+    end
+  end
+  
+  # Returns a string which is "optimal" formatted, like "34.333 GiB", rounded
+  # to "dec" digits after the comma.
+  # 
+  # Default dec: 2. A dec of "-1" means no rounding.
+  #
+  # Uses "B", "KiB", "MiB" or "GiB" as ending.
+  def opt(dec = 2)
+    case @size.abs
+    when 0..1023 then s, d=@size, " B"
+    when 1024..1024**2-1 then s, d=@size/1024, " KiB"
+    when 1024**2..1024**3-1 then s, d=@size/1024**2, " MiB"
+    else s, d=@size/1024**3, " GiB"
+    end
+    return dec==-1 ? s.to_s + d : ((s * 10**dec).round.to_f / 10**dec).to_s + d
+  end
+  
+  # Returns a string which is "optimal" formatted, but with a short
+  # ending, like "34.33g", rounded to "dec" digits after the comma.
+  #
+  # Default dec: 2. A dec of "-1" means no rounding.
+  # 
+  # Uses "", "k", "m" or "g" as ending.
+  def short(dec = 2)
+    case @size.abs
+    when 0..1023 then s, d=@size, ""
+    when 1024..1024**2-1 then s, d=@size.to_f/1024, "k"
+    when 1024**2..1024**3-1 then s, d=@size.to_f/1024**2, "m"
+    else s, d=@size.to_f/1024**3, "g"
+    end
+    return dec==-1 ? s.to_s + d : ((s * 10**dec).round.to_f / 10**dec).to_s + d
+  end
+
+  # Returns the size in bytes as an integer.
+  def b
+    @size.round
+  end
+
+  # Returns the size in bytes as a string.
+  def to_s
+    return @size.to_s
+  end
+
+  def ==(other)
+    return b == other.b
+  end
+end

data/test/smarbs_test.rb

@@ -0,0 +1,114 @@
+require 'stringio'
+require 'smarbs'
+require 'test/unit'
+
+module SMARBS
+  begin
+    remove_const "VERSION"
+    remove_const "DATE"
+  rescue NameError
+  end
+  VERSION = "0.9.1"
+  DATE = "4. September 2009"
+end
+
+module SmarbsTest
+  def clean
+    clean_all
+    `mkdir /tmp/smarbs`
+    `cd /tmp/smarbs && mkdir smarbs && mkdir backmeup && mkdir backedup`
+  end
+
+  def clean_all
+    `rm -r /tmp/smarbs` if File.exists?("/tmp/smarbs")
+  end
+
+  # give :nonequal to test for non-equality, :exact for exact results as argument
+  def assert_output(strings, *params)
+    output = with_stdout_captured { yield }
+
+    strings = [strings] if strings.class == String or strings.class == Regexp
+    strings.each do |string|
+      unless params.include? :nonequal
+        if params.include? :exact
+          assert_equal string, output
+        else
+          string = Regexp.new(string) if string.class == String
+          assert_match string, output
+        end
+      else
+        if params.include? :exact
+          assert_not_equal string, output
+        else
+          string = Regexp.new(string) if string.class == String
+          assert_no_match string, output
+        end
+      end
+    end
+  end
+
+  def assert_success(string="") #TODO write tests
+    arg = ["Successfully backed up."]
+    if string.class == Array then
+      arg += string
+    else
+      arg << string
+    end
+    assert_output(arg) do
+      yield
+    end
+  end
+
+  def assert_fail(string="")
+    arg = ["Backup NOT successful!"]
+    if string.class == Array then
+      arg += string
+    else
+      arg << string
+    end
+    assert_output(arg) do
+      yield
+    end
+  end
+
+  def assert_backup_dirs(array)
+    actual = Dir.entries("/tmp/smarbs/backedup/smarbsbackup/")
+    actual.delete(".")
+    actual.delete("..")
+    actual.collect! {|name| name.slice(/-backup.*$/)}
+    actual.sort!
+    array.collect! {|name| "-backup." + name.to_s}
+    array.sort!
+    assert_equal(array, actual)
+  end
+
+  def default_configfile
+    cf = nil
+    assert_output "" do
+      cf = ConfigFile.new("/tmp/smarbs/smarbs/backup1")
+    end
+    cf.src = ["/tmp/smarbs/backmeup"]
+    cf.dest = "/tmp/smarbs/backedup"
+    cf.write
+    cf
+  end
+
+  def assert_raise_message(string, error = RuntimeError)
+    m = assert_raise( error ) {yield}
+    assert_equal(string, m.message)
+  end
+
+private
+
+  def with_stdout_captured
+    old_stdout = $stdout
+    out = StringIO.new
+    $stdout = out
+    begin
+      yield
+    ensure
+      $stdout = old_stdout
+    end
+    out.string
+  end
+end