Debian Codegraph @

lib/packagekit-glib2/pk-package-sack.c

raw
1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
2 *
3 * Copyright (C) 2009 Richard Hughes <[email protected]>
4 *
5 * Licensed under the GNU Lesser General Public License Version 2.1
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 /**
23 * SECTION:pk-package-sack
24 * @short_description: A sack of packages that can be manipulated
25 *
26 * A package sack is a set of packages that can have operations done on them
27 * in parallel. This might be adding summary text for bare package ID's, or
28 * to add package or update details.
29 */
30
31 #include "config.h"
32
33 #include <glib-object.h>
34 #include <gio/gio.h>
35
36 #include <packagekit-glib2/pk-package-sack.h>
37 #include <packagekit-glib2/pk-client.h>
38 #include <packagekit-glib2/pk-common.h>
39 #include <packagekit-glib2/pk-enum.h>
40 #include <packagekit-glib2/pk-results.h>
41 #include <packagekit-glib2/pk-package-id.h>
42
43 static void pk_package_sack_finalize (GObject *object);
44
45 /**
46 * PkPackageSackPrivate:
47 *
48 * Private #PkPackageSack data
49 **/
50 struct _PkPackageSackPrivate
51 {
52 GHashTable *table;
53 GPtrArray *array;
54 PkClient *client;
55 };
56
57 enum {
58 SIGNAL_CHANGED,
59 SIGNAL_LAST
60 };
61
62 G_DEFINE_TYPE_WITH_PRIVATE (PkPackageSack, pk_package_sack, G_TYPE_OBJECT)
63 #define GET_PRIVATE(o) (pk_package_sack_get_instance_private (o))
64
65 /**
66 * pk_package_sack_clear:
67 * @sack: a valid #PkPackageSack instance
68 *
69 * Empty all the packages from the sack
70 *
71 * Since: 0.5.2
72 **/
73 void
74 pk_package_sack_clear (PkPackageSack *sack)
75 {
76 PkPackageSackPrivate *priv = GET_PRIVATE(sack);
77
78 g_return_if_fail (PK_IS_PACKAGE_SACK (sack));
79
80 g_ptr_array_set_size (priv->array, 0);
81 g_hash_table_remove_all (priv->table);
82 }
83
84 /**
85 * pk_package_sack_get_size:
86 * @sack: a valid #PkPackageSack instance
87 *
88 * Gets the number of packages in the sack
89 *
90 * Return value: the number of packages in the sack
91 *
92 * Since: 0.5.2
93 **/
94 guint
95 pk_package_sack_get_size (PkPackageSack *sack)
96 {
97 PkPackageSackPrivate *priv = GET_PRIVATE(sack);
98
99 g_return_val_if_fail (PK_IS_PACKAGE_SACK (sack), 0);
100
101 return priv->array->len;
102 }
103
104 /**
105 * pk_package_sack_get_ids:
106 * @sack: a valid #PkPackageSack instance
107 *
108 * Returns all the Package IDs in the sack
109 *
110 * Return value: (transfer full): the number of packages in the sack, free with g_strfreev()
111 *
112 * Since: 0.5.3
113 **/
114 gchar **
115 pk_package_sack_get_ids (PkPackageSack *sack)
116 {
117 PkPackageSackPrivate *priv = GET_PRIVATE(sack);
118 gchar **package_ids;
119 GPtrArray *array;
120 guint i;
121 PkPackage *package;
122
123 g_return_val_if_fail (PK_IS_PACKAGE_SACK (sack), NULL);
124
125 array = priv->array;
126 package_ids = g_new0 (gchar *, array->len + 1);
127 for (i = 0; i < array->len; i++) {
128 package = g_ptr_array_index (array, i);
129 package_ids[i] = g_strdup (pk_package_get_id (package));
130 }
131 return package_ids;
132 }
133
134 /**
135 * pk_package_sack_get_array:
136 * @sack: a valid #PkPackageSack instance
137 *
138 * Gets the package array from the sack
139 *
140 * Return value: (element-type PkPackage) (transfer container): A #GPtrArray, free with g_ptr_array_unref().
141 *
142 * Since: 0.6.1
143 **/
144 GPtrArray *
145 pk_package_sack_get_array (PkPackageSack *sack)
146 {
147 PkPackageSackPrivate *priv = GET_PRIVATE(sack);
148
149 g_return_val_if_fail (PK_IS_PACKAGE_SACK (sack), NULL);
150
151 return g_ptr_array_ref (priv->array);
152 }
153
154 /**
155 * pk_package_sack_filter_by_info:
156 * @sack: a valid #PkPackageSack instance
157 * @info: a #PkInfoEnum value to match
158 *
159 * Returns a new package sack which only matches packages that match the
160 * specified info enum value.
161 *
162 * Return value: (transfer full): a new #PkPackageSack, free with g_object_unref()
163 *
164 * Since: 0.6.2
165 **/
166 PkPackageSack *
167 pk_package_sack_filter_by_info (PkPackageSack *sack, PkInfoEnum info)
168 {
169 PkPackageSackPrivate *priv = GET_PRIVATE(sack);
170 PkPackageSack *results;
171 PkPackage *package;
172 PkInfoEnum info_tmp;
173 guint i;
174
175 g_return_val_if_fail (PK_IS_PACKAGE_SACK (sack), NULL);
176
177 /* create new sack */
178 results = pk_package_sack_new ();
179
180 /* add each that matches the info enum */
181 for (i = 0; i < priv->array->len; i++) {
182 package = g_ptr_array_index (priv->array, i);
183 info_tmp = pk_package_get_info (package);
184 if (info_tmp == info)
185 pk_package_sack_add_package (results, package);
186 }
187
188 return results;
189 }
190
191 /**
192 * pk_package_sack_filter:
193 * @sack: a valid #PkPackageSack instance
194 * @filter_cb: (scope call): a #PkPackageSackFilterFunc, which returns %TRUE for the #PkPackage's to add
195 * @user_data: user data to pass to @filter_cb
196 *
197 * Returns a new package sack which only matches packages that return %TRUE
198 * from the filter function.
199 *
200 * Return value: (transfer full): a new #PkPackageSack, free with g_object_unref()
201 *
202 * Since: 0.6.3
203 **/
204 PkPackageSack *
205 pk_package_sack_filter (PkPackageSack *sack, PkPackageSackFilterFunc filter_cb, gpointer user_data)
206 {
207 PkPackageSackPrivate *priv = GET_PRIVATE(sack);
208 PkPackageSack *results;
209 PkPackage *package;
210 guint i;
211
212 g_return_val_if_fail (PK_IS_PACKAGE_SACK (sack), NULL);
213 g_return_val_if_fail (filter_cb != NULL, NULL);
214
215 /* create new sack */
216 results = pk_package_sack_new ();
217
218 /* add each that matches the info enum */
219 for (i = 0; i < priv->array->len; i++) {
220 package = g_ptr_array_index (priv->array, i);
221 if (filter_cb (package, user_data))
222 pk_package_sack_add_package (results, package);
223 }
224 return results;
225 }
226
227 /**
228 * pk_package_sack_add_package:
229 * @sack: a valid #PkPackageSack instance
230 * @package: a valid #PkPackage instance
231 *
232 * Adds a package to the sack.
233 *
234 * Return value: %TRUE if the package was added to the sack
235 *
236 * Since: 0.5.2
237 **/
238 gboolean
239 pk_package_sack_add_package (PkPackageSack *sack, PkPackage *package)
240 {
241 PkPackageSackPrivate *priv = GET_PRIVATE(sack);
242
243 g_return_val_if_fail (PK_IS_PACKAGE_SACK (sack), FALSE);
244 g_return_val_if_fail (PK_IS_PACKAGE (package), FALSE);
245
246 /* add to array */
247 g_ptr_array_add (priv->array, g_object_ref (package));
248 g_hash_table_insert (priv->table,
249 (gpointer) pk_package_get_id (package),
250 (gpointer) package);
251
252 return TRUE;
253 }
254
255 /**
256 * pk_package_sack_add_package_by_id:
257 * @sack: a valid #PkPackageSack instance
258 * @package_id: a package_id descriptor
259 * @error: a #GError to put the error code and message in, or %NULL
260 *
261 * Adds a package reference to the sack.
262 *
263 * Return value: %TRUE if the package was added to the sack
264 *
265 * Since: 0.5.2
266 **/
267 gboolean
268 pk_package_sack_add_package_by_id (PkPackageSack *sack,
269 const gchar *package_id,
270 GError **error)
271 {
272 g_autoptr(PkPackage) package = NULL;
273
274 g_return_val_if_fail (PK_IS_PACKAGE_SACK (sack), FALSE);
275 g_return_val_if_fail (package_id != NULL, FALSE);
276 g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
277
278 /* create new object */
279 package = pk_package_new ();
280 if (!pk_package_set_id (package, package_id, error))
281 return FALSE;
282
283 /* add to array, array will own object */
284 pk_package_sack_add_package (sack, package);
285 return TRUE;
286 }
287
288 /*
289 * pk_package_sack_add_packages_from_line:
290 **/
291 static gboolean
292 pk_package_sack_add_packages_from_line (PkPackageSack *sack,
293 const gchar *package_str,
294 GError **error)
295 {
296 PkInfoEnum info;
297 g_autoptr(GError) error_local = NULL;
298 g_autoptr(PkPackage) package = NULL;
299 g_auto(GStrv) pdata = NULL;
300
301 package = pk_package_new ();
302 pdata = g_strsplit (package_str, "\t", -1);
303 if (g_strv_length (pdata) != 3) {
304 g_set_error (error, 1, 0, "invalid package-info line: %s", package_str);
305 return FALSE;
306 }
307
308 info = pk_info_enum_from_string (pdata[0]);
309 g_object_set (package,
310 "info", info,
311 "summary", pdata[2],
312 NULL);
313 if (!pk_package_set_id (package, pdata[1], &error_local)) {
314 g_set_error (error, 1, 0, "invalid package-id in package-info line: %s", pdata[1]);
315 return FALSE;
316 }
317 if (!pk_package_sack_add_package (sack, package))
318 g_set_error (error, 1, 0, "could not add package '%s' to package-sack!", pdata[1]);
319 return TRUE;
320 }
321
322 /**
323 * pk_package_sack_add_packages_from_file:
324 * @sack: a valid #PkPackageSack instance
325 * @file: a valid package-list file
326 * @error: a #GError to put the error code and message in, or %NULL
327 *
328 * Adds packages from package-list file to a #PkPackageSack.
329 *
330 * Return value: %TRUE if there were no errors.
331 *
332 **/
333 gboolean
334 pk_package_sack_add_packages_from_file (PkPackageSack *sack,
335 GFile *file,
336 GError **error)
337 {
338 GError *error_local = NULL;
339 g_autoptr(GFileInputStream) is = NULL;
340 g_autoptr(GDataInputStream) input = NULL;
341
342 g_return_val_if_fail (PK_IS_PACKAGE_SACK (sack), FALSE);
343
344 is = g_file_read (file, NULL, &error_local);
345 if (is == NULL) {
346 g_propagate_error (error, error_local);
347 return FALSE;
348 }
349
350 input = g_data_input_stream_new (G_INPUT_STREAM (is));
351
352 /* read package info file line by line */
353 while (TRUE) {
354 gchar *line;
355 line = g_data_input_stream_read_line (input, NULL, NULL, NULL);
356 if (line == NULL)
357 break;
358 g_strstrip (line);
359 if (!pk_package_sack_add_packages_from_line (sack, line, error))
360 return FALSE;
361 }
362 return TRUE;
363 }
364
365 /**
366 * pk_package_sack_to_file:
367 * @sack: a valid #PkPackageSack instance
368 * @file: a valid package-list file
369 * @error: a #GError to put the error code and message in, or %NULL
370 *
371 * Write the contents of a #PkPackageSack to a package-list file.
372 *
373 * Return value: %TRUE if there were no errors.
374 *
375 * Since: 0.8.6
376 **/
377 gboolean
378 pk_package_sack_to_file (PkPackageSack *sack, GFile *file, GError **error)
379 {
380 PkPackageSackPrivate *priv = GET_PRIVATE(sack);
381 gboolean ret;
382 guint i;
383 PkPackage *pkg;
384 g_autoptr(GString) string = NULL;
385
386 string = g_string_new ("");
387 for (i = 0; i < priv->array->len; i++) {
388 pkg = g_ptr_array_index (priv->array, i);
389 g_string_append_printf (string,
390 "%s\t%s\t%s\n",
391 pk_info_enum_to_string (pk_package_get_info (pkg)),
392 pk_package_get_id (pkg),
393 pk_package_get_summary (pkg));
394 }
395 ret = g_file_replace_contents (file,
396 string->str,
397 string->len,
398 NULL,
399 FALSE,
400 G_FILE_CREATE_NONE,
401 NULL,
402 NULL,
403 error);
404 if (!ret)
405 return FALSE;
406 return TRUE;
407 }
408
409 /**
410 * pk_package_sack_remove_package:
411 * @sack: a valid #PkPackageSack instance
412 * @package: a valid #PkPackage instance
413 *
414 * Removes a package reference from the sack. The pointers have to match exactly.
415 *
416 * Return value: %TRUE if the package was removed from the sack
417 *
418 * Since: 0.5.2
419 **/
420 gboolean
421 pk_package_sack_remove_package (PkPackageSack *sack, PkPackage *package)
422 {
423 PkPackageSackPrivate *priv = GET_PRIVATE(sack);
424
425 g_return_val_if_fail (PK_IS_PACKAGE_SACK (sack), FALSE);
426 g_return_val_if_fail (PK_IS_PACKAGE (package), FALSE);
427
428 /* remove from array */
429 g_hash_table_remove (priv->table, pk_package_get_id (package));
430 return g_ptr_array_remove (priv->array, package);
431 }
432
433 /**
434 * pk_package_sack_remove_package_by_id:
435 * @sack: a valid #PkPackageSack instance
436 * @package_id: a package_id descriptor
437 *
438 * Removes a package reference from the sack. As soon as one package is removed
439 * the search is stopped.
440 *
441 * Return value: %TRUE if the package was removed from the sack
442 *
443 * Since: 0.5.2
444 **/
445 gboolean
446 pk_package_sack_remove_package_by_id (PkPackageSack *sack,
447 const gchar *package_id)
448 {
449 PkPackageSackPrivate *priv = GET_PRIVATE(sack);
450 PkPackage *package;
451 guint i;
452 GPtrArray *array;
453
454 g_return_val_if_fail (PK_IS_PACKAGE_SACK (sack), FALSE);
455 g_return_val_if_fail (package_id != NULL, FALSE);
456
457 array = priv->array;
458 for (i = 0; i < array->len; i++) {
459 package = g_ptr_array_index (array, i);
460 if (g_strcmp0 (package_id, pk_package_get_id (package)) == 0) {
461 pk_package_sack_remove_package (sack, package);
462 return TRUE;
463 }
464 }
465 return FALSE;
466 }
467
468 /**
469 * pk_package_sack_remove_by_filter:
470 * @sack: a valid #PkPackageSack instance
471 * @filter_cb: (scope call): a #PkPackageSackFilterFunc, which returns %TRUE for the #PkPackage's to retain
472 * @user_data: user data to pass to @filter_cb
473 *
474 * Removes from the package sack any packages that return %FALSE from the filter
475 * function.
476 *
477 * Return value: %TRUE if a package was removed from the sack
478 *
479 * Since: 0.6.3
480 **/
481 gboolean
482 pk_package_sack_remove_by_filter (PkPackageSack *sack,
483 PkPackageSackFilterFunc filter_cb,
484 gpointer user_data)
485 {
486 PkPackageSackPrivate *priv = GET_PRIVATE(sack);
487 gboolean ret = FALSE;
488 PkPackage *package;
489 gint i;
490
491 g_return_val_if_fail (PK_IS_PACKAGE_SACK (sack), FALSE);
492 g_return_val_if_fail (filter_cb != NULL, FALSE);
493
494 /* add each that matches the info enum */
495 for (i = 0; i < (gint) priv->array->len; i++) {
496 package = g_ptr_array_index (priv->array, i);
497 if (!filter_cb (package, user_data)) {
498 ret = TRUE;
499 pk_package_sack_remove_package (sack, package);
500
501 /* ensure we pick up subsequent matches */
502 i--;
503 }
504 }
505 return ret;
506 }
507
508 /**
509 * pk_package_sack_find_by_id:
510 * @sack: a valid #PkPackageSack instance
511 * @package_id: a package_id descriptor
512 *
513 * Finds a package in a sack from reference. As soon as one package is found
514 * the search is stopped.
515 *
516 * Return value: (transfer full): the #PkPackage object, or %NULL if unfound. Free with g_object_unref()
517 *
518 * Since: 0.5.2
519 **/
520 PkPackage *
521 pk_package_sack_find_by_id (PkPackageSack *sack, const gchar *package_id)
522 {
523 PkPackageSackPrivate *priv = GET_PRIVATE(sack);
524 PkPackage *package = NULL;
525
526 g_return_val_if_fail (PK_IS_PACKAGE_SACK (sack), NULL);
527 g_return_val_if_fail (package_id != NULL, NULL);
528
529 package = g_hash_table_lookup (priv->table, package_id);
530 if (package != NULL)
531 g_object_ref (package);
532
533 return package;
534 }
535
536 /**
537 * pk_package_sack_find_by_id_name_arch:
538 * @sack: a valid #PkPackageSack instance
539 * @package_id: a package_id descriptor
540 *
541 * Finds a package in a sack by package name and architecture. As soon as one
542 * package is found the search is stopped.
543 *
544 * Return value: (transfer full): the #PkPackage object, or %NULL if not found.
545 *
546 * Since: 0.8.16
547 */
548 PkPackage *
549 pk_package_sack_find_by_id_name_arch (PkPackageSack *sack, const gchar *package_id)
550 {
551 PkPackageSackPrivate *priv = GET_PRIVATE(sack);
552 PkPackage *pkg_tmp;
553 guint i;
554 g_auto(GStrv) split = NULL;
555
556 g_return_val_if_fail (PK_IS_PACKAGE_SACK (sack), NULL);
557 g_return_val_if_fail (package_id != NULL, NULL);
558
559 /* does the package name feature in the array */
560 split = pk_package_id_split (package_id);
561 if (split == NULL)
562 return NULL;
563 for (i = 0; i < priv->array->len; i++) {
564 pkg_tmp = g_ptr_array_index (priv->array, i);
565 if (g_strcmp0 (pk_package_get_name (pkg_tmp),
566 split[PK_PACKAGE_ID_NAME]) == 0 &&
567 g_strcmp0 (pk_package_get_arch (pkg_tmp),
568 split[PK_PACKAGE_ID_ARCH]) == 0) {
569 return g_object_ref (pkg_tmp);
570 }
571 }
572 return NULL;
573 }
574
575 /*
576 * pk_package_sack_sort_compare_name_func:
577 **/
578 static gint
579 pk_package_sack_sort_compare_name_func (PkPackage **a, PkPackage **b)
580 {
581 const gchar *package_id1;
582 const gchar *package_id2;
583 g_auto(GStrv) split1 = NULL;
584 g_auto(GStrv) split2 = NULL;
585
586 package_id1 = pk_package_get_id (*a);
587 package_id2 = pk_package_get_id (*b);
588 split1 = pk_package_id_split (package_id1);
589 split2 = pk_package_id_split (package_id2);
590 return g_strcmp0 (split1[PK_PACKAGE_ID_NAME], split2[PK_PACKAGE_ID_NAME]);
591 }
592
593 /*
594 * pk_package_sack_sort_compare_package_id_func:
595 **/
596 static gint
597 pk_package_sack_sort_compare_package_id_func (PkPackage **a, PkPackage **b)
598 {
599 const gchar *package_id1;
600 const gchar *package_id2;
601 package_id1 = pk_package_get_id (*a);
602 package_id2 = pk_package_get_id (*b);
603 return g_strcmp0 (package_id1, package_id2);
604 }
605
606 /*
607 * pk_package_sack_sort_compare_summary_func:
608 **/
609 static gint
610 pk_package_sack_sort_compare_summary_func (PkPackage **a, PkPackage **b)
611 {
612 const gchar *summary1;
613 const gchar *summary2;
614 summary1 = pk_package_get_summary (*a);
615 summary2 = pk_package_get_summary (*b);
616 return g_strcmp0 (summary1, summary2);
617 }
618
619 /*
620 * pk_package_sack_sort_compare_info_func:
621 **/
622 static gint
623 pk_package_sack_sort_compare_info_func (PkPackage **a, PkPackage **b)
624 {
625 PkInfoEnum info1;
626 PkInfoEnum info2;
627 info1 = pk_package_get_info (*a);
628 info2 = pk_package_get_info (*b);
629 if (info1 == info2)
630 return 0;
631 else if (info1 > info2)
632 return -1;
633 return 1;
634 }
635
636 /**
637 * pk_package_sack_sort:
638 * @sack: a valid #PkPackageSack instance
639 * @type: the type of sorting, e.g. #PK_PACKAGE_SACK_SORT_TYPE_NAME
640 *
641 * Sorts the package sack
642 *
643 * Since: 0.6.1
644 **/
645 void
646 pk_package_sack_sort (PkPackageSack *sack, PkPackageSackSortType type)
647 {
648 PkPackageSackPrivate *priv = GET_PRIVATE(sack);
649
650 g_return_if_fail (PK_IS_PACKAGE_SACK (sack));
651
652 if (type == PK_PACKAGE_SACK_SORT_TYPE_NAME)
653 g_ptr_array_sort (priv->array, (GCompareFunc) pk_package_sack_sort_compare_name_func);
654 else if (type == PK_PACKAGE_SACK_SORT_TYPE_PACKAGE_ID)
655 g_ptr_array_sort (priv->array, (GCompareFunc) pk_package_sack_sort_compare_package_id_func);
656 else if (type == PK_PACKAGE_SACK_SORT_TYPE_SUMMARY)
657 g_ptr_array_sort (priv->array, (GCompareFunc) pk_package_sack_sort_compare_summary_func);
658 else if (type == PK_PACKAGE_SACK_SORT_TYPE_INFO)
659 g_ptr_array_sort (priv->array, (GCompareFunc) pk_package_sack_sort_compare_info_func);
660 }
661
662 /**
663 * pk_package_sack_get_total_bytes:
664 * @sack: a valid #PkPackageSack instance
665 *
666 * Gets the total size of the package sack in bytes.
667 *
668 * Return value: the size in bytes
669 *
670 * Since: 0.5.2
671 **/
672 guint64
673 pk_package_sack_get_total_bytes (PkPackageSack *sack)
674 {
675 PkPackageSackPrivate *priv = GET_PRIVATE(sack);
676 PkPackage *package = NULL;
677 guint i;
678 GPtrArray *array;
679 guint64 bytes = 0;
680 guint64 bytes_tmp = 0;
681
682 g_return_val_if_fail (PK_IS_PACKAGE_SACK (sack), FALSE);
683
684 array = priv->array;
685 for (i = 0; i < array->len; i++) {
686 package = g_ptr_array_index (array, i);
687 g_object_get (package,
688 "size", &bytes_tmp,
689 NULL);
690 bytes += bytes_tmp;
691 }
692
693 return bytes;
694 }
695
696 /*
697 * pk_package_sack_get_package_ids:
698 **/
699 static gchar **
700 pk_package_sack_get_package_ids (PkPackageSack *sack)
701 {
702 PkPackageSackPrivate *priv = GET_PRIVATE(sack);
703 const gchar *id;
704 gchar **package_ids;
705 const GPtrArray *array;
706 PkPackage *package;
707 guint i;
708
709 /* create array of package_ids */
710 array = priv->array;
711 package_ids = g_new0 (gchar *, array->len+1);
712 for (i = 0; i < array->len; i++) {
713 package = g_ptr_array_index (array, i);
714 id = pk_package_get_id (package);
715 package_ids[i] = g_strdup (id);
716 }
717
718 return package_ids;
719 }
720
721 /***************************************************************************************************/
722
723 /*
724 * pk_package_sack_resolve_cb:
725 **/
726 static void
727 pk_package_sack_resolve_cb (GObject *source_object, GAsyncResult *res, gpointer user_data)
728 {
729 g_autoptr(GTask) task = G_TASK (user_data);
730 PkClient *client = PK_CLIENT (source_object);
731 PkPackage *item;
732 guint i;
733 PkPackage *package;
734 const gchar *package_id;
735 g_autoptr(GError) error = NULL;
736 g_autoptr(PkResults) results = NULL;
737 g_autoptr(GPtrArray) packages = NULL;
738 PkPackageSack *sack;
739
740 sack = g_task_get_source_object (task);
741
742 /* get the results */
743 results = pk_client_generic_finish (client, res, &error);
744 if (results == NULL) {
745 g_warning ("failed to resolve: %s", error->message);
746 g_task_return_error (task, g_steal_pointer (&error));
747 return;
748 }
749
750 /* get the packages */
751 packages = pk_results_get_package_array (results);
752 if (packages->len == 0) {
753 g_task_return_new_error (task,
754 G_IO_ERROR, G_IO_ERROR_FAILED,
755 "no packages found!");
756 return;
757 }
758
759 /* set data on each item */
760 for (i = 0; i < packages->len; i++) {
761 item = g_ptr_array_index (packages, i);
762 package_id = pk_package_get_id (item);
763 package = pk_package_sack_find_by_id (sack, package_id);
764 if (package == NULL) {
765 g_warning ("failed to find %s", package_id);
766 continue;
767 }
768
769 /* set data */
770 g_object_set (package,
771 "info", pk_package_get_info (item),
772 "summary", pk_package_get_summary (item),
773 NULL);
774 g_object_unref (package);
775 }
776
777 g_task_return_boolean (task, TRUE);
778 }
779
780 /**
781 * pk_package_sack_resolve_async: (finish-func pk_client_generic_finish):
782 * @sack: a valid #PkPackageSack instance
783 * @cancellable: a #GCancellable or %NULL
784 * @progress_callback: (scope notified): the function to run when the progress changes
785 * @progress_user_data: data to pass to @progress_callback
786 * @callback: the function to run on completion
787 * @user_data: the data to pass to @callback
788 *
789 * Merges in details about packages using resolve.
790 *
791 * Since: 0.5.2
792 **/
793 void
794 pk_package_sack_resolve_async (PkPackageSack *sack, GCancellable *cancellable,
795 PkProgressCallback progress_callback, gpointer progress_user_data,
796 GAsyncReadyCallback callback, gpointer user_data)
797 {
798 PkPackageSackPrivate *priv = GET_PRIVATE(sack);
799 g_autoptr(GTask) task = NULL;
800 g_auto(GStrv) package_ids = NULL;
801
802 g_return_if_fail (PK_IS_PACKAGE_SACK (sack));
803 g_return_if_fail (callback != NULL);
804
805 task = g_task_new (sack, cancellable, callback, user_data);
806 g_task_set_source_tag (task, pk_package_sack_resolve_async);
807
808 /* start resolve async */
809 package_ids = pk_package_sack_get_package_ids (sack);
810 pk_client_resolve_async (priv->client,
811 pk_bitfield_value (PK_FILTER_ENUM_INSTALLED), package_ids,
812 cancellable, progress_callback, progress_user_data,
813 pk_package_sack_resolve_cb, g_steal_pointer (&task));
814 }
815
816 /**
817 * pk_package_sack_merge_generic_finish:
818 * @sack: a valid #PkPackageSack instance
819 * @res: the #GAsyncResult
820 * @error: A #GError or %NULL
821 *
822 * Gets the result from the asynchronous function.
823 *
824 * Return value: %TRUE for success
825 *
826 * Since: 0.5.2
827 **/
828 gboolean
829 pk_package_sack_merge_generic_finish (PkPackageSack *sack, GAsyncResult *res, GError **error)
830 {
831 g_return_val_if_fail (PK_IS_PACKAGE_SACK (sack), FALSE);
832 g_return_val_if_fail (g_task_is_valid (res, sack), FALSE);
833 g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
834
835 return g_task_propagate_boolean (G_TASK (res), error);
836 }
837
838 /***************************************************************************************************/
839
840 /*
841 * pk_package_sack_get_details_cb:
842 **/
843 static void
844 pk_package_sack_get_details_cb (GObject *source_object, GAsyncResult *res, gpointer user_data)
845 {
846 g_autoptr(GTask) task = G_TASK (user_data);
847 PkClient *client = PK_CLIENT (source_object);
848 PkDetails *item;
849 guint i;
850 PkPackage *package;
851 g_autoptr(GError) error = NULL;
852 g_autoptr(PkResults) results = NULL;
853 g_autoptr(GPtrArray) details = NULL;
854 PkPackageSack *sack;
855
856 sack = g_task_get_source_object (task);
857
858 /* get the results */
859 results = pk_client_generic_finish (client, res, &error);
860 if (results == NULL) {
861 g_warning ("failed to details: %s", error->message);
862 g_task_return_error (task, g_steal_pointer (&error));
863 return;
864 }
865
866 /* get the details */
867 details = pk_results_get_details_array (results);
868 if (details->len == 0) {
869 g_task_return_new_error (task,
870 G_IO_ERROR, G_IO_ERROR_FAILED,
871 "no details found!");
872 return;
873 }
874
875 /* set data on each item */
876 for (i = 0; i < details->len; i++) {
877 g_autofree gchar *package_id = NULL;
878 item = g_ptr_array_index (details, i);
879 g_object_get (item,
880 "package-id", &package_id,
881 NULL);
882
883 /* get package, and set data */
884 package = pk_package_sack_find_by_id (sack, package_id);
885 if (package == NULL) {
886 g_warning ("failed to find %s", package_id);
887 continue;
888 }
889
890 /* set data */
891 g_object_set (package,
892 "license", pk_details_get_license (item),
893 "group", pk_details_get_group (item),
894 "description", pk_details_get_description (item),
895 "url", pk_details_get_url (item),
896 "size", pk_details_get_size (item),
897 NULL);
898 g_object_unref (package);
899 }
900
901 g_task_return_boolean (task, TRUE);
902 }
903
904 /**
905 * pk_package_sack_get_details_async: (finish-func pk_client_generic_finish):
906 * @sack: a valid #PkPackageSack instance
907 * @cancellable: a #GCancellable or %NULL
908 * @progress_callback: (scope notified): the function to run when the progress changes
909 * @progress_user_data: data to pass to @progress_callback
910 * @callback: the function to run on completion
911 * @user_data: the data to pass to @callback
912 *
913 * Merges in details about packages.
914 **/
915 void
916 pk_package_sack_get_details_async (PkPackageSack *sack, GCancellable *cancellable,
917 PkProgressCallback progress_callback, gpointer progress_user_data,
918 GAsyncReadyCallback callback, gpointer user_data)
919 {
920 PkPackageSackPrivate *priv = GET_PRIVATE(sack);
921 g_autoptr(GTask) task = NULL;
922 g_auto(GStrv) package_ids = NULL;
923
924 g_return_if_fail (PK_IS_PACKAGE_SACK (sack));
925 g_return_if_fail (callback != NULL);
926
927 task = g_task_new (sack, cancellable, callback, user_data);
928 g_task_set_source_tag (task, pk_package_sack_get_details_async);
929
930 /* start details async */
931 package_ids = pk_package_sack_get_package_ids (sack);
932 pk_client_get_details_async (priv->client, package_ids,
933 cancellable, progress_callback, progress_user_data,
934 pk_package_sack_get_details_cb, task);
935 }
936
937 /***************************************************************************************************/
938
939 /*
940 * pk_package_sack_get_update_detail_cb:
941 **/
942 static void
943 pk_package_sack_get_update_detail_cb (GObject *source_object, GAsyncResult *res, gpointer user_data)
944 {
945 g_autoptr(GTask) task = G_TASK (user_data);
946 PkClient *client = PK_CLIENT (source_object);
947 PkUpdateDetail *item;
948 guint i;
949 PkPackage *package;
950 g_autoptr(GError) error = NULL;
951 g_autoptr(PkResults) results = NULL;
952 g_autoptr(GPtrArray) update_details = NULL;
953 PkPackageSack *sack;
954
955 sack = g_task_get_source_object (task);
956
957 /* get the results */
958 results = pk_client_generic_finish (client, res, &error);
959 if (results == NULL) {
960 g_warning ("failed to update_detail: %s", error->message);
961 g_task_return_error (task, g_steal_pointer (&error));
962 return;
963 }
964
965 /* get the update_details */
966 update_details = pk_results_get_update_detail_array (results);
967 if (update_details->len == 0) {
968 g_task_return_new_error (task,
969 G_IO_ERROR, G_IO_ERROR_FAILED,
970 "no update details found!");
971 return;
972 }
973
974 /* set data on each item */
975 for (i = 0; i < update_details->len; i++) {
976 PkRestartEnum restart;
977 PkUpdateStateEnum state_enum;
978 g_autofree gchar *changelog = NULL;
979 g_autofree gchar *issued = NULL;
980 g_autofree gchar *obsoletes = NULL;
981 g_autofree gchar *package_id = NULL;
982 g_autofree gchar *updated = NULL;
983 g_autofree gchar *updates = NULL;
984 g_autofree gchar *update_text = NULL;
985 g_auto(GStrv) bugzilla_urls = NULL;
986 g_auto(GStrv) cve_urls = NULL;
987 g_auto(GStrv) vendor_urls = NULL;
988
989 item = g_ptr_array_index (update_details, i);
990 g_object_get (item,
991 "package-id", &package_id,
992 "updates", &updates,
993 "obsoletes", &obsoletes,
994 "vendor-urls", &vendor_urls,
995 "bugzilla-urls", &bugzilla_urls,
996 "cve-urls", &cve_urls,
997 "restart", &restart,
998 "update-text", &update_text,
999 "changelog", &changelog,
1000 "state", &state_enum,
1001 "issued", &issued,
1002 "updated", &updated,
1003 NULL);
1004
1005 /* get package, and set data */
1006 package = pk_package_sack_find_by_id (sack, package_id);
1007 if (package == NULL) {
1008 g_warning ("failed to find %s", package_id);
1009 continue;
1010 }
1011
1012 /* set data */
1013 g_object_set (package,
1014 "update-updates", updates,
1015 "update-obsoletes", obsoletes,
1016 "update-vendor-urls", vendor_urls,
1017 "update-bugzilla-urls", bugzilla_urls,
1018 "update-cve-urls", cve_urls,
1019 "update-restart", restart,
1020 "update-text", update_text,
1021 "update-changelog", changelog,
1022 "update-state", state_enum,
1023 "update-issued", issued,
1024 "update-updated", updated,
1025 NULL);
1026 g_object_unref (package);
1027 }
1028
1029 g_task_return_boolean (task, TRUE);
1030 }
1031
1032 /**
1033 * pk_package_sack_get_update_detail_async: (finish-func pk_client_generic_finish):
1034 * @sack: a valid #PkPackageSack instance
1035 * @cancellable: a #GCancellable or %NULL
1036 * @progress_callback: (scope notified): the function to run when the progress changes
1037 * @progress_user_data: data to pass to @progress_callback
1038 * @callback: the function to run on completion
1039 * @user_data: the data to pass to @callback
1040 *
1041 * Merges in update details about packages.
1042 *
1043 * Since: 0.5.2
1044 **/
1045 void
1046 pk_package_sack_get_update_detail_async (PkPackageSack *sack, GCancellable *cancellable,
1047 PkProgressCallback progress_callback, gpointer progress_user_data,
1048 GAsyncReadyCallback callback, gpointer user_data)
1049 {
1050 PkPackageSackPrivate *priv = GET_PRIVATE(sack);
1051 g_autoptr(GTask) task = NULL;
1052 g_auto(GStrv) package_ids = NULL;
1053
1054 g_return_if_fail (PK_IS_PACKAGE_SACK (sack));
1055 g_return_if_fail (callback != NULL);
1056
1057 task = g_task_new (sack, cancellable, callback, user_data);
1058 g_task_set_source_tag (task, pk_package_sack_get_update_detail_async);
1059
1060 /* start update_detail async */
1061 package_ids = pk_package_sack_get_package_ids (sack);
1062 pk_client_get_update_detail_async (priv->client, package_ids,
1063 cancellable, progress_callback, progress_user_data,
1064 pk_package_sack_get_update_detail_cb, task);
1065 }
1066
1067 /***************************************************************************************************/
1068
1069 /*
1070 * pk_package_sack_class_init:
1071 **/
1072 static void
1073 pk_package_sack_class_init (PkPackageSackClass *klass)
1074 {
1075 GObjectClass *object_class = G_OBJECT_CLASS (klass);
1076 object_class->finalize = pk_package_sack_finalize;
1077 }
1078
1079 /*
1080 * pk_package_sack_init:
1081 **/
1082 static void
1083 pk_package_sack_init (PkPackageSack *sack)
1084 {
1085 PkPackageSackPrivate *priv = GET_PRIVATE(sack);
1086
1087 sack->priv = priv;
1088 priv->table = g_hash_table_new (g_str_hash, g_str_equal);
1089 priv->array = g_ptr_array_new_with_free_func (g_object_unref);
1090 priv->client = pk_client_new ();
1091 }
1092
1093 /*
1094 * pk_package_sack_finalize:
1095 **/
1096 static void
1097 pk_package_sack_finalize (GObject *object)
1098 {
1099 PkPackageSack *sack = PK_PACKAGE_SACK (object);
1100 PkPackageSackPrivate *priv = GET_PRIVATE(sack);
1101
1102 g_clear_pointer (&priv->array, g_ptr_array_unref);
1103 g_clear_pointer (&priv->table, g_hash_table_unref);
1104 g_clear_object (&priv->client);
1105
1106 G_OBJECT_CLASS (pk_package_sack_parent_class)->finalize (object);
1107 }
1108
1109 /**
1110 * pk_package_sack_new:
1111 *
1112 * Return value: a new #PkPackageSack object.
1113 *
1114 * Since: 0.5.2
1115 **/
1116 PkPackageSack *
1117 pk_package_sack_new (void)
1118 {
1119 PkPackageSack *sack;
1120 sack = g_object_new (PK_TYPE_PACKAGE_SACK, NULL);
1121 return PK_PACKAGE_SACK (sack);
1122 }