int main(int argc, char* argv[])
{
std::string compiler;
std::string compilerPath;
Vstring linklineA;
extract_linker(compiler, compilerPath, linklineA);
Json json;
json.add("compiler", compiler);
json.add("compilerPath", compilerPath);
json.add("link_line", linklineA);
json.fini();
std::string jsonStr = json.result();
fprintf(stdout,"%s\n",jsonStr.c_str());
return 0;
}
/** If the configuration of this installation has not been reported for the
* current version, collect the hardware statistics and send it to STK's
* server.
*/
void reportHardwareStats()
{
// Version of the hw report, which is stored in the DB. If new fields
// are added, increase this version. Each STK installation will report
// its configuration only once (per version number). So if the version
// number is increased, a new report will be sent.
const int report_version = 1;
if(UserConfigParams::m_last_hw_report_version>=report_version) return;
while(UserConfigParams::m_random_identifier==0)
{
RandomGenerator rg;
UserConfigParams::m_random_identifier = rg.get(1<<30);
user_config->saveConfig();
}
Json json;
#ifdef WIN32
json.add("os_win", 1);
#else
json.add("os_win", 0);
#endif
#ifdef __APPLE__
json.add("os_macosx", 1);
#else
json.add("os_macosx", 0);
#endif
#ifdef __linux__
json.add("os_linux", 1);
json.add("os_unix", 1);
#else
json.add("os_linux", 0);
json.add("os_unix", 0);
#endif
#ifdef DEBUG
json.add("build_debug", 1);
#endif
json.add("os_version", getOSVersion());
unsigned int ogl_version = irr_driver->getGLSLVersion();
unsigned int major = ogl_version/100;
unsigned int minor = ogl_version - 100*major;
std::string version =
StringUtils::insertValues("%d.%d", major, minor);
json.add("GL_SHADING_LANGUAGE_VERSION", version);
std::string vendor, renderer, full_version;
irr_driver->getOpenGLData(&vendor, &renderer, &full_version);
json.add("GL_VENDOR", vendor );
json.add("GL_RENDERER", renderer );
json.add("GL_VERSION", full_version );
json.add("gfx_drv_ver", "OpenGL "+vendor);
std::string card_name = vendor;
if(StringUtils::startsWith(card_name, "ATI Technologies Inc."))
card_name="ATI";
else if (StringUtils::startsWith(card_name, "NVIDIA Corporation"))
card_name="NVIDIA";
else if(StringUtils::startsWith(card_name, "S3 Graphics"))
card_name="S3";
json.add("gfx_card", card_name+" "+renderer);
json.add("video_xres", UserConfigParams::m_width );
json.add("video_yres", UserConfigParams::m_height);
int mem = getRAM();
if(mem>0)
json.add("ram_total", mem);
int nr_procs = getNumProcessors();
if(nr_procs>0)
json.add("cpu_numprocs", nr_procs);
json.add("GL_EXTENSIONS", getGLExtensions());
getGLLimits(&json);
json.finish();
// ------------------------------------------------------------------------
/** A small class which sends the HW report to the STK server. On
* completion, it will either update the last-submitted-hw-report version,
* or log an error message (in which case next time STK is started it
* wil try again to log the report).
*/
class HWReportRequest : public Online::HTTPRequest
{
private:
/** Version number of the hw report. */
int m_version;
public:
HWReportRequest(int version) : Online::HTTPRequest(/*manage memory*/true, 1)
, m_version(version)
{}
// --------------------------------------------------------------------
/** Callback after the request has been executed.
*/
virtual void callback()
{
// If the request contains incorrect data, it will not have a
// download error, but return an error string as return value:
if(hadDownloadError() || getData()=="<h1>Bad Request (400)</h1>")
{
Log::error("HW report", "Error uploading the HW report.");
if(hadDownloadError())
Log::error("HW report", "%s", getDownloadErrorMessage());
else
Log::error("HW report", "%s", getData().c_str());
}
else
{
Log::info("HW report", "Upload successful.");
UserConfigParams::m_last_hw_report_version = m_version;
// The callback is executed by the main thread, so no need
// to worry about locks when writing the file.
user_config->saveConfig();
}
} // callback
}; // HWReportRequest
// ------------------------------------------------------------------------
Online::HTTPRequest *request = new HWReportRequest(report_version);
request->addParameter("user_id", UserConfigParams::m_random_identifier);
request->addParameter("time", StkTime::getTimeSinceEpoch());
request->addParameter("type", "hwdetect");
request->addParameter("version", report_version);
request->addParameter("data", json.toString());
request->setURL((std::string)UserConfigParams::m_server_hw_report+"/upload/v1/");
//request->setURL("http://127.0.0.1:8000/upload/v1/");
request->queue();
} // reportHardwareStats
int main(int argc, char* argv[])
{
const char* executable_tracking = getenv("XALT_EXECUTABLE_TRACKING");
if (executable_tracking == NULL || (strcmp(executable_tracking,"yes") != 0))
{
std::cout << "*------------------------------------------------------------------------------*\n";
std::cout << " Warning: XALT_EXECUTABLE_TRACKING is not set to \"yes\"!!\n";
std::cout << "\n";
std::cout << " XALT will not do anything without this variable\n";
std::cout << " set to \"yes\"\n";
std::cout << "*------------------------------------------------------------------------------*\n";
return 1;
}
std::string syshost(xalt_syshost());
std::string syslog_tag("XALT_LOGGING_");
syslog_tag.append(syshost);
Vstring resultA;
std::string cmd = XALT_DIR "/bin/xalt_print_os";
capture(cmd, resultA);
std::string current_os_descript = resultA[0];
char dateStr[dateSZ];
time_t now = (time_t) epoch();
strftime(dateStr,dateSZ, "%c", localtime(&now));
const char* transmission = getenv("XALT_TRANSMISSION_STYLE");
if (transmission == NULL)
transmission = TRANSMISSION;
if ((strcasecmp(transmission,"file") != 0 ) &&
(strcasecmp(transmission,"none") != 0 ) &&
(strcasecmp(transmission,"syslog") != 0 ) &&
(strcasecmp(transmission,"syslogv1") != 0 ) &&
(strcasecmp(transmission,"direct2db") != 0 ))
transmission = "file";
const char* computeSHA1 = getenv("XALT_COMPUTE_SHA1");
if (computeSHA1 == NULL)
computeSHA1 = XALT_COMPUTE_SHA1;
const char* xalt_etc_dir = getenv("XALT_ETC_DIR");
if (xalt_etc_dir == NULL)
xalt_etc_dir = XALT_ETC_DIR;
const char* xalt_mpi_tracking = getenv("XALT_MPI_TRACKING");
if (xalt_mpi_tracking == NULL)
xalt_mpi_tracking = XALT_MPI_TRACKING;
const char* xalt_gpu_tracking = getenv("XALT_GPU_TRACKING");
if (xalt_gpu_tracking == NULL)
xalt_gpu_tracking = XALT_GPU_TRACKING;
if (strcmp(HAVE_DCGM,"no") == 0)
xalt_gpu_tracking = HAVE_DCGM;
const char* xalt_func_tracking = getenv("XALT_FUNCTION_TRACKING");
if (xalt_func_tracking == NULL)
xalt_func_tracking = XALT_FUNCTION_TRACKING;
else if (strcmp(xalt_func_tracking,"no") != 0)
xalt_func_tracking = "yes";
const char* xalt_scalar_tracking = getenv("XALT_SCALAR_TRACKING");
if (xalt_scalar_tracking == NULL)
xalt_scalar_tracking = XALT_SCALAR_TRACKING;
const char* xalt_scalar_sampling = getenv("XALT_SCALAR_SAMPLING");
if (!xalt_scalar_sampling)
xalt_scalar_sampling = getenv("XALT_SCALAR_AND_SPSR_SAMPLING");
if (xalt_scalar_sampling == NULL || strcmp(xalt_scalar_sampling,"yes") != 0)
xalt_scalar_sampling = "no";
const char* xalt_preload_only = XALT_PRELOAD_ONLY;
std::string cxx_ld_library_path = CXX_LD_LIBRARY_PATH;
if (cxx_ld_library_path == "")
cxx_ld_library_path = "<empty>";
if (argc == 2 && strcmp(argv[1],"--json") == 0)
{
Json json;
json.add("DATE", dateStr);
json.add("XALT_EXECUTABLE_TRACKING", executable_tracking);
json.add("XALT_PRELOAD_ONLY", xalt_preload_only);
json.add("XALT_SYSHOST", syshost);
json.add("XALT_VERSION", XALT_VERSION);
json.add("XALT_INTERFACE_VERSION", XALT_INTERFACE_VERSION);
json.add("XALT_GIT_VERSION", XALT_GIT_VERSION);
json.add("XALT_VERSION_STR", XALT_VERSION_STR);
json.add("XALT_FILE_PREFIX", XALT_FILE_PREFIX);
json.add("XALT_TRANSMISSION_STYLE", transmission);
json.add("XALT_FUNCTION_TRACKING", xalt_func_tracking);
if (strcmp(transmission,"syslog") == 0)
json.add("XALT_LOGGING_TAG", syslog_tag);
json.add("XALT_COMPUTE_SHA1", computeSHA1);
json.add("XALT_ETC_DIR", xalt_etc_dir);
json.add("XALT_DIR", XALT_DIR);
json.add("BAD_INSTALL", BAD_INSTALL);
json.add("XALT_CONFIG_PY", XALT_CONFIG_PY);
json.add("XALT_SYSTEM_PATH", XALT_SYSTEM_PATH);
json.add("XALT_SYSHOST_CONFIG", SYSHOST_CONFIG);
json.add("XALT_MPI_TRACKING", xalt_mpi_tracking);
json.add("XALT_GPU_TRACKING", xalt_gpu_tracking);
json.add("XALT_SCALAR_TRACKING", xalt_scalar_tracking);
json.add("XALT_SCALAR_SAMPLING", xalt_scalar_sampling);
json.add("XALT_SYSLOG_MSG_SZ", SYSLOG_MSG_SZ);
json.add("XALT_INSTALL_OS", XALT_INSTALL_OS);
json.add("XALT_CURRENT_OS", current_os_descript);
json.add("CXX_LD_LIBRARY_PATH", cxx_ld_library_path);
json.add("HAVE_32BIT", HAVE_32BIT);
json.add("MY_HOSTNAME_PARSER", MY_HOSTNAME_PARSER);
json.add("HAVE_DCGM", HAVE_DCGM);
json.add("hostnameA", hostnameSz, hostnameA);
json.add("pathPatternA", pathPatternSz, pathPatternA);
json.add("envPatternA", envPatternSz, envPatternA);
json.fini();
std::string jsonStr = json.result();
std::cout << jsonStr << std::endl;
return 0;
}
std::cout << "*------------------------------------------------------------------------------*\n";
std::cout << " XALT Configuration Report\n";
std::cout << "*------------------------------------------------------------------------------*\n\n";
std::cout << "Today's DATE: " << dateStr << "\n";
std::cout << "XALT_VERSION: " << XALT_VERSION << "\n";
std::cout << "XALT_GIT_VERSION: " << XALT_GIT_VERSION << "\n";
std::cout << "XALT_VERSION_STR: " << XALT_VERSION_STR << "\n";
std::cout << "*------------------------------------------------------------------------------*\n";
std::cout << "XALT_EXECUTABLE_TRACKING: " << executable_tracking << "\n";
std::cout << "XALT_FUNCTION_TRACKING: " << xalt_func_tracking << "\n";
std::cout << "XALT_SYSHOST: " << syshost << "\n";
std::cout << "XALT_FILE_PREFIX: " << XALT_FILE_PREFIX << "\n";
std::cout << "XALT_INTERFACE_VERSION: " << XALT_INTERFACE_VERSION << "\n";
std::cout << "XALT_TRANSMISSION_STYLE: " << transmission << "\n";
if (strcmp(transmission,"syslog") == 0)
std::cout << "XALT_LOGGING_TAG: " << syslog_tag << "\n";
std::cout << "XALT_COMPUTE_SHA1: " << computeSHA1 << "\n";
std::cout << "XALT_ETC_DIR: " << xalt_etc_dir << "\n";
std::cout << "XALT_DIR: " << XALT_DIR << "\n";
std::cout << "BAD_INSTALL: " << BAD_INSTALL << "\n";
std::cout << "XALT_CONFIG_PY: " << XALT_CONFIG_PY << "\n";
std::cout << "XALT_MPI_TRACKING: " << xalt_mpi_tracking << "\n";
std::cout << "XALT_GPU_TRACKING: " << xalt_gpu_tracking << "\n";
std::cout << "XALT_SCALAR_TRACKING: " << xalt_scalar_tracking << "\n";
std::cout << "XALT_SCALAR_SAMPLING: " << xalt_scalar_sampling << "\n";
std::cout << "XALT_SYSTEM_PATH: " << XALT_SYSTEM_PATH << "\n";
std::cout << "XALT_SYSHOST_CONFIG: " << SYSHOST_CONFIG << "\n";
std::cout << "XALT_SYSLOG_MSG_SZ: " << SYSLOG_MSG_SZ << "\n";
std::cout << "CXX_LD_LIBRARY_PATH: " << cxx_ld_library_path << "\n";
std::cout << "XALT_INSTALL_OS: " << XALT_INSTALL_OS << "\n";
std::cout << "CURRENT_OS: " << current_os_descript << "\n";
std::cout << "XALT_PRELOAD_ONLY: " << XALT_PRELOAD_ONLY << "\n";
std::cout << "HAVE_32BIT: " << HAVE_32BIT << "\n";
std::cout << "MY_HOSTNAME_PARSER: " << MY_HOSTNAME_PARSER << "\n";
std::cout << "Built with DCGM: " << HAVE_DCGM << "\n";
std::cout << "*------------------------------------------------------------------------------*\n\n";
displayArray("hostnameA", hostnameSz, hostnameA);
std::cout << "\nRemember that \"PKGS\" means a program that can also track internal packages\n";
displayArray("pathPatternA", pathPatternSz, pathPatternA);
displayArray("envPatternA", envPatternSz, envPatternA);
std::cout << "*----------------------*\n";
std::cout << " Array: interval\n";
std::cout << "*----------------------*\n";
for (int i = 0; i < rangeSz-1; ++i)
std::cout << "Time Range(seconds): [" << rangeA[i].left << ", " << rangeA[i+1].left
<< "]: probability: "<< rangeA[i].prob << "\n";
std::cout << "\n";
return 0;
}
