void SG_sync_remote__push_add(
SG_context* pCtx,
const char* pszPushId,
SG_repo* pRepo,
const char* psz_fragball_name,
SG_vhash** ppResult
)
{
SG_staging* pStaging = NULL;
SG_vhash* pvh_status = NULL;
#if TRACE_SYNC_REMOTE
SG_int64 startTime;
SG_int64 endTime;
double seconds;
#endif
SG_NULLARGCHECK_RETURN(pszPushId);
SG_NULLARGCHECK_RETURN(ppResult);
SG_ERR_CHECK( SG_staging__open(pCtx, pszPushId, &pStaging) );
#if TRACE_SYNC_REMOTE
SG_ERR_CHECK( SG_time__get_milliseconds_since_1970_utc(pCtx, &startTime) );
#endif
SG_ERR_CHECK( SG_staging__slurp_fragball(pCtx, pStaging, psz_fragball_name) );
#if TRACE_SYNC_REMOTE
SG_ERR_CHECK( SG_time__get_milliseconds_since_1970_utc(pCtx, &endTime) );
seconds = ((double)endTime-(double)startTime)/1000;
SG_ERR_CHECK( SG_console(pCtx, SG_CS_STDERR, "Fragball slurp took %1.3f seconds\n", seconds) );
SG_ERR_CHECK( SG_time__get_milliseconds_since_1970_utc(pCtx, &startTime) );
#endif
SG_ERR_CHECK( SG_staging__check_status(pCtx, pStaging, pRepo,
SG_TRUE, SG_TRUE, SG_TRUE, SG_TRUE, SG_FALSE,
&pvh_status) );
#if TRACE_SYNC_REMOTE
SG_ERR_CHECK( SG_time__get_milliseconds_since_1970_utc(pCtx, &endTime) );
seconds = ((double)endTime-(double)startTime)/1000;
SG_ERR_CHECK( SG_console(pCtx, SG_CS_STDERR, "Status check after fragball slurp took %1.3f seconds\n", seconds) );
#endif
*ppResult = pvh_status;
pvh_status = NULL;
/* fallthru */
fail:
SG_VHASH_NULLFREE(pCtx, pvh_status);
SG_STAGING_NULLFREE(pCtx, pStaging);
}
void SG_workingdir__generate_and_create_temp_dir_for_purpose(SG_context * pCtx,
const SG_pathname * pPathWorkingDirectoryTop,
const char * pszPurpose,
SG_pathname ** ppPathTempDir)
{
SG_pathname * pPathTempRoot = NULL;
SG_pathname * pPath = NULL;
SG_string * pString = NULL;
SG_int64 iTimeUTC;
SG_time tmLocal;
SG_uint32 kAttempt = 0;
SG_NONEMPTYCHECK_RETURN(pszPurpose);
SG_NULLARGCHECK_RETURN(ppPathTempDir);
// get path to "<wd-top>/.sgtemp".
SG_ERR_CHECK( SG_workingdir__get_temp_path(pCtx,pPathWorkingDirectoryTop,&pPathTempRoot) );
SG_ERR_CHECK( SG_time__get_milliseconds_since_1970_utc(pCtx,&iTimeUTC) );
SG_ERR_CHECK( SG_time__decode__local(pCtx,iTimeUTC,&tmLocal) );
SG_ERR_CHECK( SG_STRING__ALLOC(pCtx,&pString) );
while (1)
{
// build path "<wd-top>/.sgtemp/<purpose>_20091201_0".
// where <purpose> is something like "revert" or "merge".
SG_ERR_CHECK( SG_string__sprintf(pCtx,pString,"%s_%04d%02d%02d_%d",
pszPurpose,
tmLocal.year,tmLocal.month,tmLocal.mday,
kAttempt++) );
SG_ERR_CHECK( SG_PATHNAME__ALLOC__PATHNAME_SZ(pCtx,&pPath,pPathTempRoot,SG_string__sz(pString)) );
// try to create a NEW temp directory. if this path already exists on disk,
// loop and try again. if we have a hard errors, just give up.
SG_fsobj__mkdir_recursive__pathname(pCtx,pPath);
if (SG_context__has_err(pCtx) == SG_FALSE)
goto success;
if (SG_context__err_equals(pCtx,SG_ERR_DIR_ALREADY_EXISTS) == SG_FALSE)
SG_ERR_RETHROW;
SG_context__err_reset(pCtx);
SG_PATHNAME_NULLFREE(pCtx,pPath);
}
success:
*ppPathTempDir = pPath;
SG_STRING_NULLFREE(pCtx, pString);
SG_PATHNAME_NULLFREE(pCtx, pPathTempRoot);
return;
fail:
SG_STRING_NULLFREE(pCtx, pString);
SG_PATHNAME_NULLFREE(pCtx, pPathTempRoot);
SG_PATHNAME_NULLFREE(pCtx, pPath);
}
void SG_time__local_time(SG_context* pCtx, SG_time * pResult)
{
SG_int64 lMillisecondsSince1970;
SG_ERR_CHECK( SG_time__get_milliseconds_since_1970_utc(pCtx, &lMillisecondsSince1970) );
SG_ERR_CHECK( SG_time__decode__local(pCtx, lMillisecondsSince1970, pResult) );
fail:
return;
}
void sg_treediff_cache::GetStatusForPath(SG_context * pCtx, SG_bool bIsRetry, const SG_pathname * pPathName, SG_wc_status_flags * pStatusFlags, SG_bool * pbDirChanged)
{
wxCriticalSectionLocker lock(m_wc_transaction_lock);
SG_wc_status_flags statusFlags = SG_WC_STATUS_FLAGS__U__FOUND;
SG_string * psgstr_statusFlagsDetails = NULL;
if (m_pwc_tx == NULL)
{
//Start a read-only transaction.
SG_ERR_CHECK( SG_WC_TX__ALLOC__BEGIN(pCtx, &m_pwc_tx, ((pPathName)), SG_TRUE) );
}
SG_ERR_CHECK( SG_wc_tx__get_item_status_flags(pCtx, m_pwc_tx, SG_pathname__sz(pPathName), SG_FALSE, SG_FALSE, &statusFlags, NULL) );
if (pbDirChanged != NULL && (statusFlags & SG_WC_STATUS_FLAGS__T__DIRECTORY))
{
//It's a directory, so we need to check to see if there are modifications under it.
SG_wc_status_flags dirStatusFlags = SG_WC_STATUS_FLAGS__U__FOUND;
SG_ERR_CHECK( SG_wc_tx__get_item_dirstatus_flags(pCtx, m_pwc_tx, SG_pathname__sz(pPathName), &dirStatusFlags, NULL, pbDirChanged) );
}
#if DEBUG
SG_ERR_CHECK( SG_wc_debug__status__dump_flags(pCtx, statusFlags, "status flags", &psgstr_statusFlagsDetails) );
SG_ERR_CHECK( SG_log__report_verbose(pCtx, "%s", SG_string__sz(psgstr_statusFlagsDetails)) );
#endif
//Don't recurse if this is our second try.
if ((bIsRetry == SG_FALSE)
&& ((statusFlags & SG_WC_STATUS_FLAGS__T__BOGUS) == SG_WC_STATUS_FLAGS__T__BOGUS) )
{
//This is a item that is new in the directory since we started
//our transaction. Close the transaction, and start a new one.
SG_ERR_CHECK( SG_log__report_verbose(pCtx, "Got a bogus status. Restarting transaction") );
clearCache(pCtx);
GetStatusForPath(pCtx, SG_TRUE, pPathName, &statusFlags, pbDirChanged);
}
SG_ERR_CHECK( SG_time__get_milliseconds_since_1970_utc(pCtx, &m_timeLastRequest) );
*pStatusFlags = statusFlags;
fail:
SG_STRING_NULLFREE(pCtx, psgstr_statusFlagsDetails);
//Log and reset any errors on the context.
//Any error condition should report the status as
//Found and still send a message back to the client.
if (SG_context__has_err(pCtx) == SG_TRUE)
{
if (!SG_context__err_equals(pCtx, SG_ERR_WC_DB_BUSY))
{
SG_log__report_error__current_error(pCtx);
}
SG_context__err_reset(pCtx);
}
}
void sg_treediff_cache::CloseTransactionIfNecessary(SG_context * pCtx)
{
wxCriticalSectionLocker lock(m_wc_transaction_lock);
if (m_pwc_tx)
{
SG_int64 nTimeNow = 0;
SG_ERR_CHECK( SG_time__get_milliseconds_since_1970_utc(pCtx, &nTimeNow) );
//Make sure that it has been at least 250 milliseconds have passed
//since the last time we used the transaction
if ( nTimeNow > m_timeLastRequest + (250))
{
SG_ERR_IGNORE( SG_wc_tx__cancel(pCtx, m_pwc_tx) );
SG_WC_TX__NULLFREE(pCtx, m_pwc_tx);
SG_NULLFREE(pCtx, m_pPreviousCommand);
SG_NULLFREE(pCtx, m_pPreviousResult);
}
}
fail:
;
}
static void _sg_workingdir__get_entry2(SG_context * pCtx,
SG_repo * pRepo,
const SG_pathname * pPathSub,
const char * pszGid,
SG_treenode_entry_type type,
const char * pszidHidContent,
const char * pszidHidXattrs,
SG_int64 iAttributeBits,
SG_vhash * pvhTimestamps)
{
SG_file* pFile = NULL;
SG_string* pstrLink = NULL;
SG_byte* pBytes = NULL;
SG_vhash * pvhGid = NULL;
if (SG_TREENODEENTRY_TYPE_DIRECTORY == type)
{
/* create the directory and then recurse into it */
SG_ERR_CHECK( SG_fsobj__mkdir__pathname(pCtx, pPathSub) );
SG_ERR_CHECK( _sg_workingdir__get_dir(pCtx, pRepo, pPathSub, pszidHidContent, pvhTimestamps) );
}
else if (SG_TREENODEENTRY_TYPE_REGULAR_FILE == type)
{
SG_ERR_CHECK( SG_file__open__pathname(pCtx, pPathSub, SG_FILE_RDWR | SG_FILE_CREATE_NEW, SG_FSOBJ_PERMS__MASK, &pFile) );
SG_ERR_CHECK( SG_repo__fetch_blob_into_file(pCtx, pRepo, pszidHidContent, pFile, NULL) );
SG_ERR_CHECK( SG_file__close(pCtx, &pFile) );
}
else if (SG_TREENODEENTRY_TYPE_SYMLINK == type)
{
SG_uint64 iLenBytes = 0;
SG_ERR_CHECK( SG_repo__fetch_blob_into_memory(pCtx, pRepo, pszidHidContent, &pBytes, &iLenBytes) );
SG_ERR_CHECK( SG_STRING__ALLOC__BUF_LEN(pCtx, &pstrLink, pBytes, (SG_uint32) iLenBytes) );
SG_ERR_CHECK( SG_fsobj__symlink(pCtx, pstrLink, pPathSub) );
SG_NULLFREE(pCtx, pBytes);
SG_STRING_NULLFREE(pCtx, pstrLink);
}
else
{
SG_ERR_THROW(SG_ERR_NOTIMPLEMENTED);
}
if (pszidHidXattrs)
{
#ifdef SG_BUILD_FLAG_FEATURE_XATTR
SG_ERR_CHECK( _sg_workingdir__set_xattrs(pCtx, pRepo, pPathSub, pszidHidXattrs) );
#else
// TODO do we need to stuff something into the pendingtree to remind us
// TODO that the entry originally had an XAttr and we just didn't restore
// TODO it when we populated the WD on this Windows system?
#endif
}
SG_ERR_CHECK( SG_attributes__bits__apply(pCtx, pPathSub, iAttributeBits) );
if (pvhTimestamps && (SG_TREENODEENTRY_TYPE_REGULAR_FILE == type))
{
SG_fsobj_stat stat;
SG_int64 iTimeNow;
SG_ERR_CHECK( SG_fsobj__stat__pathname(pCtx, pPathSub, &stat) );
SG_ERR_CHECK( SG_time__get_milliseconds_since_1970_utc(pCtx, &iTimeNow) );
SG_ERR_CHECK( SG_VHASH__ALLOC(pCtx, &pvhGid) );
SG_ERR_CHECK( SG_vhash__add__int64(pCtx, pvhGid, "mtime_ms", stat.mtime_ms) );
SG_ERR_CHECK( SG_vhash__add__int64(pCtx, pvhGid, "clock_ms", iTimeNow) );
SG_ERR_CHECK( SG_vhash__add__vhash(pCtx, pvhTimestamps, pszGid, &pvhGid) ); // this steals our vhash
}
fail:
SG_VHASH_NULLFREE(pCtx, pvhGid);
}
static void SG_db__make_delta_from_path(
SG_context* pCtx,
SG_repo* pRepo,
SG_uint64 dagnum,
SG_varray* pva_path,
SG_uint32 flags,
SG_vhash* pvh_add,
SG_vhash* pvh_remove
)
{
#if SG_DOUBLE_CHECK__CALC_DELTA
SG_int64 t1 = -1;
SG_int64 t2 = -1;
SG_vhash* new_pvh_add = NULL;
SG_vhash* new_pvh_remove = NULL;
SG_vhash* old_pvh_add = NULL;
SG_vhash* old_pvh_remove = NULL;
SG_string* old_pstr = NULL;
SG_string* new_pstr = NULL;
SG_ERR_CHECK( SG_vhash__alloc__copy(pCtx, &new_pvh_add, pvh_add) );
SG_ERR_CHECK( SG_vhash__alloc__copy(pCtx, &new_pvh_remove, pvh_remove) );
SG_ERR_CHECK( SG_vhash__alloc__copy(pCtx, &old_pvh_add, pvh_add) );
SG_ERR_CHECK( SG_vhash__alloc__copy(pCtx, &old_pvh_remove, pvh_remove) );
SG_ERR_CHECK( SG_time__get_milliseconds_since_1970_utc(pCtx, &t1) );
SG_ERR_CHECK( old_SG_db__make_delta_from_path(
pCtx,
pRepo,
dagnum,
pva_path,
old_pvh_add,
old_pvh_remove
) );
SG_ERR_CHECK( SG_time__get_milliseconds_since_1970_utc(pCtx, &t2) );
{
SG_uint32 path_length = 0;
SG_ERR_CHECK( SG_varray__count(pCtx, pva_path, &path_length) );
fprintf(stderr, "make_delta_from_path (%d)\n", path_length);
}
fprintf(stderr, " time old %d ms\n", (int) (t2 - t1));
SG_ERR_CHECK( SG_vhash__sort(pCtx, old_pvh_add, SG_FALSE, SG_vhash_sort_callback__increasing) );
SG_ERR_CHECK( SG_vhash__sort(pCtx, old_pvh_remove, SG_FALSE, SG_vhash_sort_callback__increasing) );
SG_ERR_CHECK( SG_time__get_milliseconds_since_1970_utc(pCtx, &t1) );
SG_ERR_CHECK( SG_repo__dbndx__make_delta_from_path(
pCtx,
pRepo,
dagnum,
pva_path,
0,
new_pvh_add,
new_pvh_remove
) );
SG_ERR_CHECK( SG_time__get_milliseconds_since_1970_utc(pCtx, &t2) );
fprintf(stderr, " time new %d ms\n", (int) (t2 - t1));
SG_ERR_CHECK( SG_vhash__sort(pCtx, new_pvh_add, SG_FALSE, SG_vhash_sort_callback__increasing) );
SG_ERR_CHECK( SG_vhash__sort(pCtx, new_pvh_remove, SG_FALSE, SG_vhash_sort_callback__increasing) );
SG_ERR_CHECK( SG_string__alloc(pCtx, &old_pstr) );
SG_ERR_CHECK( SG_vhash__to_json(pCtx, old_pvh_add, old_pstr) );
SG_ERR_CHECK( SG_string__alloc(pCtx, &new_pstr) );
SG_ERR_CHECK( SG_vhash__to_json(pCtx, new_pvh_add, new_pstr) );
if (0 != strcmp(SG_string__sz(old_pstr), SG_string__sz(new_pstr)))
{
fprintf(stderr, "oldway:\n");
SG_VHASH_STDERR(old_pvh_add);
fprintf(stderr, "new:\n");
SG_VHASH_STDERR(new_pvh_add);
SG_ERR_THROW( SG_ERR_UNSPECIFIED );
}
SG_STRING_NULLFREE(pCtx, old_pstr);
SG_STRING_NULLFREE(pCtx, new_pstr);
SG_ERR_CHECK( SG_string__alloc(pCtx, &old_pstr) );
SG_ERR_CHECK( SG_vhash__to_json(pCtx, old_pvh_remove, old_pstr) );
SG_ERR_CHECK( SG_string__alloc(pCtx, &new_pstr) );
SG_ERR_CHECK( SG_vhash__to_json(pCtx, new_pvh_remove, new_pstr) );
if (0 != strcmp(SG_string__sz(old_pstr), SG_string__sz(new_pstr)))
{
fprintf(stderr, "oldway:\n");
SG_VHASH_STDERR(old_pvh_remove);
fprintf(stderr, "new:\n");
SG_VHASH_STDERR(new_pvh_remove);
SG_ERR_THROW( SG_ERR_UNSPECIFIED );
}
#endif
#if SG_DOUBLE_CHECK__CALC_DELTA
SG_ERR_CHECK( SG_time__get_milliseconds_since_1970_utc(pCtx, &t1) );
#endif
SG_ERR_CHECK( SG_repo__dbndx__make_delta_from_path(
pCtx,
pRepo,
dagnum,
pva_path,
flags,
pvh_add,
pvh_remove
) );
#if SG_DOUBLE_CHECK__CALC_DELTA
SG_ERR_CHECK( SG_time__get_milliseconds_since_1970_utc(pCtx, &t2) );
fprintf(stderr, " time NEW %d ms\n", (int) (t2 - t1));
#endif
fail:
#if SG_DOUBLE_CHECK__CALC_DELTA
SG_STRING_NULLFREE(pCtx, old_pstr);
SG_STRING_NULLFREE(pCtx, new_pstr);
SG_VHASH_NULLFREE(pCtx, old_pvh_add);
SG_VHASH_NULLFREE(pCtx, old_pvh_remove);
SG_VHASH_NULLFREE(pCtx, new_pvh_add);
SG_VHASH_NULLFREE(pCtx, new_pvh_remove);
#endif
;
}
void SG_sync__build_best_guess_dagfrag(
SG_context* pCtx,
SG_repo* pRepo,
SG_uint64 iDagNum,
SG_rbtree* prbStartFromHids,
SG_vhash* pvhConnectToHidsAndGens,
SG_dagfrag** ppFrag)
{
SG_uint32 i, countConnectTo;
SG_rbtree_iterator* pit = NULL;
SG_dagnode* pdn = NULL;
SG_dagfrag* pFrag = NULL;
SG_repo_fetch_dagnodes_handle* pdh = NULL;
SG_int32 minGen = SG_INT32_MAX;
SG_int32 maxGen = 0;
SG_uint32 gensToFetch = 0;
char* psz_repo_id = NULL;
char* psz_admin_id = NULL;
SG_bool bNextHid;
const char* pszRefHid;
SG_int32 gen;
#if TRACE_SYNC
SG_int64 startTime;
SG_int64 endTime;
#endif
SG_NULLARGCHECK_RETURN(prbStartFromHids);
/* Find the minimum generation in pertinent "connect to" nodes. */
if (pvhConnectToHidsAndGens)
{
SG_ERR_CHECK( SG_vhash__count(pCtx, pvhConnectToHidsAndGens, &countConnectTo) );
for (i = 0; i < countConnectTo; i++)
{
SG_int32 gen;
SG_ERR_CHECK( SG_vhash__get_nth_pair__int32(pCtx, pvhConnectToHidsAndGens, i, &pszRefHid, &gen) );
if (gen < minGen)
minGen = gen;
}
}
/* Happens when pulling into an empty repo, or when an entire dag is specifically requested. */
if (minGen == SG_INT32_MAX)
minGen = -1;
SG_ERR_CHECK( SG_repo__fetch_dagnodes__begin(pCtx, pRepo, iDagNum, &pdh) );
/* Find the maximum generation in pertinent "start from" nodes. */
SG_ERR_CHECK( SG_rbtree__iterator__first(pCtx, &pit, prbStartFromHids, &bNextHid, &pszRefHid, NULL) );
while (bNextHid)
{
SG_ERR_CHECK( SG_repo__fetch_dagnodes__one(pCtx, pRepo, pdh, pszRefHid, &pdn) );
SG_ERR_CHECK( SG_dagnode__get_generation(pCtx, pdn, &gen) );
if (gen > maxGen)
maxGen = gen;
SG_DAGNODE_NULLFREE(pCtx, pdn);
SG_ERR_CHECK( SG_rbtree__iterator__next(pCtx, pit, &bNextHid, &pszRefHid, NULL) );
}
SG_RBTREE_ITERATOR_NULLFREE(pCtx, pit);
if (maxGen <= minGen)
gensToFetch = FALLBACK_GENS_PER_ROUNDTRIP;
else
gensToFetch = maxGen - minGen;
#if TRACE_SYNC
{
char buf_dagnum[SG_DAGNUM__BUF_MAX__HEX];
SG_uint32 count;
SG_ERR_CHECK( SG_dagnum__to_sz__hex(pCtx, iDagNum, buf_dagnum, sizeof(buf_dagnum)) );
SG_ERR_CHECK( SG_console(pCtx, SG_CS_STDERR, "Building best guess dagfrag for dag %s...\n", buf_dagnum) );
SG_ERR_CHECK( SG_console(pCtx, SG_CS_STDERR, "Starting from nodes:\n") );
SG_ERR_CHECK( SG_rbtree_debug__dump_keys_to_console(pCtx, prbStartFromHids) );
SG_ERR_CHECK( SG_vhash_debug__dump_to_console__named(pCtx, pvhConnectToHidsAndGens, "Connecting to nodes") );
SG_ERR_CHECK( SG_rbtree__count(pCtx, prbStartFromHids, &count) );
SG_ERR_CHECK( SG_console(pCtx, SG_CS_STDERR, "result has %d generations from %u starting nodes.\n",
gensToFetch, count) );
SG_ERR_CHECK( SG_console__flush(pCtx, SG_CS_STDERR) );
SG_ERR_CHECK( SG_time__get_milliseconds_since_1970_utc(pCtx, &startTime) );
}
#endif
/* Return a frag with the corresponding generations filled in. */
SG_ERR_CHECK( SG_repo__get_repo_id(pCtx, pRepo, &psz_repo_id) );
SG_ERR_CHECK( SG_repo__get_admin_id(pCtx, pRepo, &psz_admin_id) );
SG_ERR_CHECK( SG_dagfrag__alloc(pCtx, &pFrag, psz_repo_id, psz_admin_id, iDagNum) );
SG_ERR_CHECK( SG_dagfrag__load_from_repo__multi(pCtx, pFrag, pRepo, prbStartFromHids, gensToFetch) );
#if TRACE_SYNC
SG_ERR_CHECK( SG_time__get_milliseconds_since_1970_utc(pCtx, &endTime) );
{
SG_uint32 dagnodeCount;
double seconds = ((double)endTime-(double)startTime)/1000;
SG_ERR_CHECK( SG_dagfrag__dagnode_count(pCtx, pFrag, &dagnodeCount) );
SG_ERR_CHECK( SG_console(pCtx, SG_CS_STDERR, " - %u nodes in frag, built in %1.3f seconds\n", dagnodeCount, seconds) );
SG_ERR_CHECK( SG_dagfrag_debug__dump__console(pCtx, pFrag, "best-guess dagfrag", 0, SG_CS_STDERR) );
}
#endif
*ppFrag = pFrag;
pFrag = NULL;
/* Common cleanup */
fail:
SG_NULLFREE(pCtx, psz_repo_id);
SG_NULLFREE(pCtx, psz_admin_id);
SG_RBTREE_ITERATOR_NULLFREE(pCtx, pit);
SG_DAGNODE_NULLFREE(pCtx, pdn);
SG_DAGFRAG_NULLFREE(pCtx, pFrag);
SG_ERR_IGNORE( SG_repo__fetch_dagnodes__end(pCtx, pRepo, &pdh) );
}
void SG_lib__global_initialize(SG_context * pCtx)
{
if (gbLibDataInitialized)
SG_ERR_THROW_RETURN(SG_ERR_ALREADY_INITIALIZED);
#if defined(WINDOWS) && defined(DEBUG)
// Send run-time warnings and errors to stderr (they go to debugger output by default)
_CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE);
_CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR);
_CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
_CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
#if defined(WINDOWS_CRT_LEAK_CHECK)
// Turn on Windows' C runtime library debug leak checking.
// This causes _CrtDumpMemoryLeaks() to be called when our process exits.
// You could accomplish the same thing by adding a call to _CrtDumpMemoryLeaks
// to _sg_mem_dump_atexit.
{
int flags = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
flags |= _CRTDBG_LEAK_CHECK_DF;
_CrtSetDbgFlag(flags);
}
#endif // WINDOWS_CRT_LEAK_CHECK
#if defined(SG_REAL_BUILD)
// Send assertion failures to stderr (don't raise a dialog) when performing an official build.
// SG_REAL_BUILD gets defined by CMAKE if there's an environment variable SPRAWL_BUILDER = 1.
_CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE);
_CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
#endif // SG_REAL_BUILD
#endif // WINDOWS && DEBUG
memset(&gLibData,0,sizeof(gLibData));
// WARNING: We assume that it is possible for the caller to have created
// WARNING: a properly-populated SG_context before the library is initialized.
// WARNING:
// WARNING: That is, that the creation of the SG_context MUST NOT require any
// WARNING: character encoding, locale, and/or UTF-8 stuff.
// WARNING:
// WARNING: Also, there the SG_context creation MUST NOT require us to read
// WARNING: any local settings.
//
// WARNING: We also assume that stuff in SG_malloc.c can be called before the
// WARNING: library is initialized.
// We assume that the character encoding/locale stuff should be initialized first
// before anyone tries to access the disk (for local settings and etc) because
// all of the SG_fsobj__ and SG_file__ routines convert UTF-8 SG_pathnames into
// locale-based char* or wchar_t* buffers before accessing the filesystem.
SG_ERR_CHECK( sg_lib_utf8__global_initialize(pCtx, &gLibData.pUtf8GlobalData) );
SG_ERR_CHECK( SG_curl__global_init(pCtx) );
{
SG_int64 itime = -1;
SG_ERR_CHECK( SG_time__get_milliseconds_since_1970_utc(pCtx, &itime) );
SG_random__seed((SG_uint32) itime);
}
gbLibDataInitialized = SG_TRUE;
return;
fail:
SG_ERR_IGNORE( SG_lib__global_cleanup(pCtx) );
}
