/**
* Fetch repository calalogues.
*/
int
pkgcli_update(bool force, bool strict, const char *reponame)
{
int retcode = EPKG_FATAL, update_count = 0, total_count = 0;
struct pkg_repo *r = NULL;
/* Only auto update if the user has write access. */
if (pkgdb_access(PKGDB_MODE_READ|PKGDB_MODE_WRITE|PKGDB_MODE_CREATE,
PKGDB_DB_REPO) == EPKG_ENOACCESS)
return (EPKG_OK);
if (pkg_repos_total_count() == 0) {
fprintf(stderr, "No valid repository found.\n");
return (EPKG_FATAL);
}
while (pkg_repos(&r) == EPKG_OK) {
if (reponame != NULL) {
if (strcmp(pkg_repo_name(r), reponame) != 0)
continue;
} else {
if (!pkg_repo_enabled(r))
continue;
}
if (!quiet)
printf("Updating %s repository catalogue...\n",
pkg_repo_name(r));
retcode = pkg_update(r, force);
if (retcode == EPKG_UPTODATE) {
if (!quiet)
printf("%s repository is up-to-date.\n",
pkg_repo_name(r));
}
else if (retcode != EPKG_OK && strict)
retcode = EPKG_FATAL;
total_count ++;
if (retcode != EPKG_OK)
continue;
update_count ++;
}
if (!strict || retcode == EPKG_UPTODATE)
retcode = EPKG_OK;
if (total_count == 0) {
if (!quiet)
printf("No repositories are enabled.\n");
retcode = EPKG_FATAL;
}
else if (update_count == 0) {
if (!quiet)
if (retcode == EPKG_OK)
printf("All repositories are up-to-date.\n");
}
return (retcode);
}
/**
* Fetch repository calalogues.
*/
int
pkgcli_update(bool force) {
int retcode = EPKG_FATAL, update_count = 0;
struct pkg_repo *r = NULL;
/* Only auto update if the user has write access. */
if (pkgdb_access(PKGDB_MODE_READ|PKGDB_MODE_WRITE|PKGDB_MODE_CREATE,
PKGDB_DB_REPO) == EPKG_ENOACCESS)
return (EPKG_OK);
if (!quiet)
printf("Updating repository catalogue\n");
if (pkg_repos_total_count() == 0) {
fprintf(stderr, "No valid repository found.\n");
return (EPKG_FATAL);
}
while (pkg_repos(&r) == EPKG_OK) {
if (!pkg_repo_enabled(r))
continue;
retcode = pkg_update(r, force);
if (retcode == EPKG_UPTODATE) {
if (!quiet)
printf("%s repository catalogue is "
"up-to-date, no need to fetch "
"fresh copy\n", pkg_repo_ident(r));
retcode = EPKG_OK;
}
if (retcode != EPKG_OK)
break;
update_count ++;
}
if (!quiet && update_count == 0)
printf("No repositories are enabled\n");
return (retcode);
}
int
exec_stats(int argc, char **argv)
{
struct pkgdb *db = NULL;
int64_t flatsize = 0;
unsigned int opt = 0;
char size[7];
int ch;
bool show_bytes = false;
struct option longopts[] = {
{ "bytes", no_argument, NULL, 'b' },
{ "local", no_argument, NULL, 'l' },
{ "quiet", no_argument, NULL, 'q' },
{ "remote", no_argument, NULL, 'r' },
{ NULL, 0, NULL, 0 },
};
while ((ch = getopt_long(argc, argv, "+blqr", longopts, NULL)) != -1) {
switch (ch) {
case 'b':
show_bytes = true;
break;
case 'l':
opt |= STATS_LOCAL;
break;
case 'q':
quiet = true;
break;
case 'r':
opt |= STATS_REMOTE;
break;
default:
usage_stats();
return (EX_USAGE);
}
}
argc -= optind;
argv += optind;
/* default is to show everything we have */
if (opt == 0)
opt |= (STATS_LOCAL | STATS_REMOTE);
if (pkgdb_open(&db, PKGDB_REMOTE) != EPKG_OK) {
return (EX_IOERR);
}
if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY) != EPKG_OK) {
pkgdb_close(db);
warnx("Cannot get a read lock on a database, it is locked by another process");
return (EX_TEMPFAIL);
}
if (opt & STATS_LOCAL) {
printf("Local package database:\n");
printf("\tInstalled packages: %" PRId64 "\n", pkgdb_stats(db, PKG_STATS_LOCAL_COUNT));
flatsize = pkgdb_stats(db, PKG_STATS_LOCAL_SIZE);
if (show_bytes)
printf("\tDisk space occupied: %" PRId64 "\n\n", flatsize);
else {
humanize_number(size, sizeof(size), flatsize, "B", HN_AUTOSCALE, 0);
printf("\tDisk space occupied: %s\n\n", size);
}
}
if ((opt & STATS_REMOTE) && pkg_repos_total_count() > 0) {
printf("Remote package database(s):\n");
printf("\tNumber of repositories: %" PRId64 "\n", pkgdb_stats(db, PKG_STATS_REMOTE_REPOS));
printf("\tPackages available: %" PRId64 "\n", pkgdb_stats(db, PKG_STATS_REMOTE_COUNT));
printf("\tUnique packages: %" PRId64 "\n", pkgdb_stats(db, PKG_STATS_REMOTE_UNIQUE));
flatsize = pkgdb_stats(db, PKG_STATS_REMOTE_SIZE);
if (show_bytes)
printf("\tTotal size of packages: %" PRId64 "\n", flatsize);
else {
humanize_number(size, sizeof(size), flatsize, "B", HN_AUTOSCALE, 0);
printf("\tTotal size of packages: %s\n", size);
}
}
pkgdb_release_lock(db, PKGDB_LOCK_READONLY);
pkgdb_close(db);
return (EX_OK);
}
int
exec_install(int argc, char **argv)
{
struct pkgdb *db = NULL;
struct pkg_jobs *jobs = NULL;
const char *reponame = NULL;
int retcode;
int updcode = EPKG_OK;
int ch;
int mode, repo_type;
int done = 0;
int lock_type = PKGDB_LOCK_ADVISORY;
bool rc = true;
bool local_only = false;
match_t match = MATCH_EXACT;
pkg_flags f = PKG_FLAG_NONE | PKG_FLAG_PKG_VERSION_TEST;
struct option longopts[] = {
{ "automatic", no_argument, NULL, 'A' },
{ "case-sensitive", no_argument, NULL, 'C' },
{ "force", no_argument, NULL, 'f' },
{ "fetch-only", no_argument, NULL, 'F' },
{ "glob", no_argument, NULL, 'g' },
{ "case-insensitive", no_argument, NULL, 'i' },
{ "no-install-scripts", no_argument, NULL, 'I' },
{ "local-only", no_argument, NULL, 'l' },
{ "ignore-missing", no_argument, NULL, 'M' },
{ "dry-run", no_argument, NULL, 'n' },
{ "quiet", no_argument, NULL, 'q' },
{ "repository", required_argument, NULL, 'r' },
{ "recursive", no_argument, NULL, 'R' },
{ "no-repo-update", no_argument, NULL, 'U' },
{ "regex", no_argument, NULL, 'x' },
{ "yes", no_argument, NULL, 'y' },
{ NULL, 0, NULL, 0 },
};
nbactions = nbdone = 0;
if (strcmp(argv[0], "add") == 0) {
auto_update = false;
local_only = true;
yes = true;
quiet = true;
}
while ((ch = getopt_long(argc, argv, "+ACfFgiIlMnqr:RUxy", longopts, NULL)) != -1) {
switch (ch) {
case 'A':
f |= PKG_FLAG_AUTOMATIC;
break;
case 'C':
pkgdb_set_case_sensitivity(true);
break;
case 'f':
f |= PKG_FLAG_FORCE;
break;
case 'F':
f |= PKG_FLAG_SKIP_INSTALL;
lock_type = PKGDB_LOCK_READONLY;
break;
case 'g':
match = MATCH_GLOB;
break;
case 'i':
pkgdb_set_case_sensitivity(false);
break;
case 'I':
f |= PKG_FLAG_NOSCRIPT;
break;
case 'l':
local_only = true;
auto_update = false;
break;
case 'M':
f |= PKG_FLAG_FORCE_MISSING;
break;
case 'n':
f |= PKG_FLAG_DRY_RUN;
lock_type = PKGDB_LOCK_READONLY;
dry_run = true;
break;
case 'q':
quiet = true;
break;
case 'r':
reponame = optarg;
break;
case 'R':
f |= PKG_FLAG_RECURSIVE;
break;
case 'U':
auto_update = false;
break;
case 'x':
match = MATCH_REGEX;
break;
case 'y':
yes = true;
break;
default:
usage_install();
return (EX_USAGE);
}
}
argc -= optind;
argv += optind;
if (argc < 1) {
usage_install();
return (EX_USAGE);
}
if (dry_run && !auto_update)
mode = PKGDB_MODE_READ;
else
mode = PKGDB_MODE_READ |
PKGDB_MODE_WRITE |
PKGDB_MODE_CREATE;
if (local_only)
repo_type = PKGDB_DB_LOCAL;
else
repo_type = PKGDB_DB_LOCAL|PKGDB_DB_REPO;
retcode = pkgdb_access(mode, repo_type);
if (retcode == EPKG_ENOACCESS && dry_run) {
auto_update = false;
retcode = pkgdb_access(PKGDB_MODE_READ,
repo_type);
}
if (retcode == EPKG_ENOACCESS) {
warnx("Insufficient privileges to install packages");
return (EX_NOPERM);
} else if (retcode != EPKG_OK)
return (EX_IOERR);
else
retcode = EX_SOFTWARE;
/* first update the remote repositories if needed */
if (auto_update && pkg_repos_total_count() > 0 &&
(updcode = pkgcli_update(false, false, reponame)) != EPKG_OK)
return (updcode);
if (pkgdb_open_all(&db,
local_only ? PKGDB_DEFAULT : PKGDB_MAYBE_REMOTE,
reponame) != EPKG_OK)
return (EX_IOERR);
if (pkgdb_obtain_lock(db, lock_type) != EPKG_OK) {
pkgdb_close(db);
warnx("Cannot get an advisory lock on a database, it is locked by another process");
return (EX_TEMPFAIL);
}
if (pkg_jobs_new(&jobs, PKG_JOBS_INSTALL, db) != EPKG_OK)
goto cleanup;
if (!local_only && reponame != NULL &&
pkg_jobs_set_repository(jobs, reponame) != EPKG_OK)
goto cleanup;
pkg_jobs_set_flags(jobs, f);
if (pkg_jobs_add(jobs, match, argv, argc) == EPKG_FATAL)
goto cleanup;
if (pkg_jobs_solve(jobs) != EPKG_OK)
goto cleanup;
while ((nbactions = pkg_jobs_count(jobs)) > 0) {
rc = yes;
/* print a summary before applying the jobs */
if (!quiet || dry_run) {
print_jobs_summary(jobs,
"The following %d package(s) will be affected (of %d checked):\n\n",
nbactions, pkg_jobs_total(jobs));
if (!dry_run) {
rc = query_yesno(false,
"\nProceed with this action? ");
} else {
rc = false;
}
}
if (rc) {
retcode = pkg_jobs_apply(jobs);
done = 1;
if (retcode == EPKG_CONFLICT) {
printf("Conflicts with the existing packages "
"have been found.\nOne more solver "
"iteration is needed to resolve them.\n");
continue;
}
else if (retcode != EPKG_OK)
goto cleanup;
}
if (messages != NULL) {
sbuf_finish(messages);
printf("%s", sbuf_data(messages));
}
break;
}
if (done == 0 && rc)
printf("The most recent version of packages are already installed\n");
retcode = EX_OK;
cleanup:
pkgdb_release_lock(db, lock_type);
pkg_jobs_free(jobs);
pkgdb_close(db);
if (!dry_run)
pkg_cache_full_clean();
if (!rc && newpkgversion)
newpkgversion = false;
return (retcode);
}
static void
print_jobs_summary_pkg(struct pkg *pkg, pkg_jobs_t type, int64_t *oldsize,
int64_t *newsize, int64_t *dlsize)
{
const char *oldversion, *cachedir, *why;
char path[MAXPATHLEN];
struct stat st;
int64_t flatsize, oldflatsize, pkgsize;
char size[7];
flatsize = oldflatsize = pkgsize = 0;
oldversion = NULL;
pkg_config_string(PKG_CONFIG_CACHEDIR, &cachedir);
pkg_get(pkg, PKG_OLD_VERSION, &oldversion,
PKG_FLATSIZE, &flatsize, PKG_OLD_FLATSIZE, &oldflatsize,
PKG_PKGSIZE, &pkgsize, PKG_REASON, &why);
if (pkg_is_locked(pkg)) {
pkg_printf("\tPackage %n-%v is locked ", pkg, pkg);
switch (type) {
case PKG_JOBS_INSTALL:
case PKG_JOBS_UPGRADE:
/* If it's a new install, then it
* cannot have been locked yet. */
if (oldversion != NULL) {
switch(pkg_version_change(pkg)) {
case PKG_UPGRADE:
pkg_printf("and may not be upgraded to version %v\n", pkg);
break;
case PKG_REINSTALL:
printf("and may not be reinstalled\n");
break;
case PKG_DOWNGRADE:
pkg_printf("and may not be downgraded to version %v\n", pkg);
break;
}
return;
}
break;
case PKG_JOBS_DEINSTALL:
case PKG_JOBS_AUTOREMOVE:
printf("and may not be deinstalled\n");
return;
break;
case PKG_JOBS_FETCH:
printf("but a new package can still be fetched\n");
break;
}
}
switch (type) {
case PKG_JOBS_INSTALL:
case PKG_JOBS_UPGRADE:
pkg_snprintf(path, MAXPATHLEN, "%S/%R", cachedir, pkg);
if (stat(path, &st) == -1 || pkgsize != st.st_size)
/* file looks corrupted (wrong size),
assume a checksum mismatch will
occur later and the file will be
fetched from remote again */
*dlsize += pkgsize;
if (oldversion != NULL) {
switch (pkg_version_change(pkg)) {
case PKG_DOWNGRADE:
pkg_printf("\tDowngrading %n: %V -> %v", pkg, pkg, pkg);
if (pkg_repos_total_count() > 1)
pkg_printf(" [%N]", pkg);
printf("\n");
break;
case PKG_REINSTALL:
pkg_printf("\tReinstalling %n-%v", pkg, pkg);
if (pkg_repos_total_count() > 1)
pkg_printf(" [%N]", pkg);
if (why != NULL)
printf(" (%s)", why);
printf("\n");
break;
case PKG_UPGRADE:
pkg_printf("\tUpgrading %n: %V -> %v", pkg, pkg, pkg);
if (pkg_repos_total_count() > 1)
pkg_printf(" [%N]", pkg);
printf("\n");
break;
}
*oldsize += oldflatsize;
*newsize += flatsize;
} else {
*newsize += flatsize;
pkg_printf("\tInstalling %n: %v", pkg, pkg);
if (pkg_repos_total_count() > 1)
pkg_printf(" [%N]", pkg);
printf("\n");
}
break;
case PKG_JOBS_DEINSTALL:
case PKG_JOBS_AUTOREMOVE:
*oldsize += oldflatsize;
*newsize += flatsize;
pkg_printf("\tRemoving %n-%v\n", pkg, pkg);
break;
case PKG_JOBS_FETCH:
*dlsize += pkgsize;
pkg_snprintf(path, MAXPATHLEN, "%S/%R", cachedir, pkg);
if (stat(path, &st) != -1)
*oldsize = st.st_size;
else
*oldsize = 0;
*dlsize -= *oldsize;
humanize_number(size, sizeof(size), pkgsize, "B", HN_AUTOSCALE, 0);
pkg_printf("\t%n-%v ", pkg, pkg);
printf("(%" PRId64 "%% of %s)\n", 100 - (100 * (*oldsize))/pkgsize, size);
break;
}
}
