snapsync 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 38bab1614373f2385245f2e093bc560c3c7e1dd0
-  data.tar.gz: 3343524d89264155f5ae303e85aa9a92a47fc594
+  metadata.gz: a5da01c8d37c1e84fd79ba60d9264727e5a2823b
+  data.tar.gz: 7f6aa1843176471539fb080f2f151ab3d6d33375
 SHA512:
-  metadata.gz: c13a2ac4ed65de64035f3a4e212aed9ac4ef6569c9503893f892bdcc59385f39c972319b7372d56d0c9fd89e44cb3b53a3aaa98a0b85b26b1f96ce333ecb6fde
-  data.tar.gz: 85751adfae9447bfa4b33dd8413097eeb966e050f7f2ab59794417113a80d349e6045d7a1bda5386d7811b8f76502e32d07693c577afa5dce41229c40cf69af4
+  metadata.gz: c934f77289b0ba709ee164c5bc21cb67cf5afd1cc6f7a4c7463fbcd5a3938aab1c30b5740ae7921d010ba8c8eb4d31b3b158f93a3b63241578ca410971fde90f
+  data.tar.gz: 44060ce27c293a7ac4ceda651beeaec24a53ee7411438377d4907d489bd53cd139b4bdaf6792174e9d76e09e8cd9bb133e67625914167b1111d6b734d6b94ea1

data/lib/snapsync/auto_sync.rb

@@ -5,7 +5,7 @@ module Snapsync
     # partition availability, and will run sync-all on each (declared) targets
     # when they are available, optionally auto-mounting them
     class AutoSync
-        AutoSyncTarget = Struct.new :partition_uuid, :path, :automount
+        AutoSyncTarget = Struct.new :partition_uuid, :path, :automount, :name
 
         attr_reader :config_dir
         attr_reader :targets
@@ -26,16 +26,45 @@ module Snapsync
             conf.each do |hash|
                 target = AutoSyncTarget.new
                 hash.each { |k, v| target[k] = v }
+                target.path = Pathname.new(target.path)
                 add(target)
             end
         end
 
+        def write_config(path)
+            data = each_target.map do |target|
+                Hash['partition_uuid' => target.partition_uuid,
+                     'path' => target.path.to_s,
+                     'automount' => !!target.automount,
+                     'name' => target.name]
+            end
+            File.open(path, 'w') do |io|
+                YAML.dump(data, io)
+            end
+        end
+
+        def each_target
+            return enum_for(__method__) if !block_given?
+            targets.each_value do |targets|
+                targets.each { |t| yield(t) }
+            end
+        end
+
         def add(target)
             targets[target.partition_uuid] ||= Array.new
             targets[target.partition_uuid] << target
             partitions.monitor_for(target.partition_uuid)
         end
 
+        def remove(**matcher)
+            targets.delete_if do |uuid, list|
+                list.delete_if do |t|
+                    matcher.all? { |k, v| t[k] == v }
+                end
+                list.empty?
+            end
+        end
+
         def run(period: 60)
             while true
                 partitions.poll

data/lib/snapsync/cli.rb

@@ -57,19 +57,96 @@ module Snapsync
             end
         end
 
-        desc 'init DIR', 'creates a synchronization target with a default policy'
-        def init(dir)
+        desc 'init NAME DIR [POLICY]', 'creates a synchronization target, optionally specifying the synchronization and cleanup policy'
+        long_desc <<-EOD
+By default, the default policy is used. To change this, provide additional
+arguments as would be expected by the policy subcommand. Run snapsync help
+policy for more information
+        EOD
+        option :all, type: :boolean, default: true,
+            desc: "if true (the default), create one snapsync target per snapper configuration under DIR, otherwise, initialize only one target directly in DIR"
+        option :auto, type: :boolean, default: true,
+            desc: "if true (the default), add the newly created target to auto-sync"
+        option :automount, type: :boolean, default: true,
+            desc: 'whether the supporting partition should be auto-mounted by snapsync when needed or not (the default is yes). Only useful if --no-auto has not been provided on the command line.'
+        def init(name, dir, *policy)
             dir = Pathname.new(dir)
-            if !dir.exist?
-                dir.mkpath
+
+            if policy.empty?
+                policy = ['default', Array.new]
+            elsif policy.size == 1
+                policy << Array.new
             end
 
-            target = LocalTarget.new(dir)
-            target.change_policy('default', Hash.new)
-            target.write_config
+            dirs = Array.new
+            if options[:all]
+                SnapperConfig.each_in_dir do |config|
+                    dirs << dir + config.name
+                end
+            else
+                dirs << dir
+            end
+
+            dirs.each do |path|
+                begin
+                    LocalTarget.new(path, create_if_needed: false)
+                    Snapsync.info "#{path} was already initialized"
+                rescue ArgumentError, LocalTarget::NoUUIDError
+                    path.mkpath
+                    target = LocalTarget.new(path)
+                    target.change_policy(*policy)
+                    target.write_config
+                    Snapsync.info "initialized #{path} as a snapsync target"
+                end
+            end
+
+            if options[:auto]
+                if !options[:all]
+                    Snapsync.warn "cannot use --auto without --all"
+                else
+                    auto_add(name, dir)
+                end
+            end
+        end
+
+        desc 'auto-add NAME DIR', "add DIR to the set of targets for auto-sync"
+        option :automount, type: :boolean, default: true,
+            desc: 'whether the supporting partition should be auto-mounted by snapsync when needed or not (the default is yes)'
+        def auto_add(name, dir)
+            partitions = PartitionsMonitor.new
+            uuid, relative = partitions.partition_of(Pathname.new(dir))
+
+            conf_path = Pathname.new('/etc/snapsync.conf')
+
+            autosync = AutoSync.new
+            autosync.load_config(conf_path)
+            exists = autosync.each_target.find do |t|
+                t.partition_uuid == uuid && t.path.cleanpath == relative.cleanpath
+            end
+            if exists
+                if exists.automount == options[:automount]
+                    Snapsync.info "already exists under the name #{exists.name}"
+                else
+                    Snapsync.info "already exists under the name #{exists.name} but with a different automount flag, changing"
+                    exists.automount = options[:automount]
+                end
+                exists.name ||= name
+            else
+                autosync.add AutoSync::AutoSyncTarget.new(uuid, relative, options[:automount], name)
+            end
+            autosync.write_config(conf_path)
+        end
+
+        desc 'auto-remove NAME', "remove a target from auto-sync by name"
+        def auto_remove(name)
+            conf_path = Pathname.new('/etc/snapsync.conf')
+            autosync = AutoSync.new
+            autosync.load_config(conf_path)
+            autosync.remove(name: name)
+            autosync.write_config(conf_path)
         end
 
-        desc 'policy DIR TYPE [OPTIONS]', 'sets the synchronization and cleanup policy for the given target'
+        desc 'policy DIR TYPE [OPTIONS]', 'sets the synchronization and cleanup policy for the given target or targets'
         long_desc <<-EOD
 This command sets the policy used to decide which snapshots to synchronize to
 the target, and which to not synchronize.

data/lib/snapsync/partitions_monitor.rb

@@ -28,6 +28,28 @@ module Snapsync
             monitored_partitions << partition_uuid.to_str
         end
 
+        def partition_of(dir)
+            rel = Pathname.new("")
+            while !dir.mountpoint?
+                rel = dir.basename + rel
+                dir = dir.dirname
+            end
+
+            each_partition_with_filesystem do |name, dev|
+                partition = dev['org.freedesktop.UDisks2.Block']
+                uuid = partition['IdUUID']
+
+                fs = dev['org.freedesktop.UDisks2.Filesystem']
+                mount_points = fs['MountPoints'].map do |str|
+                    str[0..-2].pack("U*")
+                end
+                if mount_points.include?(dir.to_s)
+                    return uuid, rel
+                end
+            end
+            nil
+        end
+
         def dirty!
             dirty.set
         end

data/lib/snapsync/version.rb

@@ -1,3 +1,3 @@
 module Snapsync
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: snapsync
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Sylvain Joyeux
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-03 00:00:00.000000000 Z
+date: 2015-08-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logging