emo/xbps
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Make xbps_fetch_file accept a callback to update its progress.

Browse Source 
This also makes xbps_unpack_binary_pkg follow this convention by avoiding
static variables.

--HG--
branch : progress_callback
rename : bin/xbps-repo/util.c => bin/xbps-bin/util.c
This commit is contained in:
Juan RP
2011-01-22 12:40:19 +01:00
parent 8c2ccea435
commit 984eae1578
22 changed files with 354 additions and 365 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
bin/xbps-bin/Makefile
View File

@@ -3,8 +3,8 @@ TOPDIR = ../..
BIN = xbps-bin
OBJS = check.o install.o main.o remove.o show-deps.o
OBJS += show-info-files.o ../xbps-repo/util.o find-files.o
OBJS += question.o
OBJS += show-info-files.o util.o find-files.o
OBJS += question.o fetch.o
MAN = $(BIN).8
include $(TOPDIR)/prog.mk

17
bin/xbps-bin/defs.h
View File

@@ -30,6 +30,8 @@
#define __UNCONST(a) ((void *)(unsigned long)(const void *)(a))
#endif
#include <xbps_api.h>
int xbps_install_new_pkg(const char *);
int xbps_update_pkg(const char *);
int xbps_autoupdate_pkgs(bool);
@@ -43,7 +45,22 @@ int xbps_show_pkg_reverse_deps(const char *);
int show_pkg_info_from_metadir(const char *);
int show_pkg_files_from_metadir(const char *);
int find_files_in_packages(const char *);
/* from question.c */
bool xbps_yesno(const char *, ...);
bool xbps_noyes(const char *, ...);
/* from fetch.c */
void fetch_file_progress_cb(void *);
/* From util.c */
int show_pkg_files(prop_dictionary_t);
void show_pkg_info(prop_dictionary_t);
void show_pkg_info_only_repo(prop_dictionary_t);
int show_pkg_namedesc(prop_object_t, void *, bool *);
int list_strings_in_array(prop_object_t, void *, bool *);
int list_strings_sep_in_array(prop_object_t, void *, bool *);
size_t find_longest_pkgver(prop_dictionary_t);
void print_package_line(const char *);
#endif /* !_XBPS_BIN_DEFS_H_ */

27
bin/xbps-bin/install.c
View File

@@ -100,6 +100,7 @@ static int
download_package_list(prop_object_iterator_t iter)
{
prop_object_t obj;
struct xbps_fetch_progress_data xfpd;
const char *pkgver, *repoloc, *filename, *cachedir, *sha256;
char *binfile;
int rv = 0;
@@ -145,7 +146,8 @@ again:
return errno;
}
printf("Downloading %s binary package ...\n", pkgver);
rv = xbps_fetch_file(binfile, cachedir, false, NULL);
rv = xbps_fetch_file(binfile, cachedir, false, NULL,
fetch_file_progress_cb, &xfpd);
if (rv == -1) {
fprintf(stderr, "xbps-bin: couldn't download `%s'\n",
filename);
@@ -426,7 +428,7 @@ replace_packages(prop_dictionary_t trans_dict, prop_dictionary_t pkgd,
static void
unpack_progress_cb_verbose(void *data)
{
struct xbps_progress_data *xpd = data;
struct xbps_unpack_progress_data *xpd = data;
if (xpd->entry == NULL || xpd->entry_is_metadata)
return;
@@ -441,18 +443,19 @@ unpack_progress_cb_verbose(void *data)
static void
unpack_progress_cb_percentage(void *data)
{
struct xbps_progress_data *xpd = data;
int percent = 0;
struct xbps_unpack_progress_data *xpd = data;
double percent = 0;
if (xpd->entry_is_metadata)
return;
percent =
(int)((xpd->entry_extract_count * 100) / xpd->entry_total_count);
if (percent > 100)
percent = 100;
(double)((xpd->entry_extract_count * 100.0) / xpd->entry_total_count);
if (percent > 100.0 ||
xpd->entry_extract_count >= xpd->entry_total_count)
percent = 100.0;
printf("\033[s(%3d%%)\033[u", percent);
printf("\033[s(%3.2f%%)\033[u", percent);
}
static int
@@ -461,7 +464,7 @@ exec_transaction(struct transaction *trans)
prop_dictionary_t instpkgd;
prop_object_t obj;
prop_object_iterator_t replaces_iter;
struct xbps_progress_data xpd;
struct xbps_unpack_progress_data xpd;
const char *pkgname, *version, *pkgver, *instver, *filen, *tract;
int flags = xbps_get_flags(), rv = 0;
bool update, preserve, autoinst;
@@ -574,14 +577,14 @@ exec_transaction(struct transaction *trans)
printf("Unpacking `%s' (from ../%s) ... ", pkgver, filen);
if (flags & XBPS_FLAG_VERBOSE) {
xbps_unpack_binary_pkg_set_progress_cb(
rv = xbps_unpack_binary_pkg(obj,
unpack_progress_cb_verbose, &xpd);
printf("\n");
} else {
xbps_unpack_binary_pkg_set_progress_cb(
rv = xbps_unpack_binary_pkg(obj,
unpack_progress_cb_percentage, &xpd);
}
if ((rv = xbps_unpack_binary_pkg(obj)) != 0) {
if (rv != 0) {
fprintf(stderr, "xbps-bin: error unpacking %s "
"(%s)\n", pkgver, strerror(rv));
return rv;

8
bin/xbps-bin/remove.c
View File

@@ -41,7 +41,7 @@ pkg_remove_and_purge(const char *pkgname, const char *version, bool purge)
printf("Removing package %s-%s ...\n", pkgname, version);
if ((rv = xbps_remove_pkg(pkgname, version, false)) != 0) {
fprintf(stderr, "\nE: unable to remove %s-%s (%s).\n",
xbps_error_printf("unable to remove %s-%s (%s).\n",
pkgname, version, strerror(errno));
return rv;
}
@@ -49,7 +49,7 @@ pkg_remove_and_purge(const char *pkgname, const char *version, bool purge)
printf(" Purging ... ");
(void)fflush(stdout);
if ((rv = xbps_purge_pkg(pkgname, false)) != 0) {
fprintf(stderr, "\nE: unable to purge %s-%s "
xbps_error_printf("unable to purge %s-%s "
"(%s).\n", pkgname, version,
strerror(errno));
return rv;
@@ -149,7 +149,7 @@ xbps_remove_installed_pkgs(int argc, char **argv, bool yes, bool purge,
found = true;
reqby = prop_dictionary_get(dict, "requiredby");
if (reqby != NULL && prop_array_count(reqby) > 0) {
printf("WARNING: %s IS REQUIRED BY %u PACKAGES!\n",
xbps_warn_printf("%s IS REQUIRED BY %u PACKAGES!\n",
pkgver, prop_array_count(reqby));
reqby_force = true;
}
@@ -184,7 +184,7 @@ xbps_remove_installed_pkgs(int argc, char **argv, bool yes, bool purge,
prop_object_release(sorted_pkgs);
return 0;
} else if (reqby_force && force_rm_with_deps)
printf("WARNING: Forcing removal! you've been alerted.\n");
xbps_warn_printf("Forcing removal! you've been alerted.\n");
for (x = 0; x < prop_array_count(sorted_pkgs); x++) {
dict = prop_array_get(sorted_pkgs, x);

285
bin/xbps-bin/util.c Normal file
View File

@@ -0,0 +1,285 @@
/*-
* Copyright (c) 2008-2010 Juan Romero Pardines.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <fnmatch.h>
#include <assert.h>
#include <xbps_api.h>
#include "strlcpy.h"
#include "defs.h"
#include "../xbps-repo/defs.h"
void
show_pkg_info_only_repo(prop_dictionary_t dict)
{
prop_object_t obj;
char size[8];
int rv;
obj = prop_dictionary_get(dict, "filename");
if (prop_object_type(obj) == PROP_TYPE_STRING) {
printf("Filename: %s", prop_string_cstring_nocopy(obj));
obj = prop_dictionary_get(dict, "filename-size");
if (prop_object_type(obj) == PROP_TYPE_NUMBER) {
rv = xbps_humanize_number(size,
(int64_t)prop_number_unsigned_integer_value(obj));
if (rv == -1)
printf(" (size: %ju)\n",
prop_number_unsigned_integer_value(obj));
else
printf(" (size: %s)\n", size);
} else
printf("\n");
}
obj = prop_dictionary_get(dict, "filename-sha256");
if (prop_object_type(obj) == PROP_TYPE_STRING)
printf("SHA256: %s\n", prop_string_cstring_nocopy(obj));
}
void
show_pkg_info(prop_dictionary_t dict)
{
prop_object_t obj;
const char *sep;
char size[8];
assert(dict != NULL);
assert(prop_dictionary_count(dict) != 0);
obj = prop_dictionary_get(dict, "archive-compression-type");
if (prop_object_type(obj) == PROP_TYPE_STRING)
printf("Compression type: %s\n",
prop_string_cstring_nocopy(obj));
obj = prop_dictionary_get(dict, "pkgname");
if (prop_object_type(obj) == PROP_TYPE_STRING)
printf("Package: %s\n", prop_string_cstring_nocopy(obj));
obj = prop_dictionary_get(dict, "installed_size");
if (prop_object_type(obj) == PROP_TYPE_NUMBER) {
printf("Installed size: ");
if (xbps_humanize_number(size,
(int64_t)prop_number_unsigned_integer_value(obj)) == -1)
printf("%ju\n",
prop_number_unsigned_integer_value(obj));
else
printf("%s\n", size);
}
obj = prop_dictionary_get(dict, "maintainer");
if (prop_object_type(obj) == PROP_TYPE_STRING)
printf("Maintainer: %s\n", prop_string_cstring_nocopy(obj));
obj = prop_dictionary_get(dict, "architecture");
if (prop_object_type(obj) == PROP_TYPE_STRING)
printf("Architecture: %s\n", prop_string_cstring_nocopy(obj));
obj = prop_dictionary_get(dict, "version");
if (prop_object_type(obj) == PROP_TYPE_STRING)
printf("Version: %s\n", prop_string_cstring_nocopy(obj));
obj = prop_dictionary_get(dict, "preserve");
if (prop_object_type(obj) == PROP_TYPE_BOOL)
printf("Preserve files: %s\n",
prop_bool_true(obj) ? "yes" : "no");
obj = prop_dictionary_get(dict, "replaces");
if (prop_object_type(obj) == PROP_TYPE_ARRAY) {
printf("Replaces: ");
(void)xbps_callback_array_iter_in_dict(dict, "replaces",
list_strings_sep_in_array, NULL);
}
obj = prop_dictionary_get(dict, "conflicts");
if (prop_object_type(obj) == PROP_TYPE_ARRAY) {
printf("Conflicts: ");
(void)xbps_callback_array_iter_in_dict(dict, "conflicts",
list_strings_sep_in_array, NULL);
}
obj = prop_dictionary_get(dict, "conf_files");
if (prop_object_type(obj) == PROP_TYPE_ARRAY) {
printf("Configuration files:\n");
sep = " ";
(void)xbps_callback_array_iter_in_dict(dict, "conf_files",
list_strings_sep_in_array, __UNCONST(sep));
printf("\n");
}
obj = prop_dictionary_get(dict, "short_desc");
if (prop_object_type(obj) == PROP_TYPE_STRING)
printf("Description: %s", prop_string_cstring_nocopy(obj));
obj = prop_dictionary_get(dict, "long_desc");
if (prop_object_type(obj) == PROP_TYPE_STRING)
printf(" %s\n", prop_string_cstring_nocopy(obj));
}
int
show_pkg_files(prop_dictionary_t filesd)
{
prop_array_t array;
prop_object_iterator_t iter = NULL;
prop_object_t obj;
const char *file, *array_str;
int i = 0;
/* This will print links, conf_files and files respectively. */
for (i = 0; i < 3; i++) {
if (i == 0)
array_str = "links";
else if (i == 1)
array_str = "conf_files";
else
array_str = "files";
array = prop_dictionary_get(filesd, array_str);
if (array == NULL || prop_array_count(array) == 0)
continue;
iter = xbps_get_array_iter_from_dict(filesd, array_str);
if (iter == NULL)
return EINVAL;
while ((obj = prop_object_iterator_next(iter))) {
prop_dictionary_get_cstring_nocopy(obj, "file", &file);
printf("%s\n", file);
}
prop_object_iterator_release(iter);
}
return 0;
}
static int
_find_longest_pkgver_cb(prop_object_t obj, void *arg, bool *loop_done)
{
size_t *len = arg;
const char *pkgver;
(void)loop_done;
prop_dictionary_get_cstring_nocopy(obj, "pkgver", &pkgver);
if (*len == 0 || strlen(pkgver) > *len)
*len = strlen(pkgver);
return 0;
}
size_t
find_longest_pkgver(prop_dictionary_t d)
{
size_t len = 0;
(void)xbps_callback_array_iter_in_dict(d, "packages",
_find_longest_pkgver_cb, &len);
return len;
}
int
show_pkg_namedesc(prop_object_t obj, void *arg, bool *loop_done)
{
struct repo_search_data *rsd = arg;
const char *pkgver, *pkgname, *desc;
char *tmp = NULL;
size_t i;
(void)loop_done;
assert(prop_object_type(obj) == PROP_TYPE_DICTIONARY);
assert(rsd->pattern != NULL);
prop_dictionary_get_cstring_nocopy(obj, "pkgname", &pkgname);
prop_dictionary_get_cstring_nocopy(obj, "pkgver", &pkgver);
prop_dictionary_get_cstring_nocopy(obj, "short_desc", &desc);
if ((xbps_pkgpattern_match(pkgver, rsd->pattern) == 1) ||
(xbps_pkgpattern_match(desc, rsd->pattern) == 1) ||
(strcmp(pkgname, rsd->pattern) == 0) ||
(strstr(pkgver, rsd->pattern)) || (strstr(desc, rsd->pattern))) {
tmp = calloc(1, rsd->pkgver_len + 1);
if (tmp == NULL)
return errno;
strlcpy(tmp, pkgver, rsd->pkgver_len + 1);
for (i = strlen(tmp); i < rsd->pkgver_len; i++)
tmp[i] = ' ';
printf(" %s %s\n", tmp, desc);
free(tmp);
}
return 0;
}
int
list_strings_in_array(prop_object_t obj, void *arg, bool *loop_done)
{
(void)arg;
(void)loop_done;
assert(prop_object_type(obj) == PROP_TYPE_STRING);
print_package_line(prop_string_cstring_nocopy(obj));
return 0;
}
int
list_strings_sep_in_array(prop_object_t obj, void *arg, bool *loop_done)
{
const char *sep = arg;
(void)loop_done;
assert(prop_object_type(obj) == PROP_TYPE_STRING);
printf("%s%s\n", sep ? sep : "", prop_string_cstring_nocopy(obj));
return 0;
}
void
print_package_line(const char *str)
{
static size_t cols;
static bool first;
cols += strlen(str) + 4;
if (cols <= 80) {
if (first == false) {
printf(" ");
first = true;
}
} else {
printf("\n ");
cols = strlen(str) + 4;
}
printf("%s ", str);
}