IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Jul 31, 2005, 8:04:11 AM (21 years ago)
Author:
eugene
Message:

task/job list cleanup, fixing kill/delete

Location:
trunk/Ohana/src/opihi/pantasks
Files:
1 added
17 edited

Legend:

Unmodified
Added
Removed

  • trunk/Ohana/src/opihi/pantasks/CheckJobs.c

    r4602 r4684  
    1212  while ((job = NextJob ()) != NULL) {
    1313
    14     /* check for timeout - only local jobs timeout here */
    15     if ((job[0].mode == JOB_LOCAL) && (GetTaskTimer(job[0].start) >= job[0].task[0].timeout_period)) {
    16       if (VerboseMode()) fprintf (stderr, "timeout on %s\n", job[0].task[0].name);
    17       /* run task[0].timeout macro, if it exists */
    18       if (job[0].task[0].timeout != NULL) {
    19         exec_loop (job[0].task[0].timeout);
    20       }
    21       DeleteJob (job);
    22       continue;
    23     }
    24 
    25     /* check poll period (ready to run again?) */
     14    /* check poll period (ready to ask for status?) */
    2615    if (GetTaskTimer(job[0].last) < job[0].task[0].poll_period) continue;
    2716
    … …  
    7463    }
    7564
     65    /* check for timeout - (local jobs only)
     66       we only check timeout after a poll (forces at least one poll)
     67     */
     68    if (job[0].mode == JOB_LOCAL) {
     69      if (GetTaskTimer(job[0].start) < job[0].task[0].timeout_period) continue;
     70      if (VerboseMode()) fprintf (stderr, "timeout on %s\n", job[0].task[0].name);
     71      if (!KillLocalJob (job)) {
     72        job[0].state = JOB_HUNG;
     73        if (VerboseMode()) fprintf (stderr, "child process %d is hung, cannot kill\n", job[0].pid);
     74        continue;
     75      }
     76      /* run task[0].timeout macro, if it exists */
     77      if (job[0].task[0].timeout != NULL) {
     78        exec_loop (job[0].task[0].timeout);
     79      }
     80      DeleteJob (job);
     81      continue;
     82    }
     83
    7684    /* reset polling clock */
    7785    SetTaskTimer (&job[0].last);
    … …  
    7987  return (TRUE);
    8088}
     89
     90/*
     91
     92  job / task timeline:
     93
     94  task:
     95  0           exec     
     96  start       create
     97  task clock  new job
     98
     99  job:
     100  0           1xpoll     2xpoll     3xpoll
     101  start       check      check      check
     102  job clock   status     status     status
     103
     104  .           .          .          timeout
     105                                    run
     106                                    timeout
     107
     108  must be at least one poll before timeout
     109  (timeout >= poll)
     110*/

  • trunk/Ohana/src/opihi/pantasks/CheckTasks.c

    r4603 r4684  
    1919    if (task[0].Nmax && (task[0].Njobs >= task[0].Nmax)) continue;
    2020
    21     SetCurrentTask (task[0].name);
    22 
    2321    /* ready to run? : run task.exec macro */
    2422    if (task[0].exec != NULL) {
    … …  
    2624      if (!status) continue;
    2725    }
    28 
    29     /* is task valid?  check state of task.(argc, argv) */
    30     /*** ADD CODE HERE ***/
    3126
    3227    /* construct job from task */

  • trunk/Ohana/src/opihi/pantasks/ControllerOps.c

    r4602 r4684  
    5858  if (p != NULL) {
    5959    fprintf (stderr, "unknown job %d\n", job[0].pid);
     60    FreeIOBuffer (&buffer);
    6061    return (FALSE);
    6162  }
    … …  
    384385
    385386
     387int KillControllerJob (Job *job) {
     388
     389  int status;
     390  char cmd[128];
     391  IOBuffer buffer;
     392
     393  sprintf (cmd, "kill %d", job[0].pid);
     394  InitIOBuffer (&buffer, 0x100);
     395  status = ControllerCommand (cmd, CONTROLLER_PROMPT, &buffer);
     396
     397  /** need to interpret output message & free things **/
     398  FreeIOBuffer (&buffer);
     399  return (TRUE);
     400}
     401
    386402/* memstr returns a view, not an allocated string : don't free */

  • trunk/Ohana/src/opihi/pantasks/JobOps.c

    r4450 r4684  
    11# include "scheduler.h"
    22
    3 # define MAX_N_JOBS 1000
    4 static char *JobIDList;
    5 static int   JobIDPtr = 0;
     3static Job **jobs;
     4static int   Njobs;
     5static int   NJOBS;
    66
    7 static char dot[] = ".";
     7/* counter marking job being visited by the run loop */
     8static int   ActiveJob;
    89
    9 static Job *jobs;
    10 static int  Njobs;
    11 static int  NJOBS;
    12 
    13 static char *JobName = dot;
    14 static int   CurrentJob = 0;
     10/* set up the jobs list */
     11void InitJobs () {
     12  NJOBS = 20;
     13  Njobs = 0;
     14  ALLOCATE (jobs, Job *, NJOBS);
     15  ActiveJob = -1;
     16}
    1517
    1618/* provide a mechanism to loop over the list of jobs */
    … …  
    1921  Job *job;
    2022
    21   if (CurrentJob >= Njobs) {
    22     CurrentJob = 0;
     23  ActiveJob ++;
     24  if (ActiveJob < 0) ActiveJob = 0;
     25  if (ActiveJob >= Njobs) {
     26    ActiveJob = -1;
    2327    return (NULL);
    2428  }
    25 
    26   job = &jobs[CurrentJob];
    27   CurrentJob ++;
     29  job = jobs[ActiveJob];
    2830  return (job);
    29 }
    30 
    31 void InitJobs () {
    32   NJOBS = 20;
    33   Njobs = 0;
    34   ALLOCATE (jobs, Job, NJOBS);
    35   JobName = dot;
    36 
    37   ALLOCATE (JobIDList, char, MAX_N_JOBS);
    38   bzero (JobIDList, MAX_N_JOBS*sizeof(char));
    39 }
    40 
    41 /* return next unique ID, recycle every MAX_N_JOBS */
    42 int NextJobID () {
    43 
    44   int Ntry;
    45 
    46   JobIDPtr ++;
    47   if (JobIDPtr >= MAX_N_JOBS) JobIDPtr = 0;
    48 
    49   Ntry = 0;
    50   while (JobIDList[JobIDPtr]) {
    51     Ntry ++;
    52     JobIDPtr ++;
    53     if (JobIDPtr >= MAX_N_JOBS) JobIDPtr = 0;
    54     if (Ntry == MAX_N_JOBS) return (-1);
    55   }
    56   JobIDList[JobIDPtr] = TRUE;
    57   return (JobIDPtr);
    58 }
    59 
    60 /* list known jobs */
    61 void ListJobs () {
    62 
    63   int i;
    64 
    65   for (i = 0; i < Njobs; i++) {
    66     fprintf (stderr, "%d: %-15s %5d %20s (%x)\n", Njobs, jobs[i].task[0].name, jobs[i].JobID, jobs[i].argv[0], jobs[i].argv);
    67   }
    68   return;
    6931}
    7032
    … …  
    7638  /* return job with matching JobID */
    7739  for (i = 0; i < Njobs; i++) {
    78     if (jobs[i].JobID == JobID) {
    79       return (&jobs[i]);
     40    if (jobs[i][0].JobID == JobID) {
     41      return (jobs[i]);
    8042    }
    8143  }
    … …  
    8345} 
    8446
     47/* list known jobs */
     48void ListJobs () {
     49
     50  int i;
     51
     52  if (Njobs == 0) {
     53    fprintf (stderr, "no defined jobs\n");
     54    return;
     55  }
     56
     57  for (i = 0; i < Njobs; i++) {
     58    fprintf (stderr, "%d: %-15s %5d %20s (%x)\n", Njobs, jobs[i][0].task[0].name, jobs[i][0].JobID, jobs[i][0].argv[0], jobs[i][0].argv);
     59  }
     60  return;
     61}
     62
    8563/* make a new job from a task */
    8664Job *CreateJob (Task *task) {
    8765 
    8866  int i;
     67  Job *job;
     68 
     69  ALLOCATE (job, Job, 1);
    8970
    90   jobs[Njobs].JobID = NextJobID ();
    91   jobs[Njobs].pid = 0;
    92   jobs[Njobs].mode = JOB_LOCAL;
     71  job[0].JobID = NextJobID ();
     72  job[0].pid = 0;
     73  job[0].mode = JOB_LOCAL;
    9374  if (task[0].host != NULL) {
    94     jobs[Njobs].mode = JOB_CONTROLLER;
     75    job[0].mode = JOB_CONTROLLER;
    9576  }
    9677
    … …  
    9980   *  we allocate one extra element, with value 0 to be passed to execvp
    10081   */
    101   jobs[Njobs].argc = task[0].argc;
    102   ALLOCATE (jobs[Njobs].argv, char *, MAX (task[0].argc + 1, 1));
     82  job[0].argc = task[0].argc;
     83  ALLOCATE (job[0].argv, char *, MAX (task[0].argc + 1, 1));
    10384  for (i = 0; i < task[0].argc; i++) {
    104     jobs[Njobs].argv[i] = strcreate (task[0].argv[i]);
     85    job[0].argv[i] = strcreate (task[0].argv[i]);
    10586  }
    106   jobs[Njobs].argv[i] = 0;
     87  job[0].argv[i] = 0;
    10788
    10889  /* other data from the task is needed by the job
    … …  
    11192     be applied to the existing jobs */
    11293
    113   jobs[Njobs].task = task;
     94  job[0].task = task;
    11495 
    11596  /* if we decide we need to be able to dynamically set task qualities
    … …  
    11798     entries to these quantites in the job structure */
    11899
     100  jobs[Njobs] = job;
    119101  Njobs ++;
    120102  if (Njobs == NJOBS) {
    121103    NJOBS += 20;
    122     REALLOCATE (jobs, Job, NJOBS);
     104    REALLOCATE (jobs, Job *, NJOBS);
    123105  }
    124   return (&jobs[Njobs-1]);
     106  return (jobs[Njobs-1]);
    125107}
    126108
    … …  
    130112
    131113  if (job == NULL) return;
    132 
    133   if ((job[0].JobID >= 0) || (job[0].JobID < MAX_N_JOBS)) {
    134     JobIDList[job[0].JobID] = FALSE;
    135   }
     114 
     115  FreeJobID (job[0].JobID);
    136116
    137117  for (i = 0; i < job[0].argc; i++) {
    … …  
    142122}
    143123
    144 void SetCurrentJob (char *name) {
    145   JobName = name;
    146 }
    147 
    148 char *GetCurrentJob () {
    149   return (JobName);
    150 }
    151 
     124/** are we deleting the active job?? **/
    152125int DeleteJob (Job *job) {
    153126
    … …  
    156129  Nm = -1;
    157130  for (i = 0; i < Njobs; i++) {
    158     if (job == &jobs[i]) {
     131    if (job == jobs[i]) {
    159132      Nm = i;
    160133      break;
    … …  
    166139  }
    167140
    168   FreeJob (&jobs[Nm]);
     141  FreeJob (jobs[Nm]);
    169142  for (i = Nm + 1; i < Njobs; i++)
    170143    jobs[i - 1] = jobs[i];
    171144  Njobs --;
    172145
    173   CurrentJob --;
    174   CurrentJob = MAX (CurrentJob, 0);
    175 
     146  /* adjust active job number */
     147  if (ActiveJob >= Nm) {
     148    ActiveJob --;
     149  }
    176150  return (TRUE);
    177151}

  • trunk/Ohana/src/opihi/pantasks/LocalJob.c

    r4602 r4684  
    102102  int result, waitstatus;
    103103
     104  fprintf (stderr, "checking on %d\n", job[0].pid);
     105
    104106  /* check local job status */
    105107  result = waitpid (job[0].pid, &waitstatus, WNOHANG);
    … …  
    135137        exit (1);
    136138      }
     139      fprintf (stderr, "waited for %d\n", result);
    137140     
    138141      if (WIFEXITED(waitstatus)) {
    … …  
    151154  return;
    152155}
     156
     157int KillLocalJob (Job *job) {
     158
     159  int i, result, waitstatus;
     160
     161  if (job[0].state != JOB_BUSY) return (TRUE);
     162
     163  /* send SIGTERM signal to job */
     164  kill (job[0].pid, SIGTERM);
     165  result = 0;
     166  for (i = 0; (i < 10) && (result == 0); i++) {
     167    usleep (10000);  /* 10 ms is min */
     168    result = waitpid (job[0].pid, &waitstatus, WNOHANG);
     169  }
     170  if (result) return (TRUE);
     171
     172  /* send SIGKILL signal to job */
     173  kill (job[0].pid, SIGKILL);
     174  result = 0;
     175  for (i = 0; (i < 10) && (result == 0); i++) {
     176    usleep (10000);  /* 10 ms is min */
     177    result = waitpid (job[0].pid, &waitstatus, WNOHANG);
     178  }
     179  if (result) return (TRUE);
     180
     181  /* total failure, don't reset */
     182  return (FALSE);
     183}
     184

  • trunk/Ohana/src/opihi/pantasks/Makefile

    r4603 r4684  
    3535$(SDIR)/LocalJob.$(ARCH).o \
    3636$(SDIR)/JobOps.$(ARCH).o \
     37$(SDIR)/JobIDOps.$(ARCH).o \
    3738$(SDIR)/TaskOps.$(ARCH).o \
    3839$(SDIR)/IOBufferOps.$(ARCH).o \

  • trunk/Ohana/src/opihi/pantasks/TaskOps.c

    r4603 r4684  
    1 # include "opihi.h"
    21# include "scheduler.h"
    32
    4 static char dot[] = ".";
    5 
    6 static Task *tasks;
    7 static int   Ntasks;
    8 static int   NTASKS;
    9 
    10 static char *TaskName = dot;
    11 
    12 static int   CurrentTask = 0;
    13 
    14 /* provide a mechanism to loop over the list of tasks */
    15 Task *NextTask () {
    16  
    17   Task *task;
    18 
    19   if (CurrentTask >= Ntasks) {
    20     CurrentTask = 0;
    21     return (NULL);
    22   }
    23 
    24   task = &tasks[CurrentTask];
    25   CurrentTask ++;
    26   return (task);
    27 }
    28 
     3static Task **tasks;
     4static int    Ntasks;
     5static int    NTASKS;
     6
     7/* counter marking task being visited by the run loop */
     8static int   ActiveTask;
     9
     10/* temporary holder for a new task */
     11static Task *NewTask = NULL;
     12
     13/* set up the task list system */
    2914void InitTasks () {
    3015  NTASKS = 20;
    3116  Ntasks = 0;
    32   ALLOCATE (tasks, Task, NTASKS);
    33   TaskName = dot;
    34 }
     17  ALLOCATE (tasks, Task *, NTASKS);
     18  ActiveTask = -1;
     19}
     20
     21/* provide a mechanism to loop over the list of tasks */
     22Task *NextTask () {
     23 
     24  Task *task;
     25
     26  /* move to the next task and return it */
     27  ActiveTask ++;
     28  if (ActiveTask < 0) ActiveTask = 0;
     29  if (ActiveTask >= Ntasks) {
     30    ActiveTask = -1;
     31    return (NULL);
     32  }
     33  task = tasks[ActiveTask];
     34  return (task);
     35}
     36
     37/* return task with given name */
     38Task *FindTask (char *name) {
     39
     40  int i;
     41
     42  /* try for an exact match first */
     43  for (i = 0; i < Ntasks; i++) {
     44    if (!strcmp (tasks[i][0].name, name)) {
     45      return (tasks[i]);
     46    }
     47  }
     48  return (NULL);
     49} 
    3550
    3651/* list known tasks */
    37 void ListTasks () {
     52void ListTasks (int verbose) {
    3853
    3954  int i, valid;
    4055
     56  if (Ntasks == 0) {
     57    fprintf (stderr, "no defined tasks\n");
     58    return;
     59  }
     60
     61  fprintf (stderr, "Task Status\n");
     62  fprintf (stderr, "  name            Njobs  command\n");
    4163  for (i = 0; i < Ntasks; i++) {
    42     valid = CheckTimeRanges (tasks[i].ranges, tasks[i].Nranges);
     64    valid = CheckTimeRanges (tasks[i][0].ranges, tasks[i][0].Nranges);
    4365    if (valid) {
    4466      fprintf (stderr, "+ ");
    … …  
    4668      fprintf (stderr, "- ");
    4769    }
    48     fprintf (stderr, "%-15s %4d %20s\n", tasks[i].name, tasks[i].Njobs, tasks[i].argv[0]);
     70    fprintf (stderr, "%-15s %4d   %-20s\n", tasks[i][0].name, tasks[i][0].Njobs, tasks[i][0].argv[0]);
     71    if (verbose) {
     72      fprintf (stderr, "    spawn period: %f, polling period: %f, timeout period: %f\n",
     73               tasks[i][0].poll_period, tasks[i][0].poll_period, tasks[i][0].poll_period);
     74      if (tasks[i][0].host != NULL) {
     75        if (tasks[i][0].host_required) {
     76          fprintf (stderr, "    host %s (required)\n", tasks[i][0].host);
     77        } else {
     78          fprintf (stderr, "    host %s (desired)\n", tasks[i][0].host);
     79        }
     80      } else {
     81        fprintf (stderr, "    task runs locally\n");
     82      }     
     83    }
    4984  }
    5085  return;
    … …  
    94129}
    95130
    96 /* return task with given name */
    97 Task *FindTask (char *name) {
    98 
     131/* make a new named task */
     132int FreeTask (Task *task) {
     133 
    99134  int i;
    100135
    101   /* try for an exact match first */
    102   for (i = 0; i < Ntasks; i++) {
    103     if (!strcmp (tasks[i].name, name)) {
    104       return (&tasks[i]);
    105     }
    106   }
    107   return (NULL);
    108 } 
     136  if (task == NULL) return (FALSE);
     137 
     138  if (task[0].name != NULL) free (task[0].name);
     139  if (task[0].host != NULL) free (task[0].host);
     140  if (task[0].argv != NULL) {
     141    for (i = 0; i < task[0].argc; i++) {
     142      free (task[0].argv[i]);
     143    }
     144    free (task[0].argv);
     145  }
     146  if (task[0].exec != NULL) {
     147    FreeMacro (task[0].exec);
     148    free (task[0].exec);
     149  }
     150  if (task[0].crash != NULL) {
     151    FreeMacro (task[0].crash);
     152    free (task[0].crash);
     153  }
     154  if (task[0].timeout != NULL) {
     155    FreeMacro (task[0].timeout);
     156    free (task[0].timeout);
     157  }
     158  for (i = 0; i < task[0].Nexit; i++) {
     159    if (task[0].exit[i] != NULL) {
     160      FreeMacro (task[0].exit[i]);
     161    }
     162    free (task[0].exit[i]);
     163  }
     164  free (task[0].exit);
     165
     166  if (task[0].ranges != NULL) {
     167    free (task[0].ranges);
     168  }
     169  return (TRUE);
     170}
     171
     172/**** new task functions ***/
    109173
    110174/* make a new named task */
    111175Task *CreateTask (char *name) {
    112176 
    113   tasks[Ntasks].name = strcreate (name);;
    114 
    115   tasks[Ntasks].host = NULL;
    116   tasks[Ntasks].host_required = FALSE;
    117 
    118   tasks[Ntasks].argc = 0;
    119   tasks[Ntasks].argv = NULL;
    120 
    121   tasks[Ntasks].exec = NULL;
    122   tasks[Ntasks].crash = NULL;
    123   tasks[Ntasks].timeout = NULL;
    124 
    125   tasks[Ntasks].Nexit = 0;
    126   tasks[Ntasks].NEXIT = 10;
    127   ALLOCATE (tasks[Ntasks].exit, Macro *, tasks[Ntasks].NEXIT);
     177  ALLOCATE (NewTask, Task, 1);
     178
     179  NewTask[0].name = strcreate (name);;
     180
     181  NewTask[0].host = NULL;
     182  NewTask[0].host_required = FALSE;
     183
     184  NewTask[0].argc = 0;
     185  NewTask[0].argv = NULL;
     186
     187  NewTask[0].exec = NULL;
     188  NewTask[0].crash = NULL;
     189  NewTask[0].timeout = NULL;
     190
     191  NewTask[0].Nexit = 0;
     192  NewTask[0].NEXIT = 10;
     193  ALLOCATE (NewTask[0].exit, Macro *, NewTask[0].NEXIT);
    128194  /* don't free tasks[0].exit, keep at least 1 allocated */
    129195
    130   tasks[Ntasks].exec_period = 1.0;
    131   tasks[Ntasks].poll_period = 1.0;
    132   tasks[Ntasks].timeout_period = 1.0;
    133 
    134   tasks[Ntasks].Nranges = 0;
    135   ALLOCATE (tasks[Ntasks].ranges, TimeRange, 1);
     196  NewTask[0].exec_period = 1.0;
     197  NewTask[0].poll_period = 1.0;
     198  NewTask[0].timeout_period = 1.0;
     199
     200  NewTask[0].Nranges = 0;
     201  ALLOCATE (NewTask[0].ranges, TimeRange, 1);
    136202
    137203  /* init task timer (is reset by 'run') */ 
    138   gettimeofday (&tasks[Ntasks].last, (void *) NULL);
    139   tasks[Ntasks].Njobs = 0;
    140   tasks[Ntasks].Nmax = 0;  /* default value means 'no limit' */
    141 
     204  gettimeofday (&NewTask[0].last, (void *) NULL);
     205  NewTask[0].Njobs = 0;
     206  NewTask[0].Nmax = 0;  /* default value means 'no limit' */
     207
     208  return (NewTask);
     209}
     210
     211int ValidateTask (Task *task) {
     212
     213  if (task[0].argc == 0) {
     214    fprintf (stderr, "task command not defined\n");
     215    return (FALSE);
     216  }
     217  if (task[0].argv == NULL) {
     218    fprintf (stderr, "task command arguments not defined (programming error)\n");
     219    return (FALSE);
     220  }
     221  return (TRUE);
     222}
     223
     224int RegisterNewTask () {
     225 
     226  int N;
     227
     228  N = Ntasks;
    142229  Ntasks ++;
    143230  if (Ntasks == NTASKS) {
    144231    NTASKS += 20;
    145     REALLOCATE (tasks, Task, NTASKS);
    146   }
    147   return (&tasks[Ntasks-1]);
    148 }
    149 
    150 void SetCurrentTask (char *name) {
    151   TaskName = name;
    152 }
    153 
    154 char *GetCurrentTask () {
    155   return (TaskName);
    156 }
     232    REALLOCATE (tasks, Task *, NTASKS);
     233  }
     234  tasks[N] = NewTask;
     235  NewTask = NULL;
     236  return (TRUE);
     237}
     238
     239int DeleteNewTask () {
     240  if (NewTask != NULL) {
     241    FreeTask (NewTask);
     242    free (NewTask);
     243    NewTask = NULL;
     244  }
     245  return (TRUE);
     246}
     247
     248Task *GetNewTask () {
     249  return (NewTask);
     250}
     251
     252/*** task timer functions ***/
    157253
    158254double GetTaskTimer (struct timeval start) {

  • trunk/Ohana/src/opihi/pantasks/kill.c

    r4552 r4684  
    1212  JobID = atoi (argv[1]);
    1313
    14   /* not yet implemented */
     14  job = FindJob (JobID);
    1515
     16  if (job[0].mode == JOB_LOCAL) {
     17    if (!KillLocalJob (job)) {
     18      job[0].state = JOB_HUNG;
     19      if (VerboseMode()) fprintf (stderr, "child process %d is hung, cannot kill\n", job[0].pid);
     20      return (FALSE);
     21    }
     22  } else {
     23    if (!KillControllerJob (job)) {
     24      job[0].state = JOB_HUNG;
     25      if (VerboseMode()) fprintf (stderr, "child process %d is hung, cannot kill\n", job[0].pid);
     26      return (FALSE);
     27    }
     28  }   
     29   
    1630  fprintf (stderr, "this function is not yet implemented\n");
    1731  return (TRUE);

  • trunk/Ohana/src/opihi/pantasks/scheduler.c

    r4450 r4684  
    1 # include "opihi.h"
    21# include "scheduler.h"
    32
    … …  
    4645  InitTasks ();
    4746  InitJobs ();
     47  InitJobIDs ();
    4848
    4949  rl_readline_name = opihi_name;

  • trunk/Ohana/src/opihi/pantasks/status.c

    r4602 r4684  
    88    fprintf (stderr, "scheduler is running\n");
    99  }
    10   ListTasks ();
     10  ListTasks (FALSE);
    1111  ListJobs ();
    1212

  • trunk/Ohana/src/opihi/pantasks/task.c

    r4602 r4684  
    1414  if (N = get_argument (argc, argv, "-list")) {
    1515    remove_argument (N, &argc, argv);
    16     ListTasks ();
     16    ListTasks (FALSE);
     17    return (TRUE);
     18  }
     19
     20  if (N = get_argument (argc, argv, "-longlist")) {
     21    remove_argument (N, &argc, argv);
     22    ListTasks (TRUE);
    1723    return (TRUE);
    1824  }
    … …  
    3440    task = CreateTask (argv[1]);
    3541  }
    36   SetCurrentTask (argv[1]);
     42  /* temporary task is saved statically
     43     add to list after definition is complete */
    3744
    3845  /* read in task from appropriate source (keyboard or list) until end */
    … …  
    7178           have been defined.  delete the task if not */
    7279        free (input);
     80        /* validate the new task: all mandatory elements defined? */
     81        if (!ValidateTask (task)) {
     82          DeleteNewTask ();
     83          return (FALSE);
     84        }
     85        RegisterNewTask ();
    7386        return (TRUE);
    7487        break;
    … …  
    92105    }
    93106  }
    94   return (TRUE);
     107  /* cannot ever reach here */
     108  return (FALSE);
    95109}
    96110

  • trunk/Ohana/src/opihi/pantasks/task_command.c

    r4451 r4684  
    44
    55  int i;
    6   char *taskname;
    76  Task *task;
    87
    … …  
    1312  }
    1413
    15   taskname = GetCurrentTask ();
    16   if (taskname == NULL) {
     14  task = GetNewTask ();
     15  if (task == NULL) {
    1716    fprintf (stderr, "ERROR: not defining or running a task\n");
    18     return (FALSE);
    19   }
    20   task = FindTask (taskname);
    21   if (task == NULL) {
    22     fprintf (stderr, "ERROR: current task not found??\n");
    2317    return (FALSE);
    2418  }

  • trunk/Ohana/src/opihi/pantasks/task_host.c

    r4451 r4684  
    2222  }
    2323
    24   taskname = GetCurrentTask ();
    25   if (taskname == NULL) {
     24  task = GetNewTask ();
     25  if (task == NULL) {
    2626    fprintf (stderr, "ERROR: not defining or running a task\n");
    27     return (FALSE);
    28   }
    29   task = FindTask (taskname);
    30   if (task == NULL) {
    31     fprintf (stderr, "ERROR: current task not found??\n");
    3227    return (FALSE);
    3328  }

  • trunk/Ohana/src/opihi/pantasks/task_macros.c

    r4451 r4684  
    66
    77  int i, N, NLINES, done, depth, ThisList;
    8   char *taskname, *input;
     8  char *input;
    99  Macro *macro;
    1010  Task *task;
    … …  
    2222  }
    2323
    24   taskname = GetCurrentTask ();
    25   if (taskname == NULL) {
     24  task = GetNewTask ();
     25  if (task == NULL) {
    2626    fprintf (stderr, "ERROR: not defining or running a task\n");
    27     return (FALSE);
    28   }
    29   task = FindTask (taskname);
    30   if (task == NULL) {
    31     fprintf (stderr, "ERROR: current task not found??\n");
    3227    return (FALSE);
    3328  }

  • trunk/Ohana/src/opihi/pantasks/task_nmax.c

    r4603 r4684  
    44
    55  Task *task;
    6   char *taskname;
    76
    87  if (argc != 2) goto usage;
    98
    10   taskname = GetCurrentTask ();
    11   if (taskname == NULL) {
     9  task = GetNewTask ();
     10  if (task == NULL) {
    1211    fprintf (stderr, "ERROR: not defining or running a task\n");
    13     return (FALSE);
    14   }
    15   task = FindTask (taskname);
    16   if (task == NULL) {
    17     fprintf (stderr, "ERROR: current task not found??\n");
    1812    return (FALSE);
    1913  }

  • trunk/Ohana/src/opihi/pantasks/task_periods.c

    r4451 r4684  
    55  int N, Poll, Exec, Timeout;
    66  float PollValue, ExecValue, TimeoutValue;
    7   char *taskname;
    87  Task *task;
    98
    … …  
    3837  }
    3938
    40   taskname = GetCurrentTask ();
    41   if (taskname == NULL) {
     39  task = GetNewTask ();
     40  if (task == NULL) {
    4241    fprintf (stderr, "ERROR: not defining or running a task\n");
    43     return (FALSE);
    44   }
    45   task = FindTask (taskname);
    46   if (task == NULL) {
    47     fprintf (stderr, "ERROR: current task not found??\n");
    4842    return (FALSE);
    4943  }

  • trunk/Ohana/src/opihi/pantasks/task_trange.c

    r4602 r4684  
    66  Task *task;
    77  TimeRange range;
    8   char *taskname;
    98
    109  /* add a -reset option?
    … …  
    2423  if (argc != 3) goto usage;
    2524
    26   taskname = GetCurrentTask ();
    27   if (taskname == NULL) {
     25  task = GetNewTask ();
     26  if (task == NULL) {
    2827    fprintf (stderr, "ERROR: not defining or running a task\n");
    29     return (FALSE);
    30   }
    31   task = FindTask (taskname);
    32   if (task == NULL) {
    33     fprintf (stderr, "ERROR: current task not found??\n");
    3428    return (FALSE);
    3529  }
Note: See TracChangeset for help on using the changeset viewer.