PackageKit-git.patch

   1 commit b0ef064fb549eb7cb5ee1040494b50f473f8cc2c
   2 Author: Marcin Banasiak <marcin.banasiak@gmail.com>
   3 Date:   Wed Oct 3 11:02:58 2012 +0200
   4
   5     poldek: remove UpdateSystem method
   6
   7 diff --git a/backends/poldek/pk-backend-poldek.c b/backends/poldek/pk-backend-poldek.c
   8 index d167e07..f6c182f 100644
   9 --- a/backends/poldek/pk-backend-poldek.c
  10 +++ b/backends/poldek/pk-backend-poldek.c
  11 @@ -1,6 +1,6 @@
  12  /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
  13   *
  14 - * Copyright (C) 2008-2011 Marcin Banasiak <megabajt@pld-linux.org>
  15 + * Copyright (C) 2008-2012 Marcin Banasiak <megabajt@pld-linux.org>
  16   *
  17   * Licensed under the GNU General Public License Version 2
  18   *
  19 @@ -1791,17 +1791,15 @@ static void
  20  update_packages_thread (PkBackendJob *job, GVariant *params, gpointer user_data)
  21  {
  22         struct vf_progress      vf_progress;
  23 -       gboolean                update_system;
  24         guint                   i, toupdate = 0;
  25         gchar **package_ids, *command;
  26         GString *cmd;
  27
  28 -       update_system = pk_backend_get_bool (backend, "update_system");
  29         /* FIXME: support only_trusted */
  30         package_ids = pk_backend_get_strv (backend, "package_ids");
  31
  32         /* sth goes wrong. package_ids has to be set in UpdatePackages */
  33 -       if (update_system == FALSE && package_ids == NULL) {
  34 +       if (package_ids == NULL) {
  35                 g_warning ("package_ids cannot be NULL in UpdatePackages method.");
  36                 pk_backend_job_finished (job);
  37                 return;
  38 @@ -1816,40 +1814,17 @@ update_packages_thread (PkBackendJob *job, GVariant *params, gpointer user_data)
  39
  40         cmd = g_string_new ("upgrade ");
  41
  42 -       if (update_system) {
  43 -               tn_array *packages = NULL;
  44 -
  45 -               if ((packages = execute_packages_command ("cd /all-avail; ls -q -u")) != NULL) {
  46 -                       /* UpdateSystem updates to the newest available packages */
  47 -                       do_newest (packages);
  48 -
  49 -                       for (i = 0; i < n_array_size (packages); i++) {
  50 -                               struct pkg *pkg = n_array_nth (packages, i);
  51 -
  52 -                               /* don't try to update blocked packages */
  53 -                               if (!(pkg->flags & PKG_HELD)) {
  54 -                                       g_string_append_printf (cmd, "%s-%s-%s.%s ", pkg->name,
  55 -                                                               pkg->ver, pkg->rel, pkg_arch (pkg));
  56 -
  57 -                                       toupdate++;
  58 -                               }
  59 -                       }
  60 -
  61 -                       n_array_free (packages);
  62 -               }
  63 -       } else {
  64 -               for (i = 0; i < g_strv_length (package_ids); i++) {
  65 -                       struct pkg *pkg;
  66 +       for (i = 0; i < g_strv_length (package_ids); i++) {
  67 +               struct pkg *pkg;
  68
  69 -                       pkg = poldek_get_pkg_from_package_id (package_ids[i]);
  70 +               pkg = poldek_get_pkg_from_package_id (package_ids[i]);
  71
  72 -                       g_string_append_printf (cmd, "%s-%s-%s.%s ", pkg->name,
  73 -                                               pkg->ver, pkg->rel, pkg_arch (pkg));
  74 +               g_string_append_printf (cmd, "%s-%s-%s.%s ", pkg->name,
  75 +                                       pkg->ver, pkg->rel, pkg_arch (pkg));
  76
  77 -                       toupdate++;
  78 +               toupdate++;
  79
  80 -                       pkg_free (pkg);
  81 -               }
  82 +               pkg_free (pkg);
  83         }
  84
  85         command = g_string_free (cmd, FALSE);
  86 @@ -3187,27 +3162,6 @@ pk_backend_update_packages (PkBackend *backend, PkBackendJob *job, PkBitfield tr
  87  }
  88
  89  /**
  90 - * pk_backend_update_system:
  91 - **/
  92 -void
  93 -pk_backend_update_system (PkBackend *backend, PkBackendJob *job, PkBitfield transaction_flags)
  94 -{
  95 -       if (!pk_backend_is_online (backend)) {
  96 -               pk_backend_job_error_code (job, PK_ERROR_ENUM_NO_NETWORK, "Cannot update system when offline!");
  97 -               pk_backend_job_finished (job);
  98 -               return;
  99 -       }
 100 -
 101 -       poldek_backend_set_allow_cancel (backend, TRUE, TRUE);
 102 -       pb_error_clean ();
 103 -
 104 -       poldek_backend_percentage_data_create (backend);
 105 -       pk_backend_set_uint (backend, "ts_type", TS_TYPE_ENUM_UPDATE);
 106 -       pk_backend_set_bool (backend, "update_system", TRUE);
 107 -       pk_backend_job_thread_create (job, update_packages_thread, NULL, NULL);
 108 -}
 109 -
 110 -/**
 111   * pk_backend_get_repo_list:
 112   */
 113  void
 114 commit 58c7e00f5f0889c5d44ac9ba68e50d25752cf9b9
 115 Author: Marcin Banasiak <marcin.banasiak@gmail.com>
 116 Date:   Sun Oct 7 00:28:54 2012 +0200
 117
 118     poldek: port to the new API
 119
 120 diff --git a/backends/poldek/pk-backend-poldek.c b/backends/poldek/pk-backend-poldek.c
 121 index f6c182f..7fe3d12 100644
 122 --- a/backends/poldek/pk-backend-poldek.c
 123 +++ b/backends/poldek/pk-backend-poldek.c
 124 @@ -19,6 +19,9 @@
 125   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 126   */
 127
 128 +#include <sys/types.h>
 129 +#include <pwd.h>
 130 +
 131  #include <pk-backend.h>
 132
 133  #include <log.h>
 134 @@ -36,32 +39,45 @@
 135  #include <sigint/sigint.h>
 136
 137  static gchar* poldek_pkg_evr (const struct pkg *pkg);
 138 -static void poldek_backend_package (PkBackend *backend, struct pkg *pkg, PkInfoEnum infoenum, PkBitfield filters);
 139 +static void poldek_backend_package (PkBackendJob *job, struct pkg *pkg, PkInfoEnum infoenum, PkBitfield filters);
 140  static long do_get_bytes_to_download (struct poldek_ts *ts, tn_array *pkgs);
 141  static gint do_get_files_to_download (const struct poldek_ts *ts, const gchar *mark);
 142 -static void pb_load_packages (PkBackend *backend);
 143 -static void poldek_backend_set_allow_cancel (PkBackend *backend, gboolean allow_cancel, gboolean reset);
 144 +static void pb_load_packages (PkBackendJob *job);
 145 +static void poldek_backend_set_allow_cancel (PkBackendJob *job, gboolean allow_cancel, gboolean reset);
 146
 147 -static void pb_error_show (PkBackend *backend, PkErrorEnum errorcode);
 148 +static void pb_error_show (PkBackendJob *job, PkErrorEnum errorcode);
 149  static void pb_error_clean (void);
 150 -static void poldek_backend_percentage_data_destroy (PkBackend *backend);
 151
 152 -typedef enum {
 153 -       TS_TYPE_ENUM_INSTALL,
 154 -       TS_TYPE_ENUM_UPDATE,
 155 -       TS_TYPE_ENUM_REMOVE,
 156 -       TS_TYPE_ENUM_REFRESH_CACHE
 157 -} TsType;
 158 -
 159 -enum {
 160 -       SEARCH_ENUM_NONE,
 161 -       SEARCH_ENUM_NAME,
 162 -       SEARCH_ENUM_GROUP,
 163 -       SEARCH_ENUM_DETAILS,
 164 -       SEARCH_ENUM_FILE,
 165 -       SEARCH_ENUM_PROVIDES,
 166 -       SEARCH_ENUM_RESOLVE
 167 -};
 168 +typedef struct {
 169 +       gint            step; // current step
 170 +
 171 +       /* Numer of sources to update. It's used only by refresh cache,
 172 +        * as each source can have multiple files to download. I don't
 173 +        * know how to get numer of files which will be downloaded. */
 174 +       guint           nsources;
 175 +
 176 +       long            bytesget;
 177 +       long            bytesdownload;
 178 +
 179 +       /* how many files I have already downloaded or which I'm currently
 180 +        * downloading */
 181 +       guint           filesget;
 182 +       /* how many files I have to download */
 183 +       guint           filesdownload;
 184 +
 185 +       gint            percentage;
 186 +       gint            subpercentage;
 187 +} PkBackendPoldekProgressData;
 188 +
 189 +typedef struct {
 190 +       PkBackendPoldekProgressData     *progress_data;
 191 +
 192 +       tn_array                        *to_install_pkgs;
 193 +       tn_array                        *to_update_pkgs;
 194 +       tn_array                        *to_remove_pkgs;
 195 +
 196 +       guint                           to_install;
 197 +} PkBackendPoldekJobData;
 198
 199  typedef struct {
 200         PkGroupEnum     group;
 201 @@ -89,27 +105,6 @@ static PLDGroupRegex group_perlre[] = {
 202         { 0, NULL }
 203  };
 204
 205 -typedef struct {
 206 -       gint            step; // current step
 207 -
 208 -       /* Numer of sources to update. It's used only by refresh cache,
 209 -        * as each source can have multiple files to download. I don't
 210 -        * know how to get numer of files which will be downloaded. */
 211 -       guint           nsources;
 212 -
 213 -       long            bytesget;
 214 -       long            bytesdownload;
 215 -
 216 -       /* how many files I have already downloaded or which I'm currently
 217 -        * downloading */
 218 -       guint           filesget;
 219 -       /* how many files I have to download */
 220 -       guint           filesdownload;
 221 -
 222 -       gint            percentage;
 223 -       gint            subpercentage;
 224 -} PercentageData;
 225 -
 226  typedef enum {
 227         PB_RPM_STATE_ENUM_NONE = 0,
 228         PB_RPM_STATE_ENUM_INSTALLING = (1 << 1),
 229 @@ -255,7 +250,7 @@ cut_country_code (const gchar *lang)
 230   * "pl.UTF-8", "pl_PL" and "pl". This array is needed by pkg_xuinf().
 231   **/
 232  static tn_array*
 233 -get_locale_variants (PkBackend *backend, const gchar *lang)
 234 +get_locale_variants (const gchar *lang)
 235  {
 236         tn_array *langs;
 237         gchar *copy;
 238 @@ -306,7 +301,7 @@ get_locale_variants (PkBackend *backend, const gchar *lang)
 239   * Returns pointer to struct pkguinf with localized summary and description.
 240   **/
 241  static struct pkguinf*
 242 -pkg_uinf_i18n (PkBackend *backend, struct pkg *pkg)
 243 +pkg_uinf_i18n (PkBackendJob *job, struct pkg *pkg)
 244  {
 245         struct pkguinf *pkgu = NULL;
 246         gchar *lang = NULL;
 247 @@ -316,7 +311,7 @@ pkg_uinf_i18n (PkBackend *backend, struct pkg *pkg)
 248         if (lang) {
 249                 tn_array *langs;
 250
 251 -               langs = get_locale_variants (backend, lang);
 252 +               langs = get_locale_variants (lang);
 253                 pkgu = pkg_xuinf (pkg, langs);
 254         } else {
 255                 pkgu = pkg_uinf (pkg);
 256 @@ -420,12 +415,14 @@ do_get_bytes_to_download (struct poldek_ts *ts, tn_array *pkgs)
 257   * VF_PROGRESS
 258   */
 259  static void*
 260 -poldek_vf_progress_new (void *data, const gchar *label)
 261 +poldek_vf_progress_new (void *user_data, const gchar *label)
 262  {
 263 -       PkBackend *backend = (PkBackend*) data;
 264 -       guint ts_type = pk_backend_get_uint (backend, "ts_type");
 265 +       PkBackendJob *job = (PkBackendJob *) user_data;
 266 +       PkRoleEnum role;
 267 +
 268 +       role = pk_backend_job_get_role (job);
 269
 270 -       if (ts_type == TS_TYPE_ENUM_INSTALL || ts_type == TS_TYPE_ENUM_UPDATE) {
 271 +       if (role == PK_ROLE_ENUM_INSTALL_PACKAGES || role == PK_ROLE_ENUM_UPDATE_PACKAGES) {
 272                 gchar *filename = g_path_get_basename (label), *pkgname;
 273                 tn_array *packages = NULL;
 274
 275 @@ -436,7 +433,7 @@ poldek_vf_progress_new (void *data, const gchar *label)
 276                 if ((packages = execute_packages_command ("cd /all-avail; ls -q %s", pkgname)) != NULL) {
 277                         struct pkg *pkg = n_array_nth (packages, 0);
 278
 279 -                       poldek_backend_package (backend, pkg, PK_INFO_ENUM_DOWNLOADING, PK_FILTER_ENUM_NONE);
 280 +                       poldek_backend_package (job, pkg, PK_INFO_ENUM_DOWNLOADING, PK_FILTER_ENUM_NONE);
 281
 282                         n_array_free (packages);
 283                 }
 284 @@ -445,17 +442,20 @@ poldek_vf_progress_new (void *data, const gchar *label)
 285                 g_free (filename);
 286         }
 287
 288 -       return data;
 289 +       return user_data;
 290  }
 291
 292  static void
 293 -poldek_vf_progress (void *bar, long total, long amount)
 294 +poldek_vf_progress (void *user_data, long total, long amount)
 295  {
 296 -       PkBackend       *backend = (PkBackend*) bar;
 297 -       PercentageData  *pd = pk_backend_get_pointer (backend, "percentage_ptr");
 298 -       guint ts_type = pk_backend_get_uint (backend, "ts_type");
 299 +       PkBackendJob *job = (PkBackendJob *) user_data;
 300 +       PkBackendPoldekJobData *job_data = pk_backend_job_get_user_data (job);
 301 +       PkBackendPoldekProgressData *pd = job_data->progress_data;
 302 +       PkRoleEnum role;
 303
 304 -       if (ts_type == TS_TYPE_ENUM_INSTALL || ts_type == TS_TYPE_ENUM_UPDATE) {
 305 +       role = pk_backend_job_get_role (job);
 306 +
 307 +       if (role == PK_ROLE_ENUM_INSTALL_PACKAGES || role == PK_ROLE_ENUM_UPDATE_PACKAGES) {
 308                 float   frac = (float)amount / (float)total;
 309
 310                 /* file already downloaded */
 311 @@ -470,9 +470,9 @@ poldek_vf_progress (void *bar, long total, long amount)
 312                         pd->subpercentage = (gint)(frac * 100);
 313                 }
 314
 315 -               pk_backend_set_sub_percentage (backend, pd->subpercentage);
 316 +               //pk_backend_set_sub_percentage (backend, pd->subpercentage);
 317
 318 -       } else if (ts_type == TS_TYPE_ENUM_REFRESH_CACHE) {
 319 +       } else if (role == PK_ROLE_ENUM_REFRESH_CACHE) {
 320                 if (pd->step == 0)
 321                         pd->percentage = 1;
 322                 else
 323 @@ -483,11 +483,12 @@ poldek_vf_progress (void *bar, long total, long amount)
 324  }
 325
 326  static void
 327 -poldek_vf_progress_reset (void *bar)
 328 +poldek_vf_progress_reset (void *user_data)
 329  {
 330 -       PkBackend *backend = (PkBackend *) bar;
 331 -       PercentageData *pd = pk_backend_get_pointer (backend, "percentage_ptr");
 332 -       pd->subpercentage = 0;
 333 +       PkBackendJob *job = (PkBackendJob *) user_data;
 334 +       PkBackendPoldekJobData *job_data = pk_backend_job_get_user_data (job);
 335 +
 336 +       job_data->progress_data->subpercentage = 0;
 337  }
 338
 339  /**
 340 @@ -525,21 +526,24 @@ poldek_pkg_in_array (const struct pkg *pkg, const tn_array *array, tn_fn_cmp cmp
 341  }
 342
 343  static void
 344 -get_ts_summary (TsType type, tn_array *ipkgs, tn_array *dpkgs, tn_array *rpkgs,
 345 +get_ts_summary (PkBackendJob *job, tn_array *ipkgs, tn_array *dpkgs, tn_array *rpkgs,
 346                 tn_array **install_pkgs, tn_array **update_pkgs, tn_array **remove_pkgs)
 347  {
 348 +       PkRoleEnum role;
 349         guint  i;
 350
 351 -       if (type == TS_TYPE_ENUM_INSTALL || type == TS_TYPE_ENUM_UPDATE) {
 352 +       role = pk_backend_job_get_role (job);
 353 +
 354 +       if (role == PK_ROLE_ENUM_INSTALL_PACKAGES || role == PK_ROLE_ENUM_UPDATE_PACKAGES) {
 355                 *install_pkgs = n_array_new (2, (tn_fn_free)pkg_free, (tn_fn_cmp)pkg_cmp_name_evr);
 356                 *update_pkgs = n_array_new (2, (tn_fn_free)pkg_free, (tn_fn_cmp)pkg_cmp_name_evr);
 357         }
 358
 359         *remove_pkgs = n_array_new (2, (tn_fn_free)pkg_free, (tn_fn_cmp)pkg_cmp_name_evr);
 360
 361 -       switch (type) {
 362 -               case TS_TYPE_ENUM_INSTALL:
 363 -               case TS_TYPE_ENUM_UPDATE:
 364 +       switch (role) {
 365 +               case PK_ROLE_ENUM_INSTALL_PACKAGES:
 366 +               case PK_ROLE_ENUM_UPDATE_PACKAGES:
 367                         if (rpkgs) {
 368                                 for (i = 0; i < n_array_size (rpkgs); i++) {
 369                                         struct pkg *rpkg = n_array_nth (rpkgs, i);
 370 @@ -572,7 +576,7 @@ get_ts_summary (TsType type, tn_array *ipkgs, tn_array *dpkgs, tn_array *rpkgs,
 371                                 }
 372                         }
 373                         break;
 374 -               case TS_TYPE_ENUM_REMOVE:
 375 +               case PK_ROLE_ENUM_REMOVE_PACKAGES:
 376                         /* copy packages from rpkgs and dpkgs to remove_pkgs */
 377                         if (rpkgs)
 378                                 n_array_concat_ex (*remove_pkgs, rpkgs, (tn_fn_dup)pkg_link);
 379 @@ -582,7 +586,7 @@ get_ts_summary (TsType type, tn_array *ipkgs, tn_array *dpkgs, tn_array *rpkgs,
 380
 381                         break;
 382                 default:
 383 -                       g_error ("Unknown ts_type value: %d", type);
 384 +                       g_error ("Unknown role value: %d", role);
 385         }
 386
 387         /* return sorted arrays */
 388 @@ -604,8 +608,10 @@ get_ts_summary (TsType type, tn_array *ipkgs, tn_array *dpkgs, tn_array *rpkgs,
 389  static int
 390  ts_confirm (void *data, struct poldek_ts *ts)
 391  {
 392 +       PkBackendJob *job = (PkBackendJob *) data;
 393 +       PkBackendPoldekJobData *job_data = pk_backend_job_get_user_data (job);
 394 +       PkBackendPoldekProgressData *pd = job_data->progress_data;
 395         tn_array        *ipkgs, *dpkgs, *rpkgs;
 396 -       PkBackend       *backend = (PkBackend *)data;
 397         size_t          i = 0;
 398         gint            result = 1;
 399
 400 @@ -615,7 +621,6 @@ ts_confirm (void *data, struct poldek_ts *ts)
 401
 402         if (poldek_ts_get_type (ts) == POLDEK_TS_TYPE_INSTALL) {
 403                 tn_array *update_pkgs, *remove_pkgs, *install_pkgs;
 404 -               PercentageData *pd = pk_backend_get_pointer (backend, "percentage_ptr");
 405                 guint to_install = 0;
 406
 407                 update_pkgs = n_array_new (4, (tn_fn_free)pkg_free, NULL);
 408 @@ -668,13 +673,23 @@ ts_confirm (void *data, struct poldek_ts *ts)
 409                 to_install = n_array_size (install_pkgs);
 410                 to_install += n_array_size (update_pkgs);
 411
 412 -               pk_backend_set_uint (backend, "to_install", to_install);
 413 +               job_data->to_install = to_install;
 414
 415 -               pk_backend_set_pointer (backend, "to_update_pkgs", update_pkgs);
 416 -               pk_backend_set_pointer (backend, "to_remove_pkgs", remove_pkgs);
 417 -               pk_backend_set_pointer (backend, "to_install_pkgs", install_pkgs);
 418 +               job_data->to_update_pkgs = update_pkgs;
 419 +               job_data->to_remove_pkgs = remove_pkgs;
 420 +               job_data->to_install_pkgs = install_pkgs;
 421         } else if (poldek_ts_get_type (ts) == POLDEK_TS_TYPE_UNINSTALL) {
 422 -               gboolean allow_deps = pk_backend_get_bool (backend, "allow_deps");
 423 +               GVariant *params = pk_backend_job_get_parameters (job);
 424 +               PkBitfield transaction_flags;
 425 +               gchar **package_ids;
 426 +               gboolean allow_deps;
 427 +               gboolean autoremove;
 428 +
 429 +               g_variant_get (params, "(t^a&sbb)",
 430 +                              &transaction_flags,
 431 +                              &package_ids,
 432 +                              &allow_deps,
 433 +                              &autoremove);
 434
 435                 /* check if transaction can be performed */
 436                 if (allow_deps == FALSE) {
 437 @@ -687,13 +702,13 @@ ts_confirm (void *data, struct poldek_ts *ts)
 438                         pk_backend_job_set_status (job, PK_STATUS_ENUM_REMOVE);
 439
 440                         /* we shouldn't cancel remove proccess */
 441 -                       poldek_backend_set_allow_cancel (backend, FALSE, FALSE);
 442 +                       poldek_backend_set_allow_cancel (job, FALSE, FALSE);
 443
 444                         if (dpkgs) {
 445                                 for (i = 0; i < n_array_size (dpkgs); i++) {
 446                                         struct pkg *pkg = n_array_nth (dpkgs, i);
 447
 448 -                                       poldek_backend_package (backend, pkg, PK_INFO_ENUM_REMOVING, PK_FILTER_ENUM_NONE);
 449 +                                       poldek_backend_package (job, pkg, PK_INFO_ENUM_REMOVING, PK_FILTER_ENUM_NONE);
 450                                 }
 451                         }
 452
 453 @@ -701,7 +716,7 @@ ts_confirm (void *data, struct poldek_ts *ts)
 454                                 for (i = 0; i < n_array_size (rpkgs); i++) {
 455                                         struct pkg *pkg = n_array_nth (rpkgs, i);
 456
 457 -                                       poldek_backend_package (backend, pkg, PK_INFO_ENUM_REMOVING, PK_FILTER_ENUM_NONE);
 458 +                                       poldek_backend_package (job, pkg, PK_INFO_ENUM_REMOVING, PK_FILTER_ENUM_NONE);
 459                                 }
 460                         }
 461                 }
 462 @@ -728,9 +743,9 @@ suggests_callback (void *data, const struct poldek_ts *ts, const struct pkg *pkg
 463   * setup_vf_progress:
 464   */
 465  static void
 466 -setup_vf_progress (struct vf_progress *vf_progress, PkBackend *backend)
 467 +setup_vf_progress (struct vf_progress *vf_progress, PkBackendJob *job)
 468  {
 469 -       vf_progress->data = backend;
 470 +       vf_progress->data = job;
 471         vf_progress->new = poldek_vf_progress_new;
 472         vf_progress->progress = poldek_vf_progress;
 473         vf_progress->reset = poldek_vf_progress_reset;
 474 @@ -792,14 +807,10 @@ pkg_is_installed (struct pkg *pkg)
 475  {
 476         struct pkgdb *db;
 477         gint cmprc, is_installed = 0;
 478 -       struct poldek_ts *ts;
 479
 480         g_return_val_if_fail (pkg != NULL, FALSE);
 481
 482 -       /* XXX: I don't know how to get ctx->rootdir */
 483 -       ts = poldek_ts_new (ctx, 0);
 484 -
 485 -       db = pkgdb_open (ts->pmctx, ts->rootdir, NULL, O_RDONLY, NULL);
 486 +       db = pkgdb_open (poldek_get_pmctx (ctx), NULL, NULL, O_RDONLY, NULL);
 487
 488         if (db) {
 489                 is_installed = pkgdb_is_pkg_installed (db, pkg, &cmprc);
 490 @@ -807,8 +818,6 @@ pkg_is_installed (struct pkg *pkg)
 491                 pkgdb_free (db);
 492         }
 493
 494 -       poldek_ts_free (ts);
 495 -
 496         return is_installed ? TRUE : FALSE;
 497  }
 498
 499 @@ -1205,15 +1214,12 @@ do_filtering (tn_array *packages, PkBitfield filters)
 500   */
 501  static void
 502  do_requires (tn_array *installed, tn_array *available, tn_array *requires,
 503 -            struct pkg *pkg, PkBackend *backend)
 504 +            struct pkg *pkg, PkBitfield filters, gboolean recursive)
 505  {
 506         tn_array        *tmp = NULL;
 507         size_t          i;
 508 -       PkBitfield filters;
 509 -       gboolean recursive;
 510
 511         tmp = n_array_new (2, NULL, NULL);
 512 -       filters = pk_backend_get_uint (backend, "filters");
 513
 514         /* if ~installed doesn't exists in filters, we can query installed */
 515         if (!pk_bitfield_contain (filters, PK_FILTER_ENUM_NOT_INSTALLED)) {
 516 @@ -1284,11 +1290,10 @@ do_requires (tn_array *installed, tn_array *available, tn_array *requires,
 517
 518         /* FIXME: recursive takes too much time for available packages, so don't use it */
 519         if (pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED)) {
 520 -               recursive = pk_backend_get_bool (backend, "recursive");
 521                 if (recursive && tmp && n_array_size (tmp) > 0) {
 522                         for (i = 0; i < n_array_size (tmp); i++) {
 523                                 struct pkg      *p = n_array_nth (tmp, i);
 524 -                               do_requires (installed, available, requires, p, backend);
 525 +                               do_requires (installed, available, requires, p, filters, recursive);
 526                         }
 527                 }
 528         }
 529 @@ -1300,17 +1305,13 @@ do_requires (tn_array *installed, tn_array *available, tn_array *requires,
 530   * do_depends:
 531   */
 532  static void
 533 -do_depends (tn_array *installed, tn_array *available, tn_array *depends, struct pkg *pkg, PkBackend *backend)
 534 +do_depends (tn_array *installed, tn_array *available, tn_array *depends, struct pkg *pkg, PkBitfield filters, gboolean recursive)
 535  {
 536         tn_array        *reqs = pkg->reqs;
 537         tn_array        *tmp = NULL;
 538         size_t          i;
 539 -       PkBitfield filters;
 540 -       gboolean recursive;
 541
 542         tmp = n_array_new (2, NULL, NULL);
 543 -       filters = pk_backend_get_uint (backend, "filters");
 544 -       recursive = pk_backend_get_bool (backend, "recursive");
 545
 546         /* nothing to do */
 547         if (!reqs || (reqs && n_array_size (reqs) < 1))
 548 @@ -1403,7 +1404,7 @@ do_depends (tn_array *installed, tn_array *available, tn_array *depends, struct
 549                 for (i = 0; i < n_array_size (tmp); i++) {
 550                         struct pkg      *p = n_array_nth (tmp, i);
 551
 552 -                       do_depends (installed, available, depends, p, backend);
 553 +                       do_depends (installed, available, depends, p, filters, recursive);
 554                 }
 555         }
 556
 557 @@ -1451,7 +1452,7 @@ package_id_from_pkg (struct pkg *pkg, const gchar *repo, PkBitfield filters)
 558   * poldek_backend_package:
 559   */
 560  static void
 561 -poldek_backend_package (PkBackend *backend, struct pkg *pkg, PkInfoEnum infoenum, PkBitfield filters)
 562 +poldek_backend_package (PkBackendJob *job, struct pkg *pkg, PkInfoEnum infoenum, PkBitfield filters)
 563  {
 564         struct pkguinf *pkgu = NULL;
 565         gchar *package_id;
 566 @@ -1472,7 +1473,7 @@ poldek_backend_package (PkBackend *backend, struct pkg *pkg, PkInfoEnum infoenum
 567
 568         package_id = package_id_from_pkg (pkg, NULL, filters);
 569
 570 -       if ((pkgu = pkg_uinf_i18n (backend, pkg))) {
 571 +       if ((pkgu = pkg_uinf_i18n (job, pkg))) {
 572                 pk_backend_job_package (job, infoenum, package_id, pkguinf_get (pkgu, PKGUINF_SUMMARY));
 573
 574                 pkguinf_free (pkgu);
 575 @@ -1564,30 +1565,39 @@ do_search_details (const gchar *tree, gchar **values)
 576  static void
 577  search_package_thread (PkBackendJob *job, GVariant *params, gpointer user_data)
 578  {
 579 +       GPtrArray *array = NULL;
 580         PkBitfield              filters;
 581 -       PkProvidesEnum          provides;
 582 +       PkRoleEnum              role;
 583         gchar                  *search_cmd_available = NULL;
 584         gchar                  *search_cmd_installed = NULL;
 585         tn_array               *pkgs = NULL;
 586         gchar                 **values = NULL;
 587         gchar                  *search;
 588 -       guint mode;
 589
 590 -       pb_load_packages (backend);
 591 +       role = pk_backend_job_get_role (job);
 592
 593 -       mode = pk_backend_get_uint (backend, "mode");
 594 -       filters = pk_backend_get_uint (backend, "filters");
 595 +       if (role == PK_ROLE_ENUM_WHAT_PROVIDES) {
 596 +               array = (GPtrArray *) user_data;
 597
 598 -       values = pk_backend_get_strv (backend, "search");
 599 +               g_ptr_array_add (array, NULL);
 600
 601 -       if (values == NULL) {
 602 -               pk_backend_job_error_code (job, PK_ERROR_ENUM_INTERNAL_ERROR,
 603 -                                      "failed to get 'search'");
 604 -               goto out;
 605 +               values = (gchar **) array->pdata;
 606 +
 607 +               g_variant_get (params, "(t)",
 608 +                              &filters);
 609 +
 610 +               g_ptr_array_free (array, FALSE);
 611 +       } else {
 612 +               g_variant_get (params, "(t^a&s)",
 613 +                              &filters,
 614 +                              &values);
 615         }
 616
 617 +
 618 +       pb_load_packages (job);
 619 +
 620         /* SearchName */
 621 -       if (mode == SEARCH_ENUM_NAME) {
 622 +       if (role == PK_ROLE_ENUM_SEARCH_NAME) {
 623                 search = g_strjoinv ("*", values);
 624
 625                 search_cmd_installed = g_strdup_printf ("ls -q *%s*", search);
 626 @@ -1595,7 +1605,7 @@ search_package_thread (PkBackendJob *job, GVariant *params, gpointer user_data)
 627
 628                 g_free (search);
 629         /* SearchGroup */
 630 -       } else if (mode == SEARCH_ENUM_GROUP) {
 631 +       } else if (role == PK_ROLE_ENUM_SEARCH_GROUP) {
 632                 GString *command;
 633                 guint           i;
 634
 635 @@ -1624,7 +1634,7 @@ search_package_thread (PkBackendJob *job, GVariant *params, gpointer user_data)
 636                 search_cmd_installed = g_string_free (command, FALSE);
 637                 search_cmd_available = g_strdup (search_cmd_installed);
 638         /* SearchFile */
 639 -       } else if (mode == SEARCH_ENUM_FILE) {
 640 +       } else if (role == PK_ROLE_ENUM_SEARCH_FILE) {
 641                 GString *local_pkgs = NULL;
 642                 GString *installed_pkgs = NULL;
 643                 GString *available_pkgs = NULL;
 644 @@ -1676,7 +1686,7 @@ search_package_thread (PkBackendJob *job, GVariant *params, gpointer user_data)
 645                 search_cmd_available = g_string_free (available_pkgs, FALSE);
 646
 647         /* WhatProvides */
 648 -       } else if (mode == SEARCH_ENUM_PROVIDES) {
 649 +       } else if (role == PK_ROLE_ENUM_WHAT_PROVIDES) {
 650                 search = g_strjoinv ("\\|", values);
 651
 652                 search_cmd_installed = g_strdup_printf ("search -qp --perlre /%s/", search);
 653 @@ -1684,7 +1694,7 @@ search_package_thread (PkBackendJob *job, GVariant *params, gpointer user_data)
 654
 655                 g_free (search);
 656         /* Resolve */
 657 -       } else if (mode == SEARCH_ENUM_RESOLVE) {
 658 +       } else if (role == PK_ROLE_ENUM_RESOLVE) {
 659                 search = g_strjoinv(" ", values);
 660
 661                 search_cmd_installed = g_strdup_printf ("ls -q %s", search);
 662 @@ -1693,19 +1703,19 @@ search_package_thread (PkBackendJob *job, GVariant *params, gpointer user_data)
 663                 g_free (search);
 664         }
 665
 666 -       if ((search_cmd_installed != NULL && search_cmd_available != NULL) || mode == SEARCH_ENUM_DETAILS) {
 667 +       if ((search_cmd_installed != NULL && search_cmd_available != NULL) || role == PK_ROLE_ENUM_SEARCH_DETAILS) {
 668                 tn_array *installed = NULL;
 669                 tn_array *available = NULL;
 670
 671                 if (!pk_bitfield_contain (filters, PK_FILTER_ENUM_NOT_INSTALLED)) {
 672 -                       if (mode == SEARCH_ENUM_DETAILS)
 673 +                       if (role == PK_ROLE_ENUM_SEARCH_DETAILS)
 674                                 installed = do_search_details ("cd /installed", values);
 675                         else
 676                                 installed = execute_packages_command ("cd /installed; %s", search_cmd_installed);
 677                 }
 678
 679                 if (!pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED)) {
 680 -                       if (mode == SEARCH_ENUM_DETAILS)
 681 +                       if (role == PK_ROLE_ENUM_SEARCH_DETAILS)
 682                                 available = do_search_details ("cd /all-avail", values);
 683                         else
 684                                 available = execute_packages_command ("cd /all-avail; %s", search_cmd_available);
 685 @@ -1759,7 +1769,7 @@ search_package_thread (PkBackendJob *job, GVariant *params, gpointer user_data)
 686                         if (sigint_reached ())
 687                                 break;
 688
 689 -                       poldek_backend_package (backend, pkg, PK_INFO_ENUM_UNKNOWN, filters);
 690 +                       poldek_backend_package (job, pkg, PK_INFO_ENUM_UNKNOWN, filters);
 691                 }
 692                 n_array_free (pkgs);
 693         } else {
 694 @@ -1767,12 +1777,12 @@ search_package_thread (PkBackendJob *job, GVariant *params, gpointer user_data)
 695         }
 696
 697         if (sigint_reached ()) {
 698 -               switch (mode) {
 699 -                       case SEARCH_ENUM_NAME:
 700 -                       case SEARCH_ENUM_GROUP:
 701 -                       case SEARCH_ENUM_DETAILS:
 702 -                       case SEARCH_ENUM_FILE:
 703 -                       case SEARCH_ENUM_RESOLVE:
 704 +               switch (role) {
 705 +                       case PK_ROLE_ENUM_SEARCH_NAME:
 706 +                       case PK_ROLE_ENUM_SEARCH_GROUP:
 707 +                       case PK_ROLE_ENUM_SEARCH_DETAILS:
 708 +                       case PK_ROLE_ENUM_SEARCH_FILE:
 709 +                       case PK_ROLE_ENUM_RESOLVE:
 710                                 pk_backend_job_error_code (job, PK_ERROR_ENUM_TRANSACTION_CANCELLED, "Search cancelled.");
 711                                 break;
 712                         default:
 713 @@ -1784,6 +1794,9 @@ search_package_thread (PkBackendJob *job, GVariant *params, gpointer user_data)
 714         g_free (search_cmd_available);
 715
 716  out:
 717 +       if (array)
 718 +               g_ptr_array_unref (array);
 719 +
 720         pk_backend_job_finished (job);
 721  }
 722
 723 @@ -1794,26 +1807,25 @@ update_packages_thread (PkBackendJob *job, GVariant *params, gpointer user_data)
 724         guint                   i, toupdate = 0;
 725         gchar **package_ids, *command;
 726         GString *cmd;
 727 +       PkBitfield transaction_flags;
 728
 729 -       /* FIXME: support only_trusted */
 730 -       package_ids = pk_backend_get_strv (backend, "package_ids");
 731 -
 732 -       /* sth goes wrong. package_ids has to be set in UpdatePackages */
 733 -       if (package_ids == NULL) {
 734 -               g_warning ("package_ids cannot be NULL in UpdatePackages method.");
 735 -               pk_backend_job_finished (job);
 736 -               return;
 737 -       }
 738 +       g_variant_get (params, "(t^a&s)",
 739 +                      &transaction_flags,
 740 +                      &package_ids);
 741
 742 -       setup_vf_progress (&vf_progress, backend);
 743 +       setup_vf_progress (&vf_progress, job);
 744
 745 -       pb_load_packages (backend);
 746 +       pb_load_packages (job);
 747
 748         pk_backend_job_set_status (job, PK_STATUS_ENUM_DEP_RESOLVE);
 749         pb_error_clean ();
 750
 751         cmd = g_string_new ("upgrade ");
 752
 753 +       if (pk_bitfield_contain (transaction_flags, PK_TRANSACTION_FLAG_ENUM_ONLY_DOWNLOAD)) {
 754 +               g_string_append_printf (cmd, "--fetch ");
 755 +       }
 756 +
 757         for (i = 0; i < g_strv_length (package_ids); i++) {
 758                 struct pkg *pkg;
 759
 760 @@ -1831,35 +1843,144 @@ update_packages_thread (PkBackendJob *job, GVariant *params, gpointer user_data)
 761
 762         if (toupdate > 0) {
 763                 if (execute_command (command) == FALSE) {
 764 -                       pb_error_show (backend, PK_ERROR_ENUM_TRANSACTION_ERROR);
 765 +                       pb_error_show (job, PK_ERROR_ENUM_TRANSACTION_ERROR);
 766                 }
 767         }
 768
 769 -       poldek_backend_percentage_data_destroy (backend);
 770 -
 771         g_free (command);
 772
 773         pk_backend_job_finished (job);
 774  }
 775
 776 +/**
 777 + * do_simulate_packages:
 778 + */
 779 +static void
 780 +do_simulate_packages (PkBackendJob *job, GVariant *params, gpointer user_data)
 781 +{
 782 +       struct poclidek_rcmd *rcmd = NULL;
 783 +       struct poldek_ts     *ts = NULL;
 784 +       GString      *buf = NULL;
 785 +       gchar   *cmd = NULL;
 786 +       gchar       **package_ids = NULL;
 787 +       const gchar  *command = NULL;
 788 +       guint    i;
 789 +       PkRoleEnum role;
 790 +       PkBitfield transaction_flags;
 791 +       gboolean allow_deps = FALSE;
 792 +       gboolean autoremove = FALSE;
 793 +
 794 +       role = pk_backend_job_get_role (job);
 795 +
 796 +       if (role == PK_ROLE_ENUM_INSTALL_PACKAGES) {
 797 +               command = "cd /all-avail; install --test";
 798 +
 799 +               g_variant_get (params, "(t^a&s)",
 800 +                              &transaction_flags,
 801 +                              &package_ids);
 802 +       } else if (role == PK_ROLE_ENUM_UPDATE_PACKAGES) {
 803 +               command = "cd /all-avail; upgrade --test";
 804 +
 805 +               g_variant_get (params, "(t^a&s)",
 806 +                              &transaction_flags,
 807 +                              &package_ids);
 808 +       } else if (role == PK_ROLE_ENUM_REMOVE_PACKAGES) {
 809 +               command = "cd /all-avail; uninstall --test";
 810 +
 811 +               g_variant_get (params, "(t^a&sbb)",
 812 +                              &transaction_flags,
 813 +                              &package_ids,
 814 +                              &allow_deps,
 815 +                              &autoremove);
 816 +       }
 817 +
 818 +       pk_backend_job_set_status (job, PK_STATUS_ENUM_DEP_RESOLVE);
 819 +
 820 +       buf = g_string_new (command);
 821 +
 822 +       for (i = 0; i < g_strv_length (package_ids); i++) {
 823 +               gchar *nvra = poldek_get_nvra_from_package_id (package_ids[i]);
 824 +
 825 +               g_string_append_c (buf, ' ');
 826 +               g_string_append (buf, nvra);
 827 +
 828 +               g_free (nvra);
 829 +       }
 830 +
 831 +       cmd = g_string_free (buf, FALSE);
 832 +
 833 +       ts = poldek_ts_new (ctx, 0);
 834 +       rcmd = poclidek_rcmd_new (cctx, ts);
 835 +
 836 +       ts->setop(ts, POLDEK_OP_PARTICLE, 0);
 837 +
 838 +       if (poclidek_rcmd_execline (rcmd, cmd)) {
 839 +               tn_array *ipkgs = NULL, *dpkgs = NULL, *rpkgs = NULL;
 840 +               tn_array *install_pkgs = NULL, *update_pkgs = NULL, *remove_pkgs = NULL;
 841 +
 842 +               ipkgs = poldek_ts_get_summary (ts, "I");
 843 +               dpkgs = poldek_ts_get_summary (ts, "D");
 844 +               rpkgs = poldek_ts_get_summary (ts, "R");
 845 +
 846 +               get_ts_summary (job, ipkgs, dpkgs, rpkgs, &install_pkgs, &update_pkgs, &remove_pkgs);
 847 +
 848 +               if (install_pkgs) {
 849 +                       for (i = 0; i < n_array_size (install_pkgs); i++) {
 850 +                               struct pkg *pkg = n_array_nth (install_pkgs, i);
 851 +
 852 +                               poldek_backend_package (job, pkg, PK_INFO_ENUM_INSTALLING, PK_FILTER_ENUM_NONE);
 853 +                       }
 854 +
 855 +                       n_array_free (install_pkgs);
 856 +               }
 857 +
 858 +               if (update_pkgs) {
 859 +                       for (i = 0; i < n_array_size (update_pkgs); i++) {
 860 +                               struct pkg *pkg = n_array_nth (update_pkgs, i);
 861 +
 862 +                               poldek_backend_package (job, pkg, PK_INFO_ENUM_UPDATING, PK_FILTER_ENUM_NONE);
 863 +                       }
 864 +
 865 +                       n_array_free (update_pkgs);
 866 +               }
 867 +
 868 +               if (remove_pkgs) {
 869 +                       for (i = 0; i < n_array_size (remove_pkgs); i++) {
 870 +                               struct pkg *pkg = n_array_nth (remove_pkgs, i);
 871 +
 872 +                               poldek_backend_package (job, pkg, PK_INFO_ENUM_REMOVING, PK_FILTER_ENUM_NONE);
 873 +                       }
 874 +
 875 +                       n_array_free (remove_pkgs);
 876 +               }
 877 +       }
 878 +
 879 +       g_free (cmd);
 880 +
 881 +       poclidek_rcmd_free (rcmd);
 882 +       poldek_ts_free (ts);
 883 +
 884 +       pk_backend_job_finished (job);
 885 +}
 886 +
 887  static void
 888 -pb_load_packages (PkBackend *backend)
 889 +pb_load_packages (PkBackendJob *job)
 890  {
 891 -       gboolean        allow_cancel = pk_backend_job_get_allow_cancel (backend);
 892 +       gboolean        allow_cancel = pk_backend_job_get_allow_cancel (job);
 893
 894         /* this operation can't be cancelled, so if enabled, set allow_cancel to FALSE */
 895         if (allow_cancel)
 896 -               poldek_backend_set_allow_cancel (backend, FALSE, FALSE);
 897 +               poldek_backend_set_allow_cancel (job, FALSE, FALSE);
 898
 899         /* load information about installed and available packages */
 900         poclidek_load_packages (cctx, POCLIDEK_LOAD_ALL);
 901
 902         if (allow_cancel)
 903 -               poldek_backend_set_allow_cancel (backend, TRUE, FALSE);
 904 +               poldek_backend_set_allow_cancel (job, TRUE, FALSE);
 905  }
 906
 907  static void
 908 -pb_error_show (PkBackend *backend, PkErrorEnum errorcode)
 909 +pb_error_show (PkBackendJob *job, PkErrorEnum errorcode)
 910  {
 911         if (sigint_reached()) {
 912                 pk_backend_job_error_code (job, PK_ERROR_ENUM_TRANSACTION_CANCELLED, "Action cancelled.");
 913 @@ -1883,7 +2004,7 @@ pb_error_show (PkBackend *backend, PkErrorEnum errorcode)
 914   * This function checks if it happens and if yes, emits error_code and returns TRUE.
 915   **/
 916  static gboolean
 917 -pb_error_check (PkBackend *backend)
 918 +pb_error_check (PkBackendJob *job)
 919  {
 920         PkErrorEnum     errorcode = PK_ERROR_ENUM_UNKNOWN;
 921
 922 @@ -1919,25 +2040,24 @@ pkg_n_strncmp (struct pkg *p, gchar *name)
 923  }
 924
 925  static void
 926 -show_rpm_progress (PkBackend *backend, gchar *message)
 927 +show_rpm_progress (PkBackendJob *job, gchar *message)
 928  {
 929 +       PkBackendPoldekJobData *job_data = pk_backend_job_get_user_data (job);
 930 +
 931         g_return_if_fail (message != NULL);
 932
 933         if (pberror->rpmstate & PB_RPM_STATE_ENUM_REPACKAGING) {
 934                 g_debug ("repackaging '%s'", message);
 935         } else if (pberror->rpmstate & PB_RPM_STATE_ENUM_INSTALLING) {
 936                 tn_array *upkgs, *ipkgs, *rpkgs, *arr = NULL;
 937 -               guint to_install;
 938                 PkInfoEnum pkinfo;
 939                 gint n = -2;
 940
 941                 g_debug ("installing or updating '%s'", message);
 942
 943 -               to_install = pk_backend_get_uint (backend, "to_install");
 944 -
 945 -               ipkgs = pk_backend_get_pointer (backend, "to_install_pkgs");
 946 -               upkgs = pk_backend_get_pointer (backend, "to_update_pkgs");
 947 -               rpkgs = pk_backend_get_pointer (backend, "to_remove_pkgs");
 948 +               ipkgs = job_data->to_install_pkgs;
 949 +               upkgs = job_data->to_update_pkgs;
 950 +               rpkgs = job_data->to_remove_pkgs;
 951
 952                 /* emit remove for packages marked for removal */
 953                 if (rpkgs) {
 954 @@ -1947,7 +2067,7 @@ show_rpm_progress (PkBackend *backend, gchar *message)
 955                         for (i = 0; i < n_array_size (rpkgs); i++) {
 956                                 struct pkg *pkg = n_array_nth (rpkgs, i);
 957
 958 -                               poldek_backend_package (backend, pkg, PK_INFO_ENUM_REMOVING, PK_FILTER_ENUM_NONE);
 959 +                               poldek_backend_package (job, pkg, PK_INFO_ENUM_REMOVING, PK_FILTER_ENUM_NONE);
 960
 961                                 n_array_remove_nth (rpkgs, i);
 962                         }
 963 @@ -1973,7 +2093,7 @@ show_rpm_progress (PkBackend *backend, gchar *message)
 964                         struct pkg *pkg = n_array_nth (arr, n);
 965                         guint in_arrays = 0;
 966
 967 -                       poldek_backend_package (backend, pkg, pkinfo, PK_FILTER_ENUM_NONE);
 968 +                       poldek_backend_package (job, pkg, pkinfo, PK_FILTER_ENUM_NONE);
 969
 970                         n_array_remove_nth (arr, n);
 971
 972 @@ -1984,7 +2104,7 @@ show_rpm_progress (PkBackend *backend, gchar *message)
 973                                 in_arrays += n_array_size (ipkgs);
 974                         }
 975
 976 -                       pk_backend_job_set_percentage (job, (gint)(((float)(to_install - in_arrays) / (float)to_install) * 100));
 977 +                       pk_backend_job_set_percentage (job, (gint)(((float)(job_data->to_install - in_arrays) / (float)job_data->to_install) * 100));
 978                 }
 979         }
 980  }
 981 @@ -2022,7 +2142,7 @@ get_filename_from_message (char *message)
 982  static void
 983  poldek_backend_log (void *data, int pri, char *message)
 984  {
 985 -       PkBackend *backend = (PkBackend*)data;
 986 +       PkBackendJob *job = (PkBackendJob *) data;
 987
 988         /* skip messages that we don't want to show */
 989         if (g_str_has_prefix (message, "Nothing")) // 'Nothing to do'
 990 @@ -2063,7 +2183,7 @@ poldek_backend_log (void *data, int pri, char *message)
 991                 pberror->rpmstate |= PB_RPM_STATE_ENUM_INSTALLING;
 992
 993                 /* we shouldn't cancel install / update proccess */
 994 -               poldek_backend_set_allow_cancel (backend, FALSE, FALSE);
 995 +               poldek_backend_set_allow_cancel (job, FALSE, FALSE);
 996         } else if (strstr (message, "Repackaging...")) {
 997                 pberror->rpmstate |= PB_RPM_STATE_ENUM_REPACKAGING;
 998
 999 @@ -2078,22 +2198,22 @@ poldek_backend_log (void *data, int pri, char *message)
1000                         return;
1001
1002                 if ((pberror->rpmstate & PB_RPM_STATE_ENUM_REPACKAGING) == FALSE) {
1003 -                       guint ts_type = pk_backend_get_uint (backend, "ts_type");
1004 +                       PkRoleEnum role = pk_backend_job_get_role (job);
1005
1006                         /* set proper status */
1007 -                       if (ts_type == TS_TYPE_ENUM_INSTALL) {
1008 +                       if (role == PK_ROLE_ENUM_INSTALL_PACKAGES) {
1009                                 pk_backend_job_set_status (job, PK_STATUS_ENUM_INSTALL);
1010 -                       } else if (ts_type == TS_TYPE_ENUM_UPDATE) {
1011 +                       } else if (role == PK_ROLE_ENUM_UPDATE_PACKAGES) {
1012                                 pk_backend_job_set_status (job, PK_STATUS_ENUM_UPDATE);
1013                         }
1014                 }
1015
1016 -               show_rpm_progress (backend, fn);
1017 +               show_rpm_progress (job, fn);
1018         }
1019  }
1020
1021  static void
1022 -poldek_backend_set_allow_cancel (PkBackend *backend, gboolean allow_cancel, gboolean reset)
1023 +poldek_backend_set_allow_cancel (PkBackendJob *job, gboolean allow_cancel, gboolean reset)
1024  {
1025         if (reset)
1026                 sigint_reset ();
1027 @@ -2102,34 +2222,6 @@ poldek_backend_set_allow_cancel (PkBackend *backend, gboolean allow_cancel, gboo
1028  }
1029
1030  static void
1031 -poldek_backend_percentage_data_create (PkBackend *backend)
1032 -{
1033 -       PercentageData *data;
1034 -
1035 -       data = g_new0 (PercentageData, 1);
1036 -       pk_backend_set_pointer (backend, "percentage_ptr", data);
1037 -}
1038 -
1039 -static void
1040 -poldek_backend_percentage_data_destroy (PkBackend *backend)
1041 -{
1042 -       PercentageData *data;
1043 -       tn_array *upkgs, *ipkgs, *rpkgs;
1044 -
1045 -       data = (gpointer) pk_backend_get_pointer (backend, "percentage_ptr");
1046 -
1047 -       upkgs = (gpointer) pk_backend_get_pointer (backend, "to_update_pkgs");
1048 -       ipkgs = (gpointer) pk_backend_get_pointer (backend, "to_install_pkgs");
1049 -       rpkgs = (gpointer) pk_backend_get_pointer (backend, "to_remove_pkgs");
1050 -
1051 -       n_array_cfree (&upkgs);
1052 -       n_array_cfree (&ipkgs);
1053 -       n_array_cfree (&rpkgs);
1054 -
1055 -       g_free (data);
1056 -}
1057 -
1058 -static void
1059  do_poldek_init (PkBackend *backend)
1060  {
1061         poldeklib_init ();
1062 @@ -2147,8 +2239,6 @@ do_poldek_init (PkBackend *backend)
1063         poldek_configure (ctx, POLDEK_CONF_LOGFILE, NULL);
1064         poldek_configure (ctx, POLDEK_CONF_LOGTTY, NULL);
1065
1066 -       poldek_log_set_appender ("PackageKit", (void *)backend, NULL, 0, (poldek_vlog_fn)poldek_backend_log);
1067 -
1068         /* disable unique package names */
1069         poldek_configure (ctx, POLDEK_CONF_OPT, POLDEK_OP_UNIQN, 0);
1070
1071 @@ -2160,7 +2250,6 @@ do_poldek_init (PkBackend *backend)
1072         /* (...), but we don't need choose_equiv callback */
1073         poldek_configure (ctx, POLDEK_CONF_OPT, POLDEK_OP_EQPKG_ASKUSER, 0);
1074
1075 -       poldek_configure (ctx, POLDEK_CONF_TSCONFIRM_CB, ts_confirm, backend);
1076         /* Install all suggested packages by default */
1077         poldek_configure (ctx, POLDEK_CONF_CHOOSESUGGESTS_CB, suggests_callback, NULL);
1078
1079 @@ -2179,12 +2268,12 @@ do_poldek_destroy (PkBackend *backend)
1080  }
1081
1082  static void
1083 -poldek_reload (PkBackend *backend, gboolean load_packages) {
1084 -       do_poldek_destroy (backend);
1085 -       do_poldek_init (backend);
1086 +poldek_reload (PkBackendJob *job, gboolean load_packages) {
1087 +       do_poldek_destroy (pk_backend_job_get_backend (job));
1088 +       do_poldek_init (pk_backend_job_get_backend (job));
1089
1090         if (load_packages)
1091 -               pb_load_packages (backend);
1092 +               pb_load_packages (job);
1093  }
1094
1095  /**
1096 @@ -2211,15 +2300,18 @@ pk_backend_get_author (PkBackend *backend)
1097  void
1098  pk_backend_initialize (PkBackend *backend)
1099  {
1100 +       struct passwd *uid_ent = NULL;
1101 +
1102         g_debug ("backend initalize start");
1103
1104 -       clv = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify)n_array_free);
1105 +       /* looks like rpm5 needs HOME to be set */
1106 +       if ((uid_ent = getpwuid (getuid ())) == NULL) {
1107 +               g_error ("Failed to set HOME");
1108 +       }
1109 +
1110 +       setenv ("HOME", uid_ent->pw_dir, 0);
1111
1112 -       /* BACKEND MAINTAINER: feel free to remove this when you've
1113 -        * added support for ONLY_DOWNLOAD and merged the simulate
1114 -        * methods as specified in backends/PORTING.txt */
1115 -       g_error ("Backend needs to be ported to 0.8.x -- "
1116 -                "see backends/PORTING.txt for details");
1117 +       clv = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify)n_array_free);
1118
1119         pberror = g_new0 (PbError, 1);
1120         pberror->tslog = g_string_new ("");
1121 @@ -2246,6 +2338,44 @@ pk_backend_destroy (PkBackend *backend)
1122  }
1123
1124  /**
1125 + * pk_backend_start_job:
1126 + */
1127 +void
1128 +pk_backend_start_job (PkBackend *backend, PkBackendJob *job)
1129 +{
1130 +       PkBackendPoldekJobData *job_data;
1131 +
1132 +       job_data = g_new0 (PkBackendPoldekJobData, 1);
1133 +       pk_backend_job_set_user_data (job, job_data);
1134 +
1135 +       job_data->progress_data = g_new0 (PkBackendPoldekProgressData, 1);
1136 +
1137 +       poldek_log_set_appender ("PackageKit", (void *) job, NULL, 0, (poldek_vlog_fn) poldek_backend_log);
1138 +
1139 +       poldek_configure (ctx, POLDEK_CONF_TSCONFIRM_CB, ts_confirm, job);
1140 +}
1141 +
1142 +/**
1143 + * pk_backend_stop_job:
1144 + */
1145 +void
1146 +pk_backend_stop_job (PkBackend *backend, PkBackendJob *job)
1147 +{
1148 +       PkBackendPoldekJobData *job_data = pk_backend_job_get_user_data (job);
1149 +
1150 +       if (job_data->progress_data != NULL)
1151 +               g_free (job_data->progress_data);
1152 +
1153 +       n_array_cfree (&job_data->to_install_pkgs);
1154 +       n_array_cfree (&job_data->to_update_pkgs);
1155 +       n_array_cfree (&job_data->to_remove_pkgs);
1156 +
1157 +       g_free (job_data);
1158 +
1159 +       pk_backend_job_set_user_data (job, NULL);
1160 +}
1161 +
1162 +/**
1163   * pk_backend_get_groups:
1164   */
1165  PkBitfield
1166 @@ -2315,24 +2445,26 @@ pk_backend_cancel (PkBackend *backend, PkBackendJob *job)
1167  static void
1168  backend_download_packages_thread (PkBackendJob *job, GVariant *params, gpointer user_data)
1169  {
1170 -       PercentageData *pd = pk_backend_get_pointer (backend, "percentage_ptr");
1171 +       PkBackendPoldekJobData *job_data = pk_backend_job_get_user_data (job);
1172 +       PkBackendPoldekProgressData *pd = job_data->progress_data;
1173         struct poldek_ts *ts;
1174         struct vf_progress vf_progress;
1175         tn_array *pkgs;
1176         gchar **package_ids;
1177         const gchar *destdir;
1178 -       size_t i;
1179 +       guint i;
1180
1181 -       package_ids = pk_backend_get_strv (backend, "package_ids");
1182 -       destdir = pk_backend_get_string (backend, "directory");
1183 +       g_variant_get (params, "(^a&ss)",
1184 +                      &package_ids,
1185 +                      &destdir);
1186
1187         pkgs = n_array_new (10, (tn_fn_free)pkg_free, NULL);
1188
1189         ts = poldek_ts_new (ctx, 0);
1190
1191 -       setup_vf_progress (&vf_progress, backend);
1192 +       setup_vf_progress (&vf_progress, job);
1193
1194 -       pb_load_packages (backend);
1195 +       pb_load_packages (job);
1196
1197         for (i = 0; i < g_strv_length (package_ids); i++) {
1198                 struct pkg *pkg = poldek_get_pkg_from_package_id (package_ids[i]);
1199 @@ -2346,34 +2478,24 @@ backend_download_packages_thread (PkBackendJob *job, GVariant *params, gpointer
1200         pd->bytesdownload = poldek_get_bytes_to_download (ts, pkgs);
1201
1202         if (packages_fetch (poldek_get_pmctx (ts->ctx), pkgs, destdir, 1)) {
1203 -               GString *filelist = NULL;
1204 -               gchar *result = NULL;
1205 -
1206 -               filelist = g_string_new ("");
1207 -
1208 -               /* emit the file list we downloaded */
1209                 for (i = 0; i < n_array_size (pkgs); i++) {
1210                         struct pkg *pkg = n_array_nth (pkgs, i);
1211 +                       gchar *package_id;
1212 +                       gchar *path;
1213                         gchar buf[256];
1214
1215 -                       if (i > 0)
1216 -                           g_string_append_c (filelist, ';');
1217 -
1218 -                       g_string_append_printf (filelist, "%s/%s", destdir,
1219 -                                               pkg_filename (pkg, buf, sizeof(buf)));
1220 -               }
1221 +                       package_id = package_id_from_pkg (pkg, NULL, PK_FILTER_ENUM_NONE);
1222 +                       path = g_build_filename (destdir, pkg_filename (pkg, buf, sizeof (buf)), NULL);
1223
1224 -               result = g_string_free (filelist, FALSE);
1225 +                       pk_backend_job_files (job, package_id, path);
1226
1227 -               pk_backend_job_files (job, NULL, result);
1228 -
1229 -               g_free (result);
1230 +                       g_free (package_id);
1231 +                       g_free (path);
1232 +               }
1233         }
1234
1235         poldek_ts_free (ts);
1236
1237 -       poldek_backend_percentage_data_destroy (backend);
1238 -
1239         pk_backend_job_finished (job);
1240  }
1241
1242 @@ -2382,10 +2504,9 @@ pk_backend_download_packages (PkBackend *backend, PkBackendJob *job, gchar **pac
1243                               const gchar *directory)
1244  {
1245         pk_backend_job_set_status (job, PK_STATUS_ENUM_DOWNLOAD);
1246 -       poldek_backend_set_allow_cancel (backend, FALSE, TRUE);
1247 +       poldek_backend_set_allow_cancel (job, FALSE, TRUE);
1248         pb_error_clean ();
1249
1250 -       poldek_backend_percentage_data_create (backend);
1251         pk_backend_job_thread_create (job, backend_download_packages_thread, NULL, NULL);
1252  }
1253
1254 @@ -2395,29 +2516,35 @@ pk_backend_download_packages (PkBackend *backend, PkBackendJob *job, gchar **pac
1255  static void
1256  backend_get_depends_thread (PkBackendJob *job, GVariant *params, gpointer user_data)
1257  {
1258 -       struct pkg      *pkg;
1259 -       tn_array        *deppkgs, *available, *installed;
1260 -       size_t          i;
1261 +       PkBitfield filters;
1262 +       gboolean recursive;
1263         gchar **package_ids;
1264 +       struct pkg *pkg;
1265 +       tn_array *deppkgs, *available, *installed;
1266 +       size_t i;
1267 +
1268 +       g_variant_get (params, "(t^a&sb)",
1269 +                      &filters,
1270 +                      &package_ids,
1271 +                      &recursive);
1272
1273 -       pb_load_packages (backend);
1274 +       pb_load_packages (job);
1275
1276         deppkgs = n_array_new (2, NULL, NULL);
1277
1278         installed = poldek_get_installed_packages ();
1279         available = poldek_get_avail_packages (ctx);
1280 -       package_ids = pk_backend_get_strv (backend, "package_ids");
1281
1282         pkg = poldek_get_pkg_from_package_id (package_ids[0]);
1283
1284 -       do_depends (installed, available, deppkgs, pkg, backend);
1285 +       do_depends (installed, available, deppkgs, pkg, filters, recursive);
1286
1287         n_array_sort_ex(deppkgs, (tn_fn_cmp)pkg_cmp_name_evr_rev);
1288
1289         for (i = 0; i < n_array_size (deppkgs); i++) {
1290                 struct pkg      *p = n_array_nth (deppkgs, i);
1291
1292 -               poldek_backend_package (backend, p, PK_INFO_ENUM_UNKNOWN, pk_backend_get_uint (backend, "filters"));
1293 +               poldek_backend_package (job, p, PK_INFO_ENUM_UNKNOWN, filters);
1294         }
1295
1296         pkg_free (pkg);
1297 @@ -2433,7 +2560,7 @@ void
1298  pk_backend_get_depends (PkBackend *backend, PkBackendJob *job, PkBitfield filters, gchar **package_ids, gboolean recursive)
1299  {
1300         pk_backend_job_set_status (job, PK_STATUS_ENUM_QUERY);
1301 -       poldek_backend_set_allow_cancel (backend, FALSE, TRUE);
1302 +       poldek_backend_set_allow_cancel (job, FALSE, TRUE);
1303         pb_error_clean ();
1304
1305         pk_backend_job_thread_create (job, backend_get_depends_thread, NULL, NULL);
1306 @@ -2448,9 +2575,10 @@ backend_get_details_thread (PkBackendJob *job, GVariant *params, gpointer user_d
1307         gchar **package_ids;
1308         guint n;
1309
1310 -       package_ids = pk_backend_get_strv (backend, "package_ids");
1311 +       g_variant_get (params, "(^a&s)",
1312 +                      &package_ids);
1313
1314 -       pb_load_packages (backend);
1315 +       pb_load_packages (job);
1316
1317         for (n = 0; n < g_strv_length (package_ids); n++) {
1318                 struct pkg *pkg = NULL;
1319 @@ -2461,7 +2589,7 @@ backend_get_details_thread (PkBackendJob *job, GVariant *params, gpointer user_d
1320
1321                         group = pld_group_to_enum (pkg_group (pkg));
1322
1323 -                       if ((pkgu = pkg_uinf_i18n (backend, pkg)) != NULL) {
1324 +                       if ((pkgu = pkg_uinf_i18n (job, pkg)) != NULL) {
1325                                 pk_backend_job_details (job,
1326                                                         package_ids[n],
1327                                                         pkguinf_get (pkgu, PKGUINF_LICENSE),
1328 @@ -2491,7 +2619,7 @@ void
1329  pk_backend_get_details (PkBackend *backend, PkBackendJob *job, gchar **package_ids)
1330  {
1331         pk_backend_job_set_status (job, PK_STATUS_ENUM_QUERY);
1332 -       poldek_backend_set_allow_cancel (backend, FALSE, TRUE);
1333 +       poldek_backend_set_allow_cancel (job, FALSE, TRUE);
1334         pb_error_clean ();
1335
1336         pk_backend_job_thread_create (job, backend_get_details_thread, NULL, NULL);
1337 @@ -2506,9 +2634,10 @@ backend_get_files_thread (PkBackendJob *job, GVariant *params, gpointer user_dat
1338         gchar **package_ids;
1339         size_t n;
1340
1341 -       package_ids = pk_backend_get_strv (backend, "package_ids");
1342 +       g_variant_get (params, "(^a&s)",
1343 +                      &package_ids);
1344
1345 -       pb_load_packages (backend);
1346 +       pb_load_packages (job);
1347
1348         for (n = 0; n < g_strv_length (package_ids); n++) {
1349                 struct pkg *pkg;
1350 @@ -2567,7 +2696,7 @@ void
1351  pk_backend_get_files (PkBackend *backend, PkBackendJob *job, gchar **package_ids)
1352  {
1353         pk_backend_job_set_status (job, PK_STATUS_ENUM_QUERY);
1354 -       poldek_backend_set_allow_cancel (backend, FALSE, TRUE);
1355 +       poldek_backend_set_allow_cancel (job, FALSE, TRUE);
1356         pb_error_clean ();
1357
1358         pk_backend_job_thread_create (job, backend_get_files_thread, NULL, NULL);
1359 @@ -2585,11 +2714,12 @@ backend_get_packages_thread (PkBackendJob *job, GVariant *params, gpointer user_
1360         tn_array       *packages = NULL;
1361         guint           i;
1362
1363 -       filters = pk_backend_get_uint (backend, "filters");
1364 +       g_variant_get (params, "(t)",
1365 +                      &filters);
1366
1367         pk_backend_job_set_percentage (job, 0);
1368
1369 -       pb_load_packages (backend);
1370 +       pb_load_packages (job);
1371
1372         if (pk_bitfield_contain (filters, PK_FILTER_ENUM_NOT_INSTALLED) == FALSE)
1373                 installed = poldek_get_installed_packages ();
1374 @@ -2614,7 +2744,7 @@ backend_get_packages_thread (PkBackendJob *job, GVariant *params, gpointer user_
1375
1376                         pk_backend_job_set_percentage (job, (guint)(10 + (90 * (float)(i + 1) / n_array_size (packages))));
1377
1378 -                       poldek_backend_package (backend, pkg, PK_INFO_ENUM_UNKNOWN, filters);
1379 +                       poldek_backend_package (job, pkg, PK_INFO_ENUM_UNKNOWN, filters);
1380                 }
1381         }
1382
1383 @@ -2634,7 +2764,7 @@ void
1384  pk_backend_get_packages (PkBackend *backend, PkBackendJob *job, PkBitfield filters)
1385  {
1386         pk_backend_job_set_status (job, PK_STATUS_ENUM_QUERY);
1387 -       poldek_backend_set_allow_cancel (backend, TRUE, TRUE);
1388 +       poldek_backend_set_allow_cancel (job, TRUE, TRUE);
1389         pb_error_clean ();
1390
1391         pk_backend_job_thread_create (job, backend_get_packages_thread, NULL, NULL);
1392 @@ -2650,17 +2780,23 @@ backend_get_requires_thread (PkBackendJob *job, GVariant *params, gpointer user_
1393         tn_array        *reqpkgs, *available, *installed;
1394         size_t          i;
1395         gchar **package_ids;
1396 +       PkBitfield filters;
1397 +       gboolean recursive;
1398 +
1399 +       g_variant_get (params, "(t^a&sb)",
1400 +                      &filters,
1401 +                      &package_ids,
1402 +                      &recursive);
1403
1404 -       pb_load_packages (backend);
1405 +       pb_load_packages (job);
1406
1407         reqpkgs = n_array_new (2, NULL, NULL);
1408
1409 -       package_ids = pk_backend_get_strv (backend, "package_ids");
1410         pkg = poldek_get_pkg_from_package_id (package_ids[0]);
1411         installed = poldek_get_installed_packages ();
1412         available = poldek_get_avail_packages (ctx);
1413
1414 -       do_requires (installed, available, reqpkgs, pkg, backend);
1415 +       do_requires (installed, available, reqpkgs, pkg, filters, recursive);
1416
1417         /* sort output */
1418         n_array_sort_ex(reqpkgs, (tn_fn_cmp)pkg_cmp_name_evr_rev);
1419 @@ -2668,7 +2804,7 @@ backend_get_requires_thread (PkBackendJob *job, GVariant *params, gpointer user_
1420         for (i = 0; i < n_array_size (reqpkgs); i++) {
1421                 struct pkg      *p = n_array_nth (reqpkgs, i);
1422
1423 -               poldek_backend_package (backend, p, PK_INFO_ENUM_UNKNOWN, pk_backend_get_uint (backend, "filters"));
1424 +               poldek_backend_package (job, p, PK_INFO_ENUM_UNKNOWN, filters);
1425         }
1426
1427         n_array_free (reqpkgs);
1428 @@ -2682,7 +2818,7 @@ void
1429  pk_backend_get_requires (PkBackend *backend, PkBackendJob *job, PkBitfield filters, gchar **package_ids, gboolean recursive)
1430  {
1431         pk_backend_job_set_status (job, PK_STATUS_ENUM_QUERY);
1432 -       poldek_backend_set_allow_cancel (backend, FALSE, TRUE);
1433 +       poldek_backend_set_allow_cancel (job, FALSE, TRUE);
1434         pb_error_clean ();
1435
1436         pk_backend_job_thread_create (job, backend_get_requires_thread, NULL, NULL);
1437 @@ -2691,15 +2827,17 @@ pk_backend_get_requires (PkBackend *backend, PkBackendJob *job, PkBitfield filte
1438  /**
1439   * pk_backend_get_update_detail:
1440   */
1441 -static gchar*
1442 +static GPtrArray *
1443  get_obsoletedby_pkg (struct pkg *pkg)
1444  {
1445 +       GPtrArray *obsoletes = NULL;
1446         tn_array *dbpkgs;
1447 -       GString *obsoletes = NULL;
1448         size_t i;
1449
1450         g_return_val_if_fail (pkg != NULL, NULL);
1451
1452 +       obsoletes = g_ptr_array_new ();
1453 +
1454         /* get installed packages */
1455         dbpkgs = poclidek_get_dent_packages (cctx, POCLIDEK_INSTALLEDDIR);
1456
1457 @@ -2710,22 +2848,13 @@ get_obsoletedby_pkg (struct pkg *pkg)
1458                 struct pkg *dbpkg = n_array_nth (dbpkgs, i);
1459
1460                 if (pkg_caps_obsoletes_pkg_caps (pkg, dbpkg)) {
1461 -                       gchar *package_id = package_id_from_pkg (dbpkg, "installed", 0);
1462 -
1463 -                       if (obsoletes) {
1464 -                               obsoletes = g_string_append_c (obsoletes, '^');
1465 -                               obsoletes = g_string_append (obsoletes, package_id);
1466 -                       } else {
1467 -                               obsoletes = g_string_new (package_id);
1468 -                       }
1469 -
1470 -                       g_free (package_id);
1471 +                       g_ptr_array_add (obsoletes, package_id_from_pkg (dbpkg, "installed", 0));
1472                 }
1473         }
1474
1475         n_array_free (dbpkgs);
1476
1477 -       return obsoletes ? g_string_free (obsoletes, FALSE) : NULL;
1478 +       return obsoletes;
1479  }
1480
1481  static void
1482 @@ -2734,9 +2863,10 @@ backend_get_update_detail_thread (PkBackendJob *job, GVariant *params, gpointer
1483         gchar **package_ids = NULL;
1484         guint n;
1485
1486 -       package_ids = pk_backend_get_strv (backend, "package_ids");
1487 +       g_variant_get (params, "(^a&s)",
1488 +                      &package_ids);
1489
1490 -       pb_load_packages (backend);
1491 +       pb_load_packages (job);
1492
1493         for (n = 0; n < g_strv_length (package_ids); n++) {
1494                 tn_array  *packages = NULL;
1495 @@ -2753,71 +2883,67 @@ backend_get_update_detail_thread (PkBackendJob *job, GVariant *params, gpointer
1496                         pkg = n_array_nth (packages, 0);
1497
1498                         if (strcmp (pkg->name, parts[PK_PACKAGE_ID_NAME]) == 0) {
1499 -                               gchar *updates = NULL;
1500 -                               gchar *obsoletes = NULL;
1501 -                               gchar *cve_url = NULL;
1502 +                               GPtrArray *obsoletes = NULL;
1503 +                               GPtrArray *updates = NULL;
1504 +                               GPtrArray *cve_urls = NULL;
1505                                 const gchar *changes = NULL;
1506                                 tn_array *cves = NULL;
1507                                 struct pkguinf *upkg_uinf = NULL;
1508
1509 -                               updates = package_id_from_pkg (pkg, "installed", 0);
1510 -
1511                                 upkg = poldek_get_pkg_from_package_id (package_ids[n]);
1512
1513 +                               updates = g_ptr_array_new ();
1514 +                               g_ptr_array_add (updates, package_id_from_pkg (pkg, "installed", 0));
1515 +
1516                                 obsoletes = get_obsoletedby_pkg (upkg);
1517
1518                                 if ((upkg_uinf = pkg_uinf (upkg)) != NULL) {
1519                                         changes = pkguinf_get_changelog (upkg_uinf, pkg->btime);
1520                                 }
1521
1522 +                               cve_urls = g_ptr_array_new ();
1523                                 if ((cves = poldek_pkg_get_cves_from_pld_changelog (upkg, pkg->btime))) {
1524 -                                       GString *string;
1525                                         guint i;
1526
1527 -                                       string = g_string_new ("");
1528 -
1529                                         for (i = 0; i < n_array_size (cves); i++) {
1530                                                 gchar *cve = n_array_nth (cves, i);
1531
1532 -                                               g_string_append_printf (string,
1533 -                                                                       "http://nvd.nist.gov/nvd.cfm?cvename=%s;%s",
1534 -                                                                       cve, cve);
1535 -
1536 -                                               if ((i + 1) < n_array_size (cves))
1537 -                                                       g_string_append_printf (string, ";");
1538 +                                               g_ptr_array_add (cve_urls,
1539 +                                                                g_strdup_printf ("http://web.nvd.nist.gov/view/vuln/detail?vulnId=%s", cve));
1540                                         }
1541 -
1542 -                                       cve_url = g_string_free (string, FALSE);
1543                                 }
1544
1545 +                               g_ptr_array_add (updates, NULL);
1546 +                               g_ptr_array_add (obsoletes, NULL);
1547 +                               g_ptr_array_add (cve_urls, NULL);
1548 +
1549                                 pk_backend_job_update_detail (job,
1550                                                           package_ids[n],
1551 -                                                         updates,
1552 -                                                         obsoletes ? obsoletes : "",
1553 -                                                         "",
1554 -                                                         "",
1555 -                                                         cve_url ? cve_url : "",
1556 +                                                         (gchar **) updates->pdata,
1557 +                                                         (gchar **) obsoletes->pdata,
1558 +                                                         NULL, // vendor urls
1559 +                                                         NULL, // bugzilla urls
1560 +                                                         (gchar **) cve_urls->pdata,
1561                                                           PK_RESTART_ENUM_NONE,
1562 -                                                         "", changes, PK_UPDATE_STATE_ENUM_UNKNOWN, NULL, NULL);
1563 +                                                         "", // update text
1564 +                                                         changes,
1565 +                                                         PK_UPDATE_STATE_ENUM_UNKNOWN,
1566 +                                                         NULL, // issued
1567 +                                                         NULL); // updated
1568
1569 -                               g_free (updates);
1570 -                               g_free (obsoletes);
1571 -                               g_free (cve_url);
1572 +                               g_ptr_array_unref (updates);
1573 +                               g_ptr_array_unref (obsoletes);
1574 +                               g_ptr_array_unref (cve_urls);
1575
1576                                 n_array_cfree (&cves);
1577                         }
1578
1579                         n_array_free (packages);
1580                 } else {
1581 -                       pk_backend_job_update_detail (job,
1582 -                                                 package_ids[n],
1583 -                                                 "",
1584 -                                                 "",
1585 -                                                 "",
1586 -                                                 "",
1587 -                                                 "",
1588 -                                                 PK_RESTART_ENUM_NONE,
1589 -                                                 "", NULL, PK_UPDATE_STATE_ENUM_UNKNOWN, NULL, NULL);
1590 +                       pk_backend_job_error_code (job,
1591 +                                              PK_ERROR_ENUM_PACKAGE_NOT_FOUND,
1592 +                                              "failed to find package %s",
1593 +                                              package_ids[n]);
1594                 }
1595
1596                 g_strfreev (parts);
1597 @@ -2830,7 +2956,7 @@ void
1598  pk_backend_get_update_detail (PkBackend *backend, PkBackendJob *job, gchar **package_ids)
1599  {
1600         pk_backend_job_set_status (job, PK_STATUS_ENUM_QUERY);
1601 -       poldek_backend_set_allow_cancel (backend, FALSE, TRUE);
1602 +       poldek_backend_set_allow_cancel (job, FALSE, TRUE);
1603         pb_error_clean ();
1604
1605         pk_backend_job_thread_create (job, backend_get_update_detail_thread, NULL, NULL);
1606 @@ -2844,7 +2970,7 @@ backend_get_updates_thread (PkBackendJob *job, GVariant *params, gpointer user_d
1607  {
1608         tn_array *packages = NULL;
1609
1610 -       pb_load_packages (backend);
1611 +       pb_load_packages (job);
1612
1613         if ((packages = execute_packages_command ("cd /all-avail; ls -q -u")) != NULL) {
1614                 tn_array *secupgrades = NULL;
1615 @@ -2863,11 +2989,11 @@ backend_get_updates_thread (PkBackendJob *job, GVariant *params, gpointer user_d
1616
1617                         /* mark held packages as blocked */
1618                         if (pkg->flags & PKG_HELD)
1619 -                               poldek_backend_package (backend, pkg, PK_INFO_ENUM_BLOCKED, PK_FILTER_ENUM_NONE);
1620 +                               poldek_backend_package (job, pkg, PK_INFO_ENUM_BLOCKED, PK_FILTER_ENUM_NONE);
1621                         else if (poldek_pkg_in_array (pkg, secupgrades, (tn_fn_cmp)pkg_cmp_name_evr))
1622 -                               poldek_backend_package (backend, pkg, PK_INFO_ENUM_SECURITY, PK_FILTER_ENUM_NONE);
1623 +                               poldek_backend_package (job, pkg, PK_INFO_ENUM_SECURITY, PK_FILTER_ENUM_NONE);
1624                         else
1625 -                               poldek_backend_package (backend, pkg, PK_INFO_ENUM_NORMAL, PK_FILTER_ENUM_NONE);
1626 +                               poldek_backend_package (job, pkg, PK_INFO_ENUM_NORMAL, PK_FILTER_ENUM_NONE);
1627                 }
1628
1629                 n_array_cfree (&secupgrades);
1630 @@ -2884,7 +3010,7 @@ void
1631  pk_backend_get_updates (PkBackend *backend, PkBackendJob *job, PkBitfield filters)
1632  {
1633         pk_backend_job_set_status (job, PK_STATUS_ENUM_QUERY);
1634 -       poldek_backend_set_allow_cancel (backend, TRUE, TRUE);
1635 +       poldek_backend_set_allow_cancel (job, TRUE, TRUE);
1636         pb_error_clean ();
1637
1638         pk_backend_job_thread_create (job, backend_get_updates_thread, NULL, NULL);
1639 @@ -2899,20 +3025,25 @@ backend_install_packages_thread (PkBackendJob *job, GVariant *params, gpointer u
1640         gchar                   *command;
1641         struct vf_progress      vf_progress;
1642         gchar **package_ids;
1643 +       PkBitfield transaction_flags;
1644         GString *cmd;
1645         size_t i;
1646
1647 -       pk_backend_set_uint (backend, "ts_type", TS_TYPE_ENUM_INSTALL);
1648 -
1649         /* FIXME: support only_trusted */
1650 -       package_ids = pk_backend_get_strv (backend, "package_ids");
1651 +       g_variant_get (params, "(t^a&s)",
1652 +                      &transaction_flags,
1653 +                      &package_ids);
1654
1655 -       setup_vf_progress (&vf_progress, backend);
1656 +       setup_vf_progress (&vf_progress, job);
1657
1658 -       pb_load_packages (backend);
1659 +       pb_load_packages (job);
1660
1661         cmd = g_string_new ("install ");
1662
1663 +       if (pk_bitfield_contain (transaction_flags, PK_TRANSACTION_FLAG_ENUM_ONLY_DOWNLOAD)) {
1664 +               g_string_append_printf (cmd, "--fetch ");
1665 +       }
1666 +
1667         /* prepare command */
1668         for (i = 0; i < g_strv_length (package_ids); i++) {
1669                 gchar   *nvra = poldek_get_nvra_from_package_id (package_ids[i]);
1670 @@ -2927,20 +3058,20 @@ backend_install_packages_thread (PkBackendJob *job, GVariant *params, gpointer u
1671         pk_backend_job_set_status (job, PK_STATUS_ENUM_DEP_RESOLVE);
1672
1673         if (execute_command (command)) {
1674 -               pb_error_check (backend);
1675 +               pb_error_check (job);
1676         } else {
1677 -               pb_error_show (backend, PK_ERROR_ENUM_TRANSACTION_ERROR);
1678 +               pb_error_show (job, PK_ERROR_ENUM_TRANSACTION_ERROR);
1679         }
1680
1681         g_free (command);
1682
1683 -       poldek_backend_percentage_data_destroy (backend);
1684 -
1685         pk_backend_job_finished (job);
1686  }
1687
1688  void
1689 -pk_backend_install_packages (PkBackend *backend, PkBackendJob *job, PkBitfield transaction_flags, gchar **package_ids)
1690 +pk_backend_install_packages (PkBackend *backend, PkBackendJob *job,
1691 +                            PkBitfield transaction_flags,
1692 +                            gchar **package_ids)
1693  {
1694         if (!pk_backend_is_online (backend)) {
1695                 pk_backend_job_error_code (job, PK_ERROR_ENUM_NO_NETWORK, "Cannot install package when offline!");
1696 @@ -2948,11 +3079,14 @@ pk_backend_install_packages (PkBackend *backend, PkBackendJob *job, PkBitfield t
1697                 return;
1698         }
1699
1700 -       poldek_backend_set_allow_cancel (backend, TRUE, TRUE);
1701 +       poldek_backend_set_allow_cancel (job, TRUE, TRUE);
1702         pb_error_clean ();
1703
1704 -       poldek_backend_percentage_data_create (backend);
1705 -       pk_backend_job_thread_create (job, backend_install_packages_thread, NULL, NULL);
1706 +       if (pk_bitfield_contain (transaction_flags, PK_TRANSACTION_FLAG_ENUM_SIMULATE)) {
1707 +               pk_backend_job_thread_create (job, do_simulate_packages, NULL, NULL);
1708 +       } else {
1709 +               pk_backend_job_thread_create (job, backend_install_packages_thread, NULL, NULL);
1710 +       }
1711  }
1712
1713  /**
1714 @@ -2962,11 +3096,12 @@ pk_backend_install_packages (PkBackend *backend, PkBackendJob *job, PkBitfield t
1715  static void
1716  backend_refresh_cache_thread (PkBackendJob *job, GVariant *params, gpointer user_data)
1717  {
1718 +       PkBackendPoldekJobData *job_data = pk_backend_job_get_user_data (job);
1719 +       PkBackendPoldekProgressData *pd = job_data->progress_data;
1720         tn_array                *sources = NULL;
1721         struct vf_progress      vfpro;
1722 -       PercentageData *pd = pk_backend_get_pointer (backend, "percentage_ptr");
1723
1724 -       setup_vf_progress (&vfpro, backend);
1725 +       setup_vf_progress (&vfpro, job);
1726
1727         pk_backend_job_set_percentage (job, 1);
1728
1729 @@ -2975,7 +3110,6 @@ backend_refresh_cache_thread (PkBackendJob *job, GVariant *params, gpointer user
1730         if (sources) {
1731                 size_t  i;
1732
1733 -               pk_backend_set_uint (backend, "ts_type", TS_TYPE_ENUM_REFRESH_CACHE);
1734                 pd->step = 0;
1735                 pd->nsources = 0;
1736
1737 @@ -3003,12 +3137,10 @@ backend_refresh_cache_thread (PkBackendJob *job, GVariant *params, gpointer user
1738                 n_array_free (sources);
1739         }
1740
1741 -       poldek_reload (backend, TRUE);
1742 +       poldek_reload (job, TRUE);
1743
1744         pk_backend_job_set_percentage (job, 100);
1745
1746 -       poldek_backend_percentage_data_destroy (backend);
1747 -
1748         pk_backend_job_finished (job);
1749  }
1750
1751 @@ -3022,10 +3154,9 @@ pk_backend_refresh_cache (PkBackend *backend, PkBackendJob *job, gboolean force)
1752         }
1753
1754         pk_backend_job_set_status (job, PK_STATUS_ENUM_REFRESH_CACHE);
1755 -       poldek_backend_set_allow_cancel (backend, TRUE, TRUE);
1756 +       poldek_backend_set_allow_cancel (job, TRUE, TRUE);
1757         pb_error_clean ();
1758
1759 -       poldek_backend_percentage_data_create (backend);
1760         pk_backend_job_thread_create (job, backend_refresh_cache_thread, NULL, NULL);
1761  }
1762
1763 @@ -3037,11 +3168,19 @@ backend_remove_packages_thread (PkBackendJob *job, GVariant *params, gpointer us
1764  {
1765         GString *cmd;
1766         gchar *command;
1767 +       PkBitfield transaction_flags;
1768         gchar **package_ids;
1769 +       gboolean allow_deps;
1770 +       gboolean autoremove;
1771         size_t i;
1772
1773 -       package_ids = pk_backend_get_strv (backend, "package_ids");
1774 -       pb_load_packages (backend);
1775 +       g_variant_get (params, "(t^a&sbb)",
1776 +                       &transaction_flags,
1777 +                       &package_ids,
1778 +                       &allow_deps,
1779 +                       &autoremove);
1780 +
1781 +       pb_load_packages (job);
1782
1783         cmd = g_string_new ("uninstall ");
1784
1785 @@ -3068,11 +3207,20 @@ backend_remove_packages_thread (PkBackendJob *job, GVariant *params, gpointer us
1786  }
1787
1788  void
1789 -pk_backend_remove_packages (PkBackend *backend, PkBackendJob *job, gchar **package_ids, gboolean allow_deps, gboolean autoremove)
1790 +pk_backend_remove_packages (PkBackend *backend, PkBackendJob *job,
1791 +                           PkBitfield transaction_flags,
1792 +                           gchar **package_ids,
1793 +                           gboolean allow_deps,
1794 +                           gboolean autoremove)
1795  {
1796 -       poldek_backend_set_allow_cancel (backend, FALSE, TRUE);
1797 +       poldek_backend_set_allow_cancel (job, FALSE, TRUE);
1798         pb_error_clean ();
1799 -       pk_backend_job_thread_create (job, backend_remove_packages_thread, NULL, NULL);
1800 +
1801 +       if (pk_bitfield_contain (transaction_flags, PK_TRANSACTION_FLAG_ENUM_SIMULATE)) {
1802 +               pk_backend_job_thread_create (job, do_simulate_packages, NULL, NULL);
1803 +       } else {
1804 +               pk_backend_job_thread_create (job, backend_remove_packages_thread, NULL, NULL);
1805 +       }
1806  }
1807
1808  /**
1809 @@ -3082,10 +3230,8 @@ void
1810  pk_backend_resolve (PkBackend *backend, PkBackendJob *job, PkBitfield filters, gchar **packages)
1811  {
1812         pk_backend_job_set_status (job, PK_STATUS_ENUM_QUERY);
1813 -       poldek_backend_set_allow_cancel (backend, TRUE, TRUE);
1814 +       poldek_backend_set_allow_cancel (job, TRUE, TRUE);
1815
1816 -       pk_backend_set_uint (backend, "mode", SEARCH_ENUM_RESOLVE);
1817 -       pk_backend_set_strv (backend, "search", packages);
1818         pk_backend_job_thread_create (job, search_package_thread, NULL, NULL);
1819  }
1820
1821 @@ -3096,9 +3242,8 @@ void
1822  pk_backend_search_details (PkBackend *backend, PkBackendJob *job, PkBitfield filters, gchar **search)
1823  {
1824         pk_backend_job_set_status (job, PK_STATUS_ENUM_QUERY);
1825 -       poldek_backend_set_allow_cancel (backend, TRUE, TRUE);
1826 +       poldek_backend_set_allow_cancel (job, TRUE, TRUE);
1827         pb_error_clean ();
1828 -       pk_backend_set_uint (backend, "mode", SEARCH_ENUM_DETAILS);
1829         pk_backend_job_thread_create (job, search_package_thread, NULL, NULL);
1830  }
1831
1832 @@ -3109,9 +3254,8 @@ void
1833  pk_backend_search_files (PkBackend *backend, PkBackendJob *job, PkBitfield filters, gchar **search)
1834  {
1835         pk_backend_job_set_status (job, PK_STATUS_ENUM_QUERY);
1836 -       poldek_backend_set_allow_cancel (backend, TRUE, TRUE);
1837 +       poldek_backend_set_allow_cancel (job, TRUE, TRUE);
1838         pb_error_clean ();
1839 -       pk_backend_set_uint (backend, "mode", SEARCH_ENUM_FILE);
1840         pk_backend_job_thread_create (job, search_package_thread, NULL, NULL);
1841  }
1842
1843 @@ -3122,9 +3266,8 @@ void
1844  pk_backend_search_groups (PkBackend *backend, PkBackendJob *job, PkBitfield filters, gchar **search)
1845  {
1846         pk_backend_job_set_status (job, PK_STATUS_ENUM_QUERY);
1847 -       poldek_backend_set_allow_cancel (backend, TRUE, TRUE);
1848 +       poldek_backend_set_allow_cancel (job, TRUE, TRUE);
1849         pb_error_clean ();
1850 -       pk_backend_set_uint (backend, "mode", SEARCH_ENUM_GROUP);
1851         pk_backend_job_thread_create (job, search_package_thread, NULL, NULL);
1852  }
1853
1854 @@ -3135,9 +3278,8 @@ void
1855  pk_backend_search_names (PkBackend *backend, PkBackendJob *job, PkBitfield filters, gchar **search)
1856  {
1857         pk_backend_job_set_status (job, PK_STATUS_ENUM_QUERY);
1858 -       poldek_backend_set_allow_cancel (backend, TRUE, TRUE);
1859 +       poldek_backend_set_allow_cancel (job, TRUE, TRUE);
1860         pb_error_clean ();
1861 -       pk_backend_set_uint (backend, "mode", SEARCH_ENUM_NAME);
1862         pk_backend_job_thread_create (job, search_package_thread, NULL, NULL);
1863  }
1864
1865 @@ -3153,12 +3295,14 @@ pk_backend_update_packages (PkBackend *backend, PkBackendJob *job, PkBitfield tr
1866                 return;
1867         }
1868
1869 -       poldek_backend_set_allow_cancel (backend, TRUE, TRUE);
1870 +       poldek_backend_set_allow_cancel (job, TRUE, TRUE);
1871         pb_error_clean ();
1872
1873 -       poldek_backend_percentage_data_create (backend);
1874 -       pk_backend_set_uint (backend, "ts_type", TS_TYPE_ENUM_UPDATE);
1875 -       pk_backend_job_thread_create (job, update_packages_thread, NULL, NULL);
1876 +       if (pk_bitfield_contain (transaction_flags, PK_TRANSACTION_FLAG_ENUM_SIMULATE)) {
1877 +               pk_backend_job_thread_create (job, do_simulate_packages, NULL, NULL);
1878 +       } else {
1879 +               pk_backend_job_thread_create (job, update_packages_thread, NULL, NULL);
1880 +       }
1881  }
1882
1883  /**
1884 @@ -3170,7 +3314,7 @@ pk_backend_get_repo_list (PkBackend *backend, PkBackendJob *job, PkBitfield filt
1885         tn_array *sources = NULL;
1886
1887         pk_backend_job_set_status (job, PK_STATUS_ENUM_QUERY);
1888 -       poldek_backend_set_allow_cancel (backend, FALSE, TRUE);
1889 +       poldek_backend_set_allow_cancel (job, FALSE, TRUE);
1890         pb_error_clean ();
1891
1892         sources = poldek_get_sources (ctx);
1893 @@ -3201,15 +3345,12 @@ void
1894  pk_backend_what_provides (PkBackend *backend, PkBackendJob *job, PkBitfield filters, PkProvidesEnum provides, gchar **values)
1895  {
1896         GPtrArray *array = NULL;
1897 -       gchar **search = NULL;
1898         guint i;
1899
1900         pk_backend_job_set_status (job, PK_STATUS_ENUM_QUERY);
1901 -       poldek_backend_set_allow_cancel (backend, TRUE, TRUE);
1902 +       poldek_backend_set_allow_cancel (job, TRUE, TRUE);
1903         pb_error_clean ();
1904
1905 -       pk_backend_set_uint (backend, "mode", SEARCH_ENUM_PROVIDES);
1906 -
1907         /* prepare array of commands */
1908         array = g_ptr_array_new_with_free_func (g_free);
1909
1910 @@ -3225,136 +3366,9 @@ pk_backend_what_provides (PkBackend *backend, PkBackendJob *job, PkBitfield filt
1911                 } else {
1912                         pk_backend_job_error_code (job, PK_ERROR_ENUM_PROVIDE_TYPE_NOT_SUPPORTED,
1913                                                "provide type '%s' not supported",
1914 -                                              pk_provides_enum_to_text (provides));
1915 +                                              pk_provides_enum_to_string (provides));
1916                 }
1917         }
1918
1919 -       search = pk_ptr_array_to_strv (array);
1920 -       pk_backend_set_strv (backend, "search", search);
1921 -       pk_backend_job_thread_create (job, search_package_thread, NULL, NULL);
1922 -       g_strfreev (search);
1923 -       g_ptr_array_unref (array);
1924 -}
1925 -
1926 -static gboolean do_simulate_packages (PkBackend *backend)
1927 -{
1928 -       struct poclidek_rcmd *rcmd = NULL;
1929 -       struct poldek_ts     *ts = NULL;
1930 -       GString      *buf = NULL;
1931 -       gchar   *cmd = NULL;
1932 -       gchar       **package_ids = NULL;
1933 -       const gchar  *command = NULL;
1934 -       guint    i;
1935 -       guint    ts_type;
1936 -
1937 -       package_ids = pk_backend_get_strv (backend, "package_ids");
1938 -       command = pk_backend_get_string (backend, "command");
1939 -       ts_type = pk_backend_get_uint (backend, "ts_type");
1940 -
1941 -       pk_backend_job_set_status (job, PK_STATUS_ENUM_DEP_RESOLVE);
1942 -
1943 -       buf = g_string_new (command);
1944 -
1945 -       for (i = 0; i < g_strv_length (package_ids); i++) {
1946 -               gchar *nvra = poldek_get_nvra_from_package_id (package_ids[i]);
1947 -
1948 -               g_string_append_c (buf, ' ');
1949 -               g_string_append (buf, nvra);
1950 -
1951 -               g_free (nvra);
1952 -       }
1953 -
1954 -       cmd = g_string_free (buf, FALSE);
1955 -
1956 -       ts = poldek_ts_new (ctx, 0);
1957 -       rcmd = poclidek_rcmd_new (cctx, ts);
1958 -
1959 -       ts->setop(ts, POLDEK_OP_PARTICLE, 0);
1960 -
1961 -       if (poclidek_rcmd_execline (rcmd, cmd)) {
1962 -               tn_array *ipkgs = NULL, *dpkgs = NULL, *rpkgs = NULL;
1963 -               tn_array *install_pkgs = NULL, *update_pkgs = NULL, *remove_pkgs = NULL;
1964 -
1965 -               ipkgs = poldek_ts_get_summary (ts, "I");
1966 -               dpkgs = poldek_ts_get_summary (ts, "D");
1967 -               rpkgs = poldek_ts_get_summary (ts, "R");
1968 -
1969 -               get_ts_summary (ts_type, ipkgs, dpkgs, rpkgs, &install_pkgs, &update_pkgs, &remove_pkgs);
1970 -
1971 -               if (install_pkgs) {
1972 -                       for (i = 0; i < n_array_size (install_pkgs); i++) {
1973 -                               struct pkg *pkg = n_array_nth (install_pkgs, i);
1974 -
1975 -                               poldek_backend_package (backend, pkg, PK_INFO_ENUM_INSTALLING, PK_FILTER_ENUM_NONE);
1976 -                       }
1977 -
1978 -                       n_array_free (install_pkgs);
1979 -               }
1980 -
1981 -               if (update_pkgs) {
1982 -                       for (i = 0; i < n_array_size (update_pkgs); i++) {
1983 -                               struct pkg *pkg = n_array_nth (update_pkgs, i);
1984 -
1985 -                               poldek_backend_package (backend, pkg, PK_INFO_ENUM_UPDATING, PK_FILTER_ENUM_NONE);
1986 -                       }
1987 -
1988 -                       n_array_free (update_pkgs);
1989 -               }
1990 -
1991 -               if (remove_pkgs) {
1992 -                       for (i = 0; i < n_array_size (remove_pkgs); i++) {
1993 -                               struct pkg *pkg = n_array_nth (remove_pkgs, i);
1994 -
1995 -                               poldek_backend_package (backend, pkg, PK_INFO_ENUM_REMOVING, PK_FILTER_ENUM_NONE);
1996 -                       }
1997 -
1998 -                       n_array_free (remove_pkgs);
1999 -               }
2000 -       }
2001 -
2002 -       g_free (cmd);
2003 -
2004 -       poclidek_rcmd_free (rcmd);
2005 -       poldek_ts_free (ts);
2006 -
2007 -       pk_backend_job_finished (job);
2008 -}
2009 -
2010 -/**
2011 - * pk_backend_simulate_install_packages:
2012 - */
2013 -void
2014 -pk_backend_simulate_install_packages (PkBackend *backend, gchar **package_ids)
2015 -{
2016 -       poldek_backend_set_allow_cancel (backend, TRUE, TRUE);
2017 -       pb_error_clean ();
2018 -       pk_backend_set_uint (backend, "ts_type", TS_TYPE_ENUM_INSTALL);
2019 -       pk_backend_set_string (backend, "command", "cd /all-avail; install --test");
2020 -       pk_backend_job_thread_create (job, do_simulate_packages);
2021 -}
2022 -
2023 -/**
2024 - * pk_backend_simulate_remove_packages:
2025 - */
2026 -void
2027 -pk_backend_simulate_remove_packages (PkBackend *backend, gchar **package_ids, gboolean autoremove)
2028 -{
2029 -       poldek_backend_set_allow_cancel (backend, TRUE, TRUE);
2030 -       pb_error_clean ();
2031 -       pk_backend_set_uint (backend, "ts_type", TS_TYPE_ENUM_REMOVE);
2032 -       pk_backend_set_string (backend, "command", "cd /all-avail; uninstall --test");
2033 -       pk_backend_job_thread_create (job, do_simulate_packages);
2034 -}
2035 -
2036 -/**
2037 - * pk_backend_simulate_update_packages:
2038 - */
2039 -void
2040 -pk_backend_simulate_update_packages (PkBackend *backend, gchar **package_ids)
2041 -{
2042 -       poldek_backend_set_allow_cancel (backend, TRUE, TRUE);
2043 -       pb_error_clean ();
2044 -       pk_backend_set_uint (backend, "ts_type", TS_TYPE_ENUM_UPDATE);
2045 -       pk_backend_set_string (backend, "command", "cd /all-avail; upgrade --test");
2046 -       pk_backend_job_thread_create (job, do_simulate_packages);
2047 +       pk_backend_job_thread_create (job, search_package_thread, array, NULL);
2048  }
2049 commit c0a687645059f7a15c95c5affa6bbad7374d0dc9
2050 Author: Marcin Banasiak <marcin.banasiak@gmail.com>
2051 Date:   Sun Oct 7 20:00:43 2012 +0200
2052
2053     poldek: keep pkgdb open through the whole transaction
2054
2055     It will speed up GetPackages() several times.
2056
2057 diff --git a/backends/poldek/pk-backend-poldek.c b/backends/poldek/pk-backend-poldek.c
2058 index 7fe3d12..ced514d 100644
2059 --- a/backends/poldek/pk-backend-poldek.c
2060 +++ b/backends/poldek/pk-backend-poldek.c
2061 @@ -80,6 +80,12 @@ typedef struct {
2062  } PkBackendPoldekJobData;
2063
2064  typedef struct {
2065 +       struct poldek_ctx       *ctx;
2066 +       struct poclidek_ctx     *cctx;
2067 +       struct pkgdb            *db;
2068 +} PkBackendPoldekPriv;
2069 +
2070 +typedef struct {
2071         PkGroupEnum     group;
2072         const gchar     *regex;
2073  } PLDGroupRegex;
2074 @@ -132,8 +138,7 @@ static PbError *pberror;
2075  /* cached locale variants */
2076  static GHashTable *clv;
2077
2078 -static struct poldek_ctx       *ctx = NULL;
2079 -static struct poclidek_ctx     *cctx = NULL;
2080 +static PkBackendPoldekPriv *priv = NULL;
2081
2082  /**
2083   * execute_command:
2084 @@ -155,8 +160,8 @@ execute_command (const gchar *format, ...)
2085         command = g_strdup_vprintf (format, args);
2086         va_end (args);
2087
2088 -       ts = poldek_ts_new (ctx, 0);
2089 -       rcmd = poclidek_rcmd_new (cctx, ts);
2090 +       ts = poldek_ts_new (priv->ctx, 0);
2091 +       rcmd = poclidek_rcmd_new (priv->cctx, ts);
2092
2093         ts->setop(ts, POLDEK_OP_PARTICLE, 0);
2094
2095 @@ -192,7 +197,7 @@ execute_packages_command (const gchar *format, ...)
2096         command = g_strdup_vprintf (format, args);
2097         va_end (args);
2098
2099 -       rcmd = poclidek_rcmd_new (cctx, NULL);
2100 +       rcmd = poclidek_rcmd_new (priv->cctx, NULL);
2101
2102         if (poclidek_rcmd_execline (rcmd, command)) {
2103                 packages = poclidek_rcmd_get_packages (rcmd);
2104 @@ -754,7 +759,7 @@ setup_vf_progress (struct vf_progress *vf_progress, PkBackendJob *job)
2105         vfile_configure (VFILE_CONF_VERBOSE, &verbose);
2106         vfile_configure (VFILE_CONF_STUBBORN_NRETRIES, 5);
2107
2108 -       poldek_configure (ctx, POLDEK_CONF_VFILEPROGRESS, vf_progress);
2109 +       poldek_configure (priv->ctx, POLDEK_CONF_VFILEPROGRESS, vf_progress);
2110  }
2111
2112  static gint
2113 @@ -802,20 +807,26 @@ do_post_search_process (tn_array *installed, tn_array *available)
2114         return packages;
2115  }
2116
2117 +static void
2118 +pk_backend_poldek_open_pkgdb (void)
2119 +{
2120 +       if (priv->db == NULL) {
2121 +               priv->db = pkgdb_open (poldek_get_pmctx (priv->ctx),
2122 +                                      NULL, NULL, O_RDONLY, NULL);
2123 +       }
2124 +}
2125 +
2126  static gboolean
2127  pkg_is_installed (struct pkg *pkg)
2128  {
2129 -       struct pkgdb *db;
2130         gint cmprc, is_installed = 0;
2131
2132         g_return_val_if_fail (pkg != NULL, FALSE);
2133
2134 -       db = pkgdb_open (poldek_get_pmctx (ctx), NULL, NULL, O_RDONLY, NULL);
2135 -
2136 -       if (db) {
2137 -               is_installed = pkgdb_is_pkg_installed (db, pkg, &cmprc);
2138 +       pk_backend_poldek_open_pkgdb ();
2139
2140 -               pkgdb_free (db);
2141 +       if (priv->db) {
2142 +               is_installed = pkgdb_is_pkg_installed (priv->db, pkg, &cmprc);
2143         }
2144
2145         return is_installed ? TRUE : FALSE;
2146 @@ -833,20 +844,20 @@ pkg_is_installed (struct pkg *pkg)
2147  static gchar *
2148  get_pkgid_from_localpath (const gchar *localpath)
2149  {
2150 -       struct pkgdb *db = NULL;
2151         struct poldek_ts *ts = NULL;
2152         gchar *pkgid = NULL;
2153
2154         g_return_val_if_fail (localpath != NULL, NULL);
2155
2156 -       ts = poldek_ts_new (ctx, 0);
2157 -       db = pkgdb_open (ts->pmctx, ts->rootdir, NULL, O_RDONLY, NULL);
2158 +       ts = poldek_ts_new (priv->ctx, 0);
2159
2160 -       if (db) {
2161 +       pk_backend_poldek_open_pkgdb ();
2162 +
2163 +       if (priv->db) {
2164                 const struct pm_dbrec *ldbrec;
2165                 struct pkgdb_it it;
2166
2167 -               pkgdb_it_init (db, &it, PMTAG_FILE, localpath);
2168 +               pkgdb_it_init (priv->db, &it, PMTAG_FILE, localpath);
2169
2170                 /* get only one package */
2171                 if ((ldbrec = pkgdb_it_get (&it)) != NULL) {
2172 @@ -859,8 +870,6 @@ get_pkgid_from_localpath (const gchar *localpath)
2173                 }
2174
2175                 pkgdb_it_destroy (&it);
2176 -               /* it calls pkgdb_close (db) */
2177 -               pkgdb_free (db);
2178         }
2179
2180         poldek_ts_free (ts);
2181 @@ -1015,7 +1024,7 @@ poldek_get_nvra_from_package_id (const gchar* package_id)
2182  static tn_array*
2183  poldek_get_installed_packages (void)
2184  {
2185 -       return poclidek_get_dent_packages (cctx, POCLIDEK_INSTALLEDDIR);
2186 +       return poclidek_get_dent_packages (priv->cctx, POCLIDEK_INSTALLEDDIR);
2187  }
2188
2189  static tn_array*
2190 @@ -1909,8 +1918,8 @@ do_simulate_packages (PkBackendJob *job, GVariant *params, gpointer user_data)
2191
2192         cmd = g_string_free (buf, FALSE);
2193
2194 -       ts = poldek_ts_new (ctx, 0);
2195 -       rcmd = poclidek_rcmd_new (cctx, ts);
2196 +       ts = poldek_ts_new (priv->ctx, 0);
2197 +       rcmd = poclidek_rcmd_new (priv->cctx, ts);
2198
2199         ts->setop(ts, POLDEK_OP_PARTICLE, 0);
2200
2201 @@ -1973,7 +1982,7 @@ pb_load_packages (PkBackendJob *job)
2202                 poldek_backend_set_allow_cancel (job, FALSE, FALSE);
2203
2204         /* load information about installed and available packages */
2205 -       poclidek_load_packages (cctx, POCLIDEK_LOAD_ALL);
2206 +       poclidek_load_packages (priv->cctx, POCLIDEK_LOAD_ALL);
2207
2208         if (allow_cancel)
2209                 poldek_backend_set_allow_cancel (job, TRUE, FALSE);
2210 @@ -2226,32 +2235,32 @@ do_poldek_init (PkBackend *backend)
2211  {
2212         poldeklib_init ();
2213
2214 -       ctx = poldek_new (0);
2215 +       priv->ctx = poldek_new (0);
2216
2217 -       poldek_load_config (ctx, "/etc/poldek/poldek.conf", NULL, 0);
2218 +       poldek_load_config (priv->ctx, "/etc/poldek/poldek.conf", NULL, 0);
2219
2220 -       poldek_setup (ctx);
2221 +       poldek_setup (priv->ctx);
2222
2223 -       cctx = poclidek_new (ctx);
2224 +       priv->cctx = poclidek_new (priv->ctx);
2225
2226         poldek_set_verbose (1);
2227         /* disable LOGFILE and LOGTTY logging */
2228 -       poldek_configure (ctx, POLDEK_CONF_LOGFILE, NULL);
2229 -       poldek_configure (ctx, POLDEK_CONF_LOGTTY, NULL);
2230 +       poldek_configure (priv->ctx, POLDEK_CONF_LOGFILE, NULL);
2231 +       poldek_configure (priv->ctx, POLDEK_CONF_LOGTTY, NULL);
2232
2233         /* disable unique package names */
2234 -       poldek_configure (ctx, POLDEK_CONF_OPT, POLDEK_OP_UNIQN, 0);
2235 +       poldek_configure (priv->ctx, POLDEK_CONF_OPT, POLDEK_OP_UNIQN, 0);
2236
2237 -       poldek_configure (ctx, POLDEK_CONF_OPT, POLDEK_OP_LDALLDESC, 1);
2238 +       poldek_configure (priv->ctx, POLDEK_CONF_OPT, POLDEK_OP_LDALLDESC, 1);
2239
2240         /* poldek has to ask. Otherwise callbacks won't be used */
2241 -       poldek_configure (ctx, POLDEK_CONF_OPT, POLDEK_OP_CONFIRM_INST, 1);
2242 -       poldek_configure (ctx, POLDEK_CONF_OPT, POLDEK_OP_CONFIRM_UNINST, 1);
2243 +       poldek_configure (priv->ctx, POLDEK_CONF_OPT, POLDEK_OP_CONFIRM_INST, 1);
2244 +       poldek_configure (priv->ctx, POLDEK_CONF_OPT, POLDEK_OP_CONFIRM_UNINST, 1);
2245         /* (...), but we don't need choose_equiv callback */
2246 -       poldek_configure (ctx, POLDEK_CONF_OPT, POLDEK_OP_EQPKG_ASKUSER, 0);
2247 +       poldek_configure (priv->ctx, POLDEK_CONF_OPT, POLDEK_OP_EQPKG_ASKUSER, 0);
2248
2249         /* Install all suggested packages by default */
2250 -       poldek_configure (ctx, POLDEK_CONF_CHOOSESUGGESTS_CB, suggests_callback, NULL);
2251 +       poldek_configure (priv->ctx, POLDEK_CONF_CHOOSESUGGESTS_CB, suggests_callback, NULL);
2252
2253         sigint_init ();
2254  }
2255 @@ -2261,8 +2270,13 @@ do_poldek_destroy (PkBackend *backend)
2256  {
2257         sigint_destroy ();
2258
2259 -       poclidek_free (cctx);
2260 -       poldek_free (ctx);
2261 +       if (priv->db != NULL) {
2262 +               pkgdb_close (priv->db);
2263 +               priv->db = NULL;
2264 +       }
2265 +
2266 +       poclidek_free (priv->cctx);
2267 +       poldek_free (priv->ctx);
2268
2269         poldeklib_destroy ();
2270  }
2271 @@ -2316,6 +2330,8 @@ pk_backend_initialize (PkBackend *backend)
2272         pberror = g_new0 (PbError, 1);
2273         pberror->tslog = g_string_new ("");
2274
2275 +       priv = g_new0 (PkBackendPoldekPriv, 1);
2276 +
2277         do_poldek_init (backend);
2278
2279         g_debug ("backend initalize end");
2280 @@ -2328,6 +2344,8 @@ pk_backend_destroy (PkBackend *backend)
2281  {
2282         do_poldek_destroy (backend);
2283
2284 +       g_free (priv);
2285 +
2286         /* release PbError struct */
2287         g_free (pberror->vfffmsg);
2288         g_string_free (pberror->tslog, TRUE);
2289 @@ -2352,7 +2370,7 @@ pk_backend_start_job (PkBackend *backend, PkBackendJob *job)
2290
2291         poldek_log_set_appender ("PackageKit", (void *) job, NULL, 0, (poldek_vlog_fn) poldek_backend_log);
2292
2293 -       poldek_configure (ctx, POLDEK_CONF_TSCONFIRM_CB, ts_confirm, job);
2294 +       poldek_configure (priv->ctx, POLDEK_CONF_TSCONFIRM_CB, ts_confirm, job);
2295  }
2296
2297  /**
2298 @@ -2372,6 +2390,12 @@ pk_backend_stop_job (PkBackend *backend, PkBackendJob *job)
2299
2300         g_free (job_data);
2301
2302 +       // close pkgdb as well
2303 +       if (priv->db != NULL) {
2304 +               pkgdb_close (priv->db);
2305 +               priv->db = NULL;
2306 +       }
2307 +
2308         pk_backend_job_set_user_data (job, NULL);
2309  }
2310
2311 @@ -2460,7 +2484,7 @@ backend_download_packages_thread (PkBackendJob *job, GVariant *params, gpointer
2312
2313         pkgs = n_array_new (10, (tn_fn_free)pkg_free, NULL);
2314
2315 -       ts = poldek_ts_new (ctx, 0);
2316 +       ts = poldek_ts_new (priv->ctx, 0);
2317
2318         setup_vf_progress (&vf_progress, job);
2319
2320 @@ -2533,7 +2557,7 @@ backend_get_depends_thread (PkBackendJob *job, GVariant *params, gpointer user_d
2321         deppkgs = n_array_new (2, NULL, NULL);
2322
2323         installed = poldek_get_installed_packages ();
2324 -       available = poldek_get_avail_packages (ctx);
2325 +       available = poldek_get_avail_packages (priv->ctx);
2326
2327         pkg = poldek_get_pkg_from_package_id (package_ids[0]);
2328
2329 @@ -2725,7 +2749,7 @@ backend_get_packages_thread (PkBackendJob *job, GVariant *params, gpointer user_
2330                 installed = poldek_get_installed_packages ();
2331
2332         if (pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED) == FALSE)
2333 -               available = poldek_get_avail_packages (ctx);
2334 +               available = poldek_get_avail_packages (priv->ctx);
2335
2336         pk_backend_job_set_percentage (job, 4);
2337
2338 @@ -2794,7 +2818,7 @@ backend_get_requires_thread (PkBackendJob *job, GVariant *params, gpointer user_
2339
2340         pkg = poldek_get_pkg_from_package_id (package_ids[0]);
2341         installed = poldek_get_installed_packages ();
2342 -       available = poldek_get_avail_packages (ctx);
2343 +       available = poldek_get_avail_packages (priv->ctx);
2344
2345         do_requires (installed, available, reqpkgs, pkg, filters, recursive);
2346
2347 @@ -2839,7 +2863,7 @@ get_obsoletedby_pkg (struct pkg *pkg)
2348         obsoletes = g_ptr_array_new ();
2349
2350         /* get installed packages */
2351 -       dbpkgs = poclidek_get_dent_packages (cctx, POCLIDEK_INSTALLEDDIR);
2352 +       dbpkgs = poclidek_get_dent_packages (priv->cctx, POCLIDEK_INSTALLEDDIR);
2353
2354         if (dbpkgs == NULL)
2355                 return NULL;
2356 @@ -3105,7 +3129,7 @@ backend_refresh_cache_thread (PkBackendJob *job, GVariant *params, gpointer user
2357
2358         pk_backend_job_set_percentage (job, 1);
2359
2360 -       sources = poldek_get_sources (ctx);
2361 +       sources = poldek_get_sources (priv->ctx);
2362
2363         if (sources) {
2364                 size_t  i;
2365 @@ -3317,7 +3341,7 @@ pk_backend_get_repo_list (PkBackend *backend, PkBackendJob *job, PkBitfield filt
2366         poldek_backend_set_allow_cancel (job, FALSE, TRUE);
2367         pb_error_clean ();
2368
2369 -       sources = poldek_get_sources (ctx);
2370 +       sources = poldek_get_sources (priv->ctx);
2371
2372         if (sources) {
2373                 size_t i;