static void* ThreadStarter (void* data) {
sigset_t all;
sigfillset(&all);
pthread_sigmask(SIG_SETMASK, &all, 0);
thread_data_t* d = static_cast<thread_data_t*>(data);
TRI_ASSERT(d != nullptr);
#ifdef TRI_HAVE_SYS_PRCTL_H
prctl(PR_SET_NAME, d->_name, 0, 0, 0);
#endif
try {
d->starter(d->_data);
}
catch (...) {
TRI_FreeString(TRI_CORE_MEM_ZONE, d->_name);
TRI_Free(TRI_CORE_MEM_ZONE, d);
throw;
}
TRI_FreeString(TRI_CORE_MEM_ZONE, d->_name);
TRI_Free(TRI_CORE_MEM_ZONE, d);
return nullptr;
}
void TRI_DestroyStateReplicationApplier (TRI_replication_applier_state_t* state) {
if (state->_progressMsg != NULL) {
TRI_FreeString(TRI_CORE_MEM_ZONE, state->_progressMsg);
}
if (state->_lastError._msg != NULL) {
TRI_FreeString(TRI_CORE_MEM_ZONE, state->_lastError._msg);
}
}
static TRI_vocbase_auth_t* ConvertAuthInfo (TRI_vocbase_t* vocbase,
TRI_primary_collection_t* primary,
TRI_shaped_json_t const* document) {
TRI_shaper_t* shaper;
char* user;
char* password;
bool active;
bool found;
TRI_vocbase_auth_t* result;
shaper = primary->_shaper;
// extract username
user = ExtractStringShapedJson(shaper, document, "user");
if (user == NULL) {
LOG_DEBUG("cannot extract username");
return NULL;
}
// extract password
password = ExtractStringShapedJson(shaper, document, "password");
if (password == NULL) {
TRI_FreeString(TRI_CORE_MEM_ZONE, user);
LOG_DEBUG("cannot extract password");
return NULL;
}
// extract active flag
active = ExtractBooleanShapedJson(shaper, document, "active", &found);
if (! found) {
TRI_FreeString(TRI_CORE_MEM_ZONE, user);
TRI_FreeString(TRI_CORE_MEM_ZONE, password);
LOG_DEBUG("cannot extract active flag");
return NULL;
}
result = TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_vocbase_auth_t), true);
if (result == NULL) {
TRI_FreeString(TRI_CORE_MEM_ZONE, user);
TRI_FreeString(TRI_CORE_MEM_ZONE, password);
LOG_ERROR("couldn't load auth information - out of memory");
return NULL;
}
result->_username = user;
result->_password = password;
result->_active = active;
return result;
}
static void RemoveDatafileCallback (TRI_datafile_t* datafile, void* data) {
TRI_collection_t* collection;
char* old;
char* filename;
char* name;
char* number;
bool ok;
int res;
collection = data;
number = TRI_StringUInt32(datafile->_fid);
name = TRI_Concatenate3String("deleted-", number, ".db");
filename = TRI_Concatenate2File(collection->_directory, name);
TRI_FreeString(TRI_CORE_MEM_ZONE, number);
TRI_FreeString(TRI_CORE_MEM_ZONE, name);
old = datafile->_filename;
ok = TRI_RenameDatafile(datafile, filename);
if (! ok) {
LOG_ERROR("cannot rename obsolete datafile '%s' to '%s': %s",
old,
filename,
TRI_last_error());
}
LOG_DEBUG("finished compactifing datafile '%s'", datafile->_filename);
ok = TRI_CloseDatafile(datafile);
if (! ok) {
LOG_ERROR("cannot close obsolete datafile '%s': %s",
datafile->_filename,
TRI_last_error());
}
else {
if (collection->_vocbase->_removeOnCompacted) {
LOG_DEBUG("wiping compacted datafile from disk");
res = TRI_UnlinkFile(filename);
if (res != TRI_ERROR_NO_ERROR) {
LOG_ERROR("cannot wipe obsolete datafile '%s': %s",
datafile->_filename,
TRI_last_error());
}
}
}
TRI_FreeDatafile(datafile);
TRI_FreeString(TRI_CORE_MEM_ZONE, filename);
}
char* TRI_GetDirectoryCollection (char const* path,
const TRI_col_info_t* const parameter) {
char* filename;
assert(path);
assert(parameter);
// shape collections use just the name, e.g. path/SHAPES
if (parameter->_type == TRI_COL_TYPE_SHAPE) {
filename = TRI_Concatenate2File(path, parameter->_name);
}
// other collections use the collection identifier
else if (TRI_IS_DOCUMENT_COLLECTION(parameter->_type)) {
char* tmp1;
char* tmp2;
tmp1 = TRI_StringUInt64(parameter->_cid);
if (tmp1 == NULL) {
TRI_set_errno(TRI_ERROR_OUT_OF_MEMORY);
return NULL;
}
tmp2 = TRI_Concatenate2String("collection-", tmp1);
if (tmp2 == NULL) {
TRI_FreeString(TRI_CORE_MEM_ZONE, tmp1);
TRI_set_errno(TRI_ERROR_OUT_OF_MEMORY);
return NULL;
}
filename = TRI_Concatenate2File(path, tmp2);
TRI_FreeString(TRI_CORE_MEM_ZONE, tmp1);
TRI_FreeString(TRI_CORE_MEM_ZONE, tmp2);
}
// oops, unknown collection type
else {
TRI_set_errno(TRI_ERROR_ARANGO_UNKNOWN_COLLECTION_TYPE);
return NULL;
}
if (filename == NULL) {
TRI_set_errno(TRI_ERROR_OUT_OF_MEMORY);
}
// might be NULL
return filename;
}
string homeDirectory () {
char* dir = TRI_HomeDirectory();
string result = dir;
TRI_FreeString(TRI_CORE_MEM_ZONE, dir);
return result;
}
int TRI_RemoveConfigurationReplicationApplier (TRI_vocbase_t* vocbase) {
char* filename;
int res;
if (vocbase->_type == TRI_VOCBASE_TYPE_COORDINATOR) {
return TRI_ERROR_CLUSTER_UNSUPPORTED;
}
filename = GetConfigurationFilename(vocbase);
if (filename == NULL) {
return TRI_ERROR_OUT_OF_MEMORY;
}
if (TRI_ExistsFile(filename)) {
res = TRI_UnlinkFile(filename);
}
else {
res = TRI_ERROR_NO_ERROR;
}
TRI_FreeString(TRI_CORE_MEM_ZONE, filename);
return res;
}
int TRI_SaveStateReplicationApplier (TRI_vocbase_t* vocbase,
TRI_replication_applier_state_t const* state,
bool doSync) {
TRI_json_t* json;
char* filename;
int res;
if (vocbase->_type == TRI_VOCBASE_TYPE_COORDINATOR) {
return TRI_ERROR_CLUSTER_UNSUPPORTED;
}
json = JsonApplyState(state);
if (json == nullptr) {
return TRI_ERROR_OUT_OF_MEMORY;
}
filename = GetStateFilename(vocbase);
LOG_TRACE("saving replication applier state to file '%s'", filename);
if (! TRI_SaveJson(filename, json, doSync)) {
res = TRI_errno();
}
else {
res = TRI_ERROR_NO_ERROR;
}
TRI_FreeString(TRI_CORE_MEM_ZONE, filename);
TRI_FreeJson(TRI_CORE_MEM_ZONE, json);
return res;
}
int TRI_RemoveStateReplicationApplier (TRI_vocbase_t* vocbase) {
char* filename;
int res;
if (vocbase->_type == TRI_VOCBASE_TYPE_COORDINATOR) {
return TRI_ERROR_CLUSTER_UNSUPPORTED;
}
filename = GetStateFilename(vocbase);
if (filename == nullptr) {
return TRI_ERROR_OUT_OF_MEMORY;
}
if (TRI_ExistsFile(filename)) {
LOG_TRACE("removing replication state file '%s'", filename);
res = TRI_UnlinkFile(filename);
}
else {
res = TRI_ERROR_NO_ERROR;
}
TRI_FreeString(TRI_CORE_MEM_ZONE, filename);
return res;
}
static mrb_value MR_JsonParse (mrb_state* mrb, mrb_value self) {
char* errmsg;
char* s;
/* int res; */
size_t l;
TRI_json_t* json;
/* res = */ mrb_get_args(mrb, "s", &s, &l);
if (s == NULL) {
return mrb_nil_value();
}
json = TRI_Json2String(TRI_UNKNOWN_MEM_ZONE, s, &errmsg);
if (json == NULL) {
mrb_value exc;
exc = MR_ArangoError(mrb, TRI_ERROR_HTTP_CORRUPTED_JSON, errmsg);
TRI_FreeString(TRI_UNKNOWN_MEM_ZONE, errmsg);
mrb_exc_raise(mrb, exc);
assert(false);
}
return MR_ObjectJson(mrb, json);
}
int TRI_SaveConfigurationReplicationApplier (TRI_vocbase_t* vocbase,
TRI_replication_applier_configuration_t const* config,
bool doSync) {
TRI_json_t* json;
char* filename;
int res;
json = JsonConfiguration(config, true);
if (json == NULL) {
return TRI_ERROR_OUT_OF_MEMORY;
}
filename = GetConfigurationFilename(vocbase);
if (! TRI_SaveJson(filename, json, doSync)) {
res = TRI_errno();
}
else {
res = TRI_ERROR_NO_ERROR;
}
TRI_FreeString(TRI_CORE_MEM_ZONE, filename);
TRI_FreeJson(TRI_CORE_MEM_ZONE, json);
return res;
}
static int SetError (TRI_replication_applier_t* applier,
int errorCode,
char const* msg) {
TRI_replication_applier_state_t* state;
char const* realMsg;
if (msg == NULL || strlen(msg) == 0) {
realMsg = TRI_errno_string(errorCode);
}
else {
realMsg = msg;
}
// log error message
if (errorCode != TRI_ERROR_REPLICATION_APPLIER_STOPPED) {
LOG_ERROR("replication applier error for database '%s': %s", applier->_databaseName, realMsg);
}
state = &applier->_state;
state->_lastError._code = errorCode;
TRI_GetTimeStampReplication(state->_lastError._time, sizeof(state->_lastError._time) - 1);
if (state->_lastError._msg != NULL) {
TRI_FreeString(TRI_CORE_MEM_ZONE, state->_lastError._msg);
}
state->_lastError._msg = TRI_DuplicateStringZ(TRI_CORE_MEM_ZONE, realMsg);
return errorCode;
}
char* TRI_RegisterStringAql (TRI_aql_context_t* const context,
const char* const value,
const size_t length,
const bool deescape) {
char* copy;
if (value == NULL) {
ABORT_OOM
}
if (deescape && length > 0) {
size_t outLength;
copy = TRI_UnescapeUtf8StringZ(TRI_UNKNOWN_MEM_ZONE, value, length, &outLength);
}
else {
copy = TRI_DuplicateString2Z(TRI_UNKNOWN_MEM_ZONE, value, length);
}
if (copy == NULL) {
ABORT_OOM
}
if (TRI_PushBackVectorPointer(&context->_memory._strings, copy) != TRI_ERROR_NO_ERROR) {
TRI_FreeString(TRI_UNKNOWN_MEM_ZONE, copy);
ABORT_OOM
}
int TRI_SaveStateReplicationApplier (TRI_vocbase_t* vocbase,
TRI_replication_applier_state_t const* state,
bool doSync) {
TRI_json_t* json;
char* filename;
int res;
json = JsonApplyState(state);
if (json == NULL) {
return TRI_ERROR_OUT_OF_MEMORY;
}
filename = GetStateFilename(vocbase);
LOG_TRACE("saving replication applier state to file '%s'", filename);
if (! TRI_SaveJson(filename, json, doSync)) {
res = TRI_errno();
}
else {
res = TRI_ERROR_NO_ERROR;
}
TRI_FreeString(TRI_CORE_MEM_ZONE, filename);
TRI_FreeJson(TRI_CORE_MEM_ZONE, json);
return res;
}
void TRI_SetProgressReplicationApplier (TRI_replication_applier_t* applier,
char const* msg,
bool lock) {
char* copy;
copy = TRI_DuplicateStringZ(TRI_CORE_MEM_ZONE, msg);
if (copy == NULL) {
return;
}
if (lock) {
TRI_WriteLockReadWriteLock(&applier->_statusLock);
}
if (applier->_state._progressMsg != NULL) {
TRI_FreeString(TRI_CORE_MEM_ZONE, applier->_state._progressMsg);
}
applier->_state._progressMsg = copy;
// write time in buffer
TRI_GetTimeStampReplication(applier->_state._progressTime, sizeof(applier->_state._progressTime) - 1);
if (lock) {
TRI_WriteUnlockReadWriteLock(&applier->_statusLock);
}
}
static int StopApplier (TRI_replication_applier_t* applier,
bool resetError) {
TRI_replication_applier_state_t* state;
state = &applier->_state;
if (! state->_active) {
return TRI_ERROR_INTERNAL;
}
state->_active = false;
SetTerminateFlag(applier, true);
TRI_SetProgressReplicationApplier(applier, "applier stopped", false);
if (resetError) {
if (state->_lastError._msg != NULL) {
TRI_FreeString(TRI_CORE_MEM_ZONE, state->_lastError._msg);
state->_lastError._msg = NULL;
}
state->_lastError._code = TRI_ERROR_NO_ERROR;
TRI_GetTimeStampReplication(state->_lastError._time, sizeof(state->_lastError._time) - 1);
}
TRI_LockCondition(&applier->_runStateChangeCondition);
TRI_SignalCondition(&applier->_runStateChangeCondition);
TRI_UnlockCondition(&applier->_runStateChangeCondition);
return TRI_ERROR_NO_ERROR;
}
char* TRI_GetContextErrorAql (const char* const query, const size_t line, const size_t column) {
const char* p;
char* temp;
char* result;
char c;
// note: line numbers reported by bison/flex start at 1, columns start at 0
size_t offset;
size_t currentLine = 1;
size_t currentColumn = 0;
assert(query);
p = query;
while ((c = *p)) {
if (currentLine > line || (currentLine >= line && currentColumn >= column)) {
break;
}
if (c == '\n') {
++p;
++currentLine;
currentColumn = 0;
}
else if (c == '\r') {
++p;
++currentLine;
currentColumn = 0;
if (*p == '\n') {
++p;
}
}
else {
++currentColumn;
++p;
}
}
// p is pointing at the position in the query the parse error occurred at
assert(p >= query);
offset = p - query;
if (strlen(query) < offset + SNIPPET_LENGTH) {
return TRI_DuplicateString2Z(TRI_UNKNOWN_MEM_ZONE, query + offset, strlen(query) - offset);
}
temp = TRI_DuplicateString2Z(TRI_UNKNOWN_MEM_ZONE, query + offset, SNIPPET_LENGTH);
if (!temp) {
// out of memory
return NULL;
}
result = TRI_Concatenate2StringZ(TRI_UNKNOWN_MEM_ZONE, temp, SNIPPET_SUFFIX);
TRI_FreeString(TRI_UNKNOWN_MEM_ZONE, temp);
return result;
}
int TRI_SaveCollectionInfo (char const* path, const TRI_col_info_t* const info) {
TRI_json_t* json;
char* filename;
bool ok;
filename = TRI_Concatenate2File(path, TRI_COL_PARAMETER_FILE);
// create a json info object
json = TRI_CreateArrayJson(TRI_UNKNOWN_MEM_ZONE);
if (json == NULL) {
// out of memory
LOG_ERROR("cannot save info block '%s': out of memory", filename);
TRI_FreeString(TRI_CORE_MEM_ZONE, filename);
return TRI_ERROR_OUT_OF_MEMORY;
}
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, "version", TRI_CreateNumberJson(TRI_UNKNOWN_MEM_ZONE, info->_version));
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, "type", TRI_CreateNumberJson(TRI_UNKNOWN_MEM_ZONE, info->_type));
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, "cid", TRI_CreateNumberJson(TRI_UNKNOWN_MEM_ZONE, info->_cid));
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, "deleted", TRI_CreateBooleanJson(TRI_UNKNOWN_MEM_ZONE, info->_deleted));
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, "maximalSize", TRI_CreateNumberJson(TRI_UNKNOWN_MEM_ZONE, info->_maximalSize));
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, "name", TRI_CreateStringCopyJson(TRI_UNKNOWN_MEM_ZONE, info->_name));
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, "isVolatile", TRI_CreateBooleanJson(TRI_UNKNOWN_MEM_ZONE, info->_isVolatile));
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, "waitForSync", TRI_CreateBooleanJson(TRI_UNKNOWN_MEM_ZONE, info->_waitForSync));
if (info->_keyOptions) {
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, "keyOptions", TRI_CopyJson(TRI_UNKNOWN_MEM_ZONE, info->_keyOptions));
}
// save json info to file
ok = TRI_SaveJson(filename, json);
TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, json);
if (! ok) {
LOG_ERROR("cannot save info block '%s': '%s'", filename, TRI_last_error());
TRI_FreeString(TRI_CORE_MEM_ZONE, filename);
return TRI_errno();
}
TRI_FreeString(TRI_CORE_MEM_ZONE, filename);
return TRI_ERROR_NO_ERROR;
}
static int StartApplier (TRI_replication_applier_t* applier,
TRI_voc_tick_t initialTick,
bool useTick) {
TRI_replication_applier_state_t* state;
void* fetcher;
state = &applier->_state;
if (state->_active) {
return TRI_ERROR_INTERNAL;
}
if (applier->_configuration._endpoint == NULL) {
return SetError(applier, TRI_ERROR_REPLICATION_INVALID_APPLIER_CONFIGURATION, "no endpoint configured");
}
if (applier->_configuration._database == NULL) {
return SetError(applier, TRI_ERROR_REPLICATION_INVALID_APPLIER_CONFIGURATION, "no database configured");
}
fetcher = (void*) TRI_CreateContinuousSyncerReplication(applier->_vocbase,
&applier->_configuration,
initialTick,
useTick);
if (fetcher == NULL) {
return TRI_ERROR_OUT_OF_MEMORY;
}
// reset error
if (state->_lastError._msg != NULL) {
TRI_FreeString(TRI_CORE_MEM_ZONE, state->_lastError._msg);
state->_lastError._msg = NULL;
}
state->_lastError._code = TRI_ERROR_NO_ERROR;
TRI_GetTimeStampReplication(state->_lastError._time, sizeof(state->_lastError._time) - 1);
SetTerminateFlag(applier, false);
state->_active = true;
TRI_InitThread(&applier->_thread);
if (! TRI_StartThread(&applier->_thread, "[applier]", ApplyThread, fetcher)) {
TRI_DeleteContinuousSyncerReplication(fetcher);
return TRI_ERROR_INTERNAL;
}
LOG_INFO("started replication applier for database '%s'",
applier->_databaseName);
return TRI_ERROR_NO_ERROR;
}
static int StartApplier (TRI_replication_applier_t* applier,
TRI_voc_tick_t initialTick,
bool useTick) {
TRI_replication_applier_state_t* state = &applier->_state;
if (state->_active) {
return TRI_ERROR_INTERNAL;
}
if (applier->_configuration._endpoint == nullptr) {
return SetError(applier, TRI_ERROR_REPLICATION_INVALID_APPLIER_CONFIGURATION, "no endpoint configured");
}
if (applier->_configuration._database == nullptr) {
return SetError(applier, TRI_ERROR_REPLICATION_INVALID_APPLIER_CONFIGURATION, "no database configured");
}
// TODO: prevent restart of the applier with a tick after a shutdown
auto fetcher = new triagens::arango::ContinuousSyncer(applier->_server,
applier->_vocbase,
&applier->_configuration,
initialTick,
useTick);
if (fetcher == nullptr) {
return TRI_ERROR_OUT_OF_MEMORY;
}
// reset error
if (state->_lastError._msg != nullptr) {
TRI_FreeString(TRI_CORE_MEM_ZONE, state->_lastError._msg);
state->_lastError._msg = nullptr;
}
state->_lastError._code = TRI_ERROR_NO_ERROR;
TRI_GetTimeStampReplication(state->_lastError._time, sizeof(state->_lastError._time) - 1);
SetTerminateFlag(applier, false);
state->_active = true;
TRI_InitThread(&applier->_thread);
if (! TRI_StartThread(&applier->_thread, nullptr, "[applier]", ApplyThread, static_cast<void*>(fetcher))) {
delete fetcher;
return TRI_ERROR_INTERNAL;
}
LOG_INFO("started replication applier for database '%s'",
applier->_databaseName);
return TRI_ERROR_NO_ERROR;
}
void TRI_DestroyReplicationApplier (TRI_replication_applier_t* applier) {
TRI_StopReplicationApplier(applier, true);
TRI_DestroyStateReplicationApplier(&applier->_state);
TRI_DestroyConfigurationReplicationApplier(&applier->_configuration);
TRI_FreeString(TRI_CORE_MEM_ZONE, applier->_databaseName);
TRI_DestroyCondition(&applier->_runStateChangeCondition);
TRI_DestroySpin(&applier->_threadLock);
TRI_DestroyReadWriteLock(&applier->_statusLock);
}
static void ScanPath (TRI_vocbase_t* vocbase, char const* path) {
TRI_vector_string_t files;
TRI_col_type_e type;
size_t n;
size_t i;
files = TRI_FilesDirectory(path);
n = files._length;
for (i = 0; i < n; ++i) {
char* name;
char* file;
name = files._buffer[i];
if (name[0] == '\0' || name[0] == '_' || name[0] == '.') {
continue;
}
file = TRI_Concatenate2File(path, name);
if (!file) {
continue;
}
if (TRI_IsDirectory(file)) {
TRI_col_info_t info;
bool ok;
ok = TRI_LoadParameterInfo(file, &info);
if (! ok) {
LOG_DEBUG("ignoring directory '%s' without valid parameter file '%s'", file, TRI_COL_PARAMETER_FILE);
}
else {
type = info._type;
if (type == TRI_COL_TYPE_SIMPLE_DOCUMENT) {
AddCollection(vocbase, type, info._name, info._cid, file);
LOG_DEBUG("added simple document collection from '%s'", file);
}
else {
LOG_DEBUG("skipping collection of unknown type %d", (int) type);
}
}
}
else {
LOG_DEBUG("ignoring non-directory '%s'", file);
}
TRI_FreeString(file);
}
TRI_DestroyVectorString(&files);
}
void TRI_DestroyConfigurationReplicationApplier (TRI_replication_applier_configuration_t* config) {
if (config->_endpoint != NULL) {
TRI_FreeString(TRI_CORE_MEM_ZONE, config->_endpoint);
config->_endpoint = NULL;
}
if (config->_database != NULL) {
TRI_FreeString(TRI_CORE_MEM_ZONE, config->_database);
config->_database = NULL;
}
if (config->_username != NULL) {
TRI_FreeString(TRI_CORE_MEM_ZONE, config->_username);
config->_username = NULL;
}
if (config->_password != NULL) {
TRI_FreeString(TRI_CORE_MEM_ZONE, config->_password);
config->_password = NULL;
}
}
void TRI_DestroyCollection (TRI_collection_t* collection) {
assert(collection);
TRI_FreeCollectionInfoOptions(&collection->_info);
FreeDatafilesVector(&collection->_datafiles);
FreeDatafilesVector(&collection->_journals);
FreeDatafilesVector(&collection->_compactors);
TRI_DestroyVectorString(&collection->_indexFiles);
TRI_FreeString(TRI_CORE_MEM_ZONE, collection->_directory);
}
void TRI_ShutdownProcess () {
TRI_FreeString(TRI_CORE_MEM_ZONE, ProcessName);
#ifdef TRI_TAMPER_WITH_ENVIRON
if (MustFreeEnvironment) {
size_t i = 0;
TRI_ASSERT(environ);
// free all arguments copied for environ
while (environ[i]) {
TRI_FreeString(TRI_CORE_MEM_ZONE, environ[i]);
++i;
}
TRI_Free(TRI_CORE_MEM_ZONE, environ);
}
#endif
TRI_DestroyVectorPointer(&ExternalProcesses);
TRI_DestroyMutex(&ExternalProcessesLock);
}
bool TRI_ExecuteRubyFile (mrb_state* mrb, char const* filename) {
bool ok;
char* content;
mrb_value result;
content = TRI_SlurpFile(TRI_UNKNOWN_MEM_ZONE, filename, NULL);
if (content == 0) {
LOG_TRACE("cannot loaded ruby file '%s': %s", filename, TRI_last_error());
return false;
}
ok = TRI_ExecuteRubyString(mrb, content, filename, false, &result);
TRI_FreeString(TRI_UNKNOWN_MEM_ZONE, content);
return ok;
}
bool TRI_ExecuteRubyDirectory (mrb_state* mrb, char const* path) {
TRI_vector_string_t files;
bool result;
regex_t re;
size_t i;
LOG_TRACE("loading ruby script directory: '%s'", path);
files = TRI_FilesDirectory(path);
regcomp(&re, "^(.*)\\.rb$", REG_ICASE | REG_EXTENDED);
result = true;
for (i = 0; i < files._length; ++i) {
bool ok;
char const* filename;
char* full;
filename = files._buffer[i];
if (! regexec(&re, filename, 0, 0, 0) == 0) {
continue;
}
full = TRI_Concatenate2File(path, filename);
ok = TRI_ExecuteRubyFile(mrb, full);
TRI_FreeString(TRI_CORE_MEM_ZONE, full);
result = result && ok;
if (! ok) {
TRI_LogRubyException(mrb, mrb->exc);
}
}
TRI_DestroyVectorString(&files);
regfree(&re);
return result;
}
int TRI_RemoveConfigurationReplicationApplier (TRI_vocbase_t* vocbase) {
char* filename;
int res;
filename = GetConfigurationFilename(vocbase);
if (filename == NULL) {
return TRI_ERROR_OUT_OF_MEMORY;
}
if (TRI_ExistsFile(filename)) {
res = TRI_UnlinkFile(filename);
}
else {
res = TRI_ERROR_NO_ERROR;
}
TRI_FreeString(TRI_CORE_MEM_ZONE, filename);
return res;
}
int TRI_RemoveStateReplicationApplier (TRI_vocbase_t* vocbase) {
char* filename;
int res;
filename = GetStateFilename(vocbase);
if (filename == NULL) {
return TRI_ERROR_OUT_OF_MEMORY;
}
if (TRI_ExistsFile(filename)) {
LOG_TRACE("removing replication state file '%s'", filename);
res = TRI_UnlinkFile(filename);
}
else {
res = TRI_ERROR_NO_ERROR;
}
TRI_FreeString(TRI_CORE_MEM_ZONE, filename);
return res;
}
void TRI_FreeBindParametersAql (TRI_aql_context_t* const context) {
size_t i;
size_t n;
// iterate thru all parameters allocated
n = context->_parameters._values._nrAlloc;
for (i = 0; i < n; ++i) {
TRI_aql_bind_parameter_t* parameter;
parameter = (TRI_aql_bind_parameter_t*) context->_parameters._values._table[i];
if (!parameter) {
continue;
}
assert(parameter->_name);
assert(parameter->_value);
TRI_FreeString(TRI_UNKNOWN_MEM_ZONE, parameter->_name);
TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, parameter->_value);
TRI_Free(TRI_UNKNOWN_MEM_ZONE, parameter);
}
}
