remotebackup 0.5.0

data/lib/remotebackup.rb

@@ -0,0 +1,279 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+require 'rubygems'
+require 'net/ssh'
+require 'net/scp'
+require "stringio"
+require "fileutils"
+require "rexml/document"
+require "date"
+require 'logger'
+require 'yaml'
+module Remotebackup
+	class Node
+		attr_accessor :ftype,:name,:makeMap
+		Result = {:access=>0,:link_num=>1,:user=>2,:group=>3,:size=>4,:month=>5,:day=>6,:yt=>7,:name=>8,:arrow=>9,:source=>10}
+		Month = {"Jan" => 1, "Feb" => 2, "Mar" => 3, "Apr" => 4, "May" => 5, "Jun" => 6, "Jul" => 7, "Aug" => 8,
+							"Sep" => 9, "Oct" => 10, "Nov" => 11, "Dec" => 12}
+		def initialize(out)
+			result = out.split();
+			@name = result[Result[:name]]
+			case result[Result[:access]] 
+			when /^-/
+				@ftype = :file
+				@size = result[Result[:size]].to_i
+				year = DateTime.now.year
+				month = Month[result[Result[:month]]]
+				day = result[Result[:day]].to_i
+				hour = 0
+				minute = 0
+				if result[Result[:yt]] =~ /(.*):(.*)/
+					hour = $1.to_i
+					minute = $2.to_i
+				else
+					year = result[Result[:yt]].to_i
+				end
+				@date = DateTime.new(year,month,day,hour,minute).to_s
+				@makeMap = lambda{ return {"size" => @size, "date" => @date}}
+			when /^l/
+				@ftype = :symbolic
+				@source = result[Result[:source]]
+				@makeMap = lambda{ return {"source" => @source}}
+			when /^d/
+				@ftype = :directory
+			else
+				@ftype = :special
+				$log.error("#{@name} is not regular file. ignore.")
+			end
+		end
+	end
+	class BackupInfo
+		attr_accessor :fileMap,:mod,:last_file
+		def initialize(name,server,user,password,path,ignore_list)
+			@mod = false
+			@name = name
+			@server = server
+			@user = user
+			@password = password
+			@path = path
+			@ignore_list = ignore_list
+			@nowTime = DateTime.now
+			@fileMap = {"file" => Hash.new,"symbolic" => Hash.new,"directory"=>Array.new}
+			Net::SSH.start(@server,@user,:password=>@password) { |session|
+				makeFileMapList(session,"")
+			}
+		end
+		def ignore_check(target)
+			if @ignore_list
+				@ignore_list.each do |ignore|
+					if target =~ /#{ignore}/
+						return false
+					end
+				end
+			end
+			return true
+		end
+		def makeFileMapList(session,target)
+			if target != ""
+				target_path = @path +"/"+target
+			else
+				target_path = @path
+			end
+			cmd = "export LANG=C;ls -la #{target_path}"
+			out = ""
+			channel = session.open_channel do |ch|
+				ch.exec cmd do |ch,success|
+					ch.on_data do |c,data|
+						out = data
+					end
+				end
+			end
+			channel.wait
+			if out =~ /No such file/
+				$log.error("can't open path:#{target_path}") 
+				return
+			end
+			if out == ""
+				return
+			end
+			lines = StringIO.new(out).readlines
+			if lines[0].split().length < 9
+				@fileMap["directory"]. push target unless target == ""
+				makeFileMap(session,target,lines)
+			else
+				node = Node.new(lines[0].chomp)
+				if node.ftype == :symbolic
+					@fileMap["symbolic"][File.basename(@path)] = node.makeMap.call
+				elsif node.ftype == :file
+					@fileMap["file"][File.basename(@path)] = node.makeMap.call
+				end
+			end
+		end
+		def makeFileMap(session,target,lines)
+			lines.each do |line|
+				if line.split().length < 9
+					next
+				end
+				node = Node.new(line.chomp)
+				if node.name == "." or node.name == ".."
+					next
+				end
+				if target != ""
+					target_name = target +"/"+ node.name
+				else
+					target_name = node.name
+				end
+				unless ignore_check(target_name)
+					next
+				end
+				case node.ftype
+				when :directory
+					makeFileMapList(session,target_name)
+				when :special
+					next
+				when :file
+					@fileMap["file"][target_name] = node.makeMap.call
+				when :symbolic
+					@fileMap["symbolic"][target_name] = node.makeMap.call
+				end
+			end
+		end
+		def write_to_yaml(out_dir)
+			output_dir = out_dir + "/" + @name
+			FileUtils.mkdir_p(output_dir)
+			file_name = output_dir + "/" + date_to_filename + ".yml"
+			File.open(file_name ,"w") do |f|
+				f.write YAML.dump(@fileMap)
+			end
+		end
+		def load_last_yaml(output_dir)
+			files = Array.new
+			if FileTest.directory?(output_dir)
+				dirs = Dir.glob(output_dir+ "/*.yml")
+				dirs.each do |file|
+					files.push file
+				end
+			end
+			if files.length == 0
+				return {"file" => Hash.new,"symbolic" => Hash.new,"directory"=>Array.new}
+			end
+			@last_file = files.sort.pop
+			return YAML.load(File.read(@last_file))
+		end
+		def differencial_copy(out_dir)
+			output_dir = out_dir + "/" + @name
+			oldFileInfoMap = load_last_yaml(output_dir)
+			@fileMap["directory"].each do |dir|
+				unless oldFileInfoMap["directory"].include?(dir)
+					@mod = true
+					msg_out "create directory:#{dir}"
+					FileUtils.mkdir_p(output_dir + "/" + dir)
+				end
+			end
+			oldFileMap = oldFileInfoMap["symbolic"]
+			@fileMap["symbolic"].each do |key,val|
+				if !oldFileMap[key] || oldFileMap[key]["source"] != val["source"]
+					@mod = true
+					if !oldFileMap[key]  
+						msg_out "create symbolic:#{key}"
+					else
+						msg_out "modified symbolic:#{key}"
+					end
+				end
+			end
+			oldFileMap = oldFileInfoMap["file"]
+			@fileMap["file"].each do |key,val|
+				if !oldFileMap[key] || oldFileMap[key]["size"] != val["size"] || oldFileMap[key]["date"] != val["date"] 
+					@mod = true
+					file_name = output_dir + "/" + key + date_to_filename
+					msg_out "scp #{@user}@#{@server}:#{@path}/#{key} #{file_name} #password=#{@password}"
+					Net::SSH.start(@server, @user, :password => @password) do |ssh|
+						ssh.scp.download!  "#{@path}/#{key}",file_name
+					end
+					val["file_name"] = file_name
+					if !oldFileMap[key]
+						msg_out "create file:#{key}"
+					else
+						msg_out "modified file:#{key}"
+					end
+				else
+					val["file_name"] = oldFileMap[key]["file_name"]
+				end
+			end
+		end
+		def zerosup(i)
+			if i < 10
+				"0" + i.to_s
+			else
+				i.to_s
+			end
+		end
+		def date_to_filename()
+			@nowTime.year.to_s + "_" + zerosup(@nowTime.month) + "_" + zerosup(@nowTime.day) + "_" + zerosup(@nowTime.hour) + "_" + zerosup(@nowTime.min) 
+		end
+	end
+	class Backup
+		def initialize(config_file,config_out_dir)
+			@config_file = config_file
+			@config_out_dir = config_out_dir
+			@doc = REXML::Document.new(File.open(@config_file))
+			@top = @doc.elements["/backups"]
+			@conf_backups = Array.new
+			unless @top
+				oops("/backups is not set in #{@config_file}.")
+			end
+			@top.each_element do |backup|
+				bkup_info = Hash.new
+				backup.each_element do |elem|
+					if elem.name == "ignore_list"
+						ignores = Array.new
+						elem.each_element do |ignore|
+							ignores.push(ignore.text)
+						end
+						bkup_info["ignore_list"] = ignores
+					else
+						bkup_info[elem.name] = elem.text
+					end
+				end
+				@conf_backups.push(bkup_info)
+			end
+		end
+		def start
+			i=1
+			@conf_backups.each do |conf|
+				bkup = BackupInfo.new(conf["name"],conf["server"],conf["user"],conf["password"],conf["path"],conf["ignore_list"])
+				msg_out "--------------------------------"
+				msg_out "Backup start #{conf['name']}"
+				msg_out "--------------------------------"
+				bkup.differencial_copy(@config_out_dir)
+				if bkup.mod
+					bkup.write_to_yaml(@config_out_dir)
+				else
+					FileUtils.touch([bkup.last_file])
+				end
+			end
+		end
+	end
+	class Restore
+		def initialize(config_file,config_out_dir)
+			@config_file = config_file
+			@file_info_map = YAML.load_file(config_file)
+			@config_out_dir = config_out_dir
+			FileUtils.mkdir_p(@config_out_dir)
+		end
+		def start
+			msg_out "-------------------------------------------"
+			msg_out "Restore start #{File.dirname(@config_file)}"
+			msg_out "-------------------------------------------"
+			@file_info_map["directory"].each do |dir|
+				FileUtils.mkdir_p(@config_out_dir + "/" + dir)
+			end
+			@file_info_map["symbolic"].each do |key,val|
+				FileUtils.symlink(val["source"],@config_out_dir + "/" + key)
+			end
+			@file_info_map["file"].each do |key,val|
+				FileUtils.cp(val["file_name"],@config_out_dir + "/" + key)
+			end
+		end
+	end
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/remotebackup.rb'}"
+puts "Loading remotebackup gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/script/txt2html

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+
+GEM_NAME = 'remotebackup' # what ppl will type to install your gem
+RUBYFORGE_PROJECT = 'remotebackup'
+
+require 'rubygems'
+begin
+  require 'newgem'
+  require 'rubyforge'
+rescue LoadError
+  puts "\n\nGenerating the website requires the newgem RubyGem"
+  puts "Install: gem install newgem\n\n"
+  exit(1)
+end
+require 'redcloth'
+require 'syntax/convertors/html'
+require 'erb'
+require File.dirname(__FILE__) + "/../lib/#{GEM_NAME}/version.rb"
+
+version  = Remotebackup::VERSION::STRING
+download = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
+
+def rubyforge_project_id
+  RubyForge.new.autoconfig["group_ids"][RUBYFORGE_PROJECT]
+end
+
+class Fixnum
+  def ordinal
+    # teens
+    return 'th' if (10..19).include?(self % 100)
+    # others
+    case self % 10
+    when 1: return 'st'
+    when 2: return 'nd'
+    when 3: return 'rd'
+    else    return 'th'
+    end
+  end
+end
+
+class Time
+  def pretty
+    return "#{mday}#{mday.ordinal} #{strftime('%B')} #{year}"
+  end
+end
+
+def convert_syntax(syntax, source)
+  return Syntax::Convertors::HTML.for_syntax(syntax).convert(source).gsub(%r!^<pre>|</pre>$!,'')
+end
+
+if ARGV.length >= 1
+  src, template = ARGV
+  template ||= File.join(File.dirname(__FILE__), '/../website/template.html.erb')
+else
+  puts("Usage: #{File.split($0).last} source.txt [template.html.erb] > output.html")
+  exit!
+end
+
+template = ERB.new(File.open(template).read)
+
+title = nil
+body = nil
+File.open(src) do |fsrc|
+  title_text = fsrc.readline
+  body_text_template = fsrc.read
+  body_text = ERB.new(body_text_template).result(binding)
+  syntax_items = []
+  body_text.gsub!(%r!<(pre|code)[^>]*?syntax=['"]([^'"]+)[^>]*>(.*?)</\1>!m){
+    ident = syntax_items.length
+    element, syntax, source = $1, $2, $3
+    syntax_items << "<#{element} class='syntax'>#{convert_syntax(syntax, source)}</#{element}>"
+    "syntax-temp-#{ident}"
+  }
+  title = RedCloth.new(title_text).to_html.gsub(%r!<.*?>!,'').strip
+  body = RedCloth.new(body_text).to_html
+  body.gsub!(%r!(?:<pre><code>)?syntax-temp-(\d+)(?:</code></pre>)?!){ syntax_items[$1.to_i] }
+end
+stat = File.stat(src)
+created = stat.ctime
+modified = stat.mtime
+
+$stdout << template.result(binding)