/usr/lib/python3/dist-packages/plainbox/impl/commands/__init__.py is in python3-plainbox 0.5.3-2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 | # This file is part of Checkbox.
#
# Copyright 2012 Canonical Ltd.
# Written by:
# Zygmunt Krynicki <zygmunt.krynicki@canonical.com>
#
# Checkbox is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 3,
# as published by the Free Software Foundation.
#
# Checkbox is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Checkbox. If not, see <http://www.gnu.org/licenses/>.
"""
:mod:`plainbox.impl.commands` -- shared code for plainbox sub-commands
======================================================================
.. warning::
THIS MODULE DOES NOT HAVE STABLE PUBLIC API
"""
import abc
import logging
from plainbox.i18n import gettext as _
from plainbox.impl.clitools import CommandBase, ToolBase
from plainbox.impl.providers.special import get_stubbox_def
from plainbox.impl.providers.v1 import all_providers
from plainbox.impl.secure.providers.v1 import Provider1
logger = logging.getLogger("plainbox.commands")
class PlainBoxToolBase(ToolBase):
"""
Base class for implementing commands like 'plainbox'.
The tools support a variety of sub-commands, logging and debugging
support. If argcomplete module is available and used properly in
the shell then advanced tab-completion is also available.
There are four methods to implement for a basic tool. Those are:
1. :meth:`get_exec_name()` -- to know how the command will be called
2. :meth:`get_exec_version()` -- to know how the version of the tool
3. :meth:`add_subcommands()` -- to add some actual commands to execute
4. :meth:`get_config_cls()` -- to know which config to use
This class has some complex control flow to support important and
interesting use cases. There are some concerns to people that subclass this
in order to implement their own command line tools.
The first concern is that input is parsed with two parsers, the early
parser and the full parser. The early parser quickly checks for a fraction
of supported arguments and uses that data to initialize environment before
construction of a full parser is possible. The full parser sees the
reminder of the input and does not re-parse things that where already
handled.
The second concern is that this command natively supports the concept of a
config object and a provider object. This may not be desired by all users
but it is the current state as of this writing. This means that by the time
eary init is done we have a known provider and config objects that can be
used to instantiate command objects in :meth:`add_subcommands()`. This API
might change when full multi-provider is available but details are not
known yet.
"""
def __init__(self):
"""
Initialize all the variables, real stuff happens in main()
"""
super().__init__()
self._config = None # set in late_init()
self._provider_list = [] # updated in late_init()
@classmethod
@abc.abstractmethod
def get_config_cls(cls):
"""
Get the Config class that is used by this implementation.
This can be overridden by subclasses to use a different config class
that is suitable for the particular application.
"""
def late_init(self, early_ns):
"""
Overridden version of late_init().
This method loads the configuration object and the list of providers
and stores them as instance attributes.
"""
super().late_init(early_ns)
# Load plainbox configuration
self._config = self.get_config_cls().get()
# XXX: we cannot change _provider_list as the particular list object is
# already passed as argument to several command classes. It seems safe
# to append items to it though.
self._provider_list.extend(self.get_provider_list(early_ns))
def get_provider_list(self, ns):
"""
Get the list of job providers.
This method looks at --providers argument to figure out which
providers to expose to all of the commands.
"""
# If the default value of 'None' was set for the checkbox (provider)
# argument then load the actual provider name from the configuration
# object (default for that is 'auto').
if ns.providers is None:
ns.providers = self._config.default_provider
assert ns.providers in ('all', 'stub')
# Decide which providers to expose to the rest of plainbox
if ns.providers == 'all':
return self._load_really_all_providers()
elif ns.providers == 'stub':
return self._load_stub_provider_only()
def _load_really_all_providers(self):
provider_list = []
# StubBox is always enabled
provider_list.append(
Provider1.from_definition(get_stubbox_def(), secure=False))
# Load all normal providers
all_providers.load()
provider_list.extend(all_providers.get_all_plugin_objects())
return provider_list
def _load_stub_provider_only(self):
return [Provider1.from_definition(get_stubbox_def(), secure=False)]
def add_early_parser_arguments(self, parser):
"""
Overridden version of add_early_parser_arguments().
This method adds the --providers argument to the set of early parser
arguments, so that it is visible in autocomplete and help.
"""
group = parser.add_argument_group(
title=_("provider list and development"))
group.add_argument(
'--providers',
action='store',
choices=['all', 'stub'],
# None is a special value that means 'use whatever is configured'
default=None,
help=_("which providers to load"))
super().add_early_parser_arguments(parser)
class PlainBoxCommand(CommandBase):
"""
Simple interface class for plainbox commands.
Command objects like this are consumed by PlainBoxTool subclasses to
implement hierarchical command system. The API supports arbitrary many sub
commands in arbitrary nesting arrangement.
"""
gettext_domain = "plainbox"
|