snapsync 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9d6c814ce6fcbbbeb80bfc50d4f980f041bc3dc7
+  data.tar.gz: 895b0008fcbc01edb78c9455d0eaf580e5f762ae
+SHA512:
+  metadata.gz: b3ce31df068bbd6d05afd5a29d0175c7dfcdb8cf21489ffb36a0cf6eed68cce46c7618fa79b85f4c46669eb06afc62a6e7d16048eb10ebf88a71121e1d59260b
+  data.tar.gz: 92c04cdf3c5c4feb7efbc3595a0c439ad2fcfbc05dbafafc0d678df5f18668d126f126f160bd615e7c8dfb17d9d1a946e5d7dcc1a206545e25d36c05a77f144d

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/vendor/

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.1.2
+before_install: gem install bundler -v 1.10.4

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in snapsync.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Sylvain Joyeux
+
+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,44 @@
+# Snapsync
+
+A synchronization tool for snapper
+
+This gem implements snapper-based backup, by allowing you to synchronize a
+snapper snapshot directory to a different location. It uses btrfs send and
+receive to achieve it
+
+## Installation
+
+Run
+
+    $ gem install snapsync
+
+## Usage
+
+To synchronize the snapshots of the 'home' snapper configuration to an existing
+directory, run
+
+    $ snapsync home /media/backup
+
+Snapsync uses sudo to get root access. If you wish to not run it as root, you
+will need to change the snapper permissions to give read access to all the
+snapper shapshots, e.g.
+
+    $ chmod go+rx /.snapshots
+    $ chmod go+r /.snapshots/*/info.xml
+
+In addition, sudo will ask for your root password when applicable. If you wish
+to fully automate, you will need to allow snapsync to run the btrfs tool without
+password in the sudoers file.
+
+## Development
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/snapsync.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/bin/snapsync

@@ -0,0 +1,3 @@
+#! /usr/bin/env ruby
+require 'snapsync/cli'
+Snapsync::CLI.start(ARGV)

data/lib/snapsync.rb

@@ -0,0 +1,92 @@
+require 'pathname'
+require 'logging'
+require 'pp'
+require 'securerandom'
+require 'rexml/document'
+require 'dbus'
+require 'concurrent'
+
+require "snapsync/version"
+require "snapsync/exceptions"
+require "snapsync/snapper_config"
+require "snapsync/snapshot"
+require "snapsync/local_target"
+require "snapsync/local_sync"
+require 'snapsync/cleanup'
+
+require 'snapsync/default_sync_policy'
+require 'snapsync/timeline_sync_policy'
+require 'snapsync/sync_last_policy'
+
+require 'snapsync/partitions_monitor'
+require 'snapsync/sync_all'
+require 'snapsync/auto_sync'
+
+module Logging
+    module Installer
+        def logger
+            @logger ||= Logging.logger[self]
+        end
+    end
+
+    module Forwarder
+        ::Logging::LEVELS.each do |name, _|
+            puts name
+            define_method name do |*args, &block|
+                logger.send(name, *args, &block)
+            end
+        end
+    end
+end
+
+class Module
+    def install_root_logging(level: 'INFO', forward: true, &block)
+        extend Logging::Installer
+        if block_given?
+            yield(logger)
+        else
+            logger.add_appenders Logging.appenders.stdout
+        end
+
+        if forward
+            singleton_class.class_eval do
+                install_logging_forwarder
+            end
+        end
+        logger.level = level
+    end
+
+    def install_logging_forwarder
+        ::Logging::LEVELS.each do |name, _|
+            define_method name do |*args, &block|
+                logger.send(name, *args, &block)
+            end
+        end
+    end
+
+    def install_logging(forward: true, &block)
+        extend Logging::Installer
+        if forward
+            singleton_class.class_eval do
+                install_logging_forwarder
+            end
+        end
+    end
+end
+
+class Class
+    def install_logging(forward: true, on_instance: false)
+        super(forward: forward)
+        if on_instance
+            include Logging::Installer
+            if forward
+                install_logging_forwarder
+            end
+        end
+    end
+end
+
+module Snapsync
+    install_root_logging(forward: true)
+end
+

data/lib/snapsync/auto_sync.rb

@@ -0,0 +1,74 @@
+module Snapsync
+    # Implementation of the auto-sync feature
+    #
+    # This class implements the 'snapsync auto' functionality. It monitors for
+    # 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
+
+        attr_reader :config_dir
+        attr_reader :targets
+        attr_reader :partitions
+
+        def initialize(config_dir = SnapperConfig.default_config_dir)
+            @config_dir = config_dir
+            @targets = Hash.new
+            @partitions = PartitionsMonitor.new
+        end
+
+        def load_config(path)
+            conf = YAML.load(path.read) || Array.new
+            parse_config(conf)
+        end
+
+        def parse_config(conf)
+            conf.each do |hash|
+                target = AutoSyncTarget.new
+                hash.each { |k, v| target[k] = v }
+                add(target)
+            end
+        end
+
+        def add(target)
+            targets[target.partition_uuid] ||= Array.new
+            targets[target.partition_uuid] << target
+            partitions.monitor_for(target.partition_uuid)
+        end
+
+        def run(period: 60)
+            while true
+                partitions.poll
+                partitions.known_partitions.each do |uuid, fs|
+                    mp = fs['MountPoints'].first
+                    targets[uuid].each do |t|
+                        if !mp
+                            if t.automount
+                                Snapsync.info "partition #{t.partition_uuid} is present, but not mounted, automounting"
+                                mp = fs.Mount([]).first
+                                mp = Pathname.new(mp)
+                                mounted = true
+                            else
+                                Snapsync.info "partition #{t.partition_uuid} is present, but not mounted and automount is false. Ignoring"
+                                next
+                            end
+                        else
+                            mp = Pathname.new(mp[0..-2].pack("U*"))
+                        end
+
+                        full_path = mp + t.path
+                        Snapsync.info "sync-all on #{mp + t.path} (partition #{t.partition_uuid})"
+                        op = SyncAll.new(mp + t.path, config_dir: config_dir)
+                        op.run
+                        if mounted
+                            fs.Unmount([])
+                        end
+                    end
+                end
+                Snapsync.info "done all declared autosync partitions, sleeping #{period}s"
+                sleep period
+            end
+        end
+    end
+end
+

data/lib/snapsync/cleanup.rb

@@ -0,0 +1,40 @@
+module Snapsync
+    class Cleanup
+        # The underlying timeline policy object that we use to compute which
+        # snapshots to delete and which to keep
+        attr_reader :policy
+
+        def initialize(policy)
+            @policy = policy
+        end
+
+        def cleanup(target, dry_run: false)
+            snapshots = target.each_snapshot.to_a
+            filtered_snapshots = policy.filter_snapshots_to_sync(target, snapshots).to_set
+
+            if filtered_snapshots.any? { |s| s.synchronization_point? }
+                raise InvalidPolicy, "#{policy} returned a snapsync synchronization point in its results"
+            end
+
+            if filtered_snapshots.empty?
+                raise InvalidPolicy, "#{policy} returned no snapshots"
+            end
+
+            last_sync_point = snapshots.
+                sort_by(&:num).reverse.
+                find { |s| s.synchronization_point_for?(target) }
+            if !last_sync_point
+                binding.pry
+            end
+            filtered_snapshots << last_sync_point
+            filtered_snapshots = filtered_snapshots.to_set
+
+            snapshots.sort_by(&:num).each do |s|
+                if !filtered_snapshots.include?(s)
+                    target.delete(s, dry_run: dry_run)
+                end
+            end
+        end
+    end
+end
+

data/lib/snapsync/cli.rb

@@ -0,0 +1,125 @@
+require 'thor'
+require 'snapsync'
+
+module Snapsync
+    class CLI < Thor
+        class_option :debug, type: :boolean, default: false
+
+        no_commands do
+            def config_from_name(name)
+                path = Pathname.new(name)
+                if !path.exist?
+                    path = SnapperConfig.default_config_dir + path
+                    if !path.exist?
+                        raise ArgumentError, "cannot find any snapper configuration called #{name}"
+                    end
+                end
+                SnapperConfig.load(path)
+            end
+
+            def handle_class_options
+                if options[:debug]
+                    Snapsync.logger.level = 'DEBUG'
+                end
+            end
+        end
+
+        desc 'sync CONFIG DIR', 'synchronizes the snapper configuration CONFIG with the snapsync target DIR'
+        def sync(config_name, dir)
+            handle_class_options
+
+            config = config_from_name(config_name)
+            target = LocalTarget.new(Pathname.new(dir))
+            LocalSync.new(config, target).sync
+        end
+
+        desc 'sync-all DIR', 'synchronizes all snapper configurations into corresponding subdirectories of DIR'
+        option :autoclean, type: :boolean, default: nil,
+            desc: 'whether the target should be cleaned of obsolete snapshots',
+            long_desc: "The default is to use the value specified in the target's configuration file. This command line option allows to override the default"
+        def sync_all(dir)
+            handle_class_options
+
+            op = SyncAll.new(dir, config_dir: SnapperConfig.default_config_dir, autoclean: options[:autoclean])
+            op.run
+        end
+
+        desc 'cleanup CONFIG DIR', 'cleans up the snapsync target DIR based on the policy set by the policy command'
+        option :dry_run, type: :boolean, default: false
+        def cleanup(dir)
+            handle_class_options
+
+            target = LocalTarget.new(Pathname.new(dir))
+            if target.cleanup
+                target.cleanup.cleanup(target, dry_run: options[:dry_run])
+            else
+                Snapsync.info "#{target.sync_policy.class.name} policy set, nothing to do"
+            end
+        end
+
+        desc 'init DIR', 'creates a synchronization target with a default policy'
+        def init(dir)
+            dir = Pathname.new(dir)
+            if !dir.exist?
+                dir.mkpath
+            end
+
+            target = LocalTarget.new(dir)
+            target.change_policy('default', Hash.new)
+            target.write_config
+        end
+
+        desc 'policy DIR TYPE [OPTIONS]', 'sets the synchronization and cleanup policy for the given target'
+        long_desc <<-EOD
+This command sets the policy used to decide which snapshots to synchronize to
+the target, and which to not synchronize.
+
+Three policy types can be used: default, last and timeline
+
+The default policy takes no argument. It will synchronize all snapshots present in the source, and do no cleanup
+
+The last policy takes no argument. It will synchronize (and keep) only the last snapshot
+
+The timeline policy takes periods of time as argument (as e.g. day 10 or month 20). It will keep at least
+one snapshot for each period, and for the duration specified (day 10 tells to keep one snapshot per day
+for 10 days). snapsync understands the following period names: year month day hour.
+        EOD
+        def policy(dir, type, *options)
+            handle_class_options
+
+            dir = Pathname.new(dir)
+            if !dir.exist?
+                dir.mkpath
+            end
+
+            target = LocalTarget.new(dir)
+            target.change_policy(type, options)
+            target.write_config
+        end
+
+        desc 'destroy DIR', 'destroys a snapsync target'
+        long_desc <<-EOD
+While it can easily be done manually, this command makes sure that the snapshots are properly deleted
+        EOD
+        def destroy(dir)
+            handle_class_options
+            target_dir = Pathname.new(dir)
+            target = LocalTarget.new(target_dir, create_if_needed: false)
+            snapshots = target.each_snapshot.to_a
+            snapshots.sort_by(&:num).each do |s|
+                target.delete(s)
+            end
+            target_dir.rmtree
+        end
+
+        desc "auto-sync", "automatic synchronization"
+        option :config_file, desc: "path to the config file (defaults to /etc/snapsync.conf)",
+            default: '/etc/snapsync.conf'
+        def auto_sync
+            auto = AutoSync.new(SnapperConfig.default_config_dir)
+            auto.load_config(Pathname.new(options[:config_file]))
+            auto.run
+        end
+    end
+end
+