def _printItemGrep(self, item, widths={}): """ Print item of a list on single line in grep mode @type item: hash @param item: data to print """ print self._delim, for col in self._columns: #get defined width if col['attr_name'] in widths: width = widths[col['attr_name']] else: width = 0 #skip missing attributes if not col['attr_name'] in item: print " " * width, print self._delim, continue value = item[col['attr_name']] if not col['show_in_grep']: continue if col['multiline']: value = text_to_line(value) if col['time_format'] and value is not None: value = format_date(value) print u_str(value).ljust(width), print self._delim,
def _printItem(self, item, indent=""): """ Print item from a list on number of lines @type item: hash @param item: data to print @type indent: string @param indent: text that is prepended to every printed line in multiline mode """ colWidth = self._minColumnWidth() print for col in self._columns: #skip missing attributes if not col['attr_name'] in item: continue if len(u_str(col['value'])) > 0: value = col['value'] else: value = item[col['attr_name']] if not col['multiline']: output = format_date(value) if col['time_format'] else value print ("{0:<" + u_str(colWidth + 1) + "} {1}").format(col['name'] + ":", output) # +1 to account for the : after the column name else: print indent+col['name']+":" print indent_text(value, indent+" ")
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 _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: self._log.debug("processing response %s\n%s" % (response.status, u_str(response_body))) 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 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 _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: """ print self.__delim, for column in columns: #get defined width width = column_widths.get(column['attr_name'], 0) #skip missing attributes value = self._get_column_value(column, item) if not value: print " " * width, print self.__delim, continue if column.get('multiline', False): value = text_to_line(value) print u_str(value).ljust(width), print self.__delim,
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: """ print self.__delim, 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): print " " * width, print self.__delim, continue value = self._get_column_value(column, item) if column.get('multiline', False): value = text_to_line(value) print u_str(value).ljust(width), print self.__delim,
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 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 update(self, org_id, plan_id, name, sync_date, interval, description): data = {} data = self.update_dict(data, "name", name) data = self.update_dict(data, "description", description) data = self.update_dict(data, "interval", interval) data = self.update_dict(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 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.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 == '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 update(self, orgName, prodId, description, gpgkey, nogpgkey, gpgkey_recursive): product = {} self.update_dict(product, "description", description) self.update_dict(product, "gpg_key_name", gpgkey) self.update_dict(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 _calculateGrepWidths(self, items): widths = {} #return widths for col in self._columns: key = col['attr_name'] widths[key] = len(u_str(col['name']))+1 for item in items: if not key in item: continue value = item[key] if col['time_format'] and value is not None: value = format_date(value) value = u_str(value) if widths[key] < len(value): widths[key] = len(value)+1 return widths
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 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('env') prodName = self.get_option('product') if not repoId: repo = get_repo(orgName, prodName, 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']] self.printer.add_column('id') self.printer.add_column('title') self.printer.add_column('description', multiline=True) self.printer.add_column('type') self.printer.add_column('issued') self.printer.add_column('updated') self.printer.add_column('version') self.printer.add_column('release') self.printer.add_column('status') self.printer.add_column('reboot_suggested') self.printer.add_column('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 = self.update_dict(orgdata, "description", description) path = "/api/organizations/%s" % u_str(name) return self.server.PUT(path, {"organization": orgdata})[1]
def product_by_name(self, orgName, prodName): path = "/api/organizations/%s/products" % u_str(orgName) products = self.server.GET(path, {"name": prodName})[1] if len(products) > 0: return products[0] else: return None
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 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 update(self, user_id, pw, email, disabled): userdata = {} userdata = self.update_dict(userdata, "password", pw) userdata = self.update_dict(userdata, "email", email) userdata = self.update_dict(userdata, "disabled", disabled) path = "/api/users/%s" % u_str(user_id) return self.server.PUT(path, {"user": userdata})[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') if not repoId: repo = get_repo(orgName, prodName, 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']] self.printer.add_column('id') self.printer.add_column('title') self.printer.add_column('description', multiline=True) self.printer.add_column('type') self.printer.add_column('issued') self.printer.add_column('updated') self.printer.add_column('version') self.printer.add_column('release') self.printer.add_column('status') self.printer.add_column('reboot_suggested') self.printer.add_column('affected_packages', multiline=True) self.printer.set_header(_("Errata Information")) self.printer.print_item(pack) return os.EX_OK
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 create(self, org, name, description, filter_list): data = { "name": name, "description": description, "package_list": filter_list } path = "/api/organizations/%s/filters" % u_str(org) return self.server.POST(path, data)[1]
def error(self, errorMsg): errorMsg = u_str(errorMsg) _log.error("error: %s" % errorMsg) if errorMsg == '': msg = _('error: operation failed') else: msg = errorMsg print >> sys.stderr, msg
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 text_to_line(text, glue=" "): if text == None: text = u_str(None) if isinstance(text, (list)): return glue.join(text) else: return glue.join(text.split("\n"))
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 error(self, error_msg): error_msg = u_str(error_msg) _log.error("error: %s" % error_msg) if error_msg == "": msg = _("error: operation failed") else: msg = error_msg print >> sys.stderr, msg
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 _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 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 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 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 store_item_with_product(self, option, opt_str, value, parser): if parser.values.from_product == None: raise OptionValueError( _("%s must be preceded by %s") % (option, "--from_product")) self.items[option.dest].append({ "name": u_str(value), "product": self.current_product })
def update(self, provId, name, description=None, url=None): provdata = {} provdata = self.update_dict(provdata, "name", name) provdata = self.update_dict(provdata, "description", description) provdata = self.update_dict(provdata, "repository_url", url) path = "/api/providers/%s" % u_str(provId) return self.server.PUT(path, {"provider": provdata})[1]
def create(self, provId, name, description, gpgkey): product = { "name": name, "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 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 update(self, tplId, newName, description, parentId): tplData = {} tplData = self.update_dict(tplData, "name", newName) tplData = self.update_dict(tplData, "description", description) tplData = self.update_dict(tplData, "parent_id", parentId) tplData = {"template": tplData} path = "/api/templates/%s" % u_str(tplId) return self.server.PUT(path, tplData)[1]
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 update(self, user_id, pw, email, disabled, default_environment): userdata = {} userdata = self.update_dict(userdata, "password", pw) userdata = self.update_dict(userdata, "email", email) userdata = self.update_dict(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 path = "/api/users/%s" % u_str(user_id) return self.server.PUT(path, {"user": userdata})[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 """ print 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) print("{0:<" + u_str(col_width + 1) + "} {1}").format( u_str(column['name']) + ":", u_str(value)) # +1 to account for the : after the column name else: print column['name'] + ":" print indent_text(value, " ")
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 not text: text = u_str(None) if isinstance(text, (list)): return glue.join(text) else: return glue.join(text.split("\n"))
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 not text: text = u_str(None) if isinstance(text, (list)): glue = "\n" + indent return indent + glue.join(text) else: return indent_text(text.split("\n"), indent)
def create(self, roleId, name, description, type, verbs, tagIds, orgId=None): data = { "name": name, "description": description, "type": type, "verbs": verbs, "tags": tagIds, "organization_id": orgId } path = "/api/roles/%s/permissions/" % u_str(roleId) return self.server.POST(path, data)[1]
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 """ key = column['attr_name'] width = len(column['name']) + 1 for column_value in [ u_str(self._get_column_value(column, item)) for item in items ]: if width <= len(column_value): width = len(column_value) + 1 return width
def select_repositories(self, repourls, assumeyes, 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 = 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_item(self, option, opt_str, value, parser): self.items[option.dest].append({"name": u_str(value)})
def cancel_sync(self, orgName, prodId): path = "/api/organizations/%s/products/%s/sync" % (u_str(orgName), u_str(prodId)) return self.server.DELETE(path)[1]
def store_from_product(self, option, opt_str, value, parser): self.current_product = u_str(value) parser.values.from_product = True
def store_parameter_value(self, option, opt_str, value, parser): if self.current_parameter == None: raise OptionValueError(_("each %s must be preceeded by %s") % (option, "--add_parameter") ) self.items['add_parameters'][self.current_parameter] = u_str(value) self.current_parameter = None
def delete(self, org_id, system_group_id): path = "/api/organizations/%s/system_groups/%s" % ( u_str(org_id), u_str(system_group_id)) return self.server.DELETE(path)[1]
def error(self, exception, errorMsg=None): msg = errorMsg if errorMsg else u_str(exception) print >> sys.stderr, "error: %s (more in the log file %s)" % ( msg, logfile()) _log.error(u_str(exception)) _log.error(format_exc(exception))
def store_parameter_name(self, option, opt_str, value, parser): self.current_parameter = u_str(value) self.items['add_parameters'][value] = None