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

from pvl.backup import __version__

    15

from pvl.backup.rsync import RSyncCommandFormatError

    16

from pvl.backup.invoke import InvokeError

    17

from pvl.backup import rsync, lvm

    18

    19

import optparse

    20

import shlex

    21

import os

    22

import logging

    23

    24

log = logging.getLogger('main')

    25

    26

def parse_options (argv) :

    27

    """

    28

        Parse command-line arguments.

    29

    """

    30

    31

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

    32

    33

    parser = optparse.OptionParser(

    34

            prog        = argv[0],

    35

    36

            # module docstring

    37

            description = __doc__,

    38

            version     = __version__,

    39

    )

    40

    41

    # logging

    42

    general = optparse.OptionGroup(parser, "General Options")

    43

    44

    general.add_option('-q', '--quiet',      dest='loglevel', action='store_const', const=logging.WARNING, help="Less output")

    45

    general.add_option('-v', '--verbose',    dest='loglevel', action='store_const', const=logging.INFO,  help="More output")

    46

    general.add_option('-D', '--debug',      dest='loglevel', action='store_const', const=logging.DEBUG, help="Even more output")

    47

    general.add_option('--debug-for',        action='append', metavar='MODULE', help="Enable logging for the given logger/module name")

    48

    49

    parser.add_option_group(general)

    50

    51

    #

    52

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

    54

    55

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

    57

    58

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

    59

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

    60

    61

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

    63

    64

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

    66

    67

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

    68

            help="Allow remote rsync sources")

    69

    73

    # lvm options

    74

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

    75

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

    76

    77

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

    78

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

    79

    80

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

    81

            help="retry snapshot removal by given iterations")

    82

    83

    # defaults

    84

    parser.set_defaults(

    85

        debug_for   = [],

    86

        loglevel    = logging.INFO,

    87

    88

        restrict_path   = [],

    89

    )

    90

    91

    # parse

    92

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

    93

    94

    # configure

    95

    logging.basicConfig(

    96

        format  = argv[0] + ': %(levelname)6s %(name)s : %(funcName)s : %(message)s',

    97

        level   = options.loglevel,

    98

    )

    99

   100

    # enable debugging for specific targets

   101

    for target in options.debug_for :

   102

        logging.getLogger(target).setLevel(logging.DEBUG)

   103

   104

    return options, args

   105

   106

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

   107

    """

   108

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

   109

   110

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

   111

        pseudo-path with additional handling).

   112

   113

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

   114

    """

   115

   116

    # parse the rsync command sent by the client

   117

    try :

   118

        # path = the real source path

   119

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

   120

                restrict_server     = not local,

   121

                restrict_readonly   = options.readonly,

   122

            )

   123

   124

    except RSyncCommandFormatError, e:

   125

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

   126

        return 2

   127

   128

   129

    # parse source

   130

    try :

   131

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

   132

        source = rsync.parse_source(path,

   133

                restrict_paths      = options.restrict_path,

   134

                allow_remote        = options.allow_remote,

   135

                lvm_opts            = dict(

   137

                    size    = options.snapshot_size, 

   138

                    wait    = options.snapshot_wait,

   139

                    retry   = options.snapshot_retry,

   140

                ),

   141

            )

   142

   143

    except RSyncCommandFormatError, e:

   144

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

   145

        return 2

   146

   147

    # noop?

   148

    if options.noop :

   149

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

   150

        return 0

   151

   152

    # execute

   153

    try :

   154

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

   158

   159

    except InvokeError, e:

   160

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

   161

        return e.exit

   162

   163

    # ok

   164

    return 0

   165

   166

def main (argv) :

   167

    """

   168

        Run, with full argv

   169

    """

   170

   171

    # global options + args

   172

    options, args = parse_options(argv)

   173

   174

    # was a local command, not remote?

   175

    local = False

   176

   177

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

   178

    if options.given_command :

   179

        host = args.pop(0)

   180

        command_parts = args

   181

   182

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

   183

   184

    # from env/--command

   185

    elif options.command:

   186

        # as given

   187

        command_parts = shlex.split(options.command)

   188

   189

    # normal args

   190

    elif args :

   191

        command_parts = [argv[0]] + args

   192

        local = True

   193

   194

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

   195

   196

    else :

   197

        log.error("SSH_ORIGINAL_COMMAND not given")

   198

        return 2

   199

   200

    # run

   201

    try :

   202

        return rsync_wrapper(options, command_parts, local=local)

   203

   204

    except Exception, e:

   205

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

   206

        return 3

   207

   208

    # ok

   209

    return 0

   210

   211

if __name__ == '__main__' :

   212

    import sys

   213

   214

    sys.exit(main(sys.argv))

   215