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, srcdst, path) :

    40

        """

    41

            Underlying rsync just reads from filesystem.

    42

    43

                options     - list of rsync options

    44

                srcdst      - the (source, dest) pair with None placeholder, as returned by parse_command

    45

                path        - the real path to replace None with

    46

        """

    47

    48

        # one of this will be None

    49

        src, dst = srcdst

    50

    51

        # replace None -> path

    52

        src = src or path

    53

        dst = dst or path

    54

    55

        log.debug("%r -> %r", src, dst)

    56

    57

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

    58

        invoke.invoke(RSYNC, options + [ src, dst ], data=False)

    59

    60

class RSyncFSServer (RSyncServer) :

    61

    """

    62

        Normal filesystem backup.

    63

    """

    64

    65

    def __init__ (self, path) :

    66

        RSyncServer.__init__(self)

    67

    68

        self.path = path

    69

    70

    def execute (self, options, srcdst) :

    71

        """

    72

                options     - list of rsync options

    73

                srcdst      - the (source, dest) pair with None placeholder, as returned by parse_command

    74

        """

    75

    76

        return self._execute(options, srcdst, self.path)

    77

    78

    def __str__ (self) :

    79

        return self.path

    80

    81

class RSyncRemoteServer (RSyncServer) :

    82

    """

    83

        Remote filesystem backup.

    84

    """

    85

    86

    def __init__ (self, host, path) :

    87

        """

    88

            host        - remote SSH host

    89

            path        - remote path

    90

        """

    91

    92

        RSyncServer.__init__(self)

    93

    94

        # glue

    95

        self.path = path + ':' + path

    96

    97

    def execute (self, options, srcdst) :

    98

        """

    99

                options     - list of rsync options

   100

                srcdst      - the (source, dest) pair with None placeholder, as returned by parse_command

   101

        """

   102

   103

        return self._execute(options, srcdst, self.path)

   104

   105

    def __str__ (self) :

   106

        return self.path

   107

   108

class RSyncLVMServer (RSyncServer) :

   109

    """

   110

        Backup LVM LV by snapshotting + mounting it.

   111

    """

   112

   113

    def __init__ (self, volume, **opts) :

   114

        """

   115

            volume      - the LVMVolume to snapshot

   116

            **opts      - options for LVM.snapshot

   117

        """

   118

   119

        RSyncServer.__init__(self)

   120

   121

        self.volume = volume

   122

        self.snapshot_opts = opts

   123

   124

    def execute (self, options, srcdst) :

   125

        """

   126

            Snapshot, mount, execute

   127

   128

                options     - list of rsync options

   129

                srcdst      - the (source, dest) pair with None placeholder, as returned by parse_command

   130

        """

   131

   132

        # backup target from LVM command

   133

        lvm = self.volume.lvm

   134

        volume = self.volume

   135

   136

        # snapshot

   137

        log.info("Open snapshot: %s", volume)

   138

   139

        # XXX: generate snapshot nametag to be unique?

   140

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

   141

            # mount

   142

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

   143

   144

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

   145

                # rsync!

   146

                log.info("Running rsync: %s", mountpoint)

   147

   148

                # with trailing slash

   149

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

   150

   151

            # cleanup

   152

        # cleanup

   153

   154

    def __str__ (self) :

   155

        return 'lvm:{volume}'.format(volume=self.volume)

   156

   157

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

   158

    """

   159

        Parse given rsync server command into bits. 

   160

   161

            command_parts       - the command-list sent by rsync

   162

            restrict_server     - restrict to server-mode

   163

            restrict_readonly   - restrict to read/send-mode

   164

   165

        In server mode, source will always be '.', and dest the source/dest.

   166

   167

        Returns:

   168

   169

            (cmd, options, path, (source, dest))

   170

   171

            path            -> the real source path

   172

            (source, dest)  -> combination of None for path, and the real source/dest

   173

   174

    """

   175

   176

    cmd = None

   177

    options = []

   178

    source = None

   179

    dest = None

   180

   181

    # parse

   182

    for part in command_parts :

   183

        if cmd is None :

   184

            cmd = part

   185

   186

        elif part.startswith('-') :

   187

            options.append(part)

   188

   189

        elif source is None :

   190

            source = part

   191

   192

        elif dest is None :

   193

            dest = part

   194

   195

    # options

   196

    have_server = ('--server' in options)

   197

    have_sender = ('--sender' in options)

   198

   199

    # verify

   200

    if restrict_server and not have_server :

   201

        raise RSyncCommandFormatError("Missing --server")

   202

   203

    if restrict_readonly and not have_sender :

   204

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

   205

   206

    if not source :

   207

        raise RSyncCommandFormatError("Missing source path")

   208

   209

    if not dest:

   210

        raise RSyncCommandFormatError("Missing dest path")

   211

   212

   213

    # parse real source

   214

    if have_sender :

   215

        # read; first arg will always be .

   216

        if source != '.' :

   217

            raise RSyncCommandFormatError("Invalid dest for sender")

   218

   219

        path = dest

   220

        dest = None

   221

   222

        log.debug("using server/sender source path: %s", path)

   223

   224

    elif have_server :

   225

        # write

   226

        if source != '.' :

   227

            raise RSyncCommandFormatError("Invalid source for reciever")

   228

   229

        path = dest

   230

        dest = None

   231

   232

        log.debug("using server dest path: %s", path)

   233

   234

    else :

   235

        # local src -> dst

   236

        path = source

   237

        source = None

   238

   239

        log.debug("using local src path: %s -> %s", path, dest)

   240

   241

    # ok

   242

    return cmd, options, path, (source, dest)

   243

   244

def parse_source (path, restrict_path=False, lvm_opts={}) :

   245

    """

   246

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

   247

   248

            lvm_opts        - dict of **opts for RSyncLVMServer

   249

    """

   250

   251

    # normalize

   252

    path = os.path.normpath(path)

   253

   254

    # verify path

   255

    if restrict_path :

   256

        if not path.startswith(restrict_path) :

   257

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

   258

   259

    if path.startswith('/') :

   260

        # direct filesystem path

   261

        # XXX: how to handle=

   262

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

   263

   264

        return RSyncFSServer(path)

   265

   266

    elif path.startswith('lvm:') :

   269

        # LVM LV

   270

        try :

   281

   282

        except ValueError, e:

   284

   285

        # XXX: validate?

   286

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

   287

   288

        # open

   289

        lvm = LVM(vg)

   290

        volume = lvm.volume(lv)

   291

   292

        return RSyncLVMServer(volume, **lvm_opts)

   293

   294

    elif ':' in path :

   295

        host, path = path.split(':', 1)

   296

   297

        # remote host

   298

        log.info("remote: %s:%s", host, path)

   299

   300

        return RSyncRemoteServer(host, path)

   301

   302

    else :

   303

        # invalid

   304

        raise RSyncCommandFormatError("Unrecognized backup path: {path}".format(path=path))

   305