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

    10

    11

import shlex

    12

import os.path

    13

    14

import logging

    15

    16

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

    17

    27

    28

class RSyncCommandFormatError (Exception) :

    29

    """

    30

        Improper rsync command

    31

    """

    32

    33

    pass

    34

    39

    40

    def _execute (self, options, path) :

    41

        """

    42

            Underlying rsync just reads from filesystem.

    43

        """

    47

    49

    """

    50

        Normal filesystem backup.

    51

    """

    52

    53

    def __init__ (self, path) :

    55

    56

        self.path = path

    57

    58

    def execute (self, options) :

    59

        return self._execute(options, self.path)

    60

    62

    """

    63

        Backup LVM LV by snapshotting + mounting it.

    64

    """

    65

    66

    def __init__ (self, volume) :

    68

    69

        self.volume = volume

    70

    71

    def execute (self, options) :

    72

        """

    73

            Snapshot, mount, execute

    74

        """

    75

    76

        # backup target from LVM command

    77

        lvm = self.volume.lvm

    78

        volume = self.volume

    79

    80

        # XXX: generate

    81

        path = '/mnt'

    82

    83

        # snapshot

    84

        log.info("Open snapshot...")

    85

    86

        # XXX: generate snapshot nametag to be unique?

    87

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

    88

            log.info("Snapshot opened: %s", snapshot.lvm_path)

    89

    90

            # mount

    91

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

    92

    93

            with mount(snapshot.dev_path, path) as mountpoint:

    94

                log.info("Mounted snapshot: %s", mountpoint)

    95

    96

                # rsync!

    97

                log.info("Running rsync: ...")

    98

    99

                # with trailing slash

   100

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

   101

   102

            # cleanup

   103

        # cleanup

   104

   105

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

   106

    """

   107

        Parse given rsync server command into bits. 

   108

   109

            command             - the command-string sent by rsync

   110

            restrict_server     - restrict to server-mode

   111

            restrict_readonly   - restrict to read/send-mode

   112

   113

        Returns:

   114

   115

            (cmd, options, source, dest)

   116

    """

   117

   118

    # split

   119

    parts = shlex.split(command)

   120

   121

    cmd = None

   122

    options = []

   123

    source = None

   124

    dest = None

   125

   126

    # parse

   127

    for part in parts :

   128

        if cmd is None :

   129

            cmd = part

   130

   131

        elif part.startswith('-') :

   132

            options.append(part)

   133

   134

        elif source is None :

   135

            source = part

   136

   137

        elif dest is None :

   138

            dest = part

   139

   140

    # options

   141

    have_server = ('--server' in options)

   142

    have_sender = ('--sender' in options)

   143

   144

    # verify

   145

    if not have_server :

   146

        raise RSyncCommandFormatError("Missing --server")

   147

   148

    if restrict_readonly and not have_sender :

   149

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

   150

   151

    # parse path

   152

    if have_sender :

   153

        # read

   154

        # XXX: which way does the dot go?

   155

        if source != '.' :

   156

            raise RSyncCommandFormatError("Invalid dest for sender")

   157

   158

        path = dest

   159

   160

    else :

   161

        # write

   162

        if source != '.' :

   163

            raise RSyncCommandFormatError("Invalid source for reciever")

   164

   165

        path = dest

   166

   167

    if not path :

   168

        raise RSyncCommandFormatError("Missing path")

   169

   170

    # ok

   171

    return cmd, options, source, dest

   172

   173

   174

def parse_source (path, restrict_path=False) :

   175

    """

   176

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

   177

    """

   178

   179

    # normalize

   180

    path = os.path.normpath(path)

   181

   182

    # verify path

   183

    if restrict_path :

   184

        if not path.startswith(restrict_path) :

   185

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

   186

   187

    if path.startswith('/') :

   188

        # direct filesystem path

   189

        # XXX: how to handle=

   190

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

   191

   193

   194

    elif path.startswith('lvm:') :

   195

        # LVM LV

   196

        try :

   197

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

   198

   199

        except ValueError, e:

   200

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

   201

   202

        # XXX: validate

   203

   204

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

   205

   206

        # open

   207

        lvm = LVM(vg)

   208

        volume = lvm.volume(lv)

   209

   211

   212

    else :

   213

        # invalid

   214

        raise RSyncCommandFormatError("Unrecognized backup path")

   215