dav: comparison dav/sync.c

-:4e3769d4e782
+:395763c0ee69
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
 #include <unistd.h>
+#include <signal.h>
 #include <time.h>
 #include <libxml/xmlerror.h>
 #include <sys/types.h>
 #include <ucx/string.h>
 #include <ucx/utils.h>
 #include "assistant.h"
 #include "sync.h"
 #include "libidav/session.h"
+#include <pthread.h>
 static DavContext *ctx;
+static int sync_shutdown = 0;
 static void xmlerrorfnc(void * c, const char * msg, ... ) {
 va_list ap;
 va_start(ap, msg);
 vfprintf(stderr, msg, ap);
 xmlGenericErrorFunc fnc = xmlerrorfnc;
 initGenericErrorDefaultFunc(&fnc);
 ctx = dav_context_new();
 int cfgret = load_config(ctx) || load_sync_config();
+pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+pthread_mutex_lock(&mutex);
+pthread_t tid;
 if(!strcmp(cmd, "check") || !strcmp(cmd, "check-config")) {
 if(!cfgret) {
 fprintf(stdout, "Configuration OK.\n");
 ret = EXIT_SUCCESS;
 /* no output, the warnings are written by load_config */
 ret = EXIT_FAILURE;
 }
 } else if(!cfgret) {
 if(!strcmp(cmd, "pull")) {
+tid = start_sighandler(&mutex);
 ret = cmd_pull(args);
+stop_sighandler(&mutex, tid);
 } else if(!strcmp(cmd, "push")) {
+tid = start_sighandler(&mutex);
 ret = cmd_push(args, FALSE);
+stop_sighandler(&mutex, tid);
 } else if(!strcmp(cmd, "archive")) {
+tid = start_sighandler(&mutex);
 ret = cmd_push(args, TRUE);
+stop_sighandler(&mutex, tid);
 } else if(!strcmp(cmd, "resolve-conflicts")) {
 ret = cmd_resolve_conflicts(args);
 } else if(!strcmp(cmd, "delete-conflicts")) {
 ret = cmd_delete_conflicts(args);
 } else if(!strcmp(cmd, "trash-info")) {
 fprintf(stderr, "        list-directories\n");
 fprintf(stderr, "        check-config\n");
 fprintf(stderr, "        check-repositories\n\n");
 }
+static void handlesig(int sig) {
+if(sync_shutdown) {
+exit(-1);
+}
+fprintf(stderr, "abort\n");
+sync_shutdown = 1;
+}
+static void* sighandler(void *data) {
+signal(SIGTERM, handlesig);
+signal(SIGINT, handlesig);
+pthread_mutex_t *mutex = data;
+pthread_mutex_lock(mutex); // block thread
+return NULL;
+}
+pthread_t start_sighandler(pthread_mutex_t *mutex) {
+pthread_t tid;
+if(pthread_create(&tid, NULL, sighandler, mutex)) {
+perror("pthread_create");
+exit(-1);
+}
+return tid;
+}
+void stop_sighandler(pthread_mutex_t *mutex, pthread_t tid) {
+pthread_mutex_unlock(mutex);
+void *data;
+pthread_join(tid, &data);
+}
 static int res_matches_filter(SyncDirectory *dir, char *res_path) {
 // trash filter
 if (dir->trash) {
 sstr_t rpath = sstr(util_concat_path(dir->path, res_path));
 if (sstrprefix(rpath, sstr(dir->trash))) {
 res = res->next;
 continue;
 }
 // download the resource
-if(sync_get_resource(a, dir, res, db, &sync_success)) {
+if(!sync_shutdown && sync_get_resource(a, dir, res, db, &sync_success)) {
 fprintf(stderr, "sync_get_resource failed for resource: %s\n", res->path);
 sync_error++;
 }
 // add every resource from the server to svrres
 // then db-resources contains only resources which are not on the
 // server
-LocalResource *local = ucx_map_cstr_get(db->resources, res->path);
+LocalResource *local = ucx_map_cstr_remove(db->resources, res->path);
-ucx_map_cstr_put(svrres, res->path, local);
+if(local) {
-ucx_map_cstr_remove(db->resources, res->path);
+ucx_map_cstr_put(svrres, res->path, local);
 if(local->last_modified == 0) {
 // stat this file later (directory)
 statls = ucx_list_prepend(statls, local);
 }
+} // else: sync_shutdown is TRUE
 if(res->children) {
 stack = ucx_list_prepend(stack, res->children);
 }
 res = res->next;
 UcxList *rmdirs = NULL;
 UCX_MAP_FOREACH(key, local, i) {
 if (res_matches_filter(dir, local->path)) {
 continue;
 }
-// sync_remove_resource does all necessary tests
-int ret = sync_remove_local_resource(dir, local);
+if(sync_shutdown) {
-if(ret == -1) {
+ucx_map_cstr_put(svrres, local->path, local_resource_copy(local));
-rmdirs = ucx_list_append(rmdirs, local);
+} else {
-} else if(ret == 0) {
+// sync_remove_resource does all necessary tests
-sync_delete++;
+int ret = sync_remove_local_resource(dir, local);
+if(ret == -1) {
+rmdirs = ucx_list_append(rmdirs, local);
+} else if(ret == 0) {
+sync_delete++;
+}
 }
 }
 UCX_FOREACH(elm, rmdirs) {
 LocalResource *local_dir = elm->data;
 sync_remove_local_directory(dir, local_dir);
 UcxMap *lclres = ucx_map_new(db->resources->count);
 int ret = 0;
 UCX_FOREACH(elm, resources) {
 LocalResource *local_res = elm->data;
 if (!res_matches_filter(dir, local_res->path+1)) {
+if(sync_shutdown) {
+LocalResource *lr = ucx_map_cstr_remove(db->resources, local_res->path);
+if(lr) {
+local_res->size = lr->size;
+local_res->last_modified = lr->last_modified;
+local_res->etag = lr->etag ? strdup(lr->etag) : NULL;
+local_resource_free(lr);
+ucx_map_cstr_put(lclres, local_res->path, local_res);
+}
+elm->data = NULL;
+continue;
+}
 if(res_isconflict(db, local_res)) {
 printf("skip: %s\n", local_res->path);
 sync_skipped++;
 continue;
 }
 // upload every changed file
 int error = 0;
 if (local_resource_is_changed(dir, db, local_res)) {
 DavResource *res = dav_resource_new(sn, local_res->path);
 if(!res) {
 if(ret == 0 && !archive) {
 UcxMapIterator i = ucx_map_iterator(db->resources);
 LocalResource *local;
 UCX_MAP_FOREACH(key, local, i) {
 if (!res_matches_filter(dir, local->path+1)) {
-if(sync_delete_remote_resource(sn, local, &sync_delete)) {
+if(sync_shutdown) {
-ucx_map_cstr_put(lclres, local->path, local);
+ucx_map_cstr_put(lclres, local->path, local_resource_copy(local));
+} else if(sync_delete_remote_resource(sn, local, &sync_delete)) {
+ucx_map_cstr_put(lclres, local->path, local_resource_copy(local));
 if(sn->error != DAV_NOT_FOUND) {
 print_resource_error(sn, local->path);
 sync_error++;
 break;
 }
 res->path = util_concat_path(path, "/");
 res->last_modified = s.st_mtime;
 res->isdirectory = 1;
 return res;
 }
+}
+LocalResource* local_resource_copy(LocalResource *res) {
+LocalResource *newres = calloc(1, sizeof(LocalResource));
+if(res->name) {
+newres->name = strdup(res->name);
+}
+if(res->path) {
+newres->path = strdup(res->path);
+}
+if(res->etag) {
+newres->etag = strdup(res->etag);
+}
+newres->skipped = res->skipped;
+newres->size = res->size;
+newres->last_modified = res->last_modified;
+newres->isdirectory = res->isdirectory;
+return newres;
 }
 int local_resource_is_changed(SyncDirectory *dir, SyncDatabase *db, LocalResource *res) {
 LocalResource *db_res = ucx_map_cstr_get(db->resources, res->path);
 if(db_res) {

Mercurial > hg > dav / file comparison

comparison: dav/sync.c

dav/sync.c