Midas Elog Functions (el_xxx)


Functions

INT el_submit (int run, const char *author, const char *type, const char *syst, const char *subject, const char *text, const char *reply_to, const char *encoding, const char *afilename1, char *buffer1, INT buffer_size1, const char *afilename2, char *buffer2, INT buffer_size2, const char *afilename3, char *buffer3, INT buffer_size3, char *tag, INT tag_size)


Function Documentation

INT el_submit ( int  run,
const char *  author,
const char *  type,
const char *  syst,
const char *  subject,
const char *  text,
const char *  reply_to,
const char *  encoding,
const char *  afilename1,
char *  buffer1,
INT  buffer_size1,
const char *  afilename2,
char *  buffer2,
INT  buffer_size2,
const char *  afilename3,
char *  buffer3,
INT  buffer_size3,
char *  tag,
INT  tag_size 
)

Submit an ELog entry.

Parameters:
run Run Number.
author Message author.
type Message type.
syst Message system.
subject Subject.
text Message text.
reply_to In reply to this message.
encoding Text encoding, either HTML or plain.
afilename1 File name of attachment.
buffer1 File contents.
buffer_size1 Size of buffer in bytes.
afilename2 File name of attachment.
buffer2 File contents.
buffer_size2 Size of buffer in bytes.
afilename3 File name of attachment.
buffer3 File contents.
buffer_size3 Size of buffer in bytes.
tag If given, edit existing message.
tag_size Maximum size of tag.
Returns:
EL_SUCCESS

Definition at line 81 of file elog.c.

Referenced by rpc_server_dispatch(), and submit_elog().

00086 {
00087    if (rpc_is_remote())
00088       return rpc_call(RPC_EL_SUBMIT, run, author, type, syst, subject,
00089                       text, reply_to, encoding,
00090                       afilename1, buffer1, buffer_size1,
00091                       afilename2, buffer2, buffer_size2, afilename3, buffer3, buffer_size3, tag, tag_size);
00092 
00093 #ifdef LOCAL_ROUTINES
00094    {
00095       INT n, size, fh, status, run_number, semaphore, buffer_size = 0, idx, offset = 0, tail_size = 0;
00096       struct tm *tms = NULL;
00097       char afilename[256], file_name[256], afile_name[3][256], dir[256], str[256],
00098           start_str[80], end_str[80], last[80], date[80], thread[80], attachment[256];
00099       HNDLE hDB;
00100       time_t now;
00101       char message[10000], *p;
00102       char *buffer = NULL;
00103       BOOL bedit;
00104 
00105       cm_get_experiment_database(&hDB, NULL);
00106 
00107       bedit = (tag[0] != 0);
00108 
00109       /* request semaphore */
00110       cm_get_experiment_semaphore(NULL, &semaphore, NULL, NULL);
00111       status = ss_semaphore_wait_for(semaphore, 5 * 60 * 1000);
00112       if (status != SS_SUCCESS) {
00113          cm_msg(MERROR, "el_submit", "Cannot lock experiment semaphore, ss_semaphore_wait_for() status %d", status);
00114          abort();
00115       }
00116 
00117       /* get run number from ODB if not given */
00118       if (run > 0)
00119          run_number = run;
00120       else {
00121          /* get run number */
00122          size = sizeof(run_number);
00123          status = db_get_value(hDB, 0, "/Runinfo/Run number", &run_number, &size, TID_INT, TRUE);
00124          assert(status == SUCCESS);
00125       }
00126 
00127       if (run_number < 0) {
00128          cm_msg(MERROR, "el_submit", "aborting on attempt to use invalid run number %d", run_number);
00129          abort();
00130       }
00131 
00132       for (idx = 0; idx < 3; idx++) {
00133          /* generate filename for attachment */
00134          afile_name[idx][0] = file_name[0] = 0;
00135 
00136          if (idx == 0) {
00137             strcpy(afilename, afilename1);
00138             buffer = buffer1;
00139             buffer_size = buffer_size1;
00140          } else if (idx == 1) {
00141             strcpy(afilename, afilename2);
00142             buffer = buffer2;
00143             buffer_size = buffer_size2;
00144          } else if (idx == 2) {
00145             strcpy(afilename, afilename3);
00146             buffer = buffer3;
00147             buffer_size = buffer_size3;
00148          }
00149 
00150          if (afilename[0]) {
00151             strcpy(file_name, afilename);
00152             p = file_name;
00153             while (strchr(p, ':'))
00154                p = strchr(p, ':') + 1;
00155             while (strchr(p, '\\'))
00156                p = strchr(p, '\\') + 1; /* NT */
00157             while (strchr(p, '/'))
00158                p = strchr(p, '/') + 1;  /* Unix */
00159             while (strchr(p, ']'))
00160                p = strchr(p, ']') + 1;  /* VMS */
00161 
00162             /* assemble ELog filename */
00163             if (p[0]) {
00164                dir[0] = 0;
00165                if (hDB > 0) {
00166                   size = sizeof(dir);
00167                   memset(dir, 0, size);
00168                   status = db_get_value(hDB, 0, "/Logger/Elog dir", dir, &size, TID_STRING, FALSE);
00169                   if (status != DB_SUCCESS)
00170                      db_get_value(hDB, 0, "/Logger/Data dir", dir, &size, TID_STRING, TRUE);
00171 
00172                   if (dir[0] != 0 && dir[strlen(dir) - 1] != DIR_SEPARATOR)
00173                      strcat(dir, DIR_SEPARATOR_STR);
00174                }
00175 #if !defined(OS_VXWORKS)
00176 #if !defined(OS_VMS)
00177                tzset();
00178 #endif
00179 #endif
00180 
00181                time(&now);
00182                tms = localtime(&now);
00183 
00184                strcpy(str, p);
00185                sprintf(afile_name[idx], "%02d%02d%02d_%02d%02d%02d_%s",
00186                        tms->tm_year % 100, tms->tm_mon + 1, tms->tm_mday,
00187                        tms->tm_hour, tms->tm_min, tms->tm_sec, str);
00188                sprintf(file_name, "%s%02d%02d%02d_%02d%02d%02d_%s", dir,
00189                        tms->tm_year % 100, tms->tm_mon + 1, tms->tm_mday,
00190                        tms->tm_hour, tms->tm_min, tms->tm_sec, str);
00191 
00192                /* save attachment */
00193                fh = open(file_name, O_CREAT | O_RDWR | O_BINARY, 0644);
00194                if (fh < 0) {
00195                   cm_msg(MERROR, "el_submit", "Cannot write attachment file \"%s\"", file_name);
00196                } else {
00197                   write(fh, buffer, buffer_size);
00198                   close(fh);
00199                }
00200             }
00201          }
00202       }
00203 
00204       /* generate new file name YYMMDD.log in data directory */
00205       cm_get_experiment_database(&hDB, NULL);
00206 
00207       size = sizeof(dir);
00208       memset(dir, 0, size);
00209       status = db_get_value(hDB, 0, "/Logger/Elog dir", dir, &size, TID_STRING, FALSE);
00210       if (status != DB_SUCCESS)
00211          db_get_value(hDB, 0, "/Logger/Data dir", dir, &size, TID_STRING, TRUE);
00212 
00213       if (dir[0] != 0 && dir[strlen(dir) - 1] != DIR_SEPARATOR)
00214          strcat(dir, DIR_SEPARATOR_STR);
00215 
00216 #if !defined(OS_VXWORKS)
00217 #if !defined(OS_VMS)
00218       tzset();
00219 #endif
00220 #endif
00221 
00222       if (bedit) {
00223          /* edit existing message */
00224          strcpy(str, tag);
00225          if (strchr(str, '.')) {
00226             offset = atoi(strchr(str, '.') + 1);
00227             *strchr(str, '.') = 0;
00228          }
00229          sprintf(file_name, "%s%s.log", dir, str);
00230          fh = open(file_name, O_CREAT | O_RDWR | O_BINARY, 0644);
00231          if (fh < 0) {
00232             ss_semaphore_release(semaphore);
00233             return EL_FILE_ERROR;
00234          }
00235          lseek(fh, offset, SEEK_SET);
00236          read(fh, str, 16);
00237          assert(strncmp(str, "$Start$", 7) == 0);
00238 
00239          size = atoi(str + 9);
00240          read(fh, message, size);
00241 
00242          el_decode(message, "Date: ", date, sizeof(date));
00243          el_decode(message, "Thread: ", thread, sizeof(thread));
00244          el_decode(message, "Attachment: ", attachment, sizeof(attachment));
00245 
00246          /* buffer tail of logfile */
00247          lseek(fh, 0, SEEK_END);
00248          tail_size = TELL(fh) - (offset + size);
00249 
00250          if (tail_size > 0) {
00251             buffer = (char *) M_MALLOC(tail_size);
00252             if (buffer == NULL) {
00253                close(fh);
00254                ss_semaphore_release(semaphore);
00255                return EL_FILE_ERROR;
00256             }
00257 
00258             lseek(fh, offset + size, SEEK_SET);
00259             n = read(fh, buffer, tail_size);
00260             assert(n == tail_size);
00261          }
00262          lseek(fh, offset, SEEK_SET);
00263       } else {
00264          /* create new message */
00265          time(&now);
00266          tms = localtime(&now);
00267 
00268          sprintf(file_name, "%s%02d%02d%02d.log", dir, tms->tm_year % 100, tms->tm_mon + 1, tms->tm_mday);
00269 
00270          fh = open(file_name, O_CREAT | O_RDWR | O_BINARY, 0644);
00271          if (fh < 0) {
00272             ss_semaphore_release(semaphore);
00273             return EL_FILE_ERROR;
00274          }
00275 
00276          strcpy(date, ctime(&now));
00277          date[24] = 0;
00278 
00279          if (reply_to[0])
00280             sprintf(thread, "%16s %16s", reply_to, "0");
00281          else
00282             sprintf(thread, "%16s %16s", "0", "0");
00283 
00284          lseek(fh, 0, SEEK_END);
00285       }
00286 
00287       /* compose message */
00288 
00289       sprintf(message, "Date: %s\n", date);
00290       sprintf(message + strlen(message), "Thread: %s\n", thread);
00291       sprintf(message + strlen(message), "Run: %d\n", run_number);
00292       sprintf(message + strlen(message), "Author: %s\n", author);
00293       sprintf(message + strlen(message), "Type: %s\n", type);
00294       sprintf(message + strlen(message), "System: %s\n", syst);
00295       sprintf(message + strlen(message), "Subject: %s\n", subject);
00296 
00297       /* keep original attachment if edit and no new attachment */
00298       if (bedit && afile_name[0][0] == 0 && afile_name[1][0] == 0 && afile_name[2][0] == 0)
00299          sprintf(message + strlen(message), "Attachment: %s", attachment);
00300       else {
00301          sprintf(message + strlen(message), "Attachment: %s", afile_name[0]);
00302          if (afile_name[1][0])
00303             sprintf(message + strlen(message), ",%s", afile_name[1]);
00304          if (afile_name[2][0])
00305             sprintf(message + strlen(message), ",%s", afile_name[2]);
00306       }
00307       sprintf(message + strlen(message), "\n");
00308 
00309       sprintf(message + strlen(message), "Encoding: %s\n", encoding);
00310       sprintf(message + strlen(message), "========================================\n");
00311       strcat(message, text);
00312 
00313       assert(strlen(message) < sizeof(message));        /* bomb out on array overrun. */
00314 
00315       size = 0;
00316       sprintf(start_str, "$Start$: %6d\n", size);
00317       sprintf(end_str, "$End$:   %6d\n\f", size);
00318 
00319       size = strlen(message) + strlen(start_str) + strlen(end_str);
00320 
00321       if (tag != NULL && !bedit)
00322          sprintf(tag, "%02d%02d%02d.%d", tms->tm_year % 100, tms->tm_mon + 1, tms->tm_mday, (int) TELL(fh));
00323 
00324       /* size has to fit in 6 digits */
00325       assert(size < 999999);
00326 
00327       sprintf(start_str, "$Start$: %6d\n", size);
00328       sprintf(end_str, "$End$:   %6d\n\f", size);
00329 
00330       write(fh, start_str, strlen(start_str));
00331       write(fh, message, strlen(message));
00332       write(fh, end_str, strlen(end_str));
00333 
00334       if (bedit) {
00335          if (tail_size > 0) {
00336             n = write(fh, buffer, tail_size);
00337             M_FREE(buffer);
00338          }
00339 
00340          /* truncate file here */
00341 #ifdef OS_WINNT
00342          chsize(fh, TELL(fh));
00343 #else
00344          ftruncate(fh, TELL(fh));
00345 #endif
00346       }
00347 
00348       close(fh);
00349 
00350       /* if reply, mark original message */
00351       if (reply_to[0] && !bedit) {
00352          strcpy(last, reply_to);
00353          do {
00354             status = el_search_message(last, &fh, FALSE);
00355             if (status == EL_SUCCESS) {
00356                /* position to next thread location */
00357                lseek(fh, 72, SEEK_CUR);
00358                memset(str, 0, sizeof(str));
00359                read(fh, str, 16);
00360                lseek(fh, -16, SEEK_CUR);
00361 
00362                /* if no reply yet, set it */
00363                if (atoi(str) == 0) {
00364                   sprintf(str, "%16s", tag);
00365                   write(fh, str, 16);
00366                   close(fh);
00367                   break;
00368                } else {
00369                   /* if reply set, find last one in chain */
00370                   strcpy(last, strtok(str, " "));
00371                   close(fh);
00372                }
00373             } else
00374                /* stop on error */
00375                break;
00376 
00377          } while (TRUE);
00378       }
00379 
00380       /* release elog semaphore */
00381       ss_semaphore_release(semaphore);
00382    }
00383 #endif                          /* LOCAL_ROUTINES */
00384 
00385    return EL_SUCCESS;
00386 }


Midas DOC Version 3.0.0 ---- PSI Stefan Ritt ----
Contributions: Pierre-Andre Amaudruz - Sergio Ballestrero - Suzannah Daviel - Doxygen - Peter Green - Qing Gu - Greg Hackman - Gertjan Hofman - Paul Knowles - Exaos Lee - Rudi Meier - Glenn Moloney - Dave Morris - John M O'Donnell - Konstantin Olchanski - Renee Poutissou - Tamsen Schurman - Andreas Suter - Jan M.Wouters - Piotr Adam Zolnierczuk