int csync_walker(CSYNC *ctx, const char *file, const csync_vio_file_stat_t *fs,
enum csync_ftw_flags_e flag) {
switch (flag) {
case CSYNC_FTW_FLAG_FILE:
CSYNC_LOG(CSYNC_LOG_PRIORITY_TRACE, "file: %s", file);
return _csync_detect_update(ctx, file, fs, CSYNC_FTW_TYPE_FILE);
break;
case CSYNC_FTW_FLAG_SLINK:
/* FIXME: implement support for symlinks, see csync_propagate.c too */
#if 0
if (ctx->options.sync_symbolic_links) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_TRACE, "symlink: %s", file);
return _csync_detect_update(ctx, file, fs, CSYNC_FTW_TYPE_SLINK);
}
#endif
break;
case CSYNC_FTW_FLAG_DIR: /* enter directory */
CSYNC_LOG(CSYNC_LOG_PRIORITY_TRACE, "directory: %s", file);
return _csync_detect_update(ctx, file, fs, CSYNC_FTW_TYPE_DIR);
case CSYNC_FTW_FLAG_NSTAT: /* not statable file */
case CSYNC_FTW_FLAG_DNR:
case CSYNC_FTW_FLAG_DP:
case CSYNC_FTW_FLAG_SLN:
break;
default:
break;
}
return 0;
}
static void check_csync_detect_update_db_new(void **state)
{
CSYNC *csync = *state;
csync_file_stat_t *st;
csync_vio_file_stat_t *fs;
int rc;
fs = create_fstat("file.txt", 42000, 1, 0);
assert_non_null(fs);
rc = _csync_detect_update(csync,
"/tmp/check_csync1/file.txt",
fs,
CSYNC_FTW_TYPE_FILE);
assert_int_equal(rc, 0);
/* the instruction should be set to new */
st = c_rbtree_node_data(csync->local.tree->root);
assert_int_equal(st->instruction, CSYNC_INSTRUCTION_NEW);
/* set the instruction to UPDATED that it gets written to the statedb */
st->instruction = CSYNC_INSTRUCTION_UPDATED;
/* create a statedb */
csync_set_status(csync, 0xFFFF);
csync_vio_file_stat_destroy(fs);
}
static void check_csync_detect_update_db_rename(void **state)
{
CSYNC *csync = *state;
// csync_file_stat_t *st;
csync_vio_file_stat_t *fs;
int rc = 0;
fs = create_fstat("wurst.txt", 0, 1, 42);
assert_non_null(fs);
csync_set_statedb_exists(csync, 1);
rc = _csync_detect_update(csync,
"/tmp/check_csync1/wurst.txt",
fs,
CSYNC_FTW_TYPE_FILE);
assert_int_equal(rc, 0);
/* the instruction should be set to rename */
/*
* temporarily broken.
st = c_rbtree_node_data(csync->local.tree->root);
assert_int_equal(st->instruction, CSYNC_INSTRUCTION_RENAME);
st->instruction = CSYNC_INSTRUCTION_UPDATED;
*/
/* create a statedb */
csync_set_status(csync, 0xFFFF);
csync_vio_file_stat_destroy(fs);
}
static void check_csync_detect_update_null(void **state)
{
CSYNC *csync = (CSYNC*)*state;
std::unique_ptr<csync_file_stat_t> fs;
int rc;
rc = _csync_detect_update(csync, NULL);
assert_int_equal(rc, -1);
}
int csync_walker(CSYNC *ctx, const char *file, const csync_vio_file_stat_t *fs,
enum csync_ftw_flags_e flag) {
int rc = -1;
int type = CSYNC_FTW_TYPE_SKIP;
csync_file_stat_t *st = NULL;
uint64_t h;
if (ctx->abort) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_TRACE, "Aborted!");
ctx->status_code = CSYNC_STATUS_ABORTED;
return -1;
}
switch (flag) {
case CSYNC_FTW_FLAG_FILE:
CSYNC_LOG(CSYNC_LOG_PRIORITY_TRACE, "file: %s [file_id=%s]", file, fs->file_id);
type = CSYNC_FTW_TYPE_FILE;
break;
case CSYNC_FTW_FLAG_DIR: /* enter directory */
CSYNC_LOG(CSYNC_LOG_PRIORITY_TRACE, "directory: %s [file_id=%s]", file, fs->file_id);
type = CSYNC_FTW_TYPE_DIR;
break;
case CSYNC_FTW_FLAG_NSTAT: /* not statable file */
/* if file was here before and now is not longer stat-able, still
* add it to the db, otherwise not. */
h = _hash_of_file( ctx, file );
if( h == 0 ) {
return 0;
}
st = csync_statedb_get_stat_by_hash(ctx, h);
if( !st ) {
return 0;
}
csync_file_stat_free(st);
st = NULL;
type = CSYNC_FTW_TYPE_SKIP;
break;
case CSYNC_FTW_FLAG_SLINK:
CSYNC_LOG(CSYNC_LOG_PRIORITY_TRACE, "symlink: %s - not supported", file);
type = CSYNC_FTW_TYPE_SLINK;
break;
case CSYNC_FTW_FLAG_DNR:
case CSYNC_FTW_FLAG_DP:
case CSYNC_FTW_FLAG_SLN:
default:
return 0;
break;
}
rc = _csync_detect_update(ctx, file, fs, type );
return rc;
}
static void check_csync_detect_update_null(void **state)
{
CSYNC *csync = *state;
csync_vio_file_stat_t *fs;
int rc;
fs = create_fstat("file.txt", 0, 1, 0);
assert_non_null(fs);
rc = _csync_detect_update(csync,
NULL,
fs,
CSYNC_FTW_TYPE_FILE);
assert_int_equal(rc, -1);
rc = _csync_detect_update(csync,
"/tmp/check_csync1/file.txt",
NULL,
CSYNC_FTW_TYPE_FILE);
assert_int_equal(rc, -1);
csync_vio_file_stat_destroy(fs);
}
static void check_csync_detect_update_db_eval(void **state)
{
CSYNC *csync = (CSYNC*)*state;
csync_file_stat_t *st;
std::unique_ptr<csync_file_stat_t> fs;
int rc;
fs = create_fstat("file.txt", 0, 42);
rc = _csync_detect_update(csync, std::move(fs));
assert_int_equal(rc, 0);
/* the instruction should be set to new */
st = csync->local.files.begin()->second.get();
assert_int_equal(st->instruction, CSYNC_INSTRUCTION_NEW);
/* create a statedb */
csync_set_status(csync, 0xFFFF);
}
static void check_csync_detect_update_nlink(void **state)
{
CSYNC *csync = *state;
csync_file_stat_t *st;
csync_vio_file_stat_t *fs;
int rc;
/* create vio file stat with nlink greater than 1 */
fs = create_fstat("file.txt", 0, 7, 0);
assert_non_null(fs);
/* add it to local tree */
rc = _csync_detect_update(csync,
"/tmp/check_csync1/file.txt",
fs,
CSYNC_FTW_TYPE_FILE);
assert_int_equal(rc, 0);
/* the instruction should be set to ignore */
st = c_rbtree_node_data(csync->local.tree->root);
assert_int_equal(st->instruction, CSYNC_INSTRUCTION_IGNORE);
csync_vio_file_stat_destroy(fs);
}
static void check_csync_detect_update_db_rename(void **state)
{
CSYNC *csync = (CSYNC*)*state;
// csync_file_stat_t *st;
std::unique_ptr<csync_file_stat_t> fs;
int rc = 0;
fs = create_fstat("wurst.txt", 0, 42);
rc = _csync_detect_update(csync, std::move(fs));
assert_int_equal(rc, 0);
/* the instruction should be set to rename */
/*
* temporarily broken.
st = csync->local.files.begin()->second.get();
assert_int_equal(st->instruction, CSYNC_INSTRUCTION_RENAME);
st->instruction = CSYNC_INSTRUCTION_UPDATED;
*/
/* create a statedb */
csync_set_status(csync, 0xFFFF);
}
