const char* util_getMyInfo(const char* key) {
return util_map_getValueByKey(myInfoSize, myInfoKeys, myInfoValues, key);
}
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;
}
static const char* java_getValueByKey(const struct Properties* props, const char* key) {
return util_map_getValueByKey(props->size, props->keys, props->values, key);
}
static bool java_createJavaVMInitArgs(struct JavaVMInitArgs* vm_args, const struct Properties* jvmProps) {
// ### evaluate JNI version to use ###
//jint jniVersion = JNI_VERSION_1_1;
//jint jniVersion = JNI_VERSION_1_2;
jint jniVersion = JNI_VERSION_1_4;
//jint jniVersion = JNI_VERSION_1_6;
if (jvmProps != NULL) {
const char* jniVersionFromCfg = java_getValueByKey(jvmProps,
"jvm.jni.version");
if (jniVersionFromCfg != NULL) {
unsigned long int jniVersion_tmp =
strtoul(jniVersionFromCfg, NULL, 16);
if (jniVersion_tmp != 0/* && jniVersion_tmp != ULONG_MAX*/) {
jniVersion = (jint) jniVersion_tmp;
}
}
}
simpleLog_logL(SIMPLELOG_LEVEL_FINE, "JVM: JNI version: %#x", jniVersion);
vm_args->version = jniVersion;
// ### check if debug related JVM options should be used ###
// if false, the JVM creation will fail if an
// unknown or invalid option was specified
bool useDebugOptions = true;
const char* useDebugOptionsStr = "auto";
if (jvmProps != NULL) {
const char* useDebugOptionsFromCfg =
util_map_getValueByKey(
jvmProps->size, jvmProps->keys, jvmProps->values,
"jvm.useDebugOptions");
if (useDebugOptionsFromCfg != NULL) {
useDebugOptionsStr = useDebugOptionsFromCfg;
}
}
{
if (strcmp(useDebugOptionsStr, "auto") == 0
|| strcmp(useDebugOptionsStr, "Auto") == 0
|| strcmp(useDebugOptionsStr, "AUTO") == 0
|| strcmp(useDebugOptionsStr, "a") == 0
|| strcmp(useDebugOptionsStr, "A") == 0)
{
// auto
#if defined DEBUG
useDebugOptions = true;
#else // defined DEBUG
useDebugOptions = false;
#endif // defined DEBUG
} else {
// true or false
useDebugOptions = util_strToBool(useDebugOptionsStr);
}
}
// ### check if unrecognized JVM options should be ignored ###
// if false, the JVM creation will fail if an
// unknown or invalid option was specified
bool ignoreUnrecognized = true;
if (jvmProps != NULL) {
const char* ignoreUnrecognizedFromCfg = java_getValueByKey(jvmProps,
"jvm.arguments.ignoreUnrecognized");
if (ignoreUnrecognizedFromCfg != NULL
&& !util_strToBool(ignoreUnrecognizedFromCfg)) {
ignoreUnrecognized = false;
}
}
if (ignoreUnrecognized) {
simpleLog_logL(SIMPLELOG_LEVEL_FINE,
"JVM: ignoring unrecognized options");
vm_args->ignoreUnrecognized = JNI_TRUE;
} else {
simpleLog_logL(SIMPLELOG_LEVEL_FINE,
"JVM: NOT ignoring unrecognized options");
vm_args->ignoreUnrecognized = JNI_FALSE;
}
// ### create the Java class-path option ###
// autogenerate the class path
static const size_t classPath_sizeMax = 8 * 1024;
char* classPath = util_allocStr(classPath_sizeMax);
// ..., autogenerate it ...
if (!java_createClassPath(classPath, classPath_sizeMax)) {
simpleLog_logL(SIMPLELOG_LEVEL_ERROR,
"Failed creating Java class-path.");
return false;
}
if (jvmProps != NULL) {
// ..., and append the part from the jvm options properties file,
// if it is specified there
const char* clsPathFromCfg = java_getValueByKey(jvmProps,
"jvm.option.java.class.path");
if (clsPathFromCfg != NULL) {
STRCATS(classPath, classPath_sizeMax, ENTRY_DELIM);
STRCATS(classPath, classPath_sizeMax, clsPathFromCfg);
}
}
// create the java.class.path option
static const size_t classPathOpt_sizeMax = 8 * 1024;
char* classPathOpt = util_allocStr(classPathOpt_sizeMax);
STRCPYS(classPathOpt, classPathOpt_sizeMax, "-Djava.class.path=");
STRCATS(classPathOpt, classPathOpt_sizeMax, classPath);
FREE(classPath);
// ### create the Java library-path option ###
// autogenerate the java library path
static const size_t libraryPath_sizeMax = 4 * 1024;
char* libraryPath = util_allocStr(libraryPath_sizeMax);
// ..., autogenerate it ...
if (!java_createNativeLibsPath(libraryPath, libraryPath_sizeMax)) {
simpleLog_logL(SIMPLELOG_LEVEL_ERROR,
"Failed creating Java library-path.");
return false;
}
if (jvmProps != NULL) {
// ..., and append the part from the jvm options properties file,
// if it is specified there
const char* libPathFromCfg = java_getValueByKey(jvmProps,
"jvm.option.java.library.path");
if (libPathFromCfg != NULL) {
STRCATS(libraryPath, libraryPath_sizeMax, ENTRY_DELIM);
STRCATS(libraryPath, libraryPath_sizeMax, libPathFromCfg);
}
}
// create the java.library.path option ...
// autogenerate it, and append the part from the jvm options file,
// if it is specified there
static const size_t libraryPathOpt_sizeMax = 4 * 1024;
char* libraryPathOpt = util_allocStr(libraryPathOpt_sizeMax);
STRCPYS(libraryPathOpt, libraryPathOpt_sizeMax, "-Djava.library.path=");
STRCATS(libraryPathOpt, libraryPathOpt_sizeMax, libraryPath);
FREE(libraryPath);
// ### create and set all JVM options ###
static const size_t strOptions_sizeMax = 64;
const char* strOptions[strOptions_sizeMax];
size_t op = 0;
strOptions[op++] = classPathOpt;
strOptions[op++] = libraryPathOpt;
static const char* const JCPVAL = "-Djava.class.path=";
const size_t JCPVAL_size = strlen(JCPVAL);
static const char* const JLPVAL = "-Djava.library.path=";
const size_t JLPVAL_size = strlen(JCPVAL);
if (jvmProps != NULL) {
// ### add string options from the JVM config file with property name "jvm.option.x" ###
int i;
for (i=0; i < jvmProps->size; ++i) {
if (strcmp(jvmProps->keys[i], "jvm.option.x") == 0 ||
(useDebugOptions && (strcmp(jvmProps->keys[i], "jvm.option.debug.x") == 0))) {
const char* const val = jvmProps->values[i];
const size_t val_size = strlen(val);
// ignore "-Djava.class.path=..."
// and "-Djava.library.path=..." options
if (strncmp(val, JCPVAL, minSize(val_size, JCPVAL_size)) != 0 &&
strncmp(val, JLPVAL, minSize(val_size, JLPVAL_size)) != 0) {
strOptions[op++] = val;
}
}
}
} else {
// ### ... or set default ones, if the JVM config file was not found ###
simpleLog_logL(SIMPLELOG_LEVEL_WARNING, "JVM: properties file ("JVM_PROPERTIES_FILE") not found; using default options.");
strOptions[op++] = "-Xms4M";
strOptions[op++] = "-Xmx64M";
strOptions[op++] = "-Xss512K";
strOptions[op++] = "-Xoss400K";
#if defined DEBUG
strOptions[op++] = "-Xcheck:jni";
strOptions[op++] = "-verbose:jni";
strOptions[op++] = "-XX:+UnlockDiagnosticVMOptions";
strOptions[op++] = "-XX:+LogVMOutput";
strOptions[op++] = "-Xdebug";
strOptions[op++] = "-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=7777";
// disable JIT (required for debugging under the classical VM)
strOptions[op++] = "-Djava.compiler=NONE";
// disable old JDB
strOptions[op++] = "-Xnoagent";
#endif // defined DEBUG
}
const size_t options_size = op;
vm_args->options = (struct JavaVMOption*) calloc(options_size, sizeof(struct JavaVMOption));
// fill strOptions into the JVM options
simpleLog_logL(SIMPLELOG_LEVEL_FINE, "JVM: options:", options_size);
char* dd_rw = callback->DataDirs_allocatePath(interfaceId,
"", true, true, true, false);
size_t i;
jint nOptions = 0;
for (i = 0; i < options_size; ++i) {
char* tmpOptionString = util_allocStrReplaceStr(strOptions[i],
"${home-dir}", dd_rw);
// do not add empty options
if (tmpOptionString != NULL) {
if (strlen(tmpOptionString) > 0) {
vm_args->options[nOptions].optionString = tmpOptionString;
vm_args->options[nOptions].extraInfo = NULL;
simpleLog_logL(SIMPLELOG_LEVEL_FINE, "JVM option %ul: %s", nOptions, tmpOptionString);
nOptions++;
} else {
free(tmpOptionString);
tmpOptionString = NULL;
}
}
}
vm_args->nOptions = nOptions;
FREE(dd_rw);
FREE(classPathOpt);
FREE(libraryPathOpt);
simpleLog_logL(SIMPLELOG_LEVEL_FINE, "");
return true;
}
const char* aiexport_getMyOption(int teamId, const char* key) {
return util_map_getValueByKey(
myOptionsSize[teamId],
myOptionsKeys[teamId], myOptionsValues[teamId],
key);
}
//#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
}
