IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Aug 19, 2010, 6:50:13 PM (16 years ago)
Author:
eugene
Message:

updates from trunk

Location:
branches/eam_branches/ipp-20100621/ippTools/src
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • branches/eam_branches/ipp-20100621/ippTools/src/addtool.c

    r28295 r28980  
    144144    PXOPT_LOOKUP_BOOL(simple,     config->args, "-simple", false);
    145145
    146 
    147 
    148     // find the cam_id of all the exposures that we want to queue up.
    149     psString bare_query = pxDataGet("addtool_find_cam_id.sql");
    150     if (!bare_query) {
    151         psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    152         psFree(where);
    153         return false;
    154     }
    155 
    156146    // prevent queueing an addRun if a given exposure has already been added to
    157147    // the given dvo database
    158148    psString dvodb_string = NULL;
     149    psString bare_query = NULL;
    159150    if (dvodb) {
    160         // user supplied dvodb
    161         psStringAppend(&dvodb_string, "(previous_dvodb = '%s')", dvodb);
     151      psTrace("addtool.c", PS_LOG_INFO, "dvodb argument found (%s) using addtool_find_cam_id_dvo.sql\n", dvodb);
     152        // find the cam_id of all the exposures that we want to queue up.
     153        bare_query = pxDataGet("addtool_find_cam_id_dvo.sql");
     154        // user supplied dvodb
     155        psStringAppend(&dvodb_string, "addRun.dvodb = '%s'", dvodb);
    162156    } else {
     157        psTrace("addtool.c", PS_LOG_INFO, "dvodb argument not found using addtool_find_cam_id.sql\n");
     158        // find the cam_id of all the exposures that we want to queue up.
     159        bare_query = pxDataGet("addtool_find_cam_id.sql");
    163160        // inherit dvodb from camRun, avoid matching NULL
    164161        psStringAppend(&dvodb_string, "(camRun.dvodb IS NOT NULL AND previous_dvodb = camRun.dvodb)");
     162    }
     163    if (!bare_query) {
     164        psError(PXTOOLS_ERR_SYS, false, "failed to retrieve SQL statement");
     165        psFree(where);
     166        return false;
    165167    }
    166168    // Take the bare query and add the dvodb selector

  • branches/eam_branches/ipp-20100621/ippTools/src/bgtool.c

    r28794 r28980  
    3939static bool advancechipMode(pxConfig *config);
    4040static bool revertchipMode(pxConfig *config);
     41static bool listchipMode(pxConfig *config);
    4142static bool definewarpMode(pxConfig *config);
    4243static bool updatewarpMode(pxConfig *config);
    … …  
    4748static bool advancewarpMode(pxConfig *config);
    4849static bool revertwarpMode(pxConfig *config);
     50static bool listwarpMode(pxConfig *config);
    4951static bool tocleanchipMode(pxConfig *config);
    5052static bool cleanedchipMode(pxConfig *config);
    … …  
    100102        MODECASE(BGTOOL_MODE_ADVANCECHIP, advancechipMode);
    101103        MODECASE(BGTOOL_MODE_REVERTCHIP,  revertchipMode);
     104        MODECASE(BGTOOL_MODE_LISTCHIP,    listchipMode);
    102105        MODECASE(BGTOOL_MODE_DEFINEWARP,  definewarpMode);
    103106        MODECASE(BGTOOL_MODE_UPDATEWARP,  updatewarpMode);
    … …  
    108111        MODECASE(BGTOOL_MODE_ADVANCEWARP, advancewarpMode);
    109112        MODECASE(BGTOOL_MODE_REVERTWARP,  revertwarpMode);
     113        MODECASE(BGTOOL_MODE_LISTWARP,    listwarpMode);
    110114        MODECASE(BGTOOL_MODE_TOCLEANCHIP, tocleanchipMode);
    111115        MODECASE(BGTOOL_MODE_CLEANEDCHIP, cleanedchipMode);
    … …  
    907911    int numDeleted = psDBAffectedRows(config->dbh);
    908912    psLogMsg("bgtool", PS_LOG_INFO, "Deleted %d chipBackgroundImfiles", numDeleted);
     913
     914    return true;
     915}
     916static bool listchipMode(pxConfig *config)
     917{
     918    PS_ASSERT_PTR_NON_NULL(config, false);
     919
     920    psMetadata *where = psMetadataAlloc();
     921    PXOPT_COPY_S64(config->args, where, "-chip_bg_id", "chipBackgroundRun.chip_bg_id", "==");
     922    PXOPT_COPY_STR(config->args, where, "-class_id", "chipProcessedImfile.class_id", "==");
     923
     924    // chip_bg_id is required
     925    PXOPT_LOOKUP_S64(chip_bg_id, config->args, "-chip_bg_id", true, false);
     926
     927    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     928    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     929
     930    psString query = pxDataGet("bgtool_listchip.sql");
     931    if (!query) {
     932        psError(psErrorCodeLast(), false, "failed to retreive SQL statement");
     933        return false;
     934    }
     935
     936    psString whereStr = psStringCopy("");
     937    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     938    psStringAppend(&query, "\nWHERE %s", whereClause);
     939    psFree(whereClause);
     940    psFree(where);
     941
     942    if (limit) {
     943        psString limitString = psDBGenerateLimitSQL(limit);
     944        psStringAppend(&query, " %s", limitString);
     945        psFree(limitString);
     946    }
     947
     948    if (!p_psDBRunQuery(config->dbh, query)) {
     949        psError(psErrorCodeLast(), false, "database error");
     950        psFree(query);
     951        return false;
     952    }
     953    psFree(whereStr);
     954    psFree(query);
     955
     956    psArray *output = p_psDBFetchResult(config->dbh);
     957    if (!output) {
     958        psError(psErrorCodeLast(), false, "Unable to fetch result of query %s", query);
     959        return false;
     960    }
     961    if (!psArrayLength(output)) {
     962        psTrace("bgtool", PS_LOG_INFO, "no rows found");
     963        psFree(output);
     964        return true;
     965    }
     966
     967    if (psArrayLength(output)) {
     968        if (!ippdbPrintMetadatas(stdout, output, "chipProcessedImfile", !simple)) {
     969            psError(psErrorCodeLast(), false, "failed to print array");
     970            psFree(output);
     971            return false;
     972        }
     973    }
     974
     975    psFree(output);
    909976
    910977    return true;
    … …  
    16861753    return true;
    16871754}
     1755static bool listwarpMode(pxConfig *config)
     1756{
     1757    PS_ASSERT_PTR_NON_NULL(config, false);
     1758
     1759    psMetadata *where = psMetadataAlloc();
     1760    PXOPT_COPY_S64(config->args, where, "-warp_bg_id", "warpBackgroundRun.warp_bg_id", "==");
     1761    PXOPT_COPY_STR(config->args, where, "-skycell_id", "warpSkyfile.skycell_id", "==");
     1762
     1763    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1764    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1765
     1766    psString query = pxDataGet("bgtool_listwarp.sql");
     1767    if (!query) {
     1768        psError(psErrorCodeLast(), false, "failed to retreive SQL statement");
     1769        return false;
     1770    }
     1771
     1772    psString whereStr = psStringCopy("");
     1773    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1774    psStringAppend(&query, "\nWHERE %s", whereClause);
     1775    psFree(whereClause);
     1776    psFree(where);
     1777
     1778    if (limit) {
     1779        psString limitString = psDBGenerateLimitSQL(limit);
     1780        psStringAppend(&query, " %s", limitString);
     1781        psFree(limitString);
     1782    }
     1783
     1784    if (!p_psDBRunQuery(config->dbh, query)) {
     1785        psError(psErrorCodeLast(), false, "database error");
     1786        psFree(query);
     1787        return false;
     1788    }
     1789    psFree(whereStr);
     1790    psFree(query);
     1791
     1792    psArray *output = p_psDBFetchResult(config->dbh);
     1793    if (!output) {
     1794        psError(psErrorCodeLast(), false, "Unable to fetch result of query %s", query);
     1795        return false;
     1796    }
     1797    if (!psArrayLength(output)) {
     1798        psTrace("bgtool", PS_LOG_INFO, "no rows found");
     1799        psFree(output);
     1800        return true;
     1801    }
     1802
     1803    if (psArrayLength(output)) {
     1804        if (!ippdbPrintMetadatas(stdout, output, "warpSkyfile", !simple)) {
     1805            psError(psErrorCodeLast(), false, "failed to print array");
     1806            psFree(output);
     1807            return false;
     1808        }
     1809    }
     1810
     1811    psFree(output);
     1812
     1813    return true;
     1814}
    16881815
    16891816static bool tocleanwarpMode(pxConfig *config)

  • branches/eam_branches/ipp-20100621/ippTools/src/bgtool.h

    r28794 r28980  
    3434    BGTOOL_MODE_ADVANCECHIP,
    3535    BGTOOL_MODE_REVERTCHIP,
     36    BGTOOL_MODE_LISTCHIP,
    3637    // Warp stage
    3738    BGTOOL_MODE_DEFINEWARP,
    … …  
    4344    BGTOOL_MODE_ADVANCEWARP,
    4445    BGTOOL_MODE_REVERTWARP,
     46    BGTOOL_MODE_LISTWARP,
    4547    // Cleanups
    4648    BGTOOL_MODE_TOCLEANCHIP,

  • branches/eam_branches/ipp-20100621/ippTools/src/bgtoolConfig.c

    r28794 r28980  
    184184    psMetadataAddS16(revertchipArgs, PS_LIST_TAIL, "-fault", 0, "search by fault code", 0);
    185185    psMetadataAddBool(revertchipArgs, PS_LIST_TAIL, "-all", 0, "allow everything to be queued without search terms", false);
     186
     187    // -listchip
     188    psMetadata *listchipArgs = psMetadataAlloc();
     189    psMetadataAddS64(listchipArgs, PS_LIST_TAIL, "-chip_bg_id", 0, "search by chip_bg_id (required)", 0);
     190    psMetadataAddStr(listchipArgs, PS_LIST_TAIL, "-class_id",  0, "search by class_id", NULL);
     191    psMetadataAddBool(listchipArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     192    psMetadataAddU64(listchipArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
    186193
    187194    // -tocleanchip
    … …  
    347354    psMetadataAddBool(revertwarpArgs, PS_LIST_TAIL, "-all", 0, "allow everything to be queued without search terms", false);
    348355
     356    // -listwarp
     357    psMetadata *listwarpArgs = psMetadataAlloc();
     358    psMetadataAddS64(listwarpArgs, PS_LIST_TAIL, "-warp_bg_id", 0, "search by warp_bg_id (required)", 0);
     359    psMetadataAddStr(listwarpArgs, PS_LIST_TAIL, "-skycell_id",  0, "search by skycell_id", NULL);
     360    psMetadataAddBool(listwarpArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     361    psMetadataAddU64(listwarpArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
     362
    349363    // -tocleanwarp
    350364    psMetadata *tocleanwarpArgs = psMetadataAlloc();
    … …  
    382396    PXOPT_ADD_MODE("-advancechip", "", BGTOOL_MODE_ADVANCECHIP, advancechipArgs);
    383397    PXOPT_ADD_MODE("-revertchip",  "", BGTOOL_MODE_REVERTCHIP,  revertchipArgs);
     398    PXOPT_ADD_MODE("-listchip",    "", BGTOOL_MODE_LISTCHIP,    listchipArgs);
    384399    PXOPT_ADD_MODE("-tocleanchip", "", BGTOOL_MODE_TOCLEANCHIP, tocleanchipArgs);
    385400    PXOPT_ADD_MODE("-cleanedchip", "", BGTOOL_MODE_CLEANEDCHIP, cleanedchipArgs);
    … …  
    395410    PXOPT_ADD_MODE("-advancewarp", "", BGTOOL_MODE_ADVANCEWARP, advancewarpArgs);
    396411    PXOPT_ADD_MODE("-revertwarp",  "", BGTOOL_MODE_REVERTWARP,  revertwarpArgs);
     412    PXOPT_ADD_MODE("-listwarp",    "", BGTOOL_MODE_LISTWARP,    listwarpArgs);
    397413    PXOPT_ADD_MODE("-tocleanwarp", "", BGTOOL_MODE_TOCLEANWARP, tocleanwarpArgs);
    398414    PXOPT_ADD_MODE("-cleanedwarp", "", BGTOOL_MODE_CLEANEDWARP, cleanedwarpArgs);

  • branches/eam_branches/ipp-20100621/ippTools/src/disttool.c

    r28794 r28980  
    3434static bool updaterunMode(pxConfig *config);
    3535static bool revertrunMode(pxConfig *config);
     36static bool rerunMode(pxConfig *config);
    3637static bool pendingcomponentMode(pxConfig *config);
    3738static bool addprocessedcomponentMode(pxConfig *config);
    … …  
    8384        MODECASE(DISTTOOL_MODE_UPDATERUN, updaterunMode);
    8485        MODECASE(DISTTOOL_MODE_REVERTRUN, revertrunMode);
     86        MODECASE(DISTTOOL_MODE_RERUN, rerunMode);
    8587        MODECASE(DISTTOOL_MODE_PENDINGCOMPONENT, pendingcomponentMode);
    8688        MODECASE(DISTTOOL_MODE_ADDPROCESSEDCOMPONENT, addprocessedcomponentMode);
    … …  
    327329        // stack stage doesn't require magic
    328330        no_magic = true;
     331    } else if (!strcmp(stage, "sky")) {
     332        magicRunType = "staticskyRun";
     333        query = pxDataGet("disttool_definebyquery_sky.sql");
     334        if (!query) {
     335            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     336            psFree(where);
     337            return false;
     338        }
     339
     340        if (label) {
     341            psStringAppend(&query, " AND (staticskyRun.label = '%s')", label);
     342        }
     343        if (dist_group) {
     344            psStringAppend(&query, " AND (sticskyRun.dist_group = '%s')", dist_group);
     345        }
     346        // (static)sky stage doesn't require magic
     347        no_magic = true;
    329348    } else if (!strcmp(stage, "SSdiff")) {
    330349      magicRunType = "diffRun";
    … …  
    587606}
    588607
     608static bool rerunMode(pxConfig *config)
     609{
     610    psMetadata *where = psMetadataAlloc();
     611    PXOPT_COPY_S64(config->args, where, "-dist_id", "distRun.dist_id", "==");
     612    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");;
     613    PXOPT_COPY_S64(config->args, where, "-stage_id", "stage_id", "==");
     614    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     615    PXOPT_COPY_STR(config->args, where, "-data_group", "data_group", "==");
     616
     617    // require data_group or dist_id to be supplied
     618    PXOPT_LOOKUP_STR(data_group, config->args, "-data_group", true, false);
     619    PXOPT_LOOKUP_S64(dist_id, config->args, "-dist_id", false, false);
     620    if (!data_group && !dist_id) {
     621        psError(PXTOOLS_ERR_CONFIG, true, "data_group or dist_id is required");
     622        return false;
     623    }
     624    PXOPT_LOOKUP_STR(set_label, config->args, "-set_label", false, false);
     625
     626    psString label_hook = psStringCopy("");
     627    if (set_label) {
     628        psStringAppend(&label_hook, ", label = '%s'", set_label);
     629    }
     630
     631    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
     632    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     633    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     634
     635
     636    // It might be useful to be able to query by the parameters of the underlying runs
     637
     638    if (!psListLength(where->list)) {
     639        psFree(where);
     640        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     641        return false;
     642    }
     643
     644    psString query = pxDataGet("disttool_rerun_select.sql");
     645    if (!query) {
     646        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     647        if (!psDBRollback(config->dbh)) {
     648            psError(PS_ERR_UNKNOWN, false, "database error");
     649        }
     650        return false;
     651    }
     652
     653    if (psListLength(where->list)) {
     654        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     655        psStringAppend(&query, " AND %s", whereClause);
     656        psFree(whereClause);
     657    }
     658    psFree(where);
     659
     660    if (limit) {
     661        psString limitString = psDBGenerateLimitSQL(limit);
     662        psStringAppend(&query, " %s", limitString);
     663        psFree(limitString);
     664    }
     665
     666    if (!p_psDBRunQuery(config->dbh, query)) {
     667        psError(PS_ERR_UNKNOWN, false, "database error");
     668        psFree(query);
     669        return false;
     670    }
     671    psFree(query);
     672
     673    psArray *output = p_psDBFetchResult(config->dbh);
     674    if (!output) {
     675        psError(PS_ERR_UNKNOWN, false, "database error");
     676        return false;
     677    }
     678    if (!psArrayLength(output)) {
     679        psTrace("disttool", PS_LOG_INFO, "no rows found");
     680        psFree(output);
     681        return true;
     682    }
     683
     684
     685    if (pretend) {
     686        if (!ippdbPrintMetadatas(stdout, output, "distRunsToUpdate", true)) {
     687            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     688            psFree(output);
     689            return false;
     690        }
     691        psFree(output);
     692        return true;
     693    }
     694
     695    query = "DELETE FROM distComponent where dist_id = %" PRId64;
     696   
     697    for (long i=0; i < psArrayLength(output); i++) {
     698        psMetadata *md = output->data[i];
     699        psS64 dist_id = psMetadataLookupS64(NULL, md, "dist_id");
     700
     701        if (!psDBTransaction(config->dbh)) {
     702            psError(PS_ERR_UNKNOWN, false, "database error");
     703            return false;
     704        }
     705
     706        if (!p_psDBRunQueryF(config->dbh, query, dist_id)) {
     707            psError(PS_ERR_UNKNOWN, false, "database error");
     708            psFree(query);
     709            if (!psDBRollback(config->dbh)) {
     710                psError(PS_ERR_UNKNOWN, false, "database error");
     711            }
     712            return false;
     713        }
     714
     715        if (!p_psDBRunQueryF(config->dbh,
     716        "UPDATE distRun SET state = 'new', fault=0 %s WHERE dist_id =%" PRId64,
     717                label_hook, dist_id)) {
     718            psError(PS_ERR_UNKNOWN, false, "database error");
     719            psFree(query);
     720            if (!psDBRollback(config->dbh)) {
     721                psError(PS_ERR_UNKNOWN, false, "database error");
     722            }
     723            return false;
     724        }
     725        if (!psDBCommit(config->dbh)) {
     726            psError(PS_ERR_UNKNOWN, false, "database error");
     727            return false;
     728        }
     729        printf("re-running distRun %" PRId64 "\n", dist_id);
     730    }
     731
     732    psFree(output);
     733
     734    return true;
     735}
    589736static bool revertrunMode(pxConfig *config)
    590737{

  • branches/eam_branches/ipp-20100621/ippTools/src/disttool.h

    r26193 r28980  
    2828    DISTTOOL_MODE_UPDATERUN,
    2929    DISTTOOL_MODE_REVERTRUN,
     30    DISTTOOL_MODE_RERUN,
    3031    DISTTOOL_MODE_PENDINGCOMPONENT,
    3132    DISTTOOL_MODE_ADDPROCESSEDCOMPONENT,

  • branches/eam_branches/ipp-20100621/ippTools/src/disttoolConfig.c

    r28259 r28980  
    8585    psMetadataAddS16(updaterunArgs, PS_LIST_TAIL, "-fault",      0, "define fault code", 0);
    8686
     87    // -rerun
     88    psMetadata *rerunArgs = psMetadataAlloc();
     89    psMetadataAddStr(rerunArgs, PS_LIST_TAIL, "-data_group",    0, "define data_group (required)", NULL);
     90    psMetadataAddS64(rerunArgs, PS_LIST_TAIL, "-dist_id", 0, "search by dist_id", 0);
     91    psMetadataAddStr(rerunArgs, PS_LIST_TAIL, "-stage",    0, "search by stage", NULL);
     92    psMetadataAddS64(rerunArgs, PS_LIST_TAIL, "-stage_id", 0, "search by stage_id", 0);
     93    psMetadataAddStr(rerunArgs, PS_LIST_TAIL, "-label",    0, "search by label", NULL);
     94    psMetadataAddStr(rerunArgs, PS_LIST_TAIL, "-set_label",    0, "define new label", NULL);
     95    psMetadataAddBool(rerunArgs, PS_LIST_TAIL, "-pretend", 0, "don't queue runs just display what would be selected", false);
     96    psMetadataAddU64(rerunArgs, PS_LIST_TAIL, "-limit",  0,  "limit result set to N items", 0);
     97    psMetadataAddBool(rerunArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     98
    8799    // -revertrun
    88100    psMetadata *revertrunArgs = psMetadataAlloc();
    … …  
    327339    psMetadata *modes = psMetadataAlloc();
    328340
    329     PXOPT_ADD_MODE("-definebyquery",    "", DISTTOOL_MODE_DEFINEBYQUERY, definebyqueryArgs);
    330     PXOPT_ADD_MODE("-updaterun",    "", DISTTOOL_MODE_UPDATERUN, updaterunArgs);
    331     PXOPT_ADD_MODE("-revertrun",    "", DISTTOOL_MODE_REVERTRUN, revertrunArgs);
     341    PXOPT_ADD_MODE("-definebyquery",    "define distribution run", DISTTOOL_MODE_DEFINEBYQUERY, definebyqueryArgs);
     342    PXOPT_ADD_MODE("-updaterun",    "update distRun", DISTTOOL_MODE_UPDATERUN, updaterunArgs);
     343    PXOPT_ADD_MODE("-rerun",        "reprocess a cleaned distribution run", DISTTOOL_MODE_RERUN, rerunArgs);
     344    PXOPT_ADD_MODE("-revertrun",    "revert distRun.faults", DISTTOOL_MODE_REVERTRUN, revertrunArgs);
    332345    PXOPT_ADD_MODE("-pendingcomponent",   "", DISTTOOL_MODE_PENDINGCOMPONENT,    pendingcomponentArgs);
    333346    PXOPT_ADD_MODE("-addprocessedcomponent", "", DISTTOOL_MODE_ADDPROCESSEDCOMPONENT, addprocessedcomponentArgs);
    334     PXOPT_ADD_MODE("-revertcomponent",    "", DISTTOOL_MODE_REVERTCOMPONENT, revertcomponentArgs);
     347    PXOPT_ADD_MODE("-revertcomponent",    "revert faulted components", DISTTOOL_MODE_REVERTCOMPONENT, revertcomponentArgs);
    335348    PXOPT_ADD_MODE("-processedcomponent", "", DISTTOOL_MODE_PROCESSEDCOMPONENT, processedcomponentArgs);
    336349    PXOPT_ADD_MODE("-toadvance",          "", DISTTOOL_MODE_TOADVANCE, toadvanceArgs);
    … …  
    340353    PXOPT_ADD_MODE("-updatefileset",         "", DISTTOOL_MODE_UPDATEFILESET, updatefilesetArgs);
    341354    PXOPT_ADD_MODE("-listfilesets",        "", DISTTOOL_MODE_LISTFILESETS, listfilesetsArgs);
    342     PXOPT_ADD_MODE("-revertfileset",      "", DISTTOOL_MODE_REVERTFILESET, revertfilesetArgs);
     355    PXOPT_ADD_MODE("-revertfileset",      "revert faulted filesets", DISTTOOL_MODE_REVERTFILESET, revertfilesetArgs);
    343356    PXOPT_ADD_MODE("-queuercrun",         "", DISTTOOL_MODE_QUEUERCRUN, queuercrunArgs);
    344357    PXOPT_ADD_MODE("-updatercrun",        "", DISTTOOL_MODE_UPDATERCRUN, updatercrunArgs);

  • branches/eam_branches/ipp-20100621/ippTools/src/magicdstool.c

    r28794 r28980  
    613613    PXOPT_COPY_S64(config->args, where, "-magic_ds_id", "magicDSRun.magic_ds_id", "==");
    614614    PXOPT_COPY_S64(config->args, where, "-magic_id", "magic_id", "==");
     615    PXOPT_COPY_S64(config->args, where, "-stage_id", "stage_id", "==");
    615616    pxAddLabelSearchArgs (config, where, "-label", "magicDSRun.label", "==");
    616617

  • branches/eam_branches/ipp-20100621/ippTools/src/magicdstoolConfig.c

    r28794 r28980  
    120120    psMetadataAddS64(todestreakArgs, PS_LIST_TAIL, "-magic_ds_id", 0, "search by magic Destreak ID", 0);
    121121    psMetadataAddS64(todestreakArgs, PS_LIST_TAIL, "-magic_id", 0, "search by magic ID", 0);
     122    psMetadataAddS64(todestreakArgs, PS_LIST_TAIL, "-stage_id", 0, "search by stage ID", 0);
    122123    psMetadataAddStr(todestreakArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "define label", NULL);
    123124    psMetadataAddU64(todestreakArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);

  • branches/eam_branches/ipp-20100621/ippTools/src/pstamptool.c

    r28794 r28980  
    12201220    PXOPT_COPY_S64(config->args, where, "-stage_id", "stage_id", "==");
    12211221    PXOPT_COPY_S64(config->args, where, "-dep_id", "dep_id", "==");
     1222    PXOPT_COPY_S64(config->args, where, "-job_id", "job_id", "==");
     1223    PXOPT_COPY_S64(config->args, where, "-req_id", "req_id", "==");
    12221224    PXOPT_COPY_STR(config->args, where, "-rlabel", "rlabel", "==");
    12231225    pxAddLabelSearchArgs(config, where, "-label", "pstampRequest.label", "==");

  • branches/eam_branches/ipp-20100621/ippTools/src/pstamptoolConfig.c

    r28794 r28980  
    211211    psMetadataAddStr(pendingdependentArgs, PS_LIST_TAIL, "-component", 0,    "define component for dependent", NULL);
    212212    psMetadataAddS64(pendingdependentArgs, PS_LIST_TAIL, "-dep_id", 0, "define dep_id for dependent", 0);
     213    psMetadataAddS64(pendingdependentArgs, PS_LIST_TAIL, "-job_id", 0, "define job_id for dependent", 0);
     214    psMetadataAddS64(pendingdependentArgs, PS_LIST_TAIL, "-req_id", 0, "define eqp_id for dependent", 0);
    213215    psMetadataAddStr(pendingdependentArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK,   "define label for pstampRequest", NULL);
    214216    psMetadataAddStr(pendingdependentArgs, PS_LIST_TAIL, "-rlabel", 0,   "define label for dependent", NULL);

  • branches/eam_branches/ipp-20100621/ippTools/src/staticskytool.c

    r28154 r28980  
    727727bool exportrunMode(pxConfig *config)
    728728{
    729 # if (0)
    730729  typedef struct ExportTable {
    731730    char tableName[80];
    … …  
    737736  PS_ASSERT_PTR_NON_NULL(config, NULL);
    738737
    739   PXOPT_LOOKUP_S64(det_id, config->args, "-stack_id", true,  false);
     738  PXOPT_LOOKUP_S64(det_id, config->args, "-sky_id", true,  false);
    740739  PXOPT_LOOKUP_STR(outfile, config->args, "-outfile", true,  false);
    741740  PXOPT_LOOKUP_BOOL(clean, config->args, "-clean", false);
    … …  
    753752  }
    754753  psMetadata *where = psMetadataAlloc();
    755   PXOPT_COPY_S64(config->args, where, "-stack_id", "stack_id", "==");
     754  PXOPT_COPY_S64(config->args, where, "-sky_id", "sky_id", "==");
    756755
    757756  ExportTable tables [] = {
    758     {"stackRun", "staticskytool_export_run.sql"},
    759     {"stackInputSkyfile", "staticskytool_export_input_skyfile.sql"},
    760     {"stackSumSkyfile", "staticskytool_export_sum_skyfile.sql"},
     757    {"staticskyRun", "staticskytool_export_run.sql"},
     758    {"staticskyInput", "staticskytool_export_input.sql"},
     759    {"staticskyResult", "staticskytool_export_result.sql"},
    761760  };
    762761
    … …  
    800799
    801800    if (clean) {
    802         if (!strcmp(tables[i].tableName, "stackRun")) {
    803             if (!pxSetStateCleaned("stackRun", "state", output)) {
     801        if (!strcmp(tables[i].tableName, "staticskyRun")) {
     802            if (!pxSetStateCleaned("staticskyRun", "state", output)) {
    804803                psFree(output);
    805804                psError(PS_ERR_UNKNOWN, false, "pxSetStateClean failed for table %s",  tables[i].tableName);
    … …  
    821820    fclose (f);
    822821
    823 # endif
    824822    return true;
    825823}
Note: See TracChangeset for help on using the changeset viewer.