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);
}
void SG_sync__closet_user_dags(
SG_context* pCtx,
SG_repo* pRepoSrcNotMine,
const char* pszRefHidLeafSrc,
SG_varray** ppvaSyncedUserList)
{
char* pszSrcAdminId = NULL;
char* pszHidLeafSrc = NULL;
char* pszHidLeafDest = NULL;
SG_vhash* pvhDescriptors = NULL;
SG_repo* pRepoDest = NULL;
SG_repo* pRepoSrcMine = NULL;
char* pszDestAdminId = NULL;
/* Using disallowed characters to ensure no collision with an actual repo name.
* Not that this isn't actually stored anywhere--we just use it as a key in the
* vhash below where the /real/ repos have descriptor names. */
const char* pszRefUserMasterFakeName = "\\/USER_MASTER\\/";
/* The repo routines do a null arg check of pRepoSrcNotMine.
The other args are optional. */
if (!pszRefHidLeafSrc)
{
SG_ERR_CHECK( SG_zing__get_leaf(pCtx, pRepoSrcNotMine, NULL, SG_DAGNUM__USERS, &pszHidLeafSrc) );
pszRefHidLeafSrc = pszHidLeafSrc;
}
/* Add all repositories in "normal" status, to the list we'll iterate over. */
SG_ERR_CHECK( SG_closet__descriptors__list(pCtx, &pvhDescriptors) );
/* If it exists, add the user master repo to the list. */
{
SG_bool bExists = SG_FALSE;
SG_ERR_CHECK( SG_repo__user_master__exists(pCtx, &bExists) );
if (bExists)
SG_ERR_CHECK( SG_vhash__add__null(pCtx, pvhDescriptors, pszRefUserMasterFakeName) );
}
/* Iterate over the repositories, syncing the user database. */
{
SG_int32 i = 0;
SG_uint32 numDescriptors = 0;
SG_ERR_CHECK( SG_vhash__count(pCtx, pvhDescriptors, &numDescriptors) );
for(i = 0; i < (SG_int32)numDescriptors; i++)
{
const char* pszRefNameDest = NULL;
SG_bool bAdminIdsMatch = SG_TRUE;
const SG_variant* pvRefDest = NULL;
/* Note that the source repo will be in this loop, too, but we don't need to check for
* it, adding another strcmp, because the leaf hid comparison below will effectively
* skip it. So we do one extra leaf fetch and comparison, total, rather than an extra
* strcmp for every repo in the closet. */
SG_ERR_CHECK( SG_vhash__get_nth_pair(pCtx, pvhDescriptors, i, &pszRefNameDest, &pvRefDest) );
if (SG_VARIANT_TYPE_NULL == pvRefDest->type)
SG_ERR_CHECK( SG_REPO__USER_MASTER__OPEN(pCtx, &pRepoDest) );
else
SG_ERR_CHECK( SG_REPO__OPEN_REPO_INSTANCE(pCtx, pszRefNameDest, &pRepoDest) );
SG_ERR_CHECK( SG_zing__get_leaf(pCtx, pRepoDest, NULL, SG_DAGNUM__USERS, &pszHidLeafDest) );
if (strcmp(pszRefHidLeafSrc, pszHidLeafDest))
{
/* Pull from source to dest.
* Pull is generally faster than push, so we're using it on purpose. */
SG_pull__admin__local(pCtx, pRepoDest, pRepoSrcNotMine, NULL);
if (SG_context__has_err(pCtx))
{
/* If there's an admin id mismatch, don't die. Log a warning and move on. */
if (SG_context__err_equals(pCtx, SG_ERR_ADMIN_ID_MISMATCH))
{
const char* pszRefNameSrc = NULL;
SG_ERR_DISCARD;
SG_ERR_CHECK( SG_repo__get_descriptor_name(pCtx, pRepoSrcNotMine, &pszRefNameSrc) );
if (!pszRefNameSrc)
pszRefNameSrc = pszRefUserMasterFakeName;
SG_ERR_CHECK( SG_repo__get_admin_id(pCtx, pRepoSrcNotMine, &pszSrcAdminId) );
SG_ERR_CHECK( SG_repo__get_admin_id(pCtx, pRepoDest, &pszDestAdminId) );
SG_ERR_CHECK( SG_log__report_warning(pCtx,
"admin-id mismatch when syncing users: source repo %s has %s, dest repo %s has %s",
pszRefNameSrc, pszSrcAdminId, pszRefNameDest, pszDestAdminId) );
bAdminIdsMatch = SG_FALSE;
SG_NULLFREE(pCtx, pszDestAdminId);
SG_NULLFREE(pCtx, pszSrcAdminId);
}
else
SG_ERR_RETHROW;
}
if (bAdminIdsMatch)
{
SG_NULLFREE(pCtx, pszHidLeafDest);
SG_ERR_CHECK( SG_zing__get_leaf(pCtx, pRepoDest, NULL, SG_DAGNUM__USERS, &pszHidLeafDest) );
if (strcmp(pszRefHidLeafSrc, pszHidLeafDest))
{
/* The pull from source to dest resulted in a new leaf.
* Use the new leaf and restart the loop. */
SG_NULLFREE(pCtx, pszHidLeafSrc);
pszRefHidLeafSrc = pszHidLeafSrc = pszHidLeafDest;
pszHidLeafDest = NULL;
SG_REPO_NULLFREE(pCtx, pRepoSrcMine);
pRepoSrcNotMine = pRepoSrcMine = pRepoDest;
pRepoDest = NULL;
i = -1; /* start again at the first descriptor */
}
}
}
SG_NULLFREE(pCtx, pszHidLeafDest);
SG_REPO_NULLFREE(pCtx, pRepoDest);
}
}
if (ppvaSyncedUserList)
SG_ERR_CHECK( SG_user__list_all(pCtx, pRepoSrcNotMine, ppvaSyncedUserList) );
/* fall through */
fail:
SG_NULLFREE(pCtx, pszSrcAdminId);
SG_NULLFREE(pCtx, pszHidLeafSrc);
SG_NULLFREE(pCtx, pszHidLeafDest);
SG_VHASH_NULLFREE(pCtx, pvhDescriptors);
SG_REPO_NULLFREE(pCtx, pRepoDest);
SG_REPO_NULLFREE(pCtx, pRepoSrcMine);
SG_NULLFREE(pCtx, pszDestAdminId);
}
