main/desktop/misc/packagekit/files/0001-Added-PiSi-support-back.patch

From: Berk Cakar <berk2238@hotmail.com>
Date: Thu, 24 Jun 2021 00:01:23 +0300
Subject: [PATCH] Added PiSi support back

---
 backends/pisi/meson.build       |  21 ++
 backends/pisi/pisiBackend.py    | 632 ++++++++++++++++++++++++++++++++
 backends/pisi/pk-backend-pisi.c | 369 +++++++++++++++++++
 meson_options.txt               |   2 +-
 4 files changed, 1023 insertions(+), 1 deletion(-)
 create mode 100644 backends/pisi/meson.build
 create mode 100644 backends/pisi/pisiBackend.py
 create mode 100644 backends/pisi/pk-backend-pisi.c

diff --git a/backends/pisi/meson.build b/backends/pisi/meson.build
new file mode 100644
index 000000000..71236ad11
--- /dev/null
+++ b/backends/pisi/meson.build
@@ -0,0 +1,21 @@
+shared_module(
+  'pk_backend_pisi',
+  'pk-backend-pisi.c',
+  include_directories: packagekit_src_include,
+  dependencies: [
+    packagekit_glib2_dep,
+    gmodule_dep,
+  ],
+  c_args: [
+    '-DPK_COMPILATION',
+    '-DG_LOG_DOMAIN="PackageKit-Pisi"',
+  ],
+  install: true,
+  install_dir: pk_plugin_dir,
+)
+
+install_data(
+  'pisiBackend.py',
+  install_dir: join_paths(get_option('datadir'), 'PackageKit', 'helpers', 'pisi'),
+  install_mode: 'rwxr--r--',
+)
diff --git a/backends/pisi/pisiBackend.py b/backends/pisi/pisiBackend.py
new file mode 100644
index 000000000..f9c19eeaf
--- /dev/null
+++ b/backends/pisi/pisiBackend.py
@@ -0,0 +1,632 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+#
+# Licensed under the GNU General Public License Version 2
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty 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.
+#
+# Copyright (C) 2007 S.Çağlar Onur <caglar@pardus.org.tr>
+# Copyright (C) 2013 Ikey Doherty <ikey@solusos.com>
+# Copyright (C) 2021 Berk Çakar <berk2238@hotmail.com>
+
+# Notes to PiSi based distribution maintainers
+# /etc/PackageKit/pisi.conf must contain a mapping of PiSi component to
+# PackageKit groups for correct operation, i.e.
+#   system.utils       = system
+#   desktop.gnome      = desktop-gnome
+# If you have a BTS you must also provide Bug-Regex and Bug-URI fields, i.e:
+#   Bug-Regex = Bug-SolusOS: T(\d+)
+#   Bug-URI = http://inf.solusos.com/T%s
+# We use simple python string formatting to replace the %s with the first
+# matched group in the regular expression. So in the example above, we expect
+# to see "Bug-SolusOS: T9" for example, on its own line in a package update
+# comment.
+
+import pisi
+import pisi.ui
+from packagekit.backend import *
+from packagekit.package import PackagekitPackage
+from packagekit import enums
+import os.path
+import piksemel
+import re
+
+class SimplePisiHandler(pisi.ui.UI):
+
+    def __init(self):
+        pisi.ui.UI.__init__(self, False, False)
+
+    def display_progress(self, **ka):
+        self.the_callback(**ka)
+
+
+class PackageKitPisiBackend(PackageKitBaseBackend, PackagekitPackage):
+
+    SETTINGS_FILE = "/etc/PackageKit/pisi.conf"
+
+    def __init__(self, args):
+        self.bug_regex = None
+        self.bug_uri = None
+        self._load_settings()
+        PackageKitBaseBackend.__init__(self, args)
+
+        self.componentdb = pisi.db.componentdb.ComponentDB()
+        # self.filesdb = pisi.db.filesdb.FilesDB()
+        self.installdb = pisi.db.installdb.InstallDB()
+        self.packagedb = pisi.db.packagedb.PackageDB()
+        self.repodb = pisi.db.repodb.RepoDB()
+
+        # Do not ask any question to users
+        self.options = pisi.config.Options()
+        self.options.yes_all = True
+
+        self.saved_ui = pisi.context.ui
+
+    def _load_settings(self):
+        """ Load the PK Group-> PiSi component mapping """
+        if os.path.exists(self.SETTINGS_FILE):
+            with open(self.SETTINGS_FILE, "r") as mapping:
+                self.groups = {}
+                for line in mapping.readlines():
+                    line = line.replace("\r", "").replace("\n", "").strip()
+                    if line.strip() == "" or "#" in line:
+                        continue
+
+                    splits = line.split("=")
+                    key = splits[0].strip()
+                    value = splits[1].strip()
+
+                    # Check if this contains our bug keys
+                    if key == "Bug-Regex":
+                        self.bug_regex = re.compile(value)
+                        continue
+                    if key == "Bug-URI":
+                        self.bug_uri = value
+                        continue
+                    self.groups[key] = value
+        else:
+            self.groups = {}
+
+    def __get_package_version(self, package):
+        """ Returns version string of given package """
+        # Internal FIXME: PiSi may provide this
+        if package.build is not None:
+            version = "%s-%s-%s" % (package.version, package.release,
+                                    package.build)
+        else:
+            version = "%s-%s" % (package.version, package.release)
+        return version
+
+    def __get_package(self, package, filters=None):
+        """ Returns package object suitable for other methods """
+        if self.installdb.has_package(package):
+            status = INFO_INSTALLED
+            pkg = self.installdb.get_package(package)
+        elif self.packagedb.has_package(package):
+            status = INFO_AVAILABLE
+            pkg = self.packagedb.get_package(package)
+        else:
+            self.error(ERROR_PACKAGE_NOT_FOUND, "Package was not found")
+
+        if filters:
+            if "none" not in filters:
+                if FILTER_INSTALLED in filters and status != INFO_INSTALLED:
+                    return
+                if FILTER_NOT_INSTALLED in filters and status == INFO_INSTALLED:
+                    return
+                if FILTER_GUI in filters and "app:gui" not in pkg.isA:
+                    return
+                if FILTER_NOT_GUI in filters and "app:gui" in pkg.isA:
+                    return
+
+        version = self.__get_package_version(pkg)
+
+        id = self.get_package_id(pkg.name, version, pkg.architecture, "")
+
+        return self.package(id, status, pkg.summary)
+
+    def depends_on(self, filters, package_ids, recursive):
+        """ Prints a list of depends for a given package """
+        self.allow_cancel(True)
+        self.percentage(None)
+
+        package = self.get_package_from_id(package_ids[0])[0]
+
+        for pkg in self.packagedb.get_package(package).runtimeDependencies():
+            # FIXME: PiSi API has really inconsistent for return types
+            # and arguments!
+            self.__get_package(pkg.package)
+
+    def get_details(self, package_ids):
+        """ Prints a detailed description for a given package """
+        self.allow_cancel(True)
+        self.percentage(None)
+
+        package = self.get_package_from_id(package_ids[0])[0]
+
+        if self.packagedb.has_package(package):
+            pkg = self.packagedb.get_package(package)
+            repo = self.packagedb.get_package_repo(pkg.name, None)
+            pkg_id = self.get_package_id(pkg.name,
+                                         self.__get_package_version(pkg),
+                                         pkg.architecture, repo[1])
+
+            if pkg.partOf in self.groups:
+                group = self.groups[pkg.partOf]
+            else:
+                group = GROUP_UNKNOWN
+
+            homepage = pkg.source.homepage if pkg.source.homepage is not None\
+                else ''
+
+            self.details(pkg_id, '', ",".join(pkg.license), group, pkg.description,
+                         homepage, pkg.packageSize)
+        else:
+            self.error(ERROR_PACKAGE_NOT_FOUND, "Package was not found")
+
+    def get_files(self, package_ids):
+        """ Prints a file list for a given package """
+        self.allow_cancel(True)
+        self.percentage(None)
+
+        package = self.get_package_from_id(package_ids[0])[0]
+
+        if self.installdb.has_package(package):
+            pkg = self.packagedb.get_package(package)
+            repo = self.packagedb.get_package_repo(pkg.name, None)
+            pkg_id = self.get_package_id(pkg.name,
+                                         self.__get_package_version(pkg),
+                                         pkg.architecture, repo[1])
+
+            pkg = self.installdb.get_files(package)
+
+            files = map(lambda y: "/%s" % y.path, pkg.list)
+
+            file_list = ";".join(files)
+            self.files(pkg_id, file_list)
+
+    def get_repo_list(self, filters):
+        """ Prints available repositories """
+        self.allow_cancel(True)
+        self.percentage(None)
+
+        for repo in pisi.api.list_repos():
+            # Internal FIXME: What an ugly way to get repo uri
+            # FIXME: Use repository enabled/disabled state
+            uri = self.repodb.get_repo(repo).indexuri.get_uri()
+            self.repo_detail(repo, uri, True)
+
+    def required_by(self, filters, package_ids, recursive):
+        """ Prints a list of requires for a given package """
+        self.allow_cancel(True)
+        self.percentage(None)
+
+        package = self.get_package_from_id(package_ids[0])[0]
+
+        # FIXME: Handle packages which is not installed from repository
+        for pkg in self.packagedb.get_rev_deps(package):
+            self.__get_package(pkg[0])
+
+    def get_updates(self, filter):
+        """ Prints available updates and types """
+        self.allow_cancel(True)
+        self.percentage(None)
+
+        self._updates = dict()
+        for package in pisi.api.list_upgradable():
+            pkg = self.packagedb.get_package(package)
+            version = self.__get_package_version(pkg)
+            id = self.get_package_id(pkg.name, version, pkg.architecture, "")
+            installed_package = self.installdb.get_package(package)
+
+            repo = self.packagedb.get_package_repo(pkg.name, None)[1]
+            pindex = "/var/lib/pisi/index/%s/pisi-index.xml" % repo
+
+            self._updates[pkg.name] = \
+                self._extract_update_details(pindex, pkg.name)
+            bug_uri = self._updates[pkg.name][3]
+
+            # FIXME: PiSi must provide this information as a single API call :(
+            updates = [i for i in self.packagedb.get_package(package).history
+                       if pisi.version.Version(i.release) >
+                       installed_package.release]
+            if pisi.util.any(lambda i: i.type == "security", updates):
+                self.package(id, INFO_SECURITY, pkg.summary)
+            elif bug_uri != "":
+                self.package(id, INFO_BUGFIX, pkg.summary)
+            else:
+                self.package(id, INFO_NORMAL, pkg.summary)
+
+    def _extract_update_details(self, pindex, package_name):
+        document = piksemel.parse(pindex)
+        packages = document.tags("Package")
+        for pkg in packages:
+            if pkg.getTagData("Name") == package_name:
+                history = pkg.getTag("History")
+                update = history.tags("Update")
+                update_message = "Updated"
+                update_release = 0
+                update_date = ""
+                needsReboot = False
+                bugURI = ""
+                for update in update:
+                    if int(update.getAttribute("release")) > update_release:
+                        update_release = int(update.getAttribute("release"))
+                        # updater = update.getTagData("Name")
+                        update_message = update.getTagData("Comment")
+                        update_message = update_message.replace("\n", ";")
+                        update_date = update.getTagData("Date")
+                        needsReboot = False
+                        try:
+                            requires = update.getTag("Requires")
+                            action = requires.getTagData("Action")
+                            if action == "systemRestart":
+                                needsReboot = True
+                        except Exception:
+                            pass
+                # Determine if this is a bug fix
+                for line in update_message.split(";"):
+                    m = self.bug_regex.match(line)
+                    if m is not None:
+                        bugURI = self.bug_uri % m.group(1)
+                        break
+                return (update_message, update_date, needsReboot, bugURI)
+            pkg = pkg.nextTag("Package")
+        return("Log not found", "", False, "")
+
+    def get_update_detail(self, package_ids):
+        for package_id in package_ids:
+            package = self.get_package_from_id(package_id)[0]
+            the_package = self.installdb.get_package(package)
+            updates = [package_id]
+            obsoletes = ""
+            # TODO: Add regex matching for #FIXES:ID or something similar
+            cve_url = ""
+            package_url = the_package.source.homepage
+            vendor_url = package_url if package_url is not None else ""
+            issued = ""
+
+            changelog = ""
+            # TODO: Set to security_issued if security update
+            issued = updated = ""
+            update_message, security_issued, needsReboot, bugURI = \
+                self._updates[package]
+
+            # TODO: Add tagging to repo's, or a mapping file
+            state = UPDATE_STATE_STABLE
+            reboot = "system" if needsReboot else "none"
+
+            self.update_detail(package_id, updates, obsoletes, vendor_url,
+                               bugURI, cve_url, reboot, update_message,
+                               changelog, state, issued, updated)
+
+    def download_packages(self, directory, package_ids):
+        """ Download the given packages to a directory """
+        self.allow_cancel(False)
+        self.percentage(None)
+        self.status(STATUS_DOWNLOAD)
+
+        packages = list()
+
+        def progress_cb(**kw):
+            self.percentage(int(kw['percent']))
+
+        ui = SimplePisiHandler()
+        for package_id in package_ids:
+            package = self.get_package_from_id(package_id)[0]
+            packages.append(package)
+            try:
+                pkg = self.packagedb.get_package(package)
+            except:
+                self.error(ERROR_PACKAGE_NOT_FOUND, "Package was not found")
+        try:
+            pisi.api.set_userinterface(ui)
+            ui.the_callback = progress_cb
+            if directory is None:
+                directory = os.path.curdir
+            pisi.api.fetch(packages, directory)
+            # Scan for package
+            for package in packages:
+                package_obj = self.packagedb.get_package(package)
+                uri = package_obj.packageURI.split("/")[-1]
+                location = os.path.join(directory, uri)
+                self.files(package_id, location)
+            pisi.api.set_userinterface(self.saved_ui)
+        except Exception, e:
+            self.error(ERROR_PACKAGE_DOWNLOAD_FAILED,
+                       "Could not download package: %s" % e)
+        self.percentage(None)
+
+    def install_files(self, only_trusted, files):
+        """ Installs given package into system"""
+
+        # FIXME: use only_trusted
+
+        # FIXME: install progress
+        self.allow_cancel(False)
+        self.percentage(None)
+
+        def progress_cb(**kw):
+            self.percentage(int(kw['percent']))
+
+        ui = SimplePisiHandler()
+
+        self.status(STATUS_INSTALL)
+        pisi.api.set_userinterface(ui)
+        ui.the_callback = progress_cb
+
+        try:
+            self.status(STATUS_INSTALL)
+            pisi.api.install(files)
+        except pisi.Error, e:
+            # FIXME: Error: internal-error : Package re-install declined
+            # Force needed?
+            self.error(ERROR_PACKAGE_ALREADY_INSTALLED, e)
+        pisi.api.set_userinterface(self.saved_ui)
+
+    def _report_all_for_package(self, package, remove=False):
+        """ Report all deps for the given package """
+        if not remove:
+            deps = self.packagedb.get_package(package).runtimeDependencies()
+            # TODO: Add support to report conflicting packages requiring removal
+            #conflicts = self.packagedb.get_package (package).conflicts
+            for dep in deps:
+                if not self.installdb.has_package(dep.name()):
+                    dep_pkg = self.packagedb.get_package(dep.name())
+                    repo = self.packagedb.get_package_repo(dep_pkg.name, None)
+                    version = self.__get_package_version(dep_pkg)
+                    pkg_id = self.get_package_id(dep_pkg.name, version,
+                                                 dep_pkg.architecture, repo[1])
+                    self.package(pkg_id, INFO_INSTALLING, dep_pkg.summary)
+        else:
+            rev_deps = self.installdb.get_rev_deps(package)
+            for rev_dep, depinfo in rev_deps:
+                if self.installdb.has_package(rev_dep):
+                    dep_pkg = self.packagedb.get_package(rev_dep)
+                    repo = self.packagedb.get_package_repo(dep_pkg.name, None)
+                    version = self.__get_package_version(dep_pkg)
+                    pkg_id = self.get_package_id(dep_pkg.name, version,
+                                                 dep_pkg.architecture, repo[1])
+                    self.package(pkg_id, INFO_REMOVING, dep_pkg.summary)
+
+    def install_packages(self, transaction_flags, package_ids):
+        """ Installs given package into system"""
+        # FIXME: fetch/install progress
+        self.allow_cancel(False)
+        self.percentage(None)
+
+        packages = list()
+
+        # FIXME: use only_trusted
+        for package_id in package_ids:
+            package = self.get_package_from_id(package_id)[0]
+            if self.installdb.has_package(package):
+                self.error(ERROR_PACKAGE_NOT_INSTALLED,
+                           "Package is already installed")
+            packages.append(package)
+
+        def progress_cb(**kw):
+            self.percentage(int(kw['percent']))
+
+        ui = SimplePisiHandler()
+
+        self.status(STATUS_INSTALL)
+        pisi.api.set_userinterface(ui)
+        ui.the_callback = progress_cb
+
+        if TRANSACTION_FLAG_SIMULATE in transaction_flags:
+            # Simulated, not real.
+            for package in packages:
+                self._report_all_for_package(package)
+            return
+        try:
+            pisi.api.install(packages)
+        except pisi.Error, e:
+            self.error(ERROR_UNKNOWN, e)
+        pisi.api.set_userinterface(self.saved_ui)
+
+    def refresh_cache(self, force):
+        """ Updates repository indexes """
+        # TODO: use force ?
+        self.allow_cancel(False)
+        self.percentage(0)
+        self.status(STATUS_REFRESH_CACHE)
+
+        slice = (100 / len(pisi.api.list_repos())) / 2
+
+        percentage = 0
+        for repo in pisi.api.list_repos():
+            pisi.api.update_repo(repo)
+            percentage += slice
+            self.percentage(percentage)
+
+        self.percentage(100)
+
+    def remove_packages(self, transaction_flags, package_ids,
+                        allowdeps, autoremove):
+        """ Removes given package from system"""
+        self.allow_cancel(False)
+        self.percentage(None)
+        # TODO: use autoremove
+        packages = list()
+
+        for package_id in package_ids:
+            package = self.get_package_from_id(package_id)[0]
+            if not self.installdb.has_package(package):
+                self.error(ERROR_PACKAGE_NOT_INSTALLED,
+                           "Package is not installed")
+            packages.append(package)
+
+        def progress_cb(**kw):
+            self.percentage(int(kw['percent']))
+
+        ui = SimplePisiHandler()
+
+        package = self.get_package_from_id(package_ids[0])[0]
+        self.status(STATUS_REMOVE)
+
+        if TRANSACTION_FLAG_SIMULATE in transaction_flags:
+            # Simulated, not real.
+            for package in packages:
+                self._report_all_for_package(package, remove=True)
+            return
+        try:
+            pisi.api.remove(packages)
+        except pisi.Error, e:
+            self.error(ERROR_CANNOT_REMOVE_SYSTEM_PACKAGE, e)
+        pisi.api.set_userinterface(self.saved_ui)
+
+    def repo_set_data(self, repo_id, parameter, value):
+        """ Sets a parameter for the repository specified """
+        self.allow_cancel(False)
+        self.percentage(None)
+
+        if parameter == "add-repo":
+            try:
+                pisi.api.add_repo(repo_id, value, parameter)
+            except pisi.Error, e:
+                self.error(ERROR_UNKNOWN, e)
+
+            try:
+                pisi.api.update_repo(repo_id)
+            except pisi.fetcher.FetchError:
+                pisi.api.remove_repo(repo_id)
+                err = "Could not reach the repository, removing from system"
+                self.error(ERROR_REPO_NOT_FOUND, err)
+        elif parameter == "remove-repo":
+            try:
+                pisi.api.remove_repo(repo_id)
+            except pisi.Error:
+                self.error(ERROR_REPO_NOT_FOUND, "Repository does not exist")
+        else:
+            self.error(ERROR_NOT_SUPPORTED, "Parameter not supported")
+
+    def resolve(self, filters, package):
+        """ Turns a single package name into a package_id
+        suitable for the other methods """
+        self.allow_cancel(True)
+        self.percentage(None)
+
+        self.__get_package(package[0], filters)
+
+    def search_details(self, filters, values):
+        """ Prints a detailed list of packages contains search term """
+        self.allow_cancel(True)
+        self.percentage(None)
+        self.status(STATUS_INFO)
+
+        # Internal FIXME: Use search_details instead of _package when API
+        # gains that ability :)
+        for pkg in pisi.api.search_package(values):
+            self.__get_package(pkg, filters)
+
+    def search_file(self, filters, values):
+        """ Prints the installed package which contains the specified file """
+        self.allow_cancel(True)
+        self.percentage(None)
+        self.status(STATUS_INFO)
+
+        for value in values:
+            # Internal FIXME: Why it is needed?
+            value = value.lstrip("/")
+
+            for pkg, files in pisi.api.search_file(value):
+                self.__get_package(pkg)
+
+    def search_group(self, filters, values):
+        """ Prints a list of packages belongs to searched group """
+        self.allow_cancel(True)
+        self.percentage(None)
+        self.status(STATUS_INFO)
+
+        for value in values:
+            packages = list()
+            for item in self.groups:
+                if self.groups[item] == value:
+                    try:
+                        pkgs = self.componentdb.get_packages(item, walk=False)
+                        packages.extend(pkgs)
+                    except:
+                        self.error(ERROR_GROUP_NOT_FOUND,
+                                   "Component %s was not found" % value)
+            for pkg in packages:
+                self.__get_package(pkg, filters)
+
+    def search_name(self, filters, values):
+        """ Prints a list of packages contains search term in its name """
+        self.allow_cancel(True)
+        self.percentage(None)
+        self.status(STATUS_INFO)
+
+        for value in values:
+            for pkg in pisi.api.search_package([value]):
+                self.__get_package(pkg, filters)
+
+    def update_packages(self, transaction_flags, package_ids):
+        """ Updates given package to its latest version """
+
+        # FIXME: use only_trusted
+
+        # FIXME: fetch/install progress
+        self.allow_cancel(False)
+        self.percentage(None)
+
+        packages = list()
+        for package_id in package_ids:
+            package = self.get_package_from_id(package_id)[0]
+            if not self.installdb.has_package(package):
+                self.error(ERROR_PACKAGE_NOT_INSTALLED,
+                           "Cannot update a package that is not installed")
+            packages.append(package)
+
+        def progress_cb(**kw):
+            self.percentage(int(kw['percent']))
+
+        ui = SimplePisiHandler()
+        pisi.api.set_userinterface(ui)
+        ui.the_callback = progress_cb
+
+        if TRANSACTION_FLAG_SIMULATE in transaction_flags:
+            for package in packages:
+                self._report_all_for_package(package)
+            return
+        try:
+            pisi.api.upgrade(packages)
+        except pisi.Error, e:
+            self.error(ERROR_UNKNOWN, e)
+        pisi.api.set_userinterface(self.saved_ui)
+
+    def update_system(self, only_trusted):
+        """ Updates all available packages """
+        # FIXME: use only_trusted
+        # FIXME: fetch/install progress
+        self.allow_cancel(False)
+        self.percentage(None)
+
+        if not len(pisi.api.list_upgradable()) > 0:
+            self.error(ERROR_NO_PACKAGES_TO_UPDATE, "System is already up2date")
+
+        try:
+            pisi.api.upgrade(pisi.api.list_upgradable())
+        except pisi.Error, e:
+            self.error(ERROR_UNKNOWN, e)
+
+
+def main():
+    backend = PackageKitPisiBackend('')
+    backend.dispatcher(sys.argv[1:])
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/backends/pisi/pk-backend-pisi.c b/backends/pisi/pk-backend-pisi.c
new file mode 100644
index 000000000..beb2f5836
--- /dev/null
+++ b/backends/pisi/pk-backend-pisi.c
@@ -0,0 +1,369 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2007 Richard Hughes <richard@hughsie.com>
+ * Copyright (C) 2007 S.Çağlar Onur <caglar@pardus.org.tr>
+ *
+ * Licensed under the GNU General Public License Version 2
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty 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.
+ */
+
+#include <pk-backend.h>
+#include <pk-backend-spawn.h>
+
+static PkBackendSpawn *spawn;
+
+void
+pk_backend_start_job (PkBackend *backend, PkBackendJob *job)
+{
+    if (pk_backend_spawn_is_busy (spawn)) {
+        pk_backend_job_error_code (job,
+                       PK_ERROR_ENUM_LOCK_REQUIRED,
+                       "spawned backend requires lock");
+        return;
+    }
+}
+
+void
+pk_backend_initialize (GKeyFile *conf, PkBackend *backend)
+{
+    g_debug ("backend: initialize");
+
+    /* BACKEND MAINTAINER: feel free to remove this when you've
+     * added support for ONLY_DOWNLOAD and merged the simulate
+     * methods as specified in backends/PORTING.txt */
+    /*g_error ("Backend needs to be ported to 0.8.x -- "
+         "see backends/PORTING.txt for details"); */
+
+    spawn = pk_backend_spawn_new (conf);
+    pk_backend_spawn_set_name (spawn, "pisi");
+}
+
+void
+pk_backend_destroy (PkBackend *backend)
+{
+    g_debug ("backend: destroy");
+    g_object_unref (spawn);
+}
+
+PkBitfield
+pk_backend_get_groups (PkBackend *backend)
+{
+    return pk_bitfield_from_enums (
+        PK_GROUP_ENUM_ACCESSORIES,
+        PK_GROUP_ENUM_EDUCATION,
+        PK_GROUP_ENUM_GAMES,
+        PK_GROUP_ENUM_INTERNET,
+        PK_GROUP_ENUM_OTHER,
+        PK_GROUP_ENUM_PROGRAMMING,
+        PK_GROUP_ENUM_MULTIMEDIA,
+        PK_GROUP_ENUM_SYSTEM,
+        PK_GROUP_ENUM_DESKTOP_GNOME,
+        PK_GROUP_ENUM_DESKTOP_KDE,
+        PK_GROUP_ENUM_DESKTOP_OTHER,
+        PK_GROUP_ENUM_PUBLISHING,
+        PK_GROUP_ENUM_SERVERS,
+        PK_GROUP_ENUM_FONTS,
+        PK_GROUP_ENUM_ADMIN_TOOLS,
+        PK_GROUP_ENUM_LOCALIZATION,
+        PK_GROUP_ENUM_VIRTUALIZATION,
+        PK_GROUP_ENUM_SECURITY,
+        PK_GROUP_ENUM_POWER_MANAGEMENT,
+        PK_GROUP_ENUM_UNKNOWN,
+        -1);
+}
+
+PkBitfield
+pk_backend_get_filters (PkBackend *backend)
+{
+    return pk_bitfield_from_enums(
+        PK_FILTER_ENUM_GUI,
+        PK_FILTER_ENUM_INSTALLED,
+        -1);
+}
+
+void
+pk_backend_cancel (PkBackend *backend, PkBackendJob *job)
+{
+    /* this feels bad... */
+    pk_backend_spawn_kill (spawn);
+}
+
+void
+pk_backend_download_packages (PkBackend *backend, PkBackendJob *job, gchar **package_ids, const gchar *directory)
+{
+    gchar *package_ids_temp;
+
+    /* send the complete list as stdin */
+    package_ids_temp = pk_package_ids_to_string (package_ids);
+    pk_backend_spawn_helper (spawn, job, "pisiBackend.py", "download-packages", directory, package_ids_temp, NULL);
+    g_free (package_ids_temp);
+}
+
+void
+pk_backend_depends_on (PkBackend *backend, PkBackendJob *job, PkBitfield filters, gchar **package_ids, gboolean recursive)
+{
+    gchar *filters_text;
+    gchar *package_ids_temp;
+    package_ids_temp = pk_package_ids_to_string (package_ids);
+    filters_text = pk_filter_bitfield_to_string (filters);
+    pk_backend_spawn_helper (spawn, job, "pisiBackend.py", "depends-on", filters_text, package_ids_temp, pk_backend_bool_to_string (recursive), NULL);
+    g_free (filters_text);
+    g_free (package_ids_temp);
+}
+
+void
+pk_backend_get_details (PkBackend *backend, PkBackendJob *job, gchar **package_ids)
+{
+    gchar *package_ids_temp;
+    package_ids_temp = pk_package_ids_to_string (package_ids);
+    pk_backend_spawn_helper (spawn, job, "pisiBackend.py", "get-details", package_ids_temp, NULL);
+    g_free (package_ids_temp);
+}
+
+void
+pk_backend_get_files (PkBackend *backend, PkBackendJob *job, gchar **package_ids)
+{
+    gchar *package_ids_temp;
+    package_ids_temp = pk_package_ids_to_string (package_ids);
+    pk_backend_spawn_helper (spawn, job, "pisiBackend.py", "get-files", package_ids_temp, NULL);
+    g_free (package_ids_temp);
+}
+
+void
+pk_backend_required_by (PkBackend *backend, PkBackendJob *job, PkBitfield filters, gchar **package_ids, gboolean recursive)
+{
+    gchar *filters_text;
+    gchar *package_ids_temp;
+    package_ids_temp = pk_package_ids_to_string (package_ids);
+    filters_text = pk_filter_bitfield_to_string (filters);
+    pk_backend_spawn_helper (spawn, job, "pisiBackend.py", "required-by", filters_text, package_ids_temp, pk_backend_bool_to_string (recursive), NULL);
+    g_free (filters_text);
+    g_free (package_ids_temp);
+}
+
+void
+pk_backend_get_updates (PkBackend *backend, PkBackendJob *job, PkBitfield filters)
+{
+    gchar *filters_text;
+    filters_text = pk_filter_bitfield_to_string (filters);
+    pk_backend_spawn_helper (spawn, job, "pisiBackend.py", "get-updates", filters_text, NULL);
+    g_free (filters_text);
+}
+
+void
+pk_backend_get_update_detail (PkBackend *backend, PkBackendJob *job, gchar **package_ids)
+{
+    gchar *package_ids_temp;
+    package_ids_temp = pk_package_ids_to_string (package_ids);
+    pk_backend_spawn_helper (spawn, job, "pisiBackend.py", "get-update-detail", package_ids_temp, NULL);
+    g_free (package_ids_temp);
+}
+
+void
+pk_backend_install_packages (PkBackend *backend, PkBackendJob *job, PkBitfield transaction_flags, gchar **package_ids)
+{
+    gchar *package_ids_temp;
+    gchar *transaction_flags_temp;
+
+    /* check network state */
+    if (!pk_backend_is_online (backend)) {
+        pk_backend_job_error_code (job, PK_ERROR_ENUM_NO_NETWORK, "Cannot install when offline");
+        pk_backend_job_finished (job);
+        return;
+    }
+
+    /* send the complete list as stdin */
+    package_ids_temp = pk_package_ids_to_string (package_ids);
+    transaction_flags_temp = pk_transaction_flag_bitfield_to_string (transaction_flags);
+    
+    pk_backend_spawn_helper (spawn, job, "pisiBackend.py", "install-packages", transaction_flags_temp, package_ids_temp, NULL);
+    g_free (package_ids_temp);
+    g_free (transaction_flags_temp);
+}
+
+void
+pk_backend_install_files (PkBackend *backend, PkBackendJob *job, PkBitfield transaction_flags, gchar **full_paths)
+{
+    gchar *package_ids_temp;
+    gchar *transaction_flags_temp;
+
+    /* send the complete list as stdin */
+    package_ids_temp = g_strjoinv (PK_BACKEND_SPAWN_FILENAME_DELIM, full_paths);
+    transaction_flags_temp = pk_transaction_flag_bitfield_to_string (transaction_flags);
+    
+    pk_backend_spawn_helper (spawn, job, "pisiBackend.py", "install-files", transaction_flags_temp, package_ids_temp, NULL);
+    g_free (package_ids_temp);
+    g_free (transaction_flags_temp);
+}
+
+void
+pk_backend_refresh_cache (PkBackend *backend, PkBackendJob *job, gboolean force)
+{
+    /* check network state */
+    if (!pk_backend_is_online (backend)) {
+        pk_backend_job_error_code (job, PK_ERROR_ENUM_NO_NETWORK, "Cannot refresh cache whilst offline");
+        pk_backend_job_finished (job);
+        return;
+    }
+
+    pk_backend_spawn_helper (spawn, job, "pisiBackend.py", "refresh-cache", pk_backend_bool_to_string (force), NULL);
+}
+
+void
+pk_backend_remove_packages (PkBackend *backend, PkBackendJob *job,
+                PkBitfield transaction_flags,
+                gchar **package_ids,
+                gboolean allow_deps,
+                gboolean autoremove)
+{
+    gchar *package_ids_temp;
+    gchar *transaction_flags_temp;
+
+    /* send the complete list as stdin */
+    package_ids_temp = pk_package_ids_to_string (package_ids);
+    transaction_flags_temp = pk_transaction_flag_bitfield_to_string (transaction_flags);
+    pk_backend_spawn_helper (spawn,
+        job, "pisiBackend.py",
+        "remove-packages",
+        transaction_flags_temp,
+        package_ids_temp,
+        pk_backend_bool_to_string (allow_deps),
+        pk_backend_bool_to_string (autoremove),
+        NULL);
+        
+    g_free (transaction_flags_temp);
+    g_free (package_ids_temp);
+}
+
+void
+pk_backend_search_details (PkBackend *backend, PkBackendJob *job, PkBitfield filters, gchar **values)
+{
+    gchar *filters_text;
+    gchar *search;
+    filters_text = pk_filter_bitfield_to_string (filters);
+    search = g_strjoinv ("&", values);
+    pk_backend_spawn_helper (spawn, job, "pisiBackend.py", "search-details", filters_text, search, NULL);
+    g_free (search);
+    g_free (filters_text);
+}
+
+void
+pk_backend_search_files (PkBackend *backend, PkBackendJob *job, PkBitfield filters, gchar **values)
+{
+    gchar *filters_text;
+    gchar *search;
+    filters_text = pk_filter_bitfield_to_string (filters);
+    search = g_strjoinv ("&", values);
+    pk_backend_spawn_helper (spawn, job, "pisiBackend.py", "search-file", filters_text, search, NULL);
+    g_free (search);
+    g_free (filters_text);
+}
+
+void
+pk_backend_search_groups (PkBackend *backend, PkBackendJob *job, PkBitfield filters, gchar **values)
+{
+    gchar *filters_text;
+    gchar *search;
+    filters_text = pk_filter_bitfield_to_string (filters);
+    search = g_strjoinv ("&", values);
+    pk_backend_spawn_helper (spawn, job, "pisiBackend.py", "search-group", filters_text, search, NULL);
+    g_free (search);
+    g_free (filters_text);
+}
+
+void
+pk_backend_search_names (PkBackend *backend, PkBackendJob *job, PkBitfield filters, gchar **values)
+{
+    gchar *filters_text;
+    gchar *search;
+    filters_text = pk_filter_bitfield_to_string (filters);
+    search = g_strjoinv ("&", values);
+    pk_backend_spawn_helper (spawn, job, "pisiBackend.py", "search-name", filters_text, search, NULL);
+    g_free (search);
+    g_free (filters_text);
+}
+
+void
+pk_backend_update_packages (PkBackend *backend, PkBackendJob *job, PkBitfield transaction_flags, gchar **package_ids)
+{
+    gchar *package_ids_temp;
+    gchar *transaction_flags_temp;
+
+    /* check network state */
+    if (!pk_backend_is_online (backend)) {
+        pk_backend_job_error_code (job, PK_ERROR_ENUM_NO_NETWORK, "Cannot install when offline");
+        pk_backend_job_finished (job);
+        return;
+    }
+
+    /* send the complete list as stdin */
+    package_ids_temp = pk_package_ids_to_string (package_ids);
+    transaction_flags_temp = pk_transaction_flag_bitfield_to_string (transaction_flags);
+    
+    pk_backend_spawn_helper (spawn, job, "pisiBackend.py", "update-packages", transaction_flags_temp, package_ids_temp, NULL);
+    g_free (package_ids_temp);
+    g_free (transaction_flags_temp);
+}
+
+void
+pk_backend_update_system (PkBackend *backend, PkBackendJob *job, PkBitfield transaction_flags)
+{
+    gchar *transaction_flags_temp;
+    transaction_flags_temp = pk_transaction_flag_bitfield_to_string (transaction_flags);
+    
+    pk_backend_spawn_helper (spawn, job, "pisiBackend.py", "update-system", transaction_flags_temp, NULL);
+    
+    g_free (transaction_flags_temp);
+}
+
+void
+pk_backend_resolve (PkBackend *backend, PkBackendJob *job, PkBitfield filters, gchar **package_ids)
+{
+    gchar *filters_text;
+    gchar *package_ids_temp;
+    filters_text = pk_filter_bitfield_to_string (filters);
+    package_ids_temp = pk_package_ids_to_string (package_ids);
+    pk_backend_spawn_helper (spawn, job, "pisiBackend.py", "resolve", filters_text, package_ids_temp, NULL);
+    g_free (filters_text);
+    g_free (package_ids_temp);
+}
+
+void
+pk_backend_get_repo_list (PkBackend *backend, PkBackendJob *job, PkBitfield filters)
+{
+    gchar *filters_text;
+    filters_text = pk_filter_bitfield_to_string (filters);
+    pk_backend_spawn_helper (spawn, job, "pisiBackend.py", "get-repo-list", filters_text, NULL);
+    g_free (filters_text);
+}
+
+void
+pk_backend_repo_set_data (PkBackend *backend, PkBackendJob *job, const gchar *rid, const gchar *parameter, const gchar *value)
+{
+    pk_backend_spawn_helper (spawn, job, "pisiBackend.py", "repo-set-data", rid, parameter, value, NULL);
+}
+
+const gchar *
+pk_backend_get_description (PkBackend *backend)
+{
+    return "PiSi - Packages Installed Successfully as Intended";
+}
+
+const gchar *
+pk_backend_get_author (PkBackend *backend)
+{
+    return "S.Çağlar Onur <caglar@pardus.org.tr>\nIkey Doherty <ikey@solusos.com>\nBerk Çakar <berk2238@hotmail.com>";
+}
diff --git a/meson_options.txt b/meson_options.txt
index 2f3a1dac9..7623dc9c2 100644
--- a/meson_options.txt
+++ b/meson_options.txt
@@ -1,4 +1,4 @@
-option('packaging_backend', type : 'array', choices : ['alpm', 'aptcc', 'dnf', 'dummy', 'entropy', 'poldek', 'portage', 'slack', 'zypp', 'nix'], value : ['dummy'], description : 'The name of the backend to use')
+option('packaging_backend', type : 'array', choices : ['alpm', 'aptcc', 'dnf', 'dummy', 'entropy', 'pisi', 'poldek', 'portage', 'slack', 'zypp', 'nix'], value : ['dummy'], description : 'The name of the backend to use')
 option('dnf_vendor', type : 'combo', choices : ['fedora', 'mageia', 'openmandriva', 'rosa', 'opensuse'], value : 'fedora', description : 'Vendor configuration when using the dnf backend')
 option('systemd', type : 'boolean', value : true, description : 'Use systemd and logind')
 option('systemdsystemunitdir', type : 'string', value : '', description : 'Directory for systemd service files')
-- 
2.24.3 (Apple Git-128)