Example #1
0
    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,
Example #2
0
    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+"    ")
Example #3
0
    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, "    "))
Example #4
0
    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())
Example #5
0
    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]
Example #6
0
    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,
Example #7
0
    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,
Example #8
0
    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)
Example #9
0
    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]
Example #10
0
    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]
Example #11
0
    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
Example #12
0
    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
Example #13
0
    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
Example #14
0
    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})
Example #15
0
    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
Example #16
0
    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
Example #17
0
    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)))))
Example #18
0
    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
Example #19
0
    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
Example #20
0
    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]
Example #21
0
 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
Example #22
0
    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]
Example #23
0
 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
Example #24
0
 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
Example #25
0
 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]
Example #26
0
    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
Example #27
0
 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
Example #28
0
 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]
Example #29
0
 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
Example #30
0
 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
Example #31
0
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"))
Example #32
0
 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
Example #33
0
 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
Example #34
0
 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
Example #35
0
 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
Example #36
0
    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
Example #37
0
    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
Example #38
0
 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]
Example #39
0
 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]
Example #40
0
    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]
Example #41
0
    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
        })
Example #42
0
    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]
Example #43
0
    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
Example #44
0
    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
Example #45
0
    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]
Example #46
0
 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
Example #47
0
File: user.py Project: beav/katello
    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]
Example #48
0
    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, "    ")
Example #49
0
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"))
Example #50
0
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)
Example #51
0
 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]
Example #52
0
 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
Example #53
0
File: repo.py Project: beav/katello
    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
Example #54
0
 def store_item(self, option, opt_str, value, parser):
     self.items[option.dest].append({"name": u_str(value)})
Example #55
0
 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]
Example #56
0
 def store_from_product(self, option, opt_str, value, parser):
     self.current_product = u_str(value)
     parser.values.from_product = True
Example #57
0
    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
Example #58
0
 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]
Example #59
0
 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))
Example #60
0
 def store_parameter_name(self, option, opt_str, value, parser):
     self.current_parameter = u_str(value)
     self.items['add_parameters'][value] = None