void MyFn(create_blob_from_file)(SG_context * pCtx,
SG_repo * pRepo,
const SG_pathname * pPathnameTempDir,
SG_uint64 lenFile,
const char * szSrc)
{
// create a file of length "lenFile" in the temp directory.
// use it to create a blob.
// try to create it a second time and verify that we get an duplicate-hid error.
char* pszidGidRandom1 = NULL;
char* pszidGidRandom2 = NULL;
SG_pathname * pPathnameTempFile1 = NULL;
SG_pathname * pPathnameTempFile2 = NULL;
SG_file * pFileTempFile1 = NULL;
SG_file * pFileTempFile2 = NULL;
SG_uint32 lenSrc;
SG_uint64 lenWritten;
char* pszidHidBlob1 = NULL;
char* pszidHidBlob1Dup = NULL;
char* pszidHidBlob2 = NULL;
char* pszidHidVerify1 = NULL;
char* pszidHidVerify2 = NULL;
SG_bool bEqual;
SG_repo_tx_handle* pTx = NULL;
SG_uint64 iBlobFullLength = 0;
//////////////////////////////////////////////////////////////////
// create temp-file-1 of length "lenFile" in the temp directory.
VERIFY_ERR_CHECK_DISCARD( SG_gid__alloc(pCtx, &pszidGidRandom1) );
VERIFY_ERR_CHECK_DISCARD( SG_gid__alloc(pCtx, &pszidGidRandom2) );
VERIFY_ERR_CHECK_DISCARD( SG_PATHNAME__ALLOC__PATHNAME_SZ(pCtx, &pPathnameTempFile1,pPathnameTempDir,(pszidGidRandom1)) );
VERIFY_ERR_CHECK_DISCARD( SG_file__open__pathname(pCtx, pPathnameTempFile1,SG_FILE_RDWR|SG_FILE_CREATE_NEW,0644,&pFileTempFile1) );
// write random gid at the beginning of the file
// so that we won't get collisions if we are called
// multiple times.
VERIFY_ERR_CHECK_DISCARD( SG_file__write(pCtx, pFileTempFile1,(SG_uint32)strlen(pszidGidRandom1),(SG_byte *)pszidGidRandom1,NULL) );
VERIFY_ERR_CHECK_DISCARD( SG_file__write(pCtx, pFileTempFile1,1,(SG_byte *)"\n",NULL) );
// generate lots of data in the file so that we'll cause the
// blob routines to exercise the chunking stuff.
lenSrc = (SG_uint32)strlen(szSrc);
lenWritten = 0;
while (lenWritten < lenFile)
{
VERIFY_ERR_CHECK_DISCARD( SG_file__write(pCtx, pFileTempFile1,lenSrc,(SG_byte *)szSrc,NULL) );
lenWritten += lenSrc;
}
// the test file does NOT have a final LF. i'm not sure it matters one way or the
// other, but i'm just saying that we're not putting on a final LF.
SG_ERR_IGNORE( SG_file__seek(pCtx, pFileTempFile1,0) );
//////////////////////////////////////////////////////////////////
// use currently open temp file to create a blob.
// we get the HID back. (we need to free it later.)
VERIFY_ERR_CHECK_DISCARD( SG_repo__begin_tx(pCtx, pRepo, &pTx) );
VERIFY_ERR_CHECK_DISCARD( SG_repo__store_blob_from_file(pCtx, pRepo,pTx,NULL,SG_FALSE,pFileTempFile1,&pszidHidBlob1,&iBlobFullLength) );
VERIFY_ERR_CHECK_DISCARD( SG_repo__commit_tx(pCtx, pRepo, &pTx) );
INFOP("create_blob_from_file",("Created blob [%s]",(pszidHidBlob1)));
//////////////////////////////////////////////////////////////////
// try to create blob again and verify we get an duplicate-hid error.
// Ian TODO: Put this back when SG_ERR_BLOBFILEALREADYEXISTS has been replaced.
// VERIFY_ERR_CHECK_DISCARD( SG_repo__begin_tx(pCtx, pRepo, &pTx) );
// err = SG_repo__store_blob_from_file(pRepo,pTx,SG_FALSE,pFileTempFile1,&pszidHidBlob1Dup);
// VERIFYP_CTX_ERR_IS("create_blob_from_file(duplicate)", pCtx, SG_ERR_BLOBFILEALREADYEXISTS, ("Duplicate create failed [%s][%s]",pszidHidBlob1,pszidHidBlob1Dup));
// VERIFY_ERR_CHECK_DISCARD( SG_repo__commit_tx(pCtx, pRepo, SG_DAGNUM__NONE, NULL, &pTx) );
//////////////////////////////////////////////////////////////////
// create empty temp-file-2 and try to read the blob from the repo.
VERIFY_ERR_CHECK_DISCARD( SG_PATHNAME__ALLOC__PATHNAME_SZ(pCtx, &pPathnameTempFile2,pPathnameTempDir,(pszidGidRandom2)) );
VERIFY_ERR_CHECK_DISCARD( SG_file__open__pathname(pCtx, pPathnameTempFile2,SG_FILE_RDWR|SG_FILE_CREATE_NEW,0644,&pFileTempFile2) );
VERIFY_ERR_CHECK_DISCARD( SG_repo__fetch_blob_into_file(pCtx, pRepo,pszidHidBlob1,pFileTempFile2,NULL) );
//////////////////////////////////////////////////////////////////
// verify that the contents of temp-file-2 is identical to the
// contents of temp-file-1. (we already know that the HIDs match
// and was verified during the fetch, but there are times when the
// HID is just being used as a key -- it doesn't mean that what we
// actually restored is correct.
VERIFY_ERR_CHECK_DISCARD( SG_repo__alloc_compute_hash__from_file(pCtx, pRepo, pFileTempFile1, &pszidHidVerify1) );
VERIFY_ERR_CHECK_DISCARD( SG_repo__alloc_compute_hash__from_file(pCtx, pRepo, pFileTempFile2, &pszidHidVerify2) );
bEqual = (0 == (strcmp(pszidHidVerify1,pszidHidVerify2)));
VERIFY_COND("create_blob_from_file(verify v1==v2)",bEqual);
bEqual = (0 == (strcmp(pszidHidVerify1,pszidHidBlob1)));
VERIFY_COND("create_blob_from_file(verify v1==id)",bEqual);
//////////////////////////////////////////////////////////////////
// TODO delete temp source file
SG_ERR_IGNORE( SG_file__close(pCtx, &pFileTempFile1) );
SG_ERR_IGNORE( SG_file__close(pCtx, &pFileTempFile2) );
//////////////////////////////////////////////////////////////////
// cleanup
SG_NULLFREE(pCtx, pszidGidRandom1);
SG_NULLFREE(pCtx, pszidGidRandom2);
SG_NULLFREE(pCtx, pszidHidBlob1);
SG_NULLFREE(pCtx, pszidHidBlob1Dup);
SG_NULLFREE(pCtx, pszidHidBlob2);
SG_NULLFREE(pCtx, pszidHidVerify1);
SG_NULLFREE(pCtx, pszidHidVerify2);
SG_PATHNAME_NULLFREE(pCtx, pPathnameTempFile1);
SG_PATHNAME_NULLFREE(pCtx, pPathnameTempFile2);
}
void u0026_jsonparser__create_2(SG_context* pCtx, SG_string* pStr)
{
SG_jsonwriter* pjson = NULL;
SG_vhash* pvh = NULL;
SG_varray* pva = NULL;
SG_uint32 i;
char* pid = NULL;
SG_ERR_CHECK( SG_jsonwriter__alloc(pCtx, &pjson, pStr) );
SG_ERR_CHECK( SG_jsonwriter__write_start_object(pCtx, pjson) );
SG_ERR_CHECK( SG_jsonwriter__write_pair__string__sz(pCtx, pjson, "hello", "world") );
SG_ERR_CHECK( SG_jsonwriter__write_pair__int64(pCtx, pjson, "x", 5) );
SG_ERR_CHECK( SG_jsonwriter__write_pair__double(pCtx, pjson, "pi", 3.14159) );
SG_ERR_CHECK( SG_jsonwriter__write_pair__bool(pCtx, pjson, "b1", SG_TRUE) );
SG_ERR_CHECK( SG_jsonwriter__write_pair__bool(pCtx, pjson, "b2", SG_FALSE) );
SG_ERR_CHECK( SG_jsonwriter__write_begin_pair(pCtx, pjson, "furball") );
SG_ERR_CHECK( SG_jsonwriter__write_start_array(pCtx, pjson) );
SG_ERR_CHECK( SG_jsonwriter__write_element__string__sz(pCtx, pjson, "plok") );
SG_ERR_CHECK( SG_jsonwriter__write_element__double(pCtx, pjson, 47.567) );
SG_ERR_CHECK( SG_jsonwriter__write_element__int64(pCtx, pjson, 22222) );
SG_ERR_CHECK( SG_jsonwriter__write_element__null(pCtx, pjson) );
SG_ERR_CHECK( SG_jsonwriter__write_element__bool(pCtx, pjson, SG_TRUE) );
SG_ERR_CHECK( SG_jsonwriter__write_element__bool(pCtx, pjson, SG_FALSE) );
SG_ERR_CHECK( SG_gid__alloc(pCtx, &pid) );
SG_ERR_CHECK( SG_jsonwriter__write_element__string__sz(pCtx, pjson, pid) );
SG_NULLFREE(pCtx, pid);
SG_ERR_CHECK( SG_jsonwriter__write_end_array(pCtx, pjson) );
SG_ERR_CHECK( SG_jsonwriter__write_pair__null(pCtx, pjson, "nope") );
SG_ERR_CHECK( SG_jsonwriter__write_pair__string__sz(pCtx, pjson, "messy", U0026_MESSY) );
SG_ERR_CHECK( SG_VHASH__ALLOC(pCtx, &pvh) );
SG_ERR_CHECK( SG_vhash__add__string__sz(pCtx, pvh, "fried", "tomatoes") );
SG_ERR_CHECK( SG_vhash__add__int64(pCtx, pvh, "q", 333) );
SG_ERR_CHECK( SG_jsonwriter__write_pair__vhash(pCtx, pjson, "sub", pvh) );
SG_VHASH_NULLFREE(pCtx, pvh);
SG_ERR_CHECK( SG_VARRAY__ALLOC(pCtx, &pva) );
for (i=0; i<1000; i++)
{
SG_ERR_CHECK( SG_varray__append__string__sz(pCtx, pva, "plok") );
SG_ERR_CHECK( SG_varray__append__int64(pCtx, pva, 22) );
SG_ERR_CHECK( SG_varray__append__double(pCtx, pva, 1.414) );
SG_ERR_CHECK( SG_varray__append__bool(pCtx, pva, SG_TRUE) );
SG_ERR_CHECK( SG_varray__append__bool(pCtx, pva, SG_FALSE) );
SG_ERR_CHECK( SG_varray__append__null(pCtx, pva) );
}
SG_ERR_CHECK( SG_jsonwriter__write_pair__varray(pCtx, pjson, "a", pva) );
SG_VARRAY_NULLFREE(pCtx, pva);
SG_ERR_CHECK( SG_jsonwriter__write_end_object(pCtx, pjson) );
SG_JSONWRITER_NULLFREE(pCtx, pjson);
return;
fail:
SG_VHASH_NULLFREE(pCtx, pvh);
SG_VARRAY_NULLFREE(pCtx, pva);
SG_JSONWRITER_NULLFREE(pCtx, pjson);
}
