void u0051_hidlookup__commit_all(
SG_context* pCtx,
const SG_pathname* pPathWorkingDir,
SG_dagnode** ppdn
)
{
SG_pendingtree* pPendingTree = NULL;
SG_repo* pRepo = NULL;
SG_dagnode* pdn = NULL;
SG_audit q;
SG_ERR_CHECK( SG_pendingtree__alloc(pCtx, pPathWorkingDir, SG_FALSE, &pPendingTree) );
SG_ERR_CHECK( SG_pendingtree__get_repo(pCtx, pPendingTree, &pRepo) );
SG_ERR_CHECK( SG_audit__init(pCtx, &q, pRepo, SG_AUDIT__WHEN__NOW, SG_AUDIT__WHO__FROM_SETTINGS) );
SG_ERR_CHECK( unittests_pendingtree__commit(pCtx, pPendingTree, &q, NULL, 0, NULL, NULL, 0, NULL, 0, NULL, 0, &pdn) );
SG_PENDINGTREE_NULLFREE(pCtx, pPendingTree);
*ppdn = pdn;
return;
fail:
SG_PENDINGTREE_NULLFREE(pCtx, pPendingTree);
}
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_group__add_users(
SG_context* pCtx,
SG_repo* pRepo,
const char* psz_group_name,
const char** paszMemberNames,
SG_uint32 count_names
)
{
char* psz_hid_cs_leaf = NULL;
SG_zingtx* pztx = NULL;
SG_dagnode* pdn = NULL;
SG_changeset* pcs = NULL;
SG_audit q;
SG_uint32 i = 0;
char* psz_recid_group = NULL;
char* psz_recid_user = NULL;
SG_ERR_CHECK( SG_zing__get_leaf__fail_if_needs_merge(pCtx, pRepo, SG_DAGNUM__USERS, &psz_hid_cs_leaf) );
SG_ERR_CHECK( SG_audit__init(pCtx, &q, pRepo, SG_AUDIT__WHEN__NOW, SG_AUDIT__WHO__FROM_SETTINGS) );
// lookup the recid of the group
SG_ERR_CHECK( SG_zing__lookup_recid(pCtx, pRepo, SG_DAGNUM__USERS, psz_hid_cs_leaf, "group", "name", psz_group_name, &psz_recid_group) );
/* start a changeset */
SG_ERR_CHECK( SG_zing__begin_tx(pCtx, pRepo, SG_DAGNUM__USERS, q.who_szUserId, psz_hid_cs_leaf, &pztx) );
SG_ERR_CHECK( SG_zingtx__add_parent(pCtx, pztx, psz_hid_cs_leaf) );
for (i=0; i<count_names; i++)
{
// lookup the recid of the user
SG_ERR_CHECK( SG_zing__lookup_recid(pCtx, pRepo, SG_DAGNUM__USERS, psz_hid_cs_leaf, "user", "email", paszMemberNames[i], &psz_recid_user) );
SG_ERR_CHECK( SG_zingtx__add_link__unpacked(pCtx, pztx, psz_recid_user, psz_recid_group, "member") );
SG_NULLFREE(pCtx, psz_recid_user);
}
/* commit the changes */
SG_ERR_CHECK( SG_zing__commit_tx(pCtx, q.when_int64, &pztx, &pcs, &pdn, NULL) );
// fall thru
fail:
if (pztx)
{
SG_ERR_IGNORE( SG_zing__abort_tx(pCtx, &pztx) );
}
SG_NULLFREE(pCtx, psz_hid_cs_leaf);
SG_NULLFREE(pCtx, psz_recid_group);
SG_NULLFREE(pCtx, psz_recid_user);
SG_DAGNODE_NULLFREE(pCtx, pdn);
SG_CHANGESET_NULLFREE(pCtx, pcs);
}
void SG_group__create(
SG_context* pCtx,
SG_repo* pRepo,
const char* psz_name
)
{
char* psz_hid_cs_leaf = NULL;
SG_zingtx* pztx = NULL;
SG_zingrecord* prec = NULL;
SG_dagnode* pdn = NULL;
SG_changeset* pcs = NULL;
SG_zingtemplate* pzt = NULL;
SG_zingfieldattributes* pzfa = NULL;
SG_audit q;
SG_ERR_CHECK( SG_zing__get_leaf__fail_if_needs_merge(pCtx, pRepo, SG_DAGNUM__USERS, &psz_hid_cs_leaf) );
SG_ERR_CHECK( SG_audit__init(pCtx, &q, pRepo, SG_AUDIT__WHEN__NOW, SG_AUDIT__WHO__FROM_SETTINGS) );
/* start a changeset */
SG_ERR_CHECK( SG_zing__begin_tx(pCtx, pRepo, SG_DAGNUM__USERS, q.who_szUserId, psz_hid_cs_leaf, &pztx) );
SG_ERR_CHECK( SG_zingtx__add_parent(pCtx, pztx, psz_hid_cs_leaf) );
SG_ERR_CHECK( SG_zingtx__get_template(pCtx, pztx, &pzt) );
SG_ERR_CHECK( SG_zingtx__create_new_record(pCtx, pztx, "group", &prec) );
SG_ERR_CHECK( SG_zingtemplate__get_field_attributes(pCtx, pzt, "group", "name", &pzfa) );
SG_ERR_CHECK( SG_zingrecord__set_field__string(pCtx, prec, pzfa, psz_name) );
/* commit the changes */
SG_ERR_CHECK( SG_zing__commit_tx(pCtx, q.when_int64, &pztx, &pcs, &pdn, NULL) );
// fall thru
fail:
if (pztx)
{
SG_ERR_IGNORE( SG_zing__abort_tx(pCtx, &pztx) );
}
SG_NULLFREE(pCtx, psz_hid_cs_leaf);
SG_DAGNODE_NULLFREE(pCtx, pdn);
SG_CHANGESET_NULLFREE(pCtx, pcs);
}
void SG_tag__add_tags(SG_context * pCtx, SG_repo * pRepo, SG_pendingtree * pPendingTree, const char* psz_spec_cs, SG_bool bRev, SG_bool bForce, const char** ppszTags, SG_uint32 count_args)
{
SG_pathname* pPathCwd = NULL;
char* psz_hid_cs = NULL;
SG_audit q;
SG_uint32 i = 0;
char * psz_current_hid_with_that_tag = NULL;
SG_bool bFreePendingTree = SG_FALSE;
SG_ERR_CHECK( SG_audit__init(pCtx,&q,pRepo,SG_AUDIT__WHEN__NOW,SG_AUDIT__WHO__FROM_SETTINGS) );
// TODO 4/21/10 pendingtree contains a pRepo inside it. we should
// TODO 4/21/10 refactor this to alloc the pendingtree first and then
// TODO 4/21/10 just borrow the pRepo from it.
if (psz_spec_cs)
{
if (bRev)
{
SG_ERR_CHECK( SG_repo__hidlookup__dagnode(pCtx, pRepo, SG_DAGNUM__VERSION_CONTROL, psz_spec_cs, &psz_hid_cs) );
}
else
{
SG_ERR_CHECK( SG_vc_tags__lookup__tag(pCtx, pRepo, psz_spec_cs, &psz_hid_cs) );
if (psz_hid_cs == NULL)
SG_ERR_THROW(SG_ERR_TAG_NOT_FOUND);
}
}
else
{
// tag the current baseline.
//
// when we have an uncomitted merge, we will have more than one parent.
// what does this command mean then? It feels like we we should throw
// an error and say that you have to commit first.
const SG_varray * pva_wd_parents; // we do not own this
const char * psz_hid_parent_0; // we do not own this
SG_uint32 nrParents;
if (pPendingTree == NULL)
{
SG_ERR_CHECK( SG_pendingtree__alloc_from_cwd(pCtx, SG_TRUE, &pPendingTree) );
bFreePendingTree = SG_TRUE;
}
SG_ERR_CHECK( SG_pendingtree__get_wd_parents__ref(pCtx, pPendingTree, &pva_wd_parents) );
SG_ERR_CHECK( SG_varray__count(pCtx, pva_wd_parents, &nrParents) );
if (nrParents > 1)
SG_ERR_THROW( SG_ERR_CANNOT_DO_WHILE_UNCOMMITTED_MERGE );
SG_ERR_CHECK( SG_varray__get__sz(pCtx, pva_wd_parents, 0, &psz_hid_parent_0) );
SG_ERR_CHECK( SG_strdup(pCtx, psz_hid_parent_0, &psz_hid_cs) );
}
if (!bForce)
{
//Go through and check all tags to make sure that they are not already applied.
for (i = 0; i < count_args; i++)
{
const char * pszTag = ppszTags[i];
SG_ERR_IGNORE( SG_vc_tags__lookup__tag(pCtx, pRepo, pszTag, &psz_current_hid_with_that_tag) );
if (psz_current_hid_with_that_tag != NULL && 0 != strcmp(psz_current_hid_with_that_tag, psz_hid_cs)) //The tag has been applied, but not to the given changeset.
SG_ERR_THROW(SG_ERR_TAG_ALREADY_EXISTS);
SG_NULLFREE(pCtx, psz_current_hid_with_that_tag);
}
}
for (i = 0; i < count_args; i++)
{
const char * pszTag = ppszTags[i];
SG_ERR_CHECK( SG_vc_tags__lookup__tag(pCtx, pRepo, pszTag, &psz_current_hid_with_that_tag) );
if (psz_current_hid_with_that_tag == NULL || 0 != strcmp(psz_current_hid_with_that_tag, psz_hid_cs))
{
//The tag has not been applied, or it's been applied to a different dagnode.
if ( psz_current_hid_with_that_tag != NULL && bForce) //Remove it, if it's already there
SG_ERR_CHECK( SG_vc_tags__remove(pCtx, pRepo, &q, 1, &pszTag) );
SG_ERR_CHECK( SG_vc_tags__add(pCtx, pRepo, psz_hid_cs, pszTag, &q) );
}
SG_NULLFREE(pCtx, psz_current_hid_with_that_tag);
}
fail:
SG_NULLFREE(pCtx, psz_current_hid_with_that_tag);
if (bFreePendingTree == SG_TRUE)
SG_PENDINGTREE_NULLFREE(pCtx, pPendingTree);
SG_NULLFREE(pCtx, psz_hid_cs);
SG_PATHNAME_NULLFREE(pCtx, pPathCwd);
}
void SG_tag__remove(SG_context * pCtx, SG_repo * pRepo, const char* pszRev, SG_bool bRev, SG_uint32 count_args, const char** paszArgs)
{
SG_audit q;
char* psz_hid_given = NULL;
char* psz_hid_assoc_with_tag = NULL;
SG_uint32 count_valid_tags = 0;
const char** paszValidArgs = NULL;
SG_uint32 i = 0;
if (0 == count_args)
return;
SG_ERR_CHECK( SG_audit__init(pCtx,&q,pRepo,SG_AUDIT__WHEN__NOW,SG_AUDIT__WHO__FROM_SETTINGS) );
if (pszRev)
{
if (bRev)
SG_repo__hidlookup__dagnode(pCtx, pRepo, SG_DAGNUM__VERSION_CONTROL, pszRev, &psz_hid_given);
else
SG_vc_tags__lookup__tag(pCtx, pRepo, pszRev, &psz_hid_given);
if (SG_context__has_err(pCtx))
{
if (SG_context__err_equals(pCtx, SG_ERR_AMBIGUOUS_ID_PREFIX))
{
SG_context__push_level(pCtx);
SG_console(pCtx, SG_CS_STDERR, "The revision or tag could not be found: %s\n", pszRev);
SG_context__pop_level(pCtx);
SG_ERR_RETHROW;
}
else
SG_ERR_RETHROW;
}
}
// SG_vc_tags__remove will throw on the first non-existant tag and stop
// we don't want to issue errors, just warnings and keep going
// weed out all the invalid tags here before calling SG_vc_tags__remove
SG_ERR_CHECK( SG_alloc(pCtx, count_args, sizeof(const char*), &paszValidArgs) );
for (i =0; i < count_args; i++)
{
SG_ERR_CHECK( SG_vc_tags__lookup__tag(pCtx, pRepo, paszArgs[i], &psz_hid_assoc_with_tag) );
if (psz_hid_assoc_with_tag) // tag exists
{
if (psz_hid_given)
{
if (strcmp(psz_hid_given, psz_hid_assoc_with_tag) == 0) // tag is assoc with given changeset
paszValidArgs[count_valid_tags++] = paszArgs[i];
else // tag not assoc with given changeset, no error, but warn
SG_ERR_IGNORE( SG_console(pCtx, SG_CS_STDOUT, "Tag not associated with given revision: %s\n", paszArgs[i]) );
}
else
paszValidArgs[count_valid_tags++] = paszArgs[i];
}
else
{
SG_ERR_IGNORE( SG_console(pCtx, SG_CS_STDOUT, "Tag not found: %s\n", paszArgs[i]) );
}
SG_NULLFREE(pCtx, psz_hid_assoc_with_tag);
psz_hid_assoc_with_tag = NULL;
}
SG_ERR_CHECK( SG_vc_tags__remove(pCtx, pRepo, &q, count_valid_tags, paszValidArgs) );
fail:
SG_NULLFREE(pCtx, paszValidArgs);
SG_NULLFREE(pCtx, psz_hid_given);
SG_NULLFREE(pCtx, psz_hid_assoc_with_tag);
}
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_vc_hooks__lookup_by_interface__single_result(
SG_context* pCtx,
SG_repo* pRepo,
const char* psz_interface,
SG_vhash** ppvh_latest_version
)
{
//This version will return only the hook with the largest version.
//If multiple versions of the hook are defined,
//all old versions will be deleted.
SG_varray* pva_hooks = NULL;
SG_vhash* pvh_latest_hook = NULL;
SG_zingtx* pztx = NULL;
char* psz_hid_cs_leaf = NULL;
SG_dagnode* pdn = NULL;
SG_changeset* pcs = NULL;
SG_ERR_CHECK( SG_vc_hooks__lookup_by_interface(
pCtx,
pRepo,
psz_interface,
&pva_hooks
) );
if (!pva_hooks)
{
SG_ERR_THROW2( SG_ERR_VC_HOOK_MISSING,
(pCtx, "%s", psz_interface)
);
}
else
{
SG_uint32 count = 0;
SG_ERR_CHECK( SG_varray__count(pCtx, pva_hooks, &count) );
if (0 == count)
{
SG_ERR_THROW2( SG_ERR_VC_HOOK_MISSING,
(pCtx, "%s", psz_interface)
);
}
else
{
if (count > 1)
{
SG_uint32 i = 0;
SG_int32 nVersion = 0;
SG_int32 nHighestVersion = -1;
SG_int32 nAmbiguousVersion = -2;
const char * hidRecToSave = NULL;
const char * hidrec = NULL;
SG_vhash * pvh_current_hook = NULL;
//There are multiple versions installed for this hook.
//delete the lesser numbered versions.
for (i=0; i < count; i++)
{
SG_ERR_CHECK( SG_varray__get__vhash(pCtx, pva_hooks, i, &pvh_current_hook) );
SG_ERR_CHECK( SG_vhash__get__int32(pCtx, pvh_current_hook, "version", &nVersion) );
if (nVersion == nHighestVersion)
{
nAmbiguousVersion = nHighestVersion;
}
if (nVersion > nHighestVersion)
{
nHighestVersion = nVersion;
SG_ERR_CHECK( SG_vhash__get__sz(pCtx, pvh_current_hook, "hidrec", &hidRecToSave) );
}
}
if (nAmbiguousVersion == nHighestVersion)
SG_ERR_THROW2( SG_ERR_VC_HOOK_AMBIGUOUS, (pCtx, "%s defined multiple times at version %d", psz_interface, nHighestVersion) );
if (nHighestVersion > 0 && hidRecToSave != NULL)
{
SG_audit q;
SG_ERR_CHECK( SG_audit__init(pCtx,&q,pRepo,SG_AUDIT__WHEN__NOW,SG_AUDIT__WHO__FROM_SETTINGS) );
SG_ERR_CHECK( SG_zing__get_leaf(pCtx, pRepo, NULL, SG_DAGNUM__VC_HOOKS, &psz_hid_cs_leaf) );
/* start a changeset */
SG_ERR_CHECK( SG_zing__begin_tx(pCtx, pRepo, SG_DAGNUM__VC_HOOKS, q.who_szUserId, psz_hid_cs_leaf, &pztx) );
SG_ERR_CHECK( SG_zingtx__add_parent(pCtx, pztx, psz_hid_cs_leaf) );
for (i=0; i < count; i++)
{
SG_ERR_CHECK( SG_varray__get__vhash(pCtx, pva_hooks, i, &pvh_current_hook) );
SG_ERR_CHECK( SG_vhash__get__sz(pCtx, pvh_current_hook, "hidrec", &hidrec) );
if (SG_strcmp__null(hidrec, hidRecToSave) != 0)
{
//This isn't the recid to save. Delete it!
SG_ERR_CHECK( SG_zingtx__delete_record__hid(pCtx, pztx, "hook", hidrec) );
}
}
/* commit the changes */
SG_ERR_CHECK( SG_zing__commit_tx(pCtx, q.when_int64, &pztx, &pcs, &pdn, NULL) );
}
}
else
{
//There's only one hook installed return it.
SG_vhash * pvh_temp = NULL;
SG_ERR_CHECK( SG_varray__get__vhash(pCtx, pva_hooks, 0, &pvh_temp) );
SG_ERR_CHECK( SG_VHASH__ALLOC__COPY(pCtx, &pvh_latest_hook, pvh_temp) );
}
}
}
SG_RETURN_AND_NULL(pvh_latest_hook, ppvh_latest_version);
fail:
if (pztx)
{
SG_ERR_IGNORE( SG_zing__abort_tx(pCtx, &pztx) );
}
SG_NULLFREE(pCtx, psz_hid_cs_leaf);
SG_DAGNODE_NULLFREE(pCtx, pdn);
SG_CHANGESET_NULLFREE(pCtx, pcs);
SG_VARRAY_NULLFREE(pCtx, pva_hooks);
}
/**
* Request to UNLOCK on one or more files.
*
* WARNING: This routine deviates from the model of most
* WARNING: of the SG_wc__ level-8 and/or SG_wc_tx level-7
* WARNING: API routines because we cannot just "queue" an
* WARNING: unlock like we do a RENAME with everything
* WARNING: contained within the pWcTx; we actually have
* WARNING: to update the locks dag (which is outside of
* WARNING: the scope of the WC TX).
* WARNING:
* WARNING: So we only have a level-8 API
* WARNING: so that we can completely control/bound the TX.
*
* We also deviate in that we don't take a --test
* nor --verbose option. Which means we don't have a
* JOURNAL to mess with.
*
*/
void SG_wc__unlock(SG_context * pCtx,
const SG_pathname* pPathWc,
const SG_stringarray * psaInputs,
SG_bool bForce,
const char * psz_username,
const char * psz_password,
const char * psz_repo_upstream)
{
SG_wc_tx * pWcTx = NULL;
SG_audit q;
SG_uint32 nrInputs = 0;
SG_uint32 k;
char * psz_tied_branch_name = NULL;
char * psz_repo_upstream_allocated = NULL;
SG_vhash * pvh_gids = NULL;
const char * pszRepoDescriptorName = NULL; // we do not own this
if (psaInputs)
SG_ERR_CHECK( SG_stringarray__count(pCtx, psaInputs, &nrInputs) );
if (nrInputs == 0)
SG_ERR_THROW2( SG_ERR_INVALIDARG,
(pCtx, "Nothing to unlock") );
// psz_username is optional (assume no auth required)
// psz_password is optional (assume no auth required)
// psz_server is optional (assume default server)
// Begin a WC TX so that we get all of the good stuff
// (like mapping the CWD into a REPO handle and mapping
// the inputs into GIDs).
//
// At this point I don't believe that setting a lock
// will actually make any changes in WC.DB, so I'm
// making it a READ-ONLY TX.
//
// My assumption is that the lock actually gets
// written to the Locks DAG and shared with the server.
// But I still want a TX handle for all of the other stuff.
SG_ERR_CHECK( SG_WC_TX__ALLOC__BEGIN(pCtx, &pWcTx, pPathWc, SG_FALSE) );
// We need the repo descriptor name later for the push/pull
// and to optionally look up the default destination for
// this repo. The pRepo stores this *IFF* it was properly
// opened (using a name).
SG_ERR_CHECK( SG_repo__get_descriptor_name(pCtx, pWcTx->pDb->pRepo,
&pszRepoDescriptorName) );
SG_ASSERT_RELEASE_FAIL2( (pszRepoDescriptorName && *pszRepoDescriptorName),
(pCtx, "SG_wc__unlock: Could not get repo descriptor name.") );
// now we need to know what branch we are tied to.
// if we're not tied, fail
SG_ERR_CHECK( SG_wc_tx__branch__get(pCtx, pWcTx, &psz_tied_branch_name) );
if (!psz_tied_branch_name)
SG_ERR_THROW( SG_ERR_NOT_TIED );
SG_ERR_CHECK( SG_VHASH__ALLOC(pCtx, &pvh_gids) );
for (k=0; k<nrInputs; k++)
{
const char * pszInput_k;
SG_ERR_CHECK( SG_stringarray__get_nth(pCtx, psaInputs, k, &pszInput_k) );
SG_ERR_CHECK( _map_input(pCtx, pWcTx, pvh_gids, pszInput_k) );
}
if (!psz_repo_upstream)
{
SG_localsettings__descriptor__get__sz(pCtx, pszRepoDescriptorName,
"paths/default",
&psz_repo_upstream_allocated);
if (SG_context__err_equals(pCtx, SG_ERR_NOT_FOUND))
SG_ERR_REPLACE_ANY_RETHROW( SG_ERR_NO_SERVER_SPECIFIED );
else
SG_ERR_CHECK_CURRENT;
psz_repo_upstream = psz_repo_upstream_allocated;
}
SG_ERR_CHECK( SG_audit__init(pCtx, &q, pWcTx->pDb->pRepo,
SG_AUDIT__WHEN__NOW,
SG_AUDIT__WHO__FROM_SETTINGS) );
// OK, we have all the pieces. Time to call the unlock code
SG_ERR_CHECK( SG_vc_locks__unlock(
pCtx,
pszRepoDescriptorName,
psz_repo_upstream,
psz_username,
psz_password,
psz_tied_branch_name,
pvh_gids,
bForce,
&q
) );
// Fall through and let the normal fail code discard/cancel
// the read-only WC TX. This will not affect the Locks DAG
// nor the server.
fail:
SG_ERR_IGNORE( SG_wc_tx__cancel(pCtx, pWcTx) );
SG_WC_TX__NULLFREE(pCtx, pWcTx);
SG_NULLFREE(pCtx, psz_tied_branch_name);
SG_NULLFREE(pCtx, psz_repo_upstream_allocated);
SG_VHASH_NULLFREE(pCtx, pvh_gids);
}
