IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

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

updates from trunk

Location:
branches/tap_branches
Files:
72 edited
8 copied

Legend:

Unmodified
Added
Removed

  • branches/tap_branches

  • branches/tap_branches/ippTools/src

    • Property svn:ignore

      •  

        old new  
        1616difftool
        1717disttool
         18dqstatstool
        1819faketool
        1920flatcorr

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

    r25773 r27838  
    99        disttool \
    1010        flatcorr \
     11        dqstatstool \
    1112        magictool \
    1213        magicdstool \
    … …  
    3233        pxdata.h \
    3334        pxfake.h \
     35        pxdqstats.h
    3436        pxmagic.h \
    3537        pxregister.h \
    … …  
    5254        flatcorr.h \
    5355        faketool.h \
     56        dqstatstool.h \
    5457        magictool.h \
    5558        magicdstool.h \
    … …  
    7780        pxfake.c \
    7881        pxfault.c \
     82        pxdqstats.c \
    7983        pxmagic.c \
    8084        pxregister.c \
    … …  
    142146    faketool.c \
    143147    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
    144154
    145155magictool_CFLAGS = $(PSLIB_CFLAGS) $(PSMODULES_CFLAGS) $(IPPDB_CFLAGS)

  • branches/tap_branches/ippTools/src/addtool.c

    r25840 r27838  
    9898    pxcamGetSearchArgs (config, where);
    9999    PXOPT_COPY_S64(config->args, where,  "-cam_id",    "camRun.cam_id", "==");
    100     pxAddLabelSearchArgs (config, where, "-label",     "camRun.label", "==");
     100    pxAddLabelSearchArgs (config, where, "-label",     "camRun.label", "=="); // define using camRun label
     101    pxAddLabelSearchArgs (config, where, "-data_group","camRun.data_group", "=="); // define using camRun label
    101102    PXOPT_COPY_STR(config->args, where,  "-reduction", "camRun.reduction", "==");
    102103
    103     if (!psListLength(where->list) &&
    104         !psMetadataLookupBool(NULL, config->args, "-all")) {
     104    if (!psListLength(where->list)) {
    105105        psFree(where);
    106         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     106        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    107107        return false;
    108108    }
    … …  
    115115    PXOPT_LOOKUP_STR(note,        config->args, "-set_note", false, false);
    116116    PXOPT_LOOKUP_BOOL(image_only, config->args, "-image_only", false);
     117    PXOPT_LOOKUP_BOOL(destreaked, config->args, "-destreaked", false);
    117118    PXOPT_LOOKUP_BOOL(pretend,    config->args, "-pretend", false);
    118119    PXOPT_LOOKUP_BOOL(simple,     config->args, "-simple", false);
    119120
    120121    // find the cam_id of all the exposures that we want to queue up.
    121     psString query = pxDataGet("addtool_find_cam_id.sql");
    122     if (!query) {
    123         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     122    psString bare_query = pxDataGet("addtool_find_cam_id.sql");
     123    if (!bare_query) {
     124        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    124125        psFree(where);
    125126        return false;
    126127    }
     128
     129    // prevent queueing an addRun if a given exposure has already been added to
     130    // the given dvo database
     131    psString dvodb_string = NULL;
     132    if (dvodb) {
     133        // user supplied dvodb
     134        psStringAppend(&dvodb_string, "(previous_dvodb = '%s')", dvodb);
     135    } else {
     136        // inherit dvodb from camRun, avoid matching NULL
     137        psStringAppend(&dvodb_string, "(camRun.dvodb IS NOT NULL AND previous_dvodb = camRun.dvodb)");
     138    }
     139    // Take the bare query and add the dvodb selector
     140    psString query = NULL;
     141    psStringAppend(&query, bare_query, dvodb_string);
     142    psFree(dvodb_string);
     143    psFree(bare_query);
    127144
    128145    // use psDBGenerateWhereConditionSQL because the SQL ends in a WHERE
    … …  
    131148        psStringAppend(&query, " AND %s", whereClause);
    132149        psFree(whereClause);
     150    } else {
     151        psError(PS_ERR_UNKNOWN, true, "search parameters are required");
     152        return false;
    133153    }
    134154    psFree(where);
     155
     156    if (destreaked) {
     157        psStringAppend(&query, " AND (camRun.magicked > 0)");
     158    }
    135159
    136160    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    214238        // queue the exp
    215239        if (!pxaddQueueByCamID(config,
    216                                row->cam_id,
    217                                workdir     ? workdir   : row->workdir,
    218                                reduction   ? reduction : row->reduction,
    219                                label       ? label     : row->label,
    220                                data_group  ? data_group : (label ? label : row->label),
    221                                dvodb       ? dvodb     : row->dvodb,
     240                               row->cam_id,
     241                               workdir     ? workdir   : row->workdir,
     242                               reduction   ? reduction : row->reduction,
     243                               label       ? label     : row->label,
     244                               data_group  ? data_group : (row->data_group ? row->data_group :  (label ? label : row->label)),
     245                               dvodb       ? dvodb     : row->dvodb,
    222246                               note        ? note      : NULL,
    223                                image_only
     247                               image_only
    224248        )) {
    225249            if (!psDBRollback(config->dbh)) {
    … …  
    256280    PXOPT_COPY_STR(config->args, where, "-state",     "addRun.state", "==");
    257281    PXOPT_COPY_STR(config->args, where, "-reduction", "addRun.reduction", "==");
     282    PXOPT_COPY_STR(config->args, where, "-dvodb", "addRun.dvodb", "==");
    258283
    259284    if (!psListLength(where->list)) {
    260285        psFree(where);
    261         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     286        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    262287        return false;
    263288    }
    … …  
    266291
    267292    // pxUpdateRun gets parameters from config->args and runs the update query
    268     bool result = pxUpdateRun(config, where, &query, "addRun", false);
     293    bool result = pxUpdateRun(config, where, &query, "addRun", "add_id",
     294        "addProcessedExp", false);
    269295
    270296    psFree(query);
    … …  
    272298
    273299    return result;
    274 
    275 
    276 #ifdef notdef
    277     PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
    278     PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
    279 
    280     if ((!state) && (!label)) {
    281         psError(PXTOOLS_ERR_DATA, false, "parameters are required");
    282         psFree(where);
    283         return false;
    284     }
    285 
    286     if (state) {
    287         // set addRun.state to state
    288         if (!pxaddRunSetStateByQuery(config, where, state)) {
    289             psFree(where);
    290             return false;
    291         }
    292     }
    293 
    294     if (label) {
    295         // set addRun.label to label
    296         if (!pxaddRunSetLabelByQuery(config, where, label)) {
    297             psFree(where);
    298             return false;
    299         }
    300     }
    301 
    302     psFree(where);
    303 
    304     return true;
    305 #endif
    306300}
    307301
    … …  
    322316    psString query = pxDataGet("addtool_find_pendingexp.sql");
    323317    if (!query) {
    324         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     318        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    325319        return false;
    326320    }
    … …  
    388382    psString query = pxDataGet("addtool_find_pendingexp.sql");
    389383    if (!query) {
    390         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     384        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    391385        return false;
    392386    }
    … …  
    430424        dtime_addstar,
    431425        path_base,
    432         fault
     426        fault
    433427        );
    434428
    … …  
    482476        !psMetadataLookupBool(NULL, config->args, "-all")) {
    483477        psFree(where);
    484         psError(PXTOOLS_ERR_DATA, false, "search parameters (or -all) are required");
     478        psError(PXTOOLS_ERR_CONFIG, false, "search parameters (or -all) are required");
    485479        return false;
    486480    }
    … …  
    488482    psString query = pxDataGet("addtool_find_processedexp.sql");
    489483    if (!query) {
    490         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     484        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    491485        return false;
    492486    }
    … …  
    496490        psStringAppend(&query, " WHERE %s", whereClause);
    497491        psFree(whereClause);
    498     } 
     492    }
    499493
    500494    // we either add AND (condition) or WHERE (condition):
    … …  
    502496        // list only faulted rows
    503497        psStringAppend(&query, " %s", " AND addProcessedExp.fault != 0");
    504     } 
     498    }
    505499    if (where->list && !faulted) {
    506500        // don't list faulted rows
    … …  
    510504        // list only faulted rows
    511505        psStringAppend(&query, " %s", " WHERE addProcessedExp.fault != 0");
    512     } 
     506    }
    513507    if (!where->list && !faulted) {
    514508        // don't list faulted rows
    … …  
    571565    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    572566        psFree(where);
    573         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     567        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    574568        return false;
    575569    }
    … …  
    584578        psString query = pxDataGet("addtool_reset_faulted_runs.sql");
    585579        if (!query) {
    586             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     580            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    587581            psFree(where);
    588582            return false;
    … …  
    616610                psError(PS_ERR_UNKNOWN, false, "database error");
    617611            }
    618             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     612            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    619613            psFree(where);
    620614            return false;

  • branches/tap_branches/ippTools/src/addtoolConfig.c

    r25835 r27838  
    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;
    … …  
    5252    pxcamSetSearchArgs(definebyqueryArgs);
    5353    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by camRun label", NULL);
     54    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-data_group", PS_META_DUPLICATE_OK, "search by camRun data_group", NULL);
    5455    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-reduction",          0, "search by camRun reduction class", NULL);
     56    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-destreaked",           0, "only queue destreaked runs", false);
    5557
    5658    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_workdir",        0, "define workdir", NULL);
    … …  
    6567    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_dist_group", 0,   "define new dist_group", NULL);
    6668    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_note", 0,         "define new note", NULL);
    67     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-all",               0, "allow everything to be queued without search terms", false);
    6869
    6970    // -updaterun
    … …  
    7273    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-cam_id",                 0, "search by cam_id", 0);
    7374    pxcamSetSearchArgs(updaterunArgs);
    74     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label",                  0, "search by addRun label", NULL);
    75     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state",                  0, "search by addRun state", NULL);
     75    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label",                  0, "search by addRun label", NULL);
     76    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state",                  0, "search by addRun state", NULL);
    7677    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-reduction",              0, "search by addRun reduction class", NULL);
     78    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-dvodb",                  0, "search by dvodb", NULL);
    7779    psMetadataAddBool(updaterunArgs, PS_LIST_TAIL, "-all",                   0, "allow everything to be queued without search terms", false);
    7880    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state",              0, "set state", NULL);
    7981    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_label",              0, "set label", NULL);
     82    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_dvodb",              0, "set dvodb", NULL);
    8083    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_data_group", 0,   "define new data_group", NULL);
    8184    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_dist_group", 0,   "define new dist_group", NULL);

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

    r18561 r27838  
    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/tap_branches/ippTools/src/camtool.c

    r25851 r27838  
    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    }
    … …  
    133133    psString query = pxDataGet("camtool_find_chip_id.sql");
    134134    if (!query) {
    135         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     135        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    136136        psFree(where);
    137137        return false;
    … …  
    184184        bool status;
    185185        char *end_stage = psMetadataLookupStr(&status, md, "end_stage");
    186         if (end_stage && strcasecmp(end_stage, "warp")) continue;
     186        if (end_stage && strcasecmp(end_stage, "warp")) continue;
    187187
    188188        char *raw_tess_id   = psMetadataLookupStr(&status, md, "tess_id");
    189         if (raw_tess_id || tess_id) continue;
     189        if (raw_tess_id || tess_id) continue;
    190190
    191191        char *label  = psMetadataLookupStr(&status, md, "label");
    … …  
    193193
    194194        if (!status) {
    195             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);
    196196            psFree(output);
    197197            return false;
    … …  
    199199    }
    200200
    201     // loop over our list of camRun rows
     201    // loop over our list of chipRun rows
    202202    for (long i = 0; i < psArrayLength(output); i++) {
    203203        psMetadata *md = output->data[i];
    204204
    205         camRunRow *row = camRunObjectFromMetadata(md);
     205        chipRunRow *row = chipRunObjectFromMetadata(md);
    206206        if (!row) {
    207             psError(PS_ERR_UNKNOWN, false, "failed to convert metadata into camRun");
     207            psError(PS_ERR_UNKNOWN, false, "failed to convert metadata into chipRun");
    208208            psFree(output);
    209209            return false;
    … …  
    222222                    tess_id     ? tess_id   : row->tess_id,
    223223                    end_stage   ? end_stage : row->end_stage,
     224                    row->magicked,
    224225                    note
    225226        )) {
    … …  
    254255    PXOPT_COPY_S64(config->args, where, "-cam_id",    "camRun.cam_id", "==");
    255256    PXOPT_COPY_STR(config->args, where, "-label",     "camRun.label", "==");
     257    PXOPT_COPY_STR(config->args, where, "-data_group","camRun.data_group", "==");
    256258    PXOPT_COPY_STR(config->args, where, "-state",     "camRun.state", "==");
    257259    PXOPT_COPY_STR(config->args, where, "-reduction", "camRun.reduction", "==");
    … …  
    259261    if (!psListLength(where->list)) {
    260262        psFree(where);
    261         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     263        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    262264        return false;
    263265    }
    … …  
    265267
    266268    // pxUpdateRun gets parameters from config->args and updates
    267     bool result = pxUpdateRun(config, where, &query, "camRun", true);
     269    bool result = pxUpdateRun(config, where, &query, "camRun", "cam_id", "camProcessedExp", true);
    268270    if (!result) {
    269         psError(PXTOOLS_ERR_DATA, false, "pxUpdateRun failed");
     271        psError(psErrorCodeLast(), false, "pxUpdateRun failed");
    270272    }
    271273
    … …  
    292294    psString query = pxDataGet("camtool_find_pendingexp.sql");
    293295    if (!query) {
    294         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     296        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    295297        return false;
    296298    }
    … …  
    357359    psString query = pxDataGet("camtool_find_pendingimfile.sql");
    358360    if (!query) {
    359         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     361        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    360362        return false;
    361363    }
    … …  
    479481    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
    480482    PXOPT_LOOKUP_S16(quality, config->args, "-quality", false, false);
    481    
    482     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);
    483486
    484487    // generate restrictions
    … …  
    488491    psString query = pxDataGet("camtool_find_pendingexp.sql");
    489492    if (!query) {
    490         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     493        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    491494        return false;
    492495    }
    … …  
    523526        return false;
    524527    }
     528
     529    bool status;
     530    psS64 chip_magicked = psMetadataLookupS64(&status, output->data[0], "chip_magicked");
    525531
    526532    camRunRow *pendingRow = camRunObjectFromMetadata(output->data[0]);
    … …  
    603609    }
    604610
    605     // since there is only one exp per 'new' set camRun.state = 'full'
    606     if (!pxcamRunSetState(config, row->cam_id, "full", magicked)) {
    607         psError(PS_ERR_UNKNOWN, false, "failed to change camRun.state for cam_id: %" PRId64, row->cam_id);
    608         psFree(row);
    609         psFree(pendingRow);
    610         return false;
    611     }
    612 
    613     // NULL for end_stage means go as far as possible
    614     // EAM : skip here if fault != 0
    615     // Also, we can run fake even if tess_id is not defined
    616     if (fault || (pendingRow->end_stage && psStrcasestr(pendingRow->end_stage, "cam"))) {
     611    if (fault) {
    617612        psFree(row);
    618613        psFree(pendingRow);
    … …  
    623618        return true;
    624619    }
     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    }
    625630    psFree(row);
    626     // 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    }
    627642
    628643    if (!pxfakeQueueByCamID(config,
    … …  
    666681    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    667682    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
     683    PXOPT_LOOKUP_BOOL(pstamp_order, config->args, "-pstamp_order", false);
    668684
    669685    // generate restrictions
    … …  
    672688    PXOPT_COPY_S64(config->args, where, "-cam_id",    "camRun.cam_id",    "==");
    673689    pxAddLabelSearchArgs (config, where, "-label",    "camRun.label",     "==");
     690    pxAddLabelSearchArgs (config, where, "-data_group", "camRun.data_group",     "LIKE");
    674691    PXOPT_COPY_STR(config->args, where, "-reduction", "camRun.reduction", "==");
    675692
    676     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 &&
    677703        !psMetadataLookupBool(NULL, config->args, "-all")) {
    678704        psFree(where);
    679         psError(PXTOOLS_ERR_DATA, false, "search parameters (or -all) are required");
     705        psError(PXTOOLS_ERR_CONFIG, false, "search parameters (or -all) are required");
    680706        return false;
    681707    }
    … …  
    683709    psString query = pxDataGet("camtool_find_processedexp.sql");
    684710    if (!query) {
    685         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     711        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    686712        return false;
    687713    }
    … …  
    691717        psStringAppend(&query, " WHERE %s", whereClause);
    692718        psFree(whereClause);
    693     } 
     719    }
    694720
    695721    // we either add AND (condition) or WHERE (condition):
    … …  
    697723        // list only faulted rows
    698724        psStringAppend(&query, " %s", " AND camProcessedExp.fault != 0");
    699     } 
     725    }
    700726    if (where->list && !faulted) {
    701727        // don't list faulted rows
    … …  
    705731        // list only faulted rows
    706732        psStringAppend(&query, " %s", " WHERE camProcessedExp.fault != 0");
    707     } 
     733    }
    708734    if (!where->list && !faulted) {
    709735        // don't list faulted rows
    … …  
    711737    }
    712738    psFree(where);
    713 
    714     // order by cam_id so that the postage stamp parser can easliy find the 'latest' astrometry
    715     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    }
    716750
    717751    // treat limit == 0 as "no limit"
    … …  
    766800    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    767801        psFree(where);
    768         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     802        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    769803        return false;
    770804    }
    … …  
    779813        psString query = pxDataGet("camtool_reset_faulted_runs.sql");
    780814        if (!query) {
    781             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     815            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    782816            psFree(where);
    783817            return false;
    … …  
    811845                psError(PS_ERR_UNKNOWN, false, "database error");
    812846            }
    813             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     847            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    814848            psFree(where);
    815849            return false;
    … …  
    951985    psString query = pxDataGet("camtool_pendingcleanuprun.sql");
    952986    if (!query) {
    953         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     987        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    954988        return false;
    955989    }
    … …  
    10161050    psString query = pxDataGet("camtool_pendingcleanupexp.sql");
    10171051    if (!query) {
    1018         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1052        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10191053        return false;
    10201054    }
    … …  
    10771111    psString query = pxDataGet("camtool_donecleanup.sql");
    10781112    if (!query) {
    1079         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1113        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10801114        return false;
    10811115    }
    … …  
    11631197    psString query = pxDataGet(tables[i].sqlFilename);
    11641198    if (!query) {
    1165       psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1199      psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11661200      return false;
    11671201    }

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

    r25835 r27838  
    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;
    … …  
    7373    pxcamSetSearchArgs(updaterunArgs);
    7474    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-cam_id",             0, "search by cam_id", 0);
    75     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label",              0, "search by camRun label", NULL);
    76     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);
    7778    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-reduction",          0, "search by camRun reduction class", NULL);
    7879    psMetadataAddBool(updaterunArgs, PS_LIST_TAIL, "-all",               0, "allow everything to be queued without search terms", false);
    … …  
    178179    psMetadataAddS64(processedexpArgs, PS_LIST_TAIL, "-cam_id",   0,            "search by cam_id", 0);
    179180    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);
    180182    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);
    181187
    182188    psMetadataAddU64(processedexpArgs, PS_LIST_TAIL, "-limit",    0,            "limit result set to N items", 0);

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

    r25851 r27838  
    3636
    3737static bool definebyqueryMode(pxConfig *config);
     38static bool definecopyMode(pxConfig *config);
    3839static bool updaterunMode(pxConfig *config);
    3940static bool pendingimfileMode(pxConfig *config);
    … …  
    5859static bool importrunMode(pxConfig *config);
    5960static bool runstateMode(pxConfig *config);
     61static bool setimfiletoupdateMode(pxConfig *config);
     62static bool listrunMode(pxConfig *config);
    6063
    6164# define MODECASE(caseName, func) \
    … …  
    7780    switch (config->mode) {
    7881        MODECASE(CHIPTOOL_MODE_DEFINEBYQUERY,           definebyqueryMode);
     82        MODECASE(CHIPTOOL_MODE_DEFINECOPY,              definecopyMode);
    7983        MODECASE(CHIPTOOL_MODE_UPDATERUN,               updaterunMode);
    8084        MODECASE(CHIPTOOL_MODE_PENDINGIMFILE,           pendingimfileMode);
    … …  
    9599        MODECASE(CHIPTOOL_MODE_TOFULLIMFILE,            tofullimfileMode);
    96100        MODECASE(CHIPTOOL_MODE_TOPURGEDIMFILE,          topurgedimfileMode);
    97         MODECASE(CHIPTOOL_MODE_TOSCRUBBEDIMFILE,        toscrubbedimfileMode);
     101        MODECASE(CHIPTOOL_MODE_TOSCRUBBEDIMFILE,        toscrubbedimfileMode);
    98102        MODECASE(CHIPTOOL_MODE_EXPORTRUN,               exportrunMode);
    99103        MODECASE(CHIPTOOL_MODE_IMPORTRUN,               importrunMode);
    100104        MODECASE(CHIPTOOL_MODE_RUNSTATE,                runstateMode);
     105        MODECASE(CHIPTOOL_MODE_SETIMFILETOUPDATE,       setimfiletoupdateMode);
     106        MODECASE(CHIPTOOL_MODE_LISTRUN,                 listrunMode);
    101107        default:
    102108            psAbort("invalid option (this should not happen)");
    … …  
    120126}
    121127
     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}
    122240
    123241static bool definebyqueryMode(pxConfig *config)
    … …  
    129247    psMetadata *where = psMetadataAlloc();
    130248    pxchipGetSearchArgs (config, where); // rawExp only
    131     pxAddLabelSearchArgs (config, where, "-label", "newExp.label", "LIKE");
     249    pxAddLabelSearchArgs (config, where, "-label", "newExp.label", "LIKE"); // define using newExp label
    132250
    133251    // psListLength(where->list) is at least 1 because exp_type defaults to "object"
    … …  
    135253    if ((psListLength(where->list) <= 1) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    136254        psFree(where);
    137         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     255        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    138256        return false;
    139257    }
    … …  
    157275    psString query = pxDataGet("chiptool_find_rawexp.sql");
    158276    if (!query) {
    159         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     277        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    160278        psFree(where);
    161279        return false;
    … …  
    197315    }
    198316
    199     // start a transaction so we don't end up with an exp without any associted
    200     // imfiles
    201     if (!psDBTransaction(config->dbh)) {
    202         psError(PS_ERR_UNKNOWN, false, "database error");
    203         psFree(output);
    204         return false;
    205     }
    206 
    207     // if end_stage is warp (or NULL), check for valid tess_id
    208     for (long i = 0; i < psArrayLength(output); i++) {
    209         psMetadata *md = output->data[i];
    210 
    211         bool status;
    212         char *end_stage = psMetadataLookupStr(&status, md, "end_stage");
    213         if (end_stage && strcasecmp(end_stage, "warp")) continue;
    214 
    215         char *raw_tess_id   = psMetadataLookupStr(&status, md, "tess_id");
    216         if (raw_tess_id || tess_id) continue;
    217 
    218         char *label  = psMetadataLookupStr(&status, md, "label");
    219         psS64 exp_id = psMetadataLookupS64(&status, md, "exp_id");
    220 
    221         if (!status) {
    222             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");
    223397            psFree(output);
    224398            return false;
    225399        }
    226     }
    227 
    228 
    229 # define GET_VALUE(PTYPE,CTYPE,VALUE,NAME)                              \
    230     PTYPE VALUE;                                                        \
    231     { bool status;                                                      \
    232         VALUE = psMetadataLookup##CTYPE(&status, md, NAME);             \
    233         if (!status) {                                                  \
    234             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for %s", NAME); \
    235             psFree(output);                                             \
    236             return false;                                               \
    237         } }
    238 
    239     // loop over our list of exp_ids
    240     for (long i = 0; i < psArrayLength(output); i++) {
    241         psMetadata *md = output->data[i];
    242 
    243         rawExpRow *row = rawExpObjectFromMetadata(md);
    244         if (!row) {
    245             psError(PS_ERR_UNKNOWN, false, "failed to convert metadata into chipRun");
    246             psFree(output);
    247             return false;
    248         }
    249 
    250         GET_VALUE (psS64,    S64, exp_id,        "exp_id");
    251         GET_VALUE (psString, Str, raw_workdir,   "workdir");
    252         GET_VALUE (psString, Str, raw_label,     "label");
    253         GET_VALUE (psString, Str, raw_reduction, "reduction");
    254         // GET_VALUE (psString, Str, raw_expgroup,  "expgroup");
    255         GET_VALUE (psString, Str, raw_dvodb,     "dvodb");
    256         GET_VALUE (psString, Str, raw_tess_id,   "tess_id");
    257         GET_VALUE (psString, Str, raw_end_stage, "end_stage");
    258 
    259         if (!row->exp_id) {
    260             psError(PS_ERR_UNKNOWN, false, "failed to find value for exp_id");
    261             psFree(output);
    262             return false;
    263         }
    264 
    265         // queue the exp
    266         if (!pxchipQueueByExpTag(config,
    267                                  exp_id,
    268                                  workdir     ? workdir   : raw_workdir,
    269                                  label       ? label     : raw_label,
    270                                  data_group  ? data_group : (label ? label : raw_label),
    271                                  dist_group,
    272                                  reduction   ? reduction : raw_reduction,
    273                                  // expgroup    ? expgroup  : raw_expgroup,
    274                                  // XXX how does expgroup get defined?
    275                                  expgroup,
    276                                  dvodb       ? dvodb     : raw_dvodb,
    277                                  tess_id     ? tess_id   : raw_tess_id,
    278                                  end_stage   ? end_stage : raw_end_stage,
    279                                  note
    280                                  )) {
    281             if (!psDBRollback(config->dbh)) {
    282                 psError(PS_ERR_UNKNOWN, false, "database error");
    283             }
    284             psError(PS_ERR_UNKNOWN, false,
    285                     "failed to trying to queue exp_id: %" PRId64, exp_id);
    286             psFree(output);
    287             return false;
    288         }
     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;
    289409    }
    290410    psFree(output);
    291 
    292     if (!psDBCommit(config->dbh)) {
    293         psError(PS_ERR_UNKNOWN, false, "database error");
    294         return false;
    295     }
    296411
    297412    return true;
    … …  
    314429    if (!psListLength(where->list)) {
    315430        psFree(where);
    316         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
    317         return false;
    318     }
    319     psString query = psStringCopy("UPDATE chipRun JOIN rawExp USING(exp_id)");
     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");
    320435
    321436    // pxUpdateRun gets parameters from config->args and updates
    322     bool result = pxUpdateRun(config, where, &query, "chipRun", true);
     437    bool result = pxUpdateRun(config, where, &query, "chipRun", "chip_id", "chipProcessedImfile", true);
    323438    if (!result) {
    324         psError(PXTOOLS_ERR_DATA, false, "pxUpdateRun failed");
     439        psError(psErrorCodeLast(), false, "pxUpdateRun failed");
    325440    }
    326441
    … …  
    346461    psString query = pxDataGet("chiptool_pendingimfile.sql");
    347462    if (!query) {
    348         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     463        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    349464        return false;
    350465    }
    … …  
    586701    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    587702    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
     703    PXOPT_LOOKUP_BOOL(allfiles, config->args, "-allfiles", false);
     704    if (allfiles) {
     705        faulted = false;
     706    }
    588707
    589708    psMetadata *where = psMetadataAlloc();
    … …  
    594713    PXOPT_COPY_STR(config->args, where, "-reduction", "chipRun.reduction", "==");
    595714    pxAddLabelSearchArgs (config, where, "-label", "chipRun.label", "LIKE");
     715    pxAddLabelSearchArgs (config, where, "-data_group", "chipRun.data_group", "LIKE");
    596716    PXOPT_COPY_S64(config->args, where, "-magicked", "chipProcessedImfile.magicked", "==");
    597717
    … …  
    600720    // add cuts on ra and decl if supplied
    601721    if (!pxspaceAddWhere(config, &where2, "rawExp")) {
    602         psError(PXTOOLS_ERR_DATA, false, "pxSpaceAddWhere failed");
     722        psError(psErrorCodeLast(), false, "pxSpaceAddWhere failed");
    603723        return false;
    604724    }
    … …  
    606726    psString query = pxDataGet("chiptool_processedimfile.sql");
    607727    if (!query) {
    608         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     728        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    609729        return false;
    610730    }
    … …  
    612732    if (psListLength(where->list)) {
    613733        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    614         psStringAppend(&query, " WHERE %s", whereClause);
     734        psStringAppend(&query, " WHERE %s %s", whereClause, where2 ? where2 : "");
    615735        psFree(whereClause);
    616736    } else if (psMetadataLookupBool(NULL, config->args, "-all") || (faulted || where2)) {
    … …  
    618738    } else {
    619739        psFree(where);
    620         psError(PXTOOLS_ERR_DATA, false, "search parameters (or -all) are required");
     740        psError(PXTOOLS_ERR_CONFIG, false, "search parameters (or -all) are required");
    621741        return false;
    622742    }
    … …  
    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;
    … …  
    720853    PXOPT_COPY_STR(config->args, where, "-class_id", "class_id", "==");
    721854    PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, NULL);
    722        
     855    if (psListLength(where->list) == 0) {
     856        psError(PS_ERR_UNKNOWN, true, "search parameters are required");
     857        return false;
     858    }
     859
    723860    if (!state) {
    724861      PXOPT_LOOKUP_S16(fault, config->args, "-fault", true, false);
    725      
     862
    726863      if (!pxSetFaultCode(config->dbh, "chipProcessedImfile", where, fault)) {
    727864        psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    … …  
    732869    else {
    733870      if (!pxchipProcessedImfileSetStateByQuery(config,where,state)) {
    734         psError(PS_ERR_UNKNOWN, false, "failed to set chipProcessedImfile state");
    735         return(false);
     871        psError(PS_ERR_UNKNOWN, false, "failed to set chipProcessedImfile state");
     872        return(false);
    736873      }
    737874    }
    738875
    739      
     876
    740877    return true;
    741878}
    … …  
    839976    psString query = pxDataGet("chiptool_unmasked.sql");
    840977    if (!query) {
    841         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     978        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    842979        return false;
    843980    }
    … …  
    9171054    psString query = pxDataGet("chiptool_pendingcleanuprun.sql");
    9181055    if (!query) {
    919         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1056        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    9201057        return false;
    9211058    }
    … …  
    9811118    psString query = pxDataGet("chiptool_pendingcleanupimfile.sql");
    9821119    if (!query) {
    983         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1120        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    9841121        return false;
    9851122    }
    … …  
    10421179    psString query = pxDataGet("chiptool_donecleanup.sql");
    10431180    if (!query) {
    1044         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1181        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10451182        return false;
    10461183    }
    … …  
    11001237    // make sure that the state string is valid
    11011238    if (!pxIsValidState(state)) {
    1102         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);
    11031240        return false;
    11041241    }
    … …  
    11131250    psString query = pxDataGet("chiptool_run.sql");
    11141251    if (!query) {
    1115         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1252        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11161253        return false;
    11171254    }
    … …  
    11751312    psString query = pxDataGet("chiptool_completely_processed_exp.sql");
    11761313    if (!query) {
    1177         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1314        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11781315        return false;
    11791316    }
    … …  
    12541391                    chipRun->tess_id,
    12551392                    chipRun->end_stage,
     1393                    chipRun->magicked,
    12561394                    NULL    // note does not propagate
    12571395        )) {
    … …  
    12951433    }
    12961434
    1297     psString set_magic = "";
     1435    psString set_magicked_imfile = psStringCopy("");
     1436    psString set_magicked_run = psStringCopy("");
    12981437    if (!strcmp(data_state, "full")) {
    1299         // copy the magicked state from the input to the output when transitioning to full state
    1300         set_magic = "\n , chipProcessedImfile.magicked = rawImfile.magicked";
    1301     }
    1302 
    1303     // note only updates if chipRun.state = run_state
    1304     // XXX note that we have removed this constraint for now
    1305     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)) {
    13061455        psFree(query);
    13071456        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    13141463    }
    13151464    psFree(query);
     1465    psFree(set_magicked_imfile);
     1466    psFree(set_magicked_run);
    13161467    if (psDBAffectedRows(config->dbh) < 1) {
    13171468        psError(PS_ERR_UNKNOWN, false, "should have affected atleast 1 row");
    … …  
    13201471
    13211472    query = pxDataGet("chiptool_change_exp_state.sql");
    1322     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)) {
    13231474        psFree(query);
    13241475        // rollback
    … …  
    13951546    psString query = pxDataGet(tables[i].sqlFilename);
    13961547    if (!query) {
    1397       psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1548      psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    13981549      return false;
    13991550    }
    … …  
    14311582
    14321583    if (clean) {
    1433         bool success = true; 
     1584        bool success = true;
    14341585        if (!strcmp(tables[i].tableName, "chipRun")) {
    14351586            success = pxSetStateCleaned("chipRun", "state", output);
    … …  
    15351686    psString query = pxDataGet("chiptool_runstate.sql");
    15361687    if (!query) {
    1537         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1688        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    15381689        return false;
    15391690    }
    … …  
    15441695        psFree(whereClause);
    15451696    } else {
    1546         psError(PXTOOLS_ERR_DATA, true, "search parameters or -all are required");
     1697        psError(PXTOOLS_ERR_CONFIG, true, "search parameters or -all are required");
    15471698        return false;
    15481699    }
    … …  
    15961747    return true;
    15971748}
     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/tap_branches/ippTools/src/chiptool.h

    r25822 r27838  
    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,
    … …  
    4850    CHIPTOOL_MODE_EXPORTRUN,
    4951    CHIPTOOL_MODE_IMPORTRUN,
    50     CHIPTOOL_MODE_RUNSTATE
     52    CHIPTOOL_MODE_RUNSTATE,
     53    CHIPTOOL_MODE_LISTRUN
    5154} chiptoolMode;
    5255

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

    r25835 r27838  
    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;
    … …  
    6363    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-pretend",  0,            "do not actually modify the database", false);
    6464    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", 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);
    6585
    6686    // -updaterun
    … …  
    7797    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_dist_group", 0,   "set dist group", NULL);
    7898    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);
    79105
    80106    // -pendingimfile
    … …  
    154180    psMetadataAddS16(addprocessedimfileArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code", 0);
    155181    psMetadataAddS16(addprocessedimfileArgs, PS_LIST_TAIL, "-quality",  0,            "set quality", 0);
    156     psMetadataAddBool(addprocessedimfileArgs, PS_LIST_TAIL, "-magicked",  0,        "define magicked status", false);
     182    psMetadataAddS64(addprocessedimfileArgs, PS_LIST_TAIL, "-magicked",  0,        "define magicked status", 0);
    157183
    158184    // -processedimfile
    … …  
    164190    psMetadataAddStr(processedimfileArgs,  PS_LIST_TAIL, "-reduction",          0, "search by reduction class", NULL);
    165191    psMetadataAddStr(processedimfileArgs,  PS_LIST_TAIL, "-label",  PS_META_DUPLICATE_OK, "search by chipRun label (LIKE comparison)", NULL);
     192    psMetadataAddStr(processedimfileArgs,  PS_LIST_TAIL, "-data_group",  PS_META_DUPLICATE_OK, "search by chipRun data_group (LIKE comparison)", NULL);
    166193    pxmagicAddArguments(processedimfileArgs);
    167194
    … …  
    169196    psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-all",  0,            "list everything without search terms", false);
    170197    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);
    171199    psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-simple",  0,         "use the simple output format", false);
    172200
    … …  
    189217    psMetadataAddS16(updateprocessedimfileArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code (required)", 0);
    190218    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);
     236
    191237    // -block
    192238    psMetadata *blockArgs = psMetadataAlloc();
    … …  
    292338
    293339    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);
    294341    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);
    295343    PXOPT_ADD_MODE("-pendingimfile",        "show pending imfiles",                 CHIPTOOL_MODE_PENDINGIMFILE,        pendingimfileArgs);
    296344    PXOPT_ADD_MODE("-addprocessedimfile",   "add a processed imfile",               CHIPTOOL_MODE_ADDPROCESSEDIMFILE,   addprocessedimfileArgs);
    … …  
    299347    PXOPT_ADD_MODE("-revertprocessedimfile","undo a processed imfile",              CHIPTOOL_MODE_REVERTPROCESSEDIMFILE,revertprocessedimfileArgs);
    300348    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);
    301350    PXOPT_ADD_MODE("-advanceexp",           "advance completed exposures",          CHIPTOOL_MODE_ADVANCEEXP,           advanceexpArgs);
    302351    PXOPT_ADD_MODE("-block",                "set a label block",                    CHIPTOOL_MODE_BLOCK,                blockArgs);
    … …  
    317366
    318367    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {
    319         psError(PS_ERR_UNKNOWN, true, "option parsing failed");
     368        psError(PS_ERR_UNKNOWN, false, "option parsing failed");
    320369        psFree(argSets);
    321370        psFree(modes);

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

    r23998 r27838  
    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/tap_branches/ippTools/src/dettool.c

    r25324 r27838  
    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);
    152         MODECASE(DETTOOL_MODE_PENDINGCLEANUP_DETRUNSUMMARY, pendingcleanup_detrunsummaryMode);
     154        MODECASE(DETTOOL_MODE_PENDINGCLEANUP_DETRUNSUMMARY, pendingcleanup_detrunsummaryMode);
    153155        // register
    154156        MODECASE(DETTOOL_MODE_REGISTER_DETREND, register_detrendMode);
    … …  
    185187    psString query = pxDataGet("dettool_pending.sql");
    186188    if (!query) {
    187         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    188         return false;
    189     }
    190    
     189        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     190        return false;
     191    }
     192
    191193    psMetadata *where = psMetadataAlloc();
    192194    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    … …  
    258260        psError(PS_ERR_UNKNOWN, false, "verify mode requires both -ref_det_id and -ref_iter");
    259261        return false;
    260     } 
     262    }
    261263    if (strcmp(mode, "verify") && ((ref_det_id != 0) || (ref_iter != -1))) {
    262264        psError(PS_ERR_UNKNOWN, false, "master mode cannot have -ref_det_id or -ref_iter set");
    263265        return false;
    264     } 
    265        
     266    }
     267
    266268    PXOPT_LOOKUP_STR(camera, config->args, "-inst", false, false);
    267269    PXOPT_LOOKUP_STR(telescope, config->args, "-telescope", false, false);
    … …  
    308310        psMetadataItem *mItem = NULL;
    309311        while ((mItem = psListGetAndIncrement(iter))) {
    310             psS64 exp_id = mItem->data.S64;
     312            psS64 exp_id = mItem->data.S64;
    311313            if (!psMetadataAddS64(where, PS_LIST_TAIL, "exp_id", PS_META_DUPLICATE_OK, "==", exp_id)) {
    312314                psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    … …  
    317319        }
    318320        psFree(iter);
    319     } 
     321    }
    320322    if (item->type == PS_DATA_S64) {
    321         psS64 exp_id = item->data.S64;
    322         if (!psMetadataAddS64(where, PS_LIST_TAIL, "exp_id", PS_META_DUPLICATE_OK, "==", exp_id)) {
    323             psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    324             psFree(where);
    325             return false;
    326         }
    327     } 
     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    }
    328330
    329331    if (psListLength(where->list) < 1) {
    … …  
    505507        psError(PS_ERR_UNKNOWN, false, "verify mode requires both -ref_det_id and -ref_iter");
    506508        return false;
    507     } 
     509    }
    508510    if (strcmp(mode, "verify") && ((ref_det_id != 0) || (ref_iter != -1))) {
    509511        psError(PS_ERR_UNKNOWN, false, "master mode cannot have -ref_det_id or -ref_iter set");
    510512        return false;
    511     } 
     513    }
    512514
    513515    PXOPT_LOOKUP_STR(filelevel, config->args, "-filelevel", false, false);
    … …  
    550552    PXOPT_COPY_F32(config->args, where, "-select_airmass_max", "airmass", "<=");
    551553    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", ">=");
    552555    PXOPT_COPY_F32(config->args, where, "-select_exp_time_min", "exp_time", ">=");
    553556    PXOPT_COPY_F32(config->args, where, "-select_exp_time_max", "exp_time", "<=");
    … …  
    673676                 label,
    674677                 ref_det_id,
    675                 ref_iter
     678                ref_iter
    676679        );
    677680    psS64 det_id = psDBLastInsertID(config->dbh);
    … …  
    742745{
    743746    PS_ASSERT_PTR_NON_NULL(config, false);
    744    
     747
    745748    // XXX this mode is not well-tested: probably need to specify iteration here
    746749    PXOPT_LOOKUP_S64(det_id, config->args, "-det_id", true, false); // required
    … …  
    759762        psError(PS_ERR_UNKNOWN, false, "verify mode requires both -ref_det_id and -ref_iter");
    760763        return false;
    761     } 
     764    }
    762765    if (strcmp(mode, "verify") && ((ref_det_id != 0) || (ref_iter != -1))) {
    763766        psError(PS_ERR_UNKNOWN, false, "master mode cannot have -ref_det_id or -ref_iter set");
    764767        return false;
    765     } 
     768    }
    766769
    767770    // the new detRun may have different values for these limits:
    … …  
    817820
    818821    if (iteration < 0) {
    819         iteration = detRun->iteration;
     822        iteration = detRun->iteration;
    820823    }
    821824
    … …  
    977980    psString query = pxDataGet("dettool_definebydetrun.sql");
    978981    if (!query) {
    979         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     982        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    980983        return false;
    981984    }
    … …  
    989992
    990993    if (only_accepted) {
    991         psStringAppend(&query, " AND accept = 1");
     994        psStringAppend(&query, " AND accept = 1");
    992995    }
    993996
    … …  
    10681071    psString query = pxDataGet("dettool_runs.sql");
    10691072    if (!query) {
    1070         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1073        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10711074        return false;
    10721075    }
    … …  
    11381141    psString query = pxDataGet("dettool_childlessrun.sql");
    11391142    if (!query) {
    1140         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1143        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11411144        psFree(where);
    11421145        return false;
    … …  
    12121215    psString query = pxDataGet("dettool_input.sql");
    12131216    if (!query) {
    1214         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1217        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    12151218        psFree(where);
    12161219        return false;
    … …  
    12641267    psString query = pxDataGet("dettool_raw.sql");
    12651268    if (!query) {
    1266         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1269        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    12671270        return false;
    12681271    }
    … …  
    13381341}
    13391342
    1340 // used by updatedetrunMode 
     1343// used by updatedetrunMode
    13411344bool startNewIteration(pxConfig *config, psS64 det_id)
    13421345{
    … …  
    13451348    psString query = pxDataGet("dettool_start_new_iteration.sql");
    13461349    if (!query) {
    1347         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1350        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    13481351        return false;
    13491352    }
    … …  
    15641567        }
    15651568        detInputExpRow *newInputExp = detInputExpRowAlloc(
    1566             det_id,
     1569            det_id,
    15671570            newIteration,
    15681571            inputExp->exp_id,
    … …  
    16621665                      solang_max,
    16631666                      label,
    1664                       ref_det_id,
    1665                       ref_iter
     1667                      ref_det_id,
     1668                      ref_iter
    16661669            )) {
    16671670        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    17131716{
    17141717    PS_ASSERT_PTR_NON_NULL(config, false);
    1715    
     1718
    17161719    PXOPT_LOOKUP_S64(det_id, config->args, "-det_id", true, false); // required
    17171720    PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false); // required
    … …  
    17281731
    17291732    if (!detRegisteredImfileInsert(config->dbh,
    1730                                    det_id,
    1731                                    0,  // the iteration is fixed at 0
    1732                                    class_id,
    1733                                    uri,
    1734                                    bg,
    1735                                    bg_stdev,
    1736                                    bg_mean_stdev,
    1737                                    user_1,
    1738                                    user_2,
    1739                                    user_3,
    1740                                    user_4,
    1741                                    user_5,
    1742                                    path_base,
    1743                                    "full",                                 
    1744                                    0       // fault code
    1745             )) {
     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            )) {
    17461749        psError(PS_ERR_UNKNOWN, false, "database error");
    17471750        return false;
    … …  
    18581861
    18591862
    1860 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)
    18611864{
    18621865    PS_ASSERT_PTR_NON_NULL(config, false);
     1866    PS_ASSERT_PTR_NON_NULL(where, false);
    18631867    PS_ASSERT_PTR_NON_NULL(data_state, false);
    1864     PS_ASSERT_PTR_NON_NULL(class_id, false);
    18651868
    18661869    if (!isValidDataState (data_state)) return false;
    1867    
    1868     char *query = "UPDATE detProcessedImfile SET data_state = '%s'"
    1869         " WHERE det_id = %" PRId64
    1870         " AND exp_id = %" PRId64
    1871         " AND class_id = '%s'";
    1872     if (!p_psDBRunQueryF(config->dbh, query, data_state, det_id, exp_id, class_id)) {
    1873         psError(PS_ERR_UNKNOWN, false,
    1874                 "failed to change state for det_id %" PRId64 ", exp_id %" PRId64 ", class_id %s",
    1875                 det_id, exp_id, class_id);
    1876         return false;
    1877     }
    1878 
    1879     return true;
    1880 }
    1881 
    1882 bool setProcessedExpDataState(pxConfig *config, psS64 det_id, psS64 exp_id, const char *data_state)
     1870
     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)
    18831891{
    18841892    PS_ASSERT_PTR_NON_NULL(config, false);
     1893    PS_ASSERT_PTR_NON_NULL(where, false);
    18851894    PS_ASSERT_PTR_NON_NULL(data_state, false);
    18861895
    18871896    if (!isValidDataState (data_state)) return false;
    18881897
    1889     char *query = "UPDATE detProcessedExp SET data_state = '%s'"
    1890         " WHERE det_id = %" PRId64
    1891         " AND exp_id = %" PRId64;
    1892     if (!p_psDBRunQueryF(config->dbh, query, data_state, det_id, exp_id)) {
    1893         psError(PS_ERR_UNKNOWN, false,
    1894                 "failed to change state for det_id %" PRId64 ", exp_id %" PRId64,
    1895                 det_id, exp_id);
    1896         return false;
    1897     }
    1898 
    1899     return true;
    1900 }
    1901 
    1902 
     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
    19031972bool setStackedImfileDataState(pxConfig *config, psS64 det_id, psS32 iteration, const char *class_id, const char *data_state)
    19041973{
    … …  
    19101979
    19111980    char *query = "UPDATE detStackedImfile SET data_state = '%s'"
    1912         " WHERE det_id = %" PRId64
    1913         " AND iteration = %" PRId32
    1914         " AND class_id = '%s'";
     1981        " WHERE det_id = %" PRId64
     1982        " AND iteration = %" PRId32
     1983        " AND class_id = '%s'";
    19151984    if (!p_psDBRunQueryF(config->dbh, query, data_state, det_id, iteration, class_id)) {
    19161985        psError(PS_ERR_UNKNOWN, false,
    1917                 "failed to change state for det_id %" PRId64 ", iteration %" PRId32 "class_id %s", 
    1918                 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);
    19191988        return false;
    19201989    }
    … …  
    19322001
    19332002    char *query = "UPDATE detNormalizedStatImfile SET data_state = '%s'"
    1934         " WHERE det_id = %" PRId64
    1935         " AND iteration = %" PRId32
    1936         " AND class_id = '%s'";
     2003        " WHERE det_id = %" PRId64
     2004        " AND iteration = %" PRId32
     2005        " AND class_id = '%s'";
    19372006/*     fprintf(stderr,"DETTOOL SAYS: %s\n",query); */
    19382007    if (!p_psDBRunQueryF(config->dbh, query, data_state, det_id, iteration,class_id)) {
    19392008        psError(PS_ERR_UNKNOWN, false,
    1940                 "failed to change state for det_id %" PRId64 ", iteration %" PRId32, 
    1941                 det_id, iteration);
     2009                "failed to change state for det_id %" PRId64 ", iteration %" PRId32,
     2010                det_id, iteration);
    19422011        return false;
    19432012    }
    … …  
    19552024
    19562025    char *query = "UPDATE detNormalizedImfile SET data_state = '%s'"
    1957         " WHERE det_id = %" PRId64
    1958         " AND iteration = %" PRId32
    1959         " AND class_id = '%s'";
     2026        " WHERE det_id = %" PRId64
     2027        " AND iteration = %" PRId32
     2028        " AND class_id = '%s'";
    19602029    if (!p_psDBRunQueryF(config->dbh, query, data_state, det_id, iteration, class_id)) {
    19612030        psError(PS_ERR_UNKNOWN, false,
    1962                 "failed to change state for det_id %" PRId64 ", iteration %" PRId32 " class %s", 
    1963                 det_id, iteration, class_id);
     2031                "failed to change state for det_id %" PRId64 ", iteration %" PRId32 " class %s",
     2032                det_id, iteration, class_id);
    19642033        return false;
    19652034    }
    … …  
    19762045
    19772046    char *query = "UPDATE detNormalizedExp SET data_state = '%s'"
    1978         " WHERE det_id = %" PRId64
    1979         " AND iteration = %" PRId32;
     2047        " WHERE det_id = %" PRId64
     2048        " AND iteration = %" PRId32;
    19802049    if (!p_psDBRunQueryF(config->dbh, query, data_state, det_id, iteration)) {
    19812050        psError(PS_ERR_UNKNOWN, false,
    1982                 "failed to change state for det_id %" PRId64 ", iteration %" PRId32, 
    1983                 det_id, iteration);
     2051                "failed to change state for det_id %" PRId64 ", iteration %" PRId32,
     2052                det_id, iteration);
    19842053        return false;
    19852054    }
    … …  
    19872056    return true;
    19882057}
    1989 
    1990 bool setResidImfileDataState(pxConfig *config, psS64 det_id, psS32 iteration, psS64 exp_id, const char *class_id, const char *data_state)
    1991 {
    1992     PS_ASSERT_PTR_NON_NULL(config, false);
    1993     PS_ASSERT_PTR_NON_NULL(data_state, false);
    1994     PS_ASSERT_PTR_NON_NULL(class_id, false);
    1995 
    1996     if (!isValidDataState (data_state)) return false;
    1997 
    1998     char *query = "UPDATE detResidImfile SET data_state = '%s'"
    1999         " WHERE det_id = %" PRId64
    2000         " AND iteration = %" PRId32
    2001         " AND exp_id = %" PRId64
    2002         " AND class_id = '%s'";
    2003     if (!p_psDBRunQueryF(config->dbh, query, data_state, det_id, iteration, exp_id, class_id)) {
    2004         psError(PS_ERR_UNKNOWN, false,
    2005                 "failed to change state for det_id %" PRId64 ", iteration %" PRId32 ", exp_id %" PRId64 ", class_id %s",
    2006                 det_id, iteration, exp_id, class_id);
    2007         return false;
    2008     }
    2009 
    2010     return true;
    2011 }
    2012 
    2013 bool setResidExpDataState(pxConfig *config, psS64 det_id, psS32 iteration, psS64 exp_id, const char *data_state)
    2014 {
    2015     PS_ASSERT_PTR_NON_NULL(config, false);
    2016     PS_ASSERT_PTR_NON_NULL(data_state, false);
    2017 
    2018     if (!isValidDataState (data_state)) return false;
    2019 
    2020     char *query = "UPDATE detResidExp SET data_state = '%s'"
    2021         " WHERE det_id = %" PRId64
    2022         " AND iteration = %" PRId32
    2023         " AND exp_id = %" PRId64;
    2024     if (!p_psDBRunQueryF(config->dbh, query, data_state, det_id, iteration, exp_id)) {
    2025         psError(PS_ERR_UNKNOWN, false,
    2026                 "failed to change state for det_id %" PRId64 ", iteration %" PRId32 ", exp_id %" PRId64,
    2027                 det_id, iteration, exp_id);
    2028         return false;
    2029     }
    2030 
    2031     return true;
    2032 }
     2058// End not yet modified for cleanup.
    20332059
    20342060bool exportrunMode(pxConfig *config)
    … …  
    20382064    char sqlFilename[80];
    20392065  } ExportTable;
    2040  
     2066
    20412067  int numExportTables = 12;
    20422068
    … …  
    20742100    psString query = pxDataGet(tables[i].sqlFilename);
    20752101    if (!query) {
    2076       psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     2102      psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    20772103      return false;
    20782104    }
    … …  
    21162142    }
    21172143    psFree(output);
    2118  
     2144
    21192145  }
    21202146
    … …  
    21272153{
    21282154  unsigned int nFail;
    2129  
     2155
    21302156  int numImportTables = 11;
    2131  
     2157
    21322158  char tables[11] [80] = {"detInputExp", "detNormalizedExp",
    21332159    "detNormalizedImfile", "detNormalizedStatImfile", "detProcessedExp",
    … …  
    21362162
    21372163  PS_ASSERT_PTR_NON_NULL(config, NULL);
    2138  
     2164
    21392165  PXOPT_LOOKUP_STR(infile, config->args, "-infile", true,  false);
    21402166
    … …  
    21432169  fprintf (stdout, "---- input ----\n");
    21442170  psMetadataPrint (stderr, input, 1);
    2145  
     2171
    21462172  psMetadataItem *item = psMetadataLookup (input, "detRun");
    21472173  psAssert (item, "entry not in input?");
    … …  
    21532179  detRunRow *detRun = detRunObjectFromMetadata (entry->data.md);
    21542180  detRunInsertObject (config->dbh, detRun);
    2155  
     2181
    21562182  // fprintf (stdout, "---- det run ----\n");
    21572183  // psMetadataPrint (stderr, entry->data.md, 1);
    … …  
    21612187    psAssert (item, "entry not in input?");
    21622188    psAssert (item->type == PS_DATA_METADATA_MULTI, "entry not multi?");
    2163  
     2189
    21642190    switch (i) {
    21652191      case 0:
    … …  
    21752201        }
    21762202        break;
    2177  
     2203
    21782204      case 1:
    21792205        for (int i = 0; i < item->data.list->n; i++) {
    … …  
    21882214        }
    21892215        break;
    2190        
     2216
    21912217      case 2:
    21922218        for (int i = 0; i < item->data.list->n; i++) {
    … …  
    22012227        }
    22022228        break;
    2203  
     2229
    22042230      case 3:
    22052231        for (int i = 0; i < item->data.list->n; i++) {
    … …  
    22142240        }
    22152241        break;
    2216        
     2242
    22172243      case 4:
    22182244        for (int i = 0; i < item->data.list->n; i++) {
    … …  
    22272253        }
    22282254        break;
    2229        
     2255
    22302256      case 5:
    22312257        for (int i = 0; i < item->data.list->n; i++) {
    … …  
    22402266        }
    22412267        break;
    2242        
     2268
    22432269      case 6:
    22442270        for (int i = 0; i < item->data.list->n; i++) {
    … …  
    22532279        }
    22542280        break;
    2255        
     2281
    22562282      case 7:
    22572283        for (int i = 0; i < item->data.list->n; i++) {
    … …  
    22662292        }
    22672293        break;
    2268        
     2294
    22692295      case 8:
    22702296        for (int i = 0; i < item->data.list->n; i++) {
    … …  
    22792305        }
    22802306        break;
    2281        
     2307
    22822308      case 9:
    22832309        for (int i = 0; i < item->data.list->n; i++) {
    … …  
    22922318        }
    22932319        break;
    2294        
     2320
    22952321      case 10:
    22962322        for (int i = 0; i < item->data.list->n; i++) {

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

    r25324 r27838  
    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,
    … …  
    149151bool pendingcleanup_processedexpMode(pxConfig *config);
    150152bool donecleanup_processedexpMode(pxConfig *config);
     153bool updatestateprocessedMode(pxConfig *config);
    151154
    152155// stackedimfile
    … …  
    203206bool pendingcleanup_residexpMode(pxConfig *config);
    204207bool donecleanup_residexpMode(pxConfig *config);
     208bool updatestateresidMode(pxConfig *config);
    205209
    206210// detrunsummary
    … …  
    220224
    221225// functions to set the 'data_state' for stages
    222 bool setProcessedImfileDataState(pxConfig *config, psS64 det_id, psS64 exp_id, const char *class_id, const char *data_state);
    223 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
    224231bool setStackedImfileDataState(pxConfig *config, psS64 det_id, psS32 iteration, const char *class_id, const char *data_state);
    225232bool setNormStatImfileDataState(pxConfig *config, psS64 det_id, psS32 iteration, const char *class_id, const char *data_state);
    226233bool setNormImfileDataState(pxConfig *config, psS64 det_id, psS32 iteration, const char *class_id, const char *data_state);
    227234bool setNormExpDataState(pxConfig *config, psS64 det_id, psS32 iteration, const char *data_state);
    228 bool setResidImfileDataState(pxConfig *config, psS64 det_id, psS32 iteration, psS64 exp_id, const char *class_id, const char *data_state);
    229 bool setResidExpDataState(pxConfig *config, psS64 det_id, psS32 iteration, psS64 exp_id, const char *data_state);
    230235
    231236#endif // DETTOOL_H

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

    r25324 r27838  
    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;
    … …  
    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);
    … …  
    305306    // -updateprocessedimfile
    306307    psMetadata *updateprocessedimfileArgs = psMetadataAlloc();
    307     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);
    308309    psMetadataAddS64(updateprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",               0,            "search by exp_id", 0);
    309310    psMetadataAddStr(updateprocessedimfileArgs, PS_LIST_TAIL, "-class_id",             0,            "search by exp_name", NULL);
    … …  
    314315    psMetadataAddBool(pendingcleanup_processedimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    315316    psMetadataAddU64(pendingcleanup_processedimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    316     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);
    317318    psMetadataAddS64(pendingcleanup_processedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", 0);
    318319    psMetadataAddStr(pendingcleanup_processedimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
    … …  
    322323    psMetadataAddBool(donecleanup_processedimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    323324    psMetadataAddU64(donecleanup_processedimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    324     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);
    325326    psMetadataAddS64(donecleanup_processedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", 0);
    326327    psMetadataAddStr(donecleanup_processedimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
    … …  
    366367    // -updateprocessedexp
    367368    psMetadata *updateprocessedexpArgs = psMetadataAlloc();
    368     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);
    369370    psMetadataAddS64(updateprocessedexpArgs, PS_LIST_TAIL, "-exp_id",               0,            "search by exp_id", 0);
    370371    psMetadataAddStr(updateprocessedexpArgs, PS_LIST_TAIL, "-data_state",           0,            "set state", NULL);
    … …  
    374375    psMetadataAddBool(pendingcleanup_processedexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    375376    psMetadataAddU64(pendingcleanup_processedexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    376     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);
    377378    psMetadataAddS64(pendingcleanup_processedexpArgs, PS_LIST_TAIL, "-exp_id",               0,            "search by exp_id", 0);
    378379
    … …  
    381382    psMetadataAddBool(donecleanup_processedexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    382383    psMetadataAddU64(donecleanup_processedexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    383     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);
    384385    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);
    385392
    386393    // -tostacked
    … …  
    425432    // -updatestacked
    426433    psMetadata *updatestackedArgs = psMetadataAlloc();
    427     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);
    428435    psMetadataAddS32(updatestackedArgs, PS_LIST_TAIL, "-iteration",  0,            "search by iteration number", 0);
    429436    psMetadataAddStr(updatestackedArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
    … …  
    434441    psMetadataAddBool(pendingcleanup_stackedArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    435442    psMetadataAddU64(pendingcleanup_stackedArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    436     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);
    437444    psMetadataAddS32(pendingcleanup_stackedArgs, PS_LIST_TAIL, "-iteration",  0,            "search by iteration number", 0);
    438445    psMetadataAddStr(pendingcleanup_stackedArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
    … …  
    442449    psMetadataAddBool(donecleanup_stackedArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    443450    psMetadataAddU64(donecleanup_stackedArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    444     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);
    445452    psMetadataAddS32(donecleanup_stackedArgs, PS_LIST_TAIL, "-iteration",  0,            "search by iteration number", 0);
    446453    psMetadataAddStr(donecleanup_stackedArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
    … …  
    477484    // -updatenormalizedstat
    478485    psMetadata *updatenormalizedstatArgs = psMetadataAlloc();
    479     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);
    480487    psMetadataAddS32(updatenormalizedstatArgs, PS_LIST_TAIL, "-iteration",  0,            "search by iteration number", 0);
    481488    psMetadataAddStr(updatenormalizedstatArgs, PS_LIST_TAIL, "-class_id",             0,            "search by exp_name", NULL);
    … …  
    486493    psMetadataAddBool(pendingcleanup_normalizedstatArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    487494    psMetadataAddU64(pendingcleanup_normalizedstatArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    488     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);
    489496    psMetadataAddS32(pendingcleanup_normalizedstatArgs, PS_LIST_TAIL, "-iteration",  0,            "search by iteration number", 0);
    490497    psMetadataAddStr(pendingcleanup_normalizedstatArgs, PS_LIST_TAIL, "-class_id",             0,            "search by exp_name", NULL);
    … …  
    494501    psMetadataAddBool(donecleanup_normalizedstatArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    495502    psMetadataAddU64(donecleanup_normalizedstatArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    496     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);
    497504    psMetadataAddS32(donecleanup_normalizedstatArgs, PS_LIST_TAIL, "-iteration",  0,            "search by iteration number", 0);
    498505    psMetadataAddStr(donecleanup_normalizedstatArgs, PS_LIST_TAIL, "-class_id",             0,            "search by exp_name", NULL);
    … …  
    539546    // -updatenormalizedimfile
    540547    psMetadata *updatenormalizedimfileArgs = psMetadataAlloc();
    541     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);
    542549    psMetadataAddS32(updatenormalizedimfileArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
    543550    psMetadataAddStr(updatenormalizedimfileArgs, PS_LIST_TAIL, "-class_id",             0,            "search by exp_name", NULL);
    … …  
    548555    psMetadataAddBool(pendingcleanup_normalizedimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    549556    psMetadataAddU64(pendingcleanup_normalizedimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    550     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);
    551558    psMetadataAddS32(pendingcleanup_normalizedimfileArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
    552559    psMetadataAddStr(pendingcleanup_normalizedimfileArgs, PS_LIST_TAIL, "-class_id",             0,            "search by exp_name", NULL);
    … …  
    556563    psMetadataAddBool(donecleanup_normalizedimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    557564    psMetadataAddU64(donecleanup_normalizedimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    558     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);
    559566    psMetadataAddS32(donecleanup_normalizedimfileArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
    560567    psMetadataAddStr(donecleanup_normalizedimfileArgs, PS_LIST_TAIL, "-class_id",             0,            "search by exp_name", NULL);
    … …  
    598605    // -updatenormalizedexp
    599606    psMetadata *updatenormalizedexpArgs = psMetadataAlloc();
    600     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);
    601608    psMetadataAddS32(updatenormalizedexpArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
    602609    psMetadataAddStr(updatenormalizedexpArgs, PS_LIST_TAIL, "-data_state",           0,            "set state", NULL);
    … …  
    606613    psMetadataAddBool(pendingcleanup_normalizedexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    607614    psMetadataAddU64(pendingcleanup_normalizedexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    608     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);
    609616    psMetadataAddS32(pendingcleanup_normalizedexpArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
    610617
    … …  
    613620    psMetadataAddBool(donecleanup_normalizedexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    614621    psMetadataAddU64(donecleanup_normalizedexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    615     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);
    616623    psMetadataAddS32(donecleanup_normalizedexpArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
    617624
    … …  
    676683    // -updateresidimfile
    677684    psMetadata *updateresidimfileArgs = psMetadataAlloc();
    678     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);
    679686    psMetadataAddS32(updateresidimfileArgs, PS_LIST_TAIL, "-iteration", 0,       "search by iteration number", 0);
    680687    psMetadataAddS64(updateresidimfileArgs, PS_LIST_TAIL, "-exp_id",               0,            "search by exp_id", 0);
    … …  
    686693    psMetadataAddBool(pendingcleanup_residimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    687694    psMetadataAddU64(pendingcleanup_residimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    688     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);
    689696    psMetadataAddS32(pendingcleanup_residimfileArgs, PS_LIST_TAIL, "-iteration", 0,       "search by iteration number", 0);
    690697    psMetadataAddS64(pendingcleanup_residimfileArgs, PS_LIST_TAIL, "-exp_id",               0,            "search by exp_id", 0);
    … …  
    695702    psMetadataAddBool(donecleanup_residimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    696703    psMetadataAddU64(donecleanup_residimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    697     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);
    698705    psMetadataAddS32(donecleanup_residimfileArgs, PS_LIST_TAIL, "-iteration", 0,       "search by iteration number", 0);
    699706    psMetadataAddS64(donecleanup_residimfileArgs, PS_LIST_TAIL, "-exp_id",               0,            "search by exp_id", 0);
    … …  
    778785    psMetadataAddS32(donecleanup_residexpArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
    779786    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);
    780793
    781794    // -todetrunsummary
    … …  
    924937    PXOPT_ADD_MODE("-pendingcleanup_processedexp", "", DETTOOL_MODE_PENDINGCLEANUP_PROCESSEDEXP, pendingcleanup_processedexpArgs);
    925938    PXOPT_ADD_MODE("-donecleanup_processedexp", "",    DETTOOL_MODE_DONECLEANUP_PROCESSEDEXP, donecleanup_processedexpArgs);
     939    PXOPT_ADD_MODE("-updatestate_processed", "", DETTOOL_MODE_UPDATESTATE_PROCESSED, updatestateprocessedArgs);
    926940
    927941    PXOPT_ADD_MODE("-tostacked",       "", DETTOOL_MODE_TOSTACKED,     tostackedArgs);
    … …  
    972986    PXOPT_ADD_MODE("-pendingcleanup_residexp", "", DETTOOL_MODE_PENDINGCLEANUP_RESIDEXP, pendingcleanup_residexpArgs);
    973987    PXOPT_ADD_MODE("-donecleanup_residexp", "",    DETTOOL_MODE_DONECLEANUP_RESIDEXP, donecleanup_residexpArgs);
     988    PXOPT_ADD_MODE("-updatestate_resid", "", DETTOOL_MODE_UPDATESTATE_RESID, updatestateresidArgs);
    974989
    975990    PXOPT_ADD_MODE("-todetrunsummary",  "", DETTOOL_MODE_TODETRUNSUMMARY,  todetrunsummaryArgs);

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

    r20377 r27838  
    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/tap_branches/ippTools/src/dettool_detrunsummary.c

    r25324 r27838  
    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    }
    … …  
    348348  psString query = pxDataGet("dettool_pendingcleanup_detrunsummary.sql");
    349349  if (!query) {
    350     psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     350    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    351351    return(false);
    352352  }
    353  
     353
    354354  if (psListLength(where->list)) {
    355355    psString whereClause = psDBGenerateWhereConditionSQL(where, "detRunSummary");
    … …  
    429429
    430430/*       if (!isValidDataState(data_state)) return false; */
    431      
    432      
    433      
     431
     432
     433
    434434      char *query_detRunSummary = "UPDATE detRunSummary SET data_state = '%s'"
    435         " WHERE det_id = %" PRId64
    436         " AND iteration = %" PRId32;
     435        " WHERE det_id = %" PRId64
     436        " AND iteration = %" PRId32;
    437437      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;
     438        psError(PS_ERR_UNKNOWN, false,
     439                "failed to change state for det_id %" PRId64 ", iteration %" PRId32, det_id,iteration);
     440        return false;
    441441      }
    442442
    443443      /* This check allows the one update to flag everything for cleanup.  The check for full is only temporary while I test for bugs. */
    444444      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         }
     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        }
    517517      }
    518518      /* End if */
    519      
     519
    520520    }
    521521

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

    r23688 r27838  
    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/tap_branches/ippTools/src/dettool_normalizedimfile.c

    r23688 r27838  
    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/tap_branches/ippTools/src/dettool_normalizedstat.c

    r23688 r27838  
    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/tap_branches/ippTools/src/dettool_processedexp.c

    r23688 r27838  
    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/tap_branches/ippTools/src/dettool_processedimfile.c

    r25324 r27838  
    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}
    … …  
    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    }
    … …  
    351356    if (!output) {
    352357        psError(PS_ERR_UNKNOWN, false, "database error");
    353 /*      fprintf(stderr,"WTF !output?\n"); */
     358/*      fprintf(stderr,"WTF !output?\n"); */
    354359        return false;
    355360    }
    356361    if (!psArrayLength(output)) {
    357362        psTrace("dettool", PS_LOG_INFO, "no rows found");
    358 /*      fprintf(stderr,"WTF no rows??\n"); */
     363/*      fprintf(stderr,"WTF no rows??\n"); */
    359364        psFree(output);
    360365        return true;
    … …  
    392397    psString query = pxDataGet("dettool_donecleanup_processedimfile.sql");
    393398    if (!query) {
    394         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     399        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    395400        return false;
    396401    }

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

    r23688 r27838  
    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/tap_branches/ippTools/src/dettool_residimfile.c

    r23688 r27838  
    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/tap_branches/ippTools/src/dettool_stack.c

    r23688 r27838  
    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/tap_branches/ippTools/src/difftool.c

    r25851 r27838  
    4343static bool definewarpstackMode(pxConfig *config);
    4444static bool definewarpwarpMode(pxConfig *config);
     45static bool definestackstackMode(pxConfig *config);
    4546static bool pendingcleanuprunMode(pxConfig *config);
    4647static bool pendingcleanupskyfileMode(pxConfig *config);
    … …  
    5556static bool topurgedskyfileMode(pxConfig *config);
    5657static bool toscrubbedskyfileMode(pxConfig *config);
     58static bool tofullskyfileMode(pxConfig *config);
     59static bool listrunMode(pxConfig *config);
     60static bool setskyfiletoupdateMode(pxConfig *config);
    5761
    5862
    … …  
    8892        MODECASE(DIFFTOOL_MODE_DEFINEWARPSTACK,       definewarpstackMode);
    8993        MODECASE(DIFFTOOL_MODE_DEFINEWARPWARP,        definewarpwarpMode);
     94        MODECASE(DIFFTOOL_MODE_DEFINESTACKSTACK,      definestackstackMode);
    9095        MODECASE(DIFFTOOL_MODE_PENDINGCLEANUPRUN,     pendingcleanuprunMode);
    9196        MODECASE(DIFFTOOL_MODE_PENDINGCLEANUPSKYFILE, pendingcleanupskyfileMode);
    … …  
    9499        MODECASE(DIFFTOOL_MODE_EXPORTRUN,             exportrunMode);
    95100        MODECASE(DIFFTOOL_MODE_IMPORTRUN,             importrunMode);
    96         MODECASE(DIFFTOOL_MODE_TOCLEANEDSKYFILE,   tocleanedskyfileMode);
    97         MODECASE(DIFFTOOL_MODE_TOPURGEDSKYFILE,    topurgedskyfileMode);
    98         MODECASE(DIFFTOOL_MODE_TOSCRUBBEDSKYFILE,  toscrubbedskyfileMode);
     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);
    99107
    100108        default:
    … …  
    132140    PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
    133141    PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false);
    134     PXOPT_LOOKUP_STR(reduction, config->args, "-rset_eduction", 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);
    135144    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
    136145
    … …  
    153162            exposure,
    154163            false,
     164            diff_mode,
    155165            note
    156166    );
    … …  
    186196    psMetadata *where = psMetadataAlloc();
    187197
    188     PXOPT_COPY_S64(config->args, where, "-diff_id",  "stack_id",   "==");
     198    PXOPT_COPY_S64(config->args, where, "-diff_id",  "diff_id",   "==");
    189199    PXOPT_COPY_STR(config->args, where, "-label",     "label",     "==");
     200    PXOPT_COPY_STR(config->args, where, "-data_group","data_group",     "==");
    190201    PXOPT_COPY_STR(config->args, where, "-state",     "state",     "==");
    191202    if (!psListLength(where->list)) {
    192203        psFree(where);
    193         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     204        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    194205        return false;
    195206    }
    … …  
    198209
    199210    // pxUpdateRun gets parameters from config->args and updates
    200     bool result = pxUpdateRun(config, where, &query, "diffRun", true);
     211    bool result = pxUpdateRun(config, where, &query, "diffRun", "diff_id", "diffSkyfile", true);
    201212
    202213    psFree(query);
    … …  
    204215
    205216    return result;
    206 
    207 #ifdef notdef
    208     // required options
    209     PXOPT_LOOKUP_S64(diff_id, config->args, "-diff_id", false, false);
    210     PXOPT_LOOKUP_STR(state, config->args, "-state", true, false);
    211     PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
    212    
    213     // Copy of my hacky work around from stacktool.c
    214     if ((state)&&(diff_id)) {
    215         // set detRun.state to state
    216         return setdiffRunState(config, diff_id, state, false);
    217     }
    218 
    219     if ((state)&&(label)) {
    220       return setdiffRunStateByLabel(config, label, state);
    221     }
    222 
    223     psError(PS_ERR_UNKNOWN, false, "Required options not found.");
    224 
    225     return false;
    226 #endif
    227217}
    228218
    … …  
    379369    psString query = pxDataGet("difftool_inputskyfile.sql");
    380370    if (!query) {
    381         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    382         return false;
    383     }
    384 
    385     psString whereClause = NULL;
     371        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     372        return false;
     373    }
     374
     375    psString whereClause = psStringCopy("");
    386376    if (psListLength(where->list)) {
    387377        whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    388         psStringPrepend(&whereClause, "\n AND ");
     378        psStringPrepend(&whereClause, "\n WHERE ");
    389379    }
    390380    psFree(where);
    391381
    392382    // Add condition to get only templates or only inputs
     383    psString templateClause = psStringCopy("");
    393384    {
    394         psString templateClause = NULL;
    395385        if (template) {
    396             psStringAppend(&templateClause, " %s", " template != 0");
     386            psStringAppend(&templateClause, "\n WHERE %s", " template != 0");
    397387        } else if (input) {
    398             psStringAppend(&templateClause, " %s", " template = 0");
    399         }
    400         if (templateClause) {
    401             psStringAppend(&whereClause, "\n AND %s", templateClause);
    402         }
    403         psFree(templateClause);
     388            psStringAppend(&templateClause, "\n WHERE %s", " template = 0");
     389        }
    404390    }
    405391
    … …  
    412398    }
    413399
    414     if (!p_psDBRunQueryF(config->dbh, query, whereClause, whereClause, whereClause, whereClause)) {
    415         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);
    416403        psFree(whereClause);
    417404        psFree(query);
    418405        return false;
    419406    }
     407    psFree(templateClause);
    420408    psFree(whereClause);
    421409    psFree(query);
    … …  
    469457    psString query = pxDataGet("difftool_todiffskyfile.sql");
    470458    if (!query) {
    471         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     459        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    472460        return false;
    473461    }
    … …  
    626614    psString query = pxDataGet("difftool_completed_runs.sql");
    627615    if (!query) {
    628         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     616        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    629617        return false;
    630618    }
    … …  
    717705    PXOPT_COPY_S64(config->args, where,  "-magicked", "diffSkyfile.magicked", "==");
    718706    pxAddLabelSearchArgs (config, where, "-label", "diffRun.label", "LIKE");
    719 
     707    pxAddLabelSearchArgs (config, where, "-data_group", "diffRun.data_group", "LIKE");
     708
     709    PXOPT_LOOKUP_BOOL(pstamp_order, config->args, "-pstamp_order", false);
    720710    PXOPT_LOOKUP_BOOL(template, config->args, "-template", false);
    721711    if (!template) {
    … …  
    725715        PXOPT_COPY_TIME(config->args, where, "-dateobs_begin", "rawInput.dateobs",  ">=");
    726716        PXOPT_COPY_TIME(config->args, where, "-dateobs_end",   "rawInput.dateobs",  "<=");
    727         PXOPT_COPY_STR(config->args, where, "-filter",     "rawInput.filter", "==");
     717        PXOPT_COPY_STR(config->args, where, "-filter",     "rawInput.filter", "LIKE");
    728718    } else {
    729719        PXOPT_COPY_S64(config->args, where, "-exp_id", "rawTemplate.exp_id", "==");
    … …  
    732722        PXOPT_COPY_TIME(config->args, where, "-dateobs_begin", "rawTemplate.dateobs",  ">=");
    733723        PXOPT_COPY_TIME(config->args, where, "-dateobs_end",   "rawTemplate.dateobs",  "<=");
    734         PXOPT_COPY_STR(config->args, where, "-filter",     "rawTemplate.filter", "==");
     724        PXOPT_COPY_STR(config->args, where, "-filter",     "rawTemplate.filter", "LIKE");
    735725    }
    736726
    … …  
    745735    psString query = pxDataGet("difftool_skyfile.sql");
    746736    if (!query) {
    747         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     737        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    748738        return false;
    749739    }
    … …  
    756746        psStringAppend(&query, " WHERE diffRun.diff_id is not null %s", where2);
    757747    } else if (!all) {
    758         psError(PXTOOLS_ERR_DATA, true, "search parameters or -all are required");
     748        psError(PXTOOLS_ERR_CONFIG, true, "search parameters or -all are required");
    759749        return false;
    760750    }
    761751    psFree(where);
    762752
     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           
    763761    // treat limit == 0 as "no limit"
    764762    if (limit) {
    … …  
    816814    psMetadata *where = psMetadataAlloc();
    817815    PXOPT_COPY_S64(config->args, where,  "-diff_id", "diffSkyfile.diff_id", "==");
    818     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", "==");
    819818    PXOPT_COPY_S16(config->args, where, "-fault",     "fault", "==");
    820819
    821820    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    822821        psFree(where);
    823         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
    824         return false;
    825     }
    826 
    827     if (!psDBTransaction(config->dbh)) {
    828         psError(PS_ERR_UNKNOWN, false, "database error");
    829         psFree(where);
    830         return false;
    831     }
    832 
    833     // Update state to 'new'
     822        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     823        return false;
     824    }
     825
    834826    {
    835         psString query = pxDataGet("difftool_revertdiffskyfile_update.sql");
     827        psString query = pxDataGet("difftool_revertdiffskyfile_delete.sql");
    836828        if (!query) {
    837             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    838             if (!psDBRollback(config->dbh)) {
    839                 psError(PS_ERR_UNKNOWN, false, "database error");
    840             }
     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");
    841835            return false;
    842836        }
    … …  
    845839            psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    846840            psStringAppend(&query, " AND %s", whereClause);
     841            psStringAppend(&query_updated, " AND %s", whereClause);
    847842            psFree(whereClause);
    848843        }
    … …  
    851846            psError(PS_ERR_UNKNOWN, false, "database error");
    852847            psFree(query);
    853             if (!psDBRollback(config->dbh)) {
    854                 psError(PS_ERR_UNKNOWN, false, "database error");
    855             }
    856848            return false;
    857849        }
    858850        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);
    859859
    860860        psLogMsg("difftool", PS_LOG_INFO, "Updated %" PRIu64 " rows", psDBAffectedRows(config->dbh));
    861861    }
    862862
    863     // Delete product
    864     {
    865         psString query = pxDataGet("difftool_revertdiffskyfile_delete.sql");
    866         if (!query) {
    867             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    868             if (!psDBRollback(config->dbh)) {
    869                 psError(PS_ERR_UNKNOWN, false, "database error");
    870             }
    871             return false;
    872         }
    873 
    874         if (psListLength(where->list)) {
    875             psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    876             psStringAppend(&query, " AND %s", whereClause);
    877             psFree(whereClause);
    878         }
    879 
    880         if (!p_psDBRunQuery(config->dbh, query)) {
    881             psError(PS_ERR_UNKNOWN, false, "database error");
    882             psFree(query);
    883             if (!psDBRollback(config->dbh)) {
    884                 psError(PS_ERR_UNKNOWN, false, "database error");
    885             }
    886             return false;
    887         }
    888         psFree(query);
    889 
    890         psLogMsg("difftool", PS_LOG_INFO, "Deleted %" PRIu64 " rows", psDBAffectedRows(config->dbh));
    891     }
    892 
    893863    psFree(where);
    894864
    895     if (!psDBCommit(config->dbh)) {
    896         psError(PS_ERR_UNKNOWN, false, "database error");
    897         return false;
    898     }
    899865
    900866    return true;
    … …  
    914880    if (magicked) {
    915881      char *query = "UPDATE diffRun SET state = '%s', magicked = %" PRId64 " WHERE diff_id = %"PRId64;
    916      
     882
    917883      if (!p_psDBRunQueryF(config->dbh, query, state, magicked, diff_id)) {
    918884        psError(PS_ERR_UNKNOWN, false,
    … …  
    923889    else {
    924890      char *query = "UPDATE diffRun SET state = '%s' WHERE diff_id = %"PRId64;
    925      
     891
    926892      if (!p_psDBRunQueryF(config->dbh, query, state, diff_id)) {
    927893        psError(PS_ERR_UNKNOWN, false,
    … …  
    930896      }
    931897    }
    932    
     898
    933899    return true;
    934900}
    … …  
    948914  if (!p_psDBRunQueryF(config->dbh,query,state,label)) {
    949915    psError(PS_ERR_UNKNOWN, false,
    950             "failed to change state for label %s", label);
     916            "failed to change state for label %s", label);
    951917    return(false);
    952918  }
    … …  
    986952        return false;
    987953    }
     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
    988968
    989969    // default
    … …  
    1005985            false,
    1006986            0,       // magicked
     987            diff_mode, // diff_mode
    1007988            note
    1008989    );
    … …  
    11101091
    11111092    psArray *list = psArrayAllocEmpty(16); // List of runs, to print
    1112 
     1093    // Populated Run will generate the diff_mode value
    11131094    if (!populatedrun(list, workdir, skycell_id, tess_id, label, data_group ? data_group : label, dist_group, reduction, note,
    11141095                      input_warp_id ? input_warp_id : PS_MAX_S64,
    … …  
    11381119
    11391120    psMetadata *expWhere = psMetadataAlloc();
    1140     psMetadata *warpWhere = psMetadataAlloc();
     1121    psMetadata *warp1Where = psMetadataAlloc(); // First set of restrictions on warp
     1122    psMetadata *warp2Where = psMetadataAlloc(); // Second set of restriction on warp
    11411123    psMetadata *stackWhere = psMetadataAlloc();
    11421124
    11431125    PXOPT_COPY_S64(config->args, expWhere, "-exp_id", "exp_id", "==");
    11441126    PXOPT_COPY_STR(config->args, expWhere, "-filter", "filter", "==");
    1145     PXOPT_COPY_S64(config->args, warpWhere, "-warp_id", "warpRun.warp_id", "==");
    1146     PXOPT_COPY_STR(config->args, warpWhere, "-skycell_id", "warpSkyfile.skycell_id", "==");
    1147     PXOPT_COPY_STR(config->args, warpWhere, "-tess_id", "warpRun.tess_id", "==");
    1148     PXOPT_COPY_STR(config->args, warpWhere, "-warp_label", "warpRun.label", "==");
    1149     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", ">=");
    11501138    PXOPT_COPY_STR(config->args, stackWhere, "-stack_label", "stackRun.label", "==");
    11511139
    … …  
    11671155    psString query = pxDataGet("difftool_definewarpstack_part1.sql");
    11681156    if (!query) {
    1169         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1170         return false;
    1171     }
    1172 
    1173     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;
    11741163    psString stackQuery = NULL;
    11751164    psString expQuery = NULL;
    … …  
    11831172    }
    11841173    psFree(expWhere);
    1185     if (psListLength(warpWhere->list)) {
    1186         psString whereClause = psDBGenerateWhereConditionSQL(warpWhere, NULL);
    1187         psStringAppend(&warpQuery, "\n AND %s", whereClause);
     1174    if (psListLength(warp1Where->list)) {
     1175        psString whereClause = psDBGenerateWhereConditionSQL(warp1Where, NULL);
     1176        psStringAppend(&warp1Query, "\n AND %s", whereClause);
    11881177        psFree(whereClause);
    11891178    } else {
    1190         warpQuery = psStringCopy("\n");
    1191     }
    1192     psFree(warpWhere);
    1193 
    1194     if (!available) {
    1195         // diff what's available, even if warp run has some faults and is incomplete
    1196         psStringAppend(&warpQuery, " AND warpRun.state = 'full'");
    1197     }
     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);
    11981190
    11991191    // don't queue for exposures that have already been diff'd unless requested
    … …  
    12141206    psFree(stackWhere);
    12151207
    1216     psTrace("difftool", 1, query, warpQuery, diffQuery, expQuery, stackQuery);
     1208    psTrace("difftool", 1, query, warp1Query, warp2Query, diffQuery, expQuery, stackQuery);
    12171209
    12181210    if (!psDBTransaction(config->dbh)) {
    … …  
    12211213    }
    12221214
    1223     if (!p_psDBRunQueryF(config->dbh, query, warpQuery, expQuery, diffQuery)) {
     1215    if (!p_psDBRunQueryF(config->dbh, query, warp1Query, warp2Query, expQuery, diffQuery)) {
    12241216        psError(PS_ERR_UNKNOWN, false, "database error");
    12251217        psFree(query);
    … …  
    12811273        return false;
    12821274    }
     1275    psFree(warp1Query);
    12831276    psFree(query);
    12841277    query = NULL;
    … …  
    13121305        if (!p_psDBRunQuery(config->dbh, "DELETE FROM skycellsToDiff")) {
    13131306            psError(PS_ERR_UNKNOWN, false, "database error");
    1314             psFree(warpQuery);
     1307            psFree(warp2Query);
    13151308            psFree(stackQuery);
    13161309            psFree(skycell_query);
    … …  
    13231316        if (!mdok) {
    13241317            psError(PXTOOLS_ERR_PROG, false, "warp_id not found --- ignoring row %ld", i);
    1325             psFree(warpQuery);
     1318            psFree(warp2Query);
    13261319            psFree(stackQuery);
    13271320            psFree(skycell_query);
    … …  
    13341327        if (!mdok) {
    13351328            psError(PXTOOLS_ERR_PROG, false, "skycell_count not found");
    1336             psFree(warpQuery);
     1329            psFree(warp2Query);
    13371330            psFree(stackQuery);
    13381331            psFree(skycell_query);
    … …  
    13451338        if (!mdok) {
    13461339            psError(PXTOOLS_ERR_PROG, false, "tess_id not found");
    1347             psFree(warpQuery);
     1340            psFree(warp2Query);
    13481341            psFree(stackQuery);
    13491342            psFree(skycell_query);
    … …  
    13531346            return false;
    13541347        }
     1348
    13551349        psString filter = psMetadataLookupStr(&mdok, row, "filter");
    13561350        if (!mdok) {
    13571351            psError(PXTOOLS_ERR_PROG, false, "filter not found");
    1358             psFree(warpQuery);
     1352            psFree(warp2Query);
    13591353            psFree(stackQuery);
    13601354            psFree(skycell_query);
    … …  
    13641358            return false;
    13651359        }
    1366         if (!p_psDBRunQueryF(config->dbh, skycell_query, stackQuery, warp_id, filter, warpQuery)) {
    1367             psError(PS_ERR_UNKNOWN, false, "database error");
    1368             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);
    13691379            psFree(stackQuery);
    13701380            psFree(skycell_query);
    … …  
    13771387
    13781388        if (num == 0) {
    1379             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);
    13801390            continue;
    13811391        }
    … …  
    13831393        if (!available && (num != skycell_count)) {
    13841394            psTrace("difftool", PS_LOG_INFO, "%" PRId64 " skyfiles with stack found for warp_id %" PRId64
    1385                     " need %" PRId64, num, warp_id, skycell_count);
     1395                    " but need %" PRId64, num, warp_id, skycell_count);
    13861396            continue;
    13871397        }
    … …  
    14021412                true,                   // exposure
    14031413                0,       // magicked
     1414                IPP_DIFF_MODE_WARP_STACK,
    14041415                note
    14051416        );
    … …  
    14181429        if (!p_psDBRunQuery(config->dbh, query)) {
    14191430            psError(PS_ERR_UNKNOWN, false, "database error");
    1420             psFree(warpQuery);
     1431            psFree(warp2Query);
    14211432            psFree(stackQuery);
    14221433            psFree(skycell_query);
    … …  
    14321443        if (!p_psDBRunQuery(config->dbh, query)) {
    14331444            psError(PS_ERR_UNKNOWN, false, "database error");
    1434             psFree(warpQuery);
     1445            psFree(warp2Query);
    14351446            psFree(stackQuery);
    14361447            psFree(skycell_query);
    … …  
    14471458            psError(PS_ERR_UNKNOWN, false, "failed to change diffRun.state for diff_id: %" PRId64,
    14481459                run->diff_id);
    1449             psFree(warpQuery);
     1460            psFree(warp2Query);
    14501461            psFree(stackQuery);
    14511462            psFree(skycell_query);
    … …  
    14611472    }
    14621473    psFree(output);
    1463     psFree(warpQuery);
     1474    psFree(warp2Query);
    14641475    psFree(stackQuery);
    14651476    psFree(skycell_query);
    … …  
    15491560    // Additional controls
    15501561    PXOPT_LOOKUP_BOOL(rerun, config->args, "-rerun", false);
    1551     PXOPT_LOOKUP_BOOL(available, config->args, "-available", false);
    15521562
    15531563    // Settings to apply to defined run
    … …  
    15741584        psString tempCreate = pxDataGet("difftool_definewarpwarp_temp_create.sql"); // Create temp table SQL
    15751585        if (!tempCreate) {
    1576             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1586            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    15771587            psFree(selectWhere);
    15781588            psFree(insertWhere);
    … …  
    15971607        psString tempInsert = pxDataGet("difftool_definewarpwarp_temp_insert.sql"); // Insert to temp table
    15981608        if (!tempInsert) {
    1599             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1609            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    16001610            psFree(selectWhere);
    16011611            psFree(insertWhere);
    … …  
    16291639    psString select = pxDataGet("difftool_definewarpwarp_select.sql");
    16301640    if (!select) {
    1631         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1641        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    16321642        psFree(selectWhere);
    16331643        psFree(insertWhere);
    … …  
    16421652    if (psListLength(selectWhere->list)) {
    16431653        psString new = psDBGenerateWhereConditionSQL(selectWhere, NULL);
    1644         psStringAppend(&whereClause, "\n%s %s", whereClause ? "AND" : "WHERE", new);
     1654        psStringAppend(&whereClause, "\nAND %s", new);
    16451655        psFree(new);
    16461656    }
    16471657    psFree(selectWhere);
    16481658
    1649     if (!available) {
    1650         psStringAppend(&whereClause,
    1651                        "\n%s inputWarpRun.state = 'full'"
    1652                        "AND templateWarpRun.state = 'full'",
    1653                        whereClause ? "AND" : "WHERE");
    1654     }
    1655 
    16561659    if (!rerun) {
    1657         psStringAppend(&whereClause, "\n%s diffs.diff_id IS NULL", whereClause ? "AND" : "WHERE");
     1660        psStringAppend(&whereClause, "\nAND diffs.diff_id IS NULL");
    16581661    }
    16591662
    … …  
    17321735        const char *template = psMetadataLookupStr(NULL, row, "template_warp_id");
    17331736        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
    17341742        if (!input_id || !template || !tess_id) {
    17351743            psError(PXTOOLS_ERR_PROG, false, "Identifiers not found");
    … …  
    17421750            return false;
    17431751        }
    1744 
    1745         diffRunRow *run = diffRunRowAlloc(0, "reg", workdir, label, data_group ? data_group : label, dist_group, reduction, NULL, registered,
    1746                                           tess_id, true, true, false, note); // 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
    17471768        if (!diffRunInsertObject(config->dbh, run)) {
    17481769            psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    18161837}
    18171838
     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}
    18182138
    18192139static bool pendingcleanuprunMode(pxConfig *config)
    … …  
    18252145
    18262146    psMetadata *where = psMetadataAlloc();
    1827     pxAddLabelSearchArgs (config, where, "-label", "label", "==");
     2147    pxAddLabelSearchArgs (config, where, "-label", "diffRun.label", "==");
    18282148
    18292149    psString query = pxDataGet("difftool_pendingcleanuprun.sql");
    18302150    if (!query) {
    1831         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1832         return false;
    1833     }
     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;
    18342158
    18352159    if (where && psListLength(where->list)) {
    18362160        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    1837         psStringAppend(&query, " AND %s", whereClause);
     2161        psStringAppend(&whereClause, " AND ");
     2162        psStringSubstitute(&query,whereClause,"@INNERCONSTRAINT@");
    18382163        psFree(whereClause);
     2164    }
     2165    else {
     2166      psStringSubstitute(&query,NULL,"@INNERCONSTRAINT@");
    18392167    }
    18402168    psFree(where);
    … …  
    18462174        psFree(limitString);
    18472175    }
    1848 
    18492176    //    fprintf(stderr,"%s",query);
     2177
     2178    //fprintf(stderr,"%s",query);
    18502179    if (!p_psDBRunQuery(config->dbh, query)) {
    18512180        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    18952224    psString query = pxDataGet("difftool_pendingcleanupskyfile.sql");
    18962225    if (!query) {
    1897         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     2226        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    18982227        return false;
    18992228    }
    … …  
    19552284    psString query = pxDataGet("difftool_donecleanup.sql");
    19562285    if (!query) {
    1957         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     2286        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    19582287        return false;
    19592288    }
    … …  
    20102339    psMetadata *where = psMetadataAlloc();
    20112340    PXOPT_COPY_S64(config->args, where, "-diff_id",   "diff_id",   "==");
     2341    PXOPT_COPY_STR(config->args, where, "-skycell_id", "skycell_id",   "==");
    20122342
    20132343    if (!pxSetFaultCode(config->dbh, "diffSkyfile", where, fault)) {
    … …  
    20272357  PXOPT_LOOKUP_S64(diff_id, config->args, "-diff_id", true, false);
    20282358  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  }
    20292366
    20302367  psString query = pxDataGet("difftool_change_skyfile_data_state.sql");
    … …  
    20352372  }
    20362373
     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
    20372385  // Uses the unconstrained (diffRun.state [NEED NOT EQUAL] run_state) version from warptool.c
    20382386
    2039   if (!p_psDBRunQueryF(config->dbh, query, data_state, diff_id, skycell_id)) {
     2387  if (!p_psDBRunQueryF(config->dbh, query, data_state, set_magicked_skyfile, diff_id, skycell_id)) {
    20402388    psError(PS_ERR_UNKNOWN, false, "database error");
    20412389    // rollback
    … …  
    20442392    }
    20452393    psError(PS_ERR_UNKNOWN, false, "database error");
     2394    psFree(set_magicked_skyfile);
    20462395    return(false);
    20472396  }
     2397  psFree(set_magicked_skyfile);
    20482398  psFree(query);
    20492399
    20502400  query = pxDataGet("difftool_change_run_state.sql");
    2051   if (!p_psDBRunQueryF(config->dbh, query, data_state, diff_id, data_state)) {
     2401  if (!p_psDBRunQueryF(config->dbh, query, data_state, set_magicked_run, diff_id, data_state)) {
    20522402    // rollback
    20532403    if (!psDBRollback(config->dbh)) {
    … …  
    20552405    }
    20562406    psError(PS_ERR_UNKNOWN, false, "database error");
     2407    psFree(set_magicked_run);
    20572408    return(false);
    20582409  }
    … …  
    20602411  if (!psDBCommit(config->dbh)) {
    20612412    psError(PS_ERR_UNKNOWN, false, "database error");
     2413    psFree(set_magicked_run);
    20622414    return(false);
    20632415  }
    2064  
     2416  psFree(set_magicked_run);
     2417
    20652418  return(true);
    20662419}
    … …  
    20742427static bool toscrubbedskyfileMode(pxConfig *config) {
    20752428  return change_skyfile_data_state(config, "scrubbed", "goto_scrubbed");
     2429}
     2430static bool tofullskyfileMode(pxConfig *config) {
     2431  return change_skyfile_data_state(config, "full", "update");
    20762432}
    20772433
    … …  
    21152471    psString query = pxDataGet(tables[i].sqlFilename);
    21162472    if (!query) {
    2117       psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     2473      psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    21182474      return false;
    21192475    }
    … …  
    22522608  return true;
    22532609}
     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/tap_branches/ippTools/src/difftool.h

    r25800 r27838  
    3737    DIFFTOOL_MODE_DEFINEWARPSTACK,
    3838    DIFFTOOL_MODE_DEFINEWARPWARP,
     39    DIFFTOOL_MODE_DEFINESTACKSTACK,
    3940    DIFFTOOL_MODE_PENDINGCLEANUPRUN,
    4041    DIFFTOOL_MODE_PENDINGCLEANUPSKYFILE,
    … …  
    4546    DIFFTOOL_MODE_TOCLEANEDSKYFILE,
    4647    DIFFTOOL_MODE_TOPURGEDSKYFILE,
    47     DIFFTOOL_MODE_TOSCRUBBEDSKYFILE
    48    
     48    DIFFTOOL_MODE_TOSCRUBBEDSKYFILE,
     49    DIFFTOOL_MODE_TOFULLSKYFILE,
     50    DIFFTOOL_MODE_LISTRUN,
     51    DIFFTOOL_MODE_SETSKYFILETOUPDATE,
    4952} difftoolMode;
    5053

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

    r25840 r27838  
    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;
    … …  
    5656    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_data_group",  0,     "define data group", NULL);
    5757    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);
    5859    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_note",  0,           "define note", NULL);
    5960    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    … …  
    6465    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,            "set state", NULL);
    6566    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);
    6668    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_label", 0,        "define new value for label", 0);
    6769    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state", 0,        "define new state", NULL);
    6870    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_data_group", 0,   "define new data_group", NULL);
    6971    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);
    7073    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_note", 0,         "define new note", NULL);
    7174
    … …  
    122125    psMetadataAddStr(adddiffskyfileArgs, PS_LIST_TAIL, "-hostname", 0,   "define hostname", 0);
    123126    psMetadataAddF32(adddiffskyfileArgs, PS_LIST_TAIL, "-good_frac",  0, "define %% of good pixels", NAN);
    124     psMetadataAddBool(adddiffskyfileArgs, PS_LIST_TAIL, "-magicked",  0, "define magicked state", false);
     127    psMetadataAddS64(adddiffskyfileArgs, PS_LIST_TAIL, "-magicked",  0, "define magicked state", 0);
    125128
    126129    // -advance
    … …  
    144147    psMetadataAddStr(diffskyfileArgs, PS_LIST_TAIL,  "-filter", 0,           "search for filter", NULL);
    145148    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);
    146151    psMetadataAddS16(diffskyfileArgs, PS_LIST_TAIL,  "-fault",  0,           "search by fault code", 0);
    147152    pxmagicAddArguments(diffskyfileArgs);
    148153    pxspaceAddArguments(diffskyfileArgs);
    149154
     155    psMetadataAddBool(diffskyfileArgs, PS_LIST_TAIL, "-pstamp_order",  0,    "order results for postage stamp server", false);
    150156    psMetadataAddBool(diffskyfileArgs, PS_LIST_TAIL, "-all",  0,             "search without arguments", false);
    151157    psMetadataAddU64(diffskyfileArgs, PS_LIST_TAIL,  "-limit",  0,            "limit result set to N items", 0);
    152158    psMetadataAddBool(diffskyfileArgs, PS_LIST_TAIL, "-simple",  0,          "use the simple output format", false);
    153159
     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
     183
    154184    // -revertdiffskyfile
    155185    psMetadata *revertdiffskyfileArgs = psMetadataAlloc();
    156186    psMetadataAddS64(revertdiffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,            "search by diff ID", 0);
    157     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);
    158189    psMetadataAddS16(revertdiffskyfileArgs, PS_LIST_TAIL, "-fault",  0,            "search by fault code", 0);
    159190    psMetadataAddBool(revertdiffskyfileArgs, PS_LIST_TAIL, "-all",  0, "allow no search terms", 0);
    … …  
    180211    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-tess_id", 0, "search by tess ID", NULL);
    181212    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-filter", 0, "search by filter", NULL);
     213    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-comment", 0, "search by comment (LIKE)", NULL);
    182214    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-stack_label", 0, "search by stack label", NULL);
    183215    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);
    184217    psMetadataAddF32(definewarpstackArgs, PS_LIST_TAIL, "-good_frac", 0, "minimum good fraction of skycell", NAN);
    185218    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-set_workdir", 0, "define workdir (required)", NULL);
    … …  
    192225    psMetadataAddBool(definewarpstackArgs, PS_LIST_TAIL, "-new-templates", 0, "also search for diffs with new template", false);
    193226    psMetadataAddBool(definewarpstackArgs, PS_LIST_TAIL, "-rerun", 0, "define new run even if one exists", false);
    194     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);
    195228    psMetadataAddBool(definewarpstackArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    196229    psMetadataAddBool(definewarpstackArgs, PS_LIST_TAIL, "-pretend", 0, "list results but to not queue", false);
    … …  
    217250    psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-set_note",  0,           "define note", NULL);
    218251    psMetadataAddBool(definewarpwarpArgs, PS_LIST_TAIL, "-rerun", 0, "define new run even if one exists", false);
    219     psMetadataAddBool(definewarpwarpArgs, PS_LIST_TAIL, "-available", 0, "define new run even if warpRun has some faults", false);
    220252    psMetadataAddBool(definewarpwarpArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    221253    psMetadataAddBool(definewarpwarpArgs, PS_LIST_TAIL, "-pretend", 0, "list results but to not queue", false);
    … …  
    250282    psMetadataAddStr(definewarpwarpArgs,  PS_LIST_TAIL, "-comment",            0, "search by comment field (LIKE comparison)", NULL);
    251283
     284    // -definestackstack
     285    psMetadata *definestackstackArgs = psMetadataAlloc();
     286    // stack id and exp id searches seem less useful here
     287    psMetadataAddStr(definestackstackArgs, PS_LIST_TAIL, "-skycell_id", 0, "search by skycell ID", NULL);
     288    psMetadataAddStr(definestackstackArgs, PS_LIST_TAIL, "-tess_id", 0, "search by tess ID", NULL);
     289    psMetadataAddStr(definestackstackArgs, PS_LIST_TAIL, "-filter", 0, "search by filter", NULL);
     290    psMetadataAddStr(definestackstackArgs, PS_LIST_TAIL, "-input_label", 0, "search by stack label for input", NULL);
     291    psMetadataAddStr(definestackstackArgs, PS_LIST_TAIL, "-template_label", 0, "search by stack label for template", NULL);
     292    psMetadataAddF32(definestackstackArgs, PS_LIST_TAIL, "-good_frac", 0, "minimum good fraction of skycell", NAN);
     293    psMetadataAddStr(definestackstackArgs, PS_LIST_TAIL, "-set_workdir", 0, "define workdir (required)", NULL);
     294    psMetadataAddStr(definestackstackArgs, PS_LIST_TAIL, "-set_label", 0, "define label", NULL);
     295    psMetadataAddStr(definestackstackArgs, PS_LIST_TAIL, "-set_reduction", 0, "define reduction class", NULL);
     296    psMetadataAddTime(definestackstackArgs, PS_LIST_TAIL, "-set_registered", 0, "time detrend run was registered", now);
     297    psMetadataAddStr(definestackstackArgs, PS_LIST_TAIL, "-set_data_group", 0, "define data group", NULL);
     298    psMetadataAddStr(definestackstackArgs, PS_LIST_TAIL, "-set_dist_group", 0, "define dist group", NULL);
     299    psMetadataAddStr(definestackstackArgs, PS_LIST_TAIL, "-set_note", 0, "define note", NULL);
     300    psMetadataAddBool(definestackstackArgs, PS_LIST_TAIL, "-rerun", 0, "define new run even if one exists", false);
     301    psMetadataAddBool(definestackstackArgs, PS_LIST_TAIL, "-available", 0, "define new run even if no stacks available for some skycells", false);
     302    psMetadataAddBool(definestackstackArgs, PS_LIST_TAIL, "-new-templates", 0, "also search for diffs with new template", false);
     303    psMetadataAddBool(definestackstackArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     304    psMetadataAddBool(definestackstackArgs, PS_LIST_TAIL, "-pretend", 0, "list results but do not queue", false);
     305
     306
    252307    // -pendingcleanuprun
    253308    psMetadata *pendingcleanuprunArgs = psMetadataAlloc();
    254     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);
    255310    psMetadataAddBool(pendingcleanuprunArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    256311    psMetadataAddU64(pendingcleanuprunArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    … …  
    271326    psMetadata *updatediffskyfileArgs = psMetadataAlloc();
    272327    psMetadataAddS64(updatediffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,      "define diff ID (required)", 0);
    273     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);
    274330
    275331    // -tocleanedskyfile
    … …  
    287343    psMetadataAddS64(toscrubbedskyfileArgs, PS_LIST_TAIL, "-diff_id", 0, "difftool ID to update", 0);
    288344    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
    289359
    290360    // -exportrun
    … …  
    314384    PXOPT_ADD_MODE("-advance",          "", DIFFTOOL_MODE_ADVANCE,           advanceArgs);
    315385    PXOPT_ADD_MODE("-diffskyfile",      "", DIFFTOOL_MODE_DIFFSKYFILE,       diffskyfileArgs);
     386    PXOPT_ADD_MODE("-listrun",          "", DIFFTOOL_MODE_LISTRUN,           listrunArgs);
    316387    PXOPT_ADD_MODE("-revertdiffskyfile","", DIFFTOOL_MODE_REVERTDIFFSKYFILE, revertdiffskyfileArgs);
    317388    PXOPT_ADD_MODE("-definepoprun",     "", DIFFTOOL_MODE_DEFINEPOPRUN,      definepoprunArgs);
    318389    PXOPT_ADD_MODE("-definewarpstack",  "", DIFFTOOL_MODE_DEFINEWARPSTACK,   definewarpstackArgs);
    319390    PXOPT_ADD_MODE("-definewarpwarp",   "", DIFFTOOL_MODE_DEFINEWARPWARP,    definewarpwarpArgs);
     391    PXOPT_ADD_MODE("-definestackstack", "", DIFFTOOL_MODE_DEFINESTACKSTACK,  definestackstackArgs);
    320392    PXOPT_ADD_MODE("-pendingcleanuprun",     "show runs that need to be cleaned up", DIFFTOOL_MODE_PENDINGCLEANUPRUN,    pendingcleanuprunArgs);
    321393    PXOPT_ADD_MODE("-pendingcleanupskyfile", "show runs that need to be cleaned up", DIFFTOOL_MODE_PENDINGCLEANUPSKYFILE, pendingcleanupskyfileArgs);
    322394    PXOPT_ADD_MODE("-donecleanup",           "show runs that have been cleaned",     DIFFTOOL_MODE_DONECLEANUP,          donecleanupArgs);
    323395    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
    324398    PXOPT_ADD_MODE("-exportrun",            "export run for import on other database", DIFFTOOL_MODE_EXPORTRUN, exportrunArgs);
    325399    PXOPT_ADD_MODE("-importrun",            "import run from metadata file",           DIFFTOOL_MODE_IMPORTRUN, importrunArgs);
    … …  
    328402    PXOPT_ADD_MODE("-topurgedskyfile", "set skyfile as purged", DIFFTOOL_MODE_TOPURGEDSKYFILE, topurgedskyfileArgs);
    329403    PXOPT_ADD_MODE("-toscrubbedskyfile", "set skyfile as scrubbed", DIFFTOOL_MODE_TOSCRUBBEDSKYFILE, toscrubbedskyfileArgs);
    330    
     404    PXOPT_ADD_MODE("-tofullskyfile", "set skyfile as full", DIFFTOOL_MODE_TOFULLSKYFILE, tofullskyfileArgs);
     405
    331406    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {
    332407        psError(PS_ERR_UNKNOWN, true, "option parsing failed");

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

    r25835 r27838  
    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);
     54static bool listtargetsMode(pxConfig *config);
    5255
    5356static bool definedestinationMode(pxConfig *config);
    … …  
    8689        MODECASE(DISTTOOL_MODE_TOADVANCE, toadvanceMode);
    8790        MODECASE(DISTTOOL_MODE_PENDINGFILESET, pendingfilesetMode);
     91        MODECASE(DISTTOOL_MODE_PENDINGCLEANUP, pendingcleanupMode);
    8892        MODECASE(DISTTOOL_MODE_ADDFILESET, addfilesetMode);
    8993        MODECASE(DISTTOOL_MODE_REVERTFILESET, revertfilesetMode);
     94        MODECASE(DISTTOOL_MODE_LISTFILESETS, listfilesetsMode);
     95        MODECASE(DISTTOOL_MODE_UPDATEFILESET, updatefilesetMode);
    9096        MODECASE(DISTTOOL_MODE_QUEUERCRUN, queuercrunMode);
    9197        MODECASE(DISTTOOL_MODE_UPDATERCRUN, updatercrunMode);
    … …  
    94100        MODECASE(DISTTOOL_MODE_DEFINETARGET, definetargetMode);
    95101        MODECASE(DISTTOOL_MODE_UPDATETARGET, updatetargetMode);
    96         MODECASE(DISTTOOL_MODE_LISTTARGET, listtargetMode);
     102        MODECASE(DISTTOOL_MODE_LISTTARGETS, listtargetsMode);
    97103        MODECASE(DISTTOOL_MODE_DEFINEDESTINATION, definedestinationMode);
    98104        MODECASE(DISTTOOL_MODE_UPDATEDESTINATION, updatedestinationMode);
    … …  
    131137
    132138    // optional
    133     PXOPT_LOOKUP_S64(magic_ds_id, config->args, "-magic_ds_id",  false, false);
     139    PXOPT_LOOKUP_BOOL(use_alternate, config->args, "-use_alternate", false);
    134140    PXOPT_LOOKUP_BOOL(no_magic, config->args, "-no_magic", false);
    135141    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);
    136143    PXOPT_LOOKUP_STR(set_note, config->args, "-set_note", false, false);
    137144
    138145    PXOPT_LOOKUP_S64(limit, config->args, "-limit", false, false);
    139146    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    140    
    141     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    }
    142160
    143161    // select arguments
    … …  
    155173    psString runJoinStr = NULL;
    156174    if (!strcmp(stage, "raw")) {
    157         magicRunType = "rawExp";
    158         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        }
    159182        query = pxDataGet("disttool_definebyquery_raw.sql");
    160183        if (!query) {
    161             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     184            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    162185            psFree(where);
    163186            return false;
    164187        }
    165188
    166         // 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
    167190        if (label) {
    168             psStringAppend(&query, " AND (chipRun.label = '%s')", label);
     191            psStringAppend(&query, " AND (magicDSRun.label = '%s')", label);
    169192        }
    170193        if (dist_group) {
    171             psStringAppend(&query, " AND (chipRun.dist_group = '%s')", dist_group);
     194            psStringAppend(&query, " AND (camRun.dist_group = '%s')", dist_group);
    172195        }
    173196    } else if (!strcmp(stage, "chip")) {
    … …  
    176199        query = pxDataGet("disttool_definebyquery_chip.sql");
    177200        if (!query) {
    178             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     201            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    179202            psFree(where);
    180203            return false;
    … …  
    192215        query = pxDataGet("disttool_definebyquery_camera.sql");
    193216        if (!query) {
    194             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     217            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    195218            psFree(where);
    196219            return false;
    … …  
    207230        query = pxDataGet("disttool_definebyquery_fake.sql");
    208231        if (!query) {
    209             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     232            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    210233            psFree(where);
    211234            return false;
    … …  
    225248        query = pxDataGet("disttool_definebyquery_warp.sql");
    226249        if (!query) {
    227             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     250            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    228251            psFree(where);
    229252            return false;
    … …  
    242265        query = pxDataGet("disttool_definebyquery_diff.sql");
    243266        if (!query) {
    244             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     267            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    245268            psFree(where);
    246269            return false;
    … …  
    258281        query = pxDataGet("disttool_definebyquery_stack.sql");
    259282        if (!query) {
    260             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     283            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    261284            psFree(where);
    262285            return false;
    … …  
    271294        // stack stage doesn't require magic
    272295        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;   
    273314    } else {
    274315        psError(PS_ERR_UNKNOWN, true, "unknown value for stage: %s", stage);
    275316        psFree(where);
    276317        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        }
    277325    }
    278326
    … …  
    287335
    288336    if (!no_magic) {
    289         psStringAppend(&query, " AND (%s.magicked)", magicRunType);
    290 
    291         // is selecting by magic_ds_id really interesting?
    292         if (magic_ds_id) {
    293             if (!runJoinStr) {
    294                 psError(PS_ERR_PROGRAMMING, true, "cannot select by magic_ds_id for stage: %s", stage);
    295                 psFree(query);
    296                 return false;
    297             }
    298             psStringAppend(&joinHook, "\nJOIN magicDSRun ON magicDSRun.stage = distTarget.stage"
    299                                               " AND magicDSRun.stage_id = %s", runJoinStr);
    300             psStringAppend(&query, " AND (magicDSRun.state = 'full' AND magicDSRun.re_place AND (magic_ds_id = %" PRId64 "))", magic_ds_id);
    301         }
     337        psStringAppend(&query, " AND (%s.magicked > 0)", magicRunType);
    302338    }
    303339
    … …  
    307343        psFree(limitString);
    308344    }
    309 
     345    psTrace("disttool",2,query,joinHook ? joinHook : "");
    310346    if (!p_psDBRunQueryF(config->dbh, query, joinHook ? joinHook : "")) {
    311         psError(PS_ERR_UNKNOWN, false, "database error");
    312         psFree(query);
    313         return false;
     347      psError(PS_ERR_UNKNOWN, false, "database error");
     348      psFree(query);
     349      return false;
    314350    }
    315351    psFree(query);
    … …  
    328364
    329365
    330     if (dry_run) {
     366    if (pretend) {
    331367        if (!ippdbPrintMetadatas(stdout, output, "newdistRuns", true)) {
    332368            psError(PS_ERR_UNKNOWN, false, "failed to print array");
    … …  
    352388        psS64 target_id = psMetadataLookupS64(NULL, md, "target_id");
    353389        psString stage_label = psMetadataLookupStr(NULL, md, "label");
     390        psString stage_data_group = psMetadataLookupStr(NULL, md, "data_group");
    354391        bool clean = psMetadataLookupBool(NULL, md, "clean");
    355392
    356393        psString outroot = NULL;
    357         psStringAppend(&outroot, "%s/%s/%s", workdir, run_tag, stage); 
     394        psStringAppend(&outroot, "%s/%s/%s", workdir, run_tag, stage);
    358395
    359396        psString new_label;
    … …  
    363400            new_label = stage_label;
    364401        }
     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
    365409        distRunRow *row = distRunRowAlloc(
    366410                0,      // dist_id
    … …  
    371415                new_label,
    372416                outroot,
     417                NULL,     // outdir
    373418                clean,
    374419                no_magic,
     420                use_alternate,
    375421                "new",
    376                 NULL,   // time_stamp
     422                NULL,    // time_stamp
    377423                0,       // fault
    378                 set_note    // note does not propagate
     424                new_data_group,
     425                set_note // note does not propagate
    379426                );
    380427
    … …  
    419466    PXOPT_COPY_S64(config->args, where, "-dist_id", "dist_id", "==");
    420467    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");;
    421     PXOPT_COPY_STR(config->args, where, "-state", "state", "==");
     468    PXOPT_COPY_STR(config->args, where, "-state", "distRun.state", "==");
    422469    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", "==");
    423473
    424474    if (!psListLength(where->list)) {
    425475        psFree(where);
    426         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     476        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    427477        return false;
    428478    }
    … …  
    430480    PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
    431481    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);
    432484    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
    433 
    434     if ((!state) && (!label) && (!fault)) {
    435         psError(PXTOOLS_ERR_DATA, false, "parameters (-fault or -set_state or -set_label) are required");
    436         psFree(where);
    437         return false;
    438     }
    439 
    440     psString query = psStringCopy("UPDATE distRun SET time_stamp = UTC_TIMESTAMP()");
    441 
     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    }
    442498    if (state) {
    443         psStringAppend(&query, " , state = '%s'", state);
     499        psStringAppend(&query, " , distRun.state = '%s'", state);
    444500    }
    445501
    446502    if (label) {
    447         psStringAppend(&query, " , label = '%s'", label);
     503        psStringAppend(&query, " , distRun.label = '%s'", label);
    448504    }
    449505
    450506    if (fault) {
    451         psStringAppend(&query, " , fault = %d", fault);
    452     }
     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
    453518
    454519    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    … …  
    481546    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    482547        psFree(where);
    483         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     548        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    484549        return false;
    485550    }
    … …  
    487552    psString query = pxDataGet("disttool_revertrun.sql");
    488553    if (!query) {
    489         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     554        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    490555        if (!psDBRollback(config->dbh)) {
    491556            psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    522587    PXOPT_COPY_S64(config->args, where, "-stage_id", "stage_id", "==");
    523588    PXOPT_COPY_STR(config->args, where, "-state", "state", "==");
    524     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     589    pxAddLabelSearchArgs(config, where, "-label", "distRun.label", "==");
    525590
    526591    PXOPT_COPY_S16(config->args, where,  "-fault", "distComponent.fault", "==");
    … …  
    530595    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    531596        psFree(where);
    532         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     597        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    533598        return false;
    534599    }
    … …  
    536601    psString query = pxDataGet("disttool_revertcomponent.sql");
    537602    if (!query) {
    538         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     603        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    539604        psFree(where);
    540605        return false;
    … …  
    568633
    569634    psMetadata *where = psMetadataAlloc();
    570     PXOPT_COPY_S64(config->args, where, "-dist_id", "dist_id", "==");
     635    PXOPT_COPY_S64(config->args, where, "-dist_id", "distRun.dist_id", "==");
    571636    pxAddLabelSearchArgs (config, where, "-label", "distRun.label", "==");
    572637
    … …  
    578643    psString query = pxDataGet(queryFile);
    579644    if (!query) {
    580         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement from %s", queryFile);
     645        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement from %s", queryFile);
    581646        return false;
    582647    }
    … …  
    652717    PXOPT_LOOKUP_S32(bytes, config->args, "-bytes", require_fileinfo, false);
    653718    PXOPT_LOOKUP_STR(md5sum, config->args, "-md5sum", require_fileinfo, false);
     719    PXOPT_LOOKUP_STR(outdir, config->args, "-outdir", require_fileinfo, false);
    654720    PXOPT_LOOKUP_STR(name, config->args, "-name", require_fileinfo, false);
    655721
    656     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)) {
    657723        psError(PS_ERR_UNKNOWN, false, "database error");
    658724        return false;
    … …  
    676742    psString query = pxDataGet("disttool_toadvance.sql");
    677743    if (!query) {
    678         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     744        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    679745        return false;
    680746    }
    … …  
    747813    psString query = pxDataGet("disttool_processedcomponent.sql");
    748814    if (!query) {
    749         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     815        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    750816        return false;
    751817    }
    … …  
    821887    psString query = pxDataGet("disttool_pendingfileset.sql");
    822888    if (!query) {
    823         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     889        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    824890        return false;
    825891    }
    … …  
    891957    PXOPT_LOOKUP_STR(name, config->args, "-name", fault == 0, false);
    892958
    893     if (!rcDSFilesetInsert(config->dbh, 
     959    if (!rcDSFilesetInsert(config->dbh,
    894960            0,          // fs_id
    895961            dist_id,
    … …  
    904970    return true;
    905971}
     972
    906973static bool revertfilesetMode(pxConfig *config)
    907974{
    … …  
    920987    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    921988        psFree(where);
    922         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     989        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    923990        return false;
    924991    }
    … …  
    926993    psString query = pxDataGet("disttool_revertfileset.sql");
    927994    if (!query) {
    928         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     995        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    929996        psFree(where);
    930997        return false;
    … …  
    9681035    psString query = pxDataGet("disttool_pendingdest.sql");
    9691036    if (!query) {
    970         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1037        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    9711038        return false;
    9721039    }
    … …  
    10471114    psString query = pxDataGet("disttool_queuercrun.sql");
    10481115    if (!query) {
    1049         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1116        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10501117        return false;
    10511118    }
    … …  
    10931160    // We either need rc_id or (dest_id and fs_name) to identifiy the rcRun
    10941161    if ((!rc_id) && !(dest_id && fs_name)) {
    1095         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");
    10961163        return false;
    10971164    }
    … …  
    11051172        // this can't happen because we checked above
    11061173        psFree(where);
    1107         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     1174        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    11081175        return false;
    11091176    }
    … …  
    11151182
    11161183    if (!state && (fault < 0)) {
    1117         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");
    11181185        psFree(where);
    11191186        return false;
    … …  
    11221189    psString query = pxDataGet("disttool_updatercrun.sql");
    11231190    if (!query) {
    1124         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1191        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11251192        return false;
    11261193    }
    … …  
    11791246    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    11801247        psFree(where);
    1181         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     1248        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    11821249        return false;
    11831250    }
    … …  
    11851252    psString query = pxDataGet("disttool_revertrcrun.sql");
    11861253    if (!query) {
    1187         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1254        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11881255        if (!psDBRollback(config->dbh)) {
    11891256            psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    12381305            comment
    12391306            );
    1240            
     1307
    12411308    if (!row) {
    12421309        psError(PS_ERR_UNKNOWN, false, "failed to allocate distTarget object");
    … …  
    12981365}
    12991366
    1300 static bool listtargetMode(pxConfig *config)
     1367static bool listtargetsMode(pxConfig *config)
    13011368{
    13021369    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    14041471            state ? state : "enabled"
    14051472            );
    1406            
     1473
    14071474    if (!row) {
    14081475        psError(PS_ERR_UNKNOWN, false, "failed to allocate rcDestination object");
    … …  
    14411508    if (!(state || last_fileset)) {
    14421509        psError(PS_ERR_UNKNOWN, true, "one or more of -set_state or -set_last_fileset is required");
    1443 # else 
     1510# else
    14441511    if (!state) {
    14451512#endif
    … …  
    15381605    PXOPT_COPY_STR(config->args, where, "-dist_group", "dist_group", "LIKE");
    15391606    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "LIKE");
    1540     PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
     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    }
    15411611
    15421612    psString query = pxDataGet("disttool_defineinterest.sql");
    … …  
    15981668    PXOPT_COPY_S64(config->args, where, "-dest_id",   "dest_id", "==");
    15991669    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       
    16001683
    16011684    PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
    … …  
    16051688        return false;
    16061689    }
    1607     psString query = NULL;
    1608     psStringAppend(&query, "UPDATE rcInterest SET state = '%s'", state);
     1690    psString query = pxDataGet("disttool_updateinterest.sql");
    16091691
    16101692    if (psListLength(where->list)) {
    … …  
    16201702    psFree(where);
    16211703
     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)) {
     1711        psError(PS_ERR_UNKNOWN, false, "database error");
     1712        psFree(query);
     1713        return false;
     1714    }
     1715    psFree(query);
     1716
     1717    psS64 numUpdated = psDBAffectedRows(config->dbh);
     1718    printf("updated %" PRId64 " interests\n", numUpdated);
     1719
     1720    return true;
     1721}
     1722static bool listinterestsMode(pxConfig *config)
     1723{
     1724    PS_ASSERT_PTR_NON_NULL(config, false);
     1725
     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", "==");
     1730    PXOPT_COPY_S64(config->args, where, "-target_id", "target_id", "==");
     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");
     1748
     1749    if (psListLength(where->list)) {
     1750        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1751        psStringAppend(&query, " WHERE %s", whereClause);
     1752        psFree(whereClause);
     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");
     1762    }
     1763    psFree(where);
     1764
     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
    16221772    if (!p_psDBRunQuery(config->dbh, query)) {
    16231773        psError(PS_ERR_UNKNOWN, false, "database error");
    16241774        psFree(query);
     1775        if (!psDBRollback(config->dbh)) {
     1776            psError(PS_ERR_UNKNOWN, false, "database error");
     1777        }
    16251778        return false;
    16261779    }
    16271780    psFree(query);
    16281781
    1629     return true;
    1630 }
    1631 static bool listinterestsMode(pxConfig *config)
     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)
    16321804{
    16331805    PS_ASSERT_PTR_NON_NULL(config, false);
    16341806
    16351807    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", "==");
    16361873    PXOPT_COPY_S64(config->args, where, "-int_id", "int_id", "==");
    16371874    PXOPT_COPY_S64(config->args, where, "-dest_id", "dest_id", "==");
    … …  
    16461883    PXOPT_LOOKUP_BOOL(full, config->args, "-full", false);
    16471884
     1885    pxAddLabelSearchArgs (config, where, "-label", "distRun.label", "==");
     1886
    16481887    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    16491888    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    16501889
    1651     if (clean && full) {
    1652         psError(PS_ERR_UNKNOWN, false, "can't select both -clean and -full");
    1653         return false;
    1654     }
    1655 
    1656     psString query = pxDataGet("disttool_listinterests.sql");
    1657 
    1658     if (psListLength(where->list)) {
    1659         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    1660         psStringAppend(&query, " WHERE %s", whereClause);
    1661         psFree(whereClause);
    1662         if (clean) {
    1663             psStringAppend(&query, " AND (clean)");
    1664         } else if (full) {
    1665             psStringAppend(&query, " AND (!clean)");
    1666         }
    1667     } else if (clean) {
    1668         psStringAppend(&query, " WHERE clean");
    1669     } else if (full) {
    1670         psStringAppend(&query, " WHERE !clean");
    1671     }
     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);
    16721901    psFree(where);
    16731902
    … …  
    17001929    }
    17011930
    1702     if (!ippdbPrintMetadatas(stdout, output, "rcInterest", !simple)) {
     1931    if (!ippdbPrintMetadatas(stdout, output, "distFilesets", !simple)) {
    17031932        psError(PS_ERR_UNKNOWN, false, "failed to print array");
    17041933        psFree(output);
    … …  
    17101939    return true;
    17111940}
     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/tap_branches/ippTools/src/disttool.h

    r25835 r27838  
    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,
    … …  
    4447    DISTTOOL_MODE_DEFINETARGET,
    4548    DISTTOOL_MODE_UPDATETARGET,
    46     DISTTOOL_MODE_LISTTARGET,
     49    DISTTOOL_MODE_LISTTARGETS,
    4750    DISTTOOL_MODE_DEFINEINTEREST,
    4851    DISTTOOL_MODE_UPDATEINTEREST,

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

    r25835 r27838  
    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);
     53    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_data_group",    0, "define data_group for run", NULL);
    5254    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_note",    0, "select by dist_group", NULL);
    5355
    54     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-dry_run", 0, "don't queue runs just display what would be selected", false);
     56    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-pretend", 0, "don't queue runs just display what would be selected", false);
    5557
    5658    // select args
    57     psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-target_id",     0, "define target_id", 0);
    58     psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-exp_id",        0, "define exp_id", 0);
    59     psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-chip_id",       0, "define chip_id", 0);
    60     psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-magic_ds_id",   0, "define chip_id", 0);
     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);
    6162    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label",         0, "select by run label", NULL);
    6263    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-dist_group",    0, "select by dist_group", NULL);
    … …  
    7071    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state", 0, "new value for state", NULL);
    7172    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);
    7276    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-stage",     0, "value for stage", NULL);
    7377    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state",     0, "value for state", NULL);
    7478    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);
    7581    psMetadataAddS16(updaterunArgs, PS_LIST_TAIL, "-fault",      0, "define fault code", 0);
    76 
    7782    // -revertrun
    7883    psMetadata *revertrunArgs = psMetadataAlloc();
    … …  
    9398    psMetadataAddBool(pendingcomponentArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    9499
     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);
     108
    95109
    96110    // -addprocessedcomponent
    … …  
    98112    psMetadataAddS64(addprocessedcomponentArgs, PS_LIST_TAIL, "-dist_id", 0, "define dist_id", 0);
    99113    psMetadataAddStr(addprocessedcomponentArgs, PS_LIST_TAIL, "-component", 0, "define component (required)", NULL);
     114    psMetadataAddStr(addprocessedcomponentArgs, PS_LIST_TAIL, "-outdir", 0, "define output directory", NULL);
    100115    psMetadataAddStr(addprocessedcomponentArgs, PS_LIST_TAIL, "-name", 0, "define file name", NULL);
    101116    psMetadataAddS32(addprocessedcomponentArgs, PS_LIST_TAIL, "-bytes", 0, "define file size", 0);
    … …  
    110125    psMetadataAddS64(revertcomponentArgs, PS_LIST_TAIL, "-stage_id", 0, "define stage_id", 0);
    111126    psMetadataAddStr(revertcomponentArgs, PS_LIST_TAIL, "-state",    0, "define state", NULL);
    112     psMetadataAddStr(revertcomponentArgs, PS_LIST_TAIL, "-label",    0, "define label", NULL);
     127    psMetadataAddStr(revertcomponentArgs, PS_LIST_TAIL, "-label",    PS_META_DUPLICATE_OK, "define label", NULL);
    113128    psMetadataAddS16(revertcomponentArgs, PS_LIST_TAIL, "-fault", 0, "define fault code", 0);
    114129    psMetadataAddBool(revertcomponentArgs, PS_LIST_TAIL, "-all",    0, "revert all faulted runs", NULL);
    … …  
    142157    psMetadataAddStr(addfilesetArgs, PS_LIST_TAIL, "-name",    0, "define file name", NULL);
    143158    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);
    144166
    145167    // -pendingdest
    … …  
    162184    psMetadataAddBool(revertfilesetArgs, PS_LIST_TAIL, "-all",    0, "revert all faulted runs", NULL);
    163185
     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
    164203    // -queuercrun
    165204    psMetadata *queuercrunArgs = psMetadataAlloc();
    … …  
    228267    psMetadataAddStr(updatetargetArgs, PS_LIST_TAIL, "-set_state", 0, "define new state", NULL);
    229268
    230     // -listtarget
    231     psMetadata *listtargetArgs = psMetadataAlloc();
    232     psMetadataAddS64(listtargetArgs, PS_LIST_TAIL, "-target_id", 0, "list target with target_id", 0);
    233     psMetadataAddStr(listtargetArgs, PS_LIST_TAIL, "-dist_group",  0, "list targets for dist_group", NULL);
    234     psMetadataAddStr(listtargetArgs, PS_LIST_TAIL, "-filter",    0, "define filter", NULL);
    235     psMetadataAddStr(listtargetArgs, PS_LIST_TAIL, "-stage",     0, "list targets for stage", NULL);
    236     psMetadataAddBool(listtargetArgs, PS_LIST_TAIL,"-clean",     0, "list clean targets", false);
    237     psMetadataAddBool(listtargetArgs, PS_LIST_TAIL,"-full",      0, "list full targets", false);
    238     psMetadataAddStr(listtargetArgs, PS_LIST_TAIL, "-state",     0, "list targets in state", NULL);
    239     psMetadataAddU64(listtargetArgs, PS_LIST_TAIL, "-limit",     0, "limit number of targets listed to N", 0);
    240     psMetadataAddBool(listtargetArgs, PS_LIST_TAIL, "-simple",  0, "use the simple output format", false);
     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);
    241280
    242281    // -defineinterest
    … …  
    258297    psMetadataAddS64(updateinterestArgs, PS_LIST_TAIL, "-target_id", 0, "define target_id", 0);
    259298    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);
    260305
    261306    // -listinterests
    … …  
    285330    PXOPT_ADD_MODE("-processedcomponent", "", DISTTOOL_MODE_PROCESSEDCOMPONENT, processedcomponentArgs);
    286331    PXOPT_ADD_MODE("-toadvance",          "", DISTTOOL_MODE_TOADVANCE, toadvanceArgs);
     332    PXOPT_ADD_MODE("-pendingcleanup",     "", DISTTOOL_MODE_PENDINGCLEANUP, pendingcleanupArgs);
    287333    PXOPT_ADD_MODE("-pendingfileset",     "", DISTTOOL_MODE_PENDINGFILESET, pendingfilesetArgs);
    288334    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);
    289337    PXOPT_ADD_MODE("-revertfileset",      "", DISTTOOL_MODE_REVERTFILESET, revertfilesetArgs);
    290338    PXOPT_ADD_MODE("-queuercrun",         "", DISTTOOL_MODE_QUEUERCRUN, queuercrunArgs);
    … …  
    299347    PXOPT_ADD_MODE("-definetarget",       "", DISTTOOL_MODE_DEFINETARGET, definetargetArgs);
    300348    PXOPT_ADD_MODE("-updatetarget",       "", DISTTOOL_MODE_UPDATETARGET, updatetargetArgs);
    301     PXOPT_ADD_MODE("-listtarget",         "", DISTTOOL_MODE_LISTTARGET, listtargetArgs);
     349    PXOPT_ADD_MODE("-listtargets",         "", DISTTOOL_MODE_LISTTARGETS, listtargetsArgs);
    302350
    303351    PXOPT_ADD_MODE("-defineinterest",     "", DISTTOOL_MODE_DEFINEINTEREST, defineinterestArgs);

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

    r25851 r27838  
    9292        MODECASE(FAKETOOL_MODE_TOFULLIMFILE,            tofullimfileMode);
    9393        MODECASE(FAKETOOL_MODE_TOPURGEDIMFILE,          topurgedimfileMode);
    94         MODECASE(FAKETOOL_MODE_TOSCRUBBEDIMFILE,        toscrubbedimfileMode);
     94        MODECASE(FAKETOOL_MODE_TOSCRUBBEDIMFILE,        toscrubbedimfileMode);
    9595        MODECASE(FAKETOOL_MODE_EXPORTRUN,               exportrunMode);
    9696        MODECASE(FAKETOOL_MODE_IMPORTRUN,               importrunMode);
    … …  
    123123
    124124    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", "==");
    125127    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    126128    PXOPT_COPY_STR(config->args, where, "-exp_name", "exp_name", "==");
    … …  
    130132    PXOPT_COPY_TIME(config->args, where, "-dateobs_end", "dateobs", "<=");
    131133    PXOPT_COPY_STR(config->args, where, "-exp_tag", "exp_tag", "==");
    132     pxAddLabelSearchArgs (config, where, "-label", "label", "==");
     134    pxAddLabelSearchArgs (config, where, "-label", "label", "=="); // XXX does this choose the right label?
    133135    PXOPT_COPY_STR(config->args, where, "-filelevel", "filelevel", "==");
    134136    PXOPT_COPY_STR(config->args, where, "-reduction", "reduction", "==");
    … …  
    166168        && !psMetadataLookupBool(NULL, config->args, "-all")) {
    167169        psFree(where);
    168         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     170        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    169171        return false;
    170172    }
    … …  
    188190    psString query = pxDataGet("faketool_find_camrun.sql");
    189191    if (!query) {
    190         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     192        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    191193        psFree(where);
    192194        return false;
    … …  
    339341        psFree(where);
    340342        where = NULL;
    341         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     343        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    342344        return false;
    343345    }
    … …  
    346348
    347349    // pxUpdateRun gets parameters from config->args and updates
    348     bool result = pxUpdateRun(config, where, &query, "fakeRun", true);
     350    bool result = pxUpdateRun(config, where, &query, "fakeRun", "fake_id", "fakeProcessedImfile", true);
    349351    if (!result) {
    350         psError(PXTOOLS_ERR_DATA, false, "pxUpdateRun failed");
     352        psError(psErrorCodeLast(), false, "pxUpdateRun failed");
    351353    }
    352354
    … …  
    373375    psString query = pxDataGet("faketool_find_pendingexp.sql");
    374376    if (!query) {
    375         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     377        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    376378        psFree(where);
    377379        return false;
    … …  
    440442    psString query = pxDataGet("faketool_pendingimfile.sql");
    441443    if (!query) {
    442         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     444        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    443445        return false;
    444446    }
    … …  
    556558    PXOPT_COPY_S64(config->args, where, "-exp_id", "rawExp.exp_id", "==");
    557559    PXOPT_COPY_STR(config->args, where, "-class_id", "rawImfile.class_id", "==");
    558     PXOPT_COPY_STR(config->args, where, "-inst", "rawExp.telescope", "==");
    559     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");
    560562
    561563    psString query = pxDataGet("faketool_processedimfile.sql");
    562564    if (!query) {
    563         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     565        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    564566        return false;
    565567    }
    566568
    567569    if (where && psListLength(where->list)) {
    568         psString whereClause = psDBGenerateWhereConditionSQL(where, "fakeProcessedImfile");
     570        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    569571        psStringAppend(&query, " AND %s", whereClause);
    570572        psFree(whereClause);
    … …  
    665667        && !psMetadataLookupBool(NULL, config->args, "-all")) {
    666668        psFree(where);
    667         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     669        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    668670        return false;
    669671    }
    … …  
    671673    psString query = pxDataGet("faketool_revertprocessedimfile.sql");
    672674    if (!query) {
    673         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     675        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    674676        psFree(where);
    675677        return false;
    … …  
    812814    psString query = pxDataGet("faketool_unmasked.sql");
    813815    if (!query) {
    814         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     816        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    815817        return false;
    816818    }
    … …  
    889891    psString query = pxDataGet("faketool_pendingcleanuprun.sql");
    890892    if (!query) {
    891         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     893        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    892894        return false;
    893895    }
    … …  
    954956    psString query = pxDataGet("faketool_pendingcleanupimfile.sql");
    955957    if (!query) {
    956         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     958        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    957959        return false;
    958960    }
    … …  
    10151017    psString query = pxDataGet("faketool_donecleanup.sql");
    10161018    if (!query) {
    1017         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1019        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10181020        return false;
    10191021    }
    … …  
    10771079    psString query = pxDataGet("faketool_completely_processed_exp.sql");
    10781080    if (!query) {
    1079         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1081        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10801082        return false;
    10811083    }
    … …  
    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    }

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

    r25840 r27838  
    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);

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

    r25835 r27838  
    115115    if (!psListLength(where->list)) {
    116116        psFree(where);
    117         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
    118         return false;
    119     }
    120 
    121     // 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
    122122    // across multiple cameras
    123123    PXOPT_LOOKUP_STR(camera, config->args, "-inst", true, false);
    … …  
    133133    PXOPT_LOOKUP_STR(tess_id, config->args, "-set_tess_id", false, false);
    134134    PXOPT_LOOKUP_STR(region, config->args, "-set_region", false, false);
     135    PXOPT_LOOKUP_BOOL(make_correction, config->args, "-make_correction", false);
    135136    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
    136137
    … …  
    141142    psString query = pxDataGet("chiptool_find_rawexp.sql");
    142143    if (!query) {
    143         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     144        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    144145        psFree(where);
    145146        return false;
    … …  
    172173
    173174    if (pretend) {
    174         for (long i = 0; i < psArrayLength(output); i++) {
    175             // negative simple so the default is true
    176             if (!ippdbPrintMetadataRaw(stdout, output->data[i], !simple)) {
    177                 psError(PS_ERR_UNKNOWN, false, "failed to print array");
    178                 psFree(output);
    179                 return false;
    180             }
    181         }
     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        }
    182183        psFree(output);
    183184        return true;
    … …  
    194195    // create a new flatcorrRun
    195196    if (!flatcorrRunInsert(
    196             config->dbh,
     197            config->dbh,
    197198            0,      // corr_id
    198             det_type,
     199            det_type,
    199200            dvodb,
    200             camera,
    201             telescope,
    202             NULL,
     201            camera,
     202            telescope,
     203            NULL,
    203204            filter,
    204205            "reg",  // state
     206            make_correction,
    205207            workdir,
    206208            label,
    207209            reduction,
    208             region,
    209             NULL,
    210             0
     210            region,
     211            NULL,
     212            0
    211213        )) {
    212214        if (!psDBRollback(config->dbh)) {
    … …  
    294296    PXOPT_LOOKUP_STR(tess_id, config->args, "-set_tess_id", false, false);
    295297    PXOPT_LOOKUP_STR(region, config->args, "-set_region", false, false);
     298    PXOPT_LOOKUP_BOOL(make_correction, config->args, "-make_correction", false);
    296299    // XXX probably should make the region in -set_region match ra_min, ra_max, etc
    297300
    … …  
    307310    // create a new flatcorrRun
    308311    flatcorrRunRow *row = flatcorrRunRowAlloc(
    309         0,      // corr_id
    310         det_type,
    311         dvodb,
    312         camera,
    313         telescope,
    314         NULL,
    315         filter,
    316         "reg",  // state
    317         workdir,
    318         label,
    319         reduction,
    320         region,
    321         NULL, // hostname
    322         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
    323327        );
    324328
    … …  
    331335        return false;
    332336    }
    333    
     337
    334338    // figure out the ID of the flatcorrRun we just created
    335339    psS64 corr_id = psDBLastInsertID(config->dbh);
    … …  
    373377    psString query = pxDataGet("flatcorr_dropchip.sql");
    374378    if (!query) {
    375         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    376         return false;
     379        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     380        return false;
    377381    }
    378382
    … …  
    416420    psString query = pxDataGet("flatcorr_dropcamera.sql");
    417421    if (!query) {
    418         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    419         return false;
     422        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     423        return false;
    420424    }
    421425
    … …  
    444448    psString query = pxDataGet("flatcorr_chiprundone.sql");
    445449    if (!query) {
    446         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    447         return false;
     450        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     451        return false;
    448452    }
    449453
    … …  
    457461    // treat limit == 0 as "no limit"
    458462    if (limit) {
    459         psString limitString = psDBGenerateLimitSQL(limit);
    460         psStringAppend(&query, " %s", limitString);
    461         psFree(limitString);
     463        psString limitString = psDBGenerateLimitSQL(limit);
     464        psStringAppend(&query, " %s", limitString);
     465        psFree(limitString);
    462466    }
    463467
    … …  
    520524        // queue the exp
    521525        if (!pxcamQueueByChipID(
    522                 config,
    523                 row->chip_id,
    524                 row->workdir,
    525                 row->label,
    526                 row->data_group,
    527                 row->dist_group,
    528                 row->reduction,
    529                 row->expgroup,
    530                 row->dvodb,
    531                 row->tess_id,
    532                 "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,
    533538                NULL // note does not propragate
    534539                )) {
    … …  
    543548        }
    544549
    545         // figure out the ID of the flatcorrRun we just created
    546         psS64 cam_id = psDBLastInsertID(config->dbh);
    547 
    548         // 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)
    549554        if (!flatcorrCamLinkInsert(config->dbh, corr_id, row->chip_id, cam_id, 1)) {
    550555            if (!psDBRollback(config->dbh)) {
    … …  
    554559            return false;
    555560        }
    556        
     561
    557562        psFree(row);
    558563    }
    … …  
    582587    psString query = pxDataGet("flatcorr_camerarundone.sql");
    583588    if (!query) {
    584         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    585         return false;
     589        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     590        return false;
    586591    }
    587592
    … …  
    595600    // treat limit == 0 as "no limit"
    596601    if (limit) {
    597         psString limitString = psDBGenerateLimitSQL(limit);
    598         psStringAppend(&query, " %s", limitString);
    599         psFree(limitString);
     602        psString limitString = psDBGenerateLimitSQL(limit);
     603        psStringAppend(&query, " %s", limitString);
     604        psFree(limitString);
    600605    }
    601606
    … …  
    658663        // queue the exp : force image_only to be false (flatcorr is meaningless with just image info)
    659664        if (!pxaddQueueByCamID(
    660                 config,
    661                 row->cam_id,
    662                 row->workdir,
    663                 row->reduction,
    664                 row->label,
     665                config,
     666                row->cam_id,
     667                row->workdir,
     668                row->reduction,
     669                row->label,
    665670                row->data_group,
    666                 row->dvodb,
     671                row->dvodb,
    667672                NULL,       // note is not propagated
    668                 0)) {
     673                0)) {
    669674            if (!psDBRollback(config->dbh)) {
    670675                psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    677682        }
    678683
    679         // figure out the ID of the flatcorrRun we just created
    680         psS64 add_id = psDBLastInsertID(config->dbh);
    681 
    682         // add the addRun entry to the flatcorrAddstarLink table (include is TRUE)
     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)
    683688        if (!flatcorrAddstarLinkInsert(config->dbh, corr_id, row->cam_id, add_id, 1)) {
    684689            if (!psDBRollback(config->dbh)) {
    … …  
    714719    psString query = pxDataGet("flatcorr_pendingprocess.sql");
    715720    if (!query) {
    716         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    717         return false;
     721        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     722        return false;
    718723    }
    719724
    … …  
    727732    // treat limit == 0 as "no limit"
    728733    if (limit) {
    729         psString limitString = psDBGenerateLimitSQL(limit);
    730         psStringAppend(&query, " %s", limitString);
    731         psFree(limitString);
     734        psString limitString = psDBGenerateLimitSQL(limit);
     735        psStringAppend(&query, " %s", limitString);
     736        psFree(limitString);
    732737    }
    733738
    … …  
    750755
    751756    if (!ippdbPrintMetadatas(stdout, output, "flatcorrPending", !simple)) {
    752         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    753         psFree(output);
    754         return false;
     757        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     758        psFree(output);
     759        return false;
    755760    }
    756761
    … …  
    809814    // treat limit == 0 as "no limit"
    810815    if (limit) {
    811         psString limitString = psDBGenerateLimitSQL(limit);
    812         psStringAppend(&query, " %s", limitString);
    813         psFree(limitString);
     816        psString limitString = psDBGenerateLimitSQL(limit);
     817        psStringAppend(&query, " %s", limitString);
     818        psFree(limitString);
    814819    }
    815820
    … …  
    832837
    833838    if (!ippdbPrintMetadatas(stdout, output, "flatcorrPending", !simple)) {
    834         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    835         psFree(output);
    836         return false;
     839        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     840        psFree(output);
     841        return false;
    837842    }
    838843
    … …  
    849854    PXOPT_LOOKUP_BOOL(simple,  config->args, "-simple",  false);
    850855    PXOPT_LOOKUP_BOOL(limit,   config->args, "-limit",   false);
    851    
     856
    852857    psMetadata *where = psMetadataAlloc();
    853858    PXOPT_COPY_S64(config->args, where, "-chip_id", "chipProcessedImfile.chip_id", "==");
    … …  
    855860    psString query = pxDataGet("flatcorr_inputimfile.sql");
    856861    if (!query) {
    857         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     862        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    858863        return false;
    859864    }
    … …  
    868873    // treat limit == 0 as "no limit"
    869874    if (limit) {
    870         psString limitString = psDBGenerateLimitSQL(limit);
    871         psStringAppend(&query, " %s", limitString);
    872         psFree(limitString);
     875        psString limitString = psDBGenerateLimitSQL(limit);
     876        psStringAppend(&query, " %s", limitString);
     877        psFree(limitString);
    873878    }
    874879
    … …  
    891896
    892897    if (!ippdbPrintMetadatas(stdout, output, "flatcorrPending", !simple)) {
    893         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    894         psFree(output);
    895         return false;
     898        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     899        psFree(output);
     900        return false;
    896901    }
    897902
    … …  
    905910
    906911    // check that state is a valid string value
    907     if (!strcmp(state, "reg") && 
    908         !strcmp(state, "new") &&
    909         !strcmp(state, "full"))
     912    if (!strcmp(state, "reg") &&
     913        !strcmp(state, "new") &&
     914        !strcmp(state, "full"))
    910915    {
    911916        psError(PS_ERR_UNKNOWN, false, "invalid state: %s", state);

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

    r25816 r27838  
    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);
    … …  
    7677    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_tess_id",  0,            "define tessalation", NULL);
    7778    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);
    7880    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    7981
    … …  
    129131    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-corr_id", 0, "define correction id (required)", 0);
    130132    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);
    131134
    132135    // -inputexp

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

    r25837 r27838  
    3333
    3434static bool definebyqueryMode(pxConfig *config);
     35static bool definecopyMode(pxConfig *config);
    3536static bool updaterunMode(pxConfig *config);
    3637static bool todestreakMode(pxConfig *config);
    … …  
    3839static bool advancerunMode(pxConfig *config);
    3940static bool revertdestreakedfileMode(pxConfig *config);
     41static bool clearstatefaultsMode(pxConfig *config);
    4042static bool getskycellsMode(pxConfig *config);
    4143static bool toremoveMode(pxConfig *config);
    … …  
    4446static bool tocleanupMode(pxConfig *config);
    4547
    46 static bool setmagicDSRunState(pxConfig *config, psS64 magic_id, psMetadata *where, const char *state);
     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);
     69        MODECASE(MAGICDSTOOL_MODE_DEFINECOPY,          definecopyMode);
    6770        MODECASE(MAGICDSTOOL_MODE_UPDATERUN,           updaterunMode);
    6871        MODECASE(MAGICDSTOOL_MODE_TODESTREAK,          todestreakMode);
    … …  
    7073        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);
    … …  
    110114    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
    111115    PXOPT_LOOKUP_BOOL(rerun, config->args, "-rerun", false);
    112     PXOPT_LOOKUP_BOOL(dry_run, config->args, "-dry_run", false);
     116    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
    113117    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    114118    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    124128    PXOPT_COPY_S32(config->args, where, "-streaks_max","streaks", "<=");
    125129
    126     pxAddLabelSearchArgs (config, where, "-label", "magicRun.label", "==");
     130    pxAddLabelSearchArgs (config, where, "-label", "magicRun.label", "=="); // define using magicRun label
    127131
    128132    ippStage stageNum = ippStringToStage(stage);
    129    
     133
    130134    psString query = NULL;
    131135    switch (stageNum) {
    … …  
    147151    case IPP_STAGE_FAKE:
    148152    case IPP_STAGE_STACK:
    149         psError(PXTOOLS_ERR_DATA, true, "%sRuns do not need to be destreaked", stage);
     153        psError(PXTOOLS_ERR_CONFIG, true, "%sRuns do not need to be destreaked", stage);
    150154        return false;
    151155    case IPP_STAGE_NONE:
    152         psError(PXTOOLS_ERR_DATA, true, "%s is not a valid stage", stage);
     156        psError(PXTOOLS_ERR_CONFIG, true, "%s is not a valid stage", stage);
    153157        return false;
    154158    default:
    … …  
    159163
    160164    if (!query) {
    161         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     165        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    162166        return false;
    163167    }
    … …  
    233237    // Parse the list of runs ready to be destreaked
    234238
    235     if (!dry_run && !psDBTransaction(config->dbh)) {
     239    if (!pretend && !psDBTransaction(config->dbh)) {
    236240        psError(PS_ERR_UNKNOWN, false, "database error");
    237241        return false;
    … …  
    249253        psString magicRunDataGroup = psMetadataLookupStr(NULL, row, "data_group");
    250254        psString magicRunWorkdir = psMetadataLookupStr(NULL, row, "workdir");
    251        
     255
    252256        // if workdir is not supplied use the magicRun's
    253257        if (!workdir) {
    … …  
    282286        }
    283287
    284         if (!dry_run) {
     288        if (!pretend) {
    285289            if (!magicDSRunInsertObject(config->dbh, run)) {
    286290                psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    301305    }
    302306
    303     if (!dry_run && !psDBCommit(config->dbh)) {
     307    if (!pretend && !psDBCommit(config->dbh)) {
    304308        psError(PS_ERR_UNKNOWN, false, "database error");
    305309        return false;
    … …  
    319323
    320324
     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
    321545static bool updaterunMode(pxConfig *config)
    322546{
    … …  
    326550    PXOPT_LOOKUP_STR(state, config->args, "-set_state", true, false);
    327551
     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
    328563    PXOPT_LOOKUP_S64(magic_ds_id, config->args, "-magic_ds_id", false, false);
    329564    if (magic_ds_id) {
    330565
    331         return setmagicDSRunState(config, magic_ds_id, NULL, state);
     566        return setmagicDSRunState(config, magic_ds_id, setString, NULL, state);
    332567
    333568    } else if (!strcmp(state, "full")) {
    … …  
    341576    PXOPT_COPY_S64(config->args, where, "-stage_id", "stage_id", "==");
    342577    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
    343 
     578    PXOPT_COPY_STR(config->args, where, "-state", "state", "==");
     579    PXOPT_COPY_STR(config->args, where, "-data_group", "data_group", "LIKE");
    344580
    345581    if (psListLength(where->list) < 2) {
    … …  
    353589        psMetadataAddS32(where, PS_LIST_TAIL, "re_place", 0, ">", 0);
    354590    }
    355     bool result = setmagicDSRunState(config, magic_ds_id, where, state);
     591    bool result = setmagicDSRunState(config, magic_ds_id, setString, where, state);
    356592    psFree(where);
    357593
    … …  
    379615    psString query = pxDataGet(sql_file);
    380616    if (!query) {
    381         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement from %s", sql_file);
     617        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement from %s", sql_file);
    382618        psFree(sql_file);
    383619        return false;
    … …  
    445681{
    446682    // first query the magicDSRun to find the stage and the stage_id
    447     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;
    448684
    449685    if (!p_psDBRunQueryF(config->dbh, query, magic_ds_id)) {
    … …  
    472708    psString stage= psMetadataLookupStr(NULL, row, "stage");
    473709    psS64 stage_id = psMetadataLookupS64(NULL, row, "stage_id");
     710    psS64 magic_id = psMetadataLookupS64(NULL, row, "magic_id");
    474711
    475712    ippStage stageNum = ippStringToStage(stage);
    … …  
    499736    }
    500737
    501     if (!p_psDBRunQueryF(config->dbh, query, magic_ds_id, stage_id, component)) {
     738    if (!p_psDBRunQueryF(config->dbh, query, magic_id, stage_id, component)) {
    502739        psError(PS_ERR_UNKNOWN, false, "database error");
    503740        return false;
    … …  
    518755{
    519756    // first query the magicDSRun to find the stage and the stage_id
    520     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;
    521758
    522759    if (!p_psDBRunQueryF(config->dbh, query, magic_ds_id)) {
    … …  
    545782    psString stage = psMetadataLookupStr(NULL, row, "stage");
    546783    psS64 stage_id = psMetadataLookupS64(NULL, row, "stage_id");
     784    psS64 magic_id = psMetadataLookupS64(NULL, row, "magic_id");
    547785
    548786    ippStage stageNum = ippStringToStage(stage);
    … …  
    570808        return false;
    571809    }
    572     if (!p_psDBRunQueryF(config->dbh, query, magic_ds_id, stage_id)) {
     810    if (!p_psDBRunQueryF(config->dbh, query, magic_id, stage_id)) {
    573811        psError(PS_ERR_UNKNOWN, false, "database error");
    574812        return false;
    … …  
    598836    PXOPT_LOOKUP_STR(recovery_path_base, config->args, "-recovery_path_base", false, false);
    599837    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);
    600841
    601842    if (setmagicked && (fault != 0)) {
    … …  
    620861    }
    621862
    622     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        )) {
    623874            // rollback
    624875        if (!psDBRollback(config->dbh)) {
    … …  
    651902    psString query = pxDataGet("magicdstool_completed_runs.sql");
    652903    if (!query) {
    653         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     904        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    654905        return false;
    655906    }
    … …  
    699950
    700951        // set magicDSRun.state to 'full'
    701         if (!setmagicDSRunState(config, magic_ds_id, NULL, "full")) {
     952        if (!setmagicDSRunState(config, magic_ds_id, NULL, NULL, "full")) {
    702953            psError(PS_ERR_UNKNOWN, false, "failed to change magicDSRun.state for magic_ds_id: %" PRId64,
    703954                magic_ds_id);
    … …  
    747998
    748999    if (!p_psDBRunQuery(config->dbh, query)) {
     1000        psError(PS_ERR_UNKNOWN, false, "failed to revert");
     1001        psFree(query);
     1002        return false;
     1003    }
     1004    psFree(query);
     1005    return true;
     1006}
     1007static bool clearstatefaultsMode(pxConfig *config)
     1008{
     1009    PS_ASSERT_PTR_NON_NULL(config, false);
     1010
     1011    psMetadata *where = psMetadataAlloc();
     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");
     1023
     1024    if (psListLength(where->list)) {
     1025        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1026        psStringAppend(&query, " WHERE %s", whereClause);
     1027        psFree(whereClause);
     1028    } else {
     1029        psError(PS_ERR_UNKNOWN, true, "search arguments are required");
     1030        return false;
     1031    }
     1032    psFree(where);
     1033
     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)) {
    7491045        psError(PS_ERR_UNKNOWN, false, "failed to revert");
    7501046        psFree(query);
    … …  
    8091105    for (int i=0; i<psArrayLength(output); i++) {
    8101106        psMetadata *row = output->data[i];
    811         psS64 magic_ds_id = psMetadataLookupS64(NULL, row, "magic_ds_id"); 
    812         psString old_state = psMetadataLookupStr(NULL, row, "state"); 
     1107        psS64 magic_ds_id = psMetadataLookupS64(NULL, row, "magic_ds_id");
     1108        psString old_state = psMetadataLookupStr(NULL, row, "state");
    8131109        psString new_state;
    8141110        if (!strcmp(old_state, "goto_censored")) {
    … …  
    8381134
    8391135    psMetadata *where = psMetadataAlloc();
     1136    PXOPT_COPY_S64(config->args, where, "-magic_ds_id", "magicDSRun.magic_ds_id", "==");
    8401137    PXOPT_COPY_STR(config->args, where, "-class_id",    "warpSkyCellMap.class_id", "==");
    8411138    PXOPT_COPY_STR(config->args, where, "-skycell_id",  "warpSkyCellMap.skycell_id", "==");
    … …  
    8451142    psString query = pxDataGet("magicdstool_getskycells.sql");
    8461143    if (!query) {
    847         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    848         return false;
    849     }
    850 
     1144        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1145        return false;
     1146    }
     1147
     1148    psString whereClause = NULL;
    8511149    if (psListLength(where->list)) {
    852         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    853         psStringAppend(&query, " AND %s", whereClause);
    854         psFree(whereClause);
     1150        whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1151        psStringPrepend(&whereClause, "\n AND ");
    8551152    }
    8561153    psFree(where);
    8571154
    858     if (!p_psDBRunQueryF(config->dbh, query, magic_ds_id)) {
     1155    if (!p_psDBRunQueryF(config->dbh, query, whereClause, whereClause)) {
    8591156        psError(PS_ERR_UNKNOWN, false, "database error");
    8601157        psFree(query);
    … …  
    9011198    if (!((strcmp(state, "new") == 0) ||
    9021199          (strcmp(state, "full") == 0) ||
     1200          (strcmp(state, "drop") == 0) ||
     1201          (strcmp(state, "failed_revert") == 0) ||
     1202          (strcmp(state, "failed_cleanup") == 0) ||
    9031203          (strcmp(state, "restored") == 0) ||
    9041204          (strcmp(state, "censored") == 0) ||
    … …  
    9141214}
    9151215
    916 static bool setmagicDSRunState(pxConfig *config, psS64 magic_ds_id, psMetadata *where, const char *state)
     1216static bool setmagicDSRunState(pxConfig *config, psS64 magic_ds_id, psString extraSetStr, psMetadata *where, const char *state)
    9171217{
    9181218    PS_ASSERT_PTR_NON_NULL(state, false);
    … …  
    9241224    }
    9251225
    926     psString query = psStringCopy("UPDATE magicDSRun SET state = '%s'");
     1226    psString query = NULL;
     1227    psStringAppend(&query, "UPDATE magicDSRun SET state = '%s' %s\n", state, extraSetStr ? extraSetStr : "");
    9271228    if (magic_ds_id) {
    9281229        psStringAppend(&query, " WHERE magic_ds_id = %" PRId64, magic_ds_id);
    … …  
    9321233        psFree(whereClause);
    9331234    } else {
    934         psError(PS_ERR_UNKNOWN, true, "search arugments are required");
    935         return false;
    936     }
    937 
    938     if (!p_psDBRunQueryF(config->dbh, query, state)) {
     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)) {
    9391248        psError(PS_ERR_UNKNOWN, false,
    9401249                "failed to change state for magic_id %" PRId64, magic_ds_id);
    … …  
    9601269    psString query = pxDataGet("magicdstool_toremove.sql");
    9611270    if (!query) {
    962         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1271        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    9631272        return false;
    9641273    }
    … …  
    10381347    psString query = pxDataGet(sql_file);
    10391348    if (!query) {
    1040         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);
    10411350        psFree(sql_file);
    10421351        return false;
    … …  
    11061415    psMetadata *where = psMetadataAlloc();
    11071416
    1108     PXOPT_COPY_S64(config->args, where, "-stage", "stage", "==");
     1417    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
    11091418    PXOPT_COPY_S64(config->args, where, "-magic_ds_id", "magic_ds_id", "==");
    11101419    PXOPT_COPY_S64(config->args, where, "-magic_id", "magic_id", "==");
    … …  
    11161425    psString query = pxDataGet("magicdstool_tocleanup.sql");
    11171426    if (!query) {
    1118         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1427        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11191428        return false;
    11201429    }

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

    r25835 r27838  
    2626    MAGICDSTOOL_MODE_NONE           = 0x0,
    2727    MAGICDSTOOL_MODE_DEFINEBYQUERY,
     28    MAGICDSTOOL_MODE_DEFINECOPY,
    2829    MAGICDSTOOL_MODE_UPDATERUN,
    2930    MAGICDSTOOL_MODE_TODESTREAK,
    … …  
    3132    MAGICDSTOOL_MODE_ADVANCERUN,
    3233    MAGICDSTOOL_MODE_REVERTDESTREAKEDFILE,
     34    MAGICDSTOOL_MODE_CLEARSTATEFAULTS,
    3335    MAGICDSTOOL_MODE_GETSKYCELLS,
    3436    MAGICDSTOOL_MODE_TOREMOVE,

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

    r25843 r27838  
    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;
    … …  
    6666    psMetadataAddS32(definebyqueryArgs, PS_LIST_TAIL, "-streaks_max", 0, "maximum number of streaks", 0);
    6767
    68     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-rerun",   0, "queue a new run even if one arleady exists", false);
    69     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-dry_run", 0, "don't queue runs just display what would be queued", false);
     68    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-rerun",   0, "queue a new run even if one already exists", false);
     69    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-pretend", 0, "don't queue runs just display what would be queued", false);
    7070    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple",  0, "use the simple output format", false);
    7171    psMetadataAddU64(definebyqueryArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
    7272
     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);
     95
    7396    // -updaterun
    7497    psMetadata *updaterunArgs = psMetadataAlloc();
    75     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_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);
    76101    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-magic_ds_id", 0, "define magictool ID", 0);
    77102    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-stage",     0, "define stage", NULL);
     103    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state",     0, "define state", NULL);
    78104    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-stage_id", 0, "define stage_id", 0);
    79105    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label",     0, "define label", NULL);
     106    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-data_group",     0, "data_group (LIKE) comparision", NULL);
    80107    psMetadataAddBool(updaterunArgs, PS_LIST_TAIL, "-noreplace", 0, "only update runs with replace not set", false);
    81108
    … …  
    102129    psMetadataAddStr(adddestreakedfileArgs, PS_LIST_TAIL, "-recovery_path_base", 0, "define recovery pixels URI", NULL);
    103130    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);
    104134    psMetadataAddS16(adddestreakedfileArgs, PS_LIST_TAIL, "-fault", 0, "set fault code", 0);
    105135
    … …  
    111141    psMetadataAddBool(revertdestreakedfileArgs, PS_LIST_TAIL, "-i_am_sure", 0, "confirm that you know what you are doing", false);
    112142    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);
    113151
    114152    // -getskycells
    … …  
    163201    PXOPT_ADD_MODE("-definebyquery",       "create magic de-streak runs from magic runs",
    164202                    MAGICDSTOOL_MODE_DEFINEBYQUERY,     definebyqueryArgs);
     203    PXOPT_ADD_MODE("-definecopy",          "create magic de-streak runs from magic runs for different path",
     204                    MAGICDSTOOL_MODE_DEFINECOPY,     definecopyArgs);
    165205    PXOPT_ADD_MODE("-updaterun",           "update state of magic de-streak run",
    166206                    MAGICDSTOOL_MODE_UPDATERUN,         updaterunArgs);
    … …  
    173213    PXOPT_ADD_MODE("-revertdestreakedfile", " revert a faulted de-streaked file",
    174214                    MAGICDSTOOL_MODE_REVERTDESTREAKEDFILE, revertdestreakedfileArgs);
     215    PXOPT_ADD_MODE("-clearstatefaults", " clear magicDSRuns in fault state",
     216                    MAGICDSTOOL_MODE_CLEARSTATEFAULTS, clearstatefaultsArgs);
    175217    PXOPT_ADD_MODE("-getskycells", "get skycell files ",
    176218                    MAGICDSTOOL_MODE_GETSKYCELLS, getskycellsArgs);

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

    r25844 r27838  
    114114    // Required
    115115    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", false, false);
     116    PXOPT_LOOKUP_STR(label, config->args, "-label", true, false);
    116117
    117118    // Optional
    118     PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
    119119    PXOPT_LOOKUP_STR(data_group, config->args, "-data_group", false, false);
    120120    PXOPT_LOOKUP_STR(note, config->args, "-note", false, false);
    … …  
    135135        psString query = pxDataGet("magictool_definebyquery_select.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        }
    … …  
    151151        // what if no skycells for the diff run completed?
    152152
    153         if (!rerun) {
    154             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);
    155157        }
    156158
    … …  
    176178            queryWhereStr = psStringCopy("");
    177179        }
    178 
    179         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)) {
    180185            psError(PS_ERR_UNKNOWN, false, "database error");
    181186            psFree(diffWhereStr);
    182187            psFree(queryWhereStr);
     188            psFree(rerunWhereStr);
    183189            psFree(query);
    184190            return false;
    … …  
    186192        psFree(diffWhereStr);
    187193        psFree(queryWhereStr);
     194        psFree(rerunWhereStr);
    188195        psFree(query);
    189196    }
    … …  
    427434    psString query = pxDataGet("magictool_inputskyfile.sql");
    428435    if (!query) {
    429         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     436        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    430437        return false;
    431438    }
    … …  
    500507    psString query = pxDataGet("magictool_totree.sql");
    501508    if (!query) {
    502         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     509        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    503510        return false;
    504511    }
    … …  
    573580
    574581    if (fault > 0) {
    575         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;
    576583        if (!p_psDBRunQueryF(config->dbh, query, fault, magic_id)) {
    577584            psError(PS_ERR_UNKNOWN, false,
    … …  
    612619        return false;
    613620    }
     621    psS32 numUpdated = psDBAffectedRows(config->dbh);
     622    psLogMsg("magictool", PS_LOG_INFO, "Reverted %d magic runs", numUpdated);
     623
    614624    return true;
    615625}
    … …  
    635645    psString query = pxDataGet("magictool_inputs.sql");
    636646    if (!query) {
    637         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     647        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    638648        return false;
    639649    }
    … …  
    805815    psString query = pxDataGet("magictool_toprocess_inputs.sql");
    806816    if (!query) {
    807         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     817        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    808818        return false;
    809819    }
    … …  
    867877
    868878    // look for tree nodes that need to be processed
     879
     880    // first find incomplete magicRuns
    869881    query = pxDataGet("magictool_toprocess_runs.sql");
    870882    if (!query) {
    871         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    872         return false;
    873     }
    874 
     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.
    875894    {
    876         psString limitString = psDBGenerateLimitSQL( 100 );
     895        psString limitString = psDBGenerateLimitSQL( 1000 );
    877896        psStringAppend(&query, " %s", limitString);
    878897        psFree(limitString);
    … …  
    910929    query = pxDataGet("magictool_toprocess_tree.sql");
    911930    if (!query) {
    912         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     931        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    913932        return false;
    914933    }
    … …  
    923942            psAbort("failed to lookup value for magic_id column");
    924943        }
    925        
     944
    926945        whereString = NULL;
    927946        psStringAppend(&whereString, "\nAND (magic_id = %" PRId64 ")", magic_id);
    … …  
    10411060    PXOPT_COPY_S64(config->args, where, "-magic_id", "magic_id", "==");
    10421061    PXOPT_COPY_STR(config->args, where, "-node", "node", "==");
    1043     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
    10441062    PXOPT_COPY_S16(config->args, where, "-fault", "magicNodeResult.fault", "==");
     1063    pxAddLabelSearchArgs (config, where, "-label", "magicRun.label", "==");
    10451064
    10461065    psString query = pxDataGet("magictool_revertnode.sql");
    10471066    if (!query) {
    1048         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1067        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10491068        return false;
    10501069    }
    … …  
    10671086
    10681087    psS32 numUpdated = psDBAffectedRows(config->dbh);
    1069     psLogMsg("magictool", PS_LOG_INFO, "Updated %d magic nodes", numUpdated);
     1088    psLogMsg("magictool", PS_LOG_INFO, "Reverted %d magic nodes", numUpdated);
    10701089
    10711090    return true;
    … …  
    10831102    psString query = pxDataGet("magictool_tomask.sql");
    10841103    if (!query) {
    1085         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1104        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10861105        return false;
    10871106    }
    … …  
    11711190    psString query = pxDataGet("magictool_addmask.sql");
    11721191    if (!query) {
    1173         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1192        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11741193        if (!psDBRollback(config->dbh)) {
    11751194            psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    12781297    psString query = pxDataGet("magictool_mask.sql");
    12791298    if (!query) {
    1280         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1299        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    12811300        return false;
    12821301    }

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

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

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

    r25793 r27838  
    5151static bool pendingdependentMode(pxConfig *config);
    5252static bool updatedependentMode(pxConfig *config);
     53static bool revertdependentMode(pxConfig *config);
    5354
    5455# define MODECASE(caseName, func) \
    … …  
    9192        MODECASE(PSTAMPTOOL_MODE_PENDINGDEPENDENT, pendingdependentMode);
    9293        MODECASE(PSTAMPTOOL_MODE_UPDATEDEPENDENT, updatedependentMode);
     94        MODECASE(PSTAMPTOOL_MODE_REVERTDEPENDENT, revertdependentMode);
    9395        default:
    9496            psAbort("invalid option (this should not happen)");
    … …  
    116118    PS_ASSERT_PTR_NON_NULL(config, false);
    117119
    118     PXOPT_LOOKUP_STR(uri,         config->args, "-uri",           true, false);
    119     PXOPT_LOOKUP_STR(outProduct,  config->args, "-out_product",   true, false);
    120     PXOPT_LOOKUP_STR(lastFileset, config->args, "-last_fileset", false, false);
    121     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);
    122126
    123127    if (!pstampDataStoreInsert(config->dbh,
    … …  
    125129            state,
    126130            lastFileset,
     131            NULL,       // timestamp
     132            label,      // label
    127133            outProduct,
    128             uri
     134            uri,
     135            pollInterval
    129136        )) {
    130137        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    142149    PXOPT_COPY_S64(config->args, where, "-ds_id", "ds_id", "==");
    143150
     151    PXOPT_LOOKUP_BOOL(ready, config->args, "-ready", false);
    144152    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    145153
    146154    psString query = pxDataGet("pstamptool_datastore.sql");
    147155    if (!query) {
    148         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     156        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    149157        return false;
    150158    }
    … …  
    156164    }
    157165    psFree(where);
     166    if (ready) {
     167        psStringAppend(&query, " %s", "\nAND TIMESTAMPDIFF(SECOND, timestamp, now()) > pollInterval");
     168    }
    158169
    159170    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    189200
    190201    PXOPT_LOOKUP_S64(ds_id,       config->args, "-ds_id",         true, false);
    191     PXOPT_LOOKUP_STR(lastFileset, config->args, "-last_fileset",  false, false);
    192     PXOPT_LOOKUP_STR(state,       config->args, "-state",         false, false);
    193 
    194     if (!state && !lastFileset) {
    195         psError(PS_ERR_UNKNOWN, true, "at least one of -last_fileset or -state is required");
    196         return false;
    197     }
    198 
    199     char *query = psStringCopy ("UPDATE pstampDataStore SET");
    200     bool needComma = false;
    201    
     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
    202215    if (lastFileset) {
    203         psStringAppend(&query, " lastFileset = '%s'", lastFileset);
    204         needComma = true;
     216        psStringAppend(&query, " , lastFileset = '%s'", lastFileset);
    205217    }
    206218
    207219    if (state) {
    208         psStringAppend(&query, "%s state = '%s'", needComma ? "," : " ", state);
    209         needComma = true; // be ready in case we add another field
    210     }
    211                
     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
    212231    psStringAppend(&query, " WHERE ds_id = %" PRId64, ds_id);
    213232
    … …  
    220239    psU64 affected = psDBAffectedRows(config->dbh);
    221240    if (affected != 1) {
    222         psError(PS_ERR_UNKNOWN, false, "should have affected one row but %" 
     241        psError(PS_ERR_UNKNOWN, false, "should have affected one row but %"
    223242                                        PRIu64 " rows were modified", affected);
    224243        return false;
    … …  
    245264        label,
    246265        NULL,   // outProduct
    247         uri,   
    248         0       // fault 
     266        uri,
     267        0       // fault
    249268        )) {
    250269        psError(PS_ERR_UNKNOWN, false, "failed to insert request");
    … …  
    265284    psMetadata *where = psMetadataAlloc();
    266285    PXOPT_COPY_S64(config->args, where, "-req_id", "req_id", "==");
     286    pxAddLabelSearchArgs(config, where, "-label", "label", "LIKE");
    267287
    268288    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    271291    psString query = pxDataGet("pstamptool_pendingreq.sql");
    272292    if (!query) {
    273         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     293        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    274294        return false;
    275295    }
    … …  
    342362    psFree(whereClause);
    343363    psFree(where);
    344    
     364
    345365    // treat limit == 0 as "no limit"
    346366    if (limit) {
    … …  
    365385        psTrace("pstamptool", PS_LOG_INFO, "request not found");
    366386        // This causes main to exit with PS_EXIT_DATA_ERROR which the script is looking for
    367         psError(PXTOOLS_ERR_DATA, true, "request not found");
     387        psError(PXTOOLS_ERR_CONFIG, true, "request not found");
    368388        psFree(output);
    369389        // we return false so that the caller can determine that a request does not exist
    … …  
    387407    PS_ASSERT_PTR_NON_NULL(config, false);
    388408
     409    psMetadata *where = psMetadataAlloc();
     410    pxAddLabelSearchArgs(config, where, "-label", "label", "LIKE");
     411
    389412    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    390413    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    391414
    392415    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);
    393423
    394424    // treat limit == 0 as "no limit"
    … …  
    436466    PXOPT_LOOKUP_STR(state,      config->args, "-state",      false, false);
    437467    PXOPT_LOOKUP_STR(outProduct, config->args, "-outProduct", false, false);
    438     PXOPT_LOOKUP_STR(fault,      config->args, "-fault",      false, false);
    439     PXOPT_LOOKUP_STR(uri,       config->args, "-uri",        false, false);
    440     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);
    441471    PXOPT_LOOKUP_STR(reqType,    config->args, "-reqType",    false, false);
    442472
    … …  
    454484    }
    455485    if (fault) {
    456         psStringAppend(&query, "%c fault = %s", c, fault);
     486        psStringAppend(&query, "%c fault = %d", c, fault);
    457487        c = ',';
    458488    }
    … …  
    485515    // note zero is not an error
    486516    if (affected > 1) {
    487         psError(PS_ERR_UNKNOWN, false, "should have affected one row but %" 
     517        psError(PS_ERR_UNKNOWN, false, "should have affected one row but %"
    488518                                        PRIu64 " rows were modified", affected);
    489519        return false;
    … …  
    500530
    501531    PXOPT_COPY_S64(config->args, where, "-req_id", "req_id", "==");
    502     PXOPT_COPY_S64(config->args, where, "-fault", "req_id", "==");
     532    PXOPT_COPY_S64(config->args, where, "-fault", "fault", "==");
    503533    PXOPT_COPY_STR(config->args, where, "-state", "pstampRequest.state", "==");
     534    pxAddLabelSearchArgs(config, where, "-label", "pstampRequest.label", "LIKE");
    504535
    505536    if (!psListLength(where->list)) {
    506537        psFree(where);
    507         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     538        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    508539        return false;
    509540    }
    … …  
    525556    query = pxDataGet("pstamptool_revertreq.sql");
    526557    psStringAppend(&query, " AND %s", whereClause);
    527    
     558
    528559    psFree(whereClause);
    529560
    … …  
    555586    // unless the job is being inserted with stop state require outputBase
    556587    if (strcmp(stateString, "stop") && !outputBase) {
    557         psError(PS_ERR_UNKNOWN, true, "-outputBase is required");
    558         return false;
     588        psError(PS_ERR_UNKNOWN, true, "-outputBase is required");
     589        return false;
    559590    }
    560591
    561592    // default value for job_type is defined in pstamptoolConfig.c
    562593    if (!strcmp(job_type, "get_image") || !strcmp(job_type, "detect_query") || !strcmp(job_type, "none")) {
    563         stampJob = false;
     594        stampJob = false;
    564595    } else if (!strcmp(job_type, "stamp")) {
    565         stampJob = true;
     596        stampJob = true;
    566597    } else {
    567         psError(PS_ERR_UNKNOWN, false, "unknown value for -job_type: %s", job_type);
    568         return false;
    569     }
    570     if (!pstampJobInsert(config->dbh, 
     598        psError(PS_ERR_UNKNOWN, false, "unknown value for -job_type: %s", job_type);
     599        return false;
     600    }
     601    if (!pstampJobInsert(config->dbh,
    571602            0, // job_id
    572603            req_id,
    573             rownum, 
    574             stateString, 
    575             job_type, 
    576             fault, 
    577             exp_id, 
     604            rownum,
     605            stateString,
     606            job_type,
     607            fault,
     608            exp_id,
    578609            outputBase,
    579610            options,
    … …  
    586617    psU64 affected = psDBAffectedRows(config->dbh);
    587618    if (affected != 1) {
    588         psError(PS_ERR_UNKNOWN, false, 
     619        psError(PS_ERR_UNKNOWN, false,
    589620            "should have affected one row but %" PRIu64 " rows were modified",
    590621            affected);
    … …  
    617648    psString query = pxDataGet("pstamptool_listjob.sql");
    618649    if (!query) {
    619         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     650        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    620651        return false;
    621652    }
    … …  
    674705    PXOPT_COPY_S64(config->args, where, "-job_id", "job_id", "==");
    675706    PXOPT_COPY_S64(config->args, where, "-req_id", "req_id", "==");
     707    pxAddLabelSearchArgs(config, where, "-label", "label", "LIKE");
     708
    676709    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    677710    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    679712    psString query = pxDataGet("pstamptool_pendingjob.sql");
    680713    if (!query) {
    681         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     714        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    682715        return false;
    683716    }
    … …  
    685718    // use psDBGenerateWhereSQL because the SQL yields an intermediate table
    686719    if (psListLength(where->list)) {
    687         psString whereClause = psDBGenerateWhereConditionSQL(where, "pstampJob");
     720        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    688721        psStringAppend(&query, " AND %s", whereClause);
    689722        psFree(whereClause);
    … …  
    732765    PS_ASSERT_PTR_NON_NULL(config, false);
    733766
    734     PXOPT_LOOKUP_S64(job_id,    config->args, "-job_id", true, false);
     767    PXOPT_LOOKUP_S64(job_id,    config->args, "-job_id", false, false);
     768    PXOPT_LOOKUP_S64(dep_id,    config->args, "-dep_id", false, false);
     769
     770    if (!job_id && !dep_id) {
     771        psError(PS_ERR_UNKNOWN, true, "at least -job_id or -dep_id is required");
     772        return false;
     773    }
    735774    PXOPT_LOOKUP_STR(state,     config->args, "-state",  true, false);
    736     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", "==");
    737781
    738782    psString faultStr = NULL;
    … …  
    740784        faultStr = psStringCopy("");
    741785    } else {
    742         psStringAppend(&faultStr, ", fault = '%s'", fault);
    743     }
    744 
    745     char *query ="UPDATE pstampJob"
    746         " SET state = '%s' %s"
    747         " WHERE job_id = %" PRId64;
    748    
    749     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)) {
    750797        psError(PS_ERR_UNKNOWN, false, "database error");
    751798        psFree(query);
    … …  
    753800    }
    754801    psFree(faultStr);
     802    psFree(query);
    755803
    756804    psU64 affected = psDBAffectedRows(config->dbh);
    757     if (affected != 1) {
    758         psError(PS_ERR_UNKNOWN, false, "should have affected one row but %"
    759                                         PRIu64 " rows were modified", affected);
    760         return false;
    761     }
     805    psLogMsg("pstamptool", PS_LOG_INFO, "Updated %" PRIu64 " pstampJobs", affected);
    762806
    763807    return true;
    … …  
    772816    PXOPT_COPY_S64(config->args, where, "-job_id", "job_id", "==");
    773817    PXOPT_COPY_S64(config->args, where, "-req_id", "req_id", "==");
    774     PXOPT_COPY_S64(config->args, where, "-fault",  "fault", "==");
     818    PXOPT_COPY_S64(config->args, where, "-fault",  "pstampJob.fault", "==");
    775819    PXOPT_COPY_S64(config->args, where, "-req_id_min",  "req_id", ">=");
     820    pxAddLabelSearchArgs(config, where, "-label", "pstampRequest.label", "LIKE");
     821
    776822    PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
    777823    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    }
    778833
    779834    psString query = pxDataGet("pstamptool_revertjob.sql");
    780835    if (!psListLength(where->list) && !all) {
    781836        psFree(where);
    782         psError(PXTOOLS_ERR_DATA, false, "search parameters or -all are required");
     837        psError(PXTOOLS_ERR_CONFIG, false, "search parameters or -all are required");
    783838        return false;
    784839    }
    785840    if (psListLength(where->list)) {
    786         psString whereClause = psDBGenerateWhereConditionSQL(where, "pstampJob");
     841        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    787842        psStringAppend(&query, " AND %s", whereClause);
    788843        psFree(whereClause);
    789844    }
    790845    psFree(where);
    791    
    792     if (!p_psDBRunQuery(config->dbh, query)) {
     846
     847    if (!p_psDBRunQueryF(config->dbh, query, faultClause)) {
    793848        psError(PS_ERR_UNKNOWN, false, "database error");
    794849        return false;
    … …  
    837892    psString query = pxDataGet("pstamptool_project.sql");
    838893    if (!query) {
    839         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     894        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    840895        return false;
    841896    }
    … …  
    883938
    884939    char *query = psStringCopy ("UPDATE pstampProject SET");
    885    
     940
    886941    psStringAppend(&query, " state = '%s'", state);
    887                
     942
    888943    psStringAppend(&query, " WHERE proj_id = %" PRId64, proj_id);
    889944
    … …  
    896951    psU64 affected = psDBAffectedRows(config->dbh);
    897952    if (affected != 1) {
    898         psError(PS_ERR_UNKNOWN, false, "should have affected one row but %" 
     953        psError(PS_ERR_UNKNOWN, false, "should have affected one row but %"
    899954                                        PRIu64 " rows were modified", affected);
    900955        return false;
    … …  
    910965    PXOPT_LOOKUP_STR(stage,       config->args, "-stage",   true, false);
    911966    PXOPT_LOOKUP_S64(stage_id,    config->args, "-stage_id", true, false);
     967    PXOPT_LOOKUP_STR(component,   config->args, "-component",  true, false);
    912968    PXOPT_LOOKUP_STR(imagedb,     config->args, "-imagedb",  true, false);
    913     PXOPT_LOOKUP_STR(rlabel,      config->args, "-rlabel",  false, false);
    914     PXOPT_LOOKUP_BOOL(no_magic,   config->args, "-no_magic", false);
     969    PXOPT_LOOKUP_STR(rlabel,      config->args, "-rlabel",  true, false);
     970    PXOPT_LOOKUP_BOOL(need_magic, config->args, "-need_magic", false);
    915971    PXOPT_LOOKUP_BOOL(no_create,  config->args, "-no_create", false);
    916972
    917     psString query = pxDataGet("pstamptool_pendingdependent.sql");
     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");
    918986    if (!query) {
    919         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    920         return false;
    921     }
     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
    9221000    if (!p_psDBRunQuery(config->dbh, query)) {
    9231001        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    9371015        if (!dep_id) {
    9381016            psError(PS_ERR_UNKNOWN, false, "database error");
     1017            psFree(output);
    9391018            return false;
    9401019        }
    9411020        printf("%" PRId64 "\n", dep_id);
     1021        psFree(output);
     1022        if (!psDBRollback(config->dbh)) {
     1023            psError(PS_ERR_UNKNOWN, false, "database error");
     1024        }
    9421025        return true;
    9431026    }
    9441027    if (no_create) {
     1028        if (!psDBRollback(config->dbh)) {
     1029            psError(PS_ERR_UNKNOWN, false, "database error");
     1030            return false;
     1031        }
    9451032        return true;
    9461033    }
    9471034    // 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
    9481037
    9491038    if (!pstampDependentInsert(
    … …  
    9531042        stage,
    9541043        stage_id,
     1044        component,
    9551045        imagedb,
    9561046        rlabel,
    957         no_magic
     1047        need_magic,
     1048        0               // fault
    9581049        )) {
     1050        if (!psDBRollback(config->dbh)) {
     1051            psError(PS_ERR_UNKNOWN, false, "database error");
     1052        }
    9591053        psError(PS_ERR_UNKNOWN, false, "failed to insert pstampDependent");
    9601054        return false;
    9611055    }
    9621056
     1057    // if we try and get this after commit zero is returned
    9631058    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    }
    9641075
    9651076    printf("%" PRId64 "\n", dep_id);
    … …  
    9731084
    9741085    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", "==");
    9751091
    9761092    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    9791095    psString query = pxDataGet("pstamptool_pendingdependent.sql");
    9801096    if (!query) {
    981         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1097        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    9821098        return false;
    9831099    }
    9841100
    9851101    if (psListLength(where->list)) {
    986         psString whereClause = psDBGenerateWhereConditionSQL(where, "pstampDependent");
     1102        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    9871103        psStringAppend(&query, " AND %s", whereClause);
    9881104        psFree(whereClause);
    … …  
    10311147
    10321148    PXOPT_LOOKUP_S64(dep_id,    config->args, "-dep_id", true, false);
    1033     PXOPT_LOOKUP_STR(state,     config->args, "-set_state",  true, false);
    1034 
    1035     char *query ="UPDATE pstampDependent"
    1036         " SET state = '%s'"
    1037         " WHERE dep_id = %" PRId64;
    1038    
    1039     if (!p_psDBRunQueryF(config->dbh, query, state, dep_id)) {
     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)) {
    10401169        psError(PS_ERR_UNKNOWN, false, "database error");
    10411170        psFree(query);
    … …  
    10451174    psU64 affected = psDBAffectedRows(config->dbh);
    10461175    if (affected != 1) {
    1047         psError(PS_ERR_UNKNOWN, false, "should have affected one row but %" 
     1176        psError(PS_ERR_UNKNOWN, false, "should have affected one row but %"
    10481177                                        PRIu64 " rows were modified", affected);
    10491178        return false;
    … …  
    10521181    return true;
    10531182}
     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/tap_branches/ippTools/src/pstamptool.h

    r25793 r27838  
    4646    PSTAMPTOOL_MODE_PENDINGDEPENDENT,
    4747    PSTAMPTOOL_MODE_UPDATEDEPENDENT,
     48    PSTAMPTOOL_MODE_REVERTDEPENDENT,
    4849} pstamptoolMode;
    4950

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

    r25793 r27838  
    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, "-name", 0,   "define request name", NULL); 
    68     psMetadataAddStr(addreqArgs, PS_LIST_TAIL, "-label", 0,  "define request label", 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);
    6976
    7077    // -pendingreq
    7178    psMetadata *pendingreqArgs = psMetadataAlloc();
    72     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);
    7381    psMetadataAddU64(pendingreqArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    7482    psMetadataAddBool(pendingreqArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    … …  
    7684    // -listreq
    7785    psMetadata *listreqArgs = psMetadataAlloc();
    78     psMetadataAddS64(listreqArgs, PS_LIST_TAIL, "-req_id", 0,            "list by req_id", 0); 
    79     psMetadataAddStr(listreqArgs, PS_LIST_TAIL, "-name", 0,              "list by name", NULL); 
    80     psMetadataAddS64(listreqArgs, PS_LIST_TAIL, "-not_req_id", 0,        "req_id to not list", 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);
    8189    psMetadataAddU64(listreqArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    8290    psMetadataAddBool(listreqArgs, PS_LIST_TAIL, "-simple", 0,           "use the simple output format", false);
    … …  
    8492    // -completedreq
    8593    psMetadata *completedreqArgs = psMetadataAlloc();
     94    psMetadataAddStr(completedreqArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by pstampJob label (LIKE comparision)", NULL);
    8695    psMetadataAddU64(completedreqArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    8796    psMetadataAddBool(completedreqArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    … …  
    8998    // -updatereq
    9099    psMetadata *updatereqArgs = psMetadataAlloc();
    91     psMetadataAddS64(updatereqArgs, PS_LIST_TAIL, "-req_id", 0,            "req_id for which to change state", 0); 
    92     psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-state", 0,            "new state", NULL); 
    93     psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-outProduct", 0,            "define request outProduct", NULL); 
    94     psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-fault", 0,            "define request fault code", NULL);
    95     psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-uri", 0,            "define the uri", NULL); 
    96     psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-name", 0,            "define the name", NULL); 
    97     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);
    98107
    99108    // -revertreq
    100109    psMetadata *revertreqArgs = psMetadataAlloc();
    101     psMetadataAddS64(revertreqArgs, PS_LIST_TAIL, "-req_id", 0,     "req_id to revert", 0);
    102     psMetadataAddS16(revertreqArgs, PS_LIST_TAIL, "-fault",  0,     "fault to revert", 0);
    103     psMetadataAddStr(revertreqArgs, PS_LIST_TAIL, "-state", 0,      "state to revert", NULL);
     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);
    104114
    105115    // -addjob
    106116    psMetadata *addjobArgs = psMetadataAlloc();
    107     psMetadataAddS64(addjobArgs, PS_LIST_TAIL, "-req_id", 0,           "define job req_id", 0); 
    108     psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-rownum", 0,           "define job rownum", NULL); 
    109     psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-job_type", 0,         "define job job_type", "stamp"); 
    110     psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-outputBase", 0,       "define job outputBase", NULL); 
    111     psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-state", 0,            "define state", "run"); 
    112     psMetadataAddS64(addjobArgs, PS_LIST_TAIL, "-exp_id", 0,           "define exposure id", 0); 
    113     psMetadataAddS64(addjobArgs, PS_LIST_TAIL, "-options", 0,          "define options", 0); 
    114     psMetadataAddS64(addjobArgs, PS_LIST_TAIL, "-dep_id", 0,           "define job dep_id", 0); 
    115     psMetadataAddS16(addjobArgs, PS_LIST_TAIL, "-fault", 0,            "define job result", 0); 
     117    psMetadataAddS64(addjobArgs, PS_LIST_TAIL, "-req_id", 0,           "define job req_id", 0);
     118    psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-rownum", 0,           "define job rownum", NULL);
     119    psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-job_type", 0,         "define job job_type", "stamp");
     120    psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-outputBase", 0,       "define job outputBase", NULL);
     121    psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-state", 0,            "define state", "run");
     122    psMetadataAddS64(addjobArgs, PS_LIST_TAIL, "-exp_id", 0,           "define exposure id", 0);
     123    psMetadataAddS64(addjobArgs, PS_LIST_TAIL, "-options", 0,          "define options", 0);
     124    psMetadataAddS64(addjobArgs, PS_LIST_TAIL, "-dep_id", 0,           "define job dep_id", 0);
     125    psMetadataAddS16(addjobArgs, PS_LIST_TAIL, "-fault", 0,            "define job result", 0);
    116126
    117127    // -listjob
    118128    psMetadata *listjobArgs = psMetadataAlloc();
    119     psMetadataAddS64(listjobArgs, PS_LIST_TAIL, "-req_id", 0,          "select by request ID", 0); 
    120     psMetadataAddS64(listjobArgs, PS_LIST_TAIL, "-job_id", 0,          "select by job ID", 0); 
    121     psMetadataAddS16(listjobArgs, PS_LIST_TAIL, "-fault", 0,           "select by fault", 0); 
     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);
    122132    psMetadataAddU64(listjobArgs, PS_LIST_TAIL, "-limit",  0,          "limit result set to N items", 0);
    123133    psMetadataAddBool(listjobArgs, PS_LIST_TAIL, "-simple", 0,         "use the simple output format", false);
    … …  
    125135    // -pendingjob
    126136    psMetadata *pendingjobArgs = psMetadataAlloc();
    127     psMetadataAddS64(pendingjobArgs, PS_LIST_TAIL, "-job_id", 0,            "define job", 0);
    128     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);
    129140    psMetadataAddU64(pendingjobArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    130141    psMetadataAddBool(pendingjobArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    … …  
    132143    // -updatejob
    133144    psMetadata *updatejobArgs = psMetadataAlloc();
    134     psMetadataAddS64(updatejobArgs, PS_LIST_TAIL, "-job_id", 0,            "req_id for which to change state", 0);
    135     psMetadataAddStr(updatejobArgs, PS_LIST_TAIL, "-state", 0,            "new state", NULL);
    136     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);
    137149
    138150    // -revertjob
    139151    psMetadata *revertjobArgs = psMetadataAlloc();
    140     psMetadataAddS64(revertjobArgs, PS_LIST_TAIL, "-req_id", 0,     "req_id to revert", 0);
    141     psMetadataAddS64(revertjobArgs, PS_LIST_TAIL, "-req_id_min", 0, "minimum req_id to revert", 0);
    142     psMetadataAddS64(revertjobArgs, PS_LIST_TAIL, "-job_id", 0,     "job_id to revert", 0);
    143     psMetadataAddS16(revertjobArgs, PS_LIST_TAIL, "-fault",  0,     "fault to revert", 0);
     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);
    144157    psMetadataAddBool(revertjobArgs, PS_LIST_TAIL, "-all", 0,       "revert all faulted jobs", false);
    145158    psMetadataAddU64(revertjobArgs, PS_LIST_TAIL, "-limit", 0,      "limit result set to N items", 0);
    … …  
    147160    // -getdependent
    148161    psMetadata *getdependentArgs = psMetadataAlloc();
    149     psMetadataAddS64(getdependentArgs, PS_LIST_TAIL, "-stage_id", 0, "define id for dependent run (required)", 0);
    150     psMetadataAddStr(getdependentArgs, PS_LIST_TAIL, "-stage", 0,    "define stage for dependent run (required)", NULL);
    151     psMetadataAddStr(getdependentArgs, PS_LIST_TAIL, "-imagedb", 0,  "define imagedb for depenent run (required)", NULL);
    152     psMetadataAddStr(getdependentArgs, PS_LIST_TAIL, "-rlabel", 0,   "define label for dependent run", NULL);
    153     psMetadataAddBool(getdependentArgs,PS_LIST_TAIL, "-no_magic", 0, "define no_magic", false);
    154     psMetadataAddBool(getdependentArgs,PS_LIST_TAIL, "-no_create", 0, "if no run exists do not create one", false);
     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);
    155169
    156170    // -updatedependent
    157171    psMetadata *updatedependentArgs = psMetadataAlloc();
    158     psMetadataAddS64(updatedependentArgs, PS_LIST_TAIL, "-dep_id", 0, "define id for dependent run (required)", 0);
    159     psMetadataAddStr(updatedependentArgs, PS_LIST_TAIL, "-set_state", 0, "new value for state (required)", NULL);
     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);
    160181
    161182    // -pendingdependent
    162183    psMetadata *pendingdependentArgs = psMetadataAlloc();
    163     psMetadataAddS64(pendingdependentArgs, PS_LIST_TAIL, "-stage_id", 0, "define id for dependent run", 0);
    164     psMetadataAddStr(pendingdependentArgs, PS_LIST_TAIL, "-stage", 0,    "define stage for dependent run", NULL);
    165     psMetadataAddStr(pendingdependentArgs, PS_LIST_TAIL, "-imagedb", 0,  "define imagedb for depenent run", NULL);
    166     psMetadataAddStr(pendingdependentArgs, PS_LIST_TAIL, "-rlabel", 0,   "define label for dependent run", NULL);
    167     psMetadataAddBool(pendingdependentArgs,PS_LIST_TAIL, "-no_magic", 0, "define no_magic", false);
    168     psMetadataAddBool(pendingdependentArgs,PS_LIST_TAIL, "-no_create", 0, "if no run exists do not create one", false);
     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);
    169190    psMetadataAddU64(pendingdependentArgs, PS_LIST_TAIL, "-limit",  0,    "limit result set to N items", 0);
    170191    psMetadataAddBool(pendingdependentArgs, PS_LIST_TAIL, "-simple", 0,   "use the simple output format", false);
    … …  
    182203    // -modproject
    183204    psMetadata *modprojectArgs = psMetadataAlloc();
    184     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);
    185206    psMetadataAddStr(modprojectArgs, PS_LIST_TAIL, "-imagedb",      0, "define name of database for project", NULL);
    186207    psMetadataAddStr(modprojectArgs, PS_LIST_TAIL, "-state",        0, "define state for project (enabled, disabled)", NULL);
    … …  
    192213    // -project
    193214    psMetadata *projectArgs = psMetadataAlloc();
    194     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);
    195216    psMetadataAddBool(projectArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    196217
    … …  
    218239    PXOPT_ADD_MODE("-updatedependent", "", PSTAMPTOOL_MODE_UPDATEDEPENDENT, updatedependentArgs);
    219240    PXOPT_ADD_MODE("-pendingdependent","", PSTAMPTOOL_MODE_PENDINGDEPENDENT, pendingdependentArgs);
     241    PXOPT_ADD_MODE("-revertdependent","", PSTAMPTOOL_MODE_REVERTDEPENDENT, revertdependentArgs);
    220242
    221243    PXOPT_ADD_MODE("-addproject",      "", PSTAMPTOOL_MODE_ADDPROJECT, addprojectArgs);

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

    r25256 r27838  
    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;
    … …  
    311355    PXOPT_COPY_STR(config->args, where, "-client_id", "publishClient.client_id", "==");
    312356    PXOPT_COPY_STR(config->args, where, "-comment", "publishClient.comment", "LIKE");
    313     PXOPT_COPY_STR(config->args, where, "-label", "publishRun.label", "==");
     357    pxAddLabelSearchArgs(config, where, "-label", "publishRun.label", "==");
    314358
    315359    psString query = pxDataGet("pubtool_revert.sql");
    316360    if (!query) {
    317         psError(PXTOOLS_ERR_DATA, false, "Failed to retreive SQL statement");
     361        psError(PXTOOLS_ERR_SYS, false, "Failed to retreive SQL statement");
    318362        psFree(where);
    319363        return false;

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

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

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

    r25256 r27838  
    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
    … …  
    7888    psMetadataAddStr(revertArgs, PS_LIST_TAIL, "-client_id", 0, "search on client_id", NULL);
    7989    psMetadataAddStr(revertArgs, PS_LIST_TAIL, "-comment", 0, "search on comment (LIKE)", NULL);
    80     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);
    8191
    8292
    … …  
    8595
    8696    PXOPT_ADD_MODE("-defineclient", "", PUBTOOL_MODE_DEFINECLIENT, defineclientArgs);
     97    PXOPT_ADD_MODE("-updateclient", "", PUBTOOL_MODE_UPDATECLIENT, updateclientArgs);
    8798    PXOPT_ADD_MODE("-definerun", "", PUBTOOL_MODE_DEFINERUN, definerunArgs);
    8899    PXOPT_ADD_MODE("-pending", "", PUBTOOL_MODE_PENDING, pendingArgs);

  • branches/tap_branches/ippTools/src/pxadd.c

    r25835 r27838  
    124124bool pxaddQueueByCamID(pxConfig *config,
    125125                       psS64 cam_id,
    126                        char *workdir,
    127                        char *reduction,
    128                        char *label,
     126                       char *workdir,
     127                       char *reduction,
     128                       char *label,
    129129                       char *data_group,
    130                        char *dvodb,
     130                       char *dvodb,
    131131                       char *note,
    132                        bool image_only)
     132                       bool image_only)
    133133{
    134134    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    140140        psMemSetPersistent(query, true);
    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        }
    … …  
    149149    // on 32/64
    150150    if (!p_psDBRunQueryF(config->dbh, query,
    151                         "new", // state
    152                         workdir  ? workdir   : "NULL",
    153                         "dirty", //workdir_state
    154                         reduction? reduction : "NULL",
    155                         label    ? label     : "NULL",
    156                         data_group ? data_group     : "NULL",
    157                         dvodb    ? dvodb     : "NULL",
    158                         note     ? note     : "NULL",
    159                         image_only,
    160                         (long long) cam_id
     151                        "new", // state
     152                        workdir  ? workdir   : "NULL",
     153                        "dirty", //workdir_state
     154                        reduction? reduction : "NULL",
     155                        label    ? label     : "NULL",
     156                        data_group ? data_group     : "NULL",
     157                        dvodb    ? dvodb     : "NULL",
     158                        note     ? note     : "NULL",
     159                        image_only,
     160                        (long long) cam_id
    161161    )) {
    162162        psError(PS_ERR_UNKNOWN, false, "database error");

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

    r25851 r27838  
    9494    psString query = pxDataGet("pxadmin_create_tables.sql");
    9595    if (!query) {
    96         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     96        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    9797        return false;
    9898    }
    … …  
    114114    psFree(query);
    115115
    116     if (!insert_dbversion(config, PACKAGE_VERSION)) {
     116    if (!insert_dbversion(config, IPPDB_VERSION)) {
    117117        psError(PS_ERR_UNKNOWN, false, "failed to set database version");
    118118        return false;
    … …  
    135135    psString query = pxDataGet("pxadmin_create_mirror_tables.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    }
    … …  
    155155    psFree(query);
    156156
    157     if (!insert_dbversion(config, PACKAGE_VERSION)) {
     157    if (!insert_dbversion(config, IPPDB_VERSION)) {
    158158        psError(PS_ERR_UNKNOWN, false, "failed to set database version");
    159159        return false;
    … …  
    220220    psString query = pxDataGet("pxadmin_drop_tables.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        return false;
    224224    }

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

    r25835 r27838  
    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",        "<");
    … …  
    152152                    char *tess_id,
    153153                    char *end_stage,
     154                    psS64 magicked,
    154155                    char *note)
    155156{
    … …  
    162163        psMemSetPersistent(query, true);
    163164        if (!query) {
    164             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     165            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    165166            return false;
    166167        }
    … …  
    168169
    169170    // queue the exp
    170     // 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
    171172    // different on 32/64
    172173    if (!p_psDBRunQueryF(config->dbh, query,
    … …  
    182183                tess_id  ? tess_id  : "NULL",
    183184                end_stage ? end_stage : "NULL",
     185                (long long) magicked,
    184186                note     ? note     : "NULL",
    185187                (long long)chip_id

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

    r25835 r27838  
    4040                        char *tess_id,
    4141                        char *end_stage,
     42                        psS64 magicked,
    4243                        char *note);
    4344

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

    r25835 r27838  
    9696    PXOPT_COPY_STR(config->args, where, "-exp_type", "rawExp.exp_type", "==");
    9797    PXOPT_COPY_STR(config->args, where, "-filelevel", "rawExp.filelevel", "==");
    98     PXOPT_COPY_STR(config->args, where, "-filter", "rawExp.filter", "==");
     98    PXOPT_COPY_STR(config->args, where, "-filter", "rawExp.filter", "LIKE");
    9999    PXOPT_COPY_F64(config->args, where, "-airmass_min", "rawExp.airmass", ">=");
    100100    PXOPT_COPY_F64(config->args, where, "-airmass_max", "rawExp.airmass", "<");
    … …  
    125125    PXOPT_COPY_F32(config->args, where, "-sun_angle_max", "rawExp.sun_angle", "<");
    126126    PXOPT_COPY_STR(config->args, where, "-comment", "rawExp.comment", "LIKE");
    127     PXOPT_COPY_STR(config->args, where, "-obs_mode", "rawExp.obs_mode", "==");
    128     return true;
    129 }
    130 
    131 bool pxchipRunSetState(pxConfig *config, psS64 chip_id, const char *state, const bool magicked)
     127    PXOPT_COPY_STR(config->args, where, "-obs_mode", "rawExp.obs_mode", "LIKE");
     128    return true;
     129}
     130
     131bool pxchipRunSetState(pxConfig *config, psS64 chip_id, const char *state, const psS64 magicked)
    132132{
    133133    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    140140    }
    141141
    142     char *query = "UPDATE chipRun SET state = '%s', magicked = %d WHERE chip_id = %" PRId64;
     142    char *query = "UPDATE chipRun SET state = '%s', magicked = %" PRId64 " WHERE chip_id = %" PRId64;
    143143    if (!p_psDBRunQueryF(config->dbh, query, state, magicked, chip_id)) {
    144144        psError(PS_ERR_UNKNOWN, false,
    … …  
    174174
    175175    psString query = psStringCopy("UPDATE chipRun JOIN rawExp USING(exp_id) SET state = '%s'");
     176
     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    }
    176181
    177182    if (where && psListLength(where->list) > 0) {
    … …  
    213218/*     } */
    214219
    215     psString query = psStringCopy("UPDATE chipProcessedImfile JOIN chipRun USING(chip_id) JOIN rawExp ON chipRun.exp_id = rawExp.exp_id SET state = '%s'");
     220    psString query = psStringCopy("UPDATE chipProcessedImfile JOIN chipRun USING(chip_id) JOIN rawExp ON chipRun.exp_id = rawExp.exp_id SET data_state = '%s'");
    216221
    217222    if (where && psListLength(where->list) > 0) {
    … …  
    219224        psStringAppend(&query, " %s", whereClause);
    220225        psFree(whereClause);
     226    } else {
     227        psError(PS_ERR_UNKNOWN, true, "search parameters are required");
     228        return false;
    221229    }
    222230

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

    r25835 r27838  
    2727
    2828
    29 bool pxchipRunSetState(pxConfig *config, psS64 chip_id, const char *state, const bool magicked);
     29bool pxchipRunSetState(pxConfig *config, psS64 chip_id, const char *state, const psS64 magicked);
    3030bool pxchipProcessedImfileSetStateByQuery(pxConfig *config, psMetadata *where, const char *state);
    3131

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

    r23487 r27838  
    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/tap_branches/ippTools/src/pxfake.c

    r25835 r27838  
    7474        psMemSetPersistent(query, true);
    7575        if (!query) {
    76             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     76            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    7777            return false;
    7878        }

  • branches/tap_branches/ippTools/src/pxmagic.c

    r25771 r27838  
    3535    psString query_temp = pxDataGet(queryFile);
    3636    if (!query_temp) {
    37         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement from %s", queryFile);
     37        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement from %s", queryFile);
    3838        psFree(queryFile);
    3939        if (!psDBRollback(config->dbh)) {
    … …  
    7575    if (not_destreaked) {
    7676        if (destreaked) {
    77             psError(PXTOOLS_ERR_DATA, true, "providing -not_destreaked and -destreaked makes no sense");
     77            psError(PXTOOLS_ERR_CONFIG, true, "providing -not_destreaked and -destreaked makes no sense");
    7878            return false;
    7979        }
    8080        if (magicked) {
    81             psError(PXTOOLS_ERR_DATA, true, "providing -not_destreaked and -magicked makes no sense");
     81            psError(PXTOOLS_ERR_CONFIG, true, "providing -not_destreaked and -magicked makes no sense");
    8282            return false;
    8383        }
    … …  
    8787        psStringAppend(out, " AND %s.magicked != 0", table);
    8888    }
     89    // Note -magicked is  handled by the caller. XXX: Why?
    8990    return true;
    9091}

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

    r21402 r27838  
    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/tap_branches/ippTools/src/pxregister.h

    r18336 r27838  
    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/tap_branches/ippTools/src/pxtools.c

    r25851 r27838  
    6161        if (!state) {
    6262            psError(PS_ERR_PROGRAMMING, false, "%s not found in row %ld of table %s",
    63                     columnName, i, tableName);
     63                    columnName, i, tableName);
    6464            return false;
    6565        }
    … …  
    7070            // if state isn't cleaned or full we can't set it to cleaned
    7171            psError(PS_ERR_PROGRAMMING, true, "%s with state %s may not be exported cleaned",
    72                     tableName, state);
     72                    tableName, state);
    7373            return false;
    7474        }
    … …  
    9090    psAssert (entry, "%s should at least have a place-holder", name);
    9191    if (entry->data.str) {
    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);
     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);
    107107    }
    108108    return true;
    … …  
    110110
    111111// shared code for updating the various strings for a Run
    112 bool pxUpdateRun(pxConfig *config, psMetadata *where, psString *pQuery, psString table, bool has_dist_group)
     112bool pxUpdateRun(pxConfig *config, psMetadata *where, psString *pQuery, psString runTable, psString idColumn, psString fileTable, bool has_dist_group)
    113113{
    114114    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    116116    PS_ASSERT_PTR_NON_NULL(pQuery, false);
    117117    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);
    118121
    119122    // make sure that -state is not the only selection parameter
    120123    PXOPT_LOOKUP_STR(where_state, config->args, "-state", false, false);
    121124    if (where_state && (psListLength(where->list) < 2)) {
    122         psError(PXTOOLS_ERR_DATA, true, "selection by -state alone is not allowed");
     125        psError(PXTOOLS_ERR_CONFIG, true, "selection by -state alone is not allowed");
    123126        return false;
    124127    }
    … …  
    136139
    137140    if ((!state) && (!label) && (!data_group) && (has_dist_group && !dist_group) && !(note)) {
    138         psError(PXTOOLS_ERR_DATA, false, "parameters are required");
     141        psError(PXTOOLS_ERR_CONFIG, false, "parameters are required");
    139142        return false;
    140143    }
    141144
    142145    if (state && ! pxIsValidState(state)) {
    143         psError(PXTOOLS_ERR_DATA, false, "pxIsValidState failed");
     146        psError(PXTOOLS_ERR_CONFIG, false, "pxIsValidState failed");
    144147        return false;
    145148    }
    … …  
    158161        } while (0)
    159162
    160     addColumn(table, state);
    161     addColumn(table, data_group);
     163    addColumn(runTable, state);
     164    addColumn(runTable, data_group);
    162165    if (has_dist_group) {
    163         addColumn(table, dist_group);
    164     }
    165     addColumn(table, note);
    166     addColumn(table, label);
     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    }
    167178
    168179    psString whereClause =  psDBGenerateWhereSQL(where, NULL);
    169180    psStringAppend(pQuery, " %s", whereClause);
    170181    psFree(whereClause);
    171 
    172     if (!p_psDBRunQuery(config->dbh, *pQuery)) {
     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)) {
    173193        psError(PS_ERR_UNKNOWN, false, "database error");
    174194        return false;
    … …  
    198218    }
    199219    if (psArrayLength(output) > 1) {
    200         psError(PS_ERR_UNKNOWN, true, "unexpected number of rows found in dbversion: %" PRId64,
     220        psError(PS_ERR_UNKNOWN, true, "unexpected number of rows found in dbversion: %ld",
    201221                psArrayLength(output));
    202222        return false;
    … …  
    221241        return NULL;
    222242    }
    223    
     243
    224244    psString version = psMetadataLookupStr(NULL, md, "schema_version");
    225245
    … …  
    257277        return false;
    258278    }
    259    
     279
    260280    psMetadataItem *dbversion = psListGet(multi_item->data.list, 0);
    261281    if (!dbversion) {
    … …  
    272292            return false;
    273293        }
    274        
     294
    275295        psString import_version = psMetadataLookupStr(NULL, md, "schema_version");
    276296        if (import_version && strcmp(import_version, schema_version)) {

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

    r25851 r27838  
    6565bool pxGetOptions(FILE *stream, int argc, char **argv, pxConfig *config, psMetadata *modes, psMetadata *argSets);
    6666
    67 bool pxUpdateRun(pxConfig *config, psMetadata *where, psString *pQuery, psString table, bool has_dist_group);
     67bool pxUpdateRun(pxConfig *config, psMetadata *where, psString *pQuery, psString runTable, psString idColumn, psString fileTable, bool has_dist_group);
    6868
    6969#define PXOPT_ADD_MODE(option, comment, modeval, argset) \

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

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

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

    r25418 r27838  
    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;
    … …  
    492493    psString query = pxDataGet("pztool_find_completed_exp.sql");
    493494    if (!query) {
    494         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     495        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    495496        return false;
    496497    }
    … …  
    783784    psMetadata *where = psMetadataAlloc();
    784785    PXOPT_COPY_STR(config->args, where,  "-exp_name", "exp_name", "==");
    785     PXOPT_COPY_STR(config->args, where, "-inst", "inst", "==");
     786    PXOPT_COPY_STR(config->args, where, "-inst", "camera", "==");
    786787    PXOPT_COPY_STR(config->args, where, "-telescope", "telescope", "==");
    787788    PXOPT_COPY_STR(config->args, where,  "-class", "class", "==");
    … …  
    807808    psMetadata *where = psMetadataAlloc();
    808809    PXOPT_COPY_STR(config->args, where,  "-exp_name", "exp_name", "==");
    809     PXOPT_COPY_STR(config->args, where, "-inst", "inst", "==");
     810    PXOPT_COPY_STR(config->args, where, "-inst", "camera", "==");
    810811    PXOPT_COPY_STR(config->args, where, "-telescope", "telescope", "==");
    811812    PXOPT_COPY_STR(config->args, where,  "-class", "class", "==");
    … …  
    814815    psString query = pxDataGet("pztool_revertcopied.sql");
    815816    if (!query) {
    816         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     817        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    817818        return false;
    818819    }
    … …  
    848849    psString query = pxDataGet("pztool_revert_downloadimfile_faults.sql");
    849850    if (!query) {
    850         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     851        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    851852        return false;
    852853    }
    … …  
    863864    psString query = pxDataGet("pztool_revert_fileset_faults.sql");
    864865    if (!query) {
    865         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     866        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    866867        return false;
    867868    }

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

    r25418 r27838  
    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;

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

    r24784 r27838  
    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/tap_branches/ippTools/src/receivetoolConfig.c

    r24125 r27838  
    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/tap_branches/ippTools/src/regtool.c

    r25835 r27838  
    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);
    … …  
    255264        class_id,
    256265        uri,
     266        data_state,
    257267        exp_type,
    258268        filelevel,
    … …  
    333343    PXOPT_COPY_TIME(config->args, where, "-dateobs_begin", "dateobs",  ">=");
    334344    PXOPT_COPY_TIME(config->args, where, "-dateobs_end",   "dateobs",  "<=");
    335     PXOPT_COPY_STR(config->args, where,  "-filter",        "filter", "==");
     345    PXOPT_COPY_STR(config->args, where,  "-filter",        "filter", "LIKE");
    336346    PXOPT_COPY_STR(config->args, where,  "-exp_type",      "exp_type", "==");
    337347    PXOPT_COPY_STR(config->args, where,  "-obs_mode",      "obs_mode", "==");
    338     PXOPT_COPY_S64(config->args, where,  "-magicked",      "magicked", "==");
     348    PXOPT_COPY_STR(config->args, where,  "-data_state",    "data_state", "==");
    339349
    340350    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    341351    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
     352    PXOPT_LOOKUP_BOOL(allfiles, config->args, "-allfiles", false);
     353    if (allfiles) {
     354        faulted = false;
     355    }
    342356    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    343357    PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
    … …  
    347361    psString where2 = NULL;
    348362    if (!pxmagicAddWhere(config, &where2, "rawImfile")) {
    349         psError(PXTOOLS_ERR_DATA, false, "pxSpaceAddWhere failed");
     363        psError(psErrorCodeLast(), false, "pxmagicAddWhere failed");
    350364        return false;
    351365    }
    352366    if (!pxspaceAddWhere(config, &where2, "rawImfile")) {
    353         psError(PXTOOLS_ERR_DATA, false, "pxSpaceAddWhere failed");
     367        psError(psErrorCodeLast(), false, "pxspaceAddWhere failed");
    354368        return false;
    355369    }
    … …  
    357371    psString query = pxDataGet("regtool_processedimfile.sql");
    358372    if (!query) {
    359         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     373        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    360374        psFree(where);
    361375        return false;
    … …  
    367381        psFree(whereClause);
    368382    } else if (!all && !where2) {
    369         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     383        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    370384        return false;
    371385    }
    … …  
    379393        // list only faulted rows
    380394        psStringAppend(&query, " %s", "AND rawImfile.fault != 0");
    381     } else {
     395    } else if (!allfiles) {
    382396        // don't list faulted rows
    383397        psStringAppend(&query, " %s", "AND rawImfile.fault = 0");
    … …  
    452466    psString query = pxDataGet("regtool_revertprocessedimfile.sql");
    453467    if (!query) {
    454         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     468        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    455469        psFree(where);
    456470        return false;
    … …  
    463477    } else {
    464478        psFree(where);
    465         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     479        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    466480        return false;
    467481    }
    … …  
    491505
    492506    PXOPT_LOOKUP_S16(fault, config->args, "-fault",   false, false);
    493 /*     PXOPT_LOOKUP_F64(user_1, config->args, "-user_1", false, false); */
    494507    PXOPT_LOOKUP_S16(burntool_state, config->args, "-burntool_state", false, false);
    495    
    496     if ((fault == INT16_MAX) && !isfinite(burntool_state)) {
    497         psError(PS_ERR_UNKNOWN, false, "one of -fault or -burntool_state must be selected");
    498         return false;
    499     }
    500     if ((fault != INT16_MAX) && isfinite(burntool_state)) {
     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)) {
    501517        psError(PS_ERR_UNKNOWN, false, "only one of -fault or -burntool_state must be selected");
    502518        return false;
    … …  
    508524
    509525    if (fault != INT16_MAX) {
    510         // this is fairly dangerous : can set all if the where is not set...
    511         if (!pxSetFaultCode(config->dbh, "rawImfile", where, fault)) {
    512             psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    513             psFree (where);
    514             return false;
    515         }
    516     }
    517 
    518     if (isfinite(burntool_state)) {
    519         psString query = pxDataGet("regtool_updateprocessedimfile.sql");
    520         if (!query) {
    521             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    522             return false;
    523         }
    524 
    525         if (!p_psDBRunQueryF(config->dbh, query, burntool_state, exp_id, class_id)) {
    526             psError(PS_ERR_UNKNOWN, false, "database error");
    527             psFree(query);
    528             return false;
    529         }
    530         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);
    531534    }
    532535    psFree (where);
    533536
     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
    534576    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;
    535663}
    536664
    … …  
    549677    psString query = pxDataGet("regtool_pendingexp.sql");
    550678    if (!query) {
    551         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     679        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    552680        return false;
    553681    }
    … …  
    626754    PXOPT_LOOKUP_STR(exp_type, config->args, "-exp_type", false, false);
    627755    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", false, false);
     756    PXOPT_LOOKUP_STR(state, config->args, "-state", false, false);
    628757    PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false);
    629758    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", false, false);
    … …  
    687816    psString query = pxDataGet("regtool_pendingexp.sql");
    688817    if (!query) {
    689         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     818        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    690819        return false;
    691820    }
    … …  
    787916        filelevel,
    788917        workdir,
     918        state,
    789919        reduction,
    790920        dvodb,
    … …  
    9201050    psString query = pxDataGet("regtool_processedexp.sql");
    9211051    if (!query) {
    922         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1052        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    9231053        return false;
    9241054    }
    … …  
    9301060    PXOPT_COPY_STR(config->args,   where,  "-inst", "camera", "==");
    9311061    PXOPT_COPY_STR(config->args,   where,  "-telescope", "telescope", "==");
    932     PXOPT_COPY_TIME(config->args,  where, "-dateobs_begin", "dateobs", ">=");
    933     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", "==");
    9341065    PXOPT_COPY_STR(config->args,   where,  "-exp_tag", "exp_tag", "==");
    9351066    PXOPT_COPY_STR(config->args,   where,  "-exp_type", "exp_type", "==");
    9361067    PXOPT_COPY_STR(config->args,   where,  "-filelevel", "filelevel", "==");
    9371068    PXOPT_COPY_STR(config->args,   where,  "-reduction", "reduction", "==");
    938     PXOPT_COPY_STR(config->args,   where,  "-filter", "filter", "==");
     1069    PXOPT_COPY_STR(config->args,   where,  "-filter", "filter", "LIKE");
    9391070    PXOPT_COPY_F32(config->args,   where,  "-airmass_min", "airmass", ">=");
    9401071    PXOPT_COPY_F32(config->args,   where,  "-airmass_max", "airmass", "<");
    … …  
    9651096    PXOPT_COPY_F32(config->args,   where,  "-sun_angle_max", "sun_angle", "<");
    9661097
     1098    psString where2 = NULL;
     1099    if (!pxmagicAddWhere(config, &where2, "rawExp")) {
     1100        psError(psErrorCodeLast(), false, "pxmagicAddWhere failed");
     1101        return false;
     1102    }
     1103    if (!pxspaceAddWhere(config, &where2, "rawExp")) {
     1104        psError(psErrorCodeLast(), false, "pxSpaceAddWhere failed");
     1105        return false;
     1106    }
     1107
    9671108    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    9681109    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    9701111
    9711112    if (psListLength(where->list)) {
    972         psString whereClause = psDBGenerateWhereConditionSQL(where, "rawExp");
    973         psStringAppend(&query, " AND %s", whereClause);
    974         psFree(whereClause);
     1113      psString whereClause = psDBGenerateWhereConditionSQL(where, "rawExp");
     1114      psStringAppend(&query, " AND %s", whereClause);
     1115      psFree(whereClause);
    9751116    }
    9761117    psFree(where);
    9771118
     1119    if (where2) {
     1120        psStringAppend(&query, " %s ", where2);
     1121        psFree(where2);
     1122    }
     1123
    9781124    if (faulted) {
    979         // list only faulted rows
    980         psStringAppend(&query, " %s", "AND rawExp.fault != 0");
     1125      // list only faulted rows
     1126      psStringAppend(&query, " %s", "AND rawExp.fault != 0");
    9811127    } else {
    982         // don't list faulted rows
    983         psStringAppend(&query, " %s", "AND rawExp.fault = 0");
     1128      // don't list faulted rows
     1129      psStringAppend(&query, " %s", "AND rawExp.fault = 0");
    9841130    }
    9851131
    9861132    // treat limit == 0 as "no limit"
    9871133    if (limit) {
    988         psString limitString = psDBGenerateLimitSQL(limit);
    989         psStringAppend(&query, " %s", limitString);
    990         psFree(limitString);
     1134      psString limitString = psDBGenerateLimitSQL(limit);
     1135      psStringAppend(&query, " %s", limitString);
     1136      psFree(limitString);
    9911137    }
    9921138
    9931139    if (!p_psDBRunQuery(config->dbh, query)) {
    994         psError(PS_ERR_UNKNOWN, false, "database error");
    995         return false;
     1140      psError(PS_ERR_UNKNOWN, false, "database error");
     1141      return false;
    9961142    }
    9971143    psFree(query);
    … …  
    9991145    psArray *output = p_psDBFetchResult(config->dbh);
    10001146    if (!output) {
    1001         psErrorCode err = psErrorCodeLast();
    1002         switch (err) {
    1003             case PS_ERR_DB_CLIENT:
    1004                 psError(PXTOOLS_ERR_SYS, false, "database error");
    1005             case PS_ERR_DB_SERVER:
    1006                 psError(PXTOOLS_ERR_PROG, false, "database error");
    1007             default:
    1008                 psError(PXTOOLS_ERR_PROG, false, "unknown error");
    1009         }
    1010 
    1011         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;
    10121158    }
    10131159    if (!psArrayLength(output)) {
    1014         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");
    10151169        psFree(output);
    1016         return true;
    1017     }
    1018 
    1019     if (psArrayLength(output)) {
    1020         // negative simple so the default is true
    1021         if (!ippdbPrintMetadatas(stdout, output, "rawExp", !simple)) {
    1022             psError(PS_ERR_UNKNOWN, false, "failed to print array");
    1023             psFree(output);
    1024             return false;
    1025         }
     1170        return false;
     1171      }
    10261172    }
    10271173
    … …  
    10331179static bool revertprocessedexpMode(pxConfig *config)
    10341180{
    1035     PS_ASSERT_PTR_NON_NULL(config, false);
    1036 
    1037     psMetadata *where = psMetadataAlloc();
    1038     PXOPT_COPY_S64(config->args, where,  "-exp_id",       "exp_id", "==");
    1039     PXOPT_COPY_S16(config->args, where,  "-fault",         "fault", "==");
    1040     PXOPT_COPY_S64(config->args, where,  "-exp_id_begin", "exp_id", ">=");
    1041     PXOPT_COPY_S64(config->args, where,  "-exp_id_end", "exp_id", "<=");
    1042 
    1043     psString query = pxDataGet("regtool_revertprocessedexp.sql");
    1044     if (!query) {
    1045         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1046         psFree(where);
    1047         return false;
    1048     }
    1049 
    1050     if (psListLength(where->list)) {
    1051         psString whereClause = psDBGenerateWhereConditionSQL(where, "rawExp");
    1052         psStringAppend(&query, " AND %s", whereClause);
    1053         psFree(whereClause);
    1054     } else {
    1055         psFree(where);
    1056         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
    1057         return false;
    1058     }
     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");
    10591192    psFree(where);
    1060 
    1061     if (!p_psDBRunQuery(config->dbh, query)) {
    1062         psError(PS_ERR_UNKNOWN, false, "database error");
    1063         psFree(query);
    1064         return false;
    1065     }
     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");
    10661209    psFree(query);
    1067 
    1068     int numUpdated = psDBAffectedRows(config->dbh);
    1069 
    1070     psLogMsg("regtool", PS_LOG_INFO, "Updated %d rawExp", numUpdated);
    1071 
    1072     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;
    10731219}
    10741220
    … …  
    10761222static bool updateprocessedexpMode(pxConfig *config)
    10771223{
    1078     PS_ASSERT_PTR_NON_NULL(config, false);
    1079 
    1080     psMetadata *where = psMetadataAlloc();
    1081     PXOPT_COPY_S64(config->args, where,  "-exp_id",       "exp_id", "==");
    1082 
    1083     PXOPT_LOOKUP_S16(fault, config->args, "-fault", true, false);
    1084 
    1085     if (!pxSetFaultCode(config->dbh, "rawExp", where, fault)) {
    1086         psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    1087         psFree(where);
    1088         return false;
    1089     }
     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");
    10901233    psFree(where);
    1091 
    1092     return true;
    1093 }
     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
    10941427
    10951428
    … …  
    11111444            psError(PS_ERR_UNKNOWN, false, "database error");
    11121445        }
    1113         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1446        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11141447        return false;
    11151448    }
    … …  
    11371470            psError(PS_ERR_UNKNOWN, false, "database error");
    11381471        }
    1139         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1472        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11401473        return false;
    11411474    }
    … …  
    12181551  }
    12191552
     1553  if (!pxExportVersion(config, f)) {
     1554    psError(PS_ERR_UNKNOWN, false, "failed to write dbversion to output file");
     1555    return false;
     1556  }
     1557
    12201558  psMetadata *where = psMetadataAlloc();
    12211559  PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    … …  
    12291567    psString query = pxDataGet(tables[i].sqlFilename);
    12301568    if (!query) {
    1231       psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1569      psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    12321570      return false;
    12331571    }
    … …  
    12871625
    12881626  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
    12891633
    12901634  fprintf (stdout, "---- input ----\n");

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

    r23310 r27838  
    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/tap_branches/ippTools/src/regtoolConfig.c

    r25775 r27838  
    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
    … …  
    139139    ADD_OPT(Str,  processedimfileArgs, "-obs_mode",  "search by obs_mod",                        NULL);
    140140    ADD_OPT(Str,  processedimfileArgs, "-exp_type",  "search by exposure type",                        NULL);
     141    ADD_OPT(Str,  processedimfileArgs, "-data_state", "search by data_state",                 NULL);
    141142    ADD_OPT(Time, processedimfileArgs, "-dateobs_begin", "search for exposures by time (>=)", NULL);
    142143    ADD_OPT(Time, processedimfileArgs, "-dateobs_end", "search for exposures by time (<)", NULL);
    143144    ADD_OPT(U64,  processedimfileArgs, "-limit",     "limit result set to N items",           0);
    144145    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);
    145147    ADD_OPT(Bool, processedimfileArgs, "-all",   "list without search arguments", false);
    146148    ADD_OPT(Bool, processedimfileArgs, "-simple",    "use the simple output format",          false);
    … …  
    162164    ADD_OPT(S64, updateprocessedimfileArgs, "-exp_id",        "search by exposure ID", 0);
    163165    ADD_OPT(Str, updateprocessedimfileArgs, "-class_id",      "search by class ID", NULL);
    164     ADD_OPT(S16, updateprocessedimfileArgs, "-burntool_state",        "set burntool state", 0);
     166    ADD_OPT(S16, updateprocessedimfileArgs, "-burntool_state",        "set burntool state", INT16_MAX);
    165167    ADD_OPT(S16, updateprocessedimfileArgs, "-fault",          "set fault code", INT16_MAX);
    166 
     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   
    167173    // -pendingexp
    168174    psMetadata *pendingexpArgs = psMetadataAlloc();
    … …  
    185191    ADD_OPT(Str,  addprocessedexpArgs, "-exp_type",         "define exposure type", NULL);
    186192    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);
    187194    ADD_OPT(Str,  addprocessedexpArgs, "-dvodb",            "define the dvodb for the next processing step", NULL);
    188195    ADD_OPT(Str,  addprocessedexpArgs, "-tess_id",          "define the tess_id for the next processing step", NULL);
    … …  
    253260    psMetadataAddTime(processedexpArgs, PS_LIST_TAIL, "-dateobs_begin", 0,            "search for exposures by time (>=)", NULL);
    254261    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);
    255263    psMetadataAddStr(processedexpArgs,  PS_LIST_TAIL, "-exp_tag",       0,            "search by exp_tag", NULL);
    256264    psMetadataAddStr(processedexpArgs,  PS_LIST_TAIL, "-exp_type",      0,            "search by exp_type", "object");
    … …  
    285293    psMetadataAddF32(processedexpArgs,  PS_LIST_TAIL, "-sun_angle_min",    0,         "define min solar angle", NAN);
    286294    psMetadataAddF32(processedexpArgs,  PS_LIST_TAIL, "-sun_angle_max",    0,         "define max solar angle", NAN);
     295    pxspaceAddArguments(processedexpArgs);
     296    pxmagicAddArguments(processedexpArgs);
    287297
    288298    psMetadataAddU64(processedexpArgs,  PS_LIST_TAIL, "-limit",         0,            "limit result set to N items", 0);
    … …  
    301311    psMetadataAddS64(updatedprocessedexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", 0);
    302312    psMetadataAddS16(updatedprocessedexpArgs, PS_LIST_TAIL, "-fault",    0,            "set fault code (required)", INT16_MAX);
    303 
     313    psMetadataAddStr(updatedprocessedexpArgs, PS_LIST_TAIL, "-set_state", 0,           "set state", NULL);
    304314    // -exportrun
    305315    psMetadata *exportrunArgs = psMetadataAlloc();
    … …  
    312322    psMetadataAddStr(importrunArgs, PS_LIST_TAIL, "-infile",  0,          "import from this file (required)", NULL);
    313323
    314 
    315324    // -cleardupexp
    316325    psMetadata *cleardupexpArgs = psMetadataAlloc();
    317326
     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   
    318393    psMetadata *argSets = psMetadataAlloc();
    319394    psMetadata *modes = psMetadataAlloc();
    … …  
    330405    PXOPT_ADD_MODE("-updateprocessedexp",      "", REGTOOL_MODE_UPDATEPROCESSEDEXP,      updatedprocessedexpArgs);
    331406    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);
    332410    PXOPT_ADD_MODE("-exportrun",            "export run for import on other database", REGTOOL_MODE_EXPORTRUN, exportrunArgs);
    333411    PXOPT_ADD_MODE("-importrun",            "import run from metadata file",           REGTOOL_MODE_IMPORTRUN, importrunArgs);

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

    r25851 r27838  
    124124
    125125    // select based on properties of the raw exposures
     126    PXOPT_COPY_STR(config->args,  where, "-select_comment",            "rawExp.comment", "LIKE");
    126127    PXOPT_COPY_STR(config->args,  where, "-select_inst",               "rawExp.camera", "==");
    127128    PXOPT_COPY_STR(config->args,  where, "-select_telescope",          "rawExp.telescope", "==");
    … …  
    145146    PXOPT_COPY_F32(config->args,  where, "-select_fwhm_minor_min",     "camProcessedExp.fwhm_minor", ">=");
    146147    PXOPT_COPY_F32(config->args,  where, "-select_fwhm_minor_max",     "camProcessedExp.fwhm_minor", "<=");
    147     PXOPT_COPY_F32(config->args,  where, "-select_iq_m2_max",     "camProcessedExp.iq_m2", "<=");
    148     PXOPT_COPY_F32(config->args,  where, "-select_iq_m2_min",     "camProcessedExp.iq_m2", ">=");
    149     PXOPT_COPY_F32(config->args,  where, "-select_iq_m3_max",     "camProcessedExp.iq_m3", "<=");
    150     PXOPT_COPY_F32(config->args,  where, "-select_iq_m4_min",     "camProcessedExp.iq_m4", ">=");
    151     PXOPT_COPY_F32(config->args,  where, "-select_iq_m4_max",     "camProcessedExp.iq_m4", "<=");
    152    
     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
    153154    PXOPT_COPY_STR(config->args,  where, "-select_exp_type",           "rawExp.exp_type", "==");
    154155    PXOPT_COPY_F32(config->args,  where, "-select_good_frac_min",      "warpSkyfile.good_frac", ">=");
    155156    PXOPT_COPY_STR(config->args,  where, "-select_skycell_id",         "warpSkyfile.skycell_id", "==");
    156     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
    157159
    158160    // these are used to build the HAVING restriction
    159161    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    }
    160170
    161171    // other options applied outside of the WHERE
    … …  
    168178
    169179    if (!psListLength(where->list)) {
     180        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    170181        psFree(where);
    171         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
    172         return false;
    173     }
    174 
    175     psString select = pxDataGet("stacktool_definebyquery_part1.sql");
     182        psFree(having);
     183        return false;
     184    }
     185
     186    psString select = pxDataGet("stacktool_definebyquery_select.sql");
    176187    if (!select) {
    177         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    178         return false;
    179     }
    180 
     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("");
    181195    if (psListLength(where->list)) {
    182196        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    183         psStringAppend(&select, " AND %s", whereClause);
     197        psStringAppend(&where1, "\nAND %s", whereClause);
    184198        psFree(whereClause);
    185199    }
    186200
    187     psString groupby = pxDataGet("stacktool_definebyquery_part2.sql");
    188     if (!groupby) {
    189         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    190         psFree(where);
    191         return false;
    192     }
    193     psStringAppend(&select, " %s", groupby);
    194     psFree(groupby);
     201    psString where2 = psStringCopy("");
     202    if (label) {
     203        psStringAppend(&where2, "\nWHERE stackRun.label = '%s'", label);
     204    }
    195205
    196206    // Restriction on aggregated quantities using HAVING
    … …  
    224234    psFree(having);
    225235
    226     if (!p_psDBRunQuery(config->dbh, select)) {
     236    if (!p_psDBRunQueryF(config->dbh, select, where1, where2)) {
    227237        psError(PS_ERR_UNKNOWN, false, "database error");
    228238        psFree(select);
    229         psFree(where);
     239        psFree(where1);
     240        psFree(where2);
    230241        return false;
    231242    }
    232243    psFree(select);
     244    psFree(where1);
     245    psFree(where2);
    233246
    234247    psArray *output = p_psDBFetchResult(config->dbh);
    … …  
    272285    }
    273286    if (!insert) {
    274         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     287        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    275288        psFree(where);
    276289        return false;
    … …  
    287300        psString part2 = pxDataGet("stacktool_definebyquery_insert_random_part2.sql");
    288301        if (!part2) {
    289             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     302            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    290303            psFree(insert);
    291304            return false;
    … …  
    593606    if (!psListLength(where->list)) {
    594607        psFree(where);
    595         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     608        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    596609        return false;
    597610    }
    … …  
    600613
    601614    // pxUpdateRun gets parameters from config->args and updates
    602     bool result = pxUpdateRun(config, where, &query, "stackRun", true);
     615    bool result = pxUpdateRun(config, where, &query, "stackRun", "stack_id", "stackSumSkyfile", true);
    603616
    604617    psFree(query);
    … …  
    663676    psString query = pxDataGet("stacktool_inputskyfile.sql");
    664677    if (!query) {
    665         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     678        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    666679        return false;
    667680    }
    … …  
    669682    if (psListLength(where->list)) {
    670683        psString whereClause = psDBGenerateWhereConditionSQL(where, "stackInputSkyfile");
    671         psStringAppend(&query, " AND %s", whereClause);
     684        psStringAppend(&query, " WHERE %s", whereClause);
    672685        psFree(whereClause);
    673686    }
    … …  
    737750    psString query = pxDataGet("stacktool_tosum.sql");
    738751    if (!query) {
    739         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    740         return false;
    741     }
    742 
     752        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     753        return false;
     754    }
     755
     756    psString whereClause = psStringCopy(""); // WHERE conditions to add
    743757    if (psListLength(where->list)) {
    744         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    745         psStringAppend(&query, " AND %s", whereClause);
    746         psFree(whereClause);
     758        psString new = psDBGenerateWhereConditionSQL(where, NULL);
     759        psStringAppend(&whereClause, "\nAND %s", new);
     760        psFree(new);
    747761    }
    748762    psFree(where);
    … …  
    755769    }
    756770
    757     if (!p_psDBRunQuery(config->dbh, query)) {
     771    if (!p_psDBRunQueryF(config->dbh, query, whereClause)) {
    758772        psError(PS_ERR_UNKNOWN, false, "database error");
    759773        psFree(query);
    … …  
    908922    PXOPT_COPY_STR(config->args, where, "-filter", "stackRun.filter", "LIKE");
    909923    PXOPT_COPY_STR(config->args, where, "-label", "stackRun.label", "==");
     924    PXOPT_COPY_STR(config->args, where, "-data_group", "stackRun.data_group", "LIKE");
    910925    PXOPT_COPY_S16(config->args, where, "-fault", "stackSumSkyfile.fault", "==");
    911926
    … …  
    922937    psString query = pxDataGet("stacktool_sumskyfile.sql");
    923938    if (!query) {
    924         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     939        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    925940        return false;
    926941    }
    … …  
    931946        psFree(whereClause);
    932947    } else if (!all) {
    933         psError(PXTOOLS_ERR_DATA, true, "search parameters or -all are required");
     948        psError(PXTOOLS_ERR_CONFIG, true, "search parameters or -all are required");
    934949        return false;
    935950    }
    … …  
    9911006    psMetadata *where = psMetadataAlloc();
    9921007    PXOPT_COPY_S64(config->args, where, "-stack_id", "stackSumSkyfile.stack_id", "==");
    993     PXOPT_COPY_STR(config->args, where, "-label", "stackRun.label", "==");
     1008    pxAddLabelSearchArgs(config, where, "-label", "stackRun.label", "==");
    9941009    PXOPT_COPY_S16(config->args, where, "-fault", "stackSumSkyfile.fault", "==");
    9951010
    9961011    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    9971012        psFree(where);
    998         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     1013        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    9991014        return false;
    10001015    }
    … …  
    10031018    psString delete = pxDataGet("stacktool_revertsumskyfile_delete.sql");
    10041019    if (!delete) {
    1005         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1020        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10061021        return false;
    10071022    }
    … …  
    10841099    psString query = pxDataGet("stacktool_pendingcleanuprun.sql");
    10851100    if (!query) {
    1086         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1101        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10871102        return false;
    10881103    }
    … …  
    11481163    psString query = pxDataGet("stacktool_pendingcleanupskyfile.sql");
    11491164    if (!query) {
    1150         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1165        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11511166        return false;
    11521167    }
    … …  
    12091224    psString query = pxDataGet("stacktool_donecleanup.sql");
    12101225    if (!query) {
    1211         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1226        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    12121227        return false;
    12131228    }
    … …  
    13131328    psString query = pxDataGet(tables[i].sqlFilename);
    13141329    if (!query) {
    1315       psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1330      psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    13161331      return false;
    13171332    }

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

    r25835 r27838  
    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;
    … …  
    5959    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_exp_type", 0, "search for exp_type", "object");
    6060    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);
    6163    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_inst", 0, "search for camera", NULL);
    6264    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_telescope", 0, "search for telescope", NULL);
    … …  
    116118    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_dist_group", 0,   "define new dist_group", NULL);
    117119    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_note", 0,         "define new note", NULL);
    118    
     120
    119121    // -addinputskyfile
    120122    psMetadata *addinputskyfileArgs = psMetadataAlloc();
    … …  
    181183#endif
    182184    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);
    183186    psMetadataAddStr(sumskyfileArgs, PS_LIST_TAIL, "-filter", 0,            "search by filter (LIKE comparison)", NULL);
    184187    psMetadataAddS16(sumskyfileArgs, PS_LIST_TAIL, "-fault",  0,            "search by fault code", 0);
    … …  
    190193    psMetadata *revertsumskyfileArgs= psMetadataAlloc();
    191194    psMetadataAddS64(revertsumskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,            "search by stack ID", 0);
    192     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);
    193196    psMetadataAddS16(revertsumskyfileArgs, PS_LIST_TAIL, "-fault",  0,            "search by fault code", 0);
    194197    psMetadataAddBool(revertsumskyfileArgs, PS_LIST_TAIL, "-all",  0, "allow no search terms", 0);

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

    r25851 r27838  
    5959static bool importrunMode(pxConfig *config);
    6060static bool runstateMode(pxConfig *config);
     61static bool listrunMode(pxConfig *config);
     62static bool setskyfiletoupdateMode(pxConfig *config);
    6163
    6264static bool parseAndInsertSkyCellMap(pxConfig *config, const char *mapfile);
    … …  
    104106        MODECASE(WARPTOOL_MODE_TOCLEANEDSKYFILE,   tocleanedskyfileMode);
    105107        MODECASE(WARPTOOL_MODE_TOPURGEDSKYFILE,    topurgedskyfileMode);
    106         MODECASE(WARPTOOL_MODE_TOSCRUBBEDSKYFILE,  toscrubbedskyfileMode);
     108        MODECASE(WARPTOOL_MODE_TOSCRUBBEDSKYFILE,  toscrubbedskyfileMode);
    107109        MODECASE(WARPTOOL_MODE_TOFULLSKYFILE,      tofullskyfileMode);
    108110        MODECASE(WARPTOOL_MODE_UPDATESKYFILE,      updateskyfileMode);
    … …  
    110112        MODECASE(WARPTOOL_MODE_IMPORTRUN,          importrunMode);
    111113        MODECASE(WARPTOOL_MODE_RUNSTATE,           runstateMode);
     114        MODECASE(WARPTOOL_MODE_LISTRUN,            listrunMode);
     115        MODECASE(WARPTOOL_MODE_SETSKYFILETOUPDATE, setskyfiletoupdateMode);
    112116
    113117        default:
    … …  
    247251    PXOPT_COPY_F32(config->args,   where, "-sun_angle_max",      "rawExp.sun_angle",      "<");
    248252    PXOPT_COPY_STR(config->args,   where, "-reduction",          "fakeRun.reduction",     "==");
    249     pxAddLabelSearchArgs (config,  where, "-label",             "fakeRun.label",         "==");
     253    pxAddLabelSearchArgs (config,  where, "-label",              "fakeRun.label",         "=="); // define using fake label
    250254
    251255    if (!psListLength(where->list) &&
    252256        !psMetadataLookupBool(NULL, config->args, "-all")) {
    253257        psFree(where);
    254         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     258        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    255259        return false;
    256260    }
    … …  
    279283    psString query = pxDataGet("warptool_definebyquery.sql");
    280284    if (!query) {
    281         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     285        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    282286        psFree(where);
    283287        return false;
    … …  
    383387    PXOPT_COPY_S64(config->args, where, "-warp_id",   "warpRun.warp_id",   "==");
    384388    PXOPT_COPY_STR(config->args, where, "-reduction", "warpRun.reduction", "==");
    385     PXOPT_COPY_STR(config->args, where, "-label",     "warpRun.label",     "==");
    386389    PXOPT_COPY_STR(config->args, where, "-state",     "warpRun.state",     "==");
    387     PXOPT_COPY_STR(config->args, where, "-data_group","warpRun.data_group",     "==");
    388     PXOPT_COPY_STR(config->args, where, "-dist_group","warpRun.dist_group",     "==");
     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    }
    389401
    390402    if (!psListLength(where->list)) {
    391403        psFree(where);
    392         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
    393         return false;
    394     }
    395    
    396     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)");
     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)");
    397409
    398410    // pxUpdateRun gets parameters from config->args and updates
    399     bool result = pxUpdateRun(config, where, &query, "warpRun", true);
     411    bool result = pxUpdateRun(config, where, &query, "warpRun", "warp_id", "warpSkyfile", true);
    400412
    401413    psFree(query);
    … …  
    419431    psString query = pxDataGet("warptool_exp.sql");
    420432    if (!query) {
    421         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     433        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    422434        return false;
    423435    }
    … …  
    493505    psString query = pxDataGet("warptool_imfile.sql");
    494506    if (!query) {
    495         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     507        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    496508        return false;
    497509    }
    … …  
    567579    psString query = pxDataGet("warptool_tooverlap.sql");
    568580    if (!query) {
    569         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     581        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    570582        return false;
    571583    }
    … …  
    676688    PXOPT_COPY_STR(config->args, where, "-skycell_id", "warpSkyCellMap.skycell_id", "==");
    677689    PXOPT_COPY_STR(config->args, where, "-tess_id",    "warpSkyCellMap.tess_id", "==");
    678     // PXOPT_COPY_STR(config->args, where, "-label",      "warpRun.label", "==");
    679690    pxAddLabelSearchArgs (config, where, "-label",     "warpRun.label", "==");
    680691    PXOPT_COPY_S16(config->args, where, "-fault",      "warpSkyCellMap.fault", "==");
    … …  
    683694        && !psMetadataLookupBool(NULL, config->args, "-all")) {
    684695        psFree(where);
    685         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     696        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    686697        return false;
    687698    }
    … …  
    691702        psString query = pxDataGet("warptool_revertoverlap.sql");
    692703        if (!query) {
    693             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     704            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    694705            if (!psDBRollback(config->dbh)) {
    695706                psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    823834    psString query = pxDataGet("warptool_scmap.sql");
    824835    if (!query) {
    825         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     836        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    826837        return false;
    827838    }
    … …  
    896907    psString query = pxDataGet("warptool_towarped.sql");
    897908    if (!query) {
    898         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    899         return false;
    900     }
    901 
     909        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     910        return false;
     911    }
     912
     913    psString whereStr = psStringCopy("");
    902914    if (psListLength(where->list)) {
    903915        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    904         psStringAppend(&query, " AND %s", whereClause);
     916        psStringAppend(&whereStr, "\n AND %s", whereClause);
    905917        psFree(whereClause);
    906918    }
    … …  
    908920
    909921    // treat limit == 0 as "no limit"
     922    psString limitString = psStringCopy("\n");
    910923    if (limit) {
    911         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));
    912928        psStringAppend(&query, " %s", limitString);
    913         psFree(limitString);
    914     }
    915 
    916     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)) {
    917934        psError(PS_ERR_UNKNOWN, false, "database error");
    918935        psFree(query);
    919936        return false;
    920937    }
     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);
    921947    psFree(query);
    922948
    … …  
    9771003    PXOPT_LOOKUP_STR(hostname, config->args, "-hostname", false, false);
    9781004    PXOPT_LOOKUP_F32(good_frac, config->args, "-good_frac", false, false);
    979     PXOPT_LOOKUP_S64(magicked, config->args, "-magicked", false, false);
     1005    PXOPT_LOOKUP_S64(magicked, config->args, "-set_magicked", false, false);
    9801006
    9811007    // default values
    … …  
    10401066    psString query = pxDataGet("warptool_finished_run_select.sql");
    10411067    if (!query) {
    1042         psError(PXTOOLS_ERR_DATA, false, "failed to retrieve SQL statement");
     1068        psError(PXTOOLS_ERR_SYS, false, "failed to retrieve SQL statement");
    10431069        return false;
    10441070    }
    … …  
    11161142    psString query = pxDataGet("warptool_finished_run_select.sql");
    11171143    if (!query) {
    1118         psError(PXTOOLS_ERR_DATA, false, "failed to retrieve SQL statement");
     1144        psError(PXTOOLS_ERR_SYS, false, "failed to retrieve SQL statement");
    11191145        return false;
    11201146    }
    … …  
    11941220    PXOPT_COPY_TIME(config->args, where, "-dateobs_begin", "rawExp.dateobs",  ">=");
    11951221    PXOPT_COPY_TIME(config->args, where, "-dateobs_end",   "rawExp.dateobs",  "<=");
    1196     PXOPT_COPY_STR(config->args, where, "-filter",    "rawExp.filter", "==");
     1222    PXOPT_COPY_STR(config->args, where, "-filter",    "rawExp.filter", "LIKE");
    11971223    PXOPT_COPY_S64(config->args, where, "-magicked", "warpSkyfile.magicked", "==");
    11981224    pxAddLabelSearchArgs (config, where, "-label",   "warpRun.label", "LIKE");
     1225    pxAddLabelSearchArgs (config, where, "-data_group",   "warpRun.data_group", "LIKE");
    11991226
    12001227    PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
    … …  
    12061233    psString query = pxDataGet("warptool_warped.sql");
    12071234    if (!query) {
    1208         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1235        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    12091236        return false;
    12101237    }
    … …  
    12141241    psString where2 = NULL;
    12151242    if (!pxmagicAddWhere(config, &where2, "warpSkyfile")) {
    1216         psError(PXTOOLS_ERR_DATA, false, "pxMagicAddWhere failed");
     1243        psError(psErrorCodeLast(), false, "pxMagicAddWhere failed");
    12171244        return false;
    12181245    }
    12191246    if (!pxspaceAddWhere(config, &where2, "rawExp")) {
    1220         psError(PXTOOLS_ERR_DATA, false, "pxSpaceAddWhere failed");
     1247        psError(psErrorCodeLast(), false, "pxSpaceAddWhere failed");
    12211248        return false;
    12221249    }
    … …  
    12241251    if (psListLength(where->list)) {
    12251252        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    1226         psStringAppend(&query, " AND %s", whereClause);
     1253        psStringAppend(&query, " WHERE %s", whereClause);
    12271254        psFree(whereClause);
    12281255    } else if (!all && !where2) {
    1229         psError(PXTOOLS_ERR_DATA, true, "search parameters or -all are required");
    1230         return false;
     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        }
    12311266    }
    12321267    psFree(where);
    1233 
    1234     if (where2) {
    1235         psStringAppend(&query, " %s", where2);
    1236     }
    12371268
    12381269    // treat limit == 0 as "no limit"
    … …  
    12941325    PXOPT_COPY_STR(config->args, where, "-tess_id",    "warpSkyfile.tess_id", "==");
    12951326    PXOPT_COPY_STR(config->args, where, "-reduction",  "rawExp.reduction", "==");
    1296     // PXOPT_COPY_STR(config->args, where, "-label",      "warpRun.label", "==");
    12971327    pxAddLabelSearchArgs (config, where, "-label",     "warpRun.label", "==");
    1298     PXOPT_COPY_S16(config->args, where, "-fault",       "warpSkyfile.fault", "==");
     1328    PXOPT_COPY_S16(config->args, where, "-fault",      "warpSkyfile.fault", "==");
    12991329
    13001330    if (!psListLength(where->list)
    13011331        && !psMetadataLookupBool(NULL, config->args, "-all")) {
    13021332        psFree(where);
    1303         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
    1304         return false;
    1305     }
    1306 
    1307     if (!psDBTransaction(config->dbh)) {
    1308         psError(PS_ERR_UNKNOWN, false, "database error");
    1309         psFree(where);
    1310         return false;
    1311     }
    1312 
    1313     // Delete product
    1314     int numDeleted;                     // Number deleted
    1315     {
    1316         psString query = pxDataGet("warptool_revertwarped_delete.sql");
    1317         if (!query) {
    1318             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1319             if (!psDBRollback(config->dbh)) {
    1320                 psError(PS_ERR_UNKNOWN, false, "database error");
    1321             }
    1322             return false;
    1323         }
    1324 
    1325         if (psListLength(where->list)) {
    1326             psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    1327             psStringAppend(&query, " AND %s", whereClause);
    1328             psFree(whereClause);
    1329         }
    1330 
    1331         if (!p_psDBRunQuery(config->dbh, query)) {
    1332             psError(PS_ERR_UNKNOWN, false, "database error");
    1333             psFree(query);
    1334             if (!psDBRollback(config->dbh)) {
    1335                 psError(PS_ERR_UNKNOWN, false, "database error");
    1336             }
    1337             return false;
    1338         }
     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");
    13391358        psFree(query);
    1340 
    1341         numDeleted = psDBAffectedRows(config->dbh);
    1342     }
     1359        return false;
     1360    }
     1361    psFree(query);
     1362
     1363    int numDeleted = psDBAffectedRows(config->dbh);
    13431364
    13441365    psLogMsg("warptool", PS_LOG_INFO, "Deleted %d warpSkyfiles", numDeleted);
    13451366
    1346     psFree(where);
    1347 
    1348     if (!psDBCommit(config->dbh)) {
    1349         psError(PS_ERR_UNKNOWN, false, "database error");
    1350         return false;
    1351     }
     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);
    13521379
    13531380    return true;
    … …  
    14361463    psString query = pxDataGet("warptool_pendingcleanuprun.sql");
    14371464    if (!query) {
    1438         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1465        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    14391466        return false;
    14401467    }
    … …  
    14991526    psString query = pxDataGet("warptool_pendingcleanupskyfile.sql");
    15001527    if (!query) {
    1501         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1528        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    15021529        return false;
    15031530    }
    … …  
    15601587    psString query = pxDataGet("warptool_donecleanup.sql");
    15611588    if (!query) {
    1562         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1589        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    15631590        return false;
    15641591    }
    … …  
    16481675    }
    16491676
    1650     // note only updates if warpRun.state = run_state
    1651     // XXX note that we have removed this constraint for now
    1652     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)) {
    16531693        psError(PS_ERR_UNKNOWN, false, "database error");
    16541694        // rollback
    … …  
    16601700    }
    16611701    psFree(query);
     1702    psFree(set_magicked_skyfile);
    16621703
    16631704    query = pxDataGet("warptool_change_run_state.sql");
    1664     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)) {
    16651706        // rollback
    16661707        if (!psDBRollback(config->dbh)) {
    … …  
    16701711        return false;
    16711712    }
     1713    psFree(set_magicked_run);
    16721714
    16731715    if (!psDBCommit(config->dbh)) {
    … …  
    17071749    if (!state) {
    17081750      psString query = pxDataGet("warptool_updateskyfile.sql");
    1709      
     1751
    17101752      if (!p_psDBRunQueryF(config->dbh, query, fault, warp_id, skycell_id)) {
    17111753        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    17161758    else {
    17171759      if (strcmp(state,"error_cleaned") == 0) {
    1718         change_skyfile_data_state(config,"error_cleaned","goto_cleaned");
     1760        change_skyfile_data_state(config,"error_cleaned","goto_cleaned");
    17191761      }
    17201762      else if (strcmp(state, "error_scrubbed") == 0) {
    1721         change_skyfile_data_state(config,"error_scrubbed","goto_scrubbed");
     1763        change_skyfile_data_state(config,"error_scrubbed","goto_scrubbed");
    17221764      }
    17231765      else if (strcmp(state, "error_purged") == 0) {
    1724         change_skyfile_data_state(config,"error_purged","goto_purged");
     1766        change_skyfile_data_state(config,"error_purged","goto_purged");
    17251767      }
    17261768      else {
    1727         psError(PS_ERR_UNKNOWN, false, "unhandled state given");
    1728         return(false);
     1769        psError(PS_ERR_UNKNOWN, false, "unhandled state given");
     1770        return(false);
    17291771      }
    17301772    }
    … …  
    17721814      psString query = pxDataGet(tables[i].sqlFilename);
    17731815      if (!query) {
    1774           psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1816          psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    17751817          return false;
    17761818      }
    … …  
    19391981    psString query = pxDataGet("warptool_runstate.sql");
    19401982    if (!query) {
    1941         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1983        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    19421984        return false;
    19431985    }
    … …  
    19481990        psFree(whereClause);
    19491991    } else {
    1950         psError(PXTOOLS_ERR_DATA, true, "search parameters or -all are required");
     1992        psError(PXTOOLS_ERR_CONFIG, true, "search parameters or -all are required");
    19511993        return false;
    19521994    }
    … …  
    20002042    return true;
    20012043}
     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/tap_branches/ippTools/src/warptool.h

    r25822 r27838  
    5555    WARPTOOL_MODE_IMPORTRUN,
    5656    WARPTOOL_MODE_RUNSTATE,
     57    WARPTOOL_MODE_LISTRUN,
     58    WARPTOOL_MODE_SETSKYFILETOUPDATE,
    5759} warptoolMode;
    5860

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

    r25835 r27838  
    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;
    … …  
    133133    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-reduction", 0,  "search by warpRun reduction class", NULL);
    134134    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,      "search by warpRun state", NULL);
    135     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label", 0,      "search by warpRun label", NULL);
     135    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by warpRun label", NULL);
    136136    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-data_group", 0, "search by warpRun data_group", NULL);
    137137    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);
    138142
    139143    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state", 0,        "define new state", NULL);
    … …  
    142146    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_dist_group", 0,   "define new dist_group", NULL);
    143147    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_note", 0,         "define new note", NULL);
     148
    144149    // -exp
    145150    psMetadata *expArgs = psMetadataAlloc();
    … …  
    212217    psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-hostname", 0,            "define hostname", 0);
    213218    psMetadataAddF32(addwarpedArgs, PS_LIST_TAIL, "-good_frac",  0,            "define %% of good pixels", NAN);
    214     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);
    215220    psMetadataAddS16(addwarpedArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code", 0);
    216221    psMetadataAddS16(addwarpedArgs, PS_LIST_TAIL, "-quality",  0,            "set quality", 0);
    … …  
    230235    psMetadataAddS16(warpedArgs, PS_LIST_TAIL,  "-fault",  0,           "search by fault code", 0);
    231236    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);
    232239    // add magic related arguments
    233240    pxmagicAddArguments(warpedArgs);
    … …  
    238245    psMetadataAddU64(warpedArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    239246    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);
    240273
    241274    // -revertwarped
    … …  
    309342    psMetadataAddS64(tofullskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,    "warptool ID to update", 0);
    310343    psMetadataAddStr(tofullskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0, "skycell ID to update", NULL);
    311 
    312     // -toupdateskyfile
     344    psMetadataAddS64(tofullskyfileArgs, PS_LIST_TAIL, "-set_magicked",  0, "new value for magicked", 0);
     345
     346    // -updateskyfile
    313347    psMetadata *updateskyfileArgs = psMetadataAlloc();
    314348    psMetadataAddS64(updateskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,    "warptool ID to update", 0);
    … …  
    316350    psMetadataAddS16(updateskyfileArgs, PS_LIST_TAIL, "-fault",  0,      "new fault code", 0);
    317351    psMetadataAddStr(updateskyfileArgs, PS_LIST_TAIL, "-set_state", 0,   "set state", 0);
    318    
     352
    319353    // -exportrun
    320354    psMetadata *exportrunArgs = psMetadataAlloc();
    … …  
    339373    psMetadataAddU64(runstateArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    340374    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);
    341381
    342382
    … …  
    358398    PXOPT_ADD_MODE("-advancerun",      "", WARPTOOL_MODE_ADVANCERUN,     advancerunArgs);
    359399    PXOPT_ADD_MODE("-warped",          "", WARPTOOL_MODE_WARPED,         warpedArgs);
     400    PXOPT_ADD_MODE("-listrun",         "", WARPTOOL_MODE_LISTRUN,        listrunArgs);
    360401    PXOPT_ADD_MODE("-runstate",        "", WARPTOOL_MODE_RUNSTATE,       runstateArgs);
    361402    PXOPT_ADD_MODE("-revertwarped",    "", WARPTOOL_MODE_REVERTWARPED,   revertwarpedArgs);
    … …  
    371412    PXOPT_ADD_MODE("-tofullskyfile", "set skyfile as full (updated)", WARPTOOL_MODE_TOFULLSKYFILE, tofullskyfileArgs);
    372413    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);
    373415    PXOPT_ADD_MODE("-exportrun",            "export run for import on other database", WARPTOOL_MODE_EXPORTRUN, exportrunArgs);
    374416    PXOPT_ADD_MODE("-importrun",            "import run from metadata file",           WARPTOOL_MODE_IMPORTRUN, importrunArgs);
Note: See TracChangeset for help on using the changeset viewer.