def delete(self, org_id, system_group_id, delete_systems):
if delete_systems:
path = "/api/organizations/%s/system_groups/%s/destroy_systems" % (u_str(org_id), u_str(system_group_id))
else:
path = "/api/organizations/%s/system_groups/%s" % (u_str(org_id), u_str(system_group_id))
return self.server.DELETE(path)[1]
def _store_item_with_product(self, option, opt_str, value, parser):
if (parser.values.from_product == None) and \
(parser.values.from_product_label == None) and \
(parser.values.from_product_id == None):
raise OptionValueError(
_("%s must be preceded by %s, %s or %s") %
(option, "--from_product", "--from_product_label",
"--from_product_id"))
if self.current_product_option == 'product_label':
self.items[option.dest].append({
"name":
u_str(value),
"product_label":
self.current_product
})
elif self.current_product_option == 'product_id':
self.items[option.dest].append({
"name": u_str(value),
"product_id": self.current_product
})
else:
self.items[option.dest].append({
"name": u_str(value),
"product": self.current_product
})
def _print_item(self, item, columns):
"""
Print one record.
:type item: hash
:param item: data to print
:type columns: list of dicts
:param columns: columns definition
"""
self._println()
for column in columns:
if not self._column_has_value(column, item):
continue
value = self._get_column_value(column, item)
if not column.get('multiline', False):
col_width = self._max_label_width(columns)
if not isinstance(value, (list, tuple)):
value = [value]
for v in value:
self._println(
("{0:<" + u_str(col_width) + "} : {1}").format(
u_str(column['name']), u_str(v)))
else:
self._println(column['name'] + ":")
self._println(indent_text(value, " "))
class OrganizationDefaultInfoAPI(KatelloAPI):
"""
Connection class to access default info keys under an organization
"""
def create(self, org_name, informable_type, keyname):
data = {'keyname': keyname}
path = "/api/organizations/%s/default_info/%s" % (
u_str(org_name), u_str(informable_type))
return self.server.POST(path, data)[1]
def index(self, org_name, informable_type):
path = "/api/organizations/%s/default_info/%s" % (
u_str(org_name), u_str(informable_type))
return self.server.GET(path)[1]
def destroy(self, org_name, informable_type, keyname):
path = "/api/organizations/%s/default_info/%s/%s" % (
u_str(org_name), u_str(informable_type), u_str(keyname))
return self.server.DELETE(path)[1]
def apply(self, org_name, informable_type, async=True):
data = {'async': async}
path = "/api/organizations/%s/default_info/%s/apply" % (
u_str(org_name), u_str(informable_type))
return self.server.POST(path, data)[1]
def _print_item(self, item, columns):
"""
Print one record.
:type item: hash
:param item: data to print
:type columns: list of dicts
:param columns: columns definition
"""
self._println()
for column in columns:
if not self._column_has_value(column, item):
continue
value = self._get_column_value(column, item)
if not column.get('multiline', False):
col_width = self._max_label_width(columns)
if not isinstance(value, (list, tuple)):
value = [value]
for v in value:
self._println(("{0:<" + u_str(col_width) + "} : {1}").format(u_str(column['name']), u_str(v)))
else:
self._println(column['name'] + ":")
self._println(indent_text(value, " "))
def products(self, filter_id, def_id, org_id):
path = "/api/organizations/%(org_id)s/content_view_definitions/" + \
"%(definition)s/filters/%(filter_id)s/products"
path = path % {"org_id": u_str(org_id), "definition": u_str(def_id),
"filter_id": u_str(filter_id)}
data = self.server.GET(path)[1]
return data
def _store_item(self, option, opt_str, value, parser):
if option.dest == 'add_product_label' or option.dest == 'remove_product_label':
self.items[option.dest].append({"product_label": u_str(value)})
elif option.dest == 'add_product_id' or option.dest == 'remove_product_id':
self.items[option.dest].append({"product_id": u_str(value)})
else:
self.items[option.dest].append({"name": u_str(value)})
setattr(parser.values, option.dest, value)
def error(self, exception, errorMsg=None):
msg = errorMsg if errorMsg else u_str(exception)
print >> sys.stderr, _(
"error: %(msg)s (more in the log file %(log)s)") % {
"msg": msg,
"log": logfile()
}
_log.error(u_str(exception))
_log.error(format_exc(exception))
def update(self, org_id, plan_id, name, sync_date, interval, description):
data = {}
data = update_dict_unless_none(data, "name", name)
data = update_dict_unless_none(data, "description", description)
data = update_dict_unless_none(data, "interval", interval)
data = update_dict_unless_none(data, "sync_date", sync_date)
path = "/api/organizations/%s/sync_plans/%s" % (u_str(org_id), u_str(plan_id))
return self.server.PUT(path, {"sync_plan": data})[1]
def delete(self, org_id, system_group_id, delete_systems):
if delete_systems:
path = "/api/organizations/%s/system_groups/%s/destroy_systems" % (
u_str(org_id), u_str(system_group_id))
else:
path = "/api/organizations/%s/system_groups/%s" % (
u_str(org_id), u_str(system_group_id))
return self.server.DELETE(path)[1]
def products(self, filter_id, def_id, org_id):
path = "/api/organizations/%(org_id)s/content_view_definitions/" + \
"%(definition)s/filters/%(filter_id)s/products"
path = path % {
"org_id": u_str(org_id),
"definition": u_str(def_id),
"filter_id": u_str(filter_id)
}
data = self.server.GET(path)[1]
return data
def update(self, org_id, plan_id, name, sync_date, interval, description):
data = {}
data = update_dict_unless_none(data, "name", name)
data = update_dict_unless_none(data, "description", description)
data = update_dict_unless_none(data, "interval", interval)
data = update_dict_unless_none(data, "sync_date", sync_date)
path = "/api/organizations/%s/sync_plans/%s" % (u_str(org_id),
u_str(plan_id))
return self.server.PUT(path, {"sync_plan": data})[1]
def _store_item(self, option, opt_str, value, parser):
if option.dest == "add_content_view" or option.dest == "remove_content_view":
self.items[option.dest].append({"view_name": u_str(value)})
elif option.dest == "add_content_view_label" or option.dest == "remove_content_view_label":
self.items[option.dest].append({"view_label": u_str(value)})
elif option.dest == "add_content_view_id" or option.dest == "remove_content_view_id":
self.items[option.dest].append({"view_id": u_str(value)})
else:
self.items[option.dest].append({"name": u_str(value)})
setattr(parser.values, option.dest, value)
def update(self, orgName, prodId, description, gpgkey, nogpgkey, gpgkey_recursive):
product = {}
update_dict_unless_none(product, "description", description)
update_dict_unless_none(product, "gpg_key_name", gpgkey)
update_dict_unless_none(product, "recursive", gpgkey_recursive)
if nogpgkey:
product["gpg_key_name"] = ""
path = "/api/organizations/%s/products/%s/" % (u_str(orgName), u_str(prodId))
result = self.server.PUT(path, {"product": product})[1]
return result
def run(self):
option = self.opts.option
Config()
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 _store_item_with_product(self, option, opt_str, value, parser):
if (parser.values.from_product == None) and \
(parser.values.from_product_label == None) and \
(parser.values.from_product_id == None):
raise OptionValueError(_("%s must be preceded by %s, %s or %s") %
(option, "--from_product", "--from_product_label", "--from_product_id"))
if self.current_product_option == 'product_label':
self.items[option.dest].append({"name": u_str(value), "product_label": self.current_product})
elif self.current_product_option == 'product_id':
self.items[option.dest].append({"name": u_str(value), "product_id": self.current_product})
else:
self.items[option.dest].append({"name": u_str(value), "product": self.current_product})
def update(self, orgName, prodId, description, gpgkey, nogpgkey,
gpgkey_recursive):
product = {}
update_dict_unless_none(product, "description", description)
update_dict_unless_none(product, "gpg_key_name", gpgkey)
update_dict_unless_none(product, "recursive", gpgkey_recursive)
if nogpgkey:
product["gpg_key_name"] = ""
path = "/api/organizations/%s/products/%s/" % (u_str(orgName),
u_str(prodId))
result = self.server.PUT(path, {"product": product})[1]
return result
def run(self):
option = self.opts.option
Config()
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 _store_item_with_product(self, option, opt_str, value, parser):
if (parser.values.from_product == None) and \
(parser.values.from_product_label == None) and \
(parser.values.from_product_id == None):
raise OptionValueError(_("%(option)s must be preceded by %(from_product)s, \
%(from_product_label)s or %(from_product_id)s")
% {'option':option, 'from_product':"--from_product",
'from_product_label':"--from_product_label", 'from_product_id':"--from_product_id"})
if self.current_product_option == 'from_product_label':
self.items[option.dest].append({"name": u_str(value), "from_product_label": self.current_product})
elif self.current_product_option == 'from_product_id':
self.items[option.dest].append({"name": u_str(value), "from_product_id": self.current_product})
else:
self.items[option.dest].append({"name": u_str(value), "from_product": self.current_product})
def _print_item(self, item, columns, column_widths):
"""
Print item of a list on single line
:type item: hash
:param item: data to print
:type columns: list of dicts
:param columns: columns definition
:type column_widths:
:param column_widths:
"""
for column in columns:
#get defined width
width = column_widths.get(column['attr_name'], 0)
#skip missing attributes
if not self._column_has_value(column, item):
if self.__delim:
self._print(" " * width)
else:
self._print(self.__delim)
continue
value = self._get_column_value(column, item)
if column.get('multiline', False):
value = text_to_line(value)
value = u_str(value)
if self.__delim:
self._print('%s' % (value) + self.__delim)
else:
self._print('%s%s' % (value, ' ' * (width - unicode_len(
(value)))))
def import_manifest(self, provId, manifestFile, force=False):
path = "/api/providers/%s/import_manifest" % u_str(provId)
params = {"import": manifestFile}
if force:
params["force"] = "true"
result = self.server.POST(path, params, multipart=True)[1]
return result
def run(self):
errId = self.get_option("id")
repoId = self.get_option("repo_id")
repoName = self.get_option("repo")
orgName = self.get_option("org")
envName = self.get_option("environment")
prodName = self.get_option("product")
prodLabel = self.get_option("product_label")
prodId = self.get_option("product_id")
if not repoId:
repo = get_repo(orgName, prodName, prodLabel, prodId, repoName, envName)
repoId = repo["id"]
pack = self.api.errata(errId, repoId)
pack["affected_packages"] = [u_str(pinfo["filename"]) for pkg in pack["pkglist"] for pinfo in pkg["packages"]]
batch_add_columns(self.printer, {"id": _("ID")}, {"title": _("Title")})
self.printer.add_column("description", _("Description"), multiline=True)
batch_add_columns(
self.printer,
{"type": _("Type")},
{"issued": _("Issued")},
{"updated": _("Updated")},
{"version": _("Version")},
{"release": _("Release")},
{"status": _("Status")},
{"reboot_suggested": _("Reboot Suggested")},
)
self.printer.add_column("affected_packages", _("Affected Packages"), multiline=True)
self.printer.set_header(_("Errata Information"))
self.printer.print_item(pack)
return os.EX_OK
def run(self):
errId = self.get_option('id')
repoId = self.get_option('repo_id')
repoName = self.get_option('repo')
orgName = self.get_option('org')
envName = self.get_option('environment')
prodName = self.get_option('product')
prodLabel = self.get_option('product_label')
prodId = self.get_option('product_id')
viewName = self.get_option('view_name')
viewLabel = self.get_option('view_label')
viewId = self.get_option('view_id')
if not repoId:
repo = get_repo(orgName, repoName, prodName, prodLabel, prodId, envName,
viewName, viewLabel, viewId)
repoId = repo["id"]
pack = self.api.errata(errId, repoId)
pack['affected_packages'] = [u_str(pinfo['filename'])
for pkg in pack['pkglist']
for pinfo in pkg['packages']]
batch_add_columns(self.printer, {'errata_id': _("ID")}, {'title': _("Title")})
self.printer.add_column('description', _("Description"), multiline=True)
batch_add_columns(self.printer, {'type': _("Type")}, {'issued': _("Issued")}, \
{'updated': _("Updated")}, {'version': _("Version")}, {'release': _("Release")}, \
{'status': _("Status")}, {'reboot_suggested': _("Reboot Suggested")})
self.printer.add_column('affected_packages', _("Affected Packages"), multiline=True)
self.printer.set_header(_("Errata Information"))
self.printer.print_item(pack)
return os.EX_OK
def update(self, name, description):
orgdata = {}
orgdata = update_dict_unless_none(orgdata, "description", description)
path = "/api/organizations/%s" % u_str(name)
return self.server.PUT(path, {"organization": orgdata})[1]
def _print_item(self, item, columns, column_widths):
"""
Print item of a list on single line
:type item: hash
:param item: data to print
:type columns: list of dicts
:param columns: columns definition
:type column_widths:
:param column_widths:
"""
for column in columns:
#get defined width
width = column_widths.get(column['attr_name'], 0)
#skip missing attributes
if not self._column_has_value(column, item):
if self.__delim:
self._print(" " * width)
else:
self._print(self.__delim)
continue
value = self._get_column_value(column, item)
if column.get('multiline', False):
value = text_to_line(value)
value = u_str(value)
if self.__delim:
self._print('%s' % (value) + self.__delim)
else:
self._print('%s%s' % (value, ' '*(width-unicode_len((value)))))
def _store_parameter_value(self, option, opt_str, value, parser):
if self.current_parameter == None:
raise OptionValueError(_("each %(option)s must be preceeded by %(paramater)s") \
% {'option':option, 'parameter':"--add_parameter"} )
self.items['add_parameters'][self.current_parameter] = u_str(value)
self.current_parameter = None
def import_manifest(self, provId, manifestFile, force=False):
path = "/api/providers/%s/import_manifest" % u_str(provId)
params = {"import": manifestFile}
if force:
params["force"] = "true"
result = self.server.POST(path, params, multipart=True)[1]
return result
def template_by_name(self, envId, tplName):
path = "/api/environments/%s/templates/" % u_str(envId)
tpls = self.server.GET(path, {"name": tplName})[1]
if len(tpls) > 0:
#show provides more information than index
return self.template(tpls[0]["id"])
else:
return None
def entitlements():
for entitlement in result['entitlements']:
entitlement_ext = entitlement.copy()
provided_products = ', '.join([e['name'] for e in entitlement_ext['providedProducts']])
entitlement_ext['providedProductsFormatted'] = provided_products
serial_ids = ', '.join([u_str(s['id']) for s in entitlement_ext['serials']])
entitlement_ext['serialIds'] = serial_ids
yield entitlement_ext
def product_by_name_or_label_or_id(self, orgName, prodName, prodLabel, prodId):
params = {}
update_dict_unless_none(params, "name", prodName)
update_dict_unless_none(params, "label", prodLabel)
update_dict_unless_none(params, "cp_id", prodId)
path = "/api/organizations/%s/products" % u_str(orgName)
products = self.server.GET(path, params)[1]
return products
def checkin(self, system_uuid, checkin_time=None):
path = "/api/systems/%s/checkin" % u_str(system_uuid)
if not checkin_time:
checkin_time = datetime.datetime.now()
params = {
"date": checkin_time.isoformat()
}
return self.server.PUT(path, params)[1]
def create(self, org_id, name, sync_date, interval, description):
data = {
"name": name,
"description": description,
"interval": interval,
"sync_date": sync_date
}
path = "/api/organizations/%s/sync_plans/" % u_str(org_id)
return self.server.POST(path, {"sync_plan": data})[1]
def error(self, error_msg):
"""
Logs an error and prints it to stderr
"""
error_msg = u_str(error_msg)
error_msg = error_msg if error_msg else _('operation failed')
_log.error("error: " + error_msg)
print >> sys.stderr, error_msg
def update(self, provId, name, description=None, url=None):
provdata = {}
provdata = update_dict_unless_none(provdata, "name", name)
provdata = update_dict_unless_none(provdata, "description", description)
provdata = update_dict_unless_none(provdata, "repository_url", url)
path = "/api/providers/%s" % u_str(provId)
return self.server.PUT(path, {"provider": provdata})[1]
def indent_text(text, indent="\t"):
"""
Indents given text.
:type text: string or list of strings
:param text: text to be indented
:type indent: string
:param indent: value that is added at the beggining of each line of the text
:rtype: string
"""
if text is None:
text = u_str(None)
if isinstance(text, list):
glue = "\n" + indent
return indent + glue.join([u_str(l) for l in text])
else:
return indent_text(text.split("\n"), indent)
def create(self, org_id, name, sync_date, interval, description):
data = {
"name": name,
"description": description,
"interval": interval,
"sync_date": sync_date
}
path = "/api/organizations/%s/sync_plans/" % u_str(org_id)
return self.server.POST(path, {"sync_plan": data})[1]
def error(self, error_msg):
"""
Logs an error and prints it to stderr
"""
error_msg = u_str(error_msg)
error_msg = error_msg if error_msg else _('operation failed')
_log.error("error: %s" % error_msg)
print >> sys.stderr, error_msg
def indent_text(text, indent="\t"):
"""
Indents given text.
:type text: string or list of strings
:param text: text to be indented
:type indent: string
:param indent: value that is added at the beggining of each line of the text
:rtype: string
"""
if text is None:
text = u_str(None)
if isinstance(text, list):
glue = "\n"+indent
return indent+glue.join([u_str(l) for l in text])
else:
return indent_text(text.split("\n"), indent)
def product_by_name_or_label_or_id(self, orgName, prodName, prodLabel,
prodId):
params = {}
update_dict_unless_none(params, "name", prodName)
update_dict_unless_none(params, "label", prodLabel)
update_dict_unless_none(params, "cp_id", prodId)
path = "/api/organizations/%s/products" % u_str(orgName)
products = self.server.GET(path, params)[1]
return products
def update(self, provId, name, description=None, url=None):
provdata = {}
provdata = update_dict_unless_none(provdata, "name", name)
provdata = update_dict_unless_none(provdata, "description",
description)
provdata = update_dict_unless_none(provdata, "repository_url", url)
path = "/api/providers/%s" % u_str(provId)
return self.server.PUT(path, {"provider": provdata})[1]
def create(self, provId, name, label, description, gpgkey):
product = {
"name": name,
"label": label,
"description": description,
"gpg_key_name": gpgkey
}
path = "/api/providers/%s/product_create" % u_str(provId)
result = self.server.POST(path, {"product": product})[1]
return result
def create(self, provId, name, label, description, gpgkey):
product = {
"name": name,
"label": label,
"description": description,
"gpg_key_name": gpgkey
}
path = "/api/providers/%s/product_create" % u_str(provId)
result = self.server.POST(path, {"product": product})[1]
return result
def entitlements():
for entitlement in result["entitlements"]:
entitlement_ext = entitlement.copy()
provided_products = ", ".join([e["name"] for e in entitlement_ext["providedProducts"]])
if provided_products:
entitlement_ext["providedProductsFormatted"] = _("Not Applicable")
else:
entitlement_ext["providedProductsFormatted"] = provided_products
serial_ids = ", ".join([u_str(s["id"]) for s in entitlement_ext["serials"]])
entitlement_ext["serialIds"] = serial_ids
yield entitlement_ext
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 update(self, tplId, newName, description, parentId):
tplData = {}
tplData = update_dict_unless_none(tplData, "name", newName)
tplData = update_dict_unless_none(tplData, "description", description)
tplData = update_dict_unless_none(tplData, "parent_id", parentId)
tplData = {
"template": tplData
}
path = "/api/templates/%s" % u_str(tplId)
return self.server.PUT(path, tplData)[1]
def _process_response(self, response):
"""
Try to parse the response
@type response: HTTPResponse
@param response: http response
@rtype: (int, string)
@return: tuple of the response status and response body
"""
response_body = response.read()
try:
response_body = json.loads(response_body, encoding='utf-8')
except ValueError:
content_type = response.getheader('content-type')
if content_type and (content_type.startswith('text/') or content_type.startswith('application/json')):
response_body = u_str(response_body)
else:
pass
if response_body and self._log.isEnabledFor(logging.DEBUG):
content_type = response.getheader('content-type')
if content_type and (content_type.startswith('text/') or content_type.startswith('application/json')):
self._log.debug("processing response %s\n%s" % (response.status, u_str(response_body)))
else:
self._log.debug("processing response %s of %s" % (response.status, content_type))
else:
self._log.debug("processing empty response %s" % (response.status))
if response.status >= 300:
# if the server has responded with a python traceback
# try to split it out
if isinstance(response_body, basestring) and not response_body.startswith('<html'): # pylint: disable=E1103
response_body += "\n"
message, traceback = response_body.split('\n', 1)
raise ServerRequestError(response.status, message.strip(), traceback.strip())
raise ServerRequestError(response.status, response_body, None)
return (response.status, response_body, response.getheaders())
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 update(self, user_id, pw, email, disabled, default_environment, default_locale=None):
userdata = {}
userdata = update_dict_unless_none(userdata, "password", pw)
userdata = update_dict_unless_none(userdata, "email", email)
userdata = update_dict_unless_none(userdata, "disabled", disabled)
if default_environment is None:
userdata.update(default_environment_id=None) # pylint: disable=E1101
elif default_environment is not False:
userdata.update(default_environment_id=default_environment['id']) # pylint: disable=E1101
if default_locale is not None:
userdata = update_dict_unless_none(userdata, "default_locale", default_locale)
path = "/api/users/%s" % u_str(user_id)
return self.server.PUT(path, {"user": userdata})[1]
def update(self, user_id, pw, email, disabled, default_environment, default_locale=None):
userdata = {}
userdata = update_dict_unless_none(userdata, "password", pw)
userdata = update_dict_unless_none(userdata, "email", email)
userdata = update_dict_unless_none(userdata, "disabled", disabled)
if default_environment is None:
userdata.update(default_environment_id=None) # pylint: disable=E1101
elif default_environment is not False:
userdata.update(default_environment_id=default_environment['id']) # pylint: disable=E1101
if default_locale is not None:
userdata = update_dict_unless_none(userdata, "default_locale", default_locale)
path = "/api/users/%s" % u_str(user_id)
return self.server.PUT(path, {"user": userdata})[1]
def entitlements():
for entitlement in result['entitlements']:
entitlement_ext = entitlement.copy()
provided_products = ', '.join([
e['name'] for e in entitlement_ext['providedProducts']
])
if provided_products:
entitlement_ext['providedProductsFormatted'] = _(
'Not Applicable')
else:
entitlement_ext[
'providedProductsFormatted'] = provided_products
serial_ids = ', '.join(
[u_str(s['id']) for s in entitlement_ext['serials']])
entitlement_ext['serialIds'] = serial_ids
yield entitlement_ext
def text_to_line(text, glue=" "):
"""
Squeezes a block of text to one line.
:type text: string
:param text: text to be processed
:type glue: string
:param glue: string used for joining lines of the text
:rtype: string
"""
if text is None:
text = u_str(None)
if isinstance(text, list):
return glue.join(text)
else:
return glue.join(text.split("\n"))
def _column_width(self, items, column):
"""
Returns maximum width for the column to ensure that all the data
and the label fits in.
:type columns: list of dicts
:param columns: columns definition
:type column: dict
:param column: column definition
:rtype: int
"""
width = unicode_len(column['name']) + 1
for column_value in [
u_str(self._get_column_value(column, item)) for item in items
]:
new_width = unicode_len(column_value)
if width <= new_width:
width = new_width + 1
return width
def _store_item(self, option, opt_str, value, parser):
if option.dest == 'add_product_label' or option.dest == 'remove_product_label':
self.items[option.dest].append({"product_label": u_str(value)})
elif option.dest == 'add_product_id' or option.dest == 'remove_product_id':
self.items[option.dest].append({"product_id": u_str(value)})
elif option.dest == "add_content_view" or option.dest == "remove_content_view":
self.items[option.dest].append({"view_name": u_str(value)})
elif option.dest == "add_content_view_label" or option.dest == "remove_content_view_label":
self.items[option.dest].append({"view_label": u_str(value)})
elif option.dest == "add_content_view_id" or option.dest == "remove_content_view_id":
self.items[option.dest].append({"view_id": u_str(value)})
else:
self.items[option.dest].append({"name": u_str(value)})
setattr(parser.values, option.dest, value)
def create(self, roleId, name, description, type_in, verbs, tagIds,
orgId = None, all_tags = False, all_verbs = False):
data = {
"name": name,
"description": description,
"type": type_in,
"organization_id": orgId
}
if all_tags:
data["all_tags"] = "True"
else:
data["tags"] = tagIds
if all_verbs:
data["all_verbs"] = "True"
else:
data["verbs"] = verbs
path = "/api/roles/%s/permissions/" % u_str(roleId)
return self.server.POST(path, data)[1]
def run(self):
errId = self.get_option('id')
repoId = self.get_option('repo_id')
repoName = self.get_option('repo')
orgName = self.get_option('org')
envName = self.get_option('environment')
prodName = self.get_option('product')
prodLabel = self.get_option('product_label')
prodId = self.get_option('product_id')
viewName = self.get_option('view_name')
viewLabel = self.get_option('view_label')
viewId = self.get_option('view_id')
if not repoId:
repo = get_repo(orgName, repoName, prodName, prodLabel, prodId,
envName, viewName, viewLabel, viewId)
repoId = repo["id"]
pack = self.api.errata(errId, repoId)
pack['affected_packages'] = [
u_str(pinfo['filename']) for pkg in pack['pkglist']
for pinfo in pkg['packages']
]
batch_add_columns(self.printer, {'errata_id': _("ID")},
{'title': _("Title")})
self.printer.add_column('description',
_("Description"),
multiline=True)
batch_add_columns(self.printer, {'type': _("Type")}, {'issued': _("Issued")}, \
{'updated': _("Updated")}, {'version': _("Version")}, {'release': _("Release")}, \
{'status': _("Status")}, {'reboot_suggested': _("Reboot Suggested")})
self.printer.add_column('affected_packages',
_("Affected Packages"),
multiline=True)
self.printer.set_header(_("Errata Information"))
self.printer.print_item(pack)
return os.EX_OK
def select_repositories(self, repourls, assumeyes, our_raw_input = raw_input):
selection = Selection()
if not assumeyes:
proceed = ''
num_selects = [u_str(i+1) for i in range(len(repourls))]
select_range_str = constants.SELECTION_QUERY % len(repourls)
while proceed.strip().lower() not in ['q', 'y']:
if not proceed.strip().lower() == 'h':
self.__print_urls(repourls, selection)
proceed = our_raw_input(
_("\nSelect urls for which candidate repos should be created; use `y` to confirm (h for help):"))
select_val = proceed.strip().lower()
if select_val == 'h':
print select_range_str
elif select_val == 'a':
selection.add_selection(repourls)
elif select_val in num_selects:
selection.add_selection([repourls[int(proceed.strip().lower())-1]])
elif select_val == 'q':
selection = Selection()
system_exit(os.EX_OK, _("Operation aborted upon user request."))
elif set(select_val.split(":")).issubset(num_selects):
lower, upper = tuple(select_val.split(":"))
selection.add_selection(repourls[int(lower)-1:int(upper)])
elif select_val == 'c':
selection = Selection()
elif select_val == 'y':
if not len(selection):
proceed = ''
continue
else:
break
else:
continue
else:
#select all
selection.add_selection(repourls)
self.__print_urls(repourls, selection)
return selection
def _store_from_product(self, option, opt_str, value, parser):
self.current_product = u_str(value)
self.current_product_option = option.dest
setattr(parser.values, option.dest, value)
except SocketError, se:
self.error(se.args[1])
return se.args[0]
except OptionParserExitError, opee:
return opee.args[0]
except ApiDataError, ade:
print >> sys.stderr, ade.args[0]
return os.EX_DATAERR
except SystemExitRequest, ser:
msg = "\n".join(ser.args[1]).strip()
if ser.args[0] == os.EX_OK:
out = sys.stdout
_log.info(u_str(msg))
else:
out = sys.stderr
if msg != "":
print >> out, msg
return ser.args[0]
except KeyboardInterrupt:
return os.EX_NOUSER
print ''
# optparse type extenstions --------------------------------------------------
def remove_content(self, csId, contentType, attrs):
path = "/api/changesets/%s/%s/%s/" % (u_str(csId), contentType, u_str(attrs['content_id']))
return self.server.DELETE(path, attrs)[1]
def add_content(self, csId, contentType, attrs):
path = "/api/changesets/%s/%s/" % (u_str(csId), contentType)
return self.server.POST(path, attrs)[1]
