class Snapsync::LocalTarget

Attributes

cleanup[R]

The cleanup object

dir[R]

This target's directory

sync_policy[R]

The target sync policy

uuid[R]

The target's UUID

@return [String]

Public Class Methods

new(dir, create_if_needed: true) click to toggle source
# File lib/snapsync/local_target.rb, line 41
def initialize(dir, create_if_needed: true)
    if !dir.directory?
        raise ArgumentError, "#{dir} does not exist"
    end
    @dir = dir

    begin
        read_config
    rescue NoUUIDError
        if !create_if_needed
            raise
        end
        @uuid = SecureRandom.uuid
        @sync_policy = DefaultSyncPolicy.new
        @cleanup = nil
        @enabled = true
        @autoclean = true
    end
    write_config
end
parse_policy(type, options) click to toggle source

Parse a policy specification as provided on the command line or saved in the config file into sync and cleanup policy objects

@param [String] type the policy type, either default, timeline or last @param [Array<String>] options to be passed to the from_config method

on the underlying policy classes

@return [(filter_snapshots,#filter_snapshots)] the sync policy

and the cleanup policy. The cleanup policy might be nil

@raise [InvalidConfiguration] if the policy type is unknown @see DefaultSyncPolicy TimelineSyncPolicy SyncLastPolicy

# File lib/snapsync/local_target.rb, line 135
def self.parse_policy(type, options)
    case type
    when 'default'
        sync_policy = DefaultSyncPolicy
        cleanup     = nil
    when 'timeline'
        sync_policy = TimelineSyncPolicy
        cleanup     = TimelineSyncPolicy
    when 'last'
        sync_policy = SyncLastPolicy
        cleanup     = SyncLastPolicy
    else
        raise InvalidConfiguration, "synchronization policy '#{type}' does not exist"
    end
    sync_policy = sync_policy.from_config(options)
    cleanup =
        if cleanup
            Cleanup.new(cleanup.from_config(options))
        end
    return sync_policy, cleanup
end
valid_policy?(type, options) click to toggle source

Verifies that the given policy type and options are valid

# File lib/snapsync/local_target.rb, line 158
def self.valid_policy?(type, options)
    parse_policy(type, options)
    true
rescue InvalidConfiguration
    false
end

Public Instance Methods

autoclean?() click to toggle source

Whether the target should be autocleaned on synchronization

Defaults to true

# File lib/snapsync/local_target.rb, line 31
def autoclean?; !!@autoclean end
change_policy(type, options) click to toggle source
# File lib/snapsync/local_target.rb, line 165
def change_policy(type, options)
    @sync_policy, @cleanup =
        self.class.parse_policy(type, options)
end
config_path() click to toggle source

Path to the target's configuration file

@return [Pathname]

# File lib/snapsync/local_target.rb, line 120
def config_path
    dir + "snapsync.config"
end
delete(s, dry_run: false) click to toggle source
# File lib/snapsync/local_target.rb, line 170
def delete(s, dry_run: false)
    Snapsync.info "Removing snapshot #{s.num} #{s.date.to_time} at #{s.subvolume_dir}"
    return if dry_run

    begin
        Btrfs.run("subvolume", "delete", '--commit-each', s.subvolume_dir.to_s)
    rescue Btrfs::Error
        Snapsync.warn "failed to remove snapshot at #{s.subvolume_dir}, keeping the rest of the snapshot"
        return
    end

    Snapsync.info "Flushing data to disk"
    begin
        Btrfs.run("subvolume", "sync", self.dir.to_s)
    rescue Btrfs::Error
    end

    s.snapshot_dir.rmtree
end
description() click to toggle source
# File lib/snapsync/local_target.rb, line 37
def description
    "local:#{dir}"
end
disable() click to toggle source

Disable this target, i.e. remove it from the auto synchronization and cleanup commands

# File lib/snapsync/local_target.rb, line 26
def disable; @enabled = false; self end
each_snapshot(&block) click to toggle source
# File lib/snapsync/local_target.rb, line 65
def each_snapshot(&block)
    Snapshot.each(dir, &block)
end
each_snapshot_raw(&block) click to toggle source
# File lib/snapsync/local_target.rb, line 62
def each_snapshot_raw(&block)
    Snapshot.each_snapshot_raw(dir, &block)
end
enable() click to toggle source

Enable this target, i.e. add it to the auto synchronization and cleanup commands

# File lib/snapsync/local_target.rb, line 22
def enable; @enabled = true; self end
enabled?() click to toggle source

Whether this target is enabled or not

# File lib/snapsync/local_target.rb, line 18
def enabled?; @enabled end
parse_config(config) click to toggle source
# File lib/snapsync/local_target.rb, line 99
def parse_config(config)
    uuid = config['uuid']
    if uuid.length != 36
        raise InvalidUUIDError, "uuid in #{uuid_path} was expected to be 36 characters long, but is #{uuid.length}"
    end
    @uuid = uuid

    @enabled = config.fetch('enabled', true)
    @autoclean = config.fetch('autoclean', true)

    if policy_config = config['policy']
        change_policy(policy_config['type'], policy_config['options'] || Array.new)
    else
        @sync_policy = DefaultSyncPolicy.new
        @cleanup = nil
    end
end
read_config() click to toggle source
# File lib/snapsync/local_target.rb, line 87
def read_config
    begin
        if !(raw_config = YAML.load(config_path.read))
            raise NoUUIDError, "empty configuration file found in #{config_path}"
        end

    rescue Errno::ENOENT => e
        raise NoUUIDError, e.message, e.backtrace
    end
    parse_config(raw_config)
end
write_config() click to toggle source
# File lib/snapsync/local_target.rb, line 69
def write_config
    config = Hash['uuid' => uuid, 'policy' => Hash.new]
    config['policy']['type'] =
        case sync_policy
        when TimelineSyncPolicy then 'timeline'
        when SyncLastPolicy then 'last'
        when DefaultSyncPolicy then 'default'
        end
    config['policy']['options'] =
        sync_policy.to_config
    config['enabled'] = enabled?
    config['autoclean'] = autoclean?

    config_path.open('w') do |io|
        YAML.dump(config, io)
    end
end