IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

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

updates from trunk

Location:
branches/simmosaic_branches
Files:
76 edited
17 copied

Legend:

Unmodified
Added
Removed

  • branches/simmosaic_branches

  • branches/simmosaic_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/simmosaic_branches/ippTools/src/Makefile.am

    r24512 r27839  
    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/simmosaic_branches/ippTools/src/caltoolConfig.c

    r18561 r27839  
    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/simmosaic_branches/ippTools/src/camtool.c

    r24681 r27839  
    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/simmosaic_branches/ippTools/src/camtoolConfig.c

    r24681 r27839  
    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/simmosaic_branches/ippTools/src/chiptool.c

    r24562 r27839  
    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/simmosaic_branches/ippTools/src/chiptool.h

    r23339 r27839  
    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/simmosaic_branches/ippTools/src/chiptoolConfig.c

    r24562 r27839  
    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/simmosaic_branches/ippTools/src/detselect.c

    r23998 r27839  
    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/simmosaic_branches/ippTools/src/dettool.c

    r24779 r27839  
    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);
    … …  
    276279    PXOPT_LOOKUP_F64(posang_min, config->args, "-posang_min", false, false);
    277280    PXOPT_LOOKUP_F64(posang_max, config->args, "-posang_max", false, false);
    278     PXOPT_LOOKUP_F64(solang_min, config->args, "-solang_min", false, false);
    279     PXOPT_LOOKUP_F64(solang_max, config->args, "-solang_max", false, false);
     281    PXOPT_LOOKUP_F64(solang_min, config->args, "-sun_angle_min", false, false);
     282    PXOPT_LOOKUP_F64(solang_max, config->args, "-sun_angle_max", false, false);
    280283    PXOPT_LOOKUP_TIME(time_begin, config->args, "-time_begin", false, false);
    281284    PXOPT_LOOKUP_TIME(time_end, config->args, "-time_end", 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);
    … …  
    521524    PXOPT_LOOKUP_F64(posang_min, config->args, "-posang_min", false, false);
    522525    PXOPT_LOOKUP_F64(posang_max, config->args, "-posang_max", false, false);
    523     PXOPT_LOOKUP_F64(solang_min, config->args, "-solang_min", false, false);
    524     PXOPT_LOOKUP_F64(solang_max, config->args, "-solang_max", false, false);
     526    PXOPT_LOOKUP_F64(solang_min, config->args, "-sun_angle_min", false, false);
     527    PXOPT_LOOKUP_F64(solang_max, config->args, "-sun_angle_max", false, false);
    525528
    526529    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", 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", "<=");
    … …  
    557561    PXOPT_COPY_F64(config->args, where, "-select_posang_min", "posang", ">=");
    558562    PXOPT_COPY_F64(config->args, where, "-select_posang_max", "posang", "<=");
    559     PXOPT_COPY_F64(config->args, where, "-select_solang_min", "solang", ">=");
    560     PXOPT_COPY_F64(config->args, where, "-select_solang_max", "solang", "<=");
     563    PXOPT_COPY_F64(config->args, where, "-select_sun_angle_min", "sun_angle", ">=");
     564    PXOPT_COPY_F64(config->args, where, "-select_sun_angle_max", "sun_angle", "<=");
     565    PXOPT_COPY_F64(config->args, where, "-select_sun_alt_min", "sun_alt", ">=");
     566    PXOPT_COPY_F64(config->args, where, "-select_sun_alt_max", "sun_alt", "<=");
    561567
    562568    PXOPT_COPY_F64(config->args, where, "-select_moon_angle_min", "moon_angle", ">=");
    … …  
    670676                 label,
    671677                 ref_det_id,
    672                 ref_iter
     678                ref_iter
    673679        );
    674680    psS64 det_id = psDBLastInsertID(config->dbh);
    … …  
    739745{
    740746    PS_ASSERT_PTR_NON_NULL(config, false);
    741    
     747
    742748    // XXX this mode is not well-tested: probably need to specify iteration here
    743749    PXOPT_LOOKUP_S64(det_id, config->args, "-det_id", true, false); // required
    … …  
    756762        psError(PS_ERR_UNKNOWN, false, "verify mode requires both -ref_det_id and -ref_iter");
    757763        return false;
    758     } 
     764    }
    759765    if (strcmp(mode, "verify") && ((ref_det_id != 0) || (ref_iter != -1))) {
    760766        psError(PS_ERR_UNKNOWN, false, "master mode cannot have -ref_det_id or -ref_iter set");
    761767        return false;
    762     } 
     768    }
    763769
    764770    // the new detRun may have different values for these limits:
    … …  
    775781    PXOPT_LOOKUP_F64(posang_min, config->args, "-set_posang_min", false, false);
    776782    PXOPT_LOOKUP_F64(posang_max, config->args, "-set_posang_max", false, false);
    777     PXOPT_LOOKUP_F64(solang_min, config->args, "-set_solang_min", false, false);
    778     PXOPT_LOOKUP_F64(solang_max, config->args, "-set_solang_max", false, false);
     783    PXOPT_LOOKUP_F64(solang_min, config->args, "-set_sun_angle_min", false, false);
     784    PXOPT_LOOKUP_F64(solang_max, config->args, "-set_sun_angle_max", false, false);
    779785    PXOPT_LOOKUP_TIME(registered, config->args, "-set_registered", false, false);
    780786    PXOPT_LOOKUP_TIME(time_begin, config->args, "-set_time_begin", false, false);
    … …  
    814820
    815821    if (iteration < 0) {
    816         iteration = detRun->iteration;
     822        iteration = detRun->iteration;
    817823    }
    818824
    … …  
    974980    psString query = pxDataGet("dettool_definebydetrun.sql");
    975981    if (!query) {
    976         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     982        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    977983        return false;
    978984    }
    … …  
    986992
    987993    if (only_accepted) {
    988         psStringAppend(&query, " AND accept = 1");
     994        psStringAppend(&query, " AND accept = 1");
    989995    }
    990996
    … …  
    10651071    psString query = pxDataGet("dettool_runs.sql");
    10661072    if (!query) {
    1067         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1073        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10681074        return false;
    10691075    }
    … …  
    11351141    psString query = pxDataGet("dettool_childlessrun.sql");
    11361142    if (!query) {
    1137         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1143        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11381144        psFree(where);
    11391145        return false;
    … …  
    12091215    psString query = pxDataGet("dettool_input.sql");
    12101216    if (!query) {
    1211         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1217        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    12121218        psFree(where);
    12131219        return false;
    … …  
    12611267    psString query = pxDataGet("dettool_raw.sql");
    12621268    if (!query) {
    1263         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1269        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    12641270        return false;
    12651271    }
    … …  
    13351341}
    13361342
    1337 // used by updatedetrunMode 
     1343// used by updatedetrunMode
    13381344bool startNewIteration(pxConfig *config, psS64 det_id)
    13391345{
    … …  
    13421348    psString query = pxDataGet("dettool_start_new_iteration.sql");
    13431349    if (!query) {
    1344         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1350        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    13451351        return false;
    13461352    }
    … …  
    15611567        }
    15621568        detInputExpRow *newInputExp = detInputExpRowAlloc(
    1563             det_id,
     1569            det_id,
    15641570            newIteration,
    15651571            inputExp->exp_id,
    … …  
    16131619    PXOPT_LOOKUP_F64(posang_min, config->args, "-posang_min", false, false);
    16141620    PXOPT_LOOKUP_F64(posang_max, config->args, "-posang_max", false, false);
    1615     PXOPT_LOOKUP_F64(solang_min, config->args, "-solang_min", false, false);
    1616     PXOPT_LOOKUP_F64(solang_max, config->args, "-solang_max", false, false);
     1621    PXOPT_LOOKUP_F64(solang_min, config->args, "-sun_angle_min", false, false);
     1622    PXOPT_LOOKUP_F64(solang_max, config->args, "-sun_angle_max", false, false);
    16171623    PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    16181624    PXOPT_LOOKUP_TIME(time_begin, config->args, "-time_begin", false, false);
    … …  
    16591665                      solang_max,
    16601666                      label,
    1661                       ref_det_id,
    1662                       ref_iter
     1667                      ref_det_id,
     1668                      ref_iter
    16631669            )) {
    16641670        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    17101716{
    17111717    PS_ASSERT_PTR_NON_NULL(config, false);
    1712    
     1718
    17131719    PXOPT_LOOKUP_S64(det_id, config->args, "-det_id", true, false); // required
    17141720    PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false); // required
    … …  
    17251731
    17261732    if (!detRegisteredImfileInsert(config->dbh,
    1727                                    det_id,
    1728                                    0,  // the iteration is fixed at 0
    1729                                    class_id,
    1730                                    uri,
    1731                                    bg,
    1732                                    bg_stdev,
    1733                                    bg_mean_stdev,
    1734                                    user_1,
    1735                                    user_2,
    1736                                    user_3,
    1737                                    user_4,
    1738                                    user_5,
    1739                                    path_base,
    1740                                    "full",                                 
    1741                                    0       // fault code
    1742             )) {
     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            )) {
    17431749        psError(PS_ERR_UNKNOWN, false, "database error");
    17441750        return false;
    … …  
    18251831    if (!strcmp(data_state, "drop")) return true;
    18261832    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;
    18271844
    18281845    psError(PS_ERR_UNKNOWN, true, "invalid data state: %s", data_state);
    … …  
    18441861
    18451862
    1846 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)
    18471864{
    18481865    PS_ASSERT_PTR_NON_NULL(config, false);
     1866    PS_ASSERT_PTR_NON_NULL(where, false);
    18491867    PS_ASSERT_PTR_NON_NULL(data_state, false);
    1850     PS_ASSERT_PTR_NON_NULL(class_id, false);
    18511868
    18521869    if (!isValidDataState (data_state)) return false;
    18531870
    1854     char *query = "UPDATE detProcessedImfile SET data_state = '%s'"
    1855         " WHERE det_id = %" PRId64
    1856         " AND exp_id = %" PRId64
    1857         " AND class_id = '%s'";
    1858     if (!p_psDBRunQueryF(config->dbh, query, data_state, det_id, exp_id, class_id)) {
    1859         psError(PS_ERR_UNKNOWN, false,
    1860                 "failed to change state for det_id %" PRId64 ", exp_id %" PRId64 ", class_id %s",
    1861                 det_id, exp_id, class_id);
    1862         return false;
    1863     }
    1864 
    1865     return true;
    1866 }
    1867 
    1868 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)
    18691891{
    18701892    PS_ASSERT_PTR_NON_NULL(config, false);
     1893    PS_ASSERT_PTR_NON_NULL(where, false);
    18711894    PS_ASSERT_PTR_NON_NULL(data_state, false);
    18721895
    18731896    if (!isValidDataState (data_state)) return false;
    18741897
    1875     char *query = "UPDATE detProcessedExp SET data_state = '%s'"
    1876         " WHERE det_id = %" PRId64
    1877         " AND exp_id = %" PRId64;
    1878     if (!p_psDBRunQueryF(config->dbh, query, data_state, det_id, exp_id)) {
    1879         psError(PS_ERR_UNKNOWN, false,
    1880                 "failed to change state for det_id %" PRId64 ", exp_id %" PRId64,
    1881                 det_id, exp_id);
    1882         return false;
    1883     }
    1884 
    1885     return true;
    1886 }
    1887 
    1888 
     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
    18891972bool setStackedImfileDataState(pxConfig *config, psS64 det_id, psS32 iteration, const char *class_id, const char *data_state)
    18901973{
    … …  
    18961979
    18971980    char *query = "UPDATE detStackedImfile SET data_state = '%s'"
    1898         " WHERE det_id = %" PRId64
    1899         " AND iteration = %" PRId32
    1900         " AND class_id = %s";
     1981        " WHERE det_id = %" PRId64
     1982        " AND iteration = %" PRId32
     1983        " AND class_id = '%s'";
    19011984    if (!p_psDBRunQueryF(config->dbh, query, data_state, det_id, iteration, class_id)) {
    19021985        psError(PS_ERR_UNKNOWN, false,
    1903                 "failed to change state for det_id %" PRId64 ", iteration %" PRId32 "class_id %s", 
    1904                 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);
    19051988        return false;
    19061989    }
    … …  
    19182001
    19192002    char *query = "UPDATE detNormalizedStatImfile SET data_state = '%s'"
    1920         " WHERE det_id = %" PRId64
    1921         " AND iteration = %" PRId32
    1922         " AND class_id = %s";
    1923     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)) {
    19242008        psError(PS_ERR_UNKNOWN, false,
    1925                 "failed to change state for det_id %" PRId64 ", iteration %" PRId32, 
    1926                 det_id, iteration);
     2009                "failed to change state for det_id %" PRId64 ", iteration %" PRId32,
     2010                det_id, iteration);
    19272011        return false;
    19282012    }
    … …  
    19402024
    19412025    char *query = "UPDATE detNormalizedImfile SET data_state = '%s'"
    1942         " WHERE det_id = %" PRId64
    1943         " AND iteration = %" PRId32
    1944         " AND class_id = %s";
     2026        " WHERE det_id = %" PRId64
     2027        " AND iteration = %" PRId32
     2028        " AND class_id = '%s'";
    19452029    if (!p_psDBRunQueryF(config->dbh, query, data_state, det_id, iteration, class_id)) {
    19462030        psError(PS_ERR_UNKNOWN, false,
    1947                 "failed to change state for det_id %" PRId64 ", iteration %" PRId32 " class %s", 
    1948                 det_id, iteration, class_id);
     2031                "failed to change state for det_id %" PRId64 ", iteration %" PRId32 " class %s",
     2032                det_id, iteration, class_id);
    19492033        return false;
    19502034    }
    … …  
    19612045
    19622046    char *query = "UPDATE detNormalizedExp SET data_state = '%s'"
    1963         " WHERE det_id = %" PRId64
    1964         " AND iteration = %" PRId32;
     2047        " WHERE det_id = %" PRId64
     2048        " AND iteration = %" PRId32;
    19652049    if (!p_psDBRunQueryF(config->dbh, query, data_state, det_id, iteration)) {
    19662050        psError(PS_ERR_UNKNOWN, false,
    1967                 "failed to change state for det_id %" PRId64 ", iteration %" PRId32, 
    1968                 det_id, iteration);
     2051                "failed to change state for det_id %" PRId64 ", iteration %" PRId32,
     2052                det_id, iteration);
    19692053        return false;
    19702054    }
    … …  
    19722056    return true;
    19732057}
    1974 
    1975 bool setResidImfileDataState(pxConfig *config, psS64 det_id, psS32 iteration, psS64 exp_id, const char *class_id, const char *data_state)
    1976 {
    1977     PS_ASSERT_PTR_NON_NULL(config, false);
    1978     PS_ASSERT_PTR_NON_NULL(data_state, false);
    1979     PS_ASSERT_PTR_NON_NULL(class_id, false);
    1980 
    1981     if (!isValidDataState (data_state)) return false;
    1982 
    1983     char *query = "UPDATE detResidImfile SET data_state = '%s'"
    1984         " WHERE det_id = %" PRId64
    1985         " AND iteration = %" PRId32
    1986         " AND exp_id = %" PRId64
    1987         " AND class_id = '%s'";
    1988     if (!p_psDBRunQueryF(config->dbh, query, data_state, det_id, iteration, exp_id, class_id)) {
    1989         psError(PS_ERR_UNKNOWN, false,
    1990                 "failed to change state for det_id %" PRId64 ", iteration %" PRId32 ", exp_id %" PRId64 ", class_id %s",
    1991                 det_id, iteration, exp_id, class_id);
    1992         return false;
    1993     }
    1994 
    1995     return true;
    1996 }
    1997 
    1998 bool setResidExpDataState(pxConfig *config, psS64 det_id, psS32 iteration, psS64 exp_id, const char *data_state)
    1999 {
    2000     PS_ASSERT_PTR_NON_NULL(config, false);
    2001     PS_ASSERT_PTR_NON_NULL(data_state, false);
    2002 
    2003     if (!isValidDataState (data_state)) return false;
    2004 
    2005     char *query = "UPDATE detResidExp SET data_state = '%s'"
    2006         " WHERE det_id = %" PRId64
    2007         " AND iteration = %" PRId32
    2008         " AND exp_id = %" PRId64;
    2009     if (!p_psDBRunQueryF(config->dbh, query, data_state, det_id, iteration, exp_id)) {
    2010         psError(PS_ERR_UNKNOWN, false,
    2011                 "failed to change state for det_id %" PRId64 ", iteration %" PRId32 ", exp_id %" PRId64,
    2012                 det_id, iteration, exp_id);
    2013         return false;
    2014     }
    2015 
    2016     return true;
    2017 }
     2058// End not yet modified for cleanup.
    20182059
    20192060bool exportrunMode(pxConfig *config)
    … …  
    20232064    char sqlFilename[80];
    20242065  } ExportTable;
    2025  
     2066
    20262067  int numExportTables = 12;
    20272068
    … …  
    20592100    psString query = pxDataGet(tables[i].sqlFilename);
    20602101    if (!query) {
    2061       psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     2102      psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    20622103      return false;
    20632104    }
    … …  
    21012142    }
    21022143    psFree(output);
    2103  
     2144
    21042145  }
    21052146
    … …  
    21122153{
    21132154  unsigned int nFail;
    2114  
     2155
    21152156  int numImportTables = 11;
    2116  
     2157
    21172158  char tables[11] [80] = {"detInputExp", "detNormalizedExp",
    21182159    "detNormalizedImfile", "detNormalizedStatImfile", "detProcessedExp",
    … …  
    21212162
    21222163  PS_ASSERT_PTR_NON_NULL(config, NULL);
    2123  
     2164
    21242165  PXOPT_LOOKUP_STR(infile, config->args, "-infile", true,  false);
    21252166
    … …  
    21282169  fprintf (stdout, "---- input ----\n");
    21292170  psMetadataPrint (stderr, input, 1);
    2130  
     2171
    21312172  psMetadataItem *item = psMetadataLookup (input, "detRun");
    21322173  psAssert (item, "entry not in input?");
    … …  
    21382179  detRunRow *detRun = detRunObjectFromMetadata (entry->data.md);
    21392180  detRunInsertObject (config->dbh, detRun);
    2140  
     2181
    21412182  // fprintf (stdout, "---- det run ----\n");
    21422183  // psMetadataPrint (stderr, entry->data.md, 1);
    … …  
    21462187    psAssert (item, "entry not in input?");
    21472188    psAssert (item->type == PS_DATA_METADATA_MULTI, "entry not multi?");
    2148  
     2189
    21492190    switch (i) {
    21502191      case 0:
    … …  
    21602201        }
    21612202        break;
    2162  
     2203
    21632204      case 1:
    21642205        for (int i = 0; i < item->data.list->n; i++) {
    … …  
    21732214        }
    21742215        break;
    2175        
     2216
    21762217      case 2:
    21772218        for (int i = 0; i < item->data.list->n; i++) {
    … …  
    21862227        }
    21872228        break;
    2188  
     2229
    21892230      case 3:
    21902231        for (int i = 0; i < item->data.list->n; i++) {
    … …  
    21992240        }
    22002241        break;
    2201        
     2242
    22022243      case 4:
    22032244        for (int i = 0; i < item->data.list->n; i++) {
    … …  
    22122253        }
    22132254        break;
    2214        
     2255
    22152256      case 5:
    22162257        for (int i = 0; i < item->data.list->n; i++) {
    … …  
    22252266        }
    22262267        break;
    2227        
     2268
    22282269      case 6:
    22292270        for (int i = 0; i < item->data.list->n; i++) {
    … …  
    22382279        }
    22392280        break;
    2240        
     2281
    22412282      case 7:
    22422283        for (int i = 0; i < item->data.list->n; i++) {
    … …  
    22512292        }
    22522293        break;
    2253        
     2294
    22542295      case 8:
    22552296        for (int i = 0; i < item->data.list->n; i++) {
    … …  
    22642305        }
    22652306        break;
    2266        
     2307
    22672308      case 9:
    22682309        for (int i = 0; i < item->data.list->n; i++) {
    … …  
    22772318        }
    22782319        break;
    2279        
     2320
    22802321      case 10:
    22812322        for (int i = 0; i < item->data.list->n; i++) {

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

    r23310 r27839  
    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/simmosaic_branches/ippTools/src/dettoolConfig.c

    r24779 r27839  
    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
    … …  
    6868    psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-posang_min",  0,            "define min rotator position angle", NAN);
    6969    psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-posang_max",  0,            "define max rotator position angle", NAN);
    70     psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-solang_min",  0,            "define min solar angle", NAN);
    71     psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-solang_max",  0,            "define max solar angle", NAN);
     70    psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-sun_angle_min",  0,            "define min solar angle", NAN);
     71    psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-sun_angle_max",  0,            "define max solar angle", NAN);
    7272
    7373    psMetadataAddTime(definebytagArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
    … …  
    100100    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-posang_min",  0,            "define min rotator position angle", NAN);
    101101    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-posang_max",  0,            "define max rotator position angle", NAN);
    102     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-solang_min",  0,            "define min solar angle", NAN);
    103     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-solang_max",  0,            "define max solar angle", NAN);
     102    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-sun_angle_min",  0,            "define min solar angle", NAN);
     103    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-sun_angle_max",  0,            "define max solar angle", NAN);
    104104    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
    105105    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-time_begin",  0,            "detrend applies to exposures taken during this period", NULL);
    … …  
    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);
    127     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_solang_min",  0,            "define min solar angle", NAN);
    128     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_solang_max",  0,            "define max solar angle", NAN);
     128
     129    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_sun_angle_min",  0,            "define min solar angle", NAN);
     130    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_sun_angle_max",  0,            "define max solar angle", NAN);
     131    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_sun_alt_min",  0,            "define min solar altitude", NAN);
     132    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_sun_alt_max",  0,            "define max solar altitude", NAN);
    129133
    130134    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_moon_angle_min",  0,          "define min moon angle", NAN);
    … …  
    135139    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_moon_phase_max",  0,          "define max moon phase", NAN);
    136140    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-comment",                0,          "search by comment field (LIKE comparison)", NULL);
     141
    137142
    138143    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-pretend",  0,            "print the exposures that would be included in the detrend run and exit", false);
    … …  
    164169    psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_posang_min",  0,            "define rotator position angle", NAN);
    165170    psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_posang_max",  0,            "define rotator position angle", NAN);
    166     psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_solang_min",  0,            "define solar angle", NAN);
    167     psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_solang_max",  0,            "define solar angle", NAN);
     171    psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_sun_angle_min",  0,            "define solar angle", NAN);
     172    psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_sun_angle_max",  0,            "define solar angle", NAN);
    168173    psMetadataAddTime(definebydetrunArgs, PS_LIST_TAIL, "-set_registered",  0,            "time detrend run was registered", now);
    169174    psMetadataAddTime(definebydetrunArgs, PS_LIST_TAIL, "-set_time_begin",  0,            "start of period to apply detrend too", NULL);
    … …  
    205210    // -addcorrectimfile
    206211    psMetadata *addcorrectimfileArgs = psMetadataAlloc();
    207     psMetadataAddS64(addcorrectimfileArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", 0);
    208     psMetadataAddStr(addcorrectimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search for class ID (required)", NULL);
    209     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);
    210215    psMetadataAddF64(addcorrectimfileArgs, PS_LIST_TAIL, "-bg",  0,            "define exposure background", NAN);
    211216    psMetadataAddF64(addcorrectimfileArgs, PS_LIST_TAIL, "-bg_stdev",  0,            "define exposure background stdev", NAN);
    … …  
    301306    // -updateprocessedimfile
    302307    psMetadata *updateprocessedimfileArgs = psMetadataAlloc();
    303     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);
    304309    psMetadataAddS64(updateprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",               0,            "search by exp_id", 0);
    305310    psMetadataAddStr(updateprocessedimfileArgs, PS_LIST_TAIL, "-class_id",             0,            "search by exp_name", NULL);
    306     psMetadataAddStr(updateprocessedimfileArgs, PS_LIST_TAIL, "-data_state",           0,            "search for telescope", NULL);
     311    psMetadataAddStr(updateprocessedimfileArgs, PS_LIST_TAIL, "-data_state",           0,            "set state", NULL);
    307312
    308313    // -pendingcleanup_processedimfile
    … …  
    310315    psMetadataAddBool(pendingcleanup_processedimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    311316    psMetadataAddU64(pendingcleanup_processedimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    312     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);
    313318    psMetadataAddS64(pendingcleanup_processedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", 0);
    314319    psMetadataAddStr(pendingcleanup_processedimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
    … …  
    318323    psMetadataAddBool(donecleanup_processedimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    319324    psMetadataAddU64(donecleanup_processedimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    320     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);
    321326    psMetadataAddS64(donecleanup_processedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", 0);
    322327    psMetadataAddStr(donecleanup_processedimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
    … …  
    362367    // -updateprocessedexp
    363368    psMetadata *updateprocessedexpArgs = psMetadataAlloc();
    364     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);
    365370    psMetadataAddS64(updateprocessedexpArgs, PS_LIST_TAIL, "-exp_id",               0,            "search by exp_id", 0);
    366     psMetadataAddStr(updateprocessedexpArgs, PS_LIST_TAIL, "-data_state",           0,            "search for telescope", NULL);
     371    psMetadataAddStr(updateprocessedexpArgs, PS_LIST_TAIL, "-data_state",           0,            "set state", NULL);
    367372
    368373    // -pendingcleanup_processedexp
    … …  
    370375    psMetadataAddBool(pendingcleanup_processedexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    371376    psMetadataAddU64(pendingcleanup_processedexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    372     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);
    373378    psMetadataAddS64(pendingcleanup_processedexpArgs, PS_LIST_TAIL, "-exp_id",               0,            "search by exp_id", 0);
    374379
    … …  
    377382    psMetadataAddBool(donecleanup_processedexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    378383    psMetadataAddU64(donecleanup_processedexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    379     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);
    380385    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);
    381392
    382393    // -tostacked
    … …  
    421432    // -updatestacked
    422433    psMetadata *updatestackedArgs = psMetadataAlloc();
    423     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);
    424435    psMetadataAddS32(updatestackedArgs, PS_LIST_TAIL, "-iteration",  0,            "search by iteration number", 0);
    425436    psMetadataAddStr(updatestackedArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
    426     psMetadataAddStr(updatestackedArgs, PS_LIST_TAIL, "-data_state",           0,            "search for telescope", NULL);
     437    psMetadataAddStr(updatestackedArgs, PS_LIST_TAIL, "-data_state",           0,            "set state", NULL);
    427438
    428439    // -pendingcleanup_stacked
    … …  
    430441    psMetadataAddBool(pendingcleanup_stackedArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    431442    psMetadataAddU64(pendingcleanup_stackedArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    432     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);
    433444    psMetadataAddS32(pendingcleanup_stackedArgs, PS_LIST_TAIL, "-iteration",  0,            "search by iteration number", 0);
    434445    psMetadataAddStr(pendingcleanup_stackedArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
    … …  
    438449    psMetadataAddBool(donecleanup_stackedArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    439450    psMetadataAddU64(donecleanup_stackedArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    440     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);
    441452    psMetadataAddS32(donecleanup_stackedArgs, PS_LIST_TAIL, "-iteration",  0,            "search by iteration number", 0);
    442453    psMetadataAddStr(donecleanup_stackedArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
    … …  
    473484    // -updatenormalizedstat
    474485    psMetadata *updatenormalizedstatArgs = psMetadataAlloc();
    475     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);
    476487    psMetadataAddS32(updatenormalizedstatArgs, PS_LIST_TAIL, "-iteration",  0,            "search by iteration number", 0);
    477488    psMetadataAddStr(updatenormalizedstatArgs, PS_LIST_TAIL, "-class_id",             0,            "search by exp_name", NULL);
    478     psMetadataAddStr(updatenormalizedstatArgs, PS_LIST_TAIL, "-data_state",           0,            "search for telescope", NULL);
     489    psMetadataAddStr(updatenormalizedstatArgs, PS_LIST_TAIL, "-data_state",           0,            "set state", NULL);
    479490
    480491    // -pendingcleanup_normalizedstat
    … …  
    482493    psMetadataAddBool(pendingcleanup_normalizedstatArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    483494    psMetadataAddU64(pendingcleanup_normalizedstatArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    484     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);
    485496    psMetadataAddS32(pendingcleanup_normalizedstatArgs, PS_LIST_TAIL, "-iteration",  0,            "search by iteration number", 0);
    486497    psMetadataAddStr(pendingcleanup_normalizedstatArgs, PS_LIST_TAIL, "-class_id",             0,            "search by exp_name", NULL);
    … …  
    490501    psMetadataAddBool(donecleanup_normalizedstatArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    491502    psMetadataAddU64(donecleanup_normalizedstatArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    492     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);
    493504    psMetadataAddS32(donecleanup_normalizedstatArgs, PS_LIST_TAIL, "-iteration",  0,            "search by iteration number", 0);
    494505    psMetadataAddStr(donecleanup_normalizedstatArgs, PS_LIST_TAIL, "-class_id",             0,            "search by exp_name", NULL);
    … …  
    535546    // -updatenormalizedimfile
    536547    psMetadata *updatenormalizedimfileArgs = psMetadataAlloc();
    537     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);
    538549    psMetadataAddS32(updatenormalizedimfileArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
    539550    psMetadataAddStr(updatenormalizedimfileArgs, PS_LIST_TAIL, "-class_id",             0,            "search by exp_name", NULL);
    540     psMetadataAddStr(updatenormalizedimfileArgs, PS_LIST_TAIL, "-data_state",           0,            "search for telescope", NULL);
     551    psMetadataAddStr(updatenormalizedimfileArgs, PS_LIST_TAIL, "-data_state",           0,            "set state", NULL);
    541552
    542553    // -pendingcleanup_normalizedimfile
    … …  
    544555    psMetadataAddBool(pendingcleanup_normalizedimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    545556    psMetadataAddU64(pendingcleanup_normalizedimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    546     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);
    547558    psMetadataAddS32(pendingcleanup_normalizedimfileArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
    548559    psMetadataAddStr(pendingcleanup_normalizedimfileArgs, PS_LIST_TAIL, "-class_id",             0,            "search by exp_name", NULL);
    … …  
    552563    psMetadataAddBool(donecleanup_normalizedimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    553564    psMetadataAddU64(donecleanup_normalizedimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    554     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);
    555566    psMetadataAddS32(donecleanup_normalizedimfileArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
    556567    psMetadataAddStr(donecleanup_normalizedimfileArgs, PS_LIST_TAIL, "-class_id",             0,            "search by exp_name", NULL);
    … …  
    594605    // -updatenormalizedexp
    595606    psMetadata *updatenormalizedexpArgs = psMetadataAlloc();
    596     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);
    597608    psMetadataAddS32(updatenormalizedexpArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
    598     psMetadataAddStr(updatenormalizedexpArgs, PS_LIST_TAIL, "-data_state",           0,            "search for telescope", NULL);
     609    psMetadataAddStr(updatenormalizedexpArgs, PS_LIST_TAIL, "-data_state",           0,            "set state", NULL);
    599610
    600611    // -pendingcleanup_normalizedexp
    … …  
    602613    psMetadataAddBool(pendingcleanup_normalizedexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    603614    psMetadataAddU64(pendingcleanup_normalizedexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    604     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);
    605616    psMetadataAddS32(pendingcleanup_normalizedexpArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
    606617
    … …  
    609620    psMetadataAddBool(donecleanup_normalizedexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    610621    psMetadataAddU64(donecleanup_normalizedexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    611     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);
    612623    psMetadataAddS32(donecleanup_normalizedexpArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
    613624
    … …  
    672683    // -updateresidimfile
    673684    psMetadata *updateresidimfileArgs = psMetadataAlloc();
    674     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);
    675686    psMetadataAddS32(updateresidimfileArgs, PS_LIST_TAIL, "-iteration", 0,       "search by iteration number", 0);
    676687    psMetadataAddS64(updateresidimfileArgs, PS_LIST_TAIL, "-exp_id",               0,            "search by exp_id", 0);
    677688    psMetadataAddStr(updateresidimfileArgs, PS_LIST_TAIL, "-class_id",             0,            "search by exp_name", NULL);
    678     psMetadataAddStr(updateresidimfileArgs, PS_LIST_TAIL, "-data_state",           0,            "search for telescope", NULL);
     689    psMetadataAddStr(updateresidimfileArgs, PS_LIST_TAIL, "-data_state",           0,            "set state", NULL);
    679690
    680691    // -pendingcleanup_residimfile
    … …  
    682693    psMetadataAddBool(pendingcleanup_residimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    683694    psMetadataAddU64(pendingcleanup_residimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    684     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);
    685696    psMetadataAddS32(pendingcleanup_residimfileArgs, PS_LIST_TAIL, "-iteration", 0,       "search by iteration number", 0);
    686697    psMetadataAddS64(pendingcleanup_residimfileArgs, PS_LIST_TAIL, "-exp_id",               0,            "search by exp_id", 0);
    … …  
    691702    psMetadataAddBool(donecleanup_residimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    692703    psMetadataAddU64(donecleanup_residimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    693     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);
    694705    psMetadataAddS32(donecleanup_residimfileArgs, PS_LIST_TAIL, "-iteration", 0,       "search by iteration number", 0);
    695706    psMetadataAddS64(donecleanup_residimfileArgs, PS_LIST_TAIL, "-exp_id",               0,            "search by exp_id", 0);
    … …  
    757768    psMetadataAddStr(updateresidexpArgs, PS_LIST_TAIL, "-path_base",  0,            "define base output location", NULL);
    758769    psMetadataAddBool(updateresidexpArgs, PS_LIST_TAIL, "-reject",  0,            "exposure is not to be stacked in the next iteration", false);
    759     psMetadataAddStr(updateresidexpArgs, PS_LIST_TAIL, "-data_state",           0,            "search for telescope", NULL);
     770    psMetadataAddStr(updateresidexpArgs, PS_LIST_TAIL, "-data_state",           0,            "set state", NULL);
    760771
    761772    // -pendingcleanup_residexp
    … …  
    774785    psMetadataAddS32(donecleanup_residexpArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
    775786    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);
    776793
    777794    // -todetrunsummary
    … …  
    811828    psMetadataAddBool(updatedetrunsummaryArgs, PS_LIST_TAIL, "-accept",  0,            "declare that this detrun iteration is accepted as a master", false);
    812829    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);
    813839
    814840    // -updatedetrun
    … …  
    840866    psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-posang_min",  0,            "define min rotator position angle", NAN);
    841867    psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-posang_max",  0,            "define max rotator position angle", NAN);
    842     psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-solang_min",  0,            "define min solar angle", NAN);
    843     psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-solang_max",  0,            "define max solar angle", NAN);
     868    psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-sun_angle_min",  0,            "define min solar angle", NAN);
     869    psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-sun_angle_max",  0,            "define max solar angle", NAN);
    844870    psMetadataAddTime(register_detrendArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
    845871    psMetadataAddTime(register_detrendArgs, PS_LIST_TAIL, "-time_begin",  0,            "detrend applies to exposures taken during this period", NULL);
    … …  
    911937    PXOPT_ADD_MODE("-pendingcleanup_processedexp", "", DETTOOL_MODE_PENDINGCLEANUP_PROCESSEDEXP, pendingcleanup_processedexpArgs);
    912938    PXOPT_ADD_MODE("-donecleanup_processedexp", "",    DETTOOL_MODE_DONECLEANUP_PROCESSEDEXP, donecleanup_processedexpArgs);
     939    PXOPT_ADD_MODE("-updatestate_processed", "", DETTOOL_MODE_UPDATESTATE_PROCESSED, updatestateprocessedArgs);
    913940
    914941    PXOPT_ADD_MODE("-tostacked",       "", DETTOOL_MODE_TOSTACKED,     tostackedArgs);
    … …  
    959986    PXOPT_ADD_MODE("-pendingcleanup_residexp", "", DETTOOL_MODE_PENDINGCLEANUP_RESIDEXP, pendingcleanup_residexpArgs);
    960987    PXOPT_ADD_MODE("-donecleanup_residexp", "",    DETTOOL_MODE_DONECLEANUP_RESIDEXP, donecleanup_residexpArgs);
     988    PXOPT_ADD_MODE("-updatestate_resid", "", DETTOOL_MODE_UPDATESTATE_RESID, updatestateresidArgs);
    961989
    962990    PXOPT_ADD_MODE("-todetrunsummary",  "", DETTOOL_MODE_TODETRUNSUMMARY,  todetrunsummaryArgs);
    … …  
    965993    PXOPT_ADD_MODE("-revertdetrunsummary", "", DETTOOL_MODE_REVERTDETRUNSUMMARY, revertdetrunsummaryArgs);
    966994    PXOPT_ADD_MODE("-updatedetrunsummary", "", DETTOOL_MODE_UPDATEDETRUNSUMMARY, updatedetrunsummaryArgs);
     995
     996    PXOPT_ADD_MODE("-pendingcleanup_detrunsummary", "", DETTOOL_MODE_PENDINGCLEANUP_DETRUNSUMMARY, pendingcleanup_detrunsummaryArgs);
    967997
    968998    PXOPT_ADD_MODE("-updatedetrun", "", DETTOOL_MODE_UPDATEDETRUN, updatedetrunArgs);

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

    r20377 r27839  
    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/simmosaic_branches/ippTools/src/dettool_detrunsummary.c

    r23688 r27839  
    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/simmosaic_branches/ippTools/src/dettool_normalizedexp.c

    r23688 r27839  
    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/simmosaic_branches/ippTools/src/dettool_normalizedimfile.c

    r23688 r27839  
    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/simmosaic_branches/ippTools/src/dettool_normalizedstat.c

    r23688 r27839  
    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/simmosaic_branches/ippTools/src/dettool_processedexp.c

    r23688 r27839  
    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/simmosaic_branches/ippTools/src/dettool_processedimfile.c

    r23688 r27839  
    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/simmosaic_branches/ippTools/src/dettool_residexp.c

    r23688 r27839  
    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/simmosaic_branches/ippTools/src/dettool_residimfile.c

    r23688 r27839  
    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/simmosaic_branches/ippTools/src/dettool_stack.c

    r23688 r27839  
    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/simmosaic_branches/ippTools/src/difftool.c

    r24676 r27839  
    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", "==");
    584     PXOPT_COPY_STR(config->args, where, "-tess_id", "diffSkyfile.tess_id", "==");
     702    PXOPT_COPY_S64(config->args, where, "-diff_skyfile_id", "diffInputSkyfile.diff_skyfile_id", "==");
     703    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
    664     if (!psDBTransaction(config->dbh)) {
    665         psError(PS_ERR_UNKNOWN, false, "database error");
     820    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    666821        psFree(where);
    667         return false;
    668     }
    669 
    670     // Update state to 'new'
     822        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     823        return false;
     824    }
     825
    671826    {
    672         psString query = pxDataGet("difftool_revertdiffskyfile_update.sql");
     827        psString query = pxDataGet("difftool_revertdiffskyfile_delete.sql");
    673828        if (!query) {
    674             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    675             if (!psDBRollback(config->dbh)) {
    676                 psError(PS_ERR_UNKNOWN, false, "database error");
    677             }
     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");
    678835            return false;
    679836        }
    … …  
    682839            psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    683840            psStringAppend(&query, " AND %s", whereClause);
     841            psStringAppend(&query_updated, " AND %s", whereClause);
    684842            psFree(whereClause);
    685843        }
    … …  
    688846            psError(PS_ERR_UNKNOWN, false, "database error");
    689847            psFree(query);
    690             if (!psDBRollback(config->dbh)) {
    691                 psError(PS_ERR_UNKNOWN, false, "database error");
    692             }
    693848            return false;
    694849        }
    695850        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);
    696859
    697860        psLogMsg("difftool", PS_LOG_INFO, "Updated %" PRIu64 " rows", psDBAffectedRows(config->dbh));
    698861    }
    699862
    700     // Delete product
    701     {
    702         psString query = pxDataGet("difftool_revertdiffskyfile_delete.sql");
    703         if (!query) {
    704             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    705             if (!psDBRollback(config->dbh)) {
    706                 psError(PS_ERR_UNKNOWN, false, "database error");
    707             }
    708             return false;
    709         }
    710 
    711         if (psListLength(where->list)) {
    712             psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    713             psStringAppend(&query, " AND %s", whereClause);
    714             psFree(whereClause);
    715         }
    716 
    717         if (!p_psDBRunQuery(config->dbh, query)) {
    718             psError(PS_ERR_UNKNOWN, false, "database error");
    719             psFree(query);
    720             if (!psDBRollback(config->dbh)) {
    721                 psError(PS_ERR_UNKNOWN, false, "database error");
    722             }
    723             return false;
    724         }
    725         psFree(query);
    726 
    727         psLogMsg("difftool", PS_LOG_INFO, "Deleted %" PRIu64 " rows", psDBAffectedRows(config->dbh));
    728     }
    729 
    730863    psFree(where);
    731864
    732     if (!psDBCommit(config->dbh)) {
    733         psError(PS_ERR_UNKNOWN, false, "database error");
    734         return false;
    735     }
    736865
    737866    return true;
    … …  
    749878    }
    750879
    751     char *query = "UPDATE diffRun SET state = '%s', magicked = %" PRId64 " WHERE diff_id = %"PRId64;
    752 
    753     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)) {
    754884        psError(PS_ERR_UNKNOWN, false,
    755885                "failed to change state for diff_id %"PRId64, diff_id);
    756886        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      }
    757897    }
    758898
    759899    return true;
    760900}
     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
    761923
    762924// Generate a single populated run
    … …  
    766928                         const char *tess_id, // Tessellation identifier
    767929                         const char *label, // label
     930                         const char *data_group, // data_group
     931                         const char *dist_group, // dist_group
    768932                         const char *reduction, // reduction
     933                         const char *note,      // note
    769934                         psS64 input_warp_id, // Warp identifier for input image, PS_MAX_S64 for none
    770935                         psS64 input_stack_id, // Stack identifier for input image, PS_MAX_S64 for none
    … …  
    787952        return false;
    788953    }
     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
    789968
    790969    // default
    … …  
    797976            workdir,
    798977            label,
     978            data_group ? data_group : label,
     979            dist_group,
    799980            reduction,
    800981            NULL,       // dvodb
    … …  
    803984            false,
    804985            false,
    805             0       // magicked
     986            0,       // magicked
     987            diff_mode, // diff_mode
     988            note
    806989    );
    807990
    … …  
    8771060    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", true, false); // required options
    8781061    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);
    8791064    PXOPT_LOOKUP_STR(reduction, config->args, "-reduction", false, false);
    8801065    PXOPT_LOOKUP_S64(template_warp_id, config->args, "-template_warp_id", false, false);
    … …  
    8831068    PXOPT_LOOKUP_S64(input_stack_id, config->args, "-input_stack_id", false, false);
    8841069    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1070    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
    8851071
    8861072    if (template_stack_id && template_warp_id) {
    … …  
    9051091
    9061092    psArray *list = psArrayAllocEmpty(16); // List of runs, to print
    907 
    908     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,
    9091095                      input_warp_id ? input_warp_id : PS_MAX_S64,
    9101096                      input_stack_id ? input_stack_id : PS_MAX_S64,
    … …  
    9331119
    9341120    psMetadata *expWhere = psMetadataAlloc();
    935     psMetadata *warpWhere = psMetadataAlloc();
     1121    psMetadata *warp1Where = psMetadataAlloc(); // First set of restrictions on warp
     1122    psMetadata *warp2Where = psMetadataAlloc(); // Second set of restriction on warp
    9361123    psMetadata *stackWhere = psMetadataAlloc();
    9371124
    9381125    PXOPT_COPY_S64(config->args, expWhere, "-exp_id", "exp_id", "==");
    9391126    PXOPT_COPY_STR(config->args, expWhere, "-filter", "filter", "==");
    940     PXOPT_COPY_S64(config->args, warpWhere, "-warp_id", "warpRun.warp_id", "==");
    941     PXOPT_COPY_STR(config->args, warpWhere, "-skycell_id", "warpSkyfile.skycell_id", "==");
    942     PXOPT_COPY_STR(config->args, warpWhere, "-tess_id", "warpRun.tess_id", "==");
    943     PXOPT_COPY_STR(config->args, warpWhere, "-warp_label", "warpRun.label", "==");
    944     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", ">=");
    9451138    PXOPT_COPY_STR(config->args, stackWhere, "-stack_label", "stackRun.label", "==");
    9461139
    947     PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false); // required options
    948     PXOPT_LOOKUP_STR(reduction, config->args, "-reduction", false, false); // option
    949     PXOPT_LOOKUP_STR(label, config->args, "-label", false, false); // option
    950     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
    9511148    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    9521149    PXOPT_LOOKUP_BOOL(newTemplates, config->args, "-new-templates", false);
    … …  
    9581155    psString query = pxDataGet("difftool_definewarpstack_part1.sql");
    9591156    if (!query) {
    960         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    961         return false;
    962     }
    963 
    964     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;
    9651163    psString stackQuery = NULL;
    9661164    psString expQuery = NULL;
    … …  
    9741172    }
    9751173    psFree(expWhere);
    976     if (psListLength(warpWhere->list)) {
    977         psString whereClause = psDBGenerateWhereConditionSQL(warpWhere, NULL);
    978         psStringAppend(&warpQuery, "\n AND %s", whereClause);
     1174    if (psListLength(warp1Where->list)) {
     1175        psString whereClause = psDBGenerateWhereConditionSQL(warp1Where, NULL);
     1176        psStringAppend(&warp1Query, "\n AND %s", whereClause);
    9791177        psFree(whereClause);
    9801178    } else {
    981         warpQuery = psStringCopy("\n");
    982     }
    983     psFree(warpWhere);
    984 
    985     if (!available) {
    986         // diff what's available, even if warp run has some faults and is incomplete
    987         psStringAppend(&warpQuery, " AND warpRun.state = 'full'");
    988     }
     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);
    9891190
    9901191    // don't queue for exposures that have already been diff'd unless requested
    … …  
    10051206    psFree(stackWhere);
    10061207
    1007     psTrace("difftool", 1, query, warpQuery, diffQuery, expQuery, stackQuery);
     1208    psTrace("difftool", 1, query, warp1Query, warp2Query, diffQuery, expQuery, stackQuery);
    10081209
    10091210    if (!psDBTransaction(config->dbh)) {
    … …  
    10121213    }
    10131214
    1014     if (!p_psDBRunQueryF(config->dbh, query, warpQuery, expQuery, diffQuery)) {
     1215    if (!p_psDBRunQueryF(config->dbh, query, warp1Query, warp2Query, expQuery, diffQuery)) {
    10151216        psError(PS_ERR_UNKNOWN, false, "database error");
    10161217        psFree(query);
    … …  
    10721273        return false;
    10731274    }
     1275    psFree(warp1Query);
    10741276    psFree(query);
    10751277    query = NULL;
    … …  
    11031305        if (!p_psDBRunQuery(config->dbh, "DELETE FROM skycellsToDiff")) {
    11041306            psError(PS_ERR_UNKNOWN, false, "database error");
    1105             psFree(warpQuery);
     1307            psFree(warp2Query);
    11061308            psFree(stackQuery);
    11071309            psFree(skycell_query);
    … …  
    11141316        if (!mdok) {
    11151317            psError(PXTOOLS_ERR_PROG, false, "warp_id not found --- ignoring row %ld", i);
    1116             psFree(warpQuery);
     1318            psFree(warp2Query);
    11171319            psFree(stackQuery);
    11181320            psFree(skycell_query);
    … …  
    11251327        if (!mdok) {
    11261328            psError(PXTOOLS_ERR_PROG, false, "skycell_count not found");
    1127             psFree(warpQuery);
     1329            psFree(warp2Query);
    11281330            psFree(stackQuery);
    11291331            psFree(skycell_query);
    … …  
    11361338        if (!mdok) {
    11371339            psError(PXTOOLS_ERR_PROG, false, "tess_id not found");
    1138             psFree(warpQuery);
     1340            psFree(warp2Query);
    11391341            psFree(stackQuery);
    11401342            psFree(skycell_query);
    … …  
    11441346            return false;
    11451347        }
     1348
    11461349        psString filter = psMetadataLookupStr(&mdok, row, "filter");
    11471350        if (!mdok) {
    11481351            psError(PXTOOLS_ERR_PROG, false, "filter not found");
    1149             psFree(warpQuery);
     1352            psFree(warp2Query);
    11501353            psFree(stackQuery);
    11511354            psFree(skycell_query);
    … …  
    11551358            return false;
    11561359        }
    1157         if (!p_psDBRunQueryF(config->dbh, skycell_query, stackQuery, warp_id, filter, warpQuery)) {
    1158             psError(PS_ERR_UNKNOWN, false, "database error");
    1159             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);
    11601379            psFree(stackQuery);
    11611380            psFree(skycell_query);
    … …  
    11681387
    11691388        if (num == 0) {
    1170             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);
    11711390            continue;
    11721391        }
    11731392
    11741393        if (!available && (num != skycell_count)) {
    1175             psTrace("difftool", PS_LOG_INFO, "%" PRId64 " skyfiles with stack found for warp_id %"
    1176                 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);
    11771396            continue;
    11781397        }
    … …  
    11841403                workdir,
    11851404                label,
     1405                data_group ? data_group : label,
     1406                dist_group,
    11861407                reduction,
    11871408                NULL,       // dvodb
    … …  
    11901411                false,                  // bothways
    11911412                true,                   // exposure
    1192                 0       // magicked
     1413                0,       // magicked
     1414                IPP_DIFF_MODE_WARP_STACK,
     1415                note
    11931416        );
    11941417
    … …  
    12061429        if (!p_psDBRunQuery(config->dbh, query)) {
    12071430            psError(PS_ERR_UNKNOWN, false, "database error");
    1208             psFree(warpQuery);
     1431            psFree(warp2Query);
    12091432            psFree(stackQuery);
    12101433            psFree(skycell_query);
    … …  
    12201443        if (!p_psDBRunQuery(config->dbh, query)) {
    12211444            psError(PS_ERR_UNKNOWN, false, "database error");
    1222             psFree(warpQuery);
     1445            psFree(warp2Query);
    12231446            psFree(stackQuery);
    12241447            psFree(skycell_query);
    … …  
    12351458            psError(PS_ERR_UNKNOWN, false, "failed to change diffRun.state for diff_id: %" PRId64,
    12361459                run->diff_id);
    1237             psFree(warpQuery);
     1460            psFree(warp2Query);
    12381461            psFree(stackQuery);
    12391462            psFree(skycell_query);
    … …  
    12491472    }
    12501473    psFree(output);
    1251     psFree(warpQuery);
     1474    psFree(warp2Query);
    12521475    psFree(stackQuery);
    12531476    psFree(skycell_query);
    … …  
    12591482    }
    12601483
    1261     if (!diffRunPrintObjects(stdout, list, !simple)) {
     1484    if (numGood && !diffRunPrintObjects(stdout, list, !simple)) {
    12621485        psError(PS_ERR_UNKNOWN, false, "failed to print object");
    12631486        psFree(list);
    … …  
    12881511                   "ABS(TIME_TO_SEC(TIMEDIFF(inputRawExp.dateobs, templateRawExp.dateobs)))", "<=");
    12891512
     1513    // other where restrictions:
     1514    PXOPT_COPY_TIME(config->args,  selectWhere, "-dateobs_begin",      "inputRawExp.dateobs",        ">=");
     1515    PXOPT_COPY_TIME(config->args,  selectWhere, "-dateobs_end",        "inputRawExp.dateobs",        "<=");
     1516    PXOPT_COPY_RADEC(config->args, selectWhere, "-ra_min",             "inputRawExp.ra",             ">=");
     1517    PXOPT_COPY_RADEC(config->args, selectWhere, "-ra_max",             "inputRawExp.ra",             "<");
     1518    PXOPT_COPY_RADEC(config->args, selectWhere, "-decl_min",           "inputRawExp.decl",           ">=");
     1519    PXOPT_COPY_RADEC(config->args, selectWhere, "-decl_max",           "inputRawExp.decl",           "<");
     1520    PXOPT_COPY_F32(config->args,   selectWhere, "-sat_pixel_frac_min", "inputRawExp.sat_pixel_frac", ">=");
     1521    PXOPT_COPY_F32(config->args,   selectWhere, "-sat_pixel_frac_max", "inputRawExp.sat_pixel_frac", "<");
     1522    PXOPT_COPY_F64(config->args,   selectWhere, "-airmass_min",        "inputRawExp.airmass",        ">=");
     1523    PXOPT_COPY_F64(config->args,   selectWhere, "-airmass_max",        "inputRawExp.airmass",        "<");
     1524    PXOPT_COPY_F32(config->args,   selectWhere, "-exp_time_min",       "inputRawExp.exp_time",       ">=");
     1525    PXOPT_COPY_F32(config->args,   selectWhere, "-exp_time_max",       "inputRawExp.exp_time",       "<");
     1526    PXOPT_COPY_F64(config->args,   selectWhere, "-bg_min",             "inputRawExp.bg",             ">=");
     1527    PXOPT_COPY_F64(config->args,   selectWhere, "-bg_max",             "inputRawExp.bg",             "<");
     1528    PXOPT_COPY_F64(config->args,   selectWhere, "-bg_stdev_min",       "inputRawExp.bg_stdev",       ">=");
     1529    PXOPT_COPY_F64(config->args,   selectWhere, "-bg_stdev_max",       "inputRawExp.bg_stdev",       "<");
     1530    PXOPT_COPY_F64(config->args,   selectWhere, "-bg_mean_stdev_min",  "inputRawExp.bg_mean_stdev",  ">=");
     1531    PXOPT_COPY_F64(config->args,   selectWhere, "-bg_mean_stdev_max",  "inputRawExp.bg_mean_stdev",  "<");
     1532    PXOPT_COPY_F64(config->args,   selectWhere, "-alt_min",            "inputRawExp.alt",            ">=");
     1533    PXOPT_COPY_F64(config->args,   selectWhere, "-alt_max",            "inputRawExp.alt",            "<");
     1534    PXOPT_COPY_F64(config->args,   selectWhere, "-az_min",             "inputRawExp.az",             ">=");
     1535    PXOPT_COPY_F64(config->args,   selectWhere, "-az_max",             "inputRawExp.az",             "<");
     1536    PXOPT_COPY_F32(config->args,   selectWhere, "-ccd_temp_min",       "inputRawExp.ccd_temp",       ">=");
     1537    PXOPT_COPY_F32(config->args,   selectWhere, "-ccd_temp_max",       "inputRawExp.ccd_temp",       "<");
     1538    PXOPT_COPY_F64(config->args,   selectWhere, "-posang_min",         "inputRawExp.posang",         ">=");
     1539    PXOPT_COPY_F64(config->args,   selectWhere, "-posang_max",         "inputRawExp.posang",         "<");
     1540    PXOPT_COPY_F32(config->args,   selectWhere, "-sun_angle_min",      "inputRawExp.sun_angle",      ">=");
     1541    PXOPT_COPY_F32(config->args,   selectWhere, "-sun_angle_max",      "inputRawExp.sun_angle",      "<");
     1542    PXOPT_COPY_STR(config->args,   selectWhere, "-comment",            "inputRawExp.comment",        "LIKE");
     1543
    12901544    // Haversine formula for great circle distance
    12911545    PXOPT_COPY_F32(config->args, selectWhere, "-distance",
    … …  
    13061560    // Additional controls
    13071561    PXOPT_LOOKUP_BOOL(rerun, config->args, "-rerun", false);
    1308     PXOPT_LOOKUP_BOOL(available, config->args, "-available", false);
    13091562
    13101563    // Settings to apply to defined run
    1311     PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false); // required options
    1312     PXOPT_LOOKUP_STR(reduction, config->args, "-reduction", false, false); // option
    1313     PXOPT_LOOKUP_STR(label, config->args, "-label", false, false); // option
    1314     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
    13151572    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    13161573    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
    … …  
    13271584        psString tempCreate = pxDataGet("difftool_definewarpwarp_temp_create.sql"); // Create temp table SQL
    13281585        if (!tempCreate) {
    1329             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1586            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    13301587            psFree(selectWhere);
    13311588            psFree(insertWhere);
    … …  
    13501607        psString tempInsert = pxDataGet("difftool_definewarpwarp_temp_insert.sql"); // Insert to temp table
    13511608        if (!tempInsert) {
    1352             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1609            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    13531610            psFree(selectWhere);
    13541611            psFree(insertWhere);
    … …  
    13821639    psString select = pxDataGet("difftool_definewarpwarp_select.sql");
    13831640    if (!select) {
    1384         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1641        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    13851642        psFree(selectWhere);
    13861643        psFree(insertWhere);
    … …  
    13951652    if (psListLength(selectWhere->list)) {
    13961653        psString new = psDBGenerateWhereConditionSQL(selectWhere, NULL);
    1397         psStringAppend(&whereClause, "\n%s %s", whereClause ? "AND" : "WHERE", new);
     1654        psStringAppend(&whereClause, "\nAND %s", new);
    13981655        psFree(new);
    13991656    }
    14001657    psFree(selectWhere);
    14011658
    1402     if (!available) {
    1403         psStringAppend(&whereClause,
    1404                        "\n%s inputWarpRun.state = 'full'"
    1405                        "AND templateWarpRun.state = 'full'",
    1406                        whereClause ? "AND" : "WHERE");
    1407     }
    1408 
    14091659    if (!rerun) {
    1410         psStringAppend(&whereClause, "\n%s diffs.diff_id IS NULL", whereClause ? "AND" : "WHERE");
     1660        psStringAppend(&whereClause, "\nAND diffs.diff_id IS NULL");
    14111661    }
    14121662
    … …  
    14851735        const char *template = psMetadataLookupStr(NULL, row, "template_warp_id");
    14861736        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
    14871742        if (!input_id || !template || !tess_id) {
    14881743            psError(PXTOOLS_ERR_PROG, false, "Identifiers not found");
    … …  
    14951750            return false;
    14961751        }
    1497 
    1498         diffRunRow *run = diffRunRowAlloc(0, "reg", workdir, label, reduction, NULL, registered,
    1499                                           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
    15001768        if (!diffRunInsertObject(config->dbh, run)) {
    15011769            psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    15691837}
    15701838
     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}
    15712138
    15722139static bool pendingcleanuprunMode(pxConfig *config)
    … …  
    15822149    psString query = pxDataGet("difftool_pendingcleanuprun.sql");
    15832150    if (!query) {
    1584         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1585         return false;
    1586     }
     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;
    15872158
    15882159    if (where && psListLength(where->list)) {
    15892160        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    1590         psStringAppend(&query, " AND %s", whereClause);
     2161        psStringAppend(&whereClause, " AND ");
     2162        psStringSubstitute(&query,whereClause,"@INNERCONSTRAINT@");
    15912163        psFree(whereClause);
     2164    }
     2165    else {
     2166      psStringSubstitute(&query,NULL,"@INNERCONSTRAINT@");
    15922167    }
    15932168    psFree(where);
    … …  
    15992174        psFree(limitString);
    16002175    }
    1601 
     2176    //    fprintf(stderr,"%s",query);
     2177
     2178    //fprintf(stderr,"%s",query);
    16022179    if (!p_psDBRunQuery(config->dbh, query)) {
    16032180        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    16472224    psString query = pxDataGet("difftool_pendingcleanupskyfile.sql");
    16482225    if (!query) {
    1649         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     2226        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    16502227        return false;
    16512228    }
    … …  
    17072284    psString query = pxDataGet("difftool_donecleanup.sql");
    17082285    if (!query) {
    1709         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     2286        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    17102287        return false;
    17112288    }
    … …  
    17622339    psMetadata *where = psMetadataAlloc();
    17632340    PXOPT_COPY_S64(config->args, where, "-diff_id",   "diff_id",   "==");
     2341    PXOPT_COPY_STR(config->args, where, "-skycell_id", "skycell_id",   "==");
    17642342
    17652343    if (!pxSetFaultCode(config->dbh, "diffSkyfile", where, fault)) {
    … …  
    17732351}
    17742352
    1775 static bool diffRunComplete(pxConfig *config)
    1776 {
    1777     PS_ASSERT_PTR_NON_NULL(config, false);
    1778 
    1779     // look for completed diffRuns
    1780     psString query = pxDataGet("difftool_completed_runs.sql");
    1781     if (!query) {
    1782         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1783         return false;
    1784     }
    1785 
    1786     if (!p_psDBRunQuery(config->dbh, query)) {
    1787         psError(PS_ERR_UNKNOWN, false, "database error");
    1788         psFree(query);
    1789         return false;
    1790     }
    1791     psFree(query);
    1792 
    1793     psArray *output = p_psDBFetchResult(config->dbh);
    1794     if (!output) {
    1795         psError(PS_ERR_UNKNOWN, false, "database error");
    1796         return false;
    1797     }
    1798     if (!psArrayLength(output)) {
    1799         psTrace("difftool", PS_LOG_INFO, "no rows found");
    1800         psFree(output);
    1801         return true;
    1802     }
    1803     for (long i = 0; i < psArrayLength(output); i++) {
    1804         psMetadata *row = output->data[i];
    1805 
    1806         psS64 diff_id = psMetadataLookupS64(NULL, row, "diff_id");
    1807         psS64 magicked = psMetadataLookupS64(NULL, row, "magicked");
    1808 
    1809         // set diffRun.state to 'stop'
    1810         if (!setdiffRunState(config, diff_id, "full", magicked)) {
    1811             psError(PS_ERR_UNKNOWN, false, "failed to change diffRun.state for diff_id: %" PRId64,
    1812                 diff_id);
    1813             psFree(output);
    1814             return false;
    1815         }
    1816     }
    1817 
    1818     return true;
    1819 }
     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
    18202434
    18212435bool exportrunMode(pxConfig *config)
    … …  
    18412455  }
    18422456
     2457  if (!pxExportVersion(config, f)) {
     2458    psError(PS_ERR_UNKNOWN, false, "failed to write dbversion output file");
     2459    return false;
     2460  }
    18432461  psMetadata *where = psMetadataAlloc();
    18442462  PXOPT_COPY_S64(config->args, where, "-diff_id", "diff_id", "==");
    … …  
    18532471    psString query = pxDataGet(tables[i].sqlFilename);
    18542472    if (!query) {
    1855       psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     2473      psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    18562474      return false;
    18572475    }
    … …  
    19322550  psMetadata *input = psMetadataConfigRead (NULL, &nFail, infile, false);
    19332551
    1934   fprintf (stdout, "---- input ----\n");
     2552#ifdef notdef
     2553  fprintf (stderr, "---- input ----\n");
    19352554  psMetadataPrint (stderr, input, 1);
    1936 
     2555#endif
     2556
     2557  if (!pxCheckImportVersion(config, input)) {
     2558      psError(PS_ERR_UNKNOWN, false, "pxCheckImportVersion failed");
     2559      return false;
     2560  }
    19372561  psMetadataItem *item = psMetadataLookup (input, "diffRun");
    19382562  psAssert (item, "entry not in input?");
    … …  
    19842608  return true;
    19852609}
     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/simmosaic_branches/ippTools/src/difftool.h

    r24174 r27839  
    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/simmosaic_branches/ippTools/src/difftoolConfig.c

    r24174 r27839  
    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);
     190    psMetadataAddBool(revertdiffskyfileArgs, PS_LIST_TAIL, "-all",  0, "allow no search terms", 0);
    135191
    136192    // -definepoprun
    … …  
    155211    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-tess_id", 0, "search by tess ID", NULL);
    156212    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-filter", 0, "search by filter", NULL);
     213    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-comment", 0, "search by comment (LIKE)", NULL);
    157214    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-stack_label", 0, "search by stack label", NULL);
    158215    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);
    159217    psMetadataAddF32(definewarpstackArgs, PS_LIST_TAIL, "-good_frac", 0, "minimum good fraction of skycell", NAN);
    160     psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-workdir", 0, "define workdir (required)", NULL);
    161     psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-label",  0, "define label", NULL);
    162     psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-reduction",  0, "define reduction class", NULL);
    163     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);
    164225    psMetadataAddBool(definewarpstackArgs, PS_LIST_TAIL, "-new-templates", 0, "also search for diffs with new template", false);
    165226    psMetadataAddBool(definewarpstackArgs, PS_LIST_TAIL, "-rerun", 0, "define new run even if one exists", false);
    166     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);
    167228    psMetadataAddBool(definewarpstackArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    168229    psMetadataAddBool(definewarpstackArgs, PS_LIST_TAIL, "-pretend", 0, "list results but to not queue", false);
    … …  
    181242    psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-template_label", 0, "search by warp label for template", NULL);
    182243    psMetadataAddF32(definewarpwarpArgs, PS_LIST_TAIL, "-good_frac", 0, "minimum good fraction of skycell", NAN);
    183     psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-workdir", 0, "define workdir (required)", NULL);
    184     psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-label",  0, "define label", NULL);
    185     psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-reduction",  0, "define reduction class", NULL);
    186     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);
    187251    psMetadataAddBool(definewarpwarpArgs, PS_LIST_TAIL, "-rerun", 0, "define new run even if one exists", false);
    188     psMetadataAddBool(definewarpwarpArgs, PS_LIST_TAIL, "-available", 0, "define new run even if warpRun has some faults", false);
    189252    psMetadataAddBool(definewarpwarpArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    190253    psMetadataAddBool(definewarpwarpArgs, PS_LIST_TAIL, "-pretend", 0, "list results but to not queue", false);
     254    psMetadataAddTime(definewarpwarpArgs, PS_LIST_TAIL, "-dateobs_begin",      0, "search for exposures by time (>=)", NULL);
     255    psMetadataAddTime(definewarpwarpArgs, PS_LIST_TAIL, "-dateobs_end",        0, "search for exposures by time (<)", NULL);
     256    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-ra_min",             0, "search by min RA (degrees) ", NAN);
     257    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-ra_max",             0, "search by max RA (degrees) ", NAN);
     258    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-decl_min",           0, "search by min DEC (degrees)", NAN);
     259    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-decl_max",           0, "search by max DEC (degrees)", NAN);
     260    psMetadataAddF32(definewarpwarpArgs,  PS_LIST_TAIL, "-airmass_min",        0, "search by min airmass", NAN);
     261    psMetadataAddF32(definewarpwarpArgs,  PS_LIST_TAIL, "-airmass_max",        0, "search by max airmass", NAN);
     262    psMetadataAddF32(definewarpwarpArgs,  PS_LIST_TAIL, "-exp_time_min",       0, "search by min exposure time", NAN);
     263    psMetadataAddF32(definewarpwarpArgs,  PS_LIST_TAIL, "-exp_time_max",       0, "search by max exposure time", NAN);
     264    psMetadataAddF32(definewarpwarpArgs,  PS_LIST_TAIL, "-sat_pixel_frac_min", 0, "search by min fraction of saturated pixels", NAN);
     265    psMetadataAddF32(definewarpwarpArgs,  PS_LIST_TAIL, "-sat_pixel_frac_max", 0, "search by max fraction of saturated pixels", NAN);
     266    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-bg_min",             0, "search by min background", NAN);
     267    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-bg_max",             0, "search by max background", NAN);
     268    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-bg_stdev_min",       0, "search by min background standard deviation", NAN);
     269    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-bg_stdev_max",       0, "search by max background standard deviation", NAN);
     270    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-bg_mean_stdev_min",  0, "search by min background mean standard deviation (across imfiles)", NAN);
     271    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-bg_mean_stdev_max",  0, "search by max background mean standard deviation (across imfiles)", NAN);
     272    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-alt_min",            0, "search by min altitude", NAN);
     273    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-alt_max",            0, "search by max altitude", NAN);
     274    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-az_min",             0, "search by min azimuth ", NAN);
     275    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-az_max",             0, "search by max azimuth ", NAN);
     276    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-ccd_temp_min",       0, "search by min ccd tempature", NAN);
     277    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-ccd_temp_max",       0, "search by max ccd tempature", NAN);
     278    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-posang_min",         0, "search by min rotator position angle", NAN);
     279    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-posang_max",         0, "search by max rotator position angle", NAN);
     280    psMetadataAddF32(definewarpwarpArgs,  PS_LIST_TAIL, "-sun_angle_min",         0, "search by min solar angle", NAN);
     281    psMetadataAddF32(definewarpwarpArgs,  PS_LIST_TAIL, "-sun_angle_max",         0, "search by max solar angle", NAN);
     282    psMetadataAddStr(definewarpwarpArgs,  PS_LIST_TAIL, "-comment",            0, "search by comment field (LIKE comparison)", NULL);
     283
     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
    191306
    192307    // -pendingcleanuprun
    193308    psMetadata *pendingcleanuprunArgs = psMetadataAlloc();
    194     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);
    195310    psMetadataAddBool(pendingcleanuprunArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    196311    psMetadataAddU64(pendingcleanuprunArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    … …  
    211326    psMetadata *updatediffskyfileArgs = psMetadataAlloc();
    212327    psMetadataAddS64(updatediffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,      "define diff ID (required)", 0);
    213     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
    214359
    215360    // -exportrun
    … …  
    237382    PXOPT_ADD_MODE("-todiffskyfile",    "", DIFFTOOL_MODE_TODIFFSKYFILE,     todiffskyfileArgs);
    238383    PXOPT_ADD_MODE("-adddiffskyfile",   "", DIFFTOOL_MODE_ADDDIFFSKYFILE,    adddiffskyfileArgs);
     384    PXOPT_ADD_MODE("-advance",          "", DIFFTOOL_MODE_ADVANCE,           advanceArgs);
    239385    PXOPT_ADD_MODE("-diffskyfile",      "", DIFFTOOL_MODE_DIFFSKYFILE,       diffskyfileArgs);
     386    PXOPT_ADD_MODE("-listrun",          "", DIFFTOOL_MODE_LISTRUN,           listrunArgs);
    240387    PXOPT_ADD_MODE("-revertdiffskyfile","", DIFFTOOL_MODE_REVERTDIFFSKYFILE, revertdiffskyfileArgs);
    241388    PXOPT_ADD_MODE("-definepoprun",     "", DIFFTOOL_MODE_DEFINEPOPRUN,      definepoprunArgs);
    242389    PXOPT_ADD_MODE("-definewarpstack",  "", DIFFTOOL_MODE_DEFINEWARPSTACK,   definewarpstackArgs);
    243390    PXOPT_ADD_MODE("-definewarpwarp",   "", DIFFTOOL_MODE_DEFINEWARPWARP,    definewarpwarpArgs);
     391    PXOPT_ADD_MODE("-definestackstack", "", DIFFTOOL_MODE_DEFINESTACKSTACK,  definestackstackArgs);
    244392    PXOPT_ADD_MODE("-pendingcleanuprun",     "show runs that need to be cleaned up", DIFFTOOL_MODE_PENDINGCLEANUPRUN,    pendingcleanuprunArgs);
    245393    PXOPT_ADD_MODE("-pendingcleanupskyfile", "show runs that need to be cleaned up", DIFFTOOL_MODE_PENDINGCLEANUPSKYFILE, pendingcleanupskyfileArgs);
    246394    PXOPT_ADD_MODE("-donecleanup",           "show runs that have been cleaned",     DIFFTOOL_MODE_DONECLEANUP,          donecleanupArgs);
    247395    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
    248398    PXOPT_ADD_MODE("-exportrun",            "export run for import on other database", DIFFTOOL_MODE_EXPORTRUN, exportrunArgs);
    249399    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);
    250405
    251406    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

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

    r24731 r27839  
    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);
    385 
    386         if (set_label == NULL) {
    387             set_label = target_label;
    388         }
     394        psStringAppend(&outroot, "%s/%s/%s", workdir, run_tag, stage);
     395
     396        psString new_label;
     397        if (set_label != NULL) {
     398            new_label = set_label;
     399        } else {
     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
    389409        distRunRow *row = distRunRowAlloc(
    390410                0,      // dist_id
    … …  
    392412                stage,
    393413                stage_id,
    394                 set_label,
     414                magic_ds_id,
     415                new_label,
    395416                outroot,
     417                NULL,     // outdir
    396418                clean,
    397419                no_magic,
     420                use_alternate,
    398421                "new",
    399                 NULL,   // time_stamp
    400                 0       // fault
     422                NULL,    // time_stamp
     423                0,       // fault
     424                new_data_group,
     425                set_note // note does not propagate
    401426                );
    402427
    … …  
    441466    PXOPT_COPY_S64(config->args, where, "-dist_id", "dist_id", "==");
    442467    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");;
    443     PXOPT_COPY_STR(config->args, where, "-state", "state", "==");
     468    PXOPT_COPY_STR(config->args, where, "-state", "distRun.state", "==");
    444469    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", "==");
    445473
    446474    if (!psListLength(where->list)) {
    447475        psFree(where);
    448         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     476        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    449477        return false;
    450478    }
    … …  
    452480    PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
    453481    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);
    454484    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
    455 
    456     if ((!state) && (!label) && (!fault)) {
    457         psError(PXTOOLS_ERR_DATA, false, "parameters (-fault or -set_state or -set_label) are required");
    458         psFree(where);
    459         return false;
    460     }
    461 
    462     psString query = psStringCopy("UPDATE distRun SET time_stamp = UTC_TIMESTAMP()");
    463 
     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    }
    464498    if (state) {
    465         psStringAppend(&query, " , state = '%s'", state);
     499        psStringAppend(&query, " , distRun.state = '%s'", state);
    466500    }
    467501
    468502    if (label) {
    469         psStringAppend(&query, " , label = '%s'", label);
     503        psStringAppend(&query, " , distRun.label = '%s'", label);
    470504    }
    471505
    472506    if (fault) {
    473         psStringAppend(&query, " , fault = %d", fault);
    474     }
     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
    475518
    476519    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    … …  
    497540    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
    498541
    499     // we need to disambiguate fault so make a copy of the where list before adding fault
    500     psMetadata *whereComponent = psMetadataCopy(NULL, where);
    501542    PXOPT_COPY_S16(config->args, where,  "-fault", "distRun.fault", "==");
    502     PXOPT_COPY_S16(config->args, whereComponent, "-fault", "distComponent.fault", "==");
    503543
    504544    // It might be useful to be able to query by the parameters of the underlying runs
    … …  
    506546    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    507547        psFree(where);
    508         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
    509         return false;
    510     }
    511 
    512     if (!psDBTransaction(config->dbh)) {
    513         psError(PS_ERR_UNKNOWN, false, "database error");
    514         psFree(where);
    515         return false;
    516     }
    517 
    518     // Update state to 'new'
    519     int numUpdated;                     // Number updated
    520     {
    521         psString query = pxDataGet("disttool_revertrun_update.sql");
    522         if (!query) {
    523             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    524             if (!psDBRollback(config->dbh)) {
    525                 psError(PS_ERR_UNKNOWN, false, "database error");
    526             }
    527             return false;
    528         }
    529 
    530         if (psListLength(where->list)) {
    531             psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    532             psStringAppend(&query, " AND %s", whereClause);
    533             psFree(whereClause);
    534         }
    535 
    536         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)) {
    537556            psError(PS_ERR_UNKNOWN, false, "database error");
    538             psFree(query);
    539             if (!psDBRollback(config->dbh)) {
    540                 psError(PS_ERR_UNKNOWN, false, "database error");
    541             }
    542             return false;
    543         }
    544         psFree(query);
    545 
    546         numUpdated = psDBAffectedRows(config->dbh);
    547     }
     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);
    548575
    549576    psLogMsg("disttool", PS_LOG_INFO, "Updated %d dist runs", numUpdated);
    550577
    551     // Delete product
    552     int numDeleted;                     // Number deleted
    553     {
    554         psString query = pxDataGet("disttool_revertrun_delete.sql");
    555         if (!query) {
    556             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    557             if (!psDBRollback(config->dbh)) {
    558                 psError(PS_ERR_UNKNOWN, false, "database error");
    559             }
    560             return false;
    561         }
    562 
    563         if (psListLength(whereComponent->list)) {
    564             psString whereClause = psDBGenerateWhereConditionSQL(whereComponent, NULL);
    565             psStringAppend(&query, " AND %s", whereClause);
    566             psFree(whereClause);
    567         }
    568 
    569         if (!p_psDBRunQuery(config->dbh, query)) {
    570             psError(PS_ERR_UNKNOWN, false, "database error");
    571             psFree(query);
    572             if (!psDBRollback(config->dbh)) {
    573                 psError(PS_ERR_UNKNOWN, false, "database error");
    574             }
    575             return false;
    576         }
    577         psFree(query);
    578 
    579         numDeleted = psDBAffectedRows(config->dbh);
    580     }
     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);
    581622
    582623    psLogMsg("disttool", PS_LOG_INFO, "Deleted %d distComponents", numDeleted);
    583624
    584     psFree(where);
    585     psFree(whereComponent);
    586 
    587     if (!psDBCommit(config->dbh)) {
    588         psError(PS_ERR_UNKNOWN, false, "database error");
    589         return false;
    590     }
    591 
    592625    return true;
    593626}
    … …  
    597630    PS_ASSERT_PTR_NON_NULL(config, false);
    598631
    599     psMetadata *where = psMetadataAlloc();
    600     PXOPT_COPY_S64(config->args, where, "-dist_id", "dist_id", "==");
    601     PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
    602     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", "==");
    603637
    604638    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    605639    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    606640
    607     // look for "inputs" that need to processed
    608     psString query = pxDataGet("disttool_pendingcomponent.sql");
     641    psString queryFile = NULL;
     642    psStringAppend(&queryFile, "disttool_pending_%s.sql", stage);
     643    psString query = pxDataGet(queryFile);
    609644    if (!query) {
    610         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     645        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement from %s", queryFile);
    611646        return false;
    612647    }
    … …  
    614649    if (psListLength(where->list)) {
    615650        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    616         psStringAppend(&query, " WHERE %s", whereClause);
     651        psStringAppend(&query, " AND %s", whereClause);
    617652        psFree(whereClause);
    618653    }
    … …  
    626661    }
    627662
    628     // the query has where hooks for each stage.
    629     // right now we aren't using them.
    630     // XXX: I think that I want to change the query from a union of selects on the various
    631     // stages to separate queries. As it is pending data at the later stages of the pipline
    632     // will get blocked by pending earlier stages
    633     psString    raw_where = "";
    634     psString    raw_clean_where = "";
    635     psString    chip_where = "";
    636     psString    camera_where = "";
    637     psString    fake_where = "";
    638     psString    warp_where = "";
    639     psString    diff_where = "";
    640     psString    stack_where = "";
    641 
    642     if (!p_psDBRunQueryF(config->dbh,
    643             query,
    644             raw_where,
    645             raw_clean_where,
    646             chip_where,
    647             camera_where,
    648             fake_where,
    649             warp_where,
    650             diff_where,
    651             stack_where)) {
     663    if (!p_psDBRunQuery(config->dbh, query)) {
    652664        psError(PS_ERR_UNKNOWN, false, "database error");
    653665        psFree(query);
    … …  
    705717    PXOPT_LOOKUP_S32(bytes, config->args, "-bytes", require_fileinfo, false);
    706718    PXOPT_LOOKUP_STR(md5sum, config->args, "-md5sum", require_fileinfo, false);
     719    PXOPT_LOOKUP_STR(outdir, config->args, "-outdir", require_fileinfo, false);
    707720    PXOPT_LOOKUP_STR(name, config->args, "-name", require_fileinfo, false);
    708721
    709     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)) {
    710723        psError(PS_ERR_UNKNOWN, false, "database error");
    711724        return false;
    … …  
    729742    psString query = pxDataGet("disttool_toadvance.sql");
    730743    if (!query) {
    731         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     744        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    732745        return false;
    733746    }
    … …  
    800813    psString query = pxDataGet("disttool_processedcomponent.sql");
    801814    if (!query) {
    802         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     815        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    803816        return false;
    804817    }
    … …  
    865878    psMetadata *where = psMetadataAlloc();
    866879    PXOPT_COPY_S64(config->args, where, "-dist_id", "dist_id", "==");
     880    PXOPT_COPY_STR(config->args, where, "-stage", "distRun.stage", "==");
    867881    pxAddLabelSearchArgs (config, where, "-label", "distRun.label", "==");
    868882
    … …  
    873887    psString query = pxDataGet("disttool_pendingfileset.sql");
    874888    if (!query) {
    875         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     889        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    876890        return false;
    877891    }
    … …  
    936950    // required values
    937951    PXOPT_LOOKUP_S64(dist_id, config->args, "-dist_id", true, false);
    938     PXOPT_LOOKUP_S64(prod_id, config->args, "-prod_id", true, false);
     952    PXOPT_LOOKUP_S64(dest_id, config->args, "-dest_id", true, false);
    939953
    940954    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
    … …  
    943957    PXOPT_LOOKUP_STR(name, config->args, "-name", fault == 0, false);
    944958
    945     if (!rcDSFilesetInsert(config->dbh, 
     959    if (!rcDSFilesetInsert(config->dbh,
    946960            0,          // fs_id
    947961            dist_id,
    948             prod_id,
     962            dest_id,
    949963            name,
    950964            "full",
    … …  
    956970    return true;
    957971}
     972
    958973static bool revertfilesetMode(pxConfig *config)
    959974{
    … …  
    961976    PXOPT_COPY_S64(config->args, where, "-fs_id", "fs_id", "==");
    962977    PXOPT_COPY_S64(config->args, where, "-dist_id", "rcDSFileset.dist_id", "==");
    963     PXOPT_COPY_S64(config->args, where, "-prod_id", "prod_id", "==");
     978    PXOPT_COPY_S64(config->args, where, "-dest_id", "dest_id", "==");
    964979    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");;
    965980    PXOPT_COPY_S64(config->args, where, "-stage_id", "stage_id", "==");
    … …  
    972987    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    973988        psFree(where);
    974         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     989        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    975990        return false;
    976991    }
    … …  
    978993    psString query = pxDataGet("disttool_revertfileset.sql");
    979994    if (!query) {
    980         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     995        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    981996        psFree(where);
    982997        return false;
    … …  
    10201035    psString query = pxDataGet("disttool_pendingdest.sql");
    10211036    if (!query) {
    1022         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1037        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10231038        return false;
    10241039    }
    … …  
    10891104    PXOPT_COPY_S64(config->args, where, "-dist_id",  "dist_id", "==");
    10901105    PXOPT_COPY_S64(config->args, where, "-dest_id",  "dest_id", "==");
    1091     PXOPT_COPY_S64(config->args, where, "-prod_id",  "prod_id", "==");
    10921106    PXOPT_COPY_S64(config->args, where, "-target_id","target_id", "==");
    10931107    PXOPT_COPY_S64(config->args, where, "-fs_id",    "fs_id", "==");
    … …  
    11001114    psString query = pxDataGet("disttool_queuercrun.sql");
    11011115    if (!query) {
    1102         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1116        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11031117        return false;
    11041118    }
    … …  
    11461160    // We either need rc_id or (dest_id and fs_name) to identifiy the rcRun
    11471161    if ((!rc_id) && !(dest_id && fs_name)) {
    1148         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");
    11491163        return false;
    11501164    }
    … …  
    11581172        // this can't happen because we checked above
    11591173        psFree(where);
    1160         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     1174        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    11611175        return false;
    11621176    }
    … …  
    11681182
    11691183    if (!state && (fault < 0)) {
    1170         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");
    11711185        psFree(where);
    11721186        return false;
    … …  
    11751189    psString query = pxDataGet("disttool_updatercrun.sql");
    11761190    if (!query) {
    1177         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1191        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11781192        return false;
    11791193    }
    … …  
    12321246    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    12331247        psFree(where);
    1234         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     1248        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    12351249        return false;
    12361250    }
    … …  
    12381252    psString query = pxDataGet("disttool_revertrcrun.sql");
    12391253    if (!query) {
    1240         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1254        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    12411255        if (!psDBRollback(config->dbh)) {
    12421256            psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    12731287
    12741288    // required
    1275     PXOPT_LOOKUP_STR(label, config->args, "-label", true, false);
     1289    PXOPT_LOOKUP_STR(dist_group, config->args, "-dist_group", true, false);
    12761290    PXOPT_LOOKUP_STR(filter, config->args, "-filter", true, false);
    12771291    PXOPT_LOOKUP_STR(stage, config->args, "-stage", true, false);
    … …  
    12841298    distTargetRow *row = distTargetRowAlloc(
    12851299            0,          // target_id
    1286             label,
     1300            dist_group,
    12871301            filter,
    12881302            stage,
    … …  
    12911305            comment
    12921306            );
    1293            
     1307
    12941308    if (!row) {
    12951309        psError(PS_ERR_UNKNOWN, false, "failed to allocate distTarget object");
    … …  
    13211335    psMetadata *where = psMetadataAlloc();
    13221336    PXOPT_COPY_S64(config->args, where, "-target_id", "target_id", "==");
    1323     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     1337    PXOPT_COPY_STR(config->args, where, "-dist_group", "dist_group", "==");
    13241338    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "==");
    13251339    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
    … …  
    13511365}
    13521366
    1353 static bool listtargetMode(pxConfig *config)
     1367static bool listtargetsMode(pxConfig *config)
    13541368{
    13551369    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    13571371    psMetadata *where = psMetadataAlloc();
    13581372    PXOPT_COPY_S64(config->args, where, "-target_id", "target_id", "==");
    1359     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     1373    PXOPT_COPY_STR(config->args, where, "-dist_group", "dist_group", "LIKE");
    13601374    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "==");
    13611375    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
    … …  
    14301444}
    14311445
    1432 static bool definedsproductMode(pxConfig *config)
     1446static bool definedestinationMode(pxConfig *config)
    14331447{
    14341448    PS_ASSERT_PTR_NON_NULL(config, false);
    14351449
    14361450    // required
    1437     PXOPT_LOOKUP_STR(name, config->args,   "-name", true, false);
    1438     PXOPT_LOOKUP_STR(dbname, config->args, "-ds_dbname", true, false);
    1439     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);
    14401460
    14411461    // XXX: should we insure that these names do not contatin any whitespace?
    14421462
    1443     rcDSProductRow *row = rcDSProductRowAlloc(
    1444             0,          // prod_id
     1463    rcDestinationRow *row = rcDestinationRowAlloc(
     1464            0,          // dest_id
    14451465            name,
     1466            status_uri,
     1467            comment,
     1468            last_fileset,
    14461469            dbname,
    1447             dbhost
     1470            dbhost,
     1471            state ? state : "enabled"
    14481472            );
    1449            
     1473
    14501474    if (!row) {
    1451         psError(PS_ERR_UNKNOWN, false, "failed to allocate rcDSProduct object");
    1452         return false;
    1453     }
    1454    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)) {
    14551479        psError(PS_ERR_UNKNOWN, false, "database error");
    14561480        psFree(row);
    … …  
    14591483
    14601484    // get the assigned target_id
    1461     row->prod_id = psDBLastInsertID(config->dbh);
    1462 
    1463     if (!rcDSProductPrintObject(stdout, row, true)) {
     1485    row->dest_id = psDBLastInsertID(config->dbh);
     1486
     1487    if (!rcDestinationPrintObject(stdout, row, true)) {
    14641488        psError(PS_ERR_UNKNOWN, false, "failed to print object");
    14651489        psFree(row);
    … …  
    14711495    return true;
    14721496}
    1473 static bool updatedsproductMode(pxConfig *config)
     1497
     1498static bool updatedestinationMode(pxConfig *config)
    14741499{
    14751500    PS_ASSERT_PTR_NON_NULL(config, false);
    14761501
    14771502    psMetadata *where = psMetadataAlloc();
    1478     PXOPT_COPY_S64(config->args, where, "-prod_id", "prod_id", "==");
    1479 
    1480     PXOPT_LOOKUP_STR(dbname, config->args, "-ds_dbname", false, false);
    1481     PXOPT_LOOKUP_STR(dbhost, config->args, "-ds_dbhost", false, false);
    1482 
    1483     if (!(dbname || dbhost)) {
    1484         psError(PS_ERR_UNKNOWN, true, "one or more of dbname or dbhost is required");
    1485         psFree(where);
    1486         return false;
    1487     }
    1488     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");
    14891517    psString sep = "";
    1490     if (dbname) {
    1491         psStringAppend(&query, " dbname = '%s'", dbname);
     1518    if (state) {
     1519        psStringAppend(&query, " state = '%s'", state);
    14921520        sep = ",";
    14931521    }
    1494     if (dbhost) {
    1495         psStringAppend(&query, " %s dbhost = '%s'", sep, dbhost);
    1496     }
     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
    14971530
    14981531    if (psListLength(where->list)) {
    … …  
    15181551}
    15191552
    1520 static bool definedestinationMode(pxConfig *config)
     1553static bool defineinterestMode(pxConfig *config)
    15211554{
    15221555    PS_ASSERT_PTR_NON_NULL(config, false);
    15231556
    1524     // required
    1525     PXOPT_LOOKUP_S64(prod_id, config->args,      "-prod_id", true, false);
    1526     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    }
    15271586
    15281587    // optional
    1529     PXOPT_LOOKUP_STR(status_uri, config->args,   "-status_uri", false, false);
    1530     PXOPT_LOOKUP_STR(comment, config->args,      "-comment", false, false);
    1531     PXOPT_LOOKUP_STR(last_fileset, config->args, "-last_fileset", false, false);
    1532     PXOPT_LOOKUP_STR(state, config->args,        "-set_state", false, false);
    1533 
    1534     // XXX: should we insure that these names do not contatin any whitespace?
    1535 
    1536     rcDestinationRow *row = rcDestinationRowAlloc(
    1537             0,          // dest_id
    1538             prod_id,
    1539             name,
    1540             status_uri,
    1541             comment,
    1542             last_fileset,
    1543             state ? state : "enabled"
    1544             );
    1545            
    1546     if (!row) {
    1547         psError(PS_ERR_UNKNOWN, false, "failed to allocate rcDestination object");
    1548         return false;
    1549     }
    1550    if (!rcDestinationInsertObject(config->dbh, row)) {
    1551         psError(PS_ERR_UNKNOWN, false, "database error");
    1552         psFree(row);
    1553         return false;
    1554     }
    1555 
    1556     // get the assigned target_id
    1557     row->dest_id = psDBLastInsertID(config->dbh);
    1558 
    1559     if (!rcDestinationPrintObject(stdout, row, true)) {
    1560         psError(PS_ERR_UNKNOWN, false, "failed to print object");
    1561         psFree(row);
    1562         return false;
    1563     }
    1564 
    1565     psFree(row);
    1566 
    1567     return true;
    1568 }
    1569 
    1570 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)
    15711663{
    15721664    PS_ASSERT_PTR_NON_NULL(config, false);
    15731665
    15741666    psMetadata *where = psMetadataAlloc();
    1575     PXOPT_COPY_S64(config->args, where, "-dest_id", "dest_id", "==");
    1576     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       
    15771683
    15781684    PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
    1579 #ifdef ALLOW_UPDATE_LAST_FILESET
    1580     PXOPT_LOOKUP_STR(last_fileset, config->args, "-set_last_fileset", false, false);
    1581     if (!(state || last_fileset)) {
    1582         psError(PS_ERR_UNKNOWN, true, "one or more of -set_state or -set_last_fileset is required");
    1583 # else
    15841685    if (!state) {
    1585 #endif
    1586         psFree(where);
    1587         return false;
    1588     }
    1589     psString query = psStringCopy("UPDATE rcDestination SET");
    1590     psString sep = "";
    1591     if (state) {
    1592         psStringAppend(&query, " state = '%s'", state);
    1593         sep = ",";
    1594     }
    1595 #ifdef ALLOW_UPDATE_LAST_FILESET
    1596     // last_fileset normally gets set by updatercrunMode
    1597     // Allowing it to be set here might cause problems
    1598     // especially since we are allowing selection by prod_id
    1599     if (last_fileset) {
    1600         psStringAppend(&query, " %s last_fileset = '%s'", sep, last_fileset);
    1601     }
    1602 #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");
    16031691
    16041692    if (psListLength(where->list)) {
    … …  
    16141702    psFree(where);
    16151703
    1616     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)) {
    16171711        psError(PS_ERR_UNKNOWN, false, "database error");
    16181712        psFree(query);
    … …  
    16211715    psFree(query);
    16221716
    1623     return true;
    1624 }
    1625 
    1626 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)
    16271723{
    16281724    PS_ASSERT_PTR_NON_NULL(config, false);
    16291725
    1630     // required
    1631     PXOPT_LOOKUP_S64(dest_id, config->args,      "-dest_id", true, false);
    1632     PXOPT_LOOKUP_S64(target_id, config->args,    "-target_id", true, false);
    1633 
    1634     // optional
    1635     PXOPT_LOOKUP_STR(state, config->args,        "-set_state", false, false);
    1636 
    1637     // XXX: should we insure that these names do not contatin any whitespace?
    1638 
    1639     rcInterestRow *row = rcInterestRowAlloc(
    1640             0,          // int_id
    1641             dest_id,
    1642             target_id,
    1643             state ? state : "enabled"
    1644             );
    1645            
    1646     if (!row) {
    1647         psError(PS_ERR_UNKNOWN, false, "failed to allocate rcInterest object");
    1648         return false;
    1649     }
    1650    if (!rcInterestInsertObject(config->dbh, row)) {
    1651         psError(PS_ERR_UNKNOWN, false, "database error");
    1652         psFree(row);
    1653         return false;
    1654     }
    1655 
    1656     // get the assigned target_id
    1657     row->int_id = psDBLastInsertID(config->dbh);
    1658 
    1659     if (!rcInterestPrintObject(stdout, row, true)) {
    1660         psError(PS_ERR_UNKNOWN, false, "failed to print object");
    1661         psFree(row);
    1662         return false;
    1663     }
    1664 
    1665     psFree(row);
    1666 
    1667     return true;
    1668 }
    1669 
    1670 static bool updateinterestMode(pxConfig *config)
    1671 {
    1672     PS_ASSERT_PTR_NON_NULL(config, false);
    1673 
    1674     psMetadata *where = psMetadataAlloc();
    1675     PXOPT_COPY_S64(config->args, where, "-int_id",    "int_id", "==");
    1676     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", "==");
    16771730    PXOPT_COPY_S64(config->args, where, "-target_id", "target_id", "==");
    1678 
    1679     PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
    1680     if (!state) {
    1681         psError(PS_ERR_UNKNOWN, true, "-set_state is required");
    1682         psFree(where);
    1683         return false;
    1684     }
    1685     psString query = NULL;
    1686     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");
    16871748
    16881749    if (psListLength(where->list)) {
    … …  
    16901751        psStringAppend(&query, " WHERE %s", whereClause);
    16911752        psFree(whereClause);
    1692     } else {
    1693         psError(PS_ERR_UNKNOWN, true, "search parameters are required");
    1694         psFree(where);
    1695         psFree(query);
    1696         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");
    16971762    }
    16981763    psFree(where);
    16991764
     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
    17001772    if (!p_psDBRunQuery(config->dbh, query)) {
    17011773        psError(PS_ERR_UNKNOWN, false, "database error");
    17021774        psFree(query);
     1775        if (!psDBRollback(config->dbh)) {
     1776            psError(PS_ERR_UNKNOWN, false, "database error");
     1777        }
    17031778        return false;
    17041779    }
    17051780    psFree(query);
    17061781
    1707     return true;
    1708 }
    1709 
     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/simmosaic_branches/ippTools/src/disttool.h

    r24001 r27839  
    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/simmosaic_branches/ippTools/src/disttoolConfig.c

    r24857 r27839  
    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",         PS_META_DUPLICATE_OK, "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/simmosaic_branches/ippTools/src/faketool.c

    r24733 r27839  
    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", "==");
    … …  
    157161    PXOPT_COPY_F64(config->args, where, "-posang_max", "posang", "<");
    158162    PXOPT_COPY_STR(config->args, where, "-object", "object", "==");
    159     PXOPT_COPY_F32(config->args, where, "-solang_min", "solang", ">=");
    160     PXOPT_COPY_F32(config->args, where, "-solang_max", "solang", "<");
     163    PXOPT_COPY_F32(config->args, where, "-sun_angle_min", "sun_angle", ">=");
     164    PXOPT_COPY_F32(config->args, where, "-sun_angle_max", "sun_angle", "<");
    161165    PXOPT_COPY_STR(config->args, where, "-comment", "comment", "LIKE");
    162166
    … …  
    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");
    … …  
    325332    PXOPT_COPY_F64(config->args, where, "-posang_max", "posang", "<");
    326333    PXOPT_COPY_STR(config->args, where, "-object", "object", "==");
    327     PXOPT_COPY_F32(config->args, where, "-solang_min", "solang", ">=");
    328     PXOPT_COPY_F32(config->args, where, "-solang_max", "solang", "<");
     334    PXOPT_COPY_F32(config->args, where, "-sun_angle_min", "sun_angle", ">=");
     335    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);
    … …  
    669661    PXOPT_COPY_F64(config->args, where, "-posang_max", "posang", "<");
    670662    PXOPT_COPY_STR(config->args, where, "-object", "object", "==");
    671     PXOPT_COPY_F32(config->args, where, "-solang_min", "solang", ">=");
    672     PXOPT_COPY_F32(config->args, where, "-solang_max", "solang", "<");
     663    PXOPT_COPY_F32(config->args, where, "-sun_angle_min", "sun_angle", ">=");
     664    PXOPT_COPY_F32(config->args, where, "-sun_angle_max", "sun_angle", "<");
    673665
    674666    if (!psListLength(where->list)
    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/simmosaic_branches/ippTools/src/faketool.h

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

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

    r24733 r27839  
    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);
    … …  
    8486    psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-posang_max",  0,            "define max rotator position angle", NAN);
    8587    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-object",  0,            "search by exposure object", NULL);
    86     psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-solang_min",  0,            "define min solar angle", NAN);
    87     psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-solang_max",  0,            "define max solar angle", NAN);
     88    psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-sun_angle_min",  0,            "define min solar angle", NAN);
     89    psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-sun_angle_max",  0,            "define max solar angle", NAN);
    8890    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_workdir",  0,            "define workdir", NULL);
    8991    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_label",  0,            "define label", 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);
    … …  
    137142    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-posang_max",  0,            "define max rotator position angle", NAN);
    138143    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-object",  0,            "search by exposure object", NULL);
    139     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-solang_min",  0,            "define min solar angle", NAN);
    140     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-solang_max",  0,            "define max solar angle", NAN);
     144    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-sun_angle_min",  0,            "define min solar angle", NAN);
     145    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
    … …  
    235245    psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-posang_max",  0,            "define max rotator position angle", NAN);
    236246    psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-object",  0,            "search by exposure object", NULL);
    237     psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-solang_min",  0,            "define min solar angle", NAN);
    238     psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-solang_max",  0,            "define max solar angle", NAN);
     247    psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-sun_angle_min",  0,            "define min solar angle", NAN);
     248    psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-sun_angle_max",  0,            "define max solar angle", NAN);
    239249
    240250    psMetadataAddBool(revertprocessedimfileArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);
    … …  
    300310    psMetadataAddS64(topurgedimfileArgs, PS_LIST_TAIL, "-fake_id", 0,          "fake ID to update", 0);
    301311    psMetadataAddStr(topurgedimfileArgs, PS_LIST_TAIL, "-class_id",  0,        "class ID to update", NULL);
     312
     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);
    302317
    303318    // -exportrun
    … …  
    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/simmosaic_branches/ippTools/src/flatcorr.c

    r24140 r27839  
    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/simmosaic_branches/ippTools/src/flatcorr.h

    r23310 r27839  
    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/simmosaic_branches/ippTools/src/flatcorrConfig.c

    r24140 r27839  
    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/simmosaic_branches/ippTools/src/magicdstool.c

    r24709 r27839  
    22 * magicdstool.c
    33 *
    4  * Copyright (C) 2006-2007  IfA
     4 * Copyright (C) 2006-2009  IfA
    55 *
    66 * This program is free software; you can redistribute it and/or modify it
    … …  
    2727#include <math.h>
    2828#include <ippdb.h>
     29#include <ippStages.h>
    2930
    3031#include "pxtools.h"
    … …  
    3233
    3334static bool definebyqueryMode(pxConfig *config);
    34 static psS64 definerunMode(pxConfig *config);
     35static bool definecopyMode(pxConfig *config);
    3536static bool updaterunMode(pxConfig *config);
    3637static bool todestreakMode(pxConfig *config);
    3738static bool adddestreakedfileMode(pxConfig *config);
     39static bool advancerunMode(pxConfig *config);
    3840static bool revertdestreakedfileMode(pxConfig *config);
     41static bool clearstatefaultsMode(pxConfig *config);
    3942static bool getskycellsMode(pxConfig *config);
    4043static bool toremoveMode(pxConfig *config);
    41 static bool torestoreMode(pxConfig *config);
    4244static bool torevertMode(pxConfig *config);
    43 
    44 static bool setmagicDSRunState(pxConfig *config, psS64 magic_id, const char *state);
    45 static bool magicDSRunComplete(pxConfig *config, bool setmagicked);
    46 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);
    4749
    4850# define MODECASE(caseName, func) \
    … …  
    6567    switch (config->mode) {
    6668        MODECASE(MAGICDSTOOL_MODE_DEFINEBYQUERY,       definebyqueryMode);
    67         MODECASE(MAGICDSTOOL_MODE_DEFINERUN,           definerunMode);
     69        MODECASE(MAGICDSTOOL_MODE_DEFINECOPY,          definecopyMode);
    6870        MODECASE(MAGICDSTOOL_MODE_UPDATERUN,           updaterunMode);
    6971        MODECASE(MAGICDSTOOL_MODE_TODESTREAK,          todestreakMode);
    7072        MODECASE(MAGICDSTOOL_MODE_ADDDESTREAKEDFILE,   adddestreakedfileMode);
     73        MODECASE(MAGICDSTOOL_MODE_ADVANCERUN,          advancerunMode);
    7174        MODECASE(MAGICDSTOOL_MODE_REVERTDESTREAKEDFILE,revertdestreakedfileMode);
     75        MODECASE(MAGICDSTOOL_MODE_CLEARSTATEFAULTS,    clearstatefaultsMode);
    7276        MODECASE(MAGICDSTOOL_MODE_GETSKYCELLS,         getskycellsMode);
    7377        MODECASE(MAGICDSTOOL_MODE_TOREMOVE,            toremoveMode);
    74         MODECASE(MAGICDSTOOL_MODE_TORESTORE,           torestoreMode);
    7578        MODECASE(MAGICDSTOOL_MODE_TOREVERT,            torevertMode);
     79        MODECASE(MAGICDSTOOL_MODE_COMPLETEDREVERT,     completedrevertMode);
     80        MODECASE(MAGICDSTOOL_MODE_TOCLEANUP,           tocleanupMode);
    7681        default:
    7782            psAbort("invalid option (this should not happen)");
    … …  
    97102static bool definebyqueryMode(pxConfig *config)
    98103{
    99     PS_ASSERT_PTR_NON_NULL(config, false);
    100     psError(PS_ERR_UNKNOWN, true, "definebyquery not implelmented yet");
    101 
    102     return false;
    103 #ifdef notyet
    104104
    105105    // Required
     106    PXOPT_LOOKUP_STR(stage, config->args, "-stage", true, false);
     107
     108    // Optional
    106109    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", false, false);
    107 
    108     // Optional
    109     PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
    110     PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false);
    111     PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
     110    PXOPT_LOOKUP_STR(recoveryroot, config->args, "-recoveryroot", false, false);
     111    PXOPT_LOOKUP_BOOL(noreplace, config->args, "-noreplace", false);
     112    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);
     115    PXOPT_LOOKUP_BOOL(rerun, config->args, "-rerun", false);
     116    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
    112117    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    113 
    114     // Create temporary table of the best diffs
    115     {
    116         psString query = pxDataGet("magictool_definebyquery_temp_create.sql");
    117         if (!query) {
    118             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    119             return false;
    120         }
    121 
    122         if (!p_psDBRunQuery(config->dbh, query)) {
     118    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     119
     120    // search args
     121    psMetadata *where = psMetadataAlloc();
     122    PXOPT_COPY_S64(config->args, where, "-exp_id",  "exp_id", "==");
     123    PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "==");
     124    PXOPT_COPY_S64(config->args, where, "-cam_id",  "cam_id", "==");
     125    PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
     126    PXOPT_COPY_S64(config->args, where, "-diff_id", "diff_id", "==");
     127    PXOPT_COPY_S64(config->args, where, "-magic_id","magicRun.magic_id", "==");
     128    PXOPT_COPY_S32(config->args, where, "-streaks_max","streaks", "<=");
     129
     130    pxAddLabelSearchArgs (config, where, "-label", "magicRun.label", "=="); // define using magicRun label
     131
     132    ippStage stageNum = ippStringToStage(stage);
     133
     134    psString query = NULL;
     135    switch (stageNum) {
     136    case IPP_STAGE_RAW:
     137        query = pxDataGet("magicdstool_definebyquery_raw.sql");
     138        break;
     139    case IPP_STAGE_CHIP:
     140        query = pxDataGet("magicdstool_definebyquery_chip.sql");
     141        break;
     142    case IPP_STAGE_CAMERA:
     143        query = pxDataGet("magicdstool_definebyquery_camera.sql");
     144        break;
     145    case IPP_STAGE_WARP:
     146        query = pxDataGet("magicdstool_definebyquery_warp.sql");
     147        break;
     148    case IPP_STAGE_DIFF:
     149        query = pxDataGet("magicdstool_definebyquery_diff.sql");
     150        break;
     151    case IPP_STAGE_FAKE:
     152    case IPP_STAGE_STACK:
     153        psError(PXTOOLS_ERR_CONFIG, true, "%sRuns do not need to be destreaked", stage);
     154        return false;
     155    case IPP_STAGE_NONE:
     156        psError(PXTOOLS_ERR_CONFIG, true, "%s is not a valid stage", stage);
     157        return false;
     158    default:
     159        psError(PXTOOLS_ERR_PROG, true, "ippStageToString returned %d for invalid stage %s",
     160            stageNum, stage);
     161        return false;
     162    }
     163
     164    if (!query) {
     165        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     166        return false;
     167    }
     168    char *rerun_flag =  rerun ? "\n1 " : "\n0" ;
     169
     170    if (stageNum != IPP_STAGE_DIFF) {
     171        if (psListLength(where->list)) {
     172            psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     173            psStringAppend(&query, "\nAND %s", whereClause);
     174            psFree(whereClause);
     175        }
     176        psFree(where);
     177
     178        // treat limit == 0 as "no limit"
     179        if (limit) {
     180            psString limitString = psDBGenerateLimitSQL(limit);
     181            psStringAppend(&query, " %s", limitString);
     182            psFree(limitString);
     183        }
     184        if (!p_psDBRunQueryF(config->dbh, query, rerun_flag)) {
    123185            psError(PS_ERR_UNKNOWN, false, "database error");
    124             return false;
    125         }
    126         psFree(query);
    127     }
    128 
    129     // Insert list of best diffs into temporary table
    130     {
    131         psString query = pxDataGet("magictool_definebyquery_temp_insert.sql");
    132         if (!query) {
    133             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    134             return false;
    135         }
    136 
    137         psMetadata *where = psMetadataAlloc();
    138         PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    139         PXOPT_COPY_STR(config->args, where, "-diff_label", "diffRun.label", "==");
    140         PXOPT_COPY_F32(config->args, where, "-good_frac", "warpSkyfile.good_frac", ">=");
    141 
    142         psString whereClause = NULL;    // WHERE conditions
    143         if (psListLength(where->list)) {
    144             whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    145             psStringPrepend(&whereClause, "\n AND ");
    146         }
    147         psFree(where);
    148 
    149         if (!p_psDBRunQueryF(config->dbh, query, whereClause)) {
    150             psError(PS_ERR_UNKNOWN, false, "database error");
    151             psFree(whereClause);
    152186            psFree(query);
    153187            return false;
    154188        }
    155         psFree(whereClause);
    156         psFree(query);
    157     }
    158 
    159     // Get list of exposures ready to magic
    160     {
    161         psString query = pxDataGet("magictool_definebyquery_select.sql");
    162         if (!query) {
    163             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    164             return false;
    165         }
    166 
    167         psString magicSkyCellNumsWhere = NULL;    // WHERE conditions for magicSkyCellNums
    168         {
    169             psMetadata *where = psMetadataAlloc();
    170             PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    171             PXOPT_COPY_STR(config->args, where, "-diff_label", "diffRun.label", "==");
    172             PXOPT_COPY_F32(config->args, where, "-good_frac", "warpSkyfile.good_frac", ">=");
    173 
    174             if (psListLength(where->list)) {
    175                 magicSkyCellNumsWhere = psDBGenerateWhereConditionSQL(where, NULL);
    176                 psStringPrepend(&magicSkyCellNumsWhere, "\n AND ");
    177             }
    178             psFree(where);
    179         }
    180 
    181         // "available" means only concern ourselves with exposures that have all diffs completed, unless we're
    182         // told to only take what's available.
    183         // "new" means we want a new run even if there's already a magic run defined
    184         PXOPT_LOOKUP_BOOL(available, config->args, "-available", false);
    185         PXOPT_LOOKUP_BOOL(new, config->args, "-new", false);
    186 
    187         psString queryWhere = NULL;     // WHERE conditions for entire query
    188         if (available) {
    189             psStringAppend(&queryWhere, " WHERE num_done = num_todo");
    190         }
    191         if (new) {
    192             const char *newWhere = " magic_id IS NULL"; // String to add
    193             if (queryWhere) {
    194                 psStringAppend(&queryWhere, " AND %s", newWhere);
    195             } else {
    196                 psStringAppend(&queryWhere, " WHERE %s", newWhere);
    197             }
    198         }
    199         if (queryWhere) {
    200             psStringAppend(&query, " %s", queryWhere);
    201             psFree(queryWhere);
    202         }
    203 
    204 
    205         if (!p_psDBRunQueryF(config->dbh, query, magicSkyCellNumsWhere ? magicSkyCellNumsWhere : "")) {
     189    } else {
     190        // diff stage query has two types bothways and !bothways
     191        // so we need to send the rerun flag and the where data twice
     192        psString whereString = psStringCopy("");
     193        if (psListLength(where->list)) {
     194            psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     195            psStringAppend(&whereString, "\nAND %s", whereClause);
     196            psFree(whereClause);
     197        }
     198        psFree(where);
     199
     200        // treat limit == 0 as "no limit"
     201        if (limit) {
     202            psString limitString = psDBGenerateLimitSQL(limit);
     203            psStringAppend(&query, " %s", limitString);
     204            psFree(limitString);
     205        }
     206
     207        if (!p_psDBRunQueryF(config->dbh, query, rerun_flag, whereString, rerun_flag, whereString)) {
    206208            psError(PS_ERR_UNKNOWN, false, "database error");
    207             psFree(magicSkyCellNumsWhere);
     209            psFree(whereString);
    208210            psFree(query);
    209211            return false;
    210212        }
    211         psFree(magicSkyCellNumsWhere);
    212         psFree(query);
    213     }
     213        psFree(whereString);
     214    }
     215    psFree(query);
    214216
    215217    psArray *output = p_psDBFetchResult(config->dbh);
    … …  
    233235    }
    234236
    235     // Parse the list of exposures ready to magic
    236 
    237     if (!psDBTransaction(config->dbh)) {
    238         psError(PS_ERR_UNKNOWN, false, "database error");
    239         return false;
    240     }
    241 
    242     psString insert = pxDataGet("magictool_definebyquery_insert.sql"); // Insert query
     237    // Parse the list of runs ready to be destreaked
     238
     239    if (!pretend && !psDBTransaction(config->dbh)) {
     240        psError(PS_ERR_UNKNOWN, false, "database error");
     241        return false;
     242    }
    243243
    244244    psArray *list = psArrayAllocEmpty(16); // List of runs, to print
    245245    for (long i = 0; i < psArrayLength(output); i++) {
    246246        psMetadata *row = output->data[i]; // Row of interest
    247         psS64 exp_id = psMetadataLookupS64(NULL, row, "exp_id"); // Exposure identifier
     247        psS64 stage_id = psMetadataLookupS64(NULL, row, "stage_id");
     248        psS64 exp_id = psMetadataLookupS64(NULL, row, "exp_id");
     249        psS64 magic_id = psMetadataLookupS64(NULL, row, "magic_id");
     250        psS64 inv_magic_id = psMetadataLookupS64(NULL, row, "inv_magic_id");
     251        psS64 cam_id = psMetadataLookupS64(NULL, row, "cam_id");
     252        psString magicRunLabel = psMetadataLookupStr(NULL, row, "label");
     253        psString magicRunDataGroup = psMetadataLookupStr(NULL, row, "data_group");
     254        psString magicRunWorkdir = psMetadataLookupStr(NULL, row, "workdir");
     255
     256        // if workdir is not supplied use the magicRun's
     257        if (!workdir) {
     258            workdir = magicRunWorkdir;
     259        }
     260
     261        psString outroot = NULL;
     262        // set outroot to workdir/exp_id/stage for example /somewhere/424242/chip
     263        psStringAppend(&outroot, "%s/%" PRId64 "/%s", workdir, exp_id, stage);
    248264
    249265        // create a new magicRun for this group
    250         magicRunRow *run = magicRunRowAlloc(0, exp_id, "new", workdir, "dirty", label, dvodb, registered, 0);
     266        magicDSRunRow *run = magicDSRunRowAlloc(
     267                0, // magic_ds_id
     268                magic_id,
     269                inv_magic_id,
     270                "new",
     271                stage,
     272                stage_id,
     273                cam_id,
     274                set_label ? set_label : magicRunLabel,
     275                set_data_group ? set_data_group : magicRunDataGroup,
     276                outroot,
     277                recoveryroot,
     278                noreplace ? 0 :1,   // re_place
     279                0,      // remove
     280                0,      // fault
     281                note);  // remove
     282
     283        psFree(outroot);
    251284        if (!run) {
    252             psAbort("failed to alloc magicRun object");
    253         }
    254 
    255         if (!magicRunInsertObject(config->dbh, run)) {
    256             psError(PS_ERR_UNKNOWN, false, "database error");
    257             psFree(run);
    258             psFree(insert);
    259             psFree(output);
    260             psFree(list);
    261             if (!psDBRollback(config->dbh)) {
     285            psAbort("failed to alloc magicDSRun object");
     286        }
     287
     288        if (!pretend) {
     289            if (!magicDSRunInsertObject(config->dbh, run)) {
    262290                psError(PS_ERR_UNKNOWN, false, "database error");
     291                psFree(run);
     292                psFree(output);
     293                psFree(list);
     294                if (!psDBRollback(config->dbh)) {
     295                    psError(PS_ERR_UNKNOWN, false, "database error");
     296                }
     297                return false;
    263298            }
    264             return false;
    265         }
    266 
    267         psS64 magic_id = psDBLastInsertID(config->dbh); // Assigned identifier
    268         run->magic_id = magic_id;
     299            psS64 magic_ds_id = psDBLastInsertID(config->dbh); // Assigned identifier
     300            run->magic_ds_id = magic_ds_id;
     301        }
    269302
    270303        psArrayAdd(list, list->n, run);
    271304        psFree(run);
    272 
    273         // Create a suitable insertion query for this run
    274         psString thisInsert = psStringCopy(insert);
    275         {
    276             psString idString = NULL;
    277             psStringAppend(&idString, "%" PRId64, magic_id);
    278             psStringSubstitute(&thisInsert, idString, "@MAGIC_ID@");
    279             psFree(idString);
    280         }
    281         {
    282             psString idString = NULL;
    283             psStringAppend(&idString, "%" PRId64, exp_id);
    284             psStringSubstitute(&thisInsert, idString, "@EXP_ID@");
    285             psFree(idString);
    286         }
    287 
    288         if (!p_psDBRunQueryF(config->dbh, thisInsert, magic_id, exp_id)) {
    289             psError(PS_ERR_UNKNOWN, false, "database error");
    290             psFree(thisInsert);
    291             psFree(insert);
    292             psFree(output);
    293             psFree(list);
    294             if (!psDBRollback(config->dbh)) {
    295                 psError(PS_ERR_UNKNOWN, false, "database error");
    296             }
    297             return false;
    298         }
    299         psFree(thisInsert);
    300     }
    301 
    302     if (!psDBCommit(config->dbh)) {
     305    }
     306
     307    if (!pretend && !psDBCommit(config->dbh)) {
    303308        psError(PS_ERR_UNKNOWN, false, "database error");
    304309        return false;
    … …  
    306311    psFree(output);
    307312
    308     if (!magicRunPrintObjects(stdout, list, !simple)) {
     313    if (!magicDSRunPrintObjects(stdout, list, !simple)) {
    309314        psError(PS_ERR_UNKNOWN, false, "failed to print object");
    310315        psFree(list);
    … …  
    315320
    316321    return true;
    317 #endif // notyet
    318 }
    319 
    320 static psS64 definerunMode(pxConfig *config)
     322}
     323
     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)
    321546{
    322547    PS_ASSERT_PTR_NON_NULL(config, false);
    323548
    324549    // required
    325     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
    326602    PXOPT_LOOKUP_STR(stage, config->args, "-stage", true, false);
    327     PXOPT_LOOKUP_STR(outroot, config->args, "-outroot", true, false);
    328 
    329     // optional
    330     PXOPT_LOOKUP_STR(recoveryroot, config->args, "-recoveryroot", false, false);
    331     PXOPT_LOOKUP_BOOL(re_place, config->args, "-replace", false);
    332     PXOPT_LOOKUP_BOOL(remove, config->args, "-remove", false);
    333     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    334     PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
    335 
    336     psS64 stage_id = 0, cam_id = 0;
    337 
    338     if (!magicDSGetIDs(config, stage, magic_id, &stage_id, &cam_id)) {
    339         psError(PS_ERR_UNKNOWN, false, "failed to get ids");
    340         return false;
    341     }
    342 
    343     magicDSRunRow *run = magicDSRunRowAlloc(
    344             0,          // ID
    345             magic_id,
    346             "new",      // state
    347             stage,
    348             stage_id,
    349             cam_id,
    350             label,
    351             outroot,
    352             recoveryroot,
    353             re_place,
    354             remove
    355     );
    356 
    357     if (!run) {
    358         psError(PS_ERR_UNKNOWN, false, "failed to alloc magicRun object");
    359         return false;
    360     }
    361     if (!magicDSRunInsertObject(config->dbh, run)) {
    362         psError(PS_ERR_UNKNOWN, false, "database error");
    363         psFree(run);
    364         return false;
    365     }
    366 
    367     psS64 magic_ds_id = psDBLastInsertID(config->dbh);
    368     run->magic_ds_id = magic_ds_id;
    369 
    370     if (!magicDSRunPrintObject(stdout, run, !simple)) {
    371             psError(PS_ERR_UNKNOWN, false, "failed to print object");
    372             psFree(run);
    373             return false;
    374     }
    375 
    376     psFree(run);
    377 
    378     return magic_id;
    379 }
    380 
    381 
    382 static bool updaterunMode(pxConfig *config)
    383 {
    384     PS_ASSERT_PTR_NON_NULL(config, false);
    385 
    386     // required
    387     PXOPT_LOOKUP_S64(magic_ds_id, config->args, "-magic_ds_id", true, false);
    388     PXOPT_LOOKUP_STR(state, config->args, "-state", true, false);
    389 
    390     if (state) {
    391         // set detRun.state to state
    392         return setmagicDSRunState(config, magic_ds_id, state);
    393     }
    394 
    395     return true;
    396 }
    397 
    398 
    399 static bool todestreakMode(pxConfig *config)
    400 {
    401     PS_ASSERT_PTR_NON_NULL(config, false);
    402603
    403604    psMetadata *where = psMetadataAlloc();
    404     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", "==");
    405606    PXOPT_COPY_S64(config->args, where, "-magic_id", "magic_id", "==");
    406     pxAddLabelSearchArgs (config, where, "-label", "label", "==");
     607    pxAddLabelSearchArgs (config, where, "-label", "magicDSRun.label", "==");
    407608
    408609    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    409610    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    410611
    411     // look for "inputs" that need to processed
    412     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);
    413616    if (!query) {
    414         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    415         return false;
    416     }
     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);
    417622
    418623    if (psListLength(where->list)) {
    419624        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    420         psStringAppend(&query, " WHERE %s", whereClause);
     625        psStringAppend(&query, " AND %s", whereClause);
    421626        psFree(whereClause);
    422627    }
    … …  
    476681{
    477682    // first query the magicDSRun to find the stage and the stage_id
    478     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;
    479684
    480685    if (!p_psDBRunQueryF(config->dbh, query, magic_ds_id)) {
    … …  
    501706    psMetadata *row = output->data[0];
    502707
    503     psString stage = psMetadataLookupStr(NULL, row, "stage");
     708    psString stage= psMetadataLookupStr(NULL, row, "stage");
    504709    psS64 stage_id = psMetadataLookupS64(NULL, row, "stage_id");
    505 
    506     if (!strcmp(stage, "camera")) {
    507         // no there is no magicked column in camProcessedExp
     710    psS64 magic_id = psMetadataLookupS64(NULL, row, "magic_id");
     711
     712    ippStage stageNum = ippStringToStage(stage);
     713
     714    // chose the appropriate query based on the stage
     715    switch (stageNum) {
     716    case IPP_STAGE_RAW:
     717        query = "UPDATE rawImfile SET magicked = %" PRId64 " where exp_id = %" PRId64 " AND class_id = '%s'";
     718        break;
     719    case IPP_STAGE_CHIP:
     720        query = "UPDATE chipProcessedImfile SET magicked = %" PRId64 " where chip_id = %" PRId64 " AND class_id = '%s'";
     721        break;
     722    case IPP_STAGE_CAMERA:
     723        // no there is no magicked column in camProcessedExp so we have nothing to do
    508724        psFree(output);
    509725        return true;
    510     }
    511 
    512     // chose the appropriate query based on the stage
    513     if (!strcmp(stage, "raw")) {
    514         query = "UPDATE rawImfile SET magicked = %" PRId64 " where exp_id = %" PRId64 " AND class_id = '%s'";
    515     } else if (!strcmp(stage, "chip")) {
    516         query = "UPDATE chipProcessedImfile SET magicked = %" PRId64 " where chip_id = %" PRId64 " AND class_id = '%s'";
    517     } else if (!strcmp(stage, "warp")) {
     726    case IPP_STAGE_WARP:
    518727        query = "UPDATE warpSkyfile SET magicked = %" PRId64 " where warp_id = %" PRId64 " AND skycell_id = '%s'";
    519     } else if (!strcmp(stage, "diff")) {
     728        break;
     729    case IPP_STAGE_DIFF:
    520730        query = "UPDATE diffSkyfile SET magicked = %" PRId64 " where diff_id = %" PRId64 " AND skycell_id = '%s'";
    521     } else {
     731        break;
     732    default:
    522733        psError(PS_ERR_UNKNOWN, true, "unexpected value for stage: %s found", stage);
    523734        psFree(output);
    524735        return false;
    525736    }
    526     if (!p_psDBRunQueryF(config->dbh, query, magic_ds_id, stage_id, component)) {
     737
     738    if (!p_psDBRunQueryF(config->dbh, query, magic_id, stage_id, component)) {
    527739        psError(PS_ERR_UNKNOWN, false, "database error");
    528740        return false;
    … …  
    543755{
    544756    // first query the magicDSRun to find the stage and the stage_id
    545     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;
    546758
    547759    if (!p_psDBRunQueryF(config->dbh, query, magic_ds_id)) {
    … …  
    570782    psString stage = psMetadataLookupStr(NULL, row, "stage");
    571783    psS64 stage_id = psMetadataLookupS64(NULL, row, "stage_id");
    572 
     784    psS64 magic_id = psMetadataLookupS64(NULL, row, "magic_id");
     785
     786    ippStage stageNum = ippStringToStage(stage);
    573787
    574788    // chose the appropriate query based on the stage
    575     if (!strcmp(stage, "raw")) {
     789    switch (stageNum) {
     790    case IPP_STAGE_RAW:
    576791        query = "UPDATE rawExp SET magicked = %" PRId64 " where exp_id = %" PRId64;
    577     } else if (!strcmp(stage, "chip")) {
     792        break;
     793    case IPP_STAGE_CHIP:
    578794        query = "UPDATE chipRun SET magicked = %" PRId64 " where chip_id = %" PRId64;
    579     } else if (!strcmp(stage, "camera")) {
     795        break;
     796    case IPP_STAGE_CAMERA:
    580797        query = "UPDATE camRun SET magicked = %" PRId64 " where cam_id = %" PRId64;
    581     } else if (!strcmp(stage, "warp")) {
     798        break;
     799    case IPP_STAGE_WARP:
    582800        query = "UPDATE warpRun SET magicked = %" PRId64 " where warp_id = %" PRId64;
    583     } else if (!strcmp(stage, "diff")) {
     801        break;
     802    case IPP_STAGE_DIFF:
    584803        query = "UPDATE diffRun SET magicked = %" PRId64 " where diff_id = %" PRId64;
    585     } else {
     804        break;
     805    default:
    586806        psError(PS_ERR_UNKNOWN, true, "unexpected value for stage: %s found", stage);
    587807        psFree(output);
    588808        return false;
    589809    }
    590     if (!p_psDBRunQueryF(config->dbh, query, magic_ds_id, stage_id)) {
     810    if (!p_psDBRunQueryF(config->dbh, query, magic_id, stage_id)) {
    591811        psError(PS_ERR_UNKNOWN, false, "database error");
    592812        return false;
    … …  
    616836    PXOPT_LOOKUP_STR(recovery_path_base, config->args, "-recovery_path_base", false, false);
    617837    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);
    618841
    619842    if (setmagicked && (fault != 0)) {
    … …  
    638861    }
    639862
    640     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        )) {
    641874            // rollback
    642875        if (!psDBRollback(config->dbh)) {
    … …  
    647880    }
    648881
    649     if (!magicDSRunComplete(config, setmagicked)) {
    650             // rollback
    651         if (!psDBRollback(config->dbh)) {
    652             psError(PS_ERR_UNKNOWN, false, "database error");
    653         }
    654         psError(PS_ERR_UNKNOWN, false, "database error");
    655         return false;
    656     }
    657 
    658882    if (!psDBCommit(config->dbh)) {
    659883        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    664888}
    665889
    666 static bool magicDSGetIDs(pxConfig *config, psString stage, psS64 magic_id, psS64 *stage_id, psS64 *cam_id)
     890
     891static bool advancerunMode(pxConfig *config)
    667892{
    668893    PS_ASSERT_PTR_NON_NULL(config, false);
    669     PS_ASSERT_PTR_NON_NULL(stage, false);
    670     PS_ASSERT_PTR_NON_NULL(stage_id, false);
    671     PS_ASSERT_PTR_NON_NULL(cam_id, false);
    672 
    673     if (!strcmp(stage, "diff")) {
    674         // don't need these ids for diff stage because diff_id is in the magicRun
    675         *stage_id = 0;
    676         *cam_id = 0;
    677         return true;
    678     }
    679 
    680     int stageNum;
    681     if (!strcmp(stage, "raw")) {
    682         stageNum = 0;
    683     } else if (!strcmp(stage, "chip")) {
    684         stageNum = 1;
    685     } else if (!strcmp(stage, "camera")) {
    686         stageNum = 2;
    687     } else if (!strcmp(stage, "warp")) {
    688         stageNum = 3;
    689     } else {
    690         psError(PXTOOLS_ERR_DATA, true, "%s is not a valid value for stage", stage);
    691         return false;
    692     }
    693 
    694 
    695     psString query = pxDataGet("magicdstool_getrunids.sql");
    696     if (!query) {
    697         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    698         return false;
    699     }
    700 
    701     if (!p_psDBRunQueryF(config->dbh, query, magic_id)) {
    702         psError(PS_ERR_UNKNOWN, false, "database error");
    703         psFree(query);
    704         return false;
    705     }
    706     psFree(query);
    707 
    708     psArray *output = p_psDBFetchResult(config->dbh);
    709     if (!output) {
    710         psError(PS_ERR_UNKNOWN, false, "database error");
    711         return false;
    712     }
    713     if (!psArrayLength(output)) {
    714         psTrace("magicdstool", PS_LOG_INFO, "no rows found");
    715         psFree(output);
    716         return true;
    717     }
    718     if (psArrayLength(output) > 1) {
    719         psError(PS_ERR_UNKNOWN, true, "unexpected number of rows found %ld for magic_id %" PRId64,
    720             psArrayLength(output), magic_id);
    721         return false;
    722     }
    723     psMetadata *row = output->data[0];
    724 
    725     *cam_id = psMetadataLookupS64(NULL, row, "cam_id");
    726     if (stageNum == 0) {
    727         *stage_id = psMetadataLookupS64(NULL, row, "exp_id");
    728     } else if (stageNum == 1) {
    729         *stage_id = psMetadataLookupS64(NULL, row, "chip_id");
    730     } else if (stageNum == 2) {
    731         *stage_id = *cam_id;
    732     } else if (stageNum == 3) {
    733         *stage_id = psMetadataLookupS64(NULL, row, "warp_id");
    734     }
    735 
    736     return true;
    737 }
    738 
    739 static bool magicDSRunComplete(pxConfig *config, bool setmagicked)
    740 {
    741     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);
    742900
    743901    // look for completed magicDSRuns
    744902    psString query = pxDataGet("magicdstool_completed_runs.sql");
    745903    if (!query) {
    746         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    747         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);
    748912    }
    749913
    … …  
    765929        return true;
    766930    }
     931    if (!psDBTransaction(config->dbh)) {
     932        psError(PS_ERR_UNKNOWN, false, "database error");
     933        return false;
     934    }
    767935    for (long i = 0; i < psArrayLength(output); i++) {
    768936        psMetadata *row = output->data[i];
    … …  
    770938        psS64 magic_ds_id = psMetadataLookupS64(NULL, row, "magic_ds_id");
    771939
    772         // if requested, set stageRun.magicked
     940        // if re_place, set stageRun.magicked
     941        bool setmagicked = psMetadataLookupBool(NULL, row, "re_place");
    773942        if (setmagicked && !setRunMagicked(config, magic_ds_id)) {
    774943            psError(PS_ERR_UNKNOWN, false, "failed to change stageRun.magicked for magic_ds_id: %" PRId64,
    775944                magic_ds_id);
     945            if (!psDBRollback(config->dbh)) {
     946                psError(PS_ERR_UNKNOWN, false, "database error");
     947            }
    776948            return false;
    777949        }
    778950
    779951        // set magicDSRun.state to 'full'
    780         if (!setmagicDSRunState(config, magic_ds_id, "full")) {
     952        if (!setmagicDSRunState(config, magic_ds_id, NULL, NULL, "full")) {
    781953            psError(PS_ERR_UNKNOWN, false, "failed to change magicDSRun.state for magic_ds_id: %" PRId64,
    782954                magic_ds_id);
    783955            psFree(output);
     956            if (!psDBRollback(config->dbh)) {
     957                psError(PS_ERR_UNKNOWN, false, "database error");
     958            }
    784959            return false;
    785960        }
    786961    }
    787 
     962    if (!psDBCommit(config->dbh)) {
     963        psError(PS_ERR_UNKNOWN, false, "database error");
     964        return false;
     965    }
    788966
    789967    return true;
    … …  
    794972{
    795973    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    }
    796980
    797981    psMetadata *where = psMetadataAlloc();
    … …  
    801985    pxAddLabelSearchArgs (config, where, "-label", "label", "==");
    802986
    803     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");
    804988
    805989    if (psListLength(where->list)) {
    … …  
    807991        psStringAppend(&query, " AND %s", whereClause);
    808992        psFree(whereClause);
     993    } else {
     994        psError(PS_ERR_UNKNOWN, true, "search arguments are required");
     995        return false;
    809996    }
    810997    psFree(where);
    … …  
    812999    if (!p_psDBRunQuery(config->dbh, query)) {
    8131000        psError(PS_ERR_UNKNOWN, false, "failed to revert");
    814         return false;
    815     }
     1001        psFree(query);
     1002        return false;
     1003    }
     1004    psFree(query);
    8161005    return true;
    8171006}
    818 
    819 static bool getskycellsMode(pxConfig *config)
    820 {
    821     // required
    822     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);
    8231010
    8241011    psMetadata *where = psMetadataAlloc();
    825     PXOPT_COPY_STR(config->args, where, "-class_id",    "warpSkyCellMap.class_id", "==");
    826     PXOPT_COPY_STR(config->args, where, "-skycell_id",  "warpSkyCellMap.skycell_id", "==");
    827 
    828     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    829 
    830     psString query = pxDataGet("magicdstool_getskycells.sql");
    831     if (!query) {
    832         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    833         return false;
    834     }
     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");
    8351023
    8361024    if (psListLength(where->list)) {
    8371025        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    838         psStringAppend(&query, " AND %s", whereClause);
     1026        psStringAppend(&query, " WHERE %s", whereClause);
    8391027        psFree(whereClause);
     1028    } else {
     1029        psError(PS_ERR_UNKNOWN, true, "search arguments are required");
     1030        return false;
    8401031    }
    8411032    psFree(where);
    8421033
    843     if (!p_psDBRunQueryF(config->dbh, query, magic_ds_id)) {
    844         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");
    8451046        psFree(query);
    8461047        return false;
    8471048    }
    8481049    psFree(query);
    849 
     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);
    8501086    psArray *output = p_psDBFetchResult(config->dbh);
    8511087    if (!output) {
    … …  
    8671103        return true;
    8681104    }
    869 
    870     if (psArrayLength(output)) {
    871         // negative simple so the default is true
    872         if (!ippdbPrintMetadatas(stdout, output, "magicDiffSkyfile", !simple)) {
    873             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);
    8741116            psFree(output);
    8751117            return false;
    8761118        }
    877     }
    878 
     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    }
    8791125    psFree(output);
    8801126
    … …  
    8821128}
    8831129
    884 static bool setmagicDSRunState(pxConfig *config, psS64 magic_ds_id, const char *state)
    885 {
    886     PS_ASSERT_PTR_NON_NULL(state, false);
    887 
    888     // check that state is a valid string value
    889     if (!(
    890             (strncmp(state, "new", 4) == 0)
    891             || (strncmp(state, "full", 5) == 0)
    892         )
    893     ) {
    894         psError(PS_ERR_UNKNOWN, false,
    895                 "invalid magicDSRun state: %s", state);
    896         return false;
    897     }
    898 
    899     char *query = "UPDATE magicDSRun SET state = '%s' WHERE magic_ds_id = %" PRId64;
    900     if (!p_psDBRunQueryF(config->dbh, query, state, magic_ds_id)) {
    901         psError(PS_ERR_UNKNOWN, false,
    902                 "failed to change state for magic_id %" PRId64, magic_ds_id);
    903         return false;
    904     }
    905 
    906     return true;
    907 }
    908 
    909 static bool toremoveMode(pxConfig *config)
    910 {
    911     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);
    9121134
    9131135    psMetadata *where = psMetadataAlloc();
    914     PXOPT_COPY_S64(config->args, where, "-magic_ds_id", "magic_ds_id", "==");
    915     PXOPT_COPY_S64(config->args, where, "-magic_id", "magic_id", "==");
    916     pxAddLabelSearchArgs (config, where, "-label", "label", "==");
    917 
    918     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
    9191140    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    9201141
    921     // look for "inputs" that need to processed
    922     psString query = pxDataGet("magicdstool_toremove.sql");
     1142    psString query = pxDataGet("magicdstool_getskycells.sql");
    9231143    if (!query) {
    924         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    925         return false;
    926     }
    927 
     1144        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1145        return false;
     1146    }
     1147
     1148    psString whereClause = NULL;
    9281149    if (psListLength(where->list)) {
    929         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    930         psStringAppend(&query, " WHERE %s", whereClause);
    931         psFree(whereClause);
     1150        whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1151        psStringPrepend(&whereClause, "\n AND ");
    9321152    }
    9331153    psFree(where);
    9341154
    935     // treat limit == 0 as "no limit"
    936     if (limit) {
    937         psString limitString = psDBGenerateLimitSQL(limit);
    938         psStringAppend(&query, " %s", limitString);
    939         psFree(limitString);
    940     }
    941 
    942     if (!p_psDBRunQuery(config->dbh, query)) {
     1155    if (!p_psDBRunQueryF(config->dbh, query, whereClause, whereClause)) {
    9431156        psError(PS_ERR_UNKNOWN, false, "database error");
    9441157        psFree(query);
    … …  
    9691182    if (psArrayLength(output)) {
    9701183        // negative simple so the default is true
    971         if (!ippdbPrintMetadatas(stdout, output, "toremove", !simple)) {
     1184        if (!ippdbPrintMetadatas(stdout, output, "magicDiffSkyfile", !simple)) {
    9721185            psError(PS_ERR_UNKNOWN, false, "failed to print array");
    9731186            psFree(output);
    … …  
    9801193    return true;
    9811194}
    982 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)
    9831257{
    9841258    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    9931267
    9941268    // look for "inputs" that need to processed
    995     psString query = pxDataGet("magicdstool_torestore.sql");
     1269    psString query = pxDataGet("magicdstool_toremove.sql");
    9961270    if (!query) {
    997         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1271        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    9981272        return false;
    9991273    }
    … …  
    10421316    if (psArrayLength(output)) {
    10431317        // negative simple so the default is true
    1044         if (!ippdbPrintMetadatas(stdout, output, "torestore", !simple)) {
     1318        if (!ippdbPrintMetadatas(stdout, output, "toremove", !simple)) {
    10451319            psError(PS_ERR_UNKNOWN, false, "failed to print array");
    10461320            psFree(output);
    … …  
    10541328}
    10551329
    1056 
    10571330static bool torevertMode(pxConfig *config)
    10581331{
    … …  
    10741347    psString query = pxDataGet(sql_file);
    10751348    if (!query) {
    1076         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);
    10771350        psFree(sql_file);
    10781351        return false;
    … …  
    11361409
    11371410
     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/simmosaic_branches/ippTools/src/magicdstool.h

    r24683 r27839  
    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/simmosaic_branches/ippTools/src/magicdstoolConfig.c

    r24693 r27839  
    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;
    … …  
    4949    // -definebyquery
    5050    psMetadata *definebyqueryArgs = psMetadataAlloc();
    51 #ifdef notyet
    52     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-workdir",     0, "define workdir (required)", NULL);
    53     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label",       0, "define label", NULL);
    54     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-dvodb",       0, "define dvodb", NULL);
    55     psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-registered", 0, "time detrend run was registered", now);
    56     psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-exp_id", 0, "search exp_id", 0);
    57     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-diff_label", 0, "select diff label", NULL);
    58     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-good_frac", 0, "limit good_frac", NAN);
    59     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-available", 0, "process what's immediately available?", false);
    60     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-new", 0, "generate new run even if existing?", false);
    61     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    62 #endif
    63 
    64     // -definerun
    65     psMetadata *definerunArgs = psMetadataAlloc();
    66     psMetadataAddS64(definerunArgs, PS_LIST_TAIL, "-magic_id", 0, "define magic_id (required)", 0);
    67     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-stage", 0, "define output directory (required)", NULL);
    68     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-outroot", 0, "define output directory (required)", NULL);
    69     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-recoveryroot", 0, "define recovery directory", NULL);
    70     psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-replace", 0, "use the simple output format", false);
    71     psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-remove", 0, "use the simple output format", false);
    72     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-label", 0, "define label", NULL);
    73     psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     51    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-stage",       0, "define stage (required)", NULL);
     52    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-workdir",     0, "define workdir", NULL);
     53    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-recoveryroot", 0, "define recovery directory", NULL);
     54    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-noreplace", 0, "do not replace input files with the destreaked versions", false);
     55    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);
     58
     59    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by magicRun.label", NULL);
     60    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-exp_id",   0, "search by exp_id", 0);
     61    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-chip_id",  0, "search by chip_id", 0);
     62    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-cam_id",  0, "search by cam_id", 0);
     63    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-warp_id",  0, "search by warp_id", 0);
     64    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-diff_id",  0, "search by diff_id", 0);
     65    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-magic_id", 0, "search by magic_id", 0);
     66    psMetadataAddS32(definebyqueryArgs, PS_LIST_TAIL, "-streaks_max", 0, "maximum number of streaks", 0);
     67
     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);
     70    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple",  0, "use the simple output format", false);
     71    psMetadataAddU64(definebyqueryArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
     72
     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);
    7495
    7596    // -updaterun
    7697    psMetadata *updaterunArgs = psMetadataAlloc();
    77     psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-magic_ds_id", 0, "define magictool ID (required)", 0);
    78     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);
    79108
    80109    // -addinputskyfile
    … …  
    86115    // -todestreak
    87116    psMetadata *todestreakArgs = psMetadataAlloc();
     117    psMetadataAddStr(todestreakArgs, PS_LIST_TAIL, "-stage", 0, "limit query to stage (required)", NULL);
    88118    psMetadataAddS64(todestreakArgs, PS_LIST_TAIL, "-magic_ds_id", 0, "search by magic Destreak ID", 0);
    89119    psMetadataAddS64(todestreakArgs, PS_LIST_TAIL, "-magic_id", 0, "search by magic ID", 0);
    … …  
    99129    psMetadataAddStr(adddestreakedfileArgs, PS_LIST_TAIL, "-recovery_path_base", 0, "define recovery pixels URI", NULL);
    100130    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);
    101134    psMetadataAddS16(adddestreakedfileArgs, PS_LIST_TAIL, "-fault", 0, "set fault code", 0);
    102135
    … …  
    106139    psMetadataAddStr(revertdestreakedfileArgs, PS_LIST_TAIL, "-component", 0, "search by component", NULL);
    107140    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);
    108142    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);
    109151
    110152    // -getskycells
    111153    psMetadata *getskycellsArgs = psMetadataAlloc();
    112     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);
    113155    psMetadataAddStr(getskycellsArgs, PS_LIST_TAIL, "-class_id", 0, "define class identifier", NULL);
    114156    psMetadataAddStr(getskycellsArgs, PS_LIST_TAIL, "-skycell_id", 0, "define skycell identifier", NULL);
    … …  
    122164    psMetadataAddU64(toremoveArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
    123165    psMetadataAddBool(toremoveArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    124 
    125     // -torestore
    126     psMetadata *torestoreArgs = psMetadataAlloc();
    127     psMetadataAddS64(torestoreArgs, PS_LIST_TAIL, "-magic_ds_id", 0, "search by magic Destreak ID", 0);
    128     psMetadataAddS64(torestoreArgs, PS_LIST_TAIL, "-magic_id", 0, "search by magic ID", 0);
    129     psMetadataAddStr(torestoreArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "define label", NULL);
    130     psMetadataAddU64(torestoreArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
    131     psMetadataAddBool(torestoreArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    132166
    133167    // -torevert
    … …  
    140174    psMetadataAddBool(torevertArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    141175
     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);
    142196    psFree(now);
    143197
    … …  
    147201    PXOPT_ADD_MODE("-definebyquery",       "create magic de-streak runs from magic runs",
    148202                    MAGICDSTOOL_MODE_DEFINEBYQUERY,     definebyqueryArgs);
    149     PXOPT_ADD_MODE("-definerun",           "create one magic de-streak run for one magic run",
    150                     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);
    151205    PXOPT_ADD_MODE("-updaterun",           "update state of magic de-streak run",
    152206                    MAGICDSTOOL_MODE_UPDATERUN,         updaterunArgs);
    … …  
    155209    PXOPT_ADD_MODE("-adddestreakedfile",   "add a de-streaked file",
    156210                    MAGICDSTOOL_MODE_ADDDESTREAKEDFILE, adddestreakedfileArgs);
     211    PXOPT_ADD_MODE("-advancerun", "change state for runs that have finished destrreaking",
     212                    MAGICDSTOOL_MODE_ADVANCERUN, advancerunArgs);
    157213    PXOPT_ADD_MODE("-revertdestreakedfile", " revert a faulted de-streaked file",
    158214                    MAGICDSTOOL_MODE_REVERTDESTREAKEDFILE, revertdestreakedfileArgs);
     215    PXOPT_ADD_MODE("-clearstatefaults", " clear magicDSRuns in fault state",
     216                    MAGICDSTOOL_MODE_CLEARSTATEFAULTS, clearstatefaultsArgs);
    159217    PXOPT_ADD_MODE("-getskycells", "get skycell files ",
    160218                    MAGICDSTOOL_MODE_GETSKYCELLS, getskycellsArgs);
    161219    PXOPT_ADD_MODE("-toremove", "backup images pending removal",
    162220                    MAGICDSTOOL_MODE_TOREMOVE, toremoveArgs);
    163     PXOPT_ADD_MODE("-torestore", "images pending restore of exicsed streak pixels",
    164                     MAGICDSTOOL_MODE_TORESTORE, torestoreArgs);
    165     PXOPT_ADD_MODE("-torevert", "faulted images to revert",
     221    PXOPT_ADD_MODE("-torevert", "images to restore or revert",
    166222                    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
    167229
    168230    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

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

    r24551 r27839  
    4747static bool revertmaskMode(pxConfig *config);
    4848static bool maskMode(pxConfig *config);
     49static bool censorrunMode(pxConfig *config);
    4950
    5051static bool setmagicRunState(pxConfig *config, psS64 magic_id, const char *state);
    … …  
    8586        MODECASE(MAGICTOOL_MODE_REVERTMASK,          revertmaskMode);
    8687        MODECASE(MAGICTOOL_MODE_MASK,                maskMode);
     88        MODECASE(MAGICTOOL_MODE_CENSORRUN,           censorrunMode);
    8789        default:
    8890            psAbort("invalid option (this should not happen)");
    … …  
    112114    // Required
    113115    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", false, false);
     116    PXOPT_LOOKUP_STR(label, config->args, "-label", true, false);
    114117
    115118    // Optional
    116     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);
    117121    PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false);
    118122    PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    … …  
    131135        psString query = pxDataGet("magictool_definebyquery_select.sql");
    132136        if (!query) {
    133             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     137            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    134138            return false;
    135139        }
    … …  
    147151        // what if no skycells for the diff run completed?
    148152
    149         if (!rerun) {
    150             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);
    151157        }
    152158
    … …  
    172178            queryWhereStr = psStringCopy("");
    173179        }
    174 
    175         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)) {
    176185            psError(PS_ERR_UNKNOWN, false, "database error");
    177186            psFree(diffWhereStr);
    178187            psFree(queryWhereStr);
     188            psFree(rerunWhereStr);
    179189            psFree(query);
    180190            return false;
    … …  
    182192        psFree(diffWhereStr);
    183193        psFree(queryWhereStr);
     194        psFree(rerunWhereStr);
    184195        psFree(query);
    185196    }
    … …  
    234245
    235246        // create a new magicRun for this group
    236         magicRunRow *run = magicRunRowAlloc(0, exp_id, diff_id, inverse, "new", workdir, "dirty", label,
    237                                             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);
    238260        if (!run) {
    239261            psAbort("failed to alloc magicRun object");
    … …  
    329351            "dirty",    // workdir_state
    330352            label,
     353            NULL,       // data_group
    331354            dvodb,
    332355            registered,
    333             0
     356            0,          // fault
     357            NULL
    334358    );
    335359
    … …  
    410434    psString query = pxDataGet("magictool_inputskyfile.sql");
    411435    if (!query) {
    412         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     436        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    413437        return false;
    414438    }
    … …  
    483507    psString query = pxDataGet("magictool_totree.sql");
    484508    if (!query) {
    485         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     509        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    486510        return false;
    487511    }
    … …  
    556580
    557581    if (fault > 0) {
    558         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;
    559583        if (!p_psDBRunQueryF(config->dbh, query, fault, magic_id)) {
    560584            psError(PS_ERR_UNKNOWN, false,
    … …  
    580604    PXOPT_COPY_S64(config->args, where, "-magic_id", "magic_id", "==");
    581605    PXOPT_COPY_S16(config->args, where, "-fault", "fault", "==");
     606    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
    582607
    583608    psString query = psStringCopy("UPDATE magicRun SET fault = 0, state = 'new' WHERE fault != 0");
    … …  
    594619        return false;
    595620    }
     621    psS32 numUpdated = psDBAffectedRows(config->dbh);
     622    psLogMsg("magictool", PS_LOG_INFO, "Reverted %d magic runs", numUpdated);
     623
    596624    return true;
    597625}
    … …  
    617645    psString query = pxDataGet("magictool_inputs.sql");
    618646    if (!query) {
    619         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     647        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    620648        return false;
    621649    }
    … …  
    787815    psString query = pxDataGet("magictool_toprocess_inputs.sql");
    788816    if (!query) {
    789         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     817        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    790818        return false;
    791819    }
    … …  
    801829    // treat limit == 0 as "no limit"
    802830    if (limit) {
    803         psString limitString = psDBGenerateLimitSQL(limit);
     831        // cut limit in half
     832        // hack to prevent pending leaf nodes from blocking branch nodes
     833        psString limitString = psDBGenerateLimitSQL((limit + 1) / 2);
    804834        psStringAppend(&query, " %s", limitString);
    805835        psFree(limitString);
    … …  
    847877
    848878    // look for tree nodes that need to be processed
    849     // XXX: This gets all nodes from all magicRuns that are in 'new'state
    850     // That doens't seem particularly efficient
    851     query = pxDataGet("magictool_toprocess_tree.sql");
     879
     880    // first find incomplete magicRuns
     881    query = pxDataGet("magictool_toprocess_runs.sql");
    852882    if (!query) {
    853         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    854         return false;
    855     }
    856 
     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.
     894    {
     895        psString limitString = psDBGenerateLimitSQL( 1000 );
     896        psStringAppend(&query, " %s", limitString);
     897        psFree(limitString);
     898    }
    857899
    858900    if (!p_psDBRunQueryF(config->dbh, query, whereString ? whereString :  "")) {
    … …  
    865907    psFree(query);
    866908
    867     psArray *magicTree = p_psDBFetchResult(config->dbh);
    868     if (!magicTree) {
     909    psArray *magicRuns = p_psDBFetchResult(config->dbh);
     910    if (!magicRuns) {
    869911        psErrorCode err = psErrorCodeLast();
    870912        switch (err) {
    … …  
    879921        return false;
    880922    }
    881     if (!psArrayLength(magicTree)) {
     923    if (!psArrayLength(magicRuns)) {
    882924        psTrace("magictool", PS_LOG_INFO, "no rows found");
    883         psFree(magicTree);
     925        psFree(magicRuns);
    884926        return true;
    885927    }
    886928
    887     // entries are ordered by magic_id
    888     long index = 0;
    889     while (index <  psArrayLength(magicTree)) {
    890         bool status;
     929    query = pxDataGet("magictool_toprocess_tree.sql");
     930    if (!query) {
     931        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     932        return false;
     933    }
     934
     935    for (psS64 index = 0; index < psArrayLength(magicRuns); index++) {
    891936        if (limit && (psArrayLength(output) >= limit)) {
    892937            break;
    893938        }
    894         psS64 current_magic_id = psMetadataLookupS64(&status, magicTree->data[index], "magic_id");
     939        bool status;
     940        psS64 magic_id = psMetadataLookupS64(&status, magicRuns->data[index], "magic_id");
    895941        if (!status) {
    896942            psAbort("failed to lookup value for magic_id column");
    897943        }
    898944
    899         // find the end of this block
    900         long first = index;
    901         long last = index;
    902         for (long i = index + 1; i < psArrayLength(magicTree); i++) {
    903             psS64 magic_id = psMetadataLookupS64(&status, magicTree->data[i], "magic_id");
    904             if (!status) {
    905                 psAbort("failed to lookup value for magic_id column");
     945        whereString = NULL;
     946        psStringAppend(&whereString, "\nAND (magic_id = %" PRId64 ")", magic_id);
     947        if (!p_psDBRunQueryF(config->dbh, query, whereString )) {
     948            psError(PS_ERR_UNKNOWN, false, "database error");
     949            psFree(whereString);
     950            psFree(query);
     951            return false;
     952        }
     953        psFree(whereString);
     954        psArray *magicTree = p_psDBFetchResult(config->dbh);
     955        if (!magicTree) {
     956            psErrorCode err = psErrorCodeLast();
     957            switch (err) {
     958                case PS_ERR_DB_CLIENT:
     959                    psError(PXTOOLS_ERR_SYS, false, "database error");
     960                case PS_ERR_DB_SERVER:
     961                    psError(PXTOOLS_ERR_PROG, false, "database error");
     962                default:
     963                    psError(PXTOOLS_ERR_PROG, false, "unknown error");
    906964            }
    907             if (magic_id != current_magic_id) {
    908                 break;
    909             }
    910             last = i;
    911         }
    912 
    913         index = last + 1;
    914 
    915         psHash *forest = psHashAlloc(last - first + 1);
     965
     966            return false;
     967        }
     968        psS64 length = psArrayLength(magicTree);
     969        if (!length) {
     970            psTrace("magictool", PS_LOG_INFO, "no rows found for magic_id %" PRId64, magic_id);
     971            psFree(magicTree);
     972            continue;
     973        }
     974
     975        psHash *forest = psHashAlloc(length);
    916976
    917977        // convert the array of metadata into a pxTree structure
    918         for (long i = first; i <= last; i++) {
     978        for (long i = 0; i < length; i++) {
    919979            bool status;
    920980            psString node = psMetadataLookupStr(&status, magicTree->data[i], "node");
    … …  
    9411001        pxTreeCrawl(root, findReadyNodes, output);
    9421002        psFree(root);
    943 
    944     }
    945     psFree(magicTree);
     1003        psFree(magicTree);
     1004    }
    9461005
    9471006    if (psArrayLength(output)) {
    … …  
    10011060    PXOPT_COPY_S64(config->args, where, "-magic_id", "magic_id", "==");
    10021061    PXOPT_COPY_STR(config->args, where, "-node", "node", "==");
    1003     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
    10041062    PXOPT_COPY_S16(config->args, where, "-fault", "magicNodeResult.fault", "==");
     1063    pxAddLabelSearchArgs (config, where, "-label", "magicRun.label", "==");
    10051064
    10061065    psString query = pxDataGet("magictool_revertnode.sql");
    10071066    if (!query) {
    1008         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1067        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10091068        return false;
    10101069    }
    … …  
    10271086
    10281087    psS32 numUpdated = psDBAffectedRows(config->dbh);
    1029     psLogMsg("magictool", PS_LOG_INFO, "Updated %d magic nodes", numUpdated);
     1088    psLogMsg("magictool", PS_LOG_INFO, "Reverted %d magic nodes", numUpdated);
    10301089
    10311090    return true;
    … …  
    10431102    psString query = pxDataGet("magictool_tomask.sql");
    10441103    if (!query) {
    1045         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1104        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10461105        return false;
    10471106    }
    … …  
    11311190    psString query = pxDataGet("magictool_addmask.sql");
    11321191    if (!query) {
    1133         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1192        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11341193        if (!psDBRollback(config->dbh)) {
    11351194            psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    12381297    psString query = pxDataGet("magictool_mask.sql");
    12391298    if (!query) {
    1240         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1299        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    12411300        return false;
    12421301    }
    … …  
    13671426    return true;
    13681427}
     1428
     1429static bool censorrunMode(pxConfig *config)
     1430{
     1431    PS_ASSERT_PTR_NON_NULL(config, false);
     1432
     1433    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    }
     1445
     1446    // at least one of these required
     1447    PXOPT_COPY_S64(config->args, where, "-magic_id", "magic_id", "==");
     1448    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
     1449    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     1450
     1451    if (!psListLength(where->list)) {
     1452        psError(PS_ERR_UNKNOWN, true, "either -exp_id or -magic_id is required");
     1453        psFree(where);
     1454        return false;
     1455    }
     1456
     1457    psString query = psStringCopy("UPDATE magicRun SET state = 'censored'");
     1458
     1459    psString whereClause = psDBGenerateWhereConditionSQL(where, "magicRun");
     1460    psFree(where);
     1461    psStringAppend(&query, " WHERE %s", whereClause);
     1462
     1463    if (!psDBTransaction(config->dbh)) {
     1464        psError(PS_ERR_UNKNOWN, false, "database error");
     1465        return false;
     1466    }
     1467
     1468    if (!p_psDBRunQuery(config->dbh, query)) {
     1469        psError(PS_ERR_UNKNOWN, false, "database error");
     1470        psFree(whereClause);
     1471        psFree(query);
     1472        return false;
     1473    }
     1474    psFree(query);
     1475
     1476    psS32 numUpdated = psDBAffectedRows(config->dbh);
     1477    if (numUpdated == 0) {
     1478        psError(PS_ERR_UNKNOWN, false, "failed to censor magicRun");
     1479        psFree(whereClause);
     1480        return false;
     1481    }
     1482
     1483    // Now queue any destreaked files to be re-verted
     1484
     1485    // note: on failure pxmagicRestoreStage issues the rollback
     1486    if (!pxmagicRestoreStage(config, "raw", whereClause, "goto_censored")) {
     1487        psFree(whereClause);
     1488        return false;
     1489    }
     1490    if (!pxmagicRestoreStage(config, "chip", whereClause, "goto_censored")) {
     1491        psFree(whereClause);
     1492        return false;
     1493    }
     1494    if (!pxmagicRestoreStage(config, "camera", whereClause, "goto_censored")) {
     1495        psFree(whereClause);
     1496        return false;
     1497    }
     1498    if (!pxmagicRestoreStage(config, "warp", whereClause, "goto_censored")) {
     1499        psFree(whereClause);
     1500        return false;
     1501    }
     1502    if (!pxmagicRestoreStage(config, "diff", whereClause, "goto_censored")) {
     1503        psFree(whereClause);
     1504        return false;
     1505    }
     1506
     1507    psFree(whereClause);
     1508
     1509    if (!psDBCommit(config->dbh)) {
     1510        psError(PS_ERR_UNKNOWN, false, "database error");
     1511        return false;
     1512    }
     1513
     1514    return true;
     1515}

  • branches/simmosaic_branches/ippTools/src/magictool.h

    r20700 r27839  
    4141    MAGICTOOL_MODE_REVERTMASK,
    4242    MAGICTOOL_MODE_MASK,
    43     MAGICTOOL_MODE_DIFFSKYFILE,
    44     MAGICTOOL_MODE_WARPSKYFILE,
    45     MAGICTOOL_MODE_CHIPPROCESSEDIMFILE,
    46     MAGICTOOL_MODE_RAWIMFILE,
     43    MAGICTOOL_MODE_CENSORRUN,
    4744} MAGICtoolMode;
    4845

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

    r24551 r27839  
    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);
    … …  
    108110    psMetadataAddS64(reverttreeArgs, PS_LIST_TAIL, "-magic_id", 0, "search by magictool ID", 0);
    109111    psMetadataAddS16(reverttreeArgs, PS_LIST_TAIL, "-fault", 0, "search by fault code", 0);
     112    psMetadataAddStr(reverttreeArgs, PS_LIST_TAIL, "-label", 0, "search by label", NULL);
    110113
    111114    // -inputs
    … …  
    134137    psMetadataAddS64(revertnodeArgs, PS_LIST_TAIL, "-magic_id", 0, "search by magictool ID", 0);
    135138    psMetadataAddStr(revertnodeArgs, PS_LIST_TAIL, "-node", 0, "search by node name", NULL);
    136     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);
    137140    psMetadataAddS16(revertnodeArgs, PS_LIST_TAIL, "-fault", 0, "search by fault code", 0);
    138141
    … …  
    160163    psMetadataAddBool(maskArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    161164
    162 #ifdef notdef
    163     // -diffskyfile
    164     psMetadata *diffskyfileArgs = psMetadataAlloc();
    165     psMetadataAddS64(diffskyfileArgs, PS_LIST_TAIL, "-magic_id", 0, "define magictool ID (required)", 0);
    166     psMetadataAddStr(diffskyfileArgs, PS_LIST_TAIL, "-class_id", 0, "define class identifier", NULL);
    167     psMetadataAddStr(diffskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0, "define skycell identifier", NULL);
    168     psMetadataAddBool(diffskyfileArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    169 
    170     // -warpskyfile
    171     psMetadata *warpskyfileArgs = psMetadataAlloc();
    172     psMetadataAddS64(warpskyfileArgs, PS_LIST_TAIL, "-magic_id", 0, "define magictool ID (required)", 0);
    173     psMetadataAddBool(warpskyfileArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    174     psMetadataAddStr(warpskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0, "define skycell identifier", NULL);
    175 
    176     // -chipprocessedimfile
    177     psMetadata *chipprocessedimfileArgs = psMetadataAlloc();
    178     psMetadataAddS64(chipprocessedimfileArgs, PS_LIST_TAIL, "-magic_id", 0, "define magictool ID (required)", 0);
    179     psMetadataAddStr(chipprocessedimfileArgs, PS_LIST_TAIL, "-class_id", 0, "define class identifier", NULL);
    180     psMetadataAddBool(chipprocessedimfileArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    181 
    182     // -rawimfile
    183     psMetadata *rawimfileArgs = psMetadataAlloc();
    184     psMetadataAddS64(rawimfileArgs, PS_LIST_TAIL, "-magic_id", 0, "define magictool ID (required)", 0);
    185     psMetadataAddStr(rawimfileArgs, PS_LIST_TAIL, "-class_id", 0, "define class identifier", NULL);
    186     psMetadataAddBool(rawimfileArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    187 #endif // notdef
     165    // -censorun
     166    psMetadata *censorrunArgs = psMetadataAlloc();
     167    psMetadataAddS64(censorrunArgs, PS_LIST_TAIL, "-magic_id", 0, "define magictool ID", 0);
     168    psMetadataAddS64(censorrunArgs, PS_LIST_TAIL, "-exp_id", 0, "define exposure ID", 0);
     169    psMetadataAddStr(censorrunArgs, PS_LIST_TAIL, "-label",       0, "define label", NULL);
    188170
    189171    psFree(now);
    … …  
    208190    PXOPT_ADD_MODE("-revertmask",          "", MAGICTOOL_MODE_REVERTMASK,          revertmaskArgs);
    209191    PXOPT_ADD_MODE("-mask",                "", MAGICTOOL_MODE_MASK,                maskArgs);
    210 #ifdef notdef
    211     PXOPT_ADD_MODE("-diffskyfile",         "", MAGICTOOL_MODE_DIFFSKYFILE,         diffskyfileArgs);
    212     PXOPT_ADD_MODE("-warpskyfile",         "", MAGICTOOL_MODE_WARPSKYFILE,         warpskyfileArgs);
    213     PXOPT_ADD_MODE("-chipprocessedimfile", "", MAGICTOOL_MODE_CHIPPROCESSEDIMFILE, chipprocessedimfileArgs);
    214     PXOPT_ADD_MODE("-rawimfile",           "", MAGICTOOL_MODE_RAWIMFILE,           rawimfileArgs);
    215 #endif
     192    PXOPT_ADD_MODE("-censorrun",           "", MAGICTOOL_MODE_CENSORRUN,           censorrunArgs);
    216193
    217194    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

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

    r21412 r27839  
    3434static bool datastoreMode(pxConfig *config);
    3535static bool moddatastoreMode(pxConfig *config);
    36 static bool addReqMode(pxConfig *config);
    37 static bool completedReqMode(pxConfig *config);
    38 static bool listReqMode(pxConfig *config);
    39 static bool pendingReqMode(pxConfig *config);
    40 static bool updateReqMode(pxConfig *config);
    41 static bool revertReqMode(pxConfig *config);
    42 static bool addJobMode(pxConfig *config);
    43 static bool listJobMode(pxConfig *config);
    44 static bool pendingJobMode(pxConfig *config);
    45 static bool updateJobMode(pxConfig *config);
    46 static bool addProjectMode(pxConfig *config);
     36static bool addreqMode(pxConfig *config);
     37static bool completedreqMode(pxConfig *config);
     38static bool listreqMode(pxConfig *config);
     39static bool pendingreqMode(pxConfig *config);
     40static bool updatereqMode(pxConfig *config);
     41static bool revertreqMode(pxConfig *config);
     42static bool addjobMode(pxConfig *config);
     43static bool listjobMode(pxConfig *config);
     44static bool pendingjobMode(pxConfig *config);
     45static bool updatejobMode(pxConfig *config);
     46static bool revertjobMode(pxConfig *config);
     47static bool addprojectMode(pxConfig *config);
    4748static bool projectMode(pxConfig *config);
    48 static bool modProjectMode(pxConfig *config);
     49static 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) \
    … …  
    7075        MODECASE(PSTAMPTOOL_MODE_DATASTORE, datastoreMode);
    7176        MODECASE(PSTAMPTOOL_MODE_MODDATASTORE, moddatastoreMode);
    72         MODECASE(PSTAMPTOOL_MODE_ADDREQ, addReqMode);
    73         MODECASE(PSTAMPTOOL_MODE_COMPLETEDREQ, completedReqMode);
    74         MODECASE(PSTAMPTOOL_MODE_LISTREQ, listReqMode);
    75         MODECASE(PSTAMPTOOL_MODE_PENDINGREQ, pendingReqMode);
    76         MODECASE(PSTAMPTOOL_MODE_UPDATEREQ, updateReqMode);
    77         MODECASE(PSTAMPTOOL_MODE_REVERTREQ, revertReqMode);
    78         MODECASE(PSTAMPTOOL_MODE_ADDJOB, addJobMode);
    79         MODECASE(PSTAMPTOOL_MODE_LISTJOB, listJobMode);
    80         MODECASE(PSTAMPTOOL_MODE_PENDINGJOB, pendingJobMode);
    81         MODECASE(PSTAMPTOOL_MODE_UPDATEJOB, updateJobMode);
    82         MODECASE(PSTAMPTOOL_MODE_ADDPROJECT, addProjectMode);
    83         MODECASE(PSTAMPTOOL_MODE_MODPROJECT, modProjectMode);
     77        MODECASE(PSTAMPTOOL_MODE_ADDREQ, addreqMode);
     78        MODECASE(PSTAMPTOOL_MODE_COMPLETEDREQ, completedreqMode);
     79        MODECASE(PSTAMPTOOL_MODE_LISTREQ, listreqMode);
     80        MODECASE(PSTAMPTOOL_MODE_PENDINGREQ, pendingreqMode);
     81        MODECASE(PSTAMPTOOL_MODE_UPDATEREQ, updatereqMode);
     82        MODECASE(PSTAMPTOOL_MODE_REVERTREQ, revertreqMode);
     83        MODECASE(PSTAMPTOOL_MODE_ADDJOB, addjobMode);
     84        MODECASE(PSTAMPTOOL_MODE_LISTJOB, listjobMode);
     85        MODECASE(PSTAMPTOOL_MODE_PENDINGJOB, pendingjobMode);
     86        MODECASE(PSTAMPTOOL_MODE_UPDATEJOB, updatejobMode);
     87        MODECASE(PSTAMPTOOL_MODE_REVERTJOB, revertjobMode);
     88        MODECASE(PSTAMPTOOL_MODE_ADDPROJECT, addprojectMode);
     89        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;
    … …  
    220247}
    221248
    222 static bool addReqMode(pxConfig *config)
    223 {
    224     PS_ASSERT_PTR_NON_NULL(config, false);
    225 
    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);
     249static bool addreqMode(pxConfig *config)
     250{
     251    PS_ASSERT_PTR_NON_NULL(config, false);
     252
     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    }
    … …  
    251278}
    252279
    253 static bool pendingReqMode(pxConfig *config)
     280static bool pendingreqMode(pxConfig *config)
    254281{
    255282    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    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    }
    … …  
    311339}
    312340
    313 static bool listReqMode(pxConfig *config)
    314 {
    315     PS_ASSERT_PTR_NON_NULL(config, false);
    316 
    317     PXOPT_LOOKUP_S64(req_id,  config->args, "-req_id", true, false);
     341static bool listreqMode(pxConfig *config)
     342{
     343    PS_ASSERT_PTR_NON_NULL(config, false);
     344
     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
    … …  
    359403}
    360404
    361 static bool completedReqMode(pxConfig *config)
    362 {
    363     PS_ASSERT_PTR_NON_NULL(config, false);
     405static bool completedreqMode(pxConfig *config)
     406{
     407    PS_ASSERT_PTR_NON_NULL(config, false);
     408
     409    psMetadata *where = psMetadataAlloc();
     410    pxAddLabelSearchArgs(config, where, "-label", "label", "LIKE");
    364411
    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"
    … …  
    408459}
    409460
    410 static bool updateReqMode(pxConfig *config)
     461static bool updatereqMode(pxConfig *config)
    411462{
    412463    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    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;
    … …  
    472523}
    473524
    474 static bool revertReqMode(pxConfig *config)
    475 {
    476     PS_ASSERT_PTR_NON_NULL(config, false);
    477 
    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     }
    491 
    492     return true;
    493 }
    494 
    495 static bool addJobMode(pxConfig *config)
     525static bool revertreqMode(pxConfig *config)
     526{
     527    PS_ASSERT_PTR_NON_NULL(config, false);
     528
     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);
     566
     567    return true;
     568}
     569
     570static bool addjobMode(pxConfig *config)
    496571{
    497572    bool    stampJob = false;
    498     char   *query = NULL;
    499 
    500     PS_ASSERT_PTR_NON_NULL(config, false);
    501 
    502     PXOPT_LOOKUP_S64(uri,         config->args, "-uri",        true, false);
     573
     574    PS_ASSERT_PTR_NON_NULL(config, false);
     575
    503576    PXOPT_LOOKUP_S64(req_id,      config->args, "-req_id",     true, false);
    504577    PXOPT_LOOKUP_STR(rownum,      config->args, "-rownum",     true, false);
    505578    PXOPT_LOOKUP_STR(job_type,    config->args, "-job_type",   false, false);
    506     PXOPT_LOOKUP_STR(outputBase,  config->args, "-outputBase", true,  false);
    507     PXOPT_LOOKUP_STR(argString,   config->args, "-args",       false, false);
     579    PXOPT_LOOKUP_STR(outputBase,  config->args, "-outputBase", false,  false);
    508580    PXOPT_LOOKUP_STR(stateString, config->args, "-state",      false, false);
    509     PXOPT_LOOKUP_STR(fault,       config->args, "-fault",      false, false);
     581    PXOPT_LOOKUP_S16(fault,       config->args, "-fault",      false, false);
    510582    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);
     585
     586    // unless the job is being inserted with stop state require outputBase
     587    if (strcmp(stateString, "stop") && !outputBase) {
     588        psError(PS_ERR_UNKNOWN, true, "-outputBase is required");
     589        return false;
     590    }
    511591
    512592    // default value for job_type is defined in pstamptoolConfig.c
    513     if (!strcmp(job_type, "get_image") || !strcmp(job_type, "detect_query")) {
    514         stampJob = false;
     593    if (!strcmp(job_type, "get_image") || !strcmp(job_type, "detect_query") || !strcmp(job_type, "none")) {
     594        stampJob = false;
    515595    } else if (!strcmp(job_type, "stamp")) {
    516         stampJob = true;
     596        stampJob = true;
    517597    } else {
    518         psError(PS_ERR_UNKNOWN, false, "unknown value for -job_type: %s", job_type);
    519         return false;
    520     }
    521 
    522     if (stampJob && !argString) {
    523         psError(PS_ERR_UNKNOWN, true, "-args is required for stamp job");
    524         return false;
    525     }
    526 
    527     if (stampJob) {
    528         query = pxDataGet("pstamptool_addjob_stampjob.sql");
    529     } else {
    530         query = pxDataGet("pstamptool_addjob_otherjob.sql");
    531     }
    532     if (!query) {
    533         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    534         return false;
    535     }
    536 
    537     if (!p_psDBRunQueryF(config->dbh, query, req_id, rownum, stateString, job_type, uri, exp_id, outputBase, fault, argString)) {
     598        psError(PS_ERR_UNKNOWN, false, "unknown value for -job_type: %s", job_type);
     599        return false;
     600    }
     601    if (!pstampJobInsert(config->dbh,
     602            0, // job_id
     603            req_id,
     604            rownum,
     605            stateString,
     606            job_type,
     607            fault,
     608            exp_id,
     609            outputBase,
     610            options,
     611            dep_id
     612            )) {
    538613        psError(PS_ERR_UNKNOWN, false, "database error");
    539614        return false;
    … …  
    542617    psU64 affected = psDBAffectedRows(config->dbh);
    543618    if (affected != 1) {
    544         psError(PS_ERR_UNKNOWN, false, 
     619        psError(PS_ERR_UNKNOWN, false,
    545620            "should have affected one row but %" PRIu64 " rows were modified",
    546621            affected);
    … …  
    554629}
    555630
    556 static bool listJobMode(pxConfig *config)
    557 {
    558     PS_ASSERT_PTR_NON_NULL(config, false);
    559 
    560     PXOPT_LOOKUP_S64(req_id, config->args, "-req_id", false, false);
    561     PXOPT_LOOKUP_S64(job_id, config->args, "-job_id", false, false);
     631static bool listjobMode(pxConfig *config)
     632{
     633    PS_ASSERT_PTR_NON_NULL(config, false);
     634
     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", "==");
    562639
    563640    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    564641    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    565642
    566     psString query = NULL;
    567 
    568     if (!req_id && !job_id) {
    569         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");
    570645        exit (1);
    571646    }
    572647
    573     if (req_id) {
    574         psStringAppend(&query,
    575                 "SELECT"
    576                 " pstampJob.*, pstampRequest.name, pstampRequest.outProduct"
    577                 " FROM pstampJob"
    578                 " JOIN pstampRequest USING(req_id)"
    579                 " WHERE req_id = %" PRId64, req_id
    580             );
    581     } else {
    582         psStringAppend(&query,
    583                 "SELECT"
    584                 " pstampJob.*, pstampRequest.name, pstampRequest.outProduct"
    585                 " FROM pstampJob"
    586                 " JOIN pstampRequest USING(req_id)"
    587                 " WHERE job_id = %" PRId64, job_id
    588             );
    589     }
     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);
    590661
    591662    // treat limit == 0 as "no limit"
    … …  
    626697}
    627698
    628 static bool pendingJobMode(pxConfig *config)
     699static bool pendingjobMode(pxConfig *config)
    629700{
    630701    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    634705    PXOPT_COPY_S64(config->args, where, "-job_id", "job_id", "==");
    635706    PXOPT_COPY_S64(config->args, where, "-req_id", "req_id", "==");
     707    pxAddLabelSearchArgs(config, where, "-label", "label", "LIKE");
     708
    636709    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    637710    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    639712    psString query = pxDataGet("pstamptool_pendingjob.sql");
    640713    if (!query) {
    641         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     714        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    642715        return false;
    643716    }
    … …  
    645718    // use psDBGenerateWhereSQL because the SQL yields an intermediate table
    646719    if (psListLength(where->list)) {
    647         psString whereClause = psDBGenerateWhereConditionSQL(where, "pstampJob");
     720        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    648721        psStringAppend(&query, " AND %s", whereClause);
    649722        psFree(whereClause);
    … …  
    688761}
    689762
    690 static bool updateJobMode(pxConfig *config)
    691 {
    692     PS_ASSERT_PTR_NON_NULL(config, false);
    693 
    694     PXOPT_LOOKUP_S64(job_id,    config->args, "-job_id", true, false);
     763static bool updatejobMode(pxConfig *config)
     764{
     765    PS_ASSERT_PTR_NON_NULL(config, false);
     766
     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    }
    695774    PXOPT_LOOKUP_STR(state,     config->args, "-state",  true, false);
    696     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", "==");
    697781
    698782    psString faultStr = NULL;
    … …  
    700784        faultStr = psStringCopy("");
    701785    } else {
    702         psStringAppend(&faultStr, ", fault = '%s'", fault);
    703     }
    704 
    705     char *query ="UPDATE pstampJob"
    706         " SET state = '%s' %s"
    707         " WHERE job_id = %" PRId64;
    708    
    709     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)) {
    710797        psError(PS_ERR_UNKNOWN, false, "database error");
    711798        psFree(query);
    … …  
    713800    }
    714801    psFree(faultStr);
     802    psFree(query);
    715803
    716804    psU64 affected = psDBAffectedRows(config->dbh);
    717     if (affected != 1) {
    718         psError(PS_ERR_UNKNOWN, false, "should have affected one row but %"
    719                                         PRIu64 " rows were modified", affected);
    720         return false;
    721     }
    722 
    723     return true;
    724 }
    725 static bool addProjectMode(pxConfig *config)
     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");
     849        return false;
     850    }
     851
     852    return true;
     853}
     854static bool addprojectMode(pxConfig *config)
    726855{
    727856    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    763892    psString query = pxDataGet("pstamptool_project.sql");
    764893    if (!query) {
    765         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     894        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    766895        return false;
    767896    }
    … …  
    801930    return true;
    802931}
    803 static bool modProjectMode(pxConfig *config)
     932static bool modprojectMode(pxConfig *config)
    804933{
    805934    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    809938
    810939    char *query = psStringCopy ("UPDATE pstampProject SET");
    811    
     940
    812941    psStringAppend(&query, " state = '%s'", state);
    813                
     942
    814943    psStringAppend(&query, " WHERE proj_id = %" PRId64, proj_id);
    815944
    … …  
    822951    psU64 affected = psDBAffectedRows(config->dbh);
    823952    if (affected != 1) {
    824         psError(PS_ERR_UNKNOWN, false, "should have affected one row but %" 
     953        psError(PS_ERR_UNKNOWN, false, "should have affected one row but %"
    825954                                        PRIu64 " rows were modified", affected);
    826955        return false;
    … …  
    830959}
    831960
     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/simmosaic_branches/ippTools/src/pstamptool.h

    r19760 r27839  
    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/simmosaic_branches/ippTools/src/pstamptoolConfig.c

    r20151 r27839  
    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     psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-uri", 0,            "define job file uri", NULL);
    103     psMetadataAddS64(addjobArgs, PS_LIST_TAIL, "-req_id", 0,            "define job req_id", 0);
    104     psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-rownum", 0,            "define job rownum", NULL);
    105     psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-job_type", 0,            "define job job_type", "stamp");
    106     psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-outputBase", 0,            "define job outputBase", NULL);
    107     psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-args", 0,            "define job args", NULL);
    108     psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-state", 0,            "new state", "run");
    109     psMetadataAddS64(addjobArgs, PS_LIST_TAIL, "-exp_id", 0,           "exposure id", 0);
    110     psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-fault", 0,            "new result", NULL);
     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);
    111126
    112127    // -listjob
    113128    psMetadata *listjobArgs = psMetadataAlloc();
    114     psMetadataAddS64(listjobArgs, PS_LIST_TAIL, "-req_id", 0,            "define request", 0);
    115     psMetadataAddS64(listjobArgs, PS_LIST_TAIL, "-job_id", 0,            "define job", 0);
    116     psMetadataAddU64(listjobArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    117     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);
    118134
    119135    // -pendingjob
    120136    psMetadata *pendingjobArgs = psMetadataAlloc();
    121     psMetadataAddS64(pendingjobArgs, PS_LIST_TAIL, "-job_id", 0,            "define job", 0);
    122     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);
    123140    psMetadataAddU64(pendingjobArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    124141    psMetadataAddBool(pendingjobArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    … …  
    126143    // -updatejob
    127144    psMetadata *updatejobArgs = psMetadataAlloc();
    128     psMetadataAddS64(updatejobArgs, PS_LIST_TAIL, "-job_id", 0,            "req_id for which to change state", 0);
    129     psMetadataAddStr(updatejobArgs, PS_LIST_TAIL, "-state", 0,            "new state", NULL);
    130     // psMetadataAddStr(updatejobArgs, PS_LIST_TAIL, "-result", 0,            "new result", NULL);
    131     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);
    132192
    133193    // -addproject
    … …  
    143203    // -modproject
    144204    psMetadata *modprojectArgs = psMetadataAlloc();
    145     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);
    146206    psMetadataAddStr(modprojectArgs, PS_LIST_TAIL, "-imagedb",      0, "define name of database for project", NULL);
    147207    psMetadataAddStr(modprojectArgs, PS_LIST_TAIL, "-state",        0, "define state for project (enabled, disabled)", NULL);
    … …  
    153213    // -project
    154214    psMetadata *projectArgs = psMetadataAlloc();
    155     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);
    156216    psMetadataAddBool(projectArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    157217
    … …  
    161221    PXOPT_ADD_MODE("-addreq",          "", PSTAMPTOOL_MODE_ADDREQ,       addreqArgs);
    162222    PXOPT_ADD_MODE("-pendingreq",      "", PSTAMPTOOL_MODE_PENDINGREQ,   pendingreqArgs);
    163     PXOPT_ADD_MODE("-updatereq",    "", PSTAMPTOOL_MODE_UPDATEREQ, updatereqArgs);
     223    PXOPT_ADD_MODE("-updatereq",       "", PSTAMPTOOL_MODE_UPDATEREQ, updatereqArgs);
    164224    PXOPT_ADD_MODE("-listreq",         "", PSTAMPTOOL_MODE_LISTREQ,      listreqArgs);
    165225    PXOPT_ADD_MODE("-completedreq",    "", PSTAMPTOOL_MODE_COMPLETEDREQ, completedreqArgs);
    … …  
    169229    PXOPT_ADD_MODE("-listjob",         "", PSTAMPTOOL_MODE_LISTJOB,      listjobArgs);
    170230    PXOPT_ADD_MODE("-pendingjob",      "", PSTAMPTOOL_MODE_PENDINGJOB,   pendingjobArgs);
    171     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);
    172233
    173234    PXOPT_ADD_MODE("-adddatastore",    "", PSTAMPTOOL_MODE_ADDDATASTORE, adddatastoreArgs);
    174235    PXOPT_ADD_MODE("-datastore",       "", PSTAMPTOOL_MODE_DATASTORE,    datastoreArgs);
    175236    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);
    176242
    177243    PXOPT_ADD_MODE("-addproject",      "", PSTAMPTOOL_MODE_ADDPROJECT, addprojectArgs);

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

    r24512 r27839  
    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/simmosaic_branches/ippTools/src/pubtool.h

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

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

    r24512 r27839  
    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/simmosaic_branches/ippTools/src/pxadmin.c

    r23310 r27839  
    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/simmosaic_branches/ippTools/src/pxcam.c

    r24733 r27839  
    6868    psMetadataAddF64(md,  PS_LIST_TAIL, "-posang_max",         0, "define max rotator position angle", NAN);
    6969    psMetadataAddStr(md,  PS_LIST_TAIL, "-object",             0, "search by exposure object", NULL);
    70     psMetadataAddF32(md,  PS_LIST_TAIL, "-solang_min",         0, "define min solar angle", NAN);
    71     psMetadataAddF32(md,  PS_LIST_TAIL, "-solang_max",         0, "define max solar angle", NAN);
     70    psMetadataAddF32(md,  PS_LIST_TAIL, "-sun_angle_min",         0, "define min solar angle", NAN);
     71    psMetadataAddF32(md,  PS_LIST_TAIL, "-sun_angle_max",         0, "define max solar angle", NAN);
    7272
    7373    return true;
    … …  
    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",        "<");
    … …  
    113113    PXOPT_COPY_F64(config->args,   where, "-posang_max",         "rawExp.posang",         "<");
    114114    PXOPT_COPY_STR(config->args,   where, "-object",             "rawExp.object",         "==");
    115     PXOPT_COPY_F32(config->args,   where, "-solang_min",         "rawExp.solang",         ">=");
    116     PXOPT_COPY_F32(config->args,   where, "-solang_max",         "rawExp.solang",         "<");
     115    PXOPT_COPY_F32(config->args,   where, "-sun_angle_min",         "rawExp.sun_angle",         ">=");
     116    PXOPT_COPY_F32(config->args,   where, "-sun_angle_max",         "rawExp.sun_angle",         "<");
    117117
    118118    return true;
    … …  
    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/simmosaic_branches/ippTools/src/pxcam.h

    r24681 r27839  
    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/simmosaic_branches/ippTools/src/pxchip.c

    r24733 r27839  
    6969    psMetadataAddF64(md,  PS_LIST_TAIL, "-posang_min",         0, "search by min rotator position angle", NAN);
    7070    psMetadataAddF64(md,  PS_LIST_TAIL, "-posang_max",         0, "search by max rotator position angle", NAN);
    71     psMetadataAddF32(md,  PS_LIST_TAIL, "-solang_min",         0, "search by min solar angle", NAN);
    72     psMetadataAddF32(md,  PS_LIST_TAIL, "-solang_max",         0, "search by max solar angle", NAN);
     71    psMetadataAddF32(md,  PS_LIST_TAIL, "-sun_angle_min",         0, "search by min solar angle", NAN);
     72    psMetadataAddF32(md,  PS_LIST_TAIL, "-sun_angle_max",         0, "search by max solar angle", NAN);
    7373    psMetadataAddStr(md,  PS_LIST_TAIL, "-object",             0, "search by exposure object", NULL);
    7474    psMetadataAddStr(md,  PS_LIST_TAIL, "-comment",            0, "search by comment field (LIKE comparison)", NULL);
    … …  
    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", "<");
    … …  
    122122    PXOPT_COPY_F64(config->args, where, "-posang_max", "rawExp.posang", "<");
    123123    PXOPT_COPY_STR(config->args, where, "-object", "rawExp.object", "==");
    124     PXOPT_COPY_F32(config->args, where, "-solang_min", "rawExp.solang", ">=");
    125     PXOPT_COPY_F32(config->args, where, "-solang_max", "rawExp.solang", "<");
     124    PXOPT_COPY_F32(config->args, where, "-sun_angle_min", "rawExp.sun_angle", ">=");
     125    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/simmosaic_branches/ippTools/src/pxchip.h

    r23381 r27839  
    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/simmosaic_branches/ippTools/src/pxerrors.c

    r23487 r27839  
    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/simmosaic_branches/ippTools/src/pxfake.c

    r21402 r27839  
    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/simmosaic_branches/ippTools/src/pxfake.h

    r17938 r27839  
    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/simmosaic_branches/ippTools/src/pxinject.c

    r18336 r27839  
    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/simmosaic_branches/ippTools/src/pxinjectConfig.c

    r18561 r27839  
    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/simmosaic_branches/ippTools/src/pxregister.c

    r21402 r27839  
    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/simmosaic_branches/ippTools/src/pxregister.h

    r18336 r27839  
    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/simmosaic_branches/ippTools/src/pxtools.c

    r23918 r27839  
    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/simmosaic_branches/ippTools/src/pxtools.h

    r24733 r27839  
    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/simmosaic_branches/ippTools/src/pxtoolsErrorCodes.dat

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

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

    r24487 r27839  
    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/simmosaic_branches/ippTools/src/pxwarp.h

    r24487 r27839  
    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/simmosaic_branches/ippTools/src/pztool.c

    r23688 r27839  
    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/simmosaic_branches/ippTools/src/pztoolConfig.c

    r23688 r27839  
    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/simmosaic_branches/ippTools/src/receivetool.c

    r24784 r27839  
    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/simmosaic_branches/ippTools/src/receivetoolConfig.c

    r24125 r27839  
    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/simmosaic_branches/ippTools/src/regtool.c

    r24858 r27839  
    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);
    333358    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    }
    334370
    335371    psString query = pxDataGet("regtool_processedimfile.sql");
    336372    if (!query) {
    337         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     373        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    338374        psFree(where);
    339375        return false;
    … …  
    344380        psStringAppend(&query, " AND %s", whereClause);
    345381        psFree(whereClause);
     382    } else if (!all && !where2) {
     383        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     384        return false;
    346385    }
    347386    psFree(where);
     387    if (where2) {
     388        psStringAppend(&query, " %s", where2);
     389        psFree(where2);
     390    }
    348391
    349392    if (faulted) {
    350393        // list only faulted rows
    351394        psStringAppend(&query, " %s", "AND rawImfile.fault != 0");
    352     } else {
     395    } else if (!allfiles) {
    353396        // don't list faulted rows
    354397        psStringAppend(&query, " %s", "AND rawImfile.fault = 0");
    … …  
    423466    psString query = pxDataGet("regtool_revertprocessedimfile.sql");
    424467    if (!query) {
    425         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     468        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    426469        psFree(where);
    427470        return false;
    … …  
    434477    } else {
    435478        psFree(where);
    436         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     479        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    437480        return false;
    438481    }
    … …  
    462505
    463506    PXOPT_LOOKUP_S16(fault, config->args, "-fault",   false, false);
    464     PXOPT_LOOKUP_F64(user_1, config->args, "-user_1", false, false);
    465 
    466     if ((fault == INT16_MAX) && !isfinite(user_1)) {
    467         psError(PS_ERR_UNKNOWN, false, "one of -fault or -user_1 must be selected");
    468         return false;
    469     }
    470     if ((fault != INT16_MAX) && isfinite(user_1)) {
    471         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");
    472518        return false;
    473519    }
    … …  
    478524
    479525    if (fault != INT16_MAX) {
    480         // this is fairly dangerous : can set all if the where is not set...
    481         if (!pxSetFaultCode(config->dbh, "rawImfile", where, fault)) {
    482             psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    483             psFree (where);
    484             return false;
    485         }
    486     }
    487 
    488     if (isfinite(user_1)) {
    489         psString query = pxDataGet("regtool_updateprocessedimfile.sql");
    490         if (!query) {
    491             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    492             return false;
    493         }
    494 
    495         if (!p_psDBRunQueryF(config->dbh, query, user_1, exp_id, class_id)) {
    496             psError(PS_ERR_UNKNOWN, false, "database error");
    497             psFree(query);
    498             return false;
    499         }
    500         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);
    501534    }
    502535    psFree (where);
    503536
     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
    504576    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;
    505663}
    506664
    … …  
    519677    psString query = pxDataGet("regtool_pendingexp.sql");
    520678    if (!query) {
    521         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     679        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    522680        return false;
    523681    }
    … …  
    596754    PXOPT_LOOKUP_STR(exp_type, config->args, "-exp_type", false, false);
    597755    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", false, false);
     756    PXOPT_LOOKUP_STR(state, config->args, "-state", false, false);
    598757    PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false);
    599758    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", false, false);
    … …  
    657816    psString query = pxDataGet("regtool_pendingexp.sql");
    658817    if (!query) {
    659         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     818        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    660819        return false;
    661820    }
    … …  
    757916        filelevel,
    758917        workdir,
     918        state,
    759919        reduction,
    760920        dvodb,
    … …  
    8551015                workdir,
    8561016                label,
     1017                NULL,       // data_group
     1018                NULL,       // dist_group
    8571019                reduction,
    858                 NULL, // expgroup
     1020                NULL,       // expgroup
    8591021                dvodb,
    8601022                tess_id,
    861                 end_stage
     1023                end_stage,
     1024                NULL        // note
    8621025    )) {
    8631026        // rollback
    … …  
    8871050    psString query = pxDataGet("regtool_processedexp.sql");
    8881051    if (!query) {
    889         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1052        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    8901053        return false;
    8911054    }
    … …  
    8971060    PXOPT_COPY_STR(config->args,   where,  "-inst", "camera", "==");
    8981061    PXOPT_COPY_STR(config->args,   where,  "-telescope", "telescope", "==");
    899     PXOPT_COPY_TIME(config->args,  where, "-dateobs_begin", "dateobs", ">=");
    900     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", "==");
    9011065    PXOPT_COPY_STR(config->args,   where,  "-exp_tag", "exp_tag", "==");
    9021066    PXOPT_COPY_STR(config->args,   where,  "-exp_type", "exp_type", "==");
    9031067    PXOPT_COPY_STR(config->args,   where,  "-filelevel", "filelevel", "==");
    9041068    PXOPT_COPY_STR(config->args,   where,  "-reduction", "reduction", "==");
    905     PXOPT_COPY_STR(config->args,   where,  "-filter", "filter", "==");
     1069    PXOPT_COPY_STR(config->args,   where,  "-filter", "filter", "LIKE");
    9061070    PXOPT_COPY_F32(config->args,   where,  "-airmass_min", "airmass", ">=");
    9071071    PXOPT_COPY_F32(config->args,   where,  "-airmass_max", "airmass", "<");
    … …  
    9291093    PXOPT_COPY_F64(config->args,   where,  "-posang_max", "posang", "<");
    9301094    PXOPT_COPY_STR(config->args,   where,  "-object", "object", "==");
    931     PXOPT_COPY_F32(config->args,   where,  "-solang_min", "solang", ">=");
    932     PXOPT_COPY_F32(config->args,   where,  "-solang_max", "solang", "<");
     1095    PXOPT_COPY_F32(config->args,   where,  "-sun_angle_min", "sun_angle", ">=");
     1096    PXOPT_COPY_F32(config->args,   where,  "-sun_angle_max", "sun_angle", "<");
     1097
     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    }
    9331107
    9341108    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    9371111
    9381112    if (psListLength(where->list)) {
    939         psString whereClause = psDBGenerateWhereConditionSQL(where, "rawExp");
    940         psStringAppend(&query, " AND %s", whereClause);
    941         psFree(whereClause);
     1113      psString whereClause = psDBGenerateWhereConditionSQL(where, "rawExp");
     1114      psStringAppend(&query, " AND %s", whereClause);
     1115      psFree(whereClause);
    9421116    }
    9431117    psFree(where);
    9441118
     1119    if (where2) {
     1120        psStringAppend(&query, " %s ", where2);
     1121        psFree(where2);
     1122    }
     1123
    9451124    if (faulted) {
    946         // list only faulted rows
    947         psStringAppend(&query, " %s", "AND rawExp.fault != 0");
     1125      // list only faulted rows
     1126      psStringAppend(&query, " %s", "AND rawExp.fault != 0");
    9481127    } else {
    949         // don't list faulted rows
    950         psStringAppend(&query, " %s", "AND rawExp.fault = 0");
     1128      // don't list faulted rows
     1129      psStringAppend(&query, " %s", "AND rawExp.fault = 0");
    9511130    }
    9521131
    9531132    // treat limit == 0 as "no limit"
    9541133    if (limit) {
    955         psString limitString = psDBGenerateLimitSQL(limit);
    956         psStringAppend(&query, " %s", limitString);
    957         psFree(limitString);
     1134      psString limitString = psDBGenerateLimitSQL(limit);
     1135      psStringAppend(&query, " %s", limitString);
     1136      psFree(limitString);
    9581137    }
    9591138
    9601139    if (!p_psDBRunQuery(config->dbh, query)) {
    961         psError(PS_ERR_UNKNOWN, false, "database error");
    962         return false;
     1140      psError(PS_ERR_UNKNOWN, false, "database error");
     1141      return false;
    9631142    }
    9641143    psFree(query);
    … …  
    9661145    psArray *output = p_psDBFetchResult(config->dbh);
    9671146    if (!output) {
    968         psErrorCode err = psErrorCodeLast();
    969         switch (err) {
    970             case PS_ERR_DB_CLIENT:
    971                 psError(PXTOOLS_ERR_SYS, false, "database error");
    972             case PS_ERR_DB_SERVER:
    973                 psError(PXTOOLS_ERR_PROG, false, "database error");
    974             default:
    975                 psError(PXTOOLS_ERR_PROG, false, "unknown error");
    976         }
    977 
    978         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;
    9791158    }
    9801159    if (!psArrayLength(output)) {
    981         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");
    9821169        psFree(output);
    983         return true;
    984     }
    985 
    986     if (psArrayLength(output)) {
    987         // negative simple so the default is true
    988         if (!ippdbPrintMetadatas(stdout, output, "rawExp", !simple)) {
    989             psError(PS_ERR_UNKNOWN, false, "failed to print array");
    990             psFree(output);
    991             return false;
    992         }
     1170        return false;
     1171      }
    9931172    }
    9941173
    … …  
    10001179static bool revertprocessedexpMode(pxConfig *config)
    10011180{
    1002     PS_ASSERT_PTR_NON_NULL(config, false);
    1003 
    1004     psMetadata *where = psMetadataAlloc();
    1005     PXOPT_COPY_S64(config->args, where,  "-exp_id",       "exp_id", "==");
    1006     PXOPT_COPY_S16(config->args, where,  "-fault",         "fault", "==");
    1007     PXOPT_COPY_S64(config->args, where,  "-exp_id_begin", "exp_id", ">=");
    1008     PXOPT_COPY_S64(config->args, where,  "-exp_id_end", "exp_id", "<=");
    1009 
    1010     psString query = pxDataGet("regtool_revertprocessedexp.sql");
    1011     if (!query) {
    1012         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1013         psFree(where);
    1014         return false;
    1015     }
    1016 
    1017     if (psListLength(where->list)) {
    1018         psString whereClause = psDBGenerateWhereConditionSQL(where, "rawExp");
    1019         psStringAppend(&query, " AND %s", whereClause);
    1020         psFree(whereClause);
    1021     } else {
    1022         psFree(where);
    1023         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
    1024         return false;
    1025     }
     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");
    10261192    psFree(where);
    1027 
    1028     if (!p_psDBRunQuery(config->dbh, query)) {
    1029         psError(PS_ERR_UNKNOWN, false, "database error");
    1030         psFree(query);
    1031         return false;
    1032     }
     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");
    10331209    psFree(query);
    1034 
    1035     int numUpdated = psDBAffectedRows(config->dbh);
    1036 
    1037     psLogMsg("regtool", PS_LOG_INFO, "Updated %d rawExp", numUpdated);
    1038 
    1039     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;
    10401219}
    10411220
    … …  
    10431222static bool updateprocessedexpMode(pxConfig *config)
    10441223{
    1045     PS_ASSERT_PTR_NON_NULL(config, false);
    1046 
    1047     psMetadata *where = psMetadataAlloc();
    1048     PXOPT_COPY_S64(config->args, where,  "-exp_id",       "exp_id", "==");
    1049 
    1050     PXOPT_LOOKUP_S16(fault, config->args, "-fault", true, false);
    1051 
    1052     if (!pxSetFaultCode(config->dbh, "rawExp", where, fault)) {
    1053         psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    1054         psFree(where);
    1055         return false;
    1056     }
     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");
    10571233    psFree(where);
    1058 
    1059     return true;
    1060 }
     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
    10611427
    10621428
    … …  
    10781444            psError(PS_ERR_UNKNOWN, false, "database error");
    10791445        }
    1080         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1446        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10811447        return false;
    10821448    }
    … …  
    11041470            psError(PS_ERR_UNKNOWN, false, "database error");
    11051471        }
    1106         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1472        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11071473        return false;
    11081474    }
    … …  
    11851551  }
    11861552
     1553  if (!pxExportVersion(config, f)) {
     1554    psError(PS_ERR_UNKNOWN, false, "failed to write dbversion to output file");
     1555    return false;
     1556  }
     1557
    11871558  psMetadata *where = psMetadataAlloc();
    11881559  PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    … …  
    11961567    psString query = pxDataGet(tables[i].sqlFilename);
    11971568    if (!query) {
    1198       psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1569      psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11991570      return false;
    12001571    }
    … …  
    12541625
    12551626  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
    12561633
    12571634  fprintf (stdout, "---- input ----\n");

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

    r23310 r27839  
    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/simmosaic_branches/ippTools/src/regtoolConfig.c

    r24858 r27839  
    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");
    … …  
    274291    psMetadataAddF64(processedexpArgs,  PS_LIST_TAIL, "-posang_max",    0,            "search by max rotator position angle", NAN);
    275292    psMetadataAddStr(processedexpArgs,  PS_LIST_TAIL, "-object",        0,            "search by exposure object", NULL);
    276     psMetadataAddF32(processedexpArgs,  PS_LIST_TAIL, "-solang_min",    0,            "define min solar angle", NAN);
    277     psMetadataAddF32(processedexpArgs,  PS_LIST_TAIL, "-solang_max",    0,            "define max solar angle", NAN);
     293    psMetadataAddF32(processedexpArgs,  PS_LIST_TAIL, "-sun_angle_min",    0,         "define min solar angle", NAN);
     294    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/simmosaic_branches/ippTools/src/stacktool.c

    r24736 r27839  
    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", "==");
    … …  
    133140    PXOPT_COPY_F32(config->args,  where, "-select_posang_min",         "rawExp.posang", ">=");
    134141    PXOPT_COPY_F32(config->args,  where, "-select_posang_max",         "rawExp.posang", "<=");
    135     PXOPT_COPY_F32(config->args,  where, "-select_solang_min",         "rawExp.solang", ">=");
    136     PXOPT_COPY_F32(config->args,  where, "-select_solang_max",         "rawExp.solang", "<=");
     142    PXOPT_COPY_F32(config->args,  where, "-select_sun_angle_min",      "rawExp.sun_angle", ">=");
     143    PXOPT_COPY_F32(config->args,  where, "-select_sun_angle_max",      "rawExp.sun_angle", "<=");
    137144    PXOPT_COPY_F32(config->args,  where, "-select_fwhm_major_min",     "camProcessedExp.fwhm_major", ">=");
    138145    PXOPT_COPY_F32(config->args,  where, "-select_fwhm_major_max",     "camProcessedExp.fwhm_major", "<=");
    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", "==");
     920    PXOPT_COPY_STR(config->args, where, "-tess_id", "stackRun.tess_id", "==");
     921    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);
    859933
    860934    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    863937    psString query = pxDataGet("stacktool_sumskyfile.sql");
    864938    if (!query) {
    865         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     939        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    866940        return false;
    867941    }
    … …  
    871945        psStringAppend(&query, " WHERE %s", whereClause);
    872946        psFree(whereClause);
    873     }
     947    } else if (!all) {
     948        psError(PXTOOLS_ERR_CONFIG, true, "search parameters or -all are required");
     949        return false;
     950    }
     951
    874952    psFree(where);
    875953
    … …  
    9281006    psMetadata *where = psMetadataAlloc();
    9291007    PXOPT_COPY_S64(config->args, where, "-stack_id", "stackSumSkyfile.stack_id", "==");
    930     PXOPT_COPY_STR(config->args, where, "-label", "stackRun.label", "==");
     1008    pxAddLabelSearchArgs(config, where, "-label", "stackRun.label", "==");
    9311009    PXOPT_COPY_S16(config->args, where, "-fault", "stackSumSkyfile.fault", "==");
    9321010
    933     if (!psDBTransaction(config->dbh)) {
    934         psError(PS_ERR_UNKNOWN, false, "database error");
     1011    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    9351012        psFree(where);
    936         return false;
    937     }
    938 
    939     int numStacks;                      // Number of stacks affected
    940 
    941     // Update state to 'new'
    942     {
    943         psString update = pxDataGet("stacktool_revertsumskyfile_update.sql");
    944         if (!update) {
    945             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    946             if (!psDBRollback(config->dbh)) {
    947                 psError(PS_ERR_UNKNOWN, false, "database error");
    948             }
    949             return false;
    950         }
    951 
    952         if (psListLength(where->list)) {
    953             psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    954             psStringAppend(&update, " AND %s", whereClause);
    955             psFree(whereClause);
    956         }
    957 
    958         if (!p_psDBRunQuery(config->dbh, update)) {
    959             psError(PS_ERR_UNKNOWN, false, "database error");
    960             psFree(update);
    961             psFree(where);
    962             if (!psDBRollback(config->dbh)) {
    963                 psError(PS_ERR_UNKNOWN, false, "database error");
    964             }
    965             return false;
    966         }
    967         psFree(update);
    968 
    969         numStacks = psDBAffectedRows(config->dbh);
    970 
    971         if (numStacks < 1) {
    972             psError(PS_ERR_UNKNOWN, false, "should have affected atleast 1 row");
    973             if (!psDBRollback(config->dbh)) {
    974                 psError(PS_ERR_UNKNOWN, false, "database error");
    975             }
    976             return false;
    977         }
     1013        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     1014        return false;
    9781015    }
    9791016
    9801017    // Delete product
    981     {
    982         psString delete = pxDataGet("stacktool_revertsumskyfile_delete.sql");
    983         if (!delete) {
    984             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    985             if (!psDBRollback(config->dbh)) {
    986                 psError(PS_ERR_UNKNOWN, false, "database error");
    987             }
    988             return false;
    989         }
    990 
    991         if (psListLength(where->list)) {
    992             psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    993             psStringAppend(&delete, " AND %s", whereClause);
    994             psFree(whereClause);
    995         }
    996 
    997         if (!p_psDBRunQuery(config->dbh, delete)) {
    998             psError(PS_ERR_UNKNOWN, false, "database error");
    999             psFree(delete);
    1000             psFree(where);
    1001             if (!psDBRollback(config->dbh)) {
    1002                 psError(PS_ERR_UNKNOWN, false, "database error");
    1003             }
    1004             return false;
    1005         }
     1018    psString delete = pxDataGet("stacktool_revertsumskyfile_delete.sql");
     1019    if (!delete) {
     1020        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1021        return false;
     1022    }
     1023
     1024    if (psListLength(where->list)) {
     1025        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1026        psStringAppend(&delete, " AND %s", whereClause);
     1027        psFree(whereClause);
     1028    }
     1029
     1030    if (!p_psDBRunQuery(config->dbh, delete)) {
     1031        psError(PS_ERR_UNKNOWN, false, "database error");
    10061032        psFree(delete);
    1007 
    1008         if (psDBAffectedRows(config->dbh) != numStacks) {
    1009             psError(PS_ERR_UNKNOWN, true, "Updated and deleted different number of entries!");
    1010             psFree(where);
    1011             if (!psDBRollback(config->dbh)) {
    1012                 psError(PS_ERR_UNKNOWN, false, "database error");
    1013             }
    1014             return false;
    1015         }
    1016 
    1017     }
    1018 
    1019     if (!psDBCommit(config->dbh)) {
    1020         psError(PS_ERR_UNKNOWN, false, "database error");
    1021         return false;
    1022     }
     1033        psFree(where);
     1034        return false;
     1035    }
     1036    psFree(delete);
     1037
     1038    int numRows = psDBAffectedRows(config->dbh); // Number of row affected
     1039    psLogMsg("stacktool", PS_LOG_INFO, "Deleted %d rows", numRows);
    10231040
    10241041    psFree(where);
    … …  
    10481065}
    10491066
     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
    10501089static bool pendingcleanuprunMode(pxConfig *config)
    10511090{
    … …  
    10601099    psString query = pxDataGet("stacktool_pendingcleanuprun.sql");
    10611100    if (!query) {
    1062         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1101        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10631102        return false;
    10641103    }
    … …  
    11241163    psString query = pxDataGet("stacktool_pendingcleanupskyfile.sql");
    11251164    if (!query) {
    1126         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1165        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11271166        return false;
    11281167    }
    … …  
    11851224    psString query = pxDataGet("stacktool_donecleanup.sql");
    11861225    if (!query) {
    1187         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1226        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11881227        return false;
    11891228    }
    … …  
    12731312  }
    12741313
     1314  if (!pxExportVersion(config, f)) {
     1315    psError(PS_ERR_UNKNOWN, false, "failed to write dbversion output file");
     1316    return false;
     1317  }
    12751318  psMetadata *where = psMetadataAlloc();
    12761319  PXOPT_COPY_S64(config->args, where, "-stack_id", "stack_id", "==");
    … …  
    12851328    psString query = pxDataGet(tables[i].sqlFilename);
    12861329    if (!query) {
    1287       psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1330      psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    12881331      return false;
    12891332    }
    … …  
    13591402  psMetadata *input = psMetadataConfigRead (NULL, &nFail, infile, false);
    13601403
    1361   fprintf (stdout, "---- input ----\n");
     1404#ifdef notdef
     1405  fprintf (stderr, "---- input ----\n");
    13621406  psMetadataPrint (stderr, input, 1);
    1363 
     1407#endif
     1408
     1409  if (!pxCheckImportVersion(config, input)) {
     1410      psError(PS_ERR_UNKNOWN, false, "pxCheckImportVersion failed");
     1411      return false;
     1412  }
    13641413  psMetadataItem *item = psMetadataLookup (input, "stackRun");
    13651414  psAssert (item, "entry not in input?");

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

    r24664 r27839  
    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);
    … …  
    7176    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_posang_min", 0, "define min rotator position angle", NAN);
    7277    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_posang_max", 0, "define max rotator position angle", NAN);
    73     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_solang_min", 0, "define min solar angle", NAN);
    74     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_solang_max", 0, "define max solar angle", NAN);
     78    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_sun_angle_min", 0, "define min solar angle", NAN);
     79    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_sun_angle_max", 0, "define max solar angle", NAN);
    7580    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_fwhm_major_min", 0, "define min fwhm (major axis)", NAN);
    7681    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_fwhm_major_max", 0, "define max fwhm (major axis)", NAN);
    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);
     176    psMetadataAddStr(sumskyfileArgs, PS_LIST_TAIL, "-tess_id", 0,            "search by tess ID", 0);
     177    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.
    160180    psMetadataAddS64(sumskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warp ID", 0);
    161181    psMetadataAddS64(sumskyfileArgs, PS_LIST_TAIL, "-exp_id", 0,            "search by exposure ID", 0);
    162182    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);
    163188    psMetadataAddU64(sumskyfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    164189    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);
    165191
    166192    // -revertsumskyfile
    167193    psMetadata *revertsumskyfileArgs= psMetadataAlloc();
    168194    psMetadataAddS64(revertsumskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,            "search by stack ID", 0);
    169     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);
    170196    psMetadataAddS16(revertsumskyfileArgs, PS_LIST_TAIL, "-fault",  0,            "search by fault code", 0);
     197    psMetadataAddBool(revertsumskyfileArgs, PS_LIST_TAIL, "-all",  0, "allow no search terms", 0);
    171198
    172199    // -pendingcleanuprun

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

    r24733 r27839  
    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) {
    … …  
    234248    PXOPT_COPY_F64(config->args,   where, "-posang_max",         "rawExp.posang",         "<");
    235249    PXOPT_COPY_STR(config->args,   where, "-object",             "rawExp.object",         "==");
    236     PXOPT_COPY_F32(config->args,   where, "-solang_min",         "rawExp.solang",         ">=");
    237     PXOPT_COPY_F32(config->args,   where, "-solang_max",         "rawExp.solang",         "<");
     250    PXOPT_COPY_F32(config->args,   where, "-sun_angle_min",      "rawExp.sun_angle",      ">=");
     251    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    }
    … …  
    11901212    PXOPT_COPY_S64(config->args, where, "-warp_id",    "warpSkyfile.warp_id", "==");
    11911213    PXOPT_COPY_STR(config->args, where, "-skycell_id", "warpSkyfile.skycell_id", "==");
     1214    PXOPT_COPY_S64(config->args, where, "-warp_skyfile_id", "warpImfile.warp_skyfile_id", "==");
     1215    PXOPT_COPY_STR(config->args, where, "-skycell_id", "warpSkyfile.skycell_id", "==");
    11921216    PXOPT_COPY_STR(config->args, where, "-tess_id",    "warpSkyfile.tess_id", "==");
    11931217    PXOPT_COPY_S64(config->args, where, "-exp_id",     "rawExp.exp_id", "==");
    11941218    PXOPT_COPY_STR(config->args, where, "-exp_name",   "rawExp.exp_name", "==");
    11951219    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);
    11961228
    11971229    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    12011233    psString query = pxDataGet("warptool_warped.sql");
    12021234    if (!query) {
    1203         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");
    12041248        return false;
    12051249    }
    … …  
    12071251    if (psListLength(where->list)) {
    12081252        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    1209         psStringAppend(&query, " AND %s", whereClause);
     1253        psStringAppend(&query, " WHERE %s", whereClause);
    12101254        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        }
    12111266    }
    12121267    psFree(where);
    … …  
    12701325    PXOPT_COPY_STR(config->args, where, "-tess_id",    "warpSkyfile.tess_id", "==");
    12711326    PXOPT_COPY_STR(config->args, where, "-reduction",  "rawExp.reduction", "==");
    1272     // PXOPT_COPY_STR(config->args, where, "-label",      "warpRun.label", "==");
    12731327    pxAddLabelSearchArgs (config, where, "-label",     "warpRun.label", "==");
    1274     PXOPT_COPY_S16(config->args, where, "-fault",       "warpSkyfile.fault", "==");
     1328    PXOPT_COPY_S16(config->args, where, "-fault",      "warpSkyfile.fault", "==");
    12751329
    12761330    if (!psListLength(where->list)
    12771331        && !psMetadataLookupBool(NULL, config->args, "-all")) {
    12781332        psFree(where);
    1279         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
    1280         return false;
    1281     }
    1282 
    1283     if (!psDBTransaction(config->dbh)) {
    1284         psError(PS_ERR_UNKNOWN, false, "database error");
    1285         psFree(where);
    1286         return false;
    1287     }
    1288 
    1289     // Delete product
    1290     int numDeleted;                     // Number deleted
    1291     {
    1292         psString query = pxDataGet("warptool_revertwarped_delete.sql");
    1293         if (!query) {
    1294             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1295             if (!psDBRollback(config->dbh)) {
    1296                 psError(PS_ERR_UNKNOWN, false, "database error");
    1297             }
    1298             return false;
    1299         }
    1300 
    1301         if (psListLength(where->list)) {
    1302             psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    1303             psStringAppend(&query, " AND %s", whereClause);
    1304             psFree(whereClause);
    1305         }
    1306 
    1307         if (!p_psDBRunQuery(config->dbh, query)) {
    1308             psError(PS_ERR_UNKNOWN, false, "database error");
    1309             psFree(query);
    1310             if (!psDBRollback(config->dbh)) {
    1311                 psError(PS_ERR_UNKNOWN, false, "database error");
    1312             }
    1313             return false;
    1314         }
     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");
    13151358        psFree(query);
    1316 
    1317         numDeleted = psDBAffectedRows(config->dbh);
    1318     }
     1359        return false;
     1360    }
     1361    psFree(query);
     1362
     1363    int numDeleted = psDBAffectedRows(config->dbh);
    13191364
    13201365    psLogMsg("warptool", PS_LOG_INFO, "Deleted %d warpSkyfiles", numDeleted);
    13211366
    1322     psFree(where);
    1323 
    1324     if (!psDBCommit(config->dbh)) {
    1325         psError(PS_ERR_UNKNOWN, false, "database error");
    1326         return false;
    1327     }
     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);
    13281379
    13291380    return true;
    … …  
    14121463    psString query = pxDataGet("warptool_pendingcleanuprun.sql");
    14131464    if (!query) {
    1414         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1465        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    14151466        return false;
    14161467    }
    … …  
    14751526    psString query = pxDataGet("warptool_pendingcleanupskyfile.sql");
    14761527    if (!query) {
    1477         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1528        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    14781529        return false;
    14791530    }
    … …  
    15361587    psString query = pxDataGet("warptool_donecleanup.sql");
    15371588    if (!query) {
    1538         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1589        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    15391590        return false;
    15401591    }
    … …  
    16241675    }
    16251676
    1626     // note only updates if warpRun.state = run_state
    1627     // XXX note that we have removed this constraint for now
    1628     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)) {
    16291693        psError(PS_ERR_UNKNOWN, false, "database error");
    16301694        // rollback
    … …  
    16361700    }
    16371701    psFree(query);
     1702    psFree(set_magicked_skyfile);
    16381703
    16391704    query = pxDataGet("warptool_change_run_state.sql");
    1640     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)) {
    16411706        // rollback
    16421707        if (!psDBRollback(config->dbh)) {
    … …  
    16461711        return false;
    16471712    }
     1713    psFree(set_magicked_run);
    16481714
    16491715    if (!psDBCommit(config->dbh)) {
    … …  
    16651731{
    16661732    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");
    16671737}
    16681738
    … …  
    16751745    PXOPT_LOOKUP_STR(skycell_id, config->args, "-skycell_id", true, false);
    16761746    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
    1677 
    1678     psString query = pxDataGet("warptool_updateskyfile.sql");
    1679 
    1680     if (!p_psDBRunQueryF(config->dbh, query, fault, warp_id, skycell_id)) {
    1681         psError(PS_ERR_UNKNOWN, false, "database error");
    1682         return false;
    1683     }
    1684     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    }
    16851773
    16861774    return true;
    … …  
    17071795    }
    17081796
     1797    if (!pxExportVersion(config, f)) {
     1798        psError(PS_ERR_UNKNOWN, false, "failed to write dbversion output file");
     1799        return false;
     1800    }
    17091801    psMetadata *where = psMetadataAlloc();
    17101802    PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
    … …  
    17221814      psString query = pxDataGet(tables[i].sqlFilename);
    17231815      if (!query) {
    1724           psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1816          psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    17251817          return false;
    17261818      }
    … …  
    17991891  psMetadata *input = psMetadataConfigRead (NULL, &nFail, infile, false);
    18001892
    1801   fprintf (stdout, "---- input ----\n");
     1893#ifdef notdef
     1894  fprintf (stderr, "---- input ----\n");
    18021895  psMetadataPrint (stderr, input, 1);
     1896#endif
     1897
     1898  if (!pxCheckImportVersion(config, input)) {
     1899      psError(PS_ERR_UNKNOWN, false, "pxCheckImportVersion failed");
     1900      return false;
     1901  }
    18031902
    18041903  psMetadataItem *item = psMetadataLookup (input, "warpRun");
    … …  
    18631962  return true;
    18641963}
     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/simmosaic_branches/ippTools/src/warptool.h

    r24426 r27839  
    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/simmosaic_branches/ippTools/src/warptoolConfig.c

    r24733 r27839  
    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;
    … …  
    8989    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-posang_max",         0, "search by max rotator position angle", NAN);
    9090    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-object",             0, "search by exposure object", NULL);
    91     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-solang_min",         0, "search by min solar angle", NAN);
    92     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-solang_max",         0, "search by max solar angle", NAN);
     91    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-sun_angle_min",         0, "search by min solar angle", NAN);
     92    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-sun_angle_max",         0, "search by max solar angle", NAN);
    9393    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-reduction",          0, "search by fakeRun reduction class", NULL);
    9494    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search on fakeRun label", 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);
    … …  
    208223    // -warped
    209224    psMetadata *warpedArgs = psMetadataAlloc();
    210     psMetadataAddS64(warpedArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warptool ID", 0);
    211     psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-skycell_id",  0,            "define skycell ID", NULL);
    212     psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-tess_id",  0,            "define tessellation ID", NULL);
    213     psMetadataAddS64(warpedArgs, PS_LIST_TAIL, "-exp_id", 0,            "define exposure tag", 0);
    214     psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-exp_name", 0,          "define exposure tag", 0);
    215     psMetadataAddS64(warpedArgs, PS_LIST_TAIL, "-fake_id", 0,            "define phase 3 version of exposure tag", 0);
     225    psMetadataAddS64(warpedArgs, PS_LIST_TAIL, "-warp_id", 0,           "search by warptool ID", 0);
     226    psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-skycell_id",  0,       "search by skycell ID", NULL);
     227    psMetadataAddS64(warpedArgs, PS_LIST_TAIL, "-warp_skyfile_id", 0,   "search by skyfile ID", 0);
     228    psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-tess_id",  0,          "search by tessellation ID", NULL);
     229    psMetadataAddS64(warpedArgs, PS_LIST_TAIL, "-exp_id", 0,            "search by exposure tag", 0);
     230    psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-exp_name", 0,          "search by exposure tag", 0);
     231    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);
    216245    psMetadataAddU64(warpedArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    217     psMetadataAddBool(warpedArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     246    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);
    218273
    219274    // -revertwarped
    … …  
    278333    psMetadataAddStr(topurgedskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0, "skycell ID to update", NULL);
    279334
     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
    280340    // -tofullskyfile
    281341    psMetadata *tofullskyfileArgs = psMetadataAlloc();
    282342    psMetadataAddS64(tofullskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,    "warptool ID to update", 0);
    283343    psMetadataAddStr(tofullskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0, "skycell ID to update", NULL);
    284 
    285     // -toupdateskyfile
     344    psMetadataAddS64(tofullskyfileArgs, PS_LIST_TAIL, "-set_magicked",  0, "new value for magicked", 0);
     345
     346    // -updateskyfile
    286347    psMetadata *updateskyfileArgs = psMetadataAlloc();
    287348    psMetadataAddS64(updateskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,    "warptool ID to update", 0);
    288349    psMetadataAddStr(updateskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0, "skycell ID to update", NULL);
    289350    psMetadataAddS16(updateskyfileArgs, PS_LIST_TAIL, "-fault",  0,      "new fault code", 0);
     351    psMetadataAddStr(updateskyfileArgs, PS_LIST_TAIL, "-set_state", 0,   "set state", 0);
    290352
    291353    // -exportrun
    … …  
    299361    psMetadata *importrunArgs = psMetadataAlloc();
    300362    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);
    301381
    302382
    … …  
    318398    PXOPT_ADD_MODE("-advancerun",      "", WARPTOOL_MODE_ADVANCERUN,     advancerunArgs);
    319399    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);
    320402    PXOPT_ADD_MODE("-revertwarped",    "", WARPTOOL_MODE_REVERTWARPED,   revertwarpedArgs);
    321403    PXOPT_ADD_MODE("-block",                 "set a label block",                    WARPTOOL_MODE_BLOCK,          blockArgs);
    … …  
    327409    PXOPT_ADD_MODE("-tocleanedskyfile", "set skyfile as cleaned", WARPTOOL_MODE_TOCLEANEDSKYFILE, tocleanedskyfileArgs);
    328410    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);
    329412    PXOPT_ADD_MODE("-tofullskyfile", "set skyfile as full (updated)", WARPTOOL_MODE_TOFULLSKYFILE, tofullskyfileArgs);
    330413    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);
    331415    PXOPT_ADD_MODE("-exportrun",            "export run for import on other database", WARPTOOL_MODE_EXPORTRUN, exportrunArgs);
    332416    PXOPT_ADD_MODE("-importrun",            "import run from metadata file",           WARPTOOL_MODE_IMPORTRUN, importrunArgs);
Note: See TracChangeset for help on using the changeset viewer.