1

#!/usr/bin/python

     2

     3

"""

     4

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

     8

"""

     9

    10

from pvl.backup.rsync import RSyncCommandFormatError

    11

from pvl.backup.invoke import InvokeError

    12

from pvl.backup import rsync

    13

    14

import optparse

    16

import os

    17

import logging

    18

    19

log = logging.getLogger()

    20

    21

# command-line options

    22

options = None

    23

    24

def parse_options (argv) :

    25

    """

    26

        Parse command-line arguments.

    27

    """

    28

    31

    parser = optparse.OptionParser(

    32

            prog        = argv[0],

    33

    34

            # module docstring

    35

            description = __doc__,

    36

    )

    37

    38

    # logging

    39

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

    40

    41

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

    42

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

    43

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

    44

    45

    parser.add_option_group(general)

    46

    47

    #

    48

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

    49

            help="rsync command to execute")

    50

    54

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

    55

            help="restrict to read/source mode")

    56

    57

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

    58

            help="restrict to given path prefix")

    59

    60

    # defaults

    61

    parser.set_defaults(

    62

        loglevel    = logging.WARNING,

    63

    )

    64

    65

    # parse

    66

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

    67

    68

    # configure

    69

    logging.basicConfig(

    70

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

    71

        level   = options.loglevel,

    72

    )

    73

    74

    return options, args

    75

    76

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

    77

    """

    78

        Wrap given rsync command.

    79

    80

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

    81

        pseudo-path with additional handling).

    82

    """

    83

    84

    try :

    85

        # parse the rsync command sent by the client

    86

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

    87

                restrict_readonly   = options.readonly,

    88

            )

    89

    90

    except RSyncCommandFormatError, e:

    91

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

    92

        return 2

    93

    94

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

    95

    path = dest_path

    96

    97

    try :

    98

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

    99

        source = rsync.parse_source(path,

   100

                restrict_path       = options.restrict_path,

   101

            )

   102

   103

    except RSyncCommandFormatError, e:

   104

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

   105

        return 2

   106

   107

    try :

   108

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

   109

        source.execute(rsync_options)

   110

   111

    except InvokeError, e:

   112

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

   113

        return e.exit

   114

   115

    # ok

   116

    return 0

   117

   118

def main (argv) :

   119

    global options

   120

   121

    # global options + args

   122

    options, args = parse_options(argv)

   123

   132

    # args

   134

        log.error("No arguments are handled")

   135

        return 2

   136

   142

        log.error("SSH_ORIGINAL_COMMAND not given")

   143

        return 2

   144

   147

    try :

   149

   150

    except Exception, e:

   151

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

   152

        return 3

   153

   154

    # ok

   155

    return 0

   156

   157

if __name__ == '__main__' :

   158

    import sys

   159

   160

    sys.exit(main(sys.argv))

   161