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

RSYNC = '/usr/bin/rsync'

    18

    19

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

    20

    """

    21

        Run rsync.

    22

    23

        Raises RsyncError if rsync fails.

    24

    25

        XXX: never used anywhere?

    26

    """

    27

    28

    try :

    29

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

    30

    31

    except invoke.InvokeError as ex :

    32

        raise RsyncError(ex)

    33

    34

class RSyncCommandFormatError (Exception) :

    35

    """

    36

        Improper rsync command/source.

    37

    """

    38

    39

    pass

    40

    41

class RsyncError (Exception) :

    42

    """

    43

        Rsync command invocation failed.

    44

    """

    45

    46

    pass

    47

    48

    49

class RSyncServer (object) :

    50

    """

    51

        rsync server-mode execution.

    52

    """

    53

    55

        """

    56

            Underlying rsync just reads from filesystem.

    57

    58

                options     - list of rsync options

    59

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

    60

                path        - the real path to replace None with

    63

        """

    64

    65

        # one of this will be None

    66

        src, dst = srcdst

    67

    68

        # replace None -> path

    69

        src = src or path

    70

        dst = dst or path

    71

    72

        log.info("rsync %s %s %s", ' '.join(options), src, dst)

    74

        try :

    77

    78

        except invoke.InvokeError as ex :

    79

            raise RsyncError(ex)

    80

    81

class RSyncFSServer (RSyncServer) :

    82

    """

    83

        Normal filesystem backup.

    84

    """

    85

    86

    def __init__ (self, path) :

    87

        RSyncServer.__init__(self)

    88

    89

        self.path = path

    90

    92

        """

    93

                options     - list of rsync options

    94

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

    95

        """

    96

    98

    99

    def __str__ (self) :

   100

        return self.path

   101

   102

class RSyncRemoteServer (RSyncServer) :

   103

    """

   104

        Remote filesystem backup.

   105

    """

   106

   107

    def __init__ (self, host, path) :

   108

        """

   109

            host        - remote SSH host

   110

            path        - remote path

   111

        """

   112

   113

        RSyncServer.__init__(self)

   114

   115

        # glue

   116

        self.path = host + ':' + path

   117

   119

        """

   120

                options     - list of rsync options

   121

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

   122

        """

   123

   125

   126

    def __str__ (self) :

   127

        return self.path

   128

   129

class RSyncLVMServer (RSyncServer) :

   130

    """

   131

        Backup LVM LV by snapshotting + mounting it.

   132

    """

   133

   135

        """

   136

            **opts      - options for LVM.snapshot

   137

        """

   138

   139

        RSyncServer.__init__(self)

   144

   146

        self.snapshot_opts = opts

   147

   149

        """

   150

            Snapshot, mount, execute

   151

   152

                options     - list of rsync options

   153

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

   154

        """

   155

   156

        # backup target from LVM command

   157

        lvm = self.volume.lvm

   158

        volume = self.volume

   159

   160

        # snapshot

   161

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

   162

   163

        # XXX: generate snapshot nametag to be unique?

   164

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

   165

            # mount

   166

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

   167

   169

                # rsync!

   170

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

   171

   172

                # with trailing slash

   174

   175

            # cleanup

   176

        # cleanup

   177

   178

    def __str__ (self) :

   179

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

   180

   181

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

   182

    """

   183

        Parse given rsync server command into bits. 

   184

   185

            command_parts       - the command-list sent by rsync

   186

            restrict_server     - restrict to server-mode

   187

            restrict_readonly   - restrict to read/send-mode

   188

   189

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

   190

   191

        Returns:

   192

   193

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

   194

   195

            options         -> list of -options

   196

            path            -> real source path

   197

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

   198

   199

    """

   200

   201

    cmd = None

   202

    options = []

   203

    source = None

   204

    dest = None

   205

   206

    # parse

   207

    for part in command_parts :

   208

        if cmd is None :

   209

            cmd = part

   210

   211

        elif part.startswith('-') :

   212

            options.append(part)

   213

   214

        elif source is None :

   215

            source = part

   216

   217

        elif dest is None :

   218

            dest = part

   219

   220

    log.debug("%s: %s", cmd, options)

   221

   222

    # options

   223

    have_server = ('--server' in options)

   224

    have_sender = ('--sender' in options)

   225

   226

    # verify

   227

    if restrict_server and not have_server :

   228

        raise RSyncCommandFormatError("Missing --server")

   229

   230

    if restrict_readonly and not have_sender :

   231

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

   232

   233

    if not source :

   234

        raise RSyncCommandFormatError("Missing source path")

   235

   236

    if not dest:

   237

        raise RSyncCommandFormatError("Missing dest path")

   238

   239

   240

    # parse real source

   241

    if have_sender :

   242

        # read; first arg will always be .

   243

        if source != '.' :

   244

            raise RSyncCommandFormatError("Invalid dest for sender")

   245

   246

        path = dest

   247

        dest = None

   248

   249

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

   250

   251

    elif have_server :

   252

        # write

   253

        if source != '.' :

   254

            raise RSyncCommandFormatError("Invalid source for reciever")

   255

   256

        path = dest

   257

        dest = None

   258

   259

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

   260

   261

    else :

   262

        # local src -> dst

   263

        path = source

   264

        source = None

   265

   266

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

   267

   268

    # ok

   269

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

   270

   271

def parse_source (path, restrict_paths=None, allow_remote=True, lvm_opts={}) :

   272

    """

   273

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

   274

   275

            restrict_paths  - raise RsyncCommandFormatError if source path is not under any of the given sources.

   276

            allow_remote    - allow remote backups?

   277

            lvm_opts        - dict of **opts for RSyncLVMServer

   278

    """

   279

   280

    endslash = path.endswith('/')

   281

   282

    # normalize

   283

    path = os.path.normpath(path)

   284

   285

    if endslash and not path.endswith('/') :

   286

        # add it back in

   287

        # happens for 'foo:/' and such

   288

        path += '/'

   289

   290

    # verify path

   291

    if restrict_paths :

   292

        for restrict_path in restrict_paths :

   293

            if path.startswith(restrict_path) :

   294

                # ok

   295

                break

   296

        else :

   297

            # fail

   298

            raise RSyncCommandFormatError("Restricted path".format())

   299

   300

    if path.startswith('/') :

   301

        # direct filesystem path

   302

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

   303

   304

        return RSyncFSServer(path)

   305

   306

    elif path.startswith('lvm:') :

   307

        _, lvm = path.split(':', 1)

   308

   309

        # LVM LV

   310

        try :

   311

            if ':' in lvm :

   312

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

   313

   314

                log.warn("old lvm: syntax: lvm:%s; use: lvm:%s/%s", path, vg, lv)

   315

   316

            elif '/' in lvm:

   317

                vg, lv = lvm.split('/', 1)

   318

   319

            else :

   320

                raise RSyncCommandFormatError("Invalid lvm pseudo-path: {lvm}: unrecognized vg/lv separator".format(lvm=lvm))

   321

   322

        except ValueError, e:

   323

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

   324

   325

        # XXX: validate?

   326

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

   327

   328

        # open

   330

   331

    elif ':' in path and allow_remote :

   332

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

   333

   334

        # remote host

   335

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

   336

   337

        return RSyncRemoteServer(host, path)

   338

   339

    else :

   340

        # invalid

   341

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

   342