1

"""

     2

    Invoke external commands.

     5

"""

     6

     7

import subprocess

     8

import logging

     9

    10

log = logging.getLogger('pvl.backup.invoke')

    11

    12

SUDO = '/usr/bin/sudo'

    13

    14

class InvokeError (Exception) :

    15

    def __init__ (self, cmd, exit) :

    16

        self.cmd = cmd

    17

        self.exit = exit

    18

    19

    def __str__ (self) :

    20

        return "{cmd} failed: {exit}".format(cmd=self.cmd, exit=self.exit)

    21

    22

def invoke (cmd, args, data=None, sudo=False) :

    23

    """

    24

        Invoke a command directly.

    25

    26

        data:       data to pass in on stdin, returning stdout.

    27

                    if given as False, passes through our process stdin/out

    28

        sudo:       exec using sudo

    29

    30

        Doesn't give any data on stdin, and keeps process stderr.

    31

        Returns stdout.

    32

    """

    33

    34

    log.debug("{sudo}{cmd} {args}".format(sudo=('sudo ' if sudo else ''), cmd=cmd, args=' '.join(args)))

    35

    36

    if data is False :

    37

        # keep process stdin/out

    38

        io = None

    39

    else :

    40

        io = subprocess.PIPE

    41

    42

    args = [cmd] + args

    43

    44

    if sudo :

    45

        args = [SUDO] + args

    46

    47

    p = subprocess.Popen(args, stdin=io, stdout=io)

    48

    49

    # get output

    50

    stdout, stderr = p.communicate(input=data)

    51

    52

    if p.returncode :

    53

        # failed

    54

        raise InvokeError(cmd, p.returncode)

    55

    56

    return stdout

    57

    58

def process_opt (opt, value) :

    59

    """

    60

        Mangle from python keyword-argument dict format to command-line option tuple format.

    61

    62

        >>> process_opt('foo', True)

    63

        ('--foo',)

    64

        >>> process_opt('foo', 2)

    65

        ('--foo', '2')

    66

        >>> process_opt('foo', 'bar')

    67

        ('--foo', 'bar')

    68

        >>> process_opt('foo_bar', 'asdf')

    69

        ('--foo-bar', 'asdf')

    70

    71

        # empty

    72

        >>> process_opt('foo', False)

    73

        ()

    74

        >>> process_opt('foo', None)

    75

        ()

    76

        >>> process_opt('bar', '')

    77

        ()

    78

    79

        Returns a tuple of argv items.

    80

    """

    81

    82

    # mangle opt

    83

    opt = '--' + opt.replace('_', '-')

    84

    85

    if value is True :

    86

        # flag opt

    87

        return (opt, )

    88

    89

    elif not value :

    90

        # flag opt / omit

    91

        return ( )

    92

    93

    else :

    94

        # as-is

    95

        return (opt, str(value))

    96

    97

def optargs (*args, **kwargs) :

    98

    """

    99

        Convert args/options into command-line format

   100

    """

   101

   102

    ## opts

   103

    # process

   104

    opts = [process_opt(opt, value) for opt, value in kwargs.iteritems()]

   105

   106

    # flatten

   107

    opts = [str(opt_part) for opt_parts in opts for opt_part in opt_parts if opt_part]

   108

   109

    ## args

   110

    args = [str(arg) for arg in args if arg]

   111

   112

    return opts + args

   113

   114

def command (cmd, *args, **opts) :

   115

    """

   116

        Invoke a command with options/arguments, given via Python arguments/keyword arguments.

   117

   118

        Return stdout.

   119

    """

   120

   121

    log.debug("{cmd} {opts} {args}".format(cmd=cmd, args=args, opts=opts))

   122

   123

    # invoke

   124

    return invoke(cmd, optargs(*args, **opts))

   125

   126

if __name__ == '__main__':

   127

    import doctest

   128

    doctest.testmod()

   129