X-Git-Url: https://pd.if.org/git/?p=zpackage;a=blobdiff_plain;f=zpm-syncfs.c;h=220ee039c38ab0428266f29e8c2e8d5580bc16c4;hp=c2ee8463b9eeeef7cd522b13ceb544616dec414f;hb=62f6ff407bc4f2cf03d1fa7cf3dc9a3f4026624a;hpb=293e281d6bd4b9c2c1de146184835ed34dc87b05 diff --git a/zpm-syncfs.c b/zpm-syncfs.c index c2ee846..220ee03 100644 --- a/zpm-syncfs.c +++ b/zpm-syncfs.c @@ -5,6 +5,7 @@ #include #include #include +#include #include #include #include @@ -31,6 +32,11 @@ struct config { int setuser, setgroup; int reverse, exitonerror; int overwrite, accept, acceptdir, ignoredirmd; + unsigned long ops_total, ops_completed; + unsigned long ops_remove, ops_remove_completed; + unsigned long ops_update, ops_update_completed; + unsigned long ops_install, ops_install_completed; + int progress; /* type of progress meter */ }; struct nitem { @@ -55,6 +61,27 @@ static void usage() { printf("usage: zpm $scriptname [-fncC] args ...\n"); } +static void warn(char *fmt, ...) { + va_list args; + + va_start(args, fmt); + vfprintf(stderr, fmt, args); + va_end(args); + fprintf(stderr, "\n"); +} + +static void pdots(int len, int ch, int was, int now, int total) { + was = len * was / total; + if (now > total) { + now = total; + } + now = len * now / total; + while (was++ < now) { + putchar(ch); + } + fflush(stdout); +} + static int seterror(struct config *conf, char *msgfmt, ...) { char msg[1024]; va_list ap; @@ -202,6 +229,7 @@ static char *column(char *col, int ncols, char **vals, char **cols) { #define SYSERR(x) do { conf->log->error = 2; return conf->errabort; } while (0) +/* TODO handle other ops properly */ static char *ops[] = { "new", "remove", "update", 0 }; enum op { @@ -414,6 +442,8 @@ static int read_item(struct config *conf, int ncols, char **vals, char **cols, * the the hash of the file on disk */ #define D_OHASH 0x400 +/* file exists, and is a directory, and is empty */ +#define D_ISEMPTY 0x800 /* an error occurred trying to compare the file (other than it doesn't exist */ #define D_ERROR 0x1000 /* there was a stat error */ @@ -421,6 +451,27 @@ static int read_item(struct config *conf, int ncols, char **vals, char **cols, /* there was an error calling readlink */ #define D_RLERROR 0x4000 +static int dir_is_empty(char *path) { + DIR *dir; + struct dirent *dp; + int empty; + + dir = opendir(path); + if (!dir) { + return -1; + } + + dp = readdir(dir); + if (dp) { + empty = 0; + } else { + empty = 1; + } + closedir(dir); + + return empty; +} + /* 1 = file doesn't exist, 2 = file is a directory, target isn't */ /* 4 == ftype different */ /* 8 = hash different when both are regular files */ @@ -447,6 +498,9 @@ static unsigned int file_compare(struct nitem *n, struct stat *st) { } if (stat_type == S_IFDIR) { diff |= D_EISDIR; + if (dir_is_empty(n->dest)) { + diff |= D_ISEMPTY; + } } if (n->hash && etype == S_IFREG && stat_type == S_IFREG) { @@ -573,10 +627,16 @@ static int check_existing(void *f, int ncols, char **vals, char **cols) { } unsigned int diffs = file_compare(&nitem, &st); + int sametype = (!(diffs & D_TYPE)); + if (diffs >= D_ERROR) { return seterror(conf, "can't check %s", nitem.dest); } + if (sametype && nitem.configuration) { + return 0; + } + int action = acceptable(conf, diffs, nitem.op); if (!action) { if (conf->accept) { @@ -590,39 +650,70 @@ static int check_existing(void *f, int ncols, char **vals, char **cols) { return 0; } +static void update_progress(struct config *conf, char *op, char *path) { + if (!conf->verbose) { + return; + } + + if (conf->progress == 0) { + pdots(50, '.', conf->ops_completed-1, conf->ops_completed, conf->ops_total); + } else if (conf->progress == 1) { + size_t len = strlen(path); + int offset = 0; + if (len > 50) { + offset = len-50; + } + printf("\r%lu/%lu %.10s %.50s\n", conf->ops_completed, + conf->ops_total, op, path+offset); + } else if (conf->progress == 2) { + printf("%lu/%lu %s %s\n", conf->ops_completed, + conf->ops_total, op, path); + } + fflush(stdout); +} + static int remove_files(void *f, int ncols, char **vals, char **cols) { struct config *conf = f; char *dest; struct stat st; int flags = 0; + conf->ops_completed++; + dest = COL("dest"); + char *ftype = COL("filetype"); + if (!dest) return seterror(conf,"no file dest"); + if (!ftype) return seterror(conf,"no file type"); - if (conf->dryrun) { - char *ftype = COL("filetype"); - int t = *ftype; + update_progress(conf, *ftype == 'd' ? "rmdir" : "unlink", dest); - switch(t) { - case 'd': printf("rmdir %s\n", dest); break; - default: printf("unlink %s\n", dest); break; - } - fflush(stdout); + if (conf->dryrun) { return 0; } + errno = 0; + if (lstat(dest, &st) == -1) { - return seterror(conf,"can't stat"); + switch (errno) { + case ENOENT: + if (conf->verbose > 1) { + fprintf(stderr, "expected file not found: '%s'\n", dest); + } + break; + default: + return seterror(conf, "can't stat %s: %s", dest, strerror(errno)); + } + return 0; } if (S_ISDIR(st.st_mode)) { flags = AT_REMOVEDIR; } /* TODO check that expected filetype matches actual filetype */ - - if (conf->verbose) { - fprintf(stderr, "%s(%s)\n", flags ? "rmdir" : "unlink", dest); - } + /* alternatively, just use the expected type, skip the stat, + * and let it fail if the type is wrong + */ errno = 0; @@ -630,8 +721,12 @@ static int remove_files(void *f, int ncols, char **vals, char **cols) { switch (errno) { case ENOENT: break; + case ENOTEMPTY: /* fall through */ + case EEXIST: + fprintf(stderr, "expected empty directory: %s\n", dest); + break; default: - return seterror(conf, "can't unlink"); + return seterror(conf, "can't unlink %s: %s", dest, strerror(errno)); } } @@ -640,7 +735,6 @@ static int remove_files(void *f, int ncols, char **vals, char **cols) { #define MARK fprintf(stderr, "%s %d: mark\n", __func__, __LINE__) - static int remove_dir(struct config *conf, char *path) { int rv; @@ -680,20 +774,23 @@ static int set_md(struct config *conf, struct nitem *item) { return success; } - /* can't chmod a symlink */ - if (item->ftype != 'l') { - rv = chmod(item->dest, item->mode); - + if (conf->setuser && conf->setgroup) { + rv = lchown(item->dest, item->uid, item->gid); if (rv == -1) { - setsyserr(conf, "can't chmod %o %s", item->mode, item->dest); + setsyserr(conf, "can't lchown %s", item->dest); return conf->errabort; } } - if (conf->setuser && conf->setgroup) { - rv = lchown(item->dest, item->uid, item->gid); + /* have to chmod after the chown, setuid bits may (and will) + * be cleared after a chown + */ + /* can't chmod a symlink */ + if (item->ftype != 'l') { + rv = chmod(item->dest, item->mode); + if (rv == -1) { - setsyserr(conf, "can't lchown %s", item->dest); + setsyserr(conf, "can't chmod %o %s", item->mode, item->dest); return conf->errabort; } } @@ -730,7 +827,7 @@ static int install(struct config *conf, struct nitem *item, unsigned int flags) int failure = conf->errabort; int success = 0; - if (flags & 16) { + if (flags & INS_RTF) { failure = 0; success = 1; } @@ -755,16 +852,6 @@ static int install(struct config *conf, struct nitem *item, unsigned int flags) source = conf->src ? conf->src : conf->log; - if (unlink_file) { - rv = remove_existing(conf, item->dest); - } else if (rm_dir) { - rv = remove_dir(conf, item->dest); - } - - if (rv != 1) { - return failure; - } - if (mkleading) { rv = create_leading_dirs(item->dest); if (!rv) { @@ -773,16 +860,21 @@ static int install(struct config *conf, struct nitem *item, unsigned int flags) } } - if (item->ftype == 'r') { - rv = zpm_extract(source, item->hash, item->dest, item->mode); - if (rv == 0) { - seterror(conf, "can't extract %s", item->dest); - return failure; - } - return success; + if (unlink_file) { + rv = remove_existing(conf, item->dest); + } else if (rm_dir) { + rv = remove_dir(conf, item->dest); + } + + if (rv != 1) { + return failure; } + errno = 0; switch (item->ftype) { + case 'r': rv = zpm_extract(source, item->hash, item->dest, item->mode); + if (rv == 0) rv = -1; + break; case 'd': rv = mkdir(item->dest, item->mode); break; case 'l': rv = symlink(item->target, item->dest); @@ -792,6 +884,17 @@ static int install(struct config *conf, struct nitem *item, unsigned int flags) } if (rv == -1) { + switch (item->ftype) { + case 'r': + seterror(conf, "can't extract %s", item->dest); + break; + case 'd': + setsyserr(conf, "install mkdir(\"%s\") failed", item->dest); + break; + case 'l': + setsyserr(conf, "install symlink(\"%s\") failed", item->dest); + break; + } setsyserr(conf, "installing %s failed", item->dest); return failure; } @@ -803,6 +906,24 @@ static int install(struct config *conf, struct nitem *item, unsigned int flags) return success; } +static int save_config_file(struct config *conf, struct nitem *n, char *msgfmt) { + char hash[ZPM_HASH_STRLEN+1]; + + if (!msgfmt) { + msgfmt = "saved config file %.8s"; + } + + if (zpm_import(conf->log, n->dest, 0, hash)) { + zpm_note_add(conf->log, n->pkglist, n->path, hash, msgfmt, hash); + } else { + warn("unable to import existing config file %s", n->dest); + conf->errors++; + return 0; + } + return 1; +} + +#if 0 /* * figure out what the difference is for a config file, only called * for an update of a configuration file @@ -810,67 +931,33 @@ static int install(struct config *conf, struct nitem *item, unsigned int flags) * return 1 if the new file should not be installed * return 0 if the new file should be installed */ -static int adjust_for_config(struct config *conf, struct nitem *n, unsigned int - diffs) { +static int adjust_for_config(struct nitem *n, unsigned int diffs) { if (!n->oldwasconf) { return 0; } + + int sametype = (!(diffs & D_TYPE)); + int isdir = (diffs & D_ISDIR); + int eisdir = (diffs & D_EISDIR); - /* TODO what if old was a directory? */ + /* what if old was a directory? */ if (!n->configuration) { /* replacing conf with non-conf */ /* absorb file, mark todo */ - char hash[ZPM_HASH_STRLEN+1]; - if (!conf->dryrun) { - if (conf->verbose) { - fprintf(stderr, "importing old conf file\n"); - } - if (zpm_import(conf->log, n->dest, 0, hash)) { - zpm_note_add(conf->log, n->pkglist, n->dest, hash, - "replaced config file with non-config. zpm-cat %.8s", hash); - } else { - fprintf(stderr, "unable to import existing config file %s\n", n->dest); - return -1; - } - } else { - fprintf(stderr, "dry-run: would replace config file %s with non-config file\n", n->dest); - } return 0; } - int sametype = (!(diffs & D_TYPE)); - int isdir = (diffs & D_ISDIR); - int eisdir = (diffs & D_EISDIR); - /* both old and new are config files */ if (isdir && sametype) { /* both config directories, can only be changing * metadata, so no adjustment needed */ - if (conf->verbose) { - fprintf(stderr, "both config dirs, ok to update\n"); - } return 0; } if (isdir) { - char hash[ZPM_HASH_STRLEN+1]; - - /* replacing old file with new directory */ - /* absorb, make note */ - if (!conf->dryrun) { - if (zpm_import(conf->log, n->dest, 0, hash)) { - zpm_note_add(conf->log, n->pkglist, n->dest, hash, - "replaced config file with config directory. zpm-cat %.8s", hash); - } else { - fprintf(stderr, "unable to import existing config file %s\n", n->dest); - return -1; - } - } else { - fprintf(stderr, "dry-run: would replace config file %s with config directory\n", n->dest); - } - return 0; + return 0; } if (eisdir) { @@ -885,37 +972,185 @@ static int adjust_for_config(struct config *conf, struct nitem *n, unsigned int /* replacing old file with new file */ /* new is same as on disk */ if (!(diffs & D_HASH)) { - if (conf->verbose) { - fprintf(stderr, "new config file is already on disk, probably shouldn't happen\n"); - } return 0; } /* new is different than on disk, but on disk is same as old */ if (!(diffs & D_OHASH)) { - if (conf->verbose) { - fprintf(stderr, "old config file not changed from default, replacing with new default\n"); - } - /* ok to do the update, since same as default */ - fprintf(stderr, "updating default config %s\n", n->dest); return 0; } - /* new is different than on disk, and disk different than old */ - /* log */ - if (conf->verbose) { - fprintf(stderr, "new default config file is different than on disk, and old default was changed, should keep on-disk config\n"); + return 1; + +} +#endif + +static int config_handler(void *f, int ncols, char **vals, char **cols) { + struct config *conf = f; + struct nitem nitem; + struct stat existing; + char *save = 0; + char *note = 0; + char *notehash = 0; + int update = 0; + + if (!read_item(conf, ncols, vals, cols, &nitem)) { + fprintf(stderr, "can't read item\n"); + conf->errors++; + return conf->errabort; + } + + unsigned int diffs = file_compare(&nitem, &existing); + if (diffs >= D_ERROR) { + return seterror(conf, "can't check %s", nitem.dest); + } + + int exist = (!(diffs & D_NOEXIST)); + int sametype = (!(diffs & D_TYPE)); + //int mdsame = (!(diffs & D_MD)); + int hashsame = (!(diffs & D_HASH)); + int oldhashsame = (!(diffs & D_OHASH)); + int isdir = (diffs & D_ISDIR); + int eisdir = (diffs & D_EISDIR); + update = (nitem.op == OP_UPDATE); + + notehash = nitem.hash; + + /* if the file doesn't exist in the system, nothing to do */ + /* could possibly note if we expected it, but the regular handling + * should do that + */ + if (!exist) { + return 0; + } + + if (nitem.op == OP_UPDATE && !nitem.oldwasconf) { + /* possibly save anyway */ + return 0; + } + + /* so, old was conf, and something exists in the filesystem */ + + if (!sametype) { + warn("won't %s %s%s, %s exists", + nitem.op == OP_NEW ? "install" : nitem.opstr, + nitem.path, + isdir ? "/" : "", + eisdir ? "directory" : "file" + ); + conf->errors++; + return conf->errabort; + } + + /* all below are same type of file */ + /* what about sametype, but old was different type */ + + if (isdir) { + return 0; } + + /* save or note cases */ + + if (nitem.op == OP_REMOVE) { + save ="saved removed config file %.8s"; + } else + + if (nitem.op == OP_UPDATE) { + if (!nitem.configuration) { + /* replacing config with non-config */ + save = "replacing configuration file %.8s with non-configuration file"; + } else if (oldhashsame) { + /* config file hasn't changed from old default, + * so go ahead and install the new one + */ + save = "replaced old default config (%.8s) with new one."; + notehash = nitem.ohash; + } else { + note = "kept existing config file. new default version is %.8s"; + save = 0; + } + } else + + if (nitem.op == OP_NEW && !hashsame) { + note = "config file already existed. would have installed %.8s"; + save = 0; + } + + /* + * save files, add notes + */ if (!conf->dryrun) { - zpm_note_add(conf->log, n->pkglist, n->dest, n->hash, - "default config file update. zpm-cat %.8s", n->hash); - /* TODO check for note error */ + if (save) { + warn("saving config file: %s (root %s)", nitem.path, conf->rootdir ? conf->rootdir : "/"); + save_config_file(conf, &nitem, save); + } + if (note) { + zpm_note_add(conf->log, nitem.pkglist, nitem.path, nitem.hash, + note, nitem.hash); + } } else { - fprintf(stderr, "dry-run: default config file %s update\n", - n->dest); + if (save) { + fprintf(stderr, "dry run: %s %s: ", nitem.pkglist, + nitem.path); + warn(save, notehash); + } + if (note) { + fprintf(stderr, "dry run: %s %s: ", nitem.pkglist, + nitem.path); + warn(note, notehash); + } + + } + + return 0; +} + +static void handle_config_files(struct config *conf) { + int rv; + char *errmsg; + sqlite3_str *s; + char *sql; + + s = sqlite3_str_new(conf->log->db); + sqlite3_str_appendall(s, "select *, "); + if (conf->rootdir) { + sqlite3_str_appendf(s, "printf('%%s/%%s',rtrim(%Q,'/'),ltrim(path,'/'))", conf->rootdir); + } else { + sqlite3_str_appendf(s, "printf('/%%s', trim(path, '/'))"); + } + sqlite3_str_appendall(s, " as dest from syncinfo"); + + sqlite3_str_appendall(s," where configuration > 0 and op in ('new','update','remove')"); + + if (conf->reverse) { + sqlite3_str_appendall(s," order by length(path) desc, path desc"); + } + + sql = sqlite3_str_value(s); + + rv = zpm_exec(conf->log, sql, config_handler, conf, &errmsg); + + sqlite3_str_finish(s); + + if (rv) { + fprintf(stderr, "exec fail: %s\n", sqlite3_errstr(rv)); + if (errmsg) { + fprintf(stderr, "database error: %s\n", errmsg); + conf->errors++; + } + if (conf->log->error == 1) { + fprintf(stderr, "unable to allocate memory\n"); + } + fprintf(stderr, "zpm_exec failure: %s\n", + conf->log->errmsg ? conf->log->errmsg : "unknown"); + conf->errors++; } - return 1; + if (conf->errors && conf->exitonerror) { + zpm_close(conf->log); + zpm_close(conf->src); + exit(EXIT_FAILURE); + } } static int install_files(void *f, int ncols, char **vals, char **cols) { @@ -924,7 +1159,7 @@ static int install_files(void *f, int ncols, char **vals, char **cols) { struct stat existing; int update = 0; - /* TODO put the result row in a hash table. May not actually + /* put the result row in a hash table? May not actually * be faster */ if (!read_item(conf, ncols, vals, cols, &nitem)) { @@ -938,10 +1173,10 @@ static int install_files(void *f, int ncols, char **vals, char **cols) { high = sqlite3_memory_highwater(0)/1024/1024; fprintf(stderr, "memory = %ld MB / %ld MB\n", used, high); #endif - if (conf->verbose && !conf->dryrun) { - fprintf(stderr, "%s '%c' %s\n", nitem.opstr, nitem.ftype, - nitem.dest); - } + char action[40]; + sprintf(action, "%.8s %c", nitem.opstr, nitem.ftype); + conf->ops_completed++; + update_progress(conf, action, nitem.dest); unsigned int diffs = file_compare(&nitem, &existing); if (diffs >= D_ERROR) { @@ -976,6 +1211,7 @@ static int install_files(void *f, int ncols, char **vals, char **cols) { int sametype = (!(diffs & D_TYPE)); int mdsame = (!(diffs & D_MD)); int hashsame = (!(diffs & D_HASH)); + int ohashsame = (!(diffs & D_OHASH)); int isdir = (diffs & D_ISDIR); int eisdir = (diffs & D_EISDIR); int accept = conf->accept; @@ -983,21 +1219,34 @@ static int install_files(void *f, int ncols, char **vals, char **cols) { int installing = (nitem.op == OP_NEW); update = (nitem.op == OP_UPDATE); + /* if a config file doesn't exist on disk, go ahead and do + * whatever you were going to do, this logic here just + * needs to determine if we should skip what we were going to do + * + * if the old item was a configuration item and the new one isn't, it + * will have been saved earlier, so we can just go ahead. so we only + * test for an existing file, where the item is a configuration file + */ + if (nitem.configuration && exist) { + if (!sametype && !conf->overwrite) { + return seterror(conf, "configuration file exists with different type: %s", nitem.dest); + } + + if (conf->accept) { + return 0; + } + + if (isdir && !mdsame) return 0; + if (!isdir && !ohashsame) return 0; + } + if (update) { if (!exist) { /* warn, it should exist */ - fprintf(stderr, "%s missing, installing", nitem.dest); + fprintf(stderr, "%s missing, installing\n", nitem.dest); return install(conf, &nitem, 3); } - switch (adjust_for_config(conf, &nitem, diffs)) { - case -1: return conf->errabort; break; - case 1: - fprintf(stderr, "skipping changed default config file: %s\n", nitem.dest); - return 0; break; - default: break; - } - /* file exists in filesystem */ if (sametype) { if (mdsame && hashsame) { @@ -1013,6 +1262,7 @@ static int install_files(void *f, int ncols, char **vals, char **cols) { * and group, it might be correct on disk * but not as in the local database */ + /* TODO detect whether this a logic bug or * an on-disk difference */ @@ -1030,13 +1280,14 @@ static int install_files(void *f, int ncols, char **vals, char **cols) { /* fix md */ return set_md(conf, &nitem); } - if (mdsame && !hashsame) { - /* install */ - return install(conf, &nitem, 3); - } - if (!mdsame && !hashsame) { - /* install */ - return install(conf, &nitem, 3); + + if (!hashsame) { + /* doesn't matter on the md */ + int flags = INS_MD | INS_CLD; + if (nitem.ftype == 'l') { + flags |= INS_UNLINK; + } + return install(conf, &nitem, flags); } } @@ -1071,7 +1322,7 @@ static int install_files(void *f, int ncols, char **vals, char **cols) { if (sametype) { if (mdsame && hashsame && (accept || overwrite)) { /* do nothing */ - if (conf->dryrun || conf->verbose) { + if (conf->dryrun || conf->verbose > 1) { fprintf(stderr, "accept %s: %s\n", eisdir ? "directory" : "file", nitem.dest); } @@ -1083,7 +1334,9 @@ static int install_files(void *f, int ncols, char **vals, char **cols) { } if (!mdsame && isdir && conf->ignoredirmd) { - /* TODO warn ignoring dir md */ + if (conf->verbose > 1) { + fprintf(stderr, "ignoring directory metadata difference: %s\n", nitem.dest); + } return 0; } @@ -1145,7 +1398,7 @@ static int install_files(void *f, int ncols, char **vals, char **cols) { /* error */ return seterror(conf, "%s (md+hash): %s", accept ? "existing file not acceptable" : "file exists", nitem.dest); } - /* TODO error, should be impossible */ + /* error, should be impossible */ return seterror(conf, "impossible state reached"); } @@ -1164,9 +1417,7 @@ static int install_files(void *f, int ncols, char **vals, char **cols) { /* existing path is a directory */ if (isdir) { /* fix md */ - /* impossible, if isdir and eisdir, would - * be same type - * TODO + /* impossible, if isdir and eisdir, would be same type */ return set_md(conf, &nitem); } else { @@ -1175,12 +1426,10 @@ static int install_files(void *f, int ncols, char **vals, char **cols) { return install(conf, &nitem, 11); } /* if we get here, we missed a case */ - /* TODO error */ return seterror(conf, "impossible state 2 reached"); } - /* TODO extra verbose print perms, mtime, etc, probably ls -l - * format + /* TODO extra verbose print perms, mtime, etc, probably ls -l format */ if (conf->verbose) { printf("%s\n", nitem.path); @@ -1300,6 +1549,13 @@ static void runstage(struct config *conf, char *stage, /* TODO final report function in conf var */ } +static void count_ops(struct config *conf) { + conf->ops_remove = zpm_db_int(conf->log, "select count(*) from syncinfo where op = 'remove'"); + conf->ops_update = zpm_db_int(conf->log, "select count(*) from syncinfo where op = 'update'"); + conf->ops_install = zpm_db_int(conf->log, "select count(*) from syncinfo where op = 'new'"); + conf->ops_total = conf->ops_remove + conf->ops_update + conf->ops_install; +} + int main(int ac, char **av) { struct zpm localdb; struct zpm pkgdb; @@ -1307,12 +1563,12 @@ int main(int ac, char **av) { char *pkgdbfile = 0, *localdbfile = 0; char *s; - struct config conf; + struct config conf = { 0 }; conf.errabort = 1; conf.errors = 0; conf.conflicts = 0; - conf.verbose = 0; + conf.verbose = 1; conf.dryrun = 0; conf.setuser = 1; conf.setgroup = 1; @@ -1331,12 +1587,10 @@ int main(int ac, char **av) { localdbfile = ZPM_LOCAL_DB; if ((s = getenv("ZPMDB"))) { - /* TODO does this need to be copied ? */ localdbfile = s; } if ((s = getenv("ZPM_ROOT_DIR"))) { - /* TODO does this need to be copied ? */ conf.rootdir = s; } @@ -1349,12 +1603,13 @@ int main(int ac, char **av) { * args are pkgid triple, but will do a pkg find on the pkgdb */ - while ((opt = getopt(ac, av, "f:d:c:nCR:vOAMD")) != -1) { + while ((opt = getopt(ac, av, "f:d:c:nCR:vqOAMDp")) != -1) { switch (opt) { case 'd': localdbfile = optarg; break; case 'f': pkgdbfile = optarg; break; case 'n': conf.dryrun = 1; break; case 'v': conf.verbose++; break; + case 'q': conf.verbose--; break; case 'C': conf.errabort = 0; break; case 'R': conf.rootdir = optarg; break; case 'N': conf.setuser = 0; conf.setgroup = 0; break; @@ -1362,6 +1617,7 @@ int main(int ac, char **av) { case 'A': conf.accept = 1; break; case 'M': conf.ignoredirmd = 1; case 'D': conf.acceptdir = 0; + case 'p': conf.progress++; default: usage(); exit(EXIT_FAILURE); @@ -1390,8 +1646,6 @@ int main(int ac, char **av) { } } - /* TODO find pkgid from arg */ - /* TODO set conf var to finalize error reporting */ if (conf.verbose) { fprintf(stderr, "syncing filesystem %s (ldb %s) from %s\n", @@ -1419,6 +1673,11 @@ int main(int ac, char **av) { fprintf(stderr, "beginning %ssync\n", conf.dryrun ? "dryrun " : ""); } + + if (!conf.errors) { + handle_config_files(&conf); + } + /* have to do the removes first otherwise * old files may conflict with update file * type changes @@ -1426,20 +1685,49 @@ int main(int ac, char **av) { if (!conf.errors) { conf.exitonerror = conf.dryrun ? 0 : 1; conf.errabort = conf.dryrun ? 0 : 1; - conf.reverse = 1; - if (conf.verbose) { - fprintf(stderr, "removing old files\n"); + count_ops(&conf); + fprintf(stderr, "file ops: %lu\n", conf.ops_total); + if (conf.ops_remove > 0) { + if (conf.verbose) { + fprintf(stderr, "removing %lu file%s\n", conf.ops_remove, conf.ops_remove > 1 ? "s" : ""); + } + conf.reverse = 1; + conf.ops_completed = 0; + conf.ops_total = conf.ops_remove; + runstage(&conf, "remove", remove_files); + if (conf.verbose && conf.progress < 2) { + fprintf(stderr, " done\n"); + fflush(stderr); + } } - runstage(&conf, "remove", remove_files); - conf.reverse = 0; - if (conf.verbose) { - fprintf(stderr, "updating files\n"); + + if (conf.ops_update > 0) { + if (conf.verbose) { + fprintf(stderr, "updating %lu file%s\n", conf.ops_update, conf.ops_update > 1 ? "s" : ""); + } + conf.reverse = 0; + conf.ops_completed = 0; + conf.ops_total = conf.ops_update; + runstage(&conf, "update", install_files); + if (conf.verbose && conf.progress < 2) { + fprintf(stderr, " done\n"); + fflush(stderr); + } } - runstage(&conf, "update", install_files); - if (conf.verbose) { - fprintf(stderr, "installing files\n"); + + if (conf.ops_install > 0) { + if (conf.verbose) { + fprintf(stderr, "installing %lu file%s\n", conf.ops_install, conf.ops_install > 1 ? "s" : ""); + } + conf.reverse = 0; + conf.ops_completed = 0; + conf.ops_total = conf.ops_install; + runstage(&conf, "new", install_files); + if (conf.verbose && conf.progress < 2) { + fprintf(stderr, " done\n"); + fflush(stderr); + } } - runstage(&conf, "new", install_files); } }