1

"""

     2

    rsync handling.

     3

     4

    Apologies for the 'RSync' nomenclature

     5

"""

     6

     7

from pvl.backup.lvm import LVM, LVMVolume, LVMSnapshot

     8

from pvl.backup.mount import mount

     9

from pvl.backup import invoke

    10

    11

import os.path

    12

    13

import logging

    14

    15

log = logging.getLogger('pvl.backup.rsync')

    16

    17

# Path to rsync binary

    18

RSYNC = '/usr/bin/rsync'

    19

    20

def rsync (source, dest, **opts) :

    21

    """

    22

        Run rsync.

    23

    """

    24

    25

    invoke.command(RSYNC, source, dest, **opts)

    26

    27

class RSyncCommandFormatError (Exception) :

    28

    """

    29

        Improper rsync command

    30

    """

    31

    32

    pass

    33

    34

class RSyncServer (object) :

    35

    """

    36

        rsync server-mode execution.

    37

    """

    38

    39

    def _execute (self, options, path) :

    40

        """

    41

            Underlying rsync just reads from filesystem.

    42

        """

    43

    44

        # invoke directly, no option-handling, nor stdin/out redirection

    45

        invoke.invoke(RSYNC, options + ['.', path], data=False)

    46

    47

class RSyncFSServer (RSyncServer) :

    48

    """

    49

        Normal filesystem backup.

    50

    """

    51

    52

    def __init__ (self, path) :

    53

        RSyncServer.__init__(self)

    54

    55

        self.path = path

    56

    57

    def execute (self, options) :

    58

        return self._execute(options, self.path)

    59

    60

class RSyncLVMServer (RSyncServer) :

    61

    """

    62

        Backup LVM LV by snapshotting + mounting it.

    63

    """

    64

    65

    def __init__ (self, volume) :

    66

        RSyncServer.__init__(self)

    67

    68

        self.volume = volume

    69

    70

    def execute (self, options) :

    71

        """

    72

            Snapshot, mount, execute

    73

        """

    74

    75

        # backup target from LVM command

    76

        lvm = self.volume.lvm

    77

        volume = self.volume

    78

    79

        # snapshot

    81

    82

        # XXX: generate snapshot nametag to be unique?

    83

        with lvm.snapshot(volume, tag='backup') as snapshot:

    84

            # mount

    85

            log.info("Mounting snapshot: %s", snapshot)

    86

    87

            with mount(snapshot.dev_path, name_hint=('lvm_' + snapshot.name + '_'), readonly=True) as mountpoint:

    88

                # rsync!

    90

    91

                # with trailing slash

    92

                return self._execute(options, mountpoint.path + '/')

    93

    94

            # cleanup

    95

        # cleanup

    96

    97

def parse_command (command_parts, restrict_server=True, restrict_readonly=True) :

    98

    """

    99

        Parse given rsync server command into bits. 

   100

   101

            command_parts       - the command-list sent by rsync

   102

            restrict_server     - restrict to server-mode

   103

            restrict_readonly   - restrict to read/send-mode

   104

   105

        Returns:

   106

   107

            (cmd, options, source, dest)

   108

    """

   109

   110

    cmd = None

   111

    options = []

   112

    source = None

   113

    dest = None

   114

   115

    # parse

   116

    for part in command_parts :

   117

        if cmd is None :

   118

            cmd = part

   119

   120

        elif part.startswith('-') :

   121

            options.append(part)

   122

   123

        elif source is None :

   124

            source = part

   125

   126

        elif dest is None :

   127

            dest = part

   128

   129

    # options

   130

    have_server = ('--server' in options)

   131

    have_sender = ('--sender' in options)

   132

   133

    # verify

   134

    if not have_server :

   135

        raise RSyncCommandFormatError("Missing --server")

   136

   137

    if restrict_readonly and not have_sender :

   138

        raise RSyncCommandFormatError("Missing --sender for readonly")

   139

   140

    # parse path

   141

    if have_sender :

   142

        # read

   143

        # XXX: which way does the dot go?

   144

        if source != '.' :

   145

            raise RSyncCommandFormatError("Invalid dest for sender")

   146

   147

        path = dest

   148

   149

    else :

   150

        # write

   151

        if source != '.' :

   152

            raise RSyncCommandFormatError("Invalid source for reciever")

   153

   154

        path = dest

   155

   156

    if not path :

   157

        raise RSyncCommandFormatError("Missing path")

   158

   159

    # ok

   160

    return cmd, options, source, dest

   161

   162

   163

def parse_source (path, restrict_path=False) :

   164

    """

   165

        Figure out source to rsync from, based on pseudo-path given in rsync command.

   166

    """

   167

   168

    # normalize

   169

    path = os.path.normpath(path)

   170

   171

    # verify path

   172

    if restrict_path :

   173

        if not path.startswith(restrict_path) :

   174

            raise RSyncCommandFormatError("Restricted path ({restrict})".format(restrict=restrict_path))

   175

   176

    if path.startswith('/') :

   177

        # direct filesystem path

   178

        # XXX: how to handle=

   179

        log.info("filesystem: %s", path)

   180

   181

        return RSyncFSServer(path)

   182

   183

    elif path.startswith('lvm:') :

   184

        # LVM LV

   185

        try :

   186

            lvm, vg, lv = path.split(':')

   187

   188

        except ValueError, e:

   189

            raise RSyncCommandFormatError("Invalid lvm pseudo-path: {error}".format(error=e))

   190

   191

        # XXX: validate

   192

   193

        log.info("LVM: %s/%s", vg, lv)

   194

   195

        # open

   196

        lvm = LVM(vg)

   197

        volume = lvm.volume(lv)

   198

   199

        return RSyncLVMServer(volume)

   200

   201

    else :

   202

        # invalid

   203

        raise RSyncCommandFormatError("Unrecognized backup path")

   204