1

#!/usr/bin/python

     2

     3

"""

     4

    SSH authorized_keys command="..." wrapper for rsync.

     5

     6

    Testing goes something like:

     7

        sudo sh -c "PYTHONPATH=. rsync -e './scripts/pvlbackup-rsync-wrapper --debug -C --' -ax testing:lvm:asdf:test test/tmp"

     8

"""

     9

    10

from pvl.backup import __version__

    11

from pvl.backup.rsync import RSyncCommandFormatError

    12

from pvl.backup.invoke import InvokeError

    13

from pvl.backup import rsync

    14

    15

import optparse

    16

import shlex

    17

import os

    18

import logging

    19

    20

log = logging.getLogger()

    21

    22

# command-line options

    23

options = None

    24

    25

def parse_options (argv) :

    26

    """

    27

        Parse command-line arguments.

    28

    """

    29

    30

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

    31

    32

    parser = optparse.OptionParser(

    33

            prog        = argv[0],

    34

    35

            # module docstring

    36

            description = __doc__,

    37

            version     = __version__,

    38

    )

    39

    40

    # logging

    41

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

    42

    43

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

    44

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

    45

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

    46

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

    47

    48

    parser.add_option_group(general)

    49

    50

    #

    51

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

    52

            help="rsync command to execute")

    53

    54

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

    55

            help="use given command in `rsync -e %prog` format")

    56

    57

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

    58

            help="restrict to read/source mode")

    59

    60

    parser.add_option('-P', '--restrict-path', metavar='PATH', default=False,

    61

            help="restrict to given path prefix")

    62

    63

    # defaults

    64

    parser.set_defaults(

    65

        debug_for   = [],

    66

        loglevel    = logging.INFO,

    67

    )

    68

    69

    # parse

    70

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

    71

    72

    # configure

    73

    logging.basicConfig(

    74

        format  = '%(levelname)6s %(name)s : %(funcName)s : %(message)s',

    75

        level   = options.loglevel,

    76

    )

    77

    78

    # enable debugging for specific targets

    79

    for target in options.debug_for :

    80

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

    81

    82

    return options, args

    83

    84

def rsync_wrapper (command, restrict='lvm:') :

    85

    """

    86

        Wrap given rsync command.

    87

    88

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

    89

        pseudo-path with additional handling).

    90

    """

    91

    92

    try :

    93

        # parse the rsync command sent by the client

    94

        rsync_cmd, rsync_options, source_path, dest_path = rsync.parse_command(command, 

    95

                restrict_readonly   = options.readonly,

    96

            )

    97

    98

    except RSyncCommandFormatError, e:

    99

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

   100

        return 2

   101

   102

    # XXX: the real path is always given second..

   103

    path = dest_path

   104

   105

    try :

   106

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

   107

        source = rsync.parse_source(path,

   108

                restrict_path       = options.restrict_path,

   109

            )

   110

   111

    except RSyncCommandFormatError, e:

   112

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

   113

        return 2

   114

   115

    try :

   116

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

   117

        source.execute(rsync_options)

   118

   119

    except InvokeError, e:

   120

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

   121

        return e.exit

   122

   123

    # ok

   124

    return 0

   125

   126

def main (argv) :

   127

    global options

   128

   129

    # global options + args

   130

    options, args = parse_options(argv)

   131

   132

    # command required

   133

    if options.given_command :

   134

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

   135

        host = args.pop(0)

   136

        command_parts = args

   137

   138

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

   139

   140

    # args

   141

    elif args :

   142

        log.error("No arguments are handled")

   143

        return 2

   144

   145

    elif options.command:

   146

        # as given

   147

        command_parts = shlex.split(options.command)

   148

   149

    else :

   150

        log.error("SSH_ORIGINAL_COMMAND not given")

   151

        return 2

   152

   153

   154

    # run

   155

    try :

   156

        return rsync_wrapper(command_parts)

   157

   158

    except Exception, e:

   159

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

   160

        return 3

   161

   162

    # ok

   163

    return 0

   164

   165

if __name__ == '__main__' :

   166

    import sys

   167

   168

    sys.exit(main(sys.argv))

   169