Debian Codegraph @

lib/packagekit-glib2/pk-task.c

raw
1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
2 *
3 * Copyright (C) 2012 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-task
24 * @short_description: An abstract package task GObject, dealing with unsigned
25 * transactions, GPG keys and EULA requests.
26 */
27
28 #include "config.h"
29
30 #include <gio/gio.h>
31
32 #include <packagekit-glib2/pk-task.h>
33 #include <packagekit-glib2/pk-common.h>
34 #include <packagekit-glib2/pk-enum.h>
35 #include <packagekit-glib2/pk-results.h>
36
37 static void pk_task_finalize (GObject *object);
38
39 #define PK_TASK_TRANSACTION_CANCELLED_RETRY_TIMEOUT 2000 /* ms */
40
41 /**
42 * PkTaskPrivate:
43 *
44 * Private #PkTask data
45 **/
46 struct _PkTaskPrivate
47 {
48 GHashTable *gtasks; /* uint, GTask* */
49 gboolean simulate;
50 gboolean only_download;
51 gboolean only_trusted;
52 gboolean allow_reinstall;
53 gboolean allow_downgrade;
54 };
55
56 enum {
57 PROP_0,
58 PROP_SIMULATE,
59 PROP_ONLY_DOWNLOAD,
60 PROP_ONLY_TRUSTED,
61 PROP_ALLOW_REINSTALL,
62 PROP_ALLOW_DOWNGRADE,
63 PROP_LAST
64 };
65
66 static GParamSpec *obj_properties[PROP_LAST] = { NULL, };
67
68 /**
69 * PkTaskState:
70 *
71 * For use in the async methods
72 **/
73 typedef struct {
74 guint request;
75 PkRoleEnum role;
76 PkExitEnum exit_enum;
77 gboolean simulate;
78 gboolean only_download;
79 gboolean allow_reinstall;
80 gboolean allow_downgrade;
81 gboolean transaction_flags;
82 gchar **package_ids;
83 gboolean allow_deps;
84 gboolean autoremove;
85 gchar **files;
86 PkResults *results;
87 PkProgressCallback progress_callback;
88 gpointer progress_user_data;
89 gboolean enabled;
90 gboolean force;
91 gboolean recursive;
92 gchar *directory;
93 gchar *distro_id;
94 gchar **packages;
95 gchar *repo_id;
96 gchar *transaction_id;
97 gchar **values;
98 PkBitfield filters;
99 PkUpgradeKindEnum upgrade_kind;
100 guint retry_id;
101 } PkTaskState;
102
103 G_DEFINE_TYPE_WITH_PRIVATE (PkTask, pk_task, PK_TYPE_CLIENT)
104 #define GET_PRIVATE(o) (pk_task_get_instance_private (o))
105
106 static void pk_task_ready_cb (GObject *source_object, GAsyncResult *res, gpointer user_data);
107
108 /*
109 * pk_task_generate_request_id:
110 **/
111 static guint
112 pk_task_generate_request_id (void)
113 {
114 static guint id = 0;
115 return ++id;
116 }
117
118 /*
119 * pk_task_find_by_request:
120 **/
121 static inline GTask *
122 pk_task_find_by_request (PkTask *task, guint request)
123 {
124 PkTaskPrivate *priv = GET_PRIVATE(task);
125
126 g_return_val_if_fail (PK_IS_TASK (task), NULL);
127 g_return_val_if_fail (request != 0, NULL);
128
129 return g_hash_table_lookup (priv->gtasks, GUINT_TO_POINTER (request));
130 }
131
132 /*
133 * pk_task_generic_state_finish:
134 **/
135 static void
136 pk_task_state_free (gpointer task_state)
137 {
138 PkTaskState *state = task_state;
139
140 if (state->retry_id != 0)
141 g_source_remove (state->retry_id);
142 g_free (state->directory);
143 g_free (state->distro_id);
144 g_free (state->repo_id);
145 g_free (state->transaction_id);
146 g_strfreev (state->files);
147 g_strfreev (state->package_ids);
148 g_strfreev (state->packages);
149 g_strfreev (state->values);
150 g_slice_free (PkTaskState, state);
151 }
152
153 /*
154 * pk_task_do_async_action:
155 **/
156 static void
157 pk_task_do_async_action (GTask *gtask)
158 {
159 PkTask *task = g_task_get_source_object (gtask);
160 PkTaskPrivate *priv = GET_PRIVATE(task);
161 PkTaskState *state = g_task_get_task_data (gtask);
162 GCancellable *cancellable = g_task_get_cancellable (gtask);
163 PkBitfield transaction_flags;
164
165 /* so the callback knows if we are serious or not */
166 state->simulate = FALSE;
167
168 /* only prepare the transaction */
169 transaction_flags = state->transaction_flags;
170 if (priv->only_download) {
171 pk_bitfield_add (transaction_flags,
172 PK_TRANSACTION_FLAG_ENUM_ONLY_DOWNLOAD);
173 }
174 if (priv->allow_reinstall) {
175 pk_bitfield_add (transaction_flags,
176 PK_TRANSACTION_FLAG_ENUM_ALLOW_REINSTALL);
177 }
178 if (priv->allow_downgrade) {
179 pk_bitfield_add (transaction_flags,
180 PK_TRANSACTION_FLAG_ENUM_ALLOW_DOWNGRADE);
181 }
182
183 /* do the correct action */
184 if (state->role == PK_ROLE_ENUM_INSTALL_PACKAGES) {
185 pk_client_install_packages_async (PK_CLIENT(task), transaction_flags, state->package_ids,
186 cancellable, state->progress_callback, state->progress_user_data,
187 pk_task_ready_cb, g_steal_pointer (&gtask));
188 } else if (state->role == PK_ROLE_ENUM_UPDATE_PACKAGES) {
189 pk_client_update_packages_async (PK_CLIENT(task), transaction_flags, state->package_ids,
190 cancellable, state->progress_callback, state->progress_user_data,
191 pk_task_ready_cb, g_steal_pointer (&gtask));
192 } else if (state->role == PK_ROLE_ENUM_REMOVE_PACKAGES) {
193 pk_client_remove_packages_async (PK_CLIENT(task),
194 transaction_flags,
195 state->package_ids,
196 state->allow_deps,
197 state->autoremove,
198 cancellable,
199 state->progress_callback,
200 state->progress_user_data,
201 pk_task_ready_cb, g_steal_pointer (&gtask));
202 } else if (state->role == PK_ROLE_ENUM_INSTALL_FILES) {
203 pk_client_install_files_async (PK_CLIENT(task), transaction_flags, state->files,
204 cancellable, state->progress_callback, state->progress_user_data,
205 pk_task_ready_cb, g_steal_pointer (&gtask));
206 } else if (state->role == PK_ROLE_ENUM_RESOLVE) {
207 pk_client_resolve_async (PK_CLIENT(task), state->filters, state->packages,
208 cancellable, state->progress_callback, state->progress_user_data,
209 pk_task_ready_cb, g_steal_pointer (&gtask));
210 } else if (state->role == PK_ROLE_ENUM_SEARCH_NAME) {
211 pk_client_search_names_async (PK_CLIENT(task), state->filters, state->values,
212 cancellable, state->progress_callback, state->progress_user_data,
213 pk_task_ready_cb, g_steal_pointer (&gtask));
214 } else if (state->role == PK_ROLE_ENUM_SEARCH_DETAILS) {
215 pk_client_search_details_async (PK_CLIENT(task), state->filters, state->values,
216 cancellable, state->progress_callback, state->progress_user_data,
217 pk_task_ready_cb, g_steal_pointer (&gtask));
218 } else if (state->role == PK_ROLE_ENUM_SEARCH_GROUP) {
219 pk_client_search_groups_async (PK_CLIENT(task), state->filters, state->values,
220 cancellable, state->progress_callback, state->progress_user_data,
221 pk_task_ready_cb, g_steal_pointer (&gtask));
222 } else if (state->role == PK_ROLE_ENUM_SEARCH_FILE) {
223 pk_client_search_files_async (PK_CLIENT(task), state->filters, state->values,
224 cancellable, state->progress_callback, state->progress_user_data,
225 pk_task_ready_cb, g_steal_pointer (&gtask));
226 } else if (state->role == PK_ROLE_ENUM_GET_DETAILS) {
227 pk_client_get_details_async (PK_CLIENT(task), state->package_ids,
228 cancellable, state->progress_callback, state->progress_user_data,
229 pk_task_ready_cb, g_steal_pointer (&gtask));
230 } else if (state->role == PK_ROLE_ENUM_GET_UPDATE_DETAIL) {
231 pk_client_get_update_detail_async (PK_CLIENT(task), state->package_ids,
232 cancellable, state->progress_callback, state->progress_user_data,
233 pk_task_ready_cb, g_steal_pointer (&gtask));
234 } else if (state->role == PK_ROLE_ENUM_DOWNLOAD_PACKAGES) {
235 pk_client_download_packages_async (PK_CLIENT(task), state->package_ids, state->directory,
236 cancellable, state->progress_callback, state->progress_user_data,
237 pk_task_ready_cb, g_steal_pointer (&gtask));
238 } else if (state->role == PK_ROLE_ENUM_GET_UPDATES) {
239 pk_client_get_updates_async (PK_CLIENT(task), state->filters,
240 cancellable, state->progress_callback, state->progress_user_data,
241 pk_task_ready_cb, g_steal_pointer (&gtask));
242 } else if (state->role == PK_ROLE_ENUM_DEPENDS_ON) {
243 pk_client_depends_on_async (PK_CLIENT(task), state->filters, state->package_ids, state->recursive,
244 cancellable, state->progress_callback, state->progress_user_data,
245 pk_task_ready_cb, g_steal_pointer (&gtask));
246 } else if (state->role == PK_ROLE_ENUM_GET_PACKAGES) {
247 pk_client_get_packages_async (PK_CLIENT(task), state->filters,
248 cancellable, state->progress_callback, state->progress_user_data,
249 pk_task_ready_cb, g_steal_pointer (&gtask));
250 } else if (state->role == PK_ROLE_ENUM_REQUIRED_BY) {
251 pk_client_required_by_async (PK_CLIENT(task), state->filters, state->package_ids, state->recursive,
252 cancellable, state->progress_callback, state->progress_user_data,
253 pk_task_ready_cb, g_steal_pointer (&gtask));
254 } else if (state->role == PK_ROLE_ENUM_WHAT_PROVIDES) {
255 pk_client_what_provides_async (PK_CLIENT(task), state->filters, state->values,
256 cancellable, state->progress_callback, state->progress_user_data,
257 pk_task_ready_cb, g_steal_pointer (&gtask));
258 } else if (state->role == PK_ROLE_ENUM_GET_FILES) {
259 pk_client_get_files_async (PK_CLIENT(task), state->package_ids,
260 cancellable, state->progress_callback, state->progress_user_data,
261 pk_task_ready_cb, g_steal_pointer (&gtask));
262 } else if (state->role == PK_ROLE_ENUM_GET_CATEGORIES) {
263 pk_client_get_categories_async (PK_CLIENT(task),
264 cancellable, state->progress_callback, state->progress_user_data,
265 pk_task_ready_cb, g_steal_pointer (&gtask));
266 } else if (state->role == PK_ROLE_ENUM_REFRESH_CACHE) {
267 pk_client_refresh_cache_async (PK_CLIENT(task), state->force,
268 cancellable, state->progress_callback, state->progress_user_data,
269 pk_task_ready_cb, g_steal_pointer (&gtask));
270 } else if (state->role == PK_ROLE_ENUM_GET_REPO_LIST) {
271 pk_client_get_repo_list_async (PK_CLIENT(task), state->filters,
272 cancellable, state->progress_callback, state->progress_user_data,
273 pk_task_ready_cb, g_steal_pointer (&gtask));
274 } else if (state->role == PK_ROLE_ENUM_REPO_ENABLE) {
275 pk_client_repo_enable_async (PK_CLIENT(task), state->repo_id, state->enabled,
276 cancellable, state->progress_callback, state->progress_user_data,
277 pk_task_ready_cb, g_steal_pointer (&gtask));
278 } else if (state->role == PK_ROLE_ENUM_UPGRADE_SYSTEM) {
279 pk_client_upgrade_system_async (PK_CLIENT(task), transaction_flags, state->distro_id, state->upgrade_kind,
280 cancellable, state->progress_callback, state->progress_user_data,
281 pk_task_ready_cb, g_steal_pointer (&gtask));
282 } else if (state->role == PK_ROLE_ENUM_REPAIR_SYSTEM) {
283 pk_client_repair_system_async (PK_CLIENT(task), transaction_flags,
284 cancellable, state->progress_callback, state->progress_user_data,
285 pk_task_ready_cb, g_steal_pointer (&gtask));
286 } else {
287 g_assert_not_reached ();
288 }
289 }
290
291 /*
292 * pk_task_package_filter_cb:
293 **/
294 static gboolean
295 pk_task_package_filter_cb (PkPackage *package, gpointer user_data)
296 {
297 PkInfoEnum info;
298 info = pk_package_get_info (package);
299 if (info == PK_INFO_ENUM_CLEANUP ||
300 info == PK_INFO_ENUM_UNTRUSTED ||
301 info == PK_INFO_ENUM_FINISHED)
302 return FALSE;
303 if (g_strcmp0 (pk_package_get_data (package), "local") == 0)
304 return FALSE;
305 return TRUE;
306 }
307
308 static void pk_task_do_async_simulate_action (GTask *gtask);
309
310 /*
311 * pk_task_simulate_ready_cb:
312 **/
313 static void
314 pk_task_simulate_ready_cb (GObject *source_object, GAsyncResult *res, gpointer user_data)
315 {
316 g_autoptr(GTask) gtask = G_TASK (user_data);
317 g_autoptr(GError) error = NULL;
318 g_autoptr(PkPackageSack) sack = NULL;
319 g_autoptr(PkPackageSack) untrusted_sack = NULL;
320 PkTask *task = g_task_get_source_object (gtask);
321 PkTaskState *state = g_task_get_task_data (gtask);
322
323 /* old results no longer valid */
324 g_clear_object (&state->results);
325
326 /* get the results */
327 state->results = pk_client_generic_finish (PK_CLIENT(source_object), res, &error);
328 if (state->results == NULL) {
329
330 /* handle case where this is not implemented */
331 if (error->code == PK_CLIENT_ERROR_NOT_SUPPORTED) {
332 pk_task_do_async_action (g_steal_pointer (&gtask));
333 return;
334 }
335
336 /* just abort */
337 g_task_return_error (gtask, g_steal_pointer (&error));
338 return;
339 }
340
341 /* get exit code */
342 state->exit_enum = pk_results_get_exit_code (state->results);
343 if (state->exit_enum == PK_EXIT_ENUM_NEED_UNTRUSTED) {
344 g_debug ("retrying with !only-trusted");
345 pk_bitfield_remove (state->transaction_flags,
346 PK_TRANSACTION_FLAG_ENUM_ONLY_TRUSTED);
347 /* retry this */
348 pk_task_do_async_simulate_action (g_steal_pointer (&gtask));
349 return;
350 }
351
352 if (state->exit_enum != PK_EXIT_ENUM_SUCCESS) {
353 /* we 'fail' with success so the application gets a
354 * chance to process the PackageKit-specific
355 * ErrorCode enumerated value and detail. */
356 g_task_return_pointer (gtask, g_steal_pointer (&state->results), g_object_unref);
357 return;
358 }
359
360 /* get data */
361 sack = pk_results_get_package_sack (state->results);
362
363 /* if we did a simulate and we got a message that a package was untrusted,
364 * there's no point trying to do the action with only-trusted */
365 untrusted_sack = pk_package_sack_filter_by_info (sack, PK_INFO_ENUM_UNTRUSTED);
366 if (pk_package_sack_get_size (untrusted_sack) > 0) {
367 g_debug ("we got an untrusted message, so skipping only-trusted");
368 pk_bitfield_remove (state->transaction_flags,
369 PK_TRANSACTION_FLAG_ENUM_ONLY_TRUSTED);
370 }
371
372 /* remove all the packages we want to ignore */
373 pk_package_sack_remove_by_filter (sack, pk_task_package_filter_cb, NULL);
374
375 /* no results from simulate */
376 if (pk_package_sack_get_size (sack) == 0) {
377 pk_task_do_async_action (g_steal_pointer (&gtask));
378 return;
379 }
380
381 /* sort the list, as clients will mostly want this */
382 pk_package_sack_sort (sack, PK_PACKAGE_SACK_SORT_TYPE_INFO);
383
384 /* run the callback */
385 PK_TASK_GET_CLASS (task)->simulate_question (task, state->request, state->results);
386 }
387
388 /*
389 * pk_task_do_async_simulate_action:
390 **/
391 static void
392 pk_task_do_async_simulate_action (GTask *gtask)
393 {
394 PkTask *task = g_task_get_source_object (gtask);
395 PkTaskState *state = g_task_get_task_data (gtask);
396 GCancellable *cancellable = g_task_get_cancellable (gtask);
397 PkBitfield transaction_flags = state->transaction_flags;
398
399 /* so the callback knows if we are serious or not */
400 pk_bitfield_add (transaction_flags, PK_TRANSACTION_FLAG_ENUM_SIMULATE);
401 state->simulate = TRUE;
402
403 /* do the correct action */
404 if (state->role == PK_ROLE_ENUM_INSTALL_PACKAGES) {
405 /* simulate install async */
406 g_debug ("doing install");
407 pk_client_install_packages_async (PK_CLIENT(task),
408 transaction_flags,
409 state->package_ids,
410 cancellable,
411 state->progress_callback,
412 state->progress_user_data,
413 pk_task_simulate_ready_cb,
414 g_steal_pointer (&gtask));
415 } else if (state->role == PK_ROLE_ENUM_UPDATE_PACKAGES) {
416 /* simulate update async */
417 g_debug ("doing update");
418 pk_client_update_packages_async (PK_CLIENT(task),
419 transaction_flags,
420 state->package_ids,
421 cancellable,
422 state->progress_callback,
423 state->progress_user_data,
424 pk_task_simulate_ready_cb,
425 g_steal_pointer (&gtask));
426 } else if (state->role == PK_ROLE_ENUM_REMOVE_PACKAGES) {
427 /* simulate remove async */
428 g_debug ("doing remove");
429 pk_client_remove_packages_async (PK_CLIENT(task),
430 transaction_flags,
431 state->package_ids,
432 state->allow_deps,
433 state->autoremove,
434 cancellable,
435 state->progress_callback,
436 state->progress_user_data,
437 pk_task_simulate_ready_cb,
438 g_steal_pointer (&gtask));
439 } else if (state->role == PK_ROLE_ENUM_INSTALL_FILES) {
440 /* simulate install async */
441 g_debug ("doing install files");
442 pk_client_install_files_async (PK_CLIENT(task),
443 transaction_flags,
444 state->files,
445 cancellable,
446 state->progress_callback,
447 state->progress_user_data,
448 pk_task_simulate_ready_cb,
449 g_steal_pointer (&gtask));
450 } else if (state->role == PK_ROLE_ENUM_UPGRADE_SYSTEM) {
451 /* simulate upgrade system async */
452 g_debug ("doing upgrade system");
453 pk_client_upgrade_system_async (PK_CLIENT(task),
454 transaction_flags,
455 state->distro_id,
456 state->upgrade_kind,
457 cancellable,
458 state->progress_callback,
459 state->progress_user_data,
460 pk_task_simulate_ready_cb,
461 g_steal_pointer (&gtask));
462 } else if (state->role == PK_ROLE_ENUM_REPAIR_SYSTEM) {
463 /* simulate repair system async */
464 g_debug ("doing repair system");
465 pk_client_repair_system_async (PK_CLIENT(task),
466 transaction_flags,
467 cancellable,
468 state->progress_callback,
469 state->progress_user_data,
470 pk_task_simulate_ready_cb,
471 g_steal_pointer (&gtask));
472 } else {
473 g_assert_not_reached ();
474 }
475 }
476
477 /*
478 * pk_task_install_signatures_ready_cb:
479 **/
480 static void
481 pk_task_install_signatures_ready_cb (GObject *source_object, GAsyncResult *res, gpointer user_data)
482 {
483 g_autoptr(GTask) gtask = G_TASK (user_data);
484 PkTask *task = PK_TASK (source_object);
485 PkTaskState *state = g_task_get_task_data (gtask);
486 g_autoptr(GError) error = NULL;
487
488 /* old results no longer valid */
489 g_clear_object (&state->results);
490
491 /* get the results */
492 state->results = pk_client_generic_finish (PK_CLIENT(task), res, &error);
493 if (state->results == NULL) {
494 g_task_return_error (gtask, g_steal_pointer (&error));
495 return;
496 }
497
498 /* get exit code */
499 state->exit_enum = pk_results_get_exit_code (state->results);
500
501 /* need untrusted */
502 if (state->exit_enum != PK_EXIT_ENUM_SUCCESS) {
503 g_autoptr(PkError) error_code = NULL;
504 error_code = pk_results_get_error_code (state->results);
505 /* TODO: convert the PkErrorEnum to a PK_CLIENT_ERROR_* enum */
506 g_task_return_new_error (gtask,
507 PK_CLIENT_ERROR,
508 PK_CLIENT_ERROR_FAILED,
509 "failed to install signature: %s",
510 pk_error_get_details (error_code));
511 return;
512 }
513
514 /* now try the action again */
515 pk_task_do_async_action (g_steal_pointer (&gtask));
516 }
517
518 /*
519 * pk_task_install_signatures:
520 **/
521 static void
522 pk_task_install_signatures (GTask *given_gtask)
523 {
524 GTask *gtask = given_gtask;
525 PkTask *task = g_task_get_source_object (gtask);
526 PkTaskState *state = g_task_get_task_data (gtask);
527 PkRepoSignatureRequired *item;
528 PkSigTypeEnum type;
529 g_autoptr(GError) error = NULL;
530 g_autofree gchar *key_id = NULL;
531 g_autofree gchar *package_id = NULL;
532 g_autoptr(GPtrArray) array = NULL;
533 GCancellable *cancellable;
534
535 /* get results */
536 array = pk_results_get_repo_signature_required_array (state->results);
537 if (array == NULL || array->len == 0) {
538 g_task_return_new_error (gtask,
539 PK_CLIENT_ERROR,
540 PK_CLIENT_ERROR_FAILED,
541 "no signatures to install");
542 return;
543 }
544
545 /* did we get more than result? */
546 if (array->len > 1) {
547 /* TODO: support more than one signature */
548 g_task_return_new_error (gtask,
549 PK_CLIENT_ERROR,
550 PK_CLIENT_ERROR_FAILED,
551 "more than one signature to install");
552 return;
553 }
554
555 /* get first item of data */
556 item = g_ptr_array_index (array, 0);
557 g_object_get (item,
558 "type", &type,
559 "key-id", &key_id,
560 "package-id", &package_id,
561 NULL);
562
563 /* do new async method */
564 cancellable = g_task_get_cancellable (gtask);
565 pk_client_install_signature_async (PK_CLIENT(task), type, key_id, package_id,
566 cancellable, state->progress_callback, state->progress_user_data,
567 pk_task_install_signatures_ready_cb, g_object_ref (gtask));
568 }
569
570 /*
571 * pk_task_accept_eulas_ready_cb:
572 **/
573 static void
574 pk_task_accept_eulas_ready_cb (GObject *source_object, GAsyncResult *res, gpointer user_data)
575 {
576 g_autoptr(GTask) gtask = G_TASK (user_data);
577 PkTask *task = PK_TASK (source_object);
578 PkTaskState *state = g_task_get_task_data (gtask);
579 g_autoptr(GError) error = NULL;
580
581 /* old results no longer valid */
582 g_clear_object (&state->results);
583
584 /* get the results */
585 state->results = pk_client_generic_finish (PK_CLIENT(task), res, &error);
586 if (state->results == NULL) {
587 g_task_return_error (gtask, g_steal_pointer (&error));
588 return;
589 }
590
591 /* get exit code */
592 state->exit_enum = pk_results_get_exit_code (state->results);
593
594 /* need untrusted */
595 if (state->exit_enum != PK_EXIT_ENUM_SUCCESS) {
596 g_autoptr(PkError) error_code = NULL;
597 error_code = pk_results_get_error_code (state->results);
598 /* TODO: convert the PkErrorEnum to a PK_CLIENT_ERROR_* enum */
599 g_task_return_new_error (gtask,
600 PK_CLIENT_ERROR,
601 PK_CLIENT_ERROR_FAILED,
602 "failed to accept eula: %s",
603 pk_error_get_details (error_code));
604 return;
605 }
606
607 /* now try the action again */
608 pk_task_do_async_action (g_steal_pointer (&gtask));
609 }
610
611 /*
612 * pk_task_accept_eulas:
613 **/
614 static void
615 pk_task_accept_eulas (GTask *given_gtask)
616 {
617 GTask *gtask = given_gtask;
618 PkTask *task = g_task_get_source_object (gtask);
619 PkTaskState *state = g_task_get_task_data (gtask);
620 PkEulaRequired *item;
621 g_autoptr(GError) error = NULL;
622 const gchar *eula_id;
623 g_autoptr(GPtrArray) array = NULL;
624 GCancellable *cancellable;
625
626 /* get results */
627 array = pk_results_get_eula_required_array (state->results);
628 if (array == NULL || array->len == 0) {
629 g_task_return_new_error (gtask,
630 PK_CLIENT_ERROR,
631 PK_CLIENT_ERROR_FAILED,
632 "no eulas to accept");
633 return;
634 }
635
636 /* did we get more than result? */
637 if (array->len > 1) {
638 /* TODO: support more than one eula */
639 g_task_return_new_error (gtask,
640 PK_CLIENT_ERROR,
641 PK_CLIENT_ERROR_FAILED,
642 "more than one eula to accept");
643 return;
644 }
645
646 /* get first item of data */
647 item = g_ptr_array_index (array, 0);
648 eula_id = pk_eula_required_get_eula_id (item);
649
650 /* do new async method */
651 cancellable = g_task_get_cancellable (gtask);
652 pk_client_accept_eula_async (PK_CLIENT(task), eula_id,
653 cancellable, state->progress_callback, state->progress_user_data,
654 pk_task_accept_eulas_ready_cb, g_object_ref (gtask));
655 }
656
657 /*
658 * pk_task_repair_ready_cb:
659 **/
660 static void
661 pk_task_repair_ready_cb (GObject *source_object, GAsyncResult *res, gpointer user_data)
662 {
663 g_autoptr(GTask) gtask = G_TASK (user_data);
664 PkTaskState *state = g_task_get_task_data (gtask);
665 PkTask *task = PK_TASK (source_object);
666 g_autoptr(GError) error = NULL;
667
668 /* old results no longer valid */
669 g_clear_object (&state->results);
670
671 /* get the results */
672 state->results = pk_client_generic_finish (PK_CLIENT(task), res, &error);
673 if (state->results == NULL) {
674 g_task_return_error (gtask, g_steal_pointer (&error));
675 return;
676 }
677
678 /* get exit code */
679 state->exit_enum = pk_results_get_exit_code (state->results);
680
681 /* need untrusted */
682 if (state->exit_enum != PK_EXIT_ENUM_SUCCESS) {
683 g_autoptr(PkError) error_code = NULL;
684 error_code = pk_results_get_error_code (state->results);
685 /* TODO: convert the PkErrorEnum to a PK_CLIENT_ERROR_* enum */
686 g_task_return_new_error (gtask,
687 PK_CLIENT_ERROR,
688 PK_CLIENT_ERROR_FAILED,
689 "failed to repair: %s",
690 pk_error_get_details (error_code));
691 return;
692 }
693
694 /* now try the action again */
695 pk_task_do_async_action (g_steal_pointer (&gtask));
696 }
697
698 /*
699 * pk_task_user_accepted_idle_cb:
700 **/
701 static gboolean
702 pk_task_user_accepted_idle_cb (gpointer user_data)
703 {
704 GTask *gtask = user_data;
705 PkTaskState *state = g_task_get_task_data (gtask);
706
707 /* this needs another step in the dance */
708 if (state->exit_enum == PK_EXIT_ENUM_KEY_REQUIRED) {
709 g_debug ("need to do install-sig");
710 pk_task_install_signatures (gtask);
711 return FALSE;
712 }
713
714 /* this needs another step in the dance */
715 if (state->exit_enum == PK_EXIT_ENUM_EULA_REQUIRED) {
716 g_debug ("need to do accept-eula");
717 pk_task_accept_eulas (gtask);
718 return FALSE;
719 }
720
721 /* this needs another step in the dance */
722 if (state->exit_enum == PK_EXIT_ENUM_REPAIR_REQUIRED) {
723 GCancellable *cancellable = g_task_get_cancellable (gtask);
724 PkTask *task = g_task_get_source_object (gtask);
725 g_debug ("need to do repair");
726 pk_client_repair_system_async (PK_CLIENT(task),
727 pk_bitfield_value (PK_TRANSACTION_FLAG_ENUM_NONE),
728 cancellable,
729 state->progress_callback,
730 state->progress_user_data,
731 (GAsyncReadyCallback) pk_task_repair_ready_cb, g_object_ref (gtask));
732 return FALSE;
733 }
734
735 /* doing task */
736 g_debug ("continuing with request %i", state->request);
737 pk_task_do_async_action (g_object_ref (gtask));
738 return FALSE;
739 }
740
741 /**
742 * pk_task_user_accepted:
743 * @task: a valid #PkTask instance
744 * @request: request ID for EULA.
745 *
746 * Mark a EULA as accepted by the user.
747 *
748 * Return value: %TRUE if @request is valid.
749 *
750 * Since: 0.5.2
751 **/
752 gboolean
753 pk_task_user_accepted (PkTask *task, guint request)
754 {
755 GTask *gtask;
756 GSource *idle_source;
757
758 /* get the not-yet-completed request */
759 gtask = pk_task_find_by_request (task, request);
760 if (gtask == NULL) {
761 g_warning ("request %i not found", request);
762 return FALSE;
763 }
764
765 idle_source = g_idle_source_new ();
766 g_source_set_callback (idle_source, G_SOURCE_FUNC (pk_task_user_accepted_idle_cb), g_object_ref (gtask), g_object_unref);
767 g_source_set_name (idle_source, "[PkTask] user-accept");
768 g_source_attach (idle_source, g_main_context_get_thread_default ());
769 return TRUE;
770 }
771
772 /*
773 * pk_task_user_declined_idle_cb:
774 **/
775 static gboolean
776 pk_task_user_declined_idle_cb (gpointer user_data)
777 {
778 GTask *gtask = user_data;
779 PkTaskState *state;
780
781 state = g_task_get_task_data (gtask);
782
783 /* the introduction is finished */
784 if (state->simulate) {
785 g_task_return_new_error (gtask,
786 PK_CLIENT_ERROR, PK_CLIENT_ERROR_DECLINED_SIMULATION,
787 "user declined simulation");
788 return FALSE;
789 }
790
791 /* doing task */
792 g_debug ("declined request %i", state->request);
793 g_task_return_new_error (gtask,
794 PK_CLIENT_ERROR, PK_CLIENT_ERROR_DECLINED_INTERACTION,
795 "user declined interaction");
796 return FALSE;
797 }
798
799 /**
800 * pk_task_user_declined:
801 * @task: a valid #PkTask instance
802 * @request: request ID for EULA.
803 *
804 * Mark a EULA as declined by the user.
805 *
806 * Return value: %TRUE if @request is valid.
807 *
808 * Since: 0.5.2
809 **/
810 gboolean
811 pk_task_user_declined (PkTask *task, guint request)
812 {
813 GTask *gtask;
814 GSource *idle_source;
815
816 /* get the not-yet-completed request */
817 gtask = pk_task_find_by_request (task, request);
818 if (gtask == NULL) {
819 g_warning ("request %i not found", request);
820 return FALSE;
821 }
822
823 idle_source = g_idle_source_new ();
824 g_source_set_callback (idle_source, G_SOURCE_FUNC (pk_task_user_declined_idle_cb), g_object_ref (gtask), g_object_unref);
825 g_source_set_name (idle_source, "[PkTask] user-accept");
826 g_source_attach (idle_source, g_main_context_get_thread_default ());
827 return TRUE;
828 }
829
830 /*
831 * pk_task_retry_cancelled_transaction_cb:
832 **/
833 static gboolean
834 pk_task_retry_cancelled_transaction_cb (gpointer user_data)
835 {
836 g_autoptr(GTask) gtask = G_TASK (user_data);
837 PkTaskState *state = g_task_get_task_data (gtask);
838
839 pk_task_do_async_action (g_steal_pointer (&gtask));
840 state->retry_id = 0;
841 return G_SOURCE_REMOVE;
842 }
843
844 /*
845 * pk_task_ready_cb:
846 **/
847 static void
848 pk_task_ready_cb (GObject *source_object, GAsyncResult *res, gpointer user_data)
849 {
850 g_autoptr(GTask) gtask = G_TASK (user_data);
851 PkTask *task = PK_TASK (source_object);
852 PkTaskClass *klass = PK_TASK_GET_CLASS (task);
853 PkTaskState *state = g_task_get_task_data (gtask);
854 gboolean interactive;
855 g_autoptr(GError) error = NULL;
856
857 /* old results no longer valid */
858 g_clear_object (&state->results);
859
860 /* get the results */
861 state->results = pk_client_generic_finish (PK_CLIENT(task), res, &error);
862 if (state->results == NULL) {
863 g_task_return_error (gtask, g_steal_pointer (&error));
864 return;
865 }
866
867 /* get exit code */
868 state->exit_enum = pk_results_get_exit_code (state->results);
869
870 /* can we ask the user questions? */
871 interactive = pk_client_get_interactive (PK_CLIENT (task));
872
873 /* need untrusted */
874 if (state->exit_enum == PK_EXIT_ENUM_NEED_UNTRUSTED) {
875 pk_bitfield_remove (state->transaction_flags,
876 PK_TRANSACTION_FLAG_ENUM_ONLY_TRUSTED);
877
878 /* running non-interactive */
879 if (!interactive) {
880 g_debug ("working non-interactive, so calling accept");
881 pk_task_user_accepted (task, state->request);
882 return;
883 }
884
885 /* no support */
886 if (klass->untrusted_question == NULL) {
887 g_task_return_new_error (gtask,
888 PK_CLIENT_ERROR,
889 PK_CLIENT_ERROR_NOT_SUPPORTED,
890 "could not do untrusted question as no klass support");
891 return;
892 }
893
894 /* run the callback */
895 klass->untrusted_question (task, state->request, state->results);
896 return;
897 }
898
899 /* need key */
900 if (state->exit_enum == PK_EXIT_ENUM_KEY_REQUIRED) {
901
902 /* running non-interactive */
903 if (!interactive) {
904 g_debug ("working non-interactive, so calling accept");
905 pk_task_user_accepted (task, state->request);
906 return;
907 }
908
909 /* no support */
910 if (klass->key_question == NULL) {
911 g_task_return_new_error (gtask,
912 PK_CLIENT_ERROR,
913 PK_CLIENT_ERROR_NOT_SUPPORTED,
914 "could not do key question as no klass support");
915 return;
916 }
917
918 /* run the callback */
919 klass->key_question (task, state->request, state->results);
920 return;
921 }
922
923 /* need repair */
924 if (state->exit_enum == PK_EXIT_ENUM_REPAIR_REQUIRED) {
925
926 /* running non-interactive */
927 if (!interactive) {
928 g_debug ("working non-interactive, so calling accept");
929 pk_task_user_accepted (task, state->request);
930 return;
931 }
932
933 /* no support */
934 if (klass->repair_question == NULL) {
935 g_task_return_new_error (gtask,
936 PK_CLIENT_ERROR,
937 PK_CLIENT_ERROR_NOT_SUPPORTED,
938 "could not do repair question as no klass support");
939 return;
940 }
941
942 /* run the callback */
943 klass->repair_question (task, state->request, state->results);
944 return;
945 }
946
947 /* need EULA */
948 if (state->exit_enum == PK_EXIT_ENUM_EULA_REQUIRED) {
949
950 /* running non-interactive */
951 if (!interactive) {
952 g_debug ("working non-interactive, so calling accept");
953 pk_task_user_accepted (task, state->request);
954 return;
955 }
956
957 /* no support */
958 if (klass->eula_question == NULL) {
959 g_task_return_new_error (gtask,
960 PK_CLIENT_ERROR,
961 PK_CLIENT_ERROR_NOT_SUPPORTED,
962 "could not do eula question as no klass support");
963 return;
964 }
965
966 /* run the callback */
967 klass->eula_question (task, state->request, state->results);
968 return;
969 }
970
971 /* need media change */
972 if (state->exit_enum == PK_EXIT_ENUM_MEDIA_CHANGE_REQUIRED) {
973
974 /* running non-interactive */
975 if (!interactive) {
976 g_debug ("working non-interactive, so calling accept");
977 pk_task_user_accepted (task, state->request);
978 g_task_return_pointer (gtask, g_steal_pointer (&state->results), g_object_unref);
979 return;
980 }
981
982 /* no support */
983 if (klass->media_change_question == NULL) {
984 g_task_return_new_error (gtask,
985 PK_CLIENT_ERROR,
986 PK_CLIENT_ERROR_NOT_SUPPORTED,
987 "could not do media change question as no klass support");
988 return;
989 }
990
991 /* run the callback */
992 klass->media_change_question (task, state->request, state->results);
993 return;
994 }
995
996 /* just re-run the transaction after a small delay */
997 if (state->exit_enum == PK_EXIT_ENUM_CANCELLED_PRIORITY) {
998 state->retry_id = g_timeout_add (PK_TASK_TRANSACTION_CANCELLED_RETRY_TIMEOUT,
999 pk_task_retry_cancelled_transaction_cb,
1000 g_steal_pointer (&gtask));
1001 return;
1002 }
1003
1004 /* we're done */
1005 g_task_return_pointer (gtask, g_steal_pointer (&state->results), g_object_unref);
1006 }
1007
1008 /**
1009 * pk_task_install_packages_async: (finish-func pk_task_generic_finish):
1010 * @task: a valid #PkTask instance
1011 * @package_ids: (array zero-terminated=1): a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora"
1012 * @cancellable: a #GCancellable or %NULL
1013 * @progress_callback: (scope notified): the function to run when the progress changes
1014 * @progress_user_data: data to pass to @progress_callback
1015 * @callback_ready: the function to run on completion
1016 * @user_data: the data to pass to @callback
1017 *
1018 * Merges in details about packages using resolve.
1019 *
1020 * Since: 0.5.2
1021 **/
1022 void
1023 pk_task_install_packages_async (PkTask *task, gchar **package_ids, GCancellable *cancellable,
1024 PkProgressCallback progress_callback, gpointer progress_user_data,
1025 GAsyncReadyCallback callback_ready, gpointer user_data)
1026 {
1027 PkTaskPrivate *priv = GET_PRIVATE(task);
1028 PkTaskState *state;
1029 g_autoptr(GTask) gtask = NULL;
1030 PkTaskClass *klass = PK_TASK_GET_CLASS (task);
1031
1032 g_return_if_fail (PK_IS_TASK (task));
1033 g_return_if_fail (callback_ready != NULL);
1034 g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
1035
1036 /* save state */
1037 state = g_slice_new0 (PkTaskState);
1038 state->role = PK_ROLE_ENUM_INSTALL_PACKAGES;
1039 state->progress_callback = progress_callback;
1040 state->progress_user_data = progress_user_data;
1041 state->transaction_flags = pk_bitfield_value (PK_TRANSACTION_FLAG_ENUM_ONLY_TRUSTED);
1042 if (priv->allow_reinstall) {
1043 pk_bitfield_add (state->transaction_flags,
1044 PK_TRANSACTION_FLAG_ENUM_ALLOW_REINSTALL);
1045 }
1046 if (priv->allow_downgrade) {
1047 pk_bitfield_add (state->transaction_flags,
1048 PK_TRANSACTION_FLAG_ENUM_ALLOW_DOWNGRADE);
1049 }
1050 state->package_ids = g_strdupv (package_ids);
1051 state->request = pk_task_generate_request_id ();
1052
1053 gtask = g_task_new (task, cancellable, callback_ready, user_data);
1054 g_task_set_source_tag (gtask, pk_task_install_packages_async);
1055 g_debug ("adding state %p", state);
1056 g_hash_table_insert (priv->gtasks, GUINT_TO_POINTER (state->request), g_object_ref (gtask));
1057 g_task_set_task_data (gtask, g_steal_pointer (&state), pk_task_state_free);
1058
1059 /* start trusted install async */
1060 if (priv->simulate && klass->simulate_question != NULL)
1061 pk_task_do_async_simulate_action (g_steal_pointer (&gtask));
1062 else
1063 pk_task_do_async_action (g_steal_pointer (&gtask));
1064 }
1065
1066 /**
1067 * pk_task_update_packages_async: (finish-func pk_task_generic_finish):
1068 * @task: a valid #PkTask instance
1069 * @package_ids: (array zero-terminated=1): a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora"
1070 * @cancellable: a #GCancellable or %NULL
1071 * @progress_callback: (scope notified): the function to run when the progress changes
1072 * @progress_user_data: data to pass to @progress_callback
1073 * @callback_ready: the function to run on completion
1074 * @user_data: the data to pass to @callback_ready
1075 *
1076 * Update specific packages to the newest available versions.
1077 *
1078 * Since: 0.5.2
1079 **/
1080 void
1081 pk_task_update_packages_async (PkTask *task, gchar **package_ids, GCancellable *cancellable,
1082 PkProgressCallback progress_callback, gpointer progress_user_data,
1083 GAsyncReadyCallback callback_ready, gpointer user_data)
1084 {
1085 PkTaskPrivate *priv = GET_PRIVATE(task);
1086 PkTaskState *state;
1087 g_autoptr(GTask) gtask = NULL;
1088 PkTaskClass *klass = PK_TASK_GET_CLASS (task);
1089
1090 g_return_if_fail (PK_IS_CLIENT (task));
1091 g_return_if_fail (callback_ready != NULL);
1092 g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
1093
1094 /* save state */
1095 state = g_slice_new0 (PkTaskState);
1096 state->role = PK_ROLE_ENUM_UPDATE_PACKAGES;
1097 state->transaction_flags = pk_bitfield_value (PK_TRANSACTION_FLAG_ENUM_ONLY_TRUSTED);
1098 state->package_ids = g_strdupv (package_ids);
1099 state->progress_callback = progress_callback;
1100 state->progress_user_data = progress_user_data;
1101 state->request = pk_task_generate_request_id ();
1102
1103 gtask = g_task_new (task, cancellable, callback_ready, user_data);
1104 g_task_set_source_tag (gtask, pk_task_install_packages_async);
1105 g_debug ("adding state %p", state);
1106 g_hash_table_insert (priv->gtasks, GUINT_TO_POINTER (state->request), g_object_ref (gtask));
1107 g_task_set_task_data (gtask, g_steal_pointer (&state), pk_task_state_free);
1108
1109 /* start trusted install async */
1110 if (priv->simulate && klass->simulate_question != NULL)
1111 pk_task_do_async_simulate_action (g_steal_pointer (&gtask));
1112 else
1113 pk_task_do_async_action (g_steal_pointer (&gtask));
1114 }
1115
1116 /**
1117 * pk_task_upgrade_system_async: (finish-func pk_task_generic_finish):
1118 * @task: a valid #PkTask instance
1119 * @distro_id: a distro ID such as "fedora-14"
1120 * @upgrade_kind: a #PkUpgradeKindEnum such as %PK_UPGRADE_KIND_ENUM_COMPLETE
1121 * @cancellable: a #GCancellable or %NULL
1122 * @progress_callback: (scope notified): the function to run when the progress changes
1123 * @progress_user_data: data to pass to @progress_callback
1124 * @callback_ready: the function to run on completion
1125 * @user_data: the data to pass to @callback_ready
1126 *
1127 * This transaction will update the distro to the next version, which may
1128 * involve just downloading the installer and setting up the boot device,
1129 * or may involve doing an on-line upgrade.
1130 *
1131 * The backend will decide what is best to do.
1132 *
1133 * Since: 1.0.12
1134 **/
1135 void
1136 pk_task_upgrade_system_async (PkTask *task,
1137 const gchar *distro_id,
1138 PkUpgradeKindEnum upgrade_kind,
1139 GCancellable *cancellable,
1140 PkProgressCallback progress_callback, gpointer progress_user_data,
1141 GAsyncReadyCallback callback_ready, gpointer user_data)
1142 {
1143 PkTaskPrivate *priv = GET_PRIVATE(task);
1144 PkTaskState *state;
1145 g_autoptr(GTask) gtask = NULL;
1146 PkTaskClass *klass = PK_TASK_GET_CLASS (task);
1147
1148 g_return_if_fail (PK_IS_CLIENT (task));
1149 g_return_if_fail (callback_ready != NULL);
1150 g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
1151
1152 /* save state */
1153 state = g_slice_new0 (PkTaskState);
1154 state->role = PK_ROLE_ENUM_UPGRADE_SYSTEM;
1155 state->transaction_flags = pk_bitfield_value (PK_TRANSACTION_FLAG_ENUM_ONLY_TRUSTED);
1156 state->distro_id = g_strdup (distro_id);
1157 state->upgrade_kind = upgrade_kind;
1158 state->progress_callback = progress_callback;
1159 state->progress_user_data = progress_user_data;
1160 state->request = pk_task_generate_request_id ();
1161
1162 gtask = g_task_new (task, cancellable, callback_ready, user_data);
1163 g_task_set_source_tag (gtask, pk_task_upgrade_system_async);
1164 g_debug ("adding state %p", state);
1165 g_hash_table_insert (priv->gtasks, GUINT_TO_POINTER (state->request), g_object_ref (gtask));
1166 g_task_set_task_data (gtask, g_steal_pointer (&state), pk_task_state_free);
1167
1168 /* start trusted install async */
1169 if (priv->simulate && klass->simulate_question != NULL)
1170 pk_task_do_async_simulate_action (g_steal_pointer (&gtask));
1171 else
1172 pk_task_do_async_action (g_steal_pointer (&gtask));
1173 }
1174
1175 /**
1176 * pk_task_remove_packages_async: (finish-func pk_task_generic_finish):
1177 * @task: a valid #PkTask instance
1178 * @package_ids: (array zero-terminated=1): a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora"
1179 * @allow_deps: if other dependent packages are allowed to be removed from the computer
1180 * @autoremove: if other packages installed at the same time should be tried to remove
1181 * @cancellable: a #GCancellable or %NULL
1182 * @progress_callback: (scope notified): the function to run when the progress changes
1183 * @progress_user_data: data to pass to @progress_callback
1184 * @callback_ready: the function to run on completion
1185 * @user_data: the data to pass to @callback_ready
1186 *
1187 * Remove a package (optionally with dependencies) from the system.
1188 * If @allow_deps is set to %FALSE, and other packages would have to be removed,
1189 * then the transaction would fail.
1190 *
1191 * Since: 0.5.2
1192 **/
1193 void
1194 pk_task_remove_packages_async (PkTask *task, gchar **package_ids, gboolean allow_deps, gboolean autoremove, GCancellable *cancellable,
1195 PkProgressCallback progress_callback, gpointer progress_user_data,
1196 GAsyncReadyCallback callback_ready, gpointer user_data)
1197 {
1198 PkTaskPrivate *priv = GET_PRIVATE(task);
1199 PkTaskState *state;
1200 g_autoptr(GTask) gtask = NULL;
1201 PkTaskClass *klass = PK_TASK_GET_CLASS (task);
1202
1203 g_return_if_fail (PK_IS_CLIENT (task));
1204 g_return_if_fail (callback_ready != NULL);
1205 g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
1206
1207 /* save state */
1208 state = g_slice_new0 (PkTaskState);
1209 state->role = PK_ROLE_ENUM_REMOVE_PACKAGES;
1210 state->allow_deps = allow_deps;
1211 state->autoremove = autoremove;
1212 state->package_ids = g_strdupv (package_ids);
1213 state->progress_callback = progress_callback;
1214 state->progress_user_data = progress_user_data;
1215 state->request = pk_task_generate_request_id ();
1216
1217 gtask = g_task_new (task, cancellable, callback_ready, user_data);
1218 g_task_set_source_tag (gtask, pk_task_install_packages_async);
1219 g_debug ("adding state %p", state);
1220 g_hash_table_insert (priv->gtasks, GUINT_TO_POINTER (state->request), g_object_ref (gtask));
1221 g_task_set_task_data (gtask, g_steal_pointer (&state), pk_task_state_free);
1222
1223 /* start trusted install async */
1224 if (priv->simulate && klass->simulate_question != NULL)
1225 pk_task_do_async_simulate_action (g_steal_pointer (&gtask));
1226 else
1227 pk_task_do_async_action (g_steal_pointer (&gtask));
1228 }
1229
1230 /**
1231 * pk_task_install_files_async: (finish-func pk_task_generic_finish):
1232 * @task: a valid #PkTask instance
1233 * @files: (array zero-terminated=1): a file such as "/home/hughsie/Desktop/hal-devel-0.10.0.rpm"
1234 * @cancellable: a #GCancellable or %NULL
1235 * @progress_callback: (scope notified): the function to run when the progress changes
1236 * @progress_user_data: data to pass to @progress_callback
1237 * @callback_ready: the function to run on completion
1238 * @user_data: the data to pass to @callback_ready
1239 *
1240 * Install a file locally, and get the deps from the repositories.
1241 * This is useful for double clicking on a .rpm or .deb file.
1242 *
1243 * Since: 0.5.2
1244 **/
1245 void
1246 pk_task_install_files_async (PkTask *task, gchar **files, GCancellable *cancellable,
1247 PkProgressCallback progress_callback, gpointer progress_user_data,
1248 GAsyncReadyCallback callback_ready, gpointer user_data)
1249 {
1250 PkTaskPrivate *priv = GET_PRIVATE(task);
1251 PkTaskState *state;
1252 g_autoptr(GTask) gtask = NULL;
1253 PkTaskClass *klass = PK_TASK_GET_CLASS (task);
1254
1255 g_return_if_fail (PK_IS_CLIENT (task));
1256 g_return_if_fail (callback_ready != NULL);
1257 g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
1258
1259 /* save state */
1260 state = g_slice_new0 (PkTaskState);
1261 state->role = PK_ROLE_ENUM_INSTALL_FILES;
1262 if (priv->only_trusted)
1263 state->transaction_flags = pk_bitfield_value (PK_TRANSACTION_FLAG_ENUM_ONLY_TRUSTED);
1264 else
1265 state->transaction_flags = 0;
1266 state->files = g_strdupv (files);
1267 state->progress_callback = progress_callback;
1268 state->progress_user_data = progress_user_data;
1269 state->request = pk_task_generate_request_id ();
1270
1271 gtask = g_task_new (task, cancellable, callback_ready, user_data);
1272 g_task_set_source_tag (gtask, pk_task_install_files_async);
1273 g_debug ("adding state %p", state);
1274 g_hash_table_insert (priv->gtasks, GUINT_TO_POINTER (state->request), g_object_ref (gtask));
1275 g_task_set_task_data (gtask, g_steal_pointer (&state), pk_task_state_free);
1276
1277 /* start trusted install async */
1278 if (priv->simulate && klass->simulate_question != NULL)
1279 pk_task_do_async_simulate_action (g_steal_pointer (&gtask));
1280 else
1281 pk_task_do_async_action (g_steal_pointer (&gtask));
1282 }
1283
1284 /**
1285 * pk_task_resolve_async: (finish-func pk_task_generic_finish):
1286 * @task: a valid #PkTask instance
1287 * @filters: a bitfield of filters that can be used to limit the results
1288 * @packages: (array zero-terminated=1): package names to find
1289 * @cancellable: a #GCancellable or %NULL
1290 * @progress_callback: (scope notified): the function to run when the progress changes
1291 * @progress_user_data: data to pass to @progress_callback
1292 * @callback_ready: the function to run on completion
1293 * @user_data: the data to pass to @callback
1294 *
1295 * Resolves a package name to a package-id.
1296 *
1297 * Since: 0.6.5
1298 **/
1299 void
1300 pk_task_resolve_async (PkTask *task, PkBitfield filters, gchar **packages, GCancellable *cancellable,
1301 PkProgressCallback progress_callback, gpointer progress_user_data,
1302 GAsyncReadyCallback callback_ready, gpointer user_data)
1303 {
1304 PkTaskPrivate *priv = GET_PRIVATE(task);
1305 PkTaskState *state;
1306 g_autoptr(GTask) gtask = NULL;
1307
1308 g_return_if_fail (PK_IS_TASK (task));
1309 g_return_if_fail (callback_ready != NULL);
1310 g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
1311
1312 /* save state */
1313 state = g_slice_new0 (PkTaskState);
1314 state->role = PK_ROLE_ENUM_RESOLVE;
1315 state->progress_callback = progress_callback;
1316 state->progress_user_data = progress_user_data;
1317 state->transaction_flags = pk_bitfield_value (PK_TRANSACTION_FLAG_ENUM_ONLY_TRUSTED);
1318
1319 if (priv->allow_downgrade)
1320 pk_bitfield_add (state->transaction_flags,
1321 PK_TRANSACTION_FLAG_ENUM_ALLOW_DOWNGRADE);
1322 if (priv->allow_reinstall)
1323 pk_bitfield_add (state->transaction_flags,
1324 PK_TRANSACTION_FLAG_ENUM_ALLOW_REINSTALL);
1325 state->filters = filters;
1326 state->packages = g_strdupv (packages);
1327 state->request = pk_task_generate_request_id ();
1328
1329 gtask = g_task_new (task, cancellable, callback_ready, user_data);
1330 g_task_set_source_tag (gtask, pk_task_resolve_async);
1331 g_debug ("adding state %p", state);
1332 g_hash_table_insert (priv->gtasks, GUINT_TO_POINTER (state->request), g_object_ref (gtask));
1333 g_task_set_task_data (gtask, g_steal_pointer (&state), pk_task_state_free);
1334
1335 /* run task with callbacks */
1336 pk_task_do_async_action (g_steal_pointer (&gtask));
1337 }
1338
1339 /**
1340 * pk_task_search_names_async: (finish-func pk_task_generic_finish):
1341 * @task: a valid #PkTask instance
1342 * @filters: a bitfield of filters that can be used to limit the results
1343 * @values: (array zero-terminated=1): search values
1344 * @cancellable: a #GCancellable or %NULL
1345 * @progress_callback: (scope notified): the function to run when the progress changes
1346 * @progress_user_data: data to pass to @progress_callback
1347 * @callback_ready: the function to run on completion
1348 * @user_data: the data to pass to @callback
1349 *
1350 * Searches for a package name.
1351 *
1352 * Since: 0.6.5
1353 **/
1354 void
1355 pk_task_search_names_async (PkTask *task, PkBitfield filters, gchar **values, GCancellable *cancellable,
1356 PkProgressCallback progress_callback, gpointer progress_user_data,
1357 GAsyncReadyCallback callback_ready, gpointer user_data)
1358 {
1359 PkTaskPrivate *priv = GET_PRIVATE(task);
1360 PkTaskState *state;
1361 g_autoptr(GTask) gtask = NULL;
1362
1363 g_return_if_fail (PK_IS_TASK (task));
1364 g_return_if_fail (callback_ready != NULL);
1365 g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
1366
1367 /* save state */
1368 state = g_slice_new0 (PkTaskState);
1369 state->role = PK_ROLE_ENUM_SEARCH_NAME;
1370 state->progress_callback = progress_callback;
1371 state->progress_user_data = progress_user_data;
1372 state->transaction_flags = pk_bitfield_value (PK_TRANSACTION_FLAG_ENUM_ONLY_TRUSTED);
1373 state->filters = filters;
1374 state->values = g_strdupv (values);
1375 state->request = pk_task_generate_request_id ();
1376
1377 gtask = g_task_new (task, cancellable, callback_ready, user_data);
1378 g_task_set_source_tag (gtask, pk_task_search_names_async);
1379 g_debug ("adding state %p", state);
1380 g_hash_table_insert (priv->gtasks, GUINT_TO_POINTER (state->request), g_object_ref (gtask));
1381 g_task_set_task_data (gtask, g_steal_pointer (&state), pk_task_state_free);
1382
1383 /* run task with callbacks */
1384 pk_task_do_async_action (g_steal_pointer (&gtask));
1385 }
1386
1387 /**
1388 * pk_task_search_details_async: (finish-func pk_task_generic_finish):
1389 * @task: a valid #PkTask instance
1390 * @filters: a bitfield of filters that can be used to limit the results
1391 * @values: (array zero-terminated=1): search values
1392 * @cancellable: a #GCancellable or %NULL
1393 * @progress_callback: (scope notified): the function to run when the progress changes
1394 * @progress_user_data: data to pass to @progress_callback
1395 * @callback_ready: the function to run on completion
1396 * @user_data: the data to pass to @callback
1397 *
1398 * Searches for some package details.
1399 *
1400 * Since: 0.6.5
1401 **/
1402 void
1403 pk_task_search_details_async (PkTask *task, PkBitfield filters, gchar **values, GCancellable *cancellable,
1404 PkProgressCallback progress_callback, gpointer progress_user_data,
1405 GAsyncReadyCallback callback_ready, gpointer user_data)
1406 {
1407 PkTaskPrivate *priv = GET_PRIVATE(task);
1408 PkTaskState *state;
1409 g_autoptr(GTask) gtask = NULL;
1410
1411 g_return_if_fail (PK_IS_TASK (task));
1412 g_return_if_fail (callback_ready != NULL);
1413 g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
1414
1415 /* save state */
1416 state = g_slice_new0 (PkTaskState);
1417 state->role = PK_ROLE_ENUM_SEARCH_DETAILS;
1418 state->progress_callback = progress_callback;
1419 state->progress_user_data = progress_user_data;
1420 state->transaction_flags = pk_bitfield_value (PK_TRANSACTION_FLAG_ENUM_ONLY_TRUSTED);
1421 state->filters = filters;
1422 state->values = g_strdupv (values);
1423 state->request = pk_task_generate_request_id ();
1424
1425 gtask = g_task_new (task, cancellable, callback_ready, user_data);
1426 g_task_set_source_tag (gtask, pk_task_search_details_async);
1427 g_debug ("adding state %p", state);
1428 g_hash_table_insert (priv->gtasks, GUINT_TO_POINTER (state->request), g_object_ref (gtask));
1429 g_task_set_task_data (gtask, g_steal_pointer (&state), pk_task_state_free);
1430
1431 /* run task with callbacks */
1432 pk_task_do_async_action (g_steal_pointer (&gtask));
1433 }
1434
1435 /**
1436 * pk_task_search_groups_async: (finish-func pk_task_generic_finish):
1437 * @task: a valid #PkTask instance
1438 * @filters: a bitfield of filters that can be used to limit the results
1439 * @values: (array zero-terminated=1): search values
1440 * @cancellable: a #GCancellable or %NULL
1441 * @progress_callback: (scope notified): the function to run when the progress changes
1442 * @progress_user_data: data to pass to @progress_callback
1443 * @callback_ready: the function to run on completion
1444 * @user_data: the data to pass to @callback
1445 *
1446 * Searches the group lists.
1447 *
1448 * Since: 0.6.5
1449 **/
1450 void
1451 pk_task_search_groups_async (PkTask *task, PkBitfield filters, gchar **values, GCancellable *cancellable,
1452 PkProgressCallback progress_callback, gpointer progress_user_data,
1453 GAsyncReadyCallback callback_ready, gpointer user_data)
1454 {
1455 PkTaskPrivate *priv = GET_PRIVATE(task);
1456 PkTaskState *state;
1457 g_autoptr(GTask) gtask = NULL;
1458
1459 g_return_if_fail (PK_IS_TASK (task));
1460 g_return_if_fail (callback_ready != NULL);
1461 g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
1462
1463 /* save state */
1464 state = g_slice_new0 (PkTaskState);
1465 state->role = PK_ROLE_ENUM_SEARCH_GROUP;
1466 state->progress_callback = progress_callback;
1467 state->progress_user_data = progress_user_data;
1468 state->transaction_flags = pk_bitfield_value (PK_TRANSACTION_FLAG_ENUM_ONLY_TRUSTED);
1469 state->filters = filters;
1470 state->values = g_strdupv (values);
1471 state->request = pk_task_generate_request_id ();
1472
1473 gtask = g_task_new (task, cancellable, callback_ready, user_data);
1474 g_task_set_source_tag (gtask, pk_task_search_groups_async);
1475 g_debug ("adding state %p", state);
1476 g_hash_table_insert (priv->gtasks, GUINT_TO_POINTER (state->request), g_object_ref (gtask));
1477 g_task_set_task_data (gtask, g_steal_pointer (&state), pk_task_state_free);
1478
1479 /* run task with callbacks */
1480 pk_task_do_async_action (g_steal_pointer (&gtask));
1481 }
1482
1483 /**
1484 * pk_task_search_files_async: (finish-func pk_task_generic_finish):
1485 * @task: a valid #PkTask instance
1486 * @filters: a bitfield of filters that can be used to limit the results
1487 * @values: (array zero-terminated=1): search values
1488 * @cancellable: a #GCancellable or %NULL
1489 * @progress_callback: (scope notified): the function to run when the progress changes
1490 * @progress_user_data: data to pass to @progress_callback
1491 * @callback_ready: the function to run on completion
1492 * @user_data: the data to pass to @callback
1493 *
1494 * Searches for specific files.
1495 *
1496 * Since: 0.6.5
1497 **/
1498 void
1499 pk_task_search_files_async (PkTask *task, PkBitfield filters, gchar **values, GCancellable *cancellable,
1500 PkProgressCallback progress_callback, gpointer progress_user_data,
1501 GAsyncReadyCallback callback_ready, gpointer user_data)
1502 {
1503 PkTaskPrivate *priv = GET_PRIVATE(task);
1504 PkTaskState *state;
1505 g_autoptr(GTask) gtask = NULL;
1506
1507 g_return_if_fail (PK_IS_TASK (task));
1508 g_return_if_fail (callback_ready != NULL);
1509 g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
1510
1511 /* save state */
1512 state = g_slice_new0 (PkTaskState);
1513 state->role = PK_ROLE_ENUM_SEARCH_FILE;
1514 state->progress_callback = progress_callback;
1515 state->progress_user_data = progress_user_data;
1516 state->transaction_flags = pk_bitfield_value (PK_TRANSACTION_FLAG_ENUM_ONLY_TRUSTED);
1517 state->filters = filters;
1518 state->values = g_strdupv (values);
1519 state->request = pk_task_generate_request_id ();
1520
1521 gtask = g_task_new (task, cancellable, callback_ready, user_data);
1522 g_task_set_source_tag (gtask, pk_task_install_files_async);
1523 g_debug ("adding state %p", state);
1524 g_hash_table_insert (priv->gtasks, GUINT_TO_POINTER (state->request), g_object_ref (gtask));
1525 g_task_set_task_data (gtask, g_steal_pointer (&state), pk_task_state_free);
1526
1527 /* run task with callbacks */
1528 pk_task_do_async_action (g_steal_pointer (&gtask));
1529 }
1530
1531 /**
1532 * pk_task_get_details_async: (finish-func pk_task_generic_finish):
1533 * @task: a valid #PkTask instance
1534 * @package_ids: (array zero-terminated=1): a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora"
1535 * @cancellable: a #GCancellable or %NULL
1536 * @progress_callback: (scope notified): the function to run when the progress changes
1537 * @progress_user_data: data to pass to @progress_callback
1538 * @callback_ready: the function to run on completion
1539 * @user_data: the data to pass to @callback
1540 *
1541 * Gets details about packages.
1542 *
1543 * Since: 0.6.5
1544 **/
1545 void
1546 pk_task_get_details_async (PkTask *task, gchar **package_ids, GCancellable *cancellable,
1547 PkProgressCallback progress_callback, gpointer progress_user_data,
1548 GAsyncReadyCallback callback_ready, gpointer user_data)
1549 {
1550 PkTaskPrivate *priv = GET_PRIVATE(task);
1551 PkTaskState *state;
1552 g_autoptr(GTask) gtask = NULL;
1553
1554 g_return_if_fail (PK_IS_TASK (task));
1555 g_return_if_fail (callback_ready != NULL);
1556 g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
1557
1558 /* save state */
1559 state = g_slice_new0 (PkTaskState);
1560 state->role = PK_ROLE_ENUM_GET_DETAILS;
1561 state->progress_callback = progress_callback;
1562 state->progress_user_data = progress_user_data;
1563 state->transaction_flags = pk_bitfield_value (PK_TRANSACTION_FLAG_ENUM_ONLY_TRUSTED);
1564 state->package_ids = g_strdupv (package_ids);
1565 state->request = pk_task_generate_request_id ();
1566
1567 gtask = g_task_new (task, cancellable, callback_ready, user_data);
1568 g_task_set_source_tag (gtask, pk_task_get_details_async);
1569 g_debug ("adding state %p", state);
1570 g_hash_table_insert (priv->gtasks, GUINT_TO_POINTER (state->request), g_object_ref (gtask));
1571 g_task_set_task_data (gtask, g_steal_pointer (&state), pk_task_state_free);
1572
1573 /* run task with callbacks */
1574 pk_task_do_async_action (g_steal_pointer (&gtask));
1575 }
1576
1577 /**
1578 * pk_task_get_update_detail_async: (finish-func pk_task_generic_finish):
1579 * @task: a valid #PkTask instance
1580 * @package_ids: (array zero-terminated=1): a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora"
1581 * @cancellable: a #GCancellable or %NULL
1582 * @progress_callback: (scope notified): the function to run when the progress changes
1583 * @progress_user_data: data to pass to @progress_callback
1584 * @callback_ready: the function to run on completion
1585 * @user_data: the data to pass to @callback
1586 *
1587 * Gets details about updates.
1588 *
1589 * Since: 0.6.5
1590 **/
1591 void
1592 pk_task_get_update_detail_async (PkTask *task, gchar **package_ids, GCancellable *cancellable,
1593 PkProgressCallback progress_callback, gpointer progress_user_data,
1594 GAsyncReadyCallback callback_ready, gpointer user_data)
1595 {
1596 PkTaskPrivate *priv = GET_PRIVATE(task);
1597 PkTaskState *state;
1598 g_autoptr(GTask) gtask = NULL;
1599
1600 g_return_if_fail (PK_IS_TASK (task));
1601 g_return_if_fail (callback_ready != NULL);
1602 g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
1603
1604 /* save state */
1605 state = g_slice_new0 (PkTaskState);
1606 state->role = PK_ROLE_ENUM_GET_UPDATE_DETAIL;
1607 state->progress_callback = progress_callback;
1608 state->progress_user_data = progress_user_data;
1609 state->transaction_flags = pk_bitfield_value (PK_TRANSACTION_FLAG_ENUM_ONLY_TRUSTED);
1610 state->package_ids = g_strdupv (package_ids);
1611 state->request = pk_task_generate_request_id ();
1612
1613 gtask = g_task_new (task, cancellable, callback_ready, user_data);
1614 g_task_set_source_tag (gtask, pk_task_get_update_detail_async);
1615 g_debug ("adding state %p", state);
1616 g_hash_table_insert (priv->gtasks, GUINT_TO_POINTER (state->request), g_object_ref (gtask));
1617 g_task_set_task_data (gtask, g_steal_pointer (&state), pk_task_state_free);
1618
1619 /* run task with callbacks */
1620 pk_task_do_async_action (g_steal_pointer (&gtask));
1621 }
1622
1623 /**
1624 * pk_task_download_packages_async: (finish-func pk_task_generic_finish):
1625 * @task: a valid #PkTask instance
1626 * @package_ids: (array zero-terminated=1): a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora"
1627 * @directory: the destination directory
1628 * @cancellable: a #GCancellable or %NULL
1629 * @progress_callback: (scope notified): the function to run when the progress changes
1630 * @progress_user_data: data to pass to @progress_callback
1631 * @callback_ready: the function to run on completion
1632 * @user_data: the data to pass to @callback
1633 *
1634 * Downloads packages
1635 *
1636 * Since: 0.6.5
1637 **/
1638 void
1639 pk_task_download_packages_async (PkTask *task, gchar **package_ids, const gchar *directory, GCancellable *cancellable,
1640 PkProgressCallback progress_callback, gpointer progress_user_data,
1641 GAsyncReadyCallback callback_ready, gpointer user_data)
1642 {
1643 PkTaskPrivate *priv = GET_PRIVATE(task);
1644 PkTaskState *state;
1645 g_autoptr(GTask) gtask = NULL;
1646
1647 g_return_if_fail (PK_IS_TASK (task));
1648 g_return_if_fail (callback_ready != NULL);
1649 g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
1650
1651 /* save state */
1652 state = g_slice_new0 (PkTaskState);
1653 state->role = PK_ROLE_ENUM_DOWNLOAD_PACKAGES;
1654 state->progress_callback = progress_callback;
1655 state->progress_user_data = progress_user_data;
1656 state->transaction_flags = pk_bitfield_value (PK_TRANSACTION_FLAG_ENUM_ONLY_TRUSTED);
1657 state->package_ids = g_strdupv (package_ids);
1658 state->directory = g_strdup (directory);
1659 state->request = pk_task_generate_request_id ();
1660
1661 gtask = g_task_new (task, cancellable, callback_ready, user_data);
1662 g_task_set_source_tag (gtask, pk_task_download_packages_async);
1663 g_debug ("adding state %p", state);
1664 g_hash_table_insert (priv->gtasks, GUINT_TO_POINTER (state->request), g_object_ref (gtask));
1665 g_task_set_task_data (gtask, g_steal_pointer (&state), pk_task_state_free);
1666
1667 /* run task with callbacks */
1668 pk_task_do_async_action (g_steal_pointer (&gtask));
1669 }
1670
1671 /**
1672 * pk_task_get_updates_async: (finish-func pk_task_generic_finish):
1673 * @task: a valid #PkTask instance
1674 * @filters: a bitfield of filters that can be used to limit the results
1675 * @cancellable: a #GCancellable or %NULL
1676 * @progress_callback: (scope notified): the function to run when the progress changes
1677 * @progress_user_data: data to pass to @progress_callback
1678 * @callback_ready: the function to run on completion
1679 * @user_data: the data to pass to @callback
1680 *
1681 * Gets the update lists.
1682 *
1683 * Since: 0.6.5
1684 **/
1685 void
1686 pk_task_get_updates_async (PkTask *task, PkBitfield filters, GCancellable *cancellable,
1687 PkProgressCallback progress_callback, gpointer progress_user_data,
1688 GAsyncReadyCallback callback_ready, gpointer user_data)
1689 {
1690 PkTaskPrivate *priv = GET_PRIVATE(task);
1691 PkTaskState *state;
1692 g_autoptr(GTask) gtask = NULL;
1693
1694 g_return_if_fail (PK_IS_TASK (task));
1695 g_return_if_fail (callback_ready != NULL);
1696 g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
1697
1698 /* save state */
1699 state = g_slice_new0 (PkTaskState);
1700 state->role = PK_ROLE_ENUM_GET_UPDATES;
1701 state->progress_callback = progress_callback;
1702 state->progress_user_data = progress_user_data;
1703 state->transaction_flags = pk_bitfield_value (PK_TRANSACTION_FLAG_ENUM_ONLY_TRUSTED);
1704 state->filters = filters;
1705 state->request = pk_task_generate_request_id ();
1706
1707 gtask = g_task_new (task, cancellable, callback_ready, user_data);
1708 g_task_set_source_tag (gtask, pk_task_get_updates_async);
1709 g_debug ("adding state %p", state);
1710 g_hash_table_insert (priv->gtasks, GUINT_TO_POINTER (state->request), g_object_ref (gtask));
1711 g_task_set_task_data (gtask, g_steal_pointer (&state), pk_task_state_free);
1712
1713 /* run task with callbacks */
1714 pk_task_do_async_action (g_steal_pointer (&gtask));
1715 }
1716
1717 /**
1718 * pk_task_depends_on_async: (finish-func pk_task_generic_finish):
1719 * @task: a valid #PkTask instance
1720 * @filters: a bitfield of filters that can be used to limit the results
1721 * @package_ids: (array zero-terminated=1): a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora"
1722 * @recursive: if we should recurse to packages that depend on other packages
1723 * @cancellable: a #GCancellable or %NULL
1724 * @progress_callback: (scope notified): the function to run when the progress changes
1725 * @progress_user_data: data to pass to @progress_callback
1726 * @callback_ready: the function to run on completion
1727 * @user_data: the data to pass to @callback
1728 *
1729 * Get the list of dependent packages.
1730 *
1731 * Since: 0.6.5
1732 **/
1733 void
1734 pk_task_depends_on_async (PkTask *task, PkBitfield filters, gchar **package_ids, gboolean recursive, GCancellable *cancellable,
1735 PkProgressCallback progress_callback, gpointer progress_user_data,
1736 GAsyncReadyCallback callback_ready, gpointer user_data)
1737 {
1738 PkTaskPrivate *priv = GET_PRIVATE(task);
1739 PkTaskState *state;
1740 g_autoptr(GTask) gtask = NULL;
1741
1742 g_return_if_fail (PK_IS_TASK (task));
1743 g_return_if_fail (callback_ready != NULL);
1744 g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
1745
1746 /* save state */
1747 state = g_slice_new0 (PkTaskState);
1748 state->role = PK_ROLE_ENUM_DEPENDS_ON;
1749 state->progress_callback = progress_callback;
1750 state->progress_user_data = progress_user_data;
1751 state->transaction_flags = pk_bitfield_value (PK_TRANSACTION_FLAG_ENUM_ONLY_TRUSTED);
1752 state->filters = filters;
1753 state->package_ids = g_strdupv (package_ids);
1754 state->recursive = recursive;
1755 state->request = pk_task_generate_request_id ();
1756
1757 gtask = g_task_new (task, cancellable, callback_ready, user_data);
1758 g_task_set_source_tag (gtask, pk_task_depends_on_async);
1759 g_debug ("adding state %p", state);
1760 g_hash_table_insert (priv->gtasks, GUINT_TO_POINTER (state->request), g_object_ref (gtask));
1761 g_task_set_task_data (gtask, g_steal_pointer (&state), pk_task_state_free);
1762
1763 /* run task with callbacks */
1764 pk_task_do_async_action (g_steal_pointer (&gtask));
1765 }
1766
1767 /**
1768 * pk_task_get_packages_async: (finish-func pk_task_generic_finish):
1769 * @task: a valid #PkTask instance
1770 * @filters: a bitfield of filters that can be used to limit the results
1771 * @cancellable: a #GCancellable or %NULL
1772 * @progress_callback: (scope notified): the function to run when the progress changes
1773 * @progress_user_data: data to pass to @progress_callback
1774 * @callback_ready: the function to run on completion
1775 * @user_data: the data to pass to @callback
1776 *
1777 * Gets the list of packages.
1778 *
1779 * Since: 0.6.5
1780 **/
1781 void
1782 pk_task_get_packages_async (PkTask *task, PkBitfield filters, GCancellable *cancellable,
1783 PkProgressCallback progress_callback, gpointer progress_user_data,
1784 GAsyncReadyCallback callback_ready, gpointer user_data)
1785 {
1786 PkTaskPrivate *priv = GET_PRIVATE(task);
1787 PkTaskState *state;
1788 g_autoptr(GTask) gtask = NULL;
1789
1790 g_return_if_fail (PK_IS_TASK (task));
1791 g_return_if_fail (callback_ready != NULL);
1792 g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
1793
1794 /* save state */
1795 state = g_slice_new0 (PkTaskState);
1796 state->role = PK_ROLE_ENUM_GET_PACKAGES;
1797 state->progress_callback = progress_callback;
1798 state->progress_user_data = progress_user_data;
1799 state->transaction_flags = pk_bitfield_value (PK_TRANSACTION_FLAG_ENUM_ONLY_TRUSTED);
1800 state->filters = filters;
1801 state->request = pk_task_generate_request_id ();
1802
1803 gtask = g_task_new (task, cancellable, callback_ready, user_data);
1804 g_task_set_source_tag (gtask, pk_task_install_packages_async);
1805 g_debug ("adding state %p", state);
1806 g_hash_table_insert (priv->gtasks, GUINT_TO_POINTER (state->request), g_object_ref (gtask));
1807 g_task_set_task_data (gtask, g_steal_pointer (&state), pk_task_state_free);
1808
1809 /* run task with callbacks */
1810 pk_task_do_async_action (g_steal_pointer (&gtask));
1811 }
1812
1813 /**
1814 * pk_task_required_by_async: (finish-func pk_task_generic_finish):
1815 * @task: a valid #PkTask instance
1816 * @filters: a bitfield of filters that can be used to limit the results
1817 * @package_ids: (array zero-terminated=1): a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora"
1818 * @recursive: if we should return packages that depend on the ones we do
1819 * @cancellable: a #GCancellable or %NULL
1820 * @progress_callback: (scope notified): the function to run when the progress changes
1821 * @progress_user_data: data to pass to @progress_callback
1822 * @callback_ready: the function to run on completion
1823 * @user_data: the data to pass to @callback
1824 *
1825 * Get the packages this package requires.
1826 *
1827 * Since: 0.6.5
1828 **/
1829 void
1830 pk_task_required_by_async (PkTask *task, PkBitfield filters, gchar **package_ids, gboolean recursive, GCancellable *cancellable,
1831 PkProgressCallback progress_callback, gpointer progress_user_data,
1832 GAsyncReadyCallback callback_ready, gpointer user_data)
1833 {
1834 PkTaskPrivate *priv = GET_PRIVATE(task);
1835 PkTaskState *state;
1836 g_autoptr(GTask) gtask = NULL;
1837
1838 g_return_if_fail (PK_IS_TASK (task));
1839 g_return_if_fail (callback_ready != NULL);
1840 g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
1841
1842 /* save state */
1843 state = g_slice_new0 (PkTaskState);
1844 state->role = PK_ROLE_ENUM_REQUIRED_BY;
1845 state->progress_callback = progress_callback;
1846 state->progress_user_data = progress_user_data;
1847 state->transaction_flags = pk_bitfield_value (PK_TRANSACTION_FLAG_ENUM_ONLY_TRUSTED);
1848 state->filters = filters;
1849 state->package_ids = g_strdupv (package_ids);
1850 state->recursive = recursive;
1851 state->request = pk_task_generate_request_id ();
1852
1853 gtask = g_task_new (task, cancellable, callback_ready, user_data);
1854 g_task_set_source_tag (gtask, pk_task_install_packages_async);
1855 g_debug ("adding state %p", state);
1856 g_hash_table_insert (priv->gtasks, GUINT_TO_POINTER (state->request), g_object_ref (gtask));
1857 g_task_set_task_data (gtask, g_steal_pointer (&state), pk_task_state_free);
1858
1859 /* run task with callbacks */
1860 pk_task_do_async_action (g_steal_pointer (&gtask));
1861 }
1862
1863 /**
1864 * pk_task_what_provides_async: (finish-func pk_task_generic_finish):
1865 * @task: a valid #PkTask instance
1866 * @filters: a bitfield of filters that can be used to limit the results
1867 * @values: (array zero-terminated=1): values to search for
1868 * @cancellable: a #GCancellable or %NULL
1869 * @progress_callback: (scope notified): the function to run when the progress changes
1870 * @progress_user_data: data to pass to @progress_callback
1871 * @callback_ready: the function to run on completion
1872 * @user_data: the data to pass to @callback
1873 *
1874 * Find the package that provides some resource.
1875 *
1876 * Since: 0.6.5
1877 **/
1878 void
1879 pk_task_what_provides_async (PkTask *task, PkBitfield filters,
1880 gchar **values, GCancellable *cancellable,
1881 PkProgressCallback progress_callback, gpointer progress_user_data,
1882 GAsyncReadyCallback callback_ready, gpointer user_data)
1883 {
1884 PkTaskPrivate *priv = GET_PRIVATE(task);
1885 PkTaskState *state;
1886 g_autoptr(GTask) gtask = NULL;
1887
1888 g_return_if_fail (PK_IS_TASK (task));
1889 g_return_if_fail (callback_ready != NULL);
1890 g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
1891
1892 /* save state */
1893 state = g_slice_new0 (PkTaskState);
1894 state->role = PK_ROLE_ENUM_WHAT_PROVIDES;
1895 state->progress_callback = progress_callback;
1896 state->progress_user_data = progress_user_data;
1897 state->transaction_flags = pk_bitfield_value (PK_TRANSACTION_FLAG_ENUM_ONLY_TRUSTED);
1898 state->filters = filters;
1899 state->values = g_strdupv (values);
1900 state->request = pk_task_generate_request_id ();
1901
1902 gtask = g_task_new (task, cancellable, callback_ready, user_data);
1903 g_task_set_source_tag (gtask, pk_task_install_packages_async);
1904 g_debug ("adding state %p", state);
1905 g_hash_table_insert (priv->gtasks, GUINT_TO_POINTER (state->request), g_object_ref (gtask));
1906 g_task_set_task_data (gtask, g_steal_pointer (&state), pk_task_state_free);
1907
1908 /* run task with callbacks */
1909 pk_task_do_async_action (g_steal_pointer (&gtask));
1910 }
1911
1912 /**
1913 * pk_task_get_files_async: (finish-func pk_task_generic_finish):
1914 * @task: a valid #PkTask instance
1915 * @package_ids: (array zero-terminated=1): a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora"
1916 * @cancellable: a #GCancellable or %NULL
1917 * @progress_callback: (scope notified): the function to run when the progress changes
1918 * @progress_user_data: data to pass to @progress_callback
1919 * @callback_ready: the function to run on completion
1920 * @user_data: the data to pass to @callback
1921 *
1922 * Get the files in a package.
1923 *
1924 * Since: 0.6.5
1925 **/
1926 void
1927 pk_task_get_files_async (PkTask *task, gchar **package_ids, GCancellable *cancellable,
1928 PkProgressCallback progress_callback, gpointer progress_user_data,
1929 GAsyncReadyCallback callback_ready, gpointer user_data)
1930 {
1931 PkTaskPrivate *priv = GET_PRIVATE(task);
1932 PkTaskState *state;
1933 g_autoptr(GTask) gtask = NULL;
1934
1935 g_return_if_fail (PK_IS_TASK (task));
1936 g_return_if_fail (callback_ready != NULL);
1937 g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
1938
1939 /* save state */
1940 state = g_slice_new0 (PkTaskState);
1941 state->role = PK_ROLE_ENUM_GET_FILES;
1942 state->progress_callback = progress_callback;
1943 state->progress_user_data = progress_user_data;
1944 state->transaction_flags = pk_bitfield_value (PK_TRANSACTION_FLAG_ENUM_ONLY_TRUSTED);
1945 state->package_ids = g_strdupv (package_ids);
1946 state->request = pk_task_generate_request_id ();
1947
1948 gtask = g_task_new (task, cancellable, callback_ready, user_data);
1949 g_task_set_source_tag (gtask, pk_task_install_packages_async);
1950 g_debug ("adding state %p", state);
1951 g_hash_table_insert (priv->gtasks, GUINT_TO_POINTER (state->request), g_object_ref (gtask));
1952 g_task_set_task_data (gtask, g_steal_pointer (&state), pk_task_state_free);
1953
1954 /* run task with callbacks */
1955 pk_task_do_async_action (g_steal_pointer (&gtask));
1956 }
1957
1958 /**
1959 * pk_task_get_categories_async: (finish-func pk_task_generic_finish):
1960 * @task: a valid #PkTask instance
1961 * @cancellable: a #GCancellable or %NULL
1962 * @progress_callback: (scope notified): the function to run when the progress changes
1963 * @progress_user_data: data to pass to @progress_callback
1964 * @callback_ready: (scope async): the function to run on completion
1965 * @user_data: the data to pass to @callback
1966 *
1967 * Get the categories available.
1968 *
1969 * Since: 0.6.5
1970 **/
1971 void
1972 pk_task_get_categories_async (PkTask *task, GCancellable *cancellable,
1973 PkProgressCallback progress_callback, gpointer progress_user_data,
1974 GAsyncReadyCallback callback_ready, gpointer user_data)
1975 {
1976 PkTaskPrivate *priv = GET_PRIVATE(task);
1977 PkTaskState *state;
1978 g_autoptr(GTask) gtask = NULL;
1979
1980 g_return_if_fail (PK_IS_TASK (task));
1981 g_return_if_fail (callback_ready != NULL);
1982 g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
1983
1984 /* save state */
1985 state = g_slice_new0 (PkTaskState);
1986 state->role = PK_ROLE_ENUM_GET_CATEGORIES;
1987 state->progress_callback = progress_callback;
1988 state->progress_user_data = progress_user_data;
1989 state->transaction_flags = pk_bitfield_value (PK_TRANSACTION_FLAG_ENUM_ONLY_TRUSTED);
1990 state->request = pk_task_generate_request_id ();
1991
1992 gtask = g_task_new (task, cancellable, callback_ready, user_data);
1993 g_task_set_source_tag (gtask, pk_task_install_packages_async);
1994 g_debug ("adding state %p", state);
1995 g_hash_table_insert (priv->gtasks, GUINT_TO_POINTER (state->request), g_object_ref (gtask));
1996 g_task_set_task_data (gtask, g_steal_pointer (&state), pk_task_state_free);
1997
1998 /* run task with callbacks */
1999 pk_task_do_async_action (g_steal_pointer (&gtask));
2000 }
2001
2002 /**
2003 * pk_task_refresh_cache_async: (finish-func pk_task_generic_finish):
2004 * @task: a valid #PkTask instance
2005 * @force: if the metadata should be deleted and re-downloaded even if it is correct
2006 * @cancellable: a #GCancellable or %NULL
2007 * @progress_callback: (scope notified): the function to run when the progress changes
2008 * @progress_user_data: data to pass to @progress_callback
2009 * @callback_ready: the function to run on completion
2010 * @user_data: the data to pass to @callback
2011 *
2012 * Refresh the package cache.
2013 *
2014 * Since: 0.6.5
2015 **/
2016 void
2017 pk_task_refresh_cache_async (PkTask *task, gboolean force, GCancellable *cancellable,
2018 PkProgressCallback progress_callback, gpointer progress_user_data,
2019 GAsyncReadyCallback callback_ready, gpointer user_data)
2020 {
2021 PkTaskPrivate *priv = GET_PRIVATE(task);
2022 PkTaskState *state;
2023 g_autoptr(GTask) gtask = NULL;
2024
2025 g_return_if_fail (PK_IS_TASK (task));
2026 g_return_if_fail (callback_ready != NULL);
2027 g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
2028
2029 /* save state */
2030 state = g_slice_new0 (PkTaskState);
2031 state->role = PK_ROLE_ENUM_REFRESH_CACHE;
2032 state->progress_callback = progress_callback;
2033 state->progress_user_data = progress_user_data;
2034 state->transaction_flags = pk_bitfield_value (PK_TRANSACTION_FLAG_ENUM_ONLY_TRUSTED);
2035 state->force = force;
2036 state->request = pk_task_generate_request_id ();
2037
2038 gtask = g_task_new (task, cancellable, callback_ready, user_data);
2039 g_task_set_source_tag (gtask, pk_task_install_packages_async);
2040 g_debug ("adding state %p", state);
2041 g_hash_table_insert (priv->gtasks, GUINT_TO_POINTER (state->request), g_object_ref (gtask));
2042 g_task_set_task_data (gtask, g_steal_pointer (&state), pk_task_state_free);
2043
2044 /* run task with callbacks */
2045 pk_task_do_async_action (g_steal_pointer (&gtask));
2046 }
2047
2048 /**
2049 * pk_task_get_repo_list_async: (finish-func pk_task_generic_finish):
2050 * @task: a valid #PkTask instance
2051 * @filters: a bitfield of filters that can be used to limit the results
2052 * @cancellable: a #GCancellable or %NULL
2053 * @progress_callback: (scope notified): the function to run when the progress changes
2054 * @progress_user_data: data to pass to @progress_callback
2055 * @callback_ready: the function to run on completion
2056 * @user_data: the data to pass to @callback
2057 *
2058 * Get the list of available repositories.
2059 *
2060 * Since: 0.6.5
2061 **/
2062 void
2063 pk_task_get_repo_list_async (PkTask *task, PkBitfield filters, GCancellable *cancellable,
2064 PkProgressCallback progress_callback, gpointer progress_user_data,
2065 GAsyncReadyCallback callback_ready, gpointer user_data)
2066 {
2067 PkTaskPrivate *priv = GET_PRIVATE(task);
2068 PkTaskState *state;
2069 g_autoptr(GTask) gtask = NULL;
2070
2071 g_return_if_fail (PK_IS_TASK (task));
2072 g_return_if_fail (callback_ready != NULL);
2073 g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
2074
2075 /* save state */
2076 state = g_slice_new0 (PkTaskState);
2077 state->role = PK_ROLE_ENUM_GET_REPO_LIST;
2078 state->progress_callback = progress_callback;
2079 state->progress_user_data = progress_user_data;
2080 state->transaction_flags = pk_bitfield_value (PK_TRANSACTION_FLAG_ENUM_ONLY_TRUSTED);
2081 state->filters = filters;
2082 state->request = pk_task_generate_request_id ();
2083
2084 gtask = g_task_new (task, cancellable, callback_ready, user_data);
2085 g_task_set_source_tag (gtask, pk_task_install_packages_async);
2086 g_debug ("adding state %p", state);
2087 g_hash_table_insert (priv->gtasks, GUINT_TO_POINTER (state->request), g_object_ref (gtask));
2088 g_task_set_task_data (gtask, g_steal_pointer (&state), pk_task_state_free);
2089
2090 /* run task with callbacks */
2091 pk_task_do_async_action (g_steal_pointer (&gtask));
2092 }
2093
2094 /**
2095 * pk_task_repo_enable_async: (finish-func pk_task_generic_finish):
2096 * @task: a valid #PkTask instance
2097 * @repo_id: The software repository ID
2098 * @enabled: %TRUE or %FALSE
2099 * @cancellable: a #GCancellable or %NULL
2100 * @progress_callback: (scope notified): the function to run when the progress changes
2101 * @progress_user_data: data to pass to @progress_callback
2102 * @callback_ready: the function to run on completion
2103 * @user_data: the data to pass to @callback
2104 *
2105 * Enable or disable a specific repo.
2106 *
2107 * Since: 0.6.5
2108 **/
2109 void
2110 pk_task_repo_enable_async (PkTask *task, const gchar *repo_id, gboolean enabled, GCancellable *cancellable,
2111 PkProgressCallback progress_callback, gpointer progress_user_data,
2112 GAsyncReadyCallback callback_ready, gpointer user_data)
2113 {
2114 PkTaskPrivate *priv = GET_PRIVATE(task);
2115 PkTaskState *state;
2116 g_autoptr(GTask) gtask = NULL;
2117
2118 g_return_if_fail (PK_IS_TASK (task));
2119 g_return_if_fail (callback_ready != NULL);
2120 g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
2121
2122 /* save state */
2123 state = g_slice_new0 (PkTaskState);
2124 state->role = PK_ROLE_ENUM_REPO_ENABLE;
2125 state->progress_callback = progress_callback;
2126 state->progress_user_data = progress_user_data;
2127 state->transaction_flags = pk_bitfield_value (PK_TRANSACTION_FLAG_ENUM_ONLY_TRUSTED);
2128 state->repo_id = g_strdup (repo_id);
2129 state->enabled = enabled;
2130 state->request = pk_task_generate_request_id ();
2131
2132 gtask = g_task_new (task, cancellable, callback_ready, user_data);
2133 g_task_set_source_tag (gtask, pk_task_install_packages_async);
2134 g_debug ("adding state %p", state);
2135 g_hash_table_insert (priv->gtasks, GUINT_TO_POINTER (state->request), g_object_ref (gtask));
2136 g_task_set_task_data (gtask, g_steal_pointer (&state), pk_task_state_free);
2137
2138 /* run task with callbacks */
2139 pk_task_do_async_action (g_steal_pointer (&gtask));
2140 }
2141
2142 /**
2143 * pk_task_repair_system_async: (finish-func pk_task_generic_finish):
2144 * @task: a valid #PkTask instance
2145 * @cancellable: a #GCancellable or %NULL
2146 * @progress_callback: (scope notified): the function to run when the progress changes
2147 * @progress_user_data: data to pass to @progress_callback
2148 * @callback_ready: the function to run on completion
2149 * @user_data: the data to pass to @callback_ready
2150 *
2151 * Recover the system from broken dependencies and aborted installations.
2152 *
2153 * Since: 0.7.2
2154 **/
2155 void
2156 pk_task_repair_system_async (PkTask *task,
2157 GCancellable *cancellable,
2158 PkProgressCallback progress_callback,
2159 gpointer progress_user_data,
2160 GAsyncReadyCallback callback_ready,
2161 gpointer user_data)
2162 {
2163 PkTaskPrivate *priv = GET_PRIVATE(task);
2164 PkTaskState *state;
2165 PkTaskClass *klass = PK_TASK_GET_CLASS (task);
2166 g_autoptr(GTask) gtask = NULL;
2167
2168 g_return_if_fail (PK_IS_CLIENT (task));
2169 g_return_if_fail (callback_ready != NULL);
2170 g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
2171
2172 /* save state */
2173 state = g_slice_new0 (PkTaskState);
2174 state->role = PK_ROLE_ENUM_REPAIR_SYSTEM;
2175 state->transaction_flags = pk_bitfield_value (PK_TRANSACTION_FLAG_ENUM_ONLY_TRUSTED);
2176 state->progress_callback = progress_callback;
2177 state->progress_user_data = progress_user_data;
2178 state->request = pk_task_generate_request_id ();
2179
2180 gtask = g_task_new (task, cancellable, callback_ready, user_data);
2181 g_task_set_source_tag (gtask, pk_task_repair_system_async);
2182 g_debug ("adding state %p", state);
2183 g_hash_table_insert (priv->gtasks, GUINT_TO_POINTER (state->request), g_object_ref (gtask));
2184 g_task_set_task_data (gtask, g_steal_pointer (&state), pk_task_state_free);
2185
2186
2187 /* start trusted repair system async */
2188 if (priv->simulate && klass->simulate_question != NULL)
2189 pk_task_do_async_simulate_action (g_steal_pointer (&gtask));
2190 else
2191 pk_task_do_async_action (g_steal_pointer (&gtask));
2192 }
2193
2194 /**
2195 * pk_task_generic_finish:
2196 * @task: a valid #PkTask instance
2197 * @res: the #GAsyncResult
2198 * @error: A #GError or %NULL
2199 *
2200 * Gets the result from the asynchronous function.
2201 *
2202 * Return value: (transfer full): The #PkResults of the transaction.
2203 *
2204 * Since: 0.5.2
2205 **/
2206 PkResults *
2207 pk_task_generic_finish (PkTask *task, GAsyncResult *res, GError **error)
2208 {
2209 PkTaskPrivate *priv = GET_PRIVATE(task);
2210 GTask *gtask;
2211 PkTaskState *state;
2212
2213 g_return_val_if_fail (PK_IS_TASK (task), NULL);
2214 g_return_val_if_fail (g_task_is_valid (res, task), NULL);
2215 g_return_val_if_fail (error == NULL || *error == NULL, NULL);
2216
2217 gtask = G_TASK (res);
2218 state = g_task_get_task_data (gtask);
2219 /* remove from table */
2220 g_debug ("remove state %p", state);
2221 g_hash_table_remove (priv->gtasks, GUINT_TO_POINTER (state->request));
2222
2223 return g_task_propagate_pointer (gtask, error);
2224 }
2225
2226 /**
2227 * pk_task_set_simulate:
2228 * @task: a valid #PkTask instance
2229 * @simulate: the simulate mode
2230 *
2231 * If the simulate step should be run without the actual transaction.
2232 *
2233 * Since: 0.6.10
2234 **/
2235 void
2236 pk_task_set_simulate (PkTask *task, gboolean simulate)
2237 {
2238 PkTaskPrivate *priv = GET_PRIVATE(task);
2239
2240 g_return_if_fail (PK_IS_TASK (task));
2241
2242 if (priv->simulate == simulate)
2243 return;
2244
2245 priv->simulate = simulate;
2246 g_object_notify_by_pspec (G_OBJECT(task), obj_properties[PROP_SIMULATE]);
2247 }
2248
2249 /**
2250 * pk_task_get_simulate:
2251 * @task: a valid #PkTask instance
2252 *
2253 * Gets if we are simulating.
2254 *
2255 * Return value: %TRUE if we are simulating
2256 *
2257 * Since: 0.6.10
2258 **/
2259 gboolean
2260 pk_task_get_simulate (PkTask *task)
2261 {
2262 PkTaskPrivate *priv = GET_PRIVATE(task);
2263
2264 g_return_val_if_fail (PK_IS_TASK (task), FALSE);
2265
2266 return priv->simulate;
2267 }
2268
2269 /**
2270 * pk_task_set_only_download:
2271 * @task: a valid #PkTask instance
2272 * @only_download: %FALSE to actually commit the transaction
2273 *
2274 * If the transaction should be prepared (depsolved, packages
2275 * downloaded, etc) but not committed.
2276 *
2277 * Since: 0.8.1
2278 **/
2279 void
2280 pk_task_set_only_download (PkTask *task, gboolean only_download)
2281 {
2282 PkTaskPrivate *priv = GET_PRIVATE(task);
2283
2284 g_return_if_fail (PK_IS_TASK (task));
2285
2286 if (priv->only_download == only_download)
2287 return;
2288
2289 priv->only_download = only_download;
2290 g_object_notify_by_pspec (G_OBJECT(task), obj_properties[PROP_ONLY_DOWNLOAD]);
2291 }
2292
2293 /**
2294 * pk_task_get_only_download:
2295 * @task: a valid #PkTask instance
2296 *
2297 * Gets if we are just preparing the transaction for later.
2298 *
2299 * Return value: %TRUE if only downloading
2300 *
2301 * Since: 0.8.1
2302 **/
2303 gboolean
2304 pk_task_get_only_download (PkTask *task)
2305 {
2306 PkTaskPrivate *priv = GET_PRIVATE(task);
2307
2308 g_return_val_if_fail (PK_IS_TASK (task), FALSE);
2309
2310 return priv->only_download;
2311 }
2312
2313
2314 /**
2315 * pk_task_set_only_trusted:
2316 * @task: a valid #PkTask instance
2317 * @only_trusted: %TRUE to allow only authenticated packages
2318 *
2319 * If only authenticated packages should be allowed in the
2320 * transaction.
2321 *
2322 * Since: 0.9.5
2323 **/
2324 void
2325 pk_task_set_only_trusted (PkTask *task, gboolean only_trusted)
2326 {
2327 PkTaskPrivate *priv = GET_PRIVATE(task);
2328
2329 g_return_if_fail (PK_IS_TASK (task));
2330
2331 if (priv->only_trusted == only_trusted)
2332 return;
2333
2334 priv->only_trusted = only_trusted;
2335 g_object_notify_by_pspec (G_OBJECT(task), obj_properties[PROP_ONLY_TRUSTED]);
2336 }
2337
2338 /**
2339 * pk_task_get_only_trusted:
2340 * @task: a valid #PkTask instance
2341 *
2342 * Gets if we allow only authenticated packages in the transaction.
2343 *
2344 * Return value: %TRUE if we allow only authenticated packages
2345 *
2346 * Since: 0.9.5
2347 **/
2348 gboolean
2349 pk_task_get_only_trusted (PkTask *task)
2350 {
2351 PkTaskPrivate *priv = GET_PRIVATE(task);
2352
2353 g_return_val_if_fail (PK_IS_TASK (task), FALSE);
2354
2355 return priv->only_trusted;
2356 }
2357
2358 /**
2359 * pk_task_set_allow_downgrade:
2360 * @task: a valid #PkTask instance
2361 * @allow_downgrade: %TRUE to allow packages to be downgraded.
2362 *
2363 * If package downgrades shall be allowed during transaction.
2364 *
2365 * Since: 1.0.2
2366 **/
2367 void
2368 pk_task_set_allow_downgrade (PkTask *task, gboolean allow_downgrade)
2369 {
2370 PkTaskPrivate *priv = GET_PRIVATE(task);
2371
2372 g_return_if_fail (PK_IS_TASK (task));
2373
2374 if (priv->allow_downgrade == allow_downgrade)
2375 return;
2376
2377 priv->allow_downgrade = allow_downgrade;
2378 g_object_notify_by_pspec (G_OBJECT(task), obj_properties[PROP_ALLOW_DOWNGRADE]);
2379 }
2380
2381 /**
2382 * pk_task_get_allow_downgrade:
2383 * @task: a valid #PkTask instance
2384 *
2385 * Gets if we are allow packages to be downgraded.
2386 *
2387 * Return value: %TRUE if package downgrades are allowed
2388 *
2389 * Since: 1.0.2
2390 **/
2391 gboolean
2392 pk_task_get_allow_downgrade (PkTask *task)
2393 {
2394 PkTaskPrivate *priv = GET_PRIVATE(task);
2395
2396 g_return_val_if_fail (PK_IS_TASK (task), FALSE);
2397
2398 return priv->allow_downgrade;
2399 }
2400
2401 /**
2402 * pk_task_set_allow_reinstall:
2403 * @task: a valid #PkTask instance
2404 * @allow_reinstall: %TRUE to allow packages to be reinstalled.
2405 *
2406 * If package reinstallation shall be allowed during transaction.
2407 *
2408 * Since: 1.0.2
2409 **/
2410 void
2411 pk_task_set_allow_reinstall (PkTask *task, gboolean allow_reinstall)
2412 {
2413 PkTaskPrivate *priv = GET_PRIVATE(task);
2414
2415 g_return_if_fail (PK_IS_TASK (task));
2416
2417 if (priv->allow_reinstall == allow_reinstall)
2418 return;
2419
2420 priv->allow_reinstall = allow_reinstall;
2421 g_object_notify_by_pspec (G_OBJECT (task), obj_properties[PROP_ALLOW_REINSTALL]);
2422 }
2423
2424 /**
2425 * pk_task_get_allow_reinstall:
2426 * @task: a valid #PkTask instance
2427 *
2428 * Gets if we allow packages to be reinstalled.
2429 *
2430 * Return value: %TRUE if package reinstallation is allowed
2431 *
2432 * Since: 1.0.2
2433 **/
2434 gboolean
2435 pk_task_get_allow_reinstall (PkTask *task)
2436 {
2437 PkTaskPrivate *priv = GET_PRIVATE(task);
2438
2439 g_return_val_if_fail (PK_IS_TASK (task), FALSE);
2440
2441 return priv->allow_reinstall;
2442 }
2443
2444 /*
2445 * pk_task_get_property:
2446 **/
2447 static void
2448 pk_task_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
2449 {
2450 PkTask *task = PK_TASK (object);
2451 PkTaskPrivate *priv = GET_PRIVATE(task);
2452
2453 switch (prop_id) {
2454 case PROP_SIMULATE:
2455 g_value_set_boolean (value, priv->simulate);
2456 break;
2457 case PROP_ONLY_DOWNLOAD:
2458 g_value_set_boolean (value, priv->only_download);
2459 break;
2460 case PROP_ONLY_TRUSTED:
2461 g_value_set_boolean (value, priv->only_trusted);
2462 break;
2463 case PROP_ALLOW_REINSTALL:
2464 g_value_set_boolean (value, priv->allow_reinstall);
2465 break;
2466 case PROP_ALLOW_DOWNGRADE:
2467 g_value_set_boolean (value, priv->allow_downgrade);
2468 break;
2469 default:
2470 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
2471 break;
2472 }
2473 }
2474
2475 /*
2476 * pk_task_set_property:
2477 **/
2478 static void
2479 pk_task_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
2480 {
2481 PkTask *task = PK_TASK (object);
2482 PkTaskPrivate *priv = GET_PRIVATE(task);
2483
2484 switch (prop_id) {
2485 case PROP_SIMULATE:
2486 priv->simulate = g_value_get_boolean (value);
2487 break;
2488 case PROP_ONLY_DOWNLOAD:
2489 priv->only_download = g_value_get_boolean (value);
2490 break;
2491 case PROP_ONLY_TRUSTED:
2492 priv->only_trusted = g_value_get_boolean (value);
2493 break;
2494 case PROP_ALLOW_REINSTALL:
2495 priv->allow_reinstall = g_value_get_boolean (value);
2496 break;
2497 case PROP_ALLOW_DOWNGRADE:
2498 priv->allow_downgrade = g_value_get_boolean (value);
2499 break;
2500 default:
2501 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
2502 break;
2503 }
2504 }
2505
2506 /*
2507 * pk_task_class_init:
2508 **/
2509 static void
2510 pk_task_class_init (PkTaskClass *klass)
2511 {
2512 GObjectClass *object_class = G_OBJECT_CLASS (klass);
2513 object_class->finalize = pk_task_finalize;
2514 object_class->get_property = pk_task_get_property;
2515 object_class->set_property = pk_task_set_property;
2516
2517 /**
2518 * PkTask:simulate:
2519 *
2520 * %TRUE if we are simulating.
2521 *
2522 * Since: 0.5.2
2523 */
2524 obj_properties[PROP_SIMULATE] =
2525 g_param_spec_boolean ("simulate", NULL, NULL,
2526 TRUE,
2527 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
2528
2529 /**
2530 * PkTask:only-download:
2531 *
2532 * %TRUE if we are just preparing the transaction for later.
2533 *
2534 * Since: 0.8.1
2535 */
2536 obj_properties[PROP_ONLY_DOWNLOAD] =
2537 g_param_spec_boolean ("only-download", NULL, NULL,
2538 FALSE,
2539 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
2540
2541 /**
2542 * PkTask:only-trusted:
2543 *
2544 * %TRUE if only authenticated packages should be allowed in the transaction.
2545 *
2546 * Since: 0.9.5
2547 */
2548 obj_properties[PROP_ONLY_TRUSTED] =
2549 g_param_spec_boolean ("only-trusted", NULL, NULL,
2550 TRUE,
2551 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
2552
2553 /**
2554 * PkTask:allow-reinstall:
2555 *
2556 * %TRUE if package reinstallation shall be allowed during transaction.
2557 *
2558 * Since: 1.0.2
2559 */
2560 obj_properties[PROP_ALLOW_REINSTALL] =
2561 g_param_spec_boolean ("allow-reinstall", NULL, NULL,
2562 FALSE,
2563 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
2564
2565 /**
2566 * PkTask:allow-downgrade:
2567 *
2568 * %TRUE if package downgrades are allowed.
2569 *
2570 * Since: 1.0.2
2571 */
2572 obj_properties[PROP_ALLOW_DOWNGRADE] =
2573 g_param_spec_boolean ("allow-downgrade", NULL, NULL,
2574 FALSE,
2575 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
2576
2577 g_object_class_install_properties (object_class, PROP_LAST, obj_properties);
2578 }
2579
2580 /*
2581 * pk_task_init:
2582 **/
2583 static void
2584 pk_task_init (PkTask *task)
2585 {
2586 PkTaskPrivate *priv = GET_PRIVATE(task);
2587
2588 task->priv = priv;
2589 priv->gtasks = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, g_object_unref);
2590 priv->simulate = TRUE;
2591 priv->allow_reinstall = FALSE;
2592 priv->allow_downgrade = FALSE;
2593 }
2594
2595 /*
2596 * pk_task_finalize:
2597 **/
2598 static void
2599 pk_task_finalize (GObject *object)
2600 {
2601 PkTask *task = PK_TASK (object);
2602 PkTaskPrivate *priv = GET_PRIVATE(task);
2603
2604 g_clear_pointer (&priv->gtasks, g_hash_table_unref);
2605
2606 G_OBJECT_CLASS (pk_task_parent_class)->finalize (object);
2607 }
2608
2609 /**
2610 * pk_task_new:
2611 *
2612 * Return value: a new #PkTask object.
2613 *
2614 * Since: 0.5.2
2615 **/
2616 PkTask *
2617 pk_task_new (void)
2618 {
2619 PkTask *task;
2620 task = g_object_new (PK_TYPE_TASK, NULL);
2621 return PK_TASK (task);
2622 }