1

#!/usr/bin/python

     2

     3

"""

     4

    SSH authorized_keys command="..." wrapper for rsync sender/server, with additional support for LVM snapshots.

     5

     6

    Testing:

     7

        PYTHONPATH=. ./bin/pvl.backup-rsync -- -rlptx /etc/apache2 test/foo

     8

     9

        sudo PYTHONPATH=. ./bin/pvl.backup-rsync --command 'rsync --server --sender -ax . lvm:asdf:test' -vD

    10

    11

        sudo sh -c "PYTHONPATH=. rsync -e './bin/pvl.backup-rsync --debug -C --' -ax testing:lvm:asdf:test test/tmp"

    12

"""

    13

    14

import pvl.args

    15

    16

from pvl.backup import __version__

    17

from pvl.backup.rsync import RSyncCommandFormatError

    18

from pvl.backup.invoke import InvokeError

    19

from pvl.backup import rsync, lvm

    20

    21

import optparse

    22

import shlex

    23

import os

    24

import logging

    25

    26

log = logging.getLogger('main')

    27

    28

def parse_options (argv) :

    29

    """

    30

        Parse command-line arguments.

    31

    """

    32

    33

#    import sys; sys.stderr.write("%s\n" % (argv, ))

    34

    35

    parser = optparse.OptionParser(

    36

            prog        = argv[0],

    37

    38

            # module docstring

    39

            description = __doc__,

    40

            version     = __version__,

    41

    )

    42

    44

    45

    #

    46

    parser.add_option('-c', '--command',    metavar='CMD', default=os.environ.get('SSH_ORIGINAL_COMMAND'),

    47

            help="Rsync command to execute")

    48

    49

    parser.add_option('-C', '--given-command', action='store_true', default=False,

    50

            help="Use given command in `rsync -e '%prog -C --' ...` format")

    51

    52

    parser.add_option('-n', '--noop', action='store_true', default=False,

    53

            help="Parse command, but do not execute")

    54

    55

    parser.add_option('-R', '--readonly',   action='store_true', default=False,

    56

            help="Restrict to read/source mode")

    57

    58

    parser.add_option('-P', '--restrict-path', metavar='PATH', action='append',

    59

            help="Restrict to given path prefix")

    60

    61

    parser.add_option('--allow-remote',     action='store_true', default=False,

    62

            help="Allow remote rsync sources")

    63

    64

    parser.add_option('--sudo',             action='store_true',

    65

            help="Execute rsync under sudo")

    66

    67

    # lvm options

    68

    parser.add_option('-L', '--snapshot-size', metavar='SIZE', default=lvm.LVM_SNAPSHOT_SIZE,

    69

            help="create snapshot with given LV size (used to store writes during backup)")

    70

    71

    parser.add_option('--snapshot-wait', metavar='SECONDS', default=lvm.LVM_SNAPSHOT_WAIT, type='float',

    72

            help="wait for snapshot to settle after unmounting")

    73

    74

    parser.add_option('--snapshot-retry', metavar='RETRY', default=lvm.LVM_SNAPSHOT_RETRY, type='int',

    75

            help="retry snapshot removal by given iterations")

    76

    77

    # defaults

    78

    parser.set_defaults(

    79

        restrict_path   = [],

    80

    )

    81

    82

    # parse

    83

    options, args = parser.parse_args(argv[1:])

    84

    85

    # general logging/etc

    86

    pvl.args.apply(options)

    87

    88

    return options, args

    89

    90

def rsync_wrapper (options, command, local=False) :

    91

    """

    92

        Wrap given rsync command, parsing options/path, determining source, and running rsync in the source.

    93

    94

        Parses the command, the source path, and then executes rsync within the source path (which may be a special

    95

        pseudo-path with additional handling).

    96

    97

            local       - the given command is a full local command, not an --server mode operation

    98

    """

    99

   100

    # parse the rsync command sent by the client

   101

    try :

   102

        # path = the real source path

   103

        rsync_cmd, rsync_options, path, srcdst = rsync.parse_command(command, 

   104

                restrict_server     = not local,

   105

                restrict_readonly   = options.readonly,

   106

            )

   107

   108

    except RSyncCommandFormatError, e:

   109

        log.error("invalid rsync command: %r: %s", command, e)

   110

        return 2

   111

   112

   113

    # parse source

   114

    try :

   115

        # parse the source path as given by the client, may be a real path or pseudo-path

   116

        source = rsync.parse_source(path,

   117

                restrict_paths      = options.restrict_path,

   118

                allow_remote        = options.allow_remote,

   119

                lvm_opts            = dict(

   120

                    sudo    = options.sudo,

   121

                    size    = options.snapshot_size, 

   122

                    wait    = options.snapshot_wait,

   123

                    retry   = options.snapshot_retry,

   124

                ),

   125

            )

   126

   127

    except RSyncCommandFormatError, e:

   128

        log.error("invalid rsync source: %r: %s", path, e)

   129

        return 2

   130

   131

    # noop?

   132

    if options.noop :

   133

        log.info("noop: %r -> %r: execute(%r, %r)", path, source, rsync_options, srcdst)

   134

        return 0

   135

   136

    # execute

   137

    try :

   138

        # run rsync within the source (may perform additional stuff like snapshot...)

   139

        source.execute(rsync_options, srcdst,

   140

                sudo        = options.sudo,

   141

        )

   142

   143

    except InvokeError, e:

   144

        log.error("%s failed: %d", e.cmd, e.exit)

   145

        return e.exit

   146

   147

    # ok

   148

    return 0

   149

   150

def main (argv) :

   151

    """

   152

        Run, with full argv

   153

    """

   154

   155

    # global options + args

   156

    options, args = parse_options(argv)

   157

   158

    # was a local command, not remote?

   159

    local = False

   160

   161

    # from args (as given by `rsync -e pvlbackup-rsync-wrapper`) -> 'pvlbackup-rsync-wrapper <host> (<command> ...)'

   162

    if options.given_command :

   163

        host = args.pop(0)

   164

        command_parts = args

   165

   166

        log.debug("host=%r, using command from args: %r", host, command_parts)

   167

   168

    # from env/--command

   169

    elif options.command:

   170

        # as given

   171

        command_parts = shlex.split(options.command)

   172

   173

    # normal args

   174

    elif args :

   175

        command_parts = [argv[0]] + args

   176

        local = True

   177

   178

        log.debug("using given rsync args: %r", command_parts)

   179

   180

    else :

   181

        log.error("SSH_ORIGINAL_COMMAND not given")

   182

        return 2

   183

   184

    # run

   185

    try :

   186

        return rsync_wrapper(options, command_parts, local=local)

   187

   188

    except Exception, e:

   189

        log.error("Internal error:", exc_info=e)

   190

        return 3

   191

   192

    # ok

   193

    return 0

   194

   195

if __name__ == '__main__' :

   196

    import sys

   197

   198

    sys.exit(main(sys.argv))

   199