IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Jun 25, 2009, 2:00:56 PM (17 years ago)
Author:
eugene
Message:

merging changes from head

Location:
branches/eam_branches/20090522
Files:
19 edited
3 copied

Legend:

Unmodified
Added
Removed

  • branches/eam_branches/20090522

  • branches/eam_branches/20090522/ippTools/src

    • Property svn:ignore

      •  

        old new  
        3434disttool
        3535receivetool
         36
         37pubtool

  • branches/eam_branches/20090522/ippTools/src/Makefile.am

    r24038 r24557  
    2020        stacktool \
    2121        warptool \
    22         receivetool
     22        receivetool \
     23        pubtool
    2324
    2425
    … …  
    5960        regtool.h \
    6061        stacktool.h \
    61         warptool.h
     62        warptool.h \
     63        pubtool.h
    6264
    6365lib_LTLIBRARIES = libpxtools.la
    … …  
    220222    receivetoolConfig.c
    221223
     224pubtool_CFLAGS = $(PSLIB_CFLAGS) $(PSMODULES_CFLAGS) $(IPPDB_CFLAGS)
     225pubtool_LDADD = $(PSLIB_LIBS) $(PSMODULES_LIBS) $(IPPDB_LIBS) libpxtools.la
     226pubtool_SOURCES = \
     227    pubtool.c \
     228    pubtoolConfig.c
     229
    222230clean-local:
    223231        -rm -f TAGS

  • branches/eam_branches/20090522/ippTools/src/chiptool.c

    r23919 r24557  
    473473    PXOPT_LOOKUP_F32(n_cr, config->args,           "-n_cr", false, false);
    474474    PXOPT_LOOKUP_STR(path_base, config->args,      "-path_base", false, false);
    475     PXOPT_LOOKUP_BOOL(magicked, config->args,      "-magicked", false);
     475    PXOPT_LOOKUP_S64(magicked, config->args,       "-magicked", false, false);
    476476
    477477    // default values
    … …  
    601601    PXOPT_COPY_STR(config->args, where, "-reduction", "chipRun.reduction", "==");
    602602    pxAddLabelSearchArgs (config, where, "-label", "chipRun.label", "LIKE");
    603     PXOPT_COPY_S32(config->args, where, "-magicked", "chipRun.magicked", "==");
     603    PXOPT_COPY_S64(config->args, where, "-magicked", "chipRun.magicked", "==");
    604604
    605605    if (!psListLength(where->list) &&

  • branches/eam_branches/20090522/ippTools/src/difftool.c

    r24225 r24557  
    4949static bool importrunMode(pxConfig *config);
    5050
    51 static bool setdiffRunState(pxConfig *config, psS64 diff_id, const char *state, bool magicked);
     51static bool setdiffRunState(pxConfig *config, psS64 diff_id, const char *state, psS64 magicked);
    5252static bool diffRunComplete(pxConfig *config);
    5353
    … …  
    512512    PXOPT_LOOKUP_STR(hostname, config->args, "-hostname", false, false);
    513513    PXOPT_LOOKUP_F32(good_frac, config->args, "-good_frac", false, false);
    514     PXOPT_LOOKUP_BOOL(magicked, config->args, "-magicked", false);
     514    PXOPT_LOOKUP_S64(magicked, config->args, "-magicked", false, false);
    515515
    516516    if (!psDBTransaction(config->dbh)) {
    … …  
    739739
    740740
    741 static bool setdiffRunState(pxConfig *config, psS64 diff_id, const char *state, bool magicked)
     741static bool setdiffRunState(pxConfig *config, psS64 diff_id, const char *state, psS64 magicked)
    742742{
    743743    PS_ASSERT_PTR_NON_NULL(state, false);
    … …  
    749749    }
    750750
    751     char *query = "UPDATE diffRun SET state = '%s', magicked = %d WHERE diff_id = %"PRId64;
     751    char *query = "UPDATE diffRun SET state = '%s', magicked = %" PRId64 " WHERE diff_id = %"PRId64;
    752752
    753753    if (!p_psDBRunQueryF(config->dbh, query, state, magicked, diff_id)) {
    … …  
    803803            false,
    804804            false,
    805             false       // magicked
     805            0       // magicked
    806806    );
    807807
    … …  
    11901190                false,                  // bothways
    11911191                true,                   // exposure
    1192                 false       // magicked
     1192                0       // magicked
    11931193        );
    11941194
    … …  
    18051805
    18061806        psS64 diff_id = psMetadataLookupS64(NULL, row, "diff_id");
    1807         bool magicked = psMetadataLookupBool(NULL, row, "magicked");
     1807        psS64 magicked = psMetadataLookupS64(NULL, row, "magicked");
    18081808
    18091809        // set diffRun.state to 'stop'

  • branches/eam_branches/20090522/ippTools/src/disttool.c

    r24125 r24557  
    488488    PXOPT_COPY_STR(config->args, where, "-state", "state", "==");
    489489    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
    490     PXOPT_COPY_S16(config->args, where, "-fault", "fault", "==");
     490
     491    // we need to disambiguate fault so make a copy of the where list before adding fault
     492    psMetadata *whereComponent = psMetadataCopy(NULL, where);
     493    PXOPT_COPY_S16(config->args, where,  "-fault", "distRun.fault", "==");
     494    PXOPT_COPY_S16(config->args, whereComponent, "-fault", "distComponent.fault", "==");
    491495
    492496    // It might be useful to be able to query by the parameters of the underlying runs
    … …  
    533537
    534538        numUpdated = psDBAffectedRows(config->dbh);
    535 
    536 #ifdef notdef
    537         // don't need this. distRun.state may still be in 'new' state
    538         if (numUpdated < 1) {
    539             psError(PS_ERR_UNKNOWN, false, "should have affected at least 1 row");
    540             if (!psDBRollback(config->dbh)) {
    541                 psError(PS_ERR_UNKNOWN, false, "database error");
    542             }
    543             return false;
    544         }
    545 #endif
    546539    }
    547540
    … …  
    560553        }
    561554
    562         if (psListLength(where->list)) {
    563             psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     555        if (psListLength(whereComponent->list)) {
     556            psString whereClause = psDBGenerateWhereConditionSQL(whereComponent, NULL);
    564557            psStringAppend(&query, " AND %s", whereClause);
    565558            psFree(whereClause);
    … …  
    582575
    583576    psFree(where);
     577    psFree(whereComponent);
    584578
    585579    if (!psDBCommit(config->dbh)) {
    … …  
    598592    PXOPT_COPY_S64(config->args, where, "-dist_id", "dist_id", "==");
    599593    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
    600     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     594    pxAddLabelSearchArgs (config, where, "-label", "label", "==");
    601595
    602596    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    719713    psMetadata *where = psMetadataAlloc();
    720714    PXOPT_COPY_S64(config->args, where, "-dist_id", "dist_id", "==");
    721     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     715    pxAddLabelSearchArgs (config, where, "-label", "label", "==");
    722716
    723717    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    863857    psMetadata *where = psMetadataAlloc();
    864858    PXOPT_COPY_S64(config->args, where, "-dist_id", "dist_id", "==");
    865     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     859    pxAddLabelSearchArgs (config, where, "-label", "label", "==");
    866860
    867861    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);

  • branches/eam_branches/20090522/ippTools/src/disttoolConfig.c

    r24001 r24557  
    9898    psMetadataAddS64(pendingcomponentArgs, PS_LIST_TAIL, "-dist_id", 0, "define dist_id", 0);
    9999    psMetadataAddStr(pendingcomponentArgs, PS_LIST_TAIL, "-stage",    0, "limit results to runs for stage", NULL);
    100     psMetadataAddStr(pendingcomponentArgs, PS_LIST_TAIL, "-label",    0, "limit results to label", NULL);
     100    psMetadataAddStr(pendingcomponentArgs, PS_LIST_TAIL, "-label",    PS_META_DUPLICATE_OK, "limit results to label", NULL);
    101101    psMetadataAddU64(pendingcomponentArgs, PS_LIST_TAIL, "-limit",  0,  "limit result set to N items", 0);
    102102    psMetadataAddBool(pendingcomponentArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    … …  
    121121    psMetadata *toadvanceArgs = psMetadataAlloc();
    122122    psMetadataAddS64(toadvanceArgs, PS_LIST_TAIL, "-dist_id", 0, "define dist_id", 0);
    123     psMetadataAddStr(toadvanceArgs, PS_LIST_TAIL, "-label",   0, "limit updates to label", NULL);
     123    psMetadataAddStr(toadvanceArgs, PS_LIST_TAIL, "-label",   PS_META_DUPLICATE_OK, "limit updates to label", NULL);
    124124    psMetadataAddU64(toadvanceArgs, PS_LIST_TAIL, "-limit",   0,  "limit result set to N items", 0);
    125125    psMetadataAddBool(toadvanceArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    … …  
    128128    psMetadata *pendingfilesetArgs = psMetadataAlloc();
    129129    psMetadataAddS64(pendingfilesetArgs, PS_LIST_TAIL, "-dist_id", 0, "define dist_id", 0);
    130     psMetadataAddStr(pendingfilesetArgs, PS_LIST_TAIL, "-label",   0, "limit results to label", NULL);
     130    psMetadataAddStr(pendingfilesetArgs, PS_LIST_TAIL, "-label",   PS_META_DUPLICATE_OK, "limit results to label", NULL);
    131131    psMetadataAddStr(pendingfilesetArgs, PS_LIST_TAIL, "-stage",   0, "limit results to runs for stage", NULL);
    132132    psMetadataAddU64(pendingfilesetArgs, PS_LIST_TAIL, "-limit",   0,  "limit result set to N items", 0);
    … …  
    145145    psMetadataAddU64(pendingdestArgs, PS_LIST_TAIL, "-limit",   0,  "limit result set to N items", 0);
    146146    psMetadataAddBool(pendingdestArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    147     psMetadataAddStr(pendingdestArgs, PS_LIST_TAIL, "-label",   0, "limit results to label", NULL);
     147    psMetadataAddStr(pendingdestArgs, PS_LIST_TAIL, "-label",   PS_META_DUPLICATE_OK, "limit results to label", NULL);
    148148
    149149    // -revertfileset

  • branches/eam_branches/20090522/ippTools/src/faketool.c

    r24186 r24557  
    235235        bool status;
    236236        char *end_stage = psMetadataLookupStr(&status, md, "end_stage");
    237         if (end_stage && strcasecmp(end_stage, "warp")) continue;
     237        if (end_stage && strcasecmp(end_stage, "warp")) continue;
    238238
    239239        char *raw_tess_id   = psMetadataLookupStr(&status, md, "tess_id");
    240         if (raw_tess_id || tess_id) continue;
     240        if (raw_tess_id || tess_id) continue;
    241241
    242242        char *label  = psMetadataLookupStr(&status, md, "label");
    … …  
    244244
    245245        if (!status) {
    246             psError(PS_ERR_UNKNOWN, false, "cannot queue analysis to WARP without a defined tess id: label: %s, exp_id %" PRId64, label, exp_id);
     246            psError(PS_ERR_UNKNOWN, false, "cannot queue analysis to WARP without a defined tess id: label: %s, exp_id %" PRId64, label, exp_id);
    247247            psFree(output);
    248248            return false;
    … …  
    455455
    456456    if (where && psListLength(where->list)) {
    457         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    458         psStringAppend(&query, " WHERE %s", whereClause);
     457        psString whereClause = psDBGenerateWhereConditionSQL(where, "fakeRun");
     458        psStringAppend(&query, " AND %s", whereClause);
    459459        psFree(whereClause);
    460460    }
    … …  
    11571157        // pxwarpQueueByFakeID() can only be run after fakeRun.state has been set to stop
    11581158        if (!pxwarpQueueByFakeID(config,
    1159                     fakeRun->fake_id,
    1160                     fakeRun->workdir,
    1161                     fakeRun->label,
    1162                     fakeRun->dvodb,
    1163                     fakeRun->tess_id,
    1164                     fakeRun->end_stage
     1159                                 fakeRun->fake_id,
     1160                                 fakeRun->workdir,
     1161                                 fakeRun->label,
     1162                                 fakeRun->dvodb,
     1163                                 fakeRun->tess_id,
     1164                                 fakeRun->reduction,
     1165                                 fakeRun->end_stage
    11651166        )) {
    11661167            psError(PS_ERR_UNKNOWN, false, "failed to queue warpRun");

  • branches/eam_branches/20090522/ippTools/src/magicdstool.c

    r23974 r24557  
    3838static bool revertdestreakedfileMode(pxConfig *config);
    3939static bool getskycellsMode(pxConfig *config);
     40static bool toremoveMode(pxConfig *config);
     41static bool torestoreMode(pxConfig *config);
    4042
    4143static bool setmagicDSRunState(pxConfig *config, psS64 magic_id, const char *state);
    … …  
    6870        MODECASE(MAGICDSTOOL_MODE_REVERTDESTREAKEDFILE,revertdestreakedfileMode);
    6971        MODECASE(MAGICDSTOOL_MODE_GETSKYCELLS,         getskycellsMode);
     72        MODECASE(MAGICDSTOOL_MODE_TOREMOVE,            toremoveMode);
     73        MODECASE(MAGICDSTOOL_MODE_TORESTORE,           torestoreMode);
    7074        default:
    7175            psAbort("invalid option (this should not happen)");
    … …  
    501505    // chose the appropriate query based on the stage
    502506    if (!strcmp(stage, "raw")) {
    503         query = "UPDATE rawImfile SET magicked = 1 where exp_id = %" PRId64 " AND class_id = '%s'";
     507        query = "UPDATE rawImfile SET magicked = %" PRId64 " where exp_id = %" PRId64 " AND class_id = '%s'";
    504508    } else if (!strcmp(stage, "chip")) {
    505         query = "UPDATE chipProcessedImfile SET magicked = 1 where chip_id = %" PRId64 " AND class_id = '%s'";
     509        query = "UPDATE chipProcessedImfile SET magicked = %" PRId64 " where chip_id = %" PRId64 " AND class_id = '%s'";
    506510    } else if (!strcmp(stage, "warp")) {
    507         query = "UPDATE warpSkyfile SET magicked = 1 where warp_id = %" PRId64 " AND skycell_id = '%s'";
     511        query = "UPDATE warpSkyfile SET magicked = %" PRId64 " where warp_id = %" PRId64 " AND skycell_id = '%s'";
    508512    } else if (!strcmp(stage, "diff")) {
    509         query = "UPDATE diffSkyfile SET magicked = 1 where diff_id = %" PRId64 " AND skycell_id = '%s'";
     513        query = "UPDATE diffSkyfile SET magicked = %" PRId64 " where diff_id = %" PRId64 " AND skycell_id = '%s'";
    510514    } else {
    511515        psError(PS_ERR_UNKNOWN, true, "unexpected value for stage: %s found", stage);
    … …  
    513517        return false;
    514518    }
    515     if (!p_psDBRunQueryF(config->dbh, query, stage_id, component)) {
     519    if (!p_psDBRunQueryF(config->dbh, query, magic_ds_id, stage_id, component)) {
    516520        psError(PS_ERR_UNKNOWN, false, "database error");
    517521        return false;
    … …  
    563567    // chose the appropriate query based on the stage
    564568    if (!strcmp(stage, "raw")) {
    565         query = "UPDATE rawExp SET magicked = 1 where exp_id = %" PRId64;
     569        query = "UPDATE rawExp SET magicked = %" PRId64 " where exp_id = %" PRId64;
    566570    } else if (!strcmp(stage, "chip")) {
    567         query = "UPDATE chipRun SET magicked = 1 where chip_id = %" PRId64;
     571        query = "UPDATE chipRun SET magicked = %" PRId64 " where chip_id = %" PRId64;
    568572    } else if (!strcmp(stage, "warp")) {
    569         query = "UPDATE warpRun SET magicked = 1 where warp_id = %" PRId64;
     573        query = "UPDATE warpRun SET magicked = %" PRId64 " where warp_id = %" PRId64;
    570574    } else if (!strcmp(stage, "diff")) {
    571         query = "UPDATE diffRun SET magicked = 1 where diff_id = %" PRId64;
     575        query = "UPDATE diffRun SET magicked = %" PRId64 " where diff_id = %" PRId64;
    572576    } else {
    573577        psError(PS_ERR_UNKNOWN, true, "unexpected value for stage: %s found", stage);
    … …  
    575579        return false;
    576580    }
    577     if (!p_psDBRunQueryF(config->dbh, query, stage_id)) {
     581    if (!p_psDBRunQueryF(config->dbh, query, magic_ds_id, stage_id)) {
    578582        psError(PS_ERR_UNKNOWN, false, "database error");
    579583        return false;
    … …  
    625629    }
    626630
    627     if (!magicDSFileInsert(config->dbh, magic_ds_id, component, backup_path_base, recovery_path_base, fault)) {
     631    if (!magicDSFileInsert(config->dbh, magic_ds_id, component, backup_path_base, recovery_path_base, fault, "full")) {
    628632            // rollback
    629633        if (!psDBRollback(config->dbh)) {
    … …  
    889893}
    890894
     895static bool toremoveMode(pxConfig *config)
     896{
     897    PS_ASSERT_PTR_NON_NULL(config, false);
     898
     899    psMetadata *where = psMetadataAlloc();
     900    PXOPT_COPY_S64(config->args, where, "-magic_ds_id", "magic_ds_id", "==");
     901    PXOPT_COPY_S64(config->args, where, "-magic_id", "magic_id", "==");
     902    pxAddLabelSearchArgs (config, where, "-label", "label", "==");
     903
     904    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     905    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     906
     907    // look for "inputs" that need to processed
     908    psString query = pxDataGet("magicdstool_toremove.sql");
     909    if (!query) {
     910        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     911        return false;
     912    }
     913
     914    if (psListLength(where->list)) {
     915        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     916        psStringAppend(&query, " WHERE %s", whereClause);
     917        psFree(whereClause);
     918    }
     919    psFree(where);
     920
     921    // treat limit == 0 as "no limit"
     922    if (limit) {
     923        psString limitString = psDBGenerateLimitSQL(limit);
     924        psStringAppend(&query, " %s", limitString);
     925        psFree(limitString);
     926    }
     927
     928    if (!p_psDBRunQuery(config->dbh, query)) {
     929        psError(PS_ERR_UNKNOWN, false, "database error");
     930        psFree(query);
     931        return false;
     932    }
     933    psFree(query);
     934
     935    psArray *output = p_psDBFetchResult(config->dbh);
     936    if (!output) {
     937        psErrorCode err = psErrorCodeLast();
     938        switch (err) {
     939            case PS_ERR_DB_CLIENT:
     940                psError(PXTOOLS_ERR_SYS, false, "database error");
     941            case PS_ERR_DB_SERVER:
     942                psError(PXTOOLS_ERR_PROG, false, "database error");
     943            default:
     944                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     945        }
     946
     947        return false;
     948    }
     949    if (!psArrayLength(output)) {
     950        psTrace("magicdstool", PS_LOG_INFO, "no rows found");
     951        psFree(output);
     952        return true;
     953    }
     954
     955    if (psArrayLength(output)) {
     956        // negative simple so the default is true
     957        if (!ippdbPrintMetadatas(stdout, output, "toremove", !simple)) {
     958            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     959            psFree(output);
     960            return false;
     961        }
     962    }
     963
     964    psFree(output);
     965
     966    return true;
     967}
     968static bool torestoreMode(pxConfig *config)
     969{
     970    PS_ASSERT_PTR_NON_NULL(config, false);
     971
     972    psMetadata *where = psMetadataAlloc();
     973    PXOPT_COPY_S64(config->args, where, "-magic_ds_id", "magic_ds_id", "==");
     974    PXOPT_COPY_S64(config->args, where, "-magic_id", "magic_id", "==");
     975    pxAddLabelSearchArgs (config, where, "-label", "label", "==");
     976
     977    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     978    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     979
     980    // look for "inputs" that need to processed
     981    psString query = pxDataGet("magicdstool_torestore.sql");
     982    if (!query) {
     983        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     984        return false;
     985    }
     986
     987    if (psListLength(where->list)) {
     988        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     989        psStringAppend(&query, " WHERE %s", whereClause);
     990        psFree(whereClause);
     991    }
     992    psFree(where);
     993
     994    // treat limit == 0 as "no limit"
     995    if (limit) {
     996        psString limitString = psDBGenerateLimitSQL(limit);
     997        psStringAppend(&query, " %s", limitString);
     998        psFree(limitString);
     999    }
     1000
     1001    if (!p_psDBRunQuery(config->dbh, query)) {
     1002        psError(PS_ERR_UNKNOWN, false, "database error");
     1003        psFree(query);
     1004        return false;
     1005    }
     1006    psFree(query);
     1007
     1008    psArray *output = p_psDBFetchResult(config->dbh);
     1009    if (!output) {
     1010        psErrorCode err = psErrorCodeLast();
     1011        switch (err) {
     1012            case PS_ERR_DB_CLIENT:
     1013                psError(PXTOOLS_ERR_SYS, false, "database error");
     1014            case PS_ERR_DB_SERVER:
     1015                psError(PXTOOLS_ERR_PROG, false, "database error");
     1016            default:
     1017                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     1018        }
     1019
     1020        return false;
     1021    }
     1022    if (!psArrayLength(output)) {
     1023        psTrace("magicdstool", PS_LOG_INFO, "no rows found");
     1024        psFree(output);
     1025        return true;
     1026    }
     1027
     1028    if (psArrayLength(output)) {
     1029        // negative simple so the default is true
     1030        if (!ippdbPrintMetadatas(stdout, output, "torestore", !simple)) {
     1031            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1032            psFree(output);
     1033            return false;
     1034        }
     1035    }
     1036
     1037    psFree(output);
     1038
     1039    return true;
     1040}

  • branches/eam_branches/20090522/ippTools/src/magicdstool.h

    r20764 r24557  
    3232    MAGICDSTOOL_MODE_REVERTDESTREAKEDFILE,
    3333    MAGICDSTOOL_MODE_GETSKYCELLS,
     34    MAGICDSTOOL_MODE_TOREMOVE,
     35    MAGICDSTOOL_MODE_TORESTORE,
    3436} MAGICDStoolMode;
    3537

  • branches/eam_branches/20090522/ippTools/src/magicdstoolConfig.c

    r23974 r24557  
    114114    psMetadataAddBool(getskycellsArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    115115
     116    // -toremove
     117    psMetadata *toremoveArgs = psMetadataAlloc();
     118    psMetadataAddS64(toremoveArgs, PS_LIST_TAIL, "-magic_ds_id", 0, "search by magic Destreak ID", 0);
     119    psMetadataAddS64(toremoveArgs, PS_LIST_TAIL, "-magic_id", 0, "search by magic ID", 0);
     120    psMetadataAddStr(toremoveArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "define label", NULL);
     121    psMetadataAddU64(toremoveArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
     122    psMetadataAddBool(toremoveArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     123
     124    // -torestore
     125    psMetadata *torestoreArgs = psMetadataAlloc();
     126    psMetadataAddS64(torestoreArgs, PS_LIST_TAIL, "-magic_ds_id", 0, "search by magic Destreak ID", 0);
     127    psMetadataAddS64(torestoreArgs, PS_LIST_TAIL, "-magic_id", 0, "search by magic ID", 0);
     128    psMetadataAddStr(torestoreArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "define label", NULL);
     129    psMetadataAddU64(torestoreArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
     130    psMetadataAddBool(torestoreArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     131
    116132    psFree(now);
    117133
    … …  
    133149    PXOPT_ADD_MODE("-getskycells", "get skycell files ",
    134150                    MAGICDSTOOL_MODE_GETSKYCELLS, getskycellsArgs);
     151    PXOPT_ADD_MODE("-toremove", "backup images pending removal",
     152                    MAGICDSTOOL_MODE_TOREMOVE, toremoveArgs);
     153    PXOPT_ADD_MODE("-torestore", "images pending restore of exicsed streak pixels",
     154                    MAGICDSTOOL_MODE_TORESTORE, torestoreArgs);
    135155
    136156    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • branches/eam_branches/20090522/ippTools/src/magictool.c

    r24214 r24557  
    4747static bool revertmaskMode(pxConfig *config);
    4848static bool maskMode(pxConfig *config);
    49 static bool diffskyfileMode(pxConfig *config);
    50 static bool warpskyfileMode(pxConfig *config);
    51 static bool chipprocessedimfileMode(pxConfig *config);
    52 static bool rawimfileMode(pxConfig *config);
    53 
    5449
    5550static bool setmagicRunState(pxConfig *config, psS64 magic_id, const char *state);
    … …  
    9085        MODECASE(MAGICTOOL_MODE_REVERTMASK,          revertmaskMode);
    9186        MODECASE(MAGICTOOL_MODE_MASK,                maskMode);
    92         MODECASE(MAGICTOOL_MODE_DIFFSKYFILE,         diffskyfileMode);
    93         MODECASE(MAGICTOOL_MODE_WARPSKYFILE,         warpskyfileMode);
    94         MODECASE(MAGICTOOL_MODE_CHIPPROCESSEDIMFILE, chipprocessedimfileMode);
    95         MODECASE(MAGICTOOL_MODE_RAWIMFILE,           rawimfileMode);
    9687        default:
    9788            psAbort("invalid option (this should not happen)");
    … …  
    13061297}
    13071298
    1308 
    1309 static bool diffskyfileMode(pxConfig *config)
    1310 {
    1311     PS_ASSERT_PTR_NON_NULL(config, false);
    1312 
    1313     psMetadata *where = psMetadataAlloc();
    1314     PXOPT_COPY_S64(config->args, where, "-magic_id", "magicRun.magic_id", "==");
    1315     PXOPT_COPY_STR(config->args, where, "-class_id", "warpSkyCellMap.class_id", "==");
    1316     PXOPT_COPY_STR(config->args, where, "-skycell_id", "warpSkyCellMap.skycell_id", "==");
    1317 
    1318     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    1319 
    1320     psString query = pxDataGet("magictool_diffskyfile.sql");
    1321     if (!query) {
    1322         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1323         return false;
    1324     }
    1325 
    1326     if (psListLength(where->list)) {
    1327         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    1328         psStringAppend(&query, " AND %s", whereClause);
    1329         psFree(whereClause);
    1330     }
    1331     psFree(where);
    1332 
    1333     if (!p_psDBRunQuery(config->dbh, query)) {
    1334         psError(PS_ERR_UNKNOWN, false, "database error");
    1335         psFree(query);
    1336         return false;
    1337     }
    1338     psFree(query);
    1339 
    1340     psArray *output = p_psDBFetchResult(config->dbh);
    1341     if (!output) {
    1342         psErrorCode err = psErrorCodeLast();
    1343         switch (err) {
    1344             case PS_ERR_DB_CLIENT:
    1345                 psError(PXTOOLS_ERR_SYS, false, "database error");
    1346             case PS_ERR_DB_SERVER:
    1347                 psError(PXTOOLS_ERR_PROG, false, "database error");
    1348             default:
    1349                 psError(PXTOOLS_ERR_PROG, false, "unknown error");
    1350         }
    1351 
    1352         return false;
    1353     }
    1354     if (!psArrayLength(output)) {
    1355         psTrace("magictool", PS_LOG_INFO, "no rows found");
    1356         psFree(output);
    1357         return true;
    1358     }
    1359 
    1360     if (psArrayLength(output)) {
    1361         // negative simple so the default is true
    1362         if (!ippdbPrintMetadatas(stdout, output, "magicDiffSkyfile", !simple)) {
    1363             psError(PS_ERR_UNKNOWN, false, "failed to print array");
    1364             psFree(output);
    1365             return false;
    1366         }
    1367     }
    1368 
    1369     psFree(output);
    1370 
    1371     return true;
    1372 }
    1373 
    1374 
    1375 static bool warpskyfileMode(pxConfig *config)
    1376 {
    1377     PS_ASSERT_PTR_NON_NULL(config, false);
    1378 
    1379     psMetadata *where = psMetadataAlloc();
    1380     PXOPT_COPY_S64(config->args, where, "-magic_id", "magicRun.magic_id", "==");
    1381     PXOPT_COPY_STR(config->args, where, "-skycell_id", "warpSkyfile.skycell_id", "==");
    1382 
    1383     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    1384 
    1385     psString query = pxDataGet("magictool_warpskyfile.sql");
    1386     if (!query) {
    1387         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1388         return false;
    1389     }
    1390 
    1391     if (psListLength(where->list)) {
    1392         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    1393         psStringAppend(&query, " AND %s", whereClause);
    1394         psFree(whereClause);
    1395     }
    1396     psFree(where);
    1397 
    1398     if (!p_psDBRunQuery(config->dbh, query)) {
    1399         psError(PS_ERR_UNKNOWN, false, "database error");
    1400         psFree(query);
    1401         return false;
    1402     }
    1403     psFree(query);
    1404 
    1405     psArray *output = p_psDBFetchResult(config->dbh);
    1406     if (!output) {
    1407         psErrorCode err = psErrorCodeLast();
    1408         switch (err) {
    1409             case PS_ERR_DB_CLIENT:
    1410                 psError(PXTOOLS_ERR_SYS, false, "database error");
    1411             case PS_ERR_DB_SERVER:
    1412                 psError(PXTOOLS_ERR_PROG, false, "database error");
    1413             default:
    1414                 psError(PXTOOLS_ERR_PROG, false, "unknown error");
    1415         }
    1416 
    1417         return false;
    1418     }
    1419     if (!psArrayLength(output)) {
    1420         psTrace("magictool", PS_LOG_INFO, "no rows found");
    1421         psFree(output);
    1422         return true;
    1423     }
    1424 
    1425     if (psArrayLength(output)) {
    1426         // negative simple so the default is true
    1427         if (!ippdbPrintMetadatas(stdout, output, "magicWarpSkyfile", !simple)) {
    1428             psError(PS_ERR_UNKNOWN, false, "failed to print array");
    1429             psFree(output);
    1430             return false;
    1431         }
    1432     }
    1433 
    1434     psFree(output);
    1435 
    1436     return true;
    1437 }
    1438 
    1439 
    1440 static bool chipprocessedimfileMode(pxConfig *config)
    1441 {
    1442     PS_ASSERT_PTR_NON_NULL(config, false);
    1443 
    1444     psMetadata *where = psMetadataAlloc();
    1445     PXOPT_COPY_S64(config->args, where, "-magic_id", "magicRun.magic_id", "==");
    1446     PXOPT_COPY_STR(config->args, where, "-class_id", "warpSkyCellMap.class_id", "==");
    1447 
    1448     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    1449 
    1450     psString query = pxDataGet("magictool_chipprocessedimfile.sql");
    1451     if (!query) {
    1452         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1453         return false;
    1454     }
    1455 
    1456     if (psListLength(where->list)) {
    1457         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    1458         psStringAppend(&query, " AND %s", whereClause);
    1459         psFree(whereClause);
    1460     }
    1461     psFree(where);
    1462 
    1463     if (!p_psDBRunQuery(config->dbh, query)) {
    1464         psError(PS_ERR_UNKNOWN, false, "database error");
    1465         psFree(query);
    1466         return false;
    1467     }
    1468     psFree(query);
    1469 
    1470     psArray *output = p_psDBFetchResult(config->dbh);
    1471     if (!output) {
    1472         psErrorCode err = psErrorCodeLast();
    1473         switch (err) {
    1474             case PS_ERR_DB_CLIENT:
    1475                 psError(PXTOOLS_ERR_SYS, false, "database error");
    1476             case PS_ERR_DB_SERVER:
    1477                 psError(PXTOOLS_ERR_PROG, false, "database error");
    1478             default:
    1479                 psError(PXTOOLS_ERR_PROG, false, "unknown error");
    1480         }
    1481 
    1482         return false;
    1483     }
    1484     if (!psArrayLength(output)) {
    1485         psTrace("magictool", PS_LOG_INFO, "no rows found");
    1486         psFree(output);
    1487         return true;
    1488     }
    1489 
    1490     if (psArrayLength(output)) {
    1491         // negative simple so the default is true
    1492         if (!ippdbPrintMetadatas(stdout, output, "magicChipProcessedImfile", !simple)) {
    1493             psError(PS_ERR_UNKNOWN, false, "failed to print array");
    1494             psFree(output);
    1495             return false;
    1496         }
    1497     }
    1498 
    1499     psFree(output);
    1500 
    1501     return true;
    1502 }
    1503 
    1504 
    1505 static bool rawimfileMode(pxConfig *config)
    1506 {
    1507     PS_ASSERT_PTR_NON_NULL(config, false);
    1508 
    1509     psMetadata *where = psMetadataAlloc();
    1510     PXOPT_COPY_S64(config->args, where, "-magic_id", "magicRun.magic_id", "==");
    1511     PXOPT_COPY_STR(config->args, where, "-class_id", "warpSkyCellMap.class_id", "==");
    1512 
    1513     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    1514 
    1515     psString query = pxDataGet("magictool_rawimfile.sql");
    1516     if (!query) {
    1517         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1518         return false;
    1519     }
    1520 
    1521     if (psListLength(where->list)) {
    1522         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    1523         psStringAppend(&query, " AND %s", whereClause);
    1524         psFree(whereClause);
    1525     }
    1526     psFree(where);
    1527 
    1528     if (!p_psDBRunQuery(config->dbh, query)) {
    1529         psError(PS_ERR_UNKNOWN, false, "database error");
    1530         psFree(query);
    1531         return false;
    1532     }
    1533     psFree(query);
    1534 
    1535     psArray *output = p_psDBFetchResult(config->dbh);
    1536     if (!output) {
    1537         psErrorCode err = psErrorCodeLast();
    1538         switch (err) {
    1539             case PS_ERR_DB_CLIENT:
    1540                 psError(PXTOOLS_ERR_SYS, false, "database error");
    1541             case PS_ERR_DB_SERVER:
    1542                 psError(PXTOOLS_ERR_PROG, false, "database error");
    1543             default:
    1544                 psError(PXTOOLS_ERR_PROG, false, "unknown error");
    1545         }
    1546 
    1547         return false;
    1548     }
    1549     if (!psArrayLength(output)) {
    1550         psTrace("magictool", PS_LOG_INFO, "no rows found");
    1551         psFree(output);
    1552         return true;
    1553     }
    1554 
    1555     if (psArrayLength(output)) {
    1556         // negative simple so the default is true
    1557         if (!ippdbPrintMetadatas(stdout, output, "magicRawImfile", !simple)) {
    1558             psError(PS_ERR_UNKNOWN, false, "failed to print array");
    1559             psFree(output);
    1560             return false;
    1561         }
    1562     }
    1563 
    1564     psFree(output);
    1565 
    1566     return true;
    1567 }
    1568 
    1569 
    15701299static bool setmagicRunState(pxConfig *config, psS64 magic_id, const char *state)
    15711300{

  • branches/eam_branches/20090522/ippTools/src/magictoolConfig.c

    r24174 r24557  
    160160    psMetadataAddBool(maskArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    161161
     162#ifdef notdef
    162163    // -diffskyfile
    163164    psMetadata *diffskyfileArgs = psMetadataAlloc();
    … …  
    184185    psMetadataAddStr(rawimfileArgs, PS_LIST_TAIL, "-class_id", 0, "define class identifier", NULL);
    185186    psMetadataAddBool(rawimfileArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     187#endif // notdef
    186188
    187189    psFree(now);
    … …  
    206208    PXOPT_ADD_MODE("-revertmask",          "", MAGICTOOL_MODE_REVERTMASK,          revertmaskArgs);
    207209    PXOPT_ADD_MODE("-mask",                "", MAGICTOOL_MODE_MASK,                maskArgs);
     210#ifdef notdef
    208211    PXOPT_ADD_MODE("-diffskyfile",         "", MAGICTOOL_MODE_DIFFSKYFILE,         diffskyfileArgs);
    209212    PXOPT_ADD_MODE("-warpskyfile",         "", MAGICTOOL_MODE_WARPSKYFILE,         warpskyfileArgs);
    210213    PXOPT_ADD_MODE("-chipprocessedimfile", "", MAGICTOOL_MODE_CHIPPROCESSEDIMFILE, chipprocessedimfileArgs);
    211214    PXOPT_ADD_MODE("-rawimfile",           "", MAGICTOOL_MODE_RAWIMFILE,           rawimfileArgs);
     215#endif
    212216
    213217    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • branches/eam_branches/20090522/ippTools/src/pxchip.c

    r23418 r24557  
    175175    psString query = psStringCopy("UPDATE chipRun JOIN rawExp USING(exp_id) SET state = '%s'");
    176176
    177     if (where) {
     177    if (where && psListLength(where->list) > 0) {
    178178        psString whereClause = psDBGenerateWhereSQL(where, NULL);
    179179        psStringAppend(&query, " %s", whereClause);
    … …  
    216216    psString query = psStringCopy("UPDATE chipRun JOIN rawExp USING(exp_id) SET label = '%s'");
    217217
    218     if (where) {
     218    if (where && psListLength(where->list) > 0) {
    219219        psString whereClause = psDBGenerateWhereSQL(where, NULL);
    220220        psStringAppend(&query, " %s", whereClause);
    … …  
    264264            dvodb,
    265265            tess_id,
    266             end_stage, 
     266            end_stage,
    267267            0           // magicked
    268268            )
    … …  
    277277    psS64 chip_id =  psDBLastInsertID(config->dbh);
    278278
    279     // Create rows in chipImfile table for each input exposure. 
     279    // Create rows in chipImfile table for each input exposure.
    280280    // This creates the chip_image_id values
    281281    psString query = "INSERT INTO chipImfile "
    … …  
    295295        return 0;
    296296    }
    297    
     297
    298298    return chip_id;
    299299}

  • branches/eam_branches/20090522/ippTools/src/pxwarp.c

    r23613 r24557  
    126126
    127127bool pxwarpQueueByFakeID(pxConfig *config,
    128                     psS64 fake_id,
    129                     char *workdir,
    130                     char *label,
    131                     char *dvodb,
    132                     char *tess_id,
    133                     char *end_stage)
     128                         psS64 fake_id,
     129                         const char *workdir,
     130                         const char *label,
     131                         const char *dvodb,
     132                         const char *tess_id,
     133                         const char *reduction,
     134                         const char *end_stage)
    134135{
    135136    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    146147        dvodb,
    147148        tess_id,
     149                       reduction,
    148150        end_stage,
    149151        NULL,      // registered

  • branches/eam_branches/20090522/ippTools/src/pxwarp.h

    r23613 r24557  
    3131
    3232bool pxwarpQueueByFakeID(pxConfig *config,
    33                     psS64 fake_id,
    34                     char *workdir,
    35                     char *label,
    36                     char *dvodb,
    37                     char *tess_id,
    38                     char *end_stage);
     33                         psS64 fake_id,
     34                         const char *workdir,
     35                         const char *label,
     36                         const char *dvodb,
     37                         const char *tess_id,
     38                         const char *reduction,
     39                         const char *end_stage);
    3940
    4041#endif // PXWARP_H

  • branches/eam_branches/20090522/ippTools/src/warptool.c

    r24186 r24557  
    3838static bool tooverlapMode(pxConfig *config);
    3939static bool addoverlapMode(pxConfig *config);
     40static bool revertoverlapMode(pxConfig *config);
    4041static bool scmapMode(pxConfig *config);
    4142static bool towarpedMode(pxConfig *config);
    … …  
    8687        MODECASE(WARPTOOL_MODE_TOOVERLAP,          tooverlapMode);
    8788        MODECASE(WARPTOOL_MODE_ADDOVERLAP,         addoverlapMode);
     89        MODECASE(WARPTOOL_MODE_REVERTOVERLAP,      revertoverlapMode);
    8890        MODECASE(WARPTOOL_MODE_SCMAP,              scmapMode);
    8991        MODECASE(WARPTOOL_MODE_TOWARPED,           towarpedMode);
    … …  
    137139    PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false);
    138140    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", true, false); // required (no default TESS)
     141    PXOPT_LOOKUP_STR(reduction, config->args, "-reduction", false, false); // required (no default TESS)
    139142    PXOPT_LOOKUP_STR(end_stage, config->args, "-end_stage", false, false);
    140143    PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    … …  
    157160            dvodb,
    158161            tess_id,
     162            reduction,
    159163            end_stage,
    160164            registered,
    161             false       // magicked
     165            0       // magicked
    162166    );
    163167    if (!warpRun) {
    … …  
    247251    PXOPT_LOOKUP_STR(dvodb, config->args, "-set_dvodb", false, false);
    248252    PXOPT_LOOKUP_STR(tess_id, config->args, "-set_tess_id", false, false);
     253    PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false);
    249254    PXOPT_LOOKUP_STR(end_stage, config->args, "-set_end_stage", false, false);
    250255
    … …  
    308313        }
    309314
    310         if (!tess_id  && !row->tess_id) {
    311             psError(PS_ERR_UNKNOWN, false, "cannot queue warp run without a defined tess id: label: %s, fake_id %" PRId64, row->label, row->fake_id);
     315        if (!tess_id  && !row->tess_id) {
     316            psError(PS_ERR_UNKNOWN, false, "cannot queue warp run without a defined tess id: label: %s, fake_id %" PRId64, row->label, row->fake_id);
    312317            psFree(output);
    313318            return false;
    314         }
     319        }
    315320
    316321        psFree(row);
    317322    }
    318     psFree(output);
    319323
    320324    // loop over our list of fakeRun rows
    … …  
    331335        // queue the exp
    332336        if (!pxwarpQueueByFakeID(config,
    333                     row->fake_id,
    334                     workdir     ? workdir   : row->workdir,
    335                     label       ? label     : row->label,
    336                     dvodb       ? dvodb     : row->dvodb,
    337                     tess_id     ? tess_id   : row->tess_id,
    338                     end_stage   ? end_stage : row->end_stage))
     337                                 row->fake_id,
     338                                 workdir     ? workdir   : row->workdir,
     339                                 label       ? label     : row->label,
     340                                 dvodb       ? dvodb     : row->dvodb,
     341                                 tess_id     ? tess_id   : row->tess_id,
     342                                 reduction   ? reduction : row->reduction,
     343                                 end_stage   ? end_stage : row->end_stage))
    339344          {
    340345            psError(PS_ERR_UNKNOWN, false, "failed to trying to queue fake_id: %" PRId64, row->fake_id);
    … …  
    651656        warpSkyCellMapInsert(config->dbh,
    652657            warp_id,
    653             NULL,   // skycell_id
    654             NULL,   // tess_id
    655             NULL,   // class_id
     658            "faulted",   // skycell_id
     659            "faulted",   // tess_id
     660            "faulted",   // class_id
    656661            fault    // fault
    657662        );
    … …  
    666671    return true;
    667672}
     673
     674static bool revertoverlapMode(pxConfig *config)
     675{
     676    PS_ASSERT_PTR_NON_NULL(config, false);
     677
     678    psMetadata *where = psMetadataAlloc();
     679    PXOPT_COPY_S64(config->args, where, "-warp_id",    "warpSkyCellMap.warp_id", "==");
     680    PXOPT_COPY_STR(config->args, where, "-skycell_id", "warpSkyCellMap.skycell_id", "==");
     681    PXOPT_COPY_STR(config->args, where, "-tess_id",    "warpSkyCellMap.tess_id", "==");
     682    PXOPT_COPY_STR(config->args, where, "-label",      "warpRun.label", "==");
     683    PXOPT_COPY_S16(config->args, where, "-fault",      "warpSkyCellMap.fault", "==");
     684
     685    if (!psListLength(where->list)
     686        && !psMetadataLookupBool(NULL, config->args, "-all")) {
     687        psFree(where);
     688        psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     689        return false;
     690    }
     691
     692    int numDeleted;                     // Number deleted
     693    {
     694        psString query = pxDataGet("warptool_revertoverlap.sql");
     695        if (!query) {
     696            psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     697            if (!psDBRollback(config->dbh)) {
     698                psError(PS_ERR_UNKNOWN, false, "database error");
     699            }
     700            return false;
     701        }
     702
     703        if (psListLength(where->list)) {
     704            psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     705            psStringAppend(&query, " AND %s", whereClause);
     706            psFree(whereClause);
     707        }
     708
     709        if (!p_psDBRunQuery(config->dbh, query)) {
     710            psError(PS_ERR_UNKNOWN, false, "database error");
     711            psFree(query);
     712            if (!psDBRollback(config->dbh)) {
     713                psError(PS_ERR_UNKNOWN, false, "database error");
     714            }
     715            return false;
     716        }
     717        psFree(query);
     718
     719        numDeleted = psDBAffectedRows(config->dbh);
     720    }
     721
     722    psLogMsg("warptool", PS_LOG_INFO, "Deleted %d warpSkycellMap", numDeleted);
     723
     724    psFree(where);
     725
     726    return true;
     727}
     728
    668729
    669730
    … …  
    919980    PXOPT_LOOKUP_STR(hostname, config->args, "-hostname", false, false);
    920981    PXOPT_LOOKUP_F32(good_frac, config->args, "-good_frac", false, false);
    921     PXOPT_LOOKUP_BOOL(magicked, config->args, "-magicked", false);
     982    PXOPT_LOOKUP_S64(magicked, config->args, "-magicked", false, false);
    922983
    923984    // default values
    … …  
    10231084            return false;
    10241085        }
    1025         psS32 magicked = psMetadataLookupS64(&status, row, "magicked");
     1086        psS64 magicked = psMetadataLookupS64(&status, row, "magicked");
    10261087        if (!status) {
    10271088            psError(PS_ERR_UNKNOWN, false, "failed to look up value for magicked");
    … …  
    12241285    }
    12251286
    1226 
    1227     // Update state to 'new'
    1228     int numUpdated;                     // Number updated
    1229     {
    1230         // This query is no longer necessary because we do not set warpRun's to full statte
    1231         // if they have faulted skyfiles.
    1232         // We do have runs in the DB that follow the old convention so we leave this in for
    1233         // now
    1234         psString query = pxDataGet("warptool_revertwarped_update.sql");
    1235         if (!query) {
    1236             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1237             if (!psDBRollback(config->dbh)) {
    1238                 psError(PS_ERR_UNKNOWN, false, "database error");
    1239             }
    1240             return false;
    1241         }
    1242 
    1243         if (psListLength(where->list)) {
    1244             psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    1245             psStringAppend(&query, " AND %s", whereClause);
    1246             psFree(whereClause);
    1247         }
    1248 
    1249         if (!p_psDBRunQuery(config->dbh, query)) {
    1250             psError(PS_ERR_UNKNOWN, false, "database error");
    1251             psFree(query);
    1252             if (!psDBRollback(config->dbh)) {
    1253                 psError(PS_ERR_UNKNOWN, false, "database error");
    1254             }
    1255             return false;
    1256         }
    1257         psFree(query);
    1258 
    1259         numUpdated = psDBAffectedRows(config->dbh);
    1260 
    1261 #ifdef notdef
    1262         // new warpRuns won't get changed (they're already new) so don't require an update
    1263         if (numUpdated < 1) {
    1264             psError(PS_ERR_UNKNOWN, false, "should have affected at least 1 row");
    1265             if (!psDBRollback(config->dbh)) {
    1266                 psError(PS_ERR_UNKNOWN, false, "database error");
    1267             }
    1268             return false;
    1269         }
    1270 #endif
    1271     }
    1272 
    1273     psLogMsg("warptool", PS_LOG_INFO, "Updated %d warp runs", numUpdated);
    1274 
    12751287    // Delete product
    12761288    int numDeleted;                     // Number deleted
    … …  
    17441756
    17451757    if (clean) {
    1746         bool success = true; 
     1758        bool success = true;
    17471759        if (!strcmp(tables[i].tableName, "warpRun")) {
    17481760            success = pxSetStateCleaned("warpRun", "state", output);

  • branches/eam_branches/20090522/ippTools/src/warptool.h

    r24043 r24557  
    3434    WARPTOOL_MODE_TOOVERLAP,
    3535    WARPTOOL_MODE_ADDOVERLAP,
     36    WARPTOOL_MODE_REVERTOVERLAP,
    3637    WARPTOOL_MODE_SCMAP,
    3738    WARPTOOL_MODE_TOWARPED,

  • branches/eam_branches/20090522/ippTools/src/warptoolConfig.c

    r24043 r24557  
    9898    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_dvodb",          0, "define DVO db", NULL);
    9999    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_tess_id",        0, "define tess ID", NULL);
     100    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_reduction",      0, "define reduction class", NULL);
    100101    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_end_stage",      0, "define end stage", NULL);
    101102    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-all",               0, "allow everything to be queued without search terms", false);
    … …  
    111112    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-label", 0,            "define label", NULL);
    112113    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-dvodb", 0,            "define dvodb", NULL);
    113     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-tess_id", 0,            "define tess_id", NULL);
     114    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-tess_id", 0,            "define tess_id (required)", NULL);
     115    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-reduction", 0,            "define reduction class", NULL);
    114116    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-end_stage", 0,            "define end stage", NULL);
    115117    psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
    … …  
    156158    psMetadataAddS64(addoverlapArgs, PS_LIST_TAIL, "-warp_id",  0,            "set warp ID", 0);
    157159    psMetadataAddS16(addoverlapArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code", 0);
     160
     161    // -revertoverlap
     162    psMetadata *revertoverlapArgs = psMetadataAlloc();
     163    psMetadataAddS64(revertoverlapArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warptool ID", 0);
     164    psMetadataAddStr(revertoverlapArgs, PS_LIST_TAIL, "-skycell_id",  0,            "search by skycell ID", NULL);
     165    psMetadataAddStr(revertoverlapArgs, PS_LIST_TAIL, "-tess_id",  0,            "search by tessellation ID", NULL);
     166    psMetadataAddStr(revertoverlapArgs, PS_LIST_TAIL, "-label",  0,            "search by warpRun label", NULL);
     167    psMetadataAddS16(revertoverlapArgs, PS_LIST_TAIL, "-fault",  0,            "search by fault code", 0);
     168    psMetadataAddBool(revertoverlapArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);
     169
    158170
    159171    // -scmap
    … …  
    300312    PXOPT_ADD_MODE("-tooverlap",       "", WARPTOOL_MODE_TOOVERLAP,      tooverlapArgs);
    301313    PXOPT_ADD_MODE("-addoverlap",      "", WARPTOOL_MODE_ADDOVERLAP,     addoverlapArgs);
     314    PXOPT_ADD_MODE("-revertoverlap",   "", WARPTOOL_MODE_REVERTOVERLAP,  revertoverlapArgs);
    302315    PXOPT_ADD_MODE("-scmap",           "", WARPTOOL_MODE_SCMAP,          scmapArgs);
    303316    PXOPT_ADD_MODE("-towarped",        "", WARPTOOL_MODE_TOWARPED,       towarpedArgs);
Note: See TracChangeset for help on using the changeset viewer.