revenc 0.1.2

data/lib/revenc/app.rb

@@ -0,0 +1,128 @@
+require 'configatron'
+require 'term/ansicolor'
+
+class String
+  include Term::ANSIColor
+end
+
+module Revenc
+
+  AVAILABLE_ACTIONS = %w[mount unmount copy]
+
+  class App
+
+    def initialize(base_dir, options={})
+      @base_dir = base_dir
+      @options = options
+      if @options[:verbose]
+        puts "base_dir: #{@base_dir}".cyan
+        puts "options: #{@options.inspect}".cyan
+      end
+      configure(options)
+    end
+
+    def run
+      begin
+
+        if action_argument_required?
+          action = ARGV.shift
+          unless AVAILABLE_ACTIONS.include?(action)
+            if action.nil?
+              puts "revenc action required"
+            else
+              puts "revenc invalid action: #{action}"
+            end
+            puts "revenc --help for more information"
+            exit 1
+          end
+          puts "revenc run action: #{action}".cyan if @options[:verbose]
+          raise "action #{action} not implemented" unless respond_to?(action)
+          result = send(action)
+        else
+          #
+          # default action if action_argument_required? is false
+          #
+          result = 0
+        end
+
+        exit(result ? 0 : 1)
+
+      rescue SystemExit => e
+        # This is the normal exit point, exit code from the send result
+        # or exit from another point in the system
+        puts "revenc run system exit: #{e}, status code: #{e.status}".green if @options[:verbose]
+        exit(e.status)
+      rescue Exception => e
+        STDERR.puts("revenc command failed, error(s) follow:")
+        STDERR.puts("#{e.message}".red)
+        STDERR.puts(e.backtrace.join("\n")) if @options[:verbose]
+        exit(1)
+      end
+    end
+
+    #
+    # app commands start
+    #
+    # TODO: Add status command, use encfsctl
+
+    def mount
+      EncfsWrapper.new(@base_dir, @options).mount(ARGV.shift, ARGV.shift)
+    end
+
+    def unmount
+      EncfsWrapper.new(@base_dir, @options).unmount(ARGV.shift)
+    end
+
+    def copy
+      EncfsWrapper.new(@base_dir, @options).copy(ARGV.shift, ARGV.shift)
+    end
+    
+    #
+    # app commands end
+    #
+
+  private
+
+    # true if application requires an action to be specified on the command line
+    def action_argument_required?
+      !AVAILABLE_ACTIONS.empty?
+    end
+
+    # read options for YAML config with ERB processing and initialize configatron
+    def configure(options)
+      # TODO: read ~/.revenc.conf before looking in the current folder for revenc.conf, read BOTH files
+      config = @options[:config]
+      config = File.join(@base_dir, 'revenc.conf') unless config
+      if File.exists?(config)
+        # load configatron options from the config file
+        puts "loading config file: #{config}".cyan if @options[:verbose]
+        configatron.configure_from_yaml(config)
+      else
+        # user specified a config file?
+        raise "config file not found" if @options[:config]
+        # no error if user did not specify config file
+        puts "#{config} not found".yellow if @options[:verbose]
+      end
+      
+      # 
+      # set defaults, these will NOT override setting read from YAML
+      #
+      configatron.mount.source.set_default(:name, nil)
+      configatron.mount.mountpoint.set_default(:name, nil)
+      configatron.mount.passphrasefile.set_default(:name, 'passphrase')
+      configatron.mount.keyfile.set_default(:name, 'encfs6.xml')
+      configatron.mount.set_default(:cmd, nil)
+      configatron.mount.set_default(:executable, nil)
+
+      configatron.unmount.mountpoint.set_default(:name, nil)
+      configatron.unmount.set_default(:cmd, nil)
+      configatron.unmount.set_default(:executable, nil)
+
+      configatron.copy.source.set_default(:name, nil)
+      configatron.copy.destination.set_default(:name, nil)
+      configatron.copy.set_default(:cmd, nil)
+      configatron.copy.set_default(:executable, nil)
+    end
+
+  end
+end

data/lib/revenc/encfs_wrapper.rb

@@ -0,0 +1,96 @@
+module Revenc
+
+  class EncfsWrapper
+
+    def initialize(base_dir, options)
+      raise ArgumentError, "Options should be a hash" unless options.is_a?(Hash)
+      @base_dir = base_dir
+      @options = options
+    end
+
+    def mount(source=nil, mount_point_folder=nil)
+
+      # add params from config file if not specified
+      source = configatron.mount.source.name unless source
+      mount_point_folder = configatron.mount.mountpoint.name unless mount_point_folder
+
+      # sanity check params
+      raise "source folder not specified" unless source
+      raise "mountpoint not specified" unless mount_point_folder
+
+      mount_point_options = @options.merge(:passphrasefile => configatron.mount.passphrasefile.name)
+      mount_point_options = mount_point_options.merge(:keyfile => configatron.mount.keyfile.name)
+      mount_point_options = mount_point_options.merge(:cmd => configatron.mount.cmd) if configatron.mount.cmd
+      mount_point_options = mount_point_options.merge(:executable => configatron.mount.executable) if configatron.mount.executable
+
+      mount_point = MountPoint.new(mount_point_folder, source, mount_point_options)
+
+      if @options[:verbose]
+        puts "mount: source=#{mount_point.source.name}".cyan
+        puts "mount: mountpoint=#{mount_point.name}".cyan
+        puts "mount: passphrasefile=#{mount_point.passphrasefile.name}".cyan
+        puts "mount: keyfile=#{mount_point.keyfile.name}".cyan
+        puts "mount: cmd=#{mount_point.cmd}".cyan
+        puts "mount: executable=#{mount_point.executable}".cyan
+      end
+
+      mount_point.execute
+    end
+
+    def unmount(foldername = nil)
+      
+      # add param from config file if not specified, try specific unmount
+      foldername = configatron.unmount.mountpoint.name unless foldername
+      # fallback to mount.mountpoint if specified
+      foldername = configatron.mount.mountpoint.name unless foldername
+      
+      # sanity check params
+      raise "mountpoint not specified" unless foldername
+
+      unmount_point_options = @options || {}
+      unmount_point_options = unmount_point_options.merge(:cmd => configatron.unmount.cmd) if configatron.umount.cmd
+      unmount_point_options = unmount_point_options.merge(:executable => configatron.unmount.executable) if configatron.umount.executable
+      unmount_point = UnmountPoint.new(foldername, unmount_point_options)
+
+      if @options[:verbose]
+        puts "unmount: mountpoint=#{unmount_point.mountpoint.name}".cyan
+        puts "unmount: cmd=#{unmount_point.cmd}".cyan
+        puts "unmount: executable=#{unmount_point.executable}".cyan
+      end
+
+      unmount_point.execute
+    end
+
+    def copy(source=nil, destination=nil)
+
+      # add params from config file if not specified
+      source = configatron.copy.source.name unless source
+      # fallback
+      source = configatron.mount.mountpoint.name unless source
+      destination = configatron.copy.destination.name unless destination
+
+      # sanity check params
+      raise "source folder not specified" unless source
+      raise "destination not specified" unless destination
+
+      copy_options = @options || {}
+      copy_options = copy_options.merge(:cmd => configatron.copy.cmd) if configatron.copy.cmd
+      copy_options = copy_options.merge(:executable => configatron.copy.executable) if configatron.copy.executable
+      copy_options = copy_options.merge(:mountpoint => configatron.mount.mountpoint.name) if configatron.mount.mountpoint.name
+
+      copy_folder = CopySourceFolder.new( source, destination, copy_options)
+
+      if @options[:verbose]
+        puts "copy: source=#{copy_folder.name}".cyan
+        puts "copy: destination=#{copy_folder.destination.name}".cyan
+        puts "copy: cmd=#{copy_folder.cmd}".cyan
+        puts "copy: executable=#{copy_folder.executable}".cyan
+      end
+
+      copy_folder.execute
+    end
+
+  end
+
+end
+

data/lib/revenc/errors.rb

@@ -0,0 +1,78 @@
+module Revenc
+
+  class Errors
+    include Enumerable
+
+     def initialize
+       @errors ={}
+     end
+
+     # add errors, error_on can be a symbol or object instance
+     def add(error_on, message = "Unknown error")
+
+       # humanize error_on
+       if error_on.is_a?(Symbol)
+         error_on_str = error_on.to_s
+       else
+         error_on_str = underscore(error_on.class.name)
+       end
+       error_on_str = error_on_str.gsub(/\//, '_')
+       error_on_str = error_on_str.gsub(/_/, ' ')
+       error_on_str = error_on_str.gsub(/^revenc/, '').strip
+       #error_on_str = error_on_str.capitalize
+       
+       @errors[error_on_str] ||= []
+       @errors[error_on_str] << message.to_s
+    end
+
+    def empty?
+      @errors.empty?
+    end
+ 
+    def clear
+      @errors = {}
+    end
+
+    def each
+      @errors.each_key { |attr| @errors[attr].each { |msg| yield attr, msg } }
+    end
+
+    def size
+      @errors.values.inject(0) { |error_count, attribute| error_count + attribute.size }
+    end
+ 
+    alias_method :count, :size
+    alias_method :length, :size
+
+    def messages
+      messages = []
+
+      @errors.each_key do |attr|
+      @errors[attr].each do |message|
+        next unless message
+        attr_name = attr.to_s
+        messages << attr_name + ' ' + message
+        end
+      end
+
+      messages
+    end
+
+    def to_sentences
+      messages.join("\n")
+    end
+
+    private
+
+    # from ActiveSupport
+    def underscore(camel_cased_word)
+      camel_cased_word.to_s.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+    end
+
+  end
+
+end

data/lib/revenc/io.rb

@@ -0,0 +1,265 @@
+module Revenc
+
+  class BasicAction
+
+    def initialize(name=nil, options={})
+      raise ArgumentError, "Options should be a hash" unless options.is_a?(Hash)
+      @name = name
+      @options = options
+    end
+
+    def name
+      @name
+    end
+
+    def name=(value)
+      @name = value
+    end
+
+    def options
+      @options ||= {}
+    end
+
+    def options=(value)
+      @options = value
+    end
+
+    def errors
+      @errors ||= Errors.new
+    end
+
+    def exists?
+      false
+    end
+
+    def validate
+    end
+
+    def valid?
+      errors.clear
+      validate
+      errors.empty?
+    end
+
+    def cmd
+      return nil unless @cmd
+      # process ERB
+      render(@cmd)
+    end
+
+    def cmd=(value)
+      @cmd = value
+    end
+
+  private
+
+    def system_cmd(cmd=nil)
+      raise "ERROR: cmd not given" unless cmd
+      return true if options[:dry_run]
+      system cmd
+    end
+
+    # Runs the YAML file through ERB
+    def render(value, b = binding)
+      ERB.new(value).result(b)
+    end
+
+  end
+
+  class FileSystemEntity < BasicAction
+
+    # return fully qualified name
+    def name
+      return @name unless (@name && File.exists?(@name))
+      File.expand_path(@name)
+    end
+
+    def exists?
+      File.exists?(name) if name
+    end
+
+  end
+
+  class TextFile < FileSystemEntity
+
+
+    def empty?
+      return true unless exists?
+
+      contents = nil
+      File.open(@name, "r") do |f|
+        contents = f.read
+      end 
+      contents.empty?
+    end
+
+    def validate
+      errors.add(self, "filename not specified") if @name.nil?
+      errors.add(self, "not found") unless exists?
+    end
+  end
+
+  class PassphraseFile < TextFile
+
+    def initialize(name='passphrase', options={})
+      super name, options
+    end
+
+    def validate
+      super 
+      errors.add(self, "is empty") if empty?
+    end
+  end
+
+  class KeyFile < TextFile
+
+    def initialize(name='encfs6.xml', options={})
+      super name, options
+    end
+
+    def validate
+      super 
+      errors.add(self, "is empty") if exists? && empty?
+    end
+  end
+
+  class FileFolder < FileSystemEntity
+
+    def exists?
+      !@name.nil? && File.directory?(@name)
+    end
+
+    def empty?
+      return true unless exists?
+      Dir.entries(@name).sort == [".", ".."].sort
+    end
+
+    def validate
+      errors.add(self, "not found") unless exists?
+    end
+  end
+
+  class SourceFolder < FileFolder
+
+    def validate
+      super
+      errors.add(self, "is empty") if exists? && empty?
+    end
+  end
+
+  class ActionFolder < FileFolder
+    attr_accessor :passphrasefile
+    attr_accessor :keyfile
+
+    def initialize(name=nil, options={})
+      super
+      @passphrasefile = PassphraseFile.new(options[:passphrasefile])
+      @keyfile = KeyFile.new(options[:keyfile])
+      @cmd = options[:cmd]
+      @executable = options[:executable]
+    end
+
+    def validate
+      super
+      errors.add(self, "executable filename not specified") unless @executable
+      errors.add(self, "#{@executable} executable not found") if executable.empty?
+      errors.add(self, "cmd not specified") unless cmd
+    end
+
+    def executable
+      return nil unless @executable
+      result = `which #{@executable}`
+      result.strip
+    end
+
+    # run the action if valid and return true if successful
+    def execute
+      raise errors.to_sentences unless valid?
+      
+      # default failing command
+      result = false
+      
+      # protect command from recursion
+      mutex = Revenc::Mutex.new
+      lock_sucessful = mutex.execute do
+        result = system_cmd(cmd)
+      end
+      
+      raise "action failed, lock file present" unless lock_sucessful
+      result
+    end
+  end
+
+  class MountPoint < ActionFolder
+    attr_accessor :source
+
+    def initialize(name=nil, source_folder_name=nil, options={})
+      super name, options
+      @source = SourceFolder.new(source_folder_name)
+      @cmd = options[:cmd] || "cat <%= passphrasefile.name %> | ENCFS6_CONFIG=<%= keyfile.name %> \
+                              <%= executable %> --stdinpass --reverse <%= source.name %> <%= mountpoint.name %> -- -o ro"
+      @executable = options[:executable] || 'encfs'
+    end
+
+    # allow clarity in config files, instead of <%= name %> you can use <%= mountpoint.name %>
+    def mountpoint
+      self
+    end
+
+    def validate
+      super
+      errors.add(self, "is not empty") unless empty?
+      errors.add(self, source.errors.to_sentences) unless source.valid?
+      errors.add(self, keyfile.errors.to_sentences) unless keyfile.valid?
+      errors.add(self, passphrasefile.errors.to_sentences) unless passphrasefile.valid?
+    end
+
+  end
+
+  class UnmountPoint < ActionFolder
+
+    def initialize(name=nil, options={})
+      super
+      @cmd = options[:cmd] || "<%= executable %> -u <%= mountpoint.name %>"
+      @executable = options[:executable] || 'fusermount'
+    end
+    
+    # allow clarity in config files, instead of <%= name %> you can use <%= mountpoint.name %>
+    def mountpoint
+      self
+    end
+
+  end
+
+  class DestinationPoint < BasicAction
+  end
+
+  class CopySourceFolder < ActionFolder
+    attr_accessor :destination
+    attr_accessor :mountpoint
+
+    def initialize(name=nil, destination_name=nil, options={})
+      super name, options
+      @destination = DestinationPoint.new(destination_name)
+      @mountpoint = MountPoint.new(options[:mountpoint])
+      @cmd = options[:cmd] || "<%= executable %> -r <%= source.name %> <%= destination.name %>"
+      @executable = options[:executable] || 'cp'
+    end
+    
+    # allow clarity in config files, instead of <%= name %> you can use <%= source.name %>
+    def source
+      self
+    end
+
+    def validate
+      super
+      errors.add(self, "is empty") if exists? && empty?
+      errors.add(self, "mountpoint not found") if (mountpoint.name && !mountpoint.exists?)
+      errors.add(self, "mountpoint is empty") if (mountpoint.name && mountpoint.exists? && mountpoint.empty?)
+      errors.add(self, destination.errors.to_sentences) unless destination.valid?
+    end
+
+  end
+
+end
+

data/lib/revenc/lockfile.rb

@@ -0,0 +1,66 @@
+module Revenc
+
+  class Lockfile
+    attr_accessor :lockfile
+
+    def initialize(lockfile=nil)
+      raise ArgumentError, "lockfile not specified" unless lockfile
+      @lockfile = lockfile
+    end
+
+    def locked?
+      return false unless File.exists?(lockfile)
+      result = false
+      open(lockfile, 'w') do |f|
+        # exclusive non-blocking lock
+        result = !lock(f, File::LOCK_EX | File::LOCK_NB)
+      end
+      result
+    end
+
+    # flock, get a file lock
+    #
+    # Typical usage:
+    #
+    #     open('output', 'w') do |f|
+    #       flock(f, File::LOCK_EX) do |f|
+    #       f << "write to file"
+    #       end
+    #     end
+    def lock(file, mode)
+      result = file.flock(mode)
+      if result
+        begin
+          yield file if block_given?
+        ensure
+          file.flock(File::LOCK_UN)
+        end
+      end
+      return result
+    end
+  end
+
+  class Mutex < Lockfile
+
+    def initialize(lockfile='revenc.lck')
+      super lockfile
+    end
+
+    def execute
+      result = false
+      begin
+        open(@lockfile, 'w') do |f|
+          # exclusive non-blocking lock
+          result = lock(f, File::LOCK_EX | File::LOCK_NB) do |f|
+            yield if block_given?
+          end
+        end
+      ensure
+        # clean up but only if we have a positive result meaning we wrote the lockfile
+        FileUtils.rm(@lockfile) if (result && File.exists?(@lockfile))
+      end
+      result
+    end
+  end
+
+end

data/lib/revenc.rb

@@ -0,0 +1,22 @@
+$:.unshift File.dirname(__FILE__) # For use/testing when no gem is installed
+
+require 'rubygems'
+
+module Revenc
+
+  # return the contents of the VERSION file
+  # VERSION format: 0.0.0
+  def self.version
+    version_info_file = File.join(File.dirname(__FILE__), *%w[.. VERSION])
+    File.open(version_info_file, "r") do |f|
+      f.read
+    end 
+  end
+  
+end
+
+require 'revenc/app'
+require 'revenc/io'
+require 'revenc/errors'
+require 'revenc/lockfile'
+require 'revenc/encfs_wrapper'

data/spec/revenc/error_spec.rb

@@ -0,0 +1,50 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Revenc::Errors do
+  
+  before(:each) do
+    @error_obj = Revenc::Errors.new
+  end
+  
+  it "should be empty when created" do
+    @error_obj.should be_empty
+  end
+
+  it "should return a count of the errors" do
+    @error_obj.should be_empty
+    @error_obj.add(:test_error1)
+    @error_obj.add(:test_error2)
+    @error_obj.should_not be_empty
+    @error_obj.size.should == 2
+  end
+
+  it "should clear the errors" do
+    @error_obj.should be_empty
+    @error_obj.add(:test_error1)
+    @error_obj.add(:test_error2)
+    @error_obj.should_not be_empty
+    @error_obj.size.should be(2)
+    @error_obj.clear
+    @error_obj.should be_empty
+    @error_obj.size.should be(0)
+  end
+
+  it "should return the errors in full sentences for errors on symbol" do
+    @error_obj.should be_empty
+    @error_obj.add(:test_error1, "Error no 1")
+    @error_obj.add(:test_error2, "Error no 2")
+    @error_obj.size.should be(2)
+    @error_obj.to_sentences.should == "test error1 Error no 1\ntest error2 Error no 2"
+  end
+
+  it "should return the errors in full sentences for errors on class names" do
+    @error_obj.should be_empty
+    @error_obj.add(@error_obj, "error no 1")
+    @error_obj.add(@error_obj, "error no 2")
+    @error_obj.size.should be(2)
+    @error_obj.to_sentences.should == "errors error no 1\nerrors error no 2"
+  end
+
+end
+
+