1

#!/usr/bin/python

     2

     3

"""

     4

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

     5

     6

    Testing goes something like:

     8

    10

"""

    11

    12

from pvl.backup import __version__

    13

from pvl.backup.rsync import RSyncCommandFormatError

    14

from pvl.backup.invoke import InvokeError

    15

from pvl.backup import rsync, lvm

    16

    17

import optparse

    18

import shlex

    19

import os

    20

import logging

    21

    23

    24

def parse_options (argv) :

    25

    """

    26

        Parse command-line arguments.

    27

    """

    28

    29

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

    30

    31

    parser = optparse.OptionParser(

    32

            prog        = argv[0],

    33

    34

            # module docstring

    35

            description = __doc__,

    36

            version     = __version__,

    37

    )

    38

    39

    # logging

    40

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

    41

    42

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

    43

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

    44

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

    45

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

    46

    47

    parser.add_option_group(general)

    48

    49

    #

    50

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

    51

            help="rsync command to execute")

    52

    53

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

    54

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

    55

    56

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

    57

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

    58

    59

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

    60

            help="restrict to read/source mode")

    61

    62

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

    63

            help="restrict to given path prefix")

    64

    65

    # lvm options

    66

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

    67

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

    68

    69

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

    70

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

    71

    75

    # defaults

    76

    parser.set_defaults(

    77

        debug_for   = [],

    78

        loglevel    = logging.INFO,

    79

    )

    80

    81

    # parse

    82

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

    83

    84

    # configure

    85

    logging.basicConfig(

    87

        level   = options.loglevel,

    88

    )

    89

    90

    # enable debugging for specific targets

    91

    for target in options.debug_for :

    92

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

    93

    94

    return options, args

    95

    96

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

    97

    """

    98

        Wrap given rsync command.

    99

   100

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

   101

        pseudo-path with additional handling).

   102

   103

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

   104

    """

   105

   106

    # parse the rsync command sent by the client

   107

    try :

   108

        # path = the real source path

   109

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

   110

                restrict_server     = not local,

   111

                restrict_readonly   = options.readonly,

   112

            )

   113

   114

    except RSyncCommandFormatError, e:

   115

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

   116

        return 2

   117

   118

   119

    # parse source

   120

    try :

   121

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

   122

        source = rsync.parse_source(path,

   123

                restrict_path       = options.restrict_path,

   125

            )

   126

   127

    except RSyncCommandFormatError, e:

   128

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

   129

        return 2

   130

   131

    # noop?

   132

    if options.noop :

   133

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

   134

        return 0

   135

   136

    # execute

   137

    try :

   138

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

   139

        source.execute(rsync_options, srcdst)

   140

   141

    except InvokeError, e:

   142

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

   143

        return e.exit

   144

   145

   146

    # ok

   147

    return 0

   148

   149

def main (argv) :

   150

    """

   151

        Run, with full argv

   152

    """

   153

   154

    # global options + args

   155

    options, args = parse_options(argv)

   156

   157

    # was a local command, not remote?

   158

    local = False

   159

   160

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

   161

    if options.given_command :

   162

        host = args.pop(0)

   163

        command_parts = args

   164

   165

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

   166

   167

    # from env/--command

   168

    elif options.command:

   169

        # as given

   170

        command_parts = shlex.split(options.command)

   171

   172

    # normal args

   173

    elif args :

   174

        command_parts = [argv[0]] + args

   175

        local = True

   176

   177

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

   178

   179

    else :

   180

        log.error("SSH_ORIGINAL_COMMAND not given")

   181

        return 2

   182

   183

    # run

   184

    try :

   185

        return rsync_wrapper(command_parts, options, local)

   186

   187

    except Exception, e:

   188

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

   189

        return 3

   190

   191

    # ok

   192

    return 0

   193

   194

if __name__ == '__main__' :

   195

    import sys

   196

   197

    sys.exit(main(sys.argv))

   198