mirrors/nextcloud-desktop
1
0
Fork 0
mirror of https://github.com/nextcloud/desktop.git synced 2024-11-28 11:48:56 +03:00
Code Issues Projects Releases Packages Wiki Activity

Do not fetch folder id after propagation.

Browse source 
Delay that for the next sync.
This commit is contained in:
Olivier Goffart 2013-03-05 20:02:44 +01:00
parent 259b6050bf
commit 1eb534dd53
4 changed files with 0 additions and 214 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

25
src/csync.c
View file

@ -534,29 +534,6 @@ int csync_propagate(CSYNC *ctx) {
return -1;
}
csync_gettime(&start);
ctx->current = LOCAL_REPLICA;
ctx->replica = ctx->local.type;
rc = csync_correct_id(ctx);
if (rc < 0) {
ctx->error_code = CSYNC_ERR_PROPAGATE;
return -1;
}
ctx->current = REMOTE_REPLICA;
ctx->replica = ctx->remote.type;
rc = csync_correct_id(ctx);
if (rc < 0) {
ctx->error_code = CSYNC_ERR_PROPAGATE;
return -1;
}
csync_gettime(&finish);
CSYNC_LOG(CSYNC_LOG_PRIORITY_DEBUG,
"Correct Id took. %.2f seconds ",
c_secdiff(finish, start));
ctx->status |= CSYNC_STATUS_PROPAGATE;
return 0;
@ -768,10 +745,8 @@ int csync_destroy(CSYNC *ctx) {
/* free memory */
c_rbtree_free(ctx->local.tree);
c_list_free(ctx->local.list);
c_list_free(ctx->local.id_list);
c_rbtree_free(ctx->remote.tree);
c_list_free(ctx->remote.list);
c_list_free(ctx->remote.id_list);
SAFE_FREE(ctx->local.uri);
SAFE_FREE(ctx->remote.uri);
SAFE_FREE(ctx->options.config_dir);

1
src/csync_private.h
View file

@ -110,7 +110,6 @@ struct csync_s {
char *uri;
c_rbtree_t *tree;
c_list_t *list;
c_list_t *id_list;
enum csync_replica_e type;
int read_from_db;
} remote;

186
src/csync_propagate.c
View file

@ -57,28 +57,6 @@ static int _csync_cleanup_cmp(const void *a, const void *b) {
return strcmp(st_a->path, st_b->path);
}
static void _store_id_update(CSYNC *ctx, csync_file_stat_t *st) {
c_list_t *list = NULL;
CSYNC_LOG(CSYNC_LOG_PRIORITY_DEBUG, "SYNCED remember dir: %s", st->path);
switch (ctx->current) {
case LOCAL_REPLICA:
list = c_list_prepend(ctx->local.id_list, (void*)st);
if( list != NULL ) {
ctx->local.id_list = list;
}
break;
case REMOTE_REPLICA:
list = c_list_prepend(ctx->remote.id_list, (void*)st);
if(list != NULL ) {
ctx->remote.id_list = list;
}
break;
}
}
/* Record the error in the ctx->progress
pi may be a previous csync_progressinfo_t from the database.
If pi is NULL, a new one is created, else it is re-used
@ -551,9 +529,6 @@ static int _csync_push_file(CSYNC *ctx, csync_file_stat_t *st) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_DEBUG, "PUSHED file: %s", duri);
rc = 0;
if (ctx->current == LOCAL_REPLICA) {
_store_id_update(ctx, st);
}
out:
ctx->replica = srep;
@ -837,10 +812,6 @@ static int _csync_rename_file(CSYNC *ctx, csync_file_stat_t *st) {
}
CSYNC_LOG(CSYNC_LOG_PRIORITY_DEBUG, "RENAME file: %s => %s with ID %s", st->path, st->destpath, st->md5);
if (ctx->current == REMOTE_REPLICA) {
_store_id_update(ctx, st);
}
out:
SAFE_FREE(suri);
SAFE_FREE(duri);
@ -934,11 +905,6 @@ static int _csync_remove_file(CSYNC *ctx, csync_file_stat_t *st) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_DEBUG, "REMOVED file: %s", uri);
if (ctx->current == REMOTE_REPLICA) {
_store_id_update(ctx, st);
}
rc = 0;
out:
SAFE_FREE(uri);
@ -1037,10 +1003,6 @@ static int _csync_new_dir(CSYNC *ctx, csync_file_stat_t *st) {
csync_vio_utimes(ctx, uri, times);
if (ctx->replica == REMOTE_REPLICA) {
_store_id_update(ctx, st);
}
/* set instruction for the statedb merger */
st->instruction = CSYNC_INSTRUCTION_UPDATED;
@ -1127,9 +1089,6 @@ static int _csync_sync_dir(CSYNC *ctx, csync_file_stat_t *st) {
times[0].tv_usec = times[1].tv_usec = 0;
csync_vio_utimes(ctx, uri, times);
if (ctx->replica == REMOTE_REPLICA) {
_store_id_update(ctx, st);
}
/* set instruction for the statedb merger */
st->instruction = CSYNC_INSTRUCTION_UPDATED;
@ -1263,151 +1222,6 @@ static int _cmp_char( const void *d1, const void *d2 )
return 1;
}
/* Internal helper method for _csync_correct_id */
static void _csync_correct_id_helper(CSYNC *ctx, char *path, c_list_t **seen_dirs, c_rbtree_t *tree)
{
while( path ) {
uint64_t h;
int len;
c_rbnode_t *node = NULL;
char *old_path = path;
csync_file_stat_t *tfs = NULL;
/* do stuff with the dir here */
if( *seen_dirs && c_list_find_custom( *seen_dirs, path, _cmp_char)) {
// CSYNC_LOG(CSYNC_LOG_PRIORITY_TRACE, "saw this dir already: %s", path);
} else {
CSYNC_LOG(CSYNC_LOG_PRIORITY_TRACE, "climb on dir: %s", path);
*seen_dirs = c_list_prepend( *seen_dirs, c_strdup(path));
/* Find the correct target entry. */
len = strlen(path);
h = c_jhash64((uint8_t *) path, len, 0);
node = c_rbtree_find(tree, &h);
if (node == NULL) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_ERROR, "Unable to find node");
} else {
tfs = c_rbtree_node_data(node);
if( tfs ) {
if(tfs->instruction == CSYNC_INSTRUCTION_DELETED) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_TRACE, "Skipping update of MD5 because item is deleted.");
} else {
if(tfs->md5) SAFE_FREE(tfs->md5);
tfs->md5 = _get_md5(ctx, path);
CSYNC_LOG(CSYNC_LOG_PRIORITY_TRACE, "MD5 for dir: %s %s (Instruction: %s)", tfs->path,
tfs->md5, csync_instruction_str(tfs->instruction));
if( tfs->md5 && tfs->instruction == CSYNC_INSTRUCTION_NONE ) {
/* set instruction for the statedb merger */
tfs->instruction = CSYNC_INSTRUCTION_UPDATED;
}
}
}
}
}
/* get the parent dir */
path = c_dirname( path );
/* free the old path memory */
SAFE_FREE(old_path );
/* exit on top directory */
if( c_streq(path, ".")) {
SAFE_FREE(path);
path = NULL;
}
}
}
/*
* This function corrects the unique IDs of parent directories of changed
* files. Other than in the file system, the change of a unique Id propagates
* up to the top dir. To save the correct IDs, in all propagations, pathes
* are recorded in the local and remotes id_list lists.
* In this function, the unique ID is queried for each directory once and
* stored into the according entry.
*/
int csync_correct_id(CSYNC *ctx) {
c_list_t *walk = NULL;
c_list_t *seen_dirs = NULL;
c_list_t *list = NULL;
c_rbtree_t *tree = NULL;
char *path = NULL;
switch (ctx->current) {
case LOCAL_REPLICA:
list = ctx->local.id_list;
tree = ctx->local.tree;
break;
case REMOTE_REPLICA:
list = ctx->remote.id_list;
tree = ctx->remote.tree;
break;
default:
break;
}
if (list == NULL) {
return 0;
}
list = c_list_sort(list, _csync_cleanup_cmp);
if (list == NULL) {
return -1;
}
for (walk = c_list_last(list); walk != NULL; walk = c_list_prev(walk)) {
csync_file_stat_t *st = NULL;
st = (csync_file_stat_t *) walk->data;
if( st->type == CSYNC_FTW_TYPE_FILE ) {
path = c_dirname( st->path );
} else if( st->type == CSYNC_FTW_TYPE_DIR ) {
path = c_strdup(st->path); /* Allocate mem for this not to disappoint FREE */
} else {
/* unhandled path */
}
CSYNC_LOG(CSYNC_LOG_PRIORITY_TRACE, "correct ID on dir: %s", path);
/* handle the . path */
if( path && path[0] == '.' && strlen(path) == 1) {
SAFE_FREE(path);
path = NULL;
}
_csync_correct_id_helper(ctx, path, &seen_dirs, tree);
if (st->type == CSYNC_FTW_TYPE_FILE && ctx->current == REMOTE_REPLICA
&& st->destpath) {
path = c_dirname( st->destpath );
if( path && path[0] == '.' && strlen(path) == 1) {
SAFE_FREE(path);
path = NULL;
}
_csync_correct_id_helper(ctx, path, &seen_dirs, ctx->local.tree);
}
}
/* Free the seen_dirs list */
if( seen_dirs ) {
c_list_t *walk1 = NULL;
for (walk1 = c_list_first(seen_dirs); walk1 != NULL; walk1 = c_list_next(walk1)) {
char *data = NULL;
data = (char*) walk1->data;
SAFE_FREE(data);
}
}
c_list_free(seen_dirs);
return 0;
}
static int _csync_propagation_cleanup(CSYNC *ctx) {
c_list_t *list = NULL;
c_list_t *walk = NULL;

2
src/csync_propagate.h
View file

@ -65,8 +65,6 @@
*/
int csync_propagate_files(CSYNC *ctx);
int csync_correct_id(CSYNC *ctx);
int csync_propagate_rename_file(CSYNC *ctx, csync_file_stat_t *st);
/**