# local.py

# Automatically copy all downloaded packages to a repository on the local

# filesystem and generating repo metadata.

#

# Copyright (C) 2015 Igor Gnatenko

#

# This copyrighted material is made available to anyone wishing to use,

# modify, copy, or redistribute it subject to the terms and conditions of

# the GNU General Public License v.2, or (at your option) any later version.

# This program is distributed in the hope that it will be useful, but WITHOUT

# ANY WARRANTY expressed or implied, including the implied warranties of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General

# Public License for more details.  You should have received a copy of the

# GNU General Public License along with this program; if not, write to the

# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

# 02110-1301, USA.  Any Red Hat trademarks that are incorporated in the

# source code or documentation are not subject to the GNU General Public

# License and may only be used or replicated with the express permission of

# Red Hat, Inc.

#

from __future__ import absolute_import

from __future__ import unicode_literals

from dnf.i18n import ucd

from dnfpluginscore import _, logger

import dnf

import dnf.cli

import os

import shutil

import subprocess

class LocalConfParse(object):

    """Parsing config

    Args:

      conf (libdnf.conf.ConfigParser): Config to parse

    """

    def __init__(self, conf):

        self.conf = conf

    def get_value(self, section, key, default=None):

        if self.conf.has_section(section) and self.conf.has_option(section, key):

            return self.conf.get(section, key)

        return default

    def parse_config(self):

        conf = self.conf

        main = {}

        crepo = {}

        if not conf.has_section("main") or not conf.has_section("createrepo") or \

           not conf.has_option("main", "enabled") or not conf.has_option("createrepo", "enabled"):

            raise KeyError("Missing key")

        main["enabled"] = conf.getboolean("main", "enabled")

        crepo["enabled"] = conf.getboolean("createrepo", "enabled")

        if main["enabled"]:

            main["repodir"] = self.get_value("main", "repodir",

                                             default="/var/lib/dnf/plugins/local")

        else:

            raise KeyError("Disabled")

        if crepo["enabled"]:

            crepo["cachedir"] = self.get_value("createrepo", "cachedir")

            if conf.has_option("createrepo", "quiet"):

                crepo["quiet"] = conf.getboolean("createrepo", "quiet")

            else:

                crepo["quiet"] = True

            if conf.has_option("createrepo", "verbose"):

                crepo["verbose"] = conf.getboolean("createrepo", "verbose")

            else:

                crepo["verbose"] = False

        return main, crepo

class Local(dnf.Plugin):

    name = "local"

    def __init__(self, base, cli):

        super(Local, self).__init__(base, cli)

        self.base = base

        self.main = {}

        self.crepo = {}

        self.logger = logger

    def pre_config(self):

        conf = self.read_config(self.base.conf)

        parser = LocalConfParse(conf)

        try:

            self.main, self.crepo = parser.parse_config()

        except KeyError:

            self.main["enabled"] = False

            self.crepo["enabled"] = False

            return

        local_repo = dnf.repo.Repo("_dnf_local", self.base.conf)

        local_repo.baseurl = "file://{}".format(self.main["repodir"])

        local_repo.cost = 500

        local_repo.skip_if_unavailable = True

        self.base.repos.add(local_repo)

    def transaction(self):

        main, crepo = self.main, self.crepo

        if not main["enabled"] or not self.transaction:

            return

        repodir = main["repodir"]

        if not os.path.exists(repodir):

            try:

                os.makedirs(repodir, mode=0o755)

            except OSError as e:

                self.logger.error("local: " + _(

                    "Unable to create a directory '{}' due to '{}'").format(repodir, ucd(e)))

                return

        elif not os.path.isdir(repodir):

            self.logger.error(

                "local: " + _("'{}' is not a directory").format(repodir))

            return

        needs_rebuild = False

        for pkg in self.base.transaction.install_set:

            path = pkg.localPkg()

            if os.path.dirname(path) == repodir:

                continue

            self.logger.debug(

                "local: " + _("Copying '{}' to local repo").format(path))

            try:

                shutil.copy2(path, repodir)

                needs_rebuild = True

            except IOError:

                self.logger.error(

                    "local: " + _("Can't write file '{}'").format(os.path.join(

                        repodir, os.path.basename(path))))

        if not crepo["enabled"] or not needs_rebuild:

            return

        args = ["createrepo_c", "--update", "--unique-md-filenames"]

        if crepo["verbose"]:

            args.append("--verbose")

        elif crepo["quiet"]:

            args.append("--quiet")

        if crepo["cachedir"] is not None:

            args.append("--cachedir")

            args.append(crepo["cachedir"])

        args.append(repodir)

        self.logger.debug("local: " + _("Rebuilding local repo"))

        p = subprocess.Popen(args, stdout=subprocess.PIPE,

                             stderr=subprocess.STDOUT)

        for line in p.stdout:

            print(line.decode().rstrip("\n"))