/** * Create a per-tx temp-dir if we don't already have one. * */ void sg_wc_tx__create_session_temp_dir(SG_context * pCtx, SG_wc_tx * pWcTx) { char bufTidSession[SG_TID_MAX_BUFFER_LENGTH]; SG_uint32 nrDigits = 10; if (pWcTx->pPathSessionTempDir) return; // pick a space in /tmp for exporting temporary copies of the files // so that internal and/or external tools can compare them. // // TODO 2012/05/02 Investigate the use of SG_workingdir__get_temp_path() (which // TODO creates things in .sgdrawer rather than /tmp). // TODO (see also sg_mrg__private_file_mrg.h) // TODO See also sg_vv2__diff__create_session_temp_dir(). SG_ERR_CHECK( SG_PATHNAME__ALLOC__USER_TEMP_DIRECTORY(pCtx, &pWcTx->pPathSessionTempDir) ); SG_ERR_CHECK( SG_tid__generate2(pCtx, bufTidSession, sizeof(bufTidSession), nrDigits) ); SG_ERR_CHECK( SG_pathname__append__from_sz(pCtx, pWcTx->pPathSessionTempDir, bufTidSession) ); SG_ERR_TRY( SG_fsobj__mkdir_recursive__pathname(pCtx, pWcTx->pPathSessionTempDir) ); SG_ERR_CATCH_IGNORE( SG_ERR_DIR_ALREADY_EXISTS ); SG_ERR_CATCH_END; #if 0 && defined(DEBUG) SG_ERR_IGNORE( SG_console(pCtx, SG_CS_STDERR, "CreateSessionTempDir: %s\n", SG_pathname__sz(pWcTx->pPathSessionTempDir)) ); #endif fail: return; }
void u0048_multidag_test__1(SG_context * pCtx) { char bufName[SG_TID_MAX_BUFFER_LENGTH + u0048_multidag__MY_LABEL_LENGTH]; SG_repo* pRepo = NULL; SG_rbtree* prb = NULL; SG_uint32 count; char* pid1 = NULL; char* pid1a = NULL; char* pid1b = NULL; char* pid1c = NULL; char* pid2 = NULL; char* pid2a = NULL; char* pid2b = NULL; VERIFY_ERR_CHECK( SG_strcpy(pCtx, bufName, sizeof(bufName), u0048_multidag__MY_LABEL) ); VERIFY_ERR_CHECK( SG_tid__generate2(pCtx, &bufName[u0048_multidag__MY_LABEL_LENGTH], (sizeof(bufName) - u0048_multidag__MY_LABEL_LENGTH), 32) ); /* create the repo */ VERIFY_ERR_CHECK( u0048_multidag__new_repo(pCtx, bufName, &pRepo) ); VERIFY_ERR_CHECK( u0048_multidag__add_dagnode(pCtx, &pid1, NULL, SG_DAGNUM__TESTING__NOTHING, pRepo) ); VERIFY_ERR_CHECK( u0048_multidag__add_dagnode(pCtx, &pid1a, pid1, SG_DAGNUM__TESTING__NOTHING, pRepo) ); VERIFY_ERR_CHECK( u0048_multidag__add_dagnode(pCtx, &pid1b, pid1, SG_DAGNUM__TESTING__NOTHING, pRepo) ); VERIFY_ERR_CHECK( u0048_multidag__add_dagnode(pCtx, &pid1c, pid1, SG_DAGNUM__TESTING__NOTHING, pRepo) ); VERIFY_ERR_CHECK( u0048_multidag__add_dagnode(pCtx, &pid2, NULL, SG_DAGNUM__TESTING2__NOTHING, pRepo) ); VERIFY_ERR_CHECK( u0048_multidag__add_dagnode(pCtx, &pid2a, pid2, SG_DAGNUM__TESTING2__NOTHING, pRepo) ); VERIFY_ERR_CHECK( u0048_multidag__add_dagnode(pCtx, &pid2b, pid2, SG_DAGNUM__TESTING2__NOTHING, pRepo) ); SG_NULLFREE(pCtx, pid1); SG_NULLFREE(pCtx, pid1a); SG_NULLFREE(pCtx, pid1b); SG_NULLFREE(pCtx, pid1c); SG_NULLFREE(pCtx, pid2); SG_NULLFREE(pCtx, pid2a); SG_NULLFREE(pCtx, pid2b); VERIFY_ERR_CHECK( SG_repo__fetch_dag_leaves(pCtx, pRepo, SG_DAGNUM__TESTING__NOTHING, &prb) ); VERIFY_ERR_CHECK( SG_rbtree__count(pCtx, prb, &count) ); SG_RBTREE_NULLFREE(pCtx, prb); VERIFY_COND("count", (3 == count)); VERIFY_ERR_CHECK( SG_repo__fetch_dag_leaves(pCtx, pRepo, SG_DAGNUM__TESTING2__NOTHING, &prb) ); VERIFY_ERR_CHECK( SG_rbtree__count(pCtx, prb, &count) ); SG_RBTREE_NULLFREE(pCtx, prb); VERIFY_COND("count", (2 == count)); SG_REPO_NULLFREE(pCtx, pRepo); return; fail: SG_REPO_NULLFREE(pCtx, pRepo); }
void u0051_hidlookup_test__1(SG_context * pCtx, SG_pathname* pPathTopDir) { char bufName[SG_TID_MAX_BUFFER_LENGTH]; SG_pathname* pPathWorkingDir = NULL; SG_pathname* pPathFile = NULL; SG_dagnode* pdn = NULL; const char* psz_hid_cs = NULL; SG_repo* pRepo = NULL; char buf_partial[256]; char* psz_result = NULL; SG_audit q; VERIFY_ERR_CHECK( SG_tid__generate2(pCtx, bufName, sizeof(bufName), 32) ); /* create the working dir */ VERIFY_ERR_CHECK( SG_PATHNAME__ALLOC__PATHNAME_SZ(pCtx, &pPathWorkingDir, pPathTopDir, bufName) ); VERIFY_ERR_CHECK( SG_fsobj__mkdir__pathname(pCtx, pPathWorkingDir) ); /* add stuff */ VERIFY_ERR_CHECK( u0051_hidlookup__create_file__numbers(pCtx, pPathWorkingDir, "aaa", 20) ); /* create the repo */ VERIFY_ERR_CHECK( _ut_pt__new_repo(pCtx, bufName, pPathWorkingDir) ); VERIFY_ERR_CHECK( _ut_pt__addremove(pCtx, pPathWorkingDir) ); VERIFY_ERR_CHECK( u0051_hidlookup__commit_all(pCtx, pPathWorkingDir, &pdn) ); VERIFY_ERR_CHECK( SG_dagnode__get_id_ref(pCtx, pdn, &psz_hid_cs) ); VERIFY_ERR_CHECK( SG_repo__open_repo_instance(pCtx, bufName, &pRepo) ); VERIFY_ERR_CHECK( SG_audit__init(pCtx, &q, pRepo, SG_AUDIT__WHEN__NOW, SG_AUDIT__WHO__FROM_SETTINGS) ); VERIFY_ERR_CHECK( SG_vc_tags__add(pCtx, pRepo, psz_hid_cs, "remember", &q) ); VERIFY_ERR_CHECK( SG_strcpy(pCtx, buf_partial, sizeof(buf_partial), psz_hid_cs) ); buf_partial[10] = 0; VERIFY_ERR_CHECK( SG_repo__hidlookup__dagnode(pCtx, pRepo, SG_DAGNUM__VERSION_CONTROL, buf_partial, &psz_result) ); VERIFY_COND("found", (0 == strcmp(psz_result, psz_hid_cs))); SG_NULLFREE(pCtx, psz_result); VERIFY_ERR_CHECK( SG_repo__hidlookup__blob(pCtx, pRepo, buf_partial, &psz_result) ); VERIFY_COND("found", (0 == strcmp(psz_result, psz_hid_cs))); SG_NULLFREE(pCtx, psz_result); VERIFY_ERR_CHECK( SG_vc_tags__lookup__tag(pCtx, pRepo, "remember", &psz_result) ); VERIFY_COND("found", (0 == strcmp(psz_result, psz_hid_cs))); SG_NULLFREE(pCtx, psz_result); fail: SG_NULLFREE(pCtx, psz_result); SG_REPO_NULLFREE(pCtx, pRepo); SG_DAGNODE_NULLFREE(pCtx, pdn); SG_PATHNAME_NULLFREE(pCtx, pPathWorkingDir); SG_PATHNAME_NULLFREE(pCtx, pPathFile); }
void SG_tid__alloc2(SG_context * pCtx, char ** ppszTid, SG_uint32 nrRandomDigits) { char * pszTid_Allocated = NULL; SG_NULLARGCHECK_RETURN( ppszTid ); SG_ERR_CHECK_RETURN( SG_alloc(pCtx, 1, SG_TID_MAX_BUFFER_LENGTH, &pszTid_Allocated) ); SG_ERR_CHECK( SG_tid__generate2(pCtx, pszTid_Allocated, SG_TID_MAX_BUFFER_LENGTH, nrRandomDigits) ); *ppszTid = pszTid_Allocated; return; fail: SG_NULLFREE(pCtx, pszTid_Allocated); }
void SG_tid__generate2__suffix(SG_context * pCtx, char * bufTid, SG_uint32 lenBuf, SG_uint32 nrRandomDigits, const char * pszSuffix) { SG_uint32 lenSuffix; SG_NULLARGCHECK_RETURN( bufTid ); SG_NONEMPTYCHECK_RETURN( pszSuffix ); lenSuffix = SG_STRLEN(pszSuffix); SG_ARGCHECK_RETURN( ((nrRandomDigits + 1 + lenSuffix + 1) <= lenBuf), lenBuf ); SG_ERR_CHECK_RETURN( SG_tid__generate2(pCtx, bufTid, lenBuf, nrRandomDigits) ); SG_ERR_CHECK_RETURN( SG_strcat(pCtx, bufTid, lenBuf, ".") ); SG_ERR_CHECK_RETURN( SG_strcat(pCtx, bufTid, lenBuf, pszSuffix) ); }
void u0020_utf8pathnames__mkdir_tmp_dir(SG_context * pCtx, SG_pathname ** ppPathnameTmpDir) { // create a temporary directory using a random name in the // current directory or in TMP. // // return the name of the pathname. char bufTid[SG_TID_MAX_BUFFER_LENGTH]; SG_pathname * pPathnameTmpDir = NULL; VERIFY_ERR_CHECK( SG_tid__generate2(pCtx, bufTid, sizeof(bufTid), 32) ); VERIFY_ERR_CHECK( SG_PATHNAME__ALLOC__USER_TEMP_DIRECTORY(pCtx, &pPathnameTmpDir) ); VERIFY_ERR_CHECK( SG_pathname__append__from_sz(pCtx, pPathnameTmpDir,bufTid) ); VERIFY_ERR_CHECK( SG_fsobj__mkdir_recursive__pathname(pCtx, pPathnameTmpDir) ); *ppPathnameTmpDir = pPathnameTmpDir; return; fail: SG_PATHNAME_NULLFREE(pCtx, pPathnameTmpDir); }
int u0050_logstuff_test__1(SG_context * pCtx, SG_pathname* pPathTopDir) { char bufName[SG_TID_MAX_BUFFER_LENGTH]; SG_pathname* pPathWorkingDir = NULL; SG_pathname* pPathFile = NULL; SG_vhash* pvh = NULL; SG_dagnode* pdn = NULL; const char* psz_hid_cs = NULL; SG_repo* pRepo = NULL; SG_uint32 count; SG_rbtree* prb = NULL; SG_varray* pva = NULL; SG_rbtree* prb_reversed = NULL; const char* psz_val = NULL; SG_audit q; VERIFY_ERR_CHECK( SG_tid__generate2(pCtx, bufName, sizeof(bufName), 32) ); /* create the working dir */ VERIFY_ERR_CHECK( SG_PATHNAME__ALLOC__PATHNAME_SZ(pCtx, &pPathWorkingDir, pPathTopDir, bufName) ); VERIFY_ERR_CHECK( SG_fsobj__mkdir__pathname(pCtx, pPathWorkingDir) ); /* add stuff */ VERIFY_ERR_CHECK( u0050_logstuff__create_file__numbers(pCtx, pPathWorkingDir, "aaa", 20) ); /* create the repo */ VERIFY_ERR_CHECK( _ut_pt__new_repo(pCtx, bufName, pPathWorkingDir) ); VERIFY_ERR_CHECK( _ut_pt__addremove(pCtx, pPathWorkingDir) ); VERIFY_ERR_CHECK( u0050_logstuff__commit_all(pCtx, pPathWorkingDir, &pdn) ); VERIFY_ERR_CHECK( SG_dagnode__get_id_ref(pCtx, pdn, &psz_hid_cs) ); SG_ERR_CHECK( SG_repo__open_repo_instance(pCtx, bufName, &pRepo) ); #define MY_COMMENT "The name of this new file sucks! What kind of a name is 'aaa'?" VERIFY_ERR_CHECK( SG_audit__init(pCtx, &q, pRepo, SG_AUDIT__WHEN__NOW, SG_AUDIT__WHO__FROM_SETTINGS) ); VERIFY_ERR_CHECK( SG_vc_comments__add(pCtx, pRepo, psz_hid_cs, MY_COMMENT, &q) ); VERIFY_ERR_CHECK( SG_vc_stamps__add(pCtx, pRepo, psz_hid_cs, "crap", &q) ); VERIFY_ERR_CHECK( SG_vc_tags__add(pCtx, pRepo, psz_hid_cs, "tcrap", &q) ); VERIFY_ERR_CHECK( SG_vc_comments__lookup(pCtx, pRepo, psz_hid_cs, &pva) ); VERIFY_ERR_CHECK( SG_varray__count(pCtx, pva, &count) ); VERIFY_COND("count", (1 == count)); VERIFY_ERR_CHECK( SG_varray__get__vhash(pCtx, pva, 0, &pvh) ); VERIFY_ERR_CHECK( SG_vhash__get__sz(pCtx, pvh, "text", &psz_val) ); VERIFY_COND("match", (0 == strcmp(psz_val, MY_COMMENT)) ); SG_VARRAY_NULLFREE(pCtx, pva); VERIFY_ERR_CHECK( SG_vc_stamps__lookup(pCtx, pRepo, psz_hid_cs, &pva) ); VERIFY_ERR_CHECK( SG_varray__count(pCtx, pva, &count) ); VERIFY_COND("count", (1 == count)); VERIFY_ERR_CHECK( SG_varray__get__vhash(pCtx, pva, 0, &pvh) ); VERIFY_ERR_CHECK( SG_vhash__get__sz(pCtx, pvh, "stamp", &psz_val) ); VERIFY_COND("match", (0 == strcmp(psz_val, "crap")) ); SG_VARRAY_NULLFREE(pCtx, pva); VERIFY_ERR_CHECK( SG_vc_tags__lookup(pCtx, pRepo, psz_hid_cs, &pva) ); VERIFY_ERR_CHECK( SG_varray__count(pCtx, pva, &count) ); VERIFY_COND("count", (1 == count)); VERIFY_ERR_CHECK( SG_varray__get__vhash(pCtx, pva, 0, &pvh) ); VERIFY_ERR_CHECK( SG_vhash__get__sz(pCtx, pvh, "tag", &psz_val) ); VERIFY_COND("match", (0 == strcmp(psz_val, "tcrap")) ); SG_VARRAY_NULLFREE(pCtx, pva); VERIFY_ERR_CHECK( SG_vc_tags__list(pCtx, pRepo, &prb) ); VERIFY_ERR_CHECK( SG_rbtree__count(pCtx, prb, &count) ); VERIFY_COND("count", (1 == count)); VERIFY_ERR_CHECK( SG_vc_tags__build_reverse_lookup(pCtx, prb, &prb_reversed) ); VERIFY_ERR_CHECK( SG_rbtree__count(pCtx, prb_reversed, &count) ); VERIFY_COND("count", (1 == count)); { const char* psz_my_key = NULL; const char* psz_my_val = NULL; SG_bool b; VERIFY_ERR_CHECK( SG_rbtree__iterator__first(pCtx, NULL, prb_reversed, &b, &psz_my_key, (void**) &psz_my_val) ); VERIFY_COND("ok", (0 == strcmp(psz_my_val, "tcrap")) ); VERIFY_COND("ok", (0 == strcmp(psz_my_key, psz_hid_cs)) ); } SG_RBTREE_NULLFREE(pCtx, prb_reversed); SG_RBTREE_NULLFREE(pCtx, prb); VERIFY_ERR_CHECK( SG_vc_tags__add(pCtx, pRepo, psz_hid_cs, "whatever", &q) ); VERIFY_ERR_CHECK( SG_vc_tags__lookup(pCtx, pRepo, psz_hid_cs, &pva) ); VERIFY_ERR_CHECK( SG_varray__count(pCtx, pva, &count) ); VERIFY_COND("count", (2 == count)); SG_VARRAY_NULLFREE(pCtx, pva); VERIFY_ERR_CHECK( SG_vc_tags__list(pCtx, pRepo, &prb) ); VERIFY_ERR_CHECK( SG_rbtree__count(pCtx, prb, &count) ); VERIFY_COND("count", (2 == count)); VERIFY_ERR_CHECK( SG_vc_tags__build_reverse_lookup(pCtx, prb, &prb_reversed) ); VERIFY_ERR_CHECK( SG_rbtree__count(pCtx, prb_reversed, &count) ); VERIFY_COND("count", (1 == count)); { const char* psz_my_key = NULL; const char* psz_my_val = NULL; SG_bool b; VERIFY_ERR_CHECK( SG_rbtree__iterator__first(pCtx, NULL, prb_reversed, &b, &psz_my_key, (void**) &psz_my_val) ); VERIFY_COND("ok", (0 == strcmp(psz_my_key, psz_hid_cs)) ); /* we don't know whether psz_my_val is tcrap or whatever. */ // VERIFY_COND("ok", (0 == strcmp(psz_my_val, "tcrap")) ); } SG_RBTREE_NULLFREE(pCtx, prb_reversed); SG_RBTREE_NULLFREE(pCtx, prb); { const char* psz_remove = "whatever"; VERIFY_ERR_CHECK( SG_vc_tags__remove(pCtx, pRepo, &q, 1, &psz_remove) ); /* Note that by removing whatever, we are bringing the tags list back * to a state where it has been before (just tcrap). This changeset in * the tags table will have its own csid, because the parentage is * different, but it's root idtrie HID will be the same as a previous * node. */ } VERIFY_ERR_CHECK( SG_vc_tags__lookup(pCtx, pRepo, psz_hid_cs, &pva) ); VERIFY_ERR_CHECK( SG_varray__count(pCtx, pva, &count) ); VERIFY_COND("count", (1 == count)); SG_VARRAY_NULLFREE(pCtx, pva); VERIFY_ERR_CHECK( SG_vc_tags__list(pCtx, pRepo, &prb) ); VERIFY_ERR_CHECK( SG_rbtree__count(pCtx, prb, &count) ); VERIFY_COND("count", (1 == count)); SG_RBTREE_NULLFREE(pCtx, prb); SG_REPO_NULLFREE(pCtx, pRepo); SG_DAGNODE_NULLFREE(pCtx, pdn); SG_PATHNAME_NULLFREE(pCtx, pPathWorkingDir); SG_PATHNAME_NULLFREE(pCtx, pPathFile); return 1; fail: SG_VHASH_NULLFREE(pCtx, pvh); SG_PATHNAME_NULLFREE(pCtx, pPathWorkingDir); SG_PATHNAME_NULLFREE(pCtx, pPathFile); return 0; }
void MyFn(test__simple)(SG_context* pCtx) { char bufTopDir[SG_TID_MAX_BUFFER_LENGTH]; SG_pathname* pPathTopDir = NULL; char buf_client_repo_name[SG_TID_MAX_BUFFER_LENGTH]; char buf_server_repo_name[SG_TID_MAX_BUFFER_LENGTH]; SG_pathname* pPathWorkingDir = NULL; SG_vhash* pvh = NULL; SG_repo* pClientRepo = NULL; SG_client* pClient = NULL; SG_repo* pServerRepo = NULL; SG_bool bMatch = SG_FALSE; SG_varray* pvaZingMergeLog = NULL; SG_varray* pvaZingMergeErr = NULL; VERIFY_ERR_CHECK( SG_tid__generate2(pCtx, bufTopDir, sizeof(bufTopDir), 32) ); VERIFY_ERR_CHECK( SG_PATHNAME__ALLOC__SZ(pCtx,&pPathTopDir,bufTopDir) ); VERIFY_ERR_CHECK( SG_fsobj__mkdir__pathname(pCtx,pPathTopDir) ); VERIFY_ERR_CHECK( SG_tid__generate2(pCtx, buf_client_repo_name, sizeof(buf_client_repo_name), 32) ); VERIFY_ERR_CHECK( SG_tid__generate2(pCtx, buf_server_repo_name, sizeof(buf_server_repo_name), 32) ); INFOP("test__simple", ("client repo: %s", buf_client_repo_name)); INFOP("test__simple", ("server repo: %s", buf_server_repo_name)); /* create the repo */ VERIFY_ERR_CHECK( SG_PATHNAME__ALLOC__PATHNAME_SZ(pCtx, &pPathWorkingDir, pPathTopDir, buf_server_repo_name) ); VERIFY_ERR_CHECK( SG_fsobj__mkdir__pathname(pCtx, pPathWorkingDir) ); VERIFY_ERR_CHECK( _ut_pt__new_repo2(pCtx, buf_server_repo_name, pPathWorkingDir, NULL) ); /* open that repo */ VERIFY_ERR_CHECK( SG_repo__open_repo_instance(pCtx, buf_server_repo_name, &pServerRepo) ); /* create an empty clone to pull into */ VERIFY_ERR_CHECK( SG_repo__create_empty_clone(pCtx, buf_server_repo_name, buf_client_repo_name) ); VERIFY_ERR_CHECK( SG_repo__open_repo_instance(pCtx, buf_client_repo_name, &pClientRepo) ); /* add stuff to server repo */ VERIFY_ERR_CHECK( MyFn(create_file__numbers)(pCtx, pPathWorkingDir, "aaa", 10) ); VERIFY_ERR_CHECK( _ut_pt__addremove(pCtx, pPathWorkingDir) ); VERIFY_ERR_CHECK( MyFn(commit_all)(pCtx, pPathWorkingDir, NULL) ); VERIFY_ERR_CHECK( MyFn(create_file__numbers)(pCtx, pPathWorkingDir, "bbb", 10) ); VERIFY_ERR_CHECK( _ut_pt__addremove(pCtx, pPathWorkingDir) ); VERIFY_ERR_CHECK( MyFn(commit_all)(pCtx, pPathWorkingDir, NULL) ); /* verify pre-pull repos are different */ VERIFY_ERR_CHECK( SG_sync__compare_repo_dags(pCtx, pClientRepo, pServerRepo, &bMatch) ); VERIFY_COND_FAIL("pre-pull repos differ", !bMatch); /* get a client and pull from server repo to empty client repo */ VERIFY_ERR_CHECK( SG_client__open(pCtx, buf_server_repo_name, NULL_CREDENTIAL, &pClient) ); // TODO Credentials VERIFY_ERR_CHECK( SG_pull__all(pCtx, buf_client_repo_name, pClient, &pvaZingMergeErr, &pvaZingMergeLog) ); VERIFY_COND("", !pvaZingMergeErr); SG_CLIENT_NULLFREE(pCtx, pClient); /* verify post-pull repos are identical */ VERIFY_ERR_CHECK( SG_sync__compare_repo_dags(pCtx, pClientRepo, pServerRepo, &bMatch) ); VERIFY_COND_FAIL("post-pull repo DAGs differ", bMatch); VERIFY_ERR_CHECK( SG_sync__compare_repo_blobs(pCtx, pClientRepo, pServerRepo, &bMatch) ); VERIFY_COND_FAIL("post-pull repo blobs differ", bMatch); VERIFY_ERR_CHECK( SG_repo__check_integrity(pCtx, pClientRepo, SG_REPO__CHECK_INTEGRITY__DAG_CONSISTENCY, SG_DAGNUM__VERSION_CONTROL, NULL, NULL) ); /* TODO: verify more stuff? */ /* Fall through to common cleanup */ fail: /* close client */ SG_CLIENT_NULLFREE(pCtx, pClient); /* close both repos */ SG_REPO_NULLFREE(pCtx, pServerRepo); SG_REPO_NULLFREE(pCtx, pClientRepo); SG_PATHNAME_NULLFREE(pCtx, pPathTopDir); SG_PATHNAME_NULLFREE(pCtx, pPathWorkingDir); SG_VHASH_NULLFREE(pCtx, pvh); SG_PATHNAME_NULLFREE(pCtx, pPathWorkingDir); SG_VARRAY_NULLFREE(pCtx, pvaZingMergeLog); SG_VARRAY_NULLFREE(pCtx, pvaZingMergeErr); }
void MyFn(test__wide_dag)(SG_context* pCtx) { char bufTopDir[SG_TID_MAX_BUFFER_LENGTH]; SG_pathname* pPathTopDir = NULL; char buf_client_repo_name[SG_TID_MAX_BUFFER_LENGTH]; char buf_server_repo_name[SG_TID_MAX_BUFFER_LENGTH]; SG_pathname* pPathWorkingDir = NULL; SG_vhash* pvh = NULL; SG_repo* pClientRepo = NULL; SG_client* pClient = NULL; char* pszidFirstChangeset = NULL; SG_pathname* pPathCsDir = NULL; SG_uint32 lines; SG_uint32 i, j; SG_repo* pServerRepo = NULL; SG_bool bMatch = SG_FALSE; char buf_filename[7]; SG_varray* pvaZingMergeLog = NULL; SG_varray* pvaZingMergeErr = NULL; VERIFY_ERR_CHECK( SG_tid__generate2(pCtx, bufTopDir, sizeof(bufTopDir), 32) ); VERIFY_ERR_CHECK( SG_PATHNAME__ALLOC__SZ(pCtx,&pPathTopDir,bufTopDir) ); VERIFY_ERR_CHECK( SG_fsobj__mkdir__pathname(pCtx,pPathTopDir) ); VERIFY_ERR_CHECK( SG_tid__generate2(pCtx, buf_client_repo_name, sizeof(buf_client_repo_name), 32) ); VERIFY_ERR_CHECK( SG_tid__generate2(pCtx, buf_server_repo_name, sizeof(buf_server_repo_name), 32) ); INFOP("test__wide_dag", ("client repo: %s", buf_client_repo_name)); INFOP("test__wide_dag", ("server repo: %s", buf_server_repo_name)); /* create the repo */ VERIFY_ERR_CHECK( SG_PATHNAME__ALLOC__PATHNAME_SZ(pCtx, &pPathWorkingDir, pPathTopDir, buf_server_repo_name) ); VERIFY_ERR_CHECK( SG_fsobj__mkdir__pathname(pCtx, pPathWorkingDir) ); VERIFY_ERR_CHECK( _ut_pt__new_repo2(pCtx, buf_server_repo_name, pPathWorkingDir, &pszidFirstChangeset) ); /* open that repo */ VERIFY_ERR_CHECK( SG_repo__open_repo_instance(pCtx, buf_server_repo_name, &pServerRepo) ); /* create an empty clone to pull into */ VERIFY_ERR_CHECK( SG_repo__create_empty_clone(pCtx, buf_server_repo_name, buf_client_repo_name) ); VERIFY_ERR_CHECK( SG_repo__open_repo_instance(pCtx, buf_client_repo_name, &pClientRepo) ); /* add stuff to server repo */ for (i = 0; i < 20; i++) // number of changesets { VERIFY_ERR_CHECK( _ut_pt__set_baseline(pCtx, pPathWorkingDir, pszidFirstChangeset) ); VERIFY_ERR_CHECK( SG_sprintf(pCtx, buf_filename, sizeof(buf_filename), "%d", i) ); VERIFY_ERR_CHECK( SG_PATHNAME__ALLOC__PATHNAME_SZ(pCtx, &pPathCsDir, pPathWorkingDir, buf_filename) ); VERIFY_ERR_CHECK( SG_fsobj__mkdir__pathname(pCtx, pPathCsDir) ); for (j = 0; j < 1; j++) // number of files added per changeset { VERIFY_ERR_CHECK( SG_sprintf(pCtx, buf_filename, sizeof(buf_filename), "%d", j) ); lines = (int)(2500.0 * (rand() / (RAND_MAX + 1.0))); VERIFY_ERR_CHECK( MyFn(create_file__numbers)(pCtx, pPathCsDir, buf_filename, lines) ); } SG_PATHNAME_NULLFREE(pCtx, pPathCsDir); VERIFY_ERR_CHECK( _ut_pt__addremove(pCtx, pPathWorkingDir) ); VERIFY_ERR_CHECK( MyFn(commit_all)(pCtx, pPathWorkingDir, NULL) ); } /* verify pre-pull repos are different */ VERIFY_ERR_CHECK( SG_sync__compare_repo_dags(pCtx, pClientRepo, pServerRepo, &bMatch) ); VERIFY_COND_FAIL("pre-pull repos differ", !bMatch); /* get a client and pull from server repo to empty client repo */ VERIFY_ERR_CHECK( SG_client__open(pCtx, buf_server_repo_name, NULL_CREDENTIAL, &pClient) ); // TODO Credentials VERIFY_ERR_CHECK( SG_pull__all(pCtx, buf_client_repo_name, pClient, &pvaZingMergeErr, &pvaZingMergeLog) ); VERIFY_COND("", !pvaZingMergeErr); /* verify post-pull repos are identical */ VERIFY_ERR_CHECK( SG_sync__compare_repo_dags(pCtx, pClientRepo, pServerRepo, &bMatch) ); VERIFY_COND_FAIL("post-pull repo DAGs differ", bMatch); VERIFY_ERR_CHECK( SG_sync__compare_repo_blobs(pCtx, pClientRepo, pServerRepo, &bMatch) ); VERIFY_COND_FAIL("post-pull repo blobs differ", bMatch); VERIFY_ERR_CHECK( SG_repo__check_integrity(pCtx, pClientRepo, SG_REPO__CHECK_INTEGRITY__DAG_CONSISTENCY, SG_DAGNUM__VERSION_CONTROL, NULL, NULL) ); SG_REPO_NULLFREE(pCtx, pClientRepo); /* Make another copy with clone */ VERIFY_ERR_CHECK( SG_tid__generate2(pCtx, buf_client_repo_name, sizeof(buf_client_repo_name), 32) ); SG_ERR_CHECK( SG_repo__create_empty_clone_from_remote(pCtx, pClient, buf_client_repo_name) ); VERIFY_ERR_CHECK( SG_pull__clone(pCtx, buf_client_repo_name, pClient) ); /* verify post-clone repos are identical */ VERIFY_ERR_CHECK( SG_repo__open_repo_instance(pCtx, buf_client_repo_name, &pClientRepo) ); VERIFY_ERR_CHECK( SG_sync__compare_repo_dags(pCtx, pClientRepo, pServerRepo, &bMatch) ); VERIFY_COND_FAIL("post-clone repo DAGs differ", bMatch); VERIFY_ERR_CHECK( SG_sync__compare_repo_blobs(pCtx, pClientRepo, pServerRepo, &bMatch) ); VERIFY_COND_FAIL("post-clone repo blobs differ", bMatch); VERIFY_ERR_CHECK( SG_repo__check_integrity(pCtx, pClientRepo, SG_REPO__CHECK_INTEGRITY__DAG_CONSISTENCY, SG_DAGNUM__VERSION_CONTROL, NULL, NULL) ); /* TODO: verify more stuff? */ /* Fall through to common cleanup */ fail: /* close client */ SG_CLIENT_NULLFREE(pCtx, pClient); /* close both repos */ SG_REPO_NULLFREE(pCtx, pServerRepo); SG_REPO_NULLFREE(pCtx, pClientRepo); SG_NULLFREE(pCtx, pszidFirstChangeset); SG_PATHNAME_NULLFREE(pCtx, pPathTopDir); SG_PATHNAME_NULLFREE(pCtx, pPathWorkingDir); SG_PATHNAME_NULLFREE(pCtx, pPathCsDir); SG_VHASH_NULLFREE(pCtx, pvh); SG_PATHNAME_NULLFREE(pCtx, pPathWorkingDir); SG_VARRAY_NULLFREE(pCtx, pvaZingMergeLog); SG_VARRAY_NULLFREE(pCtx, pvaZingMergeErr); }
void u0052_zip__test_1(SG_context * pCtx) { SG_zip* pzip = NULL; SG_unzip* punzip = NULL; char buf_tid[SG_TID_MAX_BUFFER_LENGTH]; SG_pathname* pPath = NULL; SG_uint32 count = 0; SG_byte buf[256]; SG_uint32 iBytesRead; SG_bool b; const char* psz_name = NULL; SG_uint64 iLen = 0; VERIFY_ERR_CHECK( SG_tid__generate2(pCtx, buf_tid, sizeof(buf_tid), 32) ); VERIFY_ERR_CHECK( SG_PATHNAME__ALLOC__SZ(pCtx, &pPath, buf_tid) ); /* ---------------------------------------------------------------- */ /* Create the zip file */ /* ---------------------------------------------------------------- */ VERIFY_ERR_CHECK( SG_zip__open(pCtx, pPath, &pzip) ); #define FILE1_CONTENTS "hello world" VERIFY_ERR_CHECK( SG_zip__begin_file(pCtx, pzip, "f1") ); VERIFY_ERR_CHECK( SG_zip__write(pCtx, pzip, (SG_byte*) FILE1_CONTENTS, (SG_uint32) (1 + strlen(FILE1_CONTENTS))) ); VERIFY_ERR_CHECK( SG_zip__end_file(pCtx, pzip) ); #define FILE2_CONTENTS "this is a test of the emergency broadcast system" VERIFY_ERR_CHECK( SG_zip__begin_file(pCtx, pzip, "f2") ); VERIFY_ERR_CHECK( SG_zip__write(pCtx, pzip, (SG_byte*) FILE2_CONTENTS, (SG_uint32) (1 + strlen(FILE2_CONTENTS))) ); VERIFY_ERR_CHECK( SG_zip__end_file(pCtx, pzip) ); #define FILE3_CONTENTS "x" VERIFY_ERR_CHECK( SG_zip__begin_file(pCtx, pzip, "f3") ); VERIFY_ERR_CHECK( SG_zip__write(pCtx, pzip, (SG_byte*) FILE3_CONTENTS, (SG_uint32) (1 + strlen(FILE3_CONTENTS))) ); VERIFY_ERR_CHECK( SG_zip__end_file(pCtx, pzip) ); #define FILE4_CONTENTS "spain" VERIFY_ERR_CHECK( SG_zip__begin_file(pCtx, pzip, "f4") ); VERIFY_ERR_CHECK( SG_zip__write(pCtx, pzip, (SG_byte*) FILE4_CONTENTS, (SG_uint32) (1 + strlen(FILE4_CONTENTS))) ); VERIFY_ERR_CHECK( SG_zip__end_file(pCtx, pzip) ); VERIFY_ERR_CHECK( SG_zip__nullclose(pCtx, &pzip) ); /* ---------------------------------------------------------------- */ /* Read the zip file */ /* ---------------------------------------------------------------- */ VERIFY_ERR_CHECK( SG_unzip__open(pCtx, pPath, &punzip) ); count = 0; b = SG_FALSE; VERIFY_ERR_CHECK( SG_unzip__goto_first_file(pCtx, punzip, &b, NULL, NULL) ); while (b) { count++; VERIFY_ERR_CHECK( SG_unzip__goto_next_file(pCtx, punzip, &b, NULL, NULL) ); } VERIFY_COND("count", (4 == count)); b = SG_FALSE; VERIFY_ERR_CHECK( SG_unzip__goto_first_file(pCtx, punzip, &b, &psz_name, &iLen) ); VERIFY_COND("b", b); VERIFY_COND("name", (0 == strcmp(psz_name, "f1"))); VERIFY_COND("len", (iLen == (1 + strlen(FILE1_CONTENTS)))); b = SG_FALSE; VERIFY_ERR_CHECK( SG_unzip__goto_next_file(pCtx, punzip, &b, &psz_name, &iLen) ); VERIFY_COND("b", b); VERIFY_COND("name", (0 == strcmp(psz_name, "f2"))); VERIFY_COND("len", (iLen == (1 + strlen(FILE2_CONTENTS)))); b = SG_FALSE; VERIFY_ERR_CHECK( SG_unzip__goto_next_file(pCtx, punzip, &b, &psz_name, &iLen) ); VERIFY_COND("b", b); VERIFY_COND("name", (0 == strcmp(psz_name, "f3"))); VERIFY_COND("len", (iLen == (1 + strlen(FILE3_CONTENTS)))); b = SG_FALSE; VERIFY_ERR_CHECK( SG_unzip__goto_next_file(pCtx, punzip, &b, &psz_name, &iLen) ); VERIFY_COND("b", b); VERIFY_COND("name", (0 == strcmp(psz_name, "f4"))); VERIFY_COND("len", (iLen == (1 + strlen(FILE4_CONTENTS)))); /* verify that locate_file works */ VERIFY_ERR_CHECK( SG_unzip__locate_file(pCtx, punzip, "f2", &b, &iLen) ); VERIFY_COND("b", b); VERIFY_COND("len", (iLen == (1 + strlen(FILE2_CONTENTS)))); VERIFY_ERR_CHECK( SG_unzip__currentfile__open(pCtx, punzip) ); VERIFY_ERR_CHECK( SG_unzip__currentfile__read(pCtx, punzip, buf, sizeof(buf), &iBytesRead) ); VERIFY_ERR_CHECK( SG_unzip__currentfile__close(pCtx, punzip) ); VERIFY_COND("len", (iLen == iBytesRead)); VERIFY_COND("match", (0 == strcmp((char*) buf, FILE2_CONTENTS))); /* verify that locate_file does not disturb things when it fails */ VERIFY_ERR_CHECK( SG_unzip__locate_file(pCtx, punzip, "not there", &b, &iLen) ); VERIFY_COND("b", !b); memset(buf, 0, 20); VERIFY_ERR_CHECK( SG_unzip__currentfile__open(pCtx, punzip) ); VERIFY_ERR_CHECK( SG_unzip__currentfile__read(pCtx, punzip, buf, sizeof(buf), &iBytesRead) ); VERIFY_ERR_CHECK( SG_unzip__currentfile__close(pCtx, punzip) ); VERIFY_COND("len", ((1 + strlen(FILE2_CONTENTS)) == iBytesRead)); VERIFY_COND("match", (0 == strcmp((char*) buf, FILE2_CONTENTS))); VERIFY_ERR_CHECK( SG_unzip__nullclose(pCtx, &punzip) ); SG_PATHNAME_NULLFREE(pCtx, pPath); return; fail: SG_ERR_IGNORE( SG_unzip__nullclose(pCtx, &punzip) ); SG_PATHNAME_NULLFREE(pCtx, pPath); }
void SG_tid__generate(SG_context * pCtx, char * bufTid, SG_uint32 lenBuf) { SG_ERR_CHECK_RETURN( SG_tid__generate2(pCtx, bufTid, lenBuf, SG_TID_LENGTH_RANDOM_MAX) ); }