Prelim success with xsetroot working.

[tlb/tomd.git] / src / common / guile_helpers.c

diff --git a/src/common/guile_helpers.c b/src/common/guile_helpers.c
index 8d3df8b..1b57dfa 100644 (file)
--- a/src/common/guile_helpers.c
+++ b/src/common/guile_helpers.c
@@ -15,22 +15,183 @@
 /* You should have received a copy of the GNU General Public License */
 /* along with tomd.  If not, see <http://www.gnu.org/licenses/>. */
 
-static load_job(void)
-{
+#include <libguile.h>
+#include <pwd.h>
+
+#include "../../include/job.h"
+#include "../../include/macros.h"
+#include "../../include/scm_interface.h"
+
+#define MANIFEST_LOC "/.config/tomd/init/manifest.scm"
+
+#define MAX_JOBS 10
+
+static struct job jobs[MAX_JOBS];
+
+static struct job load_job(SCM job_list, int index)
+{  
+  struct job ret = { NULL };
+  SCM scm_cur_job = SCM_ARR(job_list, index);
+
+  if(scm_is_false(job_predicate(scm_cur_job))){
+    tomd_p("job %d wasn't a real job type.", index);
+    return ret;
+  }
+
+  SCM scm_cmd = get_cmd(scm_cur_job);
+  SCM scm_args = get_args(scm_cur_job);
 
+  /* TODO > Handle these. */
+  /* planned is to be able to run at different points, and at */
+  /* the request of a user. for testing we do things all at */
+  /* boot up. */
+  SCM scm_start_trigger = get_start_trigger(scm_cur_job);
+  SCM scm_end_trigger = get_end_trigger(scm_cur_job);
+
+  char *job_cmd = scm_to_locale_string(scm_cmd);
+
+  char *real_args[10];
+  int jlen = scm_to_int(scm_length(scm_args));
+  for(int j = 0;
+      j < jlen;
+      j++){
+    real_args[j] =
+      scm_to_locale_string(SCM_ARR(scm_args, j));
+  }
+
+  ret.cmd = job_cmd;
+  
+  for(int j = 1;
+      j <= jlen;
+      j++){
+    ret.args[j] = real_args[j - 1];
+  }
+  ret.args[jlen + 1] = NULL;
+  ret.args[0] = ret.cmd;
+
+  return ret;
 }
 
-static void load_manifest(void *args)
+static void *load_manifest(void *args)
 {
+  char *manifest_loc;
   if(!args){
-    
+    tomd_p("arg to load_manifest is NULL");
+    exit(EXIT_FAILURE);
+  }
+  manifest_loc = (char *)args;
+
+  scm_c_primitive_load(args);
+
+  SCM scm_job_list =
+    scm_c_public_ref("tomd manifest", "job-list");
+
+  if(scm_is_false(scm_job_list)){
+    tomd_p("no job-list found in manifest.scm");
+    return NULL;
+  }
+
+  if(scm_is_false(scm_list_p(scm_job_list))){
+    tomd_p("job-list found, but isn't a list.");
+    return NULL;
+  }
+
+  int i;
+  int len = SCM_LIST_LEN(scm_job_list);
+  tomd_p("len=%d, max=%d", len, MAX_JOBS);
+  for(i = 0;
+      i < len && i < MAX_JOBS;
+      i++){
+    jobs[i] = load_job(scm_job_list, i);
+  }
+  tomd_p("looked at %d jobs.", i);
+  jobs[i].cmd = NULL;
+}
+
+static char *lookup_user_folder(void)
+{
+  uid_t user = getuid();
+  struct passwd *userpasswd =
+    getpwuid(user);
+
+  /* take the manifest location and sub ~ for pw_dir */
+  char *buffer = (char *)malloc(sizeof(char) * 300);
+  strcpy(buffer, userpasswd->pw_dir);
+  int len = strlen(userpasswd->pw_dir);
+  strcpy(buffer + len, MANIFEST_LOC);
+  return buffer;
 }
 
 void load_jobs(void)
 {
-  /* get into the manifest.scm file */
+  char *manifest = lookup_user_folder();
+  tomd_p("Loading jobs from '%s'", manifest);
+  
   void *res =
     scm_with_guile(load_manifest,
-                   (void *)config_file);
-  /* check if the variable 'job-list' is defined */
+                   (void *) manifest);
+
+  tomd_p("Finished loading.");
+
+  int i = 0;
+  while(1){
+    if(i >= MAX_JOBS ||
+       jobs[i].cmd == NULL) {
+      break;
+    }
+    tomd_p("JOB <%d>:", i);
+    tomd_p("     cmd:'%s'", jobs[i].cmd);
+    int j = 1;
+    while(1){
+      if(i >= 10 ||
+         jobs[i].args[j] == NULL){
+        break;
+      }
+      tomd_p(" arg [%d]:'%s'", j, jobs[i].args[j]);
+      j++;
+    }
+    i++;
+  }
+}
+
+void run_job(int index)
+{
+  struct job *job = &jobs[index];
+
+  pid_t pid = fork();
+  if(pid == 0){                 /* child */
+    int i = 0;
+    while(1){
+      tomd_p("hallo");
+      if(job->args[i] == NULL){
+        tomd_p("arg [%d] is NULL", i);
+        break;
+      }else{
+        tomd_p("arg [%d] is '%s'", i, job->args[i]);
+      }
+      i++;
+    }
+    execvp(job->cmd, job->args);
+    tomd_p("execvp for '%s' failed", job->cmd);
+    perror("");
+    exit(EXIT_FAILURE);
+  }else{                        /* parent */
+    tomd_p("forked [%d] to run '%s'", pid, job->cmd);
+  }
+}
+
+void run_jobs(void)
+{
+  int i;
+  for(i = 0;
+      i < MAX_JOBS;
+      i++){
+    if(jobs[i].cmd == NULL){
+      tomd_p("out of jobs");
+      return;
+    }else{
+      tomd_p("running job [%d] '%s'", i, jobs[i].cmd);
+      run_job(i);
+    }
+  }        
 }