palobr 0.1.0

data/lib/backup/file_item/base.rb

@@ -0,0 +1,37 @@
+module Backup
+	module FileItem
+  	class Base
+      def semantic_path(path)
+        if Dir.exists? path
+          path += '/'
+        else
+          path
+        end
+      end
+
+      def stat(file, timestamp = nil)
+        files = {}
+
+        stat = File.new(file).stat
+        files[file] = {
+          :uid => stat.uid,
+          :gid => stat.gid,
+          :mode => stat.mode
+        }
+        files[file][:timestamp] = timestamp if timestamp
+
+        unless Dir.exists?(file)
+          files[file][:checksum] = Digest::MD5.hexdigest(File.open(file).read)
+        end
+
+        files
+      rescue Exception => e
+        STDERR.puts e
+      end
+
+      def file_hash(file)
+        Digest::MD5.hexdigest file
+      end
+    end
+  end
+end

data/lib/backup/file_item/cloud.rb

@@ -0,0 +1,91 @@
+require 'backup/file_item/base'
+
+module Backup
+	module FileItem
+    class Cloud < Backup::FileItem::Base
+      attr_reader :key, :secret, :backet, :provider
+
+      def initialize(args = {})
+        puts_fail "Empty hash in Cloud initialize method" if args.empty?
+
+        [:key, :secret, :bucket].each do |arg|
+          puts_fail "'#{arg.to_s.green}' should not be empty" if args[arg].nil?
+          instance_eval %{@#{arg} = args[:#{arg}]}
+        end
+
+       try_to_connect_with_cloud 
+      end
+
+      def create_directory_once(*directories)
+        # Nothing happen
+      end
+
+      def create_file_once(file, data)
+        try_to_work_with_cloud do
+          @directory.files.create(
+            :key => delete_slashes(file),
+            :body => data
+          )
+        end
+      end
+
+      def read_file(file)
+        try_to_work_with_cloud do
+          file = delete_slashes(file)
+          remote_file = @directory.files.get(file)
+          remote_file.body if remote_file
+       	end
+      end
+
+      def dir(path, mask = "*")
+        path = delete_slashes(path)
+        mask = mask.gsub('.', '\.').gsub('*', '[^\/]')
+
+        try_to_work_with_cloud do
+          files = @directory.files.map &:key
+        end
+
+        files.map do |item|
+          match = item.match(/^#{path}\/([^\/]+#{mask}).*$/)
+          match[1] if match
+        end.compact.uniq
+      end
+
+      private
+
+      def delete_slashes(str)
+        str.chop! if str =~ /\/$/
+        str = str[1, str.length] if str =~ /^\//
+        str
+      end
+
+      def try_to_work_with_cloud(&block)
+        begin
+          yield
+        rescue Exception => e
+          try_to_connect_with_cloud 
+
+          yield
+        end
+      end
+
+
+      def try_to_connect_with_cloud
+        begin
+          @connection = ::Fog::Storage.new(
+            :provider => 'AWS',
+            :aws_secret_access_key => @secret,
+            :aws_access_key_id => @key
+          )
+
+          @directory = @connection.directories.get(@bucket)
+        rescue Exception => e
+          puts_verbose e.message
+          puts_fail "403 Forbidden"
+        end
+
+        puts_fail "Bucket '#{@bucket}' is not exists." if @directory.nil?
+      end
+		end
+  end
+end

data/lib/backup/file_item/local.rb

@@ -0,0 +1,26 @@
+require 'backup/file_item/base'
+
+module Backup
+	module FileItem
+    class Local < Backup::FileItem::Base
+      def create_directory_once(*directories)
+        directories.each do |path|
+          FileUtils.mkdir_p(path) unless Dir.exists?(path)
+        end
+      end
+
+      def create_file_once(file, data)
+        date = date.read if date.is_a? File
+        File.open(file, "w").puts(data) unless File.exists?(file)
+      end
+
+      def read_file(file)
+        open(file).read if File.exists? file
+      end
+
+      def dir(path, mask = "*")
+        Dir["#{path}/#{mask}"]
+      end
+    end
+  end
+end

data/lib/backup/jar.rb

@@ -0,0 +1,163 @@
+module Backup
+  class Jar
+    def initialize(file_item, root_path, local_path)
+      @root_path = root_path
+      @local_path = local_path
+      @timestamp = Backup::Timestamp.create
+      @file_item = file_item
+    end
+
+    def jar_hash
+      Digest::MD5.hexdigest(@local_path)
+    end
+
+    def save(increment = false)
+      unless increment
+        @local_files = hash_local_files
+      else
+        @local_files = {}
+        current_files = hash_local_files
+
+        last_timestamp = Jar.jar_versions(@root_path, jar_hash, true).last
+
+        if last_timestamp.nil?
+          puts_fail "First you must create a full backup for #{@local_path.dark_green}"
+        end
+
+        last_index = Jar.fetch_index_for(@root_path, jar_hash, last_timestamp)
+
+        current_files.keys.each do |file|
+          @local_files[file] = current_files[file]
+
+          #TODO: Cut to a new method {
+          current = current_files[file].dup
+          current.delete(:timestamp)
+
+          unless last_index[file].nil?
+            backup = last_index[file].dup
+            backup.delete(:timestamp)
+
+            if (current == backup) or
+               (!current[:checksum].nil? and current[:checksum] == backup[:checksum])
+
+              @local_files[file][:timestamp] = last_index[file][:timestamp]
+            end
+          end
+          # }
+        end
+      end
+
+      @file_item.create_directory_once meta_jars_path, meta_jar_path, jar_data_path
+      @file_item.create_file_once(
+      	"#{meta_jars_path}/#{jar_hash}",
+        @file_item.semantic_path(@local_path)
+      )
+      @file_item.create_file_once(
+      	"#{meta_jar_path}/#{@timestamp}.yml",
+        @local_files.to_yaml
+			)
+
+      if @file_item.is_a? Backup::FileItem::Cloud
+        pbar = ProgressBar.new(
+        	"Uploading",
+          @local_files.keys.count
+        )
+      else
+        pbar = ProgressBar.new(
+        	"Copying",
+          @local_files.keys.count
+        )
+      end
+
+      pbar.bar_mark = '*'
+
+      @local_files.keys.each do |file|
+        unless Dir.exists?(file)
+          @file_item.create_file_once "#{jar_data_path}/#{@file_item.file_hash file}",
+                                      File.open(file)
+          pbar.inc
+        end
+      end
+
+      pbar.finish
+    end
+
+    def hash_local_files
+      files = {}
+
+      puts_verbose "Create index for #{@local_path.dark_green}"
+
+      if Dir.exists? @local_path
+        matches = Dir.glob(File.join(@local_path, "/**/*"), File::FNM_DOTMATCH)
+
+        matches = matches.select do |match|
+          match[/\/..$/].nil? and match[/\/.$/].nil?
+        end
+
+        matches << @local_path
+
+        matches.each do |match|
+          files.merge!(@file_item.stat(match, @timestamp))
+        end
+      else
+        files = @file_item.stat(@local_path, @timestamp)
+      end
+
+      files
+    end
+
+    class << self
+      def hash_to_path(file_item, root_path, hash)
+        file_item.read_file("#{root_path}/meta/jars/#{hash}").chomp
+      rescue Errno::ENOENT
+        ""
+      end
+
+      def all(file_item, root_path)
+        hashes = file_item.dir("#{root_path}/meta/jars").map do |backup|
+          backup[/[0-9a-z]{32}$/]
+        end.compact.sort
+
+        result = {}
+
+        hashes.each do |hash|
+          jar_local_path = Jar.hash_to_path(file_item, root_path, hash)
+          result[jar_local_path] = hash unless jar_local_path.empty?
+        end
+
+        result
+      end
+
+      def jar_versions(file_item, root_path, jar, hash = false)
+        jar = jar.chop if jar =~ /\/$/
+        jar = Digest::MD5.hexdigest(jar) unless hash
+
+        meta_jar_path = "#{root_path}/meta/#{jar}"
+
+        file_item.dir(meta_jar_path, "*.yml").map do |file|
+          match = file.match(/^\/?([0-9]{12}).yml$/)
+          match[1] if match
+        end.compact.sort
+      end
+
+      def fetch_index_for(file_item, root_path, hash, timestamp)
+        index = file_item.read_file "#{root_path}/meta/#{hash}/#{timestamp}.yml"
+        YAML::load(index) unless index.nil?
+      end
+    end
+
+    private
+
+    def meta_jars_path
+      "#{@root_path}/meta/jars"
+    end
+
+    def meta_jar_path
+      "#{@root_path}/meta/#{jar_hash}"
+    end
+
+    def jar_data_path
+      "#{@root_path}/#{jar_hash}/#{@timestamp}"
+    end
+  end
+end

data/lib/backup/timestamp.rb

@@ -0,0 +1,48 @@
+module Backup
+  class Timestamp
+    def self.parse_timestamp(version, last = false)
+      version = version.gsub(".", "").gsub(" ", "").gsub(":", "")
+
+      puts_fail "Invalid date format: #{version}" unless version.match /[0-9]{6,}/
+
+      year, month, day, hour, min, sec =
+        version.split(/([0-9]{2})/).map do |date|
+          date.to_i unless date.empty?
+        end.compact
+
+      if last
+        hour = 23 if hour.nil?
+        min = 59 if min.nil?
+        sec = 59 if sec.nil?
+      end
+
+      time = Time.new(year + 2000, month, day, hour, min, sec, 0)
+    end
+
+    def self.last_from(list, end_date, start_date = nil)
+      list.sort.reverse.find do |version|
+        version = Backup::Timestamp.parse_timestamp version
+
+        unless start_date.nil?
+          version >= start_date and version <= end_date
+        else
+          version <= end_date
+        end
+      end
+    end
+
+    def self.create(time = nil)
+      time = time.nil? ? Time.now : time
+
+      time.utc.strftime "%y%m%d%H%M%S"
+    end
+
+    def self.to_str(version)
+      to_s parse_timestamp(version)
+    end
+
+    def self.to_s(time)
+      time.strftime "%y.%m.%d %H:%M:%S" if time.is_a? Time
+    end
+  end
+end

data/lib/crypto.rb

@@ -0,0 +1,43 @@
+require 'openssl' 
+require 'base64'
+
+module Crypto
+  
+  def self.create_keys(priv = "rsa_key", pub = "#{priv}.pub", bits = 4096)
+    private_key = OpenSSL::PKey::RSA.new(bits)
+    File.open(priv, "w+") { |fp| fp << private_key.to_s }
+    File.open(pub,  "w+") { |fp| fp << private_key.public_key.to_s }    
+    private_key
+  end
+  
+  class Key
+    def initialize(data)
+      @public = (data =~ /^-----BEGIN (RSA|DSA) PRIVATE KEY-----$/).nil?
+      @key = OpenSSL::PKey::RSA.new(data)
+    end
+  
+    def self.from_file(filename)    
+      self.new File.read( filename )
+    end
+  
+    def encrypt(text)
+      @key.send("#{key_type}_encrypt", text)
+    end
+    
+    def decrypt(text)
+      @key.send("#{key_type}_decrypt", text)
+    end
+  
+    def private?
+      !@public
+    end
+  
+    def public?
+      @public
+    end
+    
+    def key_type
+      @public ? :public : :private
+    end
+  end
+end

data/lib/helpers.rb

@@ -0,0 +1,80 @@
+def puts_fail(msg)
+  STDERR.puts "#{"Error: ".red}#{msg}"
+
+  exit msg.length
+end
+
+def puts_verbose(msg)
+  puts msg if $PRINT_VERBOSE
+end
+
+def print_verbose(msg)
+  print msg if $PRINT_VERBOSE
+end
+
+def safe_require(&block)
+  yield
+rescue Exception => e
+  puts_fail %Q{This script use these gems: fog, slop.
+    Make sure that you have them all.
+    If you don't have, you may install them: $ gem install fog slop ruby-progressbar
+  }
+end
+
+def try_create_dir(dir)
+  begin
+    FileUtils.mkdir_p dir unless Dir.exists? dir
+  rescue Errno::EACCES
+    puts_fail "Permission denied for #{dir.dark_green}"
+  end
+end
+
+def check_mode(file, first, second)
+  unless first == second
+    puts_fail "Permission wasn't changed for #{file.dark_green}"
+  end
+end
+
+def check_rights(file, first_uid, first_gid, second_uid, second_gid)
+  unless first_uid == second_uid and first_gid == second_gid
+    puts_fail "Group and user wasn't change for #{file.dark_green}"
+  end
+end
+
+class String
+  def red
+    colorize(self, "\e[1m\e[31m")
+  end
+
+  def green
+    colorize(self, "\e[1m\e[32m")
+  end
+
+  def dark_green
+    colorize(self, "\e[32m")
+  end
+
+  def yellow
+    colorize(self, "\e[1m\e[33m")
+  end
+
+  def blue
+    colorize(self, "\e[1m\e[34m")
+  end
+
+  def dark_blue
+    colorize(self, "\e[34m")
+  end
+
+  def pur
+    colorize(self, "\e[1m\e[35m")
+  end
+
+  def colorize(text, color_code)
+    if $COLORIZE
+      "#{color_code}#{text}\e[0m"
+    else
+      text
+    end
+  end
+end