Changeset 3376


Ignore:
Timestamp:
Feb 27, 2013 9:39:10 PM (10 years ago)
Author:
gah
Message:

new version of stats file handling without file locking

Location:
trunk
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/gui/scripts/molvisviewer.tcl

    r3330 r3376  
    11071107            # what data objects are using the renderer until be get here.
    11081108            global env
    1109             lappend out "hub" [exec hostname]
     1109            set hub [exec hostname]
    11101110            lappend out "viewer" "molvisviewer"
    11111111            if { [info exists env(USER)] } {
    11121112                lappend out "user" $env(USER)
    11131113            }
     1114            set session "unknown"
    11141115            if { [info exists env(SESSION)] } {
    1115                 lappend out "session" $env(SESSION)
     1116                set session $env(SESSION)
    11161117            }
    11171118            set parent [$_first parent -as object]
     
    11261127            lappend out "tool_revision" \
    11271128                [$xmlobj get tool.version.application.revision]
    1128             SendCmd "clientinfo $out"
     1129            SendCmd "clientinfo $hub/$session [list $out]"
    11291130        }
    11301131
  • trunk/gui/scripts/vtkheightmapviewer.tcl

    r3374 r3376  
    989989            lappend out "tool_title"   [$_first hints toolTitle]
    990990            lappend out "tool_dataset" [$_first hints label]
    991             SendCmd "clientinfo [list $out]"
     991            SendCmd "clientinfo $hub/$user/$session [list $out]"
    992992        }
    993993        set _fieldNames [$_first hints fieldnames]
  • trunk/packages/vizservers/nanovis/Command.cpp

    r3362 r3376  
    749749 *      Log initial values to stats file.
    750750 *       
     751 *      clientinfo path list
    751752 */
    752753static int
     
    756757    Tcl_DString ds;
    757758    int result;
    758     int i;
     759    int i, numElems;
     760    Tcl_Obj **elems;
    759761    char buf[BUFSIZ];
    760 
     762    static int first = 1;
     763
     764    if (objc != 3) {
     765        Tcl_AppendResult(interp, "wrong # of arguments: should be \"",
     766                Tcl_GetString(objv[0]), " path list\"", (char *)NULL);
     767        return TCL_ERROR;
     768    }
     769#ifdef KEEPSTATS
     770    const char *path;
     771
     772    path = Tcl_GetString(objv[1]);
     773    if (NanoVis::openStatsFile(path) < 0) {
     774        Tcl_AppendResult(interp, "can't open stats file: ",
     775                Tcl_PosixError(interp), (char *)NULL);
     776        return TCL_ERROR;
     777    }
     778#endif
    761779    Tcl_DStringInit(&ds);
    762     Tcl_DStringAppendElement(&ds, "render_start");
     780    if (first) {
     781        Tcl_DStringAppendElement(&ds, "render_start");
     782        first = 0;
     783    } else {
     784        Tcl_DStringAppendElement(&ds, "render_info");
     785    }
    763786    /* renderer */
    764787    Tcl_DStringAppendElement(&ds, "renderer");
     
    783806    Tcl_DStringAppendElement(&ds, buf);
    784807    /* Client arguments. */
    785     for (i = 1; i < objc; i++) {
    786         Tcl_DStringAppendElement(&ds, Tcl_GetString(objv[i]));
     808    if (Tcl_ListObjGetElements(interp, objv[2], &numElems, &elems) != TCL_OK) {
     809        return TCL_ERROR;
     810    }
     811    for (i = 0; i < numElems; i++) {
     812        Tcl_DStringAppendElement(&ds, Tcl_GetString(elems[i]));
    787813    }
    788814    Tcl_DStringAppend(&ds, "\n", 1);
     815
    789816#ifdef KEEPSTATS
    790817    result = NanoVis::writeToStatsFile(Tcl_DStringValue(&ds),
  • trunk/packages/vizservers/nanovis/nanovis.cpp

    r3362 r3376  
    143143FILE *NanoVis::recfile = NULL;
    144144
     145int NanoVis::statsFile = -1;
     146
    145147bool NanoVis::axisOn = true;
    146148bool NanoVis::debugFlag = false;
     
    293295
    294296#define STATSDIR        "/var/tmp/visservers"
    295 #define STATSFILE       STATSDIR "/" "nanovis_log.tcl"
    296 #define LOCKFILE        STATSDIR "/" "LCK..nanovis"
    297297
    298298static int
    299 getFileLock()
    300 {
    301     int numTries;
    302 
    303     for (numTries = 0; numTries < 10; numTries++) {
    304         int f;
    305 
    306         f = open(LOCKFILE, O_TRUNC | O_CREAT | O_EXCL | O_WRONLY, 0600);
    307         if (f >= 0) {
    308             char buf[200];
    309             ssize_t numWritten;
    310             size_t numBytes;
    311 
    312             sprintf(buf, "%d\n", getpid());
    313             numBytes = strlen(buf);
    314             numWritten = write(f, buf, numBytes);
    315             if (numWritten != (ssize_t)numBytes) {
    316                 ERROR("Wrote short lock file");
    317             }
    318             close(f);
    319             return 0;
    320         }
    321         sleep(1);                       /* Wait for lock to release. */
    322     }
    323     ERROR("Failed to open lock file");
    324     return -1;
    325 }
    326 
    327 static void
    328 releaseFileLock()
    329 {
    330     unlink(LOCKFILE);
     299SplitPath(const char *path, int *argcPtr, char ***argvPtr)
     300{
     301    char **array;
     302    int count;
     303    char *p;
     304    char *s;
     305    size_t addrsize;
     306
     307    count = 0;
     308    for (p = strchr((char *)path, '/'); p != NULL; p = strchr(p+1, '/')) {
     309        count++;
     310    }
     311    addrsize = (count + 1) * sizeof(char *);
     312    array = (char **)malloc(addrsize + strlen(path) + 1);
     313    s = (char *)array + addrsize;
     314    strcpy(s, path);
     315   
     316    count = 0;
     317    for (p = strtok(s, "/"); p != NULL; p = strtok(NULL, "/")) {
     318        array[count++] = p;
     319    }
     320    *argcPtr = count;
     321    *argvPtr = array;
     322    return count;
     323}
     324
     325int
     326NanoVis::openStatsFile(const char *path)
     327{
     328    Tcl_DString ds;
     329    char **argv;
     330    int argc;
     331    int i;
     332    const char *fileName;
     333    char string[200];
     334
     335    Tcl_DStringInit(&ds);
     336    Tcl_DStringAppend(&ds, STATSDIR, -1);
     337    SplitPath(path, &argc, &argv);
     338    for (i = 0; i < argc; i++) {
     339        char *p;
     340
     341        Tcl_DStringAppend(&ds, "/", 1);
     342        Tcl_DStringAppend(&ds, argv[i], -1);
     343        p = Tcl_DStringValue(&ds);
     344        if (access(p, X_OK) != 0) {
     345            mkdir(p, 0770);
     346        }
     347    }
     348    Tcl_DStringAppend(&ds, "/", 1);
     349    sprintf(string, "%d", getpid());
     350    Tcl_DStringAppend(&ds, string, -1);
     351    fileName = Tcl_DStringValue(&ds);
     352    free(argv);
     353    statsFile = open(fileName, O_EXCL | O_CREAT | O_WRONLY, 0600);
     354    Tcl_DStringFree(&ds);
     355    if (statsFile < 0) {
     356        ERROR("can't open \"%s\": %s", fileName, strerror(errno));
     357        return -1;
     358    }
     359    return statsFile;
    331360}
    332361
     
    334363NanoVis::writeToStatsFile(const char *s, size_t length)
    335364{
    336     int f;
    337365    ssize_t numWritten;
    338     if (access(STATSDIR, X_OK) != 0) {
    339         mkdir(STATSDIR, 0770);
    340     }
    341     if (getFileLock() < 0) {
    342         return -1;
    343     }
    344     f = open(STATSFILE, O_APPEND | O_CREAT | O_WRONLY, 0600);
    345     releaseFileLock();
    346     if (f < 0) {
    347         return -1;
    348     }
    349     numWritten = write(f, s, length);
    350     if (numWritten != (ssize_t)length) {
    351         close(f);
    352         return -1;
    353     }
    354     close(f);
     366
     367    if (statsFile >= 0) {
     368        numWritten = write(statsFile, s, length);
     369        if (numWritten == (ssize_t)length) {
     370            close(dup(statsFile));
     371        }
     372    }
    355373    return 0;
    356374}
  • trunk/packages/vizservers/nanovis/nanovis.h

    r3362 r3376  
    9797
    9898#ifdef KEEPSTATS
     99    static int openStatsFile(const char *path);
    99100    static int writeToStatsFile(const char *s, size_t length);
    100101#endif
     
    152153
    153154    static FILE *stdin, *logfile, *recfile;
    154 
     155    static int statsFile;
    155156    static unsigned int flags;
    156157    static bool debugFlag;
  • trunk/packages/vizservers/pymolproxy/pymolproxy2.c

    r3330 r3376  
    9595static int recording = FALSE;
    9696static int pymolIsAlive = TRUE;
     97static int statsFile = -1;
    9798
    9899#define WANT_DEBUG      0
     
    114115#define IO_TIMEOUT (30000)
    115116#define STATSDIR        "/var/tmp/visservers"
    116 #define STATSFILE       STATSDIR "/" "pymol_log.tcl"
    117 #define LOCKFILE        STATSDIR "/" "LCK..pymol"
    118117#define CVT2SECS(x)  ((double)(x).tv_sec) + ((double)(x).tv_usec * 1.0e-6)
    119118
     
    546545}
    547546
    548 static int
    549 GetFileLock()
    550 {
    551     int numTries;
    552 
    553     for (numTries = 0; numTries < 10; numTries++) {
    554         int f;
    555 
    556         f = open(LOCKFILE, O_TRUNC | O_CREAT | O_EXCL | O_WRONLY, 0600);
    557         if (f >= 0) {
    558             char buf[200];
    559             ssize_t numWritten;
    560             size_t numBytes;
    561 
    562             sprintf(buf, "%d\n", getpid());
    563             numBytes = strlen(buf);
    564             numWritten = write(f, buf, numBytes);
    565             if (numWritten != (ssize_t)numBytes) {
    566                 ERROR("Wrote short lock file");
    567             }
    568             close(f);
    569             return 0;
    570         }
    571         sleep(1);                       /* Wait for lock to release. */
    572     }
    573     ERROR("Failed to open lock file");
    574     return -1;
    575 }
    576 
    577 static void
    578 ReleaseFileLock()
    579 {
    580     unlink(LOCKFILE);
    581 }
    582 
    583 static int
    584 WriteToStatsFile(const char *s, size_t length)
    585 {
    586     int f;
     547
     548#define STATSDIR        "/var/tmp/visservers"
     549
     550static int
     551SplitPath(const char *path, int *argcPtr, char ***argvPtr)
     552{
     553    char **array;
     554    int count;
     555    char *p;
     556    char *s;
     557    size_t addrsize;
     558
     559    count = 0;
     560    for (p = strchr((char *)path, '/'); p != NULL; p = strchr(p+1, '/')) {
     561        count++;
     562    }
     563    addrsize = (count + 1) * sizeof(char *);
     564    array = (char **)malloc(addrsize + strlen(path) + 1);
     565    s = (char *)array + addrsize;
     566    strcpy(s, path);
     567   
     568    count = 0;
     569    for (p = strtok(s, "/"); p != NULL; p = strtok(NULL, "/")) {
     570        array[count++] = p;
     571    }
     572    *argcPtr = count;
     573    *argvPtr = array;
     574    return count;
     575}
     576
     577static int
     578OpenStatsFile(const char *path)
     579{
     580    Tcl_DString ds;
     581    char **argv;
     582    int argc;
     583    int i;
     584    const char *fileName;
     585    char string[200];
    587586
    588587    if (access(STATSDIR, X_OK) != 0) {
    589588        mkdir(STATSDIR, 0770);
    590589    }
    591     if (GetFileLock() < 0) {
     590    SplitPath(path, &argc, &argv);
     591    Tcl_DStringInit(&ds);
     592    Tcl_DStringAppend(&ds, STATSDIR, -1);
     593    for (i = 0; i < argc; i++) {
     594        char *p;
     595
     596        Tcl_DStringAppend(&ds, "/", 1);
     597        Tcl_DStringAppend(&ds, argv[i], -1);
     598        p = Tcl_DStringValue(&ds);
     599        if (access(p, X_OK) != 0) {
     600            mkdir(p, 0770);
     601        }
     602    }
     603    Tcl_DStringAppend(&ds, "/", 1);
     604    sprintf(string, "%d", getpid());
     605    Tcl_DStringAppend(&ds, string, -1);
     606    fileName = Tcl_DStringValue(&ds);
     607    free(argv);
     608    statsFile = open(fileName, O_CREAT | O_EXCL | O_WRONLY, 0600);
     609    Tcl_DStringFree(&ds);
     610    if (statsFile < 0) {
     611        ERROR("can't open \"%s\": %s", fileName, strerror(errno));
    592612        return -1;
    593613    }
    594     f = open(STATSFILE, O_APPEND | O_CREAT | O_WRONLY, 0600);
    595     ReleaseFileLock();
    596     if (f < 0) {
    597         return -1;
    598     }
    599     if (write(f, s, length) != (ssize_t)length) {
    600         close(f);
    601         return -1;
    602     }
    603     close(f);
     614    return statsFile;
     615}
     616
     617static int
     618WriteToStatsFile(const char *s, size_t length)
     619{
     620    ssize_t numWritten;
     621
     622    if (statsFile >= 0) {
     623        numWritten = write(statsFile, s, length);
     624        if (numWritten == (ssize_t)length) {
     625            close(dup(statsFile));
     626        }
     627    }
    604628    return 0;
    605629}
     
    897921 * ClientInfoCmd --
    898922 *
    899  *      info "hub" value "session" value "date" value name value name value
    900923 *       
     924 *      clientinfo path list
    901925 */
    902926static int
     
    906930    Tcl_DString ds;
    907931    int result;
    908     int i;
     932    int i, numElems;
     933    const char **elems;
    909934    char buf[BUFSIZ];
    910 
     935    static int first = 1;
     936
     937    if (argc != 3) {
     938        Tcl_AppendResult(interp, "wrong # of arguments: should be \"", argv[0],
     939                " path list\"", (char *)NULL);
     940        return TCL_ERROR;
     941    }
     942    if ((statsFile == -1) && (OpenStatsFile(argv[1]) < 0)) {
     943        Tcl_AppendResult(interp, "can't open stats file: ",
     944                         Tcl_PosixError(interp), (char *)NULL);
     945        return TCL_ERROR;
     946    }
    911947    Tcl_DStringInit(&ds);
    912     Tcl_DStringAppendElement(&ds, "render_start");
     948    if (first) {
     949        Tcl_DStringAppendElement(&ds, "render_start");
     950        first = 0;
     951    } else {
     952        Tcl_DStringAppendElement(&ds, "render_info");
     953    }
    913954    /* renderer */
    914955    Tcl_DStringAppendElement(&ds, "renderer");
     
    932973    sprintf(buf, "%ld", stats.start.tv_sec);
    933974    Tcl_DStringAppendElement(&ds, buf);
     975
    934976    /* Client arguments. */
    935     for (i = 1; i < argc; i++) {
    936         Tcl_DStringAppendElement(&ds, argv[i]);
    937     }
     977    if (Tcl_SplitList(interp, argv[2], &numElems, &elems) != TCL_OK) {
     978        return TCL_ERROR;
     979    }
     980    for (i = 0; i < numElems; i++) {
     981        Tcl_DStringAppendElement(&ds, elems[i]);
     982    }
     983    free(elems);
    938984    Tcl_DStringAppend(&ds, "\n", 1);
    939985    result = WriteToStatsFile(Tcl_DStringValue(&ds), Tcl_DStringLength(&ds));
Note: See TracChangeset for help on using the changeset viewer.