/**
* Load the interfaces JVM properties file.
*/
static bool java_readJvmCfgFile(struct Properties* props) {
bool read = false;
const size_t props_sizeMax = 256;
props->size = 0;
props->keys = (const char**) calloc(props_sizeMax, sizeof(char*));
props->values = (const char**) calloc(props_sizeMax, sizeof(char*));
// ### read JVM options config file ###
char* jvmPropFile = callback->DataDirs_allocatePath(interfaceId,
JVM_PROPERTIES_FILE, false, false, false, false);
if (jvmPropFile == NULL) {
// if the version specific file does not exist,
// try to get the common one
jvmPropFile = callback->DataDirs_allocatePath(interfaceId,
JVM_PROPERTIES_FILE, false, false, false, true);
}
if (jvmPropFile != NULL) {
props->size = util_parsePropertiesFile(jvmPropFile,
props->keys, props->values, props_sizeMax);
read = true;
simpleLog_logL(SIMPLELOG_LEVEL_FINE,
"JVM: arguments loaded from: %s", jvmPropFile);
} else {
props->size = 0;
read = false;
simpleLog_logL(SIMPLELOG_LEVEL_FINE,
"JVM: arguments NOT loaded from: %s", jvmPropFile);
}
FREE(jvmPropFile);
return read;
}
EXPORT(int) initStatic(int _interfaceId,
const struct SAIInterfaceCallback* _callback) {
bool success = false;
// initialize C part of the interface
interfaceId = _interfaceId;
callback = _callback;
const char* const myShortName = callback->AIInterface_Info_getValueByKey(interfaceId,
AI_INTERFACE_PROPERTY_SHORT_NAME);
const char* const myVersion = callback->AIInterface_Info_getValueByKey(interfaceId,
AI_INTERFACE_PROPERTY_VERSION);
static const int maxProps = 64;
const char* propKeys[maxProps];
char* propValues[maxProps];
int numProps = 0;
// ### read the interface config file (optional) ###
static const unsigned int propFilePath_sizeMax = 1024;
char propFilePath[propFilePath_sizeMax];
// eg: "~/.spring/AI/Interfaces/Java/${INTERFACE_PROPERTIES_FILE}"
bool propFileFetched = callback->DataDirs_locatePath(interfaceId,
propFilePath, propFilePath_sizeMax,
INTERFACE_PROPERTIES_FILE, false, false, false, false);
if (!propFileFetched) {
// if the version specific file does not exist,
// try to get the common one
propFileFetched = callback->DataDirs_locatePath(interfaceId,
propFilePath, propFilePath_sizeMax,
INTERFACE_PROPERTIES_FILE, false, false, false, true);
}
if (propFileFetched) {
numProps = util_parsePropertiesFile(propFilePath,
propKeys, (const char**)propValues, maxProps);
static const unsigned int ddw_sizeMax = 1024;
char ddw[ddw_sizeMax];
// eg: "~/.spring/AI/Interfaces/Java/${INTERFACE_PROPERTIES_FILE}"
bool ddwFetched = callback->DataDirs_locatePath(interfaceId,
ddw, ddw_sizeMax,
"", true, true, true, false);
if (!ddwFetched) {
simpleLog_logL(SIMPLELOG_LEVEL_ERROR,
"Failed locating writeable data-dir \"%s\"", ddw);
}
int p;
for (p=0; p < numProps; ++p) {
char* propValue_tmp = util_allocStrReplaceStr(propValues[p],
"${home-dir}", ddw);
// char* propValue_tmp = util_allocStrReplaceStr(propValues[p],
// "${home-dir}/", "");
free(propValues[p]);
propValues[p] = propValue_tmp;
}
}
// ### try to fetch the log-level from the properties ###
int logLevel = SIMPLELOG_LEVEL_NORMAL;
const char* logLevel_str =
util_map_getValueByKey(numProps, propKeys, (const char**)propValues,
"log.level");
if (logLevel_str != NULL) {
int logLevel_tmp = atoi(logLevel_str);
if (logLevel_tmp >= SIMPLELOG_LEVEL_ERROR
&& logLevel_tmp <= SIMPLELOG_LEVEL_FINEST) {
logLevel = logLevel_tmp;
}
}
// ### try to fetch whether to use time-stamps from the properties ###
bool useTimeStamps = true;
const char* useTimeStamps_str =
util_map_getValueByKey(numProps, propKeys, (const char**)propValues,
"log.useTimeStamps");
if (useTimeStamps_str != NULL) {
useTimeStamps = util_strToBool(useTimeStamps_str);
}
// ### init the log file ###
char* logFile = util_allocStrCpy(
util_map_getValueByKey(numProps, propKeys, (const char**)propValues,
"log.file"));
if (logFile == NULL) {
logFile = util_allocStrCatFSPath(2, "log", MY_LOG_FILE);
}
static const unsigned int logFilePath_sizeMax = 1024;
char logFilePath[logFilePath_sizeMax];
// eg: "~/.spring/AI/Interfaces/Java/${INTERFACE_PROPERTIES_FILE}"
bool logFileFetched = callback->DataDirs_locatePath(interfaceId,
logFilePath, logFilePath_sizeMax,
logFile, true, true, false, false);
if (logFileFetched) {
simpleLog_init(logFilePath, useTimeStamps, logLevel, false);
} else {
simpleLog_logL(SIMPLELOG_LEVEL_ERROR,
"Failed initializing log-file \"%s\"", logFileFetched);
}
// log settings loaded from interface config file
if (propFileFetched) {
simpleLog_logL(SIMPLELOG_LEVEL_FINE, "settings loaded from: %s",
propFilePath);
int p;
for (p=0; p < numProps; ++p) {
simpleLog_logL(SIMPLELOG_LEVEL_FINE, "\t%i: %s = %s",
p, propKeys[p], propValues[p]);
}
} else {
simpleLog_logL(SIMPLELOG_LEVEL_FINE, "settings NOT loaded from: %s",
propFilePath);
}
simpleLog_log("This is the log-file of the %s v%s AI Interface",
myShortName, myVersion);
simpleLog_log("Using read/write data-directory: %s",
callback->DataDirs_getWriteableDir(interfaceId));
simpleLog_log("Using log file: %s", propFilePath);
FREE(logFile);
// initialize Java part of the interface
success = java_initStatic(interfaceId, callback);
// load the JVM
success = success && java_preloadJNIEnv();
if (success) {
simpleLog_logL(SIMPLELOG_LEVEL_FINE, "Initialization successfull.");
} else {
simpleLog_logL(SIMPLELOG_LEVEL_ERROR, "Initialization failed.");
}
return success ? 0 : -1;
}
//#define LOC_PROP_FILE
bool GetJREPathFromConfig(char* path, size_t pathSize, const char* configFile)
{
#if defined LOC_PROP_FILE
// assume the config file is in properties file format
// and that the property JRE_PATH_PROPERTY contains
// the absolute path to the JRE to use
static const size_t props_sizeMax = 64;
const char* props_keys[props_sizeMax];
const char* props_values[props_sizeMax];
const size_t props_size = util_parsePropertiesFile(configFile, props_keys,
props_values, props_sizeMax);
const char* jvmLocation = util_map_getValueByKey(
props_size, props_keys, props_values,
JRE_PATH_PROPERTY);
if (jvmLocation == NULL) {
simpleLog_logL(LOG_LEVEL_DEBUG, "JRE not found in config file!");
return false;
} else {
simpleLog_logL(LOG_LEVEL_NOTICE, "JRE found in config file!");
STRCPY_T(path, pathSize, jvmLocation);
return true;
}
#else // defined LOC_PROP_FILE
// assume the config file is a plain text file containing nothing but
// the absolute path to the JRE to use in the first line
bool found = false;
FILE* cfp = fopen(configFile, "r");
if (cfp == NULL) {
return found;
}
// parse results
static const size_t line_sizeMax = 1024;
char line[line_sizeMax];
if (fgets(line, line_sizeMax, cfp)) {
size_t line_size = strlen(line);
if (*(line+line_size-1) == '\n') {
// remove trailing '\n'
*(line+line_size-1) = '\0';
line_size--;
}
simpleLog_logL(LOG_LEVEL_NOTICE,
"Fetched JRE location from \"%s\"!", configFile);
if (line_size > 0 && *line == '/') {
*(line+line_size-1) = '\0'; // remove trailing '/'
}
STRCPY_T(path, pathSize, line);
found = true;
}
fclose(cfp);
return found;
#endif // defined LOC_PROP_FILE
}
