katja/backend/pkgtools.cpp

/*
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/.
 */
module;

#include "config.h"
#include <curl/curl.h>
#include <sqlite3.h>
#include <cstdint>
#include <glib-object.h>

export module katja.pkgtools;

import katja.utils;

export namespace katja
{
class Pkgtools
{
public:
    /**
     * katja::Pkgtools::get_name:
     *
     * Retrieves the repository name.
     *
     * Returns: Repository name.
     **/
    const char *get_name() const noexcept
    {
        return this->name;
    }

    /**
     * katja::Pkgtools::get_mirror:
     *
     * Retrieves the repository mirror.
     *
     * Returns: Repository mirror.
     **/
    const char *get_mirror() const noexcept
    {
        return this->mirror;
    }

    /**
     * katja::Pkgtools::get_order:
     *
     * Retrieves the repository order.
     *
     * Returns: Repository order.
     **/
    std::uint8_t get_order() const noexcept
    {
        return this->order;
    }

    /**
     * katja::Pkgtools:is_blacklisted:
     * @pkg: Package name to check for.
     *
     * Checks whether a package is blacklisted.
     *
     * Returns: %TRUE if the package is blacklisted, %FALSE otherwise.
     **/
    bool is_blacklisted(const char *pkg) const noexcept
    {
        return this->blacklist
            && g_regex_match (this->blacklist, pkg, static_cast<GRegexMatchFlags>(0), nullptr);
    }

    virtual ~Pkgtools() noexcept
    {
    }

    /**
     * katja::Pkgtools::download:
     * @job_data: A #JobData.
     * @dest_dir_name: Destination directory.
     * @pkg_name: Package name.
     *
     * Download a package.
     *
     * Returns: %TRUE on success, %FALSE otherwise.
     **/
    bool download(JobData *job_data, const char *dest_dir_name, char *pkg_name) noexcept
    {
        char *dest_filename, *source_url;
        bool ret = false;
        sqlite3_stmt *statement = nullptr;
        CURL *curl = nullptr;

        if ((sqlite3_prepare_v2(job_data->db,
                                "SELECT location, (full_name || '.' || ext) FROM pkglist "
                                "WHERE name LIKE @name AND repo_order = @repo_order",
                                -1,
                                &statement,
                                nullptr) != SQLITE_OK))
        {
            return false;
        }
        sqlite3_bind_text(statement, 1, pkg_name, -1, SQLITE_TRANSIENT);
        sqlite3_bind_int(statement, 2, this->get_order());

        if (sqlite3_step(statement) == SQLITE_ROW)
        {
            dest_filename = g_build_filename(dest_dir_name, sqlite3_column_text(statement, 1), nullptr);
            source_url = g_strconcat(this->get_mirror(),
                                     sqlite3_column_text(statement, 0),
                                     "/",
                                     sqlite3_column_text(statement, 1),
                                     nullptr);

            ret = g_file_test(dest_filename, G_FILE_TEST_EXISTS)
                || get_file(&curl, source_url, dest_filename) == CURLE_OK;

            if (curl)
            {
                curl_easy_cleanup(curl);
            }
            g_free(source_url);
            g_free(dest_filename);
        }
        sqlite3_finalize(statement);

        return ret;
    }

    /**
     * katja::Pkgtools::install:
     * @job_data: A #JobData.
     * @pkg_name: Package name.
     *
     * Install a package.
     **/
    void install(JobData *job_data, char *pkg_name) noexcept
    {
        char *pkg_filename, *cmd_line;
        sqlite3_stmt *statement = nullptr;

        if ((sqlite3_prepare_v2(job_data->db,
                                "SELECT (full_name || '.' || ext) FROM pkglist "
                                "WHERE name LIKE @name AND repo_order = @repo_order",
                                -1,
                                &statement,
                                nullptr) != SQLITE_OK))
        {
            return;
        }

        sqlite3_bind_text(statement, 1, pkg_name, -1, SQLITE_TRANSIENT);
        sqlite3_bind_int(statement, 2, this->get_order());

        if (sqlite3_step(statement) == SQLITE_ROW)
        {
            pkg_filename = g_build_filename(LOCALSTATEDIR,
                                            "cache",
                                            "PackageKit",
                                            "downloads",
                                            sqlite3_column_text(statement, 0),
                                            nullptr);
            cmd_line = g_strconcat("/sbin/upgradepkg --install-new ", pkg_filename, nullptr);
            g_spawn_command_line_sync(cmd_line, nullptr, nullptr, nullptr, nullptr);
            g_free(cmd_line);

            g_free(pkg_filename);
        }
        sqlite3_finalize(statement);
    }

    virtual GSList *collect_cache_info (const char *tmpl) noexcept = 0;
    virtual void generate_cache(JobData *job_data, const char *tmpl) noexcept = 0;

protected:
    char *name = nullptr;
    char *mirror = nullptr;
    std::uint8_t order;
    GRegex *blacklist = nullptr;
};

/**
 * katja::cmp_repo:
 **/
int cmp_repo(const void *a, const void *b)
{
    auto repo = static_cast<const Pkgtools *> (a);

    return g_strcmp0(repo->get_name(), (char *) b);
}
}