void u0048_multidag__new_repo(
SG_context * pCtx,
const char* pszRidescName,
SG_repo** ppResult
)
{
SG_vhash* pvhPartialDescriptor = NULL;
SG_repo* pRepo = NULL;
const SG_vhash* pvhActualDescriptor = NULL;
SG_changeset* pcsFirst = NULL;
char* pszidGidActualRoot = NULL;
const char* pszidFirstChangeset = NULL;
char buf_repo_id[SG_GID_BUFFER_LENGTH];
char buf_admin_id[SG_GID_BUFFER_LENGTH];
VERIFY_ERR_CHECK( SG_gid__generate(pCtx, buf_repo_id, sizeof(buf_repo_id)) );
VERIFY_ERR_CHECK( SG_gid__generate(pCtx, buf_admin_id, sizeof(buf_admin_id)) );
VERIFY_ERR_CHECK( SG_closet__get_partial_repo_instance_descriptor_for_new_local_repo(pCtx, &pvhPartialDescriptor) );
/* This test case writes dag nodes which are not real. They don't have a
* changeset associated with them. So, if we use a caching repo, the
* caching code will fail because it tries to load a changeset
* which doesn't exist. So, we strip down to a raw repo here. */
VERIFY_ERR_CHECK( SG_repo__create_repo_instance(pCtx,pvhPartialDescriptor,SG_TRUE,NULL,buf_repo_id,buf_admin_id,&pRepo) );
VERIFY_ERR_CHECK( sg_zing__init_new_repo(pCtx, pRepo) );
VERIFY_ERR_CHECK( SG_repo__create_user_root_directory(pCtx, pRepo, "@", &pcsFirst, &pszidGidActualRoot) );
VERIFY_ERR_CHECK( SG_changeset__get_id_ref(pCtx, pcsFirst, &pszidFirstChangeset) );
VERIFY_ERR_CHECK( SG_repo__get_descriptor(pCtx, pRepo, &pvhActualDescriptor) );
/* TODO should this give an error if the ridesc name already exists? */
VERIFY_ERR_CHECK( SG_closet__descriptors__add(pCtx, pszRidescName, pvhActualDescriptor) );
SG_NULLFREE(pCtx, pszidGidActualRoot);
SG_CHANGESET_NULLFREE(pCtx, pcsFirst);
SG_VHASH_NULLFREE(pCtx, pvhPartialDescriptor);
*ppResult = pRepo;
return;
fail:
SG_VHASH_NULLFREE(pCtx, pvhPartialDescriptor);
SG_REPO_NULLFREE(pCtx, pRepo);
return;
}
void MyFn(alloc_random_buffer)(SG_context * pCtx, SG_byte** ppBuf, SG_uint32* lenBuf)
{
char bufGidRandom[SG_GID_BUFFER_LENGTH];
SG_byte* pBuf = NULL;
const char* pszTest =
"Hail! to the victors valiant\n"
"Hail! to the conqu'ring heroes\n"
"Hail! Hail! to Michigan\n"
"The leaders and best!\n"
"Hail! to the victors valiant\n"
"Hail! to the conqu'ring heroes\n"
"Hail! Hail! to Michigan,\n"
"The champions of the West!\n";
SG_uint32 lenTest = SG_STRLEN(pszTest);
SG_uint32 lenTotal = lenTest + SG_GID_BUFFER_LENGTH;
// Add some random data so we don't accidentally add duplicate blobs.
VERIFY_ERR_CHECK( SG_gid__generate(pCtx, bufGidRandom, sizeof(bufGidRandom)) );
VERIFY_ERR_CHECK( SG_alloc(pCtx, 1, lenTotal, &pBuf) );
memcpy(pBuf, pszTest, lenTest);
memcpy(pBuf + lenTest, bufGidRandom, sizeof(bufGidRandom));
*ppBuf = pBuf;
*lenBuf = lenTotal;
return;
fail:
SG_NULLFREE(pCtx, pBuf);
}
void SG_tid__generate2(SG_context * pCtx,
char * bufTid, SG_uint32 lenBuf,
SG_uint32 nrRandomDigits)
{
char bufGid[SG_GID_BUFFER_LENGTH];
SG_uint32 lenRequired;
SG_NULLARGCHECK_RETURN( bufTid );
// Note: Arbitrarily enforce a 4 digit lower bound.
SG_ARGCHECK_RETURN( ((nrRandomDigits >= 4) && (nrRandomDigits <= SG_TID_LENGTH_RANDOM_MAX)), nrRandomDigits );
lenRequired = SG_TID_LENGTH_PREFIX + nrRandomDigits + 1; // +1 for trailing null
SG_ARGCHECK_RETURN( (lenBuf >= lenRequired), lenBuf );
// We create a real GID. This gives us a lot of random hex digits.
// We then use the first n hex digits to create a TID. We assume
// that a TID is narrower than a GID (or else we'd have to create
// more than one GID).
SG_ASSERT( (SG_TID_LENGTH_RANDOM_MAX <= SG_GID_LENGTH_RANDOM) );
SG_ERR_CHECK_RETURN( SG_gid__generate(pCtx, bufGid, sizeof(bufGid)) );
SG_ASSERT( (SG_TID_LENGTH_PREFIX == 1) );
bufTid[0] = 't';
memcpy(&bufTid[SG_TID_LENGTH_PREFIX], &bufGid[SG_GID_LENGTH_PREFIX], nrRandomDigits);
bufTid[SG_TID_LENGTH_PREFIX + nrRandomDigits] = 0;
}
void MyFn(create_repo)(SG_context * pCtx, SG_repo ** ppRepo)
{
// caller must free returned value.
SG_repo * pRepo;
SG_pathname * pPathnameRepoDir = NULL;
SG_vhash* pvhPartialDescriptor = NULL;
char buf_repo_id[SG_GID_BUFFER_LENGTH];
char buf_admin_id[SG_GID_BUFFER_LENGTH];
char* pszRepoImpl = NULL;
VERIFY_ERR_CHECK( SG_gid__generate(pCtx, buf_repo_id, sizeof(buf_repo_id)) );
VERIFY_ERR_CHECK( SG_gid__generate(pCtx, buf_admin_id, sizeof(buf_admin_id)) );
VERIFY_ERR_CHECK( SG_PATHNAME__ALLOC(pCtx, &pPathnameRepoDir) );
VERIFY_ERR_CHECK( SG_pathname__set__from_cwd(pCtx, pPathnameRepoDir) );
VERIFY_ERR_CHECK( SG_VHASH__ALLOC(pCtx, &pvhPartialDescriptor) );
VERIFY_ERR_CHECK_DISCARD( SG_localsettings__get__sz(pCtx, SG_LOCALSETTING__NEWREPO_DRIVER, NULL, &pszRepoImpl, NULL) );
VERIFY_ERR_CHECK_DISCARD( SG_vhash__add__string__sz(pCtx, pvhPartialDescriptor, SG_RIDESC_KEY__STORAGE, pszRepoImpl) );
VERIFY_ERR_CHECK( SG_vhash__add__string__sz(pCtx, pvhPartialDescriptor, SG_RIDESC_FSLOCAL__PATH_PARENT_DIR, SG_pathname__sz(pPathnameRepoDir)) );
VERIFY_ERR_CHECK( SG_repo__create_repo_instance(pCtx,pvhPartialDescriptor,SG_TRUE,NULL,buf_repo_id,buf_admin_id,&pRepo) );
SG_VHASH_NULLFREE(pCtx, pvhPartialDescriptor);
{
const SG_vhash * pvhRepoDescriptor = NULL;
VERIFY_ERR_CHECK( SG_repo__get_descriptor(pCtx, pRepo,&pvhRepoDescriptor) );
//INFOP("open_repo",("Repo is [%s]",SG_string__sz(pstrRepoDescriptor)));
}
*ppRepo = pRepo;
fail:
SG_VHASH_NULLFREE(pCtx, pvhPartialDescriptor);
SG_PATHNAME_NULLFREE(pCtx, pPathnameRepoDir);
SG_NULLFREE(pCtx, pszRepoImpl);
}
void MyFn(create_repo)(SG_context * pCtx, SG_repo** ppRepo)
{
SG_repo* pRepo = NULL;
SG_pathname* pPath_repo = NULL;
char buf_repo_id[SG_GID_BUFFER_LENGTH];
char buf_admin_id[SG_GID_BUFFER_LENGTH];
SG_vhash* pvhPartialDescriptor = NULL;
char* pszRepoImpl = NULL;
VERIFY_ERR_CHECK( SG_gid__generate(pCtx, buf_repo_id, sizeof(buf_repo_id)) );
VERIFY_ERR_CHECK( SG_gid__generate(pCtx, buf_admin_id, sizeof(buf_admin_id)) );
/* Get our paths fixed up */
VERIFY_ERR_CHECK( SG_PATHNAME__ALLOC(pCtx, &pPath_repo) );
VERIFY_ERR_CHECK( SG_pathname__set__from_cwd(pCtx, pPath_repo) );
VERIFY_ERR_CHECK( SG_pathname__append__from_sz(pCtx, pPath_repo, "repo") );
SG_fsobj__mkdir__pathname(pCtx, pPath_repo);
SG_context__err_reset(pCtx);
// Create the repo
VERIFY_ERR_CHECK( SG_VHASH__ALLOC(pCtx, &pvhPartialDescriptor) );
VERIFY_ERR_CHECK_DISCARD( SG_localsettings__get__sz(pCtx, SG_LOCALSETTING__NEWREPO_DRIVER, NULL, &pszRepoImpl, NULL) );
if (pszRepoImpl)
{
VERIFY_ERR_CHECK_DISCARD( SG_vhash__add__string__sz(pCtx, pvhPartialDescriptor, SG_RIDESC_KEY__STORAGE, pszRepoImpl) );
}
VERIFY_ERR_CHECK( SG_vhash__add__string__sz(pCtx, pvhPartialDescriptor, SG_RIDESC_FSLOCAL__PATH_PARENT_DIR, SG_pathname__sz(pPath_repo)) );
VERIFY_ERR_CHECK( SG_repo__create_repo_instance(pCtx,NULL,pvhPartialDescriptor,SG_TRUE,NULL,buf_repo_id,buf_admin_id,&pRepo) );
*ppRepo = pRepo;
// Fall through to common cleanup
fail:
SG_VHASH_NULLFREE(pCtx, pvhPartialDescriptor);
SG_PATHNAME_NULLFREE(pCtx, pPath_repo);
SG_NULLFREE(pCtx, pszRepoImpl);
}
/**
* Generate a NEW GID, add it to the tbl_gid, and
* return the alias to it.
*
*/
void sg_wc_db__gid__insert_new(SG_context * pCtx,
sg_wc_db * pDb,
SG_bool bIsTmp,
SG_uint64 * puiAliasGidNew)
{
char bufGid[SG_GID_BUFFER_LENGTH+1];
SG_ERR_CHECK_RETURN( SG_gid__generate(pCtx, bufGid, sizeof(bufGid)) );
SG_ERR_CHECK_RETURN( _sg_wc_db__gid__insert(pCtx, pDb, bufGid, bIsTmp) );
SG_ERR_CHECK_RETURN( sg_wc_db__gid__get_alias_from_gid(pCtx, pDb, bufGid, puiAliasGidNew) );
if (bIsTmp)
pDb->nrTmpGids++;
}
/**
* Create a new repo in the closet.
*/
static void _vv_verbs__init_new_repo__do_init(SG_context * pCtx,
const char * pszRepoName,
const char * pszStorage,
const char * pszHashMethod,
const char * psz_shared_users,
SG_bool bFromUserMaster,
char ** ppszGidRepoId,
char ** ppszHidCSetFirst)
{
SG_repo * pRepo = NULL;
SG_repo * pRepoUserMaster = NULL;
char * pszUserMasterAdminId = NULL;
SG_changeset * pCSetFirst = NULL;
const char * pszHidCSetFirst_ref;
char * pszHidCSetFirst = NULL;
char * pszGidRepoId = NULL;
char bufAdminId[SG_GID_BUFFER_LENGTH];
// create a completely new repo in the closet.
SG_NULLARGCHECK_RETURN( pszRepoName );
// pszStorage is optional
// pszHashMethod is optional
SG_ASSERT(SG_FALSE == (psz_shared_users && bFromUserMaster)); // checked in SG_vv_verbs__init_new_repo
if (psz_shared_users)
{
SG_ERR_CHECK( _vv_verbs__init_new_repo__get_admin_id(pCtx, psz_shared_users, bufAdminId) );
}
else if (bFromUserMaster)
{
SG_ERR_CHECK( SG_REPO__USER_MASTER__OPEN(pCtx, &pRepoUserMaster) );
SG_ERR_CHECK( SG_repo__get_admin_id(pCtx, pRepoUserMaster, &pszUserMasterAdminId) );
memcpy(bufAdminId, pszUserMasterAdminId, sizeof(bufAdminId));
//SG_memcpy2(pszUserMasterAdminId, bufAdminId);
SG_NULLFREE(pCtx, pszUserMasterAdminId);
}
else
{
SG_ERR_CHECK( SG_gid__generate(pCtx, bufAdminId, sizeof(bufAdminId)) );
}
SG_ERR_CHECK( SG_repo__create__completely_new__empty__closet(pCtx, bufAdminId, pszStorage, pszHashMethod, pszRepoName) );
SG_ERR_CHECK( SG_REPO__OPEN_REPO_INSTANCE(pCtx, pszRepoName, &pRepo) );
if (!psz_shared_users && !bFromUserMaster)
{
SG_ERR_CHECK( SG_user__create_nobody(pCtx, pRepo) );
}
SG_ERR_CHECK( SG_repo__setup_basic_stuff(pCtx, pRepo, &pCSetFirst, NULL) );
if (psz_shared_users)
{
SG_ERR_CHECK( SG_pull__admin(pCtx, pRepo, psz_shared_users, NULL, NULL, NULL, NULL) );
}
else if (bFromUserMaster)
{
SG_ERR_CHECK( SG_pull__admin__local(pCtx, pRepo, pRepoUserMaster, NULL) );
}
SG_ERR_CHECK( SG_changeset__get_id_ref(pCtx, pCSetFirst, &pszHidCSetFirst_ref) );
SG_ERR_CHECK( SG_STRDUP(pCtx, pszHidCSetFirst_ref, &pszHidCSetFirst) );
SG_ERR_CHECK( SG_repo__get_repo_id(pCtx, pRepo, &pszGidRepoId) );
*ppszGidRepoId = pszGidRepoId;
*ppszHidCSetFirst = pszHidCSetFirst;
SG_REPO_NULLFREE(pCtx, pRepo);
SG_REPO_NULLFREE(pCtx, pRepoUserMaster);
SG_CHANGESET_NULLFREE(pCtx, pCSetFirst);
return;
fail:
/* If we fail to pull the admin dags after the repo's been created, delete it. */
if (pRepo)
{
SG_REPO_NULLFREE(pCtx, pRepo);
if (pszRepoName)
SG_ERR_IGNORE( _vv_verbs__init_new_repo__delete_new_repo(pCtx, pszRepoName) );
}
SG_REPO_NULLFREE(pCtx, pRepoUserMaster);
SG_CHANGESET_NULLFREE(pCtx, pCSetFirst);
SG_NULLFREE(pCtx, pszGidRepoId);
SG_NULLFREE(pCtx, pszHidCSetFirst);
}
