static void _sg_jscore_getpaths(SG_context *pCtx)
{
char * szServerFiles = NULL;
if (gpJSCoreGlobalState->pPathToDispatchDotJS)
return;
// Figure out and store relavant paths...
SG_ERR_CHECK( SG_localsettings__get__sz(pCtx, SG_LOCALSETTING__SERVER_FILES, NULL, &szServerFiles, NULL) );
if (szServerFiles)
{
SG_ERR_CHECK( SG_PATHNAME__ALLOC__SZ(pCtx, &gpJSCoreGlobalState->pPathToDispatchDotJS, szServerFiles) );
SG_ERR_CHECK( SG_pathname__append__from_sz(pCtx, gpJSCoreGlobalState->pPathToDispatchDotJS, "dispatch.js") );
SG_ERR_CHECK( SG_PATHNAME__ALLOC__SZ(pCtx, &gpJSCoreGlobalState->pPathToCore, szServerFiles) );
SG_ERR_CHECK( SG_pathname__append__from_sz(pCtx, gpJSCoreGlobalState->pPathToCore, "core") );
SG_ERR_CHECK( SG_PATHNAME__ALLOC__SZ(pCtx, &gpJSCoreGlobalState->pPathToModules, szServerFiles) );
SG_ERR_CHECK( SG_pathname__append__from_sz(pCtx, gpJSCoreGlobalState->pPathToModules, "modules") );
}
fail:
SG_NULLFREE(pCtx, szServerFiles);
}
void u0038_test_wdmapping(SG_context * pCtx)
{
SG_vhash* pvh = NULL;
SG_pathname* pPath = NULL;
SG_pathname* pMappedPath = NULL;
SG_string* pstrRepoDescriptorName = NULL;
char* pszidGid = NULL;
VERIFY_ERR_CHECK_DISCARD( SG_PATHNAME__ALLOC(pCtx, &pPath) );
VERIFY_ERR_CHECK_DISCARD( SG_pathname__set__from_cwd(pCtx, pPath) );
VERIFY_ERR_CHECK_DISCARD( SG_VHASH__ALLOC(pCtx, &pvh) );
VERIFY_ERR_CHECK_DISCARD( SG_vhash__add__string__sz(pCtx, pvh, "hello", "world") );
VERIFY_ERR_CHECK_DISCARD( SG_vhash__add__string__sz(pCtx, pvh, "hola", "mundo") );
SG_ERR_IGNORE( SG_closet__descriptors__remove(pCtx, "r1") );
VERIFY_ERR_CHECK_DISCARD( SG_closet__descriptors__add(pCtx, "r1", pvh) );
VERIFY_ERR_CHECK_DISCARD( SG_workingdir__set_mapping(pCtx, pPath, "r1", NULL) );
VERIFY_ERR_CHECK_DISCARD( SG_workingdir__find_mapping(pCtx, pPath, &pMappedPath, &pstrRepoDescriptorName, &pszidGid) );
VERIFY_COND("ridesc match", (0 == strcmp("r1", SG_string__sz(pstrRepoDescriptorName))));
VERIFY_ERR_CHECK_DISCARD( SG_pathname__append__from_sz(pCtx, pPath, "foo") );
VERIFY_ERR_CHECK_DISCARD( SG_pathname__append__from_sz(pCtx, pPath, "bar") );
VERIFY_ERR_CHECK_DISCARD( SG_pathname__append__from_sz(pCtx, pPath, "plok") );
SG_STRING_NULLFREE(pCtx, pstrRepoDescriptorName);
SG_PATHNAME_NULLFREE(pCtx, pMappedPath);
VERIFY_ERR_CHECK_DISCARD( SG_workingdir__find_mapping(pCtx, pPath, &pMappedPath, &pstrRepoDescriptorName, &pszidGid) );
SG_STRING_NULLFREE(pCtx, pstrRepoDescriptorName);
SG_PATHNAME_NULLFREE(pCtx, pMappedPath);
SG_PATHNAME_NULLFREE(pCtx, pPath);
SG_VHASH_NULLFREE(pCtx, pvh);
}
void u0038_test_wdmapping(SG_context * pCtx)
{
SG_vhash* pvh = NULL;
SG_closet_descriptor_handle* ph = NULL;
SG_pathname* pPath = NULL;
SG_pathname* pMappedPath = NULL;
SG_string* pstrRepoDescriptorName = NULL;
char* pszidGid = NULL;
char buf_tid[SG_TID_MAX_BUFFER_LENGTH];
VERIFY_ERR_CHECK_DISCARD( SG_tid__generate2__suffix(pCtx, buf_tid, sizeof(buf_tid), 32, "u0038") );
VERIFY_ERR_CHECK_DISCARD( SG_PATHNAME__ALLOC__SZ(pCtx, &pPath, buf_tid) );
VERIFY_ERR_CHECK_DISCARD( SG_fsobj__mkdir__pathname(pCtx, pPath) );
SG_ERR_IGNORE( SG_closet__descriptors__remove(pCtx, "r1") );
VERIFY_ERR_CHECK_DISCARD( SG_closet__descriptors__add_begin(pCtx, "r1", NULL, NULL, NULL, NULL, &pvh, &ph) );
VERIFY_ERR_CHECK_DISCARD( SG_closet__descriptors__add_commit(pCtx, &ph, pvh, SG_REPO_STATUS__NORMAL) );
SG_VHASH_NULLFREE(pCtx, pvh);
VERIFY_ERR_CHECK_DISCARD( SG_workingdir__set_mapping(pCtx, pPath, "r1", NULL) );
VERIFY_ERR_CHECK_DISCARD( SG_workingdir__find_mapping(pCtx, pPath, &pMappedPath, &pstrRepoDescriptorName, &pszidGid) );
VERIFY_COND("ridesc match", (0 == strcmp("r1", SG_string__sz(pstrRepoDescriptorName))));
VERIFY_ERR_CHECK_DISCARD( SG_pathname__append__from_sz(pCtx, pPath, "foo") );
VERIFY_ERR_CHECK_DISCARD( SG_pathname__append__from_sz(pCtx, pPath, "bar") );
VERIFY_ERR_CHECK_DISCARD( SG_pathname__append__from_sz(pCtx, pPath, "plok") );
SG_STRING_NULLFREE(pCtx, pstrRepoDescriptorName);
SG_PATHNAME_NULLFREE(pCtx, pMappedPath);
VERIFY_ERR_CHECK_DISCARD( SG_workingdir__find_mapping(pCtx, pPath, &pMappedPath, &pstrRepoDescriptorName, &pszidGid) );
SG_STRING_NULLFREE(pCtx, pstrRepoDescriptorName);
SG_PATHNAME_NULLFREE(pCtx, pMappedPath);
SG_PATHNAME_NULLFREE(pCtx, pPath);
}
void _set_curl_options(SG_context* pCtx, CURL* pCurl)
{
char * szServerFiles = NULL;
char * szVerifyCerts = NULL;
SG_pathname *pServerFiles = NULL;
CURLcode rc = CURLE_OK;
#ifdef WINDOWS
SG_bool bExists = SG_FALSE;
SG_bool bVerifyCerts = SG_TRUE;
#endif
SG_ERR_CHECK( SG_localsettings__get__sz(pCtx, SG_LOCALSETTING__VERIFY_SSL_CERTS, NULL, &szVerifyCerts, NULL) );
if (szVerifyCerts != NULL && (SG_strcmp__null(szVerifyCerts, "false") == 0 || SG_strcmp__null(szVerifyCerts, "FALSE") == 0))
{
#ifdef WINDOWS
bVerifyCerts = SG_FALSE;
#endif
rc = curl_easy_setopt(pCurl, CURLOPT_SSL_VERIFYPEER, SG_FALSE);
}
if (rc)
SG_ERR_THROW(SG_ERR_LIBCURL(rc));
#ifdef WINDOWS
if (bVerifyCerts)
{
SG_ERR_CHECK( SG_localsettings__get__sz(pCtx, SG_LOCALSETTING__SERVER_FILES, NULL, &szServerFiles, NULL) );
if (szServerFiles)
{
SG_ERR_CHECK( SG_pathname__alloc__sz(pCtx, &pServerFiles, szServerFiles) );
SG_ERR_CHECK( SG_pathname__append__from_sz(pCtx, pServerFiles, "ssl") );
SG_ERR_CHECK( SG_pathname__append__from_sz(pCtx, pServerFiles, "curl-ca-bundle.crt") );
SG_ERR_CHECK( SG_fsobj__exists__pathname(pCtx, pServerFiles, &bExists, NULL, NULL) );
}
if (bExists)
{
rc = curl_easy_setopt(pCurl, CURLOPT_CAINFO, SG_pathname__sz(pServerFiles));
if (rc)
SG_ERR_THROW(SG_ERR_LIBCURL(rc));
}
else
{
if (pServerFiles)
SG_ERR_CHECK( SG_log__report_warning(pCtx, "Could not find root certificate file. Looked for it at: %s. SSL connections will not work.", SG_pathname__sz(pServerFiles)) );
else
SG_ERR_CHECK( SG_log__report_warning(pCtx, "Could not find root certificate file: no server/files path is configured. SSL connections will not work.") );
}
}
#endif
fail:
SG_PATHNAME_NULLFREE(pCtx, pServerFiles);
SG_NULLFREE(pCtx, szServerFiles);
SG_NULLFREE(pCtx, szVerifyCerts);
}
/**
* Create a per-tx temp-dir if we don't already have one.
*
*/
void sg_wc_tx__create_session_temp_dir(SG_context * pCtx,
SG_wc_tx * pWcTx)
{
char bufTidSession[SG_TID_MAX_BUFFER_LENGTH];
SG_uint32 nrDigits = 10;
if (pWcTx->pPathSessionTempDir)
return;
// pick a space in /tmp for exporting temporary copies of the files
// so that internal and/or external tools can compare them.
//
// TODO 2012/05/02 Investigate the use of SG_workingdir__get_temp_path() (which
// TODO creates things in .sgdrawer rather than /tmp).
// TODO (see also sg_mrg__private_file_mrg.h)
// TODO See also sg_vv2__diff__create_session_temp_dir().
SG_ERR_CHECK( SG_PATHNAME__ALLOC__USER_TEMP_DIRECTORY(pCtx, &pWcTx->pPathSessionTempDir) );
SG_ERR_CHECK( SG_tid__generate2(pCtx, bufTidSession, sizeof(bufTidSession), nrDigits) );
SG_ERR_CHECK( SG_pathname__append__from_sz(pCtx, pWcTx->pPathSessionTempDir, bufTidSession) );
SG_ERR_TRY( SG_fsobj__mkdir_recursive__pathname(pCtx, pWcTx->pPathSessionTempDir) );
SG_ERR_CATCH_IGNORE( SG_ERR_DIR_ALREADY_EXISTS );
SG_ERR_CATCH_END;
#if 0 && defined(DEBUG)
SG_ERR_IGNORE( SG_console(pCtx, SG_CS_STDERR,
"CreateSessionTempDir: %s\n",
SG_pathname__sz(pWcTx->pPathSessionTempDir)) );
#endif
fail:
return;
}
/**
* Return a pathname set to the location of the "tmp"
* directory for this working directory.
*
* We create something like:
*
* <root>/.sgdrawer/tmp/
*
* Note that the main "tmp" directory is long-lived and
* may be used by multiple tasks at the same time. So
* for significant tasks, create a private sub-directory
* within it.
*
*/
void sg_wc_db__path__get_temp_dir(SG_context * pCtx,
const sg_wc_db * pDb,
SG_pathname ** ppPathTempDir)
{
SG_pathname * pPath = NULL;
SG_ERR_CHECK( SG_workingdir__get_drawer_path(pCtx,
pDb->pPathWorkingDirectoryTop,
&pPath) );
SG_ERR_CHECK( SG_pathname__append__from_sz(pCtx, pPath, "tmp") );
SG_ERR_CHECK( SG_pathname__add_final_slash(pCtx, pPath) );
// the "tmp" dir could get deleted by routine housekeeping,
// so re-create it if someone even thinks about using temp-based
// pathnames. i'm going to skip the usual "if (!exists) mkdir"
// stuff and just try to create it and ignore the error.
SG_fsobj__mkdir__pathname(pCtx, pPath);
if (SG_CONTEXT__HAS_ERR(pCtx))
{
if (!SG_context__err_equals(pCtx, SG_ERR_DIR_ALREADY_EXISTS))
SG_ERR_RETHROW;
SG_context__err_reset(pCtx);
}
*ppPathTempDir = pPath;
return;
fail:
SG_PATHNAME_NULLFREE(pCtx, pPath);
}
void sg_wc_db__path__sz_repopath_to_absolute(SG_context * pCtx,
const sg_wc_db * pDb,
const char * pszRepoPath,
SG_pathname ** ppPathItem)
{
SG_pathname * pPath = NULL;
// TODO 2012/01/23 This code was written before the extended-prefix repo-path
// TODO stuff, but it is still valid to require a live/wd-relative
// TODO repo-path when building an absolute pathname (because it
// TODO probably doesn't make sense to convert an arbitrary-context
// TODO repo-path (without someone doing the implied context conversion)).
// TODO
// TODO So I'm going to leave this as an assert for now.
SG_ASSERT_RELEASE_FAIL( ((pszRepoPath[0]=='@') && (pszRepoPath[1]=='/')) );
SG_ERR_CHECK( SG_PATHNAME__ALLOC__COPY(pCtx,
&pPath,
pDb->pPathWorkingDirectoryTop) );
SG_ERR_CHECK( SG_pathname__add_final_slash(pCtx, pPath) );
if (pszRepoPath[2])
SG_ERR_CHECK( SG_pathname__append__from_sz(pCtx, pPath, &pszRepoPath[2]) );
*ppPathItem = pPath;
return;
fail:
SG_PATHNAME_NULLFREE(pCtx, pPath);
}
/**
* Construct a pathname for a DB in the drawer.
* This is something of the form:
*
* <root>/.sgdrawer/wc.db
*
*/
void sg_wc_db__path__compute_pathname_in_drawer(SG_context * pCtx, sg_wc_db * pDb)
{
SG_ERR_CHECK_RETURN( SG_workingdir__get_drawer_path(pCtx,
pDb->pPathWorkingDirectoryTop,
&pDb->pPathDB) );
SG_ERR_CHECK_RETURN( SG_pathname__append__from_sz(pCtx, pDb->pPathDB, "wc.db") );
}
void u0038_test_version(SG_context * pCtx)
{
/* This test pokes around in closet internals in ways normal closet callers shouldn't. */
SG_string* pstrEnv = NULL;
SG_uint32 len;
SG_pathname* pPathCloset = NULL;
SG_pathname* pPathClosetVersion = NULL;
SG_pathname* pPathClosetVersionBackup = NULL;
SG_file* pFile = NULL;
SG_vhash* pvh = NULL;
/* Deliberately making this break for closet version 3 -- current is version 2. */
SG_byte buf[3];
VERIFY_ERR_CHECK( SG_environment__get__str(pCtx, "SGCLOSET", &pstrEnv, &len) );
if (len)
{
VERIFY_ERR_CHECK( SG_PATHNAME__ALLOC__SZ(pCtx, &pPathCloset, SG_string__sz(pstrEnv)) );
}
else
{
VERIFY_ERR_CHECK( SG_PATHNAME__ALLOC__USER_APPDATA_DIRECTORY(pCtx, &pPathCloset) );
VERIFY_ERR_CHECK( SG_pathname__append__from_sz(pCtx, pPathCloset, ".sgcloset") );
}
VERIFY_ERR_CHECK( SG_pathname__alloc__pathname_sz(pCtx, &pPathClosetVersion, pPathCloset, "version") );
VERIFY_ERR_CHECK( SG_pathname__alloc__pathname_sz(pCtx, &pPathClosetVersionBackup, pPathCloset, "version.bak") );
VERIFY_ERR_CHECK( SG_fsobj__move__pathname_pathname(pCtx, pPathClosetVersion, pPathClosetVersionBackup) );
VERIFY_ERR_CHECK( SG_file__open__pathname(pCtx, pPathClosetVersion, SG_FILE_OPEN_OR_CREATE|SG_FILE_WRONLY|SG_FILE_TRUNC, 0644, &pFile) );
VERIFY_ERR_CHECK( SG_file__write(pCtx, pFile, sizeof(buf), buf, NULL) );
VERIFY_ERR_CHECK( SG_file__close(pCtx, &pFile) );
SG_closet__descriptors__list(pCtx, &pvh);
VERIFY_COND("", SG_context__err_equals(pCtx, SG_ERR_UNSUPPORTED_CLOSET_VERSION));
SG_ERR_DISCARD;
VERIFY_ERR_CHECK( SG_fsobj__remove__pathname(pCtx, pPathClosetVersion) );
VERIFY_ERR_CHECK( SG_fsobj__move__pathname_pathname(pCtx, pPathClosetVersionBackup, pPathClosetVersion) );
/* Common cleanup */
fail:
SG_STRING_NULLFREE(pCtx, pstrEnv);
SG_PATHNAME_NULLFREE(pCtx, pPathCloset);
SG_PATHNAME_NULLFREE(pCtx, pPathClosetVersion);
SG_PATHNAME_NULLFREE(pCtx, pPathClosetVersionBackup);
SG_FILE_NULLCLOSE(pCtx, pFile);
SG_VHASH_NULLFREE(pCtx, pvh);
}
void _read_template_file(
SG_context *pCtx,
const char *templateFn,
SG_string **pContent, /**< we allocate, we free on error, else caller owns it */
const _request_headers *pRequestHeaders,
_replacer_cb replacer)
{
SG_pathname *tpath = NULL;
SG_file *pFile = NULL;
SG_uint32 got = 0;
char tbuf[1024];
//todo: make this thread-safe:
if(_sg_uridispatch__templatePath==NULL)
SG_ERR_CHECK( _sgui_set_templatePath(pCtx) );
SG_ERR_CHECK( SG_PATHNAME__ALLOC__COPY(pCtx, &tpath, _sg_uridispatch__templatePath) );
SG_ERR_CHECK( SG_pathname__append__from_sz(pCtx, tpath, templateFn) );
SG_ERR_CHECK( SG_file__open__pathname(pCtx, tpath, SG_FILE_RDONLY|SG_FILE_OPEN_EXISTING, 0644, &pFile) );
SG_PATHNAME_NULLFREE(pCtx, tpath);
SG_ERR_CHECK( SG_STRING__ALLOC(pCtx, pContent) );
do
{
SG_file__read(pCtx, pFile, sizeof(tbuf), (SG_byte *)tbuf, &got);
if (SG_context__err_equals(pCtx, SG_ERR_EOF))
{
SG_context__err_reset(pCtx);
break;
}
SG_ERR_CHECK_CURRENT;
SG_ERR_CHECK( SG_string__append__buf_len(pCtx, *pContent, (const SG_byte *)tbuf, got) );
} while (got > 0);
SG_ERR_CHECK( SG_file__close(pCtx, &pFile) );
SG_ERR_CHECK( _templatize(pCtx, *pContent, pRequestHeaders, replacer) );
return;
fail:
SG_STRING_NULLFREE(pCtx, *pContent);
SG_FILE_NULLCLOSE(pCtx, pFile);
SG_PATHNAME_NULLFREE(pCtx, tpath);
}
static void _loadModuleDir(SG_context *pCtx, const SG_pathname *path, const char *modname, JSContext *cx, JSObject *glob)
{
SG_rbtree * pJavascriptFiles = NULL;
SG_rbtree_iterator * pJavascriptFile = NULL;
const char *szJavascriptFile = NULL;
SG_pathname *pJavascriptFilePath = NULL;
SG_bool ok = SG_FALSE;
SG_bool valid = SG_FALSE;
char *psz_js = NULL; // free
SG_uint32 len_js = 0;
jsval rval = JSVAL_VOID;
SG_ERR_CHECK( SG_dir__list(pCtx, path, NULL, NULL, ".js", &pJavascriptFiles) );
SG_ERR_CHECK( SG_rbtree__iterator__first(pCtx, &pJavascriptFile, pJavascriptFiles, &ok, &szJavascriptFile, NULL) );
SG_ERR_CHECK( SG_PATHNAME__ALLOC__COPY(pCtx, &pJavascriptFilePath, path) );
while(ok)
{
SG_ERR_CHECK( _isValidJsFile(pCtx, szJavascriptFile, &valid) );
if (valid)
{
SG_ERR_CHECK( SG_pathname__append__from_sz(pCtx, pJavascriptFilePath, szJavascriptFile) );
SG_ERR_CHECK( sg_read_entire_file(pCtx, pJavascriptFilePath, &psz_js, &len_js) );
if(!JS_EvaluateScript(cx, glob, psz_js, len_js, szJavascriptFile, 1, &rval))
{
SG_ERR_CHECK_CURRENT;
SG_ERR_THROW2(SG_ERR_JS, (pCtx, "An error occurred loading %s javascript file '%s'", modname, szJavascriptFile));
}
SG_NULLFREE(pCtx, psz_js);
SG_ERR_CHECK( SG_pathname__remove_last(pCtx, pJavascriptFilePath) );
}
SG_ERR_CHECK( SG_rbtree__iterator__next(pCtx, pJavascriptFile, &ok, &szJavascriptFile, NULL) );
}
fail:
SG_PATHNAME_NULLFREE(pCtx, pJavascriptFilePath);
SG_RBTREE_ITERATOR_NULLFREE(pCtx, pJavascriptFile);
SG_RBTREE_NULLFREE(pCtx, pJavascriptFiles);
SG_NULLFREE(pCtx, psz_js);
}
/**
* Export a blob-of-interest from the REPO into a temporary directory
* so that we can let the external diff tool compare it with another
* version somewhere.
*
* We create a file with a GID-based name rather than re-creating
* the working-directory hierarchy in the temp directory. This lets
* us flatten the export in one directory without collisions and
* avoids move/rename and added/deleted sub-directory issues.
*
* pPathTempSessionDir should be something like "$TMPDIR/gid_session/".
* This should be a unique directory name such that everything being
* exported is isolated from other runs. (if we are doing a
* changeset-vs-changeset diff, we may create lots of files on each
* side -- and our command should not interfere with other diffs
* in progress in other processes.)
*
* szVersion should be a value to let us group everything from cset[0]
* in a different directory from stuff from cset[1]. this might be
* simply "0" and "1" or it might be the cset's HIDs.
*
* szGidObject is the gid of the object.
*
* szHidBlob is the HID of the content. Normally this is the content
* of the file that will be compared (corresponding to a user-file
* under version control). However, we may also want to use this
* to splat the XATTRs to a file so that they can be compared (on
* non-apple systems) -- but this may be too weird.
*
* You are responsible for freeing the returned pathname and
* deleting the file that we create.
*/
void SG_diff_utils__export_to_temp_file(SG_context * pCtx,
SG_repo * pRepo,
const SG_pathname * pPathTempSessionDir, // value of "$TMPDIR/session/"
const char * szVersion, // an index (like 0 or 1, _older_ _newer_) or maybe cset HID
const char * szGidObject,
const char * szHidBlob,
SG_pathname ** ppPathTempFile)
{
SG_pathname * pPathFile = NULL;
SG_file * pFile = NULL;
SG_bool bDirExists;
// mkdir $TMPDIR/session/version
// create pathname for the temp file: $TMPDIR/session/version/object_gid
//
// TODO do we want to append the suffix from the file to this pathname so that
// TODO tools like SGDM can use it? what if the file is renamed and given a
// TODO different suffix between versions?
SG_ERR_CHECK( SG_PATHNAME__ALLOC__PATHNAME_SZ(pCtx,&pPathFile,pPathTempSessionDir,szVersion) );
SG_ERR_CHECK( SG_fsobj__exists__pathname(pCtx,pPathFile,&bDirExists,NULL,NULL) );
if (!bDirExists)
SG_ERR_CHECK( SG_fsobj__mkdir_recursive__pathname(pCtx,pPathFile) );
SG_ERR_CHECK( SG_pathname__append__from_sz(pCtx,pPathFile,szGidObject) );
// open the file and copy the contents of the blob into it
SG_ERR_CHECK( SG_file__open__pathname(pCtx,pPathFile,SG_FILE_WRONLY|SG_FILE_CREATE_NEW,0600,&pFile) );
SG_ERR_CHECK( SG_repo__fetch_blob_into_file(pCtx,pRepo,szHidBlob,pFile,NULL) );
SG_ERR_CHECK( SG_file__close(pCtx,&pFile) );
*ppPathTempFile = pPathFile;
return;
fail:
if (pFile) // only if **WE** created the file, do we try to delete it on an error.
{
SG_FILE_NULLCLOSE(pCtx,pFile);
SG_ERR_IGNORE( SG_fsobj__remove__pathname(pCtx,pPathFile) );
}
SG_PATHNAME_NULLFREE(pCtx, pPathFile);
}
void SG_workingdir__get_temp_path(SG_context* pCtx,
const SG_pathname* pPathWorkingDirectoryTopAsGiven,
SG_pathname** ppResult)
{
SG_pathname * pPathname = NULL;
SG_NULLARGCHECK_RETURN(ppResult);
// I don't trust the given <wd-top>, get the actual one from the disk
// using this as a starting point.
SG_ERR_CHECK( SG_workingdir__find_mapping(pCtx,pPathWorkingDirectoryTopAsGiven,&pPathname,NULL,NULL) );
SG_ERR_CHECK( SG_pathname__append__from_sz(pCtx,pPathname,sg_WD_TEMP_DIRECTORY_NAME) );
*ppResult = pPathname;
return;
fail:
SG_PATHNAME_NULLFREE(pCtx, pPathname);
}
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);
}
void u0020_utf8pathnames__mkdir_tmp_dir(SG_context * pCtx, SG_pathname ** ppPathnameTmpDir)
{
// create a temporary directory using a random name in the
// current directory or in TMP.
//
// return the name of the pathname.
char bufTid[SG_TID_MAX_BUFFER_LENGTH];
SG_pathname * pPathnameTmpDir = NULL;
VERIFY_ERR_CHECK( SG_tid__generate2(pCtx, bufTid, sizeof(bufTid), 32) );
VERIFY_ERR_CHECK( SG_PATHNAME__ALLOC__USER_TEMP_DIRECTORY(pCtx, &pPathnameTmpDir) );
VERIFY_ERR_CHECK( SG_pathname__append__from_sz(pCtx, pPathnameTmpDir,bufTid) );
VERIFY_ERR_CHECK( SG_fsobj__mkdir_recursive__pathname(pCtx, pPathnameTmpDir) );
*ppPathnameTmpDir = pPathnameTmpDir;
return;
fail:
SG_PATHNAME_NULLFREE(pCtx, pPathnameTmpDir);
}
static void _sg_jscore__install_modules(SG_context * pCtx, JSContext *cx, JSObject *glob,
const SG_vhash *pServerConfig)
{
SG_pathname *pModuleDirPath = NULL;
SG_rbtree_iterator *pModuleDir = NULL;
SG_rbtree *pModules = NULL;
const char *szModuleDir = NULL;
SG_bool ok = SG_FALSE;
SG_uint32 len_js = 0;
jsval rval;
char *psz_js = NULL;
jsval fo = JSVAL_VOID;
JSObject * jsoServerConfig = NULL;
if (gpJSCoreGlobalState->bSkipModules)
return;
SG_ERR_CHECK( _modulesInstalled(pCtx, cx, glob, &ok) );
if (ok)
return;
if (! gpJSCoreGlobalState->pPathToDispatchDotJS)
return;
SG_ERR_CHECK( _setModulesInstalled(pCtx, cx, glob) );
SG_ERR_CHECK( sg_read_entire_file(pCtx, gpJSCoreGlobalState->pPathToDispatchDotJS, &psz_js, &len_js) );
if(!JS_EvaluateScript(cx, glob, psz_js, len_js, "dispatch.js", 1, &rval))
{
SG_ERR_CHECK_CURRENT;
SG_ERR_THROW2(SG_ERR_JS, (pCtx, "An error occurred evaluating dispatch.js!"));
}
SG_NULLFREE(pCtx, psz_js);
// Call init function in dispatch.js
if(pServerConfig)
{
jsval arg;
JSBool js_ok;
jsval rval2;
SG_JS_NULL_CHECK( jsoServerConfig = JS_NewObject(cx, NULL, NULL, NULL) );
SG_ERR_CHECK( sg_jsglue__copy_vhash_into_jsobject(pCtx, cx, pServerConfig, jsoServerConfig) );
arg = OBJECT_TO_JSVAL(jsoServerConfig);
js_ok = JS_CallFunctionName(cx, glob, "init", 1, &arg, &rval2);
SG_ERR_CHECK_CURRENT;
if(!js_ok)
SG_ERR_THROW2(SG_ERR_JS, (pCtx, "An error occurred initializing JavaScript framework: call to JavaScript init() failed"));
jsoServerConfig = NULL;
}
// Load core.
SG_ERR_CHECK( _loadModuleDir(pCtx, gpJSCoreGlobalState->pPathToCore, "core", cx, glob) );
// Load modules.
SG_ERR_CHECK( SG_dir__list(pCtx, gpJSCoreGlobalState->pPathToModules, NULL, NULL, NULL, &pModules) );
SG_ERR_CHECK( SG_rbtree__iterator__first(pCtx, &pModuleDir, pModules, &ok, &szModuleDir, NULL) );
SG_ERR_CHECK( SG_PATHNAME__ALLOC__COPY(pCtx, &pModuleDirPath, gpJSCoreGlobalState->pPathToModules) );
while(ok)
{
if (szModuleDir[0] != '.')
{
SG_fsobj_stat fss;
SG_ERR_CHECK( SG_pathname__append__from_sz(pCtx, pModuleDirPath, szModuleDir) );
SG_ERR_CHECK( SG_fsobj__stat__pathname(pCtx, pModuleDirPath, &fss) );
if (fss.type & SG_FSOBJ_TYPE__DIRECTORY) // dot paths?
{
SG_ERR_CHECK( _loadModuleDir(pCtx, pModuleDirPath, szModuleDir, cx, glob) );
}
SG_ERR_CHECK( SG_pathname__remove_last(pCtx, pModuleDirPath) );
}
SG_ERR_CHECK( SG_rbtree__iterator__next(pCtx, pModuleDir, &ok, &szModuleDir, NULL) );
}
if (! JS_LookupProperty(cx, glob, "initModules", &fo))
{
SG_ERR_CHECK_CURRENT;
SG_ERR_THROW2(SG_ERR_JS, (pCtx, "lookup of initModules() failed"));
}
if (!JSVAL_IS_VOID(fo))
if (! JS_CallFunctionName(cx, glob, "initModules", 0, NULL, &rval))
{
SG_ERR_CHECK_CURRENT;
SG_ERR_THROW2(SG_ERR_JS, (pCtx, "Call to initModules() failed"));
}
fail:
SG_NULLFREE(pCtx, psz_js);
SG_PATHNAME_NULLFREE(pCtx, pModuleDirPath);
SG_RBTREE_ITERATOR_NULLFREE(pCtx, pModuleDir);
SG_RBTREE_NULLFREE(pCtx, pModules);
}
