cloud_encrypted_sync 0.1.0

data/.gitignore

@@ -0,0 +1,4 @@
+.redcar
+config/config.yml
+coverage
+*.gem

data/Gemfile

@@ -0,0 +1,2 @@
+source 'http://rubygems.org'
+gemspec

data/Gemfile.lock

@@ -0,0 +1,31 @@
+PATH
+  remote: .
+  specs:
+    cloud_encrypted_sync (0.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.2.3)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    fakefs (0.4.0)
+    i18n (0.6.0)
+    metaclass (0.0.1)
+    mocha (0.11.4)
+      metaclass (~> 0.0.1)
+    multi_json (1.3.4)
+    simplecov (0.6.4)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.5.3)
+    simplecov-html (0.5.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport
+  cloud_encrypted_sync!
+  fakefs
+  mocha
+  simplecov

data/LICENSE

@@ -0,0 +1,17 @@
+Copyright (c) 2012 Jonathan S. Garvin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this
+software and associated documentation files (the "Software"), to deal in the Software
+without restriction, including without limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
+to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
+FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,60 @@
+# Cloud Encrypted Sync
+
+Cloud Encrypted Sync (CES) is a command line tool distributed as a Ruby gem for syncing a local
+folder to cloud storage via external adapters, with localy managed encryption (you control the
+keys).
+
+Even though you could simply use CES to backup a local folder to the cloud, it's original
+intended purpose is to sync a folder across multiple computers, so it should work for that,
+too.
+
+## Installation
+
+    gem install cloud_encrypted_sync
+
+In addition to this gem you'll also need to install an adapter gem for the particular cloud
+you want to backup to.  At the time of this writing, the only available adapter is for Amazon
+S3, although anyone can create an adapter to work with other clouds. Search rubygems.org for
+"cloud encrypted sync" to find out if someone has already created an adapter for your
+preferred cloud.
+
+## Getting started
+
+CES runs as a command line tool and takes options as CLI arguments and/or from a config file.
+Arguments passed at the command line take precedence over those in the config file.
+
+### Creating a valid encryption key and initialization vector.
+
+TODO
+
+### Example
+
+    ces --adapter=s3 --bucket=my-backup-bucket \
+      --s3-credentials=ACCESS_KEY_ID,SECRET_ACCESS_KEY \
+      --encryption-key=MYENCRYPTIONKEY /path/to/source/folder
+
+## Configuration
+
+Configuration options may be passed to CES via the command line, or via a config yaml file.
+
+The default location for the config file is `~/.cloud_encrypted_sync/config.rc.yml`
+
+### Available Settings
+
+CES requires the following configuration settings. Any of thse may alternatively be placed in
+the `config.rc.yml` execpt for `--data-dir` (which tells CES which folder contains the config
+file to use).
+
+* `--adapter=ADAPTERNAME` The name of the adapter to use. See instructions for your preferred
+adapter for instructions of what to place here.
+* `--encryption-key=XXX`  The encryption key (shocking, I know).
+
+In addition to these settings, your chosen adapter will probably also have additional adapter
+specific settings as well, such as credentials to log into your cloud storage account. Adapter
+specific settings may work the same the the above standard settings in that they may be included
+on the command or in the `config.rc.yml` file (unless the adapter author breaks convention and
+tries to do something weird).
+
+## Creating your own adapter
+
+TODO

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rake/testtask'
+
+task :default => :test
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end

data/bin/ces

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require 'optparse'
+require 'etc'
+require File.expand_path('../../lib/cloud_encrypted_sync', __FILE__)
+CloudEncryptedSync::Master.activate!

data/cloud_encrypted_sync.gemspec

@@ -0,0 +1,22 @@
+require File.expand_path('../lib/cloud_encrypted_sync/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name = "cloud_encrypted_sync"
+  s.version = CloudEncryptedSync::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.authors = ["Jonathan S. Garvin"]
+  s.email = ["jon@5valleys.com"]
+  s.homepage = "https://github.com/jsgarvin/cloud_encrypted_sync"
+  s.summary = %q{Encrypted sync of folder contents to/from cloud storage.}
+  s.description = %q{Encrypted sync of folder contents to/from cloud storage with user controlled encryption keys.}
+
+  s.add_development_dependency('mocha')
+  s.add_development_dependency('simplecov')
+  s.add_development_dependency('fakefs')
+  s.add_development_dependency('activesupport')
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- test/*`.split("\n")
+  s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/cloud_encrypted_sync.rb

@@ -0,0 +1,6 @@
+require File.expand_path('../cloud_encrypted_sync/master', __FILE__)
+require File.expand_path('../cloud_encrypted_sync/configuration', __FILE__)
+require File.expand_path('../cloud_encrypted_sync/cryptographer', __FILE__)
+require File.expand_path('../cloud_encrypted_sync/adapter_template', __FILE__)
+require File.expand_path('../cloud_encrypted_sync/dummy_adapter', __FILE__)
+require File.expand_path('../cloud_encrypted_sync/progress_meter', __FILE__)

data/lib/cloud_encrypted_sync/adapter_template.rb

@@ -0,0 +1,34 @@
+module CloudEncryptedSync
+  module Adapters
+    class Template
+
+      class << self
+
+        def inherited(subclass)
+          Master.register(subclass)
+        end
+
+        def parse_command_line_options(opts,command_line_options)
+          raise 'called template method: parse_command_line_options'
+        end
+
+        def write(data, key)
+          raise 'called template method: write'
+        end
+
+        def read(key)
+          raise 'called template method: read'
+        end
+
+        def delete(key)
+          raise 'called template method: delete'
+        end
+
+        def key_exists?(key)
+          raise 'called template method: key_exists?'
+        end
+
+      end
+    end
+  end
+end

data/lib/cloud_encrypted_sync/configuration.rb

@@ -0,0 +1,82 @@
+require 'yaml'
+
+module CloudEncryptedSync
+  class Configuration
+
+    class << self
+
+      attr_reader :option_parser
+
+      def settings
+        @settings ||= load_settings
+      end
+
+      def data_folder_path
+        command_line_options[:data_dir]
+      end
+
+      #######
+      private
+      #######
+
+      def load_settings
+        touch_data_folder
+        loaded_settings = {}
+        loaded_settings = YAML.load_file(config_file_path) if File.exist?(config_file_path)
+        loaded_settings.merge!(command_line_options)
+        loaded_settings = loaded_settings.inject({}) do |options, (key, value)|
+          options[(key.to_sym rescue key) || key] = value
+          options
+        end
+        loaded_settings[:sync_path] = ARGV.shift unless ARGV.empty?
+
+        if loaded_settings[:sync_path].nil?
+          message = "You must supply a path to a folder to sync.\n\n#{option_parser.help}"
+          raise IncompleteConfigurationError.new(message)
+        elsif loaded_settings[:encryption_key].nil? or loaded_settings[:encryption_key].empty?
+          message = "You must supply an encryption key.\n\n#{option_parser.help}"
+          raise IncompleteConfigurationError.new(message)
+        end
+
+        return loaded_settings
+      end
+
+      def touch_data_folder
+        FileUtils.mkdir_p(data_folder_path) unless Dir.exists?(data_folder_path)
+      end
+
+      def config_file_path
+        data_folder_path+'/config.rc.yml'
+      end
+
+      def command_line_options
+        @command_line_options ||= parse_command_line_options
+      end
+
+      def parse_command_line_options
+        executable_name = File.basename($PROGRAM_NAME)
+        clo = {:data_dir => "#{Etc.getpwuid.dir}/.cloud_encrypted_sync"}
+
+        @option_parser = OptionParser.new do |opts|
+          opts.banner = "Usage: #{executable_name} [options] /path/to/folder/to/sync"
+          opts.on('--data-dir PATH',"Data directory where snapshots and config file are found.") do |path|
+            clo[:data_dir] = path
+          end
+          opts.on('--adapter ADAPTERNAME', 'Name of cloud adapter to use.') do |adapter_name|
+            clo[:adapter_name] = adapter_name
+            clo = Master.adapters[adapter_name.to_sym].parse_command_line_options(opts,clo)
+          end
+          opts.on('--encryption-key KEY') do |key|
+            clo[:encryption_key] = key
+          end
+        end
+        @option_parser.parse!
+
+        return clo
+      end
+
+    end
+  end
+
+  class IncompleteConfigurationError < RuntimeError; end
+end

data/lib/cloud_encrypted_sync/cryptographer.rb

@@ -0,0 +1,61 @@
+require 'openssl'
+require 'digest'
+
+module CloudEncryptedSync
+  class Cryptographer
+    ALGORITHM = 'AES-256-CBC'
+
+    class << self
+
+
+      def encrypt_data(data)
+        iv = generate_random_iv
+        encrypted_data = crypt_data(:encrypt, iv, data)
+        return iv + encrypted_data
+      end
+
+      def decrypt_data(ivdata)
+        iv= ivdata.byteslice(0..15)
+        data = ivdata.byteslice(16..-1)
+        crypt_data(:decrypt, iv, data)
+      end
+
+      def hash_data(data)
+        Digest::SHA2.hexdigest(data,512)
+      end
+
+      def generate_random_key
+        initialized_cipher.random_key.unpack('H*')[0]
+      end
+
+      #######
+      private
+      #######
+
+      def generate_random_iv
+        initialized_cipher.random_iv
+      end
+
+      def initialized_cipher(crypt = nil)
+        cipher = OpenSSL::Cipher::Cipher.new(ALGORITHM)
+        cipher.send(crypt) if crypt
+        return cipher
+      end
+
+      def setup_cipher(crypt,iv)
+        cipher = initialized_cipher(crypt)
+        cipher.key = hash_data(Configuration.settings[:encryption_key])
+        cipher.iv = iv
+        return cipher
+      end
+
+      def crypt_data(direction,iv,precrypted_data)
+        cipher = setup_cipher(direction,iv)
+        crypted_data = cipher.update(precrypted_data)
+        crypted_data << cipher.final
+        return crypted_data
+      end
+    end
+
+  end
+end

data/lib/cloud_encrypted_sync/dummy_adapter.rb

@@ -0,0 +1,47 @@
+module CloudEncryptedSync
+  module Adapters
+    class Dummy < Template
+
+      class << self
+
+        def write(data,key)
+          stored_data[key] = data
+        end
+
+        def parse_command_line_options(opts,command_line_options)
+          opts.on('--bucket BUCKETNAME', 'Name of cloud adapter to use.') do |bucket_name|
+            command_line_options[:bucket_name] = bucket_name
+          end
+          return command_line_options
+        end
+
+        def read(key)
+          raise "key doesn't exist" unless key_exists?(key)
+          stored_data[bucket_name][key]
+        end
+
+        def delete(key)
+          stored_data[bucket_name].delete(key)
+        end
+
+        def key_exists?(key)
+          stored_data[bucket_name][key] ? true : false
+        end
+
+        #######
+        private
+        #######
+
+        def stored_data
+          @stored_data ||= { bucket_name => {} }
+        end
+
+        def bucket_name
+          raise RuntimeError, Configuration.settings.inspect
+          Configuration.settings[:bucket_name].to_sym
+        end
+
+      end
+    end
+  end
+end

data/lib/cloud_encrypted_sync/master.rb

@@ -0,0 +1,248 @@
+require 'find'
+require 'active_support/core_ext/string'
+
+module CloudEncryptedSync
+  class Master
+
+    class << self
+      attr_accessor :finalize_required
+      attr_reader   :command_line_options, :adapters
+      attr_writer   :sync_path
+
+      def register(adapter)
+        @adapters ||= {}
+        name = adapter.name.match(/([^:]+)$/)[0].underscore.to_sym
+        raise RegistrationError, "#{name} already registered" if @adapters[name]
+        @adapters[name] = adapter
+      end
+
+      def activate!
+        find_and_require_adapters
+        sync
+      end
+
+      def sync
+        begin
+          CloudEncryptedSync::Master.delete_local_files!
+          CloudEncryptedSync::Master.delete_remote_files!
+          CloudEncryptedSync::Master.pull_files!
+          CloudEncryptedSync::Master.push_files!
+          CloudEncryptedSync::Master.finalize!
+        rescue IncompleteConfigurationError => exception
+          puts exception.message
+        end
+      end
+
+      def push_files!
+        progress_meter = ProgressMeter.new(files_to_pull.keys.size,:label => 'Pushing Files: ')
+        pushed_files_counter = 0
+        files_to_push.each_pair do |key,relative_path|
+          if adapter.key_exists?(key)
+            #already exists. probably left over from an earlier aborted push
+            puts "Not Pushing (already exists): #{relative_path}"
+          else
+            puts "Pushing: #{relative_path}"
+            encrypt_to_adapter(File.read(full_file_path(relative_path)),key)
+            self.finalize_required = true
+          end
+          pushed_files_counter += 1
+          print progress_meter.update(pushed_files_counter)
+        end
+      end
+
+      def pull_files!
+        progress_meter = ProgressMeter.new(files_to_pull.keys.size,:label => 'Pulling Files: ')
+        pulled_files_counter = 0
+        files_to_pull.each_pair do |key,relative_path|
+          full_path = full_file_path(relative_path)
+          if File.exist?(full_path) and (file_key(full_path) == key)
+            #already exists. probably left over from an earlier aborted pull
+            puts "Not Pulling (already exists): #{path}"
+          else
+            Dir.mkdir(File.dirname(full_path)) unless File.exist?(File.dirname(full_path))
+            puts "Pulling: #{relative_path}"
+            begin
+              File.open(full_path,'w') { |file| file.write(decrypt_from_adapter(key)) }
+              self.finalize_required = true
+            rescue #AWS::S3::Errors::NoSuchKey  Should provide error for adapters to raise
+              puts "Failed to pull #{relative_path}"
+            end
+          end
+          pulled_files_counter += 1
+          print progress_meter.update(pulled_files_counter)
+        end
+      end
+
+      def delete_remote_files!
+        remote_files_to_delete.each_pair do |key,path|
+          puts "Deleting Remote: #{path}"
+          adapter.delete(key)
+          self.finalize_required = true
+        end
+      end
+
+      def delete_local_files!
+        local_files_to_delete.each_pair do |key,relative_path|
+          full_path = full_file_path(relative_path)
+          if !File.exist?(full_path) or (file_key(full_path) == key)
+            puts "Not Deleting Local: #{relative_path}"
+          else
+            puts "Deleting Local: #{relative_path}"
+            File.delete(full_path)
+            self.finalize_required = true
+          end
+        end
+      end
+
+      def finalize!
+        if finalize_required
+          store_directory_hash_file
+          File.open(snapshot_file_path, 'w') { |file| YAML.dump(directory_hash, file) }
+        end
+      end
+
+      #######
+      private
+      #######
+
+      def find_and_require_adapters
+        latest_versions_of_installed_adapters.each_pair do |adapter_name,adapter_version|
+          require File.expand_path("../../../../cloud_encrypted_sync_#{adapter_name}_adapter-#{adapter_version}", __FILE__)
+        end
+      end
+
+      def latest_versions_of_installed_adapters
+        glob_path = '../../../../cloud_encrypted_sync_*_adapter-*/lib/*.rb'
+        Dir.glob(File.expand_path(glob_path,__FILE__)).inject({}) do |hash,adapter_path|
+          if adapter_path.match(/cloud_encrypted_sync_(.+)_adapter-(.+)/)
+            adapter_name = $1
+            adapter_version = $2
+            if hash[adapter_name].to_s < adapter_version
+              hash[adapter_name] = adapter_version
+            end
+          end
+          hash
+        end
+      end
+
+      def adapter
+        @adapters[Configuration.settings[:adapter_name].to_sym]
+      end
+
+      def encrypt_to_adapter(data,key)
+        adapter.write(Cryptographer.encrypt_data(data),key)
+      end
+
+      def decrypt_from_adapter(key)
+        Cryptographer.decrypt_data(adapter.read(key))
+      end
+
+      def directory_hash
+        return @directory_hash if @directory_hash
+        @directory_hash = {}
+        progress_meter = ProgressMeter.new(Dir["#{normalized_sync_path}/**/*"].length,:label => 'Compiling Directory Analysis: ')
+        completed_files = 0
+        Find.find(normalized_sync_path) do |path|
+          print progress_meter.update(completed_files)
+          if FileTest.directory?(path)
+            completed_files += 1
+            next
+          else
+            @directory_hash[file_key(path)] = relative_file_path(path)
+            completed_files += 1
+          end
+        end
+        puts
+        return @directory_hash
+      end
+
+      def directory_key
+        @directory_key ||= Cryptographer.hash_data(Configuration.settings[:encryption_key])
+      end
+
+      def normalized_sync_path
+        @normalized_sync_path ||= normalize_sync_path
+      end
+
+      def normalize_sync_path
+        path = Configuration.settings[:sync_path]
+        if path.match(/\/$/)
+          return path
+        else
+          return path + '/'
+        end
+      end
+
+      def last_sync_date
+        @last_sync_date ||= File.exist?(snapshot_file_path) ? File.stat(snapshot_file_path).ctime : nil
+      end
+
+      def last_sync_hash
+        @last_sync_hash ||= File.exist?(snapshot_file_path) ? YAML.load(File.read(snapshot_file_path)) : {}
+      end
+
+      def files_to_push
+        syncable_files_check(directory_hash,remote_directory_hash)
+      end
+
+      def files_to_pull
+        syncable_files_check(remote_directory_hash,directory_hash)
+      end
+
+      def remote_files_to_delete
+        deletable_files_check(remote_directory_hash,directory_hash)
+      end
+
+      def local_files_to_delete
+        deletable_files_check(directory_hash,remote_directory_hash)
+      end
+
+      def remote_directory_hash
+        @remote_directory_hash ||= begin
+          YAML.parse(decrypt_from_adapter(directory_key)).to_ruby
+        rescue #AWS::S3::Errors::NoSuchKey  should provide error for adapters to raise
+          {}
+        end
+      end
+
+      def store_directory_hash_file
+        @directory_hash = nil #force re-compile before pushing to remote
+        encrypt_to_adapter(directory_hash.to_yaml,directory_key)
+      end
+
+      def deletable_files_check(source_hash,comparison_hash)
+        combined_file_check(source_hash,comparison_hash,true)
+      end
+
+      def syncable_files_check(source_hash,comparison_hash)
+        combined_file_check(source_hash,comparison_hash,false)
+      end
+
+      def combined_file_check(source_hash,comparison_hash,last_sync_has_key)
+        source_hash.select{|k,v| !comparison_hash.has_key?(k) and (last_sync_has_key ? last_sync_hash.has_key?(k) : !last_sync_hash.has_key?(k)) }
+      end
+
+      def snapshot_file_path
+        "#{Configuration.data_folder_path}/#{snapshot_filename}"
+      end
+
+      def snapshot_filename
+        "#{normalized_sync_path.gsub(/[^A-Za-z0-9]/,'_')}.snapshot.yml"
+      end
+
+      def file_key(full_path)
+        Cryptographer.hash_data(relative_file_path(full_path) + File.open(full_path).read).to_s
+      end
+
+      def relative_file_path(full_path)
+        full_path.gsub(normalized_sync_path,'')
+      end
+
+      def full_file_path(relative_path)
+        normalized_sync_path+'/'+relative_path
+      end
+    end
+  end
+
+  class RegistrationError < RuntimeError; end
+end

data/lib/cloud_encrypted_sync/progress_meter.rb

@@ -0,0 +1,43 @@
+module CloudEncryptedSync
+  class ProgressMeter
+    attr_accessor :completed_index
+    attr_reader   :max_index, :start_time, :label
+
+    def initialize(max_index,options = {})
+      @max_index = max_index.to_f
+      @label = options[:label] || ''
+      @completed_index = 0.0
+      @start_time = Time.now
+    end
+
+    def to_s
+      sprintf("\r#{label}%0.1f%% Complete. Time Remaining %s", percent_completed, estimated_time_remaining.strftime('%M:%S'))
+    end
+
+    def percent_completed
+      (completed_index/max_index)*100
+    end
+
+    def time_elapsed
+      Time.now - start_time
+    end
+
+    def estimated_finish_time
+      if percent_completed > 0
+        start_time + ((100/percent_completed)*time_elapsed)
+      else
+        start_time + 3600
+      end
+    end
+
+    def estimated_time_remaining
+      Time.at(estimated_finish_time - Time.now)
+    end
+
+    def update(completed_index)
+      self.completed_index = completed_index
+      return self
+    end
+
+  end
+end

data/lib/cloud_encrypted_sync/version.rb

@@ -0,0 +1,3 @@
+module CloudEncryptedSync
+  VERSION = '0.1.0'
+end

data/test/test_helper.rb

@@ -0,0 +1,63 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'simplecov'
+require 'fakefs/safe'
+require 'active_support/test_case'
+require 'test/unit'
+require 'etc'
+
+SimpleCov.start
+
+require 'cloud_encrypted_sync'
+
+module CloudEncryptedSync
+  class ActiveSupport::TestCase
+
+    setup :activate_fake_fs
+    setup :preset_environment
+    setup :capture_stdout
+    teardown :deactivate_fake_fs
+    teardown :release_stdout
+
+    def preset_environment
+      Configuration.instance_variable_set(:@settings,nil)
+      Configuration.instance_variable_set(:@command_line_options,nil)
+      Master.instance_variable_set(:@directory_hash, nil)
+      FileUtils.mkdir_p test_source_folder
+      FileUtils.mkdir_p test_source_folder + '/test_sub_folder'
+      File.open(test_source_folder + '/test_sub_folder/test_file_one.txt', 'w') do |test_file|
+        test_file.write('Test File One')
+      end
+    end
+
+    def test_source_folder
+      @test_source_folder ||= File.expand_path('../test_folder',  __FILE__)
+    end
+
+    def activate_fake_fs
+      FakeFS.activate!
+      FakeFS::FileSystem.clear
+    end
+
+    def deactivate_fake_fs
+      FakeFS.deactivate!
+    end
+
+    #Capture STDOUT from program for testing and not cluttering test output
+    def capture_stdout
+      @stdout = $stdout
+      $stdout = StringIO.new
+    end
+
+    def release_stdout
+      $stdout = @stdout
+    end
+
+    #Redirect intentional puts from within tests to the real STDOUT for troublshooting purposes.
+    def puts(*args)
+      @stdout.puts(*args)
+    end
+
+  end
+end
+require 'mocha'

data/test/unit/configuration_test.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+
+module CloudEncryptedSync
+  class ConfigurationTest < ActiveSupport::TestCase
+
+    def setup
+      Configuration.instance_variable_set(:@command_line_options,nil)
+      Configuration.instance_variable_set(:@settings,nil)
+      Configuration.instance_variable_set(:@option_parser,nil)
+      Object.send(:remove_const,:ARGV) #if defined?(::ARGV)
+    end
+
+    test 'should parse command line options' do
+      ::ARGV = '--adapter dummy --bucket foobar --data-dir ~/test/folder --encryption-key somestringofcharacters /some/path'.split(/\s/)
+      settings = Configuration.settings
+      assert_equal('dummy',settings[:adapter_name])
+      assert_equal('~/test/folder',settings[:data_dir])
+      assert_equal('somestringofcharacters',settings[:encryption_key])
+      assert_equal('foobar',settings[:bucket_name])
+    end
+
+    test 'should gracefully fail without path in ARGV' do
+      ::ARGV = '--adapter dummy --bucket foobar'.split(/\s/)
+      assert_raise(IncompleteConfigurationError) { Configuration.settings }
+    end
+
+    test 'should gracefully fail when not provided encryption_key and vector provided path in ARGV' do
+      ::ARGV = '--adapter dummy --bucket foobar /some/path/to/sync'.split(/\s/)
+      assert_raise(IncompleteConfigurationError) { Configuration.settings }
+    end
+
+  end
+end

data/test/unit/cryptographer_test.rb

@@ -0,0 +1,34 @@
+require 'test_helper'
+
+module CloudEncryptedSync
+  class CryptographerTest < ActiveSupport::TestCase
+
+    def setup
+      Configuration.stubs(:settings).returns({
+        :encryption_key => 'asdf',
+        :initialization_vector => 'qwerty',
+        :adapter_name => 'dummy',
+        :bucket => "test-bucket",
+        :data_dir => "#{Etc.getpwuid.dir}/.cloud_encrypted_sync",
+        :sync_path => test_source_folder
+      })
+    end
+
+    test 'should hash data' do
+      hash = Cryptographer.hash_data('abc123')
+      assert_equal('c70b5dd9ebfb6f51d09d4132b7170c9d20750a7852f00680f65658f0310e810056e6763c34c9a00b0e940076f54495c169fc2302cceb312039271c43469507dc',hash)
+    end
+
+    test 'should encrypt and decrypt data' do
+      unencrypted_data = "123xyz"
+      encrypted_data = Cryptographer.encrypt_data(unencrypted_data)
+      decrypted_data = Cryptographer.decrypt_data(encrypted_data)
+      assert_equal(unencrypted_data,decrypted_data)
+    end
+
+    test 'test should generate random key' do
+      assert_equal(String,Cryptographer.generate_random_key.class)
+    end
+
+  end
+end

data/test/unit/master_test.rb

@@ -0,0 +1,155 @@
+require 'test_helper'
+require 'yaml'
+
+module CloudEncryptedSync
+  class MasterTest < ActiveSupport::TestCase
+
+    def setup
+      Configuration.stubs(:settings).returns({
+        :encryption_key => 'asdf',
+        :initialization_vector => 'qwerty',
+        :adapter_name => 'dummy',
+        :bucket => "test-bucket",
+        :sync_path => test_source_folder
+      })
+      Configuration.stubs(:data_folder_path).returns("#{Etc.getpwuid.dir}/.cloud_encrypted_sync")
+    end
+
+    test 'should generate directory hash' do
+      assert_equal('',$stdout.string)
+      hash = Master.send(:directory_hash)
+      assert_match(/\% Complete/,$stdout.string)
+      assert_equal(1,hash.keys.size)
+      assert_equal('test_sub_folder/test_file_one.txt',hash[hash.keys.first])
+    end
+
+    test 'should_return_nil_if_never_synced_before' do
+      Master.stubs(:snapshot_file_path).returns('/non/existant/file')
+      assert_equal(nil,Master.send(:last_sync_date))
+    end
+
+    test 'should want to push everything on first run with local files and empty remote' do
+      Master.stubs(:remote_directory_hash).returns({})
+      Master.stubs(:directory_hash).returns({"old_file_key"=>"test_sub_folder/old_file.txt"})
+      Master.stubs(:last_sync_hash).returns({})
+      assert_equal(Master.directory_hash,Master.send(:files_to_push))
+    end
+
+    test 'should encrypt when writing' do
+      precrypted_data = File.read(test_source_folder + '/test_sub_folder/test_file_one.txt')
+      key = Cryptographer.hash_data('test_file_key')
+      Adapters::Dummy.expects(:write).with(anything,key).returns(true)
+      Master.send(:encrypt_to_adapter,precrypted_data,key)
+    end
+
+    test 'should decrypt_when_reading' do
+      precrypted_data = File.read(test_source_folder + '/test_sub_folder/test_file_one.txt')
+      encrypted_data = Cryptographer.encrypt_data(precrypted_data)
+      key = Cryptographer.hash_data('test_file_key')
+      Adapters::Dummy.expects(:read).with(key).returns(encrypted_data)
+      assert_equal(precrypted_data,Master.send(:decrypt_from_adapter,key))
+    end
+
+    test 'should push files' do
+      Master.stubs(:remote_directory_hash).returns({})
+      Master.stubs(:last_sync_hash).returns({})
+      Adapters::Dummy.stubs(:key_exists?).returns(false)
+      Adapters::Dummy.expects(:write).with(any_parameters).returns(true)
+      assert_equal('',$stdout.string)
+      Master.push_files!
+      assert_match(/\% Complete/,$stdout.string)
+    end
+
+    test 'should want to pull everything on first run with remote files and empty local' do
+      Master.stubs(:remote_directory_hash).returns({'new_file_key' => 'test_sub_folder/new_file.txt'})
+      Master.stubs(:directory_hash).returns({})
+      Master.stubs(:last_sync_hash).returns({})
+      assert_equal({'new_file_key' => 'test_sub_folder/new_file.txt'},Master.send(:files_to_pull))
+    end
+
+    test 'should pull files' do
+      Master.stubs(:remote_directory_hash).returns({'new_file_key' => 'test_sub_folder/new_file.txt'})
+      Master.stubs(:directory_hash).returns({})
+      Master.stubs(:last_sync_hash).returns({})
+      Adapters::Dummy.expects(:read).with('new_file_key').returns(Cryptographer.encrypt_data('foobar'))
+      assert_equal('',$stdout.string)
+      assert_difference('Dir["#{test_source_folder}/**/*"].length') do
+        Master.pull_files!
+      end
+      assert_match(/\% Complete/,$stdout.string)
+    end
+
+    test 'should only want to push new files on later run' do
+      Master.stubs(:remote_directory_hash).returns({'old_file_key' => 'test_sub_folder/old_file.txt'})
+      Master.stubs(:directory_hash).returns({'new_file_key' => 'test_sub_folder/new_file.txt', 'old_file_key' => 'test_sub_folder/old_file.txt'})
+      Master.stubs(:last_sync_hash).returns({'old_file_key' => 'test_sub_folder/old_file.txt'})
+      assert_equal({'new_file_key' => 'test_sub_folder/new_file.txt'},Master.send(:files_to_push))
+    end
+
+    test 'should want to pull new files from cloud' do
+      Master.stubs(:remote_directory_hash).returns({'new_file_key' => 'test_sub_folder/new_file.txt', 'old_file_key' => 'test_sub_folder/old_file.txt'})
+      Master.stubs(:directory_hash).returns({'old_file_key' => 'test_sub_folder/old_file.txt'})
+      Master.stubs(:last_sync_hash).returns({'old_file_key' => 'test_sub_folder/old_file.txt'})
+      assert_equal({'new_file_key' => 'test_sub_folder/new_file.txt'},Master.send(:files_to_pull))
+    end
+
+    test 'should want to delete locally missing files from cloud' do
+      Master.stubs(:remote_directory_hash).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt', 'deleted_file_key' => 'test_sub_folder/deleted_file.txt'})
+      Master.stubs(:directory_hash).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt'})
+      Master.stubs(:last_sync_hash).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt', 'deleted_file_key' => 'test_sub_folder/deleted_file.txt'})
+      assert_equal({'deleted_file_key' => 'test_sub_folder/deleted_file.txt'},Master.send(:remote_files_to_delete))
+    end
+
+    test 'should delete files from cloud' do
+      Master.stubs(:remote_directory_hash).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt', 'deleted_file_key' => 'test_sub_folder/deleted_file.txt'})
+      Master.stubs(:directory_hash).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt'})
+      Master.stubs(:last_sync_hash).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt', 'deleted_file_key' => 'test_sub_folder/deleted_file.txt'})
+      Adapters::Dummy.expects(:delete).with('deleted_file_key').returns(true)
+      Master.delete_remote_files!
+    end
+
+    test 'should want to delete appropriate files locally' do
+      Master.stubs(:remote_directory_hash).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt'})
+      Master.stubs(:directory_hash).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt', 'deleted_file_key' => 'test_sub_folder/deleted_file.txt'})
+      Master.stubs(:last_sync_hash).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt', 'deleted_file_key' => 'test_sub_folder/deleted_file.txt'})
+      assert_equal({'deleted_file_key' => 'test_sub_folder/deleted_file.txt'},Master.send(:local_files_to_delete))
+    end
+
+    test 'should delete local files' do
+      Master.stubs(:remote_directory_hash).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt'})
+      Master.stubs(:last_sync_hash).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt', 'deleted_file_key' => 'test_sub_folder/deleted_file.txt'}.merge(Master.send(:directory_hash)))
+      assert_difference('Dir["#{test_source_folder}/**/*"].length',-1) do
+        Master.delete_local_files!
+      end
+    end
+
+    test 'should finalize' do
+      FileUtils.mkdir_p(Configuration.data_folder_path)
+      sample_directory_hash = {'sample_file_key' => 'test_sub_folder/sample_file.txt'}
+      Master.instance_variable_set(:@finalize_required,true)
+      Master.stubs(:directory_hash).returns(sample_directory_hash)
+      Adapters::Dummy.expects(:write).with(anything,Master.send(:directory_key)).returns(true)
+      Master.finalize!
+    end
+
+    test 'should decrypt remote directory file' do
+      #setup mock data
+      sample_directory_hash = {'sample_file_key' => 'test_sub_folder/sample_file.txt'}
+      encrypted_directory_hash = Cryptographer.encrypt_data(sample_directory_hash.to_yaml)
+      Adapters::Dummy.stubs(:read).with(Master.send(:directory_key)).returns(encrypted_directory_hash)
+
+      #do actual test
+      decrypted_remote_hash = Master.send(:remote_directory_hash)
+      assert_equal(sample_directory_hash,decrypted_remote_hash)
+    end
+
+    test 'should puts error message to stdout' do
+      Configuration.stubs(:settings).raises(IncompleteConfigurationError,'test message')
+      assert_equal('',$stdout.string)
+      Master.expects(:pull_files).never
+      Master.sync
+      assert_match(/test message/,$stdout.string)
+    end
+
+  end
+end

data/test/unit/progress_meter_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+
+module CloudEncryptedSync
+  class ProgressMeterTest < ActiveSupport::TestCase
+
+    def setup
+      @progress_meter = ProgressMeter.new(4)
+      @progress_meter.instance_variable_set(:@start_time,Time.now-42)
+    end
+
+    test 'should calculate percent completed' do
+      @progress_meter.update(1)
+      assert_equal(25,@progress_meter.percent_completed)
+    end
+
+    test 'should calculate time elapsed' do
+      assert_in_delta(42,@progress_meter.time_elapsed,0.01)
+    end
+
+    test 'should estimate finish time' do
+      @progress_meter.update(1)
+      assert_in_delta(Time.now+(42*3),@progress_meter.estimated_finish_time,0.01)
+    end
+
+    test 'should estimate time remaining' do
+      @progress_meter.update(1)
+      assert_in_delta((42*3),@progress_meter.estimated_time_remaining.to_f,0.01)
+    end
+
+    test 'should update progress and return self' do
+      assert_difference('@progress_meter.completed_index',2) do
+        assert_equal(@progress_meter,@progress_meter.update(2))
+      end
+    end
+
+    test 'should render string' do
+      assert_match(/0\% Complete/,@progress_meter.to_s)
+    end
+  end
+end

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: cloud_encrypted_sync
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Jonathan S. Garvin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fakefs
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Encrypted sync of folder contents to/from cloud storage with user controlled
+  encryption keys.
+email:
+- jon@5valleys.com
+executables:
+- ces
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- bin/ces
+- cloud_encrypted_sync.gemspec
+- lib/cloud_encrypted_sync.rb
+- lib/cloud_encrypted_sync/adapter_template.rb
+- lib/cloud_encrypted_sync/configuration.rb
+- lib/cloud_encrypted_sync/cryptographer.rb
+- lib/cloud_encrypted_sync/dummy_adapter.rb
+- lib/cloud_encrypted_sync/master.rb
+- lib/cloud_encrypted_sync/progress_meter.rb
+- lib/cloud_encrypted_sync/version.rb
+- test/test_helper.rb
+- test/unit/configuration_test.rb
+- test/unit/cryptographer_test.rb
+- test/unit/master_test.rb
+- test/unit/progress_meter_test.rb
+homepage: https://github.com/jsgarvin/cloud_encrypted_sync
+licenses: []
+post_install_message: 
+rdoc_options: []
+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: Encrypted sync of folder contents to/from cloud storage.
+test_files:
+- test/test_helper.rb
+- test/unit/configuration_test.rb
+- test/unit/cryptographer_test.rb
+- test/unit/master_test.rb
+- test/unit/progress_meter_test.rb