1

#!/usr/bin/python

     2

     3

"""

     4

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

     5

"""

     6

     7

from pvl.backup.rsync import RSyncCommandFormatError

     8

from pvl.backup.invoke import InvokeError

     9

from pvl.backup import rsync

    10

    11

import optparse

    12

import os

    13

import logging

    14

    15

log = logging.getLogger()

    16

    17

# command-line options

    18

options = None

    19

    20

def parse_options (argv) :

    21

    """

    22

        Parse command-line arguments.

    23

    """

    24

    25

    parser = optparse.OptionParser(

    26

            prog        = argv[0],

    27

    28

            # module docstring

    29

            description = __doc__,

    30

    )

    31

    32

    # logging

    33

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

    34

    35

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

    36

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

    37

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

    38

    39

    parser.add_option_group(general)

    40

    41

    #

    42

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

    43

            help="rsync command to execute")

    44

    45

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

    46

            help="restrict to read/source mode")

    47

    48

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

    49

            help="restrict to given path prefix")

    50

    51

    # defaults

    52

    parser.set_defaults(

    53

        loglevel    = logging.WARNING,

    54

    )

    55

    56

    # parse

    57

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

    58

    59

    # configure

    60

    logging.basicConfig(

    61

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

    62

        level   = options.loglevel,

    63

    )

    64

    65

    return options, args

    66

    67

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

    68

    """

    69

        Wrap given rsync command.

    70

    71

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

    72

        pseudo-path with additional handling).

    73

    """

    74

    75

    try :

    76

        # parse the rsync command sent by the client

    77

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

    78

                restrict_readonly   = options.readonly,

    79

            )

    80

    81

    except RSyncCommandFormatError, e:

    82

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

    83

        return 2

    84

    85

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

    86

    path = dest_path

    87

    88

    try :

    89

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

    90

        source = rsync.parse_source(path,

    91

                restrict_path       = options.restrict_path,

    92

            )

    93

    94

    except RSyncCommandFormatError, e:

    95

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

    96

        return 2

    97

    98

    try :

    99

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

   100

        source.execute(rsync_options)

   101

   102

    except InvokeError, e:

   103

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

   104

        return e.exit

   105

   106

    # ok

   107

    return 0

   108

   109

def main (argv) :

   110

    global options

   111

   112

    # global options + args

   113

    options, args = parse_options(argv)

   114

   115

    # args

   116

    if args :

   117

        log.error("No arguments are handled")

   118

        return 2

   119

   120

    # command required

   121

    if not options.command:

   122

        log.error("SSH_ORIGINAL_COMMAND not given")

   123

        return 2

   124

   125

    try :

   126

        # handle it

   127

        return rsync_wrapper(options.command)

   128

   129

    except Exception, e:

   130

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

   131

        return 3

   132

   133

    # ok

   134

    return 0

   135

   136

if __name__ == '__main__' :

   137

    import sys

   138

   139

    sys.exit(main(sys.argv))

   140