IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
May 3, 2010, 8:50:52 AM (16 years ago)
Author:
eugene
Message:

updates from trunk

Location:
branches/simtest_nebulous_branches
Files:
75 edited
17 copied

Legend:

Unmodified
Added
Removed

  • branches/simtest_nebulous_branches

  • branches/simtest_nebulous_branches/ippTools/src

    • Property svn:ignore

      •  

        old new  
         1*.la
         2*.lo
        13.deps
        24.gdb_history
        … …  
        46Makefile
        57Makefile.in
         8addtool
         9caltool
         10camtool
         11chiptool
        612config.h
        713config.h.in
        8 stamp-h1
        9 *.la
        10 *.lo
         14detselect
         15dettool
         16difftool
         17disttool
         18dqstatstool
         19faketool
         20flatcorr
         21guidetool
         22magicdstool
         23magictool
         24pstamptool
         25pubtool
         26pxadmin
         27pxdata.c
         28pxinject
        1129pxtoolsErrorCodes.c
        1230pxtoolsErrorCodes.h
        13 pxadmin
        14 pxinject
        15 pztool
        1631pzgetexp
        1732pzgetimfiles
         33pztool
         34receivetool
        1835regtool
        19 guidetool
        20 chiptool
        21 camtool
         36stacktool
         37stamp-h1
        2238warptool
        23 difftool
        24 stacktool
        25 faketool
        26 dettool
        27 detselect
        28 pxdata.c
        29 magictool
        30 magicdstool
        31 caltool
        32 flatcorr
        33 pstamptool
        34 disttool
        35 receivetool
        36 
        37 pubtool

  • branches/simtest_nebulous_branches/ippTools/src/Makefile.am

    r24512 r27840  
    11bin_PROGRAMS = \
     2        addtool \
    23        caltool \
    34        camtool \
    … …  
    89        disttool \
    910        flatcorr \
     11        dqstatstool \
    1012        magictool \
    1113        magicdstool \
    … …  
    2325        pubtool
    2426
    25 
    26 bin_SCRIPTS = \
    27         fakemagic
    28 
    2927pkginclude_HEADERS = \
     28        pxadd.h \
    3029        pxadmin.h \
    3130        pxcam.h \
    … …  
    3433        pxdata.h \
    3534        pxfake.h \
     35        pxdqstats.h
     36        pxmagic.h \
    3637        pxregister.h \
     38        pxspace.h \
    3739        pxtag.h \
    3840        pxtools.h \
    … …  
    4244
    4345noinst_HEADERS = \
     46        addtool.h \
    4447        caltool.h \
    4548        camtool.h \
    … …  
    5154        flatcorr.h \
    5255        faketool.h \
     56        dqstatstool.h \
    5357        magictool.h \
    5458        magicdstool.h \
    … …  
    6872libpxtools_la_LDFLAGS   = -release $(PACKAGE_VERSION)
    6973libpxtools_la_SOURCES   = \
     74        pxadd.c \
    7075        pxcam.c \
    7176        pxchip.c \
    … …  
    7580        pxfake.c \
    7681        pxfault.c \
     82        pxdqstats.c \
     83        pxmagic.c \
    7784        pxregister.c \
     85        pxspace.c \
    7886        pxtag.c \
    7987        pxtools.c \
    … …  
    97105    pstamptoolConfig.c
    98106
     107addtool_CFLAGS = $(PSLIB_CFLAGS) $(PSMODULES_CFLAGS) $(IPPDB_CFLAGS)
     108addtool_LDADD = $(PSLIB_LIBS) $(PSMODULES_LIBS) $(IPPDB_LIBS) libpxtools.la
     109addtool_SOURCES = \
     110    addtool.c \
     111    addtoolConfig.c
     112
    99113caltool_CFLAGS = $(PSLIB_CFLAGS) $(PSMODULES_CFLAGS) $(IPPDB_CFLAGS)
    100114caltool_LDADD = $(PSLIB_LIBS) $(PSMODULES_LIBS) $(IPPDB_LIBS) libpxtools.la
    … …  
    132146    faketool.c \
    133147    faketoolConfig.c
     148
     149dqstatstool_CFLAGS = $(PSLIB_CFLAGS) $(PSMODULES_CFLAGS) $(IPPDB_CFLAGS)
     150dqstatstool_LDADD = $(PSLIB_LIBS) $(PSMODULES_LIBS) $(IPPDB_LIBS) libpxtools.la
     151dqstatstool_SOURCES = \
     152    dqstatstool.c \
     153    dqstatstoolConfig.c
    134154
    135155magictool_CFLAGS = $(PSLIB_CFLAGS) $(PSMODULES_CFLAGS) $(IPPDB_CFLAGS)

  • branches/simtest_nebulous_branches/ippTools/src/caltoolConfig.c

    r18561 r27840  
    3838    config->modules = pmConfigRead(&argc, argv, NULL);
    3939    if (!config->modules) {
    40         psError(PS_ERR_UNKNOWN, false, "Can't find site configuration");
     40        psError(psErrorCodeLast(), false, "Can't find site configuration");
    4141        psFree(config);
    4242        return NULL;

  • branches/simtest_nebulous_branches/ippTools/src/camtool.c

    r24681 r27840  
    109109    psMetadata *where = psMetadataAlloc();
    110110    pxcamGetSearchArgs (config, where);
    111     pxAddLabelSearchArgs (config, where, "-label", "camRun.label", "==");
    112     PXOPT_COPY_STR(config->args, where, "-reduction", "camRun.reduction", "==");
     111    pxAddLabelSearchArgs (config, where, "-label", "chipRun.label", "=="); // define using chipRun label
     112    PXOPT_COPY_STR(config->args, where, "-reduction", "chipRun.reduction", "==");
    113113
    114114    if (!psListLength(where->list) &&
    115115        !psMetadataLookupBool(NULL, config->args, "-all")) {
    116116        psFree(where);
    117         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     117        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    118118        return false;
    119119    }
    … …  
    121121    PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", false, false);
    122122    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
     123    PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
     124    PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false);
    123125    PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false);
    124126    PXOPT_LOOKUP_STR(expgroup, config->args, "-set_expgroup", false, false);
    … …  
    126128    PXOPT_LOOKUP_STR(tess_id, config->args, "-set_tess_id", false, false);
    127129    PXOPT_LOOKUP_STR(end_stage, config->args, "-set_end_stage", false, false);
     130    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
    128131
    129132    // find the exp_id of all the exposures that we want to queue up.
    130133    psString query = pxDataGet("camtool_find_chip_id.sql");
    131134    if (!query) {
    132         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     135        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    133136        psFree(where);
    134137        return false;
    … …  
    181184        bool status;
    182185        char *end_stage = psMetadataLookupStr(&status, md, "end_stage");
    183         if (end_stage && strcasecmp(end_stage, "warp")) continue;
     186        if (end_stage && strcasecmp(end_stage, "warp")) continue;
    184187
    185188        char *raw_tess_id   = psMetadataLookupStr(&status, md, "tess_id");
    186         if (raw_tess_id || tess_id) continue;
     189        if (raw_tess_id || tess_id) continue;
    187190
    188191        char *label  = psMetadataLookupStr(&status, md, "label");
    … …  
    190193
    191194        if (!status) {
    192             psError(PS_ERR_UNKNOWN, false, "cannot queue analysis to WARP without a defined tess id: label: %s, exp_id %" PRId64, label, exp_id);
     195            psError(PS_ERR_UNKNOWN, false, "cannot queue analysis to WARP without a defined tess id: label: %s, exp_id %" PRId64, label, exp_id);
    193196            psFree(output);
    194197            return false;
    … …  
    196199    }
    197200
    198     // loop over our list of camRun rows
     201    // loop over our list of chipRun rows
    199202    for (long i = 0; i < psArrayLength(output); i++) {
    200203        psMetadata *md = output->data[i];
    201204
    202         camRunRow *row = camRunObjectFromMetadata(md);
     205        chipRunRow *row = chipRunObjectFromMetadata(md);
    203206        if (!row) {
    204             psError(PS_ERR_UNKNOWN, false, "failed to convert metadata into camRun");
     207            psError(PS_ERR_UNKNOWN, false, "failed to convert metadata into chipRun");
    205208            psFree(output);
    206209            return false;
    … …  
    212215                    workdir     ? workdir   : row->workdir,
    213216                    label       ? label     : row->label,
     217                    data_group  ? data_group: row->data_group,
     218                    dist_group  ? dist_group: row->dist_group,
    214219                    reduction   ? reduction : row->reduction,
    215220                    expgroup    ? expgroup  : row->expgroup,
    216221                    dvodb       ? dvodb     : row->dvodb,
    217222                    tess_id     ? tess_id   : row->tess_id,
    218                     end_stage   ? end_stage : row->end_stage
     223                    end_stage   ? end_stage : row->end_stage,
     224                    row->magicked,
     225                    note
    219226        )) {
    220227            if (!psDBRollback(config->dbh)) {
    … …  
    248255    PXOPT_COPY_S64(config->args, where, "-cam_id",    "camRun.cam_id", "==");
    249256    PXOPT_COPY_STR(config->args, where, "-label",     "camRun.label", "==");
     257    PXOPT_COPY_STR(config->args, where, "-data_group","camRun.data_group", "==");
    250258    PXOPT_COPY_STR(config->args, where, "-state",     "camRun.state", "==");
    251259    PXOPT_COPY_STR(config->args, where, "-reduction", "camRun.reduction", "==");
    252260
    253     if (!psListLength(where->list)
    254         && !psMetadataLookupBool(NULL, config->args, "-all")) {
     261    if (!psListLength(where->list)) {
    255262        psFree(where);
    256         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
    257         return false;
    258     }
    259 
    260     PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
    261     PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
    262 
    263     if ((!state) && (!label)) {
    264         psError(PXTOOLS_ERR_DATA, false, "parameters are required");
    265         psFree(where);
    266         return false;
    267     }
    268 
    269     if (state) {
    270         // set camRun.state to state
    271         if (!pxcamRunSetStateByQuery(config, where, state)) {
    272             psFree(where);
    273             return false;
    274         }
    275     }
    276 
    277     if (label) {
    278         // set camRun.label to label
    279         if (!pxcamRunSetLabelByQuery(config, where, label)) {
    280             psFree(where);
    281             return false;
    282         }
    283     }
    284 
     263        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     264        return false;
     265    }
     266    psString query = psStringCopy("UPDATE camRun JOIN chipRun USING(chip_id) JOIN rawExp USING(exp_id)");
     267
     268    // pxUpdateRun gets parameters from config->args and updates
     269    bool result = pxUpdateRun(config, where, &query, "camRun", "cam_id", "camProcessedExp", true);
     270    if (!result) {
     271        psError(psErrorCodeLast(), false, "pxUpdateRun failed");
     272    }
     273
     274    psFree(query);
    285275    psFree(where);
    286276
    287     return true;
     277    return result;
    288278}
    289279
    … …  
    304294    psString query = pxDataGet("camtool_find_pendingexp.sql");
    305295    if (!query) {
    306         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     296        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    307297        return false;
    308298    }
    … …  
    369359    psString query = pxDataGet("camtool_find_pendingimfile.sql");
    370360    if (!query) {
    371         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     361        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    372362        return false;
    373363    }
    … …  
    491481    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
    492482    PXOPT_LOOKUP_S16(quality, config->args, "-quality", false, false);
    493    
    494     PXOPT_LOOKUP_S64(magicked, config->args, "-magicked", false, false);
     483
     484//    Get this from the chipRun
     485//    PXOPT_LOOKUP_S64(magicked, config->args, "-magicked", false, false);
    495486
    496487    // generate restrictions
    … …  
    500491    psString query = pxDataGet("camtool_find_pendingexp.sql");
    501492    if (!query) {
    502         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     493        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    503494        return false;
    504495    }
    … …  
    535526        return false;
    536527    }
     528
     529    bool status;
     530    psS64 chip_magicked = psMetadataLookupS64(&status, output->data[0], "chip_magicked");
    537531
    538532    camRunRow *pendingRow = camRunObjectFromMetadata(output->data[0]);
    … …  
    615609    }
    616610
    617     // since there is only one exp per 'new' set camRun.state = 'full'
    618     if (!pxcamRunSetState(config, row->cam_id, "full", magicked)) {
    619         psError(PS_ERR_UNKNOWN, false, "failed to change camRun.state for cam_id: %" PRId64, row->cam_id);
    620         psFree(row);
    621         psFree(pendingRow);
    622         return false;
    623     }
    624 
    625     // NULL for end_stage means go as far as possible
    626     // EAM : skip here if fault != 0
    627     // Also, we can run fake even if tess_id is not defined
    628     if (fault || (pendingRow->end_stage && psStrcasestr(pendingRow->end_stage, "cam"))) {
     611    if (fault) {
    629612        psFree(row);
    630613        psFree(pendingRow);
    … …  
    635618        return true;
    636619    }
     620    // else continue on...
     621
     622    // since there is only one exp per 'new' set camRun.state = 'full'
     623    // propagate magicked state from chipRun
     624    if (!pxcamRunSetState(config, row->cam_id, "full", chip_magicked)) {
     625        psError(PS_ERR_UNKNOWN, false, "failed to change camRun.state for cam_id: %" PRId64, row->cam_id);
     626        psFree(row);
     627        psFree(pendingRow);
     628        return false;
     629    }
    637630    psFree(row);
    638     // else continue on...
     631
     632    // EAM:  NULL for end_stage means go as far as possible
     633    // Also, we can run fake even if tess_id is not defined
     634    if (pendingRow->end_stage && psStrcasestr(pendingRow->end_stage, "cam")) {
     635        psFree(pendingRow);
     636        if (!psDBCommit(config->dbh)) {
     637            psError(PS_ERR_UNKNOWN, false, "database error");
     638            return false;
     639        }
     640        return true;
     641    }
    639642
    640643    if (!pxfakeQueueByCamID(config,
    … …  
    642645            pendingRow->workdir,
    643646            pendingRow->label,
     647            pendingRow->data_group,
     648            pendingRow->dist_group,
    644649            pendingRow->reduction,
    645650            pendingRow->expgroup,
    646651            pendingRow->dvodb,
    647652            pendingRow->tess_id,
    648             pendingRow->end_stage
     653            pendingRow->end_stage,
     654            NULL    // note does not propagate
    649655    )) {
    650656        // rollback
    … …  
    656662        return false;
    657663    }
     664
    658665    psFree(pendingRow);
    659666
    … …  
    674681    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    675682    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
     683    PXOPT_LOOKUP_BOOL(pstamp_order, config->args, "-pstamp_order", false);
    676684
    677685    // generate restrictions
    … …  
    680688    PXOPT_COPY_S64(config->args, where, "-cam_id",    "camRun.cam_id",    "==");
    681689    pxAddLabelSearchArgs (config, where, "-label",    "camRun.label",     "==");
     690    pxAddLabelSearchArgs (config, where, "-data_group", "camRun.data_group",     "LIKE");
    682691    PXOPT_COPY_STR(config->args, where, "-reduction", "camRun.reduction", "==");
    683692
    684     if (!psListLength(where->list) &&
     693    psString where2 = NULL;
     694    if (!pxspaceAddWhere(config, &where2, "rawExp")) {
     695        psError(psErrorCodeLast(), false, "pxSpaceAddWhere failed");
     696        return false;
     697    }
     698    if (!pxmagicAddWhere(config, &where2, "chipRun")) {
     699        psError(psErrorCodeLast(), false, "pxSpaceAddWhere failed");
     700        return false;
     701    }
     702    if (!psListLength(where->list) && !where2 &&
    685703        !psMetadataLookupBool(NULL, config->args, "-all")) {
    686704        psFree(where);
    687         psError(PXTOOLS_ERR_DATA, false, "search parameters (or -all) are required");
     705        psError(PXTOOLS_ERR_CONFIG, false, "search parameters (or -all) are required");
    688706        return false;
    689707    }
    … …  
    691709    psString query = pxDataGet("camtool_find_processedexp.sql");
    692710    if (!query) {
    693         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     711        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    694712        return false;
    695713    }
    … …  
    699717        psStringAppend(&query, " WHERE %s", whereClause);
    700718        psFree(whereClause);
    701     } 
     719    }
    702720
    703721    // we either add AND (condition) or WHERE (condition):
    … …  
    705723        // list only faulted rows
    706724        psStringAppend(&query, " %s", " AND camProcessedExp.fault != 0");
    707     } 
     725    }
    708726    if (where->list && !faulted) {
    709727        // don't list faulted rows
    … …  
    713731        // list only faulted rows
    714732        psStringAppend(&query, " %s", " WHERE camProcessedExp.fault != 0");
    715     } 
     733    }
    716734    if (!where->list && !faulted) {
    717735        // don't list faulted rows
    … …  
    719737    }
    720738    psFree(where);
    721 
    722     // order by cam_id so that the postage stamp parser can easliy find the 'latest' astrometry
    723     psStringAppend(&query, " ORDER BY cam_id");
     739    if (where2) {
     740        psStringAppend(&query, " %s", where2);
     741        psFree(where2);
     742    }
     743
     744
     745    if (pstamp_order) {
     746        // put runs in order of exposure id with newest chip Runs first
     747        // The postage stamp parser depends on this behavior
     748        psStringAppend(&query, " ORDER BY exp_id, cam_id DESC");
     749    }
    724750
    725751    // treat limit == 0 as "no limit"
    … …  
    774800    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    775801        psFree(where);
    776         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     802        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    777803        return false;
    778804    }
    … …  
    787813        psString query = pxDataGet("camtool_reset_faulted_runs.sql");
    788814        if (!query) {
    789             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     815            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    790816            psFree(where);
    791817            return false;
    … …  
    819845                psError(PS_ERR_UNKNOWN, false, "database error");
    820846            }
    821             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     847            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    822848            psFree(where);
    823849            return false;
    … …  
    959985    psString query = pxDataGet("camtool_pendingcleanuprun.sql");
    960986    if (!query) {
    961         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     987        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    962988        return false;
    963989    }
    … …  
    10241050    psString query = pxDataGet("camtool_pendingcleanupexp.sql");
    10251051    if (!query) {
    1026         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1052        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10271053        return false;
    10281054    }
    … …  
    10851111    psString query = pxDataGet("camtool_donecleanup.sql");
    10861112    if (!query) {
    1087         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1113        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10881114        return false;
    10891115    }
    … …  
    11551181  }
    11561182
     1183  if (!pxExportVersion(config, f)) {
     1184    psError(PS_ERR_UNKNOWN, false, "failed to write dbversion output file");
     1185    return false;
     1186  }
     1187
    11571188  psMetadata *where = psMetadataAlloc();
    11581189  PXOPT_COPY_S64(config->args, where, "-cam_id", "cam_id", "==");
    … …  
    11661197    psString query = pxDataGet(tables[i].sqlFilename);
    11671198    if (!query) {
    1168       psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1199      psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11691200      return false;
    11701201    }
    … …  
    12351266  psMetadata *input = psMetadataConfigRead (NULL, &nFail, infile, false);
    12361267
    1237   fprintf (stdout, "---- input ----\n");
     1268#ifdef notdef
     1269  fprintf (stderr, "---- input ----\n");
    12381270  psMetadataPrint (stderr, input, 1);
     1271#endif
     1272
     1273  if (!pxCheckImportVersion(config, input)) {
     1274      psError(PS_ERR_UNKNOWN, false, "pxCheckImportVersion failed");
     1275      return false;
     1276  }
    12391277
    12401278  psMetadataItem *item = psMetadataLookup (input, "camRun");

  • branches/simtest_nebulous_branches/ippTools/src/camtoolConfig.c

    r24681 r27840  
    4242    config->modules = pmConfigRead(&argc, argv, NULL);
    4343    if (!config->modules) {
    44         psError(PS_ERR_UNKNOWN, false, "Can't find site configuration");
     44        psError(psErrorCodeLast(), false, "Can't find site configuration");
    4545        psFree(config);
    4646        return NULL;
    … …  
    6262    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_tess_id",        0, "define tess ID", NULL);
    6363    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_end_stage",      0, "define end stage", NULL);
    64     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-all",               0, "allow everything to be queued without search terms", false);
     64    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_data_group",     0, "define data group", NULL);
     65    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_dist_group",     0, "define dist group", NULL);
     66    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_note",           0, "define note", NULL);
    6567
    6668    // -updaterun
    … …  
    7173    pxcamSetSearchArgs(updaterunArgs);
    7274    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-cam_id",             0, "search by cam_id", 0);
    73     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label",              0, "search by camRun label", NULL);
    74     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state",              0, "search by camRun state", NULL);
     75    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label",              0, "search by camRun label", NULL);
     76    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-data_group",         0, "search by camRun data_group", NULL);
     77    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state",              0, "search by camRun state", NULL);
    7578    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-reduction",          0, "search by camRun reduction class", NULL);
    7679    psMetadataAddBool(updaterunArgs, PS_LIST_TAIL, "-all",               0, "allow everything to be queued without search terms", false);
    7780    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state",          0, "set state", NULL);
    7881    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_label",          0, "set label", NULL);
    79 
     82    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_data_group", 0,   "define new data_group", NULL);
     83    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_dist_group", 0,   "define new dist_group", NULL);
     84    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_note", 0,         "define new note", NULL);
    8085    // -pendingexp
    8186    psMetadata *pendingexpArgs = psMetadataAlloc();
    … …  
    174179    psMetadataAddS64(processedexpArgs, PS_LIST_TAIL, "-cam_id",   0,            "search by cam_id", 0);
    175180    psMetadataAddStr(processedexpArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by camRun label", NULL);
     181    psMetadataAddStr(processedexpArgs, PS_LIST_TAIL, "-data_group", PS_META_DUPLICATE_OK, "search by camRun data_group (LIKE comparison)", NULL);
    176182    psMetadataAddStr(processedexpArgs, PS_LIST_TAIL, "-reduction",0,            "search by camRun reduction class", NULL);
     183    pxspaceAddArguments(processedexpArgs);
     184    pxmagicAddArguments(processedexpArgs);
     185
     186    psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-pstamp_order",  0,      "order the results for the postage stamp server", false);
    177187
    178188    psMetadataAddU64(processedexpArgs, PS_LIST_TAIL, "-limit",    0,            "limit result set to N items", 0);

  • branches/simtest_nebulous_branches/ippTools/src/chiptool.c

    r24562 r27840  
    3636
    3737static bool definebyqueryMode(pxConfig *config);
     38static bool definecopyMode(pxConfig *config);
    3839static bool updaterunMode(pxConfig *config);
    3940static bool pendingimfileMode(pxConfig *config);
    … …  
    5455static bool tofullimfileMode(pxConfig *config);
    5556static bool topurgedimfileMode(pxConfig *config);
     57static bool toscrubbedimfileMode(pxConfig *config);
    5658static bool exportrunMode(pxConfig *config);
    5759static bool importrunMode(pxConfig *config);
     60static bool runstateMode(pxConfig *config);
     61static bool setimfiletoupdateMode(pxConfig *config);
     62static bool listrunMode(pxConfig *config);
    5863
    5964# define MODECASE(caseName, func) \
    … …  
    7580    switch (config->mode) {
    7681        MODECASE(CHIPTOOL_MODE_DEFINEBYQUERY,           definebyqueryMode);
     82        MODECASE(CHIPTOOL_MODE_DEFINECOPY,              definecopyMode);
    7783        MODECASE(CHIPTOOL_MODE_UPDATERUN,               updaterunMode);
    7884        MODECASE(CHIPTOOL_MODE_PENDINGIMFILE,           pendingimfileMode);
    … …  
    9399        MODECASE(CHIPTOOL_MODE_TOFULLIMFILE,            tofullimfileMode);
    94100        MODECASE(CHIPTOOL_MODE_TOPURGEDIMFILE,          topurgedimfileMode);
     101        MODECASE(CHIPTOOL_MODE_TOSCRUBBEDIMFILE,        toscrubbedimfileMode);
    95102        MODECASE(CHIPTOOL_MODE_EXPORTRUN,               exportrunMode);
    96103        MODECASE(CHIPTOOL_MODE_IMPORTRUN,               importrunMode);
     104        MODECASE(CHIPTOOL_MODE_RUNSTATE,                runstateMode);
     105        MODECASE(CHIPTOOL_MODE_SETIMFILETOUPDATE,       setimfiletoupdateMode);
     106        MODECASE(CHIPTOOL_MODE_LISTRUN,                 listrunMode);
    97107        default:
    98108            psAbort("invalid option (this should not happen)");
    … …  
    116126}
    117127
     128// Queue exposures for chip processing
     129static bool queue_exposures(pxConfig *config,  // Configuration
     130                            const psArray *exps, // Exposures information
     131                            const char *workdir, // Working directory, or NULL to inherit
     132                            const char *label,   // Label, or NULL to inherit
     133                            const char *data_group, // Data group, or NULL to inherit
     134                            const char *dist_group, // Distribution group, or NULL to inherit
     135                            const char *reduction, // Reduction class, or NULL to inherit
     136                            const char *expgroup,  // Exposure group
     137                            const char *dvodb,     // DVO database, or NULL to inherit
     138                            const char *tess_id,   // Tessellation identifier, or NULL to inherit
     139                            const char *end_stage,  // End stage, or NULL to inherit
     140                            const char *note        // Note
     141    )
     142{
     143    // start a transaction so we don't end up with an exp without any associted
     144    // imfiles
     145    if (!psDBTransaction(config->dbh)) {
     146        psError(PS_ERR_UNKNOWN, false, "database error");
     147        return false;
     148    }
     149
     150    // if end_stage is warp (or NULL), check for valid tess_id
     151    for (long i = 0; i < psArrayLength(exps); i++) {
     152        psMetadata *md = exps->data[i];
     153
     154        bool status;
     155        char *end_stage = psMetadataLookupStr(&status, md, "end_stage");
     156        if (end_stage && strcasecmp(end_stage, "warp")) continue;
     157
     158        char *raw_tess_id   = psMetadataLookupStr(&status, md, "tess_id");
     159        if (raw_tess_id || tess_id) continue;
     160
     161        char *label  = psMetadataLookupStr(&status, md, "label");
     162        psS64 exp_id = psMetadataLookupS64(&status, md, "exp_id");
     163
     164        if (!status) {
     165            psError(PS_ERR_UNKNOWN, false,
     166                    "cannot queue analysis to WARP without a defined tess id: label: %s, exp_id %" PRId64,
     167                    label, exp_id);
     168            return false;
     169        }
     170    }
     171
     172
     173# define GET_VALUE(PTYPE,CTYPE,VALUE,NAME)                              \
     174    PTYPE VALUE;                                                        \
     175    {                                                                   \
     176        bool status;                                                    \
     177        VALUE = psMetadataLookup##CTYPE(&status, md, NAME);             \
     178        if (!status) {                                                  \
     179            psError(PS_ERR_UNKNOWN, false, "failed to lookup value for %s", NAME); \
     180            return false;                                               \
     181        }                                                               \
     182    }
     183
     184    // loop over our list of exp_ids
     185    for (long i = 0; i < psArrayLength(exps); i++) {
     186        psMetadata *md = exps->data[i];
     187
     188        rawExpRow *row = rawExpObjectFromMetadata(md);
     189        if (!row) {
     190            psError(PS_ERR_UNKNOWN, false, "failed to convert metadata into chipRun");
     191            return false;
     192        }
     193
     194        GET_VALUE (psS64,    S64, exp_id,        "exp_id");
     195        GET_VALUE (psString, Str, raw_workdir,   "workdir");
     196        GET_VALUE (psString, Str, raw_label,     "label");
     197        GET_VALUE (psString, Str, raw_reduction, "reduction");
     198        // GET_VALUE (psString, Str, raw_expgroup,  "expgroup");
     199        GET_VALUE (psString, Str, raw_dvodb,     "dvodb");
     200        GET_VALUE (psString, Str, raw_tess_id,   "tess_id");
     201        GET_VALUE (psString, Str, raw_end_stage, "end_stage");
     202
     203        if (!row->exp_id) {
     204            psError(PS_ERR_UNKNOWN, false, "failed to find value for exp_id");
     205            return false;
     206        }
     207
     208        // queue the exp
     209        if (!pxchipQueueByExpTag(config,
     210                                 exp_id,
     211                                 workdir     ? workdir   : raw_workdir,
     212                                 label       ? label     : raw_label,
     213                                 data_group  ? data_group : (label ? label : raw_label),
     214                                 dist_group,
     215                                 reduction   ? reduction : raw_reduction,
     216                                 // expgroup    ? expgroup  : raw_expgroup,
     217                                 // XXX how does expgroup get defined?
     218                                 expgroup,
     219                                 dvodb       ? dvodb     : raw_dvodb,
     220                                 tess_id     ? tess_id   : raw_tess_id,
     221                                 end_stage   ? end_stage : raw_end_stage,
     222                                 note
     223                                 )) {
     224            if (!psDBRollback(config->dbh)) {
     225                psError(PS_ERR_UNKNOWN, false, "database error");
     226            }
     227            psError(PS_ERR_UNKNOWN, false,
     228                    "failed to trying to queue exp_id: %" PRId64, exp_id);
     229            return false;
     230        }
     231    }
     232
     233    if (!psDBCommit(config->dbh)) {
     234        psError(PS_ERR_UNKNOWN, false, "database error");
     235        return false;
     236    }
     237
     238    return true;
     239}
    118240
    119241static bool definebyqueryMode(pxConfig *config)
    … …  
    125247    psMetadata *where = psMetadataAlloc();
    126248    pxchipGetSearchArgs (config, where); // rawExp only
    127     pxAddLabelSearchArgs (config, where, "-label", "newExp.label", "LIKE");
     249    pxAddLabelSearchArgs (config, where, "-label", "newExp.label", "LIKE"); // define using newExp label
    128250
    129251    // psListLength(where->list) is at least 1 because exp_type defaults to "object"
    … …  
    131253    if ((psListLength(where->list) <= 1) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    132254        psFree(where);
    133         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     255        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    134256        return false;
    135257    }
    … …  
    142264    PXOPT_LOOKUP_STR(tess_id, config->args, "-set_tess_id", false, false);
    143265    PXOPT_LOOKUP_STR(end_stage, config->args, "-set_end_stage", false, false);
     266    PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false);
     267    PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
     268    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
    144269
    145270    // default
    … …  
    150275    psString query = pxDataGet("chiptool_find_rawexp.sql");
    151276    if (!query) {
    152         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     277        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    153278        psFree(where);
    154279        return false;
    … …  
    190315    }
    191316
    192     // start a transaction so we don't end up with an exp without any associted
    193     // imfiles
    194     if (!psDBTransaction(config->dbh)) {
    195         psError(PS_ERR_UNKNOWN, false, "database error");
    196         psFree(output);
    197         return false;
    198     }
    199 
    200     // if end_stage is warp (or NULL), check for valid tess_id
    201     for (long i = 0; i < psArrayLength(output); i++) {
    202         psMetadata *md = output->data[i];
    203 
    204         bool status;
    205         char *end_stage = psMetadataLookupStr(&status, md, "end_stage");
    206         if (end_stage && strcasecmp(end_stage, "warp")) continue;
    207 
    208         char *raw_tess_id   = psMetadataLookupStr(&status, md, "tess_id");
    209         if (raw_tess_id || tess_id) continue;
    210 
    211         char *label  = psMetadataLookupStr(&status, md, "label");
    212         psS64 exp_id = psMetadataLookupS64(&status, md, "exp_id");
    213 
    214         if (!status) {
    215             psError(PS_ERR_UNKNOWN, false, "cannot queue analysis to WARP without a defined tess id: label: %s, exp_id %" PRId64, label, exp_id);
     317    if (!queue_exposures(config, output, workdir, label, data_group, dist_group, reduction, expgroup,
     318                         dvodb, tess_id, end_stage, note)) {
     319        psError(psErrorCodeLast(), false, "Unable to queue exposures for chip.");
     320        psFree(output);
     321        return false;
     322    }
     323    psFree(output);
     324
     325    return true;
     326}
     327
     328static bool definecopyMode(pxConfig *config)
     329{
     330    PS_ASSERT_PTR_NON_NULL(config, NULL);
     331
     332    PXOPT_LOOKUP_S64(exp_id, config->args, "-exp_id", false, false);
     333
     334    psMetadata *where = psMetadataAlloc();
     335    pxchipGetSearchArgs (config, where); // rawExp only
     336    pxAddLabelSearchArgs (config, where, "-label", "chipOld.label", "LIKE");
     337
     338    // psListLength(where->list) is at least 1 because exp_type defaults to "object"
     339    // so we require a list longer than 1 entry
     340    if ((psListLength(where->list) <= 1) && !psMetadataLookupBool(NULL, config->args, "-all")) {
     341        psFree(where);
     342        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     343        return false;
     344    }
     345
     346    PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", true, false);
     347    PXOPT_LOOKUP_STR(label, config->args, "-set_label", true, false);
     348    PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false);
     349    PXOPT_LOOKUP_STR(expgroup, config->args, "-set_expgroup", false, false);
     350    PXOPT_LOOKUP_STR(dvodb, config->args, "-set_dvodb", false, false);
     351    PXOPT_LOOKUP_STR(tess_id, config->args, "-set_tess_id", false, false);
     352    PXOPT_LOOKUP_STR(end_stage, config->args, "-set_end_stage", false, false);
     353    PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false);
     354    PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
     355    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
     356
     357    // default
     358    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
     359    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     360
     361    // find the exp_id of all the exposures that we want to queue up.
     362    psString query = pxDataGet("chiptool_definecopy.sql");
     363    if (!query) {
     364        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     365        psFree(where);
     366        return false;
     367    }
     368
     369    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     370    psStringAppend(&query, " AND %s", whereClause);
     371
     372    psFree(whereClause);
     373    psFree(where);
     374
     375    if (!p_psDBRunQueryF(config->dbh, query, label)) {
     376        psError(PS_ERR_UNKNOWN, false, "database error");
     377        psFree(query);
     378        return false;
     379    }
     380    psFree(query);
     381
     382    psArray *output = p_psDBFetchResult(config->dbh);
     383    if (!output) {
     384        psError(PS_ERR_UNKNOWN, false, "database error");
     385        return false;
     386    }
     387    if (!psArrayLength(output)) {
     388        psTrace("chiptool", PS_LOG_INFO, "no rows found");
     389        psFree(output);
     390        return true;
     391    }
     392
     393    if (pretend) {
     394        // negative simple so the default is true
     395        if (!ippdbPrintMetadatas(stdout, output, "rawExp", !simple)) {
     396            psError(PS_ERR_UNKNOWN, false, "failed to print array");
    216397            psFree(output);
    217398            return false;
    218399        }
    219     }
    220 
    221 
    222 # define GET_VALUE(PTYPE,CTYPE,VALUE,NAME)                              \
    223     PTYPE VALUE;                                                        \
    224     { bool status;                                                      \
    225         VALUE = psMetadataLookup##CTYPE(&status, md, NAME);             \
    226         if (!status) {                                                  \
    227             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for %s", NAME); \
    228             psFree(output);                                             \
    229             return false;                                               \
    230         } }
    231 
    232     // loop over our list of exp_ids
    233     for (long i = 0; i < psArrayLength(output); i++) {
    234         psMetadata *md = output->data[i];
    235 
    236         rawExpRow *row = rawExpObjectFromMetadata(md);
    237         if (!row) {
    238             psError(PS_ERR_UNKNOWN, false, "failed to convert metadata into chipRun");
    239             psFree(output);
    240             return false;
    241         }
    242 
    243         GET_VALUE (psS64,    S64, exp_id,        "exp_id");
    244         GET_VALUE (psString, Str, raw_workdir,   "workdir");
    245         GET_VALUE (psString, Str, raw_label,     "label");
    246         GET_VALUE (psString, Str, raw_reduction, "reduction");
    247         // GET_VALUE (psString, Str, raw_expgroup,  "expgroup");
    248         GET_VALUE (psString, Str, raw_dvodb,     "dvodb");
    249         GET_VALUE (psString, Str, raw_tess_id,   "tess_id");
    250         GET_VALUE (psString, Str, raw_end_stage, "end_stage");
    251 
    252         if (!row->exp_id) {
    253             psError(PS_ERR_UNKNOWN, false, "failed to find value for exp_id");
    254             psFree(output);
    255             return false;
    256         }
    257 
    258         // queue the exp
    259         if (!pxchipQueueByExpTag(config,
    260                                  exp_id,
    261                                  workdir     ? workdir   : raw_workdir,
    262                                  label       ? label     : raw_label,
    263                                  reduction   ? reduction : raw_reduction,
    264                                  // expgroup    ? expgroup  : raw_expgroup,
    265                                  // XXX how does expgroup get defined?
    266                                  expgroup,
    267                                  dvodb       ? dvodb     : raw_dvodb,
    268                                  tess_id     ? tess_id   : raw_tess_id,
    269                                  end_stage   ? end_stage : raw_end_stage
    270                                  )) {
    271             if (!psDBRollback(config->dbh)) {
    272                 psError(PS_ERR_UNKNOWN, false, "database error");
    273             }
    274             psError(PS_ERR_UNKNOWN, false,
    275                     "failed to trying to queue exp_id: %" PRId64, exp_id);
    276             psFree(output);
    277             return false;
    278         }
     400        psFree(output);
     401        return true;
     402    }
     403
     404    if (!queue_exposures(config, output, workdir, label, data_group, dist_group, reduction, expgroup,
     405                         dvodb, tess_id, end_stage, note)) {
     406        psError(psErrorCodeLast(), false, "Unable to queue exposures for chip.");
     407        psFree(output);
     408        return false;
    279409    }
    280410    psFree(output);
    281 
    282     if (!psDBCommit(config->dbh)) {
    283         psError(PS_ERR_UNKNOWN, false, "database error");
    284         return false;
    285     }
    286411
    287412    return true;
    … …  
    299424    PXOPT_COPY_STR(config->args,  where, "-label",   "chipRun.label",   "==");
    300425    PXOPT_COPY_STR(config->args,  where, "-state",   "chipRun.state",   "==");
    301 
    302     if (!psListLength(where->list) &&
    303         !psMetadataLookupBool(NULL, config->args, "-all")) {
     426    PXOPT_COPY_STR(config->args,  where, "-data_group", "chipRun.data_group",   "==");
     427    PXOPT_COPY_STR(config->args,  where, "-dist_group", "chipRun.dist_group",   "==");
     428
     429    if (!psListLength(where->list)) {
    304430        psFree(where);
    305         where = NULL;
    306         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
    307         return false;
    308     }
    309 
    310     PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
    311     PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
    312 
    313     if ((!state) && (!label)) {
    314         psError(PXTOOLS_ERR_DATA, false, "parameters are required");
    315         psFree(where);
    316         return false;
    317     }
    318 
    319     if (state) {
    320         // set chipRun.state to state
    321         if (!pxchipRunSetStateByQuery(config, where, state)) {
    322             psFree(where);
    323             return false;
    324         }
    325     }
    326 
    327     if (label) {
    328         // set chipRun.label to label
    329         if (!pxchipRunSetLabelByQuery(config, where, label)) {
    330             psFree(where);
    331             return false;
    332         }
    333     }
    334 
     431        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     432        return false;
     433    }
     434    psString query = psStringCopy("UPDATE chipRun JOIN rawExp USING(exp_id) -- join hook %s\n");
     435
     436    // pxUpdateRun gets parameters from config->args and updates
     437    bool result = pxUpdateRun(config, where, &query, "chipRun", "chip_id", "chipProcessedImfile", true);
     438    if (!result) {
     439        psError(psErrorCodeLast(), false, "pxUpdateRun failed");
     440    }
     441
     442    psFree(query);
    335443    psFree(where);
    336444
    337     return true;
     445    return result;
    338446}
    339447
    … …  
    353461    psString query = pxDataGet("chiptool_pendingimfile.sql");
    354462    if (!query) {
    355         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     463        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    356464        return false;
    357465    }
    … …  
    593701    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    594702    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
     703    PXOPT_LOOKUP_BOOL(allfiles, config->args, "-allfiles", false);
     704    if (allfiles) {
     705        faulted = false;
     706    }
    595707
    596708    psMetadata *where = psMetadataAlloc();
    … …  
    601713    PXOPT_COPY_STR(config->args, where, "-reduction", "chipRun.reduction", "==");
    602714    pxAddLabelSearchArgs (config, where, "-label", "chipRun.label", "LIKE");
    603     PXOPT_COPY_S64(config->args, where, "-magicked", "chipRun.magicked", "==");
    604 
    605     if (!psListLength(where->list) &&
    606         !psMetadataLookupBool(NULL, config->args, "-all")) {
    607         psFree(where);
    608         psError(PXTOOLS_ERR_DATA, false, "search parameters (or -all) are required");
     715    pxAddLabelSearchArgs (config, where, "-data_group", "chipRun.data_group", "LIKE");
     716    PXOPT_COPY_S64(config->args, where, "-magicked", "chipProcessedImfile.magicked", "==");
     717
     718    psString where2 = NULL;
     719    pxmagicAddWhere(config, &where2, "chipProcessedImfile");
     720    // add cuts on ra and decl if supplied
     721    if (!pxspaceAddWhere(config, &where2, "rawExp")) {
     722        psError(psErrorCodeLast(), false, "pxSpaceAddWhere failed");
    609723        return false;
    610724    }
    … …  
    612726    psString query = pxDataGet("chiptool_processedimfile.sql");
    613727    if (!query) {
    614         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    615         return false;
    616     }
    617 
    618     if (where && psListLength(where->list)) {
     728        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     729        return false;
     730    }
     731
     732    if (psListLength(where->list)) {
    619733        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    620         psStringAppend(&query, " WHERE %s", whereClause);
     734        psStringAppend(&query, " WHERE %s %s", whereClause, where2 ? where2 : "");
    621735        psFree(whereClause);
     736    } else if (psMetadataLookupBool(NULL, config->args, "-all") || (faulted || where2)) {
     737        psStringAppend(&query, " WHERE chipRun.chip_id IS NOT NULL %s", where2 ? where2 : "");
     738    } else {
     739        psFree(where);
     740        psError(PXTOOLS_ERR_CONFIG, false, "search parameters (or -all) are required");
     741        return false;
    622742    }
    623743    psFree(where);
    … …  
    626746        // list only faulted rows
    627747        psStringAppend(&query, " %s", "AND chipProcessedImfile.fault != 0");
    628     } else {
     748    } else if (!allfiles) {
    629749        // don't list faulted rows
    630750        psStringAppend(&query, " %s", "AND chipProcessedImfile.fault = 0");
    … …  
    683803        && !psMetadataLookupBool(NULL, config->args, "-all")) {
    684804        psFree(where);
    685         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     805        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    686806        return false;
    687807    }
    … …  
    689809    psString query = pxDataGet("chiptool_revertprocessedimfile.sql");
    690810    if (!query) {
    691         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     811        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     812        psFree(where);
     813        return false;
     814    }
     815    psString query_update = pxDataGet("chiptool_revertupdatedimfile.sql");
     816    if (!query) {
     817        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    692818        psFree(where);
    693819        return false;
    … …  
    697823        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    698824        psStringAppend(&query, " AND %s", whereClause);
     825        psStringAppend(&query_update, " AND %s", whereClause);
    699826        psFree(whereClause);
    700827    }
    … …  
    708835    }
    709836    psFree(query);
     837    if (!p_psDBRunQuery(config->dbh, query_update)) {
     838        psError(PS_ERR_UNKNOWN, false, "database error");
     839        psFree(query_update);
     840        return false;
     841    }
     842    psFree(query_update);
    710843
    711844    return true;
    … …  
    719852    PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "==");
    720853    PXOPT_COPY_STR(config->args, where, "-class_id", "class_id", "==");
    721     PXOPT_LOOKUP_S16(fault, config->args, "-fault", true, false);
    722 
    723     if (!pxSetFaultCode(config->dbh, "chipProcessedImfile", where, fault)) {
     854    PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, NULL);
     855    if (psListLength(where->list) == 0) {
     856        psError(PS_ERR_UNKNOWN, true, "search parameters are required");
     857        return false;
     858    }
     859
     860    if (!state) {
     861      PXOPT_LOOKUP_S16(fault, config->args, "-fault", true, false);
     862
     863      if (!pxSetFaultCode(config->dbh, "chipProcessedImfile", where, fault)) {
    724864        psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    725865        return false;
    726     }
    727     psFree(where);
     866      }
     867      psFree(where);
     868    }
     869    else {
     870      if (!pxchipProcessedImfileSetStateByQuery(config,where,state)) {
     871        psError(PS_ERR_UNKNOWN, false, "failed to set chipProcessedImfile state");
     872        return(false);
     873      }
     874    }
     875
    728876
    729877    return true;
    … …  
    828976    psString query = pxDataGet("chiptool_unmasked.sql");
    829977    if (!query) {
    830         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     978        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    831979        return false;
    832980    }
    … …  
    9061054    psString query = pxDataGet("chiptool_pendingcleanuprun.sql");
    9071055    if (!query) {
    908         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1056        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    9091057        return false;
    9101058    }
    … …  
    9701118    psString query = pxDataGet("chiptool_pendingcleanupimfile.sql");
    9711119    if (!query) {
    972         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1120        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    9731121        return false;
    9741122    }
    … …  
    10311179    psString query = pxDataGet("chiptool_donecleanup.sql");
    10321180    if (!query) {
    1033         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1181        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10341182        return false;
    10351183    }
    … …  
    10891237    // make sure that the state string is valid
    10901238    if (!pxIsValidState(state)) {
    1091         psError(PXTOOLS_ERR_DATA, false, "%s is not a valid state", state);
     1239        psError(PXTOOLS_ERR_CONFIG, false, "%s is not a valid state", state);
    10921240        return false;
    10931241    }
    10941242
    10951243    psMetadata *where = psMetadataAlloc();
     1244    pxchipGetSearchArgs (config, where); // chipRun, chipProcessedImfile, rawExp
     1245    PXOPT_COPY_S64(config->args, where, "-chip_id", "chipRun.chip_id", "==");
     1246    PXOPT_COPY_STR(config->args, where, "-reduction", "chipRun.reduction", "==");
    10961247    pxAddLabelSearchArgs (config, where, "-label", "label", "==");
    10971248    PXOPT_COPY_STR(config->args, where, "-state", "state", "==");
    … …  
    10991250    psString query = pxDataGet("chiptool_run.sql");
    11001251    if (!query) {
    1101         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1252        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11021253        return false;
    11031254    }
    … …  
    11611312    psString query = pxDataGet("chiptool_completely_processed_exp.sql");
    11621313    if (!query) {
    1163         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1314        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11641315        return false;
    11651316    }
    … …  
    12331384                    chipRun->workdir,
    12341385                    chipRun->label,
     1386                    chipRun->data_group,
     1387                    chipRun->dist_group,
    12351388                    chipRun->reduction,
    12361389                    chipRun->expgroup,
    12371390                    chipRun->dvodb,
    12381391                    chipRun->tess_id,
    1239                     chipRun->end_stage
     1392                    chipRun->end_stage,
     1393                    chipRun->magicked,
     1394                    NULL    // note does not propagate
    12401395        )) {
    12411396           if (!psDBRollback(config->dbh)) {
    … …  
    12781433    }
    12791434
    1280     psString set_magic = "";
     1435    psString set_magicked_imfile = psStringCopy("");
     1436    psString set_magicked_run = psStringCopy("");
    12811437    if (!strcmp(data_state, "full")) {
    1282         // copy the magicked state from the input to the output when transitioning to full state
    1283         set_magic = "\n , chipProcessedImfile.magicked = rawImfile.magicked";
    1284     }
    1285 
    1286     // note only updates if chipRun.state = run_state
    1287     // XXX note that we have removed this constraint for now
    1288     if (!p_psDBRunQueryF(config->dbh, query, data_state, set_magic, chip_id, class_id)) {
     1438        // if (chipProcessedImfile.magicked < 0 and rawImfile.magicked = 0) leave magicked unchanged. This will
     1439        // block warp processing until destreaking has been done
     1440        // otherwise copy magicked from the rawImfile
     1441        // Same thing for chipRun/rawExp
     1442        psStringAppend(&set_magicked_imfile, "\n , chipProcessedImfile.magicked = IF((chipProcessedImfile.magicked < 0"
     1443                                      " AND rawImfile.magicked = 0), chipProcessedImfile.magicked, rawImfile.magicked)");
     1444        psStringAppend(&set_magicked_run, "\n , chipRun.magicked = IF((chipRun.magicked < 0 AND rawExp.magicked = 0), "
     1445                                      " chipRun.magicked, rawExp.magicked)");
     1446
     1447    } else if (!strcmp(data_state, "cleaned") || !strcmp(data_state, "purged")) {
     1448        // if magicked is non-zero set it to -1
     1449        // Once one imfile has been cleaned, the chipRun is no longer 'magicked'
     1450        psStringAppend(&set_magicked_imfile, "\n, chipProcessedImfile.magicked = IF(chipProcessedImfile.magicked = 0, 0, -1),"
     1451                                             " chipRun.magicked = IF(chipRun.magicked = 0, 0, -1)");
     1452    }
     1453
     1454    if (!p_psDBRunQueryF(config->dbh, query, data_state, set_magicked_imfile, chip_id, class_id)) {
    12891455        psFree(query);
    12901456        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    12971463    }
    12981464    psFree(query);
     1465    psFree(set_magicked_imfile);
     1466    psFree(set_magicked_run);
    12991467    if (psDBAffectedRows(config->dbh) < 1) {
    13001468        psError(PS_ERR_UNKNOWN, false, "should have affected atleast 1 row");
    … …  
    13031471
    13041472    query = pxDataGet("chiptool_change_exp_state.sql");
    1305     if (!p_psDBRunQueryF(config->dbh, query, data_state, chip_id, data_state)) {
     1473    if (!p_psDBRunQueryF(config->dbh, query, data_state, set_magicked_run, chip_id, data_state)) {
    13061474        psFree(query);
    13071475        // rollback
    … …  
    13331501    return change_imfile_data_state(config, "purged", "goto_purged");
    13341502}
    1335 
     1503static bool toscrubbedimfileMode(pxConfig *config)
     1504{
     1505  return change_imfile_data_state(config, "scrubbed", "goto_scrubbed");
     1506}
    13361507bool exportrunMode(pxConfig *config)
    13371508{
    … …  
    13571528  }
    13581529
     1530  if (!pxExportVersion(config, f)) {
     1531    psError(PS_ERR_UNKNOWN, false, "failed to write dbversion output file");
     1532    return false;
     1533  }
     1534
    13591535  psMetadata *where = psMetadataAlloc();
    13601536  PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "==");
    … …  
    13701546    psString query = pxDataGet(tables[i].sqlFilename);
    13711547    if (!query) {
    1372       psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1548      psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    13731549      return false;
    13741550    }
    … …  
    14061582
    14071583    if (clean) {
    1408         bool success = true; 
     1584        bool success = true;
    14091585        if (!strcmp(tables[i].tableName, "chipRun")) {
    14101586            success = pxSetStateCleaned("chipRun", "state", output);
    … …  
    14481624    psVector *identifiers = psVectorAllocEmpty(16, PS_TYPE_U64); // Identifiers inserted
    14491625
     1626    psMetadataIterator *iter = psMetadataIteratorAlloc(input, PS_LIST_HEAD, NULL);       // Iterator
     1627
     1628    if (!pxCheckImportVersion(config, input)) {
     1629        psError(PS_ERR_UNKNOWN, false, "pxCheckImportVersion failed");
     1630        return false;
     1631    }
     1632    // first item is the dbversion, skip it
     1633    psMetadataItem *dbversion =  psMetadataGetAndIncrement(iter);
     1634    (void) dbversion;
     1635
    14501636    if (!psDBTransaction(config->dbh)) {
    14511637        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    14531639    }
    14541640
    1455     psMetadataIterator *iter = psMetadataIteratorAlloc(input, PS_LIST_HEAD, NULL);       // Iterator
    14561641    psMetadataItem *item;               // Item from iteration
    14571642    while ((item = psMetadataGetAndIncrement(iter))) {
    … …  
    14821667    return true;
    14831668}
     1669
     1670static bool runstateMode(pxConfig *config)
     1671{
     1672    PS_ASSERT_PTR_NON_NULL(config, false);
     1673
     1674    psMetadata *where = psMetadataAlloc();
     1675    PXOPT_COPY_S64(config->args, where, "-chip_id",    "chipRun.chip_id", "==");
     1676    PXOPT_COPY_S64(config->args, where, "-exp_id",     "rawExp.exp_id", "==");
     1677    PXOPT_COPY_STR(config->args, where, "-exp_name",   "rawExp.exp_name", "==");
     1678    pxAddLabelSearchArgs (config, where, "-label",     "chipRun.label", "LIKE");
     1679
     1680//    PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
     1681    PXOPT_LOOKUP_BOOL(no_magic, config->args, "-no_magic", false);
     1682
     1683    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1684    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1685
     1686    psString query = pxDataGet("chiptool_runstate.sql");
     1687    if (!query) {
     1688        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1689        return false;
     1690    }
     1691
     1692    if (psListLength(where->list)) {
     1693        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1694        psStringAppend(&query, " WHERE %s", whereClause);
     1695        psFree(whereClause);
     1696    } else {
     1697        psError(PXTOOLS_ERR_CONFIG, true, "search parameters or -all are required");
     1698        return false;
     1699    }
     1700    psFree(where);
     1701
     1702    // treat limit == 0 as "no limit"
     1703    if (limit) {
     1704        psString limitString = psDBGenerateLimitSQL(limit);
     1705        psStringAppend(&query, " %s", limitString);
     1706        psFree(limitString);
     1707    }
     1708
     1709    if (!p_psDBRunQuery(config->dbh, query)) {
     1710        psError(PS_ERR_UNKNOWN, false, "database error");
     1711        psFree(query);
     1712        return false;
     1713    }
     1714    psFree(query);
     1715
     1716    psArray *output = p_psDBFetchResult(config->dbh);
     1717    if (!output) {
     1718        psErrorCode err = psErrorCodeLast();
     1719        switch (err) {
     1720            case PS_ERR_DB_CLIENT:
     1721                psError(PXTOOLS_ERR_SYS, false, "database error");
     1722            case PS_ERR_DB_SERVER:
     1723                psError(PXTOOLS_ERR_PROG, false, "database error");
     1724            default:
     1725                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     1726        }
     1727
     1728        return false;
     1729    }
     1730    if (!psArrayLength(output)) {
     1731        psTrace("chiptool", PS_LOG_INFO, "no rows found");
     1732        psFree(output);
     1733        return true;
     1734    }
     1735
     1736    if (psArrayLength(output)) {
     1737        // negative simple so the default is true
     1738        if (!ippdbPrintMetadatas(stdout, output, "chipRunState", !simple)) {
     1739            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1740            psFree(output);
     1741            return false;
     1742        }
     1743    }
     1744
     1745    psFree(output);
     1746
     1747    return true;
     1748}
     1749
     1750// a very specfic function to queue a cleaned chipProcessedImfile to be updated
     1751static bool setimfiletoupdateMode(pxConfig *config)
     1752{
     1753    PS_ASSERT_PTR_NON_NULL(config, NULL);
     1754
     1755    PXOPT_LOOKUP_S64(chip_id, config->args, "-chip_id", true, false);
     1756    PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", false, false);
     1757    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
     1758
     1759    psString query = pxDataGet("chiptool_setimfiletoupdate.sql");
     1760    if (!query) {
     1761        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1762        return false;
     1763    }
     1764
     1765    psString setHook = psStringCopy("");
     1766    if (label) {
     1767        psStringAppend(&setHook, "\n , chipRun.label = '%s'", label);
     1768    }
     1769
     1770    if (class_id) {
     1771        psStringAppend(&query, " AND (chipProcessedImfile.class_id = '%s')", class_id);
     1772    }
     1773
     1774    if (!p_psDBRunQueryF(config->dbh, query, setHook, chip_id)) {
     1775        psError(PS_ERR_UNKNOWN, false, "database error");
     1776        return false;
     1777    }
     1778
     1779    psFree(setHook);
     1780    psFree(query);
     1781
     1782    return true;
     1783}
     1784
     1785static bool listrunMode(pxConfig *config)
     1786{
     1787    PS_ASSERT_PTR_NON_NULL(config, NULL);
     1788
     1789    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1790    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1791    PXOPT_LOOKUP_BOOL(pstamp_order, config->args, "-pstamp_order", false);
     1792
     1793    psMetadata *where = psMetadataAlloc();
     1794    pxchipGetSearchArgs (config, where); // chipRun, chipProcessedImfile, rawExp
     1795    PXOPT_COPY_S64(config->args, where, "-chip_id", "chipRun.chip_id", "==");
     1796    PXOPT_COPY_STR(config->args, where, "-reduction", "chipRun.reduction", "==");
     1797    PXOPT_COPY_STR(config->args, where, "-state", "chipRun.state", "==");
     1798    pxAddLabelSearchArgs (config, where, "-label", "chipRun.label", "LIKE");
     1799    pxAddLabelSearchArgs (config, where, "-data_group", "chipRun.data_group", "LIKE");
     1800    pxAddLabelSearchArgs (config, where, "-dist_group", "chipRun.dist_group", "LIKE");
     1801    PXOPT_COPY_S64(config->args, where, "-magicked", "chipRun.magicked", "==");
     1802
     1803    psString where2 = NULL;
     1804    pxmagicAddWhere(config, &where2, "chipRun");
     1805    // add cuts on ra and decl if supplied
     1806    if (!pxspaceAddWhere(config, &where2, "rawExp")) {
     1807        psError(psErrorCodeLast(), false, "pxSpaceAddWhere failed");
     1808        return false;
     1809    }
     1810
     1811    psString query = pxDataGet("chiptool_listrun.sql");
     1812    if (!query) {
     1813        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1814        return false;
     1815    }
     1816
     1817    if (psListLength(where->list)) {
     1818        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1819        psStringAppend(&query, " WHERE %s %s", whereClause, where2 ? where2 : "");
     1820        psFree(whereClause);
     1821    } else if (psMetadataLookupBool(NULL, config->args, "-all") || where2) {
     1822        psStringAppend(&query, " WHERE chipRun.chip_id IS NOT NULL %s", where2 ? where2 : "");
     1823    } else {
     1824        psFree(where);
     1825        psError(PXTOOLS_ERR_CONFIG, false, "search parameters (or -all) are required");
     1826        return false;
     1827    }
     1828    psFree(where);
     1829
     1830    if (pstamp_order) {
     1831        // put runs in order of exposure id with newest chip Runs first
     1832        // The postage stamp parser depends on this behavior
     1833        psStringAppend(&query, "\nORDER by exp_id, chip_id DESC");
     1834    }
     1835
     1836    // treat limit == 0 as "no limit"
     1837    if (limit) {
     1838        psString limitString = psDBGenerateLimitSQL(limit);
     1839        psStringAppend(&query, " %s", limitString);
     1840        psFree(limitString);
     1841    }
     1842
     1843    if (!p_psDBRunQuery(config->dbh, query)) {
     1844        psError(PS_ERR_UNKNOWN, false, "database error");
     1845        psFree(query);
     1846        return false;
     1847    }
     1848    psFree(query);
     1849
     1850    psArray *output = p_psDBFetchResult(config->dbh);
     1851    if (!output) {
     1852        psError(PS_ERR_UNKNOWN, false, "database error");
     1853        return false;
     1854    }
     1855    if (!psArrayLength(output)) {
     1856        psTrace("chiptool", PS_LOG_INFO, "no rows found");
     1857        psFree(output);
     1858        return true;
     1859    }
     1860
     1861    // negative simple so the default is true
     1862    if (!ippdbPrintMetadatas(stdout, output, "chipRun", !simple)) {
     1863        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1864        psFree(output);
     1865        return false;
     1866    }
     1867
     1868    psFree(output);
     1869
     1870    return true;
     1871}

  • branches/simtest_nebulous_branches/ippTools/src/chiptool.h

    r23339 r27840  
    2626    CHIPTOOL_MODE_NONE      = 0x0,
    2727    CHIPTOOL_MODE_DEFINEBYQUERY,
     28    CHIPTOOL_MODE_DEFINECOPY,
    2829    CHIPTOOL_MODE_UPDATERUN,
    2930    CHIPTOOL_MODE_PENDINGIMFILE,
    … …  
    3233    CHIPTOOL_MODE_REVERTPROCESSEDIMFILE,
    3334    CHIPTOOL_MODE_UPDATEPROCESSEDIMFILE,
     35    CHIPTOOL_MODE_SETIMFILETOUPDATE,
    3436    CHIPTOOL_MODE_ADVANCEEXP,
    3537    CHIPTOOL_MODE_BLOCK,
    … …  
    4547    CHIPTOOL_MODE_TOFULLIMFILE,
    4648    CHIPTOOL_MODE_TOPURGEDIMFILE,
     49    CHIPTOOL_MODE_TOSCRUBBEDIMFILE,
    4750    CHIPTOOL_MODE_EXPORTRUN,
    48     CHIPTOOL_MODE_IMPORTRUN
     51    CHIPTOOL_MODE_IMPORTRUN,
     52    CHIPTOOL_MODE_RUNSTATE,
     53    CHIPTOOL_MODE_LISTRUN
    4954} chiptoolMode;
    5055

  • branches/simtest_nebulous_branches/ippTools/src/chiptoolConfig.c

    r24562 r27840  
    3939    config->modules = pmConfigRead(&argc, argv, NULL);
    4040    if (! config->modules) {
    41         psError(PS_ERR_UNKNOWN, false, "Can't find site configuration");
     41        psError(psErrorCodeLast(), false, "Can't find site configuration");
    4242        psFree(config);
    4343        return NULL;
    … …  
    5858    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_tess_id",  0,            "define tessellation identifier", NULL);
    5959    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_end_stage",  0,            "define end stage", NULL);
     60    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_data_group",  0,      "define data group", NULL);
     61    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_dist_group",  0,      "define distribution group", NULL);
     62    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_note",  0,           "define note", NULL);
    6063    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-pretend",  0,            "do not actually modify the database", false);
    6164    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    62     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);
     65
     66    // -definecopy
     67    psMetadata *definecopyArgs = psMetadataAlloc();
     68    pxchipSetSearchArgs (definecopyArgs);
     69    psMetadataAddStr(definecopyArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by rawExp label (LIKE comparison)", NULL);
     70
     71    psMetadataAddStr(definecopyArgs, PS_LIST_TAIL, "-exp_type", PS_META_REPLACE, "search by exp_type", "object");
     72
     73    psMetadataAddStr(definecopyArgs, PS_LIST_TAIL, "-set_workdir", 0, "define workdir (required)", NULL);
     74    psMetadataAddStr(definecopyArgs, PS_LIST_TAIL, "-set_label", 0, "define label (required)", NULL);
     75    psMetadataAddStr(definecopyArgs, PS_LIST_TAIL, "-set_reduction", 0, "define reduction class", NULL);
     76    psMetadataAddStr(definecopyArgs, PS_LIST_TAIL, "-set_expgroup", 0, "define exposure group", NULL);
     77    psMetadataAddStr(definecopyArgs, PS_LIST_TAIL, "-set_dvodb", 0, "define DVO db", NULL);
     78    psMetadataAddStr(definecopyArgs, PS_LIST_TAIL, "-set_tess_id", 0, "define tessellation identifier", NULL);
     79    psMetadataAddStr(definecopyArgs, PS_LIST_TAIL, "-set_end_stage", 0, "define end stage", NULL);
     80    psMetadataAddStr(definecopyArgs, PS_LIST_TAIL, "-set_data_group", 0, "define data group", NULL);
     81    psMetadataAddStr(definecopyArgs, PS_LIST_TAIL, "-set_dist_group", 0, "define distribution group", NULL);
     82    psMetadataAddStr(definecopyArgs, PS_LIST_TAIL, "-set_note", 0, "define note", NULL);
     83    psMetadataAddBool(definecopyArgs, PS_LIST_TAIL, "-pretend", 0, "do not actually modify the database", false);
     84    psMetadataAddBool(definecopyArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    6385
    6486    // -updaterun
    … …  
    6789    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-chip_id",              0,            "search by chip ID", 0);
    6890    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,            "search by state", NULL);
    69     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label",  0,          "search by label", NULL);
     91    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label",  0,           "search by label", NULL);
     92    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-data_group",  0,      "search by data_group", NULL);
     93    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-dist_group",  0,      "search by dist_group", NULL);
    7094    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state", 0,        "set state", NULL);
    7195    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_label", 0,        "set label", NULL);
    72     psMetadataAddBool(updaterunArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);
     96    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_data_group", 0,   "set data group", NULL);
     97    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_dist_group", 0,   "set dist group", NULL);
     98    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_note", 0,         "set note", NULL);
     99
     100    // -setimfiletoupdate
     101    psMetadata *setimfiletoupdateArgs = psMetadataAlloc();
     102    psMetadataAddS64(setimfiletoupdateArgs, PS_LIST_TAIL, "-chip_id", 0,   "search by chip ID (required)", 0);
     103    psMetadataAddStr(setimfiletoupdateArgs, PS_LIST_TAIL, "-class_id", 0,  "search by class_id (required)", NULL);
     104    psMetadataAddStr(setimfiletoupdateArgs, PS_LIST_TAIL, "-set_label",  0,"new value for label", NULL);
    73105
    74106    // -pendingimfile
    … …  
    148180    psMetadataAddS16(addprocessedimfileArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code", 0);
    149181    psMetadataAddS16(addprocessedimfileArgs, PS_LIST_TAIL, "-quality",  0,            "set quality", 0);
    150     psMetadataAddBool(addprocessedimfileArgs, PS_LIST_TAIL, "-magicked",  0,        "define magicked status", false);
     182    psMetadataAddS64(addprocessedimfileArgs, PS_LIST_TAIL, "-magicked",  0,        "define magicked status", 0);
    151183
    152184    // -processedimfile
    … …  
    158190    psMetadataAddStr(processedimfileArgs,  PS_LIST_TAIL, "-reduction",          0, "search by reduction class", NULL);
    159191    psMetadataAddStr(processedimfileArgs,  PS_LIST_TAIL, "-label",  PS_META_DUPLICATE_OK, "search by chipRun label (LIKE comparison)", NULL);
    160     psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-magicked",  0,        "search by magicked status", false);
     192    psMetadataAddStr(processedimfileArgs,  PS_LIST_TAIL, "-data_group",  PS_META_DUPLICATE_OK, "search by chipRun data_group (LIKE comparison)", NULL);
     193    pxmagicAddArguments(processedimfileArgs);
     194
    161195    psMetadataAddU64(processedimfileArgs,  PS_LIST_TAIL, "-limit",  0,           "limit result set to N items", 0);
    162196    psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-all",  0,            "list everything without search terms", false);
    163197    psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-faulted",  0,        "only return imfiles with a fault status set", false);
     198    psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-allfiles",  0,       "only all matching imfiles regardless of fault status", false);
    164199    psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-simple",  0,         "use the simple output format", false);
     200
     201    pxspaceAddArguments(processedimfileArgs);
    165202
    166203    // -revertprocessedimfile
    … …  
    179216    psMetadataAddStr(updateprocessedimfileArgs,  PS_LIST_TAIL, "-class_id",           0, "search by class ID", NULL);
    180217    psMetadataAddS16(updateprocessedimfileArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code (required)", 0);
     218    psMetadataAddStr(updateprocessedimfileArgs, PS_LIST_TAIL, "-set_state", 0,         "set state", NULL);
     219
     220    // -processedExp
     221    psMetadata *listrunArgs = psMetadataAlloc();
     222    pxchipSetSearchArgs(listrunArgs);
     223    psMetadataAddS64(listrunArgs, PS_LIST_TAIL, "-chip_id",  0,         "search by  chip ID", 0);
     224    psMetadataAddStr(listrunArgs,  PS_LIST_TAIL, "-reduction",          0, "search by reduction class", NULL);
     225    psMetadataAddStr(listrunArgs,  PS_LIST_TAIL, "-label",  PS_META_DUPLICATE_OK, "search by chipRun label (LIKE comparison)", NULL);
     226    psMetadataAddStr(listrunArgs,  PS_LIST_TAIL, "-state",              0, "search by chipRun state", NULL);
     227    psMetadataAddStr(listrunArgs,  PS_LIST_TAIL, "-data_group",  PS_META_DUPLICATE_OK, "search by chipRun data_group (LIKE comparison)", NULL);
     228    psMetadataAddStr(listrunArgs,  PS_LIST_TAIL, "-dist_group",  PS_META_DUPLICATE_OK, "search by chipRun dist_group (LIKE comparison)", NULL);
     229    pxmagicAddArguments(listrunArgs);
     230
     231    psMetadataAddBool(listrunArgs, PS_LIST_TAIL, "-pstamp_order",  0,    "order results for postage stamp server", false);
     232    psMetadataAddU64(listrunArgs,  PS_LIST_TAIL, "-limit",  0,           "limit result set to N items", 0);
     233    psMetadataAddBool(listrunArgs, PS_LIST_TAIL, "-all",  0,            "list everything without search terms", false);
     234    psMetadataAddBool(listrunArgs, PS_LIST_TAIL, "-simple",  0,         "use the simple output format", false);
     235    pxspaceAddArguments(listrunArgs);
    181236
    182237    // -block
    … …  
    226281    psMetadataAddU64(runArgs, PS_LIST_TAIL, "-limit",  0,       "limit result set to N items", 0);
    227282    psMetadataAddStr(runArgs, PS_LIST_TAIL, "-state", 0,        "search by state (required)", NULL);
     283    pxchipSetSearchArgs(runArgs);
     284    psMetadataAddS64(runArgs, PS_LIST_TAIL, "-chip_id",  0,         "search by  chip ID", 0);
     285    psMetadataAddStr(runArgs,  PS_LIST_TAIL, "-reduction",          0, "search by reduction class", NULL);
    228286
    229287    // -advanceexp
    … …  
    247305    psMetadataAddS64(topurgedimfileArgs, PS_LIST_TAIL, "-chip_id", 0,          "chip ID to update", 0);
    248306    psMetadataAddStr(topurgedimfileArgs, PS_LIST_TAIL, "-class_id",  0,        "class ID to update", NULL);
     307
     308    // -toscrubbedimfile
     309    psMetadata *toscrubbedimfileArgs = psMetadataAlloc();
     310    psMetadataAddS64(toscrubbedimfileArgs, PS_LIST_TAIL, "-chip_id", 0,        "chip ID to update", 0);
     311    psMetadataAddStr(toscrubbedimfileArgs, PS_LIST_TAIL, "-class_id", 0,       "class ID to update", NULL);
    249312
    250313    // -exportrun
    … …  
    260323    psMetadataAddStr(importrunArgs, PS_LIST_TAIL, "-infile",  0,          "import from this file (required)", NULL);
    261324
     325    // -runstate
     326    psMetadata *runstateArgs = psMetadataAlloc();
     327    psMetadataAddS64(runstateArgs, PS_LIST_TAIL, "-chip_id", 0,           "search by chip ID", 0);
     328    psMetadataAddS64(runstateArgs, PS_LIST_TAIL, "-exp_id", 0,            "search by exposure tag", 0);
     329    psMetadataAddStr(runstateArgs, PS_LIST_TAIL, "-exp_name", 0,          "search by exposure tag", 0);
     330    psMetadataAddStr(runstateArgs, PS_LIST_TAIL,  "-label",  PS_META_DUPLICATE_OK, "search by warpRun label", NULL);
     331    psMetadataAddBool(runstateArgs, PS_LIST_TAIL, "-no_magic",  0,        "magic is not necessary for result", false);
     332
     333    psMetadataAddU64(runstateArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     334    psMetadataAddBool(runstateArgs, PS_LIST_TAIL, "-simple",  0,          "use the simple output format", false);
     335
    262336    psMetadata *argSets = psMetadataAlloc();
    263337    psMetadata *modes = psMetadataAlloc();
    264338
    265339    PXOPT_ADD_MODE("-definebyquery",        "create runs from raw exposures",       CHIPTOOL_MODE_DEFINEBYQUERY,        definebyqueryArgs);
     340    PXOPT_ADD_MODE("-definecopy",           "create copy runs",                     CHIPTOOL_MODE_DEFINECOPY,        definecopyArgs);
    266341    PXOPT_ADD_MODE("-updaterun",            "change chip run properties",           CHIPTOOL_MODE_UPDATERUN,            updaterunArgs);
     342    PXOPT_ADD_MODE("-setimfiletoupdate",    "set imfile state to update",           CHIPTOOL_MODE_SETIMFILETOUPDATE,    setimfiletoupdateArgs);
    267343    PXOPT_ADD_MODE("-pendingimfile",        "show pending imfiles",                 CHIPTOOL_MODE_PENDINGIMFILE,        pendingimfileArgs);
    268344    PXOPT_ADD_MODE("-addprocessedimfile",   "add a processed imfile",               CHIPTOOL_MODE_ADDPROCESSEDIMFILE,   addprocessedimfileArgs);
    … …  
    270346    PXOPT_ADD_MODE("-updateprocessedimfile","change procesed imfile properties",    CHIPTOOL_MODE_UPDATEPROCESSEDIMFILE,updateprocessedimfileArgs);
    271347    PXOPT_ADD_MODE("-revertprocessedimfile","undo a processed imfile",              CHIPTOOL_MODE_REVERTPROCESSEDIMFILE,revertprocessedimfileArgs);
     348    PXOPT_ADD_MODE("-runstate",             "list the states of chip run",          CHIPTOOL_MODE_RUNSTATE,             runstateArgs);
     349    PXOPT_ADD_MODE("-listrun",              "list chipRuns",                        CHIPTOOL_MODE_LISTRUN,              listrunArgs);
    272350    PXOPT_ADD_MODE("-advanceexp",           "advance completed exposures",          CHIPTOOL_MODE_ADVANCEEXP,           advanceexpArgs);
    273351    PXOPT_ADD_MODE("-block",                "set a label block",                    CHIPTOOL_MODE_BLOCK,                blockArgs);
    … …  
    282360    PXOPT_ADD_MODE("-tofullimfile",         "set imfile state to full",              CHIPTOOL_MODE_TOFULLIMFILE,         tofullimfileArgs);
    283361    PXOPT_ADD_MODE("-topurgedimfile",       "set imfile state to purged",            CHIPTOOL_MODE_TOPURGEDIMFILE,       topurgedimfileArgs);
     362    PXOPT_ADD_MODE("-toscrubbedimfile",     "set imfile state to scrubbed",          CHIPTOOL_MODE_TOSCRUBBEDIMFILE,     toscrubbedimfileArgs);
    284363
    285364    PXOPT_ADD_MODE("-exportrun",            "export run for import on other database", CHIPTOOL_MODE_EXPORTRUN, exportrunArgs);
    … …  
    287366
    288367    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {
    289         psError(PS_ERR_UNKNOWN, true, "option parsing failed");
     368        psError(PS_ERR_UNKNOWN, false, "option parsing failed");
    290369        psFree(argSets);
    291370        psFree(modes);

  • branches/simtest_nebulous_branches/ippTools/src/detselect.c

    r23998 r27840  
    135135    psString query = pxDataGet("detselect_search.sql");
    136136    if (!query) {
    137         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    138         return false;
    139     }
    140 
    141     // use psDBGenerateWhereConditionalSQL with AND ... because the SQL ends in a WHERE
    142     if (where && psListLength(where->list)) {
    143         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    144         psStringAppend(&query, " AND %s", whereClause);
    145         psFree(whereClause);
    146     }
    147     psFree(where);
    148 
    149     // we choose the single detrend image which matches all criteria and has
    150     // the latest insertion date
    151 
    152     // unless explicitly specified by the user, list all possible matches
    153     if (!unlimit) {
    154         psStringAppend(&query, " ORDER BY registered DESC LIMIT 1");
    155     }
    156 
    157     if (!p_psDBRunQuery(config->dbh, query)) {
    158         psError(PS_ERR_UNKNOWN, false, "database error");
    159         psFree(query);
    160         return false;
    161     }
    162     psFree(query);
    163 
    164     psArray *output = p_psDBFetchResult(config->dbh);
    165     if (!output) {
    166         psError(PS_ERR_UNKNOWN, false, "database error");
    167         return false;
    168     }
    169     if (!psArrayLength(output)) {
    170         // XXX check psError here
    171         psError(PS_ERR_UNKNOWN, false, "no detrend exposures found");
    172         psFree(output);
    173         return true;
    174     }
    175 
    176     // negate simple so the default is true
    177     if (!ippdbPrintMetadatas(stdout, output, "detExp", !simple)) {
    178         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    179         psFree(output);
    180         return false;
    181     }
    182 
    183     psFree(output);
    184 
    185     return true;
    186 }
    187 
    188 static bool selectMode(pxConfig *config)
    189 {
    190     PS_ASSERT_PTR_NON_NULL(config, false);
    191 
    192     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    193 
    194     psMetadata *where = psMetadataAlloc();
    195     PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
    196     PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
    197     PXOPT_COPY_STR(config->args, where, "-class_id",  "class_id", "==");
    198 
    199     psString query = pxDataGet("detselect_select.sql");
    200     if (!query) {
    201         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     137        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    202138        return false;
    203139    }
    … …  
    211147    psFree(where);
    212148
     149    // we choose the single detrend image which matches all criteria and has
     150    // the latest insertion date
     151
     152    // unless explicitly specified by the user, list all possible matches
     153    if (!unlimit) {
     154        psStringAppend(&query, " ORDER BY registered DESC LIMIT 1");
     155    }
     156
     157    if (!p_psDBRunQuery(config->dbh, query)) {
     158        psError(PS_ERR_UNKNOWN, false, "database error");
     159        psFree(query);
     160        return false;
     161    }
     162    psFree(query);
     163
     164    psArray *output = p_psDBFetchResult(config->dbh);
     165    if (!output) {
     166        psError(PS_ERR_UNKNOWN, false, "database error");
     167        return false;
     168    }
     169    if (!psArrayLength(output)) {
     170        // XXX check psError here
     171        psError(PS_ERR_UNKNOWN, false, "no detrend exposures found");
     172        psFree(output);
     173        return true;
     174    }
     175
     176    // negate simple so the default is true
     177    if (!ippdbPrintMetadatas(stdout, output, "detExp", !simple)) {
     178        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     179        psFree(output);
     180        return false;
     181    }
     182
     183    psFree(output);
     184
     185    return true;
     186}
     187
     188static bool selectMode(pxConfig *config)
     189{
     190    PS_ASSERT_PTR_NON_NULL(config, false);
     191
     192    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     193
     194    psMetadata *where = psMetadataAlloc();
     195    PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
     196    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
     197    PXOPT_COPY_STR(config->args, where, "-class_id",  "class_id", "==");
     198
     199    psString query = pxDataGet("detselect_select.sql");
     200    if (!query) {
     201        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     202        return false;
     203    }
     204
     205    // use psDBGenerateWhereConditionalSQL with AND ... because the SQL ends in a WHERE
     206    if (where && psListLength(where->list)) {
     207        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     208        psStringAppend(&query, " AND %s", whereClause);
     209        psFree(whereClause);
     210    }
     211    psFree(where);
     212
    213213    if (!p_psDBRunQuery(config->dbh, query)) {
    214214        psError(PS_ERR_UNKNOWN, false, "database error");

  • branches/simtest_nebulous_branches/ippTools/src/dettool.c

    r24866 r27840  
    9494        MODECASE(DETTOOL_MODE_PENDINGCLEANUP_PROCESSEDEXP, pendingcleanup_processedexpMode);
    9595        MODECASE(DETTOOL_MODE_DONECLEANUP_PROCESSEDEXP, donecleanup_processedexpMode);
     96        MODECASE(DETTOOL_MODE_UPDATESTATE_PROCESSED, updatestateprocessedMode);
    9697        // stacked
    9798        MODECASE(DETTOOL_MODE_TOSTACKED,        tostackedMode);
    … …  
    142143        MODECASE(DETTOOL_MODE_PENDINGCLEANUP_RESIDEXP, pendingcleanup_residexpMode);
    143144        MODECASE(DETTOOL_MODE_DONECLEANUP_RESIDEXP, donecleanup_residexpMode);
     145        MODECASE(DETTOOL_MODE_UPDATESTATE_RESID, updatestateresidMode);
    144146        // detrunsummary
    145147        MODECASE(DETTOOL_MODE_TODETRUNSUMMARY,  todetrunsummaryMode);
    … …  
    150152        MODECASE(DETTOOL_MODE_UPDATEDETRUN,     updatedetrunMode);
    151153        MODECASE(DETTOOL_MODE_RERUN,            rerunMode);
     154        MODECASE(DETTOOL_MODE_PENDINGCLEANUP_DETRUNSUMMARY, pendingcleanup_detrunsummaryMode);
    152155        // register
    153156        MODECASE(DETTOOL_MODE_REGISTER_DETREND, register_detrendMode);
    … …  
    184187    psString query = pxDataGet("dettool_pending.sql");
    185188    if (!query) {
    186         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    187         return false;
    188     }
    189    
     189        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     190        return false;
     191    }
     192
    190193    psMetadata *where = psMetadataAlloc();
    191194    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    … …  
    257260        psError(PS_ERR_UNKNOWN, false, "verify mode requires both -ref_det_id and -ref_iter");
    258261        return false;
    259     } 
     262    }
    260263    if (strcmp(mode, "verify") && ((ref_det_id != 0) || (ref_iter != -1))) {
    261264        psError(PS_ERR_UNKNOWN, false, "master mode cannot have -ref_det_id or -ref_iter set");
    262265        return false;
    263     } 
    264        
     266    }
     267
    265268    PXOPT_LOOKUP_STR(camera, config->args, "-inst", false, false);
    266269    PXOPT_LOOKUP_STR(telescope, config->args, "-telescope", false, false);
    … …  
    307310        psMetadataItem *mItem = NULL;
    308311        while ((mItem = psListGetAndIncrement(iter))) {
    309             psS64 exp_id = mItem->data.S64;
     312            psS64 exp_id = mItem->data.S64;
    310313            if (!psMetadataAddS64(where, PS_LIST_TAIL, "exp_id", PS_META_DUPLICATE_OK, "==", exp_id)) {
    311314                psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    … …  
    316319        }
    317320        psFree(iter);
    318     } 
     321    }
    319322    if (item->type == PS_DATA_S64) {
    320         psS64 exp_id = item->data.S64;
    321         if (!psMetadataAddS64(where, PS_LIST_TAIL, "exp_id", PS_META_DUPLICATE_OK, "==", exp_id)) {
    322             psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    323             psFree(where);
    324             return false;
    325         }
    326     } 
     323        psS64 exp_id = item->data.S64;
     324        if (!psMetadataAddS64(where, PS_LIST_TAIL, "exp_id", PS_META_DUPLICATE_OK, "==", exp_id)) {
     325            psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
     326            psFree(where);
     327            return false;
     328        }
     329    }
    327330
    328331    if (psListLength(where->list) < 1) {
    … …  
    504507        psError(PS_ERR_UNKNOWN, false, "verify mode requires both -ref_det_id and -ref_iter");
    505508        return false;
    506     } 
     509    }
    507510    if (strcmp(mode, "verify") && ((ref_det_id != 0) || (ref_iter != -1))) {
    508511        psError(PS_ERR_UNKNOWN, false, "master mode cannot have -ref_det_id or -ref_iter set");
    509512        return false;
    510     } 
     513    }
    511514
    512515    PXOPT_LOOKUP_STR(filelevel, config->args, "-filelevel", false, false);
    … …  
    549552    PXOPT_COPY_F32(config->args, where, "-select_airmass_max", "airmass", "<=");
    550553    PXOPT_COPY_F32(config->args, where, "-select_sat_pixel_frac_max", "sat_pixel_frac", "<=");
     554    PXOPT_COPY_F32(config->args, where, "-select_sat_pixel_frac_min", "sat_pixel_frac", ">=");
    551555    PXOPT_COPY_F32(config->args, where, "-select_exp_time_min", "exp_time", ">=");
    552556    PXOPT_COPY_F32(config->args, where, "-select_exp_time_max", "exp_time", "<=");
    … …  
    672676                 label,
    673677                 ref_det_id,
    674                 ref_iter
     678                ref_iter
    675679        );
    676680    psS64 det_id = psDBLastInsertID(config->dbh);
    … …  
    741745{
    742746    PS_ASSERT_PTR_NON_NULL(config, false);
    743    
     747
    744748    // XXX this mode is not well-tested: probably need to specify iteration here
    745749    PXOPT_LOOKUP_S64(det_id, config->args, "-det_id", true, false); // required
    … …  
    758762        psError(PS_ERR_UNKNOWN, false, "verify mode requires both -ref_det_id and -ref_iter");
    759763        return false;
    760     } 
     764    }
    761765    if (strcmp(mode, "verify") && ((ref_det_id != 0) || (ref_iter != -1))) {
    762766        psError(PS_ERR_UNKNOWN, false, "master mode cannot have -ref_det_id or -ref_iter set");
    763767        return false;
    764     } 
     768    }
    765769
    766770    // the new detRun may have different values for these limits:
    … …  
    816820
    817821    if (iteration < 0) {
    818         iteration = detRun->iteration;
     822        iteration = detRun->iteration;
    819823    }
    820824
    … …  
    976980    psString query = pxDataGet("dettool_definebydetrun.sql");
    977981    if (!query) {
    978         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     982        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    979983        return false;
    980984    }
    … …  
    988992
    989993    if (only_accepted) {
    990         psStringAppend(&query, " AND accept = 1");
     994        psStringAppend(&query, " AND accept = 1");
    991995    }
    992996
    … …  
    10671071    psString query = pxDataGet("dettool_runs.sql");
    10681072    if (!query) {
    1069         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1073        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10701074        return false;
    10711075    }
    … …  
    11371141    psString query = pxDataGet("dettool_childlessrun.sql");
    11381142    if (!query) {
    1139         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1143        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11401144        psFree(where);
    11411145        return false;
    … …  
    12111215    psString query = pxDataGet("dettool_input.sql");
    12121216    if (!query) {
    1213         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1217        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    12141218        psFree(where);
    12151219        return false;
    … …  
    12631267    psString query = pxDataGet("dettool_raw.sql");
    12641268    if (!query) {
    1265         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1269        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    12661270        return false;
    12671271    }
    … …  
    13371341}
    13381342
    1339 // used by updatedetrunMode 
     1343// used by updatedetrunMode
    13401344bool startNewIteration(pxConfig *config, psS64 det_id)
    13411345{
    … …  
    13441348    psString query = pxDataGet("dettool_start_new_iteration.sql");
    13451349    if (!query) {
    1346         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1350        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    13471351        return false;
    13481352    }
    … …  
    15631567        }
    15641568        detInputExpRow *newInputExp = detInputExpRowAlloc(
    1565             det_id,
     1569            det_id,
    15661570            newIteration,
    15671571            inputExp->exp_id,
    … …  
    16611665                      solang_max,
    16621666                      label,
    1663                       ref_det_id,
    1664                       ref_iter
     1667                      ref_det_id,
     1668                      ref_iter
    16651669            )) {
    16661670        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    17121716{
    17131717    PS_ASSERT_PTR_NON_NULL(config, false);
    1714    
     1718
    17151719    PXOPT_LOOKUP_S64(det_id, config->args, "-det_id", true, false); // required
    17161720    PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false); // required
    … …  
    17271731
    17281732    if (!detRegisteredImfileInsert(config->dbh,
    1729                                    det_id,
    1730                                    0,  // the iteration is fixed at 0
    1731                                    class_id,
    1732                                    uri,
    1733                                    bg,
    1734                                    bg_stdev,
    1735                                    bg_mean_stdev,
    1736                                    user_1,
    1737                                    user_2,
    1738                                    user_3,
    1739                                    user_4,
    1740                                    user_5,
    1741                                    path_base,
    1742                                    "full",                                 
    1743                                    0       // fault code
    1744             )) {
     1733                                   det_id,
     1734                                   0,  // the iteration is fixed at 0
     1735                                   class_id,
     1736                                   uri,
     1737                                   bg,
     1738                                   bg_stdev,
     1739                                   bg_mean_stdev,
     1740                                   user_1,
     1741                                   user_2,
     1742                                   user_3,
     1743                                   user_4,
     1744                                   user_5,
     1745                                   path_base,
     1746                                   "full",
     1747                                   0       // fault code
     1748            )) {
    17451749        psError(PS_ERR_UNKNOWN, false, "database error");
    17461750        return false;
    … …  
    18271831    if (!strcmp(data_state, "drop")) return true;
    18281832    if (!strcmp(data_state, "register")) return true;
     1833    // These are valid data states, and are necessary for the cleanup to work correctly.
     1834    if (!strcmp(data_state, "full")) return true;
     1835    if (!strcmp(data_state, "goto_cleaned")) return true;
     1836    if (!strcmp(data_state, "goto_scrubbed")) return true;
     1837    if (!strcmp(data_state, "goto_purged")) return true;
     1838    if (!strcmp(data_state, "cleaned")) return true;
     1839    if (!strcmp(data_state, "scrubbed")) return true;
     1840    if (!strcmp(data_state, "purged")) return true;
     1841    if (!strcmp(data_state, "error_cleaned")) return true;
     1842    if (!strcmp(data_state, "error_scrubbed")) return true;
     1843    if (!strcmp(data_state, "error_purged")) return true;
    18291844
    18301845    psError(PS_ERR_UNKNOWN, true, "invalid data state: %s", data_state);
    … …  
    18461861
    18471862
    1848 bool setProcessedImfileDataState(pxConfig *config, psS64 det_id, psS64 exp_id, const char *class_id, const char *data_state)
     1863bool setProcessedImfileDataState(pxConfig *config, psMetadata *where, const char *data_state)
    18491864{
    18501865    PS_ASSERT_PTR_NON_NULL(config, false);
     1866    PS_ASSERT_PTR_NON_NULL(where, false);
    18511867    PS_ASSERT_PTR_NON_NULL(data_state, false);
    1852     PS_ASSERT_PTR_NON_NULL(class_id, false);
    18531868
    18541869    if (!isValidDataState (data_state)) return false;
    18551870
    1856     char *query = "UPDATE detProcessedImfile SET data_state = '%s'"
    1857         " WHERE det_id = %" PRId64
    1858         " AND exp_id = %" PRId64
    1859         " AND class_id = '%s'";
    1860     if (!p_psDBRunQueryF(config->dbh, query, data_state, det_id, exp_id, class_id)) {
    1861         psError(PS_ERR_UNKNOWN, false,
    1862                 "failed to change state for det_id %" PRId64 ", exp_id %" PRId64 ", class_id %s",
    1863                 det_id, exp_id, class_id);
    1864         return false;
    1865     }
    1866 
    1867     return true;
    1868 }
    1869 
    1870 bool setProcessedExpDataState(pxConfig *config, psS64 det_id, psS64 exp_id, const char *data_state)
     1871    psString query = psStringCopy("UPDATE detProcessedImfile SET data_state = '%s'");
     1872    if (where && psListLength(where->list) > 0) {
     1873      psString whereClause = psDBGenerateWhereSQL(where,NULL);
     1874      psStringAppend(&query," %s",whereClause);
     1875      psFree(whereClause);
     1876    } else {
     1877      psError(PS_ERR_UNKNOWN, true, "search parameters are required");
     1878      return(false);
     1879    }
     1880
     1881    if (!p_psDBRunQueryF(config->dbh, query, data_state)) {
     1882      psFree(query);
     1883      psError(PS_ERR_UNKNOWN, false, "database error");
     1884      return(false);
     1885    }
     1886    psFree(query);
     1887    return(true);
     1888}
     1889
     1890bool setProcessedExpDataState(pxConfig *config, psMetadata *where, const char *data_state)
    18711891{
    18721892    PS_ASSERT_PTR_NON_NULL(config, false);
     1893    PS_ASSERT_PTR_NON_NULL(where, false);
    18731894    PS_ASSERT_PTR_NON_NULL(data_state, false);
    18741895
    18751896    if (!isValidDataState (data_state)) return false;
    18761897
    1877     char *query = "UPDATE detProcessedExp SET data_state = '%s'"
    1878         " WHERE det_id = %" PRId64
    1879         " AND exp_id = %" PRId64;
    1880     if (!p_psDBRunQueryF(config->dbh, query, data_state, det_id, exp_id)) {
    1881         psError(PS_ERR_UNKNOWN, false,
    1882                 "failed to change state for det_id %" PRId64 ", exp_id %" PRId64,
    1883                 det_id, exp_id);
    1884         return false;
    1885     }
    1886 
    1887     return true;
    1888 }
    1889 
    1890 
     1898    psString query = psStringCopy("UPDATE detProcessedExp SET data_state = '%s'");
     1899    if (where && psListLength(where->list) > 0) {
     1900      psString whereClause = psDBGenerateWhereSQL(where,NULL);
     1901      psStringAppend(&query," %s",whereClause);
     1902      psFree(whereClause);
     1903    } else {
     1904      psError(PS_ERR_UNKNOWN, true, "search parameters are required");
     1905      return(false);
     1906    }
     1907
     1908    if (!p_psDBRunQueryF(config->dbh, query, data_state)) {
     1909      psFree(query);
     1910      psError(PS_ERR_UNKNOWN, false, "database error");
     1911      return(false);
     1912    }
     1913    psFree(query);
     1914    return(true);
     1915}
     1916
     1917bool setResidImfileDataState(pxConfig *config, psMetadata *where, const char *data_state)
     1918{
     1919    PS_ASSERT_PTR_NON_NULL(config, false);
     1920    PS_ASSERT_PTR_NON_NULL(where,false);
     1921    PS_ASSERT_PTR_NON_NULL(data_state, false);
     1922
     1923    if (!isValidDataState (data_state)) return false;
     1924
     1925    psString query = psStringCopy("UPDATE detResidImfile SET data_state = '%s'");
     1926    if (where && psListLength(where->list) > 0) {
     1927      psString whereClause = psDBGenerateWhereSQL(where,NULL);
     1928      psStringAppend(&query," %s",whereClause);
     1929      psFree(whereClause);
     1930    } else {
     1931      psError(PS_ERR_UNKNOWN, true, "search parameters are required");
     1932      return(false);
     1933    }
     1934
     1935    if (!p_psDBRunQueryF(config->dbh, query, data_state)) {
     1936      psFree(query);
     1937      psError(PS_ERR_UNKNOWN, false, "database error");
     1938      return(false);
     1939    }
     1940    psFree(query);
     1941    return(true);
     1942}
     1943// This function apparently not used anymore.
     1944bool setResidExpDataState(pxConfig *config, psMetadata *where, const char *data_state)
     1945{
     1946    PS_ASSERT_PTR_NON_NULL(config, false);
     1947    PS_ASSERT_PTR_NON_NULL(where,false);
     1948    PS_ASSERT_PTR_NON_NULL(data_state, false);
     1949
     1950    if (!isValidDataState (data_state)) return false;
     1951
     1952    psString query = psStringCopy("UPDATE detResidExp SET data_state = '%s'");
     1953    if (where && psListLength(where->list) > 0) {
     1954      psString whereClause = psDBGenerateWhereSQL(where,NULL);
     1955      psStringAppend(&query," %s",whereClause);
     1956      psFree(whereClause);
     1957    } else {
     1958      psError(PS_ERR_UNKNOWN, true, "search parameters are required");
     1959      return(false);
     1960    }
     1961
     1962    if (!p_psDBRunQueryF(config->dbh, query, data_state)) {
     1963      psFree(query);
     1964      psError(PS_ERR_UNKNOWN, false, "database error");
     1965      return(false);
     1966    }
     1967    psFree(query);
     1968    return(true);
     1969}
     1970
     1971// Not yet updated for cleaning
    18911972bool setStackedImfileDataState(pxConfig *config, psS64 det_id, psS32 iteration, const char *class_id, const char *data_state)
    18921973{
    … …  
    18981979
    18991980    char *query = "UPDATE detStackedImfile SET data_state = '%s'"
    1900         " WHERE det_id = %" PRId64
    1901         " AND iteration = %" PRId32
    1902         " AND class_id = %s";
     1981        " WHERE det_id = %" PRId64
     1982        " AND iteration = %" PRId32
     1983        " AND class_id = '%s'";
    19031984    if (!p_psDBRunQueryF(config->dbh, query, data_state, det_id, iteration, class_id)) {
    19041985        psError(PS_ERR_UNKNOWN, false,
    1905                 "failed to change state for det_id %" PRId64 ", iteration %" PRId32 "class_id %s", 
    1906                 det_id, iteration, class_id);
     1986                "failed to change state for det_id %" PRId64 ", iteration %" PRId32 "class_id %s",
     1987                det_id, iteration, class_id);
    19071988        return false;
    19081989    }
    … …  
    19202001
    19212002    char *query = "UPDATE detNormalizedStatImfile SET data_state = '%s'"
    1922         " WHERE det_id = %" PRId64
    1923         " AND iteration = %" PRId32
    1924         " AND class_id = %s";
    1925     if (!p_psDBRunQueryF(config->dbh, query, data_state, det_id, iteration)) {
     2003        " WHERE det_id = %" PRId64
     2004        " AND iteration = %" PRId32
     2005        " AND class_id = '%s'";
     2006/*     fprintf(stderr,"DETTOOL SAYS: %s\n",query); */
     2007    if (!p_psDBRunQueryF(config->dbh, query, data_state, det_id, iteration,class_id)) {
    19262008        psError(PS_ERR_UNKNOWN, false,
    1927                 "failed to change state for det_id %" PRId64 ", iteration %" PRId32, 
    1928                 det_id, iteration);
     2009                "failed to change state for det_id %" PRId64 ", iteration %" PRId32,
     2010                det_id, iteration);
    19292011        return false;
    19302012    }
    … …  
    19422024
    19432025    char *query = "UPDATE detNormalizedImfile SET data_state = '%s'"
    1944         " WHERE det_id = %" PRId64
    1945         " AND iteration = %" PRId32
    1946         " AND class_id = %s";
     2026        " WHERE det_id = %" PRId64
     2027        " AND iteration = %" PRId32
     2028        " AND class_id = '%s'";
    19472029    if (!p_psDBRunQueryF(config->dbh, query, data_state, det_id, iteration, class_id)) {
    19482030        psError(PS_ERR_UNKNOWN, false,
    1949                 "failed to change state for det_id %" PRId64 ", iteration %" PRId32 " class %s", 
    1950                 det_id, iteration, class_id);
     2031                "failed to change state for det_id %" PRId64 ", iteration %" PRId32 " class %s",
     2032                det_id, iteration, class_id);
    19512033        return false;
    19522034    }
    … …  
    19632045
    19642046    char *query = "UPDATE detNormalizedExp SET data_state = '%s'"
    1965         " WHERE det_id = %" PRId64
    1966         " AND iteration = %" PRId32;
     2047        " WHERE det_id = %" PRId64
     2048        " AND iteration = %" PRId32;
    19672049    if (!p_psDBRunQueryF(config->dbh, query, data_state, det_id, iteration)) {
    19682050        psError(PS_ERR_UNKNOWN, false,
    1969                 "failed to change state for det_id %" PRId64 ", iteration %" PRId32, 
    1970                 det_id, iteration);
     2051                "failed to change state for det_id %" PRId64 ", iteration %" PRId32,
     2052                det_id, iteration);
    19712053        return false;
    19722054    }
    … …  
    19742056    return true;
    19752057}
    1976 
    1977 bool setResidImfileDataState(pxConfig *config, psS64 det_id, psS32 iteration, psS64 exp_id, const char *class_id, const char *data_state)
    1978 {
    1979     PS_ASSERT_PTR_NON_NULL(config, false);
    1980     PS_ASSERT_PTR_NON_NULL(data_state, false);
    1981     PS_ASSERT_PTR_NON_NULL(class_id, false);
    1982 
    1983     if (!isValidDataState (data_state)) return false;
    1984 
    1985     char *query = "UPDATE detResidImfile SET data_state = '%s'"
    1986         " WHERE det_id = %" PRId64
    1987         " AND iteration = %" PRId32
    1988         " AND exp_id = %" PRId64
    1989         " AND class_id = '%s'";
    1990     if (!p_psDBRunQueryF(config->dbh, query, data_state, det_id, iteration, exp_id, class_id)) {
    1991         psError(PS_ERR_UNKNOWN, false,
    1992                 "failed to change state for det_id %" PRId64 ", iteration %" PRId32 ", exp_id %" PRId64 ", class_id %s",
    1993                 det_id, iteration, exp_id, class_id);
    1994         return false;
    1995     }
    1996 
    1997     return true;
    1998 }
    1999 
    2000 bool setResidExpDataState(pxConfig *config, psS64 det_id, psS32 iteration, psS64 exp_id, const char *data_state)
    2001 {
    2002     PS_ASSERT_PTR_NON_NULL(config, false);
    2003     PS_ASSERT_PTR_NON_NULL(data_state, false);
    2004 
    2005     if (!isValidDataState (data_state)) return false;
    2006 
    2007     char *query = "UPDATE detResidExp SET data_state = '%s'"
    2008         " WHERE det_id = %" PRId64
    2009         " AND iteration = %" PRId32
    2010         " AND exp_id = %" PRId64;
    2011     if (!p_psDBRunQueryF(config->dbh, query, data_state, det_id, iteration, exp_id)) {
    2012         psError(PS_ERR_UNKNOWN, false,
    2013                 "failed to change state for det_id %" PRId64 ", iteration %" PRId32 ", exp_id %" PRId64,
    2014                 det_id, iteration, exp_id);
    2015         return false;
    2016     }
    2017 
    2018     return true;
    2019 }
     2058// End not yet modified for cleanup.
    20202059
    20212060bool exportrunMode(pxConfig *config)
    … …  
    20252064    char sqlFilename[80];
    20262065  } ExportTable;
    2027  
     2066
    20282067  int numExportTables = 12;
    20292068
    … …  
    20612100    psString query = pxDataGet(tables[i].sqlFilename);
    20622101    if (!query) {
    2063       psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     2102      psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    20642103      return false;
    20652104    }
    … …  
    21032142    }
    21042143    psFree(output);
    2105  
     2144
    21062145  }
    21072146
    … …  
    21142153{
    21152154  unsigned int nFail;
    2116  
     2155
    21172156  int numImportTables = 11;
    2118  
     2157
    21192158  char tables[11] [80] = {"detInputExp", "detNormalizedExp",
    21202159    "detNormalizedImfile", "detNormalizedStatImfile", "detProcessedExp",
    … …  
    21232162
    21242163  PS_ASSERT_PTR_NON_NULL(config, NULL);
    2125  
     2164
    21262165  PXOPT_LOOKUP_STR(infile, config->args, "-infile", true,  false);
    21272166
    … …  
    21302169  fprintf (stdout, "---- input ----\n");
    21312170  psMetadataPrint (stderr, input, 1);
    2132  
     2171
    21332172  psMetadataItem *item = psMetadataLookup (input, "detRun");
    21342173  psAssert (item, "entry not in input?");
    … …  
    21402179  detRunRow *detRun = detRunObjectFromMetadata (entry->data.md);
    21412180  detRunInsertObject (config->dbh, detRun);
    2142  
     2181
    21432182  // fprintf (stdout, "---- det run ----\n");
    21442183  // psMetadataPrint (stderr, entry->data.md, 1);
    … …  
    21482187    psAssert (item, "entry not in input?");
    21492188    psAssert (item->type == PS_DATA_METADATA_MULTI, "entry not multi?");
    2150  
     2189
    21512190    switch (i) {
    21522191      case 0:
    … …  
    21622201        }
    21632202        break;
    2164  
     2203
    21652204      case 1:
    21662205        for (int i = 0; i < item->data.list->n; i++) {
    … …  
    21752214        }
    21762215        break;
    2177        
     2216
    21782217      case 2:
    21792218        for (int i = 0; i < item->data.list->n; i++) {
    … …  
    21882227        }
    21892228        break;
    2190  
     2229
    21912230      case 3:
    21922231        for (int i = 0; i < item->data.list->n; i++) {
    … …  
    22012240        }
    22022241        break;
    2203        
     2242
    22042243      case 4:
    22052244        for (int i = 0; i < item->data.list->n; i++) {
    … …  
    22142253        }
    22152254        break;
    2216        
     2255
    22172256      case 5:
    22182257        for (int i = 0; i < item->data.list->n; i++) {
    … …  
    22272266        }
    22282267        break;
    2229        
     2268
    22302269      case 6:
    22312270        for (int i = 0; i < item->data.list->n; i++) {
    … …  
    22402279        }
    22412280        break;
    2242        
     2281
    22432282      case 7:
    22442283        for (int i = 0; i < item->data.list->n; i++) {
    … …  
    22532292        }
    22542293        break;
    2255        
     2294
    22562295      case 8:
    22572296        for (int i = 0; i < item->data.list->n; i++) {
    … …  
    22662305        }
    22672306        break;
    2268        
     2307
    22692308      case 9:
    22702309        for (int i = 0; i < item->data.list->n; i++) {
    … …  
    22792318        }
    22802319        break;
    2281        
     2320
    22822321      case 10:
    22832322        for (int i = 0; i < item->data.list->n; i++) {

  • branches/simtest_nebulous_branches/ippTools/src/dettool.h

    r23310 r27840  
    5757    DETTOOL_MODE_PENDINGCLEANUP_PROCESSEDEXP,
    5858    DETTOOL_MODE_DONECLEANUP_PROCESSEDEXP,
     59    DETTOOL_MODE_UPDATESTATE_PROCESSED,
    5960
    6061    DETTOOL_MODE_TOSTACKED,
    … …  
    105106    DETTOOL_MODE_PENDINGCLEANUP_RESIDEXP,
    106107    DETTOOL_MODE_DONECLEANUP_RESIDEXP,
     108    DETTOOL_MODE_UPDATESTATE_RESID,
    107109
    108110    DETTOOL_MODE_TODETRUNSUMMARY,
    … …  
    111113    DETTOOL_MODE_REVERTDETRUNSUMMARY,
    112114    DETTOOL_MODE_UPDATEDETRUNSUMMARY,
     115    DETTOOL_MODE_PENDINGCLEANUP_DETRUNSUMMARY,
    113116    DETTOOL_MODE_UPDATEDETRUN,
    114117    DETTOOL_MODE_RERUN,
    … …  
    148151bool pendingcleanup_processedexpMode(pxConfig *config);
    149152bool donecleanup_processedexpMode(pxConfig *config);
     153bool updatestateprocessedMode(pxConfig *config);
    150154
    151155// stackedimfile
    … …  
    202206bool pendingcleanup_residexpMode(pxConfig *config);
    203207bool donecleanup_residexpMode(pxConfig *config);
     208bool updatestateresidMode(pxConfig *config);
    204209
    205210// detrunsummary
    … …  
    209214bool revertdetrunsummaryMode(pxConfig *config);
    210215bool updatedetrunsummaryMode(pxConfig *config);
     216bool pendingcleanup_detrunsummaryMode(pxConfig *config);
    211217
    212218// other utilities
    … …  
    218224
    219225// functions to set the 'data_state' for stages
    220 bool setProcessedImfileDataState(pxConfig *config, psS64 det_id, psS64 exp_id, const char *class_id, const char *data_state);
    221 bool setProcessedExpDataState(pxConfig *config, psS64 det_id, psS64 exp_id, const char *data_state);
     226bool setProcessedImfileDataState(pxConfig *config, psMetadata *where, const char *data_state);
     227bool setProcessedExpDataState(pxConfig *config, psMetadata *where, const char *data_state);
     228bool setResidImfileDataState(pxConfig *config, psMetadata *where, const char *data_state);
     229bool setResidExpDataState(pxConfig *config, psMetadata *where, const char *data_state);
     230
    222231bool setStackedImfileDataState(pxConfig *config, psS64 det_id, psS32 iteration, const char *class_id, const char *data_state);
    223232bool setNormStatImfileDataState(pxConfig *config, psS64 det_id, psS32 iteration, const char *class_id, const char *data_state);
    224233bool setNormImfileDataState(pxConfig *config, psS64 det_id, psS32 iteration, const char *class_id, const char *data_state);
    225234bool setNormExpDataState(pxConfig *config, psS64 det_id, psS32 iteration, const char *data_state);
    226 bool setResidImfileDataState(pxConfig *config, psS64 det_id, psS32 iteration, psS64 exp_id, const char *class_id, const char *data_state);
    227 bool setResidExpDataState(pxConfig *config, psS64 det_id, psS32 iteration, psS64 exp_id, const char *data_state);
    228235
    229236#endif // DETTOOL_H

  • branches/simtest_nebulous_branches/ippTools/src/dettoolConfig.c

    r24866 r27840  
    3131    config->modules = pmConfigRead(&argc, argv, NULL);
    3232    if (!config->modules) {
    33         psError(PS_ERR_UNKNOWN, false, "Can't find site configuration");
     33        psError(psErrorCodeLast(), false, "Can't find site configuration");
    3434        psFree(config);
    3535        return NULL;
    … …  
    4141    // XXX EAM : is this used?  does it make sense?
    4242    psMetadata *pendingArgs = psMetadataAlloc();
    43     psMetadataAddS64(pendingArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", 0);
    44     psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-exp_type",  0,            "search by exposure type", NULL);
    45     psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-inst",  0,            "search by camera", NULL);
    46     psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-telescope",  0,            "search by telescope", NULL);
    47     psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-filter",  0,            "search by filter", NULL);
     43    psMetadataAddS64(pendingArgs, PS_LIST_TAIL, "-exp_id",  0,         "search by exposure ID", 0);
     44    psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-exp_type",  0,       "search by exposure type", NULL);
     45    psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-inst",  0,           "search by camera", NULL);
     46    psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-telescope",  0,      "search by telescope", NULL);
     47    psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-filter",  0,         "search by filter", NULL);
    4848    psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-uri",  0,            "search by URL", NULL);
    49     psMetadataAddBool(pendingArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     49    psMetadataAddBool(pendingArgs, PS_LIST_TAIL, "-simple",  0,        "use the simple output format", false);
    5050
    5151    // -definebytag
    … …  
    117117    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_airmass_max",  0,            "define max airmass", NAN);
    118118    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_sat_pixel_frac_max",  0,            "define max fraction of saturated pixels", NAN);
     119    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_sat_pixel_frac_min",  0,            "define min fraction of saturated pixels", NAN);
    119120    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_exp_time_min",  0,            "define min exposure time", NAN);
    120121    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_exp_time_max",  0,            "define max exposure time", NAN);
    … …  
    125126    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_posang_min",  0,            "define min rotator position angle", NAN);
    126127    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_posang_max",  0,            "define max rotator position angle", NAN);
     128
    127129    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_sun_angle_min",  0,            "define min solar angle", NAN);
    128130    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_sun_angle_max",  0,            "define max solar angle", NAN);
    … …  
    137139    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_moon_phase_max",  0,          "define max moon phase", NAN);
    138140    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-comment",                0,          "search by comment field (LIKE comparison)", NULL);
     141
    139142
    140143    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-pretend",  0,            "print the exposures that would be included in the detrend run and exit", false);
    … …  
    207210    // -addcorrectimfile
    208211    psMetadata *addcorrectimfileArgs = psMetadataAlloc();
    209     psMetadataAddS64(addcorrectimfileArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", 0);
    210     psMetadataAddStr(addcorrectimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search for class ID (required)", NULL);
    211     psMetadataAddStr(addcorrectimfileArgs, PS_LIST_TAIL, "-uri",  0,            "define resid file URI", NULL);
     212    psMetadataAddS64(addcorrectimfileArgs, PS_LIST_TAIL, "-det_id",  0,        "define detrend ID (required)", 0);
     213    psMetadataAddStr(addcorrectimfileArgs, PS_LIST_TAIL, "-class_id",  0,      "search for class ID (required)", NULL);
     214    psMetadataAddStr(addcorrectimfileArgs, PS_LIST_TAIL, "-uri",  0,           "define resid file URI", NULL);
    212215    psMetadataAddF64(addcorrectimfileArgs, PS_LIST_TAIL, "-bg",  0,            "define exposure background", NAN);
    213216    psMetadataAddF64(addcorrectimfileArgs, PS_LIST_TAIL, "-bg_stdev",  0,            "define exposure background stdev", NAN);
    … …  
    303306    // -updateprocessedimfile
    304307    psMetadata *updateprocessedimfileArgs = psMetadataAlloc();
    305     psMetadataAddS64(updateprocessedimfileArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     308    psMetadataAddS64(updateprocessedimfileArgs, PS_LIST_TAIL, "-det_id",               0,            "search by det ID", 0);
    306309    psMetadataAddS64(updateprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",               0,            "search by exp_id", 0);
    307310    psMetadataAddStr(updateprocessedimfileArgs, PS_LIST_TAIL, "-class_id",             0,            "search by exp_name", NULL);
    308     psMetadataAddStr(updateprocessedimfileArgs, PS_LIST_TAIL, "-data_state",           0,            "search for telescope", NULL);
     311    psMetadataAddStr(updateprocessedimfileArgs, PS_LIST_TAIL, "-data_state",           0,            "set state", NULL);
    309312
    310313    // -pendingcleanup_processedimfile
    … …  
    312315    psMetadataAddBool(pendingcleanup_processedimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    313316    psMetadataAddU64(pendingcleanup_processedimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    314     psMetadataAddS64(pendingcleanup_processedimfileArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     317    psMetadataAddS64(pendingcleanup_processedimfileArgs, PS_LIST_TAIL, "-det_id",               0,            "search by det ID", 0);
    315318    psMetadataAddS64(pendingcleanup_processedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", 0);
    316319    psMetadataAddStr(pendingcleanup_processedimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
    … …  
    320323    psMetadataAddBool(donecleanup_processedimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    321324    psMetadataAddU64(donecleanup_processedimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    322     psMetadataAddS64(donecleanup_processedimfileArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     325    psMetadataAddS64(donecleanup_processedimfileArgs, PS_LIST_TAIL, "-det_id",               0,            "search by det ID", 0);
    323326    psMetadataAddS64(donecleanup_processedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", 0);
    324327    psMetadataAddStr(donecleanup_processedimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
    … …  
    364367    // -updateprocessedexp
    365368    psMetadata *updateprocessedexpArgs = psMetadataAlloc();
    366     psMetadataAddS64(updateprocessedexpArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     369    psMetadataAddS64(updateprocessedexpArgs, PS_LIST_TAIL, "-det_id",               0,            "search by det ID", 0);
    367370    psMetadataAddS64(updateprocessedexpArgs, PS_LIST_TAIL, "-exp_id",               0,            "search by exp_id", 0);
    368     psMetadataAddStr(updateprocessedexpArgs, PS_LIST_TAIL, "-data_state",           0,            "search for telescope", NULL);
     371    psMetadataAddStr(updateprocessedexpArgs, PS_LIST_TAIL, "-data_state",           0,            "set state", NULL);
    369372
    370373    // -pendingcleanup_processedexp
    … …  
    372375    psMetadataAddBool(pendingcleanup_processedexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    373376    psMetadataAddU64(pendingcleanup_processedexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    374     psMetadataAddS64(pendingcleanup_processedexpArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     377    psMetadataAddS64(pendingcleanup_processedexpArgs, PS_LIST_TAIL, "-det_id",               0,            "search by det ID", 0);
    375378    psMetadataAddS64(pendingcleanup_processedexpArgs, PS_LIST_TAIL, "-exp_id",               0,            "search by exp_id", 0);
    376379
    … …  
    379382    psMetadataAddBool(donecleanup_processedexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    380383    psMetadataAddU64(donecleanup_processedexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    381     psMetadataAddS64(donecleanup_processedexpArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     384    psMetadataAddS64(donecleanup_processedexpArgs, PS_LIST_TAIL, "-det_id",               0,            "search by det ID", 0);
    382385    psMetadataAddS64(donecleanup_processedexpArgs, PS_LIST_TAIL, "-exp_id",               0,            "search by exp_id", 0);
     386
     387    // -updatestate_processed
     388    psMetadata *updatestateprocessedArgs = psMetadataAlloc();
     389    psMetadataAddS64(updatestateprocessedArgs, PS_LIST_TAIL, "-det_id",               0,            "search by det ID", 0);
     390    psMetadataAddS64(updatestateprocessedArgs, PS_LIST_TAIL, "-exp_id",               0,            "search by exp_id", 0);
     391    psMetadataAddStr(updatestateprocessedArgs, PS_LIST_TAIL, "-data_state",           0,            "set state", NULL);
    383392
    384393    // -tostacked
    … …  
    423432    // -updatestacked
    424433    psMetadata *updatestackedArgs = psMetadataAlloc();
    425     psMetadataAddS64(updatestackedArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     434    psMetadataAddS64(updatestackedArgs, PS_LIST_TAIL, "-det_id",               0,            "search by det ID", 0);
    426435    psMetadataAddS32(updatestackedArgs, PS_LIST_TAIL, "-iteration",  0,            "search by iteration number", 0);
    427436    psMetadataAddStr(updatestackedArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
    428     psMetadataAddStr(updatestackedArgs, PS_LIST_TAIL, "-data_state",           0,            "search for telescope", NULL);
     437    psMetadataAddStr(updatestackedArgs, PS_LIST_TAIL, "-data_state",           0,            "set state", NULL);
    429438
    430439    // -pendingcleanup_stacked
    … …  
    432441    psMetadataAddBool(pendingcleanup_stackedArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    433442    psMetadataAddU64(pendingcleanup_stackedArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    434     psMetadataAddS64(pendingcleanup_stackedArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     443    psMetadataAddS64(pendingcleanup_stackedArgs, PS_LIST_TAIL, "-det_id",               0,            "search by det ID", 0);
    435444    psMetadataAddS32(pendingcleanup_stackedArgs, PS_LIST_TAIL, "-iteration",  0,            "search by iteration number", 0);
    436445    psMetadataAddStr(pendingcleanup_stackedArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
    … …  
    440449    psMetadataAddBool(donecleanup_stackedArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    441450    psMetadataAddU64(donecleanup_stackedArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    442     psMetadataAddS64(donecleanup_stackedArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     451    psMetadataAddS64(donecleanup_stackedArgs, PS_LIST_TAIL, "-det_id",               0,            "search by det ID", 0);
    443452    psMetadataAddS32(donecleanup_stackedArgs, PS_LIST_TAIL, "-iteration",  0,            "search by iteration number", 0);
    444453    psMetadataAddStr(donecleanup_stackedArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
    … …  
    475484    // -updatenormalizedstat
    476485    psMetadata *updatenormalizedstatArgs = psMetadataAlloc();
    477     psMetadataAddS64(updatenormalizedstatArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     486    psMetadataAddS64(updatenormalizedstatArgs, PS_LIST_TAIL, "-det_id",               0,            "search by det ID", 0);
    478487    psMetadataAddS32(updatenormalizedstatArgs, PS_LIST_TAIL, "-iteration",  0,            "search by iteration number", 0);
    479488    psMetadataAddStr(updatenormalizedstatArgs, PS_LIST_TAIL, "-class_id",             0,            "search by exp_name", NULL);
    480     psMetadataAddStr(updatenormalizedstatArgs, PS_LIST_TAIL, "-data_state",           0,            "search for telescope", NULL);
     489    psMetadataAddStr(updatenormalizedstatArgs, PS_LIST_TAIL, "-data_state",           0,            "set state", NULL);
    481490
    482491    // -pendingcleanup_normalizedstat
    … …  
    484493    psMetadataAddBool(pendingcleanup_normalizedstatArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    485494    psMetadataAddU64(pendingcleanup_normalizedstatArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    486     psMetadataAddS64(pendingcleanup_normalizedstatArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     495    psMetadataAddS64(pendingcleanup_normalizedstatArgs, PS_LIST_TAIL, "-det_id",               0,            "search by det ID", 0);
    487496    psMetadataAddS32(pendingcleanup_normalizedstatArgs, PS_LIST_TAIL, "-iteration",  0,            "search by iteration number", 0);
    488497    psMetadataAddStr(pendingcleanup_normalizedstatArgs, PS_LIST_TAIL, "-class_id",             0,            "search by exp_name", NULL);
    … …  
    492501    psMetadataAddBool(donecleanup_normalizedstatArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    493502    psMetadataAddU64(donecleanup_normalizedstatArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    494     psMetadataAddS64(donecleanup_normalizedstatArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     503    psMetadataAddS64(donecleanup_normalizedstatArgs, PS_LIST_TAIL, "-det_id",               0,            "search by det ID", 0);
    495504    psMetadataAddS32(donecleanup_normalizedstatArgs, PS_LIST_TAIL, "-iteration",  0,            "search by iteration number", 0);
    496505    psMetadataAddStr(donecleanup_normalizedstatArgs, PS_LIST_TAIL, "-class_id",             0,            "search by exp_name", NULL);
    … …  
    537546    // -updatenormalizedimfile
    538547    psMetadata *updatenormalizedimfileArgs = psMetadataAlloc();
    539     psMetadataAddS64(updatenormalizedimfileArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     548    psMetadataAddS64(updatenormalizedimfileArgs, PS_LIST_TAIL, "-det_id",               0,            "search by det ID", 0);
    540549    psMetadataAddS32(updatenormalizedimfileArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
    541550    psMetadataAddStr(updatenormalizedimfileArgs, PS_LIST_TAIL, "-class_id",             0,            "search by exp_name", NULL);
    542     psMetadataAddStr(updatenormalizedimfileArgs, PS_LIST_TAIL, "-data_state",           0,            "search for telescope", NULL);
     551    psMetadataAddStr(updatenormalizedimfileArgs, PS_LIST_TAIL, "-data_state",           0,            "set state", NULL);
    543552
    544553    // -pendingcleanup_normalizedimfile
    … …  
    546555    psMetadataAddBool(pendingcleanup_normalizedimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    547556    psMetadataAddU64(pendingcleanup_normalizedimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    548     psMetadataAddS64(pendingcleanup_normalizedimfileArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     557    psMetadataAddS64(pendingcleanup_normalizedimfileArgs, PS_LIST_TAIL, "-det_id",               0,            "search by det ID", 0);
    549558    psMetadataAddS32(pendingcleanup_normalizedimfileArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
    550559    psMetadataAddStr(pendingcleanup_normalizedimfileArgs, PS_LIST_TAIL, "-class_id",             0,            "search by exp_name", NULL);
    … …  
    554563    psMetadataAddBool(donecleanup_normalizedimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    555564    psMetadataAddU64(donecleanup_normalizedimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    556     psMetadataAddS64(donecleanup_normalizedimfileArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     565    psMetadataAddS64(donecleanup_normalizedimfileArgs, PS_LIST_TAIL, "-det_id",               0,            "search by det ID", 0);
    557566    psMetadataAddS32(donecleanup_normalizedimfileArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
    558567    psMetadataAddStr(donecleanup_normalizedimfileArgs, PS_LIST_TAIL, "-class_id",             0,            "search by exp_name", NULL);
    … …  
    596605    // -updatenormalizedexp
    597606    psMetadata *updatenormalizedexpArgs = psMetadataAlloc();
    598     psMetadataAddS64(updatenormalizedexpArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     607    psMetadataAddS64(updatenormalizedexpArgs, PS_LIST_TAIL, "-det_id",               0,            "search by det ID", 0);
    599608    psMetadataAddS32(updatenormalizedexpArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
    600     psMetadataAddStr(updatenormalizedexpArgs, PS_LIST_TAIL, "-data_state",           0,            "search for telescope", NULL);
     609    psMetadataAddStr(updatenormalizedexpArgs, PS_LIST_TAIL, "-data_state",           0,            "set state", NULL);
    601610
    602611    // -pendingcleanup_normalizedexp
    … …  
    604613    psMetadataAddBool(pendingcleanup_normalizedexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    605614    psMetadataAddU64(pendingcleanup_normalizedexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    606     psMetadataAddS64(pendingcleanup_normalizedexpArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     615    psMetadataAddS64(pendingcleanup_normalizedexpArgs, PS_LIST_TAIL, "-det_id",               0,            "search by det ID", 0);
    607616    psMetadataAddS32(pendingcleanup_normalizedexpArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
    608617
    … …  
    611620    psMetadataAddBool(donecleanup_normalizedexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    612621    psMetadataAddU64(donecleanup_normalizedexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    613     psMetadataAddS64(donecleanup_normalizedexpArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     622    psMetadataAddS64(donecleanup_normalizedexpArgs, PS_LIST_TAIL, "-det_id",               0,            "search by det ID", 0);
    614623    psMetadataAddS32(donecleanup_normalizedexpArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
    615624
    … …  
    674683    // -updateresidimfile
    675684    psMetadata *updateresidimfileArgs = psMetadataAlloc();
    676     psMetadataAddS64(updateresidimfileArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     685    psMetadataAddS64(updateresidimfileArgs, PS_LIST_TAIL, "-det_id",               0,            "search by det ID", 0);
    677686    psMetadataAddS32(updateresidimfileArgs, PS_LIST_TAIL, "-iteration", 0,       "search by iteration number", 0);
    678687    psMetadataAddS64(updateresidimfileArgs, PS_LIST_TAIL, "-exp_id",               0,            "search by exp_id", 0);
    679688    psMetadataAddStr(updateresidimfileArgs, PS_LIST_TAIL, "-class_id",             0,            "search by exp_name", NULL);
    680     psMetadataAddStr(updateresidimfileArgs, PS_LIST_TAIL, "-data_state",           0,            "search for telescope", NULL);
     689    psMetadataAddStr(updateresidimfileArgs, PS_LIST_TAIL, "-data_state",           0,            "set state", NULL);
    681690
    682691    // -pendingcleanup_residimfile
    … …  
    684693    psMetadataAddBool(pendingcleanup_residimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    685694    psMetadataAddU64(pendingcleanup_residimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    686     psMetadataAddS64(pendingcleanup_residimfileArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     695    psMetadataAddS64(pendingcleanup_residimfileArgs, PS_LIST_TAIL, "-det_id",               0,            "search by det ID", 0);
    687696    psMetadataAddS32(pendingcleanup_residimfileArgs, PS_LIST_TAIL, "-iteration", 0,       "search by iteration number", 0);
    688697    psMetadataAddS64(pendingcleanup_residimfileArgs, PS_LIST_TAIL, "-exp_id",               0,            "search by exp_id", 0);
    … …  
    693702    psMetadataAddBool(donecleanup_residimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    694703    psMetadataAddU64(donecleanup_residimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    695     psMetadataAddS64(donecleanup_residimfileArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     704    psMetadataAddS64(donecleanup_residimfileArgs, PS_LIST_TAIL, "-det_id",               0,            "search by det ID", 0);
    696705    psMetadataAddS32(donecleanup_residimfileArgs, PS_LIST_TAIL, "-iteration", 0,       "search by iteration number", 0);
    697706    psMetadataAddS64(donecleanup_residimfileArgs, PS_LIST_TAIL, "-exp_id",               0,            "search by exp_id", 0);
    … …  
    759768    psMetadataAddStr(updateresidexpArgs, PS_LIST_TAIL, "-path_base",  0,            "define base output location", NULL);
    760769    psMetadataAddBool(updateresidexpArgs, PS_LIST_TAIL, "-reject",  0,            "exposure is not to be stacked in the next iteration", false);
    761     psMetadataAddStr(updateresidexpArgs, PS_LIST_TAIL, "-data_state",           0,            "search for telescope", NULL);
     770    psMetadataAddStr(updateresidexpArgs, PS_LIST_TAIL, "-data_state",           0,            "set state", NULL);
    762771
    763772    // -pendingcleanup_residexp
    … …  
    776785    psMetadataAddS32(donecleanup_residexpArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
    777786    psMetadataAddS64(donecleanup_residexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by detrend ID", 0);
     787
     788    // -updatestate_resid
     789    psMetadata *updatestateresidArgs = psMetadataAlloc();
     790    psMetadataAddS64(updatestateresidArgs, PS_LIST_TAIL, "-det_id",               0,            "search by det ID", 0);
     791    psMetadataAddS64(updatestateresidArgs, PS_LIST_TAIL, "-exp_id",               0,            "search by exp_id", 0);
     792    psMetadataAddStr(updatestateresidArgs, PS_LIST_TAIL, "-data_state",           0,            "set state", NULL);
    778793
    779794    // -todetrunsummary
    … …  
    813828    psMetadataAddBool(updatedetrunsummaryArgs, PS_LIST_TAIL, "-accept",  0,            "declare that this detrun iteration is accepted as a master", false);
    814829    psMetadataAddBool(updatedetrunsummaryArgs, PS_LIST_TAIL, "-reject",  0,            "reject this detrun iteration as a master", false);
     830    psMetadataAddStr(updatedetrunsummaryArgs, PS_LIST_TAIL, "-data_state", 0,          "set the data state", NULL);
     831    psMetadataAddS32(updatedetrunsummaryArgs, PS_LIST_TAIL, "-iteration", 0,           "search by iteration number", 0);
     832
     833    // -pendingcleanup_detrunsummary
     834    psMetadata *pendingcleanup_detrunsummaryArgs = psMetadataAlloc();
     835    psMetadataAddS64(pendingcleanup_detrunsummaryArgs, PS_LIST_TAIL, "-det_id", 0,     "search by detrend ID (required)", 0);
     836    psMetadataAddS32(pendingcleanup_detrunsummaryArgs, PS_LIST_TAIL, "-iteration", 0,  "search by iteration number", 0);
     837    psMetadataAddU64(pendingcleanup_detrunsummaryArgs, PS_LIST_TAIL, "-limit",  0,     "limit result set to N items", 0);
     838    psMetadataAddBool(pendingcleanup_detrunsummaryArgs, PS_LIST_TAIL, "-simple", 0,    "use the simple output format", false);
    815839
    816840    // -updatedetrun
    … …  
    913937    PXOPT_ADD_MODE("-pendingcleanup_processedexp", "", DETTOOL_MODE_PENDINGCLEANUP_PROCESSEDEXP, pendingcleanup_processedexpArgs);
    914938    PXOPT_ADD_MODE("-donecleanup_processedexp", "",    DETTOOL_MODE_DONECLEANUP_PROCESSEDEXP, donecleanup_processedexpArgs);
     939    PXOPT_ADD_MODE("-updatestate_processed", "", DETTOOL_MODE_UPDATESTATE_PROCESSED, updatestateprocessedArgs);
    915940
    916941    PXOPT_ADD_MODE("-tostacked",       "", DETTOOL_MODE_TOSTACKED,     tostackedArgs);
    … …  
    961986    PXOPT_ADD_MODE("-pendingcleanup_residexp", "", DETTOOL_MODE_PENDINGCLEANUP_RESIDEXP, pendingcleanup_residexpArgs);
    962987    PXOPT_ADD_MODE("-donecleanup_residexp", "",    DETTOOL_MODE_DONECLEANUP_RESIDEXP, donecleanup_residexpArgs);
     988    PXOPT_ADD_MODE("-updatestate_resid", "", DETTOOL_MODE_UPDATESTATE_RESID, updatestateresidArgs);
    963989
    964990    PXOPT_ADD_MODE("-todetrunsummary",  "", DETTOOL_MODE_TODETRUNSUMMARY,  todetrunsummaryArgs);
    … …  
    967993    PXOPT_ADD_MODE("-revertdetrunsummary", "", DETTOOL_MODE_REVERTDETRUNSUMMARY, revertdetrunsummaryArgs);
    968994    PXOPT_ADD_MODE("-updatedetrunsummary", "", DETTOOL_MODE_UPDATEDETRUNSUMMARY, updatedetrunsummaryArgs);
     995
     996    PXOPT_ADD_MODE("-pendingcleanup_detrunsummary", "", DETTOOL_MODE_PENDINGCLEANUP_DETRUNSUMMARY, pendingcleanup_detrunsummaryArgs);
    969997
    970998    PXOPT_ADD_MODE("-updatedetrun", "", DETTOOL_MODE_UPDATEDETRUN, updatedetrunArgs);

  • branches/simtest_nebulous_branches/ippTools/src/dettool_correction.c

    r20377 r27840  
    3434    PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
    3535
    36     // build the needed where 
     36    // build the needed where
    3737    psMetadata *where = psMetadataAlloc();
    3838    psMetadataAddS64(where, PS_LIST_TAIL, "det_id", 0, "==", ref_det_id);
    … …  
    8888         detRun->solang_max,
    8989         use_label,
    90         detRun->det_id, // ref_det_id
    91         detRun->iteration // ref_iter
     90        detRun->det_id, // ref_det_id
     91        detRun->iteration // ref_iter
    9292    );
    9393    psFree(runs);
    … …  
    140140    psString query = pxDataGet("dettool_tocorrectimfile.sql");
    141141    if (!query) {
    142         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     142        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    143143        return false;
    144144    }
    145145
    146146    if (psListLength(where->list)) {
    147         // NOTE the SQL uses an intermediate table 'det1' for this query
    148         psString whereClause = psDBGenerateWhereConditionSQL(where, "det1"); 
     147        // NOTE the SQL uses an intermediate table 'det1' for this query
     148        psString whereClause = psDBGenerateWhereConditionSQL(where, "det1");
    149149        psStringAppend(&query, " AND %s", whereClause);
    150150        psFree(whereClause);
    … …  
    198198    psString query = pxDataGet("dettool_tocorrectexp.sql");
    199199    if (!query) {
    200         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     200        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    201201        return false;
    202202    }
    … …  
    248248        return false;
    249249    }
    250    
     250
    251251    // automatically stop completed 'correct' detRuns
    252252    psString query = pxDataGet("dettool_stop_completed_correct_runs.sql");
    253253    if (!query) {
    254         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     254        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    255255        return false;
    256256    }

  • branches/simtest_nebulous_branches/ippTools/src/dettool_detrunsummary.c

    r23688 r27840  
    3535    psString query = pxDataGet("dettool_todetrunsummary.sql");
    3636    if (!query) {
    37         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     37        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    3838        return false;
    3939    }
    … …  
    135135    psString query = pxDataGet("dettool_find_completed_runs.sql");
    136136    if (!query) {
    137         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     137        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    138138        return false;
    139139    }
    … …  
    241241    psString query = pxDataGet("dettool_detrunsummary.sql");
    242242    if (!query) {
    243         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     243        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    244244        psFree(where);
    245245        return false;
    … …  
    310310    psString query = pxDataGet("dettool_revertdetrunsummary.sql");
    311311    if (!query) {
    312         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     312        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    313313        return false;
    314314    }
    … …  
    336336}
    337337
    338 // XXX need to add -data_state here
     338bool pendingcleanup_detrunsummaryMode(pxConfig *config) {
     339  PS_ASSERT_PTR_NON_NULL(config, false);
     340
     341  PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     342  PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     343
     344  psMetadata *where = psMetadataAlloc();
     345  PXOPT_COPY_S64(config->args, where, "-det_id", "det_id", "==");
     346  PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
     347
     348  psString query = pxDataGet("dettool_pendingcleanup_detrunsummary.sql");
     349  if (!query) {
     350    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     351    return(false);
     352  }
     353
     354  if (psListLength(where->list)) {
     355    psString whereClause = psDBGenerateWhereConditionSQL(where, "detRunSummary");
     356    psStringAppend(&query, " AND %s", whereClause);
     357    psFree(whereClause);
     358  }
     359  psFree(where);
     360
     361  // treat limit == 0 as "no limit"
     362  if (limit) {
     363    psString limitString = psDBGenerateLimitSQL(limit);
     364    psStringAppend(&query, " %s", limitString);
     365    psFree(limitString);
     366  }
     367  //  fprintf(stderr,">>>%s<<<\n",query);
     368  if (!p_psDBRunQuery(config->dbh, query)) {
     369    psError(PS_ERR_UNKNOWN, false, "database error");
     370    psFree(query);
     371    return(false);
     372  }
     373  psFree(query);
     374
     375  psArray *output = p_psDBFetchResult(config->dbh);
     376  if (!output) {
     377    psError(PS_ERR_UNKNOWN, false, "database error");
     378    return(false);
     379  }
     380  if (!psArrayLength(output)) {
     381    psTrace("dettool", PS_LOG_INFO, "no rows found");
     382    psFree(output);
     383    return(true);
     384  }
     385
     386  // negative simple so the default is true
     387  if (!ippdbPrintMetadatas(stdout, output, "pendingCleanupDetRun", !simple)) {
     388    psError(PS_ERR_UNKNOWN, false, "failed to print array");
     389    psFree(output);
     390    return(false);
     391  }
     392  psFree(output);
     393
     394  return(true);
     395}
     396
     397
     398// preliminary code now.
    339399bool updatedetrunsummaryMode(pxConfig *config)
    340400{
    … …  
    344404    PXOPT_LOOKUP_BOOL(accept, config->args, "-accept", false);
    345405    PXOPT_LOOKUP_BOOL(reject, config->args, "-reject", false);
     406    PXOPT_LOOKUP_STR(data_state, config->args, "-data_state", ((accept == 0)&&(reject == 0)), false);
     407    PXOPT_LOOKUP_S32(iteration, config->args, "-iteration", ((accept == 0)&&(reject == 0)), false);
     408
    346409
    347410    if (accept && reject) {
    … …  
    350413    }
    351414
    352     if (!(accept || reject)) {
    353         psError(PS_ERR_UNKNOWN, true, "either -accept or -reject is required");
    354         return false;
    355     }
    356 
    357     char *query = "UPDATE detRunSummary SET accept = %d WHERE det_id = %"PRId64;
    358     if (!p_psDBRunQueryF(config->dbh, query, accept, det_id)) {
    359         psError(PS_ERR_UNKNOWN, false, "database error");
    360         return false;
     415    if (!(accept || reject || (data_state != NULL))) {
     416        psError(PS_ERR_UNKNOWN, true, "either -accept or -reject is required if -data_state is not supplied");
     417        return false;
     418    }
     419
     420    if (accept || reject) {
     421      char *query = "UPDATE detRunSummary SET accept = %d WHERE det_id = %"PRId64;
     422      if (!p_psDBRunQueryF(config->dbh, query, accept, det_id)) {
     423        psError(PS_ERR_UNKNOWN, false, "database error");
     424        return false;
     425      }
     426    }
     427    else {
     428      PS_ASSERT_PTR_NON_NULL(data_state,false);
     429
     430/*       if (!isValidDataState(data_state)) return false; */
     431
     432
     433
     434      char *query_detRunSummary = "UPDATE detRunSummary SET data_state = '%s'"
     435        " WHERE det_id = %" PRId64
     436        " AND iteration = %" PRId32;
     437      if (!p_psDBRunQueryF(config->dbh, query_detRunSummary, data_state, det_id,iteration)) {
     438        psError(PS_ERR_UNKNOWN, false,
     439                "failed to change state for det_id %" PRId64 ", iteration %" PRId32, det_id,iteration);
     440        return false;
     441      }
     442
     443      /* This check allows the one update to flag everything for cleanup.  The check for full is only temporary while I test for bugs. */
     444      if ((!strncmp(data_state,"goto_",5)
     445           //      || (!strcmp(data_state,"full"))
     446           //      || (!strcmp(data_state,"cleaned"))
     447           ))   {
     448        char *query_detProcessedImfile = "UPDATE detProcessedImfile SET data_state = '%s'"
     449          " WHERE det_id = %" PRId64;
     450        if (!p_psDBRunQueryF(config->dbh, query_detProcessedImfile,data_state,det_id)) {
     451          psError(PS_ERR_UNKNOWN, false,
     452                  "failed to change state for detProcessedImfile det_id %" PRId64 ", iteration %" PRId32, det_id,iteration);
     453          return(false);
     454        }
     455
     456        char *query_detProcessedExp = "UPDATE detProcessedExp SET data_state = '%s'"
     457          " WHERE det_id = %" PRId64;
     458        if (!p_psDBRunQueryF(config->dbh, query_detProcessedExp,data_state,det_id)) {
     459          psError(PS_ERR_UNKNOWN, false,
     460                  "failed to change state for detProcessedExp det_id %" PRId64 ", iteration %" PRId32, det_id,iteration);
     461          return(false);
     462        }
     463
     464        char *query_detNormalizedImfile = "UPDATE detNormalizedImfile SET data_state = '%s'"
     465          " WHERE det_id = %" PRId64
     466          " AND iteration = %" PRId32;
     467        if (!p_psDBRunQueryF(config->dbh, query_detNormalizedImfile,data_state,det_id,iteration)) {
     468          psError(PS_ERR_UNKNOWN, false,
     469                  "failed to change state for detNormalizedImfile det_id %" PRId64 ", iteration %" PRId32, det_id,iteration);
     470          return(false);
     471        }
     472
     473        char *query_detNormalizedStatImfile = "UPDATE detNormalizedStatImfile SET data_state = '%s'"
     474          " WHERE det_id = %" PRId64
     475          " AND iteration = %" PRId32;
     476        if (!p_psDBRunQueryF(config->dbh, query_detNormalizedStatImfile,data_state,det_id,iteration)) {
     477          psError(PS_ERR_UNKNOWN, false,
     478                  "failed to change state for detNormalizedStatImfile det_id %" PRId64 ", iteration %" PRId32, det_id,iteration);
     479          return(false);
     480        }
     481
     482        char *query_detNormalizedExp = "UPDATE detNormalizedExp SET data_state = '%s'"
     483          " WHERE det_id = %" PRId64
     484          " AND iteration = %" PRId32;
     485        if (!p_psDBRunQueryF(config->dbh, query_detNormalizedExp,data_state,det_id,iteration)) {
     486          psError(PS_ERR_UNKNOWN, false,
     487                  "failed to change state for detNormalizedExp det_id %" PRId64 ", iteration %" PRId32, det_id,iteration);
     488          return(false);
     489        }
     490
     491        char *query_detResidImfile = "UPDATE detResidImfile SET data_state = '%s'"
     492          " WHERE det_id = %" PRId64
     493          " AND iteration = %" PRId32;
     494        if (!p_psDBRunQueryF(config->dbh, query_detResidImfile,data_state,det_id,iteration)) {
     495          psError(PS_ERR_UNKNOWN, false,
     496                  "failed to change state for detResidImfile det_id %" PRId64 ", iteration %" PRId32, det_id,iteration);
     497          return(false);
     498        }
     499
     500        char *query_detResidExp = "UPDATE detResidExp SET data_state = '%s'"
     501          " WHERE det_id = %" PRId64
     502          " AND iteration = %" PRId32;
     503        if (!p_psDBRunQueryF(config->dbh, query_detResidExp,data_state,det_id,iteration)) {
     504          psError(PS_ERR_UNKNOWN, false,
     505                  "failed to change state for detResidExp det_id %" PRId64 ", iteration %" PRId32, det_id,iteration);
     506          return(false);
     507        }
     508
     509        char *query_detStackedImfile = "UPDATE detStackedImfile SET data_state = '%s'"
     510          " WHERE det_id = %" PRId64
     511          " AND iteration = %" PRId32;
     512        if (!p_psDBRunQueryF(config->dbh, query_detStackedImfile,data_state,det_id,iteration)) {
     513          psError(PS_ERR_UNKNOWN, false,
     514                  "failed to change state for detStackedImfile det_id %" PRId64 ", iteration %" PRId32, det_id,iteration);
     515          return(false);
     516        }
     517      }
     518      /* End if */
     519
    361520    }
    362521

  • branches/simtest_nebulous_branches/ippTools/src/dettool_normalizedexp.c

    r23688 r27840  
    2929    psString query = pxDataGet("dettool_tonormalizedexp.sql");
    3030    if (!query) {
    31         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     31        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    3232        return false;
    3333    }
    … …  
    8989    psString query = pxDataGet("dettool_tonormalizedexp.sql");
    9090    if (!query) {
    91         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     91        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    9292        return false;
    9393    }
    … …  
    156156    psString query = pxDataGet("dettool_normalizedexp.sql");
    157157    if (!query) {
    158         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     158        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    159159        return false;
    160160    }
    … …  
    225225    psString query = pxDataGet("dettool_revertnormalizedexp.sql");
    226226    if (!query) {
    227         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     227        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    228228        return false;
    229229    }
    … …  
    278278    psString query = pxDataGet("dettool_pendingcleanup_normalizedexp.sql");
    279279    if (!query) {
    280         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     280        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    281281        return false;
    282282    }
    … …  
    340340    psString query = pxDataGet("dettool_donecleanup_normalizedexp.sql");
    341341    if (!query) {
    342         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     342        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    343343        return false;
    344344    }

  • branches/simtest_nebulous_branches/ippTools/src/dettool_normalizedimfile.c

    r23688 r27840  
    3030    psString query = pxDataGet("dettool_tonormalize.sql");
    3131    if (!query) {
    32         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     32        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    3333        return false;
    3434    }
    … …  
    137137    psString query = pxDataGet("dettool_normalizedimfile.sql");
    138138    if (!query) {
    139         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     139        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    140140        return false;
    141141    }
    … …  
    205205    psString query = pxDataGet("dettool_revertnormalizedimfile.sql");
    206206    if (!query) {
    207         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     207        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    208208        return false;
    209209    }
    … …  
    260260    psString query = pxDataGet("dettool_pendingcleanup_normalizedimfile.sql");
    261261    if (!query) {
    262         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     262        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    263263        return false;
    264264    }
    … …  
    323323    psString query = pxDataGet("dettool_donecleanup_normalizedimfile.sql");
    324324    if (!query) {
    325         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     325        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    326326        return false;
    327327    }

  • branches/simtest_nebulous_branches/ippTools/src/dettool_normalizedstat.c

    r23688 r27840  
    2929    psString query = pxDataGet("dettool_tonormalizedstat.sql");
    3030    if (!query) {
    31         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     31        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    3232        return false;
    3333    }
    … …  
    117117    psString query = pxDataGet("dettool_normalizedstat.sql");
    118118    if (!query) {
    119         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     119        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    120120        return false;
    121121    }
    … …  
    185185    psString query = pxDataGet("dettool_revertnormalizedstat.sql");
    186186    if (!query) {
    187         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     187        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    188188        return false;
    189189    }
    … …  
    240240    psString query = pxDataGet("dettool_pendingcleanup_normalizedstat.sql");
    241241    if (!query) {
    242         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     242        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    243243        return false;
    244244    }
    … …  
    303303    psString query = pxDataGet("dettool_donecleanup_normalizedstat.sql");
    304304    if (!query) {
    305         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     305        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    306306        return false;
    307307    }

  • branches/simtest_nebulous_branches/ippTools/src/dettool_processedexp.c

    r23688 r27840  
    2929    psString query = pxDataGet("dettool_toprocessedexp.sql");
    3030    if (!query) {
    31         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     31        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    3232        return false;
    3333    }
    … …  
    101101    psString query = pxDataGet("dettool_addprocessedexp.sql");
    102102    if (!query) {
    103         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     103        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    104104        return false;
    105105    }
    … …  
    235235    psString query = pxDataGet("dettool_revertprocessedexp.sql");
    236236    if (!query) {
    237         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     237        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    238238        return false;
    239239    }
    … …  
    266266
    267267    PXOPT_LOOKUP_S64(det_id, config->args, "-det_id", true, false);
    268     PXOPT_LOOKUP_S64(exp_id, config->args, "-exp_id", true, false);
    269268    PXOPT_LOOKUP_STR(data_state, config->args, "-data_state", true, false);
    270     if (!setProcessedExpDataState(config, det_id, exp_id, data_state)) {
    271         return false;
    272     }
    273     return true;
     269
     270    psMetadata *where = psMetadataAlloc();
     271
     272    PXOPT_COPY_S64(config->args,where,"-det_id","det_id","==");
     273    PXOPT_COPY_S64(config->args,where,"-exp_id","exp_id","==");
     274
     275    if (!setProcessedExpDataState(config, where, data_state)) {
     276        return false;
     277    }
     278    psFree(where);
     279    return true;
     280}
     281
     282bool updatestateprocessedMode(pxConfig *config) {
     283  PS_ASSERT_PTR_NON_NULL(config, NULL);
     284  PXOPT_LOOKUP_S64(det_id,config->args, "-det_id",true,false);
     285  PXOPT_LOOKUP_STR(data_state,config->args, "-data_state", true, false);
     286
     287  psMetadata *where = psMetadataAlloc();
     288
     289  PXOPT_COPY_S64(config->args,where,"-det_id","det_id","==");
     290  PXOPT_COPY_S64(config->args,where,"-exp_id","exp_id","==");
     291
     292  if (!setProcessedExpDataState(config,where,data_state)) {
     293    return(false);
     294  }
     295  if (!setProcessedImfileDataState(config,where,data_state)) {
     296    return(false);
     297  }
     298  psFree(where);
     299  return(true);
    274300}
    275301
    … …  
    287313    psString query = pxDataGet("dettool_pendingcleanup_processedexp.sql");
    288314    if (!query) {
    289         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     315        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    290316        return false;
    291317    }
    … …  
    349375    psString query = pxDataGet("dettool_donecleanup_processedexp.sql");
    350376    if (!query) {
    351         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     377        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    352378        return false;
    353379    }

  • branches/simtest_nebulous_branches/ippTools/src/dettool_processedimfile.c

    r23688 r27840  
    3434    psString query = pxDataGet("dettool_toprocessedimfile.sql");
    3535    if (!query) {
    36         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     36        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    3737        return false;
    3838    }
    … …  
    180180    psString query = pxDataGet("dettool_processedimfile.sql");
    181181    if (!query) {
    182         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     182        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    183183        psFree(where);
    184184        return false;
    … …  
    267267    psString query = pxDataGet("dettool_revertprocessedimfile.sql");
    268268    if (!query) {
    269         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     269        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    270270        return false;
    271271    }
    … …  
    298298
    299299    PXOPT_LOOKUP_S64(det_id, config->args, "-det_id", true, false);
    300     PXOPT_LOOKUP_S64(exp_id, config->args, "-exp_id", true, false);
    301     PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false);
    302300    PXOPT_LOOKUP_STR(data_state, config->args, "-data_state", true, false);
    303301
    304     if (!setProcessedImfileDataState(config, det_id, exp_id, class_id, data_state)) {
    305         return false;
    306     }
     302    psMetadata *where = psMetadataAlloc();
     303
     304    PXOPT_COPY_S64(config->args,where,"-det_id", "det_id","==");
     305    PXOPT_COPY_S64(config->args,where,"-exp_id", "exp_id","==");
     306    PXOPT_COPY_STR(config->args,where,"-class_id","class_id","==");
     307
     308    if (!setProcessedImfileDataState(config, where, data_state)) {
     309        return false;
     310    }
     311    psFree(where);
    307312    return true;
    308313}
    … …  
    314319    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    315320    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    316 
     321/*     int i; */
    317322    psMetadata *where = psMetadataAlloc();
    318323    PXOPT_COPY_S64(config->args, where, "-det_id", "det_id", "==");
    … …  
    322327    psString query = pxDataGet("dettool_pendingcleanup_processedimfile.sql");
    323328    if (!query) {
    324         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     329        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    325330        return false;
    326331    }
    … …  
    345350        return false;
    346351    }
     352/*     fprintf(stderr,"DETTOOL:procimfile: %s\n",query); */
    347353    psFree(query);
    348354
    … …  
    350356    if (!output) {
    351357        psError(PS_ERR_UNKNOWN, false, "database error");
     358/*      fprintf(stderr,"WTF !output?\n"); */
    352359        return false;
    353360    }
    354361    if (!psArrayLength(output)) {
    355362        psTrace("dettool", PS_LOG_INFO, "no rows found");
     363/*      fprintf(stderr,"WTF no rows??\n"); */
    356364        psFree(output);
    357365        return true;
    … …  
    359367
    360368    // negative simple so the default is true
     369/*     i = (int) ippdbPrintMetadatas(stdout, output, "detCleanupProcessedImfile", !simple); */
     370/*     fprintf(stderr,">>%d<<\n",i); */
    361371    if (!ippdbPrintMetadatas(stdout, output, "detCleanupProcessedImfile", !simple)) {
    362372        psError(PS_ERR_UNKNOWN, false, "failed to print array");
    … …  
    364374        return false;
    365375    }
     376/*     fprintf(stderr,"DETTOOL:procimfile: %s\n",output); */
     377/*     psFree(output); */
    366378
    367379    psFree(output);
    … …  
    385397    psString query = pxDataGet("dettool_donecleanup_processedimfile.sql");
    386398    if (!query) {
    387         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     399        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    388400        return false;
    389401    }

  • branches/simtest_nebulous_branches/ippTools/src/dettool_residexp.c

    r23688 r27840  
    3535    psString query = pxDataGet("dettool_toresidexp.sql");
    3636    if (!query) {
    37         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     37        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    3838        return false;
    3939    }
    … …  
    119119    psString query = pxDataGet("dettool_toresidexp.sql");
    120120    if (!query) {
    121         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     121        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    122122        return false;
    123123    }
    … …  
    202202    psString query = pxDataGet("dettool_residexp.sql");
    203203    if (!query) {
    204         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     204        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    205205        return false;
    206206    }
    … …  
    277277    psString query = pxDataGet("dettool_revertresidexp.sql");
    278278    if (!query) {
    279         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     279        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    280280        return false;
    281281    }
    … …  
    353353}
    354354
     355bool updatestateresidMode(pxConfig *config) {
     356  PS_ASSERT_PTR_NON_NULL(config, NULL);
     357  PXOPT_LOOKUP_S64(det_id,config->args, "-det_id",true,false);
     358  PXOPT_LOOKUP_STR(data_state,config->args, "-data_state", true, false);
     359
     360  psMetadata *where = psMetadataAlloc();
     361
     362  PXOPT_COPY_S64(config->args,where,"-det_id","det_id","==");
     363  PXOPT_COPY_S64(config->args,where,"-exp_id","exp_id","==");
     364
     365  if (!setResidExpDataState(config,where,data_state)) {
     366    return(false);
     367  }
     368  if (!setResidImfileDataState(config,where,data_state)) {
     369    return(false);
     370  }
     371  psFree(where);
     372  return(true);
     373}
     374
    355375bool pendingcleanup_residexpMode(pxConfig *config)
    356376{
    … …  
    367387    psString query = pxDataGet("dettool_pendingcleanup_residexp.sql");
    368388    if (!query) {
    369         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     389        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    370390        return false;
    371391    }
    … …  
    430450    psString query = pxDataGet("dettool_donecleanup_residexp.sql");
    431451    if (!query) {
    432         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     452        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    433453        return false;
    434454    }

  • branches/simtest_nebulous_branches/ippTools/src/dettool_residimfile.c

    r23688 r27840  
    2929    psString query = pxDataGet("dettool_toresidimfile.sql");
    3030    if (!query) {
    31         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     31        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    3232        return false;
    3333    }
    … …  
    165165    psString query = pxDataGet("dettool_residimfile.sql");
    166166    if (!query) {
    167         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     167        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    168168        return false;
    169169    }
    … …  
    253253    psString query = pxDataGet("dettool_revertresidimfile.sql");
    254254    if (!query) {
    255         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     255        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    256256        return false;
    257257    }
    … …  
    284284
    285285    PXOPT_LOOKUP_S64(det_id, config->args, "-det_id", true, false);
    286     PXOPT_LOOKUP_S32(iteration, config->args, "-iteration", true, false);
    287     PXOPT_LOOKUP_S64(exp_id, config->args, "-exp_id", true, false);
    288     PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false);
    289286    PXOPT_LOOKUP_STR(data_state, config->args, "-data_state", true, false);
    290     if (!setResidImfileDataState(config, det_id, iteration, exp_id, class_id, data_state)) {
     287
     288    psMetadata *where = psMetadataAlloc();
     289
     290    PXOPT_COPY_S64(config->args,where,"-det_id","det_id","==");
     291    PXOPT_COPY_S32(config->args,where,"-iteration", "iteration","==");
     292    PXOPT_COPY_S64(config->args,where,"-exp_id","exp_id","==");
     293    PXOPT_COPY_STR(config->args,where,"-class_id","class_id","==");
     294
     295    if (!setResidImfileDataState(config, where, data_state)) {
    291296        return false;
    292297    }
    … …  
    309314    psString query = pxDataGet("dettool_pendingcleanup_residimfile.sql");
    310315    if (!query) {
    311         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     316        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    312317        return false;
    313318    }
    … …  
    373378    psString query = pxDataGet("dettool_donecleanup_residimfile.sql");
    374379    if (!query) {
    375         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     380        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    376381        return false;
    377382    }

  • branches/simtest_nebulous_branches/ippTools/src/dettool_stack.c

    r23688 r27840  
    3131    psString query = pxDataGet("dettool_tostacked.sql");
    3232    if (!query) {
    33         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     33        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    3434        return false;
    3535    }
    … …  
    220220    psString query = pxDataGet("dettool_stacked.sql");
    221221    if (!query) {
    222         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     222        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    223223        psFree(where);
    224224        return false;
    … …  
    290290    psString query = pxDataGet("dettool_revertstacked.sql");
    291291    if (!query) {
    292         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     292        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    293293        return false;
    294294    }
    … …  
    345345    psString query = pxDataGet("dettool_pendingcleanup_stacked.sql");
    346346    if (!query) {
    347         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     347        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    348348        return false;
    349349    }
    … …  
    408408    psString query = pxDataGet("dettool_donecleanup_stacked.sql");
    409409    if (!query) {
    410         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     410        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    411411        return false;
    412412    }

  • branches/simtest_nebulous_branches/ippTools/src/difftool.c

    r24955 r27840  
    3737static bool todiffskyfileMode(pxConfig *config);
    3838static bool adddiffskyfileMode(pxConfig *config);
     39static bool advanceMode(pxConfig *config);
    3940static bool diffskyfileMode(pxConfig *config);
    4041static bool revertdiffskyfileMode(pxConfig *config);
    … …  
    4243static bool definewarpstackMode(pxConfig *config);
    4344static bool definewarpwarpMode(pxConfig *config);
     45static bool definestackstackMode(pxConfig *config);
    4446static bool pendingcleanuprunMode(pxConfig *config);
    4547static bool pendingcleanupskyfileMode(pxConfig *config);
    … …  
    5052
    5153static bool setdiffRunState(pxConfig *config, psS64 diff_id, const char *state, psS64 magicked);
    52 static bool diffRunComplete(pxConfig *config);
     54static bool change_skyfile_data_state(pxConfig *config, psString data_state, psString run_state);
     55static bool tocleanedskyfileMode(pxConfig *config);
     56static bool topurgedskyfileMode(pxConfig *config);
     57static bool toscrubbedskyfileMode(pxConfig *config);
     58static bool tofullskyfileMode(pxConfig *config);
     59static bool listrunMode(pxConfig *config);
     60static bool setskyfiletoupdateMode(pxConfig *config);
     61
     62
    5363
    5464# define MODECASE(caseName, func) \
    … …  
    7686        MODECASE(DIFFTOOL_MODE_TODIFFSKYFILE,         todiffskyfileMode);
    7787        MODECASE(DIFFTOOL_MODE_ADDDIFFSKYFILE,        adddiffskyfileMode);
     88        MODECASE(DIFFTOOL_MODE_ADVANCE,               advanceMode);
    7889        MODECASE(DIFFTOOL_MODE_DIFFSKYFILE,           diffskyfileMode);
    7990        MODECASE(DIFFTOOL_MODE_REVERTDIFFSKYFILE,     revertdiffskyfileMode);
    8091        MODECASE(DIFFTOOL_MODE_DEFINEPOPRUN,          definepoprunMode);
    81         MODECASE(DIFFTOOL_MODE_DEFINEWARPSTACK,         definewarpstackMode);
     92        MODECASE(DIFFTOOL_MODE_DEFINEWARPSTACK,       definewarpstackMode);
    8293        MODECASE(DIFFTOOL_MODE_DEFINEWARPWARP,        definewarpwarpMode);
     94        MODECASE(DIFFTOOL_MODE_DEFINESTACKSTACK,      definestackstackMode);
    8395        MODECASE(DIFFTOOL_MODE_PENDINGCLEANUPRUN,     pendingcleanuprunMode);
    8496        MODECASE(DIFFTOOL_MODE_PENDINGCLEANUPSKYFILE, pendingcleanupskyfileMode);
    … …  
    8799        MODECASE(DIFFTOOL_MODE_EXPORTRUN,             exportrunMode);
    88100        MODECASE(DIFFTOOL_MODE_IMPORTRUN,             importrunMode);
     101        MODECASE(DIFFTOOL_MODE_TOCLEANEDSKYFILE,      tocleanedskyfileMode);
     102        MODECASE(DIFFTOOL_MODE_TOPURGEDSKYFILE,       topurgedskyfileMode);
     103        MODECASE(DIFFTOOL_MODE_TOSCRUBBEDSKYFILE,     toscrubbedskyfileMode);
     104        MODECASE(DIFFTOOL_MODE_TOFULLSKYFILE,         tofullskyfileMode);
     105        MODECASE(DIFFTOOL_MODE_LISTRUN,               listrunMode);
     106        MODECASE(DIFFTOOL_MODE_SETSKYFILETOUPDATE,    setskyfiletoupdateMode);
     107
    89108        default:
    90109            psAbort("invalid option (this should not happen)");
    … …  
    114133
    115134    // required options
    116     PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false);
     135    PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", true, false);
    117136    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", true, false);
    118137    PXOPT_LOOKUP_BOOL(bothways, config->args, "-bothways", false);
    119138    PXOPT_LOOKUP_BOOL(exposure, config->args, "-exposure", false);
    120     PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
    121     PXOPT_LOOKUP_STR(reduction, config->args, "-reduction", false, false);
     139    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
     140    PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
     141    PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false);
     142    PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false);
     143    PXOPT_LOOKUP_S16(diff_mode, config->args, "-set_diff_mode", false, false);
     144    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
    122145
    123146    // default
    … …  
    130153            workdir,
    131154            label,
     155            data_group ? data_group : label,
     156            dist_group,
    132157            reduction,
    133158            NULL,       // dvodb
    … …  
    136161            bothways,
    137162            exposure,
    138             false
     163            false,
     164            diff_mode,
     165            note
    139166    );
    140167    if (!run) {
    … …  
    167194    PS_ASSERT_PTR_NON_NULL(config, false);
    168195
    169     // required options
    170     PXOPT_LOOKUP_S64(diff_id, config->args, "-diff_id", true, false);
    171     PXOPT_LOOKUP_STR(state, config->args, "-state", true, false);
    172 
    173     if (state) {
    174         // set detRun.state to state
    175         return setdiffRunState(config, diff_id, state, false);
    176     }
    177 
    178     return true;
     196    psMetadata *where = psMetadataAlloc();
     197
     198    PXOPT_COPY_S64(config->args, where, "-diff_id",  "diff_id",   "==");
     199    PXOPT_COPY_STR(config->args, where, "-label",     "label",     "==");
     200    PXOPT_COPY_STR(config->args, where, "-data_group","data_group",     "==");
     201    PXOPT_COPY_STR(config->args, where, "-state",     "state",     "==");
     202    if (!psListLength(where->list)) {
     203        psFree(where);
     204        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     205        return false;
     206    }
     207
     208    psString query = psStringCopy("UPDATE diffRun");
     209
     210    // pxUpdateRun gets parameters from config->args and updates
     211    bool result = pxUpdateRun(config, where, &query, "diffRun", "diff_id", "diffSkyfile", true);
     212
     213    psFree(query);
     214    psFree(where);
     215
     216    return result;
    179217}
    180218
    … …  
    331369    psString query = pxDataGet("difftool_inputskyfile.sql");
    332370    if (!query) {
    333         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    334         return false;
    335     }
    336 
    337     psString whereClause = NULL;
     371        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     372        return false;
     373    }
     374
     375    psString whereClause = psStringCopy("");
    338376    if (psListLength(where->list)) {
    339377        whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    340         psStringPrepend(&whereClause, "\n AND ");
     378        psStringPrepend(&whereClause, "\n WHERE ");
    341379    }
    342380    psFree(where);
    343381
    344382    // Add condition to get only templates or only inputs
     383    psString templateClause = psStringCopy("");
    345384    {
    346         psString templateClause = NULL;
    347385        if (template) {
    348             psStringAppend(&templateClause, " %s", " template != 0");
     386            psStringAppend(&templateClause, "\n WHERE %s", " template != 0");
    349387        } else if (input) {
    350             psStringAppend(&templateClause, " %s", " template = 0");
    351         }
    352         if (templateClause) {
    353             psStringAppend(&whereClause, "\n AND %s", templateClause);
    354         }
    355         psFree(templateClause);
     388            psStringAppend(&templateClause, "\n WHERE %s", " template = 0");
     389        }
    356390    }
    357391
    … …  
    364398    }
    365399
    366     if (!p_psDBRunQueryF(config->dbh, query, whereClause, whereClause, whereClause, whereClause)) {
    367         psError(PS_ERR_UNKNOWN, false, "database error");
     400    if (!p_psDBRunQueryF(config->dbh, query, whereClause, whereClause, whereClause, whereClause, templateClause)) {
     401        psError(PS_ERR_UNKNOWN, false, "database error");
     402        psFree(templateClause);
    368403        psFree(whereClause);
    369404        psFree(query);
    370405        return false;
    371406    }
     407    psFree(templateClause);
    372408    psFree(whereClause);
    373409    psFree(query);
    … …  
    421457    psString query = pxDataGet("difftool_todiffskyfile.sql");
    422458    if (!query) {
    423         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     459        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    424460        return false;
    425461    }
    … …  
    555591    }
    556592
    557     if (!diffRunComplete(config)) {
    558         if (!psDBRollback(config->dbh)) {
    559             psError(PS_ERR_UNKNOWN, false, "database error");
    560         }
    561         psError(PS_ERR_UNKNOWN, false, "database error");
    562         return false;
    563     }
    564 
    565593    // point of no return
    566594    if (!psDBCommit(config->dbh)) {
    … …  
    569597    }
    570598
     599
     600    return true;
     601}
     602
     603static bool advanceMode(pxConfig *config)
     604{
     605    PS_ASSERT_PTR_NON_NULL(config, false);
     606
     607    psMetadata *where = psMetadataAlloc();
     608    PXOPT_COPY_S64(config->args, where,  "-diff_id", "diffRun.diff_id", "==");
     609    pxAddLabelSearchArgs (config, where, "-label", "diffRun.label", "==");
     610
     611    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     612
     613    // look for completed diffRuns
     614    psString query = pxDataGet("difftool_completed_runs.sql");
     615    if (!query) {
     616        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     617        return false;
     618    }
     619
     620    psString whereString = psStringCopy("");
     621    if (psListLength(where->list)) {
     622        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     623        psStringAppend(&whereString, "\n AND %s", whereClause);
     624        psFree(whereClause);
     625    }
     626    psFree(where);
     627
     628    // treat limit == 0 as "no limit"
     629    if (limit) {
     630        psString limitString = psDBGenerateLimitSQL(limit);
     631        psStringAppend(&query, " %s", limitString);
     632        psFree(limitString);
     633    }
     634
     635    if (!psDBTransaction(config->dbh)) {
     636        psError(PS_ERR_UNKNOWN, false, "database error");
     637        psFree(whereString);
     638        return false;
     639    }
     640
     641    if (!p_psDBRunQueryF(config->dbh, query, whereString)) {
     642        psError(PS_ERR_UNKNOWN, false, "database error");
     643        psFree(query);
     644        psFree(whereString);
     645        if (!psDBRollback(config->dbh)) {
     646            psError(PS_ERR_UNKNOWN, false, "database error");
     647        }
     648        return false;
     649    }
     650    psFree(query);
     651    psFree(whereString);
     652
     653    psArray *output = p_psDBFetchResult(config->dbh);
     654    if (!output) {
     655        psError(PS_ERR_UNKNOWN, false, "database error");
     656        if (!psDBRollback(config->dbh)) {
     657            psError(PS_ERR_UNKNOWN, false, "database error");
     658        }
     659        return false;
     660    }
     661    if (!psArrayLength(output)) {
     662        psTrace("difftool", PS_LOG_INFO, "no rows found");
     663        psFree(output);
     664        return true;
     665    }
     666
     667    for (long i = 0; i < psArrayLength(output); i++) {
     668        psMetadata *row = output->data[i];
     669
     670        psS64 diff_id = psMetadataLookupS64(NULL, row, "diff_id");
     671        psS64 magicked = psMetadataLookupS64(NULL, row, "magicked");
     672
     673        // set diffRun.state to 'full'
     674        if (!setdiffRunState(config, diff_id, "full", magicked)) {
     675            psError(PS_ERR_UNKNOWN, false, "failed to change diffRun.state for diff_id: %" PRId64,
     676                diff_id);
     677            psFree(output);
     678            if (!psDBRollback(config->dbh)) {
     679                psError(PS_ERR_UNKNOWN, false, "database error");
     680            }
     681            return false;
     682        }
     683    }
     684    psFree(output);
     685
     686    if (!psDBCommit(config->dbh)) {
     687        psError(PS_ERR_UNKNOWN, false, "database error");
     688        return false;
     689    }
    571690
    572691    return true;
    … …  
    581700    PXOPT_COPY_S64(config->args, where,  "-diff_id", "diffSkyfile.diff_id", "==");
    582701    PXOPT_COPY_STR(config->args, where, "-skycell_id", "diffInputSkyfile.skycell_id", "==");
    583     PXOPT_COPY_S64(config->args, where,  "-diff_skyfile_id", "diffInputSkyfile.diff_skyfile_id", "==");
     702    PXOPT_COPY_S64(config->args, where, "-diff_skyfile_id", "diffInputSkyfile.diff_skyfile_id", "==");
    584703    PXOPT_COPY_STR(config->args, where, "-tess_id", "diffRun.tess_id", "==");
    585704    PXOPT_COPY_S16(config->args, where, "-fault", "diffSkyfile.fault", "==");
    586     PXOPT_COPY_S64(config->args, where, "-exp_id", "rawExp.exp_id", "==");
    587     PXOPT_COPY_STR(config->args, where, "-exp_name", "rawExp.exp_name", "==");
    588     PXOPT_COPY_STR(config->args, where, "-warp_id", "warpRun.warp_id", "==");
    589 
     705    PXOPT_COPY_S64(config->args, where,  "-magicked", "diffSkyfile.magicked", "==");
     706    pxAddLabelSearchArgs (config, where, "-label", "diffRun.label", "LIKE");
     707    pxAddLabelSearchArgs (config, where, "-data_group", "diffRun.data_group", "LIKE");
     708
     709    PXOPT_LOOKUP_BOOL(pstamp_order, config->args, "-pstamp_order", false);
     710    PXOPT_LOOKUP_BOOL(template, config->args, "-template", false);
     711    if (!template) {
     712        PXOPT_COPY_S64(config->args, where, "-exp_id", "rawInput.exp_id", "==");
     713        PXOPT_COPY_STR(config->args, where, "-exp_name", "rawInput.exp_name", "==");
     714        PXOPT_COPY_STR(config->args, where, "-warp_id", "warpInput.warp_id", "==");
     715        PXOPT_COPY_TIME(config->args, where, "-dateobs_begin", "rawInput.dateobs",  ">=");
     716        PXOPT_COPY_TIME(config->args, where, "-dateobs_end",   "rawInput.dateobs",  "<=");
     717        PXOPT_COPY_STR(config->args, where, "-filter",     "rawInput.filter", "LIKE");
     718    } else {
     719        PXOPT_COPY_S64(config->args, where, "-exp_id", "rawTemplate.exp_id", "==");
     720        PXOPT_COPY_STR(config->args, where, "-exp_name", "rawTemplate.exp_name", "==");
     721        PXOPT_COPY_STR(config->args, where, "-warp_id", "warpTemplate.warp_id", "==");
     722        PXOPT_COPY_TIME(config->args, where, "-dateobs_begin", "rawTemplate.dateobs",  ">=");
     723        PXOPT_COPY_TIME(config->args, where, "-dateobs_end",   "rawTemplate.dateobs",  "<=");
     724        PXOPT_COPY_STR(config->args, where, "-filter",     "rawTemplate.filter", "LIKE");
     725    }
     726
     727    PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
    590728    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    591729    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    592730
     731
     732    psString where2 = NULL;
     733    pxmagicAddWhere(config, &where2, "diffSkyfile");
     734    pxspaceAddWhere(config, &where2, template ? "rawTemplate" : "rawInput");
    593735    psString query = pxDataGet("difftool_skyfile.sql");
    594736    if (!query) {
    595         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     737        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    596738        return false;
    597739    }
    … …  
    601743        psStringAppend(&query, " WHERE %s", whereClause);
    602744        psFree(whereClause);
     745    } else if (where2) {
     746        psStringAppend(&query, " WHERE diffRun.diff_id is not null %s", where2);
     747    } else if (!all) {
     748        psError(PXTOOLS_ERR_CONFIG, true, "search parameters or -all are required");
     749        return false;
    603750    }
    604751    psFree(where);
    605752
     753    if (pstamp_order) {
     754        if (template) {
     755            psStringAppend(&query, " ORDER BY rawTemplate.exp_id, diff_id DESC");
     756        } else {
     757            psStringAppend(&query, " ORDER BY rawInput.exp_id, diff_id DESC");
     758        }
     759    }
     760           
    606761    // treat limit == 0 as "no limit"
    607762    if (limit) {
    … …  
    659814    psMetadata *where = psMetadataAlloc();
    660815    PXOPT_COPY_S64(config->args, where,  "-diff_id", "diffSkyfile.diff_id", "==");
    661     PXOPT_COPY_STR(config->args, where,  "-label", "diffRun.label", "==");
     816    PXOPT_COPY_STR(config->args, where,  "-skycell_id", "diffSkyfile.skycell_id", "==");
     817    pxAddLabelSearchArgs(config, where, "-label", "diffRun.label", "==");
    662818    PXOPT_COPY_S16(config->args, where, "-fault",     "fault", "==");
    663819
    664820    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    665821        psFree(where);
    666         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
    667         return false;
    668     }
    669 
    670     if (!psDBTransaction(config->dbh)) {
    671         psError(PS_ERR_UNKNOWN, false, "database error");
    672         psFree(where);
    673         return false;
    674     }
    675 
    676     // Update state to 'new'
     822        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     823        return false;
     824    }
     825
    677826    {
    678         psString query = pxDataGet("difftool_revertdiffskyfile_update.sql");
     827        psString query = pxDataGet("difftool_revertdiffskyfile_delete.sql");
    679828        if (!query) {
    680             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    681             if (!psDBRollback(config->dbh)) {
    682                 psError(PS_ERR_UNKNOWN, false, "database error");
    683             }
     829            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     830            return false;
     831        }
     832        psString query_updated = pxDataGet("difftool_revertdiffskyfile_updated.sql");
     833        if (!query_updated) {
     834            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    684835            return false;
    685836        }
    … …  
    688839            psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    689840            psStringAppend(&query, " AND %s", whereClause);
     841            psStringAppend(&query_updated, " AND %s", whereClause);
    690842            psFree(whereClause);
    691843        }
    … …  
    694846            psError(PS_ERR_UNKNOWN, false, "database error");
    695847            psFree(query);
    696             if (!psDBRollback(config->dbh)) {
    697                 psError(PS_ERR_UNKNOWN, false, "database error");
    698             }
    699848            return false;
    700849        }
    701850        psFree(query);
     851        psLogMsg("difftool", PS_LOG_INFO, "Deleted %" PRIu64 " rows", psDBAffectedRows(config->dbh));
     852
     853        if (!p_psDBRunQuery(config->dbh, query_updated)) {
     854            psError(PS_ERR_UNKNOWN, false, "database error");
     855            psFree(query_updated);
     856            return false;
     857        }
     858        psFree(query_updated);
    702859
    703860        psLogMsg("difftool", PS_LOG_INFO, "Updated %" PRIu64 " rows", psDBAffectedRows(config->dbh));
    704861    }
    705862
    706     // Delete product
    707     {
    708         psString query = pxDataGet("difftool_revertdiffskyfile_delete.sql");
    709         if (!query) {
    710             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    711             if (!psDBRollback(config->dbh)) {
    712                 psError(PS_ERR_UNKNOWN, false, "database error");
    713             }
    714             return false;
    715         }
    716 
    717         if (psListLength(where->list)) {
    718             psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    719             psStringAppend(&query, " AND %s", whereClause);
    720             psFree(whereClause);
    721         }
    722 
    723         if (!p_psDBRunQuery(config->dbh, query)) {
    724             psError(PS_ERR_UNKNOWN, false, "database error");
    725             psFree(query);
    726             if (!psDBRollback(config->dbh)) {
    727                 psError(PS_ERR_UNKNOWN, false, "database error");
    728             }
    729             return false;
    730         }
    731         psFree(query);
    732 
    733         psLogMsg("difftool", PS_LOG_INFO, "Deleted %" PRIu64 " rows", psDBAffectedRows(config->dbh));
    734     }
    735 
    736863    psFree(where);
    737864
    738     if (!psDBCommit(config->dbh)) {
    739         psError(PS_ERR_UNKNOWN, false, "database error");
    740         return false;
    741     }
    742865
    743866    return true;
    … …  
    755878    }
    756879
    757     char *query = "UPDATE diffRun SET state = '%s', magicked = %" PRId64 " WHERE diff_id = %"PRId64;
    758 
    759     if (!p_psDBRunQueryF(config->dbh, query, state, magicked, diff_id)) {
     880    if (magicked) {
     881      char *query = "UPDATE diffRun SET state = '%s', magicked = %" PRId64 " WHERE diff_id = %"PRId64;
     882
     883      if (!p_psDBRunQueryF(config->dbh, query, state, magicked, diff_id)) {
    760884        psError(PS_ERR_UNKNOWN, false,
    761885                "failed to change state for diff_id %"PRId64, diff_id);
    762886        return false;
     887      }
     888    }
     889    else {
     890      char *query = "UPDATE diffRun SET state = '%s' WHERE diff_id = %"PRId64;
     891
     892      if (!p_psDBRunQueryF(config->dbh, query, state, diff_id)) {
     893        psError(PS_ERR_UNKNOWN, false,
     894                "failed to change state for diff_id %"PRId64, diff_id);
     895        return false;
     896      }
    763897    }
    764898
    765899    return true;
    766900}
     901
     902
     903#ifdef notdef
     904static bool setdiffRunStateByLabel(pxConfig *config, const char *label, const char *state) {
     905  PS_ASSERT_PTR_NON_NULL(state,false);
     906
     907  // check that state is a valid string value
     908  if (!pxIsValidState(state)) {
     909    psError(PS_ERR_UNKNOWN, false, "invalid diffRun state: %s", state);
     910    return false;
     911  }
     912
     913  char *query = "UPDATE diffRun SET state = '%s' WHERE label = '%s'";
     914  if (!p_psDBRunQueryF(config->dbh,query,state,label)) {
     915    psError(PS_ERR_UNKNOWN, false,
     916            "failed to change state for label %s", label);
     917    return(false);
     918  }
     919
     920  return true;
     921}
     922#endif
    767923
    768924// Generate a single populated run
    … …  
    772928                         const char *tess_id, // Tessellation identifier
    773929                         const char *label, // label
     930                         const char *data_group, // data_group
     931                         const char *dist_group, // dist_group
    774932                         const char *reduction, // reduction
     933                         const char *note,      // note
    775934                         psS64 input_warp_id, // Warp identifier for input image, PS_MAX_S64 for none
    776935                         psS64 input_stack_id, // Stack identifier for input image, PS_MAX_S64 for none
    … …  
    793952        return false;
    794953    }
     954    psS16 diff_mode = IPP_DIFF_MODE_UNDEFINED;
     955    if ((input_warp_id != PS_MAX_S64) && (template_warp_id != PS_MAX_S64)) {
     956      diff_mode = IPP_DIFF_MODE_WARP_WARP;
     957    }
     958    else if ((input_warp_id != PS_MAX_S64) && (template_stack_id != PS_MAX_S64)) {
     959      diff_mode = IPP_DIFF_MODE_WARP_STACK;
     960    }
     961    else if ((input_stack_id != PS_MAX_S64) && (template_warp_id != PS_MAX_S64)) {
     962      diff_mode = IPP_DIFF_MODE_STACK_WARP;
     963    }
     964    else if ((input_stack_id != PS_MAX_S64) && (template_stack_id != PS_MAX_S64)) {
     965      diff_mode = IPP_DIFF_MODE_STACK_STACK;
     966    }
     967
    795968
    796969    // default
    … …  
    803976            workdir,
    804977            label,
     978            data_group ? data_group : label,
     979            dist_group,
    805980            reduction,
    806981            NULL,       // dvodb
    … …  
    809984            false,
    810985            false,
    811             0       // magicked
     986            0,       // magicked
     987            diff_mode, // diff_mode
     988            note
    812989    );
    813990
    … …  
    8831060    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", true, false); // required options
    8841061    PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
     1062    PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
     1063    PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false);
    8851064    PXOPT_LOOKUP_STR(reduction, config->args, "-reduction", false, false);
    8861065    PXOPT_LOOKUP_S64(template_warp_id, config->args, "-template_warp_id", false, false);
    … …  
    8891068    PXOPT_LOOKUP_S64(input_stack_id, config->args, "-input_stack_id", false, false);
    8901069    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1070    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
    8911071
    8921072    if (template_stack_id && template_warp_id) {
    … …  
    9111091
    9121092    psArray *list = psArrayAllocEmpty(16); // List of runs, to print
    913 
    914     if (!populatedrun(list, workdir, skycell_id, tess_id, label, reduction,
     1093    // Populated Run will generate the diff_mode value
     1094    if (!populatedrun(list, workdir, skycell_id, tess_id, label, data_group ? data_group : label, dist_group, reduction, note,
    9151095                      input_warp_id ? input_warp_id : PS_MAX_S64,
    9161096                      input_stack_id ? input_stack_id : PS_MAX_S64,
    … …  
    9391119
    9401120    psMetadata *expWhere = psMetadataAlloc();
    941     psMetadata *warpWhere = psMetadataAlloc();
     1121    psMetadata *warp1Where = psMetadataAlloc(); // First set of restrictions on warp
     1122    psMetadata *warp2Where = psMetadataAlloc(); // Second set of restriction on warp
    9421123    psMetadata *stackWhere = psMetadataAlloc();
    9431124
    9441125    PXOPT_COPY_S64(config->args, expWhere, "-exp_id", "exp_id", "==");
    9451126    PXOPT_COPY_STR(config->args, expWhere, "-filter", "filter", "==");
    946     PXOPT_COPY_S64(config->args, warpWhere, "-warp_id", "warpRun.warp_id", "==");
    947     PXOPT_COPY_STR(config->args, warpWhere, "-skycell_id", "warpSkyfile.skycell_id", "==");
    948     PXOPT_COPY_STR(config->args, warpWhere, "-tess_id", "warpRun.tess_id", "==");
    949     PXOPT_COPY_STR(config->args, warpWhere, "-warp_label", "warpRun.label", "==");
    950     PXOPT_COPY_F32(config->args, warpWhere,  "-good_frac", "warpSkyfile.good_frac", ">=");
     1127    PXOPT_COPY_STR(config->args, expWhere, "-comment", "comment", "LIKE");
     1128    PXOPT_COPY_S64(config->args, warp1Where, "-warp_id", "warpRun.warp_id", "==");
     1129    PXOPT_COPY_STR(config->args, warp1Where, "-warp_label", "warpRun.label", "==");
     1130    PXOPT_COPY_STR(config->args, warp1Where, "-tess_id", "warpRun.tess_id", "==");
     1131    PXOPT_COPY_STR(config->args, warp1Where, "-data_group", "warpRun.data_group", "==");
     1132    PXOPT_COPY_S64(config->args, warp2Where, "-warp_id", "warpRun.warp_id", "==");
     1133    PXOPT_COPY_STR(config->args, warp2Where, "-tess_id", "warpRun.tess_id", "==");
     1134    PXOPT_COPY_STR(config->args, warp2Where, "-data_group", "warpRun.data_group", "==");
     1135    PXOPT_COPY_STR(config->args, warp2Where, "-skycell_id", "warpSkyfile.skycell_id", "==");
     1136    PXOPT_COPY_STR(config->args, warp2Where, "-warp_label", "warpRun.label", "==");
     1137    PXOPT_COPY_F32(config->args, warp2Where,  "-good_frac", "warpSkyfile.good_frac", ">=");
    9511138    PXOPT_COPY_STR(config->args, stackWhere, "-stack_label", "stackRun.label", "==");
    9521139
    953     PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false); // required options
    954     PXOPT_LOOKUP_STR(reduction, config->args, "-reduction", false, false); // option
    955     PXOPT_LOOKUP_STR(label, config->args, "-label", false, false); // option
    956     PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
     1140    PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", true, false); // required option
     1141    PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false); // option
     1142    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false); // option
     1143    PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
     1144    PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false);
     1145    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
     1146    PXOPT_LOOKUP_TIME(registered, config->args, "-set_registered", false, false);
     1147
    9571148    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    9581149    PXOPT_LOOKUP_BOOL(newTemplates, config->args, "-new-templates", false);
    … …  
    9641155    psString query = pxDataGet("difftool_definewarpstack_part1.sql");
    9651156    if (!query) {
    966         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    967         return false;
    968     }
    969 
    970     psString warpQuery = NULL;
     1157        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1158        return false;
     1159    }
     1160
     1161    psString warp1Query = NULL;
     1162    psString warp2Query = NULL;
    9711163    psString stackQuery = NULL;
    9721164    psString expQuery = NULL;
    … …  
    9801172    }
    9811173    psFree(expWhere);
    982     if (psListLength(warpWhere->list)) {
    983         psString whereClause = psDBGenerateWhereConditionSQL(warpWhere, NULL);
    984         psStringAppend(&warpQuery, "\n AND %s", whereClause);
     1174    if (psListLength(warp1Where->list)) {
     1175        psString whereClause = psDBGenerateWhereConditionSQL(warp1Where, NULL);
     1176        psStringAppend(&warp1Query, "\n AND %s", whereClause);
    9851177        psFree(whereClause);
    9861178    } else {
    987         warpQuery = psStringCopy("\n");
    988     }
    989     psFree(warpWhere);
    990 
    991     if (!available) {
    992         // diff what's available, even if warp run has some faults and is incomplete
    993         psStringAppend(&warpQuery, " AND warpRun.state = 'full'");
    994     }
     1179        warp1Query = psStringCopy("\n");
     1180    }
     1181    psFree(warp1Where);
     1182    if (psListLength(warp2Where->list)) {
     1183        psString whereClause = psDBGenerateWhereConditionSQL(warp2Where, NULL);
     1184        psStringAppend(&warp2Query, "\n AND %s", whereClause);
     1185        psFree(whereClause);
     1186    } else {
     1187        warp2Query = psStringCopy("\n");
     1188    }
     1189    psFree(warp2Where);
    9951190
    9961191    // don't queue for exposures that have already been diff'd unless requested
    … …  
    10111206    psFree(stackWhere);
    10121207
    1013     psTrace("difftool", 1, query, warpQuery, diffQuery, expQuery, stackQuery);
     1208    psTrace("difftool", 1, query, warp1Query, warp2Query, diffQuery, expQuery, stackQuery);
    10141209
    10151210    if (!psDBTransaction(config->dbh)) {
    … …  
    10181213    }
    10191214
    1020     if (!p_psDBRunQueryF(config->dbh, query, warpQuery, expQuery, diffQuery)) {
     1215    if (!p_psDBRunQueryF(config->dbh, query, warp1Query, warp2Query, expQuery, diffQuery)) {
    10211216        psError(PS_ERR_UNKNOWN, false, "database error");
    10221217        psFree(query);
    … …  
    10781273        return false;
    10791274    }
     1275    psFree(warp1Query);
    10801276    psFree(query);
    10811277    query = NULL;
    … …  
    11091305        if (!p_psDBRunQuery(config->dbh, "DELETE FROM skycellsToDiff")) {
    11101306            psError(PS_ERR_UNKNOWN, false, "database error");
    1111             psFree(warpQuery);
     1307            psFree(warp2Query);
    11121308            psFree(stackQuery);
    11131309            psFree(skycell_query);
    … …  
    11201316        if (!mdok) {
    11211317            psError(PXTOOLS_ERR_PROG, false, "warp_id not found --- ignoring row %ld", i);
    1122             psFree(warpQuery);
     1318            psFree(warp2Query);
    11231319            psFree(stackQuery);
    11241320            psFree(skycell_query);
    … …  
    11311327        if (!mdok) {
    11321328            psError(PXTOOLS_ERR_PROG, false, "skycell_count not found");
    1133             psFree(warpQuery);
     1329            psFree(warp2Query);
    11341330            psFree(stackQuery);
    11351331            psFree(skycell_query);
    … …  
    11421338        if (!mdok) {
    11431339            psError(PXTOOLS_ERR_PROG, false, "tess_id not found");
    1144             psFree(warpQuery);
     1340            psFree(warp2Query);
    11451341            psFree(stackQuery);
    11461342            psFree(skycell_query);
    … …  
    11501346            return false;
    11511347        }
     1348
    11521349        psString filter = psMetadataLookupStr(&mdok, row, "filter");
    11531350        if (!mdok) {
    11541351            psError(PXTOOLS_ERR_PROG, false, "filter not found");
    1155             psFree(warpQuery);
     1352            psFree(warp2Query);
    11561353            psFree(stackQuery);
    11571354            psFree(skycell_query);
    … …  
    11611358            return false;
    11621359        }
    1163         if (!p_psDBRunQueryF(config->dbh, skycell_query, stackQuery, warp_id, filter, warpQuery)) {
    1164             psError(PS_ERR_UNKNOWN, false, "database error");
    1165             psFree(warpQuery);
     1360
     1361        psString warp_data_group = psMetadataLookupStr(&mdok, row, "data_group");
     1362        if (!mdok) {
     1363          psError(PXTOOLS_ERR_PROG, false, "warp data_group not found");
     1364          psFree(warp2Query);
     1365          psFree(stackQuery);
     1366          psFree(skycell_query);
     1367          if (!psDBRollback(config->dbh)) {
     1368            psError(PS_ERR_UNKNOWN, false, "database error");
     1369          }
     1370          return false;
     1371        }
     1372        if (warp_data_group) {
     1373          data_group = warp_data_group;
     1374        }
     1375       
     1376        if (!p_psDBRunQueryF(config->dbh, skycell_query, stackQuery, warp_id, filter, warp2Query)) {
     1377            psError(PS_ERR_UNKNOWN, false, "database error");
     1378            psFree(warp2Query);
    11661379            psFree(stackQuery);
    11671380            psFree(skycell_query);
    … …  
    11741387
    11751388        if (num == 0) {
    1176             psTrace("difftool", PS_LOG_INFO, "no skycells with stack found for %" PRId64, warp_id);
     1389            psTrace("difftool", PS_LOG_INFO, "no skycells with stack found for warp_id %" PRId64, warp_id);
    11771390            continue;
    11781391        }
    11791392
    11801393        if (!available && (num != skycell_count)) {
    1181             psTrace("difftool", PS_LOG_INFO, "%" PRId64 " skyfiles with stack found for warp_id %"
    1182                 PRId64 " need %" PRId64, num, skycell_count, warp_id);
     1394            psTrace("difftool", PS_LOG_INFO, "%" PRId64 " skyfiles with stack found for warp_id %" PRId64
     1395                    " but need %" PRId64, num, warp_id, skycell_count);
    11831396            continue;
    11841397        }
    … …  
    11901403                workdir,
    11911404                label,
     1405                data_group ? data_group : label,
     1406                dist_group,
    11921407                reduction,
    11931408                NULL,       // dvodb
    … …  
    11961411                false,                  // bothways
    11971412                true,                   // exposure
    1198                 0       // magicked
     1413                0,       // magicked
     1414                IPP_DIFF_MODE_WARP_STACK,
     1415                note
    11991416        );
    12001417
    … …  
    12121429        if (!p_psDBRunQuery(config->dbh, query)) {
    12131430            psError(PS_ERR_UNKNOWN, false, "database error");
    1214             psFree(warpQuery);
     1431            psFree(warp2Query);
    12151432            psFree(stackQuery);
    12161433            psFree(skycell_query);
    … …  
    12261443        if (!p_psDBRunQuery(config->dbh, query)) {
    12271444            psError(PS_ERR_UNKNOWN, false, "database error");
    1228             psFree(warpQuery);
     1445            psFree(warp2Query);
    12291446            psFree(stackQuery);
    12301447            psFree(skycell_query);
    … …  
    12411458            psError(PS_ERR_UNKNOWN, false, "failed to change diffRun.state for diff_id: %" PRId64,
    12421459                run->diff_id);
    1243             psFree(warpQuery);
     1460            psFree(warp2Query);
    12441461            psFree(stackQuery);
    12451462            psFree(skycell_query);
    … …  
    12551472    }
    12561473    psFree(output);
    1257     psFree(warpQuery);
     1474    psFree(warp2Query);
    12581475    psFree(stackQuery);
    12591476    psFree(skycell_query);
    … …  
    12651482    }
    12661483
    1267     if (!diffRunPrintObjects(stdout, list, !simple)) {
     1484    if (numGood && !diffRunPrintObjects(stdout, list, !simple)) {
    12681485        psError(PS_ERR_UNKNOWN, false, "failed to print object");
    12691486        psFree(list);
    … …  
    13431560    // Additional controls
    13441561    PXOPT_LOOKUP_BOOL(rerun, config->args, "-rerun", false);
    1345     PXOPT_LOOKUP_BOOL(available, config->args, "-available", false);
    13461562
    13471563    // Settings to apply to defined run
    1348     PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false); // required options
    1349     PXOPT_LOOKUP_STR(reduction, config->args, "-reduction", false, false); // option
    1350     PXOPT_LOOKUP_STR(label, config->args, "-label", false, false); // option
    1351     PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
     1564    PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", true, false); // required options
     1565    PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false); // option
     1566    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false); // option
     1567    PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false); // option
     1568    PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false); // option
     1569    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false); // option
     1570    PXOPT_LOOKUP_TIME(registered, config->args, "-set_registered", false, false);
     1571
    13521572    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    13531573    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
    … …  
    13641584        psString tempCreate = pxDataGet("difftool_definewarpwarp_temp_create.sql"); // Create temp table SQL
    13651585        if (!tempCreate) {
    1366             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1586            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    13671587            psFree(selectWhere);
    13681588            psFree(insertWhere);
    … …  
    13871607        psString tempInsert = pxDataGet("difftool_definewarpwarp_temp_insert.sql"); // Insert to temp table
    13881608        if (!tempInsert) {
    1389             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1609            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    13901610            psFree(selectWhere);
    13911611            psFree(insertWhere);
    … …  
    14191639    psString select = pxDataGet("difftool_definewarpwarp_select.sql");
    14201640    if (!select) {
    1421         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1641        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    14221642        psFree(selectWhere);
    14231643        psFree(insertWhere);
    … …  
    14321652    if (psListLength(selectWhere->list)) {
    14331653        psString new = psDBGenerateWhereConditionSQL(selectWhere, NULL);
    1434         psStringAppend(&whereClause, "\n%s %s", whereClause ? "AND" : "WHERE", new);
     1654        psStringAppend(&whereClause, "\nAND %s", new);
    14351655        psFree(new);
    14361656    }
    14371657    psFree(selectWhere);
    14381658
    1439     if (!available) {
    1440         psStringAppend(&whereClause,
    1441                        "\n%s inputWarpRun.state = 'full'"
    1442                        "AND templateWarpRun.state = 'full'",
    1443                        whereClause ? "AND" : "WHERE");
    1444     }
    1445 
    14461659    if (!rerun) {
    1447         psStringAppend(&whereClause, "\n%s diffs.diff_id IS NULL", whereClause ? "AND" : "WHERE");
     1660        psStringAppend(&whereClause, "\nAND diffs.diff_id IS NULL");
    14481661    }
    14491662
    … …  
    15221735        const char *template = psMetadataLookupStr(NULL, row, "template_warp_id");
    15231736        const char *tess_id = psMetadataLookupStr(NULL, row, "tess_id");
     1737        psString input_data_group = psMetadataLookupStr(NULL, row, "input_data_group");
     1738        if (input_data_group) {
     1739          data_group = input_data_group;
     1740        }
     1741
    15241742        if (!input_id || !template || !tess_id) {
    15251743            psError(PXTOOLS_ERR_PROG, false, "Identifiers not found");
    … …  
    15321750            return false;
    15331751        }
    1534 
    1535         diffRunRow *run = diffRunRowAlloc(0, "reg", workdir, label, reduction, NULL, registered,
    1536                                           tess_id, true, true, false); // Run to insert
     1752       
     1753        diffRunRow *run = diffRunRowAlloc(0,
     1754                                          "reg",
     1755                                          workdir,
     1756                                          label,
     1757                                          data_group ? data_group : label,
     1758                                          dist_group,
     1759                                          reduction,
     1760                                          NULL,  // dvodb
     1761                                          registered,
     1762                                          tess_id,
     1763                                          true,  // bothways
     1764                                          true,  // exposure
     1765                                          false, // magicked
     1766                                          IPP_DIFF_MODE_WARP_WARP,
     1767                                          note); // Run to insert
    15371768        if (!diffRunInsertObject(config->dbh, run)) {
    15381769            psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    16061837}
    16071838
     1839static bool definestackstackMode(pxConfig *config) {
     1840  PS_ASSERT_PTR_NON_NULL(config, false);
     1841
     1842  psMetadata *stack1Where = psMetadataAlloc();
     1843  psMetadata *stack2Where = psMetadataAlloc();
     1844
     1845  PXOPT_COPY_STR(config->args, stack1Where, "-tess_id", "stackRun.tess_id", "==");
     1846  PXOPT_COPY_STR(config->args, stack2Where, "-tess_id", "stackRun.tess_id", "==");
     1847  PXOPT_COPY_STR(config->args, stack1Where, "-filter", "stackRun.filter", "==");
     1848  PXOPT_COPY_STR(config->args, stack2Where, "-filter", "stackRun.filter", "==");
     1849  PXOPT_COPY_STR(config->args, stack1Where, "-skycell_id", "stackRun.skycell_id", "==");
     1850  PXOPT_COPY_STR(config->args, stack2Where, "-skycell_id", "stackRun.skycell_id", "==");
     1851  PXOPT_COPY_STR(config->args, stack1Where, "-input_label", "stackRun.label","==");
     1852  PXOPT_COPY_STR(config->args, stack2Where, "-template_label", "stackRun.label","==");
     1853  PXOPT_COPY_F32(config->args, stack1Where, "-good_frac", "stackSumSkyfile.good_frac", ">=");
     1854  PXOPT_COPY_F32(config->args, stack2Where, "-good_frac", "stackSumSkyfile.good_frac", ">=");
     1855
     1856  PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", true, false); // required option
     1857  PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false); // option
     1858  PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false); // option
     1859  PXOPT_LOOKUP_TIME(registered, config->args, "-set_registered", false, false);
     1860  PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
     1861  PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false);
     1862  PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
     1863
     1864  PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1865  PXOPT_LOOKUP_BOOL(reRun, config->args, "-rerun", false);
     1866  PXOPT_LOOKUP_BOOL(newTemplates,config->args,"-new-templates", false);
     1867
     1868  PXOPT_LOOKUP_BOOL(available, config->args, "-available", false);
     1869  PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
     1870
     1871  if (!(label)) {
     1872    PXOPT_LOOKUP_STR(label,config->args, "-input_label",true,false);
     1873  }
     1874
     1875  // Organize the config information into queries.
     1876  psString stack1Query = NULL;
     1877  psString stack2Query = NULL;
     1878
     1879  if (psListLength(stack1Where->list)) {
     1880    psString whereClause = psDBGenerateWhereConditionSQL(stack1Where, NULL);
     1881    psStringAppend(&stack1Query, "\n AND %s", whereClause);
     1882    psFree(whereClause);
     1883  } else {
     1884    stack1Query = psStringCopy("\n");
     1885  }
     1886  psFree(stack1Where);
     1887
     1888  if (psListLength(stack2Where->list)) {
     1889    psString whereClause = psDBGenerateWhereConditionSQL(stack2Where, NULL);
     1890    psStringAppend(&stack2Query, "\n AND %s", whereClause);
     1891    psFree(whereClause);
     1892  } else {
     1893    stack2Query = psStringCopy("\n");
     1894  }
     1895  psFree(stack2Where);
     1896
     1897  // don't queue for stacks that have already been diffed unless requested
     1898  psString diffQuery = NULL;
     1899  if (! (reRun || newTemplates) ) {
     1900    psStringAppend(&diffQuery, "\n AND diffExp.diff_id IS NULL");
     1901  } else {
     1902    diffQuery = psStringCopy("\n");
     1903  }
     1904
     1905  // find the distinct set of data_groups and filters
     1906  psString query = pxDataGet("difftool_definestackstack_part0.sql");
     1907  if (!query) {
     1908    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1909    return(false);
     1910  }
     1911  psTrace("difftool",1,query,stack2Query,stack1Query,diffQuery,stack1Query);
     1912/*   exit(10); */
     1913
     1914  if (!psDBTransaction(config->dbh)) {
     1915    psError(PS_ERR_UNKNOWN, false, "database error");
     1916    return(false);
     1917  }
     1918
     1919  if (!p_psDBRunQueryF(config->dbh, query, stack2Query, stack1Query, diffQuery, stack1Query)) {
     1920    psError(PS_ERR_UNKNOWN, false, "database error");
     1921    psFree(query);
     1922    if (!psDBRollback(config->dbh)) {
     1923      psError(PS_ERR_UNKNOWN, false, "database error");
     1924    }
     1925    return false;
     1926  }
     1927
     1928  psFree(query);
     1929
     1930  psArray *output = p_psDBFetchResult(config->dbh);
     1931  if (!output) {
     1932    psErrorCode err = psErrorCodeLast();
     1933    switch (err) {
     1934    case PS_ERR_DB_CLIENT:
     1935      psError(PXTOOLS_ERR_SYS, false, "database error");
     1936      break;
     1937    case PS_ERR_DB_SERVER:
     1938      psError(PXTOOLS_ERR_PROG, false, "database error");
     1939      break;
     1940    default:
     1941      psError(PXTOOLS_ERR_PROG, false, "unknown error");
     1942      break;
     1943    }
     1944    if (!psDBRollback(config->dbh)) {
     1945      psError(PS_ERR_UNKNOWN, false, "database error");
     1946    }
     1947    return false;
     1948  }
     1949  if (!psArrayLength(output)) {
     1950    psTrace("difftool", PS_LOG_INFO, "no rows found");
     1951    psFree(output);
     1952    if (!psDBCommit(config->dbh)) {
     1953      psError(PS_ERR_UNKNOWN, false, "database error");
     1954      return false;
     1955    }
     1956    return true;
     1957  }
     1958
     1959  query = pxDataGet("difftool_definestackstack_part1.sql");
     1960  if (pretend) {
     1961    // negative simple so the default is true
     1962    if (!ippdbPrintMetadatas(stdout, output, "diffRunTemp", !simple)) {
     1963      psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1964      psFree(output);
     1965      return false;
     1966    }
     1967    psFree(output);
     1968    return true;
     1969  }
     1970
     1971  psArray *list = psArrayAllocEmpty(16); // List of runs defined, to print
     1972  for (long i = 0; i < output->n; i++) {
     1973    psMetadata *row = output->data[i]; // Output row from query
     1974    bool mdok;                      // Status of MD lookup
     1975
     1976    psString tess_id = psMetadataLookupStr(&mdok,row,"INPUT_tess_id");
     1977    psString this_data_group = psMetadataLookupStr(&mdok,row,"INPUT_data_group");
     1978    psString this_dist_group = psMetadataLookupStr(&mdok,row,"INPUT_dist_group");
     1979    psString this_label = psMetadataLookupStr(&mdok,row,"INPUT_label");
     1980
     1981    psString this_stack1Query = psStringCopy(stack1Query);
     1982
     1983    psString thisWhere = psDBGenerateWhereConditionSQL(row,NULL);
     1984    psStringSubstitute(&thisWhere,"stackRun.","INPUT_");
     1985    psStringAppend(&this_stack1Query,"\n AND %s", thisWhere);
     1986    psFree(thisWhere);
     1987
     1988    psTrace("difftool",1, query,stack2Query,this_stack1Query,diffQuery,this_stack1Query);
     1989    if (!psDBTransaction(config->dbh)) {
     1990      psError(PS_ERR_UNKNOWN, false, "database error");
     1991      return(false);
     1992    }
     1993
     1994    if (!p_psDBRunQueryF(config->dbh, query, stack2Query, this_stack1Query, diffQuery, this_stack1Query)) {
     1995      psError(PS_ERR_UNKNOWN, false, "database error");
     1996      psFree(query);
     1997      if (!psDBRollback(config->dbh)) {
     1998        psError(PS_ERR_UNKNOWN, false, "database error");
     1999      }
     2000      return false;
     2001    }
     2002    psFree(this_stack1Query);
     2003
     2004    psArray *diff_id_output = p_psDBFetchResult(config->dbh);
     2005    if (!diff_id_output) {
     2006      psErrorCode err = psErrorCodeLast();
     2007      switch (err) {
     2008      case PS_ERR_DB_CLIENT:
     2009        psError(PXTOOLS_ERR_SYS, false, "database error");
     2010        break;
     2011      case PS_ERR_DB_SERVER:
     2012        psError(PXTOOLS_ERR_PROG, false, "database error");
     2013        break;
     2014      default:
     2015        psError(PXTOOLS_ERR_PROG, false, "unknown error");
     2016        break;
     2017      }
     2018      if (!psDBRollback(config->dbh)) {
     2019        psError(PS_ERR_UNKNOWN, false, "database error");
     2020      }
     2021      return false;
     2022    }
     2023    if (!psArrayLength(diff_id_output)) {
     2024      psTrace("difftool", PS_LOG_INFO, "no rows found");
     2025      psFree(diff_id_output);
     2026      if (!psDBCommit(config->dbh)) {
     2027        psError(PS_ERR_UNKNOWN, false, "database error");
     2028        return false;
     2029      }
     2030      return true;
     2031    }
     2032
     2033    // ok we've got one create the diffRun
     2034    diffRunRow *run = diffRunRowAlloc(
     2035                                      0,          // ID
     2036                                      "reg",      // state
     2037                                      workdir,
     2038                                      label ? label : this_label,
     2039                                      data_group ? data_group : this_data_group,
     2040                                      dist_group ? dist_group : this_dist_group,
     2041                                      reduction,
     2042                                      NULL,       // dvodb
     2043                                      registered,
     2044                                      tess_id,
     2045                                      false,                 // bothways
     2046                                      false,                 // exposure
     2047                                      0,       // magicked
     2048                                      IPP_DIFF_MODE_STACK_STACK, // diff_mode
     2049                                      note
     2050                                      );
     2051    // Commit to database
     2052    if (!diffRunInsertObject(config->dbh, run)) {
     2053      psError(PS_ERR_UNKNOWN, false, "database error");
     2054      psFree(run);
     2055      if (!psDBRollback(config->dbh)) {
     2056        psError(PS_ERR_UNKNOWN, false, "database error");
     2057      }
     2058      return false;
     2059    }
     2060/*     diffRunPrintObject(stdout,run,1); */
     2061    run->diff_id = psDBLastInsertID(config->dbh);
     2062    for (long j = 0; j < diff_id_output->n; j++) {
     2063      psMetadata *input_row = diff_id_output->data[j]; // Output row from query
     2064      bool mdok;
     2065      psString in_skycell_id  = psMetadataLookupStr(&mdok,input_row,"skycell_id");
     2066      psS64 in_input_stack_id = psMetadataLookupS64(&mdok,input_row,"stack_id");
     2067      psS64 in_template_stack_id = psMetadataLookupS64(&mdok,input_row,"max_stack_id");
     2068      psString in_tess_id = psMetadataLookupStr(&mdok,input_row,"tess_id");
     2069      psTrace("difftool",1,"%s %" PRId64 " %" PRId64 " %s\n",
     2070              in_skycell_id, in_input_stack_id, in_template_stack_id, in_tess_id);
     2071      diffInputSkyfileRow *input = diffInputSkyfileRowAlloc(
     2072                                                            run->diff_id,   // ID
     2073                                                            in_skycell_id,
     2074                                                            PS_MAX_S64, // warp1_id -> NULL
     2075                                                            in_input_stack_id, // stack1
     2076                                                            PS_MAX_S64, // warp2_id -> NULL
     2077                                                            in_template_stack_id, // stack2
     2078                                                            in_tess_id,
     2079                                                            0 // diff_skyfile_id
     2080                                                            );
     2081      // Commit to database the input
     2082      if (!diffInputSkyfileInsertObject(config->dbh, input)) {
     2083        psError(PS_ERR_UNKNOWN, false, "database error");
     2084        psFree(input);
     2085        if (!psDBRollback(config->dbh)) {
     2086          psError(PS_ERR_UNKNOWN, false, "database error");
     2087        }
     2088        return false;
     2089      }
     2090
     2091/*       diffInputSkyfilePrintObject(stdout,input,1); */
     2092      psFree(input);
     2093    }
     2094
     2095    if (!setdiffRunState(config, run->diff_id, "new", false)) {
     2096        psError(PS_ERR_UNKNOWN, false, "failed to change diffRun.state for diff_id: %" PRId64, run->diff_id);
     2097        psFree(stack1Query);
     2098        psFree(stack2Query);
     2099        psFree(diffQuery);
     2100        psFree(run);
     2101        psFree(list);
     2102        if (!psDBRollback(config->dbh)) {
     2103            psError(PS_ERR_UNKNOWN, false, "database error");
     2104        }
     2105        return false;
     2106    }
     2107    psArrayAdd(list, list->n, run);
     2108    psFree(run);
     2109  }
     2110
     2111  if (!psDBCommit(config->dbh)) {
     2112    psError(PS_ERR_UNKNOWN, false, "database error");
     2113    psFree(list);
     2114    return false;
     2115  }
     2116
     2117  if (!diffRunPrintObjects(stdout, list, !simple)) {
     2118    psError(PS_ERR_UNKNOWN, false, "failed to print object");
     2119    psFree(list);
     2120    return false;
     2121  }
     2122
     2123  psFree(query);
     2124  psFree(stack1Query);
     2125  psFree(stack2Query);
     2126  psFree(diffQuery);
     2127  psFree(output);
     2128  psFree(list);
     2129
     2130    if (!psDBCommit(config->dbh)) {
     2131        psError(PS_ERR_UNKNOWN, false, "database error");
     2132        psFree(list);
     2133        return false;
     2134    }
     2135
     2136  return(true);
     2137}
    16082138
    16092139static bool pendingcleanuprunMode(pxConfig *config)
    … …  
    16192149    psString query = pxDataGet("difftool_pendingcleanuprun.sql");
    16202150    if (!query) {
    1621         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1622         return false;
    1623     }
     2151        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     2152        return false;
     2153    }
     2154    // pxDataGet/psStringSubstitute workaround
     2155    psString queryCopy = psStringCopy(query);
     2156    psFree(query);
     2157    query = queryCopy;
    16242158
    16252159    if (where && psListLength(where->list)) {
    16262160        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    1627         psStringAppend(&query, " AND %s", whereClause);
     2161        psStringAppend(&whereClause, " AND ");
     2162        psStringSubstitute(&query,whereClause,"@INNERCONSTRAINT@");
    16282163        psFree(whereClause);
     2164    }
     2165    else {
     2166      psStringSubstitute(&query,NULL,"@INNERCONSTRAINT@");
    16292167    }
    16302168    psFree(where);
    … …  
    16362174        psFree(limitString);
    16372175    }
    1638 
     2176    //    fprintf(stderr,"%s",query);
     2177
     2178    //fprintf(stderr,"%s",query);
    16392179    if (!p_psDBRunQuery(config->dbh, query)) {
    16402180        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    16842224    psString query = pxDataGet("difftool_pendingcleanupskyfile.sql");
    16852225    if (!query) {
    1686         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     2226        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    16872227        return false;
    16882228    }
    … …  
    17442284    psString query = pxDataGet("difftool_donecleanup.sql");
    17452285    if (!query) {
    1746         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     2286        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    17472287        return false;
    17482288    }
    … …  
    17992339    psMetadata *where = psMetadataAlloc();
    18002340    PXOPT_COPY_S64(config->args, where, "-diff_id",   "diff_id",   "==");
     2341    PXOPT_COPY_STR(config->args, where, "-skycell_id", "skycell_id",   "==");
    18012342
    18022343    if (!pxSetFaultCode(config->dbh, "diffSkyfile", where, fault)) {
    … …  
    18102351}
    18112352
    1812 static bool diffRunComplete(pxConfig *config)
    1813 {
    1814     PS_ASSERT_PTR_NON_NULL(config, false);
    1815 
    1816     // look for completed diffRuns
    1817     psString query = pxDataGet("difftool_completed_runs.sql");
    1818     if (!query) {
    1819         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1820         return false;
    1821     }
    1822 
    1823     if (!p_psDBRunQuery(config->dbh, query)) {
    1824         psError(PS_ERR_UNKNOWN, false, "database error");
    1825         psFree(query);
    1826         return false;
    1827     }
    1828     psFree(query);
    1829 
    1830     psArray *output = p_psDBFetchResult(config->dbh);
    1831     if (!output) {
    1832         psError(PS_ERR_UNKNOWN, false, "database error");
    1833         return false;
    1834     }
    1835     if (!psArrayLength(output)) {
    1836         psTrace("difftool", PS_LOG_INFO, "no rows found");
    1837         psFree(output);
    1838         return true;
    1839     }
    1840     for (long i = 0; i < psArrayLength(output); i++) {
    1841         psMetadata *row = output->data[i];
    1842 
    1843         psS64 diff_id = psMetadataLookupS64(NULL, row, "diff_id");
    1844         psS64 magicked = psMetadataLookupS64(NULL, row, "magicked");
    1845 
    1846         // set diffRun.state to 'stop'
    1847         if (!setdiffRunState(config, diff_id, "full", magicked)) {
    1848             psError(PS_ERR_UNKNOWN, false, "failed to change diffRun.state for diff_id: %" PRId64,
    1849                 diff_id);
    1850             psFree(output);
    1851             return false;
    1852         }
    1853     }
    1854 
    1855     return true;
    1856 }
     2353static bool change_skyfile_data_state(pxConfig *config, psString data_state, psString run_state) {
     2354  PS_ASSERT_PTR_NON_NULL(config, false);
     2355
     2356  // diff_id, skycell_id are required
     2357  PXOPT_LOOKUP_S64(diff_id, config->args, "-diff_id", true, false);
     2358  PXOPT_LOOKUP_STR(skycell_id, config->args, "-skycell_id", true, false);
     2359
     2360
     2361  psS64 magicked = 0;
     2362  if (!strcmp(data_state, "full")) {
     2363      PXOPT_LOOKUP_S64(set_magicked, config->args, "-magicked", 0, false);
     2364      magicked = set_magicked;
     2365  }
     2366
     2367  psString query = pxDataGet("difftool_change_skyfile_data_state.sql");
     2368
     2369  if (!psDBTransaction(config->dbh)) {
     2370    psError(PS_ERR_UNKNOWN, false, "database error");
     2371    return(false);
     2372  }
     2373
     2374  psString set_magicked_skyfile = psStringCopy("");
     2375  psString set_magicked_run = psStringCopy("");
     2376  if (magicked != 0 && !strcmp(data_state, "full")) {
     2377    psStringAppend(&set_magicked_skyfile,  "\n , diffSkyfile.magicked = %" PRId64, magicked);
     2378    psStringAppend(&set_magicked_run,      "\n , diffRun.magicked = %" PRId64, magicked);
     2379
     2380  } else if (!strcmp(data_state, "cleaned") || !strcmp(data_state, "purged")) {
     2381    psStringAppend(&set_magicked_skyfile, "\n, diffSkyfile.magicked = IF(diffSkyfile.magicked = 0, 0, -1)");
     2382    psStringAppend(&set_magicked_run, "\n, diffRun.magicked = IF(diffRun.magicked = 0, 0, -1)");
     2383  }
     2384
     2385  // Uses the unconstrained (diffRun.state [NEED NOT EQUAL] run_state) version from warptool.c
     2386
     2387  if (!p_psDBRunQueryF(config->dbh, query, data_state, set_magicked_skyfile, diff_id, skycell_id)) {
     2388    psError(PS_ERR_UNKNOWN, false, "database error");
     2389    // rollback
     2390    if (!psDBRollback(config->dbh)) {
     2391      psError(PS_ERR_UNKNOWN, false, "database error");
     2392    }
     2393    psError(PS_ERR_UNKNOWN, false, "database error");
     2394    psFree(set_magicked_skyfile);
     2395    return(false);
     2396  }
     2397  psFree(set_magicked_skyfile);
     2398  psFree(query);
     2399
     2400  query = pxDataGet("difftool_change_run_state.sql");
     2401  if (!p_psDBRunQueryF(config->dbh, query, data_state, set_magicked_run, diff_id, data_state)) {
     2402    // rollback
     2403    if (!psDBRollback(config->dbh)) {
     2404      psError(PS_ERR_UNKNOWN, false, "database error");
     2405    }
     2406    psError(PS_ERR_UNKNOWN, false, "database error");
     2407    psFree(set_magicked_run);
     2408    return(false);
     2409  }
     2410
     2411  if (!psDBCommit(config->dbh)) {
     2412    psError(PS_ERR_UNKNOWN, false, "database error");
     2413    psFree(set_magicked_run);
     2414    return(false);
     2415  }
     2416  psFree(set_magicked_run);
     2417
     2418  return(true);
     2419}
     2420
     2421static bool tocleanedskyfileMode(pxConfig *config) {
     2422  return change_skyfile_data_state(config, "cleaned","goto_cleaned");
     2423}
     2424static bool topurgedskyfileMode(pxConfig *config) {
     2425  return change_skyfile_data_state(config, "purged", "goto_purged");
     2426}
     2427static bool toscrubbedskyfileMode(pxConfig *config) {
     2428  return change_skyfile_data_state(config, "scrubbed", "goto_scrubbed");
     2429}
     2430static bool tofullskyfileMode(pxConfig *config) {
     2431  return change_skyfile_data_state(config, "full", "update");
     2432}
     2433
    18572434
    18582435bool exportrunMode(pxConfig *config)
    … …  
    18782455  }
    18792456
     2457  if (!pxExportVersion(config, f)) {
     2458    psError(PS_ERR_UNKNOWN, false, "failed to write dbversion output file");
     2459    return false;
     2460  }
    18802461  psMetadata *where = psMetadataAlloc();
    18812462  PXOPT_COPY_S64(config->args, where, "-diff_id", "diff_id", "==");
    … …  
    18902471    psString query = pxDataGet(tables[i].sqlFilename);
    18912472    if (!query) {
    1892       psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     2473      psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    18932474      return false;
    18942475    }
    … …  
    19692550  psMetadata *input = psMetadataConfigRead (NULL, &nFail, infile, false);
    19702551
    1971   fprintf (stdout, "---- input ----\n");
     2552#ifdef notdef
     2553  fprintf (stderr, "---- input ----\n");
    19722554  psMetadataPrint (stderr, input, 1);
    1973 
     2555#endif
     2556
     2557  if (!pxCheckImportVersion(config, input)) {
     2558      psError(PS_ERR_UNKNOWN, false, "pxCheckImportVersion failed");
     2559      return false;
     2560  }
    19742561  psMetadataItem *item = psMetadataLookup (input, "diffRun");
    19752562  psAssert (item, "entry not in input?");
    … …  
    20212608  return true;
    20222609}
     2610
     2611static bool listrunMode(pxConfig *config)
     2612{
     2613    PS_ASSERT_PTR_NON_NULL(config, false);
     2614
     2615    psMetadata *where = psMetadataAlloc();
     2616    PXOPT_COPY_S64(config->args, where,  "-diff_id", "diffRun.diff_id", "==");
     2617    PXOPT_COPY_STR(config->args, where, "-tess_id", "diffRun.tess_id", "==");
     2618    PXOPT_COPY_S64(config->args, where,  "-magicked", "diffRun.magicked", "==");
     2619    pxAddLabelSearchArgs (config, where, "-label", "diffRun.label", "LIKE");
     2620    pxAddLabelSearchArgs (config, where, "-data_group", "diffRun.data_group", "LIKE");
     2621    pxAddLabelSearchArgs (config, where, "-dist_group", "diffRun.dist_group", "LIKE");
     2622
     2623    PXOPT_LOOKUP_BOOL(template, config->args, "-template", false);
     2624    if (!template) {
     2625        PXOPT_COPY_S64(config->args, where, "-exp_id", "rawInput.exp_id", "==");
     2626        PXOPT_COPY_STR(config->args, where, "-exp_name", "rawInput.exp_name", "==");
     2627        PXOPT_COPY_STR(config->args, where, "-warp_id", "warpInput.warp_id", "==");
     2628        PXOPT_COPY_TIME(config->args, where, "-dateobs_begin", "rawInput.dateobs",  ">=");
     2629        PXOPT_COPY_TIME(config->args, where, "-dateobs_end",   "rawInput.dateobs",  "<=");
     2630        PXOPT_COPY_STR(config->args, where, "-filter",     "rawInput.filter", "LIKE");
     2631    } else {
     2632        PXOPT_COPY_S64(config->args, where, "-exp_id", "rawTemplate.exp_id", "==");
     2633        PXOPT_COPY_STR(config->args, where, "-exp_name", "rawTemplate.exp_name", "==");
     2634        PXOPT_COPY_STR(config->args, where, "-warp_id", "warpTemplate.warp_id", "==");
     2635        PXOPT_COPY_TIME(config->args, where, "-dateobs_begin", "rawTemplate.dateobs",  ">=");
     2636        PXOPT_COPY_TIME(config->args, where, "-dateobs_end",   "rawTemplate.dateobs",  "<=");
     2637        PXOPT_COPY_STR(config->args, where, "-filter",     "rawTemplate.filter", "LIKE");
     2638    }
     2639
     2640    PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
     2641    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     2642    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     2643    PXOPT_LOOKUP_BOOL(pstamp_order, config->args, "-pstamp_order", false);
     2644
     2645
     2646    psString where2 = NULL;
     2647    pxmagicAddWhere(config, &where2, "diffRun");
     2648    pxspaceAddWhere(config, &where2, template ? "rawTemplate" : "rawInput");
     2649    psString query = pxDataGet("difftool_listrun.sql");
     2650    if (!query) {
     2651        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     2652        return false;
     2653    }
     2654
     2655    if (psListLength(where->list)) {
     2656        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     2657        psStringAppend(&query, " WHERE %s", whereClause);
     2658        psFree(whereClause);
     2659    } else if (where2) {
     2660        psStringAppend(&query, " WHERE diffRun.diff_id is not null %s", where2);
     2661    } else if (!all) {
     2662        psError(PXTOOLS_ERR_CONFIG, true, "search parameters or -all are required");
     2663        return false;
     2664    }
     2665    psFree(where);
     2666
     2667    if (pstamp_order) {
     2668        if (template) {
     2669            psStringAppend(&query, " ORDER BY rawTemplate.exp_id, diff_id DESC");
     2670        } else {
     2671            psStringAppend(&query, " ORDER BY rawInput.exp_id, diff_id DESC");
     2672        }
     2673    }
     2674           
     2675    // treat limit == 0 as "no limit"
     2676    if (limit) {
     2677        psString limitString = psDBGenerateLimitSQL(limit);
     2678        psStringAppend(&query, " %s", limitString);
     2679        psFree(limitString);
     2680    }
     2681
     2682    if (!p_psDBRunQuery(config->dbh, query)) {
     2683        psError(PS_ERR_UNKNOWN, false, "database error");
     2684        psFree(query);
     2685        return false;
     2686    }
     2687    psFree(query);
     2688
     2689    psArray *output = p_psDBFetchResult(config->dbh);
     2690    if (!output) {
     2691        psErrorCode err = psErrorCodeLast();
     2692        switch (err) {
     2693            case PS_ERR_DB_CLIENT:
     2694                psError(PXTOOLS_ERR_SYS, false, "database error");
     2695            case PS_ERR_DB_SERVER:
     2696                psError(PXTOOLS_ERR_PROG, false, "database error");
     2697            default:
     2698                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     2699        }
     2700
     2701        return false;
     2702    }
     2703    if (!psArrayLength(output)) {
     2704        psTrace("difftool", PS_LOG_INFO, "no rows found");
     2705        psFree(output);
     2706        return true;
     2707    }
     2708
     2709    if (psArrayLength(output)) {
     2710        // negative simple so the default is true
     2711        if (!ippdbPrintMetadatas(stdout, output, "diffRun", !simple)) {
     2712            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     2713            psFree(output);
     2714            return false;
     2715        }
     2716    }
     2717
     2718    psFree(output);
     2719
     2720    return true;
     2721}
     2722// a very specfic function to queue a cleaned warpSkyfile to be updated
     2723static bool setskyfiletoupdateMode(pxConfig *config)
     2724{
     2725    PS_ASSERT_PTR_NON_NULL(config, NULL);
     2726
     2727    PXOPT_LOOKUP_S64(diff_id, config->args, "-diff_id", true, false);
     2728    PXOPT_LOOKUP_STR(skycell_id, config->args, "-skycell_id", false, false);
     2729    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
     2730
     2731    psString query = pxDataGet("difftool_setskyfiletoupdate.sql");
     2732    if (!query) {
     2733        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     2734        return false;
     2735    }
     2736
     2737    psString setHook = psStringCopy("");
     2738    if (label) {
     2739        psStringAppend(&setHook, "\n , diffRun.label = '%s'", label);
     2740    }
     2741
     2742    if (skycell_id) {
     2743        psStringAppend(&query, " AND (diffSkyfile.skycell_id = '%s')", skycell_id);
     2744    }
     2745
     2746    if (!p_psDBRunQueryF(config->dbh, query, setHook, diff_id)) {
     2747        psError(PS_ERR_UNKNOWN, false, "database error");
     2748        return false;
     2749    }
     2750
     2751    psFree(setHook);
     2752    psFree(query);
     2753
     2754    return true;
     2755}

  • branches/simtest_nebulous_branches/ippTools/src/difftool.h

    r24174 r27840  
    3131    DIFFTOOL_MODE_TODIFFSKYFILE,
    3232    DIFFTOOL_MODE_ADDDIFFSKYFILE,
     33    DIFFTOOL_MODE_ADVANCE,
    3334    DIFFTOOL_MODE_DIFFSKYFILE,
    3435    DIFFTOOL_MODE_REVERTDIFFSKYFILE,
    … …  
    3637    DIFFTOOL_MODE_DEFINEWARPSTACK,
    3738    DIFFTOOL_MODE_DEFINEWARPWARP,
     39    DIFFTOOL_MODE_DEFINESTACKSTACK,
    3840    DIFFTOOL_MODE_PENDINGCLEANUPRUN,
    3941    DIFFTOOL_MODE_PENDINGCLEANUPSKYFILE,
    … …  
    4143    DIFFTOOL_MODE_UPDATEDIFFSKYFILE,
    4244    DIFFTOOL_MODE_EXPORTRUN,
    43     DIFFTOOL_MODE_IMPORTRUN
     45    DIFFTOOL_MODE_IMPORTRUN,
     46    DIFFTOOL_MODE_TOCLEANEDSKYFILE,
     47    DIFFTOOL_MODE_TOPURGEDSKYFILE,
     48    DIFFTOOL_MODE_TOSCRUBBEDSKYFILE,
     49    DIFFTOOL_MODE_TOFULLSKYFILE,
     50    DIFFTOOL_MODE_LISTRUN,
     51    DIFFTOOL_MODE_SETSKYFILETOUPDATE,
    4452} difftoolMode;
    4553

  • branches/simtest_nebulous_branches/ippTools/src/difftoolConfig.c

    r24933 r27840  
    3838    config->modules = pmConfigRead(&argc, argv, NULL);
    3939    if (!config->modules) {
    40         psError(PS_ERR_UNKNOWN, false, "Can't find site configuration");
     40        psError(psErrorCodeLast(), false, "Can't find site configuration");
    4141        psFree(config);
    4242        return NULL;
    … …  
    4747    // -definerun
    4848    psMetadata *definerunArgs = psMetadataAlloc();
    49     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-workdir", 0,            "define workdir (required)", NULL);
     49    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_workdir", 0,         "define workdir (required)", NULL);
    5050    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-tess_id",  0,            "define tessellation ID (required)", NULL);
    51     psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-bothways",  0,            "do the subtraction both ways?", false);
    52     psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-exposure",  0,            "subtraction for entire exposure?", false);
    53     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-label",  0,            "define label", NULL);
    54     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-reduction",  0,            "define reduction class", NULL);
    55     psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
     51    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-bothways",  0,          "do the subtraction both ways?", false);
     52    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-exposure",  0,          "subtraction for entire exposure?", false);
     53    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_label",  0,          "define label", NULL);
     54    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_reduction",  0,      "define reduction class", NULL);
     55    psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-set_registered",  0,    "time detrend run was registered", now);
     56    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_data_group",  0,     "define data group", NULL);
     57    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_dist_group",  0,     "define dist group", NULL);
     58    psMetadataAddS16(definerunArgs, PS_LIST_TAIL, "-set_diff_mode", 0,       "specify type of difference (WW=1,WS=2,SW=3,SS=4)", 0);
     59    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_note",  0,           "define note", NULL);
    5660    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    5761
    5862    // -updaterun
    5963    psMetadata *updaterunArgs = psMetadataAlloc();
    60     psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-diff_id", 0,            "define diff ID (required)", 0);
    61     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,            "set state (required)", NULL);
     64    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-diff_id", 0,          "define diff ID", 0);
     65    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,            "set state", NULL);
     66    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label", 0,            "define by label instead of diff ID", 0);
     67    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-data_group", 0,       "define by data_group instead of diff ID", 0);
     68    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_label", 0,        "define new value for label", 0);
     69    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state", 0,        "define new state", NULL);
     70    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_data_group", 0,   "define new data_group", NULL);
     71    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_dist_group", 0,   "define new dist_group", NULL);
     72    psMetadataAddS16(updaterunArgs, PS_LIST_TAIL, "-set_diff_mode", 0,       "specify type of difference (WW=1,WS=2,SW=3,SS=4)", 0);
     73    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_note", 0,         "define new note", NULL);
    6274
    6375    // -addinputskyfile
    … …  
    113125    psMetadataAddStr(adddiffskyfileArgs, PS_LIST_TAIL, "-hostname", 0,   "define hostname", 0);
    114126    psMetadataAddF32(adddiffskyfileArgs, PS_LIST_TAIL, "-good_frac",  0, "define %% of good pixels", NAN);
    115     psMetadataAddBool(adddiffskyfileArgs, PS_LIST_TAIL, "-magicked",  0, "define magicked state", false);
     127    psMetadataAddS64(adddiffskyfileArgs, PS_LIST_TAIL, "-magicked",  0, "define magicked state", 0);
     128
     129    // -advance
     130    psMetadata *advanceArgs = psMetadataAlloc();
     131    psMetadataAddS64(advanceArgs, PS_LIST_TAIL, "-diff_id", 0, "select by diff ID", 0);
     132    psMetadataAddStr(advanceArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "select by label", NULL);
     133    psMetadataAddS32(advanceArgs, PS_LIST_TAIL, "-limit", 0, "limit number of results", 0);
    116134
    117135    // -diffskyfile
    118136    psMetadata *diffskyfileArgs = psMetadataAlloc();
    119     psMetadataAddS64(diffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,            "search by diff ID", 0);
    120     psMetadataAddStr(diffskyfileArgs , PS_LIST_TAIL, "-skycell_id",  0,       "define skycell ID", NULL);
    121     psMetadataAddS64(diffskyfileArgs, PS_LIST_TAIL, "-diff_skyfile_id", 0,    "search by diff_skyfile_id ID", 0);
    122     psMetadataAddStr(diffskyfileArgs, PS_LIST_TAIL, "-tess_id",  0,            "define tessellation ID", NULL);
    123     psMetadataAddS64(diffskyfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "define exposure ID", 0);
    124     psMetadataAddStr(diffskyfileArgs , PS_LIST_TAIL, "-exp_name",  0,         "define exposure name", NULL);
    125     psMetadataAddStr(diffskyfileArgs , PS_LIST_TAIL, "-warp_id",  0,         "define warp_id", NULL);
    126     psMetadataAddU64(diffskyfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    127     psMetadataAddBool(diffskyfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    128     psMetadataAddS16(diffskyfileArgs, PS_LIST_TAIL, "-fault",  0,            "define fault code", 0);
     137    psMetadataAddS64(diffskyfileArgs, PS_LIST_TAIL,  "-diff_id", 0,           "search by diff ID", 0);
     138    psMetadataAddStr(diffskyfileArgs , PS_LIST_TAIL, "-skycell_id",  0,      "search by skycell ID", NULL);
     139    psMetadataAddS64(diffskyfileArgs, PS_LIST_TAIL,  "-diff_skyfile_id", 0,   "search by diff_skyfile_id ID", 0);
     140    psMetadataAddStr(diffskyfileArgs, PS_LIST_TAIL,  "-tess_id",  0,          "search by tessellation ID", NULL);
     141    psMetadataAddStr(diffskyfileArgs , PS_LIST_TAIL, "-warp_id",  0,         "search by warp_id", NULL);
     142    psMetadataAddBool(diffskyfileArgs, PS_LIST_TAIL, "-template",  0,        "apply exposure args to template of bothways diff", false);
     143    psMetadataAddS64(diffskyfileArgs, PS_LIST_TAIL,  "-exp_id",  0,           "search by exposure ID", 0);
     144    psMetadataAddStr(diffskyfileArgs , PS_LIST_TAIL, "-exp_name",  0,        "search by exposure name", NULL);
     145    psMetadataAddTime(diffskyfileArgs, PS_LIST_TAIL, "-dateobs_begin", 0,    "search for exposures by time (>=)", NULL);
     146    psMetadataAddTime(diffskyfileArgs, PS_LIST_TAIL, "-dateobs_end", 0,      "search for exposures by time (<=)", NULL);
     147    psMetadataAddStr(diffskyfileArgs, PS_LIST_TAIL,  "-filter", 0,           "search for filter", NULL);
     148    psMetadataAddStr(diffskyfileArgs,  PS_LIST_TAIL, "-label",  PS_META_DUPLICATE_OK, "search by diffRun label (LIKE comparison)", NULL);
     149    psMetadataAddStr(diffskyfileArgs,  PS_LIST_TAIL, "-data_group",  PS_META_DUPLICATE_OK, "search by diffRun data_group (LIKE comparison)", NULL);
     150    psMetadataAddStr(diffskyfileArgs,  PS_LIST_TAIL, "-dist_group",  PS_META_DUPLICATE_OK, "search by diffRun dist_group (LIKE comparison)", NULL);
     151    psMetadataAddS16(diffskyfileArgs, PS_LIST_TAIL,  "-fault",  0,           "search by fault code", 0);
     152    pxmagicAddArguments(diffskyfileArgs);
     153    pxspaceAddArguments(diffskyfileArgs);
     154
     155    psMetadataAddBool(diffskyfileArgs, PS_LIST_TAIL, "-pstamp_order",  0,    "order results for postage stamp server", false);
     156    psMetadataAddBool(diffskyfileArgs, PS_LIST_TAIL, "-all",  0,             "search without arguments", false);
     157    psMetadataAddU64(diffskyfileArgs, PS_LIST_TAIL,  "-limit",  0,            "limit result set to N items", 0);
     158    psMetadataAddBool(diffskyfileArgs, PS_LIST_TAIL, "-simple",  0,          "use the simple output format", false);
     159
     160    // -listrun
     161    psMetadata *listrunArgs = psMetadataAlloc();
     162    psMetadataAddS64(listrunArgs, PS_LIST_TAIL,  "-diff_id", 0,           "search by diff ID", 0);
     163    psMetadataAddStr(listrunArgs, PS_LIST_TAIL,  "-tess_id",  0,          "search by tessellation ID", NULL);
     164    psMetadataAddStr(listrunArgs , PS_LIST_TAIL, "-warp_id",  0,         "search by warp_id", NULL);
     165    psMetadataAddBool(listrunArgs, PS_LIST_TAIL, "-template",  0,        "apply exposure args to template of bothways diff", false);
     166    psMetadataAddS64(listrunArgs, PS_LIST_TAIL,  "-exp_id",  0,           "search by exposure ID", 0);
     167    psMetadataAddStr(listrunArgs , PS_LIST_TAIL, "-exp_name",  0,        "search by exposure name", NULL);
     168    psMetadataAddTime(listrunArgs, PS_LIST_TAIL, "-dateobs_begin", 0,    "search for exposures by time (>=)", NULL);
     169    psMetadataAddTime(listrunArgs, PS_LIST_TAIL, "-dateobs_end", 0,      "search for exposures by time (<=)", NULL);
     170    psMetadataAddStr(listrunArgs, PS_LIST_TAIL,  "-filter", 0,           "search for filter", NULL);
     171    psMetadataAddStr(listrunArgs,  PS_LIST_TAIL, "-label",  PS_META_DUPLICATE_OK, "search by diffRun label (LIKE comparison)", NULL);
     172    psMetadataAddStr(listrunArgs,  PS_LIST_TAIL, "-data_group",  PS_META_DUPLICATE_OK, "search by diffRun data_group (LIKE comparison)", NULL);
     173    psMetadataAddStr(listrunArgs,  PS_LIST_TAIL, "-dist_group",  PS_META_DUPLICATE_OK, "search by diffRun dist_group (LIKE comparison)", NULL);
     174    pxmagicAddArguments(listrunArgs);
     175    pxspaceAddArguments(listrunArgs);
     176
     177    psMetadataAddBool(listrunArgs, PS_LIST_TAIL, "-pstamp_order",  0,    "order results for postage stamp server", false);
     178
     179    psMetadataAddBool(listrunArgs, PS_LIST_TAIL, "-all",  0,             "search without arguments", false);
     180    psMetadataAddU64(listrunArgs, PS_LIST_TAIL,  "-limit",  0,            "limit result set to N items", 0);
     181    psMetadataAddBool(listrunArgs, PS_LIST_TAIL, "-simple",  0,          "use the simple output format", false);
     182
    129183
    130184    // -revertdiffskyfile
    131185    psMetadata *revertdiffskyfileArgs = psMetadataAlloc();
    132186    psMetadataAddS64(revertdiffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,            "search by diff ID", 0);
    133     psMetadataAddStr(revertdiffskyfileArgs, PS_LIST_TAIL, "-label", 0, "search by label", NULL);
     187    psMetadataAddStr(revertdiffskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0, "search by skycell_id", NULL);
     188    psMetadataAddStr(revertdiffskyfileArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by label", NULL);
    134189    psMetadataAddS16(revertdiffskyfileArgs, PS_LIST_TAIL, "-fault",  0,            "search by fault code", 0);
    135190    psMetadataAddBool(revertdiffskyfileArgs, PS_LIST_TAIL, "-all",  0, "allow no search terms", 0);
    … …  
    156211    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-tess_id", 0, "search by tess ID", NULL);
    157212    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-filter", 0, "search by filter", NULL);
     213    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-comment", 0, "search by comment (LIKE)", NULL);
    158214    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-stack_label", 0, "search by stack label", NULL);
    159215    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-warp_label", 0, "search by warp label", NULL);
     216    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-data_group", 0, "search by data_group", NULL);
    160217    psMetadataAddF32(definewarpstackArgs, PS_LIST_TAIL, "-good_frac", 0, "minimum good fraction of skycell", NAN);
    161     psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-workdir", 0, "define workdir (required)", NULL);
    162     psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-label",  0, "define label", NULL);
    163     psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-reduction",  0, "define reduction class", NULL);
    164     psMetadataAddTime(definewarpstackArgs, PS_LIST_TAIL, "-registered", 0, "time detrend run was registered", now);
     218    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-set_workdir", 0, "define workdir (required)", NULL);
     219    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-set_label",  0, "define label", NULL);
     220    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-set_reduction",  0, "define reduction class", NULL);
     221    psMetadataAddTime(definewarpstackArgs, PS_LIST_TAIL, "-set_registered", 0, "time detrend run was registered", now);
     222    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-set_data_group",  0,     "define data group", NULL);
     223    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-set_dist_group",  0,     "define dist group", NULL);
     224    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-set_note",  0,           "define note", NULL);
    165225    psMetadataAddBool(definewarpstackArgs, PS_LIST_TAIL, "-new-templates", 0, "also search for diffs with new template", false);
    166226    psMetadataAddBool(definewarpstackArgs, PS_LIST_TAIL, "-rerun", 0, "define new run even if one exists", false);
    167     psMetadataAddBool(definewarpstackArgs, PS_LIST_TAIL, "-available", 0, "define new run even if warpRun has some faults", false);
     227    psMetadataAddBool(definewarpstackArgs, PS_LIST_TAIL, "-available", 0, "define new run even if no stacks available for some skycells", false);
    168228    psMetadataAddBool(definewarpstackArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    169229    psMetadataAddBool(definewarpstackArgs, PS_LIST_TAIL, "-pretend", 0, "list results but to not queue", false);
    … …  
    182242    psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-template_label", 0, "search by warp label for template", NULL);
    183243    psMetadataAddF32(definewarpwarpArgs, PS_LIST_TAIL, "-good_frac", 0, "minimum good fraction of skycell", NAN);
    184     psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-workdir", 0, "define workdir (required)", NULL);
    185     psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-label",  0, "define label", NULL);
    186     psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-reduction",  0, "define reduction class", NULL);
    187     psMetadataAddTime(definewarpwarpArgs, PS_LIST_TAIL, "-registered", 0, "time detrend run was registered", now);
     244    psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-set_workdir", 0, "define workdir (required)", NULL);
     245    psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-set_label",  0, "define label", NULL);
     246    psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-set_reduction",  0, "define reduction class", NULL);
     247    psMetadataAddTime(definewarpwarpArgs, PS_LIST_TAIL, "-set_registered", 0, "time detrend run was registered", now);
     248    psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-set_data_group",  0,     "define data group", NULL);
     249    psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-set_dist_group",  0,     "define dist group", NULL);
     250    psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-set_note",  0,           "define note", NULL);
    188251    psMetadataAddBool(definewarpwarpArgs, PS_LIST_TAIL, "-rerun", 0, "define new run even if one exists", false);
    189     psMetadataAddBool(definewarpwarpArgs, PS_LIST_TAIL, "-available", 0, "define new run even if warpRun has some faults", false);
    190252    psMetadataAddBool(definewarpwarpArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    191253    psMetadataAddBool(definewarpwarpArgs, PS_LIST_TAIL, "-pretend", 0, "list results but to not queue", false);
    … …  
    220282    psMetadataAddStr(definewarpwarpArgs,  PS_LIST_TAIL, "-comment",            0, "search by comment field (LIKE comparison)", NULL);
    221283
     284    // -definestackstack
     285    psMetadata *definestackstackArgs = psMetadataAlloc();
     286    // stack id and exp id searches seem less useful here
     287    psMetadataAddStr(definestackstackArgs, PS_LIST_TAIL, "-skycell_id", 0, "search by skycell ID", NULL);
     288    psMetadataAddStr(definestackstackArgs, PS_LIST_TAIL, "-tess_id", 0, "search by tess ID", NULL);
     289    psMetadataAddStr(definestackstackArgs, PS_LIST_TAIL, "-filter", 0, "search by filter", NULL);
     290    psMetadataAddStr(definestackstackArgs, PS_LIST_TAIL, "-input_label", 0, "search by stack label for input", NULL);
     291    psMetadataAddStr(definestackstackArgs, PS_LIST_TAIL, "-template_label", 0, "search by stack label for template", NULL);
     292    psMetadataAddF32(definestackstackArgs, PS_LIST_TAIL, "-good_frac", 0, "minimum good fraction of skycell", NAN);
     293    psMetadataAddStr(definestackstackArgs, PS_LIST_TAIL, "-set_workdir", 0, "define workdir (required)", NULL);
     294    psMetadataAddStr(definestackstackArgs, PS_LIST_TAIL, "-set_label", 0, "define label", NULL);
     295    psMetadataAddStr(definestackstackArgs, PS_LIST_TAIL, "-set_reduction", 0, "define reduction class", NULL);
     296    psMetadataAddTime(definestackstackArgs, PS_LIST_TAIL, "-set_registered", 0, "time detrend run was registered", now);
     297    psMetadataAddStr(definestackstackArgs, PS_LIST_TAIL, "-set_data_group", 0, "define data group", NULL);
     298    psMetadataAddStr(definestackstackArgs, PS_LIST_TAIL, "-set_dist_group", 0, "define dist group", NULL);
     299    psMetadataAddStr(definestackstackArgs, PS_LIST_TAIL, "-set_note", 0, "define note", NULL);
     300    psMetadataAddBool(definestackstackArgs, PS_LIST_TAIL, "-rerun", 0, "define new run even if one exists", false);
     301    psMetadataAddBool(definestackstackArgs, PS_LIST_TAIL, "-available", 0, "define new run even if no stacks available for some skycells", false);
     302    psMetadataAddBool(definestackstackArgs, PS_LIST_TAIL, "-new-templates", 0, "also search for diffs with new template", false);
     303    psMetadataAddBool(definestackstackArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     304    psMetadataAddBool(definestackstackArgs, PS_LIST_TAIL, "-pretend", 0, "list results but do not queue", false);
     305
     306
    222307    // -pendingcleanuprun
    223308    psMetadata *pendingcleanuprunArgs = psMetadataAlloc();
    224     psMetadataAddStr(pendingcleanuprunArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "list blocks for specified label", NULL);
     309    psMetadataAddStr(pendingcleanuprunArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "list runs for cleanup with specified label", NULL);
    225310    psMetadataAddBool(pendingcleanuprunArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    226311    psMetadataAddU64(pendingcleanuprunArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    … …  
    241326    psMetadata *updatediffskyfileArgs = psMetadataAlloc();
    242327    psMetadataAddS64(updatediffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,      "define diff ID (required)", 0);
    243     psMetadataAddS16(updatediffskyfileArgs, PS_LIST_TAIL, "-fault", 0,         "set fault code (required)", 0);
     328    psMetadataAddS16(updatediffskyfileArgs, PS_LIST_TAIL, "-fault", 0,        "set fault code (required)", 0);
     329    psMetadataAddStr(updatediffskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0,   "search by skycell ID", NULL);
     330
     331    // -tocleanedskyfile
     332    psMetadata *tocleanedskyfileArgs = psMetadataAlloc();
     333    psMetadataAddS64(tocleanedskyfileArgs, PS_LIST_TAIL, "-diff_id", 0, "difftool ID to update", 0);
     334    psMetadataAddStr(tocleanedskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0, "skycell ID to update", NULL);
     335
     336    // -topurgedskyfile
     337    psMetadata *topurgedskyfileArgs = psMetadataAlloc();
     338    psMetadataAddS64(topurgedskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,    "difftool ID to update", 0);
     339    psMetadataAddStr(topurgedskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0, "skycell ID to update", NULL);
     340
     341    // -toscrubbedskyfile
     342    psMetadata *toscrubbedskyfileArgs = psMetadataAlloc();
     343    psMetadataAddS64(toscrubbedskyfileArgs, PS_LIST_TAIL, "-diff_id", 0, "difftool ID to update", 0);
     344    psMetadataAddStr(toscrubbedskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0, "skycell ID to update", NULL);
     345
     346    // -tofullskyfile
     347    psMetadata *tofullskyfileArgs = psMetadataAlloc();
     348    psMetadataAddS64(tofullskyfileArgs, PS_LIST_TAIL, "-diff_id", 0, "difftool ID to update", 0);
     349    psMetadataAddStr(tofullskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0, "skycell ID to update", NULL);
     350    psMetadataAddS64(tofullskyfileArgs, PS_LIST_TAIL, "-magicked",  0, "define magicked state", 0);
     351
     352    // -setskyfiletoupdate
     353    psMetadata *setskyfiletoupdateArgs = psMetadataAlloc();
     354    psMetadataAddS64(setskyfiletoupdateArgs, PS_LIST_TAIL, "-diff_id", 0,           "search by difftool ID (required)", 0);
     355    psMetadataAddStr(setskyfiletoupdateArgs, PS_LIST_TAIL, "-skycell_id",  0,       "search by tessellation ID", NULL);
     356    psMetadataAddStr(setskyfiletoupdateArgs, PS_LIST_TAIL, "-set_label",  0,        "new value for diffRun.label", NULL);
     357
     358
    244359
    245360    // -exportrun
    … …  
    267382    PXOPT_ADD_MODE("-todiffskyfile",    "", DIFFTOOL_MODE_TODIFFSKYFILE,     todiffskyfileArgs);
    268383    PXOPT_ADD_MODE("-adddiffskyfile",   "", DIFFTOOL_MODE_ADDDIFFSKYFILE,    adddiffskyfileArgs);
     384    PXOPT_ADD_MODE("-advance",          "", DIFFTOOL_MODE_ADVANCE,           advanceArgs);
    269385    PXOPT_ADD_MODE("-diffskyfile",      "", DIFFTOOL_MODE_DIFFSKYFILE,       diffskyfileArgs);
     386    PXOPT_ADD_MODE("-listrun",          "", DIFFTOOL_MODE_LISTRUN,           listrunArgs);
    270387    PXOPT_ADD_MODE("-revertdiffskyfile","", DIFFTOOL_MODE_REVERTDIFFSKYFILE, revertdiffskyfileArgs);
    271388    PXOPT_ADD_MODE("-definepoprun",     "", DIFFTOOL_MODE_DEFINEPOPRUN,      definepoprunArgs);
    272389    PXOPT_ADD_MODE("-definewarpstack",  "", DIFFTOOL_MODE_DEFINEWARPSTACK,   definewarpstackArgs);
    273390    PXOPT_ADD_MODE("-definewarpwarp",   "", DIFFTOOL_MODE_DEFINEWARPWARP,    definewarpwarpArgs);
     391    PXOPT_ADD_MODE("-definestackstack", "", DIFFTOOL_MODE_DEFINESTACKSTACK,  definestackstackArgs);
    274392    PXOPT_ADD_MODE("-pendingcleanuprun",     "show runs that need to be cleaned up", DIFFTOOL_MODE_PENDINGCLEANUPRUN,    pendingcleanuprunArgs);
    275393    PXOPT_ADD_MODE("-pendingcleanupskyfile", "show runs that need to be cleaned up", DIFFTOOL_MODE_PENDINGCLEANUPSKYFILE, pendingcleanupskyfileArgs);
    276394    PXOPT_ADD_MODE("-donecleanup",           "show runs that have been cleaned",     DIFFTOOL_MODE_DONECLEANUP,          donecleanupArgs);
    277395    PXOPT_ADD_MODE("-updatediffskyfile",     "update fault code for a diffskyfile",  DIFFTOOL_MODE_UPDATEDIFFSKYFILE,          updatediffskyfileArgs);
     396    PXOPT_ADD_MODE("-setskyfiletoupdate", "set cleaned skyfile to be updated", DIFFTOOL_MODE_SETSKYFILETOUPDATE, setskyfiletoupdateArgs);
     397
    278398    PXOPT_ADD_MODE("-exportrun",            "export run for import on other database", DIFFTOOL_MODE_EXPORTRUN, exportrunArgs);
    279399    PXOPT_ADD_MODE("-importrun",            "import run from metadata file",           DIFFTOOL_MODE_IMPORTRUN, importrunArgs);
     400
     401    PXOPT_ADD_MODE("-tocleanedskyfile", "set skyfile as cleaned", DIFFTOOL_MODE_TOCLEANEDSKYFILE, tocleanedskyfileArgs);
     402    PXOPT_ADD_MODE("-topurgedskyfile", "set skyfile as purged", DIFFTOOL_MODE_TOPURGEDSKYFILE, topurgedskyfileArgs);
     403    PXOPT_ADD_MODE("-toscrubbedskyfile", "set skyfile as scrubbed", DIFFTOOL_MODE_TOSCRUBBEDSKYFILE, toscrubbedskyfileArgs);
     404    PXOPT_ADD_MODE("-tofullskyfile", "set skyfile as full", DIFFTOOL_MODE_TOFULLSKYFILE, tofullskyfileArgs);
    280405
    281406    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • branches/simtest_nebulous_branches/ippTools/src/disttool.c

    r25031 r27840  
    22 * disttool.c
    33 *
    4  * Copyright (C) 2008
     4 * Copyright (C) 2008-2009
    55 *
    66 * This program is free software; you can redistribute it and/or modify it
    … …  
    3232
    3333static bool definebyqueryMode(pxConfig *config);
    34 static bool definerunMode(pxConfig *config);
    3534static bool updaterunMode(pxConfig *config);
    3635static bool revertrunMode(pxConfig *config);
    3736static bool pendingcomponentMode(pxConfig *config);
    3837static bool addprocessedcomponentMode(pxConfig *config);
     38static bool revertcomponentMode(pxConfig *config);
    3939static bool processedcomponentMode(pxConfig *config);
    4040static bool toadvanceMode(pxConfig *config);
    … …  
    4242static bool addfilesetMode(pxConfig *config);
    4343static bool revertfilesetMode(pxConfig *config);
     44static bool updatefilesetMode(pxConfig *config);
    4445static bool queuercrunMode(pxConfig *config);
    4546static bool updatercrunMode(pxConfig *config);
    4647static bool revertrcrunMode(pxConfig *config);
    4748static bool pendingdestMode(pxConfig *config);
     49static bool pendingcleanupMode(pxConfig *config);
     50static bool listfilesetsMode(pxConfig *config);
    4851
    4952static bool definetargetMode(pxConfig *config);
    5053static bool updatetargetMode(pxConfig *config);
    51 static bool listtargetMode(pxConfig *config);
    52 
    53 static bool definedsproductMode(pxConfig *config);
    54 static bool updatedsproductMode(pxConfig *config);
     54static bool listtargetsMode(pxConfig *config);
    5555
    5656static bool definedestinationMode(pxConfig *config);
    … …  
    5959static bool defineinterestMode(pxConfig *config);
    6060static bool updateinterestMode(pxConfig *config);
     61static bool listinterestsMode(pxConfig *config);
    6162
    6263# define MODECASE(caseName, func) \
    … …  
    8081    switch (config->mode) {
    8182        MODECASE(DISTTOOL_MODE_DEFINEBYQUERY, definebyqueryMode);
    82         MODECASE(DISTTOOL_MODE_DEFINERUN, definerunMode);
    8383        MODECASE(DISTTOOL_MODE_UPDATERUN, updaterunMode);
    8484        MODECASE(DISTTOOL_MODE_REVERTRUN, revertrunMode);
    … …  
    8686        MODECASE(DISTTOOL_MODE_ADDPROCESSEDCOMPONENT, addprocessedcomponentMode);
    8787        MODECASE(DISTTOOL_MODE_PROCESSEDCOMPONENT, processedcomponentMode);
     88        MODECASE(DISTTOOL_MODE_REVERTCOMPONENT, revertcomponentMode);
    8889        MODECASE(DISTTOOL_MODE_TOADVANCE, toadvanceMode);
    8990        MODECASE(DISTTOOL_MODE_PENDINGFILESET, pendingfilesetMode);
     91        MODECASE(DISTTOOL_MODE_PENDINGCLEANUP, pendingcleanupMode);
    9092        MODECASE(DISTTOOL_MODE_ADDFILESET, addfilesetMode);
    9193        MODECASE(DISTTOOL_MODE_REVERTFILESET, revertfilesetMode);
     94        MODECASE(DISTTOOL_MODE_LISTFILESETS, listfilesetsMode);
     95        MODECASE(DISTTOOL_MODE_UPDATEFILESET, updatefilesetMode);
    9296        MODECASE(DISTTOOL_MODE_QUEUERCRUN, queuercrunMode);
    9397        MODECASE(DISTTOOL_MODE_UPDATERCRUN, updatercrunMode);
    … …  
    96100        MODECASE(DISTTOOL_MODE_DEFINETARGET, definetargetMode);
    97101        MODECASE(DISTTOOL_MODE_UPDATETARGET, updatetargetMode);
    98         MODECASE(DISTTOOL_MODE_LISTTARGET, listtargetMode);
    99         MODECASE(DISTTOOL_MODE_DEFINEDSPRODUCT, definedsproductMode);
    100         MODECASE(DISTTOOL_MODE_UPDATEDSPRODUCT, updatedsproductMode);
     102        MODECASE(DISTTOOL_MODE_LISTTARGETS, listtargetsMode);
    101103        MODECASE(DISTTOOL_MODE_DEFINEDESTINATION, definedestinationMode);
    102104        MODECASE(DISTTOOL_MODE_UPDATEDESTINATION, updatedestinationMode);
    103105        MODECASE(DISTTOOL_MODE_DEFINEINTEREST, defineinterestMode);
    104106        MODECASE(DISTTOOL_MODE_UPDATEINTEREST, updateinterestMode);
     107        MODECASE(DISTTOOL_MODE_LISTINTERESTS, listinterestsMode);
    105108        default:
    106109            psAbort("invalid option (this should not happen)");
    … …  
    124127}
    125128
    126 static bool definerunMode(pxConfig *config)
    127 {
    128     PS_ASSERT_PTR_NON_NULL(config, false);
    129 
    130     // required
    131     PXOPT_LOOKUP_STR(stage, config->args, "-stage", true, false);
    132     PXOPT_LOOKUP_S64(stage_id, config->args, "-stage_id",  true, false);
    133     PXOPT_LOOKUP_STR(outroot, config->args, "-outroot", true, false);
    134     PXOPT_LOOKUP_S64(target_id, config->args, "-target_id",  true, false);
    135 
    136     // optional
    137     PXOPT_LOOKUP_BOOL(clean, config->args, "-clean", false);
    138     PXOPT_LOOKUP_BOOL(no_magic, config->args, "-no_magic", false);
    139     PXOPT_LOOKUP_STR(set_label, config->args, "-set_label", false, false);
    140 
    141     // TODO: check that stage has an expected value
    142     // XXX: all of the following concerns will be managed properly by definebyquery
    143 
    144     // TODO: should we check that stage_id actually exists for stage
    145     // in magicdstool we queue off of a magic_id so the stage_id, exp_id, and cam_id get looked up
    146     // when the run is queued
    147 
    148     if (!distRunInsert(config->dbh,
    149             0,          // dist_id
    150             target_id,
    151             stage,
    152             stage_id,
    153             set_label,
    154             outroot,
    155             clean,
    156             no_magic,
    157             "new",
    158             NULL,       // time_stamp
    159             0           // fault
    160             )) {
    161         psError(PS_ERR_UNKNOWN, false, "database error");
    162         return false;
    163     }
    164 
    165     return true;
    166 }
    167129
    168130static bool definebyqueryMode(pxConfig *config)
    … …  
    175137
    176138    // optional
    177     PXOPT_LOOKUP_S64(magic_ds_id, config->args, "-magic_ds_id",  false, false);
     139    PXOPT_LOOKUP_BOOL(use_alternate, config->args, "-use_alternate", false);
    178140    PXOPT_LOOKUP_BOOL(no_magic, config->args, "-no_magic", false);
    179141    PXOPT_LOOKUP_STR(set_label, config->args, "-set_label", false, false);
     142    PXOPT_LOOKUP_STR(set_data_group, config->args, "-set_data_group", false, false);
     143    PXOPT_LOOKUP_STR(set_note, config->args, "-set_note", false, false);
     144
    180145    PXOPT_LOOKUP_S64(limit, config->args, "-limit", false, false);
    181146    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    182    
    183     PXOPT_LOOKUP_BOOL(dry_run, config->args, "-dry_run", false);
     147
     148    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
     149
     150    if (use_alternate) {
     151        if (strcmp(stage, "raw")) {
     152            psError(PXTOOLS_ERR_SYS, true, "alternate inputs only supported for raw stage");
     153            return false;
     154        }
     155        if (no_magic) {
     156            psError(PXTOOLS_ERR_SYS, true, "no_magic forbidden with alternate inputs");
     157            return false;
     158        }
     159    }
    184160
    185161    // select arguments
    … …  
    191167
    192168    PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
     169    PXOPT_LOOKUP_STR(dist_group, config->args, "-dist_group", false, false);
    193170
    194171    psString query = NULL;
    … …  
    196173    psString runJoinStr = NULL;
    197174    if (!strcmp(stage, "raw")) {
    198         magicRunType = "rawExp";
    199         runJoinStr = "rawExp.exp_id";
     175        if (! use_alternate ) {
     176            magicRunType = "rawExp";
     177            runJoinStr = "rawExp.exp_id";
     178        } else {
     179            magicRunType = "camRun";
     180            runJoinStr = "camRun.exp_id";
     181        }
    200182        query = pxDataGet("disttool_definebyquery_raw.sql");
    201183        if (!query) {
    202             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     184            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    203185            psFree(where);
    204186            return false;
    205187        }
    206188
    207         // for raw stage we select by chipRun.label because raw labels typically aren't set
     189        // for raw stage we select by camRun.label and dist_group because rawExp doesn't have those columns
    208190        if (label) {
    209             psStringAppend(&query, " AND (chipRun.label = '%s')", label);
     191            psStringAppend(&query, " AND (magicDSRun.label = '%s')", label);
     192        }
     193        if (dist_group) {
     194            psStringAppend(&query, " AND (camRun.dist_group = '%s')", dist_group);
    210195        }
    211196    } else if (!strcmp(stage, "chip")) {
    … …  
    214199        query = pxDataGet("disttool_definebyquery_chip.sql");
    215200        if (!query) {
    216             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     201            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    217202            psFree(where);
    218203            return false;
    … …  
    222207            psStringAppend(&query, " AND (chipRun.label = '%s')", label);
    223208        }
     209        if (dist_group) {
     210            psStringAppend(&query, " AND (chipRun.dist_group = '%s')", dist_group);
     211        }
    224212    } else if (!strcmp(stage, "camera")) {
    225         magicRunType = "chipRun";    // This is used below to set the magicked business
     213        magicRunType = "camRun";    // This is used below to set the magicked business
     214        runJoinStr = "camRun.cam_id";
    226215        query = pxDataGet("disttool_definebyquery_camera.sql");
    227216        if (!query) {
    228             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     217            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    229218            psFree(where);
    230219            return false;
    … …  
    233222        if (label) {
    234223            psStringAppend(&query, " AND (camRun.label = '%s')", label);
     224        }
     225        if (dist_group) {
     226            psStringAppend(&query, " AND (camRun.dist_group = '%s')", dist_group);
    235227        }
    236228    } else if (!strcmp(stage, "fake")) {
    … …  
    238230        query = pxDataGet("disttool_definebyquery_fake.sql");
    239231        if (!query) {
    240             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     232            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    241233            psFree(where);
    242234            return false;
    … …  
    245237        if (label) {
    246238            psStringAppend(&query, " AND (fakeRun.label = '%s')", label);
     239        }
     240        if (dist_group) {
     241            psStringAppend(&query, " AND (fakeRun.dist_group = '%s')", dist_group);
    247242        }
    248243        // fake stage doesn't require magic
    … …  
    253248        query = pxDataGet("disttool_definebyquery_warp.sql");
    254249        if (!query) {
    255             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     250            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    256251            psFree(where);
    257252            return false;
    … …  
    260255        if (label) {
    261256            psStringAppend(&query, " AND (warpRun.label = '%s')", label);
     257        }
     258        if (dist_group) {
     259            psStringAppend(&query, " AND (warpRun.dist_group = '%s')", dist_group);
    262260        }
    263261
    … …  
    267265        query = pxDataGet("disttool_definebyquery_diff.sql");
    268266        if (!query) {
    269             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     267            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    270268            psFree(where);
    271269            return false;
    … …  
    274272        if (label) {
    275273            psStringAppend(&query, " AND (diffRun.label = '%s')", label);
     274        }
     275        if (dist_group) {
     276            psStringAppend(&query, " AND (diffRun.dist_group = '%s')", dist_group);
    276277        }
    277278
    … …  
    280281        query = pxDataGet("disttool_definebyquery_stack.sql");
    281282        if (!query) {
    282             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     283            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    283284            psFree(where);
    284285            return false;
    … …  
    288289            psStringAppend(&query, " AND (stackRun.label = '%s')", label);
    289290        }
    290         // stack stage doesn't require magic (perhaps let the script do this?
     291        if (dist_group) {
     292            psStringAppend(&query, " AND (stackRun.dist_group = '%s')", dist_group);
     293        }
     294        // stack stage doesn't require magic
    291295        no_magic = true;
     296    } else if (!strcmp(stage, "SSdiff")) {
     297      magicRunType = "diffRun";
     298      runJoinStr = "diffRun.diff_id";
     299      query = pxDataGet("disttool_definebyquery_SSdiff.sql");
     300      if (!query) {
     301        psError(PXTOOLS_ERR_SYS, false, "failed to retrieve SQL statement");
     302        psFree(where);
     303        return(false);
     304      }
     305
     306      if (label) {
     307        psStringAppend(&query, " AND (diffRun.label = '%s') ", label);
     308      }
     309      if (dist_group) {
     310        psStringAppend(&query, " AND (diffRun.dist_group = '%s') ", dist_group);
     311      }
     312
     313      no_magic = true;   
    292314    } else {
    293315        psError(PS_ERR_UNKNOWN, true, "unknown value for stage: %s", stage);
    294316        psFree(where);
    295317        return false;
     318    }
     319
     320    if (!strcmp(stage, "raw")) {
     321        if (!no_magic) {
     322            psStringAppend(&query, " AND (magicDSRun.re_place = %d)", !use_alternate);
     323            psStringAppend(&query, " AND (camRun.state = 'full')");
     324        }
    296325    }
    297326
    … …  
    306335
    307336    if (!no_magic) {
    308         psStringAppend(&query, " AND (distTarget.clean OR %s.magicked)", magicRunType);
    309 
    310         // is selecting by magic_ds_id really interesting?
    311         if (magic_ds_id) {
    312             if (strcmp(stage, "camera")) {
    313                 // stage other than camera
    314                 if (!runJoinStr) {
    315                     psError(PS_ERR_PROGRAMMING, true, "cannot select by magic_ds_id for stage: %s", stage);
    316                     psFree(query);
    317                     return false;
    318                 }
    319                 psStringAppend(&joinHook, "\nJOIN magicDSRun ON magicDSRun.stage = distTarget.stage"
    320                                               " AND magicDSRun.stage_id = %s", runJoinStr);
    321             } else {
    322                 // camera masks are magicked when the chipRun is magicked
    323                 // XXX: This is confusing. Is it dangerous?
    324                 // Maybe I should add a magicked bit to camRun. Note this isn't
    325                 psStringAppend(&joinHook, "\nJOIN magicDSRun ON magicDSRun.stage = 'chip'"
    326                                               " AND magicDSRun.stage_id = chipRun.chip_id");
    327             }
    328             psStringAppend(&query, " AND (magicDSRun.state = 'full' AND magicDSRun.re_place AND (magic_ds_id = %" PRId64 "))", magic_ds_id);
    329         }
     337        psStringAppend(&query, " AND (%s.magicked > 0)", magicRunType);
    330338    }
    331339
    … …  
    335343        psFree(limitString);
    336344    }
    337 
     345    psTrace("disttool",2,query,joinHook ? joinHook : "");
    338346    if (!p_psDBRunQueryF(config->dbh, query, joinHook ? joinHook : "")) {
    339         psError(PS_ERR_UNKNOWN, false, "database error");
    340         psFree(query);
    341         return false;
     347      psError(PS_ERR_UNKNOWN, false, "database error");
     348      psFree(query);
     349      return false;
    342350    }
    343351    psFree(query);
    … …  
    356364
    357365
    358     if (dry_run) {
     366    if (pretend) {
    359367        if (!ippdbPrintMetadatas(stdout, output, "newdistRuns", true)) {
    360368            psError(PS_ERR_UNKNOWN, false, "failed to print array");
    … …  
    377385        psString run_tag = psMetadataLookupStr(NULL, md, "run_tag");
    378386        psS64 stage_id = psMetadataLookupS64(NULL, md, "stage_id");
     387        psS64 magic_ds_id = psMetadataLookupS64(NULL, md, "magicked");
    379388        psS64 target_id = psMetadataLookupS64(NULL, md, "target_id");
    380         psString target_label = psMetadataLookupStr(NULL, md, "label");
     389        psString stage_label = psMetadataLookupStr(NULL, md, "label");
     390        psString stage_data_group = psMetadataLookupStr(NULL, md, "data_group");
    381391        bool clean = psMetadataLookupBool(NULL, md, "clean");
    382392
    383393        psString outroot = NULL;
    384         psStringAppend(&outroot, "%s/%s/%s", workdir, run_tag, stage); 
     394        psStringAppend(&outroot, "%s/%s/%s", workdir, run_tag, stage);
    385395
    386396        psString new_label;
    … …  
    388398            new_label = set_label;
    389399        } else {
    390             new_label = target_label;
    391         }
     400            new_label = stage_label;
     401        }
     402        psString new_data_group;
     403        if (set_data_group != NULL) {
     404            new_data_group = set_data_group;
     405        } else {
     406            new_data_group = stage_data_group;
     407        }
     408
    392409        distRunRow *row = distRunRowAlloc(
    393410                0,      // dist_id
    … …  
    395412                stage,
    396413                stage_id,
     414                magic_ds_id,
    397415                new_label,
    398416                outroot,
     417                NULL,     // outdir
    399418                clean,
    400419                no_magic,
     420                use_alternate,
    401421                "new",
    402                 NULL,   // time_stamp
    403                 0       // fault
     422                NULL,    // time_stamp
     423                0,       // fault
     424                new_data_group,
     425                set_note // note does not propagate
    404426                );
    405427
    … …  
    444466    PXOPT_COPY_S64(config->args, where, "-dist_id", "dist_id", "==");
    445467    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");;
    446     PXOPT_COPY_STR(config->args, where, "-state", "state", "==");
     468    PXOPT_COPY_STR(config->args, where, "-state", "distRun.state", "==");
    447469    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     470    PXOPT_COPY_STR(config->args, where, "-data_group", "distRun.data_group", "LIKE");
     471    PXOPT_COPY_STR(config->args, where, "-dist_group", "distTarget.dist_group", "==");
     472    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
    448473
    449474    if (!psListLength(where->list)) {
    450475        psFree(where);
    451         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     476        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    452477        return false;
    453478    }
    … …  
    455480    PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
    456481    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
     482    PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
     483    PXOPT_LOOKUP_STR(outdir, config->args, "-set_outdir", false, false);
    457484    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
    458 
    459     if ((!state) && (!label) && (!fault)) {
    460         psError(PXTOOLS_ERR_DATA, false, "parameters (-fault or -set_state or -set_label) are required");
    461         psFree(where);
    462         return false;
    463     }
    464 
    465     psString query = psStringCopy("UPDATE distRun SET time_stamp = UTC_TIMESTAMP()");
    466 
     485    PXOPT_LOOKUP_STR(set_note, config->args, "-set_note", false, false);
     486
     487    if ((!state) && (!label) && (!fault) &&(!data_group)) {
     488        psError(PXTOOLS_ERR_CONFIG, false, "parameters (-fault or -set_state or -set_label -set_data_group) are required");
     489        psFree(where);
     490        return false;
     491    }
     492
     493    psString query = psStringCopy("UPDATE distRun join distTarget using(target_id, stage) SET distRun.time_stamp = UTC_TIMESTAMP()");
     494
     495    if (outdir) {
     496        psStringAppend(&query, " , distRun.outdir = '%s'", outdir);
     497    }
    467498    if (state) {
    468         psStringAppend(&query, " , state = '%s'", state);
     499        psStringAppend(&query, " , distRun.state = '%s'", state);
    469500    }
    470501
    471502    if (label) {
    472         psStringAppend(&query, " , label = '%s'", label);
     503        psStringAppend(&query, " , distRun.label = '%s'", label);
    473504    }
    474505
    475506    if (fault) {
    476         psStringAppend(&query, " , fault = %d", fault);
    477     }
     507        psStringAppend(&query, " , distRun.fault = %d", fault);
     508    }
     509
     510    if (data_group) {
     511        psStringAppend(&query, " , distRun.data_group = '%s'", data_group);
     512    }
     513
     514    if (set_note) {
     515        psStringAppend(&query, " , distRun.note = '%s'", set_note);
     516    }
     517
    478518
    479519    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    … …  
    500540    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
    501541
    502     // we need to disambiguate fault so make a copy of the where list before adding fault
    503     psMetadata *whereComponent = psMetadataCopy(NULL, where);
    504542    PXOPT_COPY_S16(config->args, where,  "-fault", "distRun.fault", "==");
    505     PXOPT_COPY_S16(config->args, whereComponent, "-fault", "distComponent.fault", "==");
    506543
    507544    // It might be useful to be able to query by the parameters of the underlying runs
    … …  
    509546    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    510547        psFree(where);
    511         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
    512         return false;
    513     }
    514 
    515     if (!psDBTransaction(config->dbh)) {
    516         psError(PS_ERR_UNKNOWN, false, "database error");
    517         psFree(where);
    518         return false;
    519     }
    520 
    521     // Update state to 'new'
    522     int numUpdated;                     // Number updated
    523     {
    524         psString query = pxDataGet("disttool_revertrun_update.sql");
    525         if (!query) {
    526             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    527             if (!psDBRollback(config->dbh)) {
    528                 psError(PS_ERR_UNKNOWN, false, "database error");
    529             }
    530             return false;
    531         }
    532 
    533         if (psListLength(where->list)) {
    534             psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    535             psStringAppend(&query, " AND %s", whereClause);
    536             psFree(whereClause);
    537         }
    538 
    539         if (!p_psDBRunQuery(config->dbh, query)) {
     548        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     549        return false;
     550    }
     551
     552    psString query = pxDataGet("disttool_revertrun.sql");
     553    if (!query) {
     554        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     555        if (!psDBRollback(config->dbh)) {
    540556            psError(PS_ERR_UNKNOWN, false, "database error");
    541             psFree(query);
    542             if (!psDBRollback(config->dbh)) {
    543                 psError(PS_ERR_UNKNOWN, false, "database error");
    544             }
    545             return false;
    546         }
    547         psFree(query);
    548 
    549         numUpdated = psDBAffectedRows(config->dbh);
    550     }
     557        }
     558        return false;
     559    }
     560
     561    if (psListLength(where->list)) {
     562        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     563        psStringAppend(&query, " AND %s", whereClause);
     564        psFree(whereClause);
     565    }
     566    psFree(where);
     567
     568    if (!p_psDBRunQuery(config->dbh, query)) {
     569        psError(PS_ERR_UNKNOWN, false, "database error");
     570        psFree(query);
     571        return false;
     572    }
     573
     574    int numUpdated = psDBAffectedRows(config->dbh);
    551575
    552576    psLogMsg("disttool", PS_LOG_INFO, "Updated %d dist runs", numUpdated);
    553577
    554     // Delete product
    555     int numDeleted;                     // Number deleted
    556     {
    557         psString query = pxDataGet("disttool_revertrun_delete.sql");
    558         if (!query) {
    559             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    560             if (!psDBRollback(config->dbh)) {
    561                 psError(PS_ERR_UNKNOWN, false, "database error");
    562             }
    563             return false;
    564         }
    565 
    566         if (psListLength(whereComponent->list)) {
    567             psString whereClause = psDBGenerateWhereConditionSQL(whereComponent, NULL);
    568             psStringAppend(&query, " AND %s", whereClause);
    569             psFree(whereClause);
    570         }
    571 
    572         if (!p_psDBRunQuery(config->dbh, query)) {
    573             psError(PS_ERR_UNKNOWN, false, "database error");
    574             psFree(query);
    575             if (!psDBRollback(config->dbh)) {
    576                 psError(PS_ERR_UNKNOWN, false, "database error");
    577             }
    578             return false;
    579         }
    580         psFree(query);
    581 
    582         numDeleted = psDBAffectedRows(config->dbh);
    583     }
     578    return true;
     579}
     580
     581static bool revertcomponentMode(pxConfig *config)
     582{
     583    psMetadata *where = psMetadataAlloc();
     584    PXOPT_COPY_S64(config->args, where, "-dist_id", "distRun.dist_id", "==");
     585    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");;
     586    PXOPT_COPY_STR(config->args, where, "-component", "component", "==");;
     587    PXOPT_COPY_S64(config->args, where, "-stage_id", "stage_id", "==");
     588    PXOPT_COPY_STR(config->args, where, "-state", "state", "==");
     589    pxAddLabelSearchArgs(config, where, "-label", "distRun.label", "==");
     590
     591    PXOPT_COPY_S16(config->args, where,  "-fault", "distComponent.fault", "==");
     592
     593    // It might be useful to be able to query by the parameters of the underlying runs
     594
     595    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
     596        psFree(where);
     597        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     598        return false;
     599    }
     600
     601    psString query = pxDataGet("disttool_revertcomponent.sql");
     602    if (!query) {
     603        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     604        psFree(where);
     605        return false;
     606    }
     607
     608    if (psListLength(where->list)) {
     609        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     610        psStringAppend(&query, " AND %s", whereClause);
     611        psFree(whereClause);
     612    }
     613    psFree(where);
     614
     615    if (!p_psDBRunQuery(config->dbh, query)) {
     616        psError(PS_ERR_UNKNOWN, false, "database error");
     617        psFree(query);
     618        return false;
     619    }
     620
     621    int numDeleted = psDBAffectedRows(config->dbh);
    584622
    585623    psLogMsg("disttool", PS_LOG_INFO, "Deleted %d distComponents", numDeleted);
    586624
    587     psFree(where);
    588     psFree(whereComponent);
    589 
    590     if (!psDBCommit(config->dbh)) {
    591         psError(PS_ERR_UNKNOWN, false, "database error");
    592         return false;
    593     }
    594 
    595625    return true;
    596626}
    … …  
    600630    PS_ASSERT_PTR_NON_NULL(config, false);
    601631
    602     psMetadata *where = psMetadataAlloc();
    603     PXOPT_COPY_S64(config->args, where, "-dist_id", "dist_id", "==");
    604     PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
    605     pxAddLabelSearchArgs (config, where, "-label", "label", "==");
     632    PXOPT_LOOKUP_STR(stage, config->args, "-stage", true, false);
     633
     634    psMetadata *where = psMetadataAlloc();
     635    PXOPT_COPY_S64(config->args, where, "-dist_id", "distRun.dist_id", "==");
     636    pxAddLabelSearchArgs (config, where, "-label", "distRun.label", "==");
    606637
    607638    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    608639    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    609640
    610     // look for "inputs" that need to processed
    611     psString query = pxDataGet("disttool_pendingcomponent.sql");
     641    psString queryFile = NULL;
     642    psStringAppend(&queryFile, "disttool_pending_%s.sql", stage);
     643    psString query = pxDataGet(queryFile);
    612644    if (!query) {
    613         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     645        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement from %s", queryFile);
    614646        return false;
    615647    }
    … …  
    617649    if (psListLength(where->list)) {
    618650        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    619         psStringAppend(&query, " WHERE %s", whereClause);
     651        psStringAppend(&query, " AND %s", whereClause);
    620652        psFree(whereClause);
    621653    }
    … …  
    629661    }
    630662
    631     // the query has where hooks for each stage.
    632     // right now we aren't using them.
    633     // XXX: I think that I want to change the query from a union of selects on the various
    634     // stages to separate queries. As it is pending data at the later stages of the pipline
    635     // will get blocked by pending earlier stages
    636     psString    raw_where = "";
    637     psString    raw_clean_where = "";
    638     psString    chip_where = "";
    639     psString    camera_where = "";
    640     psString    fake_where = "";
    641     psString    warp_where = "";
    642     psString    diff_where = "";
    643     psString    stack_where = "";
    644 
    645     if (!p_psDBRunQueryF(config->dbh,
    646             query,
    647             raw_where,
    648             raw_clean_where,
    649             chip_where,
    650             camera_where,
    651             fake_where,
    652             warp_where,
    653             diff_where,
    654             stack_where)) {
     663    if (!p_psDBRunQuery(config->dbh, query)) {
    655664        psError(PS_ERR_UNKNOWN, false, "database error");
    656665        psFree(query);
    … …  
    708717    PXOPT_LOOKUP_S32(bytes, config->args, "-bytes", require_fileinfo, false);
    709718    PXOPT_LOOKUP_STR(md5sum, config->args, "-md5sum", require_fileinfo, false);
     719    PXOPT_LOOKUP_STR(outdir, config->args, "-outdir", require_fileinfo, false);
    710720    PXOPT_LOOKUP_STR(name, config->args, "-name", require_fileinfo, false);
    711721
    712     if (!distComponentInsert(config->dbh, dist_id, component, bytes, md5sum, "full", name, fault)) {
     722    if (!distComponentInsert(config->dbh, dist_id, component, bytes, md5sum, "full", outdir, name, fault)) {
    713723        psError(PS_ERR_UNKNOWN, false, "database error");
    714724        return false;
    … …  
    732742    psString query = pxDataGet("disttool_toadvance.sql");
    733743    if (!query) {
    734         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     744        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    735745        return false;
    736746    }
    … …  
    803813    psString query = pxDataGet("disttool_processedcomponent.sql");
    804814    if (!query) {
    805         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     815        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    806816        return false;
    807817    }
    … …  
    868878    psMetadata *where = psMetadataAlloc();
    869879    PXOPT_COPY_S64(config->args, where, "-dist_id", "dist_id", "==");
     880    PXOPT_COPY_STR(config->args, where, "-stage", "distRun.stage", "==");
    870881    pxAddLabelSearchArgs (config, where, "-label", "distRun.label", "==");
    871882
    … …  
    876887    psString query = pxDataGet("disttool_pendingfileset.sql");
    877888    if (!query) {
    878         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     889        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    879890        return false;
    880891    }
    … …  
    939950    // required values
    940951    PXOPT_LOOKUP_S64(dist_id, config->args, "-dist_id", true, false);
    941     PXOPT_LOOKUP_S64(prod_id, config->args, "-prod_id", true, false);
     952    PXOPT_LOOKUP_S64(dest_id, config->args, "-dest_id", true, false);
    942953
    943954    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
    … …  
    946957    PXOPT_LOOKUP_STR(name, config->args, "-name", fault == 0, false);
    947958
    948     if (!rcDSFilesetInsert(config->dbh, 
     959    if (!rcDSFilesetInsert(config->dbh,
    949960            0,          // fs_id
    950961            dist_id,
    951             prod_id,
     962            dest_id,
    952963            name,
    953964            "full",
    … …  
    959970    return true;
    960971}
     972
    961973static bool revertfilesetMode(pxConfig *config)
    962974{
    … …  
    964976    PXOPT_COPY_S64(config->args, where, "-fs_id", "fs_id", "==");
    965977    PXOPT_COPY_S64(config->args, where, "-dist_id", "rcDSFileset.dist_id", "==");
    966     PXOPT_COPY_S64(config->args, where, "-prod_id", "prod_id", "==");
     978    PXOPT_COPY_S64(config->args, where, "-dest_id", "dest_id", "==");
    967979    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");;
    968980    PXOPT_COPY_S64(config->args, where, "-stage_id", "stage_id", "==");
    … …  
    975987    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    976988        psFree(where);
    977         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     989        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    978990        return false;
    979991    }
    … …  
    981993    psString query = pxDataGet("disttool_revertfileset.sql");
    982994    if (!query) {
    983         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     995        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    984996        psFree(where);
    985997        return false;
    … …  
    10231035    psString query = pxDataGet("disttool_pendingdest.sql");
    10241036    if (!query) {
    1025         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1037        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10261038        return false;
    10271039    }
    … …  
    10921104    PXOPT_COPY_S64(config->args, where, "-dist_id",  "dist_id", "==");
    10931105    PXOPT_COPY_S64(config->args, where, "-dest_id",  "dest_id", "==");
    1094     PXOPT_COPY_S64(config->args, where, "-prod_id",  "prod_id", "==");
    10951106    PXOPT_COPY_S64(config->args, where, "-target_id","target_id", "==");
    10961107    PXOPT_COPY_S64(config->args, where, "-fs_id",    "fs_id", "==");
    … …  
    11031114    psString query = pxDataGet("disttool_queuercrun.sql");
    11041115    if (!query) {
    1105         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1116        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11061117        return false;
    11071118    }
    … …  
    11491160    // We either need rc_id or (dest_id and fs_name) to identifiy the rcRun
    11501161    if ((!rc_id) && !(dest_id && fs_name)) {
    1151         psError(PXTOOLS_ERR_DATA, true, "either -rc_id or (-fs_name and -dest_id) are required");
     1162        psError(PXTOOLS_ERR_CONFIG, true, "either -rc_id or (-fs_name and -dest_id) are required");
    11521163        return false;
    11531164    }
    … …  
    11611172        // this can't happen because we checked above
    11621173        psFree(where);
    1163         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     1174        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    11641175        return false;
    11651176    }
    … …  
    11711182
    11721183    if (!state && (fault < 0)) {
    1173         psError(PXTOOLS_ERR_DATA, false, "parameters (-fault or -set_state) are required");
     1184        psError(PXTOOLS_ERR_CONFIG, false, "parameters (-fault or -set_state) are required");
    11741185        psFree(where);
    11751186        return false;
    … …  
    11781189    psString query = pxDataGet("disttool_updatercrun.sql");
    11791190    if (!query) {
    1180         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1191        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11811192        return false;
    11821193    }
    … …  
    12351246    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    12361247        psFree(where);
    1237         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     1248        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    12381249        return false;
    12391250    }
    … …  
    12411252    psString query = pxDataGet("disttool_revertrcrun.sql");
    12421253    if (!query) {
    1243         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1254        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    12441255        if (!psDBRollback(config->dbh)) {
    12451256            psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    12761287
    12771288    // required
    1278     PXOPT_LOOKUP_STR(label, config->args, "-label", true, false);
     1289    PXOPT_LOOKUP_STR(dist_group, config->args, "-dist_group", true, false);
    12791290    PXOPT_LOOKUP_STR(filter, config->args, "-filter", true, false);
    12801291    PXOPT_LOOKUP_STR(stage, config->args, "-stage", true, false);
    … …  
    12871298    distTargetRow *row = distTargetRowAlloc(
    12881299            0,          // target_id
    1289             label,
     1300            dist_group,
    12901301            filter,
    12911302            stage,
    … …  
    12941305            comment
    12951306            );
    1296            
     1307
    12971308    if (!row) {
    12981309        psError(PS_ERR_UNKNOWN, false, "failed to allocate distTarget object");
    … …  
    13241335    psMetadata *where = psMetadataAlloc();
    13251336    PXOPT_COPY_S64(config->args, where, "-target_id", "target_id", "==");
    1326     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     1337    PXOPT_COPY_STR(config->args, where, "-dist_group", "dist_group", "==");
    13271338    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "==");
    13281339    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
    … …  
    13541365}
    13551366
    1356 static bool listtargetMode(pxConfig *config)
     1367static bool listtargetsMode(pxConfig *config)
    13571368{
    13581369    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    13601371    psMetadata *where = psMetadataAlloc();
    13611372    PXOPT_COPY_S64(config->args, where, "-target_id", "target_id", "==");
    1362     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     1373    PXOPT_COPY_STR(config->args, where, "-dist_group", "dist_group", "LIKE");
    13631374    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "==");
    13641375    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
    … …  
    14331444}
    14341445
    1435 static bool definedsproductMode(pxConfig *config)
     1446static bool definedestinationMode(pxConfig *config)
    14361447{
    14371448    PS_ASSERT_PTR_NON_NULL(config, false);
    14381449
    14391450    // required
    1440     PXOPT_LOOKUP_STR(name, config->args,   "-name", true, false);
    1441     PXOPT_LOOKUP_STR(dbname, config->args, "-ds_dbname", true, false);
    1442     PXOPT_LOOKUP_STR(dbhost, config->args, "-ds_dbhost", true, false);
     1451    PXOPT_LOOKUP_STR(name, config->args,         "-name", true, false);
     1452    PXOPT_LOOKUP_STR(dbname, config->args,       "-ds_dbname", true, false);
     1453    PXOPT_LOOKUP_STR(dbhost, config->args,       "-ds_dbhost", true, false);
     1454
     1455    // optional
     1456    PXOPT_LOOKUP_STR(status_uri, config->args,   "-status_uri", false, false);
     1457    PXOPT_LOOKUP_STR(comment, config->args,      "-comment", false, false);
     1458    PXOPT_LOOKUP_STR(last_fileset, config->args, "-last_fileset", false, false);
     1459    PXOPT_LOOKUP_STR(state, config->args,        "-set_state", false, false);
    14431460
    14441461    // XXX: should we insure that these names do not contatin any whitespace?
    14451462
    1446     rcDSProductRow *row = rcDSProductRowAlloc(
    1447             0,          // prod_id
     1463    rcDestinationRow *row = rcDestinationRowAlloc(
     1464            0,          // dest_id
    14481465            name,
     1466            status_uri,
     1467            comment,
     1468            last_fileset,
    14491469            dbname,
    1450             dbhost
     1470            dbhost,
     1471            state ? state : "enabled"
    14511472            );
    1452            
     1473
    14531474    if (!row) {
    1454         psError(PS_ERR_UNKNOWN, false, "failed to allocate rcDSProduct object");
    1455         return false;
    1456     }
    1457    if (!rcDSProductInsertObject(config->dbh, row)) {
     1475        psError(PS_ERR_UNKNOWN, false, "failed to allocate rcDestination object");
     1476        return false;
     1477    }
     1478   if (!rcDestinationInsertObject(config->dbh, row)) {
    14581479        psError(PS_ERR_UNKNOWN, false, "database error");
    14591480        psFree(row);
    … …  
    14621483
    14631484    // get the assigned target_id
    1464     row->prod_id = psDBLastInsertID(config->dbh);
    1465 
    1466     if (!rcDSProductPrintObject(stdout, row, true)) {
     1485    row->dest_id = psDBLastInsertID(config->dbh);
     1486
     1487    if (!rcDestinationPrintObject(stdout, row, true)) {
    14671488        psError(PS_ERR_UNKNOWN, false, "failed to print object");
    14681489        psFree(row);
    … …  
    14741495    return true;
    14751496}
    1476 static bool updatedsproductMode(pxConfig *config)
     1497
     1498static bool updatedestinationMode(pxConfig *config)
    14771499{
    14781500    PS_ASSERT_PTR_NON_NULL(config, false);
    14791501
    14801502    psMetadata *where = psMetadataAlloc();
    1481     PXOPT_COPY_S64(config->args, where, "-prod_id", "prod_id", "==");
    1482 
    1483     PXOPT_LOOKUP_STR(dbname, config->args, "-ds_dbname", false, false);
    1484     PXOPT_LOOKUP_STR(dbhost, config->args, "-ds_dbhost", false, false);
    1485 
    1486     if (!(dbname || dbhost)) {
    1487         psError(PS_ERR_UNKNOWN, true, "one or more of dbname or dbhost is required");
    1488         psFree(where);
    1489         return false;
    1490     }
    1491     psString query = psStringCopy("UPDATE rcDSProduct SET");
     1503    PXOPT_COPY_S64(config->args, where, "-dest_id", "dest_id", "==");
     1504
     1505    PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
     1506#ifdef ALLOW_UPDATE_LAST_FILESET
     1507    PXOPT_LOOKUP_STR(last_fileset, config->args, "-set_last_fileset", false, false);
     1508    if (!(state || last_fileset)) {
     1509        psError(PS_ERR_UNKNOWN, true, "one or more of -set_state or -set_last_fileset is required");
     1510# else
     1511    if (!state) {
     1512#endif
     1513        psFree(where);
     1514        return false;
     1515    }
     1516    psString query = psStringCopy("UPDATE rcDestination SET");
    14921517    psString sep = "";
    1493     if (dbname) {
    1494         psStringAppend(&query, " dbname = '%s'", dbname);
     1518    if (state) {
     1519        psStringAppend(&query, " state = '%s'", state);
    14951520        sep = ",";
    14961521    }
    1497     if (dbhost) {
    1498         psStringAppend(&query, " %s dbhost = '%s'", sep, dbhost);
    1499     }
     1522#ifdef ALLOW_UPDATE_LAST_FILESET
     1523    // last_fileset normally gets set by updatercrunMode
     1524    // Allowing it to be set here might cause problems
     1525    // especially since we are allowing selection by dest_id
     1526    if (last_fileset) {
     1527        psStringAppend(&query, " %s last_fileset = '%s'", sep, last_fileset);
     1528    }
     1529#endif
    15001530
    15011531    if (psListLength(where->list)) {
    … …  
    15211551}
    15221552
    1523 static bool definedestinationMode(pxConfig *config)
     1553static bool defineinterestMode(pxConfig *config)
    15241554{
    15251555    PS_ASSERT_PTR_NON_NULL(config, false);
    15261556
    1527     // required
    1528     PXOPT_LOOKUP_S64(prod_id, config->args,      "-prod_id", true, false);
    1529     PXOPT_LOOKUP_STR(name, config->args,         "-name", true, false);
     1557    // one of these is required
     1558    PXOPT_LOOKUP_S64(dest_id, config->args,      "-dest_id", false, false);
     1559    PXOPT_LOOKUP_STR(dest_name, config->args,    "-dest_name", false, false);
     1560    if (!dest_id && !dest_name) {
     1561        psError(PS_ERR_UNKNOWN, true, "either dest_id or dest_name is required");
     1562        return false;
     1563    }
     1564
     1565    // either target_id or stage and label are required
     1566    PXOPT_LOOKUP_S64(target_id, config->args,    "-target_id", false, false);
     1567    PXOPT_LOOKUP_STR(stage, config->args,        "-stage", false, false);
     1568    PXOPT_LOOKUP_STR(dist_group, config->args,   "-dist_group", false, false);
     1569    PXOPT_LOOKUP_STR(filter, config->args,       "-filter", false, false);
     1570    PXOPT_LOOKUP_BOOL(clean, config->args,       "-clean", false);
     1571
     1572    if (!target_id) {
     1573        bool error = false;
     1574        if (!stage) {
     1575            psError(PS_ERR_UNKNOWN, true, "stage is required if target_id is not supplied");
     1576            error = true;
     1577        }
     1578        if (!dist_group) {
     1579            psError(PS_ERR_UNKNOWN, !error, "dist_group is required if target_id is not supplied");
     1580            error = true;
     1581        }
     1582        if (error) {
     1583            return false;
     1584        }
     1585    }
    15301586
    15311587    // optional
    1532     PXOPT_LOOKUP_STR(status_uri, config->args,   "-status_uri", false, false);
    1533     PXOPT_LOOKUP_STR(comment, config->args,      "-comment", false, false);
    1534     PXOPT_LOOKUP_STR(last_fileset, config->args, "-last_fileset", false, false);
    1535     PXOPT_LOOKUP_STR(state, config->args,        "-set_state", false, false);
    1536 
    1537     // XXX: should we insure that these names do not contatin any whitespace?
    1538 
    1539     rcDestinationRow *row = rcDestinationRowAlloc(
    1540             0,          // dest_id
    1541             prod_id,
    1542             name,
    1543             status_uri,
    1544             comment,
    1545             last_fileset,
    1546             state ? state : "enabled"
    1547             );
    1548            
    1549     if (!row) {
    1550         psError(PS_ERR_UNKNOWN, false, "failed to allocate rcDestination object");
    1551         return false;
    1552     }
    1553    if (!rcDestinationInsertObject(config->dbh, row)) {
    1554         psError(PS_ERR_UNKNOWN, false, "database error");
    1555         psFree(row);
    1556         return false;
    1557     }
    1558 
    1559     // get the assigned target_id
    1560     row->dest_id = psDBLastInsertID(config->dbh);
    1561 
    1562     if (!rcDestinationPrintObject(stdout, row, true)) {
    1563         psError(PS_ERR_UNKNOWN, false, "failed to print object");
    1564         psFree(row);
    1565         return false;
    1566     }
    1567 
    1568     psFree(row);
    1569 
    1570     return true;
    1571 }
    1572 
    1573 static bool updatedestinationMode(pxConfig *config)
     1588    PXOPT_LOOKUP_S64(limit, config->args, "-limit", false, false);
     1589    PXOPT_LOOKUP_STR(state, config->args,  "-set_state", false, false);
     1590    if (state) {
     1591        if (strcmp(state, "enabled") && strcmp(state, "disabled")) {
     1592            psError(PS_ERR_PROGRAMMING, true, "state must be enabled or disabled");
     1593            return false;
     1594        }
     1595    } else {
     1596        // default state
     1597        state = "enabled";
     1598    }
     1599
     1600    // now that we've done all of our argument checking, copy the values to where
     1601    psMetadata *where = psMetadataAlloc();
     1602    PXOPT_COPY_S64(config->args, where, "-dest_id", "dest_id", "==");
     1603    PXOPT_COPY_STR(config->args, where, "-dest_name", "rcDestination.name", "==");
     1604    PXOPT_COPY_S64(config->args, where, "-target_id", "target_id", "==");
     1605    PXOPT_COPY_STR(config->args, where, "-dist_group", "dist_group", "LIKE");
     1606    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "LIKE");
     1607    // if stage is all don't add it to the query (match all stages)
     1608    if (stage && strcmp(stage, "all")) {
     1609        PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
     1610    }
     1611
     1612    psString query = pxDataGet("disttool_defineinterest.sql");
     1613
     1614    if (!psListLength(where->list)) {
     1615        // can't get here
     1616        psError(PS_ERR_PROGRAMMING, true, "search parameters are required");
     1617        psFree(where);
     1618        psFree(query);
     1619        return false;
     1620    }
     1621    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1622    psStringAppend(&query, " AND %s", whereClause);
     1623    psFree(whereClause);
     1624    psFree(where);
     1625    if (clean) {
     1626        psStringAppend(&query, " AND (distTarget.clean)");
     1627    } else {
     1628        psStringAppend(&query, " AND (!distTarget.clean)");
     1629    }
     1630    if (limit) {
     1631        psString limitString = psDBGenerateLimitSQL(limit);
     1632        psStringAppend(&query, " %s", limitString);
     1633        psFree(limitString);
     1634    }
     1635    {
     1636        // psStringSubstitute fails unless the input is a psString which it determines by
     1637        // comparing the memory blocks free function to an expected value.
     1638        // pxDataGet uses psSlurp which leaves a different free function on the memory block.
     1639        // To work around this make a copy of the query before doing the substitution.
     1640        psString queryCopy = psStringCopy(query);
     1641        psFree(query);
     1642        query = queryCopy;
     1643    }
     1644    // change the @STATE@ in the sql file to our state
     1645    if (!psStringSubstitute(&query, state, "@STATE@")) {
     1646        psError(PS_ERR_UNKNOWN, false, "failed to substitute state string");
     1647        return false;
     1648    }
     1649
     1650    if (!p_psDBRunQuery(config->dbh, query)) {
     1651        psError(PS_ERR_UNKNOWN, false, "database error");
     1652        psFree(query);
     1653        return false;
     1654    }
     1655    psFree(query);
     1656    int numInserted = psDBAffectedRows(config->dbh);
     1657    printf("inserted %d rows into rcInterest\n", numInserted);
     1658
     1659    return true;
     1660}
     1661
     1662static bool updateinterestMode(pxConfig *config)
    15741663{
    15751664    PS_ASSERT_PTR_NON_NULL(config, false);
    15761665
    15771666    psMetadata *where = psMetadataAlloc();
    1578     PXOPT_COPY_S64(config->args, where, "-dest_id", "dest_id", "==");
    1579     PXOPT_COPY_S64(config->args, where, "-prod_id", "prod_id", "==");
     1667    PXOPT_COPY_S64(config->args, where, "-int_id",    "int_id", "==");
     1668    PXOPT_COPY_S64(config->args, where, "-dest_id",   "dest_id", "==");
     1669    PXOPT_COPY_S64(config->args, where, "-target_id", "target_id", "==");
     1670    PXOPT_COPY_STR(config->args, where, "-dest_name", "rcDestination.name", "LIKE");
     1671    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
     1672    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "LIKE");
     1673    PXOPT_COPY_STR(config->args, where, "-dist_group", "dist_group", "LIKE");
     1674
     1675    PXOPT_LOOKUP_BOOL(clean, config->args, "-clean", false);
     1676    PXOPT_LOOKUP_BOOL(full, config->args, "-full", false);
     1677    if (full && clean) {
     1678        psError(PS_ERR_UNKNOWN, true, "-full and -clean makes no sense, chose one or the other");
     1679        psFree(where);
     1680        return false;
     1681    }
     1682       
    15801683
    15811684    PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
    1582 #ifdef ALLOW_UPDATE_LAST_FILESET
    1583     PXOPT_LOOKUP_STR(last_fileset, config->args, "-set_last_fileset", false, false);
    1584     if (!(state || last_fileset)) {
    1585         psError(PS_ERR_UNKNOWN, true, "one or more of -set_state or -set_last_fileset is required");
    1586 # else
    15871685    if (!state) {
    1588 #endif
    1589         psFree(where);
    1590         return false;
    1591     }
    1592     psString query = psStringCopy("UPDATE rcDestination SET");
    1593     psString sep = "";
    1594     if (state) {
    1595         psStringAppend(&query, " state = '%s'", state);
    1596         sep = ",";
    1597     }
    1598 #ifdef ALLOW_UPDATE_LAST_FILESET
    1599     // last_fileset normally gets set by updatercrunMode
    1600     // Allowing it to be set here might cause problems
    1601     // especially since we are allowing selection by prod_id
    1602     if (last_fileset) {
    1603         psStringAppend(&query, " %s last_fileset = '%s'", sep, last_fileset);
    1604     }
    1605 #endif
     1686        psError(PS_ERR_UNKNOWN, true, "-set_state is required");
     1687        psFree(where);
     1688        return false;
     1689    }
     1690    psString query = pxDataGet("disttool_updateinterest.sql");
    16061691
    16071692    if (psListLength(where->list)) {
    … …  
    16171702    psFree(where);
    16181703
    1619     if (!p_psDBRunQuery(config->dbh, query)) {
     1704    if (clean) {
     1705        psStringAppend(&query, " AND distTarget.clean");
     1706    } else {
     1707        psStringAppend(&query, " AND NOT distTarget.clean");
     1708    }
     1709
     1710    if (!p_psDBRunQueryF(config->dbh, query, state)) {
    16201711        psError(PS_ERR_UNKNOWN, false, "database error");
    16211712        psFree(query);
    … …  
    16241715    psFree(query);
    16251716
    1626     return true;
    1627 }
    1628 
    1629 static bool defineinterestMode(pxConfig *config)
     1717    psS64 numUpdated = psDBAffectedRows(config->dbh);
     1718    printf("updated %" PRId64 " interests\n", numUpdated);
     1719
     1720    return true;
     1721}
     1722static bool listinterestsMode(pxConfig *config)
    16301723{
    16311724    PS_ASSERT_PTR_NON_NULL(config, false);
    16321725
    1633     // required
    1634     PXOPT_LOOKUP_S64(dest_id, config->args,      "-dest_id", true, false);
    1635     PXOPT_LOOKUP_S64(target_id, config->args,    "-target_id", true, false);
    1636 
    1637     // optional
    1638     PXOPT_LOOKUP_STR(state, config->args,        "-set_state", false, false);
    1639 
    1640     // XXX: should we insure that these names do not contatin any whitespace?
    1641 
    1642     rcInterestRow *row = rcInterestRowAlloc(
    1643             0,          // int_id
    1644             dest_id,
    1645             target_id,
    1646             state ? state : "enabled"
    1647             );
    1648            
    1649     if (!row) {
    1650         psError(PS_ERR_UNKNOWN, false, "failed to allocate rcInterest object");
    1651         return false;
    1652     }
    1653    if (!rcInterestInsertObject(config->dbh, row)) {
    1654         psError(PS_ERR_UNKNOWN, false, "database error");
    1655         psFree(row);
    1656         return false;
    1657     }
    1658 
    1659     // get the assigned target_id
    1660     row->int_id = psDBLastInsertID(config->dbh);
    1661 
    1662     if (!rcInterestPrintObject(stdout, row, true)) {
    1663         psError(PS_ERR_UNKNOWN, false, "failed to print object");
    1664         psFree(row);
    1665         return false;
    1666     }
    1667 
    1668     psFree(row);
    1669 
    1670     return true;
    1671 }
    1672 
    1673 static bool updateinterestMode(pxConfig *config)
    1674 {
    1675     PS_ASSERT_PTR_NON_NULL(config, false);
    1676 
    1677     psMetadata *where = psMetadataAlloc();
    1678     PXOPT_COPY_S64(config->args, where, "-int_id",    "int_id", "==");
    1679     PXOPT_COPY_S64(config->args, where, "-dest_id",   "dest_id", "==");
     1726    psMetadata *where = psMetadataAlloc();
     1727    PXOPT_COPY_S64(config->args, where, "-int_id", "int_id", "==");
     1728    PXOPT_COPY_S64(config->args, where, "-dest_id", "dest_id", "==");
     1729    PXOPT_COPY_STR(config->args, where, "-dest_name", "name", "==");
    16801730    PXOPT_COPY_S64(config->args, where, "-target_id", "target_id", "==");
    1681 
    1682     PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
    1683     if (!state) {
    1684         psError(PS_ERR_UNKNOWN, true, "-set_state is required");
    1685         psFree(where);
    1686         return false;
    1687     }
    1688     psString query = NULL;
    1689     psStringAppend(&query, "UPDATE rcInterest SET state = '%s'", state);
     1731    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
     1732    PXOPT_COPY_STR(config->args, where, "-dist_group", "dist_group", "LIKE");
     1733    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "LIKE");
     1734    PXOPT_COPY_STR(config->args, where, "-state", "rcInterest.state", "==");
     1735
     1736    PXOPT_LOOKUP_BOOL(clean, config->args, "-clean", false);
     1737    PXOPT_LOOKUP_BOOL(full, config->args, "-full", false);
     1738
     1739    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1740    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1741
     1742    if (clean && full) {
     1743        psError(PS_ERR_UNKNOWN, false, "can't select both -clean and -full");
     1744        return false;
     1745    }
     1746
     1747    psString query = pxDataGet("disttool_listinterests.sql");
    16901748
    16911749    if (psListLength(where->list)) {
    … …  
    16931751        psStringAppend(&query, " WHERE %s", whereClause);
    16941752        psFree(whereClause);
    1695     } else {
    1696         psError(PS_ERR_UNKNOWN, true, "search parameters are required");
    1697         psFree(where);
    1698         psFree(query);
    1699         return false;
     1753        if (clean) {
     1754            psStringAppend(&query, " AND (clean)");
     1755        } else if (full) {
     1756            psStringAppend(&query, " AND (!clean)");
     1757        }
     1758    } else if (clean) {
     1759        psStringAppend(&query, " WHERE clean");
     1760    } else if (full) {
     1761        psStringAppend(&query, " WHERE !clean");
    17001762    }
    17011763    psFree(where);
    17021764
     1765    // treat limit == 0 as "no limit"
     1766    if (limit) {
     1767        psString limitString = psDBGenerateLimitSQL(limit);
     1768        psStringAppend(&query, " %s", limitString);
     1769        psFree(limitString);
     1770    }
     1771
    17031772    if (!p_psDBRunQuery(config->dbh, query)) {
    17041773        psError(PS_ERR_UNKNOWN, false, "database error");
    17051774        psFree(query);
     1775        if (!psDBRollback(config->dbh)) {
     1776            psError(PS_ERR_UNKNOWN, false, "database error");
     1777        }
    17061778        return false;
    17071779    }
    17081780    psFree(query);
    17091781
    1710     return true;
    1711 }
    1712 
     1782    psArray *output = p_psDBFetchResult(config->dbh);
     1783    if (!output) {
     1784        psError(PS_ERR_UNKNOWN, false, "database error");
     1785        return false;
     1786    }
     1787    if (!psArrayLength(output)) {
     1788        psTrace("disttool", PS_LOG_INFO, "no rows found");
     1789        psFree(output);
     1790        return true;
     1791    }
     1792
     1793    if (!ippdbPrintMetadatas(stdout, output, "rcInterest", !simple)) {
     1794        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1795        psFree(output);
     1796        return false;
     1797    }
     1798
     1799    psFree(output);
     1800
     1801    return true;
     1802}
     1803static bool pendingcleanupMode(pxConfig *config)
     1804{
     1805    PS_ASSERT_PTR_NON_NULL(config, false);
     1806
     1807    psMetadata *where = psMetadataAlloc();
     1808    PXOPT_COPY_S64(config->args, where, "-dist_id", "dist_id", "==");
     1809    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
     1810    pxAddLabelSearchArgs (config, where, "-label", "distRun.label", "==");
     1811
     1812    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1813    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1814    PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
     1815
     1816    psString query = pxDataGet("disttool_pendingcleanup.sql");
     1817
     1818    if (psListLength(where->list)) {
     1819        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1820        psStringAppend(&query, " AND %s", whereClause);
     1821        psFree(whereClause);
     1822        psFree(where);
     1823    } else if (!all) {
     1824        psFree(where);
     1825        psError(PXTOOLS_ERR_CONFIG, false, "search parameters or -all are required");
     1826        return false;
     1827    }
     1828
     1829    // treat limit == 0 as "no limit"
     1830    if (limit) {
     1831        psString limitString = psDBGenerateLimitSQL(limit);
     1832        psStringAppend(&query, " %s", limitString);
     1833        psFree(limitString);
     1834    }
     1835
     1836    if (!p_psDBRunQuery(config->dbh, query)) {
     1837        psError(PS_ERR_UNKNOWN, false, "database error");
     1838        psFree(query);
     1839        if (!psDBRollback(config->dbh)) {
     1840            psError(PS_ERR_UNKNOWN, false, "database error");
     1841        }
     1842        return false;
     1843    }
     1844    psFree(query);
     1845
     1846    psArray *output = p_psDBFetchResult(config->dbh);
     1847    if (!output) {
     1848        psError(PS_ERR_UNKNOWN, false, "database error");
     1849        return false;
     1850    }
     1851    if (!psArrayLength(output)) {
     1852        psTrace("disttool", PS_LOG_INFO, "no rows found");
     1853        psFree(output);
     1854        return true;
     1855    }
     1856
     1857    if (!ippdbPrintMetadatas(stdout, output, "distToCleanup", !simple)) {
     1858        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1859        psFree(output);
     1860        return false;
     1861    }
     1862
     1863    psFree(output);
     1864
     1865    return true;
     1866}
     1867static bool listfilesetsMode(pxConfig *config)
     1868{
     1869    PS_ASSERT_PTR_NON_NULL(config, false);
     1870
     1871    psMetadata *where = psMetadataAlloc();
     1872    PXOPT_COPY_S64(config->args, where, "-dist_id", "dist_id", "==");
     1873    PXOPT_COPY_S64(config->args, where, "-int_id", "int_id", "==");
     1874    PXOPT_COPY_S64(config->args, where, "-dest_id", "dest_id", "==");
     1875    PXOPT_COPY_STR(config->args, where, "-dest_name", "name", "==");
     1876    PXOPT_COPY_S64(config->args, where, "-target_id", "target_id", "==");
     1877    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
     1878    PXOPT_COPY_STR(config->args, where, "-dist_group", "dist_group", "LIKE");
     1879    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "LIKE");
     1880    PXOPT_COPY_STR(config->args, where, "-state", "state", "==");
     1881
     1882    PXOPT_LOOKUP_BOOL(clean, config->args, "-clean", false);
     1883    PXOPT_LOOKUP_BOOL(full, config->args, "-full", false);
     1884
     1885    pxAddLabelSearchArgs (config, where, "-label", "distRun.label", "==");
     1886
     1887    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1888    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1889
     1890    if (!psListLength(where->list)) {
     1891        psFree(where);
     1892        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     1893        return false;
     1894    }
     1895
     1896    psString query = pxDataGet("disttool_listfilesets.sql");
     1897
     1898    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1899    psStringAppend(&query, " WHERE %s", whereClause);
     1900    psFree(whereClause);
     1901    psFree(where);
     1902
     1903    // treat limit == 0 as "no limit"
     1904    if (limit) {
     1905        psString limitString = psDBGenerateLimitSQL(limit);
     1906        psStringAppend(&query, " %s", limitString);
     1907        psFree(limitString);
     1908    }
     1909
     1910    if (!p_psDBRunQuery(config->dbh, query)) {
     1911        psError(PS_ERR_UNKNOWN, false, "database error");
     1912        psFree(query);
     1913        if (!psDBRollback(config->dbh)) {
     1914            psError(PS_ERR_UNKNOWN, false, "database error");
     1915        }
     1916        return false;
     1917    }
     1918    psFree(query);
     1919
     1920    psArray *output = p_psDBFetchResult(config->dbh);
     1921    if (!output) {
     1922        psError(PS_ERR_UNKNOWN, false, "database error");
     1923        return false;
     1924    }
     1925    if (!psArrayLength(output)) {
     1926        psTrace("disttool", PS_LOG_INFO, "no rows found");
     1927        psFree(output);
     1928        return true;
     1929    }
     1930
     1931    if (!ippdbPrintMetadatas(stdout, output, "distFilesets", !simple)) {
     1932        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1933        psFree(output);
     1934        return false;
     1935    }
     1936
     1937    psFree(output);
     1938
     1939    return true;
     1940}
     1941static bool updatefilesetMode(pxConfig *config)
     1942{
     1943    psMetadata *where = psMetadataAlloc();
     1944    PXOPT_COPY_S64(config->args, where, "-fs_id", "fs_id", "==");
     1945
     1946    if (!psListLength(where->list)) {
     1947        psFree(where);
     1948        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     1949        return false;
     1950    }
     1951
     1952    PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
     1953
     1954    // We don't use PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false); here
     1955    // because we want -fault 0 to work
     1956    bool gotFault = false;
     1957    psS16 fault = psMetadataLookupS16(&gotFault, config->args, "-fault");
     1958
     1959    if ((!state) && (!gotFault)) {
     1960        psError(PXTOOLS_ERR_CONFIG, true, "parameters (-fault or -set_state) is required");
     1961        psFree(where);
     1962        return false;
     1963    }
     1964
     1965    psString query = psStringCopy("UPDATE rcDSFileset SET ");
     1966
     1967    if (state) {
     1968        psStringAppend(&query, " state = '%s'", state);
     1969    }
     1970
     1971    if (gotFault) {
     1972        psStringAppend(&query, "%s fault = %d", state ? ", " : "", fault);
     1973    }
     1974
     1975    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1976    psStringAppend(&query, " WHERE %s", whereClause);
     1977    psFree(whereClause);
     1978    psFree(where);
     1979
     1980    if (!p_psDBRunQuery(config->dbh, query)) {
     1981        psError(PS_ERR_UNKNOWN, false, "database error");
     1982        psFree(query);
     1983        return false;
     1984    }
     1985
     1986    return true;
     1987}

  • branches/simtest_nebulous_branches/ippTools/src/disttool.h

    r24001 r27840  
    2626    DISTTOOL_MODE_NONE      = 0x0,
    2727    DISTTOOL_MODE_DEFINEBYQUERY,
    28     DISTTOOL_MODE_DEFINERUN,
    2928    DISTTOOL_MODE_UPDATERUN,
    3029    DISTTOOL_MODE_REVERTRUN,
    3130    DISTTOOL_MODE_PENDINGCOMPONENT,
    3231    DISTTOOL_MODE_ADDPROCESSEDCOMPONENT,
     32    DISTTOOL_MODE_REVERTCOMPONENT,
    3333    DISTTOOL_MODE_PROCESSEDCOMPONENT,
    3434    DISTTOOL_MODE_TOADVANCE,
     35    DISTTOOL_MODE_PENDINGCLEANUP,
    3536    DISTTOOL_MODE_PENDINGFILESET,
    3637    DISTTOOL_MODE_ADDFILESET,
    3738    DISTTOOL_MODE_REVERTFILESET,
     39    DISTTOOL_MODE_LISTFILESETS,
     40    DISTTOOL_MODE_UPDATEFILESET,
    3841    DISTTOOL_MODE_QUEUERCRUN,
    3942    DISTTOOL_MODE_UPDATERCRUN,
    … …  
    4245    DISTTOOL_MODE_DEFINEDESTINATION,
    4346    DISTTOOL_MODE_UPDATEDESTINATION,
    44     DISTTOOL_MODE_DEFINEDSPRODUCT,
    45     DISTTOOL_MODE_UPDATEDSPRODUCT,
    4647    DISTTOOL_MODE_DEFINETARGET,
    4748    DISTTOOL_MODE_UPDATETARGET,
    48     DISTTOOL_MODE_LISTTARGET,
     49    DISTTOOL_MODE_LISTTARGETS,
    4950    DISTTOOL_MODE_DEFINEINTEREST,
    5051    DISTTOOL_MODE_UPDATEINTEREST,
     52    DISTTOOL_MODE_LISTINTERESTS,
    5153} disttoolMode;
    5254

  • branches/simtest_nebulous_branches/ippTools/src/disttoolConfig.c

    r24871 r27840  
    3838    config->modules = pmConfigRead(&argc, argv, NULL);
    3939    if (! config->modules) {
    40         psError(PS_ERR_UNKNOWN, false, "Can't find site configuration!\n");
     40        psError(psErrorCodeLast(), false, "Can't find site configuration!\n");
    4141        psFree(config);
    4242        return NULL;
    … …  
    4949
    5050    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-no_magic", 0, "magic is not needed", false);
     51    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-use_alternate", 0, "use alternate inputs", false);
    5152    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_label",    0, "define label for run", NULL);
    52 
    53     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-dry_run", 0, "don't queue runs just display what would be selected", false);
     53    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_data_group",    0, "define data_group for run", NULL);
     54    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_note",    0, "select by dist_group", NULL);
     55
     56    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-pretend", 0, "don't queue runs just display what would be selected", false);
    5457
    5558    // select args
    56     psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-target_id",     0, "define target_id", 0); 
    57     psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-exp_id",        0, "define exp_id", 0); 
    58     psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-chip_id",       0, "define chip_id", 0); 
    59     psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-magic_ds_id",   0, "define chip_id", 0);
    60     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label",         0, "select by label", NULL);
     59    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-target_id",     0, "define target_id", 0);
     60    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-exp_id",        0, "define exp_id", 0);
     61    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-chip_id",       0, "define chip_id", 0);
     62    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label",         0, "select by run label", NULL);
     63    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-dist_group",    0, "select by dist_group", NULL);
    6164
    6265    psMetadataAddU64(definebyqueryArgs, PS_LIST_TAIL, "-limit",  0,  "limit result set to N items", 0);
    6366    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    64 
    65     // -definerun
    66     psMetadata *definerunArgs = psMetadataAlloc();
    67     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-stage",         0, "define stage for bundle (required)", NULL);
    68     psMetadataAddS64(definerunArgs, PS_LIST_TAIL, "-stage_id", 0, "define stage_id (required)", 0);
    69     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-outroot",  0, "define output destination (required)", NULL);
    70     psMetadataAddS64(definerunArgs, PS_LIST_TAIL, "-target_id", 0, "define target_id (required)", 0);
    71     psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-clean", 0,   "build clean distribution bundle", false);
    72     psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-no_magic", 0, "magic is not needed", false);
    73     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_label",    0, "define label for run", NULL);
    7467
    7568    // -updaterun
    … …  
    7871    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state", 0, "new value for state", NULL);
    7972    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_label", 0, "new value for label", NULL);
     73    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_data_group", 0, "new value for label", NULL);
     74    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_outdir", 0, "new value for outdir", NULL);
     75    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_note", 0,         "define new note", NULL);
    8076    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-stage",     0, "value for stage", NULL);
    8177    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state",     0, "value for state", NULL);
    8278    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label",     0, "limit updates to label", NULL);
     79    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-data_group",     0, "limit updates to data_group", NULL);
     80    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-dist_group",     0, "limit updates to data_group", NULL);
    8381    psMetadataAddS16(updaterunArgs, PS_LIST_TAIL, "-fault",      0, "define fault code", 0);
    84 
    8582    // -revertrun
    8683    psMetadata *revertrunArgs = psMetadataAlloc();
    … …  
    9592    // -pendingcomponent
    9693    psMetadata *pendingcomponentArgs = psMetadataAlloc();
     94    psMetadataAddStr(pendingcomponentArgs, PS_LIST_TAIL, "-stage",    0, "limit results to runs for stage (required)", NULL);
    9795    psMetadataAddS64(pendingcomponentArgs, PS_LIST_TAIL, "-dist_id", 0, "define dist_id", 0);
    98     psMetadataAddStr(pendingcomponentArgs, PS_LIST_TAIL, "-stage",    0, "limit results to runs for stage", NULL);
    9996    psMetadataAddStr(pendingcomponentArgs, PS_LIST_TAIL, "-label",    PS_META_DUPLICATE_OK, "limit results to label", NULL);
    10097    psMetadataAddU64(pendingcomponentArgs, PS_LIST_TAIL, "-limit",  0,  "limit result set to N items", 0);
    10198    psMetadataAddBool(pendingcomponentArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     99
     100    // -pendingcleanup
     101    psMetadata *pendingcleanupArgs = psMetadataAlloc();
     102    psMetadataAddS64(pendingcleanupArgs, PS_LIST_TAIL, "-dist_id", 0, "define dist_id", 0);
     103    psMetadataAddStr(pendingcleanupArgs, PS_LIST_TAIL, "-stage",    0, "limit results to runs for stage", NULL);
     104    psMetadataAddStr(pendingcleanupArgs, PS_LIST_TAIL, "-label",    PS_META_DUPLICATE_OK, "limit results to label", NULL);
     105    psMetadataAddU64(pendingcleanupArgs, PS_LIST_TAIL, "-limit",  0,  "limit result set to N items", 0);
     106    psMetadataAddBool(pendingcleanupArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     107    psMetadataAddBool(pendingcleanupArgs, PS_LIST_TAIL, "-all",    0, "list all runs pending cleanup", NULL);
    102108
    103109
    … …  
    106112    psMetadataAddS64(addprocessedcomponentArgs, PS_LIST_TAIL, "-dist_id", 0, "define dist_id", 0);
    107113    psMetadataAddStr(addprocessedcomponentArgs, PS_LIST_TAIL, "-component", 0, "define component (required)", NULL);
     114    psMetadataAddStr(addprocessedcomponentArgs, PS_LIST_TAIL, "-outdir", 0, "define output directory", NULL);
    108115    psMetadataAddStr(addprocessedcomponentArgs, PS_LIST_TAIL, "-name", 0, "define file name", NULL);
    109116    psMetadataAddS32(addprocessedcomponentArgs, PS_LIST_TAIL, "-bytes", 0, "define file size", 0);
    110117    psMetadataAddStr(addprocessedcomponentArgs, PS_LIST_TAIL, "-md5sum", 0, "define stage for bundle", NULL);
    111118    psMetadataAddS32(addprocessedcomponentArgs, PS_LIST_TAIL, "-fault", 0, "define fault code", 0);
     119
     120    // -revertcomponent
     121    psMetadata *revertcomponentArgs = psMetadataAlloc();
     122    psMetadataAddS64(revertcomponentArgs, PS_LIST_TAIL, "-dist_id", 0, "define dist_id", 0);
     123    psMetadataAddStr(revertcomponentArgs, PS_LIST_TAIL, "-component", 0, "define component", NULL);
     124    psMetadataAddStr(revertcomponentArgs, PS_LIST_TAIL, "-stage",    0, "define stage", NULL);
     125    psMetadataAddS64(revertcomponentArgs, PS_LIST_TAIL, "-stage_id", 0, "define stage_id", 0);
     126    psMetadataAddStr(revertcomponentArgs, PS_LIST_TAIL, "-state",    0, "define state", NULL);
     127    psMetadataAddStr(revertcomponentArgs, PS_LIST_TAIL, "-label",    PS_META_DUPLICATE_OK, "define label", NULL);
     128    psMetadataAddS16(revertcomponentArgs, PS_LIST_TAIL, "-fault", 0, "define fault code", 0);
     129    psMetadataAddBool(revertcomponentArgs, PS_LIST_TAIL, "-all",    0, "revert all faulted runs", NULL);
    112130
    113131    // -processedcomponent
    … …  
    128146    psMetadataAddS64(pendingfilesetArgs, PS_LIST_TAIL, "-dist_id", 0, "define dist_id", 0);
    129147    psMetadataAddStr(pendingfilesetArgs, PS_LIST_TAIL, "-label",   PS_META_DUPLICATE_OK, "limit results to label", NULL);
     148    psMetadataAddStr(pendingfilesetArgs, PS_LIST_TAIL, "-dist_group",   PS_META_DUPLICATE_OK, "limit results to dist_group", NULL);
    130149    psMetadataAddStr(pendingfilesetArgs, PS_LIST_TAIL, "-stage",   0, "limit results to runs for stage", NULL);
    131150    psMetadataAddU64(pendingfilesetArgs, PS_LIST_TAIL, "-limit",   0,  "limit result set to N items", 0);
    … …  
    135154    psMetadata *addfilesetArgs = psMetadataAlloc();
    136155    psMetadataAddS64(addfilesetArgs, PS_LIST_TAIL, "-dist_id", 0, "define dist_id", 0);
    137     psMetadataAddS64(addfilesetArgs, PS_LIST_TAIL, "-prod_id", 0, "define prod_id", 0);
     156    psMetadataAddS64(addfilesetArgs, PS_LIST_TAIL, "-dest_id", 0, "define dest_id", 0);
    138157    psMetadataAddStr(addfilesetArgs, PS_LIST_TAIL, "-name",    0, "define file name", NULL);
    139158    psMetadataAddS32(addfilesetArgs, PS_LIST_TAIL, "-fault",   0, "define fault code", 0);
     159
     160    // -updatefileset
     161    psMetadata *updatefilesetArgs = psMetadataAlloc();
     162    psMetadataAddS64(updatefilesetArgs, PS_LIST_TAIL, "-fs_id", 0, "define fs_id", 0);
     163//    psMetadataAddS64(updatefilesetArgs, PS_LIST_TAIL, "-dist_id", 0, "define dist_id", 0);
     164    psMetadataAddStr(updatefilesetArgs, PS_LIST_TAIL, "-set_state",0, "new value for state", NULL);
     165    psMetadataAddS32(updatefilesetArgs, PS_LIST_TAIL, "-fault",   0, "define fault code", 0);
    140166
    141167    // -pendingdest
    … …  
    150176    psMetadataAddS64(revertfilesetArgs, PS_LIST_TAIL, "-fs_id",   0, "define fs_id", 0);
    151177    psMetadataAddS64(revertfilesetArgs, PS_LIST_TAIL, "-dist_id", 0, "define dist_id", 0);
    152     psMetadataAddS64(revertfilesetArgs, PS_LIST_TAIL, "-prod_id", 0, "define dist_id", 0);
     178    psMetadataAddS64(revertfilesetArgs, PS_LIST_TAIL, "-dest_id", 0, "define dist_id", 0);
    153179    psMetadataAddStr(revertfilesetArgs, PS_LIST_TAIL, "-stage",   0, "define stage", NULL);
    154180    psMetadataAddS64(revertfilesetArgs, PS_LIST_TAIL, "-stage_id",0, "define stage_id", 0);
    … …  
    158184    psMetadataAddBool(revertfilesetArgs, PS_LIST_TAIL, "-all",    0, "revert all faulted runs", NULL);
    159185
     186    // -listfileset
     187    psMetadata *listfilesetsArgs = psMetadataAlloc();
     188    psMetadataAddS64(listfilesetsArgs, PS_LIST_TAIL, "-dist_id", 0, "list filesets with dist_id", 0);
     189    psMetadataAddS64(listfilesetsArgs, PS_LIST_TAIL, "-target_id", 0, "list filesets with target_id", 0);
     190    psMetadataAddS64(listfilesetsArgs, PS_LIST_TAIL, "-dest_id", 0, "list filesets with dest_id", 0);
     191    psMetadataAddS64(listfilesetsArgs, PS_LIST_TAIL, "-int_id", 0, "list filesets with int_id", 0);
     192    psMetadataAddStr(listfilesetsArgs, PS_LIST_TAIL, "-dest_name",  0, "list filesets for destinationn name)", NULL);
     193    psMetadataAddStr(listfilesetsArgs, PS_LIST_TAIL, "-dist_group",  0, "list filesets for dist_group (LIKE comparison)", NULL);
     194    psMetadataAddStr(listfilesetsArgs, PS_LIST_TAIL, "-filter",    0, "list filesets by filter (LIKE comparison)", NULL);
     195    psMetadataAddStr(listfilesetsArgs, PS_LIST_TAIL, "-stage",     0, "list filesets for stage", NULL);
     196    psMetadataAddBool(listfilesetsArgs, PS_LIST_TAIL,"-clean",     0, "list clean filesets", false);
     197    psMetadataAddBool(listfilesetsArgs, PS_LIST_TAIL,"-full",      0, "list full filesets", false);
     198    psMetadataAddStr(listfilesetsArgs, PS_LIST_TAIL, "-state",     0, "list filesets in state", NULL);
     199    psMetadataAddStr(listfilesetsArgs, PS_LIST_TAIL, "-label",   PS_META_DUPLICATE_OK, "limit results to label", NULL);
     200    psMetadataAddU64(listfilesetsArgs, PS_LIST_TAIL, "-limit",     0, "limit number of filesets listed to N", 0);
     201    psMetadataAddBool(listfilesetsArgs, PS_LIST_TAIL, "-simple",  0, "use the simple output format", false);
     202
    160203    // -queuercrun
    161204    psMetadata *queuercrunArgs = psMetadataAlloc();
    162205    psMetadataAddS64(queuercrunArgs, PS_LIST_TAIL, "-dist_id",   0, "define dist_id", 0);
    163206    psMetadataAddS64(queuercrunArgs, PS_LIST_TAIL, "-dest_id",   0, "define dest_id", 0);
    164     psMetadataAddS64(queuercrunArgs, PS_LIST_TAIL, "-prod_id",   0, "define prod_id", 0);
    165207    psMetadataAddS64(queuercrunArgs, PS_LIST_TAIL, "-target_id", 0, "define target_id", 0);
    166208    psMetadataAddS64(queuercrunArgs, PS_LIST_TAIL, "-fs_id",     0, "define fs_id", 0);
    … …  
    189231    psMetadataAddBool(revertrcrunArgs, PS_LIST_TAIL, "-all",     0, "revert all faulted runs", NULL);
    190232
    191     // -definedsproduct
    192     psMetadata *definedsproductArgs = psMetadataAlloc();
    193     psMetadataAddStr(definedsproductArgs, PS_LIST_TAIL, "-name",  0, "define product name", NULL);
    194     psMetadataAddStr(definedsproductArgs, PS_LIST_TAIL, "-ds_dbname",0, "define data store database name", NULL);
    195     psMetadataAddStr(definedsproductArgs, PS_LIST_TAIL, "-ds_dbhost",0, "define data store database host", NULL);
    196 
    197     // -updatedsproduct
    198     // does this mode make sense?
    199     psMetadata *updatedsproductArgs = psMetadataAlloc();
    200     psMetadataAddS64(updatedsproductArgs, PS_LIST_TAIL, "-prod_id",   0, "select by prod_id", 0);
    201     // can't select by name because it isn't necssarily unique
    202     psMetadataAddStr(updatedsproductArgs, PS_LIST_TAIL, "-ds_dbname",0, "define data store database name", NULL);
    203     psMetadataAddStr(updatedsproductArgs, PS_LIST_TAIL, "-ds_dbhost",0, "define data store database host", NULL);
    204 
    205233    // -definedestination
    206234    psMetadata *definedestinationArgs = psMetadataAlloc();
    207     psMetadataAddS64(definedestinationArgs, PS_LIST_TAIL, "-prod_id",     0, "define prod_id (required)", 0);
    208235    psMetadataAddStr(definedestinationArgs, PS_LIST_TAIL, "-name",        0, "define destination name (required)", NULL);
     236    psMetadataAddStr(definedestinationArgs, PS_LIST_TAIL, "-ds_dbname",0, "define data store database name (required)", NULL);
     237    psMetadataAddStr(definedestinationArgs, PS_LIST_TAIL, "-ds_dbhost",0, "define data store database host (required)", NULL);
    209238    psMetadataAddStr(definedestinationArgs, PS_LIST_TAIL, "-status_uri",  0, "define status_uri", NULL);
    210239    psMetadataAddStr(definedestinationArgs, PS_LIST_TAIL, "-comment",     0, "define comment", NULL);
    … …  
    215244    psMetadata *updatedestinationArgs = psMetadataAlloc();
    216245    psMetadataAddS64(updatedestinationArgs, PS_LIST_TAIL, "-dest_id",     0, "define dest_id", 0);
    217     psMetadataAddS64(updatedestinationArgs, PS_LIST_TAIL, "-prod_id",     0, "define prod_id", 0);
    218246    psMetadataAddStr(updatedestinationArgs, PS_LIST_TAIL, "-name",        0, "define destination name", NULL);
    219247    psMetadataAddStr(updatedestinationArgs, PS_LIST_TAIL, "-status_uri",  0, "define status_uri", NULL);
    220248    psMetadataAddStr(updatedestinationArgs, PS_LIST_TAIL, "-comment",     0, "define comment", NULL);
    221 //  last_fileset gets updated by -updatercrun
    222 //  psMetadataAddStr(updatedestinationArgs, PS_LIST_TAIL, "-set_last_fileset",0, "define last_fileset", NULL);
    223249    psMetadataAddStr(updatedestinationArgs, PS_LIST_TAIL, "-set_state",   0, "define state", NULL);
    224250
    225251    // -definetarget
    226252    psMetadata *definetargetArgs = psMetadataAlloc();
    227     psMetadataAddStr(definetargetArgs, PS_LIST_TAIL, "-label",     0, "define label (required)", NULL);
     253    psMetadataAddStr(definetargetArgs, PS_LIST_TAIL, "-dist_group", 0, "define dist_group (required)", NULL);
    228254    psMetadataAddStr(definetargetArgs, PS_LIST_TAIL, "-filter",     0, "define filter (required)", NULL);
    229255    psMetadataAddStr(definetargetArgs, PS_LIST_TAIL, "-stage",     0, "define stage (required)", NULL);
    … …  
    236262    psMetadataAddS64(updatetargetArgs, PS_LIST_TAIL, "-target_id", 0, "define target_id", 0);
    237263    psMetadataAddStr(updatetargetArgs, PS_LIST_TAIL, "-stage",     0, "define stage", NULL);
    238     psMetadataAddStr(updatetargetArgs, PS_LIST_TAIL, "-set_state", 0, "define state", NULL);
    239     psMetadataAddStr(updatetargetArgs, PS_LIST_TAIL, "-label",     0, "define label", NULL);
     264    psMetadataAddStr(updatetargetArgs, PS_LIST_TAIL, "-dist_group", 0, "define dist_group", NULL);
    240265    psMetadataAddStr(updatetargetArgs, PS_LIST_TAIL, "-filter",    0, "define filter", NULL);
    241266
    242     // -listtarget
    243     psMetadata *listtargetArgs = psMetadataAlloc();
    244     psMetadataAddS64(listtargetArgs, PS_LIST_TAIL, "-target_id", 0, "list target with target_id", 0);
    245     psMetadataAddStr(listtargetArgs, PS_LIST_TAIL, "-label",  0, "list targets for label", NULL);
    246     psMetadataAddStr(listtargetArgs, PS_LIST_TAIL, "-filter",    0, "define filter", NULL);
    247     psMetadataAddStr(listtargetArgs, PS_LIST_TAIL, "-stage",     0, "list targets for stage", NULL);
    248     psMetadataAddBool(listtargetArgs, PS_LIST_TAIL,"-clean",     0, "list clean targets", false);
    249     psMetadataAddBool(listtargetArgs, PS_LIST_TAIL,"-full",      0, "list full targets", false);
    250     psMetadataAddStr(listtargetArgs, PS_LIST_TAIL, "-state",     0, "list targets in state", NULL);
    251     psMetadataAddU64(listtargetArgs, PS_LIST_TAIL, "-limit",     0, "limit number of targets listed to N", 0);
    252     psMetadataAddBool(listtargetArgs, PS_LIST_TAIL, "-simple",  0, "use the simple output format", false);
     267    psMetadataAddStr(updatetargetArgs, PS_LIST_TAIL, "-set_state", 0, "define new state", NULL);
     268
     269    // -listtargets
     270    psMetadata *listtargetsArgs = psMetadataAlloc();
     271    psMetadataAddS64(listtargetsArgs, PS_LIST_TAIL, "-target_id", 0, "list target with target_id", 0);
     272    psMetadataAddStr(listtargetsArgs, PS_LIST_TAIL, "-dist_group",  0, "list targets for dist_group", NULL);
     273    psMetadataAddStr(listtargetsArgs, PS_LIST_TAIL, "-filter",    0, "define filter", NULL);
     274    psMetadataAddStr(listtargetsArgs, PS_LIST_TAIL, "-stage",     0, "list targets for stage", NULL);
     275    psMetadataAddBool(listtargetsArgs, PS_LIST_TAIL,"-clean",     0, "list clean targets", false);
     276    psMetadataAddBool(listtargetsArgs, PS_LIST_TAIL,"-full",      0, "list full targets", false);
     277    psMetadataAddStr(listtargetsArgs, PS_LIST_TAIL, "-state",     0, "list targets in state", NULL);
     278    psMetadataAddU64(listtargetsArgs, PS_LIST_TAIL, "-limit",     0, "limit number of targets listed to N", 0);
     279    psMetadataAddBool(listtargetsArgs, PS_LIST_TAIL, "-simple",  0, "use the simple output format", false);
    253280
    254281    // -defineinterest
    255282    psMetadata *defineinterestArgs = psMetadataAlloc();
    256     psMetadataAddS64(defineinterestArgs, PS_LIST_TAIL, "-dest_id",   0, "define dest_id (required)", 0);
    257     psMetadataAddS64(defineinterestArgs, PS_LIST_TAIL, "-target_id", 0, "define target_id (required)", 0);
     283    psMetadataAddS64(defineinterestArgs, PS_LIST_TAIL, "-dest_id",   0, "define dest_id", 0);
     284    psMetadataAddStr(defineinterestArgs, PS_LIST_TAIL, "-dest_name", 0, "define destination name (LIKE comparison)", NULL);
     285    psMetadataAddS64(defineinterestArgs, PS_LIST_TAIL, "-target_id", 0, "define target_id", 0);
     286    psMetadataAddStr(defineinterestArgs, PS_LIST_TAIL, "-stage",     0, "define stage", NULL);
     287    psMetadataAddStr(defineinterestArgs, PS_LIST_TAIL, "-dist_group",     0, "define dist_group", NULL);
     288    psMetadataAddStr(defineinterestArgs, PS_LIST_TAIL, "-filter",    0, "define filter (LIKE comparison)", NULL);
     289    psMetadataAddBool(defineinterestArgs, PS_LIST_TAIL,"-clean",     0, "list clean targets", false);
    258290    psMetadataAddStr(defineinterestArgs, PS_LIST_TAIL, "-set_state", 0, "define state", NULL);
     291    psMetadataAddU64(defineinterestArgs, PS_LIST_TAIL, "-limit",     0, "limit number of targets listed to N", 0);
    259292
    260293    // -updateinterest
    … …  
    264297    psMetadataAddS64(updateinterestArgs, PS_LIST_TAIL, "-target_id", 0, "define target_id", 0);
    265298    psMetadataAddStr(updateinterestArgs, PS_LIST_TAIL, "-set_state", 0, "define state (required)", NULL);
     299    psMetadataAddStr(updateinterestArgs, PS_LIST_TAIL, "-stage",    0, "define stage", NULL);
     300    psMetadataAddStr(updateinterestArgs, PS_LIST_TAIL, "-filter",    0, "define filter (LIKE comparison)", NULL);
     301    psMetadataAddStr(updateinterestArgs, PS_LIST_TAIL, "-dest_name",    0, "define destination name", NULL);
     302    psMetadataAddStr(updateinterestArgs, PS_LIST_TAIL, "-dist_group",    0, "define distribution group", NULL);
     303    psMetadataAddBool(updateinterestArgs, PS_LIST_TAIL,"-clean",     0, "update clean interests", false);
     304    psMetadataAddBool(updateinterestArgs, PS_LIST_TAIL,"-full",     0, "update full interests", false);
     305
     306    // -listinterests
     307    psMetadata *listinterestsArgs = psMetadataAlloc();
     308    psMetadataAddS64(listinterestsArgs, PS_LIST_TAIL, "-target_id", 0, "list interests with target_id", 0);
     309    psMetadataAddS64(listinterestsArgs, PS_LIST_TAIL, "-dest_id", 0, "list interests with dest_id", 0);
     310    psMetadataAddS64(listinterestsArgs, PS_LIST_TAIL, "-int_id", 0, "list interests with int_id", 0);
     311    psMetadataAddStr(listinterestsArgs, PS_LIST_TAIL, "-dest_name",  0, "list interests for destinationn name)", NULL);
     312    psMetadataAddStr(listinterestsArgs, PS_LIST_TAIL, "-dist_group",  0, "list interests for dist_group (LIKE comparison)", NULL);
     313    psMetadataAddStr(listinterestsArgs, PS_LIST_TAIL, "-filter",    0, "list interests by filter (LIKE comparison)", NULL);
     314    psMetadataAddStr(listinterestsArgs, PS_LIST_TAIL, "-stage",     0, "list interests for stage", NULL);
     315    psMetadataAddBool(listinterestsArgs, PS_LIST_TAIL,"-clean",     0, "list clean interests", false);
     316    psMetadataAddBool(listinterestsArgs, PS_LIST_TAIL,"-full",      0, "list full interests", false);
     317    psMetadataAddStr(listinterestsArgs, PS_LIST_TAIL, "-state",     0, "list interests in state", NULL);
     318    psMetadataAddU64(listinterestsArgs, PS_LIST_TAIL, "-limit",     0, "limit number of interests listed to N", 0);
     319    psMetadataAddBool(listinterestsArgs, PS_LIST_TAIL, "-simple",  0, "use the simple output format", false);
    266320
    267321    psMetadata *argSets = psMetadataAlloc();
    … …  
    269323
    270324    PXOPT_ADD_MODE("-definebyquery",    "", DISTTOOL_MODE_DEFINEBYQUERY, definebyqueryArgs);
    271     PXOPT_ADD_MODE("-definerun",    "", DISTTOOL_MODE_DEFINERUN, definerunArgs);
    272325    PXOPT_ADD_MODE("-updaterun",    "", DISTTOOL_MODE_UPDATERUN, updaterunArgs);
    273326    PXOPT_ADD_MODE("-revertrun",    "", DISTTOOL_MODE_REVERTRUN, revertrunArgs);
    274     PXOPT_ADD_MODE("-pendingcomponent",       "", DISTTOOL_MODE_PENDINGCOMPONENT,    pendingcomponentArgs);
    275     PXOPT_ADD_MODE("-addprocessedcomponent",      "", DISTTOOL_MODE_ADDPROCESSEDCOMPONENT, addprocessedcomponentArgs);
     327    PXOPT_ADD_MODE("-pendingcomponent",   "", DISTTOOL_MODE_PENDINGCOMPONENT,    pendingcomponentArgs);
     328    PXOPT_ADD_MODE("-addprocessedcomponent", "", DISTTOOL_MODE_ADDPROCESSEDCOMPONENT, addprocessedcomponentArgs);
     329    PXOPT_ADD_MODE("-revertcomponent",    "", DISTTOOL_MODE_REVERTCOMPONENT, revertcomponentArgs);
    276330    PXOPT_ADD_MODE("-processedcomponent", "", DISTTOOL_MODE_PROCESSEDCOMPONENT, processedcomponentArgs);
    277331    PXOPT_ADD_MODE("-toadvance",          "", DISTTOOL_MODE_TOADVANCE, toadvanceArgs);
     332    PXOPT_ADD_MODE("-pendingcleanup",     "", DISTTOOL_MODE_PENDINGCLEANUP, pendingcleanupArgs);
    278333    PXOPT_ADD_MODE("-pendingfileset",     "", DISTTOOL_MODE_PENDINGFILESET, pendingfilesetArgs);
    279334    PXOPT_ADD_MODE("-addfileset",         "", DISTTOOL_MODE_ADDFILESET, addfilesetArgs);
     335    PXOPT_ADD_MODE("-updatefileset",         "", DISTTOOL_MODE_UPDATEFILESET, updatefilesetArgs);
     336    PXOPT_ADD_MODE("-listfilesets",        "", DISTTOOL_MODE_LISTFILESETS, listfilesetsArgs);
    280337    PXOPT_ADD_MODE("-revertfileset",      "", DISTTOOL_MODE_REVERTFILESET, revertfilesetArgs);
    281338    PXOPT_ADD_MODE("-queuercrun",         "", DISTTOOL_MODE_QUEUERCRUN, queuercrunArgs);
    … …  
    284341    PXOPT_ADD_MODE("-pendingdest",        "", DISTTOOL_MODE_PENDINGDEST, pendingdestArgs);
    285342
    286     PXOPT_ADD_MODE("-definedsproduct",    "", DISTTOOL_MODE_DEFINEDSPRODUCT, definedsproductArgs);
    287     PXOPT_ADD_MODE("-updatedsproduct",    "", DISTTOOL_MODE_UPDATEDSPRODUCT, updatedsproductArgs);
    288 //  PXOPT_ADD_MODE("-listdsproduct",      "", DISTTOOL_MODE_LISTDSPRODUCT, updatedsproductArgs);
    289 
    290343    PXOPT_ADD_MODE("-definedestination",  "", DISTTOOL_MODE_DEFINEDESTINATION, definedestinationArgs);
    291344    PXOPT_ADD_MODE("-updatedestination",  "", DISTTOOL_MODE_UPDATEDESTINATION, updatedestinationArgs);
    … …  
    294347    PXOPT_ADD_MODE("-definetarget",       "", DISTTOOL_MODE_DEFINETARGET, definetargetArgs);
    295348    PXOPT_ADD_MODE("-updatetarget",       "", DISTTOOL_MODE_UPDATETARGET, updatetargetArgs);
    296     PXOPT_ADD_MODE("-listtarget",         "", DISTTOOL_MODE_LISTTARGET, listtargetArgs);
     349    PXOPT_ADD_MODE("-listtargets",         "", DISTTOOL_MODE_LISTTARGETS, listtargetsArgs);
    297350
    298351    PXOPT_ADD_MODE("-defineinterest",     "", DISTTOOL_MODE_DEFINEINTEREST, defineinterestArgs);
    299352    PXOPT_ADD_MODE("-updateinterest",     "", DISTTOOL_MODE_UPDATEINTEREST, updateinterestArgs);
    300 //  PXOPT_ADD_MODE("-listinterest",       "", DISTTOOL_MODE_LISTINTEREST, listinterestArgs);
     353    PXOPT_ADD_MODE("-listinterests",       "", DISTTOOL_MODE_LISTINTERESTS, listinterestsArgs);
    301354
    302355    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • branches/simtest_nebulous_branches/ippTools/src/faketool.c

    r24866 r27840  
    5252static bool tofullimfileMode(pxConfig *config);
    5353static bool topurgedimfileMode(pxConfig *config);
     54static bool toscrubbedimfileMode(pxConfig *config);
    5455static bool exportrunMode(pxConfig *config);
    5556static bool importrunMode(pxConfig *config);
    … …  
    9192        MODECASE(FAKETOOL_MODE_TOFULLIMFILE,            tofullimfileMode);
    9293        MODECASE(FAKETOOL_MODE_TOPURGEDIMFILE,          topurgedimfileMode);
     94        MODECASE(FAKETOOL_MODE_TOSCRUBBEDIMFILE,        toscrubbedimfileMode);
    9395        MODECASE(FAKETOOL_MODE_EXPORTRUN,               exportrunMode);
    9496        MODECASE(FAKETOOL_MODE_IMPORTRUN,               importrunMode);
    … …  
    121123
    122124    psMetadata *where = psMetadataAlloc();
     125    PXOPT_COPY_S64(config->args, where, "-cam_id", "cam_id", "==");
     126    PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "==");
    123127    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    124128    PXOPT_COPY_STR(config->args, where, "-exp_name", "exp_name", "==");
    … …  
    128132    PXOPT_COPY_TIME(config->args, where, "-dateobs_end", "dateobs", "<=");
    129133    PXOPT_COPY_STR(config->args, where, "-exp_tag", "exp_tag", "==");
    130     pxAddLabelSearchArgs (config, where, "-label", "label", "==");
     134    pxAddLabelSearchArgs (config, where, "-label", "label", "=="); // XXX does this choose the right label?
    131135    PXOPT_COPY_STR(config->args, where, "-filelevel", "filelevel", "==");
    132136    PXOPT_COPY_STR(config->args, where, "-reduction", "reduction", "==");
    … …  
    164168        && !psMetadataLookupBool(NULL, config->args, "-all")) {
    165169        psFree(where);
    166         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     170        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    167171        return false;
    168172    }
    … …  
    175179    PXOPT_LOOKUP_STR(tess_id, config->args, "-set_tess_id", false, false);
    176180    PXOPT_LOOKUP_STR(end_stage, config->args, "-set_end_stage", false, false);
     181    PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
     182    PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false);
     183    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
    177184
    178185    // default
    … …  
    183190    psString query = pxDataGet("faketool_find_camrun.sql");
    184191    if (!query) {
    185         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     192        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    186193        psFree(where);
    187194        return false;
    … …  
    263270
    264271        // queue the exp
    265         if (!pxfakeQueueByCamID(config, cam_id, workdir, label, reduction, expgroup, dvodb, tess_id, end_stage)) {
     272        if (!pxfakeQueueByCamID(config, cam_id, workdir, label, data_group ? data_group : label, dist_group, reduction, expgroup, dvodb, tess_id, end_stage, note)) {
    266273            if (!psDBRollback(config->dbh)) {
    267274                psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    328335    PXOPT_COPY_F32(config->args, where, "-sun_angle_max", "sun_angle", "<");
    329336    PXOPT_COPY_STR(config->args, where, "-label", "fakeRun.label", "==");
    330 
    331     if (!psListLength(where->list)
    332         && !psMetadataLookupBool(NULL, config->args, "-all")) {
     337    PXOPT_COPY_STR(config->args, where, "-data_group", "fakeRun.data_group", "==");
     338    PXOPT_COPY_STR(config->args, where, "-dist_group", "fakeRun.dist_group", "==");
     339
     340    if (!psListLength(where->list)) {
    333341        psFree(where);
    334342        where = NULL;
    335         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
    336         return false;
    337     }
    338 
    339     PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
    340     PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
    341 
    342     if ((!state) && (!label)) {
    343         psError(PXTOOLS_ERR_DATA, false, "parameters are required");
    344         psFree(where);
    345         return false;
    346     }
    347 
    348     if (state) {
    349         // set fakeRun.state to state
    350         if (!pxfakeRunSetStateByQuery(config, where, state)) {
    351             psFree(where);
    352             return false;
    353         }
    354     }
    355 
    356     if (label) {
    357         // set fakeRun.label to label
    358         if (!pxfakeRunSetLabelByQuery(config, where, label)) {
    359             psFree(where);
    360             return false;
    361         }
    362     }
    363 
     343        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     344        return false;
     345    }
     346
     347    psString query = psStringCopy("UPDATE fakeRun JOIN camRun USING(cam_id) JOIN chipRun USING(chip_id) JOIN rawExp USING(exp_id)");
     348
     349    // pxUpdateRun gets parameters from config->args and updates
     350    bool result = pxUpdateRun(config, where, &query, "fakeRun", "fake_id", "fakeProcessedImfile", true);
     351    if (!result) {
     352        psError(psErrorCodeLast(), false, "pxUpdateRun failed");
     353    }
     354
     355    psFree(query);
    364356    psFree(where);
    365357
    366     return true;
     358    return result;
    367359}
    368360
    … …  
    383375    psString query = pxDataGet("faketool_find_pendingexp.sql");
    384376    if (!query) {
    385         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     377        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    386378        psFree(where);
    387379        return false;
    … …  
    450442    psString query = pxDataGet("faketool_pendingimfile.sql");
    451443    if (!query) {
    452         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     444        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    453445        return false;
    454446    }
    … …  
    566558    PXOPT_COPY_S64(config->args, where, "-exp_id", "rawExp.exp_id", "==");
    567559    PXOPT_COPY_STR(config->args, where, "-class_id", "rawImfile.class_id", "==");
    568     PXOPT_COPY_STR(config->args, where, "-inst", "rawExp.telescope", "==");
    569     PXOPT_COPY_STR(config->args, where, "-filter", "rawExp.filter", "==");
     560    PXOPT_COPY_STR(config->args, where, "-inst", "rawExp.camera", "==");
     561    PXOPT_COPY_STR(config->args, where, "-filter", "rawExp.filter", "LIKE");
    570562
    571563    psString query = pxDataGet("faketool_processedimfile.sql");
    572564    if (!query) {
    573         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     565        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    574566        return false;
    575567    }
    576568
    577569    if (where && psListLength(where->list)) {
    578         psString whereClause = psDBGenerateWhereConditionSQL(where, "fakeProcessedImfile");
     570        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    579571        psStringAppend(&query, " AND %s", whereClause);
    580572        psFree(whereClause);
    … …  
    675667        && !psMetadataLookupBool(NULL, config->args, "-all")) {
    676668        psFree(where);
    677         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     669        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    678670        return false;
    679671    }
    … …  
    681673    psString query = pxDataGet("faketool_revertprocessedimfile.sql");
    682674    if (!query) {
    683         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     675        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    684676        psFree(where);
    685677        return false;
    … …  
    822814    psString query = pxDataGet("faketool_unmasked.sql");
    823815    if (!query) {
    824         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     816        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    825817        return false;
    826818    }
    … …  
    899891    psString query = pxDataGet("faketool_pendingcleanuprun.sql");
    900892    if (!query) {
    901         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     893        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    902894        return false;
    903895    }
    … …  
    964956    psString query = pxDataGet("faketool_pendingcleanupimfile.sql");
    965957    if (!query) {
    966         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     958        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    967959        return false;
    968960    }
    … …  
    10251017    psString query = pxDataGet("faketool_donecleanup.sql");
    10261018    if (!query) {
    1027         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1019        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10281020        return false;
    10291021    }
    … …  
    10871079    psString query = pxDataGet("faketool_completely_processed_exp.sql");
    10881080    if (!query) {
    1089         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1081        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10901082        return false;
    10911083    }
    … …  
    11601152                                 fakeRun->workdir,
    11611153                                 fakeRun->label,
     1154                                 fakeRun->data_group,
     1155                                 fakeRun->dist_group,
    11621156                                 fakeRun->dvodb,
    11631157                                 fakeRun->tess_id,
    11641158                                 fakeRun->reduction,
    1165                                  fakeRun->end_stage
     1159                                 fakeRun->end_stage,
     1160                                 NULL // note does not propagate
    11661161        )) {
    11671162            psError(PS_ERR_UNKNOWN, false, "failed to queue warpRun");
    … …  
    12511246    return change_imfile_data_state(config, "purged", "goto_purged");
    12521247}
     1248static bool toscrubbedimfileMode(pxConfig *config)
     1249{
     1250     return change_imfile_data_state(config, "scrubbed", "goto_scrubbed");
     1251}
    12531252
    12541253bool exportrunMode(pxConfig *config)
    … …  
    12731272    return false;
    12741273  }
    1275 
     1274  if (!pxExportVersion(config, f)) {
     1275    psError(PS_ERR_UNKNOWN, false, "failed to write dbversion output file");
     1276    return false;
     1277  }
    12761278  psMetadata *where = psMetadataAlloc();
    12771279  PXOPT_COPY_S64(config->args, where, "-fake_id", "fake_id", "==");
    … …  
    12851287    psString query = pxDataGet(tables[i].sqlFilename);
    12861288    if (!query) {
    1287       psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1289      psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    12881290      return false;
    12891291    }
    … …  
    13541356  psMetadata *input = psMetadataConfigRead (NULL, &nFail, infile, false);
    13551357
    1356   fprintf (stdout, "---- input ----\n");
     1358#ifdef notdef
     1359  fprintf (stderr, "---- input ----\n");
    13571360  psMetadataPrint (stderr, input, 1);
    1358 
     1361#endif
     1362
     1363  if (!pxCheckImportVersion(config, input)) {
     1364      psError(PS_ERR_UNKNOWN, false, "pxCheckImportVersion failed");
     1365      return false;
     1366  }
    13591367  psMetadataItem *item = psMetadataLookup (input, "fakeRun");
    13601368  psAssert (item, "entry not in input?");

  • branches/simtest_nebulous_branches/ippTools/src/faketool.h

    r23339 r27840  
    4545    FAKETOOL_MODE_TOFULLIMFILE,
    4646    FAKETOOL_MODE_TOPURGEDIMFILE,
     47    FAKETOOL_MODE_TOSCRUBBEDIMFILE,
    4748    FAKETOOL_MODE_EXPORTRUN,
    4849    FAKETOOL_MODE_IMPORTRUN

  • branches/simtest_nebulous_branches/ippTools/src/faketoolConfig.c

    r24866 r27840  
    3939    config->modules = pmConfigRead(&argc, argv, NULL);
    4040    if (! config->modules) {
    41         psError(PS_ERR_UNKNOWN, false, "Can't find site configuration");
     41        psError(psErrorCodeLast(), false, "Can't find site configuration");
    4242        psFree(config);
    4343        return NULL;
    … …  
    4747    psMetadata *queueArgs = psMetadataAlloc();
    4848    // XXX need to allow multiple exp_ids
     49    psMetadataAddS64(queueArgs, PS_LIST_TAIL, "-cam_id",             0, "search by cam_id", 0);
     50    psMetadataAddS64(queueArgs, PS_LIST_TAIL, "-chip_id",            0, "search by chip_id", 0);
    4951    psMetadataAddS64(queueArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exp_id", 0);
    5052    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-exp_name",  0,            "search by exp_name", NULL);
    … …  
    9395    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_tess_id",  0,            "define tessellation identifier", NULL);
    9496    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_end_stage",  0,            "define end stage", NULL);
     97    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_dist_group",  0,           "define dist group", NULL);
     98    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_data_group",  0,           "define data group", NULL);
     99    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_note",  0,                 "define note", NULL);
    95100    psMetadataAddBool(queueArgs, PS_LIST_TAIL, "-pretend",  0,            "do not actually modify the database", false);
    96101    psMetadataAddBool(queueArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);
    … …  
    139144    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-sun_angle_min",  0,            "define min solar angle", NAN);
    140145    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-sun_angle_max",  0,            "define max solar angle", NAN);
     146    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0, "search by state", NULL);
    141147    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label", 0, "search by label", NULL);
     148    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-data_group", 0, "search by data_group", NULL);
     149    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-dist_group", 0, "search by data_group", NULL);
    142150
    143151    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state", 0,            "set state", NULL);
    144152    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_label", 0,            "set label", NULL);
    145     psMetadataAddBool(updaterunArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);
     153    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_data_group", 0,   "define new data_group", NULL);
     154    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_dist_group", 0,   "define new dist_group", NULL);
     155    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_note", 0,         "define new note", NULL);
    146156
    147157    // -pendingexp
    … …  
    301311    psMetadataAddStr(topurgedimfileArgs, PS_LIST_TAIL, "-class_id",  0,        "class ID to update", NULL);
    302312
     313    // -toscrubbedimfile
     314    psMetadata *toscrubbedimfileArgs = psMetadataAlloc();
     315    psMetadataAddS64(toscrubbedimfileArgs, PS_LIST_TAIL, "-fake_id", 0,         "fake ID to update", 0);
     316    psMetadataAddStr(toscrubbedimfileArgs, PS_LIST_TAIL, "-class_id", 0,        "class ID to update", NULL);
     317
    303318    // -exportrun
    304319    psMetadata *exportrunArgs = psMetadataAlloc();
    … …  
    337352    PXOPT_ADD_MODE("-tofullimfile",        "set imfile state to full",               FAKETOOL_MODE_TOFULLIMFILE,         tofullimfileArgs);
    338353    PXOPT_ADD_MODE("-topurgedimfile",      "set imfile state to purged",             FAKETOOL_MODE_TOPURGEDIMFILE,       topurgedimfileArgs);
     354    PXOPT_ADD_MODE("-toscrubbedimfile",    "set imfile state to scrubbed",           FAKETOOL_MODE_TOSCRUBBEDIMFILE,     toscrubbedimfileArgs);
    339355    PXOPT_ADD_MODE("-exportrun",            "export run for import on other database", FAKETOOL_MODE_EXPORTRUN, exportrunArgs);
    340356    PXOPT_ADD_MODE("-importrun",            "import run from metadata file",           FAKETOOL_MODE_IMPORTRUN, importrunArgs);

  • branches/simtest_nebulous_branches/ippTools/src/flatcorr.c

    r24140 r27840  
    3333#include "pxtools.h"
    3434#include "pxchip.h"
     35#include "pxcam.h"
     36#include "pxadd.h"
    3537#include "flatcorr.h"
    3638
    … …  
    3840static bool definerunMode(pxConfig *config);
    3941static bool addchipMode(pxConfig *config);
     42static bool dropchipMode(pxConfig *config);
    4043static bool addcameraMode(pxConfig *config);
    41 static bool dropchipMode(pxConfig *config);
    4244static bool dropcameraMode(pxConfig *config);
     45static bool advancecameraMode(pxConfig *config);
     46static bool advanceaddstarMode(pxConfig *config);
    4347static bool pendingprocessMode(pxConfig *config);
    4448static bool addprocessMode(pxConfig *config);
    … …  
    4650static bool inputexpMode(pxConfig *config);
    4751static bool inputimfileMode(pxConfig *config);
    48 static bool exportrunMode(pxConfig *config);
    49 static bool importrunMode(pxConfig *config);
    5052
    5153static bool setflatcorrRunState(pxConfig *config, psS64 corr_id, const char *state);
    … …  
    7274        MODECASE(FLATCORR_MODE_DEFINERUN,      definerunMode);
    7375        MODECASE(FLATCORR_MODE_ADDCHIP,        addchipMode);
     76        MODECASE(FLATCORR_MODE_DROPCHIP,       dropchipMode);
    7477        MODECASE(FLATCORR_MODE_ADDCAMERA,      addcameraMode);
    75         MODECASE(FLATCORR_MODE_DROPCHIP,       dropchipMode);
    7678        MODECASE(FLATCORR_MODE_DROPCAMERA,     dropcameraMode);
     79        MODECASE(FLATCORR_MODE_ADVANCECAMERA,  advancecameraMode);
     80        MODECASE(FLATCORR_MODE_ADVANCEADDSTAR, advanceaddstarMode);
    7781        MODECASE(FLATCORR_MODE_PENDINGPROCESS, pendingprocessMode);
    7882        MODECASE(FLATCORR_MODE_ADDPROCESS,     addprocessMode);
    … …  
    8084        MODECASE(FLATCORR_MODE_INPUTEXP,       inputexpMode);
    8185        MODECASE(FLATCORR_MODE_INPUTIMFILE,    inputimfileMode);
    82         MODECASE(FLATCORR_MODE_EXPORTRUN,      exportrunMode);
    83         MODECASE(FLATCORR_MODE_IMPORTRUN,      importrunMode);
    8486        default:
    8587            psAbort("invalid option (this should not happen)");
    … …  
    113115    if (!psListLength(where->list)) {
    114116        psFree(where);
    115         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
    116         return false;
    117     }
    118 
    119     // require the camera to be defined: this analysis does not make sense 
     117        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     118        return false;
     119    }
     120
     121    // require the camera to be defined: this analysis does not make sense
    120122    // across multiple cameras
    121123    PXOPT_LOOKUP_STR(camera, config->args, "-inst", true, false);
    … …  
    131133    PXOPT_LOOKUP_STR(tess_id, config->args, "-set_tess_id", false, false);
    132134    PXOPT_LOOKUP_STR(region, config->args, "-set_region", false, false);
     135    PXOPT_LOOKUP_BOOL(make_correction, config->args, "-make_correction", false);
     136    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
    133137
    134138    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
    … …  
    138142    psString query = pxDataGet("chiptool_find_rawexp.sql");
    139143    if (!query) {
    140         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     144        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    141145        psFree(where);
    142146        return false;
    … …  
    169173
    170174    if (pretend) {
    171         for (long i = 0; i < psArrayLength(output); i++) {
    172             // negative simple so the default is true
    173             if (!ippdbPrintMetadataRaw(stdout, output->data[i], !simple)) {
    174                 psError(PS_ERR_UNKNOWN, false, "failed to print array");
    175                 psFree(output);
    176                 return false;
    177             }
    178         }
     175        for (long i = 0; i < psArrayLength(output); i++) {
     176            // negative simple so the default is true
     177            if (!ippdbPrintMetadataRaw(stdout, output->data[i], !simple)) {
     178                psError(PS_ERR_UNKNOWN, false, "failed to print array");
     179                psFree(output);
     180                return false;
     181            }
     182        }
    179183        psFree(output);
    180184        return true;
    … …  
    191195    // create a new flatcorrRun
    192196    if (!flatcorrRunInsert(
    193             config->dbh,
     197            config->dbh,
    194198            0,      // corr_id
    195             det_type,
     199            det_type,
    196200            dvodb,
    197             camera,
    198             telescope,
    199             NULL,
     201            camera,
     202            telescope,
     203            NULL,
    200204            filter,
    201205            "reg",  // state
     206            make_correction,
    202207            workdir,
    203208            label,
    204209            reduction,
    205             region,
    206             NULL,
    207             0
     210            region,
     211            NULL,
     212            0
    208213        )) {
    209214        if (!psDBRollback(config->dbh)) {
    … …  
    233238
    234239        // queue the exp : force this to stop at the chip stage
    235         psS64 chip_id = pxchipQueueByExpTag(config, exp_id, workdir, label, reduction, expgroup, dvodb, tess_id, "chip");
     240        psS64 chip_id = pxchipQueueByExpTag(config, exp_id, workdir, label, label, NULL, reduction, expgroup, dvodb, tess_id, "chip", note);
    236241        if (!chip_id) {
    237242            if (!psDBRollback(config->dbh)) {
    … …  
    291296    PXOPT_LOOKUP_STR(tess_id, config->args, "-set_tess_id", false, false);
    292297    PXOPT_LOOKUP_STR(region, config->args, "-set_region", false, false);
     298    PXOPT_LOOKUP_BOOL(make_correction, config->args, "-make_correction", false);
    293299    // XXX probably should make the region in -set_region match ra_min, ra_max, etc
    294300
    … …  
    297303    // start a transaction so we don't end up with an exp without any associted
    298304    // imfiles
    299     if (!psDBTransaction(config->dbh)) {
    300         psError(PS_ERR_UNKNOWN, false, "database error");
    301         return false;
    302     }
     305    // if (!psDBTransaction(config->dbh)) {
     306    //     psError(PS_ERR_UNKNOWN, false, "database error");
     307    //     return false;
     308    // }
    303309
    304310    // create a new flatcorrRun
    305311    flatcorrRunRow *row = flatcorrRunRowAlloc(
    306         0,      // corr_id
    307         det_type,
    308         dvodb,
    309         camera,
    310         telescope,
    311         NULL,
    312         filter,
    313         "reg",  // state
    314         workdir,
    315         label,
    316         reduction,
    317         region,
    318         NULL, // hostname
    319         0 // fault
     312        0,      // corr_id
     313        det_type,
     314        dvodb,
     315        camera,
     316        telescope,
     317        NULL,
     318        filter,
     319        "reg",  // state
     320        make_correction,
     321        workdir,
     322        label,
     323        reduction,
     324        region,
     325        NULL, // hostname
     326        0 // fault
    320327        );
    321328
    … …  
    328335        return false;
    329336    }
    330    
     337
    331338    // figure out the ID of the flatcorrRun we just created
    332339    psS64 corr_id = psDBLastInsertID(config->dbh);
    333340    row->corr_id = corr_id;
    334341
     342    // if (!psDBCommit(config->dbh)) {
     343    //     psError(PS_ERR_UNKNOWN, false, "database error");
     344    //     return false;
     345    // }
     346
    335347    flatcorrRunPrintObject (stdout, row, !simple);
    336348    return true;
    … …  
    365377    psString query = pxDataGet("flatcorr_dropchip.sql");
    366378    if (!query) {
    367         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    368         return false;
     379        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     380        return false;
    369381    }
    370382
    371383    if (!p_psDBRunQueryF(config->dbh, query, (long long) corr_id, (long long) chip_id)) {
     384        psError(PS_ERR_UNKNOWN, false, "database error");
     385        psFree(query);
     386        return false;
     387    }
     388
     389    return true;
     390}
     391
     392static bool addcameraMode(pxConfig *config)
     393{
     394    PS_ASSERT_PTR_NON_NULL(config, false);
     395
     396    // required
     397    PXOPT_LOOKUP_S64(corr_id, config->args, "-corr_id", true, false);
     398    PXOPT_LOOKUP_S64(chip_id, config->args, "-chip_id", true, false);
     399    PXOPT_LOOKUP_S64(cam_id, config->args, "-cam_id", true, false);
     400
     401    // add a flatcorrCamLink (initial state has include = TRUE)
     402    // XXX should add checks that the chip_id and corr_id are in ChipLink
     403    if (!flatcorrCamLinkInsert(config->dbh, corr_id, chip_id, cam_id, 1)) {
     404        psError(PS_ERR_UNKNOWN, false, "database error");
     405        return false;
     406    }
     407
     408    return true;
     409}
     410
     411static bool dropcameraMode(pxConfig *config)
     412{
     413    PS_ASSERT_PTR_NON_NULL(config, false);
     414
     415    // required
     416    PXOPT_LOOKUP_S64(corr_id, config->args, "-corr_id", true, false);
     417    PXOPT_LOOKUP_S64(cam_id, config->args, "-cam_id", true, false);
     418
     419    // UPDATE flatcorrCamLink set include = 0 where corr_id = %lld AND cam_id = %lld
     420    psString query = pxDataGet("flatcorr_dropcamera.sql");
     421    if (!query) {
     422        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     423        return false;
     424    }
     425
     426    if (!p_psDBRunQueryF(config->dbh, query, (long long) corr_id, (long long) cam_id)) {
    372427        psError(PS_ERR_UNKNOWN, false, "database error");
    373428        psFree(query);
    … …  
    380435// select the flatcorr chip runs that have completed and for which there is no camera entry
    381436// queue a new camera run for them
    382 static bool addcameraMode(pxConfig *config)
     437static bool advancecameraMode(pxConfig *config)
    383438{
    384439    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    388443    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
    389444
     445    psMetadata *where = psMetadataAlloc();
     446    pxAddLabelSearchArgs (config, where, "-label", "flatcorrRun.label", "==");
     447
    390448    psString query = pxDataGet("flatcorr_chiprundone.sql");
    391449    if (!query) {
    392         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    393         return false;
    394     }
     450        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     451        return false;
     452    }
     453
     454    if (where && psListLength(where->list)) {
     455        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     456        psStringAppend(&query, " AND %s", whereClause);
     457        psFree(whereClause);
     458    }
     459    psFree(where);
    395460
    396461    // treat limit == 0 as "no limit"
    397462    if (limit) {
    398         psString limitString = psDBGenerateLimitSQL(limit);
    399         psStringAppend(&query, " %s", limitString);
    400         psFree(limitString);
     463        psString limitString = psDBGenerateLimitSQL(limit);
     464        psStringAppend(&query, " %s", limitString);
     465        psFree(limitString);
    401466    }
    402467
    … …  
    459524        // queue the exp
    460525        if (!pxcamQueueByChipID(
    461                 config,
    462                 row->chip_id,
    463                 row->workdir,
    464                 row->label,
    465                 row->reduction,
    466                 row->expgroup,
    467                 row->dvodb,
    468                 row->tess_id,
    469                 "camera")) {
     526                config,
     527                row->chip_id,
     528                row->workdir,
     529                row->label,
     530                row->data_group,
     531                row->dist_group,
     532                row->reduction,
     533                row->expgroup,
     534                row->dvodb,
     535                row->tess_id,
     536                "camera",
     537                row->magicked,
     538                NULL // note does not propragate
     539                )) {
    470540            if (!psDBRollback(config->dbh)) {
    471541                psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    478548        }
    479549
    480         // figure out the ID of the flatcorrRun we just created
    481         psS64 cam_id = psDBLastInsertID(config->dbh);
    482 
    483         // add the camRun entry to the flatcorrCamLink table (include is TRUE)
     550        // figure out the ID of the flatcorrRun we just created
     551        psS64 cam_id = psDBLastInsertID(config->dbh);
     552
     553        // add the camRun entry to the flatcorrCamLink table (include is TRUE)
    484554        if (!flatcorrCamLinkInsert(config->dbh, corr_id, row->chip_id, cam_id, 1)) {
    485555            if (!psDBRollback(config->dbh)) {
    … …  
    489559            return false;
    490560        }
    491        
     561
    492562        psFree(row);
    493563    }
    … …  
    502572}
    503573
    504 static bool dropcameraMode(pxConfig *config)
    505 {
    506     PS_ASSERT_PTR_NON_NULL(config, false);
    507 
    508     // required
    509     PXOPT_LOOKUP_S64(corr_id, config->args, "-corr_id", true, false);
    510     PXOPT_LOOKUP_S64(cam_id, config->args, "-cam_id", true, false);
    511 
    512     // UPDATE flatcorrCamLink set include = 0 where corr_id = %lld AND cam_id = %lld
    513     psString query = pxDataGet("flatcorr_dropcamera.sql");
    514     if (!query) {
    515         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    516         return false;
    517     }
    518 
    519     if (!p_psDBRunQueryF(config->dbh, query, (long long) corr_id, (long long) cam_id)) {
    520         psError(PS_ERR_UNKNOWN, false, "database error");
    521         psFree(query);
    522         return false;
    523     }
    524 
    525     return true;
    526 }
    527 
    528 // select the flatcorr chip runs that have completed and for which there is no camera entry
    529 // queue a new camera run for them
    530 static bool pendingprocessMode(pxConfig *config)
     574// Select the flatcorr camera runs that have completed and for which there is no addstar
     575// entry.  Queue a new addstar run for them
     576static bool advanceaddstarMode(pxConfig *config)
    531577{
    532578    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    534580    PXOPT_LOOKUP_BOOL(simple,  config->args, "-simple",  false);
    535581    PXOPT_LOOKUP_BOOL(limit,   config->args, "-limit",   false);
     582    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
    536583
    537584    psMetadata *where = psMetadataAlloc();
    538     pxAddLabelSearchArgs (config, where, "-label", "label", "==");
    539 
    540     psString query = pxDataGet("flatcorr_pendingprocess.sql");
     585    pxAddLabelSearchArgs (config, where, "-label", "flatcorrRun.label", "==");
     586
     587    psString query = pxDataGet("flatcorr_camerarundone.sql");
    541588    if (!query) {
    542         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    543         return false;
     589        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     590        return false;
    544591    }
    545592
    … …  
    553600    // treat limit == 0 as "no limit"
    554601    if (limit) {
    555         psString limitString = psDBGenerateLimitSQL(limit);
    556         psStringAppend(&query, " %s", limitString);
    557         psFree(limitString);
     602        psString limitString = psDBGenerateLimitSQL(limit);
     603        psStringAppend(&query, " %s", limitString);
     604        psFree(limitString);
    558605    }
    559606
    … …  
    575622    }
    576623
     624    if (pretend) {
     625        // negative simple so the default is true
     626        if (!ippdbPrintMetadatas(stdout, output, "flatcorr_addcamera", !simple)) {
     627            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     628            psFree(output);
     629            return false;
     630        }
     631    }
     632
     633    // start a transaction so we don't end up with an exp without any associted
     634    // imfiles
     635    if (!psDBTransaction(config->dbh)) {
     636        psError(PS_ERR_UNKNOWN, false, "database error");
     637        psFree(output);
     638        return false;
     639    }
     640
     641    // loop over our list of chipRun rows
     642    for (long i = 0; i < psArrayLength(output); i++) {
     643        psMetadata *md = output->data[i];
     644
     645        bool status;
     646        psS64 corr_id = psMetadataLookupS64(&status, md, "corr_id");
     647        if (!status) {
     648            if (!psDBRollback(config->dbh)) {
     649                psError(PS_ERR_UNKNOWN, false, "database error");
     650            }
     651            psError(PS_ERR_UNKNOWN, false, "failed to lookup value for corr_id");
     652            psFree(output);
     653            return false;
     654        }
     655
     656        camRunRow *row = camRunObjectFromMetadata(md);
     657        if (!row) {
     658            psError(PS_ERR_UNKNOWN, false, "failed to convert metadata into chipRun");
     659            psFree(output);
     660            return false;
     661        }
     662
     663        // queue the exp : force image_only to be false (flatcorr is meaningless with just image info)
     664        if (!pxaddQueueByCamID(
     665                config,
     666                row->cam_id,
     667                row->workdir,
     668                row->reduction,
     669                row->label,
     670                row->data_group,
     671                row->dvodb,
     672                NULL,       // note is not propagated
     673                0)) {
     674            if (!psDBRollback(config->dbh)) {
     675                psError(PS_ERR_UNKNOWN, false, "database error");
     676            }
     677            psError(PS_ERR_UNKNOWN, false,
     678                    "failed to trying to queue cam_id: %" PRId64, row->cam_id);
     679            psFree(row);
     680            psFree(output);
     681            return false;
     682        }
     683
     684        // figure out the ID of the flatcorrRun we just created
     685        psS64 add_id = psDBLastInsertID(config->dbh);
     686
     687        // add the addRun entry to the flatcorrAddstarLink table (include is TRUE)
     688        if (!flatcorrAddstarLinkInsert(config->dbh, corr_id, row->cam_id, add_id, 1)) {
     689            if (!psDBRollback(config->dbh)) {
     690                psError(PS_ERR_UNKNOWN, false, "database error");
     691            }
     692            psError(PS_ERR_UNKNOWN, false, "database error");
     693            return false;
     694        }
     695        psFree(row);
     696    }
     697    psFree(output);
     698
     699    if (!psDBCommit(config->dbh)) {
     700        psError(PS_ERR_UNKNOWN, false, "database error");
     701        return false;
     702    }
     703
     704    return false;
     705}
     706
     707// select the flatcorr chip runs that have completed and for which there is no camera entry
     708// queue a new camera run for them
     709static bool pendingprocessMode(pxConfig *config)
     710{
     711    PS_ASSERT_PTR_NON_NULL(config, false);
     712
     713    PXOPT_LOOKUP_BOOL(simple,  config->args, "-simple",  false);
     714    PXOPT_LOOKUP_BOOL(limit,   config->args, "-limit",   false);
     715
     716    psMetadata *where = psMetadataAlloc();
     717    pxAddLabelSearchArgs (config, where, "-label", "label", "==");
     718
     719    psString query = pxDataGet("flatcorr_pendingprocess.sql");
     720    if (!query) {
     721        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     722        return false;
     723    }
     724
     725    if (where && psListLength(where->list)) {
     726        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     727        psStringAppend(&query, " AND %s", whereClause);
     728        psFree(whereClause);
     729    }
     730    psFree(where);
     731
     732    // treat limit == 0 as "no limit"
     733    if (limit) {
     734        psString limitString = psDBGenerateLimitSQL(limit);
     735        psStringAppend(&query, " %s", limitString);
     736        psFree(limitString);
     737    }
     738
     739    if (!p_psDBRunQuery(config->dbh, query)) {
     740        psError(PS_ERR_UNKNOWN, false, "database error");
     741        psFree(query);
     742        return false;
     743    }
     744
     745    psArray *output = p_psDBFetchResult(config->dbh);
     746    if (!output) {
     747        psError(PS_ERR_UNKNOWN, false, "database error");
     748        return false;
     749    }
     750    if (!psArrayLength(output)) {
     751        psTrace("flatcorr", PS_LOG_INFO, "no rows found");
     752        psFree(output);
     753        return true;
     754    }
     755
    577756    if (!ippdbPrintMetadatas(stdout, output, "flatcorrPending", !simple)) {
    578         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    579         psFree(output);
    580         return false;
     757        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     758        psFree(output);
     759        return false;
     760    }
     761
     762    return true;
     763}
     764
     765// XXX need a fault state
     766static bool addprocessMode(pxConfig *config)
     767{
     768    PS_ASSERT_PTR_NON_NULL(config, false);
     769
     770    PXOPT_LOOKUP_S64(corr_id, config->args, "-corr_id", true, false);
     771    PXOPT_LOOKUP_STR(hostname, config->args, "-hostname", false, false);
     772    PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
     773
     774    char *query = "UPDATE flatcorrRun SET state = 'full', hostname = '%s', fault = '%hd' WHERE corr_id = %" PRId64;
     775
     776    if (!p_psDBRunQueryF(config->dbh, query, hostname, code, corr_id)) {
     777        psError(PS_ERR_UNKNOWN, false, "failed to change state for corr_id %" PRId64, corr_id);
     778        return false;
     779    }
     780
     781    return true;
     782}
     783
     784static bool updaterunMode(pxConfig *config)
     785{
     786    PS_ASSERT_PTR_NON_NULL(config, false);
     787
     788    PXOPT_LOOKUP_S64(corr_id, config->args, "-corr_id", true, false);
     789    PXOPT_LOOKUP_STR(state, config->args, "-state", true, false);
     790
     791    if (!setflatcorrRunState(config, corr_id, state)) {
     792        if (!psDBRollback(config->dbh)) {
     793            psError(PS_ERR_UNKNOWN, false, "database error");
     794        }
     795        psError(PS_ERR_UNKNOWN, false, "failed to set run state");
     796        return false;
    581797    }
    582798
    … …  
    598814    // treat limit == 0 as "no limit"
    599815    if (limit) {
    600         psString limitString = psDBGenerateLimitSQL(limit);
    601         psStringAppend(&query, " %s", limitString);
    602         psFree(limitString);
     816        psString limitString = psDBGenerateLimitSQL(limit);
     817        psStringAppend(&query, " %s", limitString);
     818        psFree(limitString);
    603819    }
    604820
    … …  
    621837
    622838    if (!ippdbPrintMetadatas(stdout, output, "flatcorrPending", !simple)) {
    623         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    624         psFree(output);
    625         return false;
     839        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     840        psFree(output);
     841        return false;
    626842    }
    627843
    … …  
    638854    PXOPT_LOOKUP_BOOL(simple,  config->args, "-simple",  false);
    639855    PXOPT_LOOKUP_BOOL(limit,   config->args, "-limit",   false);
    640    
     856
    641857    psMetadata *where = psMetadataAlloc();
    642858    PXOPT_COPY_S64(config->args, where, "-chip_id", "chipProcessedImfile.chip_id", "==");
    … …  
    644860    psString query = pxDataGet("flatcorr_inputimfile.sql");
    645861    if (!query) {
    646         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     862        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    647863        return false;
    648864    }
    … …  
    657873    // treat limit == 0 as "no limit"
    658874    if (limit) {
    659         psString limitString = psDBGenerateLimitSQL(limit);
    660         psStringAppend(&query, " %s", limitString);
    661         psFree(limitString);
     875        psString limitString = psDBGenerateLimitSQL(limit);
     876        psStringAppend(&query, " %s", limitString);
     877        psFree(limitString);
    662878    }
    663879
    … …  
    680896
    681897    if (!ippdbPrintMetadatas(stdout, output, "flatcorrPending", !simple)) {
    682         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    683         psFree(output);
    684         return false;
    685     }
    686 
    687     return true;
    688 }
    689 
    690 // XXX need a fault state
    691 static bool addprocessMode(pxConfig *config)
    692 {
    693     PS_ASSERT_PTR_NON_NULL(config, false);
    694 
    695     PXOPT_LOOKUP_S64(corr_id, config->args, "-corr_id", true, false);
    696     PXOPT_LOOKUP_STR(hostname, config->args, "-hostname", false, false);
    697     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    698 
    699     char *query = "UPDATE flatcorrRun SET state = 'full', hostname = '%s', fault = '%hd' WHERE corr_id = %" PRId64;
    700 
    701     if (!p_psDBRunQueryF(config->dbh, query, hostname, code, corr_id)) {
    702         psError(PS_ERR_UNKNOWN, false, "failed to change state for corr_id %" PRId64, corr_id);
    703         return false;
    704     }
    705 
    706     return true;
    707 }
    708 
    709 static bool updaterunMode(pxConfig *config)
    710 {
    711     PS_ASSERT_PTR_NON_NULL(config, false);
    712 
    713     PXOPT_LOOKUP_S64(corr_id, config->args, "-corr_id", true, false);
    714     PXOPT_LOOKUP_STR(state, config->args, "-state", true, false);
    715 
    716     if (!setflatcorrRunState(config, corr_id, state)) {
    717         if (!psDBRollback(config->dbh)) {
    718             psError(PS_ERR_UNKNOWN, false, "database error");
    719         }
    720         psError(PS_ERR_UNKNOWN, false, "failed to set run state");
     898        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     899        psFree(output);
    721900        return false;
    722901    }
    … …  
    731910
    732911    // check that state is a valid string value
    733     if (!strcmp(state, "reg") && 
    734         !strcmp(state, "new") &&
    735         !strcmp(state, "full"))
     912    if (!strcmp(state, "reg") &&
     913        !strcmp(state, "new") &&
     914        !strcmp(state, "full"))
    736915    {
    737916        psError(PS_ERR_UNKNOWN, false, "invalid state: %s", state);
    … …  
    748927    return true;
    749928}
    750 
    751 bool exportrunMode(pxConfig *config)
    752 {
    753   typedef struct ExportTable {
    754     char tableName[80];
    755     char sqlFilename[80];
    756   } ExportTable;
    757  
    758   int numExportTables = 3;
    759 
    760   PS_ASSERT_PTR_NON_NULL(config, NULL);
    761 
    762   PXOPT_LOOKUP_S64(det_id, config->args, "-corr_id", true,  false);
    763   PXOPT_LOOKUP_STR(outfile, config->args, "-outfile", true,  false);
    764   PXOPT_LOOKUP_U64(limit,   config->args, "-limit",   false, false);
    765 
    766   FILE *f = fopen (outfile, "w");
    767   if (f == NULL) {
    768     psError(PS_ERR_UNKNOWN, false, "failed to open output file");
    769     return false;
    770   }
    771 
    772   psMetadata *where = psMetadataAlloc();
    773   PXOPT_COPY_S64(config->args, where, "-corr_id", "corr_id", "==");
    774 
    775   ExportTable tables [] = {
    776     {"flatcorrRun", "flatcorr_export_run.sql"},
    777     {"flatcorrCamLink", "flatcorr_export_cam_link.sql"},
    778     {"flatcorrChipLink", "flatcorr_export_chip_link.sql"},
    779   };
    780 
    781   for (int i=0; i < numExportTables; i++) {
    782     psString query = pxDataGet(tables[i].sqlFilename);
    783     if (!query) {
    784       psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    785       return false;
    786     }
    787 
    788     if (where && psListLength(where->list)) {
    789       psString whereClause = psDBGenerateWhereSQL(where, NULL);
    790       psStringAppend(&query, " %s", whereClause);
    791       psFree(whereClause);
    792     }
    793 
    794     // treat limit == 0 as "no limit"
    795     if (limit) {
    796       psString limitString = psDBGenerateLimitSQL(limit);
    797       psStringAppend(&query, " %s", limitString);
    798       psFree(limitString);
    799     }
    800 
    801     if (!p_psDBRunQuery(config->dbh, query)) {
    802       psError(PS_ERR_UNKNOWN, false, "database error");
    803       psFree(query);
    804       return false;
    805     }
    806     psFree(query);
    807 
    808     psArray *output = p_psDBFetchResult(config->dbh);
    809     if (!output) {
    810       psError(PS_ERR_UNKNOWN, false, "database error");
    811       return false;
    812     }
    813     if (!psArrayLength(output)) {
    814       psTrace("regtool", PS_LOG_INFO, "no rows found");
    815       psFree(output);
    816       return true;
    817     }
    818 
    819     // we must write the export table in non-simple (true) format
    820     if (!ippdbPrintMetadatas(f, output, tables[i].tableName, true)) {
    821       psError(PS_ERR_UNKNOWN, false, "failed to print array");
    822       psFree(output);
    823       return false;
    824     }
    825     psFree(output);
    826   }
    827 
    828     fclose (f);
    829 
    830     return true;
    831 }
    832 
    833 bool importrunMode(pxConfig *config)
    834 {
    835   unsigned int nFail;
    836   psMetadataItem *item, *entry;
    837  
    838   int numImportTables = 3;
    839  
    840   char tables[3] [80] = {"flatcorrRun", "flatcorrCamLink", "flatcorrChipLink"};
    841 
    842   PS_ASSERT_PTR_NON_NULL(config, NULL);
    843  
    844   PXOPT_LOOKUP_STR(infile, config->args, "-infile", true,  false);
    845 
    846   psMetadata *input = psMetadataConfigRead (NULL, &nFail, infile, false);
    847 
    848   fprintf (stdout, "---- input ----\n");
    849   psMetadataPrint (stderr, input, 1);
    850 
    851   for (int i = 0; i < numImportTables; i++) {
    852     item = psMetadataLookup (input, tables[i]);
    853     psAssert (item, "entry not in input?");
    854     psAssert (item->type == PS_DATA_METADATA_MULTI, "entry not multi?");
    855    
    856     entry = psListGet (item->data.list, 0);
    857     assert (entry);
    858     assert (entry->type == PS_DATA_METADATA);
    859  
    860     switch (i) {
    861       case 0:
    862       {
    863         flatcorrRunRow *flatcorrRun = flatcorrRunObjectFromMetadata (entry->data.md);
    864         flatcorrRunInsertObject (config->dbh, flatcorrRun);
    865 
    866         // fprintf (stdout, "---- flatcorr run ----\n");
    867         // psMetadataPrint (stderr, entry->data.md, 1);
    868         break;
    869       }
    870       case 1:
    871       {
    872         flatcorrCamLinkRow *flatcorrCamLink = flatcorrCamLinkObjectFromMetadata (entry->data.md);
    873         flatcorrCamLinkInsertObject (config->dbh, flatcorrCamLink);
    874 
    875         // fprintf (stdout, "---- flatcorr cam link ----\n");
    876         // psMetadataPrint (stderr, entry->data.md, 1);
    877         break;
    878       }
    879       case 2:
    880       {
    881         flatcorrChipLinkRow *flatcorrChipLink = flatcorrChipLinkObjectFromMetadata (entry->data.md);
    882         flatcorrChipLinkInsertObject (config->dbh, flatcorrChipLink);
    883 
    884         // fprintf (stdout, "---- flatcorr chip link ----\n");
    885         // psMetadataPrint (stderr, entry->data.md, 1);
    886         break;
    887       }
    888     }
    889   }
    890   return true;
    891 }

  • branches/simtest_nebulous_branches/ippTools/src/flatcorr.h

    r23310 r27840  
    2828    FLATCORR_MODE_DEFINERUN,
    2929    FLATCORR_MODE_ADDCHIP,
     30    FLATCORR_MODE_DROPCHIP,
    3031    FLATCORR_MODE_ADDCAMERA,
    31     FLATCORR_MODE_DROPCHIP,
    3232    FLATCORR_MODE_DROPCAMERA,
     33    FLATCORR_MODE_ADVANCECAMERA,
     34    FLATCORR_MODE_ADVANCEADDSTAR,
    3335    FLATCORR_MODE_PENDINGPROCESS,
    3436    FLATCORR_MODE_ADDPROCESS,
    … …  
    3638    FLATCORR_MODE_INPUTEXP,
    3739    FLATCORR_MODE_INPUTIMFILE,
    38     FLATCORR_MODE_EXPORTRUN,
    39     FLATCORR_MODE_IMPORTRUN
    4040} flatcorrMode;
    4141

  • branches/simtest_nebulous_branches/ippTools/src/flatcorrConfig.c

    r24140 r27840  
    5959    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_tess_id",  0,            "define tessalation", NULL);
    6060    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_region",   0,            "define region", NULL);
     61    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-make_correction",  0,       "generate a correction image and add to detrend database", false);
    6162
    6263    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-pretend",  0,            "print the exposures that would be included in the detrend run and exit", false);
    … …  
    6566    // -definerun
    6667    psMetadata *definerunArgs = psMetadataAlloc();
     68    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-inst", 0, "define camera", NULL);
     69    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-telescope", 0, "define telescope", NULL);
    6770    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-det_type",     0,            "define detrend type to be generated", NULL);
    6871    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_workdir",  0,            "define workdir", NULL);
    … …  
    7477    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_tess_id",  0,            "define tessalation", NULL);
    7578    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_region",  0,            "define region", NULL);
     79    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-make_correction",  0,       "generate a correction image and add to detrend database", false);
    7680    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    7781
    … …  
    8892    // -addcamera
    8993    psMetadata *addcameraArgs = psMetadataAlloc();
    90     psMetadataAddU64 (addcameraArgs, PS_LIST_TAIL, "-limit",   0, "limit result set to N items", 0);
    91     psMetadataAddBool(addcameraArgs, PS_LIST_TAIL, "-simple",  0, "use the simple output format", false);
    92     psMetadataAddBool(addcameraArgs, PS_LIST_TAIL, "-pretend", 0, "use the simple output format", false);
     94    psMetadataAddS64(addcameraArgs, PS_LIST_TAIL, "-corr_id", 0,            "define Flat Correction ID (required)", 0);
     95    psMetadataAddS64(addcameraArgs, PS_LIST_TAIL, "-chip_id", 0,            "define Chip ID (required)", 0);
     96    psMetadataAddS64(addcameraArgs, PS_LIST_TAIL, "-cam_id", 0,             "define Camera ID (required)", 0);
    9397
    9498    // -dropcamera
    … …  
    96100    psMetadataAddS64(dropcameraArgs, PS_LIST_TAIL, "-corr_id", 0,      "define Flat Correction ID (required)", 0);
    97101    psMetadataAddS64(dropcameraArgs, PS_LIST_TAIL, "-cam_id", 0,       "define Camera ID (required)", 0);
     102
     103    // -advancecamera
     104    psMetadata *advancecameraArgs = psMetadataAlloc();
     105    psMetadataAddU64 (advancecameraArgs, PS_LIST_TAIL, "-limit",   0, "limit result set to N items", 0);
     106    psMetadataAddBool(advancecameraArgs, PS_LIST_TAIL, "-simple",  0, "use the simple output format", false);
     107    psMetadataAddBool(advancecameraArgs, PS_LIST_TAIL, "-pretend", 0, "use the simple output format", false);
     108    psMetadataAddStr(advancecameraArgs,  PS_LIST_TAIL, "-label",  PS_META_DUPLICATE_OK, "search by label", NULL);
     109
     110    // -advanceaddstar
     111    psMetadata *advanceaddstarArgs = psMetadataAlloc();
     112    psMetadataAddU64 (advanceaddstarArgs, PS_LIST_TAIL, "-limit",   0, "limit result set to N items", 0);
     113    psMetadataAddBool(advanceaddstarArgs, PS_LIST_TAIL, "-simple",  0, "use the simple output format", false);
     114    psMetadataAddBool(advanceaddstarArgs, PS_LIST_TAIL, "-pretend", 0, "use the simple output format", false);
     115    psMetadataAddStr(advanceaddstarArgs,  PS_LIST_TAIL, "-label",  PS_META_DUPLICATE_OK, "search by label", NULL);
    98116
    99117    // -pendingprocess
    … …  
    113131    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-corr_id", 0, "define correction id (required)", 0);
    114132    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state",   0, "set state (required)", NULL);
     133    // XXX add mechanism to change this value: psMetadataAddBool(updaterunArgs, PS_LIST_TAIL, "-set_correction",  0, "generate a correction image and add to detrend database", false);
    115134
    116135    // -inputexp
    … …  
    142161    psMetadata *modes = psMetadataAlloc();
    143162
    144     PXOPT_ADD_MODE("-definebyquery",  "create a new, populated flat correction run",       FLATCORR_MODE_DEFINEBYQUERY,  definebyqueryArgs);
    145     PXOPT_ADD_MODE("-definerun",      "create a new, empty flat correction run",           FLATCORR_MODE_DEFINERUN,      definerunArgs);
    146     PXOPT_ADD_MODE("-addchip",        "add a chip to a flat correction run",               FLATCORR_MODE_ADDCHIP,        addchipArgs);
    147     PXOPT_ADD_MODE("-addcamera",      "migrate completed chips to camera stage analysis", FLATCORR_MODE_ADDCAMERA,      addcameraArgs);
    148     PXOPT_ADD_MODE("-dropchip",       "drop a chip from a flat correction run",            FLATCORR_MODE_DROPCHIP,       dropchipArgs);
    149     PXOPT_ADD_MODE("-dropcamera",     "drop an exposure (camera stage analysis)",          FLATCORR_MODE_DROPCAMERA,     dropcameraArgs);
    150     PXOPT_ADD_MODE("-pendingprocess", "show flat correction runs needing to be processed", FLATCORR_MODE_PENDINGPROCESS, pendingprocessArgs);
    151     PXOPT_ADD_MODE("-addprocess",     "report completed flat correction analysis",         FLATCORR_MODE_ADDPROCESS,     addprocessArgs);
    152     PXOPT_ADD_MODE("-updaterun",      "change a flat calibration run's state",             FLATCORR_MODE_UPDATERUN,      updaterunArgs);
    153     PXOPT_ADD_MODE("-inputexp",       "list exposures for a correction run",               FLATCORR_MODE_INPUTEXP,       inputexpArgs);
    154     PXOPT_ADD_MODE("-inputimfile",    "list imfiles for a chip run",                       FLATCORR_MODE_INPUTIMFILE,    inputimfileArgs);
    155     PXOPT_ADD_MODE("-exportrun",            "export run for import on other database", FLATCORR_MODE_EXPORTRUN, exportrunArgs);
    156     PXOPT_ADD_MODE("-importrun",            "import run from metadata file",           FLATCORR_MODE_IMPORTRUN, importrunArgs);
     163    PXOPT_ADD_MODE("-definebyquery",  "create a new, populated flat correction run",         FLATCORR_MODE_DEFINEBYQUERY,  definebyqueryArgs);
     164    PXOPT_ADD_MODE("-definerun",      "create a new, empty flat correction run",             FLATCORR_MODE_DEFINERUN,      definerunArgs);
     165    PXOPT_ADD_MODE("-addchip",        "add an existing chip run to a flat correction run",   FLATCORR_MODE_ADDCHIP,        addchipArgs);
     166    PXOPT_ADD_MODE("-addcamera",      "add an existing camera run to a flat correction run", FLATCORR_MODE_ADDCAMERA,      addcameraArgs);
     167    PXOPT_ADD_MODE("-advancecamera",  "migrate completed chips to camera stage analysis",    FLATCORR_MODE_ADVANCECAMERA,  advancecameraArgs);
     168    PXOPT_ADD_MODE("-advanceaddstar", "migrate completed exposures to addstar processing",   FLATCORR_MODE_ADVANCEADDSTAR,  advanceaddstarArgs);
     169    PXOPT_ADD_MODE("-dropchip",       "drop a chip from a flat correction run",              FLATCORR_MODE_DROPCHIP,       dropchipArgs);
     170    PXOPT_ADD_MODE("-dropcamera",     "drop an exposure (camera stage analysis)",            FLATCORR_MODE_DROPCAMERA,     dropcameraArgs);
     171    PXOPT_ADD_MODE("-pendingprocess", "show flat correction runs needing to be processed",   FLATCORR_MODE_PENDINGPROCESS, pendingprocessArgs);
     172    PXOPT_ADD_MODE("-addprocess",     "report completed flat correction analysis",           FLATCORR_MODE_ADDPROCESS,     addprocessArgs);
     173    PXOPT_ADD_MODE("-updaterun",      "change a flat calibration run's state",               FLATCORR_MODE_UPDATERUN,      updaterunArgs);
     174    PXOPT_ADD_MODE("-inputexp",       "list exposures for a correction run",                 FLATCORR_MODE_INPUTEXP,       inputexpArgs);
     175    PXOPT_ADD_MODE("-inputimfile",    "list imfiles for a chip run",                         FLATCORR_MODE_INPUTIMFILE,    inputimfileArgs);
    157176
    158177    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • branches/simtest_nebulous_branches/ippTools/src/magicdstool.c

    r25015 r27840  
    3333
    3434static bool definebyqueryMode(pxConfig *config);
    35 static psS64 definerunMode(pxConfig *config);
     35static bool definecopyMode(pxConfig *config);
    3636static bool updaterunMode(pxConfig *config);
    3737static bool todestreakMode(pxConfig *config);
    3838static bool adddestreakedfileMode(pxConfig *config);
     39static bool advancerunMode(pxConfig *config);
    3940static bool revertdestreakedfileMode(pxConfig *config);
     41static bool clearstatefaultsMode(pxConfig *config);
    4042static bool getskycellsMode(pxConfig *config);
    4143static bool toremoveMode(pxConfig *config);
    42 static bool torestoreMode(pxConfig *config);
    4344static bool torevertMode(pxConfig *config);
    44 
    45 static bool setmagicDSRunState(pxConfig *config, psS64 magic_id, const char *state);
    46 static bool magicDSRunComplete(pxConfig *config, bool setmagicked);
    47 static bool magicDSGetIDs(pxConfig *config, psString stage, psS64 magic_id, psS64 *stage_id, psS64 *cam_id);
     45static bool completedrevertMode(pxConfig *config);
     46static bool tocleanupMode(pxConfig *config);
     47
     48static bool setmagicDSRunState(pxConfig *config, psS64 magic_id, psString extraSetString, psMetadata *where, const char *state);
    4849
    4950# define MODECASE(caseName, func) \
    … …  
    6667    switch (config->mode) {
    6768        MODECASE(MAGICDSTOOL_MODE_DEFINEBYQUERY,       definebyqueryMode);
    68         MODECASE(MAGICDSTOOL_MODE_DEFINERUN,           definerunMode);
     69        MODECASE(MAGICDSTOOL_MODE_DEFINECOPY,          definecopyMode);
    6970        MODECASE(MAGICDSTOOL_MODE_UPDATERUN,           updaterunMode);
    7071        MODECASE(MAGICDSTOOL_MODE_TODESTREAK,          todestreakMode);
    7172        MODECASE(MAGICDSTOOL_MODE_ADDDESTREAKEDFILE,   adddestreakedfileMode);
     73        MODECASE(MAGICDSTOOL_MODE_ADVANCERUN,          advancerunMode);
    7274        MODECASE(MAGICDSTOOL_MODE_REVERTDESTREAKEDFILE,revertdestreakedfileMode);
     75        MODECASE(MAGICDSTOOL_MODE_CLEARSTATEFAULTS,    clearstatefaultsMode);
    7376        MODECASE(MAGICDSTOOL_MODE_GETSKYCELLS,         getskycellsMode);
    7477        MODECASE(MAGICDSTOOL_MODE_TOREMOVE,            toremoveMode);
    75         MODECASE(MAGICDSTOOL_MODE_TORESTORE,           torestoreMode);
    7678        MODECASE(MAGICDSTOOL_MODE_TOREVERT,            torevertMode);
     79        MODECASE(MAGICDSTOOL_MODE_COMPLETEDREVERT,     completedrevertMode);
     80        MODECASE(MAGICDSTOOL_MODE_TOCLEANUP,           tocleanupMode);
    7781        default:
    7882            psAbort("invalid option (this should not happen)");
    … …  
    105109    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", false, false);
    106110    PXOPT_LOOKUP_STR(recoveryroot, config->args, "-recoveryroot", false, false);
    107     PXOPT_LOOKUP_BOOL(re_place, config->args, "-replace", false);
     111    PXOPT_LOOKUP_BOOL(noreplace, config->args, "-noreplace", false);
    108112    PXOPT_LOOKUP_STR(set_label, config->args, "-set_label", false, false);
     113    PXOPT_LOOKUP_STR(set_data_group, config->args, "-set_data_group", false, false);
     114    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
    109115    PXOPT_LOOKUP_BOOL(rerun, config->args, "-rerun", false);
    110     PXOPT_LOOKUP_BOOL(dry_run, config->args, "-dry_run", false);
     116    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
    111117    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    112118    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    119125    PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
    120126    PXOPT_COPY_S64(config->args, where, "-diff_id", "diff_id", "==");
    121     PXOPT_COPY_S64(config->args, where, "-magic_id","magic_id", "==");
     127    PXOPT_COPY_S64(config->args, where, "-magic_id","magicRun.magic_id", "==");
    122128    PXOPT_COPY_S32(config->args, where, "-streaks_max","streaks", "<=");
    123129
    124     pxAddLabelSearchArgs (config, where, "-label", "magicRun.label", "==");
     130    pxAddLabelSearchArgs (config, where, "-label", "magicRun.label", "=="); // define using magicRun label
    125131
    126132    ippStage stageNum = ippStringToStage(stage);
    127    
     133
    128134    psString query = NULL;
    129135    switch (stageNum) {
    … …  
    145151    case IPP_STAGE_FAKE:
    146152    case IPP_STAGE_STACK:
    147         psError(PXTOOLS_ERR_DATA, true, "%sRuns do not need to be destreaked", stage);
     153        psError(PXTOOLS_ERR_CONFIG, true, "%sRuns do not need to be destreaked", stage);
    148154        return false;
    149155    case IPP_STAGE_NONE:
    150         psError(PXTOOLS_ERR_DATA, true, "%s is not a valid stage", stage);
     156        psError(PXTOOLS_ERR_CONFIG, true, "%s is not a valid stage", stage);
    151157        return false;
    152158    default:
    … …  
    157163
    158164    if (!query) {
    159         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     165        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    160166        return false;
    161167    }
    … …  
    231237    // Parse the list of runs ready to be destreaked
    232238
    233     if (!dry_run && !psDBTransaction(config->dbh)) {
     239    if (!pretend && !psDBTransaction(config->dbh)) {
    234240        psError(PS_ERR_UNKNOWN, false, "database error");
    235241        return false;
    … …  
    245251        psS64 cam_id = psMetadataLookupS64(NULL, row, "cam_id");
    246252        psString magicRunLabel = psMetadataLookupStr(NULL, row, "label");
     253        psString magicRunDataGroup = psMetadataLookupStr(NULL, row, "data_group");
    247254        psString magicRunWorkdir = psMetadataLookupStr(NULL, row, "workdir");
    248        
     255
    249256        // if workdir is not supplied use the magicRun's
    250257        if (!workdir) {
    … …  
    266273                cam_id,
    267274                set_label ? set_label : magicRunLabel,
     275                set_data_group ? set_data_group : magicRunDataGroup,
    268276                outroot,
    269277                recoveryroot,
    270                 re_place,
    271                 0); // remove
     278                noreplace ? 0 :1,   // re_place
     279                0,      // remove
     280                0,      // fault
     281                note);  // remove
    272282
    273283        psFree(outroot);
    … …  
    276286        }
    277287
    278         if (!dry_run) {
     288        if (!pretend) {
    279289            if (!magicDSRunInsertObject(config->dbh, run)) {
    280290                psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    295305    }
    296306
    297     if (!dry_run && !psDBCommit(config->dbh)) {
     307    if (!pretend && !psDBCommit(config->dbh)) {
    298308        psError(PS_ERR_UNKNOWN, false, "database error");
    299309        return false;
    … …  
    312322}
    313323
    314 static psS64 definerunMode(pxConfig *config)
     324
     325// XXX This currently allows multiple destreak runs to be queued on the same exposure if there are multiple
     326// magicRuns selected!
     327static bool definecopyMode(pxConfig *config)
     328{
     329    // Required
     330    PXOPT_LOOKUP_STR(stage, config->args, "-stage", true, false);
     331    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false);
     332
     333    // Optional
     334    PXOPT_LOOKUP_STR(recoveryroot, config->args, "-recoveryroot", false, false);
     335    PXOPT_LOOKUP_BOOL(noreplace, config->args, "-noreplace", false);
     336    PXOPT_LOOKUP_STR(set_label, config->args, "-set_label", false, false);
     337    PXOPT_LOOKUP_STR(set_data_group, config->args, "-set_data_group", false, false);
     338    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
     339    PXOPT_LOOKUP_BOOL(rerun, config->args, "-rerun", false);
     340    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
     341    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     342    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     343
     344    // search args
     345    psMetadata *where = psMetadataAlloc();
     346    PXOPT_COPY_S64(config->args, where, "-exp_id",  "chipRun.exp_id", "==");
     347    PXOPT_COPY_S64(config->args, where, "-chip_id", "chipRun.chip_id", "==");
     348    PXOPT_COPY_S64(config->args, where, "-cam_id",  "camRun.cam_id", "==");
     349    PXOPT_COPY_S64(config->args, where, "-warp_id", "warpRun.warp_id", "==");
     350    PXOPT_COPY_S64(config->args, where, "-diff_id", "diffRun.diff_id", "==");
     351    PXOPT_COPY_S64(config->args, where, "-magic_id", "magicRun.magic_id", "==");
     352    PXOPT_COPY_S32(config->args, where, "-streaks_max", "magicMask.streaks", "<=");
     353
     354    pxAddLabelSearchArgs (config, where, "-magic_label", "magicRun.label", "=="); // define magic label
     355    psString labelName = NULL;                                                    // Name of label
     356    psStringAppend(&labelName, "%sRun.label", stage);
     357    pxAddLabelSearchArgs (config, where, "-stage_label", labelName, "=="); // define stageRun label
     358    psFree(labelName);
     359
     360    ippStage stageNum = ippStringToStage(stage);
     361
     362    psString query = NULL;
     363    switch (stageNum) {
     364      case IPP_STAGE_RAW:
     365        psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Raw stage is not appropriate for a copied destreak");
     366        return false;
     367      case IPP_STAGE_CHIP:
     368        query = pxDataGet("magicdstool_definecopy_chip.sql");
     369        break;
     370      case IPP_STAGE_WARP:
     371        query = pxDataGet("magicdstool_definecopy_warp.sql");
     372        break;
     373      case IPP_STAGE_CAMERA:
     374      case IPP_STAGE_DIFF:
     375      case IPP_STAGE_FAKE:
     376        psError(PS_ERR_BAD_PARAMETER_VALUE, true, "%s has not been coded.", stage);
     377        return false;
     378      case IPP_STAGE_STACK:
     379        psError(PXTOOLS_ERR_CONFIG, true, "Stacks do not need to be destreaked");
     380        return false;
     381      case IPP_STAGE_NONE:
     382        psError(PXTOOLS_ERR_CONFIG, true, "%s is not a valid stage", stage);
     383        return false;
     384      default:
     385        psError(PXTOOLS_ERR_PROG, true, "ippStageToString returned %d for invalid stage %s",
     386                stageNum, stage);
     387        return false;
     388    }
     389
     390    if (!query) {
     391        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     392        return false;
     393    }
     394    const char *rerun_flag =  rerun ? "" : "\n"; // String to give query to activate (or not) rerun
     395
     396    if (stageNum != IPP_STAGE_DIFF) {
     397        if (psListLength(where->list)) {
     398            psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     399            psStringAppend(&query, "\nAND %s", whereClause);
     400            psFree(whereClause);
     401        }
     402        psFree(where);
     403
     404        // treat limit == 0 as "no limit"
     405        if (limit) {
     406            psString limitString = psDBGenerateLimitSQL(limit);
     407            psStringAppend(&query, " %s", limitString);
     408            psFree(limitString);
     409        }
     410        if (!p_psDBRunQueryF(config->dbh, query, set_label, rerun_flag)) {
     411            psError(PS_ERR_UNKNOWN, false, "database error");
     412            psFree(query);
     413            return false;
     414        }
     415    } else {
     416        // diff stage query has two types bothways and !bothways
     417        // so we need to send the rerun flag and the where data twice
     418        psString whereString = psStringCopy("");
     419        if (psListLength(where->list)) {
     420            psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     421            psStringAppend(&whereString, "\nAND %s", whereClause);
     422            psFree(whereClause);
     423        }
     424        psFree(where);
     425
     426        // treat limit == 0 as "no limit"
     427        if (limit) {
     428            psString limitString = psDBGenerateLimitSQL(limit);
     429            psStringAppend(&query, " %s", limitString);
     430            psFree(limitString);
     431        }
     432
     433        if (!p_psDBRunQueryF(config->dbh, query, rerun_flag, whereString, rerun_flag, whereString)) {
     434            psError(PS_ERR_UNKNOWN, false, "database error");
     435            psFree(whereString);
     436            psFree(query);
     437            return false;
     438        }
     439        psFree(whereString);
     440    }
     441    psFree(query);
     442
     443    psArray *output = p_psDBFetchResult(config->dbh);
     444    if (!output) {
     445        psErrorCode err = psErrorCodeLast();
     446        switch (err) {
     447          case PS_ERR_DB_CLIENT:
     448            psError(PXTOOLS_ERR_SYS, false, "database error");
     449          case PS_ERR_DB_SERVER:
     450            psError(PXTOOLS_ERR_PROG, false, "database error");
     451          default:
     452            psError(PXTOOLS_ERR_PROG, false, "unknown error");
     453        }
     454
     455        return false;
     456    }
     457    if (!psArrayLength(output)) {
     458        psTrace("magictool", PS_LOG_INFO, "no rows found");
     459        psFree(output);
     460        return true;
     461    }
     462
     463    // Parse the list of runs ready to be destreaked
     464
     465    if (!pretend && !psDBTransaction(config->dbh)) {
     466        psError(PS_ERR_UNKNOWN, false, "database error");
     467        return false;
     468    }
     469
     470    psArray *list = psArrayAllocEmpty(16); // List of runs, to print
     471    for (long i = 0; i < psArrayLength(output); i++) {
     472        psMetadata *row = output->data[i]; // Row of interest
     473        psS64 stage_id = psMetadataLookupS64(NULL, row, "stage_id");
     474        psS64 exp_id = psMetadataLookupS64(NULL, row, "exp_id");
     475        psS64 magic_id = psMetadataLookupS64(NULL, row, "magic_id");
     476        psS64 inv_magic_id = psMetadataLookupS64(NULL, row, "inv_magic_id");
     477        psS64 cam_id = psMetadataLookupS64(NULL, row, "cam_id");
     478        psString magicRunLabel = psMetadataLookupStr(NULL, row, "label");
     479        psString magicRunDataGroup = psMetadataLookupStr(NULL, row, "data_group");
     480
     481        psString outroot = NULL;
     482        // set outroot to workdir/exp_id/stage for example /somewhere/424242/chip
     483        psStringAppend(&outroot, "%s/%" PRId64 "/%s", workdir, exp_id, stage);
     484
     485        // create a new magicRun for this group
     486        magicDSRunRow *run = magicDSRunRowAlloc(
     487                0, // magic_ds_id
     488                magic_id,
     489                inv_magic_id,
     490                "new",
     491                stage,
     492                stage_id,
     493                cam_id,
     494                set_label ? set_label : magicRunLabel,
     495                set_data_group ? set_data_group : magicRunDataGroup,
     496                outroot,
     497                recoveryroot,
     498                noreplace ? 0 :1,   // re_place
     499                0,      // remove
     500                0,      // fault
     501                note);  // remove
     502
     503        psFree(outroot);
     504        if (!run) {
     505            psAbort("failed to alloc magicDSRun object");
     506        }
     507
     508        if (!pretend) {
     509            if (!magicDSRunInsertObject(config->dbh, run)) {
     510                psError(PS_ERR_UNKNOWN, false, "database error");
     511                psFree(run);
     512                psFree(output);
     513                psFree(list);
     514                if (!psDBRollback(config->dbh)) {
     515                    psError(PS_ERR_UNKNOWN, false, "database error");
     516                }
     517                return false;
     518            }
     519            psS64 magic_ds_id = psDBLastInsertID(config->dbh); // Assigned identifier
     520            run->magic_ds_id = magic_ds_id;
     521        }
     522
     523        psArrayAdd(list, list->n, run);
     524        psFree(run);
     525    }
     526
     527    if (!pretend && !psDBCommit(config->dbh)) {
     528        psError(PS_ERR_UNKNOWN, false, "database error");
     529        return false;
     530    }
     531    psFree(output);
     532
     533    if (!magicDSRunPrintObjects(stdout, list, !simple)) {
     534        psError(PS_ERR_UNKNOWN, false, "failed to print object");
     535        psFree(list);
     536        return false;
     537    }
     538
     539    psFree(list);
     540
     541    return true;
     542}
     543
     544
     545static bool updaterunMode(pxConfig *config)
    315546{
    316547    PS_ASSERT_PTR_NON_NULL(config, false);
    317548
    318549    // required
    319     PXOPT_LOOKUP_S64(magic_id, config->args, "-magic_id", true, false);
     550    PXOPT_LOOKUP_STR(state, config->args, "-set_state", true, false);
     551
     552    // optional
     553    PXOPT_LOOKUP_STR(set_label, config->args, "-set_label", false, false);
     554    PXOPT_LOOKUP_STR(set_data_group, config->args, "-set_data_group", false, false);
     555    psString setString = NULL;
     556    if (set_label) {
     557        psStringAppend(&setString, ", label = '%s'", set_label);
     558    }
     559    if (set_data_group) {
     560        psStringAppend(&setString, ", data_group = '%s'", set_data_group);
     561    }
     562
     563    PXOPT_LOOKUP_S64(magic_ds_id, config->args, "-magic_ds_id", false, false);
     564    if (magic_ds_id) {
     565
     566        return setmagicDSRunState(config, magic_ds_id, setString, NULL, state);
     567
     568    } else if (!strcmp(state, "full")) {
     569        psError(PS_ERR_UNKNOWN, true, "magic_ds_id is required to update run state to full");
     570        return false;
     571    }
     572    // we can transition by query as well
     573
     574    psMetadata *where = psMetadataAlloc();
     575    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     576    PXOPT_COPY_S64(config->args, where, "-stage_id", "stage_id", "==");
     577    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
     578    PXOPT_COPY_STR(config->args, where, "-state", "state", "==");
     579    PXOPT_COPY_STR(config->args, where, "-data_group", "data_group", "LIKE");
     580
     581    if (psListLength(where->list) < 2) {
     582        psError(PS_ERR_UNKNOWN, true, "at least 2 search arguments are required");
     583        return false;
     584    }
     585
     586
     587    PXOPT_LOOKUP_BOOL(noreplace, config->args, "-noreplace", false);
     588    if (!noreplace) {
     589        psMetadataAddS32(where, PS_LIST_TAIL, "re_place", 0, ">", 0);
     590    }
     591    bool result = setmagicDSRunState(config, magic_ds_id, setString, where, state);
     592    psFree(where);
     593
     594    return result;
     595}
     596
     597
     598static bool todestreakMode(pxConfig *config)
     599{
     600    PS_ASSERT_PTR_NON_NULL(config, false);
     601
    320602    PXOPT_LOOKUP_STR(stage, config->args, "-stage", true, false);
    321     PXOPT_LOOKUP_STR(outroot, config->args, "-outroot", true, false);
    322 
    323     // optional
    324     PXOPT_LOOKUP_STR(recoveryroot, config->args, "-recoveryroot", false, false);
    325     PXOPT_LOOKUP_BOOL(re_place, config->args, "-replace", false);
    326     PXOPT_LOOKUP_BOOL(remove, config->args, "-remove", false);
    327     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    328     PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
    329 
    330     psS64 stage_id = 0, cam_id = 0;
    331 
    332     if (!magicDSGetIDs(config, stage, magic_id, &stage_id, &cam_id)) {
    333         psError(PS_ERR_UNKNOWN, false, "failed to get ids");
    334         return false;
    335     }
    336 
    337     magicDSRunRow *run = magicDSRunRowAlloc(
    338             0,          // ID
    339             magic_id,
    340             0,          // inv_magic_id
    341             "new",      // state
    342             stage,
    343             stage_id,
    344             cam_id,
    345             label,
    346             outroot,
    347             recoveryroot,
    348             re_place,
    349             remove
    350     );
    351 
    352     if (!run) {
    353         psError(PS_ERR_UNKNOWN, false, "failed to alloc magicRun object");
    354         return false;
    355     }
    356     if (!magicDSRunInsertObject(config->dbh, run)) {
    357         psError(PS_ERR_UNKNOWN, false, "database error");
    358         psFree(run);
    359         return false;
    360     }
    361 
    362     psS64 magic_ds_id = psDBLastInsertID(config->dbh);
    363     run->magic_ds_id = magic_ds_id;
    364 
    365     if (!magicDSRunPrintObject(stdout, run, !simple)) {
    366             psError(PS_ERR_UNKNOWN, false, "failed to print object");
    367             psFree(run);
    368             return false;
    369     }
    370 
    371     psFree(run);
    372 
    373     return magic_id;
    374 }
    375 
    376 
    377 static bool updaterunMode(pxConfig *config)
    378 {
    379     PS_ASSERT_PTR_NON_NULL(config, false);
    380 
    381     // required
    382     PXOPT_LOOKUP_S64(magic_ds_id, config->args, "-magic_ds_id", true, false);
    383     PXOPT_LOOKUP_STR(state, config->args, "-state", true, false);
    384 
    385     if (state) {
    386         // set detRun.state to state
    387         return setmagicDSRunState(config, magic_ds_id, state);
    388     }
    389 
    390     return true;
    391 }
    392 
    393 
    394 static bool todestreakMode(pxConfig *config)
    395 {
    396     PS_ASSERT_PTR_NON_NULL(config, false);
    397603
    398604    psMetadata *where = psMetadataAlloc();
    399     PXOPT_COPY_S64(config->args, where, "-magic_ds_id", "magic_ds_id", "==");
     605    PXOPT_COPY_S64(config->args, where, "-magic_ds_id", "magicDSRun.magic_ds_id", "==");
    400606    PXOPT_COPY_S64(config->args, where, "-magic_id", "magic_id", "==");
    401     pxAddLabelSearchArgs (config, where, "-label", "label", "==");
    402     PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
     607    pxAddLabelSearchArgs (config, where, "-label", "magicDSRun.label", "==");
    403608
    404609    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    405610    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    406611
    407     // look for "inputs" that need to processed
    408     psString query = pxDataGet("magicdstool_todestreak.sql");
     612    psString sql_file = NULL;
     613    psStringAppend(&sql_file, "magicdstool_todestreak_%s.sql", stage);
     614
     615    psString query = pxDataGet(sql_file);
    409616    if (!query) {
    410         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    411         return false;
    412     }
     617        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement from %s", sql_file);
     618        psFree(sql_file);
     619        return false;
     620    }
     621    psFree(sql_file);
    413622
    414623    if (psListLength(where->list)) {
    415624        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    416         psStringAppend(&query, " WHERE %s", whereClause);
     625        psStringAppend(&query, " AND %s", whereClause);
    417626        psFree(whereClause);
    418627    }
    … …  
    472681{
    473682    // first query the magicDSRun to find the stage and the stage_id
    474     psString query = "SELECT stage, stage_id from magicDSRun where magic_ds_id = %" PRId64;
     683    psString query = "SELECT stage, stage_id, magic_id from magicDSRun where magic_ds_id = %" PRId64;
    475684
    476685    if (!p_psDBRunQueryF(config->dbh, query, magic_ds_id)) {
    … …  
    499708    psString stage= psMetadataLookupStr(NULL, row, "stage");
    500709    psS64 stage_id = psMetadataLookupS64(NULL, row, "stage_id");
     710    psS64 magic_id = psMetadataLookupS64(NULL, row, "magic_id");
    501711
    502712    ippStage stageNum = ippStringToStage(stage);
    … …  
    526736    }
    527737
    528     if (!p_psDBRunQueryF(config->dbh, query, magic_ds_id, stage_id, component)) {
     738    if (!p_psDBRunQueryF(config->dbh, query, magic_id, stage_id, component)) {
    529739        psError(PS_ERR_UNKNOWN, false, "database error");
    530740        return false;
    … …  
    545755{
    546756    // first query the magicDSRun to find the stage and the stage_id
    547     psString query = "SELECT stage, stage_id from magicDSRun where magic_ds_id = %" PRId64;
     757    psString query = "SELECT stage, stage_id, magic_id from magicDSRun where magic_ds_id = %" PRId64;
    548758
    549759    if (!p_psDBRunQueryF(config->dbh, query, magic_ds_id)) {
    … …  
    572782    psString stage = psMetadataLookupStr(NULL, row, "stage");
    573783    psS64 stage_id = psMetadataLookupS64(NULL, row, "stage_id");
     784    psS64 magic_id = psMetadataLookupS64(NULL, row, "magic_id");
    574785
    575786    ippStage stageNum = ippStringToStage(stage);
    … …  
    597808        return false;
    598809    }
    599     if (!p_psDBRunQueryF(config->dbh, query, magic_ds_id, stage_id)) {
     810    if (!p_psDBRunQueryF(config->dbh, query, magic_id, stage_id)) {
    600811        psError(PS_ERR_UNKNOWN, false, "database error");
    601812        return false;
    … …  
    625836    PXOPT_LOOKUP_STR(recovery_path_base, config->args, "-recovery_path_base", false, false);
    626837    PXOPT_LOOKUP_BOOL(setmagicked, config->args, "-setmagicked", false);
     838    PXOPT_LOOKUP_F32(streak_frac, config->args, "-streak_frac", false, false);
     839    PXOPT_LOOKUP_F32(nondiff_frac, config->args, "-nondiff_frac", false, false);
     840    PXOPT_LOOKUP_F32(run_time, config->args, "-run_time", false, false);
    627841
    628842    if (setmagicked && (fault != 0)) {
    … …  
    647861    }
    648862
    649     if (!magicDSFileInsert(config->dbh, magic_ds_id, component, backup_path_base, recovery_path_base, fault, "full")) {
     863    if (!magicDSFileInsert(config->dbh,
     864            magic_ds_id,
     865            component,
     866            backup_path_base,
     867            recovery_path_base,
     868            streak_frac,
     869            nondiff_frac,
     870            run_time,
     871            fault,
     872            "full"  // data_state
     873        )) {
    650874            // rollback
    651875        if (!psDBRollback(config->dbh)) {
    … …  
    656880    }
    657881
    658     if (!magicDSRunComplete(config, setmagicked)) {
    659             // rollback
    660         if (!psDBRollback(config->dbh)) {
    661             psError(PS_ERR_UNKNOWN, false, "database error");
    662         }
    663         psError(PS_ERR_UNKNOWN, false, "database error");
    664         return false;
    665     }
    666 
    667882    if (!psDBCommit(config->dbh)) {
    668883        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    673888}
    674889
    675 static bool magicDSGetIDs(pxConfig *config, psString stage, psS64 magic_id, psS64 *stage_id, psS64 *cam_id)
     890
     891static bool advancerunMode(pxConfig *config)
    676892{
    677893    PS_ASSERT_PTR_NON_NULL(config, false);
    678     PS_ASSERT_PTR_NON_NULL(stage, false);
    679     PS_ASSERT_PTR_NON_NULL(stage_id, false);
    680     PS_ASSERT_PTR_NON_NULL(cam_id, false);
    681 
    682     int stageNum = ippStringToStage(stage);;
    683     if (stageNum == IPP_STAGE_NONE) {
    684         psError(PXTOOLS_ERR_DATA, false, "%s is not a valid value for stage", stage);
    685         return false;
    686     }
    687 
    688     psString query = pxDataGet("magicdstool_getrunids.sql");
    689     if (!query) {
    690         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    691         return false;
    692     }
    693 
    694     if (!p_psDBRunQueryF(config->dbh, query, magic_id)) {
    695         psError(PS_ERR_UNKNOWN, false, "database error");
    696         psFree(query);
    697         return false;
    698     }
    699     psFree(query);
    700 
    701     psArray *output = p_psDBFetchResult(config->dbh);
    702     if (!output) {
    703         psError(PS_ERR_UNKNOWN, false, "database error");
    704         return false;
    705     }
    706     if (!psArrayLength(output)) {
    707         psTrace("magicdstool", PS_LOG_INFO, "no rows found");
    708         psFree(output);
    709         return true;
    710     }
    711     if (psArrayLength(output) > 1) {
    712         psError(PS_ERR_UNKNOWN, true, "unexpected number of rows found %ld for magic_id %" PRId64,
    713             psArrayLength(output), magic_id);
    714         return false;
    715     }
    716     psMetadata *row = output->data[0];
    717 
    718     *cam_id = psMetadataLookupS64(NULL, row, "cam_id");
    719     switch (stageNum) {
    720     case IPP_STAGE_RAW:
    721         *stage_id = psMetadataLookupS64(NULL, row, "exp_id");
    722         break;
    723     case IPP_STAGE_CHIP:
    724         *stage_id = psMetadataLookupS64(NULL, row, "chip_id");
    725         break;
    726     case IPP_STAGE_CAMERA:
    727         *stage_id = *cam_id;
    728         return true;
    729     case IPP_STAGE_WARP:
    730         *stage_id = psMetadataLookupS64(NULL, row, "warp_id");
    731         break;
    732     case IPP_STAGE_DIFF:
    733         *stage_id = psMetadataLookupS64(NULL, row, "diff_id");
    734         break;
    735     }
    736 
    737     return true;
    738 }
    739 
    740 static bool magicDSRunComplete(pxConfig *config, bool setmagicked)
    741 {
    742     PS_ASSERT_PTR_NON_NULL(config, false);
     894
     895    psMetadata *where = psMetadataAlloc();
     896    PXOPT_COPY_S64(config->args, where, "-magic_ds_id", "magicDSRun.magic_ds_id", "==");
     897    pxAddLabelSearchArgs (config, where, "-label", "magicDSRun.label", "==");
     898
     899    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    743900
    744901    // look for completed magicDSRuns
    745902    psString query = pxDataGet("magicdstool_completed_runs.sql");
    746903    if (!query) {
    747         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    748         return false;
     904        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     905        return false;
     906    }
     907
     908    if (psListLength(where->list)) {
     909        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     910        psStringAppend(&query, " WHERE %s", whereClause);
     911        psFree(whereClause);
    749912    }
    750913
    … …  
    766929        return true;
    767930    }
     931    if (!psDBTransaction(config->dbh)) {
     932        psError(PS_ERR_UNKNOWN, false, "database error");
     933        return false;
     934    }
    768935    for (long i = 0; i < psArrayLength(output); i++) {
    769936        psMetadata *row = output->data[i];
    … …  
    771938        psS64 magic_ds_id = psMetadataLookupS64(NULL, row, "magic_ds_id");
    772939
    773         // if requested, set stageRun.magicked
     940        // if re_place, set stageRun.magicked
     941        bool setmagicked = psMetadataLookupBool(NULL, row, "re_place");
    774942        if (setmagicked && !setRunMagicked(config, magic_ds_id)) {
    775943            psError(PS_ERR_UNKNOWN, false, "failed to change stageRun.magicked for magic_ds_id: %" PRId64,
    776944                magic_ds_id);
     945            if (!psDBRollback(config->dbh)) {
     946                psError(PS_ERR_UNKNOWN, false, "database error");
     947            }
    777948            return false;
    778949        }
    779950
    780951        // set magicDSRun.state to 'full'
    781         if (!setmagicDSRunState(config, magic_ds_id, "full")) {
     952        if (!setmagicDSRunState(config, magic_ds_id, NULL, NULL, "full")) {
    782953            psError(PS_ERR_UNKNOWN, false, "failed to change magicDSRun.state for magic_ds_id: %" PRId64,
    783954                magic_ds_id);
    784955            psFree(output);
     956            if (!psDBRollback(config->dbh)) {
     957                psError(PS_ERR_UNKNOWN, false, "database error");
     958            }
    785959            return false;
    786960        }
    787961    }
    788 
     962    if (!psDBCommit(config->dbh)) {
     963        psError(PS_ERR_UNKNOWN, false, "database error");
     964        return false;
     965    }
    789966
    790967    return true;
    … …  
    795972{
    796973    PS_ASSERT_PTR_NON_NULL(config, false);
     974
     975    PXOPT_LOOKUP_BOOL(i_am_sure, config->args, "-i_am_sure", true);
     976    if (!i_am_sure) {
     977        psError(PS_ERR_UNKNOWN, true, "Reverting destreaked files must be done carefully. -i_am_sure is required.");
     978        return false;
     979    }
    797980
    798981    psMetadata *where = psMetadataAlloc();
    … …  
    802985    pxAddLabelSearchArgs (config, where, "-label", "label", "==");
    803986
    804     psString query = psStringCopy("DELETE FROM magicDSFile USING magicDSFile, magicDSRun  WHERE (magicDSRun.magic_ds_id = magicDSFile.magic_ds_id) AND magicDSFile.fault != 0");
     987    psString query = pxDataGet("magicdstool_revertdestreakedfile.sql");
    805988
    806989    if (psListLength(where->list)) {
    … …  
    808991        psStringAppend(&query, " AND %s", whereClause);
    809992        psFree(whereClause);
     993    } else {
     994        psError(PS_ERR_UNKNOWN, true, "search arguments are required");
     995        return false;
    810996    }
    811997    psFree(where);
    … …  
    813999    if (!p_psDBRunQuery(config->dbh, query)) {
    8141000        psError(PS_ERR_UNKNOWN, false, "failed to revert");
    815         return false;
    816     }
     1001        psFree(query);
     1002        return false;
     1003    }
     1004    psFree(query);
    8171005    return true;
    8181006}
    819 
    820 static bool getskycellsMode(pxConfig *config)
    821 {
    822     // required
    823     PXOPT_LOOKUP_S64(magic_ds_id, config->args, "-magic_ds_id", true, false);
     1007static bool clearstatefaultsMode(pxConfig *config)
     1008{
     1009    PS_ASSERT_PTR_NON_NULL(config, false);
    8241010
    8251011    psMetadata *where = psMetadataAlloc();
    826     PXOPT_COPY_STR(config->args, where, "-class_id",    "warpSkyCellMap.class_id", "==");
    827     PXOPT_COPY_STR(config->args, where, "-skycell_id",  "warpSkyCellMap.skycell_id", "==");
    828 
    829     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    830 
    831     psString query = pxDataGet("magicdstool_getskycells.sql");
    832     if (!query) {
    833         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    834         return false;
    835     }
     1012    // new state
     1013    PXOPT_LOOKUP_STR(new_state, config->args, "-set_state", false, false);
     1014    // old state (required)
     1015    PXOPT_LOOKUP_STR(state, config->args, "-state", true, false);
     1016
     1017    PXOPT_COPY_STR(config->args, where, "-state", "state", "==");
     1018    PXOPT_COPY_S64(config->args, where, "-magic_ds_id", "magicDSRun.magic_ds_id", "==");
     1019    PXOPT_COPY_S16(config->args, where, "-fault", "fault", "==");
     1020    pxAddLabelSearchArgs (config, where, "-label", "label", "==");
     1021
     1022    psString query = pxDataGet("magicdstool_clearstatefaults.sql");
    8361023
    8371024    if (psListLength(where->list)) {
    8381025        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    839         psStringAppend(&query, " AND %s", whereClause);
     1026        psStringAppend(&query, " WHERE %s", whereClause);
    8401027        psFree(whereClause);
     1028    } else {
     1029        psError(PS_ERR_UNKNOWN, true, "search arguments are required");
     1030        return false;
    8411031    }
    8421032    psFree(where);
    8431033
    844     if (!p_psDBRunQueryF(config->dbh, query, magic_ds_id)) {
    845         psError(PS_ERR_UNKNOWN, false, "database error");
     1034    if (!new_state) {
     1035        if (!strcmp(state, "failed_revert")) {
     1036            new_state = "new";
     1037        } else if (!strcmp(state, "failed_cleanup")) {
     1038            new_state = "goto_cleaned";
     1039        } else {
     1040            psError(PS_ERR_UNKNOWN, true, "unexpected value for state: %s", state);
     1041            return false;
     1042        }
     1043    }
     1044    if (!p_psDBRunQueryF(config->dbh, query, new_state)) {
     1045        psError(PS_ERR_UNKNOWN, false, "failed to revert");
    8461046        psFree(query);
    8471047        return false;
    8481048    }
    8491049    psFree(query);
    850 
     1050    return true;
     1051}
     1052
     1053static bool completedrevertMode(pxConfig *config)
     1054{
     1055    PS_ASSERT_PTR_NON_NULL(config, false);
     1056
     1057    psMetadata *where = psMetadataAlloc();
     1058    PXOPT_COPY_S64(config->args, where, "-magic_ds_id", "magicDSRun.magic_ds_id", "==");
     1059    pxAddLabelSearchArgs (config, where, "-label", "label", "==");
     1060
     1061    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1062
     1063    psString query = pxDataGet("magicdstool_completedrevert.sql");
     1064    // treat limit == 0 as "no limit"
     1065    if (limit) {
     1066        psString limitString = psDBGenerateLimitSQL(limit);
     1067        psStringAppend(&query, " %s", limitString);
     1068        psFree(limitString);
     1069    }
     1070
     1071    psString whereString = NULL;
     1072    if (psListLength(where->list)) {
     1073        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1074        psStringAppend(&whereString, "\nAND %s", whereClause);
     1075        psFree(whereClause);
     1076    }
     1077    psFree(where);
     1078
     1079    if (!p_psDBRunQueryF(config->dbh, query, whereString ? whereString : "")) {
     1080        psFree(whereString);
     1081        psError(PS_ERR_UNKNOWN, false, "failed to revert");
     1082        return false;
     1083    }
     1084    psFree(whereString);
     1085    psFree(query);
    8511086    psArray *output = p_psDBFetchResult(config->dbh);
    8521087    if (!output) {
    … …  
    8681103        return true;
    8691104    }
    870 
    871     if (psArrayLength(output)) {
    872         // negative simple so the default is true
    873         if (!ippdbPrintMetadatas(stdout, output, "magicDiffSkyfile", !simple)) {
    874             psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1105    for (int i=0; i<psArrayLength(output); i++) {
     1106        psMetadata *row = output->data[i];
     1107        psS64 magic_ds_id = psMetadataLookupS64(NULL, row, "magic_ds_id");
     1108        psString old_state = psMetadataLookupStr(NULL, row, "state");
     1109        psString new_state;
     1110        if (!strcmp(old_state, "goto_censored")) {
     1111            new_state = "censored";
     1112        } else if (!strcmp(old_state, "goto_restored")) {
     1113            new_state = "restored";
     1114        } else {
     1115            psError(PXTOOLS_ERR_PROG, true, "unexpected state found: %s", old_state);
    8751116            psFree(output);
    8761117            return false;
    8771118        }
    878     }
    879 
     1119        char *query2 = "UPDATE magicDSRun SET state = '%s' WHERE magic_ds_id = %" PRId64;
     1120        if (!p_psDBRunQueryF(config->dbh, query2, new_state, magic_ds_id)) {
     1121            psError(PS_ERR_UNKNOWN, false, "failed to set run magicDSRun.state to %s", new_state);
     1122            return false;
     1123        }
     1124    }
    8801125    psFree(output);
    8811126
    … …  
    8831128}
    8841129
    885 static bool setmagicDSRunState(pxConfig *config, psS64 magic_ds_id, const char *state)
    886 {
    887     PS_ASSERT_PTR_NON_NULL(state, false);
    888 
    889     // check that state is a valid string value
    890     if (!(
    891             (strncmp(state, "new", 4) == 0)
    892             || (strncmp(state, "full", 5) == 0)
    893         )
    894     ) {
    895         psError(PS_ERR_UNKNOWN, false,
    896                 "invalid magicDSRun state: %s", state);
    897         return false;
    898     }
    899 
    900     char *query = "UPDATE magicDSRun SET state = '%s' WHERE magic_ds_id = %" PRId64;
    901     if (!p_psDBRunQueryF(config->dbh, query, state, magic_ds_id)) {
    902         psError(PS_ERR_UNKNOWN, false,
    903                 "failed to change state for magic_id %" PRId64, magic_ds_id);
    904         return false;
    905     }
    906 
    907     return true;
    908 }
    909 
    910 static bool toremoveMode(pxConfig *config)
    911 {
    912     PS_ASSERT_PTR_NON_NULL(config, false);
     1130static bool getskycellsMode(pxConfig *config)
     1131{
     1132    // required
     1133    PXOPT_LOOKUP_S64(magic_ds_id, config->args, "-magic_ds_id", true, false);
    9131134
    9141135    psMetadata *where = psMetadataAlloc();
    915     PXOPT_COPY_S64(config->args, where, "-magic_ds_id", "magic_ds_id", "==");
    916     PXOPT_COPY_S64(config->args, where, "-magic_id", "magic_id", "==");
    917     pxAddLabelSearchArgs (config, where, "-label", "label", "==");
    918 
    919     PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1136    PXOPT_COPY_S64(config->args, where, "-magic_ds_id", "magicDSRun.magic_ds_id", "==");
     1137    PXOPT_COPY_STR(config->args, where, "-class_id",    "warpSkyCellMap.class_id", "==");
     1138    PXOPT_COPY_STR(config->args, where, "-skycell_id",  "warpSkyCellMap.skycell_id", "==");
     1139
    9201140    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    9211141
    922     // look for "inputs" that need to processed
    923     psString query = pxDataGet("magicdstool_toremove.sql");
     1142    psString query = pxDataGet("magicdstool_getskycells.sql");
    9241143    if (!query) {
    925         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    926         return false;
    927     }
    928 
     1144        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1145        return false;
     1146    }
     1147
     1148    psString whereClause = NULL;
    9291149    if (psListLength(where->list)) {
    930         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    931         psStringAppend(&query, " WHERE %s", whereClause);
    932         psFree(whereClause);
     1150        whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1151        psStringPrepend(&whereClause, "\n AND ");
    9331152    }
    9341153    psFree(where);
    9351154
    936     // treat limit == 0 as "no limit"
    937     if (limit) {
    938         psString limitString = psDBGenerateLimitSQL(limit);
    939         psStringAppend(&query, " %s", limitString);
    940         psFree(limitString);
    941     }
    942 
    943     if (!p_psDBRunQuery(config->dbh, query)) {
     1155    if (!p_psDBRunQueryF(config->dbh, query, whereClause, whereClause)) {
    9441156        psError(PS_ERR_UNKNOWN, false, "database error");
    9451157        psFree(query);
    … …  
    9701182    if (psArrayLength(output)) {
    9711183        // negative simple so the default is true
    972         if (!ippdbPrintMetadatas(stdout, output, "toremove", !simple)) {
     1184        if (!ippdbPrintMetadatas(stdout, output, "magicDiffSkyfile", !simple)) {
    9731185            psError(PS_ERR_UNKNOWN, false, "failed to print array");
    9741186            psFree(output);
    … …  
    9811193    return true;
    9821194}
    983 static bool torestoreMode(pxConfig *config)
     1195
     1196static bool validDSRunState(const char *state)
     1197{
     1198    if (!((strcmp(state, "new") == 0) ||
     1199          (strcmp(state, "full") == 0) ||
     1200          (strcmp(state, "drop") == 0) ||
     1201          (strcmp(state, "failed_revert") == 0) ||
     1202          (strcmp(state, "failed_cleanup") == 0) ||
     1203          (strcmp(state, "restored") == 0) ||
     1204          (strcmp(state, "censored") == 0) ||
     1205          (strcmp(state, "cleaned") == 0) ||
     1206          (strcmp(state, "goto_restored") == 0) ||
     1207          (strcmp(state, "goto_censored") == 0) ||
     1208          (strcmp(state, "goto_cleaned") == 0))
     1209        ) {
     1210        return false;
     1211    } else {
     1212        return true;
     1213    }
     1214}
     1215
     1216static bool setmagicDSRunState(pxConfig *config, psS64 magic_ds_id, psString extraSetStr, psMetadata *where, const char *state)
     1217{
     1218    PS_ASSERT_PTR_NON_NULL(state, false);
     1219
     1220    if (!validDSRunState(state)) {
     1221        psError(PS_ERR_UNKNOWN, false,
     1222                "invalid magicDSRun state: %s", state);
     1223        return false;
     1224    }
     1225
     1226    psString query = NULL;
     1227    psStringAppend(&query, "UPDATE magicDSRun SET state = '%s' %s\n", state, extraSetStr ? extraSetStr : "");
     1228    if (magic_ds_id) {
     1229        psStringAppend(&query, " WHERE magic_ds_id = %" PRId64, magic_ds_id);
     1230    } else if (where && psListLength(where->list)) {
     1231        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1232        psStringAppend(&query, " WHERE %s", whereClause);
     1233        psFree(whereClause);
     1234    } else {
     1235        psError(PS_ERR_UNKNOWN, true, "search arguments are required");
     1236        return false;
     1237    }
     1238
     1239    if (!strcmp(state, "goto_cleaned")) {
     1240        // Don't set state back to goto_cleaned if it is already cleaned
     1241        psStringAppend(&query, " AND (magicDSRun.state != 'cleaned')");
     1242
     1243        // don't clean up magicDSRun's where stage is camera
     1244        psStringAppend(&query, " AND (magicDSRun.stage != 'camera')");
     1245    }
     1246
     1247    if (!p_psDBRunQuery(config->dbh, query)) {
     1248        psError(PS_ERR_UNKNOWN, false,
     1249                "failed to change state for magic_id %" PRId64, magic_ds_id);
     1250        return false;
     1251    }
     1252
     1253    return true;
     1254}
     1255
     1256static bool toremoveMode(pxConfig *config)
    9841257{
    9851258    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    9941267
    9951268    // look for "inputs" that need to processed
    996     psString query = pxDataGet("magicdstool_torestore.sql");
     1269    psString query = pxDataGet("magicdstool_toremove.sql");
    9971270    if (!query) {
    998         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1271        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    9991272        return false;
    10001273    }
    … …  
    10431316    if (psArrayLength(output)) {
    10441317        // negative simple so the default is true
    1045         if (!ippdbPrintMetadatas(stdout, output, "torestore", !simple)) {
     1318        if (!ippdbPrintMetadatas(stdout, output, "toremove", !simple)) {
    10461319            psError(PS_ERR_UNKNOWN, false, "failed to print array");
    10471320            psFree(output);
    … …  
    10551328}
    10561329
    1057 
    10581330static bool torevertMode(pxConfig *config)
    10591331{
    … …  
    10751347    psString query = pxDataGet(sql_file);
    10761348    if (!query) {
    1077         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement from %s", sql_file);
     1349        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement from %s", sql_file);
    10781350        psFree(sql_file);
    10791351        return false;
    … …  
    11371409
    11381410
     1411static bool tocleanupMode(pxConfig *config)
     1412{
     1413    PS_ASSERT_PTR_NON_NULL(config, false);
     1414
     1415    psMetadata *where = psMetadataAlloc();
     1416
     1417    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
     1418    PXOPT_COPY_S64(config->args, where, "-magic_ds_id", "magic_ds_id", "==");
     1419    PXOPT_COPY_S64(config->args, where, "-magic_id", "magic_id", "==");
     1420    pxAddLabelSearchArgs (config, where, "-label", "magicDSRun.label", "==");
     1421
     1422    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1423    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1424
     1425    psString query = pxDataGet("magicdstool_tocleanup.sql");
     1426    if (!query) {
     1427        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1428        return false;
     1429    }
     1430
     1431    if (psListLength(where->list)) {
     1432        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1433        psStringAppend(&query, " AND %s", whereClause);
     1434        psFree(whereClause);
     1435    }
     1436    psFree(where);
     1437
     1438    // treat limit == 0 as "no limit"
     1439    if (limit) {
     1440        psString limitString = psDBGenerateLimitSQL(limit);
     1441        psStringAppend(&query, " %s", limitString);
     1442        psFree(limitString);
     1443    }
     1444
     1445    if (!p_psDBRunQuery(config->dbh, query)) {
     1446        psError(PS_ERR_UNKNOWN, false, "database error");
     1447        psFree(query);
     1448        return false;
     1449    }
     1450    psFree(query);
     1451
     1452    psArray *output = p_psDBFetchResult(config->dbh);
     1453    if (!output) {
     1454        psErrorCode err = psErrorCodeLast();
     1455        switch (err) {
     1456            case PS_ERR_DB_CLIENT:
     1457                psError(PXTOOLS_ERR_SYS, false, "database error");
     1458            case PS_ERR_DB_SERVER:
     1459                psError(PXTOOLS_ERR_PROG, false, "database error");
     1460            default:
     1461                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     1462        }
     1463
     1464        return false;
     1465    }
     1466    if (!psArrayLength(output)) {
     1467        psTrace("magicdstool", PS_LOG_INFO, "no rows found");
     1468        psFree(output);
     1469        return true;
     1470    }
     1471
     1472    if (psArrayLength(output)) {
     1473        // negative simple so the default is true
     1474        if (!ippdbPrintMetadatas(stdout, output, "tocleanup", !simple)) {
     1475            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1476            psFree(output);
     1477            return false;
     1478        }
     1479    }
     1480
     1481    psFree(output);
     1482
     1483    return true;
     1484}

  • branches/simtest_nebulous_branches/ippTools/src/magicdstool.h

    r24683 r27840  
    2626    MAGICDSTOOL_MODE_NONE           = 0x0,
    2727    MAGICDSTOOL_MODE_DEFINEBYQUERY,
    28     MAGICDSTOOL_MODE_DEFINERUN,
     28    MAGICDSTOOL_MODE_DEFINECOPY,
    2929    MAGICDSTOOL_MODE_UPDATERUN,
    3030    MAGICDSTOOL_MODE_TODESTREAK,
    3131    MAGICDSTOOL_MODE_ADDDESTREAKEDFILE,
     32    MAGICDSTOOL_MODE_ADVANCERUN,
    3233    MAGICDSTOOL_MODE_REVERTDESTREAKEDFILE,
     34    MAGICDSTOOL_MODE_CLEARSTATEFAULTS,
    3335    MAGICDSTOOL_MODE_GETSKYCELLS,
    3436    MAGICDSTOOL_MODE_TOREMOVE,
    35     MAGICDSTOOL_MODE_TORESTORE,
    3637    MAGICDSTOOL_MODE_TOREVERT,
     38    MAGICDSTOOL_MODE_COMPLETEDREVERT,
     39    MAGICDSTOOL_MODE_TOCLEANUP,
    3740} MAGICDStoolMode;
    3841

  • branches/simtest_nebulous_branches/ippTools/src/magicdstoolConfig.c

    r24937 r27840  
    4040    config->modules = pmConfigRead(&argc, argv, NULL);
    4141    if (!config->modules) {
    42         psError(PS_ERR_UNKNOWN, false, "Can't find site configuration");
     42        psError(psErrorCodeLast(), false, "Can't find site configuration");
    4343        psFree(config);
    4444        return NULL;
    … …  
    5252    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-workdir",     0, "define workdir", NULL);
    5353    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-recoveryroot", 0, "define recovery directory", NULL);
    54     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-replace", 0, "replace input files with the destreaked versions", false);
     54    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-noreplace", 0, "do not replace input files with the destreaked versions", false);
    5555    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_label",    0, "define label", NULL);
     56    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_data_group", 0, "define data_group", NULL);
     57    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_note", 0, "define note", NULL);
    5658
    5759    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by magicRun.label", NULL);
    … …  
    6466    psMetadataAddS32(definebyqueryArgs, PS_LIST_TAIL, "-streaks_max", 0, "maximum number of streaks", 0);
    6567
    66     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-rerun",   0, "queue a new run even if one arleady exists", false);
    67     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-dry_run", 0, "don't queue runs just display what would be queued", false);
     68    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-rerun",   0, "queue a new run even if one already exists", false);
     69    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-pretend", 0, "don't queue runs just display what would be queued", false);
    6870    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple",  0, "use the simple output format", false);
    6971    psMetadataAddU64(definebyqueryArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
    7072
    71     // -definerun
    72     psMetadata *definerunArgs = psMetadataAlloc();
    73     psMetadataAddS64(definerunArgs, PS_LIST_TAIL, "-magic_id", 0, "define magic_id (required)", 0);
    74     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-stage", 0, "define stage for run (required)", NULL);
    75     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-outroot", 0, "define output directory (required)", NULL);
    76     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-recoveryroot", 0, "define recovery directory", NULL);
    77     psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-replace", 0, "use the simple output format", false);
    78     psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-remove", 0, "use the simple output format", false);
    79     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-label", 0, "define label", NULL);
    80     psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     73    // -definecopy
     74    psMetadata *definecopyArgs = psMetadataAlloc();
     75    psMetadataAddStr(definecopyArgs, PS_LIST_TAIL, "-stage",       0, "define stage (required)", NULL);
     76    psMetadataAddStr(definecopyArgs, PS_LIST_TAIL, "-workdir",     0, "define workdir (required)", NULL);
     77    psMetadataAddStr(definecopyArgs, PS_LIST_TAIL, "-recoveryroot", 0, "define recovery directory", NULL);
     78    psMetadataAddBool(definecopyArgs, PS_LIST_TAIL, "-noreplace", 0, "do not replace input files with the destreaked versions", false);
     79    psMetadataAddStr(definecopyArgs, PS_LIST_TAIL, "-set_label",    0, "define label", NULL);
     80    psMetadataAddStr(definecopyArgs, PS_LIST_TAIL, "-set_data_group", 0, "define data_group", NULL);
     81    psMetadataAddStr(definecopyArgs, PS_LIST_TAIL, "-set_note", 0, "define note", NULL);
     82    psMetadataAddStr(definecopyArgs, PS_LIST_TAIL, "-stage_label", PS_META_DUPLICATE_OK, "search by stageRun.label", NULL);
     83    psMetadataAddStr(definecopyArgs, PS_LIST_TAIL, "-magic_label", PS_META_DUPLICATE_OK, "search by magicRun.label", NULL);
     84    psMetadataAddS64(definecopyArgs, PS_LIST_TAIL, "-exp_id",   0, "search by exp_id", 0);
     85    psMetadataAddS64(definecopyArgs, PS_LIST_TAIL, "-chip_id",  0, "search by chip_id", 0);
     86    psMetadataAddS64(definecopyArgs, PS_LIST_TAIL, "-cam_id",  0, "search by cam_id", 0);
     87    psMetadataAddS64(definecopyArgs, PS_LIST_TAIL, "-warp_id",  0, "search by warp_id", 0);
     88    psMetadataAddS64(definecopyArgs, PS_LIST_TAIL, "-diff_id",  0, "search by diff_id", 0);
     89    psMetadataAddS64(definecopyArgs, PS_LIST_TAIL, "-magic_id", 0, "search by magic_id", 0);
     90    psMetadataAddS32(definecopyArgs, PS_LIST_TAIL, "-streaks_max", 0, "maximum number of streaks", 0);
     91    psMetadataAddBool(definecopyArgs, PS_LIST_TAIL, "-rerun",   0, "queue a new run even if one already exists", false);
     92    psMetadataAddBool(definecopyArgs, PS_LIST_TAIL, "-pretend", 0, "don't queue runs just display what would be queued", false);
     93    psMetadataAddBool(definecopyArgs, PS_LIST_TAIL, "-simple",  0, "use the simple output format", false);
     94    psMetadataAddU64(definecopyArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
    8195
    8296    // -updaterun
    8397    psMetadata *updaterunArgs = psMetadataAlloc();
    84     psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-magic_ds_id", 0, "define magictool ID (required)", 0);
    85     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0, "set state (required)", NULL);
     98    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state", 0, "set state", NULL);
     99    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_label", 0, "set label", NULL);
     100    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_data_group", 0, "set data_group", NULL);
     101    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-magic_ds_id", 0, "define magictool ID", 0);
     102    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-stage",     0, "define stage", NULL);
     103    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state",     0, "define state", NULL);
     104    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-stage_id", 0, "define stage_id", 0);
     105    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label",     0, "define label", NULL);
     106    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-data_group",     0, "data_group (LIKE) comparision", NULL);
     107    psMetadataAddBool(updaterunArgs, PS_LIST_TAIL, "-noreplace", 0, "only update runs with replace not set", false);
    86108
    87109    // -addinputskyfile
    … …  
    93115    // -todestreak
    94116    psMetadata *todestreakArgs = psMetadataAlloc();
     117    psMetadataAddStr(todestreakArgs, PS_LIST_TAIL, "-stage", 0, "limit query to stage (required)", NULL);
    95118    psMetadataAddS64(todestreakArgs, PS_LIST_TAIL, "-magic_ds_id", 0, "search by magic Destreak ID", 0);
    96119    psMetadataAddS64(todestreakArgs, PS_LIST_TAIL, "-magic_id", 0, "search by magic ID", 0);
    97120    psMetadataAddStr(todestreakArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "define label", NULL);
    98     psMetadataAddStr(todestreakArgs, PS_LIST_TAIL, "-stage", 0, "limit query to stage", NULL);
    99121    psMetadataAddU64(todestreakArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
    100122    psMetadataAddBool(todestreakArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    … …  
    107129    psMetadataAddStr(adddestreakedfileArgs, PS_LIST_TAIL, "-recovery_path_base", 0, "define recovery pixels URI", NULL);
    108130    psMetadataAddBool(adddestreakedfileArgs, PS_LIST_TAIL, "-setmagicked", 0, "update the magicked state of the file", false);
     131    psMetadataAddF32(adddestreakedfileArgs, PS_LIST_TAIL, "-streak_frac", 0, "set fraction of pixels masked by streaks", 0);
     132    psMetadataAddF32(adddestreakedfileArgs, PS_LIST_TAIL, "-nondiff_frac", 0, "set fraction of pixels masked because nondiffed", 0);
     133    psMetadataAddF32(adddestreakedfileArgs, PS_LIST_TAIL, "-run_time", 0, "set the streaksremove run time for component ", 0);
    109134    psMetadataAddS16(adddestreakedfileArgs, PS_LIST_TAIL, "-fault", 0, "set fault code", 0);
    110135
    … …  
    114139    psMetadataAddStr(revertdestreakedfileArgs, PS_LIST_TAIL, "-component", 0, "search by component", NULL);
    115140    psMetadataAddS16(revertdestreakedfileArgs, PS_LIST_TAIL, "-fault", 0, "search by fault code", 0);
     141    psMetadataAddBool(revertdestreakedfileArgs, PS_LIST_TAIL, "-i_am_sure", 0, "confirm that you know what you are doing", false);
    116142    psMetadataAddStr(revertdestreakedfileArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "define label", NULL);
     143
     144    // -clearstatefaults
     145    psMetadata *clearstatefaultsArgs = psMetadataAlloc();
     146    psMetadataAddStr(clearstatefaultsArgs, PS_LIST_TAIL, "-set_state", 0, "new value for state", NULL);
     147    psMetadataAddStr(clearstatefaultsArgs, PS_LIST_TAIL, "-state", 0, "search by state (required)", NULL);
     148    psMetadataAddS64(clearstatefaultsArgs, PS_LIST_TAIL, "-magic_ds_id", 0, "search by magictool de-streak ID", 0);
     149    psMetadataAddS16(clearstatefaultsArgs, PS_LIST_TAIL, "-fault", 0, "search by fault code", 0);
     150    psMetadataAddStr(clearstatefaultsArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by label", NULL);
    117151
    118152    // -getskycells
    119153    psMetadata *getskycellsArgs = psMetadataAlloc();
    120     psMetadataAddS64(getskycellsArgs, PS_LIST_TAIL, "-magic_ds_id", 0, "define magic de-streak ID (required)", 0);
     154    psMetadataAddS64(getskycellsArgs, PS_LIST_TAIL, "-magic_ds_id", 0, "define magic de-streak ID", 0);
    121155    psMetadataAddStr(getskycellsArgs, PS_LIST_TAIL, "-class_id", 0, "define class identifier", NULL);
    122156    psMetadataAddStr(getskycellsArgs, PS_LIST_TAIL, "-skycell_id", 0, "define skycell identifier", NULL);
    … …  
    130164    psMetadataAddU64(toremoveArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
    131165    psMetadataAddBool(toremoveArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    132 
    133     // -torestore
    134     psMetadata *torestoreArgs = psMetadataAlloc();
    135     psMetadataAddS64(torestoreArgs, PS_LIST_TAIL, "-magic_ds_id", 0, "search by magic Destreak ID", 0);
    136     psMetadataAddS64(torestoreArgs, PS_LIST_TAIL, "-magic_id", 0, "search by magic ID", 0);
    137     psMetadataAddStr(torestoreArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "define label", NULL);
    138     psMetadataAddU64(torestoreArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
    139     psMetadataAddBool(torestoreArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    140166
    141167    // -torevert
    … …  
    148174    psMetadataAddBool(torevertArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    149175
     176    // -completedrevert
     177    psMetadata *completedrevertArgs = psMetadataAlloc();
     178    psMetadataAddS64(completedrevertArgs, PS_LIST_TAIL, "-magic_ds_id", 0, "search by magic Destreak ID", 0);
     179    psMetadataAddStr(completedrevertArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "define label", NULL);
     180    psMetadataAddU64(completedrevertArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
     181
     182    // -advancerun
     183    psMetadata *advancerunArgs = psMetadataAlloc();
     184    psMetadataAddS64(advancerunArgs, PS_LIST_TAIL, "-magic_ds_id", 0, "search by magic Destreak ID", 0);
     185    psMetadataAddStr(advancerunArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "define label", NULL);
     186    psMetadataAddU64(advancerunArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
     187
     188    // -tocleanup
     189    psMetadata *tocleanupArgs = psMetadataAlloc();
     190    psMetadataAddS64(tocleanupArgs, PS_LIST_TAIL, "-magic_ds_id", 0, "search by magic Destreak ID", 0);
     191    psMetadataAddS64(tocleanupArgs, PS_LIST_TAIL, "-magic_id", 0, "search by magic ID", 0);
     192    psMetadataAddStr(tocleanupArgs, PS_LIST_TAIL, "-stage", 0, "define output directory", NULL);
     193    psMetadataAddStr(tocleanupArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "define label", NULL);
     194    psMetadataAddU64(tocleanupArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
     195    psMetadataAddBool(tocleanupArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    150196    psFree(now);
    151197
    … …  
    155201    PXOPT_ADD_MODE("-definebyquery",       "create magic de-streak runs from magic runs",
    156202                    MAGICDSTOOL_MODE_DEFINEBYQUERY,     definebyqueryArgs);
    157     PXOPT_ADD_MODE("-definerun",           "create one magic de-streak run for one magic run",
    158                     MAGICDSTOOL_MODE_DEFINERUN,         definerunArgs);
     203    PXOPT_ADD_MODE("-definecopy",          "create magic de-streak runs from magic runs for different path",
     204                    MAGICDSTOOL_MODE_DEFINECOPY,     definecopyArgs);
    159205    PXOPT_ADD_MODE("-updaterun",           "update state of magic de-streak run",
    160206                    MAGICDSTOOL_MODE_UPDATERUN,         updaterunArgs);
    … …  
    163209    PXOPT_ADD_MODE("-adddestreakedfile",   "add a de-streaked file",
    164210                    MAGICDSTOOL_MODE_ADDDESTREAKEDFILE, adddestreakedfileArgs);
     211    PXOPT_ADD_MODE("-advancerun", "change state for runs that have finished destrreaking",
     212                    MAGICDSTOOL_MODE_ADVANCERUN, advancerunArgs);
    165213    PXOPT_ADD_MODE("-revertdestreakedfile", " revert a faulted de-streaked file",
    166214                    MAGICDSTOOL_MODE_REVERTDESTREAKEDFILE, revertdestreakedfileArgs);
     215    PXOPT_ADD_MODE("-clearstatefaults", " clear magicDSRuns in fault state",
     216                    MAGICDSTOOL_MODE_CLEARSTATEFAULTS, clearstatefaultsArgs);
    167217    PXOPT_ADD_MODE("-getskycells", "get skycell files ",
    168218                    MAGICDSTOOL_MODE_GETSKYCELLS, getskycellsArgs);
    169219    PXOPT_ADD_MODE("-toremove", "backup images pending removal",
    170220                    MAGICDSTOOL_MODE_TOREMOVE, toremoveArgs);
    171     PXOPT_ADD_MODE("-torestore", "images pending restore of exicsed streak pixels",
    172                     MAGICDSTOOL_MODE_TORESTORE, torestoreArgs);
    173     PXOPT_ADD_MODE("-torevert", "faulted images to revert",
     221    PXOPT_ADD_MODE("-torevert", "images to restore or revert",
    174222                    MAGICDSTOOL_MODE_TOREVERT, torevertArgs);
     223
     224    PXOPT_ADD_MODE("-completedrevert", "change state for runs that have finished reverting",
     225                    MAGICDSTOOL_MODE_COMPLETEDREVERT, completedrevertArgs);
     226    PXOPT_ADD_MODE("-tocleanup", "destreak runs to clean up",
     227                    MAGICDSTOOL_MODE_TOCLEANUP, tocleanupArgs);
     228
    175229
    176230    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • branches/simtest_nebulous_branches/ippTools/src/magictool.c

    r24949 r27840  
    114114    // Required
    115115    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", false, false);
     116    PXOPT_LOOKUP_STR(label, config->args, "-label", true, false);
    116117
    117118    // Optional
    118     PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
     119    PXOPT_LOOKUP_STR(data_group, config->args, "-data_group", false, false);
     120    PXOPT_LOOKUP_STR(note, config->args, "-note", false, false);
    119121    PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false);
    120122    PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    … …  
    133135        psString query = pxDataGet("magictool_definebyquery_select.sql");
    134136        if (!query) {
    135             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     137            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    136138            return false;
    137139        }
    … …  
    149151        // what if no skycells for the diff run completed?
    150152
    151         if (!rerun) {
    152             psStringAppend(&queryWhereStr, "\n%s magic_id IS NULL", queryWhereStr ? "AND" : "WHERE");
     153        psStringAppend(&queryWhereStr, "\n%s magic_id IS NULL", queryWhereStr ? "AND" : "WHERE");
     154        psString rerunWhereStr = NULL;
     155        if (rerun) {
     156            psStringAppend(&rerunWhereStr, "\n WHERE magicRun.label = '%s'", label);
    153157        }
    154158
    … …  
    174178            queryWhereStr = psStringCopy("");
    175179        }
    176 
    177         if (!p_psDBRunQueryF(config->dbh, query, diffWhereStr, diffWhereStr, queryWhereStr)) {
     180        if (!rerunWhereStr) {
     181            rerunWhereStr = psStringCopy("");
     182        }
     183
     184        if (!p_psDBRunQueryF(config->dbh, query, diffWhereStr, diffWhereStr, rerunWhereStr, queryWhereStr)) {
    178185            psError(PS_ERR_UNKNOWN, false, "database error");
    179186            psFree(diffWhereStr);
    180187            psFree(queryWhereStr);
     188            psFree(rerunWhereStr);
    181189            psFree(query);
    182190            return false;
    … …  
    184192        psFree(diffWhereStr);
    185193        psFree(queryWhereStr);
     194        psFree(rerunWhereStr);
    186195        psFree(query);
    187196    }
    … …  
    236245
    237246        // create a new magicRun for this group
    238         magicRunRow *run = magicRunRowAlloc(0, exp_id, diff_id, inverse, "new", workdir, "dirty", label,
    239                                             dvodb, registered, 0);
     247        magicRunRow *run = magicRunRowAlloc(0,
     248                                            exp_id,
     249                                            diff_id,
     250                                            inverse,
     251                                            "new",      // state
     252                                            workdir,
     253                                            "dirty",    // workdir_state
     254                                            label,
     255                                            data_group ? data_group : label,
     256                                            dvodb,
     257                                            registered,
     258                                            0,          // fault
     259                                            note);
    240260        if (!run) {
    241261            psAbort("failed to alloc magicRun object");
    … …  
    331351            "dirty",    // workdir_state
    332352            label,
     353            NULL,       // data_group
    333354            dvodb,
    334355            registered,
    335             0
     356            0,          // fault
     357            NULL
    336358    );
    337359
    … …  
    412434    psString query = pxDataGet("magictool_inputskyfile.sql");
    413435    if (!query) {
    414         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     436        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    415437        return false;
    416438    }
    … …  
    485507    psString query = pxDataGet("magictool_totree.sql");
    486508    if (!query) {
    487         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     509        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    488510        return false;
    489511    }
    … …  
    558580
    559581    if (fault > 0) {
    560         char *query = "UPDATE magicRun SET fault = %d, state = 'full' WHERE magic_id = %" PRId64;
     582        char *query = "UPDATE magicRun SET fault = %d WHERE magic_id = %" PRId64;
    561583        if (!p_psDBRunQueryF(config->dbh, query, fault, magic_id)) {
    562584            psError(PS_ERR_UNKNOWN, false,
    … …  
    597619        return false;
    598620    }
     621    psS32 numUpdated = psDBAffectedRows(config->dbh);
     622    psLogMsg("magictool", PS_LOG_INFO, "Reverted %d magic runs", numUpdated);
     623
    599624    return true;
    600625}
    … …  
    620645    psString query = pxDataGet("magictool_inputs.sql");
    621646    if (!query) {
    622         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     647        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    623648        return false;
    624649    }
    … …  
    790815    psString query = pxDataGet("magictool_toprocess_inputs.sql");
    791816    if (!query) {
    792         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     817        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    793818        return false;
    794819    }
    … …  
    852877
    853878    // look for tree nodes that need to be processed
     879
     880    // first find incomplete magicRuns
    854881    query = pxDataGet("magictool_toprocess_runs.sql");
    855882    if (!query) {
    856         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    857         return false;
    858     }
    859 
     883        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     884        return false;
     885    }
     886
     887    // we limit the query even though it is cheap (only magic_id is selected)
     888
     889    // XXX: if the first 1000 unfinished magicRuns have no ready nodes
     890    // that haven't faulted, later runs won't get returned even though
     891    // they have work to do. When we used a limit of 100 we actually ran
     892    // into this problem. Since we're using labels a limit of 1000 will
     893    // probably be ok.
    860894    {
    861         psString limitString = psDBGenerateLimitSQL( 100 );
     895        psString limitString = psDBGenerateLimitSQL( 1000 );
    862896        psStringAppend(&query, " %s", limitString);
    863897        psFree(limitString);
    … …  
    895929    query = pxDataGet("magictool_toprocess_tree.sql");
    896930    if (!query) {
    897         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     931        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    898932        return false;
    899933    }
    … …  
    908942            psAbort("failed to lookup value for magic_id column");
    909943        }
    910        
     944
    911945        whereString = NULL;
    912946        psStringAppend(&whereString, "\nAND (magic_id = %" PRId64 ")", magic_id);
    … …  
    10261060    PXOPT_COPY_S64(config->args, where, "-magic_id", "magic_id", "==");
    10271061    PXOPT_COPY_STR(config->args, where, "-node", "node", "==");
    1028     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
    10291062    PXOPT_COPY_S16(config->args, where, "-fault", "magicNodeResult.fault", "==");
     1063    pxAddLabelSearchArgs (config, where, "-label", "magicRun.label", "==");
    10301064
    10311065    psString query = pxDataGet("magictool_revertnode.sql");
    10321066    if (!query) {
    1033         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1067        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10341068        return false;
    10351069    }
    … …  
    10521086
    10531087    psS32 numUpdated = psDBAffectedRows(config->dbh);
    1054     psLogMsg("magictool", PS_LOG_INFO, "Updated %d magic nodes", numUpdated);
     1088    psLogMsg("magictool", PS_LOG_INFO, "Reverted %d magic nodes", numUpdated);
    10551089
    10561090    return true;
    … …  
    10681102    psString query = pxDataGet("magictool_tomask.sql");
    10691103    if (!query) {
    1070         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1104        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10711105        return false;
    10721106    }
    … …  
    11561190    psString query = pxDataGet("magictool_addmask.sql");
    11571191    if (!query) {
    1158         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1192        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11591193        if (!psDBRollback(config->dbh)) {
    11601194            psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    12631297    psString query = pxDataGet("magictool_mask.sql");
    12641298    if (!query) {
    1265         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1299        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    12661300        return false;
    12671301    }
    … …  
    13931427}
    13941428
    1395 static bool censorStage(pxConfig *config, psString stage, psString whereClause)
    1396 {
    1397     psString queryFile = NULL;
    1398     psStringAppend(&queryFile, "magictool_censor_%s.sql", stage);
    1399     psString query = pxDataGet(queryFile);
    1400     if (!query) {
    1401         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement from %s", queryFile);
    1402         psFree(queryFile);
    1403         if (!psDBRollback(config->dbh)) {
    1404             psError(PS_ERR_UNKNOWN, false, "database error");
    1405         }
    1406         return false;
    1407     }
    1408     psFree(queryFile);
    1409 
    1410     psStringAppend(&query, " WHERE %s",  whereClause);
    1411 
    1412     if (!p_psDBRunQuery(config->dbh, query)) {
    1413         psError(PS_ERR_UNKNOWN, false, "database error");
    1414         psFree(query);
    1415         if (!psDBRollback(config->dbh)) {
    1416             psError(PS_ERR_UNKNOWN, false, "database error");
    1417         }
    1418         return false;
    1419     }
    1420     psFree(query);
    1421 
    1422     return true;
    1423 }
    1424 
    14251429static bool censorrunMode(pxConfig *config)
    14261430{
    14271431    PS_ASSERT_PTR_NON_NULL(config, false);
    14281432
    1429     psError(PS_ERR_PROGRAMMING, true, "-censorrun mode not ready yet");
    1430     return false;
    1431 
    14321433    psMetadata *where = psMetadataAlloc();
     1434
     1435    PXOPT_LOOKUP_S64(magic_id, config->args, "-magic_id", false, false);
     1436    PXOPT_LOOKUP_S64(exp_id, config->args, "-exp_id", false, false);
     1437    PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
     1438
     1439    if (!magic_id) {
     1440        if (!exp_id && !label) {
     1441            psError(PS_ERR_UNKNOWN, true, "either -magic_id or exp_id and label is required");
     1442            return false;
     1443        }
     1444    }
    14331445
    14341446    // at least one of these required
    14351447    PXOPT_COPY_S64(config->args, where, "-magic_id", "magic_id", "==");
    14361448    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
     1449    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
    14371450
    14381451    if (!psListLength(where->list)) {
    … …  
    14701483    // Now queue any destreaked files to be re-verted
    14711484
    1472     // note: on failure censorStage issues the rollback
    1473     if (!censorStage(config, "raw", whereClause)) {
     1485    // note: on failure pxmagicRestoreStage issues the rollback
     1486    if (!pxmagicRestoreStage(config, "raw", whereClause, "goto_censored")) {
    14741487        psFree(whereClause);
    14751488        return false;
    14761489    }
    1477     if (!censorStage(config, "chip", whereClause)) {
     1490    if (!pxmagicRestoreStage(config, "chip", whereClause, "goto_censored")) {
    14781491        psFree(whereClause);
    14791492        return false;
    14801493    }
    1481     if (!censorStage(config, "camera", whereClause)) {
     1494    if (!pxmagicRestoreStage(config, "camera", whereClause, "goto_censored")) {
    14821495        psFree(whereClause);
    14831496        return false;
    14841497    }
    1485     if (!censorStage(config, "warp", whereClause)) {
     1498    if (!pxmagicRestoreStage(config, "warp", whereClause, "goto_censored")) {
    14861499        psFree(whereClause);
    14871500        return false;
    14881501    }
    1489     if (!censorStage(config, "diff", whereClause)) {
     1502    if (!pxmagicRestoreStage(config, "diff", whereClause, "goto_censored")) {
    14901503        psFree(whereClause);
    14911504        return false;

  • branches/simtest_nebulous_branches/ippTools/src/magictoolConfig.c

    r24946 r27840  
    4040    config->modules = pmConfigRead(&argc, argv, NULL);
    4141    if (!config->modules) {
    42         psError(PS_ERR_UNKNOWN, false, "Can't find site configuration");
     42        psError(psErrorCodeLast(), false, "Can't find site configuration");
    4343        psFree(config);
    4444        return NULL;
    … …  
    5050    psMetadata *definebyqueryArgs = psMetadataAlloc();
    5151    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-workdir",     0, "define workdir (required)", NULL);
    52     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label",       0, "define label", NULL);
     52    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label",       0, "define label (required)", NULL);
    5353    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-dvodb",       0, "define dvodb", NULL);
    5454    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-registered", 0, "time detrend run was registered", now);
     55    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-data_group",  0, "define data group", NULL);
     56    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-note",  0, "define note", NULL);
    5557    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-diff_id", 0, "search diff_id", 0);
    5658    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-exp_id", 0, "search exp_id", 0);
    … …  
    135137    psMetadataAddS64(revertnodeArgs, PS_LIST_TAIL, "-magic_id", 0, "search by magictool ID", 0);
    136138    psMetadataAddStr(revertnodeArgs, PS_LIST_TAIL, "-node", 0, "search by node name", NULL);
    137     psMetadataAddStr(revertnodeArgs, PS_LIST_TAIL, "-label",0, "search by label", NULL);
     139    psMetadataAddStr(revertnodeArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by label", NULL);
    138140    psMetadataAddS16(revertnodeArgs, PS_LIST_TAIL, "-fault", 0, "search by fault code", 0);
    139141
    … …  
    165167    psMetadataAddS64(censorrunArgs, PS_LIST_TAIL, "-magic_id", 0, "define magictool ID", 0);
    166168    psMetadataAddS64(censorrunArgs, PS_LIST_TAIL, "-exp_id", 0, "define exposure ID", 0);
     169    psMetadataAddStr(censorrunArgs, PS_LIST_TAIL, "-label",       0, "define label", NULL);
    167170
    168171    psFree(now);

  • branches/simtest_nebulous_branches/ippTools/src/pstamptool.c

    r25054 r27840  
    4444static bool pendingjobMode(pxConfig *config);
    4545static bool updatejobMode(pxConfig *config);
     46static bool revertjobMode(pxConfig *config);
    4647static bool addprojectMode(pxConfig *config);
    4748static bool projectMode(pxConfig *config);
    4849static bool modprojectMode(pxConfig *config);
     50static bool getdependentMode(pxConfig *config);
     51static bool pendingdependentMode(pxConfig *config);
     52static bool updatedependentMode(pxConfig *config);
     53static bool revertdependentMode(pxConfig *config);
    4954
    5055# define MODECASE(caseName, func) \
    … …  
    8085        MODECASE(PSTAMPTOOL_MODE_PENDINGJOB, pendingjobMode);
    8186        MODECASE(PSTAMPTOOL_MODE_UPDATEJOB, updatejobMode);
     87        MODECASE(PSTAMPTOOL_MODE_REVERTJOB, revertjobMode);
    8288        MODECASE(PSTAMPTOOL_MODE_ADDPROJECT, addprojectMode);
    8389        MODECASE(PSTAMPTOOL_MODE_MODPROJECT, modprojectMode);
    8490        MODECASE(PSTAMPTOOL_MODE_PROJECT, projectMode);
     91        MODECASE(PSTAMPTOOL_MODE_GETDEPENDENT, getdependentMode);
     92        MODECASE(PSTAMPTOOL_MODE_PENDINGDEPENDENT, pendingdependentMode);
     93        MODECASE(PSTAMPTOOL_MODE_UPDATEDEPENDENT, updatedependentMode);
     94        MODECASE(PSTAMPTOOL_MODE_REVERTDEPENDENT, revertdependentMode);
    8595        default:
    8696            psAbort("invalid option (this should not happen)");
    … …  
    108118    PS_ASSERT_PTR_NON_NULL(config, false);
    109119
    110     PXOPT_LOOKUP_STR(uri,         config->args, "-uri",           true, false);
    111     PXOPT_LOOKUP_STR(outProduct,  config->args, "-out_product",   true, false);
    112     PXOPT_LOOKUP_STR(lastFileset, config->args, "-last_fileset", false, false);
    113     PXOPT_LOOKUP_STR(state,       config->args, "-state",         false, false);
     120    PXOPT_LOOKUP_STR(uri,         config->args, "-set_uri",           true, false);
     121    PXOPT_LOOKUP_STR(outProduct,  config->args, "-set_out_product",   true, false);
     122    PXOPT_LOOKUP_STR(lastFileset, config->args, "-set_last_fileset", false, false);
     123    PXOPT_LOOKUP_STR(state,       config->args, "-set_state",         false, false);
     124    PXOPT_LOOKUP_STR(label,       config->args, "-set_label",         false, false);
     125    PXOPT_LOOKUP_S32(pollInterval, config->args, "-set_poll_interval",false, false);
    114126
    115127    if (!pstampDataStoreInsert(config->dbh,
    … …  
    117129            state,
    118130            lastFileset,
     131            NULL,       // timestamp
     132            label,      // label
    119133            outProduct,
    120             uri
     134            uri,
     135            pollInterval
    121136        )) {
    122137        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    134149    PXOPT_COPY_S64(config->args, where, "-ds_id", "ds_id", "==");
    135150
     151    PXOPT_LOOKUP_BOOL(ready, config->args, "-ready", false);
    136152    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    137153
    138154    psString query = pxDataGet("pstamptool_datastore.sql");
    139155    if (!query) {
    140         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     156        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    141157        return false;
    142158    }
    … …  
    148164    }
    149165    psFree(where);
     166    if (ready) {
     167        psStringAppend(&query, " %s", "\nAND TIMESTAMPDIFF(SECOND, timestamp, now()) > pollInterval");
     168    }
    150169
    151170    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    181200
    182201    PXOPT_LOOKUP_S64(ds_id,       config->args, "-ds_id",         true, false);
    183     PXOPT_LOOKUP_STR(lastFileset, config->args, "-last_fileset",  false, false);
    184     PXOPT_LOOKUP_STR(state,       config->args, "-state",         false, false);
    185 
    186     if (!state && !lastFileset) {
    187         psError(PS_ERR_UNKNOWN, true, "at least one of -last_fileset or -state is required");
    188         return false;
    189     }
    190 
    191     char *query = psStringCopy ("UPDATE pstampDataStore SET");
    192     bool needComma = false;
    193    
     202    PXOPT_LOOKUP_STR(lastFileset, config->args, "-set_last_fileset",  false, false);
     203    PXOPT_LOOKUP_STR(state,       config->args, "-set_state",         false, false);
     204    PXOPT_LOOKUP_STR(label,       config->args, "-set_label",         false, false);
     205    PXOPT_LOOKUP_S32(pollInterval, config->args, "-set_poll_interval",         false, false);
     206    PXOPT_LOOKUP_BOOL(update_timestamp, config->args, "-update_timestamp", false);
     207
     208    if (!state && !lastFileset && !pollInterval && !update_timestamp && !label) {
     209        psError(PS_ERR_UNKNOWN, true, "at least one of -last_fileset or -set_state is required");
     210        return false;
     211    }
     212
     213    char *query = psStringCopy ("UPDATE pstampDataStore SET timestamp = CURRENT_TIMESTAMP() ");
     214
    194215    if (lastFileset) {
    195         psStringAppend(&query, " lastFileset = '%s'", lastFileset);
    196         needComma = true;
     216        psStringAppend(&query, " , lastFileset = '%s'", lastFileset);
    197217    }
    198218
    199219    if (state) {
    200         psStringAppend(&query, "%s state = '%s'", needComma ? "," : " ", state);
    201         needComma = true; // be ready in case we add another field
    202     }
    203                
     220        psStringAppend(&query, ", state = '%s'", state);
     221    }
     222
     223    if (label) {
     224        psStringAppend(&query, ", label = '%s'", label);
     225    }
     226
     227    if (pollInterval) {
     228        psStringAppend(&query, ", pollInterval = %d", pollInterval);
     229    }
     230
    204231    psStringAppend(&query, " WHERE ds_id = %" PRId64, ds_id);
    205232
    … …  
    212239    psU64 affected = psDBAffectedRows(config->dbh);
    213240    if (affected != 1) {
    214         psError(PS_ERR_UNKNOWN, false, "should have affected one row but %" 
     241        psError(PS_ERR_UNKNOWN, false, "should have affected one row but %"
    215242                                        PRIu64 " rows were modified", affected);
    216243        return false;
    … …  
    224251    PS_ASSERT_PTR_NON_NULL(config, false);
    225252
    226     PXOPT_LOOKUP_STR(uri,         config->args, "-uri",           true, false);
    227     // PXOPT_LOOKUP_STR(outFileset,  config->args, "-out_fileset",   true, false);
    228     PXOPT_LOOKUP_S64(ds_id,       config->args, "-ds_id",         false, false);
    229 
    230     char *query ="INSERT INTO pstampRequest"
    231                      " (state, uri, ds_id, fault)"
    232                      " VALUES( 'new', '%s', %" PRId64 ", 0 )";
    233     if (!p_psDBRunQueryF(config->dbh, query, uri, ds_id)) {
    234         psError(PS_ERR_UNKNOWN, false, "database error");
    235         return false;
    236     }
    237 
    238     psU64 affected = psDBAffectedRows(config->dbh);
    239     if (affected != 1) {
    240         psError(PS_ERR_UNKNOWN, false,
    241             "should have affected one row but %" PRIu64 " rows were modified",
    242             affected);
     253    PXOPT_LOOKUP_STR(uri,         config->args, "-uri",   true, false);
     254    PXOPT_LOOKUP_STR(name,        config->args, "-name",  false, false);
     255    PXOPT_LOOKUP_STR(label,       config->args, "-label",  false, false);
     256    PXOPT_LOOKUP_S64(ds_id,       config->args, "-ds_id", false, false);
     257
     258    if (!pstampRequestInsert(config->dbh,
     259        0,      // req_id
     260        ds_id,
     261        "new",  //state
     262        name,
     263        NULL,   // reqType
     264        label,
     265        NULL,   // outProduct
     266        uri,
     267        0       // fault
     268        )) {
     269        psError(PS_ERR_UNKNOWN, false, "failed to insert request");
    243270        return false;
    244271    }
    … …  
    257284    psMetadata *where = psMetadataAlloc();
    258285    PXOPT_COPY_S64(config->args, where, "-req_id", "req_id", "==");
     286    pxAddLabelSearchArgs(config, where, "-label", "label", "LIKE");
    259287
    260288    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    263291    psString query = pxDataGet("pstamptool_pendingreq.sql");
    264292    if (!query) {
    265         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     293        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    266294        return false;
    267295    }
    … …  
    315343    PS_ASSERT_PTR_NON_NULL(config, false);
    316344
    317     PXOPT_LOOKUP_S64(req_id,  config->args, "-req_id", true, false);
     345    psMetadata *where = psMetadataAlloc();
     346    PXOPT_COPY_S64(config->args, where, "-req_id", "req_id", "==");
     347    PXOPT_COPY_S64(config->args, where, "-not_req_id", "req_id", "!=");
     348    PXOPT_COPY_STR(config->args, where, "-name", "name", "==");
     349
    318350    PXOPT_LOOKUP_U64(limit,   config->args, "-limit",  false, false);
    319351    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    320352
    321     psString query = NULL;
    322     psStringAppend(&query, "SELECT * from pstampRequest WHERE req_id = %" PRId64, req_id);
    323    
     353    if (!psListLength(where->list)) {
     354        psError(PS_ERR_UNKNOWN, true, "-req_id or -name must be supplied");
     355        return false;
     356    }
     357
     358    psString query = psStringCopy("SELECT * from pstampRequest");
     359
     360    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     361    psStringAppend(&query, " WHERE %s", whereClause);
     362    psFree(whereClause);
     363    psFree(where);
     364
    324365    // treat limit == 0 as "no limit"
    325366    if (limit) {
    … …  
    342383    }
    343384    if (!psArrayLength(output)) {
    344         psTrace("pstamptool", PS_LOG_INFO, "no rows found");
    345         psFree(output);
    346         return true;
     385        psTrace("pstamptool", PS_LOG_INFO, "request not found");
     386        // This causes main to exit with PS_EXIT_DATA_ERROR which the script is looking for
     387        psError(PXTOOLS_ERR_CONFIG, true, "request not found");
     388        psFree(output);
     389        // we return false so that the caller can determine that a request does not exist
     390        return false;
    347391    }
    348392
    … …  
    363407    PS_ASSERT_PTR_NON_NULL(config, false);
    364408
     409    psMetadata *where = psMetadataAlloc();
     410    pxAddLabelSearchArgs(config, where, "-label", "label", "LIKE");
     411
    365412    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    366413    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    367414
    368     psString query =
    369         "SELECT * FROM pstampRequest WHERE state = 'run' AND "
    370             "(SELECT count(*) FROM pstampJob WHERE pstampJob.req_id = pstampRequest.req_id "
    371             " AND pstampJob.state != 'stop') = 0" ;
     415    psString query = pxDataGet("pstamptool_completedreq.sql");
     416
     417    if (psListLength(where->list)) {
     418        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     419        psStringAppend(&query, " AND %s", whereClause);
     420        psFree(whereClause);
     421    }
     422    psFree(where);
    372423
    373424    // treat limit == 0 as "no limit"
    … …  
    415466    PXOPT_LOOKUP_STR(state,      config->args, "-state",      false, false);
    416467    PXOPT_LOOKUP_STR(outProduct, config->args, "-outProduct", false, false);
    417     PXOPT_LOOKUP_STR(fault,      config->args, "-fault",      false, false);
    418     PXOPT_LOOKUP_STR(uri,       config->args, "-uri",        false, false);
    419     PXOPT_LOOKUP_STR(name,      config->args, "-name",       false, false);
     468    PXOPT_LOOKUP_S16(fault,      config->args, "-fault",      false, false);
     469    PXOPT_LOOKUP_STR(uri,       config->args, "-uri",        false, false);
     470    PXOPT_LOOKUP_STR(name,      config->args, "-name",       false, false);
    420471    PXOPT_LOOKUP_STR(reqType,    config->args, "-reqType",    false, false);
    421472
    … …  
    433484    }
    434485    if (fault) {
    435         psStringAppend(&query, "%c fault = %s", c, fault);
     486        psStringAppend(&query, "%c fault = %d", c, fault);
    436487        c = ',';
    437488    }
    … …  
    464515    // note zero is not an error
    465516    if (affected > 1) {
    466         psError(PS_ERR_UNKNOWN, false, "should have affected one row but %" 
     517        psError(PS_ERR_UNKNOWN, false, "should have affected one row but %"
    467518                                        PRIu64 " rows were modified", affected);
    468519        return false;
    … …  
    476527    PS_ASSERT_PTR_NON_NULL(config, false);
    477528
    478     PXOPT_LOOKUP_S64(req_id,     config->args, "-req_id",     true, false);
    479 
    480     // printf("Revert request %" PRId64 "\n", req_id);
    481    
    482     if (!p_psDBRunQueryF(config->dbh, "DELETE FROM pstampJob where req_id = %" PRId64, req_id)) {
    483         psError(PS_ERR_UNKNOWN, false, "database error");
    484         return false;
    485     }
    486     if (!p_psDBRunQueryF(config->dbh,
    487         "UPDATE pstampRequest set state ='new', name=NULL, reqType=NULL, fault=0 where req_id = %" PRId64, req_id)) {
    488         psError(PS_ERR_UNKNOWN, false, "database error");
    489         return false;
    490     }
     529    psMetadata *where = psMetadataAlloc();
     530
     531    PXOPT_COPY_S64(config->args, where, "-req_id", "req_id", "==");
     532    PXOPT_COPY_S64(config->args, where, "-fault", "fault", "==");
     533    PXOPT_COPY_STR(config->args, where, "-state", "pstampRequest.state", "==");
     534    pxAddLabelSearchArgs(config, where, "-label", "pstampRequest.label", "LIKE");
     535
     536    if (!psListLength(where->list)) {
     537        psFree(where);
     538        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     539        return false;
     540    }
     541
     542    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     543    psFree(where);
     544
     545    // delete any jobs that were queued by requests that didn't complete parsing (pstampRequest.state = 'new'
     546    // If state =  'run' was supplied this will be a no-op
     547    psString query = pxDataGet("pstamptool_revertreq_deletejobs.sql");
     548    psStringAppend(&query, " AND %s", whereClause);
     549    if (!p_psDBRunQuery(config->dbh, query)) {
     550        psError(PS_ERR_UNKNOWN, false, "database error");
     551        return false;
     552    }
     553    psFree(query);
     554
     555    // clear fault for requests
     556    query = pxDataGet("pstamptool_revertreq.sql");
     557    psStringAppend(&query, " AND %s", whereClause);
     558
     559    psFree(whereClause);
     560
     561    if (!p_psDBRunQuery(config->dbh, query)) {
     562        psError(PS_ERR_UNKNOWN, false, "database error");
     563        return false;
     564    }
     565    psFree(query);
    491566
    492567    return true;
    … …  
    506581    PXOPT_LOOKUP_S16(fault,       config->args, "-fault",      false, false);
    507582    PXOPT_LOOKUP_S64(exp_id,      config->args, "-exp_id",     false, false);
     583    PXOPT_LOOKUP_S64(options,     config->args, "-options",     false, false);
     584    PXOPT_LOOKUP_S64(dep_id,      config->args, "-dep_id",     false, false);
    508585
    509586    // unless the job is being inserted with stop state require outputBase
    510587    if (strcmp(stateString, "stop") && !outputBase) {
    511         psError(PS_ERR_UNKNOWN, true, "-outputBase is required");
    512         return false;
     588        psError(PS_ERR_UNKNOWN, true, "-outputBase is required");
     589        return false;
    513590    }
    514591
    515592    // default value for job_type is defined in pstamptoolConfig.c
    516     if (!strcmp(job_type, "get_image") || !strcmp(job_type, "detect_query")) {
    517         stampJob = false;
     593    if (!strcmp(job_type, "get_image") || !strcmp(job_type, "detect_query") || !strcmp(job_type, "none")) {
     594        stampJob = false;
    518595    } else if (!strcmp(job_type, "stamp")) {
    519         stampJob = true;
     596        stampJob = true;
    520597    } else {
    521         psError(PS_ERR_UNKNOWN, false, "unknown value for -job_type: %s", job_type);
    522         return false;
    523     }
    524     if (!pstampJobInsert(config->dbh, 
     598        psError(PS_ERR_UNKNOWN, false, "unknown value for -job_type: %s", job_type);
     599        return false;
     600    }
     601    if (!pstampJobInsert(config->dbh,
    525602            0, // job_id
    526603            req_id,
    527             rownum,
    528             stateString,
    529             job_type,
    530             fault,
    531             exp_id,
    532             outputBase
     604            rownum,
     605            stateString,
     606            job_type,
     607            fault,
     608            exp_id,
     609            outputBase,
     610            options,
     611            dep_id
    533612            )) {
    534613        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    538617    psU64 affected = psDBAffectedRows(config->dbh);
    539618    if (affected != 1) {
    540         psError(PS_ERR_UNKNOWN, false, 
     619        psError(PS_ERR_UNKNOWN, false,
    541620            "should have affected one row but %" PRIu64 " rows were modified",
    542621            affected);
    … …  
    554633    PS_ASSERT_PTR_NON_NULL(config, false);
    555634
    556     PXOPT_LOOKUP_S64(req_id, config->args, "-req_id", false, false);
    557     PXOPT_LOOKUP_S64(job_id, config->args, "-job_id", false, false);
     635    psMetadata *where = psMetadataAlloc();
     636    PXOPT_COPY_S64(config->args, where, "-job_id", "job_id", "==");
     637    PXOPT_COPY_S64(config->args, where, "-req_id", "req_id", "==");
     638    PXOPT_COPY_S64(config->args, where, "-fault",  "fault", "==");
    558639
    559640    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    560641    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    561642
    562     psString query = NULL;
    563 
    564     if (!req_id && !job_id) {
    565         fprintf(stderr, "either req_id or job_id must be specified\n");
     643    if (!psListLength(where->list)) {
     644        fprintf(stderr, "search arguments are required\n");
    566645        exit (1);
    567646    }
    568647
    569     if (req_id) {
    570         psStringAppend(&query,
    571                 "SELECT"
    572                 " pstampJob.*, pstampRequest.name, pstampRequest.outProduct"
    573                 " FROM pstampJob"
    574                 " JOIN pstampRequest USING(req_id)"
    575                 " WHERE req_id = %" PRId64, req_id
    576             );
    577     } else {
    578         psStringAppend(&query,
    579                 "SELECT"
    580                 " pstampJob.*, pstampRequest.name, pstampRequest.outProduct"
    581                 " FROM pstampJob"
    582                 " JOIN pstampRequest USING(req_id)"
    583                 " WHERE job_id = %" PRId64, job_id
    584             );
    585     }
     648    psString query = pxDataGet("pstamptool_listjob.sql");
     649    if (!query) {
     650        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     651        return false;
     652    }
     653
     654    // use psDBGenerateWhereSQL because the SQL yields an intermediate table
     655    if (psListLength(where->list)) {
     656        psString whereClause = psDBGenerateWhereConditionSQL(where, "pstampJob");
     657        psStringAppend(&query, " WHERE %s", whereClause);
     658        psFree(whereClause);
     659    }
     660    psFree(where);
    586661
    587662    // treat limit == 0 as "no limit"
    … …  
    630705    PXOPT_COPY_S64(config->args, where, "-job_id", "job_id", "==");
    631706    PXOPT_COPY_S64(config->args, where, "-req_id", "req_id", "==");
     707    pxAddLabelSearchArgs(config, where, "-label", "label", "LIKE");
     708
    632709    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    633710    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    635712    psString query = pxDataGet("pstamptool_pendingjob.sql");
    636713    if (!query) {
    637         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     714        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    638715        return false;
    639716    }
    … …  
    641718    // use psDBGenerateWhereSQL because the SQL yields an intermediate table
    642719    if (psListLength(where->list)) {
    643         psString whereClause = psDBGenerateWhereConditionSQL(where, "pstampJob");
     720        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    644721        psStringAppend(&query, " AND %s", whereClause);
    645722        psFree(whereClause);
    … …  
    688765    PS_ASSERT_PTR_NON_NULL(config, false);
    689766
    690     PXOPT_LOOKUP_S64(job_id,    config->args, "-job_id", true, false);
     767    PXOPT_LOOKUP_S64(job_id,    config->args, "-job_id", false, false);
     768    PXOPT_LOOKUP_S64(dep_id,    config->args, "-dep_id", false, false);
     769
     770    if (!job_id && !dep_id) {
     771        psError(PS_ERR_UNKNOWN, true, "at least -job_id or -dep_id is required");
     772        return false;
     773    }
    691774    PXOPT_LOOKUP_STR(state,     config->args, "-state",  true, false);
    692     PXOPT_LOOKUP_STR(fault,     config->args, "-fault",  false, false);
     775    PXOPT_LOOKUP_S32(fault,     config->args, "-fault",  false, false);
     776
     777    psMetadata *where = psMetadataAlloc();
     778
     779    PXOPT_COPY_S64(config->args, where, "-job_id", "job_id", "==");
     780    PXOPT_COPY_S64(config->args, where, "-dep_id", "dep_id", "==");
    693781
    694782    psString faultStr = NULL;
    … …  
    696784        faultStr = psStringCopy("");
    697785    } else {
    698         psStringAppend(&faultStr, ", fault = '%s'", fault);
    699     }
    700 
    701     char *query ="UPDATE pstampJob"
    702         " SET state = '%s' %s"
    703         " WHERE job_id = %" PRId64;
    704    
    705     if (!p_psDBRunQueryF(config->dbh, query, state, faultStr, job_id)) {
     786        psStringAppend(&faultStr, "\n, pstampJob.fault = %d", fault);
     787    }
     788
     789    psString query = pxDataGet("pstamptool_updatejob.sql");
     790
     791    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     792    psStringAppend(&query, " WHERE %s", whereClause);
     793    psFree(whereClause);
     794    psFree(where);
     795
     796    if (!p_psDBRunQueryF(config->dbh, query, state, faultStr)) {
    706797        psError(PS_ERR_UNKNOWN, false, "database error");
    707798        psFree(query);
    … …  
    709800    }
    710801    psFree(faultStr);
     802    psFree(query);
    711803
    712804    psU64 affected = psDBAffectedRows(config->dbh);
    713     if (affected != 1) {
    714         psError(PS_ERR_UNKNOWN, false, "should have affected one row but %"
    715                                         PRIu64 " rows were modified", affected);
     805    psLogMsg("pstamptool", PS_LOG_INFO, "Updated %" PRIu64 " pstampJobs", affected);
     806
     807    return true;
     808}
     809
     810static bool revertjobMode(pxConfig *config)
     811{
     812    PS_ASSERT_PTR_NON_NULL(config, false);
     813
     814    psMetadata *where = psMetadataAlloc();
     815
     816    PXOPT_COPY_S64(config->args, where, "-job_id", "job_id", "==");
     817    PXOPT_COPY_S64(config->args, where, "-req_id", "req_id", "==");
     818    PXOPT_COPY_S64(config->args, where, "-fault",  "pstampJob.fault", "==");
     819    PXOPT_COPY_S64(config->args, where, "-req_id_min",  "req_id", ">=");
     820    pxAddLabelSearchArgs(config, where, "-label", "pstampRequest.label", "LIKE");
     821
     822    PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
     823    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     824    PXOPT_LOOKUP_S16(fault, config->args, "-fault",  false, false);
     825
     826    // By default only revert faults < 10 which are our "ipp exit codes"
     827    // codes larger than that are the pstamp request interface.
     828    // Don't fault those unless -fault waa provided
     829    psString faultClause = "";
     830    if (!fault) {
     831        faultClause = " \nAND (pstampJob.fault < 10)";
     832    }
     833
     834    psString query = pxDataGet("pstamptool_revertjob.sql");
     835    if (!psListLength(where->list) && !all) {
     836        psFree(where);
     837        psError(PXTOOLS_ERR_CONFIG, false, "search parameters or -all are required");
     838        return false;
     839    }
     840    if (psListLength(where->list)) {
     841        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     842        psStringAppend(&query, " AND %s", whereClause);
     843        psFree(whereClause);
     844    }
     845    psFree(where);
     846
     847    if (!p_psDBRunQueryF(config->dbh, query, faultClause)) {
     848        psError(PS_ERR_UNKNOWN, false, "database error");
    716849        return false;
    717850    }
    … …  
    759892    psString query = pxDataGet("pstamptool_project.sql");
    760893    if (!query) {
    761         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     894        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    762895        return false;
    763896    }
    … …  
    805938
    806939    char *query = psStringCopy ("UPDATE pstampProject SET");
    807    
     940
    808941    psStringAppend(&query, " state = '%s'", state);
    809                
     942
    810943    psStringAppend(&query, " WHERE proj_id = %" PRId64, proj_id);
    811944
    … …  
    818951    psU64 affected = psDBAffectedRows(config->dbh);
    819952    if (affected != 1) {
    820         psError(PS_ERR_UNKNOWN, false, "should have affected one row but %" 
     953        psError(PS_ERR_UNKNOWN, false, "should have affected one row but %"
    821954                                        PRIu64 " rows were modified", affected);
    822955        return false;
    … …  
    826959}
    827960
     961static bool getdependentMode(pxConfig *config)
     962{
     963    PS_ASSERT_PTR_NON_NULL(config, false);
     964
     965    PXOPT_LOOKUP_STR(stage,       config->args, "-stage",   true, false);
     966    PXOPT_LOOKUP_S64(stage_id,    config->args, "-stage_id", true, false);
     967    PXOPT_LOOKUP_STR(component,   config->args, "-component",  true, false);
     968    PXOPT_LOOKUP_STR(imagedb,     config->args, "-imagedb",  true, false);
     969    PXOPT_LOOKUP_STR(rlabel,      config->args, "-rlabel",  true, false);
     970    PXOPT_LOOKUP_BOOL(need_magic, config->args, "-need_magic", false);
     971    PXOPT_LOOKUP_BOOL(no_create,  config->args, "-no_create", false);
     972
     973    psMetadata *where = psMetadataAlloc();
     974    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
     975    PXOPT_COPY_STR(config->args, where, "-imagedb", "imagedb", "==");
     976    PXOPT_COPY_S64(config->args, where, "-stage_id", "stage_id", "==");
     977    PXOPT_COPY_STR(config->args, where, "-component", "component", "==");
     978
     979    // start a transaction eraly so it will contain any row level locks
     980    if (!psDBTransaction(config->dbh)) {
     981        psError(PS_ERR_UNKNOWN, false, "database error");
     982        return false;
     983    }
     984
     985    psString query = pxDataGet("pstamptool_getdependent.sql");
     986    if (!query) {
     987        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     988        return false;
     989    }
     990    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     991    if (!no_create) {
     992        // This will lock the row until the transaction is committed
     993        psStringAppend(&query, " AND %s FOR UPDATE", whereClause);
     994    } else {
     995        psStringAppend(&query, " AND %s", whereClause);
     996    }
     997    psFree(whereClause);
     998    psFree(where);
     999
     1000    if (!p_psDBRunQuery(config->dbh, query)) {
     1001        psError(PS_ERR_UNKNOWN, false, "database error");
     1002        psFree(query);
     1003        return false;
     1004    }
     1005    psFree(query);
     1006
     1007    psArray *output = p_psDBFetchResult(config->dbh);
     1008    if (!output) {
     1009        psError(PS_ERR_UNKNOWN, false, "database error");
     1010        return false;
     1011    }
     1012    if (psArrayLength(output)) {
     1013        psMetadata *dep = output->data[0];
     1014        psS64 dep_id = psMetadataLookupS64(NULL, dep, "dep_id");
     1015        if (!dep_id) {
     1016            psError(PS_ERR_UNKNOWN, false, "database error");
     1017            psFree(output);
     1018            return false;
     1019        }
     1020        printf("%" PRId64 "\n", dep_id);
     1021        psFree(output);
     1022        if (!psDBRollback(config->dbh)) {
     1023            psError(PS_ERR_UNKNOWN, false, "database error");
     1024        }
     1025        return true;
     1026    }
     1027    if (no_create) {
     1028        if (!psDBRollback(config->dbh)) {
     1029            psError(PS_ERR_UNKNOWN, false, "database error");
     1030            return false;
     1031        }
     1032        return true;
     1033    }
     1034    // no existing dependent that matches, insert one
     1035    // Since we have multiple processes running jobs we have a
     1036    // race condition here so that's why we need to lock the table
     1037
     1038    if (!pstampDependentInsert(
     1039        config->dbh,
     1040        0,              // dep_id
     1041        "new",          // state
     1042        stage,
     1043        stage_id,
     1044        component,
     1045        imagedb,
     1046        rlabel,
     1047        need_magic,
     1048        0               // fault
     1049        )) {
     1050        if (!psDBRollback(config->dbh)) {
     1051            psError(PS_ERR_UNKNOWN, false, "database error");
     1052        }
     1053        psError(PS_ERR_UNKNOWN, false, "failed to insert pstampDependent");
     1054        return false;
     1055    }
     1056
     1057    // if we try and get this after commit zero is returned
     1058    psS64 dep_id = psDBLastInsertID(config->dbh);
     1059    if (!dep_id) {
     1060        psError(PS_ERR_UNKNOWN, false, "psDBLastInsertID returned NULL");
     1061        if (!psDBRollback(config->dbh)) {
     1062            psError(PS_ERR_UNKNOWN, false, "database error");
     1063        }
     1064        return false;
     1065    }
     1066
     1067    if (!psDBCommit(config->dbh)) {
     1068        // rollback
     1069        if (!psDBRollback(config->dbh)) {
     1070            psError(PS_ERR_UNKNOWN, false, "database error");
     1071        }
     1072        psError(PS_ERR_UNKNOWN, false, "database error");
     1073        return false;
     1074    }
     1075
     1076    printf("%" PRId64 "\n", dep_id);
     1077
     1078    return true;
     1079}
     1080
     1081static bool pendingdependentMode(pxConfig *config)
     1082{
     1083    PS_ASSERT_PTR_NON_NULL(config, false);
     1084
     1085    psMetadata *where = psMetadataAlloc();
     1086    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
     1087    PXOPT_COPY_STR(config->args, where, "-imagedb", "imagedb", "==");
     1088    PXOPT_COPY_S64(config->args, where, "-stage_id", "stage_id", "==");
     1089    PXOPT_COPY_STR(config->args, where, "-rlabel", "rlabel", "==");
     1090    pxAddLabelSearchArgs(config, where, "-label", "pstampRequest.label", "==");
     1091
     1092    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1093    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1094
     1095    psString query = pxDataGet("pstamptool_pendingdependent.sql");
     1096    if (!query) {
     1097        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1098        return false;
     1099    }
     1100
     1101    if (psListLength(where->list)) {
     1102        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1103        psStringAppend(&query, " AND %s", whereClause);
     1104        psFree(whereClause);
     1105    }
     1106    psFree(where);
     1107
     1108    // treat limit == 0 as "no limit"
     1109    if (limit) {
     1110        psString limitString = psDBGenerateLimitSQL(limit);
     1111        psStringAppend(&query, " %s", limitString);
     1112        psFree(limitString);
     1113    }
     1114
     1115    if (!p_psDBRunQuery(config->dbh, query)) {
     1116        psError(PS_ERR_UNKNOWN, false, "database error");
     1117        psFree(query);
     1118        return false;
     1119    }
     1120    psFree(query);
     1121
     1122    psArray *output = p_psDBFetchResult(config->dbh);
     1123    if (!output) {
     1124        psError(PS_ERR_UNKNOWN, false, "database error");
     1125        return false;
     1126    }
     1127    if (!psArrayLength(output)) {
     1128        psTrace("pstamptool", PS_LOG_INFO, "no rows found");
     1129        psFree(output);
     1130        return true;
     1131    }
     1132
     1133    // negative simple so the default is true
     1134    if (!ippdbPrintMetadatas(stdout, output, "pstampDependent", !simple)) {
     1135        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1136        psFree(output);
     1137        return false;
     1138    }
     1139
     1140    psFree(output);
     1141
     1142    return true;
     1143}
     1144static bool updatedependentMode(pxConfig *config)
     1145{
     1146    PS_ASSERT_PTR_NON_NULL(config, false);
     1147
     1148    PXOPT_LOOKUP_S64(dep_id,    config->args, "-dep_id", true, false);
     1149    PXOPT_LOOKUP_STR(state,     config->args, "-set_state",  false, false);
     1150    PXOPT_LOOKUP_S16(fault,     config->args, "-fault",  false, false);
     1151
     1152    if (!fault && !state) {
     1153        psError(PS_ERR_UNKNOWN, true, "at least one of -set_state or fault is required");
     1154        return false;
     1155    }
     1156    psString query = psStringCopy("UPDATE pstampDependent SET");
     1157    bool needComma = false;
     1158    if (state) {
     1159        psStringAppend(&query, " state = '%s'", state);
     1160        needComma = true;
     1161    }
     1162    if (fault) {
     1163        psStringAppend(&query, "%s fault = %d", needComma ? ", " : "", fault);
     1164        needComma = true;
     1165    }
     1166    psStringAppend(&query, " WHERE dep_id = %" PRId64, dep_id);
     1167
     1168    if (!p_psDBRunQuery(config->dbh, query)) {
     1169        psError(PS_ERR_UNKNOWN, false, "database error");
     1170        psFree(query);
     1171        return false;
     1172    }
     1173
     1174    psU64 affected = psDBAffectedRows(config->dbh);
     1175    if (affected != 1) {
     1176        psError(PS_ERR_UNKNOWN, false, "should have affected one row but %"
     1177                                        PRIu64 " rows were modified", affected);
     1178        return false;
     1179    }
     1180
     1181    return true;
     1182}
     1183static bool revertdependentMode(pxConfig *config)
     1184{
     1185    PS_ASSERT_PTR_NON_NULL(config, false);
     1186
     1187    psMetadata *where = psMetadataAlloc();
     1188    PXOPT_COPY_S64(config->args, where, "-fault", "pstampDependent.fault", "==");
     1189    PXOPT_COPY_S64(config->args, where, "-dep_id", "dep_id", "==");
     1190    pxAddLabelSearchArgs(config, where, "-label", "pstampRequest.label", "==");
     1191
     1192    if (!psListLength(where->list)) {
     1193        psFree(where);
     1194        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     1195        return false;
     1196    }
     1197    psString query = pxDataGet("pstamptool_revertdependent.sql");
     1198    if (!query) {
     1199        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1200        return false;
     1201    }
     1202
     1203    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1204    psStringAppend(&query, " AND %s", whereClause);
     1205    psFree(whereClause);
     1206    psFree(where);
     1207
     1208    if (!p_psDBRunQuery(config->dbh, query)) {
     1209        psError(PS_ERR_UNKNOWN, false, "database error");
     1210        psFree(query);
     1211        return false;
     1212    }
     1213
     1214    return true;
     1215}

  • branches/simtest_nebulous_branches/ippTools/src/pstamptool.h

    r19760 r27840  
    3939    PSTAMPTOOL_MODE_JOBRESULT,
    4040    PSTAMPTOOL_MODE_UPDATEJOB,
     41    PSTAMPTOOL_MODE_REVERTJOB,
    4142    PSTAMPTOOL_MODE_ADDPROJECT,
    4243    PSTAMPTOOL_MODE_MODPROJECT,
    4344    PSTAMPTOOL_MODE_PROJECT,
     45    PSTAMPTOOL_MODE_GETDEPENDENT,
     46    PSTAMPTOOL_MODE_PENDINGDEPENDENT,
     47    PSTAMPTOOL_MODE_UPDATEDEPENDENT,
     48    PSTAMPTOOL_MODE_REVERTDEPENDENT,
    4449} pstamptoolMode;
    4550

  • branches/simtest_nebulous_branches/ippTools/src/pstamptoolConfig.c

    r25054 r27840  
    3838    config->modules = pmConfigRead(&argc, argv, NULL);
    3939    if (! config->modules) {
    40         psError(PS_ERR_UNKNOWN, false, "Can't find site configuration!\n");
     40        psError(psErrorCodeLast(), false, "Can't find site configuration!\n");
    4141        psFree(config);
    4242        return NULL;
    … …  
    4545    // -adddatastore
    4646    psMetadata *adddatastoreArgs = psMetadataAlloc();
    47     psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-uri",          0, "define storage uri (required)", NULL);
    48     psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-out_product",  0, "define output product name (required)", NULL);
    49     psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-last_fileset", 0, "define last fileset seen", NULL);
    50     psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-state",        0, "define datastore state", "enabled");
    51    
     47    psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-set_uri",          0, "define storage uri (required)", NULL);
     48    psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-set_out_product",  0, "define output product name (required)", NULL);
     49    psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-set_last_fileset", 0, "define last fileset seen", NULL);
     50    psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-set_state",        0, "define datastore state", "enabled");
     51    psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-set_label",        0, "define datastore label", NULL);
     52    psMetadataAddS32(adddatastoreArgs, PS_LIST_TAIL, "-set_poll_interval", 0, "define datastore poll interval (seconds)", 60);
     53
    5254    // -datastore
    5355    psMetadata *datastoreArgs = psMetadataAlloc();
    54     psMetadataAddS64(datastoreArgs, PS_LIST_TAIL, "-ds_id", 0,            "define ds_id", 0);
     56    psMetadataAddS64(datastoreArgs, PS_LIST_TAIL, "-ds_id", 0,            "define ds_id", 0);
     57    psMetadataAddBool(datastoreArgs, PS_LIST_TAIL, "-ready", 0,           "list data stores ready to be polled", false);
    5558    psMetadataAddBool(datastoreArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    5659
    5760    // -moddatastore
    5861    psMetadata *moddatastoreArgs = psMetadataAlloc();
    59     psMetadataAddS64(moddatastoreArgs, PS_LIST_TAIL, "-ds_id", 0,            "define ds_id", 0);
    60     psMetadataAddStr(moddatastoreArgs, PS_LIST_TAIL, "-last_fileset", 0,     "set last_fileset seen", NULL);
    61     psMetadataAddStr(moddatastoreArgs, PS_LIST_TAIL, "-state", 0,            "set state", NULL);
     62    psMetadataAddS64(moddatastoreArgs, PS_LIST_TAIL, "-ds_id", 0,            "define ds_id", 0);
     63    psMetadataAddStr(moddatastoreArgs, PS_LIST_TAIL, "-set_last_fileset", 0,     "set last_fileset seen", NULL);
     64    psMetadataAddStr(moddatastoreArgs, PS_LIST_TAIL, "-set_state", 0,            "set state", NULL);
     65    psMetadataAddStr(moddatastoreArgs, PS_LIST_TAIL, "-set_label", 0,            "set label", NULL);
     66    psMetadataAddS32(moddatastoreArgs, PS_LIST_TAIL, "-set_poll_interval", 0, "define datastore poll interval (seconds)", 0);
     67    psMetadataAddBool(moddatastoreArgs, PS_LIST_TAIL, "-update_timestamp", 0, "update the timestamp", false);
     68    psMetadataAddStr(moddatastoreArgs, PS_LIST_TAIL, "-state", 0,            "search by state", NULL);
    6269
    6370    // -addreq
    6471    psMetadata *addreqArgs = psMetadataAlloc();
    65     psMetadataAddStr(addreqArgs, PS_LIST_TAIL, "-uri", 0,            "define request file uri (required)", NULL);
    66     psMetadataAddS64(addreqArgs, PS_LIST_TAIL, "-ds_id", 0,            "define request ds_id", 0);
    67     // psMetadataAddStr(addreqArgs, PS_LIST_TAIL, "-out_fileset", 0,            "define request output_fileset", NULL);
     72    psMetadataAddStr(addreqArgs, PS_LIST_TAIL, "-uri", 0,    "define request file uri (required)", NULL);
     73    psMetadataAddS64(addreqArgs, PS_LIST_TAIL, "-ds_id", 0,  "define request ds_id", 0);
     74    psMetadataAddStr(addreqArgs, PS_LIST_TAIL, "-name", 0,   "define request name", NULL);
     75    psMetadataAddStr(addreqArgs, PS_LIST_TAIL, "-label", 0,  "define request label", NULL);
    6876
    6977    // -pendingreq
    7078    psMetadata *pendingreqArgs = psMetadataAlloc();
    71     psMetadataAddS64(pendingreqArgs, PS_LIST_TAIL, "-req_id", 0,            "define req_id", 0);
     79    psMetadataAddS64(pendingreqArgs, PS_LIST_TAIL, "-req_id", 0,            "define req_id", 0);
     80    psMetadataAddStr(pendingreqArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by pstampRequest label (LIKE comparision)", NULL);
    7281    psMetadataAddU64(pendingreqArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    7382    psMetadataAddBool(pendingreqArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    … …  
    7584    // -listreq
    7685    psMetadata *listreqArgs = psMetadataAlloc();
    77     psMetadataAddS64(listreqArgs, PS_LIST_TAIL, "-req_id", 0,            "define req_id (required)", 0);
     86    psMetadataAddS64(listreqArgs, PS_LIST_TAIL, "-req_id", 0,            "list by req_id", 0);
     87    psMetadataAddStr(listreqArgs, PS_LIST_TAIL, "-name", 0,              "list by name", NULL);
     88    psMetadataAddS64(listreqArgs, PS_LIST_TAIL, "-not_req_id", 0,        "req_id to not list", 0);
    7889    psMetadataAddU64(listreqArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    79     psMetadataAddBool(listreqArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
     90    psMetadataAddBool(listreqArgs, PS_LIST_TAIL, "-simple", 0,           "use the simple output format", false);
    8091
    8192    // -completedreq
    8293    psMetadata *completedreqArgs = psMetadataAlloc();
     94    psMetadataAddStr(completedreqArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by pstampJob label (LIKE comparision)", NULL);
    8395    psMetadataAddU64(completedreqArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    8496    psMetadataAddBool(completedreqArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    … …  
    8698    // -updatereq
    8799    psMetadata *updatereqArgs = psMetadataAlloc();
    88     psMetadataAddS64(updatereqArgs, PS_LIST_TAIL, "-req_id", 0,            "req_id for which to change state", 0); 
    89     psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-state", 0,            "new state", NULL); 
    90     psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-outProduct", 0,            "define request outProduct", NULL); 
    91     psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-fault", 0,            "define request fault code", NULL);
    92     psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-uri", 0,            "define the uri", NULL); 
    93     psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-name", 0,            "define the name", NULL); 
    94     psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-reqType", 0,            "define the reqType", NULL); 
     100    psMetadataAddS64(updatereqArgs, PS_LIST_TAIL, "-req_id", 0,            "req_id for which to change state", 0);
     101    psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-state", 0,            "new state", NULL);
     102    psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-outProduct", 0,            "define request outProduct", NULL);
     103    psMetadataAddS16(updatereqArgs, PS_LIST_TAIL, "-fault", 0,            "define request fault code", 0);
     104    psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-uri", 0,            "define the uri", NULL);
     105    psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-name", 0,            "define the name", NULL);
     106    psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-reqType", 0,            "define the reqType", NULL);
    95107
    96108    // -revertreq
    97109    psMetadata *revertreqArgs = psMetadataAlloc();
    98     psMetadataAddS64(revertreqArgs, PS_LIST_TAIL, "-req_id", 0,            "req_id for which to revert", 0);
     110    psMetadataAddS64(revertreqArgs, PS_LIST_TAIL, "-req_id", 0,     "req_id to revert", 0);
     111    psMetadataAddS16(revertreqArgs, PS_LIST_TAIL, "-fault",  0,     "fault to revert", 0);
     112    psMetadataAddStr(revertreqArgs, PS_LIST_TAIL, "-state", 0,      "state to revert", NULL);
     113    psMetadataAddStr(revertreqArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by pstampRequest label (LIKE comparision)", NULL);
    99114
    100115    // -addjob
    101116    psMetadata *addjobArgs = psMetadataAlloc();
    102     psMetadataAddS64(addjobArgs, PS_LIST_TAIL, "-req_id", 0,            "define job req_id", 0);
    103     psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-rownum", 0,            "define job rownum", NULL);
    104     psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-job_type", 0,            "define job job_type", "stamp");
    105     psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-outputBase", 0,            "define job outputBase", NULL);
    106     psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-state", 0,            "new state", "run");
    107     psMetadataAddS64(addjobArgs, PS_LIST_TAIL, "-exp_id", 0,           "exposure id", 0);
    108     psMetadataAddS16(addjobArgs, PS_LIST_TAIL, "-fault", 0,            "new result", 0);
     117    psMetadataAddS64(addjobArgs, PS_LIST_TAIL, "-req_id", 0,           "define job req_id", 0);
     118    psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-rownum", 0,           "define job rownum", NULL);
     119    psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-job_type", 0,         "define job job_type", "stamp");
     120    psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-outputBase", 0,       "define job outputBase", NULL);
     121    psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-state", 0,            "define state", "run");
     122    psMetadataAddS64(addjobArgs, PS_LIST_TAIL, "-exp_id", 0,           "define exposure id", 0);
     123    psMetadataAddS64(addjobArgs, PS_LIST_TAIL, "-options", 0,          "define options", 0);
     124    psMetadataAddS64(addjobArgs, PS_LIST_TAIL, "-dep_id", 0,           "define job dep_id", 0);
     125    psMetadataAddS16(addjobArgs, PS_LIST_TAIL, "-fault", 0,            "define job result", 0);
    109126
    110127    // -listjob
    111128    psMetadata *listjobArgs = psMetadataAlloc();
    112     psMetadataAddS64(listjobArgs, PS_LIST_TAIL, "-req_id", 0,            "define request", 0);
    113     psMetadataAddS64(listjobArgs, PS_LIST_TAIL, "-job_id", 0,            "define job", 0);
    114     psMetadataAddU64(listjobArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    115     psMetadataAddBool(listjobArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
     129    psMetadataAddS64(listjobArgs, PS_LIST_TAIL, "-req_id", 0,          "select by request ID", 0);
     130    psMetadataAddS64(listjobArgs, PS_LIST_TAIL, "-job_id", 0,          "select by job ID", 0);
     131    psMetadataAddS16(listjobArgs, PS_LIST_TAIL, "-fault", 0,           "select by fault", 0);
     132    psMetadataAddU64(listjobArgs, PS_LIST_TAIL, "-limit",  0,          "limit result set to N items", 0);
     133    psMetadataAddBool(listjobArgs, PS_LIST_TAIL, "-simple", 0,         "use the simple output format", false);
    116134
    117135    // -pendingjob
    118136    psMetadata *pendingjobArgs = psMetadataAlloc();
    119     psMetadataAddS64(pendingjobArgs, PS_LIST_TAIL, "-job_id", 0,            "define job", 0);
    120     psMetadataAddS64(pendingjobArgs, PS_LIST_TAIL, "-req_id", 0,            "define request", 0);
     137    psMetadataAddS64(pendingjobArgs, PS_LIST_TAIL, "-job_id", 0,            "define job", 0);
     138    psMetadataAddS64(pendingjobArgs, PS_LIST_TAIL, "-req_id", 0,            "define request", 0);
     139    psMetadataAddStr(pendingjobArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by pstampJob label (LIKE comparision)", NULL);
    121140    psMetadataAddU64(pendingjobArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    122141    psMetadataAddBool(pendingjobArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    … …  
    124143    // -updatejob
    125144    psMetadata *updatejobArgs = psMetadataAlloc();
    126     psMetadataAddS64(updatejobArgs, PS_LIST_TAIL, "-job_id", 0,            "req_id for which to change state", 0);
    127     psMetadataAddStr(updatejobArgs, PS_LIST_TAIL, "-state", 0,            "new state", NULL);
    128     psMetadataAddStr(updatejobArgs, PS_LIST_TAIL, "-fault", 0,            "new result", NULL);
     145    psMetadataAddS64(updatejobArgs, PS_LIST_TAIL, "-job_id", 0,            "req_id for which to change state", 0);
     146    psMetadataAddS64(updatejobArgs, PS_LIST_TAIL, "-dep_id", 0,            "dep_id for which to change state", 0);
     147    psMetadataAddStr(updatejobArgs, PS_LIST_TAIL, "-state", 0,            "new state", NULL);
     148    psMetadataAddS16(updatejobArgs, PS_LIST_TAIL, "-fault", 0,            "new result", 0);
     149
     150    // -revertjob
     151    psMetadata *revertjobArgs = psMetadataAlloc();
     152    psMetadataAddS64(revertjobArgs, PS_LIST_TAIL, "-req_id", 0,     "req_id to revert", 0);
     153    psMetadataAddS64(revertjobArgs, PS_LIST_TAIL, "-req_id_min", 0, "minimum req_id to revert", 0);
     154    psMetadataAddS64(revertjobArgs, PS_LIST_TAIL, "-job_id", 0,     "job_id to revert", 0);
     155    psMetadataAddS16(revertjobArgs, PS_LIST_TAIL, "-fault",  0,     "fault to revert", 0);
     156    psMetadataAddStr(revertjobArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by pstampRequest label (LIKE comparision)", NULL);
     157    psMetadataAddBool(revertjobArgs, PS_LIST_TAIL, "-all", 0,       "revert all faulted jobs", false);
     158    psMetadataAddU64(revertjobArgs, PS_LIST_TAIL, "-limit", 0,      "limit result set to N items", 0);
     159
     160    // -getdependent
     161    psMetadata *getdependentArgs = psMetadataAlloc();
     162    psMetadataAddS64(getdependentArgs, PS_LIST_TAIL, "-stage_id", 0, "define id for dependent (required)", 0);
     163    psMetadataAddStr(getdependentArgs, PS_LIST_TAIL, "-stage", 0,    "define stage for dependent (required)", NULL);
     164    psMetadataAddStr(getdependentArgs, PS_LIST_TAIL, "-component", 0, "define component for depenent (required)", NULL);
     165    psMetadataAddStr(getdependentArgs, PS_LIST_TAIL, "-imagedb", 0,  "define imagedb for depenent (required)", NULL);
     166    psMetadataAddStr(getdependentArgs, PS_LIST_TAIL, "-rlabel", 0,   "define label for dependent ", NULL);
     167    psMetadataAddBool(getdependentArgs,PS_LIST_TAIL, "-need_magic", 0, "define need_magic", false);
     168    psMetadataAddBool(getdependentArgs,PS_LIST_TAIL, "-no_create", 0, "if no matching dependent do not create one", false);
     169
     170    // -updatedependent
     171    psMetadata *updatedependentArgs = psMetadataAlloc();
     172    psMetadataAddS64(updatedependentArgs, PS_LIST_TAIL, "-dep_id", 0, "define id for dependent (required)", 0);
     173    psMetadataAddStr(updatedependentArgs, PS_LIST_TAIL, "-set_state", 0, "new value for state", NULL);
     174    psMetadataAddS16(updatedependentArgs, PS_LIST_TAIL, "-fault",  0,   "new value for fault", 0);
     175
     176    // -revertdependent
     177    psMetadata *revertdependentArgs = psMetadataAlloc();
     178    psMetadataAddS64(revertdependentArgs, PS_LIST_TAIL, "-dep_id", 0, "define id for dependent", 0);
     179    psMetadataAddStr(revertdependentArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK,   "define label for dependent ", NULL);
     180    psMetadataAddS16(revertdependentArgs, PS_LIST_TAIL, "-fault",  0,   "define fault", 0);
     181
     182    // -pendingdependent
     183    psMetadata *pendingdependentArgs = psMetadataAlloc();
     184    psMetadataAddS64(pendingdependentArgs, PS_LIST_TAIL, "-stage_id", 0, "define id for dependent", 0);
     185    psMetadataAddStr(pendingdependentArgs, PS_LIST_TAIL, "-stage", 0,    "define stage for dependent", NULL);
     186    psMetadataAddStr(pendingdependentArgs, PS_LIST_TAIL, "-component", 0,    "define component for dependent", NULL);
     187    psMetadataAddStr(pendingdependentArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK,   "define label for pstampRequest", NULL);
     188    psMetadataAddStr(pendingdependentArgs, PS_LIST_TAIL, "-rlabel", 0,   "define label for dependent", NULL);
     189    psMetadataAddStr(pendingdependentArgs, PS_LIST_TAIL, "-imagedb", 0,  "define imagedb for depenent", NULL);
     190    psMetadataAddU64(pendingdependentArgs, PS_LIST_TAIL, "-limit",  0,    "limit result set to N items", 0);
     191    psMetadataAddBool(pendingdependentArgs, PS_LIST_TAIL, "-simple", 0,   "use the simple output format", false);
    129192
    130193    // -addproject
    … …  
    140203    // -modproject
    141204    psMetadata *modprojectArgs = psMetadataAlloc();
    142     psMetadataAddS64(modprojectArgs, PS_LIST_TAIL, "-proj_id",      0, "define project ID to modify (required)", 0); 
     205    psMetadataAddS64(modprojectArgs, PS_LIST_TAIL, "-proj_id",      0, "define project ID to modify (required)", 0);
    143206    psMetadataAddStr(modprojectArgs, PS_LIST_TAIL, "-imagedb",      0, "define name of database for project", NULL);
    144207    psMetadataAddStr(modprojectArgs, PS_LIST_TAIL, "-state",        0, "define state for project (enabled, disabled)", NULL);
    … …  
    150213    // -project
    151214    psMetadata *projectArgs = psMetadataAlloc();
    152     psMetadataAddStr(projectArgs, PS_LIST_TAIL, "-name", 0, "define project name to list (required)", NULL); 
     215    psMetadataAddStr(projectArgs, PS_LIST_TAIL, "-name", 0, "define project name to list (required)", NULL);
    153216    psMetadataAddBool(projectArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    154217
    … …  
    158221    PXOPT_ADD_MODE("-addreq",          "", PSTAMPTOOL_MODE_ADDREQ,       addreqArgs);
    159222    PXOPT_ADD_MODE("-pendingreq",      "", PSTAMPTOOL_MODE_PENDINGREQ,   pendingreqArgs);
    160     PXOPT_ADD_MODE("-updatereq",    "", PSTAMPTOOL_MODE_UPDATEREQ, updatereqArgs);
     223    PXOPT_ADD_MODE("-updatereq",       "", PSTAMPTOOL_MODE_UPDATEREQ, updatereqArgs);
    161224    PXOPT_ADD_MODE("-listreq",         "", PSTAMPTOOL_MODE_LISTREQ,      listreqArgs);
    162225    PXOPT_ADD_MODE("-completedreq",    "", PSTAMPTOOL_MODE_COMPLETEDREQ, completedreqArgs);
    … …  
    166229    PXOPT_ADD_MODE("-listjob",         "", PSTAMPTOOL_MODE_LISTJOB,      listjobArgs);
    167230    PXOPT_ADD_MODE("-pendingjob",      "", PSTAMPTOOL_MODE_PENDINGJOB,   pendingjobArgs);
    168     PXOPT_ADD_MODE("-updatejob",    "", PSTAMPTOOL_MODE_UPDATEJOB, updatejobArgs);
     231    PXOPT_ADD_MODE("-updatejob",       "", PSTAMPTOOL_MODE_UPDATEJOB,    updatejobArgs);
     232    PXOPT_ADD_MODE("-revertjob",       "", PSTAMPTOOL_MODE_REVERTJOB,    revertjobArgs);
    169233
    170234    PXOPT_ADD_MODE("-adddatastore",    "", PSTAMPTOOL_MODE_ADDDATASTORE, adddatastoreArgs);
    171235    PXOPT_ADD_MODE("-datastore",       "", PSTAMPTOOL_MODE_DATASTORE,    datastoreArgs);
    172236    PXOPT_ADD_MODE("-moddatastore",    "", PSTAMPTOOL_MODE_MODDATASTORE, moddatastoreArgs);
     237
     238    PXOPT_ADD_MODE("-getdependent",    "", PSTAMPTOOL_MODE_GETDEPENDENT, getdependentArgs);
     239    PXOPT_ADD_MODE("-updatedependent", "", PSTAMPTOOL_MODE_UPDATEDEPENDENT, updatedependentArgs);
     240    PXOPT_ADD_MODE("-pendingdependent","", PSTAMPTOOL_MODE_PENDINGDEPENDENT, pendingdependentArgs);
     241    PXOPT_ADD_MODE("-revertdependent","", PSTAMPTOOL_MODE_REVERTDEPENDENT, revertdependentArgs);
    173242
    174243    PXOPT_ADD_MODE("-addproject",      "", PSTAMPTOOL_MODE_ADDPROJECT, addprojectArgs);

  • branches/simtest_nebulous_branches/ippTools/src/pubtool.c

    r24512 r27840  
    3232
    3333static bool defineclientMode(pxConfig *config);
     34static bool updateclientMode(pxConfig *config);
    3435static bool definerunMode(pxConfig *config);
    3536static bool pendingMode(pxConfig *config);
    … …  
    5758    switch (config->mode) {
    5859        MODECASE(PUBTOOL_MODE_DEFINECLIENT, defineclientMode);
     60        MODECASE(PUBTOOL_MODE_UPDATECLIENT, updateclientMode);
    5961        MODECASE(PUBTOOL_MODE_DEFINERUN, definerunMode);
    6062        MODECASE(PUBTOOL_MODE_PENDING, pendingMode);
    … …  
    9395    // optional
    9496    PXOPT_LOOKUP_STR(comment, config->args, "-comment",  false, false);
    95 
    96     if (!publishClientInsert(config->dbh, 0, product, stage, workdir, comment)) {
    97         psError(PS_ERR_UNKNOWN, false, "Database error");
    98         return false;
    99     }
     97    PXOPT_LOOKUP_BOOL(unmagicked, config->args, "-unmagicked",  false);
     98
     99    if (!publishClientInsert(config->dbh, 0, 0, product, stage, !unmagicked, workdir, comment)) {
     100        psError(PS_ERR_UNKNOWN, false, "Database error");
     101        return false;
     102    }
     103
     104    return true;
     105}
     106
     107static bool updateclientMode(pxConfig *config)
     108{
     109    PS_ASSERT_PTR_NON_NULL(config, false);
     110
     111    psMetadata *where = psMetadataAlloc(); // WHERE conditions
     112    PXOPT_COPY_S64(config->args, where, "-client_id", "client_id", "==");
     113    PXOPT_COPY_STR(config->args, where, "-product", "product", "==");
     114    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
     115    PXOPT_COPY_STR(config->args, where, "-comment", "comment", "LIKE");
     116
     117    PXOPT_LOOKUP_BOOL(active, config->args, "-active",  false);
     118    PXOPT_LOOKUP_BOOL(inactive, config->args, "-inactive",  false);
     119
     120    if ((!active && !inactive) || (active && inactive)) {
     121        psError(PS_ERR_UNKNOWN, false, "Must specify one, and only one, of -active and -inactive.");
     122        psFree(where);
     123        return false;
     124    }
     125
     126    psString query = NULL;              // Query to run
     127    psStringAppend(&query, "UPDATE publishClient SET active = %d", active ? 1 : 0);
     128
     129    if (psListLength(where->list)) {
     130        psString clause = psDBGenerateWhereConditionSQL(where, NULL);
     131        psStringAppend(&query, "\n WHERE %s", clause);
     132        psFree(clause);
     133    }
     134    psFree(where);
     135
     136    if (!p_psDBRunQuery(config->dbh, query)) {
     137        psError(PS_ERR_UNKNOWN, false, "Database error");
     138        psFree(query);
     139        return false;
     140    }
     141    psFree(query);
     142
     143    long numUpdated = psDBAffectedRows(config->dbh);
     144    psLogMsg("pubtool", PS_LOG_INFO, "%ld rows updated.", numUpdated);
    100145
    101146    return true;
    … …  
    112157    // optional
    113158    PXOPT_COPY_S64(config->args, where, "-client_id", "client_id", "==");
    114     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
    115 
    116     PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
     159    pxAddLabelSearchArgs(config, where, "-label", "label", "=="); // define using newExp label
    117160
    118161    psString query = pxDataGet("pubtool_definerun.sql"); // Query to run
    119162    if (!query) {
    120         psError(PXTOOLS_ERR_DATA, false, "Failed to retreive SQL statement");
     163        psError(PXTOOLS_ERR_SYS, false, "Failed to retreive SQL statement");
    121164        psFree(where);
    122165        return false;
    … …  
    167210        psS64 client = psMetadataLookupS64(NULL, row, "client_id"); // Client identifier
    168211        psS64 stage = psMetadataLookupS64(NULL, row, "stage_id");   // Stage identifier
     212        char *label = psMetadataLookupStr(NULL, row, "src_label");   // label from correct source
    169213
    170214        if (!publishRunInsert(config->dbh, 0, client, stage, label, "new")) {
    … …  
    205249    psString query = pxDataGet("pubtool_pending.sql");
    206250    if (!query) {
    207         psError(PXTOOLS_ERR_DATA, false, "Failed to retreive SQL statement");
     251        psError(PXTOOLS_ERR_SYS, false, "Failed to retreive SQL statement");
    208252        psFree(where);
    209253        return false;
    … …  
    259303    // required
    260304    PXOPT_LOOKUP_S64(pub_id, config->args, "-pub_id", true, false);
    261     PXOPT_LOOKUP_STR(path_base, config->args, "-path_base",  true, false);
     305    PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", true, false);
    262306
    263307    // optional
     308    PXOPT_LOOKUP_STR(hostname, config->args, "-hostname", false, false);
     309    PXOPT_LOOKUP_F32(dtime_script, config->args, "-dtime_script", false, false);
    264310    PXOPT_LOOKUP_S32(fault, config->args, "-fault", false, false);
    265311
    … …  
    269315    }
    270316
    271     if (!publishDoneInsert(config->dbh, pub_id, path_base, fault)) {
     317    if (!publishDoneInsert(config->dbh, pub_id, path_base, hostname, dtime_script, fault)) {
    272318        psError(PS_ERR_UNKNOWN, false, "Unable to add file");
    273319        if (!psDBRollback(config->dbh)) {
    … …  
    309355    PXOPT_COPY_STR(config->args, where, "-client_id", "publishClient.client_id", "==");
    310356    PXOPT_COPY_STR(config->args, where, "-comment", "publishClient.comment", "LIKE");
    311     PXOPT_COPY_STR(config->args, where, "-label", "publishRun.label", "==");
     357    pxAddLabelSearchArgs(config, where, "-label", "publishRun.label", "==");
    312358
    313359    psString query = pxDataGet("pubtool_revert.sql");
    314360    if (!query) {
    315         psError(PXTOOLS_ERR_DATA, false, "Failed to retreive SQL statement");
     361        psError(PXTOOLS_ERR_SYS, false, "Failed to retreive SQL statement");
    316362        psFree(where);
    317363        return false;
    … …  
    332378    psFree(query);
    333379
    334     return true;
    335 }
    336 
     380    psLogMsg("pubtool", PS_LOG_INFO, "Deleted %" PRIu64 " rows", psDBAffectedRows(config->dbh));
     381
     382    return true;
     383}
     384

  • branches/simtest_nebulous_branches/ippTools/src/pubtool.h

    r24512 r27840  
    2626    PUBTOOL_MODE_NONE      = 0x0,
    2727    PUBTOOL_MODE_DEFINECLIENT,
     28    PUBTOOL_MODE_UPDATECLIENT,
    2829    PUBTOOL_MODE_DEFINERUN,
    2930    PUBTOOL_MODE_PENDING,

  • branches/simtest_nebulous_branches/ippTools/src/pubtoolConfig.c

    r24512 r27840  
    3838    config->modules = pmConfigRead(&argc, argv, NULL);
    3939    if (!config->modules) {
    40         psError(PS_ERR_UNKNOWN, false, "Can't find site configuration!");
     40        psError(psErrorCodeLast(), false, "Can't find site configuration!");
    4141        psFree(config);
    4242        return NULL;
    … …  
    4949    psMetadataAddStr(defineclientArgs, PS_LIST_TAIL, "-workdir", 0, "define workdir (required)", NULL);
    5050    psMetadataAddStr(defineclientArgs, PS_LIST_TAIL, "-comment", 0, "define comment", NULL);
     51    psMetadataAddBool(defineclientArgs, PS_LIST_TAIL, "-unmagicked", 0, "allow unmagicked data?", false);
     52
     53    // -updateclient
     54    psMetadata *updateclientArgs = psMetadataAlloc();
     55    psMetadataAddS64(updateclientArgs, PS_LIST_TAIL, "-client_id", 0, "search by client_id", 0);
     56    psMetadataAddStr(updateclientArgs, PS_LIST_TAIL, "-stage", 0, "search by stage", NULL);
     57    psMetadataAddStr(updateclientArgs, PS_LIST_TAIL, "-product", 0, "search by product", NULL);
     58    psMetadataAddStr(updateclientArgs, PS_LIST_TAIL, "-comment", 0, "search by comment (LIKE)", NULL);
     59    psMetadataAddBool(updateclientArgs, PS_LIST_TAIL, "-active", 0, "set to active state", NULL);
     60    psMetadataAddBool(updateclientArgs, PS_LIST_TAIL, "-inactive", 0, "set to inactive state", NULL);
    5161
    5262    // -definerun
    5363    psMetadata *definerunArgs = psMetadataAlloc();
    5464    psMetadataAddS64(definerunArgs, PS_LIST_TAIL, "-client_id", 0, "search by client_id", 0);
    55     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-label", 0, "set and search by label", NULL);
     65    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "set and search by label", NULL);
    5666
    5767    // -pending
    … …  
    6878    psMetadataAddS64(addArgs, PS_LIST_TAIL, "-pub_id", 0, "define pub_id (required)", 0);
    6979    psMetadataAddStr(addArgs, PS_LIST_TAIL, "-path_base", 0, "define path_base (required)", NULL);
     80    psMetadataAddStr(addArgs, PS_LIST_TAIL, "-hostname", 0, "define hostname", NULL);
     81    psMetadataAddF32(addArgs, PS_LIST_TAIL, "-dtime_script", 0, "define time for script", NAN);
    7082    psMetadataAddS32(addArgs, PS_LIST_TAIL, "-fault", 0, "define fault code", 0);
    7183
    … …  
    7688    psMetadataAddStr(revertArgs, PS_LIST_TAIL, "-client_id", 0, "search on client_id", NULL);
    7789    psMetadataAddStr(revertArgs, PS_LIST_TAIL, "-comment", 0, "search on comment (LIKE)", NULL);
    78     psMetadataAddStr(revertArgs, PS_LIST_TAIL, "-label", 0, "search on label", NULL);
     90    psMetadataAddStr(revertArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search on label", NULL);
    7991
    8092
    … …  
    8395
    8496    PXOPT_ADD_MODE("-defineclient", "", PUBTOOL_MODE_DEFINECLIENT, defineclientArgs);
     97    PXOPT_ADD_MODE("-updateclient", "", PUBTOOL_MODE_UPDATECLIENT, updateclientArgs);
    8598    PXOPT_ADD_MODE("-definerun", "", PUBTOOL_MODE_DEFINERUN, definerunArgs);
    8699    PXOPT_ADD_MODE("-pending", "", PUBTOOL_MODE_PENDING, pendingArgs);

  • branches/simtest_nebulous_branches/ippTools/src/pxadmin.c

    r23310 r27840  
    22 * pxadmin.c
    33 *
    4  * Copyright (C) 2006-2008  Joshua Hoblitt
     4 * Copyright (C) 2006-2009  Joshua Hoblitt
    55 *
    66 * This program is free software; you can redistribute it and/or modify it
    … …  
    3131bool createMirrorMode(pxConfig *config);
    3232bool deleteMode(pxConfig *config);
     33static bool insert_dbversion(pxConfig * config, const char *versionString);
    3334static bool runMultipleStatments(pxConfig *config, const char *query);
    3435
    … …  
    9394    psString query = pxDataGet("pxadmin_create_tables.sql");
    9495    if (!query) {
    95         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     96        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    9697        return false;
    9798    }
    … …  
    113114    psFree(query);
    114115
     116    if (!insert_dbversion(config, IPPDB_VERSION)) {
     117        psError(PS_ERR_UNKNOWN, false, "failed to set database version");
     118        return false;
     119    }
     120
    115121    // COMMIT
    116122    if (!psDBCommit(config->dbh)) {
    … …  
    129135    psString query = pxDataGet("pxadmin_create_mirror_tables.sql");
    130136    if (!query) {
    131         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     137        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    132138        return false;
    133139    }
    … …  
    149155    psFree(query);
    150156
     157    if (!insert_dbversion(config, IPPDB_VERSION)) {
     158        psError(PS_ERR_UNKNOWN, false, "failed to set database version");
     159        return false;
     160    }
     161
    151162    // COMMIT
    152163    if (!psDBCommit(config->dbh)) {
    … …  
    209220    psString query = pxDataGet("pxadmin_drop_tables.sql");
    210221    if (!query) {
    211         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     222        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    212223        return false;
    213224    }
    … …  
    262273    return true;
    263274}
     275
     276#ifdef notdef
     277static bool update_dbversion(pxConfig * config, const char *versionString)
     278{
     279    psString query = pxDataGet("pxadmin_update_version.sql");
     280    if (!query) {
     281        psError(PS_ERR_UNKNOWN, false, "failed to retrieve SQL statement");
     282        psFree(query);
     283        return false;
     284    }
     285    if (!p_psDBRunQueryF(config->dbh, query, versionString)) {
     286        psError(PS_ERR_UNKNOWN, false, "database error");
     287        psFree(query);
     288        return false;
     289    }
     290    return true;
     291}
     292#endif
     293static bool insert_dbversion(pxConfig * config, const char *versionString)
     294{
     295    psString query = "INSERT INTO dbversion VALUES('%s', CURRENT_TIMESTAMP())";
     296    if (!query) {
     297        psError(PS_ERR_UNKNOWN, false, "failed to retrieve SQL statement");
     298        psFree(query);
     299        return false;
     300    }
     301    if (!p_psDBRunQueryF(config->dbh, query, versionString)) {
     302        psError(PS_ERR_UNKNOWN, false, "database error");
     303        psFree(query);
     304        return false;
     305    }
     306    return true;
     307}

  • branches/simtest_nebulous_branches/ippTools/src/pxcam.c

    r24866 r27840  
    7676bool pxcamGetSearchArgs (pxConfig *config, psMetadata *where) {
    7777
    78     PXOPT_COPY_S64(config->args,   where, "-chip_id",            "chipRun.chip_id",     "==");
    79     PXOPT_COPY_S64(config->args,   where, "-exp_id",             "rawExp.exp_id",       "==");
    80     PXOPT_COPY_STR(config->args,   where, "-exp_name",           "rawExp.exp_name",     "==");
    81     PXOPT_COPY_STR(config->args,   where, "-inst",               "rawExp.camera",       "==");
    82     PXOPT_COPY_STR(config->args,   where, "-telescope",          "rawExp.telescope",    "==");
    83     PXOPT_COPY_TIME(config->args,  where, "-dateobs_begin",      "rawExp.dateobs",      ">=");
    84     PXOPT_COPY_TIME(config->args,  where, "-dateobs_end",        "rawExp.dateobs",      "<=");
    85     PXOPT_COPY_STR(config->args,   where, "-exp_tag",            "rawExp.exp_tag",      "==");
    86     PXOPT_COPY_STR(config->args,   where, "-exp_type",           "rawExp.exp_type",     "==");
    87     PXOPT_COPY_STR(config->args,   where, "-comment",            "rawExp.comment",      "LIKE");
    88     PXOPT_COPY_STR(config->args,   where, "-filelevel",          "rawExp.filelevel",    "==");
    89     PXOPT_COPY_STR(config->args,   where, "-filter",             "rawExp.filter",         "==");
     78    PXOPT_COPY_S64(config->args,   where, "-chip_id",            "chipRun.chip_id",     "==");
     79    PXOPT_COPY_S64(config->args,   where, "-exp_id",             "rawExp.exp_id",       "==");
     80    PXOPT_COPY_STR(config->args,   where, "-exp_name",           "rawExp.exp_name",     "==");
     81    PXOPT_COPY_STR(config->args,   where, "-inst",               "rawExp.camera",       "==");
     82    PXOPT_COPY_STR(config->args,   where, "-telescope",          "rawExp.telescope",    "==");
     83    PXOPT_COPY_TIME(config->args,  where, "-dateobs_begin",      "rawExp.dateobs",      ">=");
     84    PXOPT_COPY_TIME(config->args,  where, "-dateobs_end",        "rawExp.dateobs",      "<=");
     85    PXOPT_COPY_STR(config->args,   where, "-exp_tag",            "rawExp.exp_tag",      "==");
     86    PXOPT_COPY_STR(config->args,   where, "-exp_type",           "rawExp.exp_type",     "==");
     87    PXOPT_COPY_STR(config->args,   where, "-comment",            "rawExp.comment",      "LIKE");
     88    PXOPT_COPY_STR(config->args,   where, "-filelevel",          "rawExp.filelevel",    "==");
     89    PXOPT_COPY_STR(config->args,   where, "-filter",             "rawExp.filter",         "LIKE");
    9090    PXOPT_COPY_F64(config->args,   where, "-airmass_min",        "rawExp.airmass",        ">=");
    9191    PXOPT_COPY_F64(config->args,   where, "-airmass_max",        "rawExp.airmass",        "<");
    … …  
    141141}
    142142
    143 
    144 bool pxcamRunSetStateByQuery(pxConfig *config, psMetadata *where, const char *state)
    145 {
    146     PS_ASSERT_PTR_NON_NULL(config, false);
    147     PS_ASSERT_PTR_NON_NULL(state, false);
    148 
    149     // check that state is a valid string value
    150     if (!pxIsValidState(state)) {
    151         psError(PS_ERR_UNKNOWN, false,
    152                 "invalid chipRun state: %s", state);
    153         return false;
    154     }
    155 
    156     psString query = psStringCopy("UPDATE camRun JOIN chipRun USING(chip_id) JOIN rawExp USING(exp_id) SET camRun.state = '%s'");
    157 
    158     if (where) {
    159         psString whereClause = psDBGenerateWhereSQL(where, NULL);
    160         psStringAppend(&query, " %s", whereClause);
    161         psFree(whereClause);
    162     }
    163 
    164     if (!p_psDBRunQueryF(config->dbh, query, state)) {
    165         psFree(query);
    166         psError(PS_ERR_UNKNOWN, false, "database error");
    167         return false;
    168     }
    169 
    170     psFree(query);
    171 
    172     return true;
    173 }
    174 
    175 
    176 bool pxcamRunSetLabel(pxConfig *config, psS64 cam_id, const char *label)
    177 {
    178     PS_ASSERT_PTR_NON_NULL(config, false);
    179     // note label == NULL should be explicitly allowed
    180 
    181     char *query = "UPDATE camRun SET camRun.label = '%s' WHERE cam_id = %" PRId64;
    182     if (!p_psDBRunQueryF(config->dbh, query, label, cam_id)) {
    183         psError(PS_ERR_UNKNOWN, false,
    184                 "failed to change state for cam_id %" PRId64, cam_id);
    185         return false;
    186     }
    187 
    188     return true;
    189 }
    190 
    191 bool pxcamRunSetLabelByQuery(pxConfig *config, psMetadata *where, const char *label)
    192 {
    193     PS_ASSERT_PTR_NON_NULL(config, false);
    194     // note label == NULL should be explicitly allowed
    195 
    196     psString query = psStringCopy("UPDATE camRun JOIN chipRun USING(chip_id) JOIN rawExp USING(exp_id) SET camRun.label = '%s'");
    197 
    198     if (where) {
    199         psString whereClause = psDBGenerateWhereSQL(where, NULL);
    200         psStringAppend(&query, " %s", whereClause);
    201         psFree(whereClause);
    202     }
    203 
    204     if (!p_psDBRunQueryF(config->dbh, query, label)) {
    205         psFree(query);
    206         psError(PS_ERR_UNKNOWN, false, "database error");
    207         return false;
    208     }
    209 
    210     psFree(query);
    211 
    212     return true;
    213 }
    214 
    215 
    216143bool pxcamQueueByChipID(pxConfig *config,
    217144                    psS64 chip_id,
    218145                    char *workdir,
    219146                    char *label,
     147                    char *data_group,
     148                    char *dist_group,
    220149                    char *recipe,
    221150                    char *expgroup,
    222151                    char *dvodb,
    223152                    char *tess_id,
    224                     char *end_stage)
     153                    char *end_stage,
     154                    psS64 magicked,
     155                    char *note)
    225156{
    226157    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    232163        psMemSetPersistent(query, true);
    233164        if (!query) {
    234             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     165            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    235166            return false;
    236167        }
    … …  
    238169
    239170    // queue the exp
    240     // XXX chip_id is being cast here work around psS64 have a different type
     171    // XXX chip_id and magicked are being cast here work around psS64 have a different type
    241172    // different on 32/64
    242173    if (!p_psDBRunQueryF(config->dbh, query,
    … …  
    245176                "dirty", //workdir_state
    246177                label    ? label    : "NULL",
     178                data_group ? data_group : "NULL",
     179                dist_group ? dist_group : "NULL",
    247180                recipe   ? recipe   : "NULL",
    248181                expgroup ? expgroup : "NULL",
    … …  
    250183                tess_id  ? tess_id  : "NULL",
    251184                end_stage ? end_stage : "NULL",
     185                (long long) magicked,
     186                note     ? note     : "NULL",
    252187                (long long)chip_id
    253188    )) {

  • branches/simtest_nebulous_branches/ippTools/src/pxcam.h

    r24681 r27840  
    2626
    2727bool pxcamRunSetState(pxConfig *config, psS64 cam_id, const char *state, psS64 magicked);
    28 bool pxcamRunSetStateByQuery(pxConfig *config, psMetadata *where, const char *state);
    29 bool pxcamRunSetLabel(pxConfig *config, psS64 cam_id, const char *label);
    30 bool pxcamRunSetLabelByQuery(pxConfig *config, psMetadata *where, const char *label);
    31 
    3228bool pxcamSetSearchArgs (psMetadata *md);
    3329bool pxcamGetSearchArgs (pxConfig *config, psMetadata *where);
    … …  
    3733                        char *workdir,
    3834                        char *label,
     35                        char *data_group,
     36                        char *dist_group,
    3937                        char *recipe,
    4038                        char *expgroup,
    4139                        char *dvodb,
    4240                        char *tess_id,
    43                         char *end_stage);
     41                        char *end_stage,
     42                        psS64 magicked,
     43                        char *note);
    4444
    4545#endif // PXCAM_H

  • branches/simtest_nebulous_branches/ippTools/src/pxchip.c

    r24866 r27840  
    9696    PXOPT_COPY_STR(config->args, where, "-exp_type", "rawExp.exp_type", "==");
    9797    PXOPT_COPY_STR(config->args, where, "-filelevel", "rawExp.filelevel", "==");
    98     PXOPT_COPY_STR(config->args, where, "-filter", "rawExp.filter", "==");
     98    PXOPT_COPY_STR(config->args, where, "-filter", "rawExp.filter", "LIKE");
    9999    PXOPT_COPY_F64(config->args, where, "-airmass_min", "rawExp.airmass", ">=");
    100100    PXOPT_COPY_F64(config->args, where, "-airmass_max", "rawExp.airmass", "<");
    … …  
    125125    PXOPT_COPY_F32(config->args, where, "-sun_angle_max", "rawExp.sun_angle", "<");
    126126    PXOPT_COPY_STR(config->args, where, "-comment", "rawExp.comment", "LIKE");
    127     PXOPT_COPY_STR(config->args, where, "-obs_mode", "rawExp.obs_mode", "==");
    128     return true;
    129 }
    130 
    131 bool pxchipRunSetState(pxConfig *config, psS64 chip_id, const char *state, const bool magicked)
     127    PXOPT_COPY_STR(config->args, where, "-obs_mode", "rawExp.obs_mode", "LIKE");
     128    return true;
     129}
     130
     131bool pxchipRunSetState(pxConfig *config, psS64 chip_id, const char *state, const psS64 magicked)
    132132{
    133133    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    140140    }
    141141
    142     char *query = "UPDATE chipRun SET state = '%s', magicked = %d WHERE chip_id = %" PRId64;
     142    char *query = "UPDATE chipRun SET state = '%s', magicked = %" PRId64 " WHERE chip_id = %" PRId64;
    143143    if (!p_psDBRunQueryF(config->dbh, query, state, magicked, chip_id)) {
    144144        psError(PS_ERR_UNKNOWN, false,
    … …  
    175175    psString query = psStringCopy("UPDATE chipRun JOIN rawExp USING(exp_id) SET state = '%s'");
    176176
     177    if (!strcmp(state, "cleaned") || !strcmp(state, "purged")) {
     178        // if magicked is non-zero set it to -1
     179        psStringAppend(&query, ", chipRun.magicked = IF(chipRun.magicked = 0, 0, -1)");
     180    }
     181
    177182    if (where && psListLength(where->list) > 0) {
    178183        psString whereClause = psDBGenerateWhereSQL(where, NULL);
    … …  
    192197}
    193198
    194 
    195 bool pxchipRunSetLabel(pxConfig *config, psS64 chip_id, const char *label)
     199bool pxchipProcessedImfileSetStateByQuery(pxConfig *config, psMetadata *where, const char *state)
    196200{
    197201    PS_ASSERT_PTR_NON_NULL(config, false);
    198     // note label == NULL should be explicitly allowed
    199 
    200     char *query = "UPDATE chipRun SET label = '%s' WHERE chip_id = %" PRId64;
    201     if (!p_psDBRunQueryF(config->dbh, query, label, chip_id)) {
    202         psError(PS_ERR_UNKNOWN, false,
    203                 "failed to change state for chip_id %" PRId64, chip_id);
    204         return false;
    205     }
    206 
    207     return true;
    208 }
    209 
    210 
    211 bool pxchipRunSetLabelByQuery(pxConfig *config, psMetadata *where, const char *label)
    212 {
    213     PS_ASSERT_PTR_NON_NULL(config, false);
    214     // note label == NULL should be explicitly allowed
    215 
    216     psString query = psStringCopy("UPDATE chipRun JOIN rawExp USING(exp_id) SET label = '%s'");
     202    PS_ASSERT_PTR_NON_NULL(state, false);
     203
     204    // check that state is a valid string value
     205    if (!pxIsValidState(state)) {
     206        psError(PS_ERR_UNKNOWN, false, "invalid chipProcessedImfile state: %s", state);
     207        return false;
     208    }
     209
     210/*     if (!strcmp(state, "full")) { */
     211/*         // There are states that need to be met for a run to be set to full that we don't */
     212/*         // check here. */
     213/*         // for example all of the run's Imfiles must have chipProcessedImfile.data_state == "full" */
     214/*         // chipRun.magicked = (SUM(!chipProcessedImfile.magicked) = 0) */
     215/*         // so don't do allow setting the state to full */
     216/*         psError(PS_ERR_UNKNOWN, true, "cannot use -updaterun so set chipRun state to full"); */
     217/*         return false; */
     218/*     } */
     219
     220    psString query = psStringCopy("UPDATE chipProcessedImfile JOIN chipRun USING(chip_id) JOIN rawExp ON chipRun.exp_id = rawExp.exp_id SET data_state = '%s'");
    217221
    218222    if (where && psListLength(where->list) > 0) {
    … …  
    220224        psStringAppend(&query, " %s", whereClause);
    221225        psFree(whereClause);
    222     }
    223 
    224     if (!p_psDBRunQueryF(config->dbh, query, label)) {
     226    } else {
     227        psError(PS_ERR_UNKNOWN, true, "search parameters are required");
     228        return false;
     229    }
     230
     231    if (!p_psDBRunQueryF(config->dbh, query, state)) {
    225232        psFree(query);
    226233        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    232239    return true;
    233240}
    234 
    235241
    236242psS64 pxchipQueueByExpTag(pxConfig *config,
    … …  
    238244                         const char *workdir,
    239245                         const char *label,
     246                         const char *data_group,
     247                         const char *dist_group,
    240248                         const char *reduction,
    241249                         const char *expgroup,
    242250                         const char *dvodb,
    243251                         const char *tess_id,
    244                          const char *end_stage)
     252                         const char *end_stage,
     253                         const char *note)
    245254{
    246255    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    260269            "dirty",    // workdir_state
    261270            label,
     271            data_group,
     272            dist_group,
    262273            reduction,
    263274            expgroup,
    … …  
    265276            tess_id,
    266277            end_stage,
    267             0           // magicked
     278            0,          // magicked
     279            note
    268280            )
    269281    ) {

  • branches/simtest_nebulous_branches/ippTools/src/pxchip.h

    r23381 r27840  
    2525#include "pxtools.h"
    2626
    27 bool pxchipRunSetState(pxConfig *config, psS64 chip_id, const char *state, const bool magicked);
    28 bool pxchipRunSetStateByQuery(pxConfig *config, psMetadata *where, const char *state);
    29 bool pxchipRunSetLabel(pxConfig *config, psS64 chip_id, const char *label);
    30 bool pxchipRunSetLabelByQuery(pxConfig *config, psMetadata *where, const char *label);
     27
     28
     29bool pxchipRunSetState(pxConfig *config, psS64 chip_id, const char *state, const psS64 magicked);
     30bool pxchipProcessedImfileSetStateByQuery(pxConfig *config, psMetadata *where, const char *state);
    3131
    3232psS64 pxchipQueueByExpTag(pxConfig *config,
    … …  
    3434                         const char *workdir,
    3535                         const char *label,
     36                         const char *data_group,
     37                         const char *dist_group,
    3638                         const char *reduction,
    3739                         const char *expgroup,
    3840                         const char *dvodb,
    3941                         const char *tess_id,
    40                          const char *end_stage);
     42                         const char *end_stage,
     43                         const char *note);
    4144
    4245

  • branches/simtest_nebulous_branches/ippTools/src/pxerrors.c

    r23487 r27840  
    2929    switch (err) {
    3030      case PXTOOLS_ERR_SYS:
    31     return PS_EXIT_SYS_ERROR;
     31        return PS_EXIT_SYS_ERROR;
    3232      case PXTOOLS_ERR_CONFIG:
    33     return PS_EXIT_CONFIG_ERROR;
     33        return PS_EXIT_CONFIG_ERROR;
    3434      case PXTOOLS_ERR_PROG:
    35     return PS_EXIT_PROG_ERROR;
    36       case PXTOOLS_ERR_DATA:
    37     return PS_EXIT_DATA_ERROR;
     35        return PS_EXIT_PROG_ERROR;
    3836      default:
    39     return PS_EXIT_UNKNOWN_ERROR;
     37        return PS_EXIT_UNKNOWN_ERROR;
    4038    }
    4139    return PS_EXIT_UNKNOWN_ERROR;

  • branches/simtest_nebulous_branches/ippTools/src/pxfake.c

    r21402 r27840  
    5151}
    5252
    53 
    54 bool pxfakeRunSetStateByQuery(pxConfig *config, psMetadata *where, const char *state)
    55 {
    56     PS_ASSERT_PTR_NON_NULL(config, false);
    57     PS_ASSERT_PTR_NON_NULL(state, false);
    58 
    59     // check that state is a valid string value
    60     if (!pxIsValidState(state)) {
    61         psError(PS_ERR_UNKNOWN, false,
    62                 "invalid fakeRun state: %s", state);
    63         return false;
    64     }
    65 
    66     psString query = psStringCopy("UPDATE fakeRun JOIN camRun USING(cam_id) JOIN chipRun USING(chip_id) JOIN rawExp USING(exp_id) SET fakeRun.state = '%s'");
    67 
    68     if (where) {
    69         psString whereClause = psDBGenerateWhereSQL(where, NULL);
    70         psStringAppend(&query, " %s", whereClause);
    71         psFree(whereClause);
    72     }
    73 
    74     if (!p_psDBRunQueryF(config->dbh, query, state)) {
    75         psFree(query);
    76         psError(PS_ERR_UNKNOWN, false, "database error");
    77         return false;
    78     }
    79 
    80     psFree(query);
    81 
    82     return true;
    83 }
    84 
    85 
    86 bool pxfakeRunSetLabel(pxConfig *config, psS64 fake_id, const char *label)
    87 {
    88     PS_ASSERT_PTR_NON_NULL(config, false);
    89     // note label == NULL should be explicitly allowed
    90 
    91     char *query = "UPDATE fakeRun SET fakeRun.label = '%s' WHERE fake_id = %" PRId64;
    92     if (!p_psDBRunQueryF(config->dbh, query, label, fake_id)) {
    93         psError(PS_ERR_UNKNOWN, false,
    94                 "failed to change state for fake_id %" PRId64, fake_id);
    95         return false;
    96     }
    97 
    98     return true;
    99 }
    100 
    101 
    102 bool pxfakeRunSetLabelByQuery(pxConfig *config, psMetadata *where, const char *label)
    103 {
    104     PS_ASSERT_PTR_NON_NULL(config, false);
    105     // note label == NULL should be explicitly allowed
    106 
    107     psString query = psStringCopy("UPDATE fakeRun JOIN camRun USING(cam_id) JOIN chipRun USING(chip_id) JOIN rawExp USING(exp_id) SET fakeRun.label = '%s'");
    108 
    109     if (where) {
    110         psString whereClause = psDBGenerateWhereSQL(where, NULL);
    111         psStringAppend(&query, " %s", whereClause);
    112         psFree(whereClause);
    113     }
    114 
    115     if (!p_psDBRunQueryF(config->dbh, query, label)) {
    116         psFree(query);
    117         psError(PS_ERR_UNKNOWN, false, "database error");
    118         return false;
    119     }
    120 
    121     psFree(query);
    122 
    123     return true;
    124 }
    125 
    126 
    12753psS64 pxfakeQueueByCamID(pxConfig *config,
    12854                    psS64 cam_id,
    12955                    char *workdir,
    13056                    char *label,
     57                    char *data_group,
     58                    char *dist_group,
    13159                    char *reduction,
    13260                    char *expgroup,
    13361                    char *dvodb,
    13462                    char *tess_id,
    135                     char *end_stage)
     63                    char *end_stage,
     64                    char *note)
    13665{
    13766    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    14574        psMemSetPersistent(query, true);
    14675        if (!query) {
    147             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     76            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    14877            return false;
    14978        }
    … …  
    15786                workdir  ? workdir  : "NULL",
    15887                label    ? label    : "NULL",
     88                data_group ? data_group : "NULL",
     89                dist_group ? dist_group : "NULL",
    15990                reduction? reduction: "NULL",
    16091                expgroup ? expgroup : "NULL",
    … …  
    16293                tess_id  ? tess_id  : "NULL",
    16394                end_stage ? end_stage : "NULL",
     95                note     ? note     : "NULL",
    16496                (long long)cam_id
    16597    )) {

  • branches/simtest_nebulous_branches/ippTools/src/pxfake.h

    r17938 r27840  
    2626
    2727bool pxfakeRunSetState(pxConfig *config, psS64 fake_id, const char *state);
    28 bool pxfakeRunSetStateByQuery(pxConfig *config, psMetadata *where, const char *state);
    29 bool pxfakeRunSetLabel(pxConfig *config, psS64 fake_id, const char *label);
    30 bool pxfakeRunSetLabelByQuery(pxConfig *config, psMetadata *where, const char *label);
    31 
    3228
    3329psS64 pxfakeQueueByCamID(pxConfig *config,
    … …  
    3531                    char *workdir,
    3632                    char *label,
     33                    char *data_group,
     34                    char *dist_group,
    3735                    char *reduction,
    3836                    char *expgroup,
    3937                    char *dvodb,
    4038                    char *tess_id,
    41                     char *end_stage);
     39                    char *end_stage,
     40                    char *note);
    4241
    4342

  • branches/simtest_nebulous_branches/ippTools/src/pxinject.c

    r18336 r27840  
    137137    PXOPT_LOOKUP_STR(tmp_class_id, config->args, "-tmp_class_id", true, false);
    138138    PXOPT_LOOKUP_STR(uri, config->args, "-uri", true, false);
     139    PXOPT_LOOKUP_S32(bytes, config->args, "-bytes", false, false);
     140    PXOPT_LOOKUP_STR(md5sum, config->args, "-md5sum", false, false);
    139141
    140142    // insert with error flag state set to 0 (no errors)
    141     if (!newImfileInsert(config->dbh, exp_id, tmp_class_id, uri, NULL)) {
     143    if (!newImfileInsert(config->dbh, exp_id, tmp_class_id, uri, NULL, bytes, md5sum)) {
    142144        psError(PS_ERR_UNKNOWN, false, "database error");
    143145        return false;

  • branches/simtest_nebulous_branches/ippTools/src/pxinjectConfig.c

    r18561 r27840  
    6161    psMetadataAddStr(newImfileArgs, PS_LIST_TAIL, "-tmp_class_id",  0,            "define the class ID (required)", NULL);
    6262    psMetadataAddStr(newImfileArgs, PS_LIST_TAIL, "-uri",  0,            "define the URI (required)", NULL);
     63    psMetadataAddS32(newImfileArgs, PS_LIST_TAIL, "-bytes",  0,            "define the size of the file", 0);
     64    psMetadataAddStr(newImfileArgs, PS_LIST_TAIL, "-md5sum",  0,            "define the size of the file", NULL);
    6365
    6466    // -updatenewExp

  • branches/simtest_nebulous_branches/ippTools/src/pxregister.c

    r21402 r27840  
    5858    return true;
    5959}
     60
     61bool pxrawExpSetState(pxConfig *config, psS64 exp_id, const char *state)
     62{
     63    if (!exp_id) {
     64        psError(PS_ERR_UNKNOWN, true, "0 is not a valid exp_id");
     65        return false;
     66    }
     67    PS_ASSERT_PTR_NON_NULL(state, false);
     68
     69    // check that state is a valid string value
     70    if (!(
     71            (strncmp(state, "full", 5) == 0)
     72            || (strncmp(state, "new", 4) == 0)
     73            || (strncmp(state, "goto_compressed", 14) == 0)
     74            || (strncmp(state, "compressed", 11) == 0)
     75            || (strncmp(state, "goto_lossy", 11) == 0)
     76            || (strncmp(state, "lossy", 6) == 0)
     77        )
     78    ) {
     79        psError(PS_ERR_UNKNOWN, false,
     80                "invalid rawExp state: %s", state);
     81        return false;
     82    }
     83
     84    char *query = "UPDATE rawExp SET state = '%s' WHERE exp_id = %"PRId64;
     85    if (!p_psDBRunQueryF(config->dbh, query, state, exp_id)) {
     86        psError(PS_ERR_UNKNOWN, false,
     87                "failed to change state for exp_id %"PRId64, exp_id);
     88        return false;
     89    }
     90
     91    return true;
     92}
     93bool pxrawImfileSetState(pxConfig *config, psS64 exp_id, const char *class_id, const char *state)
     94{
     95    if (!exp_id) {
     96        psError(PS_ERR_UNKNOWN, true, "0 is not a valid exp_id");
     97        return false;
     98    }
     99    PS_ASSERT_PTR_NON_NULL(state, false);
     100
     101    // check that state is a valid string value
     102    if (!(
     103            (strncmp(state, "full", 5) == 0)
     104            || (strncmp(state, "new", 4) == 0)
     105            || (strncmp(state, "goto_compressed", 14) == 0)
     106            || (strncmp(state, "compressed", 11) == 0)
     107            || (strncmp(state, "goto_lossy", 11) == 0)
     108            || (strncmp(state, "lossy", 6) == 0)
     109        )
     110    ) {
     111        psError(PS_ERR_UNKNOWN, false,
     112                "invalid rawImfile data_state: %s", state);
     113        return false;
     114    }
     115
     116    char *query = "UPDATE rawImfile SET data_state = '%s' WHERE class_id = %s AND exp_id = %"PRId64;
     117    if (!p_psDBRunQueryF(config->dbh, query, state, class_id, exp_id)) {
     118        psError(PS_ERR_UNKNOWN, false,
     119                "failed to change state for exp_id %"PRId64, exp_id);
     120        return false;
     121    }
     122
     123    return true;
     124}

  • branches/simtest_nebulous_branches/ippTools/src/pxregister.h

    r18336 r27840  
    2626
    2727bool pxnewExpSetState(pxConfig *config, psS64 exp_id, const char *state);
     28bool pxrawExpSetState(pxConfig *config, psS64 exp_id, const char *state);
     29bool pxrawImfileSetState(pxConfig *config, psS64 exp_id, const char *class_id, const char *state);
    2830
    2931#endif // PXREGISTER_H

  • branches/simtest_nebulous_branches/ippTools/src/pxtools.c

    r23918 r27840  
    3737    if (!strcmp(state, "goto_cleaned")) return true;
    3838    if (!strcmp(state, "error_cleaned")) return true;
     39    if (!strcmp(state, "goto_purged")) return true;
     40    if (!strcmp(state, "error_purged")) return true;
    3941    if (!strcmp(state, "goto_scrubbed")) return true;
    4042    if (!strcmp(state, "error_scrubbed")) return true;
    … …  
    4244    if (!strcmp(state, "update")) return true;
    4345    if (!strcmp(state, "purged")) return true;
    44     if (!strcmp(state, "goto_purged")) return true;
    45     if (!strcmp(state, "error_purged")) return true;
    46 
     46    if (!strcmp(state, "scrubbed")) return true;
    4747    return false;
    4848}
    4949
    50 // 'scrubbed' is a virtual state equivalent to cleaned, but allows files to be removed
    51 // even if the config files is missing
     50// 'scrubbed' is no longer a virtual state equivalent to cleaned, but allows files to be removed
     51// even if the config files is missing.  This change was prompted as files that are cleaned can
     52// be regenerated, but that is not certain after being scrubbed.
    5253
    5354
    … …  
    6061        if (!state) {
    6162            psError(PS_ERR_PROGRAMMING, false, "%s not found in row %ld of table %s",
    62                     columnName, i, tableName);
     63                    columnName, i, tableName);
    6364            return false;
    6465        }
    … …  
    6970            // if state isn't cleaned or full we can't set it to cleaned
    7071            psError(PS_ERR_PROGRAMMING, true, "%s with state %s may not be exported cleaned",
    71                     tableName, state);
     72                    tableName, state);
    7273            return false;
    7374        }
    … …  
    8990    psAssert (entry, "%s should at least have a place-holder", name);
    9091    if (entry->data.str) {
    91         psListIterator *iter = psListIteratorAlloc (item->data.list, PS_LIST_HEAD, true);
    92         psMetadataItem *item = NULL;
    93         while ((item = psListGetAndIncrement(iter))) {
    94             // need to change the name and comment
    95             psFree (item->name);
    96             item->name = psStringCopy (field);
    97             psFree (item->comment);
    98             item->comment = psStringCopy (op);
    99             if (!psMetadataAddItem(where, item, PS_LIST_TAIL, PS_META_DUPLICATE_OK)) {
    100                 psError(PS_ERR_UNKNOWN, false, "failed to add item %s", field);
    101                 psFree(where);
    102                 return false;
    103             }
    104         }
    105         psFree (iter);
    106     }
    107     return true;
    108 }
     92        psListIterator *iter = psListIteratorAlloc (item->data.list, PS_LIST_HEAD, true);
     93        psMetadataItem *item = NULL;
     94        while ((item = psListGetAndIncrement(iter))) {
     95            // need to change the name and comment
     96            psFree (item->name);
     97            item->name = psStringCopy (field);
     98            psFree (item->comment);
     99            item->comment = psStringCopy (op);
     100            if (!psMetadataAddItem(where, item, PS_LIST_TAIL, PS_META_DUPLICATE_OK)) {
     101                psError(PS_ERR_UNKNOWN, false, "failed to add item %s", field);
     102                psFree(where);
     103                return false;
     104            }
     105        }
     106        psFree (iter);
     107    }
     108    return true;
     109}
     110
     111// shared code for updating the various strings for a Run
     112bool pxUpdateRun(pxConfig *config, psMetadata *where, psString *pQuery, psString runTable, psString idColumn, psString fileTable, bool has_dist_group)
     113{
     114    PS_ASSERT_PTR_NON_NULL(config, false);
     115    PS_ASSERT_PTR_NON_NULL(where, false);
     116    PS_ASSERT_PTR_NON_NULL(pQuery, false);
     117    PS_ASSERT_PTR_NON_NULL(*pQuery, false);
     118    PS_ASSERT_PTR_NON_NULL(runTable, false);
     119    PS_ASSERT_PTR_NON_NULL(idColumn, false);
     120    PS_ASSERT_PTR_NON_NULL(fileTable, false);
     121
     122    // make sure that -state is not the only selection parameter
     123    PXOPT_LOOKUP_STR(where_state, config->args, "-state", false, false);
     124    if (where_state && (psListLength(where->list) < 2)) {
     125        psError(PXTOOLS_ERR_CONFIG, true, "selection by -state alone is not allowed");
     126        return false;
     127    }
     128
     129    PXOPT_LOOKUP_STR(state, config->args,       "-set_state", false, false);
     130    PXOPT_LOOKUP_STR(label, config->args,       "-set_label", false, false);
     131    PXOPT_LOOKUP_STR(data_group, config->args,  "-set_data_group", false, false);
     132    PXOPT_LOOKUP_STR(note, config->args,        "-set_note", false, false);
     133
     134    psString dist_group = NULL;
     135    if (has_dist_group) {
     136        PXOPT_LOOKUP_STR(tmp_dist_group, config->args,  "-set_dist_group", false, false);
     137        dist_group = tmp_dist_group;
     138    }
     139
     140    if ((!state) && (!label) && (!data_group) && (has_dist_group && !dist_group) && !(note)) {
     141        psError(PXTOOLS_ERR_CONFIG, false, "parameters are required");
     142        return false;
     143    }
     144
     145    if (state && ! pxIsValidState(state)) {
     146        psError(PXTOOLS_ERR_CONFIG, false, "pxIsValidState failed");
     147        return false;
     148    }
     149
     150    // first paramter is added with "SET param = 'value'"
     151    // subseqent ones with ", param = 'value'"
     152    char *separator = " SET ";
     153    char *comma = ",";
     154
     155#   define addColumn(_tab, _val) \
     156        do { \
     157            if (_val) { \
     158                psStringAppend(pQuery, "%s %s.%s = '%s'", separator, _tab, #_val, _val); \
     159                separator = comma; \
     160            } \
     161        } while (0)
     162
     163    addColumn(runTable, state);
     164    addColumn(runTable, data_group);
     165    if (has_dist_group) {
     166        addColumn(runTable, dist_group);
     167    }
     168    addColumn(runTable, note);
     169    addColumn(runTable, label);
     170
     171    psString joinHook = psStringCopy("");
     172    psString fileWhere = NULL;
     173    if (state && !strcmp(state, "update")) {
     174        psStringAppend(&joinHook, "\n JOIN %s USING(%s)", fileTable, idColumn);
     175        psStringAppend(pQuery, ", %s.data_state = 'update'", fileTable);
     176        psStringAppend(&fileWhere, "AND %s.data_state = 'cleaned'", fileTable);
     177    }
     178
     179    psString whereClause =  psDBGenerateWhereSQL(where, NULL);
     180    psStringAppend(pQuery, " %s", whereClause);
     181    psFree(whereClause);
     182    if (fileWhere) {
     183        psStringAppend(pQuery, "%s", fileWhere);
     184    }
     185
     186    bool mdok;                          // Status of MD lookup
     187    if (psMetadataLookupBool(&mdok, config->args, "-pretend")) {
     188        psLogMsg("pxtools", PS_LOG_INFO, "Query to run: %s\n", *pQuery);
     189        return true;
     190    }
     191
     192    if (!p_psDBRunQueryF(config->dbh, *pQuery, joinHook)) {
     193        psError(PS_ERR_UNKNOWN, false, "database error");
     194        return false;
     195    }
     196
     197    return true;
     198}
     199
     200bool pxLookupVersion(pxConfig *config, psArray **pArray)
     201{
     202    const char *query = "SELECT * FROM dbversion";
     203
     204    if (!p_psDBRunQuery(config->dbh, query)) {
     205        psError(PS_ERR_UNKNOWN, false, "database error");
     206        return false;
     207    }
     208
     209    psArray *output = p_psDBFetchResult(config->dbh);
     210    if (!output) {
     211        psError(PS_ERR_UNKNOWN, false, "database error");
     212        return false;
     213    }
     214    if (!psArrayLength(output)) {
     215        psFree(output);
     216        psError(PS_ERR_UNKNOWN, true, "no rows in dbversion");
     217        return false;
     218    }
     219    if (psArrayLength(output) > 1) {
     220        psError(PS_ERR_UNKNOWN, true, "unexpected number of rows found in dbversion: %ld",
     221                psArrayLength(output));
     222        return false;
     223    }
     224    *pArray = output;
     225
     226    return true;
     227}
     228
     229psString pxGetDBVersion(pxConfig *config)
     230{
     231    PS_ASSERT_PTR_NON_NULL(config, NULL);
     232
     233    psArray *array = NULL;
     234    if (!pxLookupVersion(config, &array)) {
     235        psError(PS_ERR_UNKNOWN, false, "pxLookupVersion failed");
     236        return NULL;
     237    }
     238    psMetadata *md = array->data[0];
     239    if (!md) {
     240        psError(PS_ERR_UNKNOWN, true, "output of pxLookupVersion is null");
     241        return NULL;
     242    }
     243
     244    psString version = psMetadataLookupStr(NULL, md, "schema_version");
     245
     246    return version;
     247}
     248
     249bool pxExportVersion(pxConfig *config, FILE *file)
     250{
     251    PS_ASSERT_PTR_NON_NULL(config, NULL);
     252    PS_ASSERT_PTR_NON_NULL(file, NULL);
     253
     254    psArray *array = NULL;
     255    if (!pxLookupVersion(config, &array) || !array) {
     256        psError(PS_ERR_UNKNOWN, false, "pxLookupVersion failed");
     257        return false;
     258    }
     259    if (!ippdbPrintMetadatas(file, array, "dbversion", true)) {
     260        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     261        psFree(array);
     262        return false;
     263    }
     264    return true;
     265}
     266
     267bool pxCheckImportVersion(pxConfig *config, psMetadata *input)
     268{
     269    PS_ASSERT_PTR_NON_NULL(config, NULL);
     270    PS_ASSERT_PTR_NON_NULL(input, NULL);
     271
     272    // This code was adapted from the way camtool parses the structures.
     273    // Is this really the way to do it?
     274    psMetadataItem *multi_item =  psMetadataLookup(input, "dbversion");
     275    if (!multi_item || (multi_item->type != PS_DATA_METADATA_MULTI)) {
     276        psError(PS_ERR_UNKNOWN, true, "dbversion multi not found in input");
     277        return false;
     278    }
     279
     280    psMetadataItem *dbversion = psListGet(multi_item->data.list, 0);
     281    if (!dbversion) {
     282        psError(PS_ERR_UNKNOWN, true, "dbversion not found in input");
     283        return false;
     284    }
     285
     286    if (!strcmp(dbversion->name, "dbversion")) {
     287        // horray
     288        psMetadata *md = dbversion->data.md;
     289        psString schema_version = pxGetDBVersion(config);
     290        if (!schema_version) {
     291            psError(PS_ERR_UNKNOWN, false, "pxGetDBVersion failed");
     292            return false;
     293        }
     294
     295        psString import_version = psMetadataLookupStr(NULL, md, "schema_version");
     296        if (import_version && strcmp(import_version, schema_version)) {
     297            psError(PS_ERR_UNKNOWN, true, "input file schema_version: %s does not match data base: %s",
     298                import_version, schema_version);
     299            return false;
     300        } else if (!import_version) {
     301            psError(PS_ERR_UNKNOWN, true, "input file schema_version is NULL");
     302            return false;
     303        } else {
     304            // YIPPEE this file is the same version
     305        }
     306    } else {
     307        psError(PS_ERR_UNKNOWN, true, "Unexpected config dump format");
     308        return false;
     309    }
     310
     311    return true;
     312}

  • branches/simtest_nebulous_branches/ippTools/src/pxtools.h

    r24733 r27840  
    3737#include "pxtoolsErrorCodes.h"
    3838
     39#include "pxadd.h"
    3940#include "pxcam.h"
    4041#include "pxchip.h"
    … …  
    4546#include "pxtag.h"
    4647#include "pxtree.h"
     48#include "pxmagic.h"
     49#include "pxspace.h"
    4750
    4851# define MAX_ROWS 10e9
    … …  
    5457
    5558bool pxSetFaultCode(psDB *dbh, const char *tableName, psMetadata *where, psS16 code);
     59bool pxExportVersion(pxConfig *config, FILE *f);
     60bool pxCheckImportVersion(pxConfig *config, psMetadata *md);
    5661
    5762psExit pxerrorGetExitStatus(void);
    … …  
    5964void pxUsage(FILE *stream, int argc, char **argv, const char *modeName, psMetadata *argSet);
    6065bool pxGetOptions(FILE *stream, int argc, char **argv, pxConfig *config, psMetadata *modes, psMetadata *argSets);
     66
     67bool pxUpdateRun(pxConfig *config, psMetadata *where, psString *pQuery, psString runTable, psString idColumn, psString fileTable, bool has_dist_group);
    6168
    6269#define PXOPT_ADD_MODE(option, comment, modeval, argset) \

  • branches/simtest_nebulous_branches/ippTools/src/pxtoolsErrorCodes.dat

    r23695 r27840  
    88CONFIG                  Problem in configure files
    99PROG                    Programming error
    10 DATA                    invalid data

  • branches/simtest_nebulous_branches/ippTools/src/pxwarp.c

    r24487 r27840  
    2929#include "pxwarp.h"
    3030
    31 bool pxwarpRunSetState(pxConfig *config, psS64 warp_id, const char *state)
    32 {
    33     PS_ASSERT_PTR_NON_NULL(config, false);
    34     PS_ASSERT_PTR_NON_NULL(state, false);
    35 
    36     // check that state is a valid string value
    37     if (!pxIsValidState(state)) {
    38         psError(PS_ERR_UNKNOWN, false, "invalid warpRun state: %s", state);
    39         return false;
    40     }
    41 
    42     char *query = "UPDATE warpRun SET state = '%s' WHERE warp_id = %" PRId64;
    43     if (!p_psDBRunQueryF(config->dbh, query, state, warp_id)) {
    44         psError(PS_ERR_UNKNOWN, false,
    45                 "failed to change state for warp_id %" PRId64, warp_id);
    46         return false;
    47     }
    48 
    49     return true;
    50 }
    51 
    52 
    53 bool pxwarpRunSetStateByQuery(pxConfig *config, psMetadata *where, const char *state)
    54 {
    55     PS_ASSERT_PTR_NON_NULL(config, false);
    56     PS_ASSERT_PTR_NON_NULL(state, false);
    57 
    58     // check that state is a valid string value
    59     if (!pxIsValidState(state)) {
    60         psError(PS_ERR_UNKNOWN, false, "invalid warpRun state: %s", state);
    61         return false;
    62     }
    63 
    64     psString query = psStringCopy("UPDATE warpRun JOIN fakeRun USING(fake_id) JOIN camRun USING(cam_id) JOIN chipRun USING(chip_id) JOIN rawExp USING(exp_id) SET warpRun.state = '%s'");
    65 
    66     if (where) {
    67         psString whereClause = psDBGenerateWhereSQL(where, NULL);
    68         if (whereClause && strlen(whereClause) > 0) {
    69             psStringAppend(&query, " %s", whereClause);
    70         }
    71         psFree(whereClause);
    72     }
    73 
    74     if (!p_psDBRunQueryF(config->dbh, query, state)) {
    75         psFree(query);
    76         psError(PS_ERR_UNKNOWN, false, "database error");
    77         return false;
    78     }
    79 
    80     psFree(query);
    81 
    82     return true;
    83 }
    84 
    85 
    86 bool pxwarpRunSetLabel(pxConfig *config, psS64 warp_id, const char *label)
    87 {
    88     PS_ASSERT_PTR_NON_NULL(config, false);
    89     // note label == NULL should be explicitly allowed
    90 
    91     char *query = "UPDATE warpRun SET warpRun.label = '%s' WHERE warp_id = %" PRId64;
    92     if (!p_psDBRunQueryF(config->dbh, query, label, warp_id)) {
    93         psError(PS_ERR_UNKNOWN, false,
    94                 "failed to change label for warp_id %" PRId64, warp_id);
    95         return false;
    96     }
    97 
    98     return true;
    99 }
    100 
    101 
    102 bool pxwarpRunSetLabelByQuery(pxConfig *config, psMetadata *where, const char *label)
    103 {
    104     PS_ASSERT_PTR_NON_NULL(config, false);
    105     // note label == NULL should be explicitly allowed
    106 
    107     psString query = psStringCopy("UPDATE warpRun JOIN fakeRun USING(fake_id) JOIN camRun USING(cam_id) JOIN chipRun USING(chip_id) JOIN rawExp USING(exp_id) SET warpRun.label = '%s'");
    108 
    109     if (where) {
    110         psString whereClause = psDBGenerateWhereSQL(where, NULL);
    111         psStringAppend(&query, " %s", whereClause);
    112         psFree(whereClause);
    113     }
    114 
    115     if (!p_psDBRunQueryF(config->dbh, query, label)) {
    116         psFree(query);
    117         psError(PS_ERR_UNKNOWN, false, "database error");
    118         return false;
    119     }
    120 
    121     psFree(query);
    122 
    123     return true;
    124 }
    125 
    126 
    12731bool pxwarpQueueByFakeID(pxConfig *config,
    12832                         psS64 fake_id,
    12933                         const char *workdir,
    13034                         const char *label,
     35                         const char *data_group,
     36                         const char *dist_group,
    13137                         const char *dvodb,
    13238                         const char *tess_id,
    13339                         const char *reduction,
    134                          const char *end_stage)
     40                         const char *end_stage,
     41                         const char *note)
    13542{
    13643    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    14552        "dirty",    // workdir_state
    14653        label,
     54        data_group,
     55        dist_group,
    14756        dvodb,
    14857        tess_id,
    149                        reduction,
     58        reduction,
    15059        end_stage,
    15160        NULL,      // registered
    152         0          // magicked zero when created will get updated when warpRun goes to 'full'
     61        0,         // magicked set to zero when created may get updated when warpRun goes to 'full'
     62        NULL        // note
    15363    )) {
    15464        psError(PS_ERR_UNKNOWN, false, "database error");

  • branches/simtest_nebulous_branches/ippTools/src/pxwarp.h

    r24487 r27840  
    2525#include "pxtools.h"
    2626
    27 bool pxwarpRunSetState(pxConfig *config, psS64 warp_id, const char *state);
    28 bool pxwarpRunSetStateByQuery(pxConfig *config, psMetadata *where, const char *state);
    29 bool pxwarpRunSetLabel(pxConfig *config, psS64 warp_id, const char *label);
    30 bool pxwarpRunSetLabelByQuery(pxConfig *config, psMetadata *where, const char *label);
    31 
    3227bool pxwarpQueueByFakeID(pxConfig *config,
    3328                         psS64 fake_id,
    3429                         const char *workdir,
    3530                         const char *label,
     31                         const char *data_group,
     32                         const char *dist_group,
    3633                         const char *dvodb,
    3734                         const char *tess_id,
    3835                         const char *reduction,
    39                          const char *end_stage);
     36                         const char *end_stage,
     37                         const char *note);
    4038
    4139#endif // PXWARP_H

  • branches/simtest_nebulous_branches/ippTools/src/pztool.c

    r23688 r27840  
    117117            telescope,
    118118            uri,
    119             NULL  // epoch
     119            NULL,  // epoch
     120            0      // use_compress
    120121        )) {
    121122        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    304305    psArray *cameras = pzGetPendingCameras(config);
    305306    if (!cameras) {
    306         psError(PXTOOLS_ERR_DATA, false, "failed to find any cameras");
     307        psError(PXTOOLS_ERR_CONFIG, false, "failed to find any cameras");
    307308        return false;
    308309    }
    … …  
    314315        psString query = pxDataGet("pztool_pendingimfile.sql");
    315316        if (!query) {
    316             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     317            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    317318            psFree(cameraImfiles);
    318319            return false;
    … …  
    401402    PXOPT_LOOKUP_STR(hostname, config->args, "-hostname", false, false);
    402403    PXOPT_LOOKUP_BOOL(row_lock, config->args, "-row_lock", false);
     404    PXOPT_LOOKUP_S32(bytes, config->args, "-bytes", false, false);
     405    PXOPT_LOOKUP_STR(md5sum, config->args, "-md5sum", false, false);
    403406
    404407    // default values
    … …  
    457460            fault,
    458461            NULL,    // epoch
    459             hostname
     462            hostname,
     463            bytes,
     464            md5sum
    460465    )) {
    461466        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    488493    psString query = pxDataGet("pztool_find_completed_exp.sql");
    489494    if (!query) {
    490         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     495        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    491496        return false;
    492497    }
    … …  
    595600                "       pzDownloadImfile.class_id," // tmp_class_id
    596601                "       pzDownloadImfile.uri,"      // uri
    597                 "       NULL"                       // epoch
     602                "       NULL,"                       // epoch
     603                "       pzDownloadImfile.bytes,"    // bytes
     604                "       pzDownloadImfile.md5sum"    // md5sum
    598605                "   FROM pzDownloadImfile"
    599606                "   WHERE"
    … …  
    777784    psMetadata *where = psMetadataAlloc();
    778785    PXOPT_COPY_STR(config->args, where,  "-exp_name", "exp_name", "==");
    779     PXOPT_COPY_STR(config->args, where, "-inst", "inst", "==");
     786    PXOPT_COPY_STR(config->args, where, "-inst", "camera", "==");
    780787    PXOPT_COPY_STR(config->args, where, "-telescope", "telescope", "==");
    781788    PXOPT_COPY_STR(config->args, where,  "-class", "class", "==");
    … …  
    801808    psMetadata *where = psMetadataAlloc();
    802809    PXOPT_COPY_STR(config->args, where,  "-exp_name", "exp_name", "==");
    803     PXOPT_COPY_STR(config->args, where, "-inst", "inst", "==");
     810    PXOPT_COPY_STR(config->args, where, "-inst", "camera", "==");
    804811    PXOPT_COPY_STR(config->args, where, "-telescope", "telescope", "==");
    805812    PXOPT_COPY_STR(config->args, where,  "-class", "class", "==");
    … …  
    808815    psString query = pxDataGet("pztool_revertcopied.sql");
    809816    if (!query) {
    810         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     817        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    811818        return false;
    812819    }
    … …  
    842849    psString query = pxDataGet("pztool_revert_downloadimfile_faults.sql");
    843850    if (!query) {
    844         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     851        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    845852        return false;
    846853    }
    … …  
    857864    psString query = pxDataGet("pztool_revert_fileset_faults.sql");
    858865    if (!query) {
    859         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     866        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    860867        return false;
    861868    }

  • branches/simtest_nebulous_branches/ippTools/src/pztoolConfig.c

    r23688 r27840  
    3838    config->modules = pmConfigRead(&argc, argv, NULL);
    3939    if (! config->modules) {
    40         psError(PS_ERR_UNKNOWN, false, "Can't find site configuration!\n");
     40        psError(psErrorCodeLast(), false, "Can't find site configuration!\n");
    4141        psFree(config);
    4242        return NULL;
    … …  
    9595    psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-label",  0,        "define the label for the chip stage", NULL);
    9696    psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-hostname",  0,     "define the host that copied the image", NULL);
     97    psMetadataAddS32(copydoneArgs, PS_LIST_TAIL, "-bytes",  0,     "define the size in bytes for the copied image", 0);
     98    psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-md5sum",  0,     "define the md5 sum for the copied image", NULL);
    9799    psMetadataAddS16(copydoneArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code", 0);
    98100    psMetadataAddBool(copydoneArgs, PS_LIST_TAIL, "-row_lock", 0,     "lock pzDownImfile rows while advancing an exposure", false);

  • branches/simtest_nebulous_branches/ippTools/src/receivetool.c

    r24784 r27840  
    105105    // optional
    106106    PXOPT_LOOKUP_STR(comment, config->args, "-comment",  false, false);
     107    PXOPT_LOOKUP_STR(state, config->args, "-state",  false, false);
    107108    PXOPT_LOOKUP_STR(last, config->args, "-last",  false, false);
    108109    PXOPT_LOOKUP_STR(status_product, config->args, "-status_product",  false, false);
    … …  
    110111    PXOPT_LOOKUP_STR(ds_dbhost, config->args, "-ds_dbhost",  false, false);
    111112
    112     if (!receiveSourceInsert(config->dbh, 0, source, product, workdir, comment, last, status_product, ds_dbname, ds_dbhost)) {
     113    if (!receiveSourceInsert(config->dbh, 0, source, product, workdir, state, comment, last, status_product, ds_dbname, ds_dbhost)) {
    113114        psError(PS_ERR_UNKNOWN, false, "Database error");
    114115        return false;
    … …  
    135136    psString query = pxDataGet("receivetool_list.sql");
    136137    if (!query) {
    137         psError(PXTOOLS_ERR_DATA, false, "Failed to retreive SQL statement");
     138        psError(PXTOOLS_ERR_SYS, false, "Failed to retreive SQL statement");
    138139        psFree(where);
    139140        return false;
    … …  
    142143    if (psListLength(where->list)) {
    143144        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    144         psStringAppend(&query, " WHERE %s", whereClause);
     145        psStringAppend(&query, " AND %s", whereClause);
    145146        psFree(whereClause);
    146147    }
    … …  
    194195    psString query = pxDataGet("receivetool_addfileset.sql");
    195196    if (!query) {
    196         psError(PXTOOLS_ERR_DATA, false, "Failed to retreive SQL statement");
     197        psError(PXTOOLS_ERR_SYS, false, "Failed to retreive SQL statement");
    197198        return false;
    198199    }
    … …  
    301302    psString query = pxDataGet("receivetool_pendingfileset.sql");
    302303    if (!query) {
    303         psError(PXTOOLS_ERR_DATA, false, "Failed to retreive SQL statement");
     304        psError(PXTOOLS_ERR_SYS, false, "Failed to retreive SQL statement");
    304305        psFree(where);
    305306        return false;
    … …  
    380381        psString file_type = psMetadataLookupStr(NULL, md, "file_type");
    381382        psString component = psMetadataLookupStr(NULL, md, "component");
    382        
     383
    383384        if (!file) {
    384385            psError(PS_ERR_UNKNOWN, false, "failed to find value for file");
    … …  
    430431    psString query = pxDataGet("receivetool_pendingfile.sql");
    431432    if (!query) {
    432         psError(PXTOOLS_ERR_DATA, false, "Failed to retreive SQL statement");
     433        psError(PXTOOLS_ERR_SYS, false, "Failed to retreive SQL statement");
    433434        psFree(where);
    434435        return false;
    … …  
    513514    psString query = pxDataGet("receivetool_revert.sql");
    514515    if (!query) {
    515         psError(PXTOOLS_ERR_DATA, false, "Failed to retreive SQL statement");
     516        psError(PXTOOLS_ERR_SYS, false, "Failed to retreive SQL statement");
    516517        psFree(where);
    517518        return false;
    … …  
    546547    psString query = pxDataGet("receivetool_toadvance.sql");
    547548    if (!query) {
    548         psError(PXTOOLS_ERR_DATA, false, "Failed to retreive SQL statement");
     549        psError(PXTOOLS_ERR_SYS, false, "Failed to retreive SQL statement");
    549550        psFree(where);
    550551        return false;
    … …  
    612613    psString query = NULL;              // Query to execute
    613614    psStringAppend(&query, "UPDATE receiveFileset SET ");
    614    
     615
    615616    psString sep = "";
    616617    if (fault) {
    … …  
    630631        sep = ",";
    631632    }
    632    
     633
    633634    psStringAppend(&query, " WHERE fileset_id = %" PRId64, fileset_id);
    634635

  • branches/simtest_nebulous_branches/ippTools/src/receivetoolConfig.c

    r24125 r27840  
    3838    config->modules = pmConfigRead(&argc, argv, NULL);
    3939    if (!config->modules) {
    40         psError(PS_ERR_UNKNOWN, false, "Can't find site configuration!");
     40        psError(psErrorCodeLast(), false, "Can't find site configuration!");
    4141        psFree(config);
    4242        return NULL;
    … …  
    4949    psMetadataAddStr(definesourceArgs, PS_LIST_TAIL, "-workdir",   0, "define workdir (required)", NULL);
    5050    psMetadataAddStr(definesourceArgs, PS_LIST_TAIL, "-comment", 0, "define comment", NULL);
     51    psMetadataAddStr(definesourceArgs, PS_LIST_TAIL, "-state", 0, "define state", "enabled");
    5152    psMetadataAddStr(definesourceArgs, PS_LIST_TAIL, "-last", 0, "define last fileset", NULL);
    5253    psMetadataAddStr(definesourceArgs, PS_LIST_TAIL, "-status_product", 0, "define status_product", NULL);

  • branches/simtest_nebulous_branches/ippTools/src/regtool.c

    r24866 r27840  
    3737static bool revertprocessedimfileMode(pxConfig *config);
    3838static bool updateprocessedimfileMode(pxConfig *config);
     39static bool pendingcompressimfileMode(pxConfig *config);
    3940// exp
    4041static bool pendingexpMode(pxConfig *config);
    … …  
    4445static bool updateprocessedexpMode(pxConfig *config);
    4546static bool cleardupexpMode(pxConfig *config);
     47static bool finishcompressexpMode(pxConfig *config);
     48
     49static bool updatebyqueryMode(pxConfig *config);
     50
    4651static bool exportrunMode(pxConfig *config);
    4752static bool importrunMode(pxConfig *config);
    … …  
    7782        MODECASE(REGTOOL_MODE_REVERTPROCESSEDEXP,    revertprocessedexpMode);
    7883        MODECASE(REGTOOL_MODE_UPDATEPROCESSEDEXP,    updateprocessedexpMode);
     84        MODECASE(REGTOOL_MODE_UPDATEBYQUERY,         updatebyqueryMode);
     85        MODECASE(REGTOOL_MODE_PENDINGCOMPRESSIMFILE, pendingcompressimfileMode);
     86        MODECASE(REGTOOL_MODE_FINISHCOMPRESSEXP,     finishcompressexpMode);
    7987        MODECASE(REGTOOL_MODE_CLEARDUPEXP,           cleardupexpMode);
    8088        MODECASE(REGTOOL_MODE_EXPORTRUN,             exportrunMode);
    … …  
    117125    psString query = pxDataGet("regtool_pendingimfile.sql");
    118126    if (!query) {
    119         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     127        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    120128        return false;
    121129    }
    … …  
    189197    PXOPT_LOOKUP_STR(obs_mode, config->args, "-obs_mode", false, false);
    190198    PXOPT_LOOKUP_STR(obs_group, config->args, "-obs_group", false, false);
     199    PXOPT_LOOKUP_STR(data_state, config->args, "-data_state", false, false);
    191200
    192201    PXOPT_LOOKUP_F32(airmass, config->args, "-airmass", false, false);
    … …  
    224233    PXOPT_LOOKUP_F32(teltemp_extra, config->args, "-teltemp_extra", false, false);
    225234    PXOPT_LOOKUP_F32(pon_time, config->args, "-pon_time", false, false);
     235    PXOPT_LOOKUP_S16(burntool_state, config->args, "-burntool_state", false, false);
    226236    PXOPT_LOOKUP_F64(user_1, config->args, "-user_1", false, false);
    227237    PXOPT_LOOKUP_F64(user_2, config->args, "-user_2", false, false);
    … …  
    238248    PXOPT_LOOKUP_TIME(dateobs, config->args, "-dateobs", false, false);
    239249    PXOPT_LOOKUP_STR(hostname, config->args, "-hostname", false, false);
     250    PXOPT_LOOKUP_S32(bytes, config->args,  "-bytes", false, false);
     251    PXOPT_LOOKUP_STR(md5sum, config->args, "-md5sum", false, false);
    240252
    241253    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
    … …  
    252264        class_id,
    253265        uri,
     266        data_state,
    254267        exp_type,
    255268        filelevel,
    … …  
    307320        quality,
    308321        NULL,
    309         0
     322        0,
     323        bytes,
     324        md5sum,
     325        0   // burntool_state
    310326    )) {
    311327        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    327343    PXOPT_COPY_TIME(config->args, where, "-dateobs_begin", "dateobs",  ">=");
    328344    PXOPT_COPY_TIME(config->args, where, "-dateobs_end",   "dateobs",  "<=");
     345    PXOPT_COPY_STR(config->args, where,  "-filter",        "filter", "LIKE");
     346    PXOPT_COPY_STR(config->args, where,  "-exp_type",      "exp_type", "==");
     347    PXOPT_COPY_STR(config->args, where,  "-obs_mode",      "obs_mode", "==");
     348    PXOPT_COPY_STR(config->args, where,  "-data_state",    "data_state", "==");
    329349
    330350    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    331351    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
     352    PXOPT_LOOKUP_BOOL(allfiles, config->args, "-allfiles", false);
     353    if (allfiles) {
     354        faulted = false;
     355    }
    332356    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     357    PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
     358    PXOPT_LOOKUP_BOOL(ordered_by_date, config->args, "-ordered_by_date", false);
     359
     360    // build where string for some parameters that don't fit PXOPT_COPY*
     361    psString where2 = NULL;
     362    if (!pxmagicAddWhere(config, &where2, "rawImfile")) {
     363        psError(psErrorCodeLast(), false, "pxmagicAddWhere failed");
     364        return false;
     365    }
     366    if (!pxspaceAddWhere(config, &where2, "rawImfile")) {
     367        psError(psErrorCodeLast(), false, "pxspaceAddWhere failed");
     368        return false;
     369    }
    333370
    334371    psString query = pxDataGet("regtool_processedimfile.sql");
    335372    if (!query) {
    336         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     373        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    337374        psFree(where);
    338375        return false;
    … …  
    343380        psStringAppend(&query, " AND %s", whereClause);
    344381        psFree(whereClause);
     382    } else if (!all && !where2) {
     383        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     384        return false;
    345385    }
    346386    psFree(where);
     387    if (where2) {
     388        psStringAppend(&query, " %s", where2);
     389        psFree(where2);
     390    }
    347391
    348392    if (faulted) {
    349393        // list only faulted rows
    350394        psStringAppend(&query, " %s", "AND rawImfile.fault != 0");
    351     } else {
     395    } else if (!allfiles) {
    352396        // don't list faulted rows
    353397        psStringAppend(&query, " %s", "AND rawImfile.fault = 0");
     398    }
     399
     400    // add the ORDER BY statement if desired
     401    if (ordered_by_date) {
     402        psStringAppend(&query, " ORDER BY dateobs");
    354403    }
    355404
    … …  
    417466    psString query = pxDataGet("regtool_revertprocessedimfile.sql");
    418467    if (!query) {
    419         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     468        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    420469        psFree(where);
    421470        return false;
    … …  
    428477    } else {
    429478        psFree(where);
    430         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     479        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    431480        return false;
    432481    }
    … …  
    456505
    457506    PXOPT_LOOKUP_S16(fault, config->args, "-fault",   false, false);
    458     PXOPT_LOOKUP_F64(user_1, config->args, "-user_1", false, false);
    459 
    460     if ((fault == INT16_MAX) && !isfinite(user_1)) {
    461         psError(PS_ERR_UNKNOWN, false, "one of -fault or -user_1 must be selected");
    462         return false;
    463     }
    464     if ((fault != INT16_MAX) && isfinite(user_1)) {
    465         psError(PS_ERR_UNKNOWN, false, "only one of -fault or -user_1 must be selected");
     507    PXOPT_LOOKUP_S16(burntool_state, config->args, "-burntool_state", false, false);
     508    PXOPT_LOOKUP_S32(set_bytes, config->args, "-set_bytes", false, false);
     509    PXOPT_LOOKUP_STR(set_md5sum, config->args, "-set_md5sum", false, false);
     510    PXOPT_LOOKUP_STR(set_state, config->args, "-set_state", false, false);
     511
     512    if ((fault == INT16_MAX) && !isfinite(burntool_state) && !(set_state)) {
     513        psError(PS_ERR_UNKNOWN, false, "one of -fault or -burntool_state or -set_state must be selected");
     514        return false;
     515    }
     516    if ((fault != INT16_MAX) && isfinite(burntool_state)) {
     517        psError(PS_ERR_UNKNOWN, false, "only one of -fault or -burntool_state must be selected");
    466518        return false;
    467519    }
    … …  
    472524
    473525    if (fault != INT16_MAX) {
    474         // this is fairly dangerous : can set all if the where is not set...
    475         if (!pxSetFaultCode(config->dbh, "rawImfile", where, fault)) {
    476             psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    477             psFree (where);
    478             return false;
    479         }
    480     }
    481 
    482     if (isfinite(user_1)) {
    483         psString query = pxDataGet("regtool_updateprocessedimfile.sql");
    484         if (!query) {
    485             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    486             return false;
    487         }
    488 
    489         if (!p_psDBRunQueryF(config->dbh, query, user_1, exp_id, class_id)) {
    490             psError(PS_ERR_UNKNOWN, false, "database error");
    491             psFree(query);
    492             return false;
    493         }
    494         psFree(query);
     526        // this is fairly dangerous : can set all if the where is not set...
     527        if (!pxSetFaultCode(config->dbh, "rawImfile", where, fault)) {
     528            psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
     529            psFree (where);
     530            return false;
     531        }
     532        psFree (where);
     533        return(true);
    495534    }
    496535    psFree (where);
    497536
     537    psString setvalues = NULL;
     538    if (burntool_state != INT16_MAX) {
     539      psStringAppend(&setvalues,"rawImfile.burntool_state = %d",burntool_state);
     540    }
     541    if (set_bytes != INT32_MAX) {
     542      if (setvalues) {
     543        psStringAppend(&setvalues,",");
     544      }
     545      psStringAppend(&setvalues,"rawImfile.bytes = %d",set_bytes);
     546    }
     547    if (set_md5sum) {
     548      if (setvalues) {
     549        psStringAppend(&setvalues,",");
     550      }
     551      psStringAppend(&setvalues,"rawImfile.md5sum = '%s'",set_md5sum);
     552    }
     553    if (set_state) {
     554      if (setvalues) {
     555        psStringAppend(&setvalues,",");
     556      }
     557      psStringAppend(&setvalues,"rawImfile.data_state = '%s'",set_state);
     558    }
     559
     560    psString query = pxDataGet("regtool_updateprocessedimfile.sql");
     561    if (!query) {
     562      psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     563      return false;
     564    }
     565
     566    //    printf(query,setvalues,exp_id,class_id);
     567    if (!p_psDBRunQueryF(config->dbh, query, setvalues, exp_id,class_id)) {
     568      psError(PS_ERR_UNKNOWN, false, "database error");
     569      psFree(query);
     570      psFree(setvalues);
     571      return false;
     572    }
     573    psFree(setvalues);
     574    psFree(query);
     575
    498576    return true;
     577}
     578
     579static bool pendingcompressimfileMode(pxConfig *config) {
     580  PS_ASSERT_PTR_NON_NULL(config, false);
     581
     582  psMetadata *where = psMetadataAlloc();
     583  PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
     584  PXOPT_COPY_STR(config->args, where, "-class_id", "class_id", "==");
     585
     586  psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     587  if (whereClause) {
     588    psStringPrepend(&whereClause, "\n AND ");
     589  }
     590  PXOPT_LOOKUP_BOOL(compress, config->args, "-compress", false);
     591  PXOPT_LOOKUP_BOOL(clean,    config->args, "-clean", false);
     592
     593  if ((compress && clean) || (!compress && !clean)) {
     594      psStringAppend(&whereClause, "\n AND ((data_state = 'goto_compressed' AND state = 'goto_compressed')\n  OR (data_state = 'goto_lossy' AND state = 'goto_lossy')) ");
     595  }
     596  else if (compress) {
     597    psStringAppend(&whereClause, "\n AND ((data_state = 'goto_compressed' AND state = 'goto_compressed')) ");
     598  }
     599  else if (clean) {
     600    psStringAppend(&whereClause, "\n AND ((data_state = 'goto_lossy' AND state = 'goto_lossy')) ");
     601  }
     602  else {
     603    psStringAppend(&whereClause, "\n AND ((data_state = 'goto_compressed' AND state = 'goto_compressed')\n  OR (data_state = 'goto_lossy' AND state = 'goto_lossy')) ");
     604  }
     605
     606  PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     607  PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     608
     609  psString query = pxDataGet("regtool_pendingcompressimfile.sql");
     610  if (!query) {
     611    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     612    return(false);
     613  }
     614  psString limitString = NULL;
     615  if (limit) {
     616    limitString = psDBGenerateLimitSQL(limit);
     617    psStringPrepend(&limitString, "\n");
     618  }
     619  //  printf(query,whereClause,limitString);
     620  if (!p_psDBRunQueryF(config->dbh, query, whereClause, limitString ? limitString : "")) {
     621    psError(PXTOOLS_ERR_PROG, false, "database error");
     622    psFree(limitString);
     623    psFree(query);
     624    psFree(whereClause);
     625    psFree(where);
     626    return(false);
     627  }
     628  psFree(limitString);
     629  psFree(query);
     630  psFree(whereClause);
     631  psFree(where);
     632
     633  psArray *output = p_psDBFetchResult(config->dbh);
     634  if (!output) {
     635    psErrorCode err = psErrorCodeLast();
     636    switch (err) {
     637    case PS_ERR_DB_CLIENT:
     638      psError(PXTOOLS_ERR_SYS, false, "database error");
     639    case PS_ERR_DB_SERVER:
     640      psError(PXTOOLS_ERR_PROG, false, "database error");
     641    default:
     642      psError(PXTOOLS_ERR_PROG, false, "unknown error");
     643    }
     644
     645    return false;
     646  }
     647  if (!psArrayLength(output)) {
     648    psTrace("regtool", PS_LOG_INFO, "no rows found");
     649    psFree(output);
     650    return true;
     651  }
     652
     653  // negate simple so the default is true
     654  if (!ippdbPrintMetadatas(stdout, output, "regPendingCompressImfile", !simple)) {
     655    psError(PXTOOLS_ERR_PROG, false, "failed to print array");
     656    psFree(output);
     657    return false;
     658  }
     659
     660  psFree(output);
     661
     662  return true;
    499663}
    500664
    … …  
    513677    psString query = pxDataGet("regtool_pendingexp.sql");
    514678    if (!query) {
    515         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     679        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    516680        return false;
    517681    }
    … …  
    590754    PXOPT_LOOKUP_STR(exp_type, config->args, "-exp_type", false, false);
    591755    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", false, false);
     756    PXOPT_LOOKUP_STR(state, config->args, "-state", false, false);
    592757    PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false);
    593758    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", false, false);
    … …  
    651816    psString query = pxDataGet("regtool_pendingexp.sql");
    652817    if (!query) {
    653         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     818        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    654819        return false;
    655820    }
    … …  
    751916        filelevel,
    752917        workdir,
     918        state,
    753919        reduction,
    754920        dvodb,
    … …  
    8491015                workdir,
    8501016                label,
     1017                NULL,       // data_group
     1018                NULL,       // dist_group
    8511019                reduction,
    852                 NULL, // expgroup
     1020                NULL,       // expgroup
    8531021                dvodb,
    8541022                tess_id,
    855                 end_stage
     1023                end_stage,
     1024                NULL        // note
    8561025    )) {
    8571026        // rollback
    … …  
    8811050    psString query = pxDataGet("regtool_processedexp.sql");
    8821051    if (!query) {
    883         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1052        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    8841053        return false;
    8851054    }
    … …  
    8911060    PXOPT_COPY_STR(config->args,   where,  "-inst", "camera", "==");
    8921061    PXOPT_COPY_STR(config->args,   where,  "-telescope", "telescope", "==");
    893     PXOPT_COPY_TIME(config->args,  where, "-dateobs_begin", "dateobs", ">=");
    894     PXOPT_COPY_TIME(config->args,  where, "-dateobs_end", "dateobs", "<=");
     1062    PXOPT_COPY_TIME(config->args,  where,  "-dateobs_begin", "dateobs", ">=");
     1063    PXOPT_COPY_TIME(config->args,  where,  "-dateobs_end", "dateobs", "<=");
     1064    PXOPT_COPY_STR(config->args,   where,  "-state", "state", "==");
    8951065    PXOPT_COPY_STR(config->args,   where,  "-exp_tag", "exp_tag", "==");
    8961066    PXOPT_COPY_STR(config->args,   where,  "-exp_type", "exp_type", "==");
    8971067    PXOPT_COPY_STR(config->args,   where,  "-filelevel", "filelevel", "==");
    8981068    PXOPT_COPY_STR(config->args,   where,  "-reduction", "reduction", "==");
    899     PXOPT_COPY_STR(config->args,   where,  "-filter", "filter", "==");
     1069    PXOPT_COPY_STR(config->args,   where,  "-filter", "filter", "LIKE");
    9001070    PXOPT_COPY_F32(config->args,   where,  "-airmass_min", "airmass", ">=");
    9011071    PXOPT_COPY_F32(config->args,   where,  "-airmass_max", "airmass", "<");
    … …  
    9261096    PXOPT_COPY_F32(config->args,   where,  "-sun_angle_max", "sun_angle", "<");
    9271097
     1098    psString where2 = NULL;
     1099    if (!pxmagicAddWhere(config, &where2, "rawExp")) {
     1100        psError(psErrorCodeLast(), false, "pxmagicAddWhere failed");
     1101        return false;
     1102    }
     1103    if (!pxspaceAddWhere(config, &where2, "rawExp")) {
     1104        psError(psErrorCodeLast(), false, "pxSpaceAddWhere failed");
     1105        return false;
     1106    }
     1107
    9281108    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    9291109    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    9311111
    9321112    if (psListLength(where->list)) {
    933         psString whereClause = psDBGenerateWhereConditionSQL(where, "rawExp");
    934         psStringAppend(&query, " AND %s", whereClause);
    935         psFree(whereClause);
     1113      psString whereClause = psDBGenerateWhereConditionSQL(where, "rawExp");
     1114      psStringAppend(&query, " AND %s", whereClause);
     1115      psFree(whereClause);
    9361116    }
    9371117    psFree(where);
    9381118
     1119    if (where2) {
     1120        psStringAppend(&query, " %s ", where2);
     1121        psFree(where2);
     1122    }
     1123
    9391124    if (faulted) {
    940         // list only faulted rows
    941         psStringAppend(&query, " %s", "AND rawExp.fault != 0");
     1125      // list only faulted rows
     1126      psStringAppend(&query, " %s", "AND rawExp.fault != 0");
    9421127    } else {
    943         // don't list faulted rows
    944         psStringAppend(&query, " %s", "AND rawExp.fault = 0");
     1128      // don't list faulted rows
     1129      psStringAppend(&query, " %s", "AND rawExp.fault = 0");
    9451130    }
    9461131
    9471132    // treat limit == 0 as "no limit"
    9481133    if (limit) {
    949         psString limitString = psDBGenerateLimitSQL(limit);
    950         psStringAppend(&query, " %s", limitString);
    951         psFree(limitString);
     1134      psString limitString = psDBGenerateLimitSQL(limit);
     1135      psStringAppend(&query, " %s", limitString);
     1136      psFree(limitString);
    9521137    }
    9531138
    9541139    if (!p_psDBRunQuery(config->dbh, query)) {
    955         psError(PS_ERR_UNKNOWN, false, "database error");
    956         return false;
     1140      psError(PS_ERR_UNKNOWN, false, "database error");
     1141      return false;
    9571142    }
    9581143    psFree(query);
    … …  
    9601145    psArray *output = p_psDBFetchResult(config->dbh);
    9611146    if (!output) {
    962         psErrorCode err = psErrorCodeLast();
    963         switch (err) {
    964             case PS_ERR_DB_CLIENT:
    965                 psError(PXTOOLS_ERR_SYS, false, "database error");
    966             case PS_ERR_DB_SERVER:
    967                 psError(PXTOOLS_ERR_PROG, false, "database error");
    968             default:
    969                 psError(PXTOOLS_ERR_PROG, false, "unknown error");
    970         }
    971 
    972         return false;
     1147      psErrorCode err = psErrorCodeLast();
     1148      switch (err) {
     1149      case PS_ERR_DB_CLIENT:
     1150        psError(PXTOOLS_ERR_SYS, false, "database error");
     1151      case PS_ERR_DB_SERVER:
     1152        psError(PXTOOLS_ERR_PROG, false, "database error");
     1153      default:
     1154        psError(PXTOOLS_ERR_PROG, false, "unknown error");
     1155      }
     1156
     1157      return false;
    9731158    }
    9741159    if (!psArrayLength(output)) {
    975         psTrace("regtool", PS_LOG_INFO, "no rows found");
     1160      psTrace("regtool", PS_LOG_INFO, "no rows found");
     1161      psFree(output);
     1162      return true;
     1163    }
     1164
     1165    if (psArrayLength(output)) {
     1166      // negative simple so the default is true
     1167      if (!ippdbPrintMetadatas(stdout, output, "rawExp", !simple)) {
     1168        psError(PS_ERR_UNKNOWN, false, "failed to print array");
    9761169        psFree(output);
    977         return true;
    978     }
    979 
    980     if (psArrayLength(output)) {
    981         // negative simple so the default is true
    982         if (!ippdbPrintMetadatas(stdout, output, "rawExp", !simple)) {
    983             psError(PS_ERR_UNKNOWN, false, "failed to print array");
    984             psFree(output);
    985             return false;
    986         }
     1170        return false;
     1171      }
    9871172    }
    9881173
    … …  
    9941179static bool revertprocessedexpMode(pxConfig *config)
    9951180{
    996     PS_ASSERT_PTR_NON_NULL(config, false);
    997 
    998     psMetadata *where = psMetadataAlloc();
    999     PXOPT_COPY_S64(config->args, where,  "-exp_id",       "exp_id", "==");
    1000     PXOPT_COPY_S16(config->args, where,  "-fault",         "fault", "==");
    1001     PXOPT_COPY_S64(config->args, where,  "-exp_id_begin", "exp_id", ">=");
    1002     PXOPT_COPY_S64(config->args, where,  "-exp_id_end", "exp_id", "<=");
    1003 
    1004     psString query = pxDataGet("regtool_revertprocessedexp.sql");
    1005     if (!query) {
    1006         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1007         psFree(where);
    1008         return false;
    1009     }
    1010 
    1011     if (psListLength(where->list)) {
    1012         psString whereClause = psDBGenerateWhereConditionSQL(where, "rawExp");
    1013         psStringAppend(&query, " AND %s", whereClause);
    1014         psFree(whereClause);
    1015     } else {
    1016         psFree(where);
    1017         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
    1018         return false;
    1019     }
     1181  PS_ASSERT_PTR_NON_NULL(config, false);
     1182
     1183  psMetadata *where = psMetadataAlloc();
     1184  PXOPT_COPY_S64(config->args, where,  "-exp_id",       "exp_id", "==");
     1185  PXOPT_COPY_S16(config->args, where,  "-fault",         "fault", "==");
     1186  PXOPT_COPY_S64(config->args, where,  "-exp_id_begin", "exp_id", ">=");
     1187  PXOPT_COPY_S64(config->args, where,  "-exp_id_end", "exp_id", "<=");
     1188
     1189  psString query = pxDataGet("regtool_revertprocessedexp.sql");
     1190  if (!query) {
     1191    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10201192    psFree(where);
    1021 
    1022     if (!p_psDBRunQuery(config->dbh, query)) {
    1023         psError(PS_ERR_UNKNOWN, false, "database error");
    1024         psFree(query);
    1025         return false;
    1026     }
     1193    return false;
     1194  }
     1195
     1196  if (psListLength(where->list)) {
     1197    psString whereClause = psDBGenerateWhereConditionSQL(where, "rawExp");
     1198    psStringAppend(&query, " AND %s", whereClause);
     1199    psFree(whereClause);
     1200  } else {
     1201    psFree(where);
     1202    psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     1203    return false;
     1204  }
     1205  psFree(where);
     1206
     1207  if (!p_psDBRunQuery(config->dbh, query)) {
     1208    psError(PS_ERR_UNKNOWN, false, "database error");
    10271209    psFree(query);
    1028 
    1029     int numUpdated = psDBAffectedRows(config->dbh);
    1030 
    1031     psLogMsg("regtool", PS_LOG_INFO, "Updated %d rawExp", numUpdated);
    1032 
    1033     return true;
     1210    return false;
     1211  }
     1212  psFree(query);
     1213
     1214  int numUpdated = psDBAffectedRows(config->dbh);
     1215
     1216  psLogMsg("regtool", PS_LOG_INFO, "Updated %d rawExp", numUpdated);
     1217
     1218  return true;
    10341219}
    10351220
    … …  
    10371222static bool updateprocessedexpMode(pxConfig *config)
    10381223{
    1039     PS_ASSERT_PTR_NON_NULL(config, false);
    1040 
    1041     psMetadata *where = psMetadataAlloc();
    1042     PXOPT_COPY_S64(config->args, where,  "-exp_id",       "exp_id", "==");
    1043 
    1044     PXOPT_LOOKUP_S16(fault, config->args, "-fault", true, false);
    1045 
    1046     if (!pxSetFaultCode(config->dbh, "rawExp", where, fault)) {
    1047         psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    1048         psFree(where);
    1049         return false;
    1050     }
     1224  PS_ASSERT_PTR_NON_NULL(config, false);
     1225
     1226  psMetadata *where = psMetadataAlloc();
     1227  PXOPT_COPY_S64(config->args, where,  "-exp_id",       "exp_id", "==");
     1228
     1229  PXOPT_LOOKUP_S16(fault, config->args, "-fault", true, false);
     1230
     1231  if (!pxSetFaultCode(config->dbh, "rawExp", where, fault)) {
     1232    psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    10511233    psFree(where);
    1052 
    1053     return true;
    1054 }
     1234    return false;
     1235  }
     1236  psFree(where);
     1237
     1238  return true;
     1239}
     1240
     1241
     1242static bool finishcompressexpMode(pxConfig *config) {
     1243
     1244  PS_ASSERT_PTR_NON_NULL(config, false);
     1245
     1246  PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1247
     1248  psMetadata *where = psMetadataAlloc();
     1249  PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
     1250
     1251  PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1252
     1253  psString query = pxDataGet("regtool_finishcompressexp.sql");
     1254  if (!query) {
     1255    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1256    return(false);
     1257  }
     1258  if (where && psListLength(where->list)) {
     1259    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1260    psStringAppend(&query, " %s ", whereClause);
     1261    psFree(whereClause);
     1262  }
     1263  psFree(where);
     1264
     1265  if (limit) {
     1266    psString limitString = psDBGenerateLimitSQL(limit);
     1267    psStringAppend(&query, " %s ", limitString);
     1268    psFree(limitString);
     1269  }
     1270  //  printf(query);
     1271  //  return(false);
     1272  if (!p_psDBRunQuery(config->dbh, query)) {
     1273    psError(PS_ERR_UNKNOWN, false, "database error");
     1274    psFree(query);
     1275    return(false);
     1276  }
     1277  psFree(query);
     1278
     1279  psArray *output = p_psDBFetchResult(config->dbh);
     1280  if (!output) {
     1281    psError(PS_ERR_UNKNOWN, false, "database error");
     1282    return(false);
     1283  }
     1284  if (!psArrayLength(output)) {
     1285    psTrace("chiptool", PS_LOG_INFO, "no rows found");
     1286    psFree(output);
     1287    return(true);
     1288  }
     1289
     1290  for (long i = 0; i < psArrayLength(output); i++) {
     1291    psMetadata *md = output->data[i];
     1292
     1293    rawExpRow *row = rawExpObjectFromMetadata(md);
     1294    if (!psDBTransaction(config->dbh)) {
     1295      psError(PS_ERR_UNKNOWN, false, "database error");
     1296      return(false);
     1297    }
     1298
     1299    if (strcmp(row->state,"goto_compressed") == 0) {
     1300      if (!pxrawExpSetState(config,row->exp_id, "compressed")) {
     1301        psError(PS_ERR_UNKNOWN, false, "failed to set rawExp.state for exp_id: %" PRId64, row->exp_id);
     1302        psFree(row);
     1303        psFree(output);
     1304        return(false);
     1305      }
     1306    }
     1307    else if (strcmp(row->state,"goto_lossy") == 0) {
     1308      if (!pxrawExpSetState(config,row->exp_id, "lossy")) {
     1309        psError(PS_ERR_UNKNOWN, false, "failed to set rawExp.state for exp_id: %" PRId64, row->exp_id);
     1310        psFree(row);
     1311        psFree(output);
     1312        return(false);
     1313      }
     1314    }
     1315    if (!psDBCommit(config->dbh)) {
     1316      psError(PS_ERR_UNKNOWN, false, "database error");
     1317      return false;
     1318    }
     1319    psFree(row);
     1320  }
     1321
     1322  psFree(output);
     1323  return(true);
     1324}
     1325
     1326static bool updatebyqueryMode(pxConfig *config) {
     1327  PS_ASSERT_PTR_NON_NULL(config, false);
     1328
     1329  PXOPT_LOOKUP_STR(set_state, config->args, "-set_state", true, false);
     1330
     1331  // XX test this out; need to make this consistent with the list in regtoolConfig.c
     1332  psMetadata *where = psMetadataAlloc();
     1333  PXOPT_COPY_S64(config->args,   where,  "-exp_id", "rawExp.exp_id", "==");
     1334  PXOPT_COPY_STR(config->args,   where,  "-exp_name", "rawExp.exp_name", "==");
     1335  PXOPT_COPY_STR(config->args,   where,  "-inst", "rawExp.camera", "==");
     1336  PXOPT_COPY_STR(config->args,   where,  "-telescope", "rawExp.telescope", "==");
     1337  PXOPT_COPY_TIME(config->args,  where, "-dateobs_begin", "rawExp.dateobs", ">=");
     1338  PXOPT_COPY_TIME(config->args,  where, "-dateobs_end", "rawExp.dateobs", "<=");
     1339  PXOPT_COPY_STR(config->args,   where,  "-exp_tag", "rawExp.exp_tag", "==");
     1340  PXOPT_COPY_STR(config->args,   where,  "-exp_type", "rawExp.exp_type", "==");
     1341  PXOPT_COPY_STR(config->args,   where,  "-filelevel", "rawExp.filelevel", "==");
     1342  PXOPT_COPY_STR(config->args,   where,  "-state",     "rawExp.state", "==");
     1343  PXOPT_COPY_STR(config->args,   where,  "-reduction", "rawExp.reduction", "==");
     1344  PXOPT_COPY_STR(config->args,   where,  "-filter", "rawExp.filter", "==");
     1345  PXOPT_COPY_F32(config->args,   where,  "-airmass_min", "rawExp.airmass", ">=");
     1346  PXOPT_COPY_F32(config->args,   where,  "-airmass_max", "rawExp.airmass", "<");
     1347  PXOPT_COPY_RADEC(config->args, where,  "-ra_min", "rawExp.ra", ">=");
     1348  PXOPT_COPY_RADEC(config->args, where,  "-ra_max", "rawExp.ra", "<");
     1349  PXOPT_COPY_RADEC(config->args, where,  "-decl_min", "rawExp.decl", ">=");
     1350  PXOPT_COPY_RADEC(config->args, where,  "-decl_max", "rawExp.decl", "<");
     1351  PXOPT_COPY_F32(config->args,   where,  "-exp_time_min", "rawExp.exp_time", ">=");
     1352  PXOPT_COPY_F32(config->args,   where,  "-exp_time_max", "rawExp.exp_time", "<");
     1353  PXOPT_COPY_F32(config->args,   where,  "-sat_pixel_frac_min", "rawExp.sat_pixel_frac", ">=");
     1354  PXOPT_COPY_F32(config->args,   where,  "-sat_pixel_frac_max", "rawExp.sat_pixel_frac", "<");
     1355  PXOPT_COPY_F64(config->args,   where,  "-bg_min", "rawExp.bg", ">=");
     1356  PXOPT_COPY_F64(config->args,   where,  "-bg_max", "rawExp.bg", "<");
     1357  PXOPT_COPY_F64(config->args,   where,  "-bg_stdev_min", "rawExp.bg_stdev", ">=");
     1358  PXOPT_COPY_F64(config->args,   where,  "-bg_stdev_max", "rawExp.bg_stdev", "<");
     1359  PXOPT_COPY_F64(config->args,   where,  "-bg_mean_stdev_min", "rawExp.bg_mean_stdev", ">=");
     1360  PXOPT_COPY_F64(config->args,   where,  "-bg_mean_stdev_max", "rawExp.bg_mean_stdev", "<");
     1361  PXOPT_COPY_F64(config->args,   where,  "-alt_min", "rawExp.alt", ">=");
     1362  PXOPT_COPY_F64(config->args,   where,  "-alt_max", "rawExp.alt", "<");
     1363  PXOPT_COPY_F64(config->args,   where,  "-az_min", "rawExp.az", ">=");
     1364  PXOPT_COPY_F64(config->args,   where,  "-az_max", "rawExp.az", "<");
     1365  PXOPT_COPY_F64(config->args,   where,  "-ccd_temp_min", "rawExp.ccd_temp", ">=");
     1366  PXOPT_COPY_F64(config->args,   where,  "-ccd_temp_max", "rawExp.ccd_temp", "<");
     1367  PXOPT_COPY_F64(config->args,   where,  "-posang_min", "rawExp.posang", ">=");
     1368  PXOPT_COPY_F64(config->args,   where,  "-posang_max", "rawExp.posang", "<");
     1369  PXOPT_COPY_F32(config->args,   where,  "-sun_angle_min", "rawExp.sun_angle", ">=");
     1370  PXOPT_COPY_F32(config->args,   where,  "-sun_angle_max", "rawExp.sun_angle", "<");
     1371  PXOPT_COPY_STR(config->args,   where,  "-object", "rawExp.object", "==");
     1372  PXOPT_COPY_STR(config->args,   where,  "-comment", "rawExp.comment", "LIKE");
     1373  PXOPT_COPY_STR(config->args,   where,  "-obs_mode", "rawExp.obs_mode", "LIKE");
     1374
     1375
     1376  psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1377  psStringPrepend(&whereClause,"\n AND ");
     1378  PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1379  PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1380
     1381  psString limitString = NULL;
     1382  if (limit) {
     1383    limitString = psDBGenerateLimitSQL(limit);
     1384    psStringPrepend(&limitString, "\n");
     1385  }
     1386  // Update the imfiles first, because if you select by state, you'll clobber things
     1387  psString query = pxDataGet("regtool_updatebyqueryimfile.sql");
     1388  if (!query) {
     1389    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1390    return(false);
     1391  }
     1392
     1393  //  printf(query,set_state,whereClause,limitString);
     1394  if (!p_psDBRunQueryF(config->dbh, query, set_state, whereClause, limitString ? limitString : "")) {
     1395    psError(PXTOOLS_ERR_PROG, false, "database error");
     1396    psFree(limitString);
     1397    psFree(query);
     1398    psFree(whereClause);
     1399    psFree(where);
     1400    return(false);
     1401  }
     1402
     1403  psFree(query);
     1404  // Now up date the exposure.
     1405  query = pxDataGet("regtool_updatebyquery.sql");
     1406  if (!query) {
     1407    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1408    return(false);
     1409  }
     1410  if (!p_psDBRunQueryF(config->dbh, query, set_state,whereClause, limitString ? limitString : "")) {
     1411    psError(PXTOOLS_ERR_PROG, false, "database error");
     1412    psFree(limitString);
     1413    psFree(query);
     1414    psFree(whereClause);
     1415    psFree(where);
     1416    return(false);
     1417  }
     1418
     1419  psFree(limitString);
     1420  psFree(query);
     1421  psFree(whereClause);
     1422  psFree(where);
     1423
     1424  return true;
     1425}
     1426
    10551427
    10561428
    … …  
    10721444            psError(PS_ERR_UNKNOWN, false, "database error");
    10731445        }
    1074         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1446        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10751447        return false;
    10761448    }
    … …  
    10981470            psError(PS_ERR_UNKNOWN, false, "database error");
    10991471        }
    1100         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1472        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11011473        return false;
    11021474    }
    … …  
    11791551  }
    11801552
     1553  if (!pxExportVersion(config, f)) {
     1554    psError(PS_ERR_UNKNOWN, false, "failed to write dbversion to output file");
     1555    return false;
     1556  }
     1557
    11811558  psMetadata *where = psMetadataAlloc();
    11821559  PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    … …  
    11901567    psString query = pxDataGet(tables[i].sqlFilename);
    11911568    if (!query) {
    1192       psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1569      psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11931570      return false;
    11941571    }
    … …  
    12481625
    12491626  psMetadata *input = psMetadataConfigRead (NULL, &nFail, infile, false);
     1627
     1628  if (!pxCheckImportVersion(config, input)) {
     1629    psError(PS_ERR_UNKNOWN, false, "pxCheckImportVersion failed");
     1630    return false;
     1631  }
     1632
    12501633
    12511634  fprintf (stdout, "---- input ----\n");

  • branches/simtest_nebulous_branches/ippTools/src/regtool.h

    r23310 r27840  
    3636    REGTOOL_MODE_UPDATEPROCESSEDEXP,
    3737    REGTOOL_MODE_CLEARDUPEXP,
     38    REGTOOL_MODE_UPDATEBYQUERY,
     39    REGTOOL_MODE_PENDINGCOMPRESSIMFILE,
     40    REGTOOL_MODE_FINISHCOMPRESSEXP,
    3841    REGTOOL_MODE_EXPORTRUN,
    3942    REGTOOL_MODE_IMPORTRUN

  • branches/simtest_nebulous_branches/ippTools/src/regtoolConfig.c

    r24922 r27840  
    4343    config->modules = pmConfigRead(&argc, argv, NULL);
    4444    if (!config->modules) {
    45         psError(PXTOOLS_ERR_CONFIG, false, "Can't find site configuration");
     45        psError(psErrorCodeLast(), false, "Can't find site configuration");
    4646        psFree(config);
    4747        return NULL;
    … …  
    7272    ADD_OPT(Str,  addprocessedimfileArgs, "-comment",        "define comment ",             NULL);
    7373    ADD_OPT(Str,  addprocessedimfileArgs, "-obs_mode",       "define observing mode (data usage goal)",             NULL);
    74     ADD_OPT(Str,  addprocessedimfileArgs, "-obs_group",      "define observing group (set of associated observations)",             NULL);
    75 
     74    ADD_OPT(Str,  addprocessedimfileArgs, "-obs_group",      "define observing group (set of associated observations)",   NULL);
     75    ADD_OPT(Str,  addprocessedimfileArgs, "-data_state",     "define the data_state",       "full");
    7676    // Note: RA & DEC are supplied here in radians, but the query options use degrees.  This
    7777    // can be justified by the fact that this option (addprocessedimfile) is a software
    … …  
    125125    ADD_OPT(Time, addprocessedimfileArgs, "-dateobs",        "define observation time",         NULL);
    126126    ADD_OPT(Str,  addprocessedimfileArgs, "-hostname",       "define host name",                NULL);
     127    ADD_OPT(Str,  addprocessedimfileArgs, "-md5sum",         "define md5sum",                NULL);
     128    ADD_OPT(S32,  addprocessedimfileArgs, "-bytes",          "define bytes",                0);
     129    ADD_OPT(S16,  addprocessedimfileArgs, "-burntool_state",        "set burntool state", 0);
    127130    ADD_OPT(S16,  addprocessedimfileArgs, "-fault",           "set fault code",                  0);
    128131    ADD_OPT(S16,  addprocessedimfileArgs, "-quality",        "set quality flag", 0);
    … …  
    133136    ADD_OPT(Str,  processedimfileArgs, "-exp_name",  "search by exposure name",               NULL);
    134137    ADD_OPT(Str,  processedimfileArgs, "-class_id",  "search by class ID",                    NULL);
     138    ADD_OPT(Str,  processedimfileArgs, "-filter",  "search by filter",                        NULL);
     139    ADD_OPT(Str,  processedimfileArgs, "-obs_mode",  "search by obs_mod",                        NULL);
     140    ADD_OPT(Str,  processedimfileArgs, "-exp_type",  "search by exposure type",                        NULL);
     141    ADD_OPT(Str,  processedimfileArgs, "-data_state", "search by data_state",                 NULL);
    135142    ADD_OPT(Time, processedimfileArgs, "-dateobs_begin", "search for exposures by time (>=)", NULL);
    136143    ADD_OPT(Time, processedimfileArgs, "-dateobs_end", "search for exposures by time (<)", NULL);
    137144    ADD_OPT(U64,  processedimfileArgs, "-limit",     "limit result set to N items",           0);
    138145    ADD_OPT(Bool, processedimfileArgs, "-faulted",   "only return imfiles with a fault status set", false);
     146    ADD_OPT(Bool, processedimfileArgs, "-allfiles",   "return imfiles regardless of fault status", false);
     147    ADD_OPT(Bool, processedimfileArgs, "-all",   "list without search arguments", false);
    139148    ADD_OPT(Bool, processedimfileArgs, "-simple",    "use the simple output format",          false);
    140149    ADD_OPT(Bool, processedimfileArgs, "-ordered_by_date", "force output to be in DATE order", false);
     150    pxspaceAddArguments(processedimfileArgs);
     151    pxmagicAddArguments(processedimfileArgs);
    141152
    142153    // -revertprocessedimfile
    … …  
    153164    ADD_OPT(S64, updateprocessedimfileArgs, "-exp_id",        "search by exposure ID", 0);
    154165    ADD_OPT(Str, updateprocessedimfileArgs, "-class_id",      "search by class ID", NULL);
    155     ADD_OPT(F64, updateprocessedimfileArgs, "-user_1",        "set user stat (1)", NAN);
     166    ADD_OPT(S16, updateprocessedimfileArgs, "-burntool_state",        "set burntool state", INT16_MAX);
    156167    ADD_OPT(S16, updateprocessedimfileArgs, "-fault",          "set fault code", INT16_MAX);
    157 
     168    ADD_OPT(S32, updateprocessedimfileArgs, "-set_bytes",      "set bytes", INT32_MAX);
     169    ADD_OPT(Str, updateprocessedimfileArgs, "-set_md5sum",     "set md5sum", NULL);
     170    ADD_OPT(Str, updateprocessedimfileArgs, "-set_state",      "set data state", NULL);
     171
     172   
    158173    // -pendingexp
    159174    psMetadata *pendingexpArgs = psMetadataAlloc();
    … …  
    176191    ADD_OPT(Str,  addprocessedexpArgs, "-exp_type",         "define exposure type", NULL);
    177192    ADD_OPT(Str,  addprocessedexpArgs, "-workdir",          "define the \"default\" workdir for this exposure", NULL);
     193    ADD_OPT(Str,  addprocessedexpArgs, "-state",            "define the state for this exposure", NULL);
    178194    ADD_OPT(Str,  addprocessedexpArgs, "-dvodb",            "define the dvodb for the next processing step", NULL);
    179195    ADD_OPT(Str,  addprocessedexpArgs, "-tess_id",          "define the tess_id for the next processing step", NULL);
    … …  
    244260    psMetadataAddTime(processedexpArgs, PS_LIST_TAIL, "-dateobs_begin", 0,            "search for exposures by time (>=)", NULL);
    245261    psMetadataAddTime(processedexpArgs, PS_LIST_TAIL, "-dateobs_end",   0,            "search for exposures by time (<)", NULL);
     262    psMetadataAddStr(processedexpArgs,  PS_LIST_TAIL, "-state",         0,            "search by exposure state", NULL);
    246263    psMetadataAddStr(processedexpArgs,  PS_LIST_TAIL, "-exp_tag",       0,            "search by exp_tag", NULL);
    247264    psMetadataAddStr(processedexpArgs,  PS_LIST_TAIL, "-exp_type",      0,            "search by exp_type", "object");
    … …  
    276293    psMetadataAddF32(processedexpArgs,  PS_LIST_TAIL, "-sun_angle_min",    0,         "define min solar angle", NAN);
    277294    psMetadataAddF32(processedexpArgs,  PS_LIST_TAIL, "-sun_angle_max",    0,         "define max solar angle", NAN);
     295    pxspaceAddArguments(processedexpArgs);
     296    pxmagicAddArguments(processedexpArgs);
    278297
    279298    psMetadataAddU64(processedexpArgs,  PS_LIST_TAIL, "-limit",         0,            "limit result set to N items", 0);
    … …  
    292311    psMetadataAddS64(updatedprocessedexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", 0);
    293312    psMetadataAddS16(updatedprocessedexpArgs, PS_LIST_TAIL, "-fault",    0,            "set fault code (required)", INT16_MAX);
    294 
     313    psMetadataAddStr(updatedprocessedexpArgs, PS_LIST_TAIL, "-set_state", 0,           "set state", NULL);
    295314    // -exportrun
    296315    psMetadata *exportrunArgs = psMetadataAlloc();
    … …  
    303322    psMetadataAddStr(importrunArgs, PS_LIST_TAIL, "-infile",  0,          "import from this file (required)", NULL);
    304323
    305 
    306324    // -cleardupexp
    307325    psMetadata *cleardupexpArgs = psMetadataAlloc();
    308326
     327    // -updatebyquery
     328    psMetadata *updatebyqueryArgs = psMetadataAlloc();
     329   
     330    psMetadataAddStr(updatebyqueryArgs,  PS_LIST_TAIL, "-set_state",     0,            "set the state", NULL);
     331                     
     332    psMetadataAddS64(updatebyqueryArgs,  PS_LIST_TAIL, "-exp_id",        0,            "search by exposure ID", 0);
     333    psMetadataAddStr(updatebyqueryArgs,  PS_LIST_TAIL, "-exp_name",      0,            "search by exp_name", NULL);
     334    psMetadataAddStr(updatebyqueryArgs,  PS_LIST_TAIL, "-inst",          0,            "search for camera", NULL);
     335    psMetadataAddStr(updatebyqueryArgs,  PS_LIST_TAIL, "-telescope",     0,            "search for telescope", NULL);
     336    psMetadataAddTime(updatebyqueryArgs, PS_LIST_TAIL, "-dateobs_begin", 0,            "search for exposures by time (>=)", NULL);
     337    psMetadataAddTime(updatebyqueryArgs, PS_LIST_TAIL, "-dateobs_end",   0,            "search for exposures by time (<)", NULL);
     338    psMetadataAddStr(updatebyqueryArgs,  PS_LIST_TAIL, "-exp_tag",       0,            "search by exp_tag", NULL);
     339    psMetadataAddStr(updatebyqueryArgs,  PS_LIST_TAIL, "-exp_type",      0,            "search by exp_type", NULL);
     340    psMetadataAddStr(updatebyqueryArgs,  PS_LIST_TAIL, "-filelevel",     0,            "search by filelevel", NULL);
     341    psMetadataAddStr(updatebyqueryArgs,  PS_LIST_TAIL, "-state",         0,            "search by rawExp.state", NULL);
     342    psMetadataAddStr(updatebyqueryArgs,  PS_LIST_TAIL, "-reduction",     0,            "search by reduction class", NULL);
     343    psMetadataAddStr(updatebyqueryArgs,  PS_LIST_TAIL, "-filter",        0,            "search for filter", NULL);
     344    psMetadataAddF32(updatebyqueryArgs,  PS_LIST_TAIL, "-airmass_min",   0,            "search by min airmass", NAN);
     345    psMetadataAddF32(updatebyqueryArgs,  PS_LIST_TAIL, "-airmass_max",   0,            "search by max airmass", NAN);
     346    psMetadataAddF64(updatebyqueryArgs,  PS_LIST_TAIL, "-ra_min",        0,            "search by min RA (degrees) ", NAN);
     347    psMetadataAddF64(updatebyqueryArgs,  PS_LIST_TAIL, "-ra_max",        0,            "search by max RA (degrees) ", NAN);
     348    psMetadataAddF64(updatebyqueryArgs,  PS_LIST_TAIL, "-decl_min",      0,            "search by min DEC (degrees)", NAN);
     349    psMetadataAddF64(updatebyqueryArgs,  PS_LIST_TAIL, "-decl_max",      0,            "search by max DEC (degrees)", NAN);
     350    psMetadataAddF32(updatebyqueryArgs,  PS_LIST_TAIL, "-exp_time_min",  0,            "search by min exposure time", NAN);
     351    psMetadataAddF32(updatebyqueryArgs,  PS_LIST_TAIL, "-exp_time_max",  0,            "search by max exposure time", NAN);
     352    psMetadataAddF32(updatebyqueryArgs,  PS_LIST_TAIL, "-sat_pixel_frac_min",  0,      "search by min fraction of saturated pixels", NAN);
     353    psMetadataAddF32(updatebyqueryArgs,  PS_LIST_TAIL, "-sat_pixel_frac_max",  0,      "search by max fraction of saturated pixels", NAN);
     354    psMetadataAddF64(updatebyqueryArgs,  PS_LIST_TAIL, "-bg_min",        0,            "search by min background", NAN);
     355    psMetadataAddF64(updatebyqueryArgs,  PS_LIST_TAIL, "-bg_max",        0,            "search by max background", NAN);
     356    psMetadataAddF64(updatebyqueryArgs,  PS_LIST_TAIL, "-bg_stdev_min",  0,            "search by min background standard deviation", NAN);
     357    psMetadataAddF64(updatebyqueryArgs,  PS_LIST_TAIL, "-bg_stdev_max",  0,            "search by max background standard deviation", NAN);
     358    psMetadataAddF64(updatebyqueryArgs,  PS_LIST_TAIL, "-bg_mean_stdev_min",  0,       "search by min background mean standard deviation (across imfiles)", NAN);
     359    psMetadataAddF64(updatebyqueryArgs,  PS_LIST_TAIL, "-bg_mean_stdev_max",  0,       "search by max background mean standard deviation (across imfiles)", NAN);
     360    psMetadataAddF64(updatebyqueryArgs,  PS_LIST_TAIL, "-alt_min",       0,            "search by min altitude", NAN);
     361    psMetadataAddF64(updatebyqueryArgs,  PS_LIST_TAIL, "-alt_max",       0,            "search by max altitude", NAN);
     362    psMetadataAddF64(updatebyqueryArgs,  PS_LIST_TAIL, "-az_min",        0,            "search by min azimuth ", NAN);
     363    psMetadataAddF64(updatebyqueryArgs,  PS_LIST_TAIL, "-az_max",        0,            "search by max azimuth ", NAN);
     364    psMetadataAddF64(updatebyqueryArgs,  PS_LIST_TAIL, "-ccd_temp_min",  0,            "search by min ccd tempature", NAN);
     365    psMetadataAddF64(updatebyqueryArgs,  PS_LIST_TAIL, "-ccd_temp_max",  0,            "search by max ccd tempature", NAN);
     366    psMetadataAddF64(updatebyqueryArgs,  PS_LIST_TAIL, "-posang_min",    0,            "search by min rotator position angle", NAN);
     367    psMetadataAddF64(updatebyqueryArgs,  PS_LIST_TAIL, "-posang_max",    0,            "search by max rotator position angle", NAN);
     368    psMetadataAddF32(updatebyqueryArgs,  PS_LIST_TAIL, "-sun_angle_min",    0,         "search by min solar angle", NAN);
     369    psMetadataAddF32(updatebyqueryArgs,  PS_LIST_TAIL, "-sun_angle_max",    0,         "search by max solar angle", NAN);
     370    psMetadataAddStr(updatebyqueryArgs,  PS_LIST_TAIL, "-object",        0,            "search by exposure object", NULL);
     371    psMetadataAddStr(updatebyqueryArgs,  PS_LIST_TAIL, "-comment",        0,            "search by comment", NULL);
     372    psMetadataAddStr(updatebyqueryArgs,  PS_LIST_TAIL, "-obs_mode",       0,            "search by obs_mode", NULL);
     373   
     374    psMetadataAddU64(updatebyqueryArgs,  PS_LIST_TAIL, "-limit",         0,            "limit result set to N items", 0);
     375    psMetadataAddBool(updatebyqueryArgs, PS_LIST_TAIL, "-simple",        0,            "use the simple output format", false);
     376
     377   
     378    // -pendingcompressimfile
     379    psMetadata *pendingcompressimfileArgs = psMetadataAlloc();
     380    psMetadataAddS64(pendingcompressimfileArgs, PS_LIST_TAIL, "-exp_id", 0,      "search by exp_id", 0);
     381    psMetadataAddStr(pendingcompressimfileArgs, PS_LIST_TAIL, "-class_id", 0,    "search by class ID",                    NULL);
     382    psMetadataAddBool(pendingcompressimfileArgs, PS_LIST_TAIL, "-simple", 0,     "use the simple output format", false);
     383    psMetadataAddU64(pendingcompressimfileArgs, PS_LIST_TAIL, "-limit",   0,     "limit result set to N items", 0);
     384    psMetadataAddBool(pendingcompressimfileArgs, PS_LIST_TAIL, "-compress", 0,   "search only for files to compress", 0);
     385    psMetadataAddBool(pendingcompressimfileArgs, PS_LIST_TAIL, "-clean",  0,     "search only for files to clean originals", 0);
     386   
     387    // -finishcompressexp
     388    psMetadata *finishcompressexpArgs = psMetadataAlloc();
     389    psMetadataAddS64(finishcompressexpArgs, PS_LIST_TAIL, "-exp_id", 0,       "search by exp_id", 0);
     390    psMetadataAddBool(finishcompressexpArgs, PS_LIST_TAIL, "-simple", 0,   "use the simple output format", false);
     391    psMetadataAddU64(finishcompressexpArgs, PS_LIST_TAIL, "-limit",   0,   "limit result set to N items", 0);
     392   
    309393    psMetadata *argSets = psMetadataAlloc();
    310394    psMetadata *modes = psMetadataAlloc();
    … …  
    321405    PXOPT_ADD_MODE("-updateprocessedexp",      "", REGTOOL_MODE_UPDATEPROCESSEDEXP,      updatedprocessedexpArgs);
    322406    PXOPT_ADD_MODE("-cleardupexp",             "", REGTOOL_MODE_CLEARDUPEXP,      cleardupexpArgs);
     407    PXOPT_ADD_MODE("-updatebyquery",           "", REGTOOL_MODE_UPDATEBYQUERY, updatebyqueryArgs);
     408    PXOPT_ADD_MODE("-pendingcompressimfile",   "", REGTOOL_MODE_PENDINGCOMPRESSIMFILE, pendingcompressimfileArgs);
     409    PXOPT_ADD_MODE("-finishcompressexp",       "", REGTOOL_MODE_FINISHCOMPRESSEXP, finishcompressexpArgs);
    323410    PXOPT_ADD_MODE("-exportrun",            "export run for import on other database", REGTOOL_MODE_EXPORTRUN, exportrunArgs);
    324411    PXOPT_ADD_MODE("-importrun",            "import run from metadata file",           REGTOOL_MODE_IMPORTRUN, importrunArgs);

  • branches/simtest_nebulous_branches/ippTools/src/stacktool.c

    r24954 r27840  
    109109
    110110    // required options
    111     PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false);
    112     PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
    113     PXOPT_LOOKUP_STR(reduction, config->args, "-reduction", false, false);
    114     PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false);
     111    PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", true, false);
     112
     113    // optional
     114    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
     115    PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
     116    PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false);
     117    PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false);
     118    PXOPT_LOOKUP_STR(dvodb, config->args, "-set_dvodb", false, false);
     119    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
     120    PXOPT_LOOKUP_TIME(registered, config->args, "-set_registered", false, false);
    115121
    116122    psMetadata *where = psMetadataAlloc();
    … …  
    118124
    119125    // select based on properties of the raw exposures
     126    PXOPT_COPY_STR(config->args,  where, "-select_comment",            "rawExp.comment", "LIKE");
    120127    PXOPT_COPY_STR(config->args,  where, "-select_inst",               "rawExp.camera", "==");
    121128    PXOPT_COPY_STR(config->args,  where, "-select_telescope",          "rawExp.telescope", "==");
    … …  
    139146    PXOPT_COPY_F32(config->args,  where, "-select_fwhm_minor_min",     "camProcessedExp.fwhm_minor", ">=");
    140147    PXOPT_COPY_F32(config->args,  where, "-select_fwhm_minor_max",     "camProcessedExp.fwhm_minor", "<=");
     148    PXOPT_COPY_F32(config->args,  where, "-select_iq_m2_max",          "camProcessedExp.iq_m2", "<=");
     149    PXOPT_COPY_F32(config->args,  where, "-select_iq_m2_min",          "camProcessedExp.iq_m2", ">=");
     150    PXOPT_COPY_F32(config->args,  where, "-select_iq_m3_max",          "camProcessedExp.iq_m3", "<=");
     151    PXOPT_COPY_F32(config->args,  where, "-select_iq_m4_min",          "camProcessedExp.iq_m4", ">=");
     152    PXOPT_COPY_F32(config->args,  where, "-select_iq_m4_max",          "camProcessedExp.iq_m4", "<=");
     153
    141154    PXOPT_COPY_STR(config->args,  where, "-select_exp_type",           "rawExp.exp_type", "==");
    142155    PXOPT_COPY_F32(config->args,  where, "-select_good_frac_min",      "warpSkyfile.good_frac", ">=");
    143156    PXOPT_COPY_STR(config->args,  where, "-select_skycell_id",         "warpSkyfile.skycell_id", "==");
    144     pxAddLabelSearchArgs (config, where, "-select_label",              "warpRun.label", "LIKE");
     157    PXOPT_COPY_STR(config->args,  where, "-select_data_group",         "warpRun.data_group", "==");
     158    pxAddLabelSearchArgs (config, where, "-select_label",              "warpRun.label", "LIKE"); // define using warp label
    145159
    146160    // these are used to build the HAVING restriction
    147161    PXOPT_COPY_S32(config->args, having, "-min_num", "num_warp", ">=");
     162    PXOPT_LOOKUP_S32(min_num,     config->args, "-min_num",  false, false);
     163    if (min_num < 2) {
     164        psError(PXTOOLS_ERR_CONFIG, true, "Require at least two inputs for a stack, but min_num = %d",
     165                min_num);
     166        psFree(where);
     167        psFree(having);
     168        return false;
     169    }
    148170
    149171    // other options applied outside of the WHERE
    … …  
    154176    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    155177    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
    156     PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    157 
    158     if (!psListLength(where->list) &&
    159         !psMetadataLookupBool(NULL, config->args, "-all")) {
     178
     179    if (!psListLength(where->list)) {
     180        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    160181        psFree(where);
    161         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
    162         return false;
    163     }
    164 
    165     psString select = pxDataGet("stacktool_definebyquery_part1.sql");
     182        psFree(having);
     183        return false;
     184    }
     185
     186    psString select = pxDataGet("stacktool_definebyquery_select.sql");
    166187    if (!select) {
    167         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    168         return false;
    169     }
    170 
     188        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     189        psFree(where);
     190        psFree(having);
     191        return false;
     192    }
     193
     194    psString where1 = psStringCopy("");
    171195    if (psListLength(where->list)) {
    172196        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    173         psStringAppend(&select, " AND %s", whereClause);
     197        psStringAppend(&where1, "\nAND %s", whereClause);
    174198        psFree(whereClause);
    175199    }
    176200
    177     psString groupby = pxDataGet("stacktool_definebyquery_part2.sql");
    178     if (!groupby) {
    179         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    180         psFree(where);
    181         return false;
    182     }
    183     psStringAppend(&select, " %s", groupby);
    184     psFree(groupby);
     201    psString where2 = psStringCopy("");
     202    if (label) {
     203        psStringAppend(&where2, "\nWHERE stackRun.label = '%s'", label);
     204    }
    185205
    186206    // Restriction on aggregated quantities using HAVING
    … …  
    214234    psFree(having);
    215235
    216     if (!p_psDBRunQuery(config->dbh, select)) {
     236    if (!p_psDBRunQueryF(config->dbh, select, where1, where2)) {
    217237        psError(PS_ERR_UNKNOWN, false, "database error");
    218238        psFree(select);
    219         psFree(where);
     239        psFree(where1);
     240        psFree(where2);
    220241        return false;
    221242    }
    222243    psFree(select);
     244    psFree(where1);
     245    psFree(where2);
    223246
    224247    psArray *output = p_psDBFetchResult(config->dbh);
    … …  
    262285    }
    263286    if (!insert) {
    264         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     287        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    265288        psFree(where);
    266289        return false;
    … …  
    277300        psString part2 = pxDataGet("stacktool_definebyquery_insert_random_part2.sql");
    278301        if (!part2) {
    279             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     302            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    280303            psFree(insert);
    281304            return false;
    … …  
    339362            workdir,
    340363            label,
     364            data_group ? data_group : label,
     365            dist_group,
    341366            reduction,
    342367            dvodb,
    … …  
    344369            skycell_id,
    345370            tess_id,
    346             filter);
     371            filter,
     372            note);
    347373
    348374        if (!stackRunInsertObject(config->dbh, run)) {
    … …  
    462488
    463489    // required options
    464     PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false);
     490    PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", true, false);
    465491    PXOPT_LOOKUP_STR(skycell_id, config->args, "-skycell_id", true, false);
    466492    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", true, false);
    … …  
    469495    // default
    470496    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    471     PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
     497    PXOPT_LOOKUP_TIME(registered, config->args, "-set_registered", false, false);
    472498
    473499    // options
    474     PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
    475     PXOPT_LOOKUP_STR(reduction, config->args, "-reduction", false, false);
    476     PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false);
     500    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
     501    PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
     502    PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false);
     503    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
     504    PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false);
     505    PXOPT_LOOKUP_STR(dvodb, config->args, "-set_dvodb", false, false);
    477506
    478507    // we have to support multipe exp_ids
    … …  
    489518        workdir,
    490519        label,
     520        data_group ? data_group : label,
     521        dist_group,
    491522        reduction,
    492523        dvodb,
    … …  
    494525        skycell_id,
    495526        tess_id,
    496         filter);
     527        filter,
     528        note);
    497529
    498530    if (!run) {
    … …  
    563595    PS_ASSERT_PTR_NON_NULL(config, false);
    564596
    565     PXOPT_LOOKUP_S64(stack_id, config->args, "-stack_id", true, false);
     597#ifdef notdef
     598    PXOPT_LOOKUP_S64(stack_id, config->args, "-stack_id", false, false);
    566599    PXOPT_LOOKUP_STR(state, config->args, "-state", true, false);
    567 
    568     if (state) {
     600    PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
     601#endif
     602    psMetadata *where = psMetadataAlloc();
     603    PXOPT_COPY_S64(config->args, where, "-stack_id",  "stack_id",   "==");
     604    PXOPT_COPY_STR(config->args, where, "-label",     "label",     "==");
     605    PXOPT_COPY_STR(config->args, where, "-state",     "state",     "==");
     606    if (!psListLength(where->list)) {
     607        psFree(where);
     608        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     609        return false;
     610    }
     611
     612    psString query = psStringCopy("UPDATE stackRun");
     613
     614    // pxUpdateRun gets parameters from config->args and updates
     615    bool result = pxUpdateRun(config, where, &query, "stackRun", "stack_id", "stackSumSkyfile", true);
     616
     617    psFree(query);
     618    psFree(where);
     619
     620    return result;
     621
     622#ifdef notdef
     623    // Hack-y work around to make stacktool more like the other tools, without breaking other stuff (hopefully).
     624
     625    if ((state)&&(stack_id)) {
    569626        // set detRun.state to state
    570627        return setstackRunState(config, stack_id, state);
    571628    }
    572629
    573     return true;
     630    if ((state)&&(label)) {
     631      return setstackRunStateByLabel(config, label, state);
     632    }
     633
     634    psError(PS_ERR_UNKNOWN, false, "Required options not found.");
     635    return false;
     636#endif
    574637}
    575638
    … …  
    613676    psString query = pxDataGet("stacktool_inputskyfile.sql");
    614677    if (!query) {
    615         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     678        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    616679        return false;
    617680    }
    … …  
    619682    if (psListLength(where->list)) {
    620683        psString whereClause = psDBGenerateWhereConditionSQL(where, "stackInputSkyfile");
    621         psStringAppend(&query, " AND %s", whereClause);
     684        psStringAppend(&query, " WHERE %s", whereClause);
    622685        psFree(whereClause);
    623686    }
    … …  
    687750    psString query = pxDataGet("stacktool_tosum.sql");
    688751    if (!query) {
    689         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    690         return false;
    691     }
    692 
     752        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     753        return false;
     754    }
     755
     756    psString whereClause = psStringCopy(""); // WHERE conditions to add
    693757    if (psListLength(where->list)) {
    694         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    695         psStringAppend(&query, " AND %s", whereClause);
    696         psFree(whereClause);
     758        psString new = psDBGenerateWhereConditionSQL(where, NULL);
     759        psStringAppend(&whereClause, "\nAND %s", new);
     760        psFree(new);
    697761    }
    698762    psFree(where);
    … …  
    705769    }
    706770
    707     if (!p_psDBRunQuery(config->dbh, query)) {
     771    if (!p_psDBRunQueryF(config->dbh, query, whereClause)) {
    708772        psError(PS_ERR_UNKNOWN, false, "database error");
    709773        psFree(query);
    … …  
    853917
    854918    psMetadata *where = psMetadataAlloc();
    855     PXOPT_COPY_S64(config->args, where, "-warp_id", "warpRun.warp_id", "==");
    856919    PXOPT_COPY_S64(config->args, where, "-stack_id", "stackSumSkyfile.stack_id", "==");
    857     PXOPT_COPY_S64(config->args, where, "-exp_id", "rawExp.exp_id", "==");
    858     PXOPT_COPY_STR(config->args, where, "-exp_name", "rawExp.exp_name", "==");
    859920    PXOPT_COPY_STR(config->args, where, "-tess_id", "stackRun.tess_id", "==");
    860921    PXOPT_COPY_STR(config->args, where, "-skycell_id", "stackRun.skycell_id", "==");
     922    PXOPT_COPY_STR(config->args, where, "-filter", "stackRun.filter", "LIKE");
     923    PXOPT_COPY_STR(config->args, where, "-label", "stackRun.label", "==");
     924    PXOPT_COPY_STR(config->args, where, "-data_group", "stackRun.data_group", "LIKE");
     925    PXOPT_COPY_S16(config->args, where, "-fault", "stackSumSkyfile.fault", "==");
     926
     927//  The following three selectors are incompatible with the sql so omit them
     928//    PXOPT_COPY_S64(config->args, where, "-warp_id", "warpRun.warp_id", "==");
     929//     PXOPT_COPY_S64(config->args, where, "-exp_id", "rawExp.exp_id", "==");
     930//    PXOPT_COPY_STR(config->args, where, "-exp_name", "rawExp.exp_name", "==");
     931
     932    PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
    861933
    862934    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    865937    psString query = pxDataGet("stacktool_sumskyfile.sql");
    866938    if (!query) {
    867         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     939        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    868940        return false;
    869941    }
    … …  
    873945        psStringAppend(&query, " WHERE %s", whereClause);
    874946        psFree(whereClause);
    875     }
     947    } else if (!all) {
     948        psError(PXTOOLS_ERR_CONFIG, true, "search parameters or -all are required");
     949        return false;
     950    }
     951
    876952    psFree(where);
    877953
    … …  
    9301006    psMetadata *where = psMetadataAlloc();
    9311007    PXOPT_COPY_S64(config->args, where, "-stack_id", "stackSumSkyfile.stack_id", "==");
    932     PXOPT_COPY_STR(config->args, where, "-label", "stackRun.label", "==");
     1008    pxAddLabelSearchArgs(config, where, "-label", "stackRun.label", "==");
    9331009    PXOPT_COPY_S16(config->args, where, "-fault", "stackSumSkyfile.fault", "==");
    9341010
    9351011    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    9361012        psFree(where);
    937         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     1013        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    9381014        return false;
    9391015    }
    … …  
    9421018    psString delete = pxDataGet("stacktool_revertsumskyfile_delete.sql");
    9431019    if (!delete) {
    944         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1020        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    9451021        return false;
    9461022    }
    … …  
    9891065}
    9901066
     1067#ifdef notdef
     1068static bool setstackRunStateByLabel(pxConfig *config, const char *label, const char *state)
     1069{
     1070    PS_ASSERT_PTR_NON_NULL(state, false);
     1071
     1072    // check that state is a valid string value
     1073    if (!pxIsValidState(state)) {
     1074        psError(PS_ERR_UNKNOWN, false, "invalid stackRun state: %s", state);
     1075        return false;
     1076    }
     1077
     1078    char *query = "UPDATE stackRun SET state = '%s' WHERE label = '%s'";
     1079    if (!p_psDBRunQueryF(config->dbh, query, state, label)) {
     1080        psError(PS_ERR_UNKNOWN, false,
     1081                "failed to change state for label %s", label);
     1082        return false;
     1083    }
     1084
     1085    return true;
     1086}
     1087#endif
     1088
    9911089static bool pendingcleanuprunMode(pxConfig *config)
    9921090{
    … …  
    10011099    psString query = pxDataGet("stacktool_pendingcleanuprun.sql");
    10021100    if (!query) {
    1003         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1101        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10041102        return false;
    10051103    }
    … …  
    10651163    psString query = pxDataGet("stacktool_pendingcleanupskyfile.sql");
    10661164    if (!query) {
    1067         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1165        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10681166        return false;
    10691167    }
    … …  
    11261224    psString query = pxDataGet("stacktool_donecleanup.sql");
    11271225    if (!query) {
    1128         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1226        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11291227        return false;
    11301228    }
    … …  
    12141312  }
    12151313
     1314  if (!pxExportVersion(config, f)) {
     1315    psError(PS_ERR_UNKNOWN, false, "failed to write dbversion output file");
     1316    return false;
     1317  }
    12161318  psMetadata *where = psMetadataAlloc();
    12171319  PXOPT_COPY_S64(config->args, where, "-stack_id", "stack_id", "==");
    … …  
    12261328    psString query = pxDataGet(tables[i].sqlFilename);
    12271329    if (!query) {
    1228       psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1330      psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    12291331      return false;
    12301332    }
    … …  
    13001402  psMetadata *input = psMetadataConfigRead (NULL, &nFail, infile, false);
    13011403
    1302   fprintf (stdout, "---- input ----\n");
     1404#ifdef notdef
     1405  fprintf (stderr, "---- input ----\n");
    13031406  psMetadataPrint (stderr, input, 1);
    1304 
     1407#endif
     1408
     1409  if (!pxCheckImportVersion(config, input)) {
     1410      psError(PS_ERR_UNKNOWN, false, "pxCheckImportVersion failed");
     1411      return false;
     1412  }
    13051413  psMetadataItem *item = psMetadataLookup (input, "stackRun");
    13061414  psAssert (item, "entry not in input?");

  • branches/simtest_nebulous_branches/ippTools/src/stacktoolConfig.c

    r24954 r27840  
    3838    config->modules = pmConfigRead(&argc, argv, NULL);
    3939    if (!config->modules) {
    40         psError(PS_ERR_UNKNOWN, false, "Can't find site configuration");
     40        psError(psErrorCodeLast(), false, "Can't find site configuration");
    4141        psFree(config);
    4242        return NULL;
    … …  
    4747    // -definebyquery
    4848    psMetadata *definebyqueryArgs = psMetadataAlloc();
    49     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-workdir", 0, "define workdir (required)", NULL);
    50     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label", 0, "define label", NULL);
    51     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-reduction", 0, "define reduction", NULL);
    52     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-dvodb", 0, "define dvodb", NULL);
    53     psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-registered", 0, "time detrend run was registered", now);
     49    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_workdir", 0, "define workdir (required)", NULL);
     50    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_label", 0, "define label", NULL);
     51    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_data_group", 0, "define data group", NULL);
     52    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_dist_group", 0, "define dist group", NULL);
     53    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_note", 0, "define note", NULL);
     54    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_reduction", 0, "define reduction", NULL);
     55    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_dvodb", 0, "define dvodb", NULL);
     56    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-set_registered", 0, "time detrend run was registered", now);
    5457    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_skycell_id", 0, "search for skycell_id", NULL);
    5558    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_good_frac_min", 0, "define min good_frac", 0.0);
    5659    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_exp_type", 0, "search for exp_type", "object");
    5760    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_label", PS_META_DUPLICATE_OK, "search by warpRun label (LIKE comparison, multiple OK)", NULL);
     61    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_data_group", 0 , "search by warpRun data_group", NULL);
     62    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_comment", 0, "search for comment (LIKE)", NULL);
    5863    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_inst", 0, "search for camera", NULL);
    5964    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_telescope", 0, "search for telescope", NULL);
    … …  
    7782    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_fwhm_minor_min", 0, "define min fwhm (minor axis)", NAN);
    7883    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_fwhm_minor_max", 0, "define max fwhm (minor axis)", NAN);
     84    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_iq_m2_min", 0, "define min iq_m2", NAN);
     85    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_iq_m2_max", 0, "define max iq_m2", NAN);
     86    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_iq_m3_min", 0, "define min iq_m3", NAN);
     87    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_iq_m3_max", 0, "define max iq_m3", NAN);
     88    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_iq_m4_min", 0, "define min iq_m4", NAN);
     89    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_iq_m4_max", 0, "define max iq_m4", NAN);
    7990    psMetadataAddS32(definebyqueryArgs, PS_LIST_TAIL, "-random", 0, "use this number of random elements", 0);
    80     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-all", 0, "allow everything to be queued without search terms", false);
    8191    psMetadataAddS32(definebyqueryArgs, PS_LIST_TAIL, "-min_num", 0, "minimum number of inputs", 0);
    8292    psMetadataAddS32(definebyqueryArgs, PS_LIST_TAIL, "-min_new", 0, "minimum number of new inputs", 0);
    … …  
    8797    // -definerun
    8898    psMetadata *definerunArgs = psMetadataAlloc();
    89     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-workdir", 0,            "define workdir (required)", NULL);
    90     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-label", 0, "define label", NULL);
    91     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-reduction", 0, "define reduction", NULL);
    92     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-dvodb", 0, "define dvodb", NULL);
    93     psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
     99    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_workdir", 0,            "define workdir (required)", NULL);
     100    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_label", 0, "define label", NULL);
     101    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_reduction", 0, "define reduction", NULL);
     102    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_dvodb", 0, "define dvodb", NULL);
     103    psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-set_registered",  0,            "time detrend run was registered", now);
    94104    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-skycell_id",  0,            "define skycell ID (required)", NULL);
    95105    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-tess_id",  0,            "define tessellation ID (required)", NULL);
    … …  
    100110    // -updaterun
    101111    psMetadata *updaterunArgs = psMetadataAlloc();
    102     psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-stack_id", 0,            "define stack ID (required)", 0);
    103     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,            "set state (required)", NULL);
     112    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-stack_id", 0,         "search by stack ID", 0);
     113    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,            "search by state", NULL);
     114    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label", 0,            "search by label", 0);
     115    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_label", 0,        "define new value for label", 0);
     116    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state", 0,        "define new state", NULL);
     117    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_data_group", 0,   "define new data_group", NULL);
     118    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_dist_group", 0,   "define new dist_group", NULL);
     119    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_note", 0,         "define new note", NULL);
    104120
    105121    // -addinputskyfile
    … …  
    158174    psMetadata *sumskyfileArgs= psMetadataAlloc();
    159175    psMetadataAddS64(sumskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,            "search by stack ID", 0);
    160     psMetadataAddS64(sumskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warp ID", 0);
    161176    psMetadataAddStr(sumskyfileArgs, PS_LIST_TAIL, "-tess_id", 0,            "search by tess ID", 0);
    162177    psMetadataAddStr(sumskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0,         "search by skycell ID", 0);
     178#ifdef notdef
     179    // These don't work so omit (for now) We probably should create a different mode for this type of search.
     180    psMetadataAddS64(sumskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warp ID", 0);
    163181    psMetadataAddS64(sumskyfileArgs, PS_LIST_TAIL, "-exp_id", 0,            "search by exposure ID", 0);
    164182    psMetadataAddStr(sumskyfileArgs, PS_LIST_TAIL, "-exp_name", 0,          "search by exposure name", NULL);
     183#endif
     184    psMetadataAddStr(sumskyfileArgs, PS_LIST_TAIL, "-label", 0,             "search by stackRun.label", NULL);
     185    psMetadataAddStr(sumskyfileArgs, PS_LIST_TAIL, "-data_group", 0,        "search by stackRun.data_group (LIKE comparison)", NULL);
     186    psMetadataAddStr(sumskyfileArgs, PS_LIST_TAIL, "-filter", 0,            "search by filter (LIKE comparison)", NULL);
     187    psMetadataAddS16(sumskyfileArgs, PS_LIST_TAIL, "-fault",  0,            "search by fault code", 0);
    165188    psMetadataAddU64(sumskyfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    166189    psMetadataAddBool(sumskyfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     190    psMetadataAddBool(sumskyfileArgs, PS_LIST_TAIL, "-all",  0,            "enable search without arguments", false);
    167191
    168192    // -revertsumskyfile
    169193    psMetadata *revertsumskyfileArgs= psMetadataAlloc();
    170194    psMetadataAddS64(revertsumskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,            "search by stack ID", 0);
    171     psMetadataAddStr(revertsumskyfileArgs, PS_LIST_TAIL, "-label", 0, "search by label", 0);
     195    psMetadataAddStr(revertsumskyfileArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by label", 0);
    172196    psMetadataAddS16(revertsumskyfileArgs, PS_LIST_TAIL, "-fault",  0,            "search by fault code", 0);
    173197    psMetadataAddBool(revertsumskyfileArgs, PS_LIST_TAIL, "-all",  0, "allow no search terms", 0);

  • branches/simtest_nebulous_branches/ippTools/src/warptool.c

    r24956 r27840  
    5353static bool tocleanedskyfileMode(pxConfig *config);
    5454static bool topurgedskyfileMode(pxConfig *config);
     55static bool toscrubbedskyfileMode(pxConfig *config);
    5556static bool tofullskyfileMode(pxConfig *config);
    5657static bool updateskyfileMode(pxConfig *config);
    5758static bool exportrunMode(pxConfig *config);
    5859static bool importrunMode(pxConfig *config);
     60static bool runstateMode(pxConfig *config);
     61static bool listrunMode(pxConfig *config);
     62static bool setskyfiletoupdateMode(pxConfig *config);
    5963
    6064static bool parseAndInsertSkyCellMap(pxConfig *config, const char *mapfile);
    … …  
    102106        MODECASE(WARPTOOL_MODE_TOCLEANEDSKYFILE,   tocleanedskyfileMode);
    103107        MODECASE(WARPTOOL_MODE_TOPURGEDSKYFILE,    topurgedskyfileMode);
     108        MODECASE(WARPTOOL_MODE_TOSCRUBBEDSKYFILE,  toscrubbedskyfileMode);
    104109        MODECASE(WARPTOOL_MODE_TOFULLSKYFILE,      tofullskyfileMode);
    105110        MODECASE(WARPTOOL_MODE_UPDATESKYFILE,      updateskyfileMode);
    106111        MODECASE(WARPTOOL_MODE_EXPORTRUN,          exportrunMode);
    107112        MODECASE(WARPTOOL_MODE_IMPORTRUN,          importrunMode);
     113        MODECASE(WARPTOOL_MODE_RUNSTATE,           runstateMode);
     114        MODECASE(WARPTOOL_MODE_LISTRUN,            listrunMode);
     115        MODECASE(WARPTOOL_MODE_SETSKYFILETOUPDATE, setskyfiletoupdateMode);
    108116
    109117        default:
    … …  
    137145    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false); // required
    138146    PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
     147    PXOPT_LOOKUP_STR(data_group, config->args, "-data_group", false, false);
     148    PXOPT_LOOKUP_STR(dist_group, config->args, "-dist_group", false, false);
     149    PXOPT_LOOKUP_STR(note, config->args, "-note", false, false);
    139150    PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false);
    140151    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", true, false); // required (no default TESS)
    … …  
    158169            "dirty",    // workdir_state
    159170            label,
     171            data_group ? data_group : label,
     172            dist_group,
    160173            dvodb,
    161174            tess_id,
    … …  
    163176            end_stage,
    164177            registered,
    165             0       // magicked
     178            0,       // magicked
     179            note
    166180    );
    167181    if (!warpRun) {
    … …  
    237251    PXOPT_COPY_F32(config->args,   where, "-sun_angle_max",      "rawExp.sun_angle",      "<");
    238252    PXOPT_COPY_STR(config->args,   where, "-reduction",          "fakeRun.reduction",     "==");
    239     pxAddLabelSearchArgs (config,  where, "-label",             "fakeRun.label",         "==");
     253    pxAddLabelSearchArgs (config,  where, "-label",              "fakeRun.label",         "=="); // define using fake label
    240254
    241255    if (!psListLength(where->list) &&
    242256        !psMetadataLookupBool(NULL, config->args, "-all")) {
    243257        psFree(where);
    244         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     258        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    245259        return false;
    246260    }
    … …  
    249263    PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", false, false);
    250264    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
     265    PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
     266    PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false);
    251267    PXOPT_LOOKUP_STR(dvodb, config->args, "-set_dvodb", false, false);
    252268    PXOPT_LOOKUP_STR(tess_id, config->args, "-set_tess_id", false, false);
    253269    PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false);
    254270    PXOPT_LOOKUP_STR(end_stage, config->args, "-set_end_stage", false, false);
     271    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
    255272
    256273    PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    … …  
    266283    psString query = pxDataGet("warptool_definebyquery.sql");
    267284    if (!query) {
    268         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     285        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    269286        psFree(where);
    270287        return false;
    … …  
    338355                                 workdir     ? workdir   : row->workdir,
    339356                                 label       ? label     : row->label,
     357                                 data_group  ? data_group: row->data_group,
     358                                 dist_group  ? dist_group: row->dist_group,
    340359                                 dvodb       ? dvodb     : row->dvodb,
    341360                                 tess_id     ? tess_id   : row->tess_id,
    342361                                 reduction   ? reduction : row->reduction,
    343                                  end_stage   ? end_stage : row->end_stage))
     362                                 end_stage   ? end_stage : row->end_stage,
     363                                 note))
    344364          {
    345365            psError(PS_ERR_UNKNOWN, false, "failed to trying to queue fake_id: %" PRId64, row->fake_id);
    … …  
    367387    PXOPT_COPY_S64(config->args, where, "-warp_id",   "warpRun.warp_id",   "==");
    368388    PXOPT_COPY_STR(config->args, where, "-reduction", "warpRun.reduction", "==");
    369     PXOPT_COPY_STR(config->args, where, "-label",     "warpRun.label",     "==");
    370389    PXOPT_COPY_STR(config->args, where, "-state",     "warpRun.state",     "==");
    371 
    372     if (!psListLength(where->list)
    373         && !psMetadataLookupBool(NULL, config->args, "-all")) {
     390    PXOPT_COPY_STR(config->args, where, "-data_group","warpRun.data_group","==");
     391    PXOPT_COPY_STR(config->args, where, "-dist_group","warpRun.dist_group","==");
     392    pxAddLabelSearchArgs(config,  where, "-label",    "warpRun.label",     "==");
     393
     394    PXOPT_COPY_TIME(config->args, where, "-registered_begin", "warpRun.registered",  ">=");
     395    PXOPT_COPY_TIME(config->args, where, "-registered_end",   "warpRun.registered",  "<");
     396
     397    PXOPT_LOOKUP_BOOL(destreaked, config->args, "-destreaked", false);
     398    if (destreaked) {
     399        psMetadataAddS64(where, PS_LIST_TAIL, "warpRun.magicked", PS_META_DUPLICATE_OK, ">", 0);
     400    }
     401
     402    if (!psListLength(where->list)) {
    374403        psFree(where);
    375         where = NULL;
    376         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
    377         return false;
    378     }
    379 
    380     PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
    381     PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
    382 
    383     if ((!state) && (!label)) {
    384         psError(PXTOOLS_ERR_DATA, false, "parameters (-state or -label) are required");
    385         psFree(where);
    386         return false;
    387     }
    388 
    389     if (state) {
    390         // set warpRun.state to state
    391         if (!pxwarpRunSetStateByQuery(config, where, state)) {
    392             psFree(where);
    393             return false;
    394         }
    395     }
    396 
    397     if (label) {
    398         // set chipRun.label to label
    399         if (!pxwarpRunSetLabelByQuery(config, where, label)) {
    400             psFree(where);
    401             return false;
    402         }
    403     }
    404 
     404        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     405        return false;
     406    }
     407
     408    psString query = psStringCopy("UPDATE warpRun JOIN warpSkyfile USING(warp_id) JOIN fakeRun USING(fake_id) JOIN camRun USING(cam_id) JOIN chipRun USING(chip_id) JOIN rawExp USING(exp_id)");
     409
     410    // pxUpdateRun gets parameters from config->args and updates
     411    bool result = pxUpdateRun(config, where, &query, "warpRun", "warp_id", "warpSkyfile", true);
     412
     413    psFree(query);
    405414    psFree(where);
    406415
    407     return true;
    408 }
    409 
     416    return result;
     417}
    410418
    411419static bool expMode(pxConfig *config)
    … …  
    423431    psString query = pxDataGet("warptool_exp.sql");
    424432    if (!query) {
    425         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     433        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    426434        return false;
    427435    }
    … …  
    497505    psString query = pxDataGet("warptool_imfile.sql");
    498506    if (!query) {
    499         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     507        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    500508        return false;
    501509    }
    … …  
    571579    psString query = pxDataGet("warptool_tooverlap.sql");
    572580    if (!query) {
    573         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     581        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    574582        return false;
    575583    }
    … …  
    680688    PXOPT_COPY_STR(config->args, where, "-skycell_id", "warpSkyCellMap.skycell_id", "==");
    681689    PXOPT_COPY_STR(config->args, where, "-tess_id",    "warpSkyCellMap.tess_id", "==");
    682     // PXOPT_COPY_STR(config->args, where, "-label",      "warpRun.label", "==");
    683690    pxAddLabelSearchArgs (config, where, "-label",     "warpRun.label", "==");
    684691    PXOPT_COPY_S16(config->args, where, "-fault",      "warpSkyCellMap.fault", "==");
    … …  
    687694        && !psMetadataLookupBool(NULL, config->args, "-all")) {
    688695        psFree(where);
    689         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     696        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    690697        return false;
    691698    }
    … …  
    695702        psString query = pxDataGet("warptool_revertoverlap.sql");
    696703        if (!query) {
    697             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     704            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    698705            if (!psDBRollback(config->dbh)) {
    699706                psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    827834    psString query = pxDataGet("warptool_scmap.sql");
    828835    if (!query) {
    829         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     836        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    830837        return false;
    831838    }
    … …  
    900907    psString query = pxDataGet("warptool_towarped.sql");
    901908    if (!query) {
    902         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    903         return false;
    904     }
    905 
     909        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     910        return false;
     911    }
     912
     913    psString whereStr = psStringCopy("");
    906914    if (psListLength(where->list)) {
    907915        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    908         psStringAppend(&query, " AND %s", whereClause);
     916        psStringAppend(&whereStr, "\n AND %s", whereClause);
    909917        psFree(whereClause);
    910918    }
    … …  
    912920
    913921    // treat limit == 0 as "no limit"
     922    psString limitString = psStringCopy("\n");
    914923    if (limit) {
    915         psString limitString = psDBGenerateLimitSQL(limit);
     924        // We apply the limit to both sides of the UNION
     925        // to avoid slow queries and to the query itself
     926        // to satisfy the user's requested limit
     927        psStringAppend(&limitString, "%s", psDBGenerateLimitSQL(limit));
    916928        psStringAppend(&query, " %s", limitString);
    917         psFree(limitString);
    918     }
    919 
    920     if (!p_psDBRunQuery(config->dbh, query)) {
     929    }
     930
     931#define TWO_WHERES
     932#ifdef TWO_WHERES
     933    if (!p_psDBRunQueryF(config->dbh, query, whereStr, limitString, whereStr,  limitString)) {
    921934        psError(PS_ERR_UNKNOWN, false, "database error");
    922935        psFree(query);
    923936        return false;
    924937    }
     938#else
     939    if (!p_psDBRunQueryF(config->dbh, query, whereStr)) {
     940        psError(PS_ERR_UNKNOWN, false, "database error");
     941        psFree(query);
     942        return false;
     943    }
     944#endif
     945    psFree(limitString);
     946    psFree(whereStr);
    925947    psFree(query);
    926948
    … …  
    9811003    PXOPT_LOOKUP_STR(hostname, config->args, "-hostname", false, false);
    9821004    PXOPT_LOOKUP_F32(good_frac, config->args, "-good_frac", false, false);
    983     PXOPT_LOOKUP_S64(magicked, config->args, "-magicked", false, false);
     1005    PXOPT_LOOKUP_S64(magicked, config->args, "-set_magicked", false, false);
    9841006
    9851007    // default values
    … …  
    10441066    psString query = pxDataGet("warptool_finished_run_select.sql");
    10451067    if (!query) {
    1046         psError(PXTOOLS_ERR_DATA, false, "failed to retrieve SQL statement");
     1068        psError(PXTOOLS_ERR_SYS, false, "failed to retrieve SQL statement");
    10471069        return false;
    10481070    }
    … …  
    11201142    psString query = pxDataGet("warptool_finished_run_select.sql");
    11211143    if (!query) {
    1122         psError(PXTOOLS_ERR_DATA, false, "failed to retrieve SQL statement");
     1144        psError(PXTOOLS_ERR_SYS, false, "failed to retrieve SQL statement");
    11231145        return false;
    11241146    }
    … …  
    11961218    PXOPT_COPY_STR(config->args, where, "-exp_name",   "rawExp.exp_name", "==");
    11971219    PXOPT_COPY_S64(config->args, where, "-fake_id",    "fakeRun.fake_id", "==");
     1220    PXOPT_COPY_TIME(config->args, where, "-dateobs_begin", "rawExp.dateobs",  ">=");
     1221    PXOPT_COPY_TIME(config->args, where, "-dateobs_end",   "rawExp.dateobs",  "<=");
     1222    PXOPT_COPY_STR(config->args, where, "-filter",    "rawExp.filter", "LIKE");
     1223    PXOPT_COPY_S64(config->args, where, "-magicked", "warpSkyfile.magicked", "==");
     1224    pxAddLabelSearchArgs (config, where, "-label",   "warpRun.label", "LIKE");
     1225    pxAddLabelSearchArgs (config, where, "-data_group",   "warpRun.data_group", "LIKE");
     1226
     1227    PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
    11981228
    11991229    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    12031233    psString query = pxDataGet("warptool_warped.sql");
    12041234    if (!query) {
    1205         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1235        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1236        return false;
     1237    }
     1238
     1239    // generate where strings for arguments that require extra processing
     1240    // beyond PXOPT_COPY*
     1241    psString where2 = NULL;
     1242    if (!pxmagicAddWhere(config, &where2, "warpSkyfile")) {
     1243        psError(psErrorCodeLast(), false, "pxMagicAddWhere failed");
     1244        return false;
     1245    }
     1246    if (!pxspaceAddWhere(config, &where2, "rawExp")) {
     1247        psError(psErrorCodeLast(), false, "pxSpaceAddWhere failed");
    12061248        return false;
    12071249    }
    … …  
    12091251    if (psListLength(where->list)) {
    12101252        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    1211         psStringAppend(&query, " AND %s", whereClause);
     1253        psStringAppend(&query, " WHERE %s", whereClause);
    12121254        psFree(whereClause);
     1255    } else if (!all && !where2) {
     1256        psError(PXTOOLS_ERR_CONFIG, true, "search parameters or -all are required");
     1257        return false;
     1258    }
     1259
     1260    if (where2) {
     1261        if (psListLength(where->list)) {
     1262            psStringAppend(&query, " %s", where2);
     1263        } else {
     1264            psStringAppend(&query, " WHERE 1 %s", where2);
     1265        }
    12131266    }
    12141267    psFree(where);
    … …  
    12721325    PXOPT_COPY_STR(config->args, where, "-tess_id",    "warpSkyfile.tess_id", "==");
    12731326    PXOPT_COPY_STR(config->args, where, "-reduction",  "rawExp.reduction", "==");
    1274     // PXOPT_COPY_STR(config->args, where, "-label",      "warpRun.label", "==");
    12751327    pxAddLabelSearchArgs (config, where, "-label",     "warpRun.label", "==");
    1276     PXOPT_COPY_S16(config->args, where, "-fault",       "warpSkyfile.fault", "==");
     1328    PXOPT_COPY_S16(config->args, where, "-fault",      "warpSkyfile.fault", "==");
    12771329
    12781330    if (!psListLength(where->list)
    12791331        && !psMetadataLookupBool(NULL, config->args, "-all")) {
    12801332        psFree(where);
    1281         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
    1282         return false;
    1283     }
    1284 
    1285     if (!psDBTransaction(config->dbh)) {
    1286         psError(PS_ERR_UNKNOWN, false, "database error");
    1287         psFree(where);
    1288         return false;
    1289     }
    1290 
    1291     // Delete product
    1292     int numDeleted;                     // Number deleted
    1293     {
    1294         psString query = pxDataGet("warptool_revertwarped_delete.sql");
    1295         if (!query) {
    1296             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1297             if (!psDBRollback(config->dbh)) {
    1298                 psError(PS_ERR_UNKNOWN, false, "database error");
    1299             }
    1300             return false;
    1301         }
    1302 
    1303         if (psListLength(where->list)) {
    1304             psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    1305             psStringAppend(&query, " AND %s", whereClause);
    1306             psFree(whereClause);
    1307         }
    1308 
    1309         if (!p_psDBRunQuery(config->dbh, query)) {
    1310             psError(PS_ERR_UNKNOWN, false, "database error");
    1311             psFree(query);
    1312             if (!psDBRollback(config->dbh)) {
    1313                 psError(PS_ERR_UNKNOWN, false, "database error");
    1314             }
    1315             return false;
    1316         }
     1333        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     1334        return false;
     1335    }
     1336
     1337    psString query = pxDataGet("warptool_revertwarped_delete.sql");
     1338    if (!query) {
     1339        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1340        return false;
     1341    }
     1342    psString query_updated = pxDataGet("warptool_revertwarped_updated.sql");
     1343    if (!query_updated) {
     1344        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1345        return false;
     1346    }
     1347
     1348    if (psListLength(where->list)) {
     1349        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1350        psStringAppend(&query, " AND %s", whereClause);
     1351        psStringAppend(&query_updated, " AND %s", whereClause);
     1352        psFree(whereClause);
     1353    }
     1354    psFree(where);
     1355
     1356    if (!p_psDBRunQuery(config->dbh, query)) {
     1357        psError(PS_ERR_UNKNOWN, false, "database error");
    13171358        psFree(query);
    1318 
    1319         numDeleted = psDBAffectedRows(config->dbh);
    1320     }
     1359        return false;
     1360    }
     1361    psFree(query);
     1362
     1363    int numDeleted = psDBAffectedRows(config->dbh);
    13211364
    13221365    psLogMsg("warptool", PS_LOG_INFO, "Deleted %d warpSkyfiles", numDeleted);
    13231366
    1324     psFree(where);
    1325 
    1326     if (!psDBCommit(config->dbh)) {
    1327         psError(PS_ERR_UNKNOWN, false, "database error");
    1328         return false;
    1329     }
     1367    // fix any faulted warpSkyfiles in data_state 'update'
     1368
     1369    if (!p_psDBRunQuery(config->dbh, query_updated)) {
     1370        psError(PS_ERR_UNKNOWN, false, "database error");
     1371        psFree(query_updated);
     1372        return false;
     1373    }
     1374    psFree(query_updated);
     1375
     1376    int numUpdated = psDBAffectedRows(config->dbh);
     1377
     1378    psLogMsg("warptool", PS_LOG_INFO, "Updated %d warpSkyfiles", numUpdated);
    13301379
    13311380    return true;
    … …  
    14141463    psString query = pxDataGet("warptool_pendingcleanuprun.sql");
    14151464    if (!query) {
    1416         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1465        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    14171466        return false;
    14181467    }
    … …  
    14771526    psString query = pxDataGet("warptool_pendingcleanupskyfile.sql");
    14781527    if (!query) {
    1479         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1528        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    14801529        return false;
    14811530    }
    … …  
    15381587    psString query = pxDataGet("warptool_donecleanup.sql");
    15391588    if (!query) {
    1540         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1589        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    15411590        return false;
    15421591    }
    … …  
    16261675    }
    16271676
    1628     // note only updates if warpRun.state = run_state
    1629     // XXX note that we have removed this constraint for now
    1630     if (!p_psDBRunQueryF(config->dbh, query, data_state, warp_id, skycell_id)) {
     1677    psString set_magicked_skyfile = psStringCopy("");
     1678    psString set_magicked_run = psStringCopy("");
     1679    if (!strcmp(data_state, "full")) {
     1680        // magicked is only an argument for for -tofullskyfile
     1681        PXOPT_LOOKUP_S64(magicked, config->args, "-set_magicked", false, false);
     1682        if (magicked) {
     1683            psStringAppend(&set_magicked_skyfile, "\n , warpSkyfile.magicked = %" PRId64, magicked);
     1684            psStringAppend(&set_magicked_run, "\n,  warpRun.magicked = %" PRId64, magicked);
     1685        }
     1686    } else if (!strcmp(data_state, "cleaned") || !strcmp(data_state, "purged")) {
     1687        // if magicked is currently nonzero set it to -1
     1688        // Set warpRun.magicked when the first skyfile is cleaned
     1689        psStringAppend(&set_magicked_skyfile, "\n, warpSkyfile.magicked = IF(warpSkyfile.magicked = 0, 0, -1), warpRun.magicked = IF(warpRun.magicked = 0, 0, -1)");
     1690    }
     1691
     1692    if (!p_psDBRunQueryF(config->dbh, query, data_state, set_magicked_skyfile, warp_id, skycell_id)) {
    16311693        psError(PS_ERR_UNKNOWN, false, "database error");
    16321694        // rollback
    … …  
    16381700    }
    16391701    psFree(query);
     1702    psFree(set_magicked_skyfile);
    16401703
    16411704    query = pxDataGet("warptool_change_run_state.sql");
    1642     if (!p_psDBRunQueryF(config->dbh, query, data_state, warp_id, data_state)) {
     1705    if (!p_psDBRunQueryF(config->dbh, query, data_state, set_magicked_run, warp_id, data_state)) {
    16431706        // rollback
    16441707        if (!psDBRollback(config->dbh)) {
    … …  
    16481711        return false;
    16491712    }
     1713    psFree(set_magicked_run);
    16501714
    16511715    if (!psDBCommit(config->dbh)) {
    … …  
    16671731{
    16681732    return change_skyfile_data_state(config, "purged", "goto_purged");
     1733}
     1734static bool toscrubbedskyfileMode(pxConfig *config)
     1735{
     1736     return change_skyfile_data_state(config, "scrubbed", "goto_scrubbed");
    16691737}
    16701738
    … …  
    16771745    PXOPT_LOOKUP_STR(skycell_id, config->args, "-skycell_id", true, false);
    16781746    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
    1679 
    1680     psString query = pxDataGet("warptool_updateskyfile.sql");
    1681 
    1682     if (!p_psDBRunQueryF(config->dbh, query, fault, warp_id, skycell_id)) {
    1683         psError(PS_ERR_UNKNOWN, false, "database error");
    1684         return false;
    1685     }
    1686     psFree(query);
     1747    PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
     1748
     1749    if (!state) {
     1750      psString query = pxDataGet("warptool_updateskyfile.sql");
     1751
     1752      if (!p_psDBRunQueryF(config->dbh, query, fault, warp_id, skycell_id)) {
     1753        psError(PS_ERR_UNKNOWN, false, "database error");
     1754        return false;
     1755      }
     1756      psFree(query);
     1757    }
     1758    else {
     1759      if (strcmp(state,"error_cleaned") == 0) {
     1760        change_skyfile_data_state(config,"error_cleaned","goto_cleaned");
     1761      }
     1762      else if (strcmp(state, "error_scrubbed") == 0) {
     1763        change_skyfile_data_state(config,"error_scrubbed","goto_scrubbed");
     1764      }
     1765      else if (strcmp(state, "error_purged") == 0) {
     1766        change_skyfile_data_state(config,"error_purged","goto_purged");
     1767      }
     1768      else {
     1769        psError(PS_ERR_UNKNOWN, false, "unhandled state given");
     1770        return(false);
     1771      }
     1772    }
    16871773
    16881774    return true;
    … …  
    17091795    }
    17101796
     1797    if (!pxExportVersion(config, f)) {
     1798        psError(PS_ERR_UNKNOWN, false, "failed to write dbversion output file");
     1799        return false;
     1800    }
    17111801    psMetadata *where = psMetadataAlloc();
    17121802    PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
    … …  
    17241814      psString query = pxDataGet(tables[i].sqlFilename);
    17251815      if (!query) {
    1726           psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1816          psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    17271817          return false;
    17281818      }
    … …  
    18011891  psMetadata *input = psMetadataConfigRead (NULL, &nFail, infile, false);
    18021892
    1803   fprintf (stdout, "---- input ----\n");
     1893#ifdef notdef
     1894  fprintf (stderr, "---- input ----\n");
    18041895  psMetadataPrint (stderr, input, 1);
     1896#endif
     1897
     1898  if (!pxCheckImportVersion(config, input)) {
     1899      psError(PS_ERR_UNKNOWN, false, "pxCheckImportVersion failed");
     1900      return false;
     1901  }
    18051902
    18061903  psMetadataItem *item = psMetadataLookup (input, "warpRun");
    … …  
    18651962  return true;
    18661963}
     1964
     1965static bool runstateMode(pxConfig *config)
     1966{
     1967    PS_ASSERT_PTR_NON_NULL(config, false);
     1968
     1969    psMetadata *where = psMetadataAlloc();
     1970    PXOPT_COPY_S64(config->args, where, "-warp_id",    "warpRun.warp_id", "==");
     1971    PXOPT_COPY_S64(config->args, where, "-exp_id",     "rawExp.exp_id", "==");
     1972    PXOPT_COPY_STR(config->args, where, "-exp_name",   "rawExp.exp_name", "==");
     1973    pxAddLabelSearchArgs (config, where, "-label",     "warpRun.label", "LIKE");
     1974
     1975//    PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
     1976    PXOPT_LOOKUP_BOOL(no_magic, config->args, "-no_magic", false);
     1977
     1978    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1979    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1980
     1981    psString query = pxDataGet("warptool_runstate.sql");
     1982    if (!query) {
     1983        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1984        return false;
     1985    }
     1986
     1987    if (psListLength(where->list)) {
     1988        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1989        psStringAppend(&query, " WHERE %s", whereClause);
     1990        psFree(whereClause);
     1991    } else {
     1992        psError(PXTOOLS_ERR_CONFIG, true, "search parameters or -all are required");
     1993        return false;
     1994    }
     1995    psFree(where);
     1996
     1997    // treat limit == 0 as "no limit"
     1998    if (limit) {
     1999        psString limitString = psDBGenerateLimitSQL(limit);
     2000        psStringAppend(&query, " %s", limitString);
     2001        psFree(limitString);
     2002    }
     2003
     2004    if (!p_psDBRunQuery(config->dbh, query)) {
     2005        psError(PS_ERR_UNKNOWN, false, "database error");
     2006        psFree(query);
     2007        return false;
     2008    }
     2009    psFree(query);
     2010
     2011    psArray *output = p_psDBFetchResult(config->dbh);
     2012    if (!output) {
     2013        psErrorCode err = psErrorCodeLast();
     2014        switch (err) {
     2015            case PS_ERR_DB_CLIENT:
     2016                psError(PXTOOLS_ERR_SYS, false, "database error");
     2017            case PS_ERR_DB_SERVER:
     2018                psError(PXTOOLS_ERR_PROG, false, "database error");
     2019            default:
     2020                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     2021        }
     2022
     2023        return false;
     2024    }
     2025    if (!psArrayLength(output)) {
     2026        psTrace("warptool", PS_LOG_INFO, "no rows found");
     2027        psFree(output);
     2028        return true;
     2029    }
     2030
     2031    if (psArrayLength(output)) {
     2032        // negative simple so the default is true
     2033        if (!ippdbPrintMetadatas(stdout, output, "warpRunState", !simple)) {
     2034            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     2035            psFree(output);
     2036            return false;
     2037        }
     2038    }
     2039
     2040    psFree(output);
     2041
     2042    return true;
     2043}
     2044
     2045static bool listrunMode(pxConfig *config)
     2046{
     2047    PS_ASSERT_PTR_NON_NULL(config, false);
     2048
     2049    psMetadata *where = psMetadataAlloc();
     2050    PXOPT_COPY_S64(config->args, where, "-warp_id",    "warpRun.warp_id", "==");
     2051    PXOPT_COPY_STR(config->args, where, "-tess_id",    "warpRun.tess_id", "==");
     2052    PXOPT_COPY_STR(config->args, where, "-state",      "warpRun.state", "==");
     2053    PXOPT_COPY_S64(config->args, where, "-exp_id",     "rawExp.exp_id", "==");
     2054    PXOPT_COPY_STR(config->args, where, "-exp_name",   "rawExp.exp_name", "==");
     2055    PXOPT_COPY_S64(config->args, where, "-fake_id",    "fakeRun.fake_id", "==");
     2056    PXOPT_COPY_TIME(config->args, where, "-dateobs_begin", "rawExp.dateobs",  ">=");
     2057    PXOPT_COPY_TIME(config->args, where, "-dateobs_end",   "rawExp.dateobs",  "<=");
     2058    PXOPT_COPY_STR(config->args, where, "-filter",    "rawExp.filter", "LIKE");
     2059    PXOPT_COPY_S64(config->args, where, "-magicked", "warpRun.magicked", "==");
     2060    pxAddLabelSearchArgs (config, where, "-label",   "warpRun.label", "LIKE");
     2061    pxAddLabelSearchArgs (config, where, "-data_group",   "warpRun.data_group", "LIKE");
     2062    pxAddLabelSearchArgs (config, where, "-dist_group",   "warpRun.dist_group", "LIKE");
     2063
     2064    PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
     2065
     2066    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     2067    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     2068    PXOPT_LOOKUP_BOOL(pstamp_order, config->args, "-pstamp_order", false);
     2069
     2070    // find all rawImfiles matching the default query
     2071    psString query = pxDataGet("warptool_listrun.sql");
     2072    if (!query) {
     2073        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     2074        return false;
     2075    }
     2076
     2077    // generate where strings for arguments that require extra processing
     2078    // beyond PXOPT_COPY*
     2079    psString where2 = NULL;
     2080    if (!pxmagicAddWhere(config, &where2, "warpRun")) {
     2081        psError(psErrorCodeLast(), false, "pxMagicAddWhere failed");
     2082        return false;
     2083    }
     2084    if (!pxspaceAddWhere(config, &where2, "rawExp")) {
     2085        psError(psErrorCodeLast(), false, "pxSpaceAddWhere failed");
     2086        return false;
     2087    }
     2088
     2089    if (psListLength(where->list)) {
     2090        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     2091        psStringAppend(&query, " WHERE %s", whereClause);
     2092        psFree(whereClause);
     2093    } else if (!all && !where2) {
     2094        psError(PXTOOLS_ERR_CONFIG, true, "search parameters or -all are required");
     2095        return false;
     2096    }
     2097
     2098    if (where2) {
     2099        if (psListLength(where->list)) {
     2100            psStringAppend(&query, " %s", where2);
     2101        } else {
     2102            psStringAppend(&query, " WHERE 1 %s", where2);
     2103        }
     2104    }
     2105    psFree(where);
     2106
     2107    if (pstamp_order) {
     2108        // put runs in order of exposure id with newest chip Runs first
     2109        // The postage stamp parser depends on this behavior
     2110        psStringAppend(&query, "\nORDER by exp_id, warp_id DESC");
     2111    }
     2112
     2113
     2114    // treat limit == 0 as "no limit"
     2115    if (limit) {
     2116        psString limitString = psDBGenerateLimitSQL(limit);
     2117        psStringAppend(&query, " %s", limitString);
     2118        psFree(limitString);
     2119    }
     2120
     2121    if (!p_psDBRunQuery(config->dbh, query)) {
     2122        psError(PS_ERR_UNKNOWN, false, "database error");
     2123        psFree(query);
     2124        return false;
     2125    }
     2126    psFree(query);
     2127
     2128    psArray *output = p_psDBFetchResult(config->dbh);
     2129    if (!output) {
     2130        psErrorCode err = psErrorCodeLast();
     2131        switch (err) {
     2132            case PS_ERR_DB_CLIENT:
     2133                psError(PXTOOLS_ERR_SYS, false, "database error");
     2134            case PS_ERR_DB_SERVER:
     2135                psError(PXTOOLS_ERR_PROG, false, "database error");
     2136            default:
     2137                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     2138        }
     2139
     2140        return false;
     2141    }
     2142    if (!psArrayLength(output)) {
     2143        psTrace("warptool", PS_LOG_INFO, "no rows found");
     2144        psFree(output);
     2145        return true;
     2146    }
     2147
     2148    if (psArrayLength(output)) {
     2149        // negative simple so the default is true
     2150        if (!ippdbPrintMetadatas(stdout, output, "warpRun", !simple)) {
     2151            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     2152            psFree(output);
     2153            return false;
     2154        }
     2155    }
     2156
     2157    psFree(output);
     2158
     2159    return true;
     2160}
     2161
     2162// a very specfic function to queue a cleaned warpSkyfile to be updated
     2163static bool setskyfiletoupdateMode(pxConfig *config)
     2164{
     2165    PS_ASSERT_PTR_NON_NULL(config, NULL);
     2166
     2167    PXOPT_LOOKUP_S64(warp_id, config->args, "-warp_id", true, false);
     2168    PXOPT_LOOKUP_STR(skycell_id, config->args, "-skycell_id", false, false);
     2169    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
     2170
     2171    psString query = pxDataGet("warptool_setskyfiletoupdate.sql");
     2172    if (!query) {
     2173        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     2174        return false;
     2175    }
     2176
     2177    psString setHook = psStringCopy("");
     2178    if (label) {
     2179        psStringAppend(&setHook, "\n , warpRun.label = '%s'", label);
     2180    }
     2181
     2182    if (skycell_id) {
     2183        psStringAppend(&query, " AND (warpSkyfile.skycell_id = '%s')", skycell_id);
     2184    }
     2185
     2186    if (!p_psDBRunQueryF(config->dbh, query, setHook, warp_id)) {
     2187        psError(PS_ERR_UNKNOWN, false, "database error");
     2188        return false;
     2189    }
     2190
     2191    psFree(setHook);
     2192    psFree(query);
     2193
     2194    return true;
     2195}

  • branches/simtest_nebulous_branches/ippTools/src/warptool.h

    r24426 r27840  
    4949    WARPTOOL_MODE_TOCLEANEDSKYFILE,
    5050    WARPTOOL_MODE_TOPURGEDSKYFILE,
     51    WARPTOOL_MODE_TOSCRUBBEDSKYFILE,
    5152    WARPTOOL_MODE_TOFULLSKYFILE,
    5253    WARPTOOL_MODE_UPDATESKYFILE,
    5354    WARPTOOL_MODE_EXPORTRUN,
    54     WARPTOOL_MODE_IMPORTRUN
     55    WARPTOOL_MODE_IMPORTRUN,
     56    WARPTOOL_MODE_RUNSTATE,
     57    WARPTOOL_MODE_LISTRUN,
     58    WARPTOOL_MODE_SETSKYFILETOUPDATE,
    5559} warptoolMode;
    5660

  • branches/simtest_nebulous_branches/ippTools/src/warptoolConfig.c

    r24956 r27840  
    4040    config->modules = pmConfigRead(&argc, argv, NULL);
    4141    if (!config->modules) {
    42         psError(PS_ERR_UNKNOWN, false, "Can't find site configuration");
     42        psError(psErrorCodeLast(), false, "Can't find site configuration");
    4343        psFree(config);
    4444        return NULL;
    … …  
    100100    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_reduction",      0, "define reduction class", NULL);
    101101    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_end_stage",      0, "define end stage", NULL);
    102     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-all",               0, "allow everything to be queued without search terms", false);
     102    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_data_group",     0, "define data group", NULL);
     103    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_dist_group",     0, "define dist group", NULL);
     104    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_note",           0, "define note", NULL);
    103105
    104106    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
    … …  
    117119    psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
    118120    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     121    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_end_stage",      0, "define end stage", NULL);
     122    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_data_group",     0, "define data group", NULL);
     123    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_dist_group",     0, "define dist group", NULL);
     124    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_note",           0, "define note", NULL);
    119125
    120126    // -updaterun
    … …  
    127133    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-reduction", 0,  "search by warpRun reduction class", NULL);
    128134    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,      "search by warpRun state", NULL);
    129     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label", 0,      "search by warpRun label", NULL);
    130     psMetadataAddBool(updaterunArgs, PS_LIST_TAIL, "-all",  0,      "allow everything to be queued without search terms", false);
    131     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state", 0,  "set state", NULL);
    132     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_label", 0,  "set label", NULL);
     135    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by warpRun label", NULL);
     136    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-data_group", 0, "search by warpRun data_group", NULL);
     137    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-dist_group", 0, "search by warpRun dist_group", NULL);
     138    psMetadataAddTime(updaterunArgs, PS_LIST_TAIL, "-registered_begin", 0, "search for runs by registration time (>=)", NULL);
     139    psMetadataAddTime(updaterunArgs, PS_LIST_TAIL, "-registered_end", 0, "search for runs by registration time (<)", NULL);
     140    psMetadataAddBool(updaterunArgs, PS_LIST_TAIL, "-destreaked", 0, "search for runs that have been destreaked", false);
     141    psMetadataAddBool(updaterunArgs, PS_LIST_TAIL, "-pretend", 0, "only pretend to run the query", false);
     142
     143    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state", 0,        "define new state", NULL);
     144    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_label", 0,        "define new value for label", 0);
     145    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_data_group", 0,   "define new data_group", NULL);
     146    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_dist_group", 0,   "define new dist_group", NULL);
     147    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_note", 0,         "define new note", NULL);
    133148
    134149    // -exp
    … …  
    202217    psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-hostname", 0,            "define hostname", 0);
    203218    psMetadataAddF32(addwarpedArgs, PS_LIST_TAIL, "-good_frac",  0,            "define %% of good pixels", NAN);
    204     psMetadataAddBool(addwarpedArgs, PS_LIST_TAIL, "-magicked",  0, "define if this skycell has been magicked", false);
     219    psMetadataAddS64(addwarpedArgs, PS_LIST_TAIL, "-set_magicked",  0, "define if this skycell has been magicked", 0);
    205220    psMetadataAddS16(addwarpedArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code", 0);
    206221    psMetadataAddS16(addwarpedArgs, PS_LIST_TAIL, "-quality",  0,            "set quality", 0);
    … …  
    215230    psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-exp_name", 0,          "search by exposure tag", 0);
    216231    psMetadataAddS64(warpedArgs, PS_LIST_TAIL, "-fake_id", 0,           "search by phase 3 version of exposure tag", 0);
     232    psMetadataAddTime(warpedArgs, PS_LIST_TAIL, "-dateobs_begin", 0,    "search for exposures by time (>=)", NULL);
     233    psMetadataAddTime(warpedArgs, PS_LIST_TAIL, "-dateobs_end", 0,      "search for exposures by time (<=)", NULL);
     234    psMetadataAddStr(warpedArgs, PS_LIST_TAIL,  "-filter", 0,           "search for exposures by filter", NULL);
     235    psMetadataAddS16(warpedArgs, PS_LIST_TAIL,  "-fault",  0,           "search by fault code", 0);
     236    psMetadataAddStr(warpedArgs, PS_LIST_TAIL,  "-label",  PS_META_DUPLICATE_OK, "search by warpRun label", NULL);
     237    psMetadataAddStr(warpedArgs, PS_LIST_TAIL,  "-data_group",  PS_META_DUPLICATE_OK, "search by warpRun data_group", NULL);
     238    psMetadataAddStr(warpedArgs, PS_LIST_TAIL,  "-dist_group",  PS_META_DUPLICATE_OK, "search by warpRun dist_group", NULL);
     239    // add magic related arguments
     240    pxmagicAddArguments(warpedArgs);
     241    // add arguments for spatial search
     242    pxspaceAddArguments(warpedArgs);
     243
     244    psMetadataAddBool(warpedArgs, PS_LIST_TAIL, "-all",  0,             "search without arguments", false);
    217245    psMetadataAddU64(warpedArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    218246    psMetadataAddBool(warpedArgs, PS_LIST_TAIL, "-simple",  0,          "use the simple output format", false);
     247
     248    // -listrun
     249    psMetadata *listrunArgs = psMetadataAlloc();
     250    psMetadataAddS64(listrunArgs, PS_LIST_TAIL, "-warp_id", 0,           "search by warptool ID", 0);
     251    psMetadataAddStr(listrunArgs, PS_LIST_TAIL, "-tess_id",  0,          "search by tessellation ID", NULL);
     252    psMetadataAddStr(listrunArgs, PS_LIST_TAIL, "-state",  0,            "search by state", NULL);
     253    psMetadataAddS64(listrunArgs, PS_LIST_TAIL, "-exp_id", 0,            "search by exposure tag", 0);
     254    psMetadataAddStr(listrunArgs, PS_LIST_TAIL, "-exp_name", 0,          "search by exposure tag", 0);
     255    psMetadataAddS64(listrunArgs, PS_LIST_TAIL, "-fake_id", 0,           "search by phase 3 version of exposure tag", 0);
     256    psMetadataAddTime(listrunArgs, PS_LIST_TAIL, "-dateobs_begin", 0,    "search for exposures by time (>=)", NULL);
     257    psMetadataAddTime(listrunArgs, PS_LIST_TAIL, "-dateobs_end", 0,      "search for exposures by time (<=)", NULL);
     258    psMetadataAddStr(listrunArgs, PS_LIST_TAIL,  "-filter", 0,           "search for exposures by filter", NULL);
     259    psMetadataAddS16(listrunArgs, PS_LIST_TAIL,  "-fault",  0,           "search by fault code", 0);
     260    psMetadataAddStr(listrunArgs, PS_LIST_TAIL,  "-label",  PS_META_DUPLICATE_OK, "search by warpRun label", NULL);
     261    psMetadataAddStr(listrunArgs, PS_LIST_TAIL,  "-data_group",  PS_META_DUPLICATE_OK, "search by warpRun data_group", NULL);
     262    psMetadataAddStr(listrunArgs, PS_LIST_TAIL,  "-dist_group",  PS_META_DUPLICATE_OK, "search by warpRun dist_group", NULL);
     263    // add magic related arguments
     264    pxmagicAddArguments(listrunArgs);
     265    // add arguments for spatial search
     266    pxspaceAddArguments(listrunArgs);
     267
     268    psMetadataAddBool(listrunArgs, PS_LIST_TAIL, "-pstamp_order",  0,    "order results for postage stamp server", false);
     269
     270    psMetadataAddBool(listrunArgs, PS_LIST_TAIL, "-all",  0,             "search without arguments", false);
     271    psMetadataAddU64(listrunArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     272    psMetadataAddBool(listrunArgs, PS_LIST_TAIL, "-simple",  0,          "use the simple output format", false);
    219273
    220274    // -revertwarped
    … …  
    279333    psMetadataAddStr(topurgedskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0, "skycell ID to update", NULL);
    280334
     335    // -toscrubbedskyfile
     336    psMetadata *toscrubbedskyfileArgs = psMetadataAlloc();
     337    psMetadataAddS64(toscrubbedskyfileArgs, PS_LIST_TAIL, "-warp_id", 0, "warptool ID to update", 0);
     338    psMetadataAddStr(toscrubbedskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0, "skycell ID to update", NULL);
     339
    281340    // -tofullskyfile
    282341    psMetadata *tofullskyfileArgs = psMetadataAlloc();
    283342    psMetadataAddS64(tofullskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,    "warptool ID to update", 0);
    284343    psMetadataAddStr(tofullskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0, "skycell ID to update", NULL);
    285 
    286     // -toupdateskyfile
     344    psMetadataAddS64(tofullskyfileArgs, PS_LIST_TAIL, "-set_magicked",  0, "new value for magicked", 0);
     345
     346    // -updateskyfile
    287347    psMetadata *updateskyfileArgs = psMetadataAlloc();
    288348    psMetadataAddS64(updateskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,    "warptool ID to update", 0);
    289349    psMetadataAddStr(updateskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0, "skycell ID to update", NULL);
    290350    psMetadataAddS16(updateskyfileArgs, PS_LIST_TAIL, "-fault",  0,      "new fault code", 0);
     351    psMetadataAddStr(updateskyfileArgs, PS_LIST_TAIL, "-set_state", 0,   "set state", 0);
    291352
    292353    // -exportrun
    … …  
    300361    psMetadata *importrunArgs = psMetadataAlloc();
    301362    psMetadataAddStr(importrunArgs, PS_LIST_TAIL, "-infile",  0,          "import from this file (required)", NULL);
     363
     364    // -runstate
     365    psMetadata *runstateArgs = psMetadataAlloc();
     366    psMetadataAddS64(runstateArgs, PS_LIST_TAIL, "-warp_id", 0,           "search by warptool ID", 0);
     367//    psMetadataAddStr(runstateArgs, PS_LIST_TAIL, "-tess_id",  0,          "search by tessellation ID", NULL);
     368    psMetadataAddS64(runstateArgs, PS_LIST_TAIL, "-exp_id", 0,            "search by exposure tag", 0);
     369    psMetadataAddStr(runstateArgs, PS_LIST_TAIL, "-exp_name", 0,          "search by exposure tag", 0);
     370    psMetadataAddStr(runstateArgs, PS_LIST_TAIL,  "-label",  PS_META_DUPLICATE_OK, "search by warpRun label", NULL);
     371    psMetadataAddBool(runstateArgs, PS_LIST_TAIL, "-no_magic",  0,        "magic is not necessary for result", false);
     372
     373    psMetadataAddU64(runstateArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     374    psMetadataAddBool(runstateArgs, PS_LIST_TAIL, "-simple",  0,          "use the simple output format", false);
     375
     376    // -setskyfiletoupdate
     377    psMetadata *setskyfiletoupdateArgs = psMetadataAlloc();
     378    psMetadataAddS64(setskyfiletoupdateArgs, PS_LIST_TAIL, "-warp_id", 0,           "search by warptool ID (required)", 0);
     379    psMetadataAddStr(setskyfiletoupdateArgs, PS_LIST_TAIL, "-skycell_id",  0,       "search by tessellation ID", NULL);
     380    psMetadataAddStr(setskyfiletoupdateArgs, PS_LIST_TAIL, "-set_label",  0,        "new value for warpRun.label", NULL);
    302381
    303382
    … …  
    319398    PXOPT_ADD_MODE("-advancerun",      "", WARPTOOL_MODE_ADVANCERUN,     advancerunArgs);
    320399    PXOPT_ADD_MODE("-warped",          "", WARPTOOL_MODE_WARPED,         warpedArgs);
     400    PXOPT_ADD_MODE("-listrun",         "", WARPTOOL_MODE_LISTRUN,        listrunArgs);
     401    PXOPT_ADD_MODE("-runstate",        "", WARPTOOL_MODE_RUNSTATE,       runstateArgs);
    321402    PXOPT_ADD_MODE("-revertwarped",    "", WARPTOOL_MODE_REVERTWARPED,   revertwarpedArgs);
    322403    PXOPT_ADD_MODE("-block",                 "set a label block",                    WARPTOOL_MODE_BLOCK,          blockArgs);
    … …  
    328409    PXOPT_ADD_MODE("-tocleanedskyfile", "set skyfile as cleaned", WARPTOOL_MODE_TOCLEANEDSKYFILE, tocleanedskyfileArgs);
    329410    PXOPT_ADD_MODE("-topurgedskyfile", "set skyfile as purged", WARPTOOL_MODE_TOPURGEDSKYFILE, topurgedskyfileArgs);
     411    PXOPT_ADD_MODE("-toscrubbedskyfile", "set skyfile as scrubbed", WARPTOOL_MODE_TOSCRUBBEDSKYFILE, toscrubbedskyfileArgs);
    330412    PXOPT_ADD_MODE("-tofullskyfile", "set skyfile as full (updated)", WARPTOOL_MODE_TOFULLSKYFILE, tofullskyfileArgs);
    331413    PXOPT_ADD_MODE("-updateskyfile", "update fault code for skyfile", WARPTOOL_MODE_UPDATESKYFILE, updateskyfileArgs);
     414    PXOPT_ADD_MODE("-setskyfiletoupdate", "set cleaned skyfile to be updated", WARPTOOL_MODE_SETSKYFILETOUPDATE, setskyfiletoupdateArgs);
    332415    PXOPT_ADD_MODE("-exportrun",            "export run for import on other database", WARPTOOL_MODE_EXPORTRUN, exportrunArgs);
    333416    PXOPT_ADD_MODE("-importrun",            "import run from metadata file",           WARPTOOL_MODE_IMPORTRUN, importrunArgs);
Note: See TracChangeset for help on using the changeset viewer.