/**
* Try to FIX each ISSUE in the array and update the WD and allow
* incremental saves of the pendingtree.
*/
static void _resolve__do_fix(SG_context * pCtx, struct _resolve_data * pData)
{
SG_uint32 k, kLimit;
SG_ERR_CHECK( SG_stringarray__count(pCtx, pData->psaGids, &kLimit) );
for (k=0; k<kLimit; k++)
{
const char * pszGid_k;
enum _fix_status fixStatus;
SG_ERR_CHECK( SG_stringarray__get_nth(pCtx, pData->psaGids, k, &pszGid_k) );
SG_ERR_CHECK( _resolve__fix(pCtx, pData, pszGid_k, &fixStatus) );
// If everything went well, we go on to the next ISSUE in the list.
// If the user aborted the merge (or if we had a problem of some kind
// we should probably just stop).
if ((fixStatus != FIX_USER_MERGED) && (k+1 < kLimit))
{
// TODO 2010/07/12 Ask if they want to continue anyway.
break;
}
}
fail:
return;
}
/**
* Print detailed info for each ISSUE in the array.
*/
static void _resolve__do_list(SG_context * pCtx, struct _resolve_data * pData)
{
SG_uint32 k, kLimit;
SG_ERR_CHECK( SG_stringarray__count(pCtx, pData->psaGids, &kLimit) );
for (k=0; k<kLimit; k++)
{
const char * pszGid_k;
const SG_vhash * pvhIssue_k;
SG_bool bFound;
SG_ERR_CHECK( SG_stringarray__get_nth(pCtx, pData->psaGids, k, &pszGid_k) );
SG_ERR_CHECK( SG_pendingtree__find_wd_issue_by_gid(pCtx, pData->pPendingTree, pszGid_k, &bFound, &pvhIssue_k) );
if (!bFound)
{
// This should never happen because we are still holding the
// pendingtree lock and still have the original pendingtree
// structure in memory.
SG_ERR_THROW2( SG_ERR_ASSERT,
(pCtx, "RESOLVE failed to find ISSUE for GID %s.", pszGid_k) );
}
SG_ERR_CHECK( _resolve__list(pCtx, pData, pvhIssue_k, NULL) );
}
fail:
return;
}
void SG_stringarray__alloc__copy(
SG_context* pCtx,
SG_stringarray** ppThis,
const SG_stringarray* pOther
)
{
SG_uint32 count = 0;
SG_stringarray * pThis = NULL;
SG_uint32 i;
SG_ASSERT(pCtx!=NULL);
SG_NULLARGCHECK_RETURN(ppThis);
SG_NULLARGCHECK_RETURN(pOther);
SG_ERR_CHECK( SG_stringarray__count(pCtx, pOther, &count) );
SG_ERR_CHECK( SG_stringarray__alloc(pCtx, &pThis, count) );
for(i=0;i<count;++i)
{
const char * sz = NULL;
SG_ERR_CHECK( SG_stringarray__get_nth(pCtx, pOther, i, &sz) );
SG_ERR_CHECK( SG_stringarray__add(pCtx, pThis, sz) );
}
*ppThis = pThis;
return;
fail:
SG_STRINGARRAY_NULLFREE(pCtx, pThis);
}
// TODO consider the possible perf benefits of changing this routine
// to accept lots of changeset ids instead of just one, so it
// can handle them all at once.
void SG_treendx__update__multiple(
SG_context* pCtx,
SG_treendx* pTreeNdx,
SG_stringarray* psa
)
{
SG_changeset* pcs = NULL;
sqlite3_stmt* pStmt = NULL;
SG_vhash* pvh_treepaths = NULL;
SG_uint32 count_treepaths = 0;
SG_uint32 count_changesets = 0;
SG_uint32 ics = 0;
SG_NULLARGCHECK_RETURN(psa);
SG_NULLARGCHECK_RETURN(pTreeNdx);
SG_ERR_CHECK( SG_stringarray__count(pCtx, psa, &count_changesets) );
SG_ERR_CHECK( sg_sqlite__exec__va(pCtx, pTreeNdx->psql, "BEGIN TRANSACTION; ") );
SG_ERR_CHECK( sg_sqlite__prepare(pCtx, pTreeNdx->psql, &pStmt, "INSERT OR IGNORE INTO treendx (gid, strpath) VALUES (?, ?)") );
for (ics=0; ics<count_changesets; ics++)
{
const char* psz_hid = NULL;
SG_uint32 i = 0;
SG_ERR_CHECK( SG_stringarray__get_nth(pCtx, psa, ics, &psz_hid) );
SG_ERR_CHECK( SG_changeset__load_from_repo(pCtx, pTreeNdx->pRepo, psz_hid, &pcs) );
SG_ERR_CHECK( SG_changeset__get_treepaths(pCtx, pcs, &pvh_treepaths) );
if (pvh_treepaths)
{
SG_ERR_CHECK( SG_vhash__count(pCtx, pvh_treepaths, &count_treepaths) );
for (i=0; i<count_treepaths; i++)
{
const char* psz_gid = NULL;
const SG_variant* pv = NULL;
const char* psz_path = NULL;
SG_ERR_CHECK( SG_vhash__get_nth_pair(pCtx, pvh_treepaths, i, &psz_gid, &pv) );
SG_ERR_CHECK( SG_variant__get__sz(pCtx, pv, &psz_path) );
SG_ERR_CHECK( sg_sqlite__reset(pCtx, pStmt) );
SG_ERR_CHECK( sg_sqlite__clear_bindings(pCtx, pStmt) );
SG_ERR_CHECK( sg_sqlite__bind_text(pCtx, pStmt, 1, psz_gid) );
SG_ERR_CHECK( sg_sqlite__bind_text(pCtx, pStmt, 2, psz_path) );
SG_ERR_CHECK( sg_sqlite__step(pCtx, pStmt, SQLITE_DONE) );
}
}
SG_CHANGESET_NULLFREE(pCtx, pcs);
}
SG_ERR_CHECK( sg_sqlite__nullfinalize(pCtx, &pStmt) );
SG_ERR_CHECK( sg_sqlite__exec__va(pCtx, pTreeNdx->psql, "COMMIT TRANSACTION; ") );
fail:
SG_CHANGESET_NULLFREE(pCtx, pcs);
}
void SG_treendx__get_path_in_dagnode(SG_context* pCtx, SG_treendx* pTreeNdx, const char* psz_search_item_gid, const char* psz_changeset, SG_treenode_entry ** ppTreeNodeEntry)
{
SG_rbtree_iterator * rb_it = NULL;
const char * pPath = NULL;
SG_changeset * pChangeset = NULL;
SG_stringarray * pPaths = NULL;
const char* pszHidTreeNode = NULL;
SG_treenode * pTreenodeRoot = NULL;
char* pszReturnedGID = NULL;
SG_uint32 i = 0;
SG_uint32 count = 0;
SG_ERR_CHECK_RETURN( SG_gid__argcheck(pCtx, psz_search_item_gid) );
SG_ERR_CHECK( SG_treendx__get_all_paths(pCtx, pTreeNdx, psz_search_item_gid, &pPaths) );
*ppTreeNodeEntry = NULL;
SG_ERR_CHECK( SG_changeset__load_from_repo(pCtx, pTreeNdx->pRepo, psz_changeset, &pChangeset) );
SG_ERR_CHECK( SG_changeset__get_root(pCtx, pChangeset, &pszHidTreeNode) );
SG_ERR_CHECK( SG_treenode__load_from_repo(pCtx, pTreeNdx->pRepo, pszHidTreeNode, &pTreenodeRoot) );
SG_ERR_CHECK( SG_stringarray__count(pCtx, pPaths, &count ) );
for (i = 0; i < count; i++)
{
SG_ERR_CHECK( SG_stringarray__get_nth(pCtx, pPaths, i, &pPath) );
SG_ERR_CHECK( SG_treenode__find_treenodeentry_by_path(pCtx, pTreeNdx->pRepo, pTreenodeRoot, pPath, &pszReturnedGID, ppTreeNodeEntry) );
if (*ppTreeNodeEntry != NULL && strcmp(pszReturnedGID, psz_search_item_gid) == 0)
{
break;
}
else if (*ppTreeNodeEntry != NULL)
{
SG_TREENODE_ENTRY_NULLFREE(pCtx, *ppTreeNodeEntry);
*ppTreeNodeEntry = NULL; //It's not the right GID, even though it's in the right spot.
}
}
SG_NULLFREE(pCtx, pszReturnedGID);
SG_CHANGESET_NULLFREE(pCtx, pChangeset);
SG_TREENODE_NULLFREE(pCtx, pTreenodeRoot);
SG_STRINGARRAY_NULLFREE(pCtx, pPaths);
SG_RBTREE_ITERATOR_NULLFREE(pCtx, rb_it);
return;
fail:
SG_NULLFREE(pCtx, pszReturnedGID);
SG_CHANGESET_NULLFREE(pCtx, pChangeset);
SG_STRINGARRAY_NULLFREE(pCtx, pPaths);
SG_RBTREE_ITERATOR_NULLFREE(pCtx, rb_it);
return;
}
/**
* Update the RESOLVED/UNRESOLVED status for each ISSUE in the array
* and then SAVE the pendingtree.
*/
static void _resolve__do_mark(SG_context * pCtx, struct _resolve_data * pData, SG_bool bMarkResolved)
{
SG_uint32 k, kLimit;
SG_ERR_CHECK( SG_stringarray__count(pCtx, pData->psaGids, &kLimit) );
for (k=0; k<kLimit; k++)
{
const char * pszGid_k;
SG_ERR_CHECK( SG_stringarray__get_nth(pCtx, pData->psaGids, k, &pszGid_k) );
SG_ERR_CHECK( _resolve__do_mark_1(pCtx, pData, pszGid_k, bMarkResolved) );
}
fail:
return;
}
/**
* Begin a canonical STATUS when given one or more items using a SG_stringarray.
* If psaInputs is NULL, assume the entire tree.
*
* We accumulate all of the results into a single pvaStatus.
*
* This status routine uses a pWcTx so that the results
* reflect the in-progress transaction.
*
*/
void SG_wc_tx__status__stringarray(SG_context * pCtx,
SG_wc_tx * pWcTx,
const SG_stringarray * psaInputs,
SG_uint32 depth,
SG_bool bListUnchanged,
SG_bool bNoIgnores,
SG_bool bNoTSC,
SG_bool bListSparse,
SG_bool bListReserved,
SG_bool bNoSort,
SG_varray ** ppvaStatus,
SG_vhash ** ppvhLegend)
{
SG_varray * pvaStatus = NULL;
SG_uint32 k, count;
SG_vhash * pvhLegend = NULL;
SG_NULLARGCHECK_RETURN( pWcTx );
SG_NULLARGCHECK_RETURN( ppvaStatus );
// ppvhLegend is optional
SG_ERR_CHECK( SG_VARRAY__ALLOC(pCtx, &pvaStatus) );
if (psaInputs)
{
SG_ERR_CHECK( SG_stringarray__count(pCtx, psaInputs, &count) );
for (k=0; k<count; k++)
{
const char * pszInput_k;
SG_ERR_CHECK( SG_stringarray__get_nth(pCtx, psaInputs, k, &pszInput_k) );
SG_ERR_CHECK( _sg_wc_tx__status(pCtx, pWcTx, pvaStatus, pszInput_k, depth,
bListUnchanged, bNoIgnores, bNoTSC, bListSparse, bListReserved,
(((k==0) && ppvhLegend) ? &pvhLegend : NULL)) );
}
if (ppvhLegend)
{
*ppvhLegend = pvhLegend;
pvhLegend = NULL;
}
// In case they said, "vv status foo foo foo" or something
// like "vv status dirA/foo dirA" we need to de-dup the results
// since we called the internal status with each input[k] and
// just accumulated the results.
SG_ERR_CHECK( SG_vaofvh__dedup(pCtx, pvaStatus, "gid") );
}
else
{
// if no args, assume "@/" for the STATUS.
SG_ERR_CHECK( _sg_wc_tx__status(pCtx, pWcTx, pvaStatus, NULL, depth,
bListUnchanged, bNoIgnores, bNoTSC, bListSparse, bListReserved,
ppvhLegend) );
// we don't need to de-dup since we simulated 1 argument.
}
if (!bNoSort)
SG_ERR_CHECK( SG_wc__status__sort_by_repopath(pCtx, pvaStatus) );
*ppvaStatus = pvaStatus;
pvaStatus = NULL;
fail:
SG_VARRAY_NULLFREE(pCtx, pvaStatus);
SG_VHASH_NULLFREE(pCtx, pvhLegend);
}
static void _merge__compute_target_hid(SG_context * pCtx,
SG_mrg * pMrg)
{
const SG_rev_spec * pRevSpec = ((pMrg->pMergeArgs) ? pMrg->pMergeArgs->pRevSpec : NULL);
SG_stringarray * psaHids = NULL;
SG_stringarray * psaMissingHids = NULL;
SG_rev_spec * pRevSpec_Allocated = NULL;
SG_bool bRequestedAttachedBranch = SG_FALSE;
SG_stringarray * psaBranchesRequested = NULL;
const char * pszBranchNameRequested = NULL;
SG_uint32 nrMatched = 0;
SG_uint32 nrMatchedExcludingParent = 0;
if (pRevSpec)
{
SG_uint32 uTotal = 0u;
SG_uint32 uBranches = 0u;
SG_ERR_CHECK( SG_rev_spec__count(pCtx, pRevSpec, &uTotal) );
SG_ERR_CHECK( SG_rev_spec__count_branches(pCtx, pRevSpec, &uBranches) );
if (uTotal == 0u)
{
// if the rev spec is empty, just pretend it doesn't exist
pRevSpec = NULL;
}
else if (uTotal > 1u)
{
// we can only handle a single specification
SG_ERR_THROW2(SG_ERR_INVALIDARG, (pCtx, "Merge can accept at most one revision/tag/branch specifier."));
}
else if (uTotal == 1u && uBranches == 1u)
{
SG_ERR_CHECK( SG_rev_spec__branches(pCtx, (/*const*/ SG_rev_spec *)pRevSpec, &psaBranchesRequested) );
SG_ERR_CHECK( SG_stringarray__get_nth(pCtx, psaBranchesRequested, 0, &pszBranchNameRequested) );
if (pMrg->pszBranchName_Starting)
bRequestedAttachedBranch = (strcmp(pszBranchNameRequested, pMrg->pszBranchName_Starting) == 0);
}
}
if (!pRevSpec)
{
if (!pMrg->pszBranchName_Starting)
SG_ERR_THROW( SG_ERR_NOT_TIED );
SG_ERR_CHECK( SG_REV_SPEC__ALLOC(pCtx, &pRevSpec_Allocated) );
SG_ERR_CHECK( SG_rev_spec__add_branch(pCtx, pRevSpec_Allocated, pMrg->pszBranchName_Starting) );
pRevSpec = pRevSpec_Allocated;
pszBranchNameRequested = pMrg->pszBranchName_Starting;
bRequestedAttachedBranch = SG_TRUE;
}
// Lookup the given (or synthesized) --rev/--tag/--branch
// and see how many csets it refers to. Disregard/filter-out
// any that are not present in the local repo.
SG_ERR_CHECK( SG_rev_spec__get_all__repo(pCtx, pMrg->pWcTx->pDb->pRepo, pRevSpec, SG_TRUE,
&psaHids, &psaMissingHids) );
SG_ERR_CHECK( SG_stringarray__count(pCtx, psaHids, &nrMatched) );
if (nrMatched == 0)
{
SG_uint32 nrMissing = 0;
SG_ASSERT_RELEASE_FAIL( (psaMissingHids != NULL) );
SG_ERR_CHECK( SG_stringarray__count(pCtx, psaMissingHids, &nrMissing) );
if (nrMissing == 1)
{
const char * psz_0;
SG_ERR_CHECK( SG_stringarray__get_nth(pCtx, psaMissingHids, 0, &psz_0) );
SG_ERR_THROW2( SG_ERR_BRANCH_HEAD_CHANGESET_NOT_PRESENT,
(pCtx, "Branch '%s' refers to changeset '%s'. Consider pulling.",
pszBranchNameRequested, psz_0) );
}
else
{
SG_ERR_THROW2( SG_ERR_BRANCH_HEAD_CHANGESET_NOT_PRESENT,
(pCtx, "Branch '%s' refers to %d changesets that are not present. Consider pulling.",
pszBranchNameRequested, nrMissing) );
}
}
else if (nrMatched == 1)
{
// We found a single unique match for our request.
// We ***DO NOT*** disqualify the current baseline
// in this case. We let routines like do_cmd_merge_preview()
// report that.
const char * psz_0;
SG_ERR_CHECK( SG_stringarray__get_nth(pCtx, psaHids, 0, &psz_0) );
SG_ERR_CHECK( SG_STRDUP(pCtx, psz_0, &pMrg->pszHidTarget) );
}
else
{
// We can only get here if pRevSpec contained a "--branch ..."
// reference (because the "--rev" lookup throws when given a
// non-unique prefix and "--tag" can only be bound to a single
// cset).
//
// If they referenced the attached branch (and the baseline is
// pointing at a head), we'll get our baseline in the result set,
// so get rid of it.
SG_ERR_CHECK( SG_stringarray__remove_all(pCtx, psaHids, pMrg->pszHid_StartingBaseline, NULL) );
SG_ERR_CHECK( SG_stringarray__count(pCtx, psaHids, &nrMatchedExcludingParent) );
if (nrMatchedExcludingParent == 1)
{
// parent may or may not be a head of this branch, but
// we found a single head or single other head.
const char * psz_0;
SG_ERR_CHECK( SG_stringarray__get_nth(pCtx, psaHids, 0, &psz_0) );
SG_ERR_CHECK( SG_STRDUP(pCtx, psz_0, &pMrg->pszHidTarget) );
}
else if (nrMatchedExcludingParent < nrMatched)
{
// There were at least 3 heads of this branch and the baseline
// is one of them. Throwing a generic 'needs merge' message is
// not helpful.
SG_ERR_THROW2( SG_ERR_BRANCH_NEEDS_MERGE,
(pCtx, "Branch '%s' has %d heads (excluding the baseline). Consider merging one of the other heads using --rev/--tag.",
pszBranchNameRequested, nrMatchedExcludingParent) );
}
else //if (nrMatchedExcludingParent == nrMatched)
{
// The requested branch has multiple heads and the current
// baseline is NOT one of them. The current baseline MAY OR MAY NOT
// be in that branch. (And independently, we may or may not be
// attached to that branch.)
//
// See how the heads are related to the current baseline.
const char * pszDescendant0 = NULL;
const char * pszAncestor0 = NULL;
SG_uint32 nrDescendants = 0;
SG_uint32 nrAncestors = 0;
SG_uint32 k;
for (k=0; k<nrMatched; k++)
{
const char * psz_k;
SG_dagquery_relationship dqRel;
SG_ERR_CHECK( SG_stringarray__get_nth(pCtx, psaHids, k, &psz_k) );
SG_ERR_CHECK( SG_dagquery__how_are_dagnodes_related(pCtx, pMrg->pWcTx->pDb->pRepo,
SG_DAGNUM__VERSION_CONTROL,
psz_k, pMrg->pszHid_StartingBaseline,
SG_FALSE, SG_FALSE, &dqRel) );
if (dqRel == SG_DAGQUERY_RELATIONSHIP__DESCENDANT)
{
pszDescendant0 = psz_k;
nrDescendants++; // target[k] is descendant of baseline
}
else if (dqRel == SG_DAGQUERY_RELATIONSHIP__ANCESTOR)
{
pszAncestor0 = psz_k;
nrAncestors++; // target[k] is ancestor of baseline
}
}
SG_ASSERT( ((nrDescendants == 0) || (nrAncestors == 0)) );
if (nrDescendants == 1)
{
if (bRequestedAttachedBranch) // The current baseline is attached to the same branch, just not a head.
SG_ERR_THROW2( SG_ERR_BRANCH_NEEDS_MERGE,
(pCtx, "Branch '%s' has %d heads. Only changeset '%s' is a descendant of the current baseline. Consider updating to it and then merging the branch.",
pszBranchNameRequested, nrMatched, pszDescendant0) );
else if (pMrg->pszBranchName_Starting) // currently attached to a different branch
SG_ERR_THROW2( SG_ERR_BRANCH_NEEDS_MERGE,
(pCtx, "Branch '%s' has %d heads. Only changeset '%s' is a descendant of the current baseline. Consider updating to it. You are attached to branch '%s'.",
pszBranchNameRequested, nrMatched, pszDescendant0, pMrg->pszBranchName_Starting) );
else // currently detached
SG_ERR_THROW2( SG_ERR_BRANCH_NEEDS_MERGE,
(pCtx, "Branch '%s' has %d heads. Only changeset '%s' is a descendant of the current baseline. Consider updating to it. You are not attached to a branch.",
pszBranchNameRequested, nrMatched, pszDescendant0) );
}
else if (nrDescendants > 1) // nrDescendants may or may not be equal to nrMatched since there may be peers too.
{
if (bRequestedAttachedBranch) // The current baseline is attached to the same branch, just not a head.
SG_ERR_THROW2( SG_ERR_BRANCH_NEEDS_MERGE,
(pCtx, "Branch '%s' has %d heads. %d are descendants of the current baseline. Consider updating to one of them and then merging the branch.",
pszBranchNameRequested, nrMatched, nrDescendants) );
else if (pMrg->pszBranchName_Starting) // currently attached to a different branch
SG_ERR_THROW2( SG_ERR_BRANCH_NEEDS_MERGE,
(pCtx, "Branch '%s' has %d heads. %d are descendants of the current baseline. Consider updating to one of them. You are attached to branch '%s'.",
pszBranchNameRequested, nrMatched, nrDescendants, pMrg->pszBranchName_Starting) );
else // currently detached
SG_ERR_THROW2( SG_ERR_BRANCH_NEEDS_MERGE,
(pCtx, "Branch '%s' has %d heads. %d are descendants of the current baseline. Consider updating to one of them. You are not attached to a branch.",
pszBranchNameRequested, nrMatched, nrDescendants) );
}
else if (nrAncestors == 1)
{
if (bRequestedAttachedBranch) // The current baseline is attached to the same branch, but the head pointer is not pointing at us.
SG_ERR_THROW2( SG_ERR_BRANCH_NEEDS_MERGE,
(pCtx, "Branch '%s' has %d heads. Changeset '%s' is an ancestor of the current baseline. Consider moving that head forward and then merging the branch.",
pszBranchNameRequested, nrMatched, pszAncestor0) );
else if (pMrg->pszBranchName_Starting) // currently attached to a different branch
SG_ERR_THROW2( SG_ERR_BRANCH_NEEDS_MERGE,
(pCtx, "Branch '%s' has %d heads. Changeset '%s' is an ancestor of the current baseline. Consider moving that head forward. You are attached to branch '%s'.",
pszBranchNameRequested, nrMatched, pszAncestor0, pMrg->pszBranchName_Starting) );
else // currently detached
SG_ERR_THROW2( SG_ERR_BRANCH_NEEDS_MERGE,
(pCtx, "Branch '%s' has %d heads. Changeset '%s' is an ancestor of the current baseline. Consider moving that head forward. You are not attached to a branch.",
pszBranchNameRequested, nrMatched, pszAncestor0) );
}
else if (nrAncestors > 1) // nrAncestors may or may not be equal to nrMatched since there may be peers too.
{
SG_ERR_THROW2( SG_ERR_BRANCH_NEEDS_MERGE,
(pCtx, "Branch '%s' has %d heads. All of them are ancestors of the current baseline. Consider moving one of the heads forward and removing the others.",
pszBranchNameRequested, nrMatched) );
}
else // All of the heads are peers of the current baseline.
{
if (bRequestedAttachedBranch) // The current baseline is attached to the same branch, but the head pointer is not pointing at us.
SG_ERR_THROW2( SG_ERR_BRANCH_NEEDS_MERGE,
(pCtx, "Branch '%s' has %d heads. All are peers of the current baseline. Consider merging one of the other heads using --rev/--tag.",
pszBranchNameRequested, nrMatched) );
else if (pMrg->pszBranchName_Starting) // currently attached to a different branch
SG_ERR_THROW2( SG_ERR_BRANCH_NEEDS_MERGE,
(pCtx, "Branch '%s' has %d heads. All are peers of the current baseline. Consider merging one of the other heads using --rev/--tag. You are attached to branch '%s'.",
pszBranchNameRequested, nrMatched, pMrg->pszBranchName_Starting) );
else // currently detached
SG_ERR_THROW2( SG_ERR_BRANCH_NEEDS_MERGE,
(pCtx, "Branch '%s' has %d heads. All are peers of the current baseline. Consider merging one of the other heads using --rev/--tag. You are not attached to a branch.",
pszBranchNameRequested, nrMatched) );
}
}
}
fail:
SG_STRINGARRAY_NULLFREE(pCtx, psaBranchesRequested);
SG_STRINGARRAY_NULLFREE(pCtx, psaHids);
SG_STRINGARRAY_NULLFREE(pCtx, psaMissingHids);
SG_REV_SPEC_NULLFREE(pCtx, pRevSpec_Allocated);
}
void SG_vc_hooks__BROADCAST__AFTER_COMMIT(
SG_context* pCtx,
SG_repo* pRepo,
SG_changeset* pcs,
const char* psz_tied_branch_name,
const SG_audit* pq,
const char* psz_comment,
const char* const* paszAssocs,
SG_uint32 count_assocs,
const SG_stringarray* psa_stamps
)
{
SG_varray* pva_hooks = NULL;
SG_vhash* pvh_params = NULL;
char* psz_repo_id = NULL;
char* psz_admin_id = NULL;
SG_ERR_CHECK( SG_vc_hooks__lookup_by_interface(
pCtx,
pRepo,
SG_VC_HOOK__INTERFACE__BROADCAST__AFTER_COMMIT,
&pva_hooks
) );
if (pva_hooks)
{
SG_uint32 count_hooks = 0;
SG_uint32 i_hook = 0;
const char* psz_descriptor_name = NULL;
SG_ERR_CHECK( SG_repo__get_admin_id(pCtx, pRepo, &psz_admin_id) );
SG_ERR_CHECK( SG_repo__get_repo_id( pCtx, pRepo, &psz_repo_id ) );
SG_ERR_CHECK( SG_repo__get_descriptor_name(pCtx, pRepo, &psz_descriptor_name) );
SG_ERR_CHECK( SG_varray__count(pCtx, pva_hooks, &count_hooks) );
for (i_hook=0; i_hook<count_hooks; i_hook++)
{
SG_vhash* pvh_hook = NULL;
const char* psz_js = NULL;
const char* psz_csid = NULL;
SG_vhash* pvh_changeset = NULL;
SG_ERR_CHECK( SG_varray__get__vhash(pCtx, pva_hooks, i_hook, &pvh_hook) );
SG_ERR_CHECK( SG_changeset__get_id_ref(pCtx, pcs, &psz_csid) );
SG_ERR_CHECK( SG_changeset__get_vhash_ref(pCtx, pcs, &pvh_changeset) );
SG_ERR_CHECK( SG_vhash__get__sz(pCtx, pvh_hook, "js", &psz_js) );
SG_ERR_CHECK( SG_VHASH__ALLOC(pCtx, &pvh_params) );
SG_ERR_CHECK( SG_vhash__add__string__sz(pCtx, pvh_params, "csid", psz_csid) );
SG_ERR_CHECK( SG_vhash__add__string__sz(pCtx, pvh_params, "repo_id", psz_repo_id) );
SG_ERR_CHECK( SG_vhash__add__string__sz(pCtx, pvh_params, "admin_id", psz_admin_id) );
if (psz_descriptor_name)
{
SG_ERR_CHECK( SG_vhash__add__string__sz(pCtx, pvh_params, "descriptor_name", psz_descriptor_name) );
}
if (pq)
{
SG_ERR_CHECK( SG_vhash__add__string__sz(pCtx, pvh_params, "userid", pq->who_szUserId) );
}
if (psz_comment)
{
SG_ERR_CHECK( SG_vhash__add__string__sz(pCtx, pvh_params, "comment", psz_comment) );
}
if (psz_tied_branch_name)
{
SG_ERR_CHECK( SG_vhash__add__string__sz(pCtx, pvh_params, "branch", psz_tied_branch_name) );
}
SG_ERR_CHECK( SG_vhash__addcopy__vhash(pCtx, pvh_params, "changeset", pvh_changeset) );
if (paszAssocs && count_assocs)
{
SG_uint32 i = 0;
SG_varray* pva_ids = NULL;
SG_ERR_CHECK( SG_vhash__addnew__varray(pCtx, pvh_params, "wit_ids", &pva_ids) );
for (i=0; i<count_assocs; i++)
{
SG_ERR_CHECK( SG_varray__append__string__sz(pCtx, pva_ids, paszAssocs[i]) );
}
}
if (psa_stamps)
{
SG_uint32 count = 0;
SG_uint32 i = 0;
SG_varray* pva_stamps = NULL;
SG_ERR_CHECK( SG_vhash__addnew__varray(pCtx, pvh_params, "stamps", &pva_stamps) );
SG_ERR_CHECK( SG_stringarray__count(pCtx, psa_stamps, &count) );
for (i=0; i<count; i++)
{
const char* psz_stamp = NULL;
SG_ERR_CHECK( SG_stringarray__get_nth(pCtx, psa_stamps, i, &psz_stamp) );
SG_ERR_CHECK( SG_varray__append__string__sz(pCtx, pva_stamps, psz_stamp) );
}
}
SG_ERR_CHECK( SG_vc_hooks__execute(pCtx, psz_js, pvh_params, NULL) );
SG_VHASH_NULLFREE(pCtx, pvh_params);
}
}
fail:
SG_VHASH_NULLFREE(pCtx, pvh_params);
SG_VARRAY_NULLFREE(pCtx, pva_hooks);
SG_NULLFREE(pCtx, psz_repo_id);
SG_NULLFREE(pCtx, psz_admin_id);
}
// TODO not sure we really want to pass this much stuff to this interface
void SG_vc_hooks__ASK__WIT__ADD_ASSOCIATIONS(
SG_context* pCtx,
SG_repo* pRepo,
SG_changeset* pcs,
const char* psz_tied_branch_name,
const SG_audit* pq,
const char* psz_comment,
const char* const* paszAssocs,
SG_uint32 count_assocs,
const SG_stringarray* psa_stamps
)
{
SG_vhash* pvh_hook = NULL;
SG_vhash* pvh_params = NULL;
SG_vhash* pvh_result = NULL;
char* psz_repo_id = NULL;
char* psz_admin_id = NULL;
SG_ERR_CHECK( sg_vc_hooks__lookup_by_interface__single_result(
pCtx,
pRepo,
SG_VC_HOOK__INTERFACE__ASK__WIT__ADD_ASSOCIATIONS,
&pvh_hook
) );
if (pvh_hook)
{
const char* psz_js = NULL;
SG_uint32 i = 0;
SG_varray* pva_ids = NULL;
const char* psz_descriptor_name = NULL;
const char* psz_csid = NULL;
SG_vhash* pvh_changeset = NULL;
SG_ERR_CHECK( SG_repo__get_admin_id(pCtx, pRepo, &psz_admin_id) );
SG_ERR_CHECK( SG_repo__get_repo_id( pCtx, pRepo, &psz_repo_id ) );
SG_ERR_CHECK( SG_repo__get_descriptor_name(pCtx, pRepo, &psz_descriptor_name) );
SG_ERR_CHECK( SG_changeset__get_id_ref(pCtx, pcs, &psz_csid) );
SG_ERR_CHECK( SG_changeset__get_vhash_ref(pCtx, pcs, &pvh_changeset) );
SG_ERR_CHECK( SG_vhash__get__sz(pCtx, pvh_hook, "js", &psz_js) );
SG_ERR_CHECK( SG_VHASH__ALLOC(pCtx, &pvh_params) );
SG_ERR_CHECK( SG_vhash__add__string__sz(pCtx, pvh_params, "csid", psz_csid) );
SG_ERR_CHECK( SG_vhash__add__string__sz(pCtx, pvh_params, "repo_id", psz_repo_id) );
SG_ERR_CHECK( SG_vhash__add__string__sz(pCtx, pvh_params, "admin_id", psz_admin_id) );
if (psz_descriptor_name)
{
SG_ERR_CHECK( SG_vhash__add__string__sz(pCtx, pvh_params, "descriptor_name", psz_descriptor_name) );
}
if (pq)
{
SG_ERR_CHECK( SG_vhash__add__string__sz(pCtx, pvh_params, "userid", pq->who_szUserId) );
}
if (psz_comment)
{
SG_ERR_CHECK( SG_vhash__add__string__sz(pCtx, pvh_params, "comment", psz_comment) );
}
if (psz_tied_branch_name)
{
SG_ERR_CHECK( SG_vhash__add__string__sz(pCtx, pvh_params, "branch", psz_tied_branch_name) );
}
SG_ERR_CHECK( SG_vhash__addcopy__vhash(pCtx, pvh_params, "changeset", pvh_changeset) );
SG_ERR_CHECK( SG_vhash__addnew__varray(pCtx, pvh_params, "wit_ids", &pva_ids) );
for (i=0; i<count_assocs; i++)
{
SG_ERR_CHECK( SG_varray__append__string__sz(pCtx, pva_ids, paszAssocs[i]) );
}
if (psa_stamps)
{
SG_uint32 count = 0;
SG_uint32 i = 0;
SG_varray* pva_stamps = NULL;
SG_ERR_CHECK( SG_vhash__addnew__varray(pCtx, pvh_params, "stamps", &pva_stamps) );
SG_ERR_CHECK( SG_stringarray__count(pCtx, psa_stamps, &count) );
for (i=0; i<count; i++)
{
const char* psz_stamp = NULL;
SG_ERR_CHECK( SG_stringarray__get_nth(pCtx, psa_stamps, i, &psz_stamp) );
SG_ERR_CHECK( SG_varray__append__string__sz(pCtx, pva_stamps, psz_stamp) );
}
}
SG_ERR_CHECK( SG_vc_hooks__execute(pCtx, psz_js, pvh_params, &pvh_result) );
// TODO process the result
if (pvh_result)
{
SG_bool hasErrors = SG_FALSE;
SG_ERR_CHECK( SG_vhash__has(pCtx, pvh_result, "error", &hasErrors) );
if (hasErrors)
{
const char *emsg = NULL;
SG_ERR_CHECK( SG_vhash__get__sz(pCtx, pvh_result, "error", &emsg) );
SG_ERR_THROW2( SG_ERR_VC_HOOK_REFUSED, (pCtx, "\n:%s: %s", SG_VC_HOOK__INTERFACE__ASK__WIT__ADD_ASSOCIATIONS, emsg) );
}
}
}
fail:
SG_VHASH_NULLFREE(pCtx, pvh_params);
SG_VHASH_NULLFREE(pCtx, pvh_result);
SG_VHASH_NULLFREE(pCtx, pvh_hook);
SG_NULLFREE(pCtx, psz_repo_id);
SG_NULLFREE(pCtx, psz_admin_id);
}
void sg_vv2__history__repo2(
SG_context * pCtx,
SG_repo * pRepo,
const SG_stringarray * psaArgs, // if present these must be full repo-paths
const SG_rev_spec* pRevSpec,
const SG_rev_spec* pRevSpec_single_revisions,
const char* pszUser,
const char* pszStamp,
SG_uint32 nResultLimit,
SG_bool bHideObjectMerges,
SG_int64 nFromDate,
SG_int64 nToDate,
SG_bool bListAll,
SG_bool bReassembleDag,
SG_bool* pbHasResult,
SG_history_result ** ppResult,
SG_history_token ** ppHistoryToken)
{
SG_stringarray * pStringArrayChangesets_starting = NULL;
SG_stringarray * pStringArrayChangesetsMissing = NULL;
SG_stringarray * pStringArrayChangesets_single_revisions = NULL;
SG_bool bRecommendDagWalk = SG_FALSE;
SG_bool bLeaves = SG_FALSE;
const char * pszCurrentDagnodeID = NULL;
SG_stringarray * pStringArrayGIDs = NULL;
SG_uint32 i = 0, nChangesetCount = 0;
SG_uint32 count_args = 0;
//Determine the starting changeset IDs. strBranch and bLeaves control this.
//We do this step here, so that repo paths can be looked up before we call into history__core.
SG_ERR_CHECK( sg_vv2__history__get_starting_changesets(pCtx, pRepo, pRevSpec,
&pStringArrayChangesets_starting,
&pStringArrayChangesetsMissing,
&bRecommendDagWalk,
&bLeaves) );
if (pStringArrayChangesetsMissing)
{
// See K2177, K1322, W0836, W8132. We requested specific starting
// points and ran into some csets that were referenced (by --tag
// or --branch) that are not present in the local repo. Try to
// silently ignore them.
SG_uint32 nrFound = 0;
SG_ERR_CHECK( SG_stringarray__count(pCtx, pStringArrayChangesets_starting, &nrFound) );
if (nrFound > 0)
{
// Yes there were missing csets, but we still found some
// of the referenced ones. Just ignore the missing ones.
// This should behave just like we had the older tag/branch
// dag prior to the push -r on the vc dag.
}
else
{
const char * psz_0;
// TODO 2012/10/19 Do we want a different message if the number of missing is > 1 ?
SG_ERR_CHECK( SG_stringarray__get_nth(pCtx, pStringArrayChangesetsMissing, 0, &psz_0) );
SG_ERR_THROW2( SG_ERR_CHANGESET_BLOB_NOT_FOUND,
(pCtx, "%s", psz_0) );
}
}
if (bListAll)
{
// See W8493. If they gave us a --list-all along with a --rev or --tag, they
// want to force us to show the full history rather than just the info for the
// named cset.
bRecommendDagWalk = SG_TRUE;
}
if (pRevSpec_single_revisions)
{
// We DO NOT pass a psaMissingHids here because we want
// it to throw if the user names a missing cset.
SG_ERR_CHECK( SG_rev_spec__get_all__repo__dedup(pCtx, pRepo, pRevSpec_single_revisions, SG_TRUE,
&pStringArrayChangesets_single_revisions, NULL) );
}
// TODO 2012/07/02 Is the following loop really what we want?
// TODO As written, it will look at each changeset
// TODO in the list and lookup each item's GID with
// TODO it. If cset[k] does not have *ALL* of the
// TODO items, we discard the array of GIDs already
// TODO discovered and then try cset[k+1].
// TODO
// TODO This seems wasteful and likely to fail in
// TODO the presence of lots of adds and deletes.
// TODO
// TODO Seems like it would be better to start the
// TODO result list outside of the loop and remove
// TODO items from the search list as we find them
// TODO as we iterate over the csets. This would
// TODO let us stop as soon as we have them all and
// TODO not require us to repeat the expensive mapping
// TODO of repo-path to gid.
// TODO
// TODO Then again, I think the caller has limited us
// TODO to only having *1* item in the set of files/folders,
// TODO so this might not actually matter.
if (psaArgs)
SG_ERR_CHECK( SG_stringarray__count(pCtx, psaArgs, &count_args) );
if (count_args > 0)
{
SG_ERR_CHECK( SG_stringarray__count(pCtx, pStringArrayChangesets_starting, &nChangesetCount) );
//Look up the GIDs for all of the arguments.
//Try every changeset, until we get one that has the GID in question.
for (i = 0; i < nChangesetCount; i++)
{
SG_ERR_CHECK( SG_stringarray__get_nth(pCtx, pStringArrayChangesets_starting, i, &pszCurrentDagnodeID) );
//This might be used if you have --leaves, or if there are multiple parents
//since they specified a changeset, we need to use the full repo path @/blah/blah to look up the objects
sg_vv2__history__lookup_gids_by_repopaths(pCtx, pRepo, pszCurrentDagnodeID, psaArgs,
&pStringArrayGIDs);
if (SG_CONTEXT__HAS_ERR(pCtx))
{
if (i == (nChangesetCount - 1) || ! SG_context__err_equals(pCtx, SG_ERR_NOT_FOUND) )
{
SG_STRINGARRAY_NULLFREE(pCtx, pStringArrayGIDs);
SG_ERR_RETHROW;
}
else
{
SG_STRINGARRAY_NULLFREE(pCtx, pStringArrayGIDs);
SG_context__err_reset(pCtx);
}
}
else
break;
}
}
//Call history core with the GIDs
SG_ERR_CHECK( SG_history__run(pCtx, pRepo, pStringArrayGIDs,
pStringArrayChangesets_starting, pStringArrayChangesets_single_revisions,
pszUser, pszStamp, nResultLimit, bLeaves, bHideObjectMerges,
nFromDate, nToDate, bRecommendDagWalk, bReassembleDag, pbHasResult, ppResult, ppHistoryToken) );
fail:
SG_STRINGARRAY_NULLFREE(pCtx, pStringArrayGIDs);
SG_STRINGARRAY_NULLFREE(pCtx, pStringArrayChangesets_starting);
SG_STRINGARRAY_NULLFREE(pCtx, pStringArrayChangesetsMissing);
SG_STRINGARRAY_NULLFREE(pCtx, pStringArrayChangesets_single_revisions);
}
void sg_vv2__history__working_folder(
SG_context * pCtx,
const SG_stringarray * psaInputs,
const SG_rev_spec* pRevSpec,
const SG_rev_spec* pRevSpec_single_revisions,
const char* pszUser,
const char* pszStamp,
SG_bool bDetectCurrentBranch,
SG_uint32 nResultLimit,
SG_bool bHideObjectMerges,
SG_int64 nFromDate,
SG_int64 nToDate,
SG_bool bListAll,
SG_bool* pbHasResult,
SG_vhash** ppvhBranchPile,
SG_history_result ** ppResult,
SG_history_token ** ppHistoryToken)
{
SG_repo * pRepo = NULL;
SG_stringarray * pStringArrayGIDs = NULL;
SG_stringarray * pStringArrayChangesets = NULL;
SG_stringarray * pStringArrayChangesetsMissing = NULL;
SG_stringarray * pStringArrayChangesets_single_revisions = NULL;
SG_bool bRecommendDagWalk = SG_FALSE;
SG_bool bLeaves = SG_FALSE;
const char * pszBranchName = NULL; // we do not own this
SG_vhash* pvhBranchPile = NULL;
SG_varray* pvaParents = NULL; // we do not own this
SG_bool bMyBranchWalkRecommendation = SG_FALSE;
SG_rev_spec* pRevSpec_Allocated = NULL;
SG_wc_tx * pWcTx = NULL;
SG_vhash * pvhInfo = NULL;
SG_uint32 count_args = 0;
SG_uint32 countRevsSpecified = 0;
if (psaInputs)
SG_ERR_CHECK( SG_stringarray__count(pCtx, psaInputs, &count_args) );
// Use the WD to try to get the initial info.
// I'm going to deviate from the model and use
// a read-only TX here so that I can get a bunch
// of fields that we need later.
SG_ERR_CHECK( SG_WC_TX__ALLOC__BEGIN(pCtx, &pWcTx, NULL, SG_TRUE) );
if (count_args > 0)
SG_ERR_CHECK( SG_wc_tx__get_item_gid__stringarray(pCtx, pWcTx, psaInputs, &pStringArrayGIDs) );
SG_ERR_CHECK( SG_wc_tx__get_wc_info(pCtx, pWcTx, &pvhInfo) );
SG_ERR_CHECK( SG_wc_tx__get_repo_and_wd_top(pCtx, pWcTx, &pRepo, NULL) );
/* If no revisions were specified, and the caller wants us to use the current branch,
* create a revision spec with the current branch. */
if (pRevSpec)
{
SG_ERR_CHECK( SG_REV_SPEC__ALLOC__COPY(pCtx, pRevSpec, &pRevSpec_Allocated) );
SG_ERR_CHECK( SG_rev_spec__count(pCtx, pRevSpec_Allocated, &countRevsSpecified) );
}
else
{
SG_ERR_CHECK( SG_REV_SPEC__ALLOC(pCtx, &pRevSpec_Allocated) );
}
if (pRevSpec_single_revisions != NULL)
{
SG_uint32 countRevsSpecified_singles = 0;
SG_ERR_CHECK( SG_rev_spec__count(pCtx, pRevSpec_single_revisions, &countRevsSpecified_singles) );
countRevsSpecified += countRevsSpecified_singles;
}
if (bDetectCurrentBranch && countRevsSpecified == 0)
{
SG_ERR_CHECK( SG_vhash__check__sz(pCtx, pvhInfo, "branch", &pszBranchName) );
if (pszBranchName)
{
/* The working folder is attached to a branch. Does it exist? */
SG_bool bHasBranches = SG_FALSE;
SG_bool bBranchExists = SG_FALSE;
SG_ERR_CHECK( SG_vc_branches__cleanup(pCtx, pRepo, &pvhBranchPile) );
SG_ERR_CHECK( SG_vhash__has(pCtx, pvhBranchPile, "branches", &bHasBranches) );
if (bHasBranches)
{
SG_vhash* pvhRefBranches;
SG_ERR_CHECK( SG_vhash__get__vhash(pCtx, pvhBranchPile, "branches", &pvhRefBranches) );
SG_ERR_CHECK( SG_vhash__has(pCtx, pvhRefBranches, pszBranchName, &bBranchExists) );
}
if (bBranchExists)
{
SG_uint32 numParents, i;
const char* pszRefParent;
/* If that branch exists, just add to our rev spec. */
SG_ERR_CHECK( SG_rev_spec__add_branch(pCtx, pRevSpec_Allocated, pszBranchName) );
/* Plus, if the working folder's parents are not in the branch (yet), add them as well
* (they'll be in it after the user commits something...). */
SG_ERR_CHECK( SG_vhash__get__varray(pCtx, pvhInfo, "parents", &pvaParents) );
SG_ERR_CHECK( SG_varray__count(pCtx, pvaParents, &numParents) );
for (i = 0; i < numParents; i++)
{
SG_bool already_in_rev_spec = SG_FALSE;
SG_ERR_CHECK( SG_varray__get__sz(pCtx, pvaParents, i, &pszRefParent) );
SG_ERR_CHECK( SG_rev_spec__contains(pCtx, pRepo, pRevSpec_Allocated, pszRefParent,
&already_in_rev_spec) );
if(!already_in_rev_spec)
SG_ERR_CHECK( SG_rev_spec__add_rev(pCtx, pRevSpec_Allocated, pszRefParent) );
}
}
else
{
/* If the branch doesn't exist, add the working folder's baseline(s) to the rev spec
* and force a dag walk. */
SG_uint32 numParents, i;
const char* pszRefParent;
SG_ERR_CHECK( SG_vhash__get__varray(pCtx, pvhInfo, "parents", &pvaParents) );
SG_ERR_CHECK( SG_varray__count(pCtx, pvaParents, &numParents) );
for (i = 0; i < numParents; i++)
{
SG_ERR_CHECK( SG_varray__get__sz(pCtx, pvaParents, i, &pszRefParent) );
SG_ERR_CHECK( SG_rev_spec__add_rev(pCtx, pRevSpec_Allocated, pszRefParent) );
}
bMyBranchWalkRecommendation = SG_TRUE;
}
}
}
// Determine the starting changeset IDs. strBranch and bLeaves control this.
// We do this step here, so that repo paths can be looked up before we call into history__core.
SG_ERR_CHECK( sg_vv2__history__get_starting_changesets(pCtx, pRepo, pRevSpec_Allocated,
&pStringArrayChangesets,
&pStringArrayChangesetsMissing,
&bRecommendDagWalk,
&bLeaves) );
if (pStringArrayChangesetsMissing)
{
// See K2177, K1322, W0836, W8132. We requested specific starting
// points and ran into some csets that were referenced (by --tag
// or --branch) that are not present in the local repo. Try to
// silently ignore them.
SG_uint32 nrFound = 0;
SG_ERR_CHECK( SG_stringarray__count(pCtx, pStringArrayChangesets, &nrFound) );
if (nrFound > 0)
{
// Yes there were missing csets, but we still found some
// of the referenced ones. Just ignore the missing ones.
// This should behave just like we had the older tag/branch
// dag prior to the push -r on the vc dag.
}
else
{
const char * psz_0;
// TODO 2012/10/19 Do we want a different message if the number of missing is > 1 ?
SG_ERR_CHECK( SG_stringarray__get_nth(pCtx, pStringArrayChangesetsMissing, 0, &psz_0) );
SG_ERR_THROW2( SG_ERR_CHANGESET_BLOB_NOT_FOUND,
(pCtx, "%s", psz_0) );
}
}
bRecommendDagWalk = bRecommendDagWalk || bMyBranchWalkRecommendation;
//This hack is here to detect when we're being asked for the parent of a certain
//object from the sg_parents code. parents always wants the dag walk.
//The better solution would be to allow users to pass in a flag about their dagwalk
//preferences
if (count_args == 1 && nResultLimit == 1)
bRecommendDagWalk = SG_TRUE;
if (bListAll)
{
// See W8493. If they gave us a --list-all along with a --rev or --tag, they
// want to force us to show the full history rather than just the info for the
// named cset.
bRecommendDagWalk = SG_TRUE;
}
if (pRevSpec_single_revisions)
{
// We DO NOT pass a psaMissingHids here because we want
// it to throw if the user names a missing cset.
SG_ERR_CHECK( SG_rev_spec__get_all__repo__dedup(pCtx, pRepo, pRevSpec_single_revisions, SG_TRUE,
&pStringArrayChangesets_single_revisions, NULL) );
}
// TODO 2012/07/03 The deviates from the model. This call directly returns the
// TODO allocated data into the caller's pointers. If anything fails
// TODO (such as the call to get the branches below), we'll probably
// TODO leak the result and token.
SG_ERR_CHECK( SG_history__run(pCtx, pRepo, pStringArrayGIDs,
pStringArrayChangesets, pStringArrayChangesets_single_revisions,
pszUser, pszStamp, nResultLimit, bLeaves, bHideObjectMerges,
nFromDate, nToDate, bRecommendDagWalk, SG_FALSE, pbHasResult, ppResult, ppHistoryToken) );
/* This is kind of a hack. History callers often need branch data to format ouput.
* But we open the repo down here. I didn't want to open/close it again. And there's logic
* in here about which repo to open. So instead, we do this. */
if (ppvhBranchPile)
{
if (pvhBranchPile)
{
*ppvhBranchPile = pvhBranchPile;
pvhBranchPile = NULL;
}
else
SG_ERR_CHECK( SG_vc_branches__cleanup(pCtx, pRepo, ppvhBranchPile) );
}
fail:
SG_ERR_IGNORE( SG_wc_tx__cancel(pCtx, pWcTx) );
SG_WC_TX__NULLFREE(pCtx, pWcTx);
SG_REV_SPEC_NULLFREE(pCtx, pRevSpec_Allocated);
SG_STRINGARRAY_NULLFREE(pCtx, pStringArrayChangesets);
SG_STRINGARRAY_NULLFREE(pCtx, pStringArrayChangesetsMissing);
SG_STRINGARRAY_NULLFREE(pCtx, pStringArrayChangesets_single_revisions);
SG_STRINGARRAY_NULLFREE(pCtx, pStringArrayGIDs);
SG_VHASH_NULLFREE(pCtx, pvhBranchPile);
SG_VHASH_NULLFREE(pCtx, pvhInfo);
SG_REPO_NULLFREE(pCtx, pRepo);
}
/**
* 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);
}
