/** * dnf_get_filter_for_ids: */ PkBitfield dnf_get_filter_for_ids (gchar **package_ids) { gboolean available = FALSE; gboolean installed = FALSE; guint i; PkBitfield filters = 0; for (i = 0; package_ids[i] != NULL && (!installed || !available); i++) { g_auto(GStrv) split = pk_package_id_split (package_ids[i]); if (g_strcmp0 (split[PK_PACKAGE_ID_DATA], "installed") == 0) installed = TRUE; else available = TRUE; } /* a mixture */ if (installed && available) return pk_bitfield_value (PK_FILTER_ENUM_NONE); /* we can restrict what's loaded into the sack */ if (!installed) filters = pk_bitfield_value (PK_FILTER_ENUM_NOT_INSTALLED); if (!available) filters = pk_bitfield_value (PK_FILTER_ENUM_INSTALLED); return filters; }
/** * gs_plugin_refresh: */ gboolean gs_plugin_refresh (GsPlugin *plugin, guint cache_age, GsPluginRefreshFlags flags, GCancellable *cancellable, GError **error) { PkBitfield filter; PkBitfield transaction_flags; ProgressData data; g_auto(GStrv) package_ids = NULL; g_autoptr(PkPackageSack) sack = NULL; g_autoptr(PkResults) results2 = NULL; g_autoptr(PkResults) results = NULL; /* not us */ if ((flags & GS_PLUGIN_REFRESH_FLAGS_UPDATES) == 0) return TRUE; /* cache age of 0 is user-initiated */ pk_client_set_background (PK_CLIENT (plugin->priv->task), cache_age > 0); data.plugin = plugin; data.ptask = NULL; /* update UI as this might take some time */ gs_plugin_status_update (plugin, NULL, GS_PLUGIN_STATUS_WAITING); /* do sync call */ filter = pk_bitfield_value (PK_FILTER_ENUM_NONE); pk_client_set_cache_age (PK_CLIENT (plugin->priv->task), cache_age); results = pk_client_get_updates (PK_CLIENT (plugin->priv->task), filter, cancellable, gs_plugin_packagekit_progress_cb, &data, error); if (results == NULL) return FALSE; /* download all the updates */ sack = pk_results_get_package_sack (results); if (pk_package_sack_get_size (sack) == 0) return TRUE; package_ids = pk_package_sack_get_ids (sack); transaction_flags = pk_bitfield_value (PK_TRANSACTION_FLAG_ENUM_ONLY_DOWNLOAD); results2 = pk_client_update_packages (PK_CLIENT (plugin->priv->task), transaction_flags, package_ids, cancellable, gs_plugin_packagekit_progress_cb, &data, error); return results2 != NULL; }
/** * pk_filter_bitfield_from_text: * @filters: the enumerated constant value, e.g. "available;~gui" * * Converts text representation to its enumerated type bitfield, or 0 for invalid * * Return value: The enumerated type values **/ PkBitfield pk_filter_bitfield_from_text (const gchar *filters) { PkBitfield filters_enum = 0; gchar **split; guint length; guint i; PkFilterEnum filter; split = g_strsplit (filters, ";", 0); if (split == NULL) { egg_warning ("unable to split"); goto out; } length = g_strv_length (split); for (i=0; i<length; i++) { filter = pk_filter_enum_from_text (split[i]); if (filter == PK_FILTER_ENUM_UNKNOWN) { filters_enum = 0; break; } filters_enum += pk_bitfield_value (filter); } out: g_strfreev (split); return filters_enum; }
/** * pk_group_bitfield_from_text: * @groups: the enumerated constant value, e.g. "available;~gui" * * Converts text representation to its enumerated type bitfield * * Return value: The enumerated type values, or 0 for invalid **/ PkBitfield pk_group_bitfield_from_text (const gchar *groups) { PkBitfield groups_enum = 0; gchar **split; guint length; guint i; PkGroupEnum group; split = g_strsplit (groups, ";", 0); if (split == NULL) { egg_warning ("unable to split"); goto out; } length = g_strv_length (split); for (i=0; i<length; i++) { group = pk_group_enum_from_text (split[i]); if (group == PK_GROUP_ENUM_UNKNOWN) { groups_enum = 0; break; } groups_enum += pk_bitfield_value (group); } out: g_strfreev (split); return groups_enum; }
/** * pk_package_sack_resolve_async: * @sack: a valid #PkPackageSack instance * @cancellable: a #GCancellable or %NULL * @progress_callback: (scope call): the function to run when the progress changes * @progress_user_data: data to pass to @progress_callback * @callback: the function to run on completion * @user_data: the data to pass to @callback * * Merges in details about packages using resolve. * * Since: 0.5.2 **/ void pk_package_sack_resolve_async (PkPackageSack *sack, GCancellable *cancellable, PkProgressCallback progress_callback, gpointer progress_user_data, GAsyncReadyCallback callback, gpointer user_data) { GSimpleAsyncResult *res; PkPackageSackState *state; gchar **package_ids; g_return_if_fail (PK_IS_PACKAGE_SACK (sack)); g_return_if_fail (callback != NULL); res = g_simple_async_result_new (G_OBJECT (sack), callback, user_data, pk_package_sack_resolve_async); /* save state */ state = g_slice_new0 (PkPackageSackState); state->res = g_object_ref (res); state->sack = g_object_ref (sack); if (cancellable != NULL) { state->cancellable = g_object_ref (cancellable); } state->ret = FALSE; /* start resolve async */ package_ids = pk_package_sack_get_package_ids (sack); pk_client_resolve_async (sack->priv->client, pk_bitfield_value (PK_FILTER_ENUM_INSTALLED), package_ids, cancellable, progress_callback, progress_user_data, (GAsyncReadyCallback) pk_package_sack_resolve_cb, state); g_strfreev (package_ids); g_object_unref (res); }
/** * pk_role_bitfield_from_text: * @roles: the enumerated constant value, e.g. "available;~gui" * * Converts text representation to its enumerated type bitfield * * Return value: The enumerated type values, or 0 for invalid **/ PkBitfield pk_role_bitfield_from_text (const gchar *roles) { PkBitfield roles_enum = 0; gchar **split; guint length; guint i; PkRoleEnum role; split = g_strsplit (roles, ";", 0); if (split == NULL) { egg_warning ("unable to split"); goto out; } length = g_strv_length (split); for (i=0; i<length; i++) { role = pk_role_enum_from_text (split[i]); if (role == PK_ROLE_ENUM_UNKNOWN) { roles_enum = 0; break; } roles_enum += pk_bitfield_value (role); } out: g_strfreev (split); return roles_enum; }
/** * pk_transaction_flag_bitfield_to_string: * @transaction_flags: The enumerated type values * * Converts a enumerated type bitfield to its text representation * * Return value: the enumerated constant value, e.g. "only-trusted;simulate" * * Since: 0.8.1 **/ gchar * pk_transaction_flag_bitfield_to_string (PkBitfield transaction_flags) { GString *string; guint i; /* shortcut */ if (transaction_flags == 0) return g_strdup (pk_transaction_flag_enum_to_string (PK_TRANSACTION_FLAG_ENUM_NONE)); string = g_string_new (""); for (i = 0; i < PK_TRANSACTION_FLAG_ENUM_LAST; i++) { if ((transaction_flags & pk_bitfield_value (i)) == 0) continue; g_string_append_printf (string, "%s;", pk_transaction_flag_enum_to_string (i)); } /* do we have a 'none' transaction_flag? \n */ if (string->len == 0) { g_warning ("not valid!"); g_string_append (string, pk_transaction_flag_enum_to_string (PK_TRANSACTION_FLAG_ENUM_NONE)); } else { /* remove last \n */ g_string_set_size (string, string->len - 1); } return g_string_free (string, FALSE); }
/** * pk_filter_bitfield_to_string: * @filters: The enumerated type values * * Converts a enumerated type bitfield to its text representation * * Return value: the enumerated constant value, e.g. "available;~gui" * * Since: 0.5.2 **/ gchar * pk_filter_bitfield_to_string (PkBitfield filters) { GString *string; guint i; /* shortcut */ if (filters == 0) return g_strdup (pk_filter_enum_to_string (PK_FILTER_ENUM_NONE)); string = g_string_new (""); for (i = 0; i < PK_FILTER_ENUM_LAST; i++) { if ((filters & pk_bitfield_value (i)) == 0) continue; g_string_append_printf (string, "%s;", pk_filter_enum_to_string (i)); } /* do we have a 'none' filter? \n */ if (string->len == 0) { g_warning ("not valid!"); g_string_append (string, pk_filter_enum_to_string (PK_FILTER_ENUM_NONE)); } else { /* remove last \n */ g_string_set_size (string, string->len - 1); } return g_string_free (string, FALSE); }
/** * pk_plugin_get_installed_package_for_file: **/ static PkPackage * pk_plugin_get_installed_package_for_file (PkPlugin *plugin, const gchar *filename, GError **error) { PkPackage *package = NULL; gchar **filenames; /* use PK to find the correct package */ if (plugin->priv->list->len > 0) g_ptr_array_set_size (plugin->priv->list, 0); pk_backend_reset_job (plugin->backend, plugin->job); pk_backend_job_set_vfunc (plugin->job, PK_BACKEND_SIGNAL_FINISHED, (PkBackendJobVFunc) pk_plugin_finished_cb, plugin); pk_backend_job_set_vfunc (plugin->job, PK_BACKEND_SIGNAL_PACKAGE, (PkBackendJobVFunc) pk_plugin_package_cb, plugin); filenames = g_strsplit (filename, "|||", -1); pk_backend_search_files (plugin->backend, plugin->job, pk_bitfield_value (PK_FILTER_ENUM_INSTALLED), filenames); g_strfreev (filenames); /* wait for finished */ g_main_loop_run (plugin->priv->loop); /* check that we only matched one package */ if (plugin->priv->list->len == 0) { g_set_error_literal (error, 1, 0, "no packages own this file"); goto out; } if (plugin->priv->list->len > 1) { g_set_error (error, 1, 0, "%i packages own this file", plugin->priv->list->len); goto out; } /* get the package */ package = g_ptr_array_index (plugin->priv->list, 0); if (package == NULL) { g_set_error_literal (error, 1, 0, "package invalid"); goto out; } out: return package; }
/** * pk_bitfield_from_enums: * @value: the first value we want to add to the bitfield * @...: other values to add, terminated by -1 * * Create a bitfield with the suppied values set. * * Return value: a #PkBitfield, or 0 if invalid * * Since: 0.5.2 **/ PkBitfield pk_bitfield_from_enums (gint value, ...) { va_list args; guint i; gint value_temp; PkBitfield values; /* we must query at least one thing */ values = pk_bitfield_value (value); /* process the valist */ va_start (args, value); for (i = 0;; i++) { value_temp = va_arg (args, gint); if (value_temp == -1) break; values += pk_bitfield_value (value_temp); } va_end (args); return values; }
void zypp_emit_packages_in_list (PkBackend *backend, std::vector<zypp::sat::Solvable> *v, PkBitfield filters) { for (std::vector<zypp::sat::Solvable>::iterator it = v->begin (); it != v->end (); it++) { gchar *package_id = zypp_build_package_id_from_resolvable (*it); // iterate through the given filters if (filters != 0){ gboolean print = TRUE; for (guint i = 0; i < PK_FILTER_ENUM_LAST; i++) { if ((filters & pk_bitfield_value (i)) == 0) continue; if (i == PK_FILTER_ENUM_INSTALLED && !(it->isSystem ())) print = FALSE; if (i == PK_FILTER_ENUM_NOT_INSTALLED && it->isSystem ()) print = FALSE;; if (i == PK_FILTER_ENUM_ARCH) { if (it->arch () != zypp::ZConfig::defaultSystemArchitecture () && it->arch () != zypp::Arch_noarch && ! system_and_package_are_x86 (*it)) print = FALSE; } if (i == PK_FILTER_ENUM_NOT_ARCH) { if (it->arch () == zypp::ZConfig::defaultSystemArchitecture () || system_and_package_are_x86 (*it)) print = FALSE; } if (i == PK_FILTER_ENUM_SOURCE && !(zypp::isKind<zypp::SrcPackage>(*it))) { print = FALSE; } if (i == PK_FILTER_ENUM_NOT_SOURCE && zypp::isKind<zypp::SrcPackage>(*it)) { print = FALSE; } //const gchar * myarch = zypp::ZConfig::defaultSystemArchitecture().asString().c_str(); //egg_debug ("my default arch is %s", myarch); } if (!print) continue; } pk_backend_package (backend, it->isSystem() == true ? PK_INFO_ENUM_INSTALLED : PK_INFO_ENUM_AVAILABLE, package_id, it->lookupStrAttribute (zypp::sat::SolvAttr::summary).c_str ()); g_free (package_id); } }
/** * pk_debuginfo_install_get_repo_list: **/ static gboolean pk_debuginfo_install_get_repo_list (PkDebuginfoInstallPrivate *priv, GError **error) { gboolean ret = FALSE; PkResults *results = NULL; guint i; GPtrArray *array; GError *error_local = NULL; PkRepoDetail *item; PkError *error_code = NULL; gboolean enabled; gchar *repo_id; /* get all repo details */ results = pk_client_get_repo_list (priv->client, pk_bitfield_value (PK_FILTER_ENUM_NONE), NULL, NULL, NULL, &error_local); if (results == NULL) { *error = g_error_new (1, 0, "failed to get repo list: %s", error_local->message); g_error_free (error_local); goto out; } /* check error code */ error_code = pk_results_get_error_code (results); if (error_code != NULL) { *error = g_error_new (1, 0, "failed to get repo list: %s, %s", pk_error_enum_to_string (pk_error_get_code (error_code)), pk_error_get_details (error_code)); goto out; } /* get results */ array = pk_results_get_repo_detail_array (results); for (i=0; i<array->len; i++) { item = g_ptr_array_index (array, i); g_object_get (item, "enabled", &enabled, "repo-id", &repo_id, NULL); if (enabled) g_ptr_array_add (priv->enabled, repo_id); else g_ptr_array_add (priv->disabled, repo_id); } ret = TRUE; out: if (error_code != NULL) g_object_unref (error_code); if (results != NULL) g_object_unref (results); return ret; }
/** * pk_transaction_flag_bitfield_from_string: * @transaction_flags: the enumerated constant value, e.g. "only-trusted;simulate" * * Converts text representation to its enumerated type bitfield, or 0 for invalid * * Return value: The enumerated type values * * Since: 0.8.1 **/ PkBitfield pk_transaction_flag_bitfield_from_string (const gchar *transaction_flags) { PkBitfield transaction_flags_enum = 0; guint length; guint i; PkFilterEnum transaction_flag; g_auto(GStrv) split = NULL; split = g_strsplit (transaction_flags, ";", 0); if (split == NULL) { g_warning ("unable to split"); return 0; } length = g_strv_length (split); for (i = 0; i < length; i++) { transaction_flag = pk_transaction_flag_enum_from_string (split[i]); transaction_flags_enum += pk_bitfield_value (transaction_flag); } return transaction_flags_enum; }
/** * pk_group_bitfield_to_string: * @groups: The enumerated type values * * Converts a enumerated type bitfield to its text representation * * Return value: the enumerated constant value, e.g. "gnome;kde" * * Since: 0.5.2 **/ gchar * pk_group_bitfield_to_string (PkBitfield groups) { GString *string; guint i; string = g_string_new (""); for (i = 0; i < PK_GROUP_ENUM_LAST; i++) { if ((groups & pk_bitfield_value (i)) == 0) continue; g_string_append_printf (string, "%s;", pk_group_enum_to_string (i)); } /* do we have a no bitfield? \n */ if (string->len == 0) { g_warning ("not valid!"); g_string_append (string, pk_group_enum_to_string (PK_GROUP_ENUM_UNKNOWN)); } else { /* remove last \n */ g_string_set_size (string, string->len - 1); } return g_string_free (string, FALSE); }
/** * pk_role_bitfield_from_string: * @roles: the enumerated constant value, e.g. "search-file;update-system" * * Converts text representation to its enumerated type bitfield * * Return value: The enumerated type values, or 0 for invalid * * Since: 0.5.2 **/ PkBitfield pk_role_bitfield_from_string (const gchar *roles) { PkBitfield roles_enum = 0; guint length; guint i; PkRoleEnum role; g_auto(GStrv) split = NULL; split = g_strsplit (roles, ";", 0); if (split == NULL) { g_warning ("unable to split"); return 0; } length = g_strv_length (split); for (i = 0; i < length; i++) { role = pk_role_enum_from_string (split[i]); if (role != PK_ROLE_ENUM_UNKNOWN) roles_enum += pk_bitfield_value (role); } return roles_enum; }
/** * pk_filter_bitfield_from_string: * @filters: the enumerated constant value, e.g. "available;~gui" * * Converts text representation to its enumerated type bitfield, or 0 for invalid * * Return value: The enumerated type values * * Since: 0.5.2 **/ PkBitfield pk_filter_bitfield_from_string (const gchar *filters) { PkBitfield filters_enum = 0; guint length; guint i; PkFilterEnum filter; g_auto(GStrv) split = NULL; split = g_strsplit (filters, ";", 0); if (split == NULL) { g_warning ("unable to split"); return 0; } length = g_strv_length (split); for (i = 0; i < length; i++) { filter = pk_filter_enum_from_string (split[i]); if (filter != PK_FILTER_ENUM_UNKNOWN) filters_enum += pk_bitfield_value (filter); } return filters_enum; }
/** * pk_group_bitfield_from_string: * @groups: the enumerated constant value, e.g. "available;~gui" * * Converts text representation to its enumerated type bitfield * * Return value: The enumerated type values, or 0 for invalid * * Since: 0.5.2 **/ PkBitfield pk_group_bitfield_from_string (const gchar *groups) { PkBitfield groups_enum = 0; guint length; guint i; PkGroupEnum group; g_auto(GStrv) split = NULL; split = g_strsplit (groups, ";", 0); if (split == NULL) { g_warning ("unable to split"); return 0; } length = g_strv_length (split); for (i = 0; i < length; i++) { group = pk_group_enum_from_string (split[i]); if (group != PK_GROUP_ENUM_UNKNOWN) groups_enum += pk_bitfield_value (group); } return groups_enum; }
void pk_bitfield_test (gpointer user_data) { EggTest *test = (EggTest *) user_data; gchar *text; PkBitfield filter; gint value; PkBitfield values; if (!egg_test_start (test, "PkBitfield")) return; /************************************************************/ egg_test_title (test, "check we can convert filter bitfield to text (none)"); text = pk_filter_bitfield_to_text (pk_bitfield_value (PK_FILTER_ENUM_NONE)); if (g_strcmp0 (text, "none") == 0) egg_test_success (test, NULL); else egg_test_failed (test, "text was %s", text); g_free (text); /************************************************************/ egg_test_title (test, "check we can invert a bit 1 -> 0"); values = pk_bitfield_value (PK_FILTER_ENUM_NOT_DEVELOPMENT) | pk_bitfield_value (PK_FILTER_ENUM_NOT_NEWEST); pk_bitfield_invert (values, PK_FILTER_ENUM_NOT_DEVELOPMENT); if (values == pk_bitfield_value (PK_FILTER_ENUM_NOT_NEWEST)) egg_test_success (test, NULL); else egg_test_failed (test, "values were %" PK_BITFIELD_FORMAT, values); /************************************************************/ egg_test_title (test, "check we can invert a bit 0 -> 1"); values = 0; pk_bitfield_invert (values, PK_FILTER_ENUM_NOT_DEVELOPMENT); if (values == pk_bitfield_value (PK_FILTER_ENUM_NOT_DEVELOPMENT)) egg_test_success (test, NULL); else egg_test_failed (test, "values were %" PK_BITFIELD_FORMAT, values); /************************************************************/ egg_test_title (test, "check we can convert filter bitfield to text (single)"); text = pk_filter_bitfield_to_text (pk_bitfield_value (PK_FILTER_ENUM_NOT_DEVELOPMENT)); if (g_strcmp0 (text, "~devel") == 0) egg_test_success (test, NULL); else egg_test_failed (test, "text was %s", text); g_free (text); /************************************************************/ egg_test_title (test, "check we can convert filter bitfield to text (plural)"); text = pk_filter_bitfield_to_text (pk_bitfield_value (PK_FILTER_ENUM_NOT_DEVELOPMENT) | pk_bitfield_value (PK_FILTER_ENUM_GUI) | pk_bitfield_value (PK_FILTER_ENUM_NEWEST)); if (g_strcmp0 (text, "~devel;gui;newest") == 0) egg_test_success (test, NULL); else egg_test_failed (test, "text was %s", text); g_free (text); /************************************************************/ egg_test_title (test, "check we can convert filter text to bitfield (none)"); filter = pk_filter_bitfield_from_text ("none"); if (filter == pk_bitfield_value (PK_FILTER_ENUM_NONE)) egg_test_success (test, NULL); else egg_test_failed (test, "filter was %" PK_BITFIELD_FORMAT, filter); /************************************************************/ egg_test_title (test, "check we can convert filter text to bitfield (single)"); filter = pk_filter_bitfield_from_text ("~devel"); if (filter == pk_bitfield_value (PK_FILTER_ENUM_NOT_DEVELOPMENT)) egg_test_success (test, NULL); else egg_test_failed (test, "filter was %" PK_BITFIELD_FORMAT, filter); /************************************************************/ egg_test_title (test, "check we can convert filter text to bitfield (plural)"); filter = pk_filter_bitfield_from_text ("~devel;gui;newest"); if (filter == (pk_bitfield_value (PK_FILTER_ENUM_NOT_DEVELOPMENT) | pk_bitfield_value (PK_FILTER_ENUM_GUI) | pk_bitfield_value (PK_FILTER_ENUM_NEWEST))) egg_test_success (test, NULL); else egg_test_failed (test, "filter was %" PK_BITFIELD_FORMAT, filter); /************************************************************/ egg_test_title (test, "check we can add / remove bitfield"); filter = pk_bitfield_value (PK_FILTER_ENUM_NOT_DEVELOPMENT) | pk_bitfield_value (PK_FILTER_ENUM_GUI) | pk_bitfield_value (PK_FILTER_ENUM_NEWEST); pk_bitfield_add (filter, PK_FILTER_ENUM_NOT_FREE); pk_bitfield_remove (filter, PK_FILTER_ENUM_NOT_DEVELOPMENT); text = pk_filter_bitfield_to_text (filter); if (g_strcmp0 (text, "gui;~free;newest") == 0) egg_test_success (test, NULL); else egg_test_failed (test, "text was %s", text); g_free (text); /************************************************************/ egg_test_title (test, "check we can test enum presence"); filter = pk_bitfield_value (PK_FILTER_ENUM_NOT_DEVELOPMENT) | pk_bitfield_value (PK_FILTER_ENUM_GUI) | pk_bitfield_value (PK_FILTER_ENUM_NEWEST); if (pk_bitfield_contain (filter, PK_FILTER_ENUM_NOT_DEVELOPMENT)) egg_test_success (test, NULL); else egg_test_failed (test, "wrong boolean"); /************************************************************/ egg_test_title (test, "check we can test enum false-presence"); if (!pk_bitfield_contain (filter, PK_FILTER_ENUM_FREE)) egg_test_success (test, NULL); else egg_test_failed (test, "wrong boolean"); /************************************************************/ egg_test_title (test, "check we can add / remove bitfield to nothing"); filter = pk_bitfield_value (PK_FILTER_ENUM_NOT_DEVELOPMENT); pk_bitfield_remove (filter, PK_FILTER_ENUM_NOT_DEVELOPMENT); text = pk_filter_bitfield_to_text (filter); if (g_strcmp0 (text, "none") == 0) egg_test_success (test, NULL); else egg_test_failed (test, "text was %s", text); g_free (text); /************************************************************/ egg_test_title (test, "role bitfield from enums (unknown)"); values = pk_bitfield_from_enums (PK_ROLE_ENUM_UNKNOWN, -1); if (values == pk_bitfield_value (PK_ROLE_ENUM_UNKNOWN)) egg_test_success (test, NULL); else egg_test_failed (test, "returned bitfield %" PK_BITFIELD_FORMAT, values); /************************************************************/ egg_test_title (test, "role bitfield from enums (random)"); values = pk_bitfield_from_enums (PK_ROLE_ENUM_SEARCH_GROUP, PK_ROLE_ENUM_SEARCH_DETAILS, -1); if (values == (pk_bitfield_value (PK_ROLE_ENUM_SEARCH_DETAILS) | pk_bitfield_value (PK_ROLE_ENUM_SEARCH_GROUP))) egg_test_success (test, NULL); else egg_test_failed (test, "returned bitfield %" PK_BITFIELD_FORMAT, values); /************************************************************/ egg_test_title (test, "group bitfield from enums (unknown)"); values = pk_bitfield_from_enums (PK_GROUP_ENUM_UNKNOWN, -1); if (values == pk_bitfield_value (PK_GROUP_ENUM_UNKNOWN)) egg_test_success (test, NULL); else egg_test_failed (test, "returned bitfield %" PK_BITFIELD_FORMAT, values); /************************************************************/ egg_test_title (test, "group bitfield from enums (random)"); values = pk_bitfield_from_enums (PK_GROUP_ENUM_ACCESSIBILITY, -1); if (values == (pk_bitfield_value (PK_GROUP_ENUM_ACCESSIBILITY))) egg_test_success (test, NULL); else egg_test_failed (test, "returned bitfield %" PK_BITFIELD_FORMAT, values); /************************************************************/ egg_test_title (test, "group bitfield to text (unknown)"); values = pk_bitfield_from_enums (PK_GROUP_ENUM_UNKNOWN, -1); text = pk_group_bitfield_to_text (values); if (g_strcmp0 (text, "unknown") == 0) egg_test_success (test, NULL); else egg_test_failed (test, "returned bitfield text %s (%" PK_BITFIELD_FORMAT ")", text, values); g_free (text); /************************************************************/ egg_test_title (test, "group bitfield to text (first and last)"); values = pk_bitfield_from_enums (PK_GROUP_ENUM_ACCESSIBILITY, PK_GROUP_ENUM_UNKNOWN, -1); text = pk_group_bitfield_to_text (values); if (g_strcmp0 (text, "unknown;accessibility") == 0) egg_test_success (test, NULL); else egg_test_failed (test, "returned bitfield text %s (%" PK_BITFIELD_FORMAT ")", text, values); g_free (text); /************************************************************/ egg_test_title (test, "group bitfield to text (random)"); values = pk_bitfield_from_enums (PK_GROUP_ENUM_UNKNOWN, PK_GROUP_ENUM_REPOS, -1); text = pk_group_bitfield_to_text (values); if (g_strcmp0 (text, "unknown;repos") == 0) egg_test_success (test, NULL); else egg_test_failed (test, "returned bitfield text %s (%" PK_BITFIELD_FORMAT ")", text, values); g_free (text); /************************************************************/ egg_test_title (test, "priority check missing"); values = pk_bitfield_value (PK_ROLE_ENUM_SEARCH_DETAILS) | pk_bitfield_value (PK_ROLE_ENUM_SEARCH_GROUP); value = pk_bitfield_contain_priority (values, PK_ROLE_ENUM_SEARCH_FILE, -1); if (value == -1) egg_test_success (test, NULL); else egg_test_failed (test, "returned priority %i when should be missing", value); /************************************************************/ egg_test_title (test, "priority check first"); value = pk_bitfield_contain_priority (values, PK_ROLE_ENUM_SEARCH_GROUP, -1); if (value == PK_ROLE_ENUM_SEARCH_GROUP) egg_test_success (test, NULL); else egg_test_failed (test, "returned wrong value; %i", value); /************************************************************/ egg_test_title (test, "priority check second, correct"); value = pk_bitfield_contain_priority (values, PK_ROLE_ENUM_SEARCH_FILE, PK_ROLE_ENUM_SEARCH_GROUP, -1); if (value == PK_ROLE_ENUM_SEARCH_GROUP) egg_test_success (test, NULL); else egg_test_failed (test, "returned wrong value; %i", value); egg_test_end (test); }
/** * main: **/ int main (int argc, char *argv[]) { GError *error = NULL; GOptionContext *context; gchar *options_help; gboolean ret; gchar *filename = NULL; PkClient *client = NULL; PkControl *control = NULL; PkBitfield roles; gchar *tempdir = NULL; gboolean exists; gboolean overwrite; gchar **excludes = NULL; gchar *package_id = NULL; PkServicePack *pack = NULL; gchar *directory = NULL; gchar *package_list = NULL; gchar *package = NULL; gboolean updates = FALSE; gint retval = 1; const GOptionEntry options[] = { { "with-package-list", 'l', 0, G_OPTION_ARG_STRING, &package_list, /* TRANSLATORS: we can exclude certain packages (glibc) when we know they'll exist on the target */ _("Set the file name of dependencies to be excluded"), NULL}, { "output", 'o', 0, G_OPTION_ARG_STRING, &directory, /* TRANSLATORS: the output location */ _("The output file or directory (the current directory is used if omitted)"), NULL}, { "package", 'p', 0, G_OPTION_ARG_STRING, &package, /* TRANSLATORS: put a list of packages in the pack */ _("The package to be put into the service pack"), NULL}, { "updates", 'u', 0, G_OPTION_ARG_NONE, &updates, /* TRANSLATORS: put all pending updates in the pack */ _("Put all updates available in the service pack"), NULL}, { NULL} }; setlocale (LC_ALL, ""); bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); #if (GLIB_MAJOR_VERSION == 2 && GLIB_MINOR_VERSION < 31) if (! g_thread_supported ()) g_thread_init (NULL); #endif g_type_init (); /* do stuff on ctrl-c */ signal (SIGINT, pk_generate_pack_sigint_cb); context = g_option_context_new ("PackageKit Pack Generator"); g_option_context_add_main_entries (context, options, NULL); g_option_context_add_group (context, pk_debug_get_option_group ()); g_option_context_parse (context, &argc, &argv, NULL); /* Save the usage string in case command parsing fails. */ options_help = g_option_context_get_help (context, TRUE, NULL); g_option_context_free (context); client = pk_client_new (); pack = pk_service_pack_new (); cancellable = g_cancellable_new (); progressbar = pk_progress_bar_new (); pk_progress_bar_set_size (progressbar, 25); pk_progress_bar_set_padding (progressbar, 20); /* neither options selected */ if (package == NULL && !updates) { /* TRANSLATORS: This is when the user fails to supply the correct arguments */ g_print ("%s\n", _("Neither --package or --updates option selected.")); retval = 1; goto out; } /* both options selected */ if (package != NULL && updates) { /* TRANSLATORS: This is when the user fails to supply just one argument */ g_print ("%s\n", _("Both options selected.")); retval = 1; goto out; } /* no argument given to --package */ if (package != NULL && package[0] == '\0') { /* TRANSLATORS: This is when the user fails to supply the package name */ g_print ("%s\n", _("A package name is required")); retval = 1; goto out; } /* no argument given to --output */ if (directory != NULL && directory[0] == '\0') { /* TRANSLATORS: This is when the user fails to supply the output */ g_print ("%s\n", _("A output directory or file name is required")); retval = 1; goto out; } /* fall back to the system copy */ if (package_list == NULL) package_list = g_strdup (PK_SYSTEM_PACKAGE_LIST_FILENAME); /* fall back to CWD */ if (directory == NULL) directory = g_get_current_dir (); /* are we dumb and can't do some actions */ control = pk_control_new (); ret = pk_control_get_properties (control, NULL, &error); if (!ret) { /* TRANSLATORS: This is when the daemon is not-installed/broken and fails to startup */ g_print ("%s: %s\n", _("The daemon failed to startup"), error->message); goto out; } /* get data */ g_object_get (control, "roles", &roles, NULL); if (!pk_bitfield_contain (roles, PK_ROLE_ENUM_GET_DEPENDS)) { /* TRANSLATORS: This is when the backend doesn't have the capability to get-depends */ g_print ("%s (GetDepends)\n", _("The package manager cannot perform this type of operation.")); retval = 1; goto out; } if (!pk_bitfield_contain (roles, PK_ROLE_ENUM_DOWNLOAD_PACKAGES)) { /* TRANSLATORS: This is when the backend doesn't have the capability to download */ g_print ("%s (DownloadPackage)\n", _("The package manager cannot perform this type of operation.")); retval = 1; goto out; } #ifndef HAVE_ARCHIVE_H /* TRANSLATORS: This is when the distro didn't include libarchive support into PK */ g_print ("%s\n", _("Service packs cannot be created as PackageKit was not built with libarchive support.")); goto out; #endif /* the user can speciify a complete path */ ret = g_file_test (directory, G_FILE_TEST_IS_DIR); if (ret) { filename = pk_generate_pack_get_filename (package, directory); } else { if (!g_str_has_suffix (directory, PK_SERVICE_PACK_FILE_EXTENSION)) { /* TRANSLATORS: the user specified an absolute path, but didn't get the extension correct */ g_print ("%s .%s \n", _("If specifying a file, the service pack name must end with"), PK_SERVICE_PACK_FILE_EXTENSION); retval = 1; goto out; } filename = g_strdup (directory); } /* download packages to a temporary directory */ tempdir = g_build_filename (g_get_tmp_dir (), "pack", NULL); /* check if file exists before we overwrite it */ exists = g_file_test (filename, G_FILE_TEST_EXISTS); /*ask user input*/ if (exists) { /* TRANSLATORS: This is when file already exists */ overwrite = pk_console_get_prompt (_("A pack with the same name already exists, do you want to overwrite it?"), FALSE); if (!overwrite) { /* TRANSLATORS: This is when the pack was not overwritten */ g_print ("%s\n", _("The pack was not overwritten.")); retval = 1; goto out; } } /* get rid of temp directory if it already exists */ g_rmdir (tempdir); /* make the temporary directory */ retval = g_mkdir_with_parents (tempdir, 0777); if (retval != 0) { /* TRANSLATORS: This is when the temporary directory cannot be created, the directory name follows */ g_print ("%s '%s'\n", _("Failed to create directory:"), tempdir); retval = 1; goto out; } pk_service_pack_set_temp_directory (pack, tempdir); /* get the exclude list */ excludes = NULL; #if 0 ret = pk_obj_list_from_file (PK_OBJ_LIST(list), package_list); if (!ret) { /* TRANSLATORS: This is when the list of packages from the remote computer cannot be opened */ g_print ("%s: '%s'\n", _("Failed to open package list."), package_list); retval = 1; goto out; } #endif /* resolve package name to package_id */ if (!updates) { /* TRANSLATORS: The package name is being matched up to available packages */ g_print ("%s\n", _("Finding package name.")); package_id = pk_console_resolve_package (client, pk_bitfield_value (PK_FILTER_ENUM_NONE), package, &error); if (package_id == NULL) { /* TRANSLATORS: This is when the package cannot be found in any software source. The detailed error follows */ g_print (_("Failed to find package '%s': %s"), package, error->message); g_error_free (error); retval = 1; goto out; } } /* TRANSLATORS: This is telling the user we are in the process of making the pack */ g_print ("%s\n", _("Creating service pack...")); if (updates) ret = pk_generate_pack_create_for_updates (pack, filename, excludes, &error); else { gchar **package_ids; package_ids = pk_package_ids_from_id (package_id); ret = pk_generate_pack_create_for_package_ids (pack, filename, package_ids, excludes, &error); g_strfreev (package_ids); } /* no more progress */ pk_progress_bar_end (progressbar); if (ret) { /* TRANSLATORS: we succeeded in making the file */ g_print (_("Service pack created '%s'"), filename); g_print ("\n"); retval = 0; } else { /* TRANSLATORS: we failed to make te file */ g_print (_("Failed to create '%s': %s"), filename, error->message); g_print ("\n"); g_error_free (error); } out: /* get rid of temp directory */ g_rmdir (tempdir); g_object_unref (cancellable); if (progressbar != NULL) g_object_unref (progressbar); if (pack != NULL) g_object_unref (pack); if (client != NULL) g_object_unref (client); if (control != NULL) g_object_unref (control); g_free (tempdir); g_free (filename); g_free (package_id); g_free (directory); g_free (package_list); g_free (options_help); g_strfreev (excludes); return retval; }
/** * pk_debuginfo_install_add_deps: **/ static gboolean pk_debuginfo_install_add_deps (PkDebuginfoInstallPrivate *priv, GPtrArray *packages_search, GPtrArray *packages_results, GError **error) { gboolean ret = TRUE; PkResults *results = NULL; PkPackage *item; gchar *package_id = NULL; GPtrArray *list = NULL; GError *error_local = NULL; gchar **package_ids = NULL; gchar *name_debuginfo; guint i; gchar **split; PkError *error_code = NULL; /* get depends for them all, not adding dup's */ package_ids = pk_ptr_array_to_strv (packages_search); results = pk_client_get_depends (priv->client, pk_bitfield_value (PK_FILTER_ENUM_NONE), package_ids, TRUE, NULL, NULL, NULL, &error_local); if (results == NULL) { *error = g_error_new (1, 0, "failed to get_depends: %s", error_local->message); g_error_free (error_local); ret = FALSE; goto out; } /* check error code */ error_code = pk_results_get_error_code (results); if (error_code != NULL) { *error = g_error_new (1, 0, "failed to get depends: %s, %s", pk_error_enum_to_string (pk_error_get_code (error_code)), pk_error_get_details (error_code)); ret = FALSE; goto out; } /* add dependent packages */ list = pk_results_get_package_array (results); for (i=0; i<list->len; i++) { item = g_ptr_array_index (list, i); split = pk_package_id_split (pk_package_get_id (item)); /* add -debuginfo */ name_debuginfo = pk_debuginfo_install_name_to_debuginfo (split[PK_PACKAGE_ID_NAME]); g_strfreev (split); /* resolve name */ g_debug ("resolving: %s", name_debuginfo); package_id = pk_debuginfo_install_resolve_name_to_id (priv, name_debuginfo, &error_local); if (package_id == NULL) { /* TRANSLATORS: we couldn't find the package name, non-fatal */ g_print (_("Failed to find the package %s, or already installed: %s"), name_debuginfo, error_local->message); g_print ("\n"); g_error_free (error_local); /* don't quit, this is non-fatal */ error = NULL; } /* add to array to install */ if (package_id != NULL && !g_str_has_suffix (package_id, "installed")) { g_debug ("going to try to install (for deps): %s", package_id); g_ptr_array_add (packages_results, g_strdup (package_id)); } g_free (package_id); g_free (name_debuginfo); } out: if (error_code != NULL) g_object_unref (error_code); if (results != NULL) g_object_unref (results); if (list != NULL) g_ptr_array_unref (list); g_strfreev (package_ids); return ret; }