void SG_sync_remote__heartbeat(
SG_context* pCtx,
SG_repo* pRepo,
SG_vhash** ppvh)
{
SG_vhash* pvh = NULL;
char* pszRepoId = NULL;
char* pszAdminId = NULL;
char* pszHashMethod = NULL;
SG_ERR_CHECK( SG_VHASH__ALLOC(pCtx, &pvh) );
SG_ERR_CHECK( SG_repo__get_repo_id(pCtx, pRepo, &pszRepoId) );
SG_ERR_CHECK( SG_repo__get_admin_id(pCtx, pRepo, &pszAdminId) );
SG_ERR_CHECK( SG_repo__get_hash_method(pCtx, pRepo, &pszHashMethod) );
SG_ERR_CHECK( SG_vhash__add__string__sz(pCtx, pvh, SG_SYNC_REPO_INFO_KEY__REPO_ID, pszRepoId) );
SG_ERR_CHECK( SG_vhash__add__string__sz(pCtx, pvh, SG_SYNC_REPO_INFO_KEY__ADMIN_ID, pszAdminId) );
SG_ERR_CHECK( SG_vhash__add__string__sz(pCtx, pvh, SG_SYNC_REPO_INFO_KEY__HASH_METHOD, pszHashMethod) );
*ppvh = pvh;
pvh = NULL;
/* fall through */
fail:
SG_VHASH_NULLFREE(pCtx, pvh);
SG_NULLFREE(pCtx, pszRepoId);
SG_NULLFREE(pCtx, pszAdminId);
SG_NULLFREE(pCtx, pszHashMethod);
}
void MyFn(create_zero_byte_blob)(SG_context* pCtx,
SG_repo* pRepo)
{
struct z
{
const char * pszHashMethod;
const char * pszTrivialHash;
};
struct z az[] = { { "SHA1/160", "da39a3ee5e6b4b0d3255bfef95601890afd80709" },
{ "SHA2/256", "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" },
{ "SHA2/384", "38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b" },
{ "SHA2/512", "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e" },
};
char* pszidHidBlob1 = NULL;
char * pbuf1 = NULL;
char * pbuf2 = NULL;
SG_uint64 lenBuf2;
SG_repo_tx_handle* pTx = NULL;
SG_uint32 lenBuf1 = 0;
char * pszHashMethod = NULL;
SG_uint32 k, kLimit;
pbuf1 = (char *)SG_calloc(1,lenBuf1+1);
VERIFY_ERR_CHECK_DISCARD( SG_repo__begin_tx(pCtx, pRepo, &pTx) );
VERIFY_ERR_CHECK_DISCARD( SG_repo__store_blob_from_memory(pCtx, pRepo,pTx,NULL,SG_FALSE,(SG_byte *)pbuf1,lenBuf1,&pszidHidBlob1) );
VERIFY_ERR_CHECK_DISCARD( SG_repo__commit_tx(pCtx, pRepo, &pTx) );
INFOP("create_zero_byte_blob",("Created blob [%s]",(pszidHidBlob1)));
//////////////////////////////////////////////////////////////////
// fetch blob into a new buffer and verify that it matches.
VERIFY_ERR_CHECK_DISCARD( SG_repo__fetch_blob_into_memory(pCtx, pRepo,pszidHidBlob1,(SG_byte **)&pbuf2,&lenBuf2) );
VERIFY_COND("create_zero_byte_blob(fetch blob)",(lenBuf2 == (SG_uint64)lenBuf1));
VERIFY_COND("create_zero_byte_blob(memcmp)",(memcmp(pbuf1,pbuf2,lenBuf1)==0));
VERIFY_ERR_CHECK_DISCARD( SG_repo__get_hash_method(pCtx, pRepo, &pszHashMethod) );
kLimit = SG_NrElements(az);
for (k=0; k<kLimit; k++)
{
if (strcmp(pszHashMethod,az[k].pszHashMethod) == 0)
{
// The empty blob should always have this hid
VERIFY_COND("zero byte blob hid mismatch",
strcmp(pszidHidBlob1, az[k].pszTrivialHash) == 0);
}
}
//////////////////////////////////////////////////////////////////
// cleanup
SG_NULLFREE(pCtx, pbuf1);
SG_NULLFREE(pCtx, pbuf2);
SG_NULLFREE(pCtx, pszidHidBlob1);
SG_NULLFREE(pCtx, pszHashMethod);
}
/**
* 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_server__get_repo_info(SG_context* pCtx,
SG_repo* pRepo,
char** ppszRepoId,
char** ppszAdminId,
char** ppszHashMethod)
{
char* pszRepoId = NULL;
char* pszAdminId = NULL;
char* pszHashMethod = NULL;
SG_NULLARGCHECK_RETURN(pRepo);
if (ppszRepoId)
SG_ERR_CHECK( SG_repo__get_repo_id(pCtx, pRepo, &pszRepoId) );
if (ppszAdminId)
SG_ERR_CHECK( SG_repo__get_admin_id(pCtx, pRepo, &pszAdminId) );
if (ppszHashMethod)
SG_ERR_CHECK( SG_repo__get_hash_method(pCtx, pRepo, &pszHashMethod) );
if (ppszRepoId)
{
*ppszRepoId = pszRepoId;
pszRepoId = NULL;
}
if (ppszAdminId)
{
*ppszAdminId = pszAdminId;
pszAdminId = NULL;
}
if (ppszHashMethod)
{
*ppszHashMethod = pszHashMethod;
pszHashMethod = NULL;
}
/* fall through */
fail:
SG_NULLFREE(pCtx, pszRepoId);
SG_NULLFREE(pCtx, pszAdminId);
SG_NULLFREE(pCtx, pszHashMethod);
}
void SG_sync_remote__get_repo_info(
SG_context* pCtx,
SG_repo* pRepo,
SG_bool bIncludeBranches,
SG_bool b_include_areas,
SG_vhash** ppvh)
{
SG_vhash* pvh = NULL;
char* pszRepoId = NULL;
char* pszAdminId = NULL;
char* pszHashMethod = NULL;
SG_uint32 count_dagnums = 0;
SG_uint64* paDagNums = NULL;
SG_uint32 i = 0;
SG_vhash* pvh_dags = NULL;
SG_vhash* pvh_areas = NULL;
SG_vhash* pvhBranchPile = NULL;
SG_bool bHasBranchDag = SG_FALSE;
SG_NULLARGCHECK_RETURN(pRepo);
SG_ERR_CHECK( SG_VHASH__ALLOC(pCtx, &pvh) );
/* Protocol version */
SG_ERR_CHECK( SG_vhash__add__int64(pCtx, pvh, SG_SYNC_REPO_INFO_KEY__PROTOCOL_VERSION, 1) );
/* Basic repository info */
SG_ERR_CHECK( SG_repo__get_repo_id(pCtx, pRepo, &pszRepoId) );
SG_ERR_CHECK( SG_repo__get_admin_id(pCtx, pRepo, &pszAdminId) );
SG_ERR_CHECK( SG_repo__get_hash_method(pCtx, pRepo, &pszHashMethod) );
SG_ERR_CHECK( SG_vhash__add__string__sz(pCtx, pvh, SG_SYNC_REPO_INFO_KEY__REPO_ID, pszRepoId) );
SG_ERR_CHECK( SG_vhash__add__string__sz(pCtx, pvh, SG_SYNC_REPO_INFO_KEY__ADMIN_ID, pszAdminId) );
SG_ERR_CHECK( SG_vhash__add__string__sz(pCtx, pvh, SG_SYNC_REPO_INFO_KEY__HASH_METHOD, pszHashMethod) );
/* All DAGs in the repository */
SG_ERR_CHECK( SG_repo__list_dags(pCtx, pRepo, &count_dagnums, &paDagNums) );
SG_ERR_CHECK( SG_vhash__addnew__vhash(pCtx, pvh, "dags", &pvh_dags) );
for (i=0; i<count_dagnums; i++)
{
char buf_dagnum[SG_DAGNUM__BUF_MAX__HEX];
SG_ERR_CHECK_RETURN( SG_dagnum__to_sz__hex(pCtx, paDagNums[i], buf_dagnum, sizeof(buf_dagnum)) );
SG_ERR_CHECK( SG_vhash__add__null(pCtx, pvh_dags, buf_dagnum) );
/* Asking for a DAG for the first time in a repo will create that DAG.
* When pushing into an empty repo, we don't want this initial query to create
* empty new DAGs, so we make sure they exist before we query them. */
if (paDagNums[i] == SG_DAGNUM__VC_BRANCHES)
bHasBranchDag = SG_TRUE;
}
// TODO the following code is a problem, because it requires that this repo
// instance have indexes, and we would prefer to preserve the ability of
// an index-free instance to support push, pull, and clone.
/* All areas in the repository */
if (b_include_areas)
{
SG_ERR_CHECK( SG_area__list(pCtx, pRepo, &pvh_areas) );
if (pvh_areas)
{
SG_ERR_CHECK( SG_vhash__add__vhash(pCtx, pvh, "areas", &pvh_areas) );
}
}
/* Branches */
if (bIncludeBranches && bHasBranchDag)
{
SG_ERR_CHECK( SG_vc_branches__cleanup(pCtx, pRepo, &pvhBranchPile) );
if (pvhBranchPile)
{
SG_bool bHasBranches;
SG_ERR_CHECK( SG_vhash__has(pCtx, pvhBranchPile, "branches", &bHasBranches) );
if (bHasBranches)
SG_ERR_CHECK( SG_vhash__add__vhash(pCtx, pvh, "branches", &pvhBranchPile) );
}
}
*ppvh = pvh;
pvh = NULL;
/* fall through */
fail:
SG_NULLFREE(pCtx, paDagNums);
SG_VHASH_NULLFREE(pCtx, pvh);
SG_NULLFREE(pCtx, pszRepoId);
SG_NULLFREE(pCtx, pszAdminId);
SG_NULLFREE(pCtx, pszHashMethod);
SG_VHASH_NULLFREE(pCtx, pvh_areas);
SG_VHASH_NULLFREE(pCtx, pvhBranchPile);
}
