Experiment::Experiment(const QJsonObject &jo, const QVector<DataSeries *> &descs, const Environments& envs)
: wasRun(false), data(descs)
{
title = jo["title"].toString();
prepare = jo["prepare"].toString();
cleanup = jo["cleanup"].toString();
command = jo["command"].toString();
for (QJsonValueRef o : jo["environment_sets"].toArray()) {
EnvironmentSet* s = envs.findSet(o.toString());
if (s == nullptr) {
qWarning() << "Unknown environment set for Experiment " << title << "Broken file?";
} else {
envSets.append(envs.findSet(o.toString()));
}
}
for (QJsonValueRef v : jo["environments"].toArray()) {
const QJsonObject& o = v.toObject();
Environment* e = new Environment(o);
if (o.contains("runs")) {
for (QJsonValueRef vr : o["runs"].toArray()) {
QJsonObject ro = vr.toObject();
QPair<double,double> v(ro["from"].toDouble(),ro["to"].toDouble());
runs[e].push_back(v);
}
wasRun = true;
}
}
cooldown_time = jo["cooldown_time"].toInt();
tail_time = jo["tail_time"].toInt();
}
Environments
parse_icecc_version(const string &target_platform )
{
Environments envs;
string icecc_version = getenv( "ICECC_VERSION");
assert( !icecc_version.empty() );
// free after the C++-Programming-HOWTO
string::size_type lastPos = icecc_version.find_first_not_of(',', 0);
string::size_type pos = icecc_version.find_first_of(',', lastPos);
list<string> platforms;
while (pos != string::npos || lastPos != string::npos)
{
string couple = icecc_version.substr(lastPos, pos - lastPos);
string platform = target_platform;
string version = couple;
string::size_type colon = couple.find( ':' );
if ( colon != string::npos ) {
platform = couple.substr( 0, colon );
version = couple.substr( colon + 1, couple.length() );
}
// Skip delimiters. Note the "not_of"
lastPos = icecc_version.find_first_not_of(',', pos);
// Find next "non-delimiter"
pos = icecc_version.find_first_of(',', lastPos);
if (find(platforms.begin(), platforms.end(), platform) != platforms.end()) {
log_error() << "there are two environments for platform " << platform << " - ignoring " << version << endl;
continue;
}
if ( ::access( version.c_str(), R_OK ) ) {
log_error() << "$ICECC_VERSION has to point to an existing file to be installed " << version << endl;
continue;
}
struct stat st;
if ( lstat( version.c_str(), &st ) || !S_ISREG( st.st_mode ) || st.st_size < 500 ) {
log_error() << "$ICECC_VERSION has to point to an existing file to be installed " << version << endl;
continue;
}
envs.push_back(make_pair( platform, version ) );
platforms.push_back(platform);
}
return envs;
}
static Environments
rip_out_paths(const Environments &envs, map<string, string> &version_map, map<string, string> &versionfile_map)
{
version_map.clear();
Environments env2;
static const char *suffs[] = { ".tar.bz2", ".tar.gz", ".tar", ".tgz", NULL };
string versfile;
for (Environments::const_iterator it = envs.begin(); it != envs.end(); ++it) {
for (int i = 0; suffs[i] != NULL; i++)
if (endswith(it->second, suffs[i], versfile)) {
versionfile_map[it->first] = it->second;
versfile = find_basename(versfile);
version_map[it->first] = versfile;
env2.push_back(make_pair(it->first, versfile));
}
}
return env2;
}
static void list_target_dirs( const string ¤t_target, const string &targetdir, Environments &envs )
{
DIR *envdir = opendir( targetdir.c_str() );
if ( !envdir )
return;
for ( struct dirent *ent = readdir(envdir); ent; ent = readdir( envdir ) )
{
string dirname = ent->d_name;
if ( !access( string( targetdir + "/" + dirname + "/usr/bin/gcc" ).c_str(), X_OK ) )
envs.push_back( make_pair( current_target, dirname ) );
}
closedir( envdir );
}
int build_remote(CompileJob &job, MsgChannel *local_daemon, const Environments &_envs, int permill )
{
srand( time( 0 ) + getpid() );
int torepeat = 1;
// older compilers do not support the options we need to make it reproducible
#if defined(__GNUC__) && ( ( (__GNUC__ == 3) && (__GNUC_MINOR__ >= 3) ) || (__GNUC__ >=4) )
if (!compiler_is_clang(job)) {
if ( rand() % 1000 < permill)
torepeat = 3;
}
#endif
trace() << job.inputFile() << " compiled " << torepeat << " times on " << job.targetPlatform() << "\n";
map<string, string> versionfile_map, version_map;
Environments envs = rip_out_paths( _envs, version_map, versionfile_map );
if (!envs.size()) {
log_error() << "$ICECC_VERSION needs to point to .tar files\n";
throw(22);
}
const char *preferred_host = getenv("ICECC_PREFERRED_HOST");
if ( torepeat == 1 ) {
string fake_filename;
list<string> args = job.remoteFlags();
for ( list<string>::const_iterator it = args.begin(); it != args.end(); ++it )
fake_filename += "/" + *it;
args = job.restFlags();
for ( list<string>::const_iterator it = args.begin(); it != args.end(); ++it )
fake_filename += "/" + *it;
fake_filename += get_absfilename( job.inputFile() );
GetCSMsg getcs (envs, fake_filename, job.language(), torepeat,
job.targetPlatform(), job.argumentFlags(),
preferred_host ? preferred_host : string(),
ignore_unverified());
if (!local_daemon->send_msg (getcs)) {
log_warning() << "asked for CS\n";
throw( 24 );
}
UseCSMsg *usecs = get_server( local_daemon );
int ret;
if (!maybe_build_local (local_daemon, usecs, job, ret))
ret = build_remote_int( job, usecs, local_daemon,
version_map[usecs->host_platform],
versionfile_map[usecs->host_platform],
0, true );
delete usecs;
return ret;
} else
{
char *preproc = 0;
dcc_make_tmpnam( "icecc", ".ix", &preproc, 0 );
const CharBufferDeleter preproc_holder(preproc);
int cpp_fd = open(preproc, O_WRONLY );
/* When call_cpp returns normally (for the parent) it will have closed
the write fd, i.e. cpp_fd. */
pid_t cpp_pid = call_cpp(job, cpp_fd );
if ( cpp_pid == -1 ) {
::unlink( preproc );
throw( 10 );
}
int status = 255;
waitpid( cpp_pid, &status, 0);
if ( shell_exit_status(status) ) { // failure
::unlink( preproc );
return shell_exit_status( status );
}
char rand_seed[400]; // "designed to be oversized" (Levi's)
sprintf( rand_seed, "-frandom-seed=%d", rand() );
job.appendFlag( rand_seed, Arg_Remote );
GetCSMsg getcs (envs, get_absfilename( job.inputFile() ), job.language(), torepeat,
job.targetPlatform(), job.argumentFlags(), preferred_host ? preferred_host : string(),
ignore_unverified());
if (!local_daemon->send_msg (getcs)) {
log_warning() << "asked for CS\n";
throw( 0 );
}
map<pid_t, int> jobmap;
CompileJob *jobs = new CompileJob[torepeat];
UseCSMsg **umsgs = new UseCSMsg*[torepeat];
bool misc_error = false;
int *exit_codes = new int[torepeat];
for ( int i = 0; i < torepeat; i++ ) // init
exit_codes[i] = 42;
for ( int i = 0; i < torepeat; i++ ) {
jobs[i] = job;
char *buffer = 0;
if ( i ) {
dcc_make_tmpnam( "icecc", ".o", &buffer, 0 );
jobs[i].setOutputFile( buffer );
} else
buffer = strdup( job.outputFile().c_str() );
const CharBufferDeleter buffer_holder( buffer );
umsgs[i] = get_server( local_daemon );
remote_daemon = umsgs[i]->hostname;
trace() << "got_server_for_job " << umsgs[i]->hostname << endl;
flush_debug();
pid_t pid = fork();
if ( !pid ) {
int ret = 42;
try {
if (!maybe_build_local (local_daemon, umsgs[i], jobs[i], ret))
ret = build_remote_int(
jobs[i], umsgs[i], local_daemon,
version_map[umsgs[i]->host_platform],
versionfile_map[umsgs[i]->host_platform],
preproc, i == 0 );
} catch ( int error ) {
log_info() << "build_remote_int failed and has thrown " << error << endl;
kill( getpid(), SIGTERM );
return 0; // shouldn't matter
}
_exit( ret );
return 0; // doesn't matter
} else {
jobmap[pid] = i;
}
}
for ( int i = 0; i < torepeat; i++ ) {
pid_t pid = wait( &status );
if ( pid < 0 ) {
log_perror( "wait failed" );
status = -1;
} else {
if ( WIFSIGNALED( status ) )
{
// there was some misc error in processing
misc_error = true;
break;
}
exit_codes[jobmap[pid]] = shell_exit_status( status );
}
}
if (! misc_error ) {
string first_md5 = md5_for_file( jobs[0].outputFile() );
for ( int i = 1; i < torepeat; i++ ) {
if ( !exit_codes[0] ) { // if the first failed, we fail anyway
if ( exit_codes[i] == 42 ) // they are free to fail for misc reasons
continue;
if ( exit_codes[i] ) {
log_error() << umsgs[i]->hostname << " compiled with exit code " << exit_codes[i]
<< " and " << umsgs[0]->hostname << " compiled with exit code " << exit_codes[0] << " - aborting!\n";
::unlink( jobs[0].outputFile().c_str());
exit_codes[0] = -1; // overwrite
break;
}
string other_md5 = md5_for_file( jobs[i].outputFile() );
if ( other_md5 != first_md5 ) {
log_error() << umsgs[i]->hostname << " compiled " << jobs[0].outputFile() << " with md5 sum " << other_md5 << "(" << jobs[i].outputFile() << ")"
<< " and " << umsgs[0]->hostname << " compiled with md5 sum " << first_md5 << " - aborting!\n";
rename( jobs[0].outputFile().c_str(), ( jobs[0].outputFile() + ".caught" ).c_str() );
rename( preproc, ( string( preproc ) + ".caught" ).c_str() );
exit_codes[0] = -1; // overwrite
break;
}
}
::unlink( jobs[i].outputFile().c_str() );
delete umsgs[i];
}
} else {
::unlink( jobs[0].outputFile().c_str() );
for ( int i = 1; i < torepeat; i++ ) {
::unlink( jobs[i].outputFile().c_str());
delete umsgs[i];
}
}
delete umsgs[0];
::unlink( preproc );
int ret = exit_codes[0];
delete [] umsgs;
delete [] jobs;
delete [] exit_codes;
if ( misc_error )
throw ( 27 );
return ret;
}
return 0;
}
int main(int argc, char **argv)
{
char *env = getenv("ICECC_DEBUG");
int debug_level = Error;
if (env) {
if (!strcasecmp(env, "info")) {
debug_level |= Info | Warning;
} else if (!strcasecmp(env, "warnings")) {
debug_level |= Warning; // taking out warning
} else { // any other value
debug_level |= Info | Debug | Warning;
}
}
std::string logfile;
if (const char *logfileEnv = getenv("ICECC_LOGFILE")) {
logfile = logfileEnv;
}
setup_debug(debug_level, logfile, "ICECC");
CompileJob job;
bool icerun = false;
string compiler_name = argv[0];
dcc_client_catch_signals();
char cwd[ PATH_MAX ];
if( getcwd( cwd, PATH_MAX ) != NULL )
job.setWorkingDirectory( cwd );
if (find_basename(compiler_name) == rs_program_name) {
if (argc > 1) {
string arg = argv[1];
if (arg == "--help") {
dcc_show_usage();
return 0;
}
if (arg == "--version") {
printf("ICECC " VERSION "\n");
return 0;
}
if (arg == "--build-native") {
return create_native(argv + 2);
}
if (arg.size() > 0) {
job.setCompilerName(arg);
job.setCompilerPathname(arg);
}
}
} else if (find_basename(compiler_name) == "icerun") {
icerun = true;
if (argc > 1) {
string arg = argv[1];
if (arg == "--help") {
icerun_show_usage();
return 0;
}
if (arg == "--version") {
printf("ICERUN " VERSION "\n");
return 0;
}
if (arg.size() > 0) {
job.setCompilerName(arg);
job.setCompilerPathname(arg);
}
}
} else {
std::string resolved;
// check if it's a symlink to icerun
if (resolve_link(compiler_name, resolved) == 0 && find_basename(resolved) == "icerun") {
icerun = true;
}
}
int sg_level = dcc_recursion_safeguard();
if (sg_level > 0) {
log_error() << "icecream seems to have invoked itself recursively!" << endl;
return EXIT_RECURSION;
}
/* Ignore SIGPIPE; we consistently check error codes and will
* see the EPIPE. */
dcc_ignore_sigpipe(1);
list<string> extrafiles;
local |= analyse_argv(argv, job, icerun, &extrafiles);
/* If ICECC is set to disable, then run job locally, without contacting
the daemon at all. Because of file-based locking that is used in this
case, all calls will be serialized and run by one.
If ICECC is set to no, the job is run locally as well, but it is
serialized using the daemon, so several may be run at once.
*/
char *icecc = getenv("ICECC");
if (icecc && !strcasecmp(icecc, "disable")) {
return build_local(job, 0);
}
if (icecc && !strcasecmp(icecc, "no")) {
local = true;
}
if (const char *extrafilesenv = getenv("ICECC_EXTRAFILES")) {
for (;;) {
const char *colon = strchr(extrafilesenv, ':');
string file;
if (colon == NULL) {
file = extrafilesenv;
} else {
file = string(extrafilesenv, colon - extrafilesenv);
}
file = get_absfilename(file);
struct stat st;
if (stat(file.c_str(), &st) == 0) {
extrafiles.push_back(file);
} else {
log_warning() << "File in ICECC_EXTRAFILES not found: " << file << endl;
return build_local(job, 0);
}
if (colon == NULL) {
break;
}
extrafilesenv = colon + 1;
}
}
MsgChannel *local_daemon;
if (getenv("ICECC_TEST_SOCKET") == NULL) {
/* try several options to reach the local daemon - 3 sockets, one TCP */
local_daemon = Service::createChannel("/var/run/icecc/iceccd.socket");
if (!local_daemon) {
local_daemon = Service::createChannel("/var/run/iceccd.socket");
}
if (!local_daemon && getenv("HOME")) {
string path = getenv("HOME");
path += "/.iceccd.socket";
local_daemon = Service::createChannel(path);
}
if (!local_daemon) {
local_daemon = Service::createChannel("127.0.0.1", 10245, 0/*timeout*/);
}
} else {
local_daemon = Service::createChannel(getenv("ICECC_TEST_SOCKET"));
if (!local_daemon) {
log_error() << "test socket error" << endl;
return EXIT_TEST_SOCKET_ERROR;
}
}
if (!local_daemon) {
log_warning() << "no local daemon found" << endl;
return build_local(job, 0);
}
Environments envs;
if (!local) {
if (getenv("ICECC_VERSION")) { // if set, use it, otherwise take default
try {
envs = parse_icecc_version(job.targetPlatform(), find_prefix(job.compilerName()));
} catch (int x) {
// we just build locally
}
} else if (!extrafiles.empty() && !IS_PROTOCOL_32(local_daemon)) {
log_warning() << "Local daemon is too old to handle compiler plugins." << endl;
local = true;
} else {
if (!local_daemon->send_msg(GetNativeEnvMsg(compiler_is_clang(job)
? "clang" : "gcc", extrafiles))) {
log_warning() << "failed to write get native environment" << endl;
goto do_local_error;
}
// the timeout is high because it creates the native version
Msg *umsg = local_daemon->get_msg(4 * 60);
string native;
if (umsg && umsg->type == M_NATIVE_ENV) {
native = static_cast<UseNativeEnvMsg*>(umsg)->nativeVersion;
}
if (native.empty() || ::access(native.c_str(), R_OK)) {
log_warning() << "daemon can't determine native environment. "
"Set $ICECC_VERSION to an icecc environment.\n";
} else {
envs.push_back(make_pair(job.targetPlatform(), native));
log_info() << "native " << native << endl;
}
delete umsg;
}
// we set it to local so we tell the local daemon about it - avoiding file locking
if (envs.size() == 0) {
local = true;
}
for (Environments::const_iterator it = envs.begin(); it != envs.end(); ++it) {
trace() << "env: " << it->first << " '" << it->second << "'" << endl;
if (::access(it->second.c_str(), R_OK)) {
log_error() << "can't read environment " << it->second << endl;
local = true;
}
}
}
int ret;
if (local) {
log_block b("building_local");
struct rusage ru;
Msg *startme = 0L;
/* Inform the daemon that we like to start a job. */
if (local_daemon->send_msg(JobLocalBeginMsg(0, get_absfilename(job.outputFile())))) {
/* Now wait until the daemon gives us the start signal. 40 minutes
should be enough for all normal compile or link jobs. */
startme = local_daemon->get_msg(40 * 60);
}
/* If we can't talk to the daemon anymore we need to fall back
to lock file locking. */
if (!startme || startme->type != M_JOB_LOCAL_BEGIN) {
goto do_local_error;
}
ret = build_local(job, local_daemon, &ru);
} else {
try {
// check if it should be compiled three times
const char *s = getenv("ICECC_REPEAT_RATE");
int rate = s ? atoi(s) : 0;
ret = build_remote(job, local_daemon, envs, rate);
/* We have to tell the local daemon that everything is fine and
that the remote daemon will send the scheduler our done msg.
If we don't, the local daemon will have to assume the job failed
and tell the scheduler - and that fail message may arrive earlier
than the remote daemon's success msg. */
if (ret == 0) {
local_daemon->send_msg(EndMsg());
}
} catch (int error) {
if (error >= 100) {
log_info() << "local build forced by error " << error << endl;
goto do_local_error;
}
if (remote_daemon.size()) {
log_error() << "got exception " << error
<< " (" << remote_daemon.c_str() << ") " << endl;
} else {
log_error() << "got exception " << error << " (this should be an exception!)" <<
endl;
}
/* currently debugging a client? throw an error then */
if (debug_level != Error) {
return error;
}
goto do_local_error;
}
}
delete local_daemon;
return ret;
do_local_error:
delete local_daemon;
return build_local(job, 0);
}
