int TRI_LoadStateReplicationApplier (TRI_vocbase_t* vocbase,
TRI_replication_applier_state_t* state) {
TRI_json_t* json;
TRI_json_t* serverId;
char* filename;
int res;
TRI_InitStateReplicationApplier(state);
filename = GetStateFilename(vocbase);
if (filename == NULL) {
return TRI_ERROR_OUT_OF_MEMORY;
}
LOG_TRACE("looking for replication state file '%s'", filename);
if (! TRI_ExistsFile(filename)) {
TRI_FreeString(TRI_CORE_MEM_ZONE, filename);
return TRI_ERROR_FILE_NOT_FOUND;
}
LOG_TRACE("replication state file '%s' found", filename);
json = TRI_JsonFile(TRI_CORE_MEM_ZONE, filename, NULL);
TRI_FreeString(TRI_CORE_MEM_ZONE, filename);
if (! TRI_IsArrayJson(json)) {
if (json != NULL) {
TRI_FreeJson(TRI_CORE_MEM_ZONE, json);
}
return TRI_ERROR_REPLICATION_INVALID_APPLIER_STATE;
}
res = TRI_ERROR_NO_ERROR;
// read the server id
serverId = TRI_LookupArrayJson(json, "serverId");
if (! TRI_IsStringJson(serverId)) {
res = TRI_ERROR_REPLICATION_INVALID_APPLIER_STATE;
}
else {
state->_serverId = TRI_UInt64String2(serverId->_value._string.data,
serverId->_value._string.length - 1);
}
if (res == TRI_ERROR_NO_ERROR) {
// read the ticks
res |= ReadTick(json, "lastAppliedContinuousTick", &state->_lastAppliedContinuousTick);
// set processed = applied
state->_lastProcessedContinuousTick = state->_lastAppliedContinuousTick;
}
TRI_FreeJson(TRI_CORE_MEM_ZONE, json);
LOG_TRACE("replication state file read successfully");
return res;
}
static int LoadConfiguration (TRI_vocbase_t* vocbase,
TRI_replication_applier_configuration_t* config) {
TRI_json_t* json;
TRI_json_t* value;
char* filename;
int res;
TRI_DestroyConfigurationReplicationApplier(config);
TRI_InitConfigurationReplicationApplier(config);
filename = GetConfigurationFilename(vocbase);
if (! TRI_ExistsFile(filename)) {
TRI_FreeString(TRI_CORE_MEM_ZONE, filename);
return TRI_ERROR_FILE_NOT_FOUND;
}
json = TRI_JsonFile(TRI_CORE_MEM_ZONE, filename, NULL);
TRI_FreeString(TRI_CORE_MEM_ZONE, filename);
if (! TRI_IsArrayJson(json)) {
if (json != NULL) {
TRI_FreeJson(TRI_CORE_MEM_ZONE, json);
}
return TRI_ERROR_REPLICATION_INVALID_APPLIER_CONFIGURATION;
}
res = TRI_ERROR_NO_ERROR;
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;
}
// read the endpoint
value = TRI_LookupArrayJson(json, "endpoint");
if (! TRI_IsStringJson(value)) {
res = TRI_ERROR_REPLICATION_INVALID_APPLIER_CONFIGURATION;
}
else {
config->_endpoint = TRI_DuplicateString2Z(TRI_CORE_MEM_ZONE,
value->_value._string.data,
value->_value._string.length - 1);
}
// read the database name
value = TRI_LookupArrayJson(json, "database");
if (! TRI_IsStringJson(value)) {
config->_database = TRI_DuplicateStringZ(TRI_CORE_MEM_ZONE,
vocbase->_name);
}
else {
config->_database = TRI_DuplicateString2Z(TRI_CORE_MEM_ZONE,
value->_value._string.data,
value->_value._string.length - 1);
}
// read username / password
value = TRI_LookupArrayJson(json, "username");
if (TRI_IsStringJson(value)) {
config->_username = TRI_DuplicateString2Z(TRI_CORE_MEM_ZONE,
value->_value._string.data,
value->_value._string.length - 1);
}
value = TRI_LookupArrayJson(json, "password");
if (TRI_IsStringJson(value)) {
config->_password = TRI_DuplicateString2Z(TRI_CORE_MEM_ZONE,
value->_value._string.data,
value->_value._string.length - 1);
}
value = TRI_LookupArrayJson(json, "requestTimeout");
if (TRI_IsNumberJson(value)) {
config->_requestTimeout = value->_value._number;
}
value = TRI_LookupArrayJson(json, "connectTimeout");
if (TRI_IsNumberJson(value)) {
config->_connectTimeout = value->_value._number;
}
value = TRI_LookupArrayJson(json, "maxConnectRetries");
if (TRI_IsNumberJson(value)) {
config->_maxConnectRetries = (uint64_t) value->_value._number;
}
value = TRI_LookupArrayJson(json, "chunkSize");
if (TRI_IsNumberJson(value)) {
config->_chunkSize = (uint64_t) value->_value._number;
}
value = TRI_LookupArrayJson(json, "autoStart");
if (TRI_IsBooleanJson(value)) {
config->_autoStart = value->_value._boolean;
}
value = TRI_LookupArrayJson(json, "adaptivePolling");
if (TRI_IsBooleanJson(value)) {
config->_adaptivePolling = value->_value._boolean;
}
TRI_FreeJson(TRI_CORE_MEM_ZONE, json);
return res;
}
int TRI_LoadCollectionInfo (char const* path, TRI_col_info_t* parameter) {
TRI_json_t* json;
char* filename;
char* error = NULL;
size_t i;
size_t n;
memset(parameter, 0, sizeof(TRI_col_info_t));
// find parameter file
filename = TRI_Concatenate2File(path, TRI_COL_PARAMETER_FILE);
if (filename == NULL) {
LOG_ERROR("cannot load parameter info for collection '%s', out of memory", path);
return TRI_set_errno(TRI_ERROR_OUT_OF_MEMORY);
}
if (! TRI_ExistsFile(filename)) {
TRI_FreeString(TRI_CORE_MEM_ZONE, filename);
return TRI_set_errno(TRI_ERROR_ARANGO_ILLEGAL_PARAMETER_FILE);
}
json = TRI_JsonFile(TRI_UNKNOWN_MEM_ZONE, filename, &error);
if (json == NULL) {
if (error != NULL) {
LOG_ERROR("cannot open '%s', parameter block not readable: %s", filename, error);
TRI_FreeString(TRI_CORE_MEM_ZONE, error);
}
else {
LOG_ERROR("cannot open '%s', parameter block not readable", filename);
}
TRI_FreeString(TRI_CORE_MEM_ZONE, filename);
return TRI_set_errno(TRI_ERROR_ARANGO_ILLEGAL_PARAMETER_FILE);
}
if (json->_type != TRI_JSON_ARRAY) {
LOG_ERROR("cannot open '%s', file does not contain a json array", filename);
TRI_FreeString(TRI_CORE_MEM_ZONE, filename);
return TRI_set_errno(TRI_ERROR_ARANGO_ILLEGAL_PARAMETER_FILE);
}
TRI_FreeString(TRI_CORE_MEM_ZONE, filename);
// convert json
n = json->_value._objects._length;
for (i = 0; i < n; i += 2) {
TRI_json_t* key;
TRI_json_t* value;
key = TRI_AtVector(&json->_value._objects, i);
value = TRI_AtVector(&json->_value._objects, i + 1);
if (key->_type == TRI_JSON_STRING && value->_type == TRI_JSON_NUMBER) {
if (TRI_EqualString(key->_value._string.data, "version")) {
parameter->_version = value->_value._number;
}
else if (TRI_EqualString(key->_value._string.data, "type")) {
parameter->_type = value->_value._number;
}
else if (TRI_EqualString(key->_value._string.data, "cid")) {
parameter->_cid = value->_value._number;
}
else if (TRI_EqualString(key->_value._string.data, "maximalSize")) {
parameter->_maximalSize = value->_value._number;
}
}
else if (key->_type == TRI_JSON_STRING && value->_type == TRI_JSON_STRING) {
if (TRI_EqualString(key->_value._string.data, "name")) {
TRI_CopyString(parameter->_name, value->_value._string.data, sizeof(parameter->_name));
parameter->_isSystem = TRI_IsSystemCollectionName(parameter->_name);
}
}
else if (key->_type == TRI_JSON_STRING && value->_type == TRI_JSON_BOOLEAN) {
if (TRI_EqualString(key->_value._string.data, "deleted")) {
parameter->_deleted = value->_value._boolean;
}
else if (TRI_EqualString(key->_value._string.data, "isVolatile")) {
parameter->_isVolatile = value->_value._boolean;
}
else if (TRI_EqualString(key->_value._string.data, "waitForSync")) {
parameter->_waitForSync = value->_value._boolean;
}
}
else if (key->_type == TRI_JSON_STRING && value->_type == TRI_JSON_ARRAY) {
if (TRI_EqualString(key->_value._string.data, "keyOptions")) {
parameter->_keyOptions = TRI_CopyJson(TRI_UNKNOWN_MEM_ZONE, value);
}
}
}
TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, json);
return TRI_ERROR_NO_ERROR;
}
