X-Git-Url: https://git.ucc.asn.au/?a=blobdiff_plain;f=server%2Fcontrol.c;h=280a1323aba0d680252219fc53bac00f94e918eb;hb=3521cee9644bd955fd053c5b4ea173efd1e78fe8;hp=2c0fd7927462e96e39cddc395cad9110f6291a77;hpb=270dc6627ca3a8417d50195da96a8acc859d9e7b;p=matches%2FMCTX3420.git diff --git a/server/control.c b/server/control.c index 2c0fd79..280a132 100644 --- a/server/control.c +++ b/server/control.c @@ -3,27 +3,80 @@ * @brief Handles all client control requests (admin related) */ #include "common.h" +#include "options.h" #include "control.h" #include "sensor.h" #include "actuator.h" +#include +#include +#include +/** + * Control state information (start/stop/pause etc) + */ typedef struct ControlData { - ControlModes current_mode; - pthread_mutex_t mutex; - struct timeval start_time; + ControlModes current_mode; /** Current experiment mode **/ + pthread_mutex_t mutex; /** Mutex to serialise access to control methods **/ + struct timespec start_time; /** Start time of current experiment **/ + char user_name[31]; /** The user who owns the currently running experiment **/ + char experiment_dir[BUFSIZ]; /** Directory for experiment **/ + char experiment_name[BUFSIZ]; /** Name of the current experiment **/ } ControlData; ControlData g_controls = {CONTROL_STOP, PTHREAD_MUTEX_INITIALIZER, {0}}; -static bool PathExists(const char *path) { - FILE *fp = fopen(path, "r"); - if (fp) { - fclose(fp); +/** + * Determines if a directory exists or not. + * @param path The path to check + * @return true iff the path exists + */ +bool DirExists(const char *path) +{ + DIR *dir = opendir(path); + if (dir) { + closedir(dir); return true; } return false; } +/** + * Lists all experiments for the current user. + * @param context The context to work in + */ +void ListExperiments(FCGIContext *context) +{ + DIR * dir = opendir(context->user_dir); + if (dir == NULL) + { + FCGI_RejectJSON(context, "Failed to open user directory"); + return; + } + struct dirent * ent; + FCGI_BeginJSON(context, STATUS_OK); + FCGI_JSONKey("experiments"); + FCGI_PrintRaw("["); + + bool first = true; + while ((ent = readdir(dir)) != NULL) { + char *ext = strrchr(ent->d_name, '.'); + if (ext && !strcmp(ext, ".exp")) { + if (!first) { + FCGI_PrintRaw(", "); + } + + *ext = '\0'; // Ummm... probably not a great idea + FCGI_PrintRaw("\"%s\"", ent->d_name); + first = false; + } + } + FCGI_PrintRaw("]"); + FCGI_EndJSON(); + + closedir(dir); + return; +} + /** * System control handler. This covers high-level control, including * admin related functions and starting/stopping experiments.. @@ -31,72 +84,118 @@ static bool PathExists(const char *path) { * @param params The input parameters */ void Control_Handler(FCGIContext *context, char *params) { - const char *action, *key = "", *name = ""; + const char *action = ""; + const char *name = ""; bool force = false; ControlModes desired_mode; - - FCGIValue values[4] = { + + // Login/auth now handled entirely in fastcgi.c and login.c + //TODO: Need to not have the ability for any user to stop someone else' experiment... + // (achieve by storing the username of the person running the current experiment, even when they log out?) + // (Our program should only realisitically support a single experiment at a time, so that should be sufficient) + FCGIValue values[3] = { {"action", &action, FCGI_REQUIRED(FCGI_STRING_T)}, - {"key", &key, FCGI_STRING_T}, {"force", &force, FCGI_BOOL_T}, {"name", &name, FCGI_STRING_T} }; - if (!FCGI_ParseRequest(context, params, values, 4)) + if (!FCGI_ParseRequest(context, params, values, 3)) return; - - if (!strcmp(action, "lock")) { - FCGI_LockControl(context, force); - return; - } else if (!strcmp(action, "emergency")) { - desired_mode = CONTROL_EMERGENCY; - } else if (!strcmp(action, "query")) { + + if (!strcmp(action, "identify")) { FCGI_BeginJSON(context, STATUS_OK); - FCGI_JSONPair("state", Control_GetModeName(Control_GetMode())); + FCGI_JSONLong("control_state_id", g_controls.current_mode); + FCGI_JSONPair("control_user_name", g_controls.user_name); + FCGI_JSONPair("control_experiment_name", g_controls.experiment_name); FCGI_EndJSON(); return; - } else if (FCGI_HasControl(context, key)) { - if (!strcmp(action, "release")) { - FCGI_ReleaseControl(context); - } else if (!strcmp(action, "start")) { - desired_mode = CONTROL_START; - } else if (!strcmp(action, "pause")) { - desired_mode = CONTROL_PAUSE; - } else if (!strcmp(action, "resume")) { - desired_mode = CONTROL_RESUME; - } else if (!strcmp(action, "stop")) { - desired_mode = CONTROL_STOP; - } else { - FCGI_RejectJSON(context, "Unknown action specified."); - return; - } + } else if (!strcmp(action, "list")) { + ListExperiments(context); + return; + } + //TODO: Need a "load" action to set data files (but not run) from a past experiment + + //TODO: Need a "delete" action so that people can overwrite experiments (without all this "force" shenanigans) + + if (!strcmp(action, "emergency")) { + desired_mode = CONTROL_EMERGENCY; + } else if (!strcmp(action, "start")) { + desired_mode = CONTROL_START; + } else if (!strcmp(action, "pause")) { + desired_mode = CONTROL_PAUSE; + } else if (!strcmp(action, "resume")) { + desired_mode = CONTROL_RESUME; + } else if (!strcmp(action, "stop")) { + desired_mode = CONTROL_STOP; } else { - FCGI_RejectJSONEx(context, STATUS_UNAUTHORIZED, - "Invalid control key specified."); + FCGI_RejectJSON(context, "Unknown action specified."); return; } + if ((*g_controls.user_name) != '\0' && strcmp(g_controls.user_name, context->user_name) != 0) + { + if (context->user_type != USER_ADMIN) { + FCGI_RejectJSON(context, "Another user has an experiment in progress."); + return; + } + + if (!force) { + Log(LOGERR, "User %s is currently running an experiment!", g_controls.user_name); + FCGI_RejectJSON(context, "Pass \"force\" to take control over another user's experiment"); + return; + } + } + void *arg = NULL; + char experiment_dir[BUFSIZ] = {0}; if (desired_mode == CONTROL_START) { - int len = strlen(name); - if (len <= 0) { + int ret; + + if (*name == '\0') { FCGI_RejectJSON(context, "An experiment name must be specified."); return; - } else if (PathExists(name) && !force) { + } if (strpbrk(name, INVALID_CHARACTERS)) { + FCGI_RejectJSON(context, + "An experiment name must not contain: " INVALID_CHARACTERS_JSON); + return; + } + + if (*(context->user_dir) == '\0') { + FCGI_RejectJSON(context, "Not creating experiment in root dir."); + return; + } + + ret = snprintf(experiment_dir, BUFSIZ, "%s/%s.exp", + context->user_dir, name); + if (ret >= BUFSIZ) { + FCGI_RejectJSON(context, "The experiment name is too long."); + return; + } else if (DirExists(experiment_dir) && !force) { FCGI_RejectJSON(context, "An experiment with that name already exists."); return; } - arg = (void*)name; + arg = (void*) experiment_dir; } const char *ret; if ((ret = Control_SetMode(desired_mode, arg)) != NULL) { FCGI_RejectJSON(context, ret); } else { - FCGI_BeginJSON(context, STATUS_OK); - FCGI_JSONPair("description", "ok"); - FCGI_EndJSON(); + if (desired_mode == CONTROL_STOP) { + g_controls.user_name[0] = '\0'; + g_controls.experiment_dir[0] = '\0'; + g_controls.experiment_name[0] = '\0'; + } else if (desired_mode == CONTROL_START) { + snprintf(g_controls.user_name, sizeof(g_controls.user_name), + "%s", context->user_name); + snprintf(g_controls.experiment_dir, sizeof(g_controls.experiment_dir), + "%s", experiment_dir); + snprintf(g_controls.experiment_name, sizeof(g_controls.experiment_name), + "%s", name); + } + + FCGI_AcceptJSON(context, "Ok"); } } @@ -111,26 +210,38 @@ const char* Control_SetMode(ControlModes desired_mode, void * arg) const char *ret = NULL; pthread_mutex_lock(&(g_controls.mutex)); - if (g_controls.current_mode == CONTROL_EMERGENCY && desired_mode != CONTROL_STOP) { - ret = "In emergency mode. Stop before doing anything else."; - } else if (g_controls.current_mode == desired_mode) { - ret = "Already in desired mode."; - } else if (desired_mode == CONTROL_START) { - if (g_controls.current_mode == CONTROL_STOP) { - //TODO Sanitise name (ensure it contains no special chars eg \ / .. . - FILE *fp = fopen((const char*) arg, "a"); - if (fp) { - fclose(fp); - gettimeofday(&(g_controls.start_time), NULL); - } else { - ret = "Cannot open experiment name marker"; - } - } else { - ret = "Cannot start when not in a stopped state."; - } - } else if (desired_mode == CONTROL_RESUME) { - if (g_controls.current_mode != CONTROL_PAUSE) - ret = "Cannot resume when not in a paused state."; + if (g_controls.current_mode == desired_mode) + ret = "Already in the desired mode."; + else if (g_controls.current_mode == CONTROL_EMERGENCY && desired_mode != CONTROL_STOP) + ret = "In emergency mode. You must stop before continuing."; + else switch (desired_mode) { + case CONTROL_START: + if (g_controls.current_mode == CONTROL_STOP) { + const char * path = arg; + if (mkdir(path, 0777) != 0 && errno != EEXIST) { + Log(LOGERR, "Couldn't create experiment directory %s - %s", + path, strerror(errno)); + ret = "Couldn't create experiment directory."; + } else { + clock_gettime(CLOCK_MONOTONIC, &(g_controls.start_time)); + } + } else + ret = "Cannot start when not in a stopped state."; + break; + case CONTROL_PAUSE: + if (g_controls.current_mode != CONTROL_START) + ret = "Cannot pause when not in a running state."; + break; + case CONTROL_RESUME: + if (g_controls.current_mode != CONTROL_PAUSE) + ret = "Cannot resume when not in a paused state."; + break; + case CONTROL_EMERGENCY: + if (g_controls.current_mode != CONTROL_START) //pfft + ret = "Not running so how can there be an emergency?"; + break; + default: + break; } if (ret == NULL) { @@ -146,22 +257,13 @@ const char* Control_SetMode(ControlModes desired_mode, void * arg) } /** - * Gets the current mode. - * @return The current mode - */ -ControlModes Control_GetMode() { - return g_controls.current_mode; -} - -/** - * Gets a string representation of a mode - * @param mode The mode to get a string representation of + * Gets a string representation of the current mode * @return The string representation of the mode */ -const char * Control_GetModeName(ControlModes mode) { +const char * Control_GetModeName() { const char * ret = "Unknown"; - switch (mode) { + switch (g_controls.current_mode) { case CONTROL_START: ret = "Running"; break; case CONTROL_PAUSE: ret = "Paused"; break; case CONTROL_RESUME: ret = "Resumed"; break; @@ -171,23 +273,10 @@ const char * Control_GetModeName(ControlModes mode) { return ret; } -/* -bool Control_Lock() { - pthread_mutex_lock(&(g_controls.mutex)); - if (g_controls.state == STATE_RUNNING || g_controls.state == STATE_PAUSED) - return true; - pthread_mutex_unlock(&(g_controls.mutex)); - return false; -} - -void Control_Unlock() { - pthread_mutex_unlock(&(g_controls.mutex)); -}*/ - /** * Gets the start time for the current experiment * @return the start time */ -const struct timeval* Control_GetStartTime() { +const struct timespec * Control_GetStartTime() { return &g_controls.start_time; -} \ No newline at end of file +}