crackup 1.0.0

data/HISTORY

@@ -0,0 +1,4 @@
+Crackup Release History
+
+Version 1.0.0 (11/16/2006)
+  * First release.

data/LICENSE

@@ -0,0 +1,25 @@
+Copyright (c) 2006 Ryan Grove <ryan@wonko.com>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+    * Neither the name of Crackup nor the names of its contributors may be used
+      to endorse or promote products derived from this software without
+      specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README

@@ -0,0 +1,24 @@
+= Crackup (Crappy Remote Backup)
+
+Crackup is a pretty simple, pretty secure remote backup solution for folks who
+want to keep their data securely backed up but aren't particularly concerned
+about bandwidth usage.
+
+Crackup is ideal for backing up lots of small files, but somewhat less ideal
+for backing up large files, since any change to a file means the entire file
+must be transferred. If you need something bandwidth-efficient, try Duplicity.
+
+Backups are compressed and (optionally) encrypted via GPG and can be
+transferred to the remote location over a variety of protocols, including FTP.
+Additional storage drivers can easily be written in Ruby.
+
+Author::    Ryan Grove (mailto:ryan@wonko.com)
+Version::   1.0.0
+Copyright:: Copyright (c) 2006 Ryan Grove. All rights reserved.
+License::   New BSD License (http://opensource.org/licenses/bsd-license.php)
+Website::   http://wonko.com/software/crackup
+
+== Dependencies
+
+- Ruby 1.8.5+
+- GPG 1.4.2+ (if you want to encrypt your backups)

data/bin/crackup

@@ -0,0 +1,191 @@
+#!/usr/bin/env ruby
+#
+# crackup - command-line tool for performing Crackup backups. See 
+# <tt>crackup -h</tt> for usage information.
+#
+# Author::    Ryan Grove (mailto:ryan@wonko.com)
+# Version::   1.0.0
+# Copyright:: Copyright (c) 2006 Ryan Grove. All rights reserved.
+# License::   New BSD License (http://opensource.org/licenses/bsd-license.php)
+#
+
+require 'crackup'
+require 'optparse'
+
+APP_NAME      = 'crackup'
+APP_VERSION   = '1.0.0'
+APP_COPYRIGHT = 'Copyright (c) 2006 Ryan Grove (ryan@wonko.com). All rights reserved.'
+APP_URL       = 'http://wonko.com/software/crackup'
+
+for sig in [:SIGINT, :SIGTERM]
+  trap(sig) { abort 'Interrupted' }
+end
+
+$stdout.sync = true
+$stderr.sync = true
+    
+module Crackup
+  @options = {
+    :from       => [Dir.pwd],
+    :exclude    => [],
+    :passphrase => nil,
+    :to         => nil,
+    :verbose    => false
+  }
+  
+  optparse = OptionParser.new do |optparse|
+    optparse.summary_width  = 24
+    optparse.summary_indent = '  '
+    
+    optparse.banner = "Usage: #{File.basename(__FILE__)} -t <url> [-p <pass>] [-x <file>] [-v] [<file|dir> ...]"
+    optparse.separator ''
+    
+    optparse.on '-p', '--passphrase <pass>',
+        'Encryption passphrase (if not specified, no',
+        'encryption will be used)' do |passphrase|
+      @options[:passphrase] = passphrase
+    end
+    
+    optparse.on '-t', '--to <url>',
+        'Destination URL (e.g.,',
+        'ftp://user:pass@server.com/path)' do |url|
+      @options[:to] = url.gsub("\\", '/').chomp('/')
+    end
+    
+    optparse.on '-v', '--verbose',
+        'Verbose output' do
+      @options[:verbose] = true
+    end
+    
+    optparse.on '-x', '--exclude <file>',
+        'Exclude files and directories whose names match the',
+        'list in the specified file' do |filename|
+      unless File.file?(filename)
+        error "Exclusion list does not exist: #{filename}"
+      end
+      
+      unless File.readable?(filename)
+        error "Exclusion list is not readable: #{filename}"
+      end
+      
+      begin
+        @options[:exclude] = File.readlines(filename)
+        @options[:exclude].map! {|item| item.chomp }
+      rescue => e
+        error "Error reading exclusion file: #{e}"
+      end
+    end
+    
+    optparse.on_tail '-h', '--help',
+        'Display usage information (this message)' do
+      puts optparse
+      exit
+    end
+    
+    optparse.on_tail '--version',
+        'Display version information' do
+      puts "#{APP_NAME} v#{APP_VERSION} <#{APP_URL}>"
+      puts "#{APP_COPYRIGHT}"
+      puts
+      puts "#{APP_NAME} comes with ABSOLUTELY NO WARRANTY."
+      puts
+      puts "This program is open source software distributed under the terms of"
+      puts "the New BSD License. For details, see the LICENSE file contained in"
+      puts "the source distribution."
+      exit
+    end
+  end
+  
+  # Parse command line options.
+  begin
+    optparse.parse!(ARGV)
+  rescue => e
+    puts optparse
+    puts
+    abort("Error: #{e}")
+  end
+  
+  if @options[:to].nil?
+    puts optparse
+    puts
+    abort 'Error: No destination URL specified.'
+  end
+  
+  # Add files to the "from" array.
+  if ARGV.length > 0
+    @options[:from] = []
+    
+    while filename = ARGV.shift
+      @options[:from] << filename.chomp('/')
+    end
+  end
+  
+  # Load driver.
+  begin
+    @driver = Crackup::Driver.get_driver(@options[:to])
+  rescue => e
+    error e
+  end
+  
+  # Get the remote file index.
+  debug 'Retrieving remote file index...'
+  
+  begin
+    @remote_files = get_remote_files(@options[:to])
+  rescue => e
+    error e
+  end
+  
+  # Build a list of local files and directories.
+  debug 'Building local file list...'
+  
+  begin
+    @local_files = get_local_files()
+  rescue => e
+    error e
+  end
+  
+  # Determine differences.
+  debug 'Determining differences...'  
+  begin
+    update = get_updated_files(@local_files, @remote_files)
+    remove = get_removed_files(@local_files, @remote_files)
+  rescue => e
+    error e
+  end
+  
+  # Remove files from the remote location if necessary.
+  unless remove.empty?
+    debug 'Removing stale files from remote location...'
+    
+    begin
+      remove_files(remove)
+    rescue => e
+      error e
+    end
+  end
+  
+  # Update files at the remote location if necessary.
+  unless update.empty?
+    debug 'Updating remote location with new/changed files...'
+    
+    begin
+      update_files(update)
+    rescue => e
+      error e
+    end
+  end
+  
+  # Update the remote file index if necessary.
+  unless remove.empty? && update.empty?
+    debug 'Updating remote index...'
+    
+    begin
+      update_remote_index
+    rescue => e
+      error e
+    end
+  end
+  
+  debug 'Finished!'
+end

data/bin/crackup-restore

@@ -0,0 +1,163 @@
+#!/usr/bin/env ruby
+#
+# crackup-restore - command-line tool for restoring files from Crackup backups.
+# See <tt>crackup-restore -h</tt> for usage information.
+#
+# Author::    Ryan Grove (mailto:ryan@wonko.com)
+# Version::   1.0.0
+# Copyright:: Copyright (c) 2006 Ryan Grove. All rights reserved.
+# License::   New BSD License (http://opensource.org/licenses/bsd-license.php)
+#
+
+require 'crackup'
+require 'optparse'
+
+APP_NAME      = 'crackup-restore'
+APP_VERSION   = '1.0.0'
+APP_COPYRIGHT = 'Copyright (c) 2006 Ryan Grove (ryan@wonko.com). All rights reserved.'
+APP_URL       = 'http://wonko.com/software/crackup'
+  
+for sig in [:SIGINT, :SIGTERM]
+  trap(sig) { abort 'Interrupted' }
+end
+
+$stdout.sync = true
+$stderr.sync = true
+    
+module Crackup
+  @options = {
+    :all        => false,
+    :from       => nil,
+    :list       => false,
+    :only       => [],
+    :passphrase => nil,
+    :to         => Dir.pwd,
+    :verbose    => false
+  }
+  
+  optparse = OptionParser.new do |optparse|
+    optparse.summary_width  = 24
+    optparse.summary_indent = '  '
+    
+    optparse.banner = "Usage: #{File.basename(__FILE__)} -f <url> -t <path> [-p <pass>] [-v] [<file|dir> ...]\n" +
+                      "       #{File.basename(__FILE__)} -f <url> -l [-p <pass>] [-v]"
+    optparse.separator ''
+    
+    optparse.on '-f', '--from <url>',
+        'Remote URL to restore from (e.g.,',
+        'ftp://user:pass@server.com/path)' do |url|
+      @options[:from] = url.gsub("\\", '/').chomp('/')
+    end
+    
+    optparse.on '-l', '--list',
+        'List all files at the remote location' do
+      @options[:list] = true
+    end
+
+    optparse.on '-p', '--passphrase <pass>',
+        'Encryption passphrase (if not specified, no',
+        'encryption will be used)' do |passphrase|
+      @options[:passphrase] = passphrase
+    end
+    
+    optparse.on '-t', '--to <path>',
+        'Destination root directory for the restored files' do |path|
+      @options[:to] = path.chomp('/')
+    end
+    
+    optparse.on '-v', '--verbose',
+        'Verbose output' do
+      @options[:verbose] = true
+    end
+    
+    optparse.on_tail '-h', '--help',
+        'Display usage information (this message)' do
+      puts optparse
+      exit
+    end
+    
+    optparse.on_tail '--version',
+        'Display version information' do
+      puts "#{APP_NAME} v#{APP_VERSION} <#{APP_URL}>"
+      puts "#{APP_COPYRIGHT}"
+      puts
+      puts "#{APP_NAME} comes with ABSOLUTELY NO WARRANTY."
+      puts
+      puts "This program is open source software distributed under the terms of"
+      puts "the New BSD License. For details, see the LICENSE file contained in"
+      puts "the source distribution."
+      exit
+    end
+  end
+  
+  # Parse command line options.
+  begin
+    optparse.parse!(ARGV)
+  rescue => e
+    puts optparse
+    puts
+    error e
+  end
+  
+  if @options[:from].nil?
+    puts optparse
+    puts
+    abort 'Error: No remote URL specified.'
+  end
+  
+  # Add files to the "only" array.
+  if ARGV.length > 0
+    @options[:only] = []
+    
+    while filename = ARGV.shift
+      @options[:only] << filename.chomp('/')
+    end
+  else
+    @options[:all] = true
+  end
+  
+  # Load driver.
+  begin
+    @driver = Crackup::Driver.get_driver(@options[:from])
+  rescue => e
+    error e
+  end
+  
+  # Get the list of remote files and directories.
+  debug 'Retrieving remote file list...'
+  
+  begin
+    @remote_files = get_remote_files(@options[:from])
+  rescue => e
+    error e
+  end
+  
+  # List remote files if the --list option was given.
+  if @options[:list]
+    puts get_list(@remote_files).sort
+    exit
+  end
+
+  # Restore files.
+  debug 'Restoring files...'
+
+  begin
+    if @options[:all]
+      @remote_files.each_value {|file| file.restore(@options[:to]) }
+    else
+      @options[:only].each do |pattern|
+        files = find_remote_files(pattern)
+      
+        if files.empty?
+          error "Remote file not found: #{pattern}"
+        end
+        
+        files.each {|file| file.restore(@options[:to]) }
+      end
+    end
+  rescue => e
+    error e
+  end
+  
+  debug 'Finished!'
+end

data/lib/crackup/dirobject.rb

@@ -0,0 +1,92 @@
+require 'crackup/fsobject'
+
+module Crackup
+
+  # Represents a directory on the local filesystem. Can contain any number of
+  # Crackup::FileSystemObjects as children.
+  class DirectoryObject
+    include FileSystemObject
+
+    attr_reader :children
+
+    #--
+    # Public Class Methods
+    #++
+    
+    def initialize(name)
+      unless File.directory?(name)
+        raise ArgumentError, "#{name} is not a directory"
+      end
+
+      super(name)
+
+      refresh_children
+    end
+    
+    #--
+    # Public Instance Methods
+    #++
+    
+    # Gets an array of files contained in this directory or its children whose
+    # local filenames match _pattern_.
+    def find(pattern)
+      files = []
+      
+      @children.each do |name, child|
+        if File.fnmatch?(pattern, child.name)
+          files << child
+          next
+        end
+        
+        next unless child.is_a?(Crackup::DirectoryObject)
+        files << result if result = child.find(pattern)
+      end
+      
+      return files
+    end
+
+    # Builds a Hash of child objects by analyzing the local filesystem. A
+    # refresh is automatically performed when the object is instantiated.
+    def refresh_children
+      @children = {}
+
+      Dir.open(@name) do |dir|
+        dir.each do |filename|
+          next if filename == '.' || filename == '..'
+
+          filename = File.join(dir.path, filename).gsub("\\", "/")
+
+          # Skip this file if it's in the exclusion list.
+          unless Crackup::options[:exclude].nil?
+            next if Crackup::options[:exclude].any? do |pattern|
+              File.fnmatch?(pattern, filename)
+            end
+          end
+
+          if File.directory?(filename)
+            @children[filename.chomp('/')] = Crackup::DirectoryObject.new(filename)
+          elsif File.file?(filename)
+            @children[filename] = Crackup::FileObject.new(filename)
+          end
+        end
+      end
+    end
+
+    # Removes the remote copy of this directory and all its children.
+    def remove
+      @children.each_value {|child| child.remove }
+    end
+
+    # Restores the remote copy of this directory to the specified local 
+    # <em>path</em>.
+    def restore(path)
+      @children.each_value {|child| child.restore(path) }
+    end
+    
+    # Uploads this directory and all its children to the remote location.
+    def update
+      @children.each_value {|child| child.update }
+    end
+  end
+
+end

data/lib/crackup/driver.rb

@@ -0,0 +1,80 @@
+require 'uri'
+
+module Crackup
+
+  # Base storage driver module for Crackup.
+  # 
+  # To write a Crackup storage driver:
+  # 
+  # - Create a class in Crackup::Driver named "FooDriver", where "Foo" is the
+  #   capitalized version of the URI scheme your driver will handle (e.g.,
+  #   "Ftp", "Sftp", etc.).
+  # - Name your class file <tt>foo.rb</tt> ("foo" being the lowercase URI scheme
+  #   this time) and place it in Crackup's <tt>lib/crackup/drivers</tt>
+  #   directory.
+  # - In your class, mixin the Crackup::Driver module and override at least the
+  #   delete, get, and put methods.
+  #   
+  # That's all there is to it. See Crackup::Driver::FileDriver and
+  # Crackup::Driver::FtpDriver for examples.
+  module Driver
+    attr_reader :url
+    
+    # Gets an instance of the appropriate storage driver to handle the specified
+    # _url_. If no suitable driver is found, raises a Crackup::StorageError.
+    def self.get_driver(url)
+      begin
+        uri = URI::parse(url)
+      rescue => e
+        raise Crackup::StorageError, "Invalid URL: #{url}: #{e}"
+      end
+      
+      # Use the filesystem driver if no scheme is specified or if the scheme is
+      # a single letter (which indicates a Windows drive letter).
+      if uri.scheme.nil? || uri.scheme =~ /^[a-z]$/i
+        scheme = 'file'
+      else
+        scheme = uri.scheme.downcase
+      end
+      
+      # Load the driver.
+      unless require(File.dirname(__FILE__) + "/drivers/#{scheme}")
+        raise Crackup::StorageError, "Driver not found for scheme '#{uri.scheme}'"
+      end
+      
+      return const_get("#{scheme.capitalize}Driver").new(url)
+    end
+    
+    def initialize(url)
+      @url = url
+    end
+    
+    # Deletes the file at the specified _url_. This method does nothing and is
+    # intended to be overridden by a driver class.
+    def delete(url)
+      return false
+    end
+    
+    # Downloads the file at _url_ to <em>local_filename</em>. This method does
+    # nothing and is intended to be overridden by a driver class.
+    def get(url, local_filename)
+      return false
+    end
+    
+    # Gets the path portion of _url_.
+    def get_path(url)
+      uri = URI::parse(url)
+      return uri.path
+
+    rescue => e
+      raise Crackup::StorageError, "Invalid URL: #{url}: #{e}"
+    end
+      
+    # Uploads the file at <em>local_filename</em> to _url_. This method does
+    # nothing and is intended to be overridden by a driver class.
+    def put(url, local_filename)
+      return false
+    end
+  end
+
+end

data/lib/crackup/drivers/file.rb

@@ -0,0 +1,73 @@
+require 'crackup/driver'
+require 'fileutils'
+require 'uri'
+
+module Crackup; module Driver
+
+  # Filesystem storage driver for Crackup.
+  # 
+  # Author::    Ryan Grove (mailto:ryan@wonko.com)
+  # Copyright:: Copyright (c) 2006 Ryan Grove. All rights reserved.
+  # License::   New BSD License (http://opensource.org/licenses/bsd-license.php)
+  # 
+  class FileDriver
+    include Driver
+  
+    # Deletes the file at the specified _url_.
+    def delete(url)
+      File.delete(get_path(url))
+      return true
+      
+    rescue => e
+      raise Crackup::StorageError, "Unable to delete #{url}: #{e}"
+    end
+    
+    # Downloads the file at _url_ to _local_filename_.
+    def get(url, local_filename)
+      FileUtils::copy(get_path(url), local_filename)
+      return true
+    
+    rescue => e
+      raise Crackup::StorageError, "Unable to get #{url}: #{e}"
+    end
+    
+    # Gets the filesystem path represented by _url_. This method is capable of
+    # parsing URLs in any of the following formats:
+    # 
+    # - file:///foo/bar
+    # - file://c:/foo/bar
+    # - c:/foo/bar
+    # - /foo/bar
+    # - //smbhost/foo/bar
+    def get_path(url)
+      uri  = URI::parse(url)
+      path = ''
+      
+      if uri.scheme =~ /^[a-z]$/i
+        # Windows drive letter.
+        path = uri.scheme + ':'
+      elsif uri.host =~ /^[a-z]$/i
+        # Windows drive letter.
+        path = uri.host + ':'
+      elsif uri.scheme.nil? && !uri.host.nil?
+        # SMB share.
+        path = '//' + uri.host
+      end
+      
+      return path += uri.path
+      
+    rescue => e
+      raise Crackup::StorageError, "Invalid URL: #{url}"
+    end
+    
+    # Uploads the file at _local_filename_ to _url_.
+    def put(url, local_filename)
+      FileUtils::copy(local_filename, get_path(url))
+      return true
+      
+    rescue => e
+      raise Crackup::StorageError, "Unable to put #{url}: #{e}"
+    end
+  end
+
+end; end

data/lib/crackup/drivers/ftp.rb

@@ -0,0 +1,71 @@
+require 'crackup/driver'
+require 'net/ftp'
+require 'uri'
+
+module Crackup; module Driver
+
+  # FTP storage driver for Crackup.
+  # 
+  # Author::    Ryan Grove (mailto:ryan@wonko.com)
+  # Copyright:: Copyright (c) 2006 Ryan Grove. All rights reserved.
+  # License::   New BSD License (http://opensource.org/licenses/bsd-license.php)
+  # 
+  class FtpDriver
+    include Driver
+  
+    # Connects to the FTP server specified in _url_.
+    def initialize(url)
+      super(url)
+      
+      # Parse URL.
+      begin
+        uri = URI::parse(url)
+      rescue => e
+        raise Crackup::StorageError, "Invalid URL: #{url}: #{e}"
+      end
+      
+      @ftp = Net::FTP.new
+      @ftp.passive = true
+
+      begin
+        @ftp.connect(uri.host, uri.port.nil? ? 21 : uri.port)
+      rescue => e
+        raise Crackup::StorageError, "FTP connect failed: #{e}"
+      end
+      
+      begin
+        @ftp.login(uri.user.nil? ? 'anonymous' : uri.user, uri.password)
+      rescue => e
+        raise Crackup::StorageError, "FTP login failed: #{e}"
+      end
+    end
+
+    # Deletes the file at the specified _url_.
+    def delete(url)
+      @ftp.delete(get_path(url))
+      return true
+      
+    rescue => e
+      raise Crackup::StorageError, "Unable to delete #{url}: #{e}"
+    end
+    
+    # Downloads the file at _url_ to _local_filename_.
+    def get(url, local_filename)
+      @ftp.getbinaryfile(get_path(url), local_filename)
+      return true
+    
+    rescue => e
+      raise Crackup::StorageError, "Unable to download #{url}: #{e}"
+    end
+    
+    # Uploads the file at _local_filename_ to _url_.
+    def put(url, local_filename)
+      @ftp.putbinaryfile(local_filename, get_path(url))
+      return true
+      
+    rescue => e
+      raise Crackup::StorageError, "Unable to upload #{url}: #{e}"
+    end
+  end
+
+end; end

data/lib/crackup/errors.rb

@@ -0,0 +1,9 @@
+module Crackup
+
+  class Error < StandardError; end
+  class CompressionError < Crackup::Error; end
+  class EncryptionError < Crackup::Error; end
+  class IndexError < Crackup::Error; end
+  class StorageError < Crackup::Error; end
+
+end

data/lib/crackup/fileobject.rb

@@ -0,0 +1,86 @@
+require 'crackup/fsobject'
+require 'digest/sha2'
+require 'fileutils'
+
+module Crackup
+
+  # Represents a file on the local filesystem.
+  class FileObject
+    include FileSystemObject
+
+    attr_reader :file_hash, :url
+  
+    def initialize(filename)
+      unless File.file?(filename)
+        raise ArgumentError, "#{filename} is not a file"
+      end
+      
+      super(filename)
+      
+      # Get the file's SHA256 hash.
+      digest = Digest::SHA256.new()
+      
+      File.open(filename, 'rb') do |file|
+        until file.eof? do
+          digest << file.read(1048576)
+        end
+      end
+
+      @file_hash = digest.hexdigest()
+      @url       = "#{Crackup.driver.url}/crackup_#{@name_hash}"
+    end
+    
+    # Removes this file from the remote location.
+    def remove
+      Crackup.debug "--> #{@name}"
+      Crackup.driver.delete(@url)
+    end
+
+    # Restores the remote copy of this file to the local path specified by
+    # _path_.
+    def restore(path)
+      path     = path.chomp('/') + '/' + File.dirname(@name).delete(':')
+      filename = path + '/' + File.basename(@name)
+
+      Crackup.debug "--> #{filename}"
+      
+      # Create the path if it doesn't exist.
+      unless File.directory?(path)
+        begin
+          FileUtils.mkdir_p(path)
+        rescue => e
+          raise Crackup::Error, "Unable to create local directory: #{path}"
+        end
+      end
+      
+      # Download the remote file.
+      tempfile = Crackup.get_tempfile()
+      Crackup.driver.get(@url, tempfile)
+      
+      # Decompress/decrypt the file.
+      if Crackup.options[:passphrase].nil?
+        Crackup.decompress_file(tempfile, filename)
+      else
+        Crackup.decrypt_file(tempfile, filename)
+      end
+    end
+    
+    # Uploads this file to the remote location.
+    def update
+      Crackup.debug "--> #{@name}"
+      
+      # Compress/encrypt the file.
+      tempfile = Crackup.get_tempfile()
+      
+      if Crackup.options[:passphrase].nil?
+        Crackup.compress_file(@name, tempfile)
+      else
+        Crackup.encrypt_file(@name, tempfile)
+      end
+      
+      # Upload the file.
+      Crackup.driver.put(@url, tempfile)
+    end
+  end
+
+end

data/lib/crackup/fsobject.rb

@@ -0,0 +1,18 @@
+require 'digest/sha2'
+
+module Crackup
+  
+  # Represents a filesystem object on the local filesystem.
+  module FileSystemObject
+    attr_reader :name, :name_hash
+    
+    def initialize(name)
+      @name      = name.chomp('/')
+      @name_hash = Digest::SHA256.hexdigest(name)
+    end
+    
+    def remove; end
+    def restore(local_path); end
+  end
+
+end

data/lib/crackup.rb

@@ -0,0 +1,321 @@
+ENV['PATH'] = "#{File.dirname(__FILE__)};#{ENV['PATH']}"
+
+require 'crackup/errors'
+require 'crackup/dirobject'
+require 'crackup/driver'
+require 'crackup/fileobject'
+require 'tempfile'
+require 'zlib'
+
+module Crackup
+
+  GPG_DECRYPT = 'echo :passphrase | gpg --batch --quiet --no-tty --no-secmem-warning --cipher-algo aes256 --compress-algo bzip2 --passphrase-fd 0 --output :output_file :input_file'
+  GPG_ENCRYPT = 'echo :passphrase | gpg --batch --quiet --no-tty --no-secmem-warning --cipher-algo aes256 --compress-algo bzip2 --passphrase-fd 0 --output :output_file --symmetric :input_file'
+  
+  attr_accessor :driver, :local_files, :options, :remote_files
+  
+  # Reads _infile_ and compresses it to _outfile_ using zlib compression.
+  def self.compress_file(infile, outfile)
+    File.open(infile, 'rb') do |input|
+      Zlib::GzipWriter.open(outfile, 9) do |output|
+        while data = input.read(1048576) do
+          output.write(data)
+        end
+      end
+    end
+    
+  rescue => e
+    raise Crackup::CompressionError, "Unable to compress #{infile}: #{e}"
+  end
+  
+  # Prints _message_ to +stdout+ if verbose mode is enabled.
+  def self.debug(message)
+    puts message if @options[:verbose] || $VERBOSE
+  end
+  
+  # Reads _infile_ and decompresses it to _outfile_ using zlib compression.
+  def self.decompress_file(infile, outfile)
+    Zlib::GzipReader.open(infile) do |input|
+      File.open(outfile, 'wb') do |output|
+        while data = input.read(1048576) do
+          output.write(data)
+        end
+      end
+    end
+  
+  rescue => e
+    raise Crackup::CompressionError, "Unable to decompress #{infile}: #{e}"
+  end
+  
+  # Calls GPG to decrypt _infile_ to _outfile_.
+  def self.decrypt_file(infile, outfile)
+    File.delete(outfile) if File.exist?(outfile)
+
+    gpg_command = String.new(GPG_DECRYPT)
+    gpg_command.gsub!(':input_file', escapeshellarg(infile))
+    gpg_command.gsub!(':output_file', escapeshellarg(outfile))
+    gpg_command.gsub!(':passphrase', escapeshellarg(@options[:passphrase]))
+    
+    unless system(gpg_command)
+      raise Crackup::EncryptionError, "Unable to decrypt file: #{infile}"
+    end
+  end
+  
+  def self.driver
+    return @driver
+  end
+  
+  # Calls GPG to encrypt _infile_ to _outfile_.
+  def self.encrypt_file(infile, outfile)
+    File.delete(outfile) if File.exist?(outfile)
+
+    gpg_command = String.new(GPG_ENCRYPT)
+    gpg_command.gsub!(':input_file', escapeshellarg(infile))
+    gpg_command.gsub!(':output_file', escapeshellarg(outfile))
+    gpg_command.gsub!(':passphrase', escapeshellarg(@options[:passphrase]))
+    
+    unless system(gpg_command)
+      raise Crackup::EncryptionError, "Unable to encrypt file: #{infile}"
+    end
+  end
+  
+  # Prints the specified _message_ to +stderr+ and exits with an error
+  # code of 1.
+  def self.error(message)
+    abort "#{APP_NAME}: #{message}"
+  end
+  
+  # Wraps _arg_ in single quotes, escaping any single quotes contained therein,
+  # thus making it safe for use as a shell argument.
+  def self.escapeshellarg(arg)
+    return "'#{arg.gsub("'", "\\'")}'"
+  end
+  
+  # Gets an array of files in the remote file index whose local paths match
+  # _pattern_.
+  def self.find_remote_files(pattern)
+    files = []
+    pattern.chomp!('/')
+    
+    @remote_files.each do |name, file|
+      if File.fnmatch?(pattern, file.name)
+        files << file
+        next
+      end
+
+      next unless file.is_a?(Crackup::DirectoryObject)
+      files += file.find(pattern)
+    end
+    
+    return files
+  end
+  
+  # Gets a flat array of filenames from _files_, which may be either a Hash
+  # or a Crackup::FileSystemObject.
+  def self.get_list(files)
+    list = []
+  
+    if files.is_a?(Hash)
+      files.each_value {|value| list += get_list(value) }
+    elsif files.is_a?(Crackup::DirectoryObject)
+      list += get_list(files.children)
+    elsif files.is_a?(Crackup::FileObject)
+      list << files.name 
+    end
+    
+    return list
+  end
+
+  # Gets a Hash of Crackup::FileSystemObjects representing the files and
+  # directories on the local system in the locations specified by the array of
+  # filenames in <tt>options[:from]</tt>.
+  def self.get_local_files
+    local_files = {}
+    
+    @options[:from].each do |filename|
+      next unless File.exist?(filename = filename.chomp('/'))
+      next if local_files.has_key?(filename)
+      
+      # Skip this file if it's in the exclusion list.
+      unless @options[:exclude].nil?
+        next if @options[:exclude].any? do |pattern|
+          File.fnmatch?(pattern, filename)
+        end
+      end
+      
+      if File.directory?(filename)
+        debug "--> #{filename}"
+        local_files[filename] = Crackup::DirectoryObject.new(filename)
+      elsif File.file?(filename)
+        debug "--> #{filename}"
+        local_files[filename] = Crackup::FileObject.new(filename)
+      end
+    end
+    
+    return local_files
+  end
+  
+  # Gets a Hash of Crackup::FileSystemObjects present at the remote location.
+  def self.get_remote_files(url)
+    tempfile = get_tempfile()
+    
+    # Download the index file.
+    begin
+      @driver.get(url + '/.crackup_index', tempfile)
+    rescue => e
+      return {}
+    end
+    
+    # Decompress/decrypt the index file.
+    oldfile  = tempfile
+    tempfile = get_tempfile()
+    
+    if @options[:passphrase].nil?
+      begin
+        decompress_file(oldfile, tempfile)
+      rescue => e
+        raise Crackup::IndexError, "Unable to decompress index file. Maybe " +
+            "it's encrypted?"
+      end
+    else
+      begin
+        decrypt_file(oldfile, tempfile)
+      rescue => e
+        raise Crackup::IndexError, "Unable to decrypt index file."
+      end
+    end
+    
+    # Load the index file.
+    file_list = {}
+
+    begin
+      File.open(tempfile, 'rb') {|file| file_list = Marshal.load(file) }
+    rescue => e
+      raise Crackup::IndexError, "Remote index is invalid!"
+    end
+    
+    unless file_list.is_a?(Hash)
+      raise Crackup::IndexError, "Remote index is invalid!"
+    end
+    
+    return file_list
+  end
+  
+  # Gets an Array of Crackup::FileSystemObjects representing files and
+  # directories that exist at the remote location but no longer exist at the
+  # local location.
+  def self.get_removed_files(local_files, remote_files)
+    removed = []
+
+    remote_files.each do |name, remotefile|
+      unless local_files.has_key?(name)
+        removed << remotefile
+        next
+      end
+
+      localfile = local_files[name]
+      
+      if remotefile.is_a?(Crackup::DirectoryObject) && 
+          localfile.is_a?(Crackup::DirectoryObject)
+        removed += get_removed_files(localfile.children, remotefile.children)
+      end
+    end
+    
+    return removed
+  end
+  
+  # Creates a new temporary file in the system's temporary directory and returns
+  # its name. All temporary files will be deleted when the program exits.
+  def self.get_tempfile
+    tempfile = Tempfile.new('.crackup')
+    tempfile.close
+    
+    return tempfile.path
+  end
+
+  # Gets an Array of Crackup::FileSystemObjects representing files and
+  # directories that are new or have been modified at the local location and
+  # need to be updated at the remote location.
+  def self.get_updated_files(local_files, remote_files)
+    updated = []
+    
+    local_files.each do |name, localfile|
+      # Add the file to the list if it doesn't exist at the remote location.
+      unless remote_files.has_key?(name)
+        updated << localfile
+        next
+      end
+      
+      remotefile = remote_files[name]
+      
+      if localfile.is_a?(Crackup::DirectoryObject) && 
+          remotefile.is_a?(Crackup::DirectoryObject)
+        # Add to the list all updated files contained in the directory and its 
+        # subdirectories.
+        updated += get_updated_files(localfile.children, remotefile.children)
+      elsif localfile.is_a?(Crackup::FileObject) && 
+          remotefile.is_a?(Crackup::FileObject)
+        # Add the file to the list if the local file has been modified.
+        unless localfile.file_hash == remotefile.file_hash
+          updated << localfile
+        end
+      end
+    end
+    
+    return updated
+  end
+  
+  def self.options
+    return @options
+  end
+
+  # Prints _message_ to +stdout+ and waits for user input, which is then
+  # returned.
+  def self.prompt(message)
+    puts message + ': '
+    return $stdin.gets
+  end
+  
+  # Deletes each Crackup::FileSystemObject specified in the _files_ array from
+  # the remote location.
+  def self.remove_files(files)
+    files.each do |file|
+      file.remove
+    end
+  end
+  
+  # Uploads each Crackup::FileSystemObject specified in the _files_ array to the
+  # remote location.
+  def self.update_files(files)
+    files.each do |file|
+      file.update
+    end
+  end
+  
+  # Brings the remote file index up to date with the local one.
+  def self.update_remote_index
+    tempfile   = get_tempfile()
+    remotefile = @options[:to] + '/.crackup_index'
+  
+    File.open(tempfile, 'wb') {|file| Marshal.dump(@local_files, file) }
+    
+    oldfile  = tempfile
+    tempfile = get_tempfile()
+    
+    if @options[:passphrase].nil?
+      compress_file(oldfile, tempfile)
+    else
+      encrypt_file(oldfile, tempfile)
+    end
+    
+    begin
+      success = @driver.put(remotefile, tempfile)
+    rescue => e
+      tryagain = prompt('Unable to update remote index. Try again? (y/n)')
+    
+      retry if tryagain.downcase == 'y'
+      raise Crackup::IndexError, "Unable to update remote index: #{e}"
+    end
+  end
+  
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: crackup
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+date: 2006-11-15 00:00:00 -08:00
+summary: Crackup is a pretty simple, pretty secure remote backup solution for folks who want to keep their data securely backed up but aren't particularly concerned about bandwidth usage.
+require_paths: 
+- lib
+email: ryan@wonko.com
+homepage: http://wonko.com/software/crackup
+rubyforge_project: 
+description: 
+autorequire: crackup
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.4
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Ryan Grove
+files: 
+- bin/crackup
+- bin/crackup-restore
+- lib/crackup
+- lib/crackup.rb
+- lib/crackup/dirobject.rb
+- lib/crackup/driver.rb
+- lib/crackup/drivers
+- lib/crackup/errors.rb
+- lib/crackup/fileobject.rb
+- lib/crackup/fsobject.rb
+- lib/crackup/drivers/file.rb
+- lib/crackup/drivers/ftp.rb
+- LICENSE
+- HISTORY
+- README
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+executables: 
+- crackup
+- crackup-restore
+extensions: []
+
+requirements: []
+
+dependencies: []
+