static void do_test_cstat_set_backup_list(enum protocol protocol) { struct cstat *cstat; cstat=setup_cstat(CNAME, protocol); ck_assert_str_eq(CLIENTCONFDIR "/" CNAME, cstat->conffile); cstat->permitted=1; fail_unless(recursive_delete(BASE)==0); build_storage_dirs((struct sdirs *)cstat->sdirs, sd123, ARR_LEN(sd123)); fail_unless(!cstat_set_backup_list(cstat)); fail_unless(cstat->bu!=NULL); fail_unless(recursive_delete(BASE)==0); build_storage_dirs((struct sdirs *)cstat->sdirs, sd13, ARR_LEN(sd13)); fail_unless(!cstat_set_backup_list(cstat)); fail_unless(cstat->bu!=NULL); fail_unless(recursive_delete(BASE)==0); build_storage_dirs((struct sdirs *)cstat->sdirs, sd12345, ARR_LEN(sd12345)); fail_unless(!cstat_set_backup_list(cstat)); fail_unless(cstat->bu!=NULL); cstat->permitted=0; fail_unless(!cstat_set_backup_list(cstat)); fail_unless(cstat->bu==NULL); tear_down(&cstat); }
static void test_cstat_set_run_status_client_crashed(enum protocol protocol) { struct cstat *cstat; cstat=set_run_status_setup(protocol, 1 /*permitted*/); fail_unless(recursive_delete(BASE)==0); build_storage_dirs((struct sdirs *)cstat->sdirs, sd1w, ARR_LEN(sd1w)); cstat_set_run_status(cstat); fail_unless(cstat->run_status==RUN_STATUS_CLIENT_CRASHED); tear_down(&cstat); }
static void test_cstat_set_run_status_server_crashed(enum protocol protocol) { struct cstat *cstat; struct sdirs *sdirs; cstat=set_run_status_setup(protocol, 1 /*permitted*/); fail_unless(recursive_delete(BASE)==0); build_storage_dirs((struct sdirs *)cstat->sdirs, sd1w, ARR_LEN(sd1w)); sdirs=(struct sdirs *)cstat->sdirs; build_file(sdirs->lock->path, NULL); cstat_set_run_status(cstat); fail_unless(cstat->run_status==RUN_STATUS_SERVER_CRASHED); tear_down(&cstat); }
static struct sdirs *setup_sdirs(struct sd *s, int slen, enum protocol protocol) { struct sdirs *sdirs; fail_unless(recursive_delete(BASE)==0); fail_unless((sdirs=sdirs_alloc())!=NULL); fail_unless(!sdirs_init(sdirs, protocol, BASE, // directory "utestclient", // cname NULL, // client_lockdir "a_group", // dedup_group NULL // manual_delete )); build_storage_dirs(sdirs, s, slen); return sdirs; }
static void run_test(enum protocol protocol, int use_cache) { struct cstat *cstat; cstat=setup_cstat(CNAME, protocol); build_storage_dirs((struct sdirs *)cstat->sdirs, sd1, ARR_LEN(sd1)); cstat->permitted=1; fail_unless(!cstat_set_backup_list(cstat)); fail_unless(!browse_manifest( cstat, cstat->bu, NULL, // browse use_cache)); if(use_cache) cache_free(); tear_down(&cstat); }
END_TEST static void do_test_cstat_reload_from_client_confs(enum protocol protocol) { struct cstat *c1; struct cstat *c2; struct cstat *clist=NULL; c1=setup_cstat("cli1", protocol); c2=setup_cstat("cli2", protocol); cstat_add_to_list(&clist, c1); cstat_add_to_list(&clist, c2); c1->permitted=1; // First time, nothing is reloaded. fail_unless(reload_from_clientdir(&clist)==0); fail_unless(c1->run_status==RUN_STATUS_IDLE); fail_unless(c2->run_status==RUN_STATUS_UNSET); fail_unless(c1->bu==NULL); fail_unless(c2->bu==NULL); // Add some storage dirs, and c1 is loaded. build_storage_dirs((struct sdirs *)c1->sdirs, sd123, ARR_LEN(sd123)); fail_unless(reload_from_clientdir(&clist)==1); fail_unless(c1->run_status==RUN_STATUS_IDLE); fail_unless(c2->run_status==RUN_STATUS_UNSET); fail_unless(c1->bu!=NULL); fail_unless(c2->bu==NULL); // Go again, nothing should be reloaded. fail_unless(reload_from_clientdir(&clist)==0); // Get a lock. lock_get_quick(((struct sdirs *)c1->sdirs)->lock); fail_unless(reload_from_clientdir(&clist)==1); sdirs_free((struct sdirs **)&c1->sdirs); sdirs_free((struct sdirs **)&c2->sdirs); cstat_list_free(&clist); clean(); alloc_check(); }
static void run_test( int expected_result, int entries, void setup_datadir_tmp_callback( struct slist *slist, struct fdirs *fdirs, struct conf **confs)) { struct conf **confs; struct sdirs *sdirs; struct fdirs *fdirs; struct slist *slist; setup(&sdirs, &fdirs, &confs); build_storage_dirs(sdirs, sd1, ARR_LEN(sd1)); slist=build_manifest( fdirs->manifest, PROTO_1, entries, /*phase*/ 3); setup_datadir_tmp_callback(slist, fdirs, confs); clock_t start; clock_t diff; start = clock(); fail_unless(backup_phase4_server_protocol1(sdirs, confs) ==expected_result); diff = clock() - start; int msec = diff * 1000 / CLOCKS_PER_SEC; printf("%d.%d\n", msec/1000, msec%1000); log_fzp_set(NULL, confs); assert_datadir(slist, fdirs); slist_free(&slist); tear_down(&sdirs, &fdirs, &confs); }
static void test_cstat_set_run_status_running(enum protocol protocol) { int waitstat; struct cstat *cstat; struct sdirs *sdirs; struct lock *lock; cstat=set_run_status_setup(protocol, 1 /*permitted*/); clean(); build_storage_dirs((struct sdirs *)cstat->sdirs, sd1w, ARR_LEN(sd1w)); sdirs=(struct sdirs *)cstat->sdirs; lock=sdirs->lock; switch(fork()) { case -1: fail_unless(0==1); break; case 0: // Child. { lock_get_quick(lock); sleep(2); lock_release(lock); exit(0); } default: break; } // Parent. sleep(1); lock_get(lock); fail_unless(lock->status==GET_LOCK_NOT_GOT); cstat_set_run_status(cstat); fail_unless(cstat->run_status==RUN_STATUS_RUNNING); wait(&waitstat); tear_down(&cstat); }
static void do_test_json_send_clients_with_backup(const char *path, struct sd *sd, int s, const char *specific_client) { struct asfd *asfd; struct cstat *c=NULL; struct cstat *clist=NULL; const char *cnames[] = {"cli1", "cli2", "cli3", NULL}; fail_unless(recursive_delete(CLIENTCONFDIR)==0); build_clientconfdir_files(cnames, NULL); fail_unless(!cstat_get_client_names(&clist, CLIENTCONFDIR)); assert_cstat_list(clist, cnames); for(c=clist; c; c=c->next) { c->permitted=1; c->protocol=PROTO_1; fail_unless((c->sdirs=setup_sdirs(c->protocol, c->name))!=NULL); build_storage_dirs((struct sdirs *)c->sdirs, sd, s); fail_unless(!cstat_set_backup_list(c)); fail_unless(c->bu!=NULL); // Hack the cntr timestamps so that they are always the same. c->cntr->ent[(uint8_t)CMD_TIMESTAMP]->count=200; c->cntr->ent[(uint8_t)CMD_TIMESTAMP_END]->count=400; } asfd=asfd_setup(path); c=NULL; if(specific_client) fail_unless((c=cstat_get_by_name(clist, specific_client))!=NULL); fail_unless(!json_send(asfd, clist, c, NULL, NULL, NULL, 0/*cache*/)); cstat_list_free_sdirs(clist); cstat_list_free(&clist); fail_unless(!recursive_delete(SDIRS)); tear_down(&asfd); }
static void run_test(int expected_ret, enum protocol protocol, int manio_entries, int blocks_per_file, void setup_asfds_callback(struct asfd *asfd, struct slist *slist)) { struct async *as; struct asfd *asfd; struct sdirs *sdirs; struct conf **confs; struct slist *slist=NULL; char *dir_for_notify=NULL; prng_init(0); base64_init(); hexmap_init(); setup(protocol, &as, &sdirs, &confs); set_string(confs[OPT_BACKUP], "1"); set_protocol(confs, protocol); asfd=asfd_mock_setup(&reads, &writes); as->asfd_add(as, asfd); as->read_write=async_rw_simple; as->read_quick=async_rw_simple; asfd->as=as; build_storage_dirs(sdirs, sd1, ARR_LEN(sd1)); if(manio_entries) { struct sbuf *s; if(protocol==PROTO_2) slist=build_manifest_with_data_files(sdirs->cmanifest, sdirs->data, manio_entries, blocks_per_file); else { slist=build_manifest(sdirs->cmanifest, protocol, manio_entries, 0 /*phase*/); for(s=slist->head; s; s=s->next) { char path[256]; if(!sbuf_is_filedata(s)) continue; snprintf(path, sizeof(path), "%s/%s%s", sdirs->currentdata, TREE_DIR, s->path.buf); build_file(path, "data"); } } } setup_asfds_callback(asfd, slist); fail_unless(do_restore_server( asfd, sdirs, ACTION_RESTORE, 0, // srestore &dir_for_notify, confs )==expected_ret); if(!expected_ret) { // FIX THIS: Should check for the presence and correctness of // changed and unchanged manios. } slist_free(&slist); free_w(&dir_for_notify); tear_down(&as, &asfd, &sdirs, &confs); }