1

"""

     2

    Command implementations

     3

"""

     4

     5

import inspect, logging, traceback, concurrent

     6

     7

class CommandList (object) :

     8

    """

     9

        A list of available Commands

    10

    11

        XXX: not yet used

    12

    """

    13

    14

    def __init__ (self, commands) :

    15

        """

    16

            Store with given initial commands

    17

        """

    18

    19

        self.list = commands

    20

        self.dict = dict((cmd.name, cmd) for cmd in commands)

    21

    22

    def lookup (self, name) :

    23

        """

    24

            Lookup a command by name

    25

        """

    26

    27

        return self.dict[name]

    28

    29

class Command (object) :

    30

    """

    31

        A Command is simply a function that can be executed from the command line with some options/arguments

    32

    """

    33

    34

    def __init__ (self, name, func, doc=None) :

    35

        """

    36

            Create a new Command

    37

    38

             name       - the name of the command

    39

             func       - the callable python function

    40

             doc        - descriptive help text

    41

        """

    42

    43

        self.name = name

    44

        self.func = func

    45

        self.doc = doc

    46

    47

    def setup (self, config, gallery) :

    48

        """

    49

            Run the command with the given context

    50

        """

    51

    52

        return CommandContext(self, config, gallery)

    53

    54

class CommandContext (object) :

    55

    """

    56

        A CommandContext is the context that a Command executes in

    57

    58

        It is bound to a Configuration and a Gallery.

    59

    """

    60

    61

    def __init__ (self, command, config, gallery) :

    62

        """

    63

            Create the execution environment

    64

        """

    65

    66

        self.command = command

    67

        self.config = config

    68

        self.gallery = gallery

    69

    70

        # conccurency

    71

        self.concurrent = concurrent.Manager(thread_count=config.thread_count)

    72

    73

    def execute (self, *args, **kwargs) :

    74

        """

    75

            Run the command in this context

    76

        """

    77

    78

        return self.command.func(self, *args, **kwargs)

    79

    80

    def run (self, *args, **kwargs) :

    81

        """

    82

            Run the command with error handling

    83

        """

    84

    85

        try :

    86

            # run it

    87

            return self.execute(*args, **kwargs)

    88

    89

        except KeyboardInterrupt :

    90

            self.log_error("Interrupted")

    91

    92

        except :

    93

            # dump traceback

    95

            self.handle_error()

    96

    97

    def log_msg (self, level, msg, *args, **kwargs) :

    98

        """

    99

            Output a log message with the given level

   100

   101

            XXX: unicode

   102

        """

   103

   104

        # control level of output

   105

        if level < self.config.log_level :

   106

            return

   107

   108

        # format?

   109

        if args or kwargs :

   110

            if args and not kwargs :

   111

                msg = msg % args

   112

   113

            elif kwargs and not args :

   114

                msg = msg % kwargs

   115

   116

            else :

   117

                raise Exception("log_msg called with both args and kwargs")

   118

   119

        # output

   120

        # XXX: stdout/err?

   121

        print msg

   122

   123

    def log_debug (self, msg, *args, **kwargs) :

   124

        self.log_msg(logging.DEBUG, msg, *args, **kwargs)

   125

   126

    def log_info (self, msg, *args, **kwargs) :

   127

        self.log_msg(logging.INFO, msg, *args, **kwargs)

   128

   129

    def log_warning (self, msg, *args, **kwargs) :

   130

        self.log_msg(logging.WARNING, msg, *args, **kwargs)

   131

   132

    def log_error (self, msg, *args, **kwargs) :

   133

        self.log_msg(logging.ERROR, msg, *args, **kwargs)

   134

   135

    def handle_error (self, exc_info=None) :

   136

        """

   137

            Do something to handle an error that occured

   138

        """

   139

   140

        if exc_info :

   141

            traceback.print_execption(*exc_info)

   142

   143

        else :

   144

            traceback.print_exc()

   145

   146

def command (func) :

   147

    """

   148

        A function decorator used to define Commands automatically

   149

    """

   150

   151

    return Command(func.__name__, func, inspect.getdoc(func))

   152