int main(int argc, char **argv) {
//LOGFILE = stdout;
LOGFILE = fopen("/tmp/taskcontroller.log", "a+");
int i=0;
for (i=0; i<argc; i++)
fprintf(LOGFILE, "Arg[%i] = %s\n", i, argv[i]);
//Minimum number of arguments required to run the task-controller
if (argc < 4) {
display_usage(LOGFILE);
return INVALID_ARGUMENT_NUMBER;
}
int command;
const char * job_id = NULL;
const char * task_id = NULL;
const char * cred_file = NULL;
const char * script_file = NULL;
const char * current_dir = NULL;
const char * job_xml = NULL;
int exit_code = 0;
char * dir_to_be_deleted = NULL;
char *executable_file = get_executable();
#ifndef HADOOP_CONF_DIR
#error HADOOP_CONF_DIR must be defined
#endif
char *orig_conf_file = STRINGIFY(HADOOP_CONF_DIR) "/" CONF_FILENAME;
char *conf_file = realpath(orig_conf_file, NULL);
if (conf_file == NULL) {
fprintf(LOGFILE, "Configuration file %s not found.\n", orig_conf_file);
return INVALID_CONFIG_FILE;
}
if (check_configuration_permissions(conf_file) != 0) {
return INVALID_CONFIG_FILE;
}
read_config(conf_file);
free(conf_file);
// look up the task tracker group in the config file
char *tt_group = get_value(TT_GROUP_KEY);
if (tt_group == NULL) {
fprintf(LOGFILE, "Can't get configured value for %s.\n", TT_GROUP_KEY);
exit(INVALID_CONFIG_FILE);
}
struct group *group_info = getgrnam(tt_group);
if (group_info == NULL) {
fprintf(LOGFILE, "Can't get group information for %s - %s.\n", tt_group,
strerror(errno));
exit(INVALID_CONFIG_FILE);
}
set_tasktracker_uid(getuid(), group_info->gr_gid);
// if we are running from a setuid executable, make the real uid root
setuid(0);
// set the real and effective group id to the task tracker group
setgid(group_info->gr_gid);
if (check_taskcontroller_permissions(executable_file) != 0) {
fprintf(LOGFILE, "Invalid permissions on task-controller binary.\n");
return INVALID_TASKCONTROLLER_PERMISSIONS;
}
//checks done for user name
if (argv[optind] == NULL) {
fprintf(LOGFILE, "Invalid user name \n");
return INVALID_USER_NAME;
}
int ret = set_user(argv[optind]);
if (ret != 0) {
return ret;
}
optind = optind + 1;
command = atoi(argv[optind++]);
fprintf(LOGFILE, "main : command provided %d\n",command);
fprintf(LOGFILE, "main : user is %s\n", user_detail->pw_name);
switch (command) {
case INITIALIZE_JOB:
if (argc < 7) {
fprintf(LOGFILE, "Too few arguments (%d vs 7) for initialize job\n",
argc);
return INVALID_ARGUMENT_NUMBER;
}
job_id = argv[optind++];
cred_file = argv[optind++];
job_xml = argv[optind++];
exit_code = initialize_job(user_detail->pw_name, job_id, cred_file,
job_xml, argv + optind);
break;
case LAUNCH_TASK_JVM:
if (argc < 7) {
fprintf(LOGFILE, "Too few arguments (%d vs 7) for launch task\n",
argc);
return INVALID_ARGUMENT_NUMBER;
}
job_id = argv[optind++];
task_id = argv[optind++];
current_dir = argv[optind++];
script_file = argv[optind++];
exit_code = run_task_as_user(user_detail->pw_name, job_id, task_id,
current_dir, script_file);
break;
case SIGNAL_TASK:
if (argc < 5) {
fprintf(LOGFILE, "Too few arguments (%d vs 5) for signal task\n",
argc);
return INVALID_ARGUMENT_NUMBER;
} else {
char* end_ptr = NULL;
char* option = argv[optind++];
int task_pid = strtol(option, &end_ptr, 10);
if (option == end_ptr || *end_ptr != '\0') {
fprintf(LOGFILE, "Illegal argument for task pid %s\n", option);
return INVALID_ARGUMENT_NUMBER;
}
option = argv[optind++];
int signal = strtol(option, &end_ptr, 10);
if (option == end_ptr || *end_ptr != '\0') {
fprintf(LOGFILE, "Illegal argument for signal %s\n", option);
return INVALID_ARGUMENT_NUMBER;
}
exit_code = signal_user_task(user_detail->pw_name, task_pid, signal);
}
break;
case DELETE_AS_USER:
dir_to_be_deleted = argv[optind++];
exit_code= delete_as_user(user_detail->pw_name, dir_to_be_deleted);
break;
case DELETE_LOG_AS_USER:
dir_to_be_deleted = argv[optind++];
exit_code= delete_log_directory(dir_to_be_deleted);
break;
case RUN_COMMAND_AS_USER:
exit_code = run_command_as_user(user_detail->pw_name, argv + optind);
break;
default:
exit_code = INVALID_COMMAND_PROVIDED;
}
fclose(LOGFILE);
return exit_code;
}
int main(int argc, char **argv) {
LOGFILE = stdout;
int my_username = 0;
// clean up any junk from previous run
system("chmod -R u=rwx " TEST_ROOT "; rm -fr " TEST_ROOT);
if (mkdirs(TEST_ROOT "/logs/userlogs", 0755) != 0) {
exit(1);
}
if (write_config_file(TEST_ROOT "/test.cfg") != 0) {
exit(1);
}
read_config(TEST_ROOT "/test.cfg");
create_tt_roots();
if (getuid() == 0 && argc == 2) {
username = argv[1];
} else {
username = strdup(getpwuid(getuid())->pw_name);
my_username = 1;
}
set_tasktracker_uid(geteuid(), getegid());
if (set_user(username)) {
exit(1);
}
printf("\nStarting tests\n");
printf("\nTesting get_user_directory()\n");
test_get_user_directory();
printf("\nTesting get_job_directory()\n");
test_get_job_directory();
printf("\nTesting get_attempt_directory()\n");
test_get_attempt_directory();
printf("\nTesting get_task_launcher_file()\n");
test_get_task_launcher_file();
printf("\nTesting get_job_log_dir()\n");
test_get_job_log_dir();
test_check_configuration_permissions();
printf("\nTesting delete_task()\n");
test_delete_task();
printf("\nTesting delete_job()\n");
test_delete_job();
test_delete_user();
test_check_user();
// the tests that change user need to be run in a subshell, so that
// when they change user they don't give up our privs
run_test_in_child("test_signal_task", test_signal_task);
run_test_in_child("test_signal_task_group", test_signal_task_group);
// init job and run task can't be run if you aren't testing as root
if (getuid() == 0) {
// these tests do internal forks so that the change_owner and execs
// don't mess up our process.
test_init_job();
test_run_task();
}
seteuid(0);
run("rm -fr " TEST_ROOT);
printf("\nFinished tests\n");
if (my_username) {
free(username);
}
free_configurations();
return 0;
}
