lnbackup 2.1

data/lib/lnbackup/freespace.rb

@@ -0,0 +1,73 @@
+class FreeSpaceCalc
+  def initialize( path, free_files=0, free_blocks=10, log=nil )
+    @log = log
+    @stat = FileSystem.stat(path)
+
+    if (free_blocks.class == String) and (free_blocks =~ /^(\d+)%$/)
+      free_blocks = @stat.blocks * $1.to_i / 100
+    else
+      free_blocks = free_blocks.to_i rescue 100
+    end
+    # vzdy nechame alespon 100 volnych bloku (typicky blok=4kB)
+    @free_blocks = free_blocks < 100 ? 100 : free_blocks
+
+    if (free_files.class == String) and (free_files =~ /^(\d+)%$/)
+      free_files = @stat.files * $1.to_i / 100
+    else
+      free_files = free_files.to_i rescue 100
+    end
+    # vzdy nechame alespon 100 volnych inodu (pokud dojdou, fs se umi prekne 
+    # podelat a ani fsck z toho nema radost)
+    @free_files = free_files < 100 ? 100 : free_files
+  end
+
+  def much_used?
+    @stat = FileSystem.stat(@stat.path)
+    if Process.euid == 0
+      if (@stat.blocks_free < @free_blocks) or (@stat.files_free  < @free_files)
+        @log.debug { "FreeSpaceCalc: much used (euid=#{Process.euid}) (#{@stat.blocks_free} < #{@free_blocks}) or (#{@stat.files_free} < #{@free_files})" }
+        return true
+      end
+    else
+      if (@stat.blocks_avail < @free_blocks) or (@stat.files_avail  < @free_files)
+        @log.debug { "FreeSpaceCalc: much used (euid=#{Process.euid}) (#{@stat.blocks_avail} < #{@free_blocks}) or (#{@stat.files_avail} < #{@free_files})" }
+        return true
+      end
+    end
+    return false
+  end
+
+  def get_free
+    @stat = FileSystem.stat(@stat.path)
+    return [ @stat.blocks_free, @stat.files_free ]
+  end
+
+  def can_backup?( path )
+    begin
+      @stat = FileSystem.stat(@stat.path)
+      if Process.euid == 0
+        if (@stat.blocks_free < @free_blocks) or (@stat.files_free  < @free_files) or 
+           (File.size(path) >= ( @stat.block_size * (@stat.blocks_free-@free_blocks) ))
+
+          @log.debug { "FreeSpaceCalc: (euid=#{Process.euid}) can't backup #{path} size #{File.size(path)}" }
+          @log.debug { "FreeSpaceCalc: blocks avail: #{@stat.blocks_free} should have: #{@free_blocks}" }
+          @log.debug { "FreeSpaceCalc: files  avail: #{@stat.files_free}  should have: #{@free_files}" }
+          return false
+        end
+      else
+        if (@stat.blocks_avail < @free_blocks) or (@stat.files_avail  < @free_files) or
+           (File.size(path) >= ( @stat.block_size * (@stat.blocks_avail-@free_blocks) ))
+
+          @log.debug { "FreeSpaceCalc: (euid=#{Process.euid}) can't backup #{path} size #{File.size(path)}" }
+          @log.debug { "FreeSpaceCalc: blocks avail: #{@stat.blocks_avail} should have: #{@free_blocks}" }
+          @log.debug { "FreeSpaceCalc: files  avail: #{@stat.files_avail}  should have: #{@free_files}" }
+          return false
+        end
+      end
+      return true
+    rescue Errno::ENOENT # pokud soubor, ktery kontrolujeme prestal existovat, 
+                         # podminka je trivialne splnena 
+      return true
+    end
+  end
+end

data/lib/lnbackup/util.rb

@@ -0,0 +1,123 @@
+class File
+  TOO_BIG = 1024 * 1024 * 2  # 2MB
+
+  # a variant of syscopy, that propagates exception Errno::ENOSPC 
+  # and handles some extra error states
+  #
+  def File.syscopy2 from, to
+    fsize = size(from)
+    fsize = 1024 if fsize < 512
+    fsize = TOO_BIG if fsize > TOO_BIG
+    fmode = stat(from).mode
+    tpath = to
+    not_exist = !exist?(tpath)
+    begin
+      from = open(from, "r")
+      from.binmode
+      to = open(to, "w")
+      to.binmode
+
+      while true
+        r = from.sysread(fsize)
+        rsize = r.size
+        w = 0
+        while w < rsize
+          t = to.syswrite(r[w, rsize - w])
+          w += t
+        end
+      end
+    rescue EOFError
+      ret = true
+    rescue Errno::ENOSPC
+      raise
+    rescue
+      ret = false
+    ensure
+      begin; to.close; rescue; end
+      begin; from.close; rescue; end
+    end
+    chmod(fmode, tpath) if not_exist
+    ret
+  end
+end
+
+class Hash
+  # "aktualizace" hashe jinou hashi: existujici klice jsou prepsany,
+  # neexistujici pridany a to cele rekurzivne po hashich
+  def append( hash )
+    hash.each_pair do |k,v|
+      if self.has_key?(k)
+        case v
+        when Hash
+          self[k].append(v)
+        else
+          self[k] = v
+        end
+      else
+        self[k] = v
+      end
+    end
+  end
+end
+
+class SysCopyFailure < StandardError
+end
+
+class MakeSpaceFailure < StandardError
+  attr_accessor :code
+  def initialize(code)
+    @code = code
+    super
+  end
+end
+
+class Date
+  # formatovani data do cesty pro zalohu
+  def backup_dir(hourly)
+    if hourly
+        "%d/%02d/%02d-%02d" % [year, month, day, Time.now.hour]
+    else
+        "%d/%02d/%02d" % [year, month, day]
+    end
+  end
+end
+
+module Find
+  #
+  # reimplementace funkce "find" s osetrenim vyjimky Errno::EOVERFLOW, ktera minimalne
+  # na ruby1.6 nastava pri zachazeni (napr. stat) se souborem o velikosti >2GB
+  #
+  # pruchod je udelan pomoci zasobniku s hloubkou, aby bylo mozne usetrit pamet
+  #
+  def Find.find3(*path)
+    path.collect!{|d| [d.dup,0]}
+    while temp = path.shift
+      catch(:prune) do
+        (file, depth) = temp
+        yield [file, depth]
+        begin
+          if File.lstat(file).directory? then
+            d = Dir.open(file)
+            begin
+              for f in d
+                next if f == "." or f == ".."
+                if File::ALT_SEPARATOR and file =~ /^(?:[\/\\]|[A-Za-z]:[\/\\]?)$/ then
+                  f = file + f
+                elsif file == "/" then
+                  f = "/" + f
+                else
+                  f = File.join(file, f)
+                end
+                path.unshift [f, depth+1]
+              end
+            ensure
+              d.close
+            end
+          end
+        rescue Errno::ENOENT, Errno::EACCES, Errno::EOVERFLOW
+        end
+      end
+    end
+  end
+end
+

data/lib/lnbackup/version.rb

@@ -0,0 +1,3 @@
+module LnBackup
+  VERSION=2.1
+end

data/lib/lnbackup.rb

@@ -0,0 +1,21 @@
+require 'lnbackup/backup.rb'
+require 'lnbackup/freespace.rb'
+require 'lnbackup/util.rb'
+require 'lnbackup/version.rb'
+
+require 'find'
+require 'date'
+#require 'ftools'
+require 'fileutils'
+begin 
+  require 'filesystem'
+rescue LoadError
+  require 'sys/filesystem'
+  include Sys
+  FileSystem = Filesystem
+end
+
+
+require 'logger'
+require 'time'
+

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: lnbackup
+version: !ruby/object:Gem::Version
+  version: '2.1'
+  prerelease: 
+platform: ruby
+authors:
+- Martin Povolny
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-08 00:00:00.000000000 Z
+dependencies: []
+description: ! "\nLnbackup is a hardlink backup system for hard drives. \n\nLnbackup
+  operates in a way similar to the '--link-dest' switch in rsync.\n\nIt creates incremental
+  backups using hardlinks so that each backup seems like a full backup. Additionaly
+  it can make (using hardlinks) bootable mirror from the latest backup.\n\nObviously
+  the target filesystem of lnbackup needs to support hardlinks.\n\nIt's run on ~200
+  servers for several years and it is considered stable.\n\nRead the man page for
+  more information."
+email: martin.povolny@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/lnbackup.rb
+- lib/lnbackup/version.rb
+- lib/lnbackup/freespace.rb
+- lib/lnbackup/backup.rb
+- lib/lnbackup/util.rb
+- bin/lnbackup
+- bin/lnumount
+- bin/lnmount
+- bin/lnstat
+- bin/pc_backup
+- bin/sql_backup.sh
+homepage: https://github.com/martinpovolny/lnbackup
+licenses: []
+post_install_message: 
+rdoc_options:
+- --title
+- Lnbackup -- hardlink backup system for hard drives.
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Hardlink backup system for hard drives.
+test_files: []