static void _default_replacer(
SG_context * pCtx,
const _request_headers *pRequestHeaders,
SG_string *keyword,
SG_string *replacement,
SG_bool *needEncoding)
{
SG_string *pstrRepoDescriptorName = NULL;
SG_repo *repo = NULL;
SG_UNUSED(pRequestHeaders);
if (seq(keyword, "WFREPO"))
{
SG_ERR_CHECK( _getDescriptorName(pCtx, pRequestHeaders, &pstrRepoDescriptorName) );
SG_ERR_CHECK( SG_string__set__string(pCtx, replacement, pstrRepoDescriptorName) );
}
else if (seq(keyword, "USERNAME"))
{
SG_ERR_CHECK( _getDescriptorName(pCtx, pRequestHeaders, &pstrRepoDescriptorName) );
if (pstrRepoDescriptorName != NULL)
{
SG_ERR_CHECK( SG_repo__open_repo_instance(pCtx, SG_string__sz(pstrRepoDescriptorName), &repo) );
}
SG_ERR_CHECK( _getUserId(pCtx, repo, replacement) );
}
else if (seq(keyword, "EMAIL"))
{
SG_ERR_CHECK( _getDescriptorName(pCtx, pRequestHeaders, &pstrRepoDescriptorName) );
if (pstrRepoDescriptorName != NULL)
{
SG_ERR_CHECK( SG_repo__open_repo_instance(pCtx, SG_string__sz(pstrRepoDescriptorName), &repo) );
}
SG_ERR_CHECK( _getUserEmail(pCtx, repo, replacement) );
}
else if (seq(keyword, "USERSELECTION"))
{
SG_ERR_CHECK( _getDescriptorName(pCtx, pRequestHeaders, &pstrRepoDescriptorName) );
SG_ERR_CHECK( _fillInUserSelection(pCtx, pstrRepoDescriptorName, replacement) );
*needEncoding = SG_FALSE;
}
fail:
SG_STRING_NULLFREE(pCtx, pstrRepoDescriptorName);
SG_REPO_NULLFREE(pCtx, repo);
}
void sg_client__c__pull_clone(
SG_context* pCtx,
SG_client* pClient,
const SG_pathname* pStagingPathname,
char** ppszFragballName)
{
sg_client_c_instance_data* pMe = NULL;
SG_repo* pRepo = NULL;
SG_vhash* pvhStatus = NULL;
SG_NULLARGCHECK_RETURN(pClient);
SG_NULLARGCHECK_RETURN(ppszFragballName);
pMe = (sg_client_c_instance_data*)pClient->p_vtable_instance_data;
SG_ERR_CHECK( SG_repo__open_repo_instance(pCtx, pClient->psz_remote_repo_spec, &pRepo) );
SG_ERR_CHECK( SG_context__msg__emit(pCtx, "Copying repository...") );
SG_ERR_CHECK( SG_repo__fetch_repo__fragball(pCtx, pRepo, pStagingPathname, ppszFragballName) );
SG_ERR_CHECK( SG_context__msg__emit(pCtx, "done") );
/* fall through */
fail:
SG_REPO_NULLFREE(pCtx, pRepo);
SG_VHASH_NULLFREE(pCtx, pvhStatus);
SG_ERR_IGNORE( SG_context__msg__emit(pCtx, "\n") );
}
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);
}
/**
* Creates a staging area and returns an initialized instance data structure.
*/
static void _pull_init(SG_context* pCtx,
SG_client* pClient,
const char* pszPullIntoRepoDescriptorName,
sg_pull_instance_data** ppMe)
{
char* pszThisRepoId = NULL;
char* pszThisHashMethod = NULL;
char* pszOtherRepoId = NULL;
char* pszOtherHashMethod = NULL;
sg_pull_instance_data* pMe = NULL;
SG_repo* pPullIntoRepo = NULL;
SG_NULLARGCHECK_RETURN(pszPullIntoRepoDescriptorName);
SG_NULLARGCHECK_RETURN(ppMe);
SG_ERR_CHECK( SG_client__get_repo_info(pCtx, pClient, &pszOtherRepoId, NULL, &pszOtherHashMethod) );
SG_ERR_CHECK( SG_repo__open_repo_instance(pCtx, pszPullIntoRepoDescriptorName, &pPullIntoRepo) );
/* TODO This will care about dagnums once we're using the user dag. */
SG_ERR_CHECK( SG_repo__get_repo_id(pCtx, pPullIntoRepo, &pszThisRepoId) );
if (strcmp(pszThisRepoId, pszOtherRepoId) != 0)
SG_ERR_THROW(SG_ERR_REPO_ID_MISMATCH);
/* TODO check admin id when appropriate */
SG_ERR_CHECK( SG_repo__get_hash_method(pCtx, pPullIntoRepo, &pszThisHashMethod) );
if (strcmp(pszThisHashMethod, pszOtherHashMethod) != 0)
SG_ERR_THROW(SG_ERR_REPO_HASH_METHOD_MISMATCH);
// alloc instance data, store pull id in it (which identifies the staging area)
SG_ERR_CHECK( SG_alloc1(pCtx, pMe) );
SG_ERR_CHECK( SG_staging__create(pCtx, pszPullIntoRepoDescriptorName, &pMe->pszPullId, &pMe->pStaging) );
pMe->pPullIntoRepo = pPullIntoRepo;
pPullIntoRepo = NULL;
SG_RETURN_AND_NULL(pMe, ppMe);
/* fall through */
fail:
SG_NULLFREE(pCtx, pszThisRepoId);
SG_NULLFREE(pCtx, pszThisHashMethod);
SG_NULLFREE(pCtx, pszOtherRepoId);
SG_NULLFREE(pCtx, pszOtherHashMethod);
SG_NULLFREE(pCtx, pPullIntoRepo);
_NULLFREE_INSTANCE_DATA(pCtx, pMe);
}
void sg_client__c__get_dagnode_info(
SG_context* pCtx,
SG_client* pClient,
SG_vhash* pvhRequest,
SG_varray** ppvaInfo)
{
sg_client_c_instance_data* pMe = NULL;
SG_repo* pRepo = NULL;
SG_NULLARGCHECK_RETURN(pClient);
pMe = (sg_client_c_instance_data*)pClient->p_vtable_instance_data;
SG_ERR_CHECK( SG_repo__open_repo_instance(pCtx, pClient->psz_remote_repo_spec, &pRepo) );
SG_ERR_CHECK( SG_server__get_dagnode_info(pCtx, pRepo, pvhRequest, ppvaInfo) );
/* fall through */
fail:
SG_REPO_NULLFREE(pCtx, pRepo);
}
void sg_client__c__get_repo_info(SG_context* pCtx,
SG_client* pClient,
char** ppszRepoId,
char** ppszAdminId,
char** ppszHashMethod)
{
sg_client_c_instance_data* pMe = NULL;
SG_repo* pRepo = NULL;
SG_NULLARGCHECK_RETURN(pClient);
pMe = (sg_client_c_instance_data*)pClient->p_vtable_instance_data;
SG_ERR_CHECK( SG_repo__open_repo_instance(pCtx, pClient->psz_remote_repo_spec, &pRepo) );
SG_ERR_CHECK( SG_server__get_repo_info(pCtx, pRepo, ppszRepoId, ppszAdminId, ppszHashMethod) );
/* fall through */
fail:
SG_REPO_NULLFREE(pCtx, pRepo);
}
void sg_client__c__pull_request_fragball(SG_context* pCtx,
SG_client* pClient,
SG_vhash* pvhRequest,
const SG_pathname* pStagingPathname,
char** ppszFragballName,
SG_vhash** ppvhStatus)
{
sg_client_c_instance_data* pMe = NULL;
SG_repo* pRepo = NULL;
char* pszFragballName = NULL;
SG_vhash* pvhStatus = NULL;
SG_NULLARGCHECK_RETURN(pClient);
SG_NULLARGCHECK_RETURN(ppszFragballName);
SG_NULLARGCHECK_RETURN(ppvhStatus);
pMe = (sg_client_c_instance_data*)pClient->p_vtable_instance_data;
SG_ERR_CHECK( SG_repo__open_repo_instance(pCtx, pClient->psz_remote_repo_spec, &pRepo) );
/* Tell the server to build its fragball in our staging directory.
We can do this just calling pServer directly because we know it's a local repo. */
SG_ERR_CHECK( SG_server__pull_request_fragball(pCtx, pRepo, pvhRequest, pStagingPathname, &pszFragballName, &pvhStatus) );
*ppszFragballName = pszFragballName;
pszFragballName = NULL;
*ppvhStatus = pvhStatus;
pvhStatus = NULL;
/* fall through */
fail:
SG_REPO_NULLFREE(pCtx, pRepo);
SG_VHASH_NULLFREE(pCtx, pvhStatus);
SG_NULLFREE(pCtx, pszFragballName);
SG_VHASH_NULLFREE(pCtx, pvhStatus);
}
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 SG_workingdir__create_and_get(
SG_context* pCtx,
const char* pszDescriptorName,
const SG_pathname* pPathDirPutTopLevelDirInHere,
SG_bool bCreateDrawer,
const char* psz_spec_hid_cs_baseline
)
{
SG_repo* pRepo = NULL;
SG_rbtree* pIdsetLeaves = NULL;
SG_uint32 count_leaves = 0;
SG_changeset* pcs = NULL;
const char* pszidUserSuperRoot = NULL;
SG_bool b = SG_FALSE;
char* psz_hid_cs_baseline = NULL;
SG_pendingtree * pPendingTree = NULL;
SG_vhash * pvhTimestamps = NULL;
/*
* Fetch the descriptor by its given name and use it to connect to
* the repo.
*/
SG_ERR_CHECK( SG_repo__open_repo_instance(pCtx, pszDescriptorName, &pRepo) );
if (psz_spec_hid_cs_baseline)
{
SG_ERR_CHECK( SG_strdup(pCtx, psz_spec_hid_cs_baseline, &psz_hid_cs_baseline) );
}
else
{
const char* psz_hid = NULL;
/*
* If you do not specify a hid to be the baseline, then this routine
* currently only works if there is exactly one leaf in the repo.
*/
SG_ERR_CHECK( SG_repo__fetch_dag_leaves(pCtx, pRepo,SG_DAGNUM__VERSION_CONTROL,&pIdsetLeaves) );
SG_ERR_CHECK( SG_rbtree__count(pCtx, pIdsetLeaves, &count_leaves) );
if (count_leaves != 1)
SG_ERR_THROW( SG_ERR_MULTIPLE_HEADS_FROM_DAGNODE );
SG_ERR_CHECK( SG_rbtree__iterator__first(pCtx, NULL, pIdsetLeaves, &b, &psz_hid, NULL) );
SG_ERR_CHECK( SG_STRDUP(pCtx, psz_hid, &psz_hid_cs_baseline) );
}
/*
* Load the desired changeset from the repo so we can look up the
* id of its user root directory
*/
SG_ERR_CHECK( SG_changeset__load_from_repo(pCtx, pRepo, psz_hid_cs_baseline, &pcs) );
SG_ERR_CHECK( SG_changeset__get_root(pCtx, pcs, &pszidUserSuperRoot) );
if (bCreateDrawer)
{
SG_ERR_CHECK( SG_VHASH__ALLOC(pCtx, &pvhTimestamps) );
// Retrieve everything into the WD and capture the timestamps on the files that we create.
SG_ERR_CHECK( sg_workingdir__do_get_dir__top(pCtx, pRepo, pPathDirPutTopLevelDirInHere, pszidUserSuperRoot, pvhTimestamps) );
// this creates "repo.json" with the repo-descriptor.
SG_ERR_CHECK( SG_workingdir__set_mapping(pCtx, pPathDirPutTopLevelDirInHere, pszDescriptorName, NULL) );
// this creates an empty "wd.json" file (which doesn't know anything).
SG_ERR_CHECK( SG_PENDINGTREE__ALLOC(pCtx, pPathDirPutTopLevelDirInHere, SG_TRUE, &pPendingTree) );
// force set the initial parents to the current changeset.
SG_ERR_CHECK( SG_pendingtree__set_single_wd_parent(pCtx, pPendingTree, psz_hid_cs_baseline) );
// force initialize the timestamp cache to the list that we just built; this should
// be the only timestamps in the cache since we just populated the WD.
SG_ERR_CHECK( SG_pendingtree__set_wd_timestamp_cache(pCtx, pPendingTree, &pvhTimestamps) ); // this steals our vhash
SG_ERR_CHECK( SG_pendingtree__save(pCtx, pPendingTree) );
}
else
{
// Retrieve everything into the WD but do not create .sgdrawer or record timestamps.
// This is more like an EXPORT operation.
SG_ERR_CHECK( sg_workingdir__do_get_dir__top(pCtx, pRepo, pPathDirPutTopLevelDirInHere, pszidUserSuperRoot, NULL) );
}
fail:
SG_VHASH_NULLFREE(pCtx, pvhTimestamps);
SG_NULLFREE(pCtx, psz_hid_cs_baseline);
SG_CHANGESET_NULLFREE(pCtx, pcs);
SG_RBTREE_NULLFREE(pCtx, pIdsetLeaves);
SG_REPO_NULLFREE(pCtx, pRepo);
SG_PENDINGTREE_NULLFREE(pCtx, pPendingTree);
}
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);
}
static void _fillInUserSelection(
SG_context *pCtx,
SG_string *pstrRepoDescriptorName,
SG_string *replacement)
{
SG_repo *repo = NULL;
SG_varray *users = NULL;
SG_vhash *user = NULL;
SG_uint32 i = 0;
SG_uint32 count;
SG_string *semail = NULL;
SG_string *suid = NULL;
SG_string *entry = NULL;
SG_string *curuid = NULL;
SG_ERR_CHECK( SG_string__clear(pCtx, replacement) );
SG_ERR_CHECK( SG_repo__open_repo_instance(pCtx, SG_string__sz(pstrRepoDescriptorName), &repo) );
SG_ERR_CHECK( SG_user__list_all(pCtx, repo, &users) );
SG_ERR_CHECK( SG_varray__count(pCtx, users, &count) );
SG_ERR_CHECK( SG_STRING__ALLOC(pCtx, &semail) );
SG_ERR_CHECK( SG_STRING__ALLOC(pCtx, &suid) );
SG_ERR_CHECK( SG_STRING__ALLOC(pCtx, &entry) );
SG_ERR_CHECK( SG_STRING__ALLOC(pCtx, &curuid) );
SG_ERR_CHECK( _getUserId(pCtx, repo, curuid) );
for ( i = 0; i < count; ++i )
{
const char *uid = NULL;
const char *email = NULL;
const char *selected = NULL;
SG_ERR_CHECK( SG_varray__get__vhash(pCtx, users, i, &user) );
SG_ERR_CHECK( SG_vhash__get__sz(pCtx, user, "recid", &uid) );
SG_ERR_CHECK( SG_vhash__get__sz(pCtx, user, "email", &email) );
SG_ERR_CHECK( _getEncoded(pCtx, uid, suid) );
SG_ERR_CHECK( _getEncoded(pCtx, email, semail) );
if (eq(SG_string__sz(curuid), uid))
{
selected = " selected='selected' ";
}
else
{
selected = "";
}
SG_ERR_CHECK( SG_string__sprintf(pCtx, entry, "<option value=\"%s\" %s>%s</option>",
SG_string__sz(suid), selected, SG_string__sz(semail)) );
SG_ERR_CHECK( SG_string__append__string(pCtx, replacement, entry) );
}
fail:
SG_VARRAY_NULLFREE(pCtx, users);
SG_REPO_NULLFREE(pCtx, repo);
SG_STRING_NULLFREE(pCtx, semail);
SG_STRING_NULLFREE(pCtx, suid);
SG_STRING_NULLFREE(pCtx, entry);
SG_STRING_NULLFREE(pCtx, curuid);
}
