示例#1
0
def main():
    available_repositories = utils.available_repositories()
    for item in os.listdir(cst.repos):
        repo_conf = os.path.join(cst.repos, item, cst.repo_file)
        if os.access(repo_conf, os.F_OK):
            with open(repo_conf) as data:
                data = conf.ReadConfig(data.read().splitlines(), delimiter="@")
            if item in available_repositories:
                out.normal("%s [%s]" % (item, out.color("enabled", "brightgreen")))
            else:
                out.normal("%s [%s]" % (item, out.color("disabled", "brightred")))
            out.notify("system name: %s" % item)
            if hasattr(data, "name"):
                out.notify("development name: %s" % data.name)
            else:
                out.warn("development name is not defined!")
            if hasattr(data, "summary"):
                out.notify("summary: %s" % data.summary)
            else:
                out.warn("summary is not defined!")
            if hasattr(data, "maintainer"):
                out.notify("maintainer: %s" % data.maintainer)
            else:
                out.warn("maintainer is not defined!")
            out.write("\n")
示例#2
0
    def main(self):
        out.normal("searching for %s\n" % self.keyword)

        for (repo, category, name, version, path) in self.search():
            try:
                replace = re.compile("(%s)" % "|".join([self.keyword]), re.I)
                out.write(
                    "%s/%s/%s-%s -- %s\n"
                    % (
                        out.color(repo, "green"),
                        out.color(category, "green"),
                        out.color(name, "green"),
                        out.color(version, "green"),
                        replace.sub(out.color(r"\1", "brightred"), path),
                    )
                )
            except:
                out.write(
                    "%s/%s/%s-%s -- %s\n"
                    % (
                        out.color(repo, "green"),
                        out.color(category, "green"),
                        out.color(name, "green"),
                        out.color(version, "green"),
                        path,
                    )
                )
示例#3
0
 def about(self):
     """
     Shows application name and version and exits
     """
     out.write("%s %s\n" % (__APP_NAME__, __VERSION__))
     # Do nothing after after showing version information
     sys.exit(0)
示例#4
0
    def run_extract(self):
        # if the environment has no extract_plan variable, doesn't run extract function
        if not hasattr(self.environment, "extract_nevertheless"
                       ) or not self.environment.extract_nevertheless:
            if not hasattr(self.environment, "extract_plan"): return
        target = os.path.dirname(self.environment.build_dir)
        extracted_file = os.path.join(os.path.dirname(target), ".extracted")
        if os.path.isfile(extracted_file):
            if self.environment.force_extract:
                shelltools.remove_file(extracted_file)
            else:
                out.write("%s %s/%s-%s had been already extracted.\n" % (out.color(">>", "brightyellow"), \
                    self.environment.category, self.environment.name, self.environment.version))
                return True

        utils.xterm_title("lpms: extracting %s/%s/%s-%s" % (self.environment.repo, self.environment.category, \
                self.environment.name, self.environment.version))
        out.notify("extracting archive(s) to %s" %
                   os.path.dirname(self.environment.build_dir))

        # now, extract the archives
        self.run_stage("extract")
        out.notify("%s has been extracted." % self.environment.fullname)
        shelltools.touch(extracted_file)
        if self.environment.stage == "extract":
            lpms.terminate()
示例#5
0
def initialize():
    '''Initializes lpms package manager'''
    try:
        LPMSCore().initialize()
    except LpmsTerminate as err:
        # TODO: Parse these err variable when debug mode is enabled.
        out.write("Terminated.\n")
示例#6
0
def main():
    available_repositories = utils.available_repositories()
    for item in os.listdir(cst.repos):
        repo_conf = os.path.join(cst.repos, item, cst.repo_file)
        if os.access(repo_conf, os.F_OK):
            with open(repo_conf) as data:
                data = conf.ReadConfig(data.read().splitlines(), delimiter="@")
            if item in available_repositories:
                out.normal("%s [%s]" %
                           (item, out.color("enabled", "brightgreen")))
            else:
                out.normal("%s [%s]" %
                           (item, out.color("disabled", "brightred")))
            out.notify("system name: %s" % item)
            if hasattr(data, "name"):
                out.notify("development name: %s" % data.name)
            else:
                out.warn("development name is not defined!")
            if hasattr(data, "summary"):
                out.notify("summary: %s" % data.summary)
            else:
                out.warn("summary is not defined!")
            if hasattr(data, "maintainer"):
                out.notify("maintainer: %s" % data.maintainer)
            else:
                out.warn("maintainer is not defined!")
            out.write("\n")
示例#7
0
def system(cmd, show=False, stage=None, sandbox=None):
    cfg = conf.LPMSConfig()
    if sandbox is None:
        sandbox = True if cfg.sandbox else False
        # override 'sandbox' variable if the user wants to modifiy from cli
        if lpms.getopt("--enable-sandbox"):
            sandbox = True
        elif lpms.getopt("--disable-sandbox"):
            sandbox = False
    if lpms.getopt("--verbose"):
        ret, output, err = run_cmd(cmd, True)
    elif (not cfg.print_output or lpms.getopt("--quiet")) and not show:
        ret, output, err = run_cmd(cmd, show=False, enable_sandbox=sandbox)
    else:
        ret, output, err = run_cmd(cmd, show=True, enable_sandbox=sandbox)

    if ret != 0:
        if not conf.LPMSConfig().print_output or lpms.getopt("--quiet"):
            out.brightred("\n>> error messages:\n")
            out.write(err)
        out.warn("command failed: %s" % out.color(cmd, "red"))
        if stage and output and err:
            return False, output + err
        return False
    return True
示例#8
0
    def main(self):
        if not self.command_line:
            out.error("no command given.")
            return

        for command in self.command_line:
            if command == "list":
                self.list_news()
                return
            elif command == "read":
                id_index = self.command_line.index(command) + 1
                try:
                    self.cursor.get_all_news()
                    news_id = self.command_line[id_index]
                    self.read_news(news_id)
                    return
                except IndexError:
                    out.error("you must give a index number!")
                    return
            elif command in ("--help", "-h"):
                self.usage()
                return
            elif command in ("--help", "-h"):
                out.write("lnews %s\n" % __version__)
                return
            else:
                out.error("invalid command: %s" % command)
                return
示例#9
0
 def about(self):
     """
     Shows application name and version and exits
     """
     out.write("%s %s\n" % (__APP_NAME__, __VERSION__))
     # Do nothing after after showing version information
     sys.exit(0)
示例#10
0
    def main(self):
        if not self.command_line:
            out.error("no command given.")
            return

        for command in self.command_line:
            if command == "list":
                self.list_news()
                return
            elif command == "read":
                id_index = self.command_line.index(command) + 1
                try:
                    self.cursor.get_all_news()
                    news_id = self.command_line[id_index]
                    self.read_news(news_id)
                    return
                except IndexError:
                    out.error("you must give a index number!")
                    return
            elif command in ("--help", "-h"):
                self.usage()
                return
            elif command in ("--help", "-h"):
                out.write("lnews %s\n" % __version__)
                return
            else:
                out.error("invalid command: %s" % command)
                return
示例#11
0
def system(cmd, show=False, stage=None, sandbox=None):
    cfg = conf.LPMSConfig()
    if sandbox is None:
        sandbox = True if cfg.sandbox else False
        # override 'sandbox' variable if the user wants to modifiy from cli
        if lpms.getopt('--enable-sandbox'):
            sandbox = True
        elif lpms.getopt('--disable-sandbox'):
            sandbox = False
    if lpms.getopt("--verbose"):
        ret, output, err = run_cmd(cmd, True)
    elif (not cfg.print_output or lpms.getopt("--quiet")) \
            and not show:
        ret, output, err = run_cmd(cmd, show=False, enable_sandbox=sandbox)
    else:
        ret, output, err = run_cmd(cmd, show=True, enable_sandbox=sandbox)

    if ret != 0:
        if not conf.LPMSConfig().print_output or lpms.getopt("--quiet"):
            out.brightred("\n>> error messages:\n")
            out.write(err)
        out.warn("command failed: %s" % out.color(cmd, "red"))
        if stage and output and err:
            return False, output + err
        return False
    return True
示例#12
0
 def remove(self):
     try:
         api.remove_package(self.request.names, self.request.instruction)
     except PackageNotFound as err:
         out.write(">> %s could not be found.\n" %
                   out.color(err.message, "red"))
         sys.exit(0)
示例#13
0
 def parse_traceback(exception_type=None):
     '''Parse exceptions and show nice and more readable error messages'''
     out.write(
         out.color(">>", "brightred") + " %s/%s/%s-%s\n" %
         (self.environment.repo, self.environment.category,
          self.environment.name, self.environment.version))
     exc_type, exc_value, exc_traceback = sys.exc_info()
     formatted_lines = traceback.format_exception(
         exc_type, exc_value, exc_traceback)
     if not self.environment.debug:
         for item in formatted_lines:
             item = item.strip()
             if item.startswith("File"):
                 regex = re.compile(r'(\w+)\S*$')
                 regex = regex.search(item)
                 if regex is None:
                     continue
                 if regex.group() in operation_order:
                     line = re.compile(r'[^\d.]+')
                     line = line.sub('', item)
                     out.write("%s %s " %
                               (out.color("on line %s:" % line,
                                          "red"), formatted_lines[-1]))
                     break
     else:
         traceback.print_exc()
     out.error("an error occurred when running the %s function." %
               out.color(operation, "red"))
     return False
示例#14
0
    def perform_operation(self):
        utils.xterm_title("(%s/%s) lpms: merging %s/%s-%s from %s" %
                          (self.environment.index, self.environment.count,
                           self.environment.category, self.environment.name,
                           self.environment.version, self.environment.repo))
        # create $info_file_name.gz archive and remove info file
        self.create_info_archive()
        # merge the package
        self.merge_package()
        # clean the previous version if it is exists
        self.clean_obsolete_content()
        # write to database
        self.write_db()
        # create or update /usr/share/info/dir
        self.update_info_index()

        if self.backup:
            out.write("%s%s configuration file changed. Use %s to fix these files.\n" %
                    (out.color(" > ", "green"), len(self.backup), \
                            out.color("merge-conf", "red")))

        if shelltools.is_exists(cst.lock_file):
            shelltools.remove_file(cst.lock_file)

        return True, self.environment
示例#15
0
def main(files):
    opr = Generate(os.getcwd(), files)
    if "--help" in files:
        usage()
    elif "--version" in files:
        out.write("%s-%s\n" % (app_name, app_version))
    opr.check_repo_dir()
    opr.calculate_hashes()
示例#16
0
def main(files):
    opr = Generate(os.getcwd(), files)
    if "--help" in files:
        usage()
    elif "--version" in files:
        out.write("%s-%s\n" % (app_name, app_version))
    opr.check_repo_dir()
    opr.calculate_hashes()
示例#17
0
def confirm(text):
    turns = 5
    while turns:
        turns -= 1
        out.warn(text+"["+out.color("yes", "green")+"/"+out.color("no", "red")+"]")
        answer = sys.stdin.readline().strip()
        if answer == "yes" or answer == "y" or answer == "":
            return True
        elif answer == "no" or answer == "n":
            return False
        out.write(out.color("Sorry, response " + answer + " not understood! yes/y or no/n\n", "red"))
示例#18
0
def gnome2_icon_cache_update(*args, **kwargs):
    parameters = "-q -t -f"
    target = "/usr/share/icons/hicolor"

    if args:
        parameters = " ".join(args)

    if kwargs:
        if "target" in kwargs:
            target = kwargs["target"]

    out.notify("updating GTK+ icon cache...")
    if not shelltools.system("gtk-update-icon-cache %s %s" % (parameters, target), sandbox=False):
        out.write(out.color("\n\tFAILED\n", "red"))
示例#19
0
def confirm(text):
    turns = 5
    while turns:
        turns -= 1
        out.warn(text + "[" + out.color("yes", "green") + "/" +
                 out.color("no", "red") + "]")
        answer = sys.stdin.readline().strip()
        if answer == "yes" or answer == "y" or answer == "":
            return True
        elif answer == "no" or answer == "n":
            return False
        out.write(
            out.color(
                "Sorry, response " + answer +
                " not understood! yes/y or no/n\n", "red"))
示例#20
0
    def main(self):
        out.normal("searching for %s\n" % self.keyword)

        for (repo, category, name, version, path) in self.search():
            try:
                replace = re.compile("(%s)" % '|'.join([self.keyword]), re.I)
                out.write(
                    "%s/%s/%s-%s -- %s\n" %
                    (out.color(repo, "green"), out.color(category, "green"),
                     out.color(name, "green"), out.color(version, "green"),
                     replace.sub(out.color(r"\1", "brightred"), path)))
            except:
                out.write(
                    "%s/%s/%s-%s -- %s\n" %
                    (out.color(repo, "green"), out.color(
                        category, "green"), out.color(
                            name, "green"), out.color(version, "green"), path))
示例#21
0
def standard_extract():
    """
    Runs standard extract procedure
    """
    target = os.path.dirname(build_dir)
    for url in extract_plan:
        out.write("   %s %s\n" % (out.color(">", "green"), \
                os.path.join(cfg.LPMSConfig().src_cache, \
                os.path.basename(url))))
        archive_path = os.path.join(cfg.LPMSConfig().src_cache, \
                os.path.basename(url))
        try:
            partial = [atom.strip() for atom in partial.split(" ")
                    if atom != "#"]
            archive.extract(str(archive_path), str(target), partial)
        except NameError:
            archive.extract(str(archive_path), str(target))
示例#22
0
    def select_pkgs(self):
        for pkg in self.instdb.get_all_packages():
            self.repo, self.category, self.name, self.version, self.slot = pkg
            # catch packages which are from the outside
            if not self.repodb.find_package(package_name=self.name, \
                    package_category=self.category):
                if not (self.category, self.name) in self.notfound_pkg:
                    self.notfound_pkg.append((self.category, self.name))

            # get version data from repository database
            repository_items = self.repodb.find_package(package_name=self.name, \
                    package_category=self.category)
            if not repository_items:
                # if the installed package could not found in the repository database
                # add the item to not-founds list
                self.notfound_pkg.append((self.category, self.name))
                continue

            # collect available package version by slot value
            available_versions = {}
            for item in repository_items:
                if item.slot in available_versions:
                    available_versions[item.slot].append(item.version)
                else:
                    available_versions[item.slot] = [item.version]

            # comparise versions
            for item in repository_items:
                if item.slot == self.slot:
                    best_version = utils.best_version(
                        available_versions[item.slot])
                    result = utils.vercmp(best_version, self.version)
                    if result != 0:
                        self.packages.append(
                            os.path.join(self.category, self.name) + ":" +
                            self.slot)
                        break

        if self.notfound_pkg:
            out.write(
                "%s: the following packages were installed but they could not be found in the database:\n\n"
                % out.color("WARNING", "brightyellow"))
            for no_category, no_name, in self.notfound_pkg:
                out.notify("%s/%s" % (no_category, no_name))
            out.write("\n")
示例#23
0
def standard_extract():
    """
    Runs standard extract procedure
    """
    target = os.path.dirname(build_dir)
    for url in extract_plan:
        out.write("   %s %s\n" % (out.color(">", "green"), \
                os.path.join(cfg.LPMSConfig().src_cache, \
                os.path.basename(url))))
        archive_path = os.path.join(cfg.LPMSConfig().src_cache, \
                os.path.basename(url))
        try:
            partial = [
                atom.strip() for atom in partial.split(" ") if atom != "#"
            ]
            archive.extract(str(archive_path), str(target), partial)
        except NameError:
            archive.extract(str(archive_path), str(target))
示例#24
0
    def read_news(self, news_id):
        try:
            news_id = int(news_id)
            repo, metadata, message = self.cursor.data[news_id]
        except ValueError:
            out.error("invalid id: %s" % news_id)
            return
        except IndexError:
            out.error("message found not found with this id: %d" % news_id)
            return

        out.write(out.color("from", "green")+": "+metadata["from"]+"\n")
        out.write(out.color("summary", "green")+": "+metadata["summary"]+"\n")
        out.write(out.color("date", "green")+": "+metadata["date"]+"\n")
        out.write(out.color("priority", "green")+": "+metadata["priority"]+"\n")
        out.write(message+"\n")

        self.cursor.mark_as_read("%s/%s" % (repo, metadata["summary"]))
示例#25
0
    def select_pkgs(self):
        for pkg in self.instdb.get_all_packages():
            self.repo, self.category, self.name, self.version, self.slot = pkg
            # catch packages which are from the outside
            if not self.repodb.find_package(package_name=self.name, \
                    package_category=self.category):
                if not (self.category, self.name) in self.notfound_pkg:
                    self.notfound_pkg.append((self.category, self.name))

            # get version data from repository database
            repository_items = self.repodb.find_package(package_name=self.name, \
                    package_category=self.category)
            if not repository_items:
                # if the installed package could not found in the repository database
                # add the item to not-founds list
                self.notfound_pkg.append((self.category, self.name))
                continue

            # collect available package version by slot value
            available_versions = {}
            for item in repository_items:
                if item.slot in available_versions:
                    available_versions[item.slot].append(item.version)
                else:
                    available_versions[item.slot] = [item.version]

            # comparise versions
            for item in repository_items:
                if item.slot == self.slot:
                    best_version = utils.best_version(available_versions[item.slot])
                    result = utils.vercmp(best_version, self.version)
                    if result != 0:
                        self.packages.append(os.path.join(self.category, self.name)+":"+self.slot)
                        break

        if self.notfound_pkg:
            out.write("%s: the following packages were installed but they could not be found in the database:\n\n" 
                    % out.color("WARNING", "brightyellow"))
            for no_category, no_name, in self.notfound_pkg:
                out.notify("%s/%s" % (no_category, no_name))
            out.write("\n")
示例#26
0
    def read_news(self, news_id):
        try:
            news_id = int(news_id)
            repo, metadata, message = self.cursor.data[news_id]
        except ValueError:
            out.error("invalid id: %s" % news_id)
            return
        except IndexError:
            out.error("message found not found with this id: %d" % news_id)
            return

        out.write(out.color("from", "green") + ": " + metadata["from"] + "\n")
        out.write(
            out.color("summary", "green") + ": " + metadata["summary"] + "\n")
        out.write(out.color("date", "green") + ": " + metadata["date"] + "\n")
        out.write(
            out.color("priority", "green") + ": " + metadata["priority"] +
            "\n")
        out.write(message + "\n")

        self.cursor.mark_as_read("%s/%s" % (repo, metadata["summary"]))
示例#27
0
 def show_info(self, package):
     items = self.instdb.database.get_package_build_info(package.id)   
     template = (
             'Start_Time',
             'End Time',
             'Requestor',
             'Requestor ID',
             'HOST',
             'CFLAGS',
             'CXXFLAGS',
             'LDFLAGS',
             'JOBS',
             'CC',
             'CXX'
     )
     out.normal("Build information for %s/%s/%s-%s {%s:%s}" % (package.repo, \
             package.category, package.name, package.version, package.slot, package.arch))
     for index, item in enumerate(template, 1):
         if index in (1, 2):
             out.write("%s: %s\n" % (out.color(item, "green"), \
                     datetime.datetime.fromtimestamp(items[index]).strftime('%Y-%m-%d %H:%M:%S')))
             if index == 2:
                 delta = datetime.datetime.fromtimestamp(items[2])-\
                         datetime.datetime.fromtimestamp(items[1])
                 operation_time = str(round(float(delta.seconds)/60, 1))+" minutes" if delta.seconds >= 60 \
                         else str(delta.seconds)+" seconds"
                 out.write("%s: %s\n" % (out.color("Operation Time", "green"), operation_time))
             continue
         out.write("%s: %s\n" % (out.color(item, "green"), items[index]))
示例#28
0
def usage():
    out.normal("A tool that creates \'hashes\' file for lpms packages.")
    out.green("General Usage:\n")
    out.write(" $ lhashgen <spec name>\n")
    out.write("\nIf you do not give any package name with command, it scans the directory and operates all valid specs\n")
    out.write("\nUse \'--version\' to see program's version\n")
    lpms.terminate()
示例#29
0
    def perform_operation(self):
        utils.xterm_title("(%s/%s) lpms: merging %s/%s-%s from %s" % (self.environment.index, self.environment.count, 
            self.environment.category, self.environment.name, self.environment.version, self.environment.repo))
        # create $info_file_name.gz archive and remove info file
        self.create_info_archive()
        # merge the package
        self.merge_package()
        # clean the previous version if it is exists
        self.clean_obsolete_content()
        # write to database
        self.write_db()
        # create or update /usr/share/info/dir 
        self.update_info_index()

        if self.backup:
            out.write("%s%s configuration file changed. Use %s to fix these files.\n" % 
                    (out.color(" > ", "green"), len(self.backup), \
                            out.color("merge-conf", "red")))

        if shelltools.is_exists(cst.lock_file):
            shelltools.remove_file(cst.lock_file)

        return True, self.environment
示例#30
0
 def parse_traceback(exception_type=None):
     '''Parse exceptions and show nice and more readable error messages'''
     out.write(out.color(">>", "brightred")+" %s/%s/%s-%s\n" % (self.environment.repo, self.environment.category, 
         self.environment.name, self.environment.version))
     exc_type, exc_value, exc_traceback = sys.exc_info()
     formatted_lines = traceback.format_exception(exc_type, exc_value, exc_traceback)
     if not self.environment.debug:
         for item in formatted_lines:
             item = item.strip()
             if item.startswith("File"):
                 regex = re.compile(r'(\w+)\S*$')
                 regex = regex.search(item)
                 if regex is None:
                     continue
                 if regex.group() in operation_order:
                     line = re.compile(r'[^\d.]+')
                     line = line.sub('', item)
                     out.write("%s %s " % (out.color("on line %s:" % line, "red"), formatted_lines[-1]))
                     break
     else:
         traceback.print_exc()
     out.error("an error occurred when running the %s function." % out.color(operation, "red"))
     return False
示例#31
0
def usage():
    out.normal("A tool that creates \'hashes\' file for lpms packages.")
    out.green("General Usage:\n")
    out.write(" $ lhashgen <spec name>\n")
    out.write(
        "\nIf you do not give any package name with command, it scans the directory and operates all valid specs\n"
    )
    out.write("\nUse \'--version\' to see program's version\n")
    lpms.terminate()
示例#32
0
    def run_extract(self):
        # if the environment has no extract_plan variable, doesn't run extract function
        if not hasattr(self.environment, "extract_nevertheless") or not self.environment.extract_nevertheless:
            if not hasattr(self.environment, "extract_plan"): return
        target = os.path.dirname(self.environment.build_dir)
        extracted_file = os.path.join(os.path.dirname(target), ".extracted")
        if os.path.isfile(extracted_file):
            if self.environment.force_extract:
                shelltools.remove_file(extracted_file)
            else:
                out.write("%s %s/%s-%s had been already extracted.\n" % (out.color(">>", "brightyellow"), \
                    self.environment.category, self.environment.name, self.environment.version))
                return True

        utils.xterm_title("lpms: extracting %s/%s/%s-%s" % (self.environment.repo, self.environment.category, \
                self.environment.name, self.environment.version))
        out.notify("extracting archive(s) to %s" % os.path.dirname(self.environment.build_dir))
        
        # now, extract the archives
        self.run_stage("extract")
        out.notify("%s has been extracted." % self.environment.fullname)
        shelltools.touch(extracted_file)
        if self.environment.stage == "extract":
            lpms.terminate()
示例#33
0
 def usage(self):
     out.normal("Search given keywords in database")
     out.green("General Usage:\n")
     out.write(" $ lpms -s <keyword>\n")
     out.write("\nOther options:\n")
     for item in help_output:
         if len(item) == 2:
             out.write("%-28s: %s\n" %
                       (out.color(item[0], "green"), item[1]))
     lpms.terminate()
示例#34
0
        def collision_check():
            # TODO: This is a temporary solution. collision_check function
            # must be a reusable part for using in remove operation
            out.normal("checking file collisions...")
            lpms.logger.info("checking file collisions")
            collision_object = file_collisions.CollisionProtect(
                environment.category,
                environment.name,
                environment.slot,
                real_root=environment.real_root,
                source_dir=environment.install_dir)
            collision_object.handle_collisions()
            if collision_object.orphans:
                out.write(
                    out.color(" > ", "brightyellow") +
                    "these files are orphan. the package will adopt the files:\n"
                )
                index = 0
                for orphan in collision_object.orphans:
                    out.notify(orphan)
                    index += 1
                    if index > 100:
                        # FIXME: the files must be logged
                        out.write(
                            out.color(" > ", "brightyellow") +
                            "...and many others.")
                        break

            if collision_object.collisions:
                out.write(
                    out.color(" > ", "brightyellow") +
                    "file collisions detected:\n")
            for item in collision_object.collisions:
                (category, name, slot, version), path = item
                out.write(out.color(" -- ", "red")+category+"/"+name+"-"\
                        +version+":"+slot+" -> "+path+"\n")
            if collision_object.collisions and self.config.collision_protect:
                if environment.force_file_collision:
                    out.warn(
                        "Disregarding these collisions, you have been warned!")
                else:
                    return False
            return True
示例#35
0
    def main(self):
        parsed = self.pkgname.split("/")
        if len(parsed) == 3:
            repo, category, name = parsed
            name, version = utils.parse_pkgname(name)
            packages = self.instdb.find_package(
                    package_repo=repo,
                    package_category=category,
                    package_name=name,
                    package_version=version
                    )
        elif len(parsed) == 2:
            category, name = parsed
            name, version = utils.parse_pkgname(name)
            packages = self.instdb.find_package(
                    package_category=category,
                    package_name=name,
                    package_version=version
                    )
        elif len(parsed) == 1:
            name, version = utils.parse_pkgname(self.pkgname)
            packages = self.instdb.find_package(
                    package_name=name,
                    package_version=version
                    )
        else:
            out.error("%s could not be recognized." % self.pkgname)
            lpms.terminate()

        if not packages:
            out.error("%s not installed." % self.pkgname)
            lpms.terminate()
        
        for package in packages:        
            symdirs = {}
            out.normal("%s/%s/%s-%s" % (package.repo, package.category, \
                    package.name, package.version))
            content = self.filesdb.get_paths_by_package(package.name, \
                    category=package.category, version=package.version)
            for item in content:
                item = item[0].encode('UTF-8')
                if os.path.islink(item):
                    out.write("%s -> %s\n" % (out.color(item, "green"), os.readlink(item)))
                    if os.path.isdir(os.path.realpath(item)):
                        symdirs[os.path.realpath(item)+"/"] = item+"/"
                else:
                    out.write(item+"\n")
                if symdirs:
                    for symdir in symdirs:
                        if item.startswith(symdir):
                            out.write("%s -> %s\n" % (out.color(item.replace(symdir, \
                                    symdirs[symdir]), "brightwhite"), out.color(item, "brightwhite")))
示例#36
0
    def main(self):
        parsed = self.pkgname.split("/")
        if len(parsed) == 3:
            repo, category, name = parsed
            name, version = utils.parse_pkgname(name)
            packages = self.instdb.find_package(
                package_repo=repo, package_category=category, package_name=name, package_version=version
            )
        elif len(parsed) == 2:
            category, name = parsed
            name, version = utils.parse_pkgname(name)
            packages = self.instdb.find_package(package_category=category, package_name=name, package_version=version)
        elif len(parsed) == 1:
            name, version = utils.parse_pkgname(self.pkgname)
            packages = self.instdb.find_package(package_name=name, package_version=version)
        else:
            out.error("%s could not be recognized." % self.pkgname)
            lpms.terminate()

        if not packages:
            out.error("%s not installed." % self.pkgname)
            lpms.terminate()

        for package in packages:
            symdirs = {}
            out.normal("%s/%s/%s-%s" % (package.repo, package.category, package.name, package.version))
            content = self.filesdb.get_paths_by_package(
                package.name, category=package.category, version=package.version
            )
            for item in content:
                item = item[0].encode("UTF-8")
                if os.path.islink(item):
                    out.write("%s -> %s\n" % (out.color(item, "green"), os.readlink(item)))
                    if os.path.isdir(os.path.realpath(item)):
                        symdirs[os.path.realpath(item) + "/"] = item + "/"
                else:
                    out.write(item + "\n")
                if symdirs:
                    for symdir in symdirs:
                        if item.startswith(symdir):
                            out.write(
                                "%s -> %s\n"
                                % (
                                    out.color(item.replace(symdir, symdirs[symdir]), "brightwhite"),
                                    out.color(item, "brightwhite"),
                                )
                            )
示例#37
0
    def list_news(self):
        self.cursor.get_all_news()
        i = 0
        if not self.cursor.data:
            out.warn("no readable news.")
            return
        out.normal("readable messages listed:")
        out.write("index   repo            priority     summary\n")
        out.write("===============================================\n")
        for news in self.cursor.data:
            repo, metadata = news[:-1]
            if not "%s/%s" % (repo, metadata["summary"]) in self.read_items:
                read = out.color("*", "brightgreen")
            else:
                read = ""

            out.write("[%s]%s\t%-15s\t%-12s %s\n" % (out.color(str(i), "green"), read, repo, \
                    metadata["priority"], metadata["summary"]))
            i += 1
示例#38
0
    def list_news(self):
        self.cursor.get_all_news()
        i = 0
        if not self.cursor.data:
            out.warn("no readable news.")
            return
        out.normal("readable messages listed:")
        out.write("index   repo            priority     summary\n")
        out.write("===============================================\n")
        for news in self.cursor.data:
            repo, metadata = news[:-1]
            if not "%s/%s" % (repo, metadata["summary"]) in self.read_items:
                read = out.color("*", "brightgreen")
            else:
                read = ""

            out.write("[%s]%s\t%-15s\t%-12s %s\n" % (out.color(str(i), "green"), read, repo, \
                    metadata["priority"], metadata["summary"]))
            i += 1
示例#39
0
 def show_info(self, package):
     items = self.instdb.database.get_package_build_info(package.id)
     template = (
         "Start_Time",
         "End Time",
         "Requestor",
         "Requestor ID",
         "HOST",
         "CFLAGS",
         "CXXFLAGS",
         "LDFLAGS",
         "JOBS",
         "CC",
         "CXX",
     )
     out.normal(
         "Build information for %s/%s/%s-%s {%s:%s}"
         % (package.repo, package.category, package.name, package.version, package.slot, package.arch)
     )
     for index, item in enumerate(template, 1):
         if index in (1, 2):
             out.write(
                 "%s: %s\n"
                 % (
                     out.color(item, "green"),
                     datetime.datetime.fromtimestamp(items[index]).strftime("%Y-%m-%d %H:%M:%S"),
                 )
             )
             if index == 2:
                 delta = datetime.datetime.fromtimestamp(items[2]) - datetime.datetime.fromtimestamp(items[1])
                 operation_time = (
                     str(round(float(delta.seconds) / 60, 1)) + " minutes"
                     if delta.seconds >= 60
                     else str(delta.seconds) + " seconds"
                 )
                 out.write("%s: %s\n" % (out.color("Operation Time", "green"), operation_time))
             continue
         out.write("%s: %s\n" % (out.color(item, "green"), items[index]))
示例#40
0
    def show_package(self, packages):
        package = packages.get(0)
        installed_packages = self.instdb.find_package(package_name=package.name, package_category=package.category)
        metadata = self.repodb.get_package_metadata(package_id=package.id)
        if installed_packages:
            installed_versions, available_versions, package_options = {}, {}, {}
            for package_item in packages:
                if package_item.arch in available_versions:
                    available_versions[package_item.arch].add(package_item.version)
                else:
                    available_versions[package_item.arch] = set([package_item.version])

            for installed_package in installed_packages:
                if installed_package.arch in installed_versions:
                    installed_versions[installed_package.arch].add(installed_package.version)
                else:
                    installed_versions[installed_package.arch] = set([installed_package.version])
                if installed_package.applied_options is None:
                    continue
                for option in installed_package.options:
                    if option in installed_package.applied_options:
                        key = out.color(
                            "{"
                            + installed_package.slot
                            + "} "
                            + installed_package.repo
                            + "::"
                            + installed_package.version,
                            "yellow",
                        )
                        if not key in package_options:
                            package_options[key] = [out.color(option, "red")]
                        else:
                            package_options[key].append(out.color(option, "red"))
                for option in installed_package.options:
                    if not option in installed_package.applied_options:
                        key = out.color(
                            "{"
                            + installed_package.slot
                            + "} "
                            + installed_package.repo
                            + "::"
                            + installed_package.version,
                            "yellow",
                        )
                        if not key in package_options:
                            package_options[key] = [option]
                        else:
                            package_options[key].append(option)
            versions = ""
            for arch in available_versions:
                versions += out.color(arch, "yellow") + "(" + ", ".join(available_versions[arch]) + ") "
            installed_vers = ""
            for arch in installed_versions:
                installed_vers += out.color(arch, "yellow") + "(" + ", ".join(installed_versions[arch]) + ") "
            out.write(
                "[%s] %s/%s\n"
                % (
                    out.color("I", "backgroundgreen"),
                    out.color(package.category, "brightgreen"),
                    out.color(package.name, "brightgreen"),
                )
            )
            out.write("    %s  %s\n" % (out.color("available versions:", "green"), versions))
            out.write("    %s  %s\n" % (out.color("installed versions:", "green"), installed_vers))
            out.write("    %s             %s\n" % (out.color("summary:", "green"), metadata.summary))
            out.write("    %s            %s\n" % (out.color("homepage:", "green"), metadata.homepage))
            out.write("    %s             %s\n" % (out.color("license:", "green"), metadata.license))
            if package_options:
                out.write("    %s  " % out.color("options:", "green"))
                for index, version in enumerate(package_options):
                    if index == 0:
                        out.write("           => %s" % version + "(" + ", ".join(package_options[version]) + ")")
                    else:
                        out.write(
                            "                         => %s" % out.color(version, "brightblue")
                            + "("
                            + ", ".join(package_options[version])
                            + ")"
                        )
                    out.write("\n")
        else:
            available_versions, package_options = {}, {}
            for package_item in packages:
                if package_item.arch in available_versions:
                    available_versions[package_item.arch].add(package_item.version)
                else:
                    available_versions[package_item.arch] = set([package_item.version])
                if package_item.options is not None:
                    package_options[
                        "{" + package_item.slot + "} " + package_item.repo + "::" + package_item.version
                    ] = package_item.options
            versions = ""
            for arch in available_versions:
                versions += out.color(arch, "yellow") + "(" + ", ".join(available_versions[arch]) + ") "
            out.write("%s %s/%s\n" % (out.color(" * ", "green"), package.category, out.color(package.name, "white")))
            out.write("    %s  %s\n" % (out.color("available versions:", "green"), versions))
            out.write("    %s             %s\n" % (out.color("summary:", "green"), metadata.summary))
            out.write("    %s            %s\n" % (out.color("homepage:", "green"), metadata.homepage))
            out.write("    %s             %s\n" % (out.color("license:", "green"), metadata.license))
            if package_options:
                out.write("    %s  " % out.color("options:", "green"))
                for index, version in enumerate(package_options):
                    if index == 0:
                        out.write(
                            "           => %s" % out.color(version, "brightblue")
                            + "("
                            + ", ".join(package_options[version])
                            + ")"
                        )
                    else:
                        out.write(
                            "                         => %s" % out.color(version, "brightblue")
                            + "("
                            + ", ".join(package_options[version])
                            + ")"
                        )
                    out.write("\n")
示例#41
0
 def usage(self):
     out.normal("Get information about given package")
     out.green("General Usage:\n")
     out.write(" $ lpms -i repo/category/pkgname\n")
     out.write("\nrepo and category keywords are optional.\n")
     lpms.terminate()
示例#42
0
 def usage(self):
     out.normal("news reader for lpms")
     out.write("Use 'list' command to list available messages. For reading these messages, use read <id>\n")
示例#43
0
 def ask():
     for c, s in enumerate(sets):
         out.write("	"+out.color(str(c+1), "green")+") "+s+"\n")
     out.write("\nselect one of them:\n")
     out.write("to exit, press Q or q.\n")
示例#44
0
    def update_package(self, repo_path, category, my_pkg, my_version = None, update = False):
        dataset = LCollect()
        # Register some variables to use after
        self.env.repo = os.path.basename(repo_path)
        self.env.category = category

        dataset.repo = self.env.repo
        dataset.category = category

        os.chdir(os.path.join(repo_path, category, my_pkg))
        for pkg in glob.glob("*"+cst.spec_suffix):
            script_path = os.path.join(repo_path, category, my_pkg, pkg)

            self.env.name, self.env.version = utils.parse_pkgname(pkg.split(cst.spec_suffix)[0])

            dataset.name = self.env.name
            dataset.version = self.env.version

            # FIXME: We must develop a upper-class or environment to 
            # use that cases to prevent code duplication

            # Begins code duplication
            interphase = re.search(r'-r[0-9][0-9]', self.env.version)
            if not interphase:
                interphase = re.search(r'-r[0-9]', self.env.version)
            self.env.raw_version = self.env.version
            self.env.revision = ""
            # Now, set real values of these variables if package revisioned. 
            if interphase is not None and interphase.group():
                self.env.raw_version = self.env.version.replace(interphase.group(), "")
                self.env.revision = interphase.group()
            # End of code duplication

            self.env.__dict__["fullname"] = self.env.name+"-"+self.env.version

            if not self.import_script(script_path):
                out.error("an error occured while processing the spec: %s" \
                        % out.color(script_path, "red"))
                out.error("please report the above error messages to the package maintainer.")
                continue

            metadata = utils.metadata_parser(self.env.metadata)
            metadata.update({"name": self.env.name, "version": self.env.version})
            # This method checks metadata integrity. 
            # It warn the user and pass the spec if a spec is broken
            self.check_metadata_integrity(metadata)
            # These values are optional
            if not "options" in metadata:
                metadata.update({"options": None})
            if not "slot" in metadata:
                metadata.update({"slot": "0"})
            if not "src_url" in metadata:
                metadata.update({"src_url": None})

            if lpms.getopt("--verbose"):
                out.write("    %s-%s\n" % (self.env.name, self.env.version))
            
            try:
                dataset.summary = metadata['summary']
                dataset.homepage = metadata['homepage']
                dataset.license = metadata['license']
                dataset.src_uri = metadata['src_url']
                if metadata['options'] is None:
                    dataset.options = None
                else:
                    dataset.options = metadata['options'].split(" ")
                dataset.slot = metadata['slot']

            except KeyError as err:
                out.error("%s/%s/%s-%s: invalid metadata" % (repo_name, category, \
                        self.env.name, self.env.version))
                out.warn("repository update was failed and the repository database was removed.")
                out.warn("you can run 'lpms --reload-previous-repodb' command to reload previous db version.")
                lpms.terminate("good luck!")

            if update:
                self.repodb.delete_package(package_repo=dataset.repo, package_category=dataset.category, \
                        package_name=self.env.name, package_version=self.env.version)

            static_depends_runtime = []; static_depends_build = []; static_depends_postmerge = []; static_depends_conflict = []
            if 'depends' in self.env.__dict__.keys():
                deps = utils.depends_parser(self.env.depends)
                if 'runtime' in deps:
                    static_depends_runtime.extend(deps['runtime'])
                if 'build' in deps:
                    static_depends_build.extend(deps['build'])
                if 'common' in deps:
                    static_depends_runtime.extend(deps['common'])
                    static_depends_build.extend(deps['common'])
                if 'postmerge' in deps:
                    static_depends_postmerge.extend(deps['postmerge'])
                if 'conflict' in deps:
                    static_depends_conflict.extend(deps['conflict'])

            optional_depends_runtime = []; optional_depends_build = []; optional_depends_postmerge = []; optional_depends_conflict = []
            for opt in ('opt_common', 'opt_conflict', 'opt_postmerge', 'opt_runtime', 'opt_build'):
                try:
                    deps = utils.parse_opt_deps(getattr(self.env, opt))
                    if opt.split("_")[1] == "runtime":
                        optional_depends_runtime.append(deps)
                    elif opt.split("_")[1] == "build":
                        optional_depends_build.append(deps)
                    elif opt.split("_")[1] == "common":
                        optional_depends_build.append(deps)
                        optional_depends_runtime.append(deps)
                    elif opt.split("_")[1] == "postmerge":
                        optional_depends_postmerge.append(deps)
                    elif opt.split("_")[1] == "conflict":
                        optional_depends_conflict.append(deps)
                    del deps
                except AttributeError:
                    continue

            dataset.optional_depends_runtime = optional_depends_runtime
            dataset.optional_depends_build = optional_depends_build
            dataset.optional_depends_postmerge = optional_depends_postmerge
            dataset.optional_depends_conflict = optional_depends_conflict

            dataset.static_depends_runtime = static_depends_runtime
            dataset.static_depends_build = static_depends_build
            dataset.static_depends_postmerge = static_depends_postmerge
            dataset.static_depends_conflict = static_depends_conflict

            if metadata['arch'] is not None:
                arches = metadata['arch'].split(" ")
                for arch in arches:
                    dataset.arch = arch
                    self.repodb.insert_package(dataset)
            else:
                dataset.arch = None
                self.repodb.insert_package(dataset)

            # remove optional keys
            for key in ('depends', 'options', 'opt_runtime', 'opt_build', \
                    'opt_conflict', 'opt_common', 'opt_postmerge'):
                try:
                    del self.env.__dict__[key]
                except KeyError:
                    pass
            self.packages_num += 1
示例#45
0
def main(params):
    # determine operation type
    repo_name = None
    if params:
        repo_name = params[0]

    # create operation object
    operation = Update()

    repo_num = 0 
    if repo_name is None:
        # firstly, lpms tries to create a copy of current repository database.
        db_backup()

        out.normal("updating repository database...")
        operation.repodb.database.begin_transaction()
        for repo_name in os.listdir(cst.repos):
            if not repo_name in utils.available_repositories():
                continue
            if os.path.isfile(os.path.join(cst.repos, repo_name, "info/repo.conf")):
                out.write(out.color(" * ", "red") + repo_name+"\n")
                
                operation.update_repository(repo_name)
                repo_num += 1

        operation.repodb.database.commit()
        out.normal("%s repository(ies) is/are updated." % repo_num)
    else:
        if repo_name == ".":
            current_path = os.getcwd()
            for repo_path in [os.path.join(cst.repos, item) \
                    for item in utils.available_repositories()]:
                if current_path == repo_path or len(current_path.split(repo_path)) == 2:
                    # convert it a valid repo_name variable from the path
                    repo_name = current_path.split(cst.repos)[1][1:]
                    break
            if repo_name == ".":
                out.warn("%s does not seem a valid repository path." % \
                        out.color(current_path, "red"))
                lpms.terminate()

        if len(repo_name.split("/")) == 2:
            out.normal("updating %s" % repo_name)
            repo, category = repo_name.split("/")
            repo_path = os.path.join(cst.repos, repo)
            
            if not repo in utils.available_repositories():
                out.error("%s is not a repository." % out.color(repo, "red"))
                lpms.terminate()

            operation.repodb.database.begin_transaction()
            for pkg in os.listdir(os.path.join(repo_path, category)):
                try:
                    operation.update_package(repo_path, category, pkg, update=True)
                except IntegrityError:
                    continue
            operation.repodb.database.commit()

        elif len(repo_name.split("/")) == 3:
            version = None
            repo, category, name = repo_name.split("/")
            
            if repo.startswith("="):
                repo = repo[1:]
                try:
                    name, version = utils.parse_pkgname(name)
                except TypeError:
                    out.error("you should give a version number")
                    lpms.terminate()
            else:
                if utils.parse_pkgname(name) is not None and len(utils.parse_pkgname(name)) == 2:
                    out.error("you must use %s" % (out.color("="+repo_name, "red")))
                    lpms.terminate()
            
            if not repo in utils.available_repositories():
                out.error("%s is not a repository." % out.color(repo, "red"))
                lpms.terminate()

            repo_path = os.path.join(cst.repos, repo)
            out.normal("updating %s/%s/%s" % (repo, category, name))
            operation.repodb.database.begin_transaction()
            operation.update_package(repo_path, category, name, my_version = version, update = True)
            operation.repodb.database.commit()
        
        else:
            if not repo_name in utils.available_repositories():
                out.error("%s is not a repository." % out.color(repo_name, "red"))
                lpms.terminate()
            
            repo_dir = os.path.join(cst.repos, repo_name)
            if os.path.isdir(repo_dir):
                repo_path = os.path.join(repo_dir, cst.repo_file)
                if os.path.isfile(repo_path):
                    operation.repodb.database.begin_transaction()
                    out.normal("updating repository: %s" % out.color(repo_name, "green"))
                    operation.update_repository(repo_name)
                    operation.repodb.database.commit()
                else:
                    lpms.terminate("repo.conf file could not found in %s" % repo_dir+"/info")
            else:
                lpms.terminate("repo.conf not found in %s" % os.path.join(cst.repos, repo_name))

    out.normal("Total %s packages have been processed." % operation.packages_num)
    
    # Drop inactive repository from the database
    for name in operation.repodb.get_repository_names():
        if not name in utils.available_repositories():
            operation.repodb.delete_repository(name, commit=True)
            out.warn("%s dropped." % name)
    
    # Close the database connection
    operation.repodb.database.close()
示例#46
0
 def ask():
     for c, s in enumerate(sets):
         out.write("	" + out.color(str(c + 1), "green") + ") " + s +
                   "\n")
     out.write("\nselect one of them:\n")
     out.write("to exit, press Q or q.\n")
示例#47
0
    def usage(self):
        """
        Prints available commands with their descriptions.
        """
        out.normal("lpms -- %s Package Management System %s\n" % \
                (out.color("L", "red"), out.color("v"+__VERSION__, "green")))
        out.write("In order to build a package:\n\n")
        out.write(" # lpms <package-name> <extra-command>\n\n")
        out.write("To see extra commands use --help parameter.\n\n")
        out.write("Build related arguments:\n")
        for build_argument in self.build_arguments:
            if hasattr(build_argument, "short"):
                out.write(('%-29s %-10s : %s\n' % \
                        (out.color(build_argument.arg, 'green'), \
                        out.color(build_argument.short, 'green'), \
                        build_argument.description)))
            else:
                out.write(('%-32s : %s\n' % \
                        (out.color(build_argument.arg, 'green'), \
                        build_argument.description)))

        out.write("\nOther arguments:\n")
        for other_argument in self.other_arguments:
            if hasattr(other_argument, "short"):
                out.write(('%-29s %-10s : %s\n' % \
                        (out.color(other_argument.arg, 'green'), \
                        out.color(other_argument.short, 'green'), \
                        other_argument.description)))
            else:
                out.write(('%-32s : %s\n' % \
                        (out.color(other_argument.arg, 'green'), \
                        other_argument.description)))

        # Do nothing after showing help message
        sys.exit(0)
示例#48
0
def show(packages, conflicts, options, installdb):
    '''Shows operation summary to the user'''
    # TODO: This can be splitted as a module
    for package in packages:
        status_bar = [' ', '  ']
        other_version = ""
        installed_packages = installdb.find_package(
                package_name=package.name, \
                package_category=package.category)
        if not installed_packages:
            installed_package = None
            status_bar[0] = out.color("N", "brightgreen")
        else:
            if not [installed_package for installed_package in installed_packages \
                    if package.slot == installed_package.slot]:
                status_bar[1] = out.color("NS", "brightgreen")
            else:
                for installed_package in installed_packages:
                    if installed_package.slot == package.slot:
                        if package.version != installed_package.version:
                            compare = utils.vercmp(package.version, \
                                    installed_package.version)
                            if compare == -1:
                                status_bar[0] = out.color("D", "brightred")
                                other_version = "[%s]" % out.color(\
                                        installed_package.version, "brightred")
                            elif compare == 1:
                                status_bar[0] = out.color("U", "brightgreen")
                                other_version = "[%s]" % out.color(\
                                        installed_package.version, "green")
                        elif package.version == installed_package.version:
                            status_bar[0] = out.color("R", "brightyellow")

        class FormattedOptions(list):
            def __init__(self, data):
                super(FormattedOptions, self).extend(data)

            def append(self, item, color=None):
                self.remove(item)
                if color is not None:
                    super(FormattedOptions, self).insert(0, out.color("*"+item, color))
                else:
                    super(FormattedOptions, self).insert(0, item)

        formatted_options = []
        if package.options is not None:
            installed_package = None
            for item in installed_packages:
                if item.slot == package.slot:
                    installed_package = item
            formatted_options = FormattedOptions(package.options)
            if package.id in options:
                if not status_bar[0].strip() or not status_bar[1].strip():
                    for applied_option in options[package.id]:
                        if installed_package:
                            if installed_package.applied_options is not None and not \
                                    applied_option in installed_package.applied_options:
                                formatted_options.append(applied_option, "brightgreen")
                                continue
                            elif installed_package.applied_options is None:
                                formatted_options.append(applied_option, "brightgreen")
                                continue
                        formatted_options.append(applied_option, "red")
                    if installed_package and installed_package.applied_options is not None:
                        for applied_option in installed_package.applied_options:
                            if not applied_option in options[package.id]:
                                formatted_options.append(applied_option, "brightyellow")
            else:
                for option in package.options:
                    if installed_package and installed_package.applied_options is not None and \
                            option in installed_package.applied_options:
                        formatted_options.append(option, "brightyellow")
                    else:
                        formatted_options.append(option)
        else:
            if hasattr(installed_package, "applied_options") and installed_package.applied_options is not None:
                formatted_options = [out.color("%"+applied_option, "brightyellow") \
                        for applied_option in installed_package.applied_options]

        out.write("  [%s] %s/%s/%s {%s:%s} {%s} %s%s\n" % (
                " ".join(status_bar), \
                package.repo, \
                package.category, \
                package.name, \
                out.color(package.slot, "yellow"),\
                out.color(package.version, "green"),\
                package.arch, \
                other_version, \
                " ("+", ".join(formatted_options)+")" if formatted_options else ""
                )
        )
        
        if package.id in conflicts:
            for conflict in conflicts[package.id]:
                category, name, slot = conflict.split("/")
                conflict = installdb.find_package(package_name=name, \
                        package_category=category, \
                        package_slot = slot).get(0)
                out.write("\t %s %s/%s/%s-%s" % (out.color(">> conflict:", "green"), \
                conflict.repo,\
                        conflict.category, \
                            conflict.name, \
                            conflict.version
                    ))
示例#49
0
    def get_convenient_package(self, package, instdb=False):
        def inline_options_management(inline_options):
            # TODO: inline_options variable must be a set
            # Check inline options, if an option is not available for the package, warn the user
            for inline_option in inline_options:
                if not inline_option in package.options:
                    out.warn("%s option is not available for %s/%s/%s-%s. So that the option is removing..." % (
                        inline_option,
                        package.repo,
                        package.category,
                        package.name,
                        package.version
                    ))
                    inline_options.remove(inline_option)

            if inline_options:
                target = self.current_package.id if self.current_package is not \
                        None else self.parent_package.id
                my_package = package.category+"/"+package.name+"/"+package.slot
                if target in self.inline_option_targets:
                    if my_package in self.inline_option_targets[target]:
                        for option in inline_options:
                            self.inline_option_targets[target][my_package].add(option)
                    else:
                        self.inline_option_targets[target][my_package] = set(inline_options)
                else:
                    self.inline_option_targets[target] = {my_package: set(inline_options)}
                
                if package.id in self.inline_options:
                    if not package.id in self.package_options:
                        self.package_options[package.id] = set()
                    for option in inline_options:
                        if not option in self.inline_options[package.id]:
                            self.inline_options[package.id].append(option)
                            if package.id in self.package_options:
                                self.package_options[package.id].add(option)
                else:
                    self.inline_options[package.id] = inline_options
                    if package.id in self.package_options:
                        for inline_option in inline_options:
                            self.package_options[package.id].add(inline_option)
                    else:
                        self.package_options[package.id] = set(inline_options)

        convenient_arches = utils.get_convenient_arches(self.conf.arch)
        current_package = self.parent_package if self.parent_package is not \
                None else self.current_package
        result = LCollect()
        database = self.repodb if instdb is False else self.instdb
        slot = None
        gte, lte, lt, gt, et = False, False, False, False, False
        slot_parsed = package.split(":")

        if len(slot_parsed) == 2:
            data, slot = slot_parsed
        elif len(slot_parsed) > 2:
            out.error("%s invalid dependency in %s.py" % (data, self.current_package))
            # Use and exception
            raise DependencyError
        else:
            data = package

        if ">=" == data[:2]:
            gte = True
            pkgname = data[2:]
        elif "<=" == data[:2]:
            lte = True
            pkgname = data[2:]
        elif "<" == data[:1]:
            lt = True
            pkgname = data[1:]
        elif ">" == data[:1]:
            gt = True
            pkgname = data[1:]
        elif "==" == data[:2]:
            et = True
            pkgname = data[2:]
        else:
            category, name = data.split("/")
            inline_options = self.parse_inline_options(name)
            if inline_options:
                name = name[:name.index("[")]
            if (category, name) in self.repository_cache:
                results = self.repository_cache[(category, name)]
            else:
                results = database.find_package(package_name=name, package_category=category)
                self.repository_cache[(category, name)] = results
            slot = self.get_convenient_slot(results, slot)
            if not results:
                if instdb:
                    return
                current_package = current_package.repo+"/"+current_package.category+\
                        "/"+current_package.name+"-"+current_package.version+":"+current_package.slot
                out.error("unmet dependency: %s depends on %s" % (out.color(current_package, \
                        "red"), out.color(package, "red")))
                raise DependencyError
            try:
                package = utils.get_convenient_package(
                        results, 
                        self.locked_packages,
                        self.custom_arch_requests, 
                        convenient_arches, 
                        self.instdb, 
                        slot
                )
            except UnavailablePackage:
                for result in results:
                    out.error("%s/%s/%s-%s:%s {%s} is unavailable for your arch(%s)." % (result.repo, result.category, \
                            result.name, result.version, result.slot, result.arch, self.conf.arch))
                out.write("\n")
                out.write("%s %s/%s/%s-%s:%s {%s}\n" % (out.color("->", "brightyellow"), current_package.repo, \
                        current_package.category, current_package.name, current_package.version, \
                        current_package.slot, current_package.arch))
                out.write(" %s %s/%s/%s-%s:%s {%s}\n" % (out.color("->", "brightyellow"), current_package.repo, \
                        current_package.category, current_package.name, current_package.version, \
                        current_package.slot, current_package.arch))
                raise DependencyError
            except LockedPackage:
                out.error("these package(s) is/are locked by the system administrator:")
                for result in results:
                    out.error_notify("%s/%s/%s-%s:%s {%s}" % (result.repo, result.category, \
                            result.name, result.version, result.slot, result.arch))
                out.write("\n")
                out.write("%s %s/%s/%s-%s:%s {%s}\n" % (out.color("->", "brightyellow"), current_package.repo, \
                        current_package.category, current_package.name, current_package.version, \
                        current_package.slot, current_package.arch))
                out.write(" %s %s/%s/%s-%s:%s {%s}\n" % (out.color("->", "brightyellow"), current_package.repo, \
                        current_package.category, current_package.name, current_package.version, \
                        current_package.slot, current_package.arch))
                raise DependencyError

            # Set some variables to manage inline options
            inline_options_management(inline_options)

            return package

        category, name = pkgname.split("/")
        inline_options = self.parse_inline_options(name)
        if inline_options:
            name = name[:name.index("[")]
        name, version = utils.parse_pkgname(name)
        if (category, name) in self.repository_cache:
            results = self.repository_cache[(category, name)]
        else:
            results = database.find_package(package_name=name, package_category=category)
            self.repository_cache[(category, name)] = results
        slot = self.get_convenient_slot(results, slot)
        packages = []
        decision_point = {}
        owner_package = current_package.repo+"/"+current_package.category+\
                "/"+current_package.name+"-"+current_package.version
        if gte:
            decision_point = {"type": ">=", "version": version, \
                    "owner_package": owner_package, "owner_id": current_package.id}
            for result in results:
                comparison = utils.vercmp(result.version, version)
                if comparison == 1 or comparison == 0:
                    packages.append(result)
        elif lte:
            decision_point = {"type": "<=", "version": version, \
                    "owner_package": owner_package, "owner_id": current_package.id}
            for result in results:
                comparison = utils.vercmp(result.version, version)
                if comparison == -1 or comparison == 0:
                    packages.append(result)
        elif lt:
            decision_point = {"type": "<", "version": version, \
                    "owner_package": owner_package, "owner_id": current_package.id}
            for result in results:
                comparison = utils.vercmp(result.version, version)
                if comparison == -1:
                    packages.append(result)
        elif gt:
            decision_point = {"type": ">", "version": version, \
                    "owner_package": owner_package, "owner_id": current_package.id}
            for result in results:
                comparison = utils.vercmp(result.version, version)
                if comparison == 1:
                    packages.append(result)
        elif et:
            decision_point = {"type": "==", "version": version, \
                    "owner_package": owner_package, "owner_id": current_package.id}
            for result in results:
                comparison = utils.vercmp(result.version, version)
                if comparison == 0:
                    packages.append(result)

        if not packages:
            out.error("unmet dependency: %s/%s/%s-%s:%s {%s} depends on %s" % \
                    (current_package.repo, \
                    current_package.category, \
                    current_package.name, \
                    current_package.version, \
                    current_package.slot, \
                    current_package.arch, \
                    out.color(package, "red")))
            raise DependencyError

        try:
            package = utils.get_convenient_package(
                    results if not packages else packages,
                    self.locked_packages,
                    self.custom_arch_requests,
                    convenient_arches,
                    self.instdb,
                    slot
                    )
        except UnavailablePackage:
            for result in results:
                out.error("%s/%s/%s-%s:%s {%s}is unavailable for your arch(%s)." % (result.repo, result.category, \
                        result.name, result.version, result.slot, result.arch, self.conf.arch))
            out.write("\n")
            out.write("%s %s/%s/%s-%s:%s {%s}\n" % (out.color("->", "brightyellow"), current_package.repo, \
                    current_package.category, current_package.name, current_package.version, \
                    current_package.slot, current_package.arch))
            out.write(" %s %s/%s/%s-%s:%s {%s}\n" % (out.color("->", "brightyellow"), current_package.repo, \
                    current_package.category, current_package.name, current_package.version, \
                    current_package.slot, current_package.arch))
            raise DependencyError
        except LockedPackage:
            out.error("these package(s) is/are locked by the system administrator:")
            for result in results:
                out.error_notify("%s/%s/%s-%s:%s {%s}" % (result.repo, result.category, \
                        result.name, result.version, result.slot, result.arch))
            out.write("\n")
            out.write("%s %s/%s/%s-%s:%s {%s}\n" % (out.color("->", "brightyellow"), current_package.repo, \
                    current_package.category, current_package.name, current_package.version, \
                    current_package.slot, current_package.arch))
            out.write(" %s %s/%s/%s-%s:%s {%s}\n" % (out.color("->", "brightyellow"), current_package.repo, \
                    current_package.category, current_package.name, current_package.version, \
                    current_package.slot, current_package.arch))
            raise DependencyError

        # Set some variables to manage inline options
        inline_options_management(inline_options)

        if package.id in self.conditional_packages:
            self.conditional_packages[package.id].append(decision_point)
        else:
            self.conditional_packages[package.id] = [decision_point]

        return package
示例#50
0
import sys

from lpms import out
from lpms import utils
from lpms import shelltools

from lpms.db import dbapi

filesdb = dbapi.FilesDB()
installdb = dbapi.InstallDB()

cmdline = sys.argv

if "--help" in cmdline:
    out.normal("A tool that to create reverse depends database from scratch.")
    out.write("To hide outputs use '--quiet' parameter.\n")

if "--quiet" in cmdline:
    out.normal("creating reverse depends database...")

if os.path.exists("/var/db/lpms/reverse_depends.db"):
    shelltools.remove_file("/var/db/lpms/reverse_depends.db")

reversedb = dbapi.ReverseDependsDB()

for package in installdb.get_all_names():
    reverse_repo, reverse_category, reverse_name = package
    versions = []
    map(
        lambda ver: versions.extend(ver),
        installdb.get_version(reverse_name,
示例#51
0
def write(msg):
    out.write(msg)
示例#52
0
文件: api.py 项目: hasansarikaya/lpms
def remove_package(pkgnames, instruction):
    '''Triggers remove operation for given packages'''
    if instruction.like:
        # handle shortened package names
        database = dbapi.InstallDB()
        for item in instruction.like:
            query = database.db.cursor.execute(
                "SELECT name FROM package where name LIKE ?", (item, ))
            results = query.fetchall()
            if results:
                for result in results:
                    pkgnames.append(result[0])
        del database
    file_relationsdb = dbapi.FileRelationsDB()
    #try:
    packages = [
        GetPackage(pkgname, installdb=True).select() for pkgname in pkgnames
    ]
    #except PackageNotFound as package_name:
    #    out.error("%s seems not installed." % package_name)
    #    lpms.terminate()

    instruction.count = len(packages)
    index = 0
    # FIXME: I must create a new reverse dependency handler implementation

    #if instruct["show-reverse-depends"]:
    #    instruct["ask"] = True
    #    # WARNING: the mechanism only shows directly reverse dependencies
    #    # supposing that if A is a reverse dependency of B and C is depends on A.
    #    # when the user removes B, A and C will be broken. But lpms will warn the user about A.
    #    broken_packages = []
    #    reversedb = dbapi.ReverseDependsDB()
    #    out.normal("resolving primary reverse dependencies...\n")
    #    for package in packages:
    #        category, name, version = package[1:]
    #        if lpms.getopt("--use-file-relations"):
    #            broken_packages.extend(file_relations.get_packages(category, name, version))
    #        else:
    #            broken_packages.extend(reversedb.get_reverse_depends(category, name))

    #    if broken_packages:
    #        out.warn("the following packages will be broken:\n")
    #        for broken_package in broken_packages:
    #            broken_repo, broken_category, broken_name, broken_version = broken_package
    #            out.write(" %s %s/%s/%s-%s\n" % (out.color(">", "brightred"), broken_repo, broken_category, \
    #                    broken_name, broken_version))
    #    else:
    #        out.warn("no reverse dependency found.")

    if instruction.ask:
        out.write("\n")
        for package in packages:
            out.write(
                " %s %s/%s/%s-%s\n" % (out.color(
                    ">", "brightgreen"), out.color(package.repo, "green"),
                                       out.color(package.category, "green"),
                                       out.color(package.name, "green"),
                                       out.color(package.version, "green")))
        utils.xterm_title("lpms: confirmation request")
        out.write("\nTotal %s package will be removed.\n\n" %
                  out.color(str(instruction.count), "green"))
        if not utils.confirm("Would you like to continue?"):
            out.write("quitting...\n")
            utils.xterm_title_reset()
            lpms.terminate()

    realroot = instruction.new_root if instruction.new_root else cst.root
    config = conf.LPMSConfig()
    for package in packages:
        fdb = file_collisions.CollisionProtect(package.category, package.name, \
                package.slot, version=package.version, real_root=realroot)
        fdb.handle_collisions()
        if fdb.collisions:
            out.write(out.color(" > ", "brightyellow")+"file collisions detected while removing %s/%s/%s-%s\n\n" \
                    % (package.repo, package.category, package.name, package.version))
        for (c_package, c_path) in fdb.collisions:
            c_category, c_name, c_slot, c_version = c_package
            out.write(out.color(" -- ", "red")+c_category+"/"+c_name+"-"\
                    +c_version+":"+c_slot+" -> "+c_path+"\n")
            if fdb.collisions and config.collision_protect and not \
                    lpms.getopt('--force-file-collision'):
                out.write(
                    "\nquitting... use '--force-file-collision' to continue.\n"
                )
                lpms.terminate()
        index += 1
        instruction.index = index
        if not initpreter.InitializeInterpreter(
                package, instruction, ['remove'], remove=True).initialize():
            out.warn("an error occured during remove operation: %s/%s/%s-%s" % (package.repo, package.category, \
                    package.name, package.version))
        else:
            file_relationsdb.delete_item_by_pkgdata(package.category,
                                                    package.name,
                                                    package.version,
                                                    commit=True)
示例#53
0
    def create_operation_plan(self):
        '''Resolve dependencies and prepares a convenient operation plan'''
        single_packages = PackageItem()
        for package in self.packages:
            self.parent_package = package
            self.current_package = None
            self.package_heap[package.id] = package
            dependencies = []
            package_dependencies = self.collect_dependencies(package)
            if not package_dependencies:
                single_packages.add(package)
                continue
            # Create a list that consists of parent and child items
            for dependency in package_dependencies:
                dependency.parent = package.category+"/"+package.name+"/"+package.slot
                dependencies.append((package.id, dependency))
            while True:
                buff = []
                for parent, dependency in dependencies:
                    self.current_package = dependency
                    self.parent_package = None
                    self.package_query.append((dependency.id, parent))
                    if dependency.id in self.processed:
                        if self.processed[dependency.id] == self.package_options.get(dependency.id, None):
                            # This package was processed and it has no option changes
                            continue

                    # Keep the package options to prevent extra transaction
                    self.processed[dependency.id] = self.package_options.get(dependency.id, None)

                    # Keep the package information for the next operations.
                    # We don't want to create a new transaction for it.
                    self.package_heap[dependency.id] = dependency

                    # Get its dependencies
                    package_collection = self.collect_dependencies(dependency)
                    if not package_collection:
                        # The item has no dependency
                        continue
                    # Create a list that consists of parent and child items
                    for item in package_collection:
                        item.parent = package.category+"/"+package.name+"/"+package.slot
                        buff.append((dependency.id, item))
                if not buff:
                    # End of the node
                    break
                dependencies = buff

        try:
            # Sort packages for building operation
            plan = sorter.topsort(self.package_query)
        except sorter.CycleError as err:
            answer, num_parents, children = err
            out.brightred("Circular dependency detected:\n")
            for items in sorter.find_cycles(parent_children=children):
                for item in items:
                    package = self.repodb.find_package(package_id=item).get(0)
                    out.write(package.repo+"/"+package.category+"/"+package.name+"-"\
                            +package.version+":"+package.slot+"  ")
            out.write("\n")
            raise DependencyError

        # This part detects inline option conflicts
        removed = {}
        option_conflict = set()
        for package_id in self.inline_option_targets:
            for target in self.inline_option_targets[package_id]:
                for option in self.inline_option_targets[package_id][target]:
                    if option.startswith("-"):
                        if option in removed:
                            removed[option].add((package_id, target))
                        else:
                            removed[option] = set([(package_id, target)])
                    else:
                        if "-"+option in removed:
                            for (my_pkg_id, my_target)  in removed["-"+option]:
                                if my_target == target:
                                    option_conflict.add((my_target, \
                                            self.package_heap[package_id], \
                                            self.package_heap[my_pkg_id],\
                                            option))
        if option_conflict:
            out.error("option conflict detected:\n")
            for (pkg, add, remove, option)in option_conflict:
                out.error(out.color(option, "red")+" option on "+pkg+"\n")
                out.warn("%s/%s/%s/%s adds the option." % (add.repo, add.category, \
                        add.name, add.version))
                out.warn("%s/%s/%s/%s removes the option." % (remove.repo, remove.category, \
                        remove.name, remove.version))
            lpms.terminate()

        self.conditional_versions = {}
        for (key, values) in self.conditional_packages.items():
            for value in values:
                target_package = self.package_heap[key]
                my_item = {
                            "type": value["type"],
                            "version": value["version"],
                            "target": target_package.category+"/"+target_package.name+\
                                    "/"+target_package.slot,
                }
                if not value["owner_id"] in self.conditional_versions:
                    self.conditional_versions[value["owner_id"]] = [my_item]
                else:
                    self.conditional_versions[value["owner_id"]].append(my_item)

        # TODO: I think I must use most professional way for ignore-depends feature.
        if lpms.getopt("--ignore-deps"):
            result = LCollect()
            result.packages = self.packages
            result.dependencies = self.package_dependencies
            result.options = self.package_options
            result.inline_option_targets = self.inline_option_targets
            result.conditional_versions = self.conditional_versions
            result.conflicts = self.conflicts
            return result

        # Workaround for postmerge dependencies
        for (id_dependency, id_package) in self.postmerge_dependencies:
            plan.remove(id_dependency)
            plan.insert(plan.index(id_package)+1, id_dependency)

        final_plan = PackageItem()
        required_package_ids = [package.id for package in self.packages]
        for package_id in plan:
            package = self.package_heap[package_id]
            continue_conditional = False
            # If a package has a conditional decision point,
            # we should consider the condition
            if package.id not in self.conditional_packages:
                for c_package_id in self.conditional_packages:
                    c_package = self.package_heap[c_package_id]
                    if package.pk == c_package.pk:
                        continue_conditional = True
                        if package_id in required_package_ids:
                            final_plan.add_by_pk(c_package)
                            break
                if package_id in required_package_ids:
                    if continue_conditional is False:
                        final_plan.add_by_pk(package)
            if continue_conditional:
                continue
            installed_package = self.instdb.find_package(
                    package_category=package.category,
                    package_name=package.name,
                    package_slot=package.slot
            )
            if installed_package:
                if package.id in self.inline_options:
                    if installed_package.get(0).applied_options is None:
                        final_plan.add_by_pk(package)
                        continue
                    continue_inline = False
                    for inline_option in self.inline_options[package.id]:
                        if not inline_option in installed_package.get(0).applied_options:
                            final_plan.add_by_pk(package)
                            continue_inline = True
                            break
                    if continue_inline:
                        continue
                try:
                    conditional_versions_query = self.instdb.find_conditional_versions(
                            target=package.category+"/"+package.name+"/"+package.slot)
                    if conditional_versions_query:
                        for item in conditional_versions_query:
                            item.decision_point["package_id"]=item.package_id
                            if package.id in self.conditional_packages:
                                if not item.decision_point in self.conditional_packages[package.id]:
                                    self.conditional_packages[package.id].append(item.decision_point)
                            else:
                                self.conditional_packages[package.id] = [item.decision_point]
                    if package.id in self.conditional_packages:
                        decision_points = self.conditional_packages[package.id]
                        for decision_point in decision_points:
                            comparison = utils.vercmp(installed_package.get(0).version, \
                                        decision_point["version"])
                            if decision_point["type"] == ">=":
                                if self.handle_condition_conflict(decision_point, final_plan, \
                                        package.pk, ("<", ">"), (0, 1)) is False:
                                    continue
                                if not comparison in (1, 0) or package.id in required_package_ids:
                                    final_plan.add_by_pk(package)
                            elif decision_point["type"] == "<":
                                if self.handle_condition_conflict(decision_point, final_plan, \
                                        package.pk, (">", "<"), (0, -1)) is False:
                                    continue
                                if comparison != -1:
                                    final_plan.add_by_pk(package)
                            elif decision_point["type"] == ">":
                                if self.handle_condition_conflict(decision_point, final_plan, \
                                        package.pk, ("<", ">"), (0, 1)) is False:
                                    continue
                                if comparison != 1 or package.id in required_package_ids:
                                    final_plan.add_by_pk(package)
                            elif decision_point["type"] == "<=":
                                if self.handle_condition_conflict(decision_point, final_plan, \
                                        package.pk, (">", "<"), (0, -1)) is False:
                                    continue
                                if not comparison in (-1, 0) or package.id in required_package_ids:
                                    final_plan.add_by_pk(package)
                            elif decision_point["type"] == "==":
                                if comparison != 0 or package.id in required_package_ids:
                                    final_plan.add_by_pk(package)
                except ConditionConflict:
                    if not "owner_package" in decision_point:
                        conflict_package = self.instdb.find_package(package_id=\
                                decision_point["package_id"]).get(0)
                        decision_point["owner_package"] = conflict_package.repo+"/"+ \
                        conflict_package.category+"/"+ \
                        conflict_package.name+"/"+ \
                        conflict_package.version

                    out.error("while selecting a convenient version of %s, a conflict detected:\n" % \
                            out.color(package.pk, "red"))
                    out.notify(decision_point["owner_package"]+" wants "+\
                            decision_point["type"]+decision_point["version"])
                    out.notify(self.conflict_point["owner_package"]+" wants "+\
                            self.conflict_point["type"]+self.conflict_point["version"])
                    lpms.terminate("\nplease contact the package maintainers.")

                # Use new options if the package is effected
                if self.use_new_options and not package in final_plan:
                    if package.id in self.package_options:
                        for option in self.package_options[package.id]:
                            if not option in installed_package.get(0).applied_options:
                                final_plan.add_by_pk(package)
                                break
            else:
                final_plan.add_by_pk(package)

        # Oh my god! Some packages have no dependency.
        if single_packages:
            for single_package in single_packages:
                for item_id in plan:
                    if self.package_heap[item_id].pk == single_package.pk:
                        single_packages.remove(single_package)
                        break
            for single_package in single_packages:
                final_plan.insert_into(0, single_package)

        # Create LCollect object to manage package dependency data
        operation_plan = LCollect()
        operation_plan.packages = final_plan
        operation_plan.dependencies = self.package_dependencies
        operation_plan.options = self.package_options
        operation_plan.inline_option_targets = self.inline_option_targets
        operation_plan.conditional_versions = self.conditional_versions
        operation_plan.conflicts = self.conflicts
        return operation_plan
示例#54
0
    def usage(self):
        """
        Prints available commands with their descriptions.
        """
        out.normal("lpms -- %s Package Management System %s\n" % \
                (out.color("L", "red"), out.color("v"+__VERSION__, "green")))
        out.write("In order to build a package:\n\n")
        out.write(" # lpms <package-name> <extra-command>\n\n")
        out.write("To see extra commands use --help parameter.\n\n")
        out.write("Build related arguments:\n")
        for build_argument in self.build_arguments:
            if hasattr(build_argument, "short"):
                out.write(('%-29s %-10s : %s\n' % \
                        (out.color(build_argument.arg, 'green'), \
                        out.color(build_argument.short, 'green'), \
                        build_argument.description)))
            else:
                out.write(('%-32s : %s\n' % \
                        (out.color(build_argument.arg, 'green'), \
                        build_argument.description)))

        out.write("\nOther arguments:\n")
        for other_argument in self.other_arguments:
            if hasattr(other_argument, "short"):
                out.write(('%-29s %-10s : %s\n' % \
                        (out.color(other_argument.arg, 'green'), \
                        out.color(other_argument.short, 'green'), \
                        other_argument.description)))
            else:
                out.write(('%-32s : %s\n' % \
                        (out.color(other_argument.arg, 'green'), \
                        other_argument.description)))

        # Do nothing after showing help message
        sys.exit(0)
import sys

from lpms import out
from lpms import utils
from lpms import shelltools

from lpms.db import dbapi

filesdb = dbapi.FilesDB()
installdb = dbapi.InstallDB()

cmdline = sys.argv

if "--help" in cmdline:
    out.normal("A tool that to create reverse depends database from scratch.")
    out.write("To hide outputs use '--quiet' parameter.\n")

if "--quiet" in cmdline:
    out.normal("creating reverse depends database...") 

if os.path.exists("/var/db/lpms/reverse_depends.db"):
    shelltools.remove_file("/var/db/lpms/reverse_depends.db")

reversedb = dbapi.ReverseDependsDB()

for package in installdb.get_all_names():
    reverse_repo, reverse_category, reverse_name = package
    versions = []
    map(lambda ver: versions.extend(ver), installdb.get_version(reverse_name, pkg_category=reverse_category).values())
    for reverse_version in versions:
        depends = installdb.get_depends(reverse_repo, reverse_category, reverse_name, reverse_version)
示例#56
0
    def package_mangler(self, **kwargs):
        def collision_check():
            # TODO: This is a temporary solution. collision_check function
            # must be a reusable part for using in remove operation
            out.normal("checking file collisions...")
            lpms.logger.info("checking file collisions")
            collision_object = file_collisions.CollisionProtect(
                environment.category,
                environment.name,
                environment.slot,
                real_root=environment.real_root,
                source_dir=environment.install_dir)
            collision_object.handle_collisions()
            if collision_object.orphans:
                out.write(
                    out.color(" > ", "brightyellow") +
                    "these files are orphan. the package will adopt the files:\n"
                )
                index = 0
                for orphan in collision_object.orphans:
                    out.notify(orphan)
                    index += 1
                    if index > 100:
                        # FIXME: the files must be logged
                        out.write(
                            out.color(" > ", "brightyellow") +
                            "...and many others.")
                        break

            if collision_object.collisions:
                out.write(
                    out.color(" > ", "brightyellow") +
                    "file collisions detected:\n")
            for item in collision_object.collisions:
                (category, name, slot, version), path = item
                out.write(out.color(" -- ", "red")+category+"/"+name+"-"\
                        +version+":"+slot+" -> "+path+"\n")
            if collision_object.collisions and self.config.collision_protect:
                if environment.force_file_collision:
                    out.warn(
                        "Disregarding these collisions, you have been warned!")
                else:
                    return False
            return True

        names = kwargs.get("names", self.request.names)
        # Prepare build environment
        out.normal("resolving dependencies")
        targets = api.resolve_dependencies(names, self.request.instruction)
        if self.request.instruction.pretend:
            out.write("\n")
            out.normal("these packages will be merged, respectively:\n")
            showplan.show(targets.packages,
                          targets.conflicts,
                          targets.options,
                          installdb=dbapi.InstallDB())
            out.write("\ntotal %s package(s) listed.\n\n" \
                    % out.color(str(len(targets.packages)), "green"))
            raise LpmsTerminate

        if self.request.instruction.ask:
            out.write("\n")
            out.normal("these packages will be merged, respectively:\n")
            showplan.show(targets.packages,
                          targets.conflicts,
                          targets.options,
                          installdb=dbapi.InstallDB())
            utils.xterm_title("lpms: confirmation request")
            out.write("\ntotal %s package(s) will be merged.\n\n" \
                    % out.color(str(len(targets.packages)), "green"))

            if not utils.confirm("Would you like to continue?"):
                # Reset terminal title and terminate lpms.
                utils.xterm_title_reset()
                raise LpmsTerminate

        self.request.instruction.count = len(targets.packages)
        for index, package in enumerate(targets.packages, 1):
            self.request.instruction.index = index
            retval, environment = api.prepare_environment(
                    package,
                    self.request.instruction,
                    dependencies=targets.dependencies[package.id] if package.id in \
                            targets.dependencies else None,
                    options=targets.options[package.id] if package.id in \
                            targets.options else None,
                    conditional_versions=targets.conditional_versions[package.id] \
                            if package.id in targets.conditional_versions else None,
                    conflicts=targets.conflicts[package.id] if package.id \
                            in targets.conflicts else None,
                    inline_option_targets=targets.inline_option_targets[package.id] \
                            if package.id in targets.inline_option_targets else None
            )
            if not retval:
                out.error(
                    "There are some errors while preparing environment to build FOO."
                )
                out.error(
                    "So you should submit a bug report to fix the issue.")
                raise LpmsTerminate("thanks to flying with lpms.")
            # Now, run package script(spec) for configuring, building and install
            retval, environment = self.interpreter.initialize(environment)
            if retval is False:
                out.error(
                    "There are some errors while building FOO from source.")
                out.error("Error messages should be seen above.")
                out.error(
                    "If you want to submit a bug report, please attatch BAR or send above messages in a proper way."
                )
                raise LpmsTerminate("thanks to flying with lpms.")
            elif retval is None:
                raise LpmsTerminate

            if not collision_check():
                out.error(
                    "File collisions detected. If you want to overwrite these files,"
                )
                out.error(
                    "You have to use --force-file-collisions parameter or disable collision_protect in configuration file."
                )
                raise LpmsTerminate("thanks to flying with lpms.")

            # Merge package to livefs
            if environment.not_merge:
                raise LpmsTerminate("not merging...")
            retval, environment = merge.Merge(environment).perform_operation()
            if not retval:
                raise LpmsTerminate("Some errors occured while merging %s" %
                                    environment.fullname)

            lpms.logger.info("finished %s/%s/%s-%s" %
                             (package.repo, package.category, package.name,
                              package.version))

            utils.xterm_title("lpms: %s/%s finished" %
                              (package.category, package.name))

            out.normal("Cleaning build directory")
            shelltools.remove_dir(os.path.dirname(environment.install_dir))
            catdir = os.path.dirname(os.path.dirname(environment.install_dir))
            if not os.listdir(catdir):
                shelltools.remove_dir(catdir)

            # There is no error, exitting...
            out.normal("Completed.")