1

#!/usr/bin/python

     2

     3

from pvl.backup.rsync import RSyncCommandFormatError

     4

from pvl.backup.invoke import InvokeError

     5

from pvl.backup import rsync

     6

     7

import optparse

     8

import os

     9

import logging

    10

    11

log = logging.getLogger()

    12

    13

# command-line options

    14

options = None

    15

    16

def parse_options (argv) :

    17

    """

    18

        Parse command-line arguments.

    19

    """

    20

    21

    22

    parser = optparse.OptionParser()

    23

    24

    # logging

    25

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

    26

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

    27

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

    28

    29

    # 

    30

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

    31

            help="rsync command to execute")

    32

    33

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

    34

            help="restrict to read operations")

    35

    36

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

    37

            help="restrict to given path")

    38

    39

    # defaults

    40

    parser.set_defaults(

    41

        loglevel    = logging.WARNING,

    42

    )

    43

    44

    # parse

    45

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

    46

    47

    # configure

    48

    logging.basicConfig(

    49

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

    50

        level   = options.loglevel,

    51

    )

    52

    53

    return options, args

    54

    55

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

    56

    """

    57

        Wrap given rsync command.

    58

    59

        Backups the LVM LV given in the rsync command.

    60

    """

    61

    62

    try :

    63

        # parse

    64

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

    65

                restrict_readonly   = options.readonly,

    66

            )

    67

    68

    except RSyncCommandFormatError, e:

    69

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

    70

        return 2

    71

    72

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

    73

    path = dest_path

    74

    75

    try :

    76

        # parse source

    77

        source = rsync.parse_source(path,

    78

                restrict_path       = options.restrict_path,

    79

            )

    80

    81

    except RSyncCommandFormatError, e:

    82

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

    83

        return 2

    84

    85

    try :

    86

        # run

    87

        source.execute(rsync_options)

    88

    89

    except InvokeError, e:

    90

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

    91

        return e.exit

    92

    93

    # ok

    94

    return 0

    95

    96

def main (argv) :

    97

    """

    98

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

    99

    """

   100

   101

    global options

   102

   103

    # global options + args

   104

    options, args = parse_options(argv)

   105

   106

    # args

   107

    if args :

   108

        log.error("No arguments are handled")

   109

        return 2

   110

   111

    if not options.command:

   112

        log.error("SSH_ORIGINAL_COMMAND not given")

   113

        return 2

   114

   115

    try :

   116

        # handle it

   117

        return rsync_wrapper(options.command)

   118

   119

    except Exception, e:

   120

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

   121

        return 3

   122

   123

    # ok

   124

    return 0

   125

   126

if __name__ == '__main__' :

   127

    import sys

   128

   129

    sys.exit(main(sys.argv))

   130