bitferry 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 07536a8e52281f9dbe3a085aa9bedff6164f116babcb163149e8a13e2214f771
-  data.tar.gz: a81dbb898d67e9c9e2083871c69bfd6396e56caa12904b085cf8e7c5e85248d5
+  metadata.gz: '08ca0d191eb9905a93c35437fba08ccd3ef79ec0f04d1b64b9ac8e48582fd83a'
+  data.tar.gz: f7fdb4592f72f72a532dfbf48f362b7fa8d3b4141a11cd8483d2e98c56a9f1bd
 SHA512:
-  metadata.gz: c8025822e4520ec87254036acd3b7c6f3933949b3a0737cc9d12d91d5ae4d5fa5d98487a9f2d60a18c15cfb9d4009212b35ead99ce415ececdc42b48c03bcd7f
-  data.tar.gz: 1af8e4d44dd64818f78eadb27b62233e33bd4f7f1cc493dfafbcb7ca4defd77e5ea868ad5060ee28e6eefc3f4c122842e7774b4627506305ee553e12157ea3c0
+  metadata.gz: 3fb6e3700029f5ca720228aa3dd6d61b21949322b4ee3d497597b586715962f9e46ebda45d2eec07d1782dbccd7a5b3c3a6b444f832d7060e88f74301748b6db
+  data.tar.gz: 75fcc7c1724b5219eecc3a421a5ff4bcbd90018f5e74eb7491be260faebf9e5686021768be785bfe5f59a5aa517fd766688f443083adf7c8dfc8daeaecbbea43

data/CHANGES.md

@@ -0,0 +1,8 @@
+## 0.0.2
+
+- Fix infinite nesting of directories during GEM installation
+- Doc updates
+
+## 0.0.1
+
+- Initial release

data/README.md

@@ -1,4 +1,4 @@
-# Bitferry - file synchronization/backup automation tool
+# Bitferry - file synchronization/backup automation
 
 <div align="right"><i>Ein Backup ist kein Backup</i></div><br><br>
 
@@ -6,8 +6,9 @@ The [Bitferry](https://github.com/okhlybov/bitferry) is aimed at establishing th
 
 The intended usage ranges from maintaining simple directory copy to another location (disk, mount point) to complex many-to-many (online/offline) data replication/backup solution employing portable media as additional data storage and a means of data propagation between the offsites.
 
-Bitferry is a frontend to the [Rclone](https://rclone.org) and [Restic](https://restic.net) utilities.
+The core idea that drives Bitferry is the conversion of full (absolute) endpoint's paths into the volume-relative ones, where the volume is a data file which is put along the endpoint's data and denotes the root of the directory hierarchy. This leads to the important location independence property meaning that Bitferry is then able to restore the tasks' source-destination endpoint connections in spite of the volume location changes, which is a likely scenario in case of portable storage (different UNIX mount points, Windows drives etc.).
 
+Bitferry is effectively a frontend to the [Rclone](https://rclone.org) and [Restic](https://restic.net) utilities.
 
 ## Features
 
@@ -27,7 +28,6 @@ Bitferry is a frontend to the [Rclone](https://rclone.org) and [Restic](https://
 
 * Offline portable storage (USB flash, HDDs, SSDs etc.) relay
 
-
 ## Use cases
 
 * Maintain an update-only files copy in a separate location on the same site
@@ -36,7 +36,6 @@ Bitferry is a frontend to the [Rclone](https://rclone.org) and [Restic](https://
 
 * Maintain an incremental files backup on a portable medium with multiple offsite copies of the repository
 
-
 ## Implementation
 
 The Bitferry itself is written in [Ruby](https://www.ruby-lang.org) programming language. Being a Ruby code, the Bitferry requires the platform-specific Ruby runtime, version 3.0 or higher. 
@@ -45,7 +44,6 @@ The source code is hosted on [GitHub](https://github.com/okhlybov/bitferry) and
 
 In addition, the platform-specific [Rclone](https://github.com/rclone/rclone/releases) and [Restic](https://github.com/restic/restic/releases) executables are required to be accessible through the `PATH` directory list or through the respective `RCLONE` and `RESTIC` environment variables.
 
-
 ## Kickstart
 
 Install Bitferry

data/lib/bitferry/cli.rb

@@ -165,14 +165,14 @@ Clamp do
       subcommand ['copy', 'c'], 'Create copy task' do
         banner %{
           Create source --> destination file copy task.
-      
+
           The task operates recursively on two specified endpoints.
           This task unconditionally copies all source files overwriting existing files in destination.
-      
+
           #{Endpoint}
-      
+
           #{Encryption}
-          
+
           This task employs the Rclone worker.
         }
         setup_rclone_task(self)
@@ -185,12 +185,12 @@ Clamp do
       subcommand ['update', 'u'], 'Create update task' do
         banner %{
           Create source --> destination file update (freshen) task.
-      
+
           The task operates recursively on two specified endpoints.
           This task copies newer source files while skipping unchanged files in destination.
-      
+
           #{Endpoint}
-      
+
           #{Encryption}
 
           This task employs the Rclone worker.
@@ -205,15 +205,15 @@ Clamp do
       subcommand ['synchronize', 'sync', 's'], 'Create one way sync task' do
         banner %{
           Create source --> destination one way file synchronization task.
-      
+
           The task operates recursively on two specified endpoints.
           This task copies newer source files while skipping unchanged files in destination.
           Also, it deletes destination files which are non-existent in source.
-      
+
           #{Endpoint}
 
           #{Encryption}
-      
+
           This task employs the Rclone worker.
         }
         setup_rclone_task(self)
@@ -226,15 +226,15 @@ Clamp do
       subcommand ['equalize', 'bisync', 'e'], 'Create two way sync task' do
         banner %{
           Create source <-> destination two way file synchronization task.
-      
+
           The task operates recursively on two specified endpoints.
           This task retains only the most recent versions of files on both endpoints.
           Opon execution both endpoints are left identical.
-      
+
           #{Endpoint}
 
           #{Encryption}
-      
+
           This task employs the Rclone worker.
         }
         setup_rclone_task(self)
@@ -341,4 +341,4 @@ Clamp do
   end
 
 
-end
+end

data/lib/bitferry.rb

@@ -12,10 +12,9 @@ require 'shellwords'
 module Bitferry
 
 
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 
 
-  # :nodoc:
   module Logging
     def self.log
       unless @log
@@ -488,7 +487,7 @@ module Bitferry
 
     include Logging
     extend  Logging
-  
+
 
     attr_reader :tag
 
@@ -627,7 +626,7 @@ module Bitferry
 
     include Logging
     extend  Logging
-  
+
 
     def self.executable = @executable ||= (rclone = ENV['RCLONE']).nil? ? 'rclone' : rclone
 
@@ -651,300 +650,301 @@ module Bitferry
     def self.reveal(token) = exec('reveal', '--', token)
 
 
-  end
+    class Encryption
 
 
-  class Rclone::Encryption
+      PROCESS = {
+        default: ['--crypt-filename-encoding', :base32, '--crypt-filename-encryption', :standard],
+        extended: ['--crypt-filename-encoding', :base32768, '--crypt-filename-encryption', :standard]
+      }
+      PROCESS[nil] = PROCESS[:default]
 
 
-    PROCESS = {
-      default: ['--crypt-filename-encoding', :base32, '--crypt-filename-encryption', :standard],
-      extended: ['--crypt-filename-encoding', :base32768, '--crypt-filename-encryption', :standard]
-    }
-    PROCESS[nil] = PROCESS[:default]
+      def process_options = @process_options.nil? ? [] : @process_options # As a mandatory option it should never be nil
 
 
-    def process_options = @process_options.nil? ? [] : @process_options # As a mandatory option it should never be nil
+      def initialize(token, process: nil)
+        @process_options = Bitferry.optional(process, PROCESS)
+        @token = token
+      end
 
 
-    def initialize(token, process: nil)
-      @process_options = Bitferry.optional(process, PROCESS)
-      @token = token
-    end
+      def create(password, **opts) = initialize(Rclone.obscure(password), **opts)
 
 
-    def create(password, **opts) = initialize(Rclone.obscure(password), **opts)
+      def restore(hash) = @process_options = hash[:rclone]
 
 
-    def restore(hash) = @process_options = hash[:rclone]
+      def externalize = process_options.empty? ? {} : { rclone: process_options }
 
 
-    def externalize = process_options.empty? ? {} : { rclone: process_options }
+      def configure(task) = install_token(task)
 
 
-    def configure(task) = install_token(task)
+      def process(task) = ENV['RCLONE_CRYPT_PASSWORD'] = obtain_token(task)
 
 
-    def process(task) = ENV['RCLONE_CRYPT_PASSWORD'] = obtain_token(task)
+      def arguments(task) = process_options + ['--crypt-remote', encrypted(task).root.to_s]
 
 
-    def arguments(task) = process_options + ['--crypt-remote', encrypted(task).root.to_s]
+      def install_token(task)
+        x = decrypted(task)
+        raise TypeError, 'unsupported unencrypted endpoint type' unless x.is_a?(Endpoint::Bitferry)
+        Volume[x.volume_tag].vault[task.tag] = @token # Token is stored on the decrypted end only
+      end
 
 
-    def install_token(task)
-      x = decrypted(task)
-      raise TypeError, 'unsupported unencrypted endpoint type' unless x.is_a?(Endpoint::Bitferry)
-      Volume[x.volume_tag].vault[task.tag] = @token # Token is stored on the decrypted end only
-    end
+      def obtain_token(task) = Volume[decrypted(task).volume_tag].vault.fetch(task.tag)
 
 
-    def obtain_token(task) = Volume[decrypted(task).volume_tag].vault.fetch(task.tag)
+      def self.new(*args, **opts)
+        obj = allocate
+        obj.send(:create, *args, **opts)
+        obj
+      end
 
 
-    def self.new(*args, **opts)
-      obj = allocate
-      obj.send(:create, *args, **opts)
-      obj
-    end
+      def self.restore(hash)
+        obj = ROUTE.fetch(hash.fetch(:operation).intern).allocate
+        obj.send(:restore, hash)
+        obj
+      end
 
 
-    def self.restore(hash)
-      obj = ROUTE.fetch(hash.fetch(:operation).intern).allocate
-      obj.send(:restore, hash)
-      obj
     end
 
 
-  end
+    class Encrypt < Encryption
 
 
-  class Rclone::Encrypt < Rclone::Encryption
+      def encrypted(task) = task.destination
 
 
-    def encrypted(task) = task.destination
+      def decrypted(task) = task.source
 
 
-    def decrypted(task) = task.source
+      def externalize = super.merge(operation: :encrypt)
 
 
-    def externalize = super.merge(operation: :encrypt)
+      def show_operation = 'encrypt+'
 
 
-    def show_operation = 'encrypt+'
+      def arguments(task) = super + [decrypted(task).root.to_s, ':crypt:']
 
 
-    def arguments(task) = super + [decrypted(task).root.to_s, ':crypt:']
+    end
 
 
-  end
+    class Decrypt < Encryption
 
 
-  class Rclone::Decrypt < Rclone::Encryption
+      def encrypted(task) = task.source
 
 
-    def encrypted(task) = task.source
+      def decrypted(task) = task.destination
 
 
-    def decrypted(task) = task.destination
+      def externalize = super.merge(operation: :decrypt)
 
 
-    def externalize = super.merge(operation: :decrypt)
+      def show_operation = 'decrypt+'
 
 
-    def show_operation = 'decrypt+'
+      def arguments(task) = super + [':crypt:', decrypted(task).root.to_s]
 
 
-    def arguments(task) = super + [':crypt:', decrypted(task).root.to_s]
+    end
 
-  end
 
+    ROUTE = {
+      encrypt: Encrypt,
+      decrypt: Decrypt
+    }
 
-  Rclone::Encryption::ROUTE = {
-    encrypt: Rclone::Encrypt,
-    decrypt: Rclone::Decrypt
-  }
 
+    class Task < Bitferry::Task
 
-  class Rclone::Task < Task
 
+      attr_reader :source, :destination
 
-    attr_reader :source, :destination
 
+      attr_reader :encryption
 
-    attr_reader :encryption
 
+      attr_reader :token
 
-    attr_reader :token
 
+      PROCESS = {
+        default: ['--metadata']
+      }
+      PROCESS[nil] = PROCESS[:default]
 
-    PROCESS = {
-      default: ['--metadata']
-    }
-    PROCESS[nil] = PROCESS[:default]
 
+      def initialize(source, destination, encryption: nil, process: nil, **opts)
+        super(**opts)
+        @process_options = Bitferry.optional(process, PROCESS)
+        @source = source.is_a?(Endpoint) ? source : Bitferry.endpoint(source)
+        @destination = destination.is_a?(Endpoint) ? destination : Bitferry.endpoint(destination)
+        @encryption = encryption
+      end
 
-    def initialize(source, destination, encryption: nil, process: nil, **opts)
-      super(**opts)
-      @process_options = Bitferry.optional(process, PROCESS)
-      @source = source.is_a?(Endpoint) ? source : Bitferry.endpoint(source)
-      @destination = destination.is_a?(Endpoint) ? destination : Bitferry.endpoint(destination)
-      @encryption = encryption
-    end
 
+      def create(*args, process: nil, **opts)
+        super(*args, process: process, **opts)
+        encryption.configure(self) unless encryption.nil?
+      end
 
-    def create(*args, process: nil, **opts)
-      super(*args, process: process, **opts)
-      encryption.configure(self) unless encryption.nil?
-    end
 
+      def show_status = "#{show_operation} #{source.show_status} #{show_direction} #{destination.show_status}"
 
-    def show_status = "#{show_operation} #{source.show_status} #{show_direction} #{destination.show_status}"
 
+      def show_operation = encryption.nil? ? '' : encryption.show_operation
 
-    def show_operation = encryption.nil? ? '' : encryption.show_operation
 
+      def show_direction = '-->'
 
-    def show_direction = '-->'
 
+      def intact? = live? && source.intact? && destination.intact?
 
-    def intact? = live? && source.intact? && destination.intact?
 
+      def refers?(volume) = source.refers?(volume) || destination.refers?(volume)
 
-    def refers?(volume) = source.refers?(volume) || destination.refers?(volume)
 
+      def touch
+        @generation = [source.generation, destination.generation].max + 1
+        super
+      end
 
-    def touch
-      @generation = [source.generation, destination.generation].max + 1
-      super
-    end
 
+      def format = nil
 
-    def format = nil
 
+      def common_options
+        [
+          '--config', Bitferry.windows? ? 'NUL' : '/dev/null',
+          case Bitferry.verbosity
+            when :verbose then '--verbose'
+            when :quiet then '--quiet'
+            else nil
+          end,
+          Bitferry.verbosity == :verbose ? '--progress' : nil,
+          Bitferry.simulate? ? '--dry-run' : nil,
+        ].compact
+      end
 
-    def common_options
-      [
-        '--config', Bitferry.windows? ? 'NUL' : '/dev/null',
-        case Bitferry.verbosity
-          when :verbose then '--verbose'
-          when :quiet then '--quiet'
-          else nil
-        end,
-        Bitferry.verbosity == :verbose ? '--progress' : nil,
-        Bitferry.simulate? ? '--dry-run' : nil,
-      ].compact
-    end
 
+      def process_arguments
+        ['--filter', "- #{Volume::STORAGE}", '--filter', "- #{Volume::STORAGE_}"] + common_options + process_options + (
+          encryption.nil? ? [source.root.to_s, destination.root.to_s] : encryption.arguments(self)
+        )
+      end
 
-    def process_arguments
-      ['--filter', "- #{Volume::STORAGE}", '--filter', "- #{Volume::STORAGE_}"] + common_options + process_options + (
-        encryption.nil? ? [source.root.to_s, destination.root.to_s] : encryption.arguments(self)
-      )
-    end
 
+      def execute(*args)
+        cmd = [Rclone.executable] + args
+        cms = cmd.collect(&:shellescape).join(' ')
+        puts cms if Bitferry.verbosity == :verbose
+        log.info(cms)
+        status = Open3.pipeline(cmd).first
+        raise "rclone exit code #{status.exitstatus}" unless status.success?
+        status.success?
+      end
 
-    def execute(*args)
-      cmd = [Rclone.executable] + args
-      cms = cmd.collect(&:shellescape).join(' ')
-      puts cms if Bitferry.verbosity == :verbose
-      log.info(cms)
-      status = Open3.pipeline(cmd).first
-      raise "rclone exit code #{status.exitstatus}" unless status.success?
-      status.success?
-    end
 
+      def process
+        log.info("processing task #{tag}")
+        encryption.process(self) unless encryption.nil?
+        execute(*process_arguments)
+      end
 
-    def process
-      log.info("processing task #{tag}")
-      encryption.process(self) unless encryption.nil?
-      execute(*process_arguments)
-    end
 
+      def externalize
+        super.merge(
+          source: source.externalize,
+          destination: destination.externalize,
+          encryption: encryption.nil? ? nil : encryption.externalize,
+          rclone: process_options.empty? ? nil : process_options
+        ).compact
+      end
 
-    def externalize
-      super.merge(
-        source: source.externalize,
-        destination: destination.externalize,
-        encryption: encryption.nil? ? nil : encryption.externalize,
-        rclone: process_options.empty? ? nil : process_options
-      ).compact
-    end
+
+      def restore(hash)
+        initialize(
+          restore_endpoint(hash.fetch(:source)),
+          restore_endpoint(hash.fetch(:destination)),
+          tag: hash.fetch(:task),
+          modified: hash.fetch(:modified, DateTime.now),
+          process: hash[:rclone],
+          encryption: hash[:encryption].nil? ? nil : Rclone::Encryption.restore(hash[:encryption])
+        )
+        super(hash)
+      end
 
 
-    def restore(hash)
-      initialize(
-        restore_endpoint(hash.fetch(:source)),
-        restore_endpoint(hash.fetch(:destination)),
-        tag: hash.fetch(:task),
-        modified: hash.fetch(:modified, DateTime.now),
-        process: hash[:rclone],
-        encryption: hash[:encryption].nil? ? nil : Rclone::Encryption.restore(hash[:encryption])
-      )
-      super(hash)
     end
 
 
-  end
+    class Copy < Task
 
 
-  class Rclone::Copy < Rclone::Task
+      def process_arguments = ['copy'] + super
 
 
-    def process_arguments = ['copy'] + super
+      def externalize = super.merge(operation: :copy)
 
 
-    def externalize = super.merge(operation: :copy)
+      def show_operation = super + 'copy'
 
 
-    def show_operation = super + 'copy'
+    end
 
 
-  end
+    class Update < Task
 
 
-  class Rclone::Update < Rclone::Task
+      def process_arguments = ['copy', '--update'] + super
 
 
-    def process_arguments = ['copy', '--update'] + super
+      def externalize = super.merge(operation: :update)
 
 
-    def externalize = super.merge(operation: :update)
+      def show_operation = super + 'update'
 
 
-    def show_operation = super + 'update'
+    end
 
 
-  end
+    class Synchronize < Task
 
 
-  class Rclone::Synchronize < Rclone::Task
+      def process_arguments = ['sync'] + super
 
 
-    def process_arguments = ['sync'] + super
+      def externalize = super.merge(operation: :synchronize)
 
 
-    def externalize = super.merge(operation: :synchronize)
+      def show_operation = super + 'synchronize'
 
 
-    def show_operation = super + 'synchronize'
+    end
 
 
-  end
+    class Equalize < Task
 
 
-  class Rclone::Equalize < Rclone::Task
+      def process_arguments = ['bisync', '--resync'] + super
 
 
-    def process_arguments = ['bisync', '--resync'] + super
+      def externalize = super.merge(operation: :equalize)
 
 
-    def externalize = super.merge(operation: :equalize)
+      def show_operation = super + 'equalize'
 
 
-    def show_operation = super + 'equalize'
+      def show_direction = '<->'
 
 
-    def show_direction = '<->'
+    end
 
 
   end
@@ -955,7 +955,7 @@ module Bitferry
 
     include Logging
     extend  Logging
-  
+
 
     def self.executable = @executable ||= (restic = ENV['RESTIC']).nil? ? 'restic' : restic
 
@@ -973,272 +973,275 @@ module Bitferry
     end
 
 
-  end
+    class Task < Bitferry::Task
 
 
-  class Restic::Task < Task
+      attr_reader :directory, :repository
 
 
-    attr_reader :directory, :repository
+      def initialize(directory, repository, **opts)
+        super(**opts)
+        @directory = directory.is_a?(Endpoint) ? directory : Bitferry.endpoint(directory)
+        @repository = repository.is_a?(Endpoint) ? repository : Bitferry.endpoint(repository)
+      end
 
 
-    def initialize(directory, repository, **opts)
-      super(**opts)
-      @directory = directory.is_a?(Endpoint) ? directory : Bitferry.endpoint(directory)
-      @repository = repository.is_a?(Endpoint) ? repository : Bitferry.endpoint(repository)
-    end
-
+      def create(directory, repository, password, **opts)
+        super(directory, repository, **opts)
+        raise TypeError, 'unsupported unencrypted endpoint type' unless self.directory.is_a?(Endpoint::Bitferry)
+        Volume[self.directory.volume_tag].vault[tag] = Rclone.obscure(@password = password) # Token is stored on the decrypted end only
+      end
 
-    def create(directory, repository, password, **opts)
-      super(directory, repository, **opts)
-      raise TypeError, 'unsupported unencrypted endpoint type' unless self.directory.is_a?(Endpoint::Bitferry)
-      Volume[self.directory.volume_tag].vault[tag] = Rclone.obscure(@password = password) # Token is stored on the decrypted end only
-    end
 
+      def password = @password ||= Rclone.reveal(Volume[directory.volume_tag].vault.fetch(tag))
 
-    def password = @password ||= Rclone.reveal(Volume[directory.volume_tag].vault.fetch(tag))
 
+      def intact? = live? && directory.intact? && repository.intact?
 
-    def intact? = live? && directory.intact? && repository.intact?
 
+      def refers?(volume) = directory.refers?(volume) || repository.refers?(volume)
 
-    def refers?(volume) = directory.refers?(volume) || repository.refers?(volume)
 
+      def touch
+        @generation = [directory.generation, repository.generation].max + 1
+        super
+      end
 
-    def touch
-      @generation = [directory.generation, repository.generation].max + 1
-      super
-    end
 
-    def format = nil
+      def format = nil
 
 
-    def common_options
-      [
-        case Bitferry.verbosity
-          when :verbose then '--verbose'
-          when :quiet then '--quiet'
-          else nil
-        end,
-        '-r', repository.root.to_s
-      ].compact
-    end
+      def common_options
+        [
+          case Bitferry.verbosity
+            when :verbose then '--verbose'
+            when :quiet then '--quiet'
+            else nil
+          end,
+          '-r', repository.root.to_s
+        ].compact
+      end
 
 
-    def execute(*args, simulate: false, chdir: nil)
-      cmd = [Restic.executable] + args
-      ENV['RESTIC_PASSWORD'] = password
-      cms = cmd.collect(&:shellescape).join(' ')
-      puts cms if Bitferry.verbosity == :verbose
-      log.info(cms)
-      if simulate
-        log.info('(simulated)')
-        true
-      else
-        wd = Dir.getwd unless chdir.nil?
-        begin
-          Dir.chdir(chdir) unless chdir.nil?
-          status = Open3.pipeline(cmd).first
-          raise "restic exit code #{status.exitstatus}" unless status.success?
-        ensure
-          Dir.chdir(wd) unless chdir.nil?
+      def execute(*args, simulate: false, chdir: nil)
+        cmd = [Restic.executable] + args
+        ENV['RESTIC_PASSWORD'] = password
+        cms = cmd.collect(&:shellescape).join(' ')
+        puts cms if Bitferry.verbosity == :verbose
+        log.info(cms)
+        if simulate
+          log.info('(simulated)')
+          true
+        else
+          wd = Dir.getwd unless chdir.nil?
+          begin
+            Dir.chdir(chdir) unless chdir.nil?
+            status = Open3.pipeline(cmd).first
+            raise "restic exit code #{status.exitstatus}" unless status.success?
+          ensure
+            Dir.chdir(wd) unless chdir.nil?
+          end
         end
       end
-    end
 
 
-    def externalize
-      super.merge(
-        directory: directory.externalize,
-        repository: repository.externalize,
-      ).compact
-    end
+      def externalize
+        super.merge(
+          directory: directory.externalize,
+          repository: repository.externalize,
+        ).compact
+      end
 
 
-    def restore(hash)
-      initialize(
-        restore_endpoint(hash.fetch(:directory)),
-        restore_endpoint(hash.fetch(:repository)),
-        tag: hash.fetch(:task),
-        modified: hash.fetch(:modified, DateTime.now)
-      )
-      super(hash)
-    end
+      def restore(hash)
+        initialize(
+          restore_endpoint(hash.fetch(:directory)),
+          restore_endpoint(hash.fetch(:repository)),
+          tag: hash.fetch(:task),
+          modified: hash.fetch(:modified, DateTime.now)
+        )
+        super(hash)
+      end
 
 
-  end
+    end
 
 
-  class Restic::Backup < Restic::Task
+    class Backup < Task
 
 
-    PROCESS = {
-      default: ['--no-cache']
-    }
-    PROCESS[nil] = PROCESS[:default]
+      PROCESS = {
+        default: ['--no-cache']
+      }
+      PROCESS[nil] = PROCESS[:default]
 
 
-    FORGET = {
-      default: ['--prune', '--keep-within-hourly', '24h', '--keep-within-daily', '7d', '--keep-within-weekly', '30d', '--keep-within-monthly', '1y', '--keep-within-yearly', '100y']
-    }
-    FORGET[nil] = nil # Skip processing retention policy by default
+      FORGET = {
+        default: ['--prune', '--keep-within-hourly', '24h', '--keep-within-daily', '7d', '--keep-within-weekly', '30d', '--keep-within-monthly', '1y', '--keep-within-yearly', '100y']
+      }
+      FORGET[nil] = nil # Skip processing retention policy by default
 
 
-    CHECK = {
-      default: [],
-      full: ['--read-data']
-    }
-    CHECK[nil] = nil # Skip integrity checking by default
+      CHECK = {
+        default: [],
+        full: ['--read-data']
+      }
+      CHECK[nil] = nil # Skip integrity checking by default
 
 
-    attr_reader :forget_options
-    attr_reader :check_options
+      attr_reader :forget_options
+      attr_reader :check_options
 
 
-    def create(*args, format: nil, process: nil, forget: nil, check: nil, **opts)
-      super(*args, **opts)
-      @format = format
-      @process_options = Bitferry.optional(process, PROCESS)
-      @forget_options = Bitferry.optional(forget, FORGET)
-      @check_options = Bitferry.optional(check, CHECK)
-    end
+      def create(*args, format: nil, process: nil, forget: nil, check: nil, **opts)
+        super(*args, **opts)
+        @format = format
+        @process_options = Bitferry.optional(process, PROCESS)
+        @forget_options = Bitferry.optional(forget, FORGET)
+        @check_options = Bitferry.optional(check, CHECK)
+      end
 
 
-    def show_status = "#{show_operation} #{directory.show_status} #{show_direction} #{repository.show_status}"
+      def show_status = "#{show_operation} #{directory.show_status} #{show_direction} #{repository.show_status}"
 
 
-    def show_operation = 'encrypt+backup'
+      def show_operation = 'encrypt+backup'
 
 
-    def show_direction = '-->'
+      def show_direction = '-->'
 
 
-    def process
-      begin
-        log.info("processing task #{tag}")
-        execute('backup', '.', '--tag', "bitferry,#{tag}", '--exclude', Volume::STORAGE, '--exclude', Volume::STORAGE_, *process_options, *common_options_simulate, chdir: directory.root)
-        unless check_options.nil?
-          log.info("checking repository in #{repository.root}")
-          execute('check', *check_options, *common_options)
-        end
-        unless forget_options.nil?
-          log.info("performing repository maintenance tasks in #{repository.root}")
-          execute('forget', '--tag', "bitferry,#{tag}", *forget_options.collect(&:to_s), *common_options_simulate)
+      def process
+        begin
+          log.info("processing task #{tag}")
+          execute('backup', '.', '--tag', "bitferry,#{tag}", '--exclude', Volume::STORAGE, '--exclude', Volume::STORAGE_, *process_options, *common_options_simulate, chdir: directory.root)
+          unless check_options.nil?
+            log.info("checking repository in #{repository.root}")
+            execute('check', *check_options, *common_options)
+          end
+          unless forget_options.nil?
+            log.info("performing repository maintenance tasks in #{repository.root}")
+            execute('forget', '--tag', "bitferry,#{tag}", *forget_options.collect(&:to_s), *common_options_simulate)
+          end
+          true
+        rescue
+          false
         end
-        true
-      rescue
-        false
       end
-    end
 
 
-    def common_options_simulate = common_options + [Bitferry.simulate? ? '--dry-run' : nil].compact
+      def common_options_simulate = common_options + [Bitferry.simulate? ? '--dry-run' : nil].compact
 
 
-    def externalize
-      restic = {
-        process: process_options,
-        forget: forget_options,
-        check: check_options
-      }.compact
-      super.merge({
-        operation: :backup,
-        restic: restic.empty? ? nil : restic
-      }.compact)
-    end
+      def externalize
+        restic = {
+          process: process_options,
+          forget: forget_options,
+          check: check_options
+        }.compact
+        super.merge({
+          operation: :backup,
+          restic: restic.empty? ? nil : restic
+        }.compact)
+      end
 
 
-    def restore(hash)
-      super
-      opts = hash.fetch(:restic, {})
-      @process_options = opts[:process]
-      @forget_options = opts[:forget]
-      @check_options = opts[:check]
-    end
+      def restore(hash)
+        super
+        opts = hash.fetch(:restic, {})
+        @process_options = opts[:process]
+        @forget_options = opts[:forget]
+        @check_options = opts[:check]
+      end
 
 
-    def format
-      if Bitferry.simulate?
-        log.info('skipped repository initialization (simulation)')
-      else
-        log.info("initializing repository for task #{tag}")
-        if @format == true
-          log.debug("wiping repository in #{repository.root}")
-          ['config', 'data', 'index', 'keys', 'locks', 'snapshots'].each { |x| FileUtils.rm_rf(File.join(repository.root.to_s, x)) }
-        end
-        if @format == false
-          # TODO validate existing repo
-          log.info("attached to existing repository for task #{tag} in #{repository.root}")
+      def format
+        if Bitferry.simulate?
+          log.info('skipped repository initialization (simulation)')
         else
-          begin
-            execute(*common_options, 'init')
-            log.info("initialized repository for task #{tag} in #{repository.root}")
-          rescue
-            log.fatal("failed to initialize repository for task #{tag} in #{repository.root}")
-            raise
+          log.info("initializing repository for task #{tag}")
+          if @format == true
+            log.debug("wiping repository in #{repository.root}")
+            ['config', 'data', 'index', 'keys', 'locks', 'snapshots'].each { |x| FileUtils.rm_rf(File.join(repository.root.to_s, x)) }
+          end
+          if @format == false
+            # TODO validate existing repo
+            log.info("attached to existing repository for task #{tag} in #{repository.root}")
+          else
+            begin
+              execute(*common_options, 'init')
+              log.info("initialized repository for task #{tag} in #{repository.root}")
+            rescue
+              log.fatal("failed to initialize repository for task #{tag} in #{repository.root}")
+              raise
+            end
           end
         end
+        @state = :intact
       end
-      @state = :intact
-    end
 
-  end
 
+    end
 
-  class Restic::Restore < Restic::Task
 
+    class Restore < Task
 
-    PROCESS = {
-      default: ['--no-cache', '--sparse']
-    }
-    PROCESS[nil] = PROCESS[:default]
 
+      PROCESS = {
+        default: ['--no-cache', '--sparse']
+      }
+      PROCESS[nil] = PROCESS[:default]
 
-    def create(*args, process: nil, **opts)
-      super(*args, **opts)
-      @process_options = Bitferry.optional(process, PROCESS)
-    end
 
+      def create(*args, process: nil, **opts)
+        super(*args, **opts)
+        @process_options = Bitferry.optional(process, PROCESS)
+      end
 
-    def show_status = "#{show_operation} #{repository.show_status} #{show_direction} #{directory.show_status}"
 
+      def show_status = "#{show_operation} #{repository.show_status} #{show_direction} #{directory.show_status}"
 
-    def show_operation = 'decrypt+restore'
 
+      def show_operation = 'decrypt+restore'
 
-    def show_direction = '-->'
 
+      def show_direction = '-->'
 
-    def externalize
-      restic = {
-        process: process_options
-      }.compact
-      super.merge({
-        operation: :restore,
-        restic: restic.empty? ? nil : restic
-      }.compact)
-    end
 
+      def externalize
+        restic = {
+          process: process_options
+        }.compact
+        super.merge({
+          operation: :restore,
+          restic: restic.empty? ? nil : restic
+        }.compact)
+      end
 
-    def restore(hash)
-      super
-      opts = hash.fetch(:rclone, {})
-      @process_options = opts[:process]
-    end
+
+      def restore(hash)
+        super
+        opts = hash.fetch(:rclone, {})
+        @process_options = opts[:process]
+      end
 
 
-    def process
-      log.info("processing task #{tag}")
-      begin
-        # FIXME restore specifically tagged latest snapshot
-        execute('restore', 'latest', '--target', '.', *process_options, *common_options, simulate: Bitferry.simulate?, chdir: directory.root)
-        true
-      rescue
-        false
+      def process
+        log.info("processing task #{tag}")
+        begin
+          # FIXME restore specifically tagged latest snapshot
+          execute('restore', 'latest', '--target', '.', *process_options, *common_options, simulate: Bitferry.simulate?, chdir: directory.root)
+          true
+        rescue
+          false
+        end
       end
+
+
     end
 
 
+
   end
 
 
@@ -1262,109 +1265,109 @@ module Bitferry
     end
 
 
-  end
+    class Local < Endpoint
 
 
-  class Endpoint::Local < Endpoint
+      attr_reader :root
 
 
-    attr_reader :root
+      def initialize(root) = @root = Pathname.new(root).realdirpath
 
 
-    def initialize(root) = @root = Pathname.new(root).realdirpath
+      def restore(hash) = initialize(hash.fetch(:root))
 
 
-    def restore(hash) = initialize(hash.fetch(:root))
+      def externalize
+        {
+          endpoint: :local,
+          root: root
+        }
+      end
 
 
-    def externalize
-      {
-        endpoint: :local,
-        root: root
-      }
-    end
+      def show_status = root.to_s
 
 
-    def show_status = root.to_s
+      def intact? = true
 
 
-    def intact? = true
+      def refers?(volume) = false
 
 
-    def refers?(volume) = false
+      def generation = 0
 
 
-    def generation = 0
+    end
 
 
-  end
+    class Rclone < Endpoint
+      # TODO
+    end
 
 
-  class Endpoint::Rclone < Endpoint
-    # TODO
-  end
+    class Bitferry < Endpoint
 
 
-  class Endpoint::Bitferry < Endpoint
+      attr_reader :volume_tag
 
 
-    attr_reader :volume_tag
+      attr_reader :path
 
 
-    attr_reader :path
+      def root = Volume[volume_tag].root.join(path)
 
 
-    def root = Volume[volume_tag].root.join(path)
+      def initialize(volume, path)
+        @volume_tag = volume.tag
+        @path = Pathname.new(path)
+        raise ArgumentError, "expected relative path but got #{self.path}" unless (/^[\.\/]/ =~ self.path.to_s).nil?
+      end
 
 
-    def initialize(volume, path)
-      @volume_tag = volume.tag
-      @path = Pathname.new(path)
-      raise ArgumentError, "expected relative path but got #{self.path}" unless (/^[\.\/]/ =~ self.path.to_s).nil?
-    end
+      def restore(hash)
+        @volume_tag = hash.fetch(:volume)
+        @path = Pathname.new(hash.fetch(:path))
+      end
 
 
-    def restore(hash)
-      @volume_tag = hash.fetch(:volume)
-      @path = Pathname.new(hash.fetch(:path))
-    end
+      def externalize
+        {
+          endpoint: :bitferry,
+          volume: volume_tag,
+          path: path
+        }
+      end
 
 
-    def externalize
-      {
-        endpoint: :bitferry,
-        volume: volume_tag,
-        path: path
-      }
-    end
+      def show_status = intact? ? ":#{volume_tag}:#{path}" : ":{#{volume_tag}}:#{path}"
 
 
-    def show_status = intact? ? ":#{volume_tag}:#{path}" : ":{#{volume_tag}}:#{path}"
+      def intact? = !Volume[volume_tag].nil?
 
 
-    def intact? = !Volume[volume_tag].nil?
+      def refers?(volume) = volume.tag == volume_tag
 
 
-    def refers?(volume) = volume.tag == volume_tag
+      def generation
+        v = Volume[volume_tag]
+        v ? v.generation : 0
+      end
 
 
-    def generation
-      v = Volume[volume_tag]
-      v ? v.generation : 0
     end
 
 
-  end
+    ROUTE = {
+      local: Local,
+      rclone: Rclone,
+      bitferry: Bitferry
+    }
 
 
-  Endpoint::ROUTE = {
-    local: Endpoint::Local,
-    rclone: Endpoint::Rclone,
-    bitferry: Endpoint::Bitferry
-  }
+  end
 
 
   reset
 
 
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bitferry
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Oleg A. Khlybov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-03-05 00:00:00.000000000 Z
+date: 2024-03-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -73,6 +73,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGES.md
 - README.md
 - bin/bitferry
 - lib/bitferry.rb
@@ -97,7 +98,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.33
+rubygems_version: 3.4.19
 signing_key:
 specification_version: 4
 summary: File synchronization/backup automation tool