def run(self):
option = self.opts.option
Config.parser.remove_option('options', option)
try:
Config.save()
print _("Successfully forgot option [ %s ]") % u_str(option)
except (Exception):
print _("Unsuccessfully forgot option [ %s ]") % u_str(option)
raise # re-raise to get into main method -> log
return os.EX_OK
def run(self):
option = self.opts.option
Config.parser.remove_option('options', option)
try:
Config.save()
print _("Successfully forgot option [ %s ]") % u_str(option)
except (Exception):
print _("Unsuccessfully forgot option [ %s ]") % u_str(option)
raise # re-raise to get into main method -> log
return os.EX_OK
def __init__(self, admin_cli):
# remove stdout stream encoding while in 'shell' mode, becuase this breaks readline
# (autocompletion and shell history). In 'shell' mode the stdout
# is encoded just for time necessary for command execution see precmd a postcmd
sys.stdout = stdout_origin
self.stdout_with_codec = encode_stream(sys.stdout, "utf-8")
self.completion_matches = None
Cmd.__init__(self)
self.admin_cli = admin_cli
self.completion = Completion(self.admin_cli)
try:
Config()
self.prompt = Config.parser.get('shell', 'prompt') + ' '
except (ConfigFileError, ConfigParser.Error):
self.prompt = 'katello> '
try:
# don't split on hyphens during tab completion (important for completing parameters)
newdelims = readline.get_completer_delims()
newdelims = re.sub('-', '', newdelims)
readline.set_completer_delims(newdelims)
if (Config.parser.get('shell', 'nohistory').lower() != 'true'):
self.__init_history()
except ConfigParser.Error:
pass
self.__init_commands()
def load_saved_options(cls, parser):
Config()
if not Config.parser.has_section('options'):
return
for opt_name, opt_value in Config.parser.items('options'):
opt = parser.get_option_by_name(opt_name)
if not opt is None:
parser.set_default(opt.get_dest(), opt_value)
def get_katello_mode():
Config()
path = Config.parser.get('server', 'path') if Config.parser.has_option(
'server', 'path') else ''
if "headpin" in path or "sam" in path:
return "headpin"
else:
return "katello"
def run(self):
option = self.opts.option
value = self.opts.value
if not Config.parser.has_section('options'):
Config.parser.add_section('options')
has_option = Config.parser.has_option('options', option)
Config.parser.set('options', option, value)
try:
Config.save()
verb = "overwrote" if has_option else "remembered"
print _("Successfully " + verb + " option [ %s ] ") % u_str(option)
except (Exception):
print _("Unsuccessfully remembered option [ %s ]") % u_str(option)
raise # re-raise to get into main method -> log
return os.EX_OK
def __print_strategy(self):
Config()
if (self.has_option('grep') or (Config.parser.has_option('interface', 'force_grep_friendly') \
and Config.parser.get('interface', 'force_grep_friendly').lower() == 'true')):
return GrepStrategy(delimiter=self.get_option('delimiter'))
elif (self.has_option('verbose') or (Config.parser.has_option('interface', 'force_verbose') \
and Config.parser.get('interface', 'force_verbose').lower() == 'true')):
return VerboseStrategy()
else:
return None
def run(self):
option = self.opts.option
value = self.opts.value
if not Config.parser.has_section('options'):
Config.parser.add_section('options')
has_option = Config.parser.has_option('options', option)
Config.parser.set('options', option, value)
try:
Config.save()
verb = "overwrote" if has_option else "remembered"
print _("Successfully " + verb + " option [ %s ] ") % u_str(option)
except (Exception):
print _("Unsuccessfully remembered option [ %s ]") % u_str(option)
raise # re-raise to get into main method -> log
return os.EX_OK
def run(self):
option = self.opts.option
value = self.opts.value
Config()
if not Config.parser.has_section("options"):
Config.parser.add_section("options")
has_option = Config.parser.has_option("options", option)
Config.parser.set("options", option, value)
try:
Config.save()
if has_option:
print _("Successfully overwrote option [ %s ] ") % u_str(option)
else:
print _("Successfully remembered option [ %s ] ") % u_str(option)
except (Exception):
print _("Unsuccessfully remembered option [ %s ]") % u_str(option)
raise # re-raise to get into main method -> log
return os.EX_OK
def run(self):
self.printer.set_header(_("Saved Options"))
Config()
if Config.parser.has_section('options'):
options = Config.parser.options('options')
options_list = [{
'option': o,
'value': Config.parser.get('options', o)
} for o in options]
self.printer.add_column('option', _("Option"))
self.printer.add_column('value', _("Value"))
self.printer.print_items(options_list)
return os.EX_OK
import os
from gettext import gettext as _
from urlparse import urlparse
from katello.client.api.provider import ProviderAPI
from katello.client.server import ServerRequestError
from katello.client.config import Config
from katello.client.core.base import BaseAction, Command
from katello.client.core.utils import test_record, get_abs_path, run_async_task_with_status, run_spinner_in_bg, AsyncTask, format_sync_errors, system_exit
from katello.client.core.repo import format_sync_state, format_sync_time
from katello.client.core.utils import ProgressBar
from katello.client.api.utils import get_provider
from katello.client.utils import printer
Config()
# base provider action =========================================================
class ProviderAction(BaseAction):
def __init__(self):
super(ProviderAction, self).__init__()
self.api = ProviderAPI()
class SingleProviderAction(ProviderAction):
def setup_parser(self, parser):
parser.add_option('--name',
dest='name',
help=_("provider name (required)"))
parser.add_option('--org',
def setup_parser(self, parser):
"""
Add options to the command line parser.
@note: this method may be overridden to define new options
"""
parser.add_option("-v",
"--version",
action="store_true",
default=False,
dest="version",
help=_('prints version information'))
parser.add_option("-d",
"--debug",
action="store_true",
default=False,
dest="debug",
help=_('send debug information into logs'))
credentials = OptionGroup(parser,
_('Katello User Account Credentials'))
credentials.add_option('-u',
'--username',
dest='username',
default=None,
help=_('account username'))
credentials.add_option('-p',
'--password',
dest='password',
default=None,
help=_('account password'))
credentials.add_option('--cert-file',
dest='certfile',
default=None,
help=SUPPRESS_HELP)
credentials.add_option('--key-file',
dest='keyfile',
default=None,
help=SUPPRESS_HELP)
parser.add_option_group(credentials)
Config()
server_opt = OptionGroup(parser, _('Katello Server Information'))
host = Config.parser.get('server', 'host') or 'localhost.localdomain'
server_opt.add_option(
'--host',
dest='host',
default=host,
help=_('katello server host name (default: %s)') % host)
port = Config.parser.get('server', 'port') or '443'
server_opt.add_option('--port',
dest='port',
default=port,
help=SUPPRESS_HELP)
scheme = Config.parser.get('server', 'scheme') or 'https'
server_opt.add_option('--scheme',
dest='scheme',
default=scheme,
help=SUPPRESS_HELP)
path = Config.parser.get('server', 'path') or '/katello/api'
server_opt.add_option('--path',
dest='path',
default=path,
help=SUPPRESS_HELP)
parser.add_option_group(server_opt)
