IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Oct 21, 2010, 2:45:13 PM (16 years ago)
Author:
eugene
Message:

merge changes from trunk

Location:
branches/eam_branches/ipp-20100823/ippTools/src
Files:
20 edited

Legend:

Unmodified
Added
Removed

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

    r28856 r29515  
    493493
    494494    // since there is only one exp per 'new' set addRun.state = 'full'
    495     if (!pxaddRunSetState(config, row->add_id, "full")) {
     495    // but check to make sure there are no faults
     496
     497    if (!fault) {
     498      if (!pxaddRunSetState(config, row->add_id, "full")) {
    496499        psError(PS_ERR_UNKNOWN, false, "failed to change addRun.state for add_id: %" PRId64, row->add_id);
    497500        psFree(row);
    498501        psFree(pendingRow);
    499502        return false;
     503      }
    500504    }
    501505    psFree(row);

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

    r28941 r29515  
    658658    }
    659659
    660     if (!chipBackgroundImfileInsert(config->dbh, chip_bg_id, class_id, path_base, magicked, dtime_script,
     660    if (!chipBackgroundImfileInsert(config->dbh, chip_bg_id, class_id, path_base, "full", magicked, dtime_script,
    661661                                    hostname, quality, fault, ver_code, bg, bg_stdev, maskfrac_npix,
    662662                                    maskfrac_static, maskfrac_dynamic, maskfrac_magic, maskfrac_advisory)) {
    … …  
    14971497    }
    14981498
    1499     if (!warpBackgroundSkyfileInsert(config->dbh, warp_bg_id, skycell_id, path_base, magicked, dtime_script,
     1499    if (!warpBackgroundSkyfileInsert(config->dbh, warp_bg_id, skycell_id, path_base, "full", magicked, dtime_script,
    15001500                                    hostname, quality, fault, ver_code, bg, bg_stdev, maskfrac_npix,
    15011501                                    maskfrac_static, maskfrac_dynamic, maskfrac_magic, maskfrac_advisory)) {

  • branches/eam_branches/ipp-20100823/ippTools/src/chiptool.c

    r28716 r29515  
    5050static bool pendingcleanuprunMode(pxConfig *config);
    5151static bool pendingcleanupimfileMode(pxConfig *config);
     52static bool revertcleanupMode(pxConfig *config);
    5253static bool donecleanupMode(pxConfig *config);
    5354static bool runMode(pxConfig *config);
    … …  
    9495        MODECASE(CHIPTOOL_MODE_PENDINGCLEANUPRUN,       pendingcleanuprunMode);
    9596        MODECASE(CHIPTOOL_MODE_PENDINGCLEANUPIMFILE,    pendingcleanupimfileMode);
     97        MODECASE(CHIPTOOL_MODE_REVERTCLEANUP,           revertcleanupMode);
    9698        MODECASE(CHIPTOOL_MODE_DONECLEANUP,             donecleanupMode);
    9799        MODECASE(CHIPTOOL_MODE_RUN,                     runMode);
    … …  
    859861    }
    860862    psString query_update = pxDataGet("chiptool_revertupdatedimfile.sql");
    861     if (!query) {
     863    if (!query_update) {
    862864        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    863865        psFree(where);
    864866        return false;
    865867    }
     868
    866869
    867870    if (where && psListLength(where->list)) {
    … …  
    886889    }
    887890    psFree(query_update);
     891
     892    return true;
     893}
     894static bool revertcleanupMode(pxConfig *config)
     895{
     896    PS_ASSERT_PTR_NON_NULL(config, false);
     897
     898    psMetadata *where = psMetadataAlloc();
     899    PXOPT_COPY_S64(config->args, where, "-chip_id", "chipRun.chip_id", "==");
     900    pxAddLabelSearchArgs (config, where, "-label", "chipRun.label", "LIKE");
     901    pxAddLabelSearchArgs (config, where, "-data_group", "chipRun.data_group", "LIKE");
     902    PXOPT_LOOKUP_STR(state, config->args, "-state", false, false);
     903
     904    char* newState = NULL;
     905    if (!state) {
     906        state = "error_cleaned";
     907    }
     908    if (!strcmp(state, "error_cleaned")) {
     909        newState = "goto_cleaned";
     910    } else if (!strcmp(state, "error_purged")) {
     911        newState = "goto_purged";
     912    } else if (!strcmp(state, "error_scrubbed")) {
     913        newState = "goto_scrubbed";
     914    } else {
     915        psError(PXTOOLS_ERR_CONFIG, true, "-state must be either error_cleaned, error_purged, or error_scrubbed");
     916        return false;
     917    }
     918
     919    if (!psListLength(where->list)) {
     920        psFree(where);
     921        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     922        return false;
     923    }
     924
     925    psString query = pxDataGet("chiptool_revertcleanup.sql");
     926    if (!query) {
     927        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     928        psFree(where);
     929        return false;
     930    }
     931
     932    if (where && psListLength(where->list)) {
     933        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     934        psStringAppend(&query, " AND %s", whereClause);
     935        psFree(whereClause);
     936    }
     937
     938    psFree(where);
     939
     940    if (!p_psDBRunQueryF(config->dbh, query, newState, state, state)) {
     941        psError(PS_ERR_UNKNOWN, false, "database error");
     942        psFree(query);
     943        return false;
     944    }
     945    psFree(query);
    888946
    889947    return true;

  • branches/eam_branches/ipp-20100823/ippTools/src/chiptool.h

    r27742 r29515  
    4242    CHIPTOOL_MODE_PENDINGCLEANUPRUN,
    4343    CHIPTOOL_MODE_PENDINGCLEANUPIMFILE,
     44    CHIPTOOL_MODE_REVERTCLEANUP,
    4445    CHIPTOOL_MODE_DONECLEANUP,
    4546    CHIPTOOL_MODE_RUN,

  • branches/eam_branches/ipp-20100823/ippTools/src/chiptoolConfig.c

    r28716 r29515  
    290290    psMetadataAddU64(donecleanupArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    291291
     292    // -revertcleanup
     293    psMetadata *revertcleanupArgs = psMetadataAlloc();
     294    psMetadataAddS64(revertcleanupArgs, PS_LIST_TAIL, "-chip_id", 0,            "search by chip ID", 0);
     295    psMetadataAddStr(revertcleanupArgs,  PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by chipRun label (LIKE comparison)", NULL);
     296    psMetadataAddStr(revertcleanupArgs,  PS_LIST_TAIL, "-data_group",  PS_META_DUPLICATE_OK, "search by chipRun data_group (LIKE comparison)", NULL);
     297    psMetadataAddStr(revertcleanupArgs, PS_LIST_TAIL, "-state", 0,             "search by current state", NULL);
     298    psMetadataAddS16(revertcleanupArgs, PS_LIST_TAIL, "-fault",  0,            "search by fault code", 0);
     299
    292300    // -run
    293301    psMetadata *runArgs = psMetadataAlloc();
    … …  
    371379    PXOPT_ADD_MODE("-pendingcleanupimfile", "show runs that need to be cleaned up", CHIPTOOL_MODE_PENDINGCLEANUPIMFILE, pendingcleanupimfileArgs);
    372380    PXOPT_ADD_MODE("-donecleanup",          "show runs that have been cleaned",     CHIPTOOL_MODE_DONECLEANUP,          donecleanupArgs);
     381    PXOPT_ADD_MODE("-revertcleanup",        "show runs that have been cleaned",     CHIPTOOL_MODE_REVERTCLEANUP,        revertcleanupArgs);
    373382    PXOPT_ADD_MODE("-run",                  "show runs",                            CHIPTOOL_MODE_RUN,                  runArgs);
    374383    PXOPT_ADD_MODE("-tocleanedimfile",      "set imfile state to cleaned",          CHIPTOOL_MODE_TOCLEANEDIMFILE,      tocleanedimfileArgs);

  • branches/eam_branches/ipp-20100823/ippTools/src/difftool.c

    r29324 r29515  
    4848static bool pendingcleanuprunMode(pxConfig *config);
    4949static bool pendingcleanupskyfileMode(pxConfig *config);
     50static bool revertcleanupMode(pxConfig *config);
    5051static bool donecleanupMode(pxConfig *config);
    5152static bool updatediffskyfileMode(pxConfig *config);
    … …  
    6061static bool tofullskyfileMode(pxConfig *config);
    6162static bool listrunMode(pxConfig *config);
     63static bool listssrunMode(pxConfig *config);
    6264static bool setskyfiletoupdateMode(pxConfig *config);
    6365
    … …  
    99101        MODECASE(DIFFTOOL_MODE_PENDINGCLEANUPRUN,     pendingcleanuprunMode);
    100102        MODECASE(DIFFTOOL_MODE_PENDINGCLEANUPSKYFILE, pendingcleanupskyfileMode);
     103        MODECASE(DIFFTOOL_MODE_REVERTCLEANUP,         revertcleanupMode);
    101104        MODECASE(DIFFTOOL_MODE_DONECLEANUP,           donecleanupMode);
    102105        MODECASE(DIFFTOOL_MODE_UPDATEDIFFSKYFILE,     updatediffskyfileMode);
    … …  
    108111        MODECASE(DIFFTOOL_MODE_TOFULLSKYFILE,         tofullskyfileMode);
    109112        MODECASE(DIFFTOOL_MODE_LISTRUN,               listrunMode);
     113        MODECASE(DIFFTOOL_MODE_LISTSSRUN,             listssrunMode);
    110114        MODECASE(DIFFTOOL_MODE_SETSKYFILETOUPDATE,    setskyfiletoupdateMode);
    111115
    … …  
    478482    }
    479483    psFree(where);
     484
     485     psStringAppend(&query, "\nORDER by priority DESC, diff_id");
    480486
    481487    // treat limit == 0 as "no limit"
    … …  
    12361242    PXOPT_COPY_F32(config->args, warp2Where,  "-good_frac", "warpSkyfile.good_frac", ">=");
    12371243    PXOPT_COPY_STR(config->args, stackWhere, "-stack_label", "stackRun.label", "==");
     1244    PXOPT_COPY_STR(config->args, stackWhere, "-stack_data_group", "stackRun.data_group", "==");
    12381245
    12391246    PXOPT_LOOKUP_BOOL(bothways, config->args, "-bothways", false);
    … …  
    16091616    PXOPT_COPY_S64(config->args, selectWhere, "-warp_id", "inputWarpRun.warp_id", "==");
    16101617    PXOPT_COPY_S64(config->args, selectWhere, "-exp_id", "inputRawExp.exp_id", "==");
     1618    PXOPT_COPY_S64(config->args, selectWhere, "-template_exp_id", "templateRawExp.exp_id", "==");
    16111619    PXOPT_COPY_STR(config->args, selectWhere, "-filter", "inputRawExp.filter", "==");
    16121620    PXOPT_COPY_STR(config->args, selectWhere, "-obs_mode", "inputRawExp.obs_mode", "==");
    … …  
    16471655    PXOPT_COPY_F32(config->args,   selectWhere, "-sun_angle_min",      "inputRawExp.sun_angle",      ">=");
    16481656    PXOPT_COPY_F32(config->args,   selectWhere, "-sun_angle_max",      "inputRawExp.sun_angle",      "<");
    1649     PXOPT_COPY_STR(config->args,   selectWhere, "-comment",            "inputRawExp.comment",        "LIKE");
     1657    PXOPT_COPY_STR(config->args,   selectWhere, "-input_comment",      "inputRawExp.comment",        "LIKE");
     1658    PXOPT_COPY_STR(config->args,   selectWhere, "-template_comment",   "templateRawExp.comment",     "LIKE");
    16501659
    16511660    PXOPT_LOOKUP_BOOL(not_bothways, config->args, "-not-bothways", false);
    … …  
    16801689
    16811690    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1691    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    16821692    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
    16831693
    … …  
    18391849    long numGood = 0;                   // Number of good rows added
    18401850    for (long i = 0; i < results->n; i++) {
     1851        if (limit && numGood >= limit) {
     1852            break;
     1853        }
    18411854        psMetadata *row = results->data[i]; // Result row from query
    18421855
    … …  
    25352548
    25362549
     2550static bool revertcleanupMode(pxConfig *config)
     2551{
     2552    PS_ASSERT_PTR_NON_NULL(config, false);
     2553
     2554    psMetadata *where = psMetadataAlloc();
     2555    PXOPT_COPY_S64(config->args, where, "-diff_id",    "diffSkyfile.diff_id", "==");
     2556    pxAddLabelSearchArgs (config, where, "-label",     "diffRun.label", "LIKE");
     2557    pxAddLabelSearchArgs (config, where, "-data_group",   "diffRun.data_group", "LIKE");
     2558
     2559    PXOPT_LOOKUP_STR(state, config->args, "-state", false, false);
     2560
     2561    if (!psListLength(where->list)) {
     2562        psFree(where);
     2563        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     2564        return false;
     2565    }
     2566    if (!state) {
     2567        state = "error_cleaned";
     2568    }
     2569    char *newState = NULL;
     2570    if (!strcmp(state, "error_cleaned")) {
     2571        newState = "goto_cleaned";
     2572    } else if (!strcmp(state, "error_purged")) {
     2573        newState = "goto_purged";
     2574    } else if (!strcmp(state, "error_scrubbed")) {
     2575        newState = "goto_scrubbed";
     2576    } else {
     2577        psError(PXTOOLS_ERR_CONFIG, true, "-state must be either error_cleaned, error_purged, or error_scrubbed");
     2578        return false;
     2579    }
     2580
     2581    psString query = pxDataGet("difftool_revertcleanup.sql");
     2582    if (!query) {
     2583        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     2584        return false;
     2585    }
     2586
     2587    if (psListLength(where->list)) {
     2588        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     2589        psStringAppend(&query, " AND %s", whereClause);
     2590        psFree(whereClause);
     2591    }
     2592    psFree(where);
     2593
     2594    if (!p_psDBRunQueryF(config->dbh, query, newState, state, state)) {
     2595        psError(PS_ERR_UNKNOWN, false, "database error");
     2596        psFree(query);
     2597        return false;
     2598    }
     2599    psFree(query);
     2600
     2601    int numDeleted = psDBAffectedRows(config->dbh);
     2602
     2603    psLogMsg("difftool", PS_LOG_INFO, "Reverted %d diffRuns and diffSkyfiles", numDeleted);
     2604
     2605    return true;
     2606}
    25372607static bool donecleanupMode(pxConfig *config)
    25382608{
    … …  
    28772947
    28782948    psMetadata *where = psMetadataAlloc();
    2879     PXOPT_COPY_S64(config->args, where,  "-diff_id", "diffRun.diff_id", "==");
    2880     PXOPT_COPY_STR(config->args, where, "-tess_id", "diffRun.tess_id", "==");
    2881     PXOPT_COPY_S64(config->args, where,  "-magicked", "diffRun.magicked", "==");
    2882     pxAddLabelSearchArgs (config, where, "-label", "diffRun.label", "LIKE");
     2949    PXOPT_COPY_S64(config->args, where,  "-diff_id",    "diffRun.diff_id",  "==");
     2950    PXOPT_COPY_STR(config->args, where,  "-tess_id",    "diffRun.tess_id",  "LIKE");
     2951    PXOPT_COPY_S64(config->args, where,  "-magicked",   "diffRun.magicked", "==");
     2952    PXOPT_COPY_STR(config->args, where,  "-state",      "diffRun.state",    "==");
     2953    pxAddLabelSearchArgs (config, where, "-label",      "diffRun.label", "LIKE");
    28832954    pxAddLabelSearchArgs (config, where, "-data_group", "diffRun.data_group", "LIKE");
    28842955    pxAddLabelSearchArgs (config, where, "-dist_group", "diffRun.dist_group", "LIKE");
    2885 
     2956   
    28862957    PXOPT_LOOKUP_BOOL(template, config->args, "-template", false);
    28872958    if (!template) {
    … …  
    29052976    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    29062977    PXOPT_LOOKUP_BOOL(pstamp_order, config->args, "-pstamp_order", false);
    2907 
     2978    PXOPT_LOOKUP_S16(diff_mode, config->args, "-diff_mode", false, false);
     2979    if (diff_mode) {
     2980      PXOPT_COPY_S16(config->args, where, "-diff_mode", "diffRun.diff_mode", "==");
     2981    }
    29082982
    29092983    psString where2 = NULL;
    … …  
    29833057    return true;
    29843058}
     3059static bool listssrunMode(pxConfig *config)
     3060{
     3061    PS_ASSERT_PTR_NON_NULL(config, false);
     3062
     3063    psMetadata *where = psMetadataAlloc();
     3064    PXOPT_COPY_S64(config->args, where,  "-diff_id",    "diffRun.diff_id",  "==");
     3065    PXOPT_COPY_S64(config->args, where,  "-stack_id",   "stackInput.stack_id",  "==");
     3066    PXOPT_COPY_S64(config->args, where,  "-template_stack_id",  "stackTemplate.stack_id",  "==");
     3067    PXOPT_COPY_STR(config->args, where,  "-tess_id",    "diffRun.tess_id",  "LIKE");
     3068    PXOPT_COPY_STR(config->args, where,  "-state",      "diffRun.state",    "==");
     3069    pxAddLabelSearchArgs (config, where, "-label",      "diffRun.label", "LIKE");
     3070    pxAddLabelSearchArgs (config, where, "-data_group", "diffRun.data_group", "LIKE");
     3071    pxAddLabelSearchArgs (config, where, "-dist_group", "diffRun.dist_group", "LIKE");
     3072
     3073    // lookup these so we don't compare to zero if they are not supplied
     3074    PXOPT_LOOKUP_F64(mjd_obs_begin, config->args, "-mjd_obs_begin", false, false);
     3075    PXOPT_LOOKUP_F64(mjd_obs_end, config->args, "-mjd_obs_end", false, false);
     3076   
     3077    PXOPT_LOOKUP_BOOL(template, config->args, "-template", false);
     3078
     3079    if (!template) {
     3080        if (mjd_obs_begin) {
     3081            PXOPT_COPY_F64(config->args, where, "-mjd_obs_begin", "stackInput.mjd_obs",  ">=");
     3082        }
     3083        if (mjd_obs_end) {
     3084            PXOPT_COPY_F64(config->args, where, "-mjd_obs_end",   "stackInput.mjd_obs",  "<=");
     3085        }
     3086        PXOPT_COPY_STR(config->args, where, "-filter",        "stackInputRun.filter", "LIKE");
     3087    } else {
     3088        if (mjd_obs_begin) {
     3089            PXOPT_COPY_F64(config->args, where, "-mjd_obs_begin", "stackTemplate.mjd_obs",  ">=");
     3090        }
     3091        if (mjd_obs_end) {
     3092            PXOPT_COPY_F64(config->args, where, "-mjd_obs_end",   "stackTemplate.mjd_obs",  "<=");
     3093        }
     3094        PXOPT_COPY_STR(config->args, where, "-filter",        "stackTemplateRun.filter", "LIKE");
     3095    }
     3096
     3097    PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
     3098    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     3099    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     3100    PXOPT_LOOKUP_BOOL(pstamp_order, config->args, "-pstamp_order", false);
     3101
     3102    psString where2 = NULL;
     3103    psString query = pxDataGet("difftool_listssrun.sql");
     3104    if (!query) {
     3105        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     3106        return false;
     3107    }
     3108
     3109    if (psListLength(where->list)) {
     3110        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     3111        psStringAppend(&query, " AND %s", whereClause);
     3112        psFree(whereClause);
     3113    } else if (where2) {
     3114        psStringAppend(&query, " AND %s", where2);
     3115    } else if (!all) {
     3116        psError(PXTOOLS_ERR_CONFIG, true, "search parameters or -all are required");
     3117        return false;
     3118    }
     3119    psFree(where);
     3120
     3121    if (pstamp_order) {
     3122        if (template) {
     3123            psStringAppend(&query, " ORDER BY stackTemplate.stack_id, diff_id DESC");
     3124        } else {
     3125            psStringAppend(&query, " ORDER BY stackInput.stack_id, diff_id DESC");
     3126        }
     3127    }
     3128           
     3129    // treat limit == 0 as "no limit"
     3130    if (limit) {
     3131        psString limitString = psDBGenerateLimitSQL(limit);
     3132        psStringAppend(&query, " %s", limitString);
     3133        psFree(limitString);
     3134    }
     3135
     3136    if (!p_psDBRunQuery(config->dbh, query)) {
     3137        psError(PS_ERR_UNKNOWN, false, "database error");
     3138        psFree(query);
     3139        return false;
     3140    }
     3141    psFree(query);
     3142
     3143    psArray *output = p_psDBFetchResult(config->dbh);
     3144    if (!output) {
     3145        psErrorCode err = psErrorCodeLast();
     3146        switch (err) {
     3147            case PS_ERR_DB_CLIENT:
     3148                psError(PXTOOLS_ERR_SYS, false, "database error");
     3149            case PS_ERR_DB_SERVER:
     3150                psError(PXTOOLS_ERR_PROG, false, "database error");
     3151            default:
     3152                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     3153        }
     3154
     3155        return false;
     3156    }
     3157    if (!psArrayLength(output)) {
     3158        psTrace("difftool", PS_LOG_INFO, "no rows found");
     3159        psFree(output);
     3160        return true;
     3161    }
     3162
     3163    if (psArrayLength(output)) {
     3164        // negative simple so the default is true
     3165        if (!ippdbPrintMetadatas(stdout, output, "diffRun", !simple)) {
     3166            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     3167            psFree(output);
     3168            return false;
     3169        }
     3170    }
     3171
     3172    psFree(output);
     3173
     3174    return true;
     3175}
    29853176// a very specfic function to queue a cleaned warpSkyfile to be updated
    29863177static bool setskyfiletoupdateMode(pxConfig *config)

  • branches/eam_branches/ipp-20100823/ippTools/src/difftool.h

    r28375 r29515  
    4242    DIFFTOOL_MODE_PENDINGCLEANUPRUN,
    4343    DIFFTOOL_MODE_PENDINGCLEANUPSKYFILE,
     44    DIFFTOOL_MODE_REVERTCLEANUP,
    4445    DIFFTOOL_MODE_DONECLEANUP,
    4546    DIFFTOOL_MODE_UPDATEDIFFSKYFILE,
    … …  
    5152    DIFFTOOL_MODE_TOFULLSKYFILE,
    5253    DIFFTOOL_MODE_LISTRUN,
     54    DIFFTOOL_MODE_LISTSSRUN,
    5355    DIFFTOOL_MODE_SETSKYFILETOUPDATE,
    5456} difftoolMode;

  • branches/eam_branches/ipp-20100823/ippTools/src/difftoolConfig.c

    r29324 r29515  
    173173    psMetadata *listrunArgs = psMetadataAlloc();
    174174    psMetadataAddS64(listrunArgs, PS_LIST_TAIL,  "-diff_id", 0,           "search by diff ID", 0);
    175     psMetadataAddStr(listrunArgs, PS_LIST_TAIL,  "-tess_id",  0,          "search by tessellation ID", NULL);
     175    psMetadataAddStr(listrunArgs, PS_LIST_TAIL,  "-tess_id",  0,          "search by tessellation ID (LIKE comparison)", NULL);
    176176    psMetadataAddStr(listrunArgs , PS_LIST_TAIL, "-warp_id",  0,         "search by warp_id", NULL);
    177177    psMetadataAddBool(listrunArgs, PS_LIST_TAIL, "-template",  0,        "apply exposure args to template of bothways diff", false);
    … …  
    184184    psMetadataAddStr(listrunArgs,  PS_LIST_TAIL, "-data_group",  PS_META_DUPLICATE_OK, "search by diffRun data_group (LIKE comparison)", NULL);
    185185    psMetadataAddStr(listrunArgs,  PS_LIST_TAIL, "-dist_group",  PS_META_DUPLICATE_OK, "search by diffRun dist_group (LIKE comparison)", NULL);
     186    psMetadataAddS16(listrunArgs,  PS_LIST_TAIL, "-diff_mode", 0,        "search for diff_mode", 0);
     187    psMetadataAddStr(listrunArgs, PS_LIST_TAIL,  "-state",  0,           "search by state", NULL);
    186188    pxmagicAddArguments(listrunArgs);
    187189    pxspaceAddArguments(listrunArgs);
    … …  
    192194    psMetadataAddU64(listrunArgs, PS_LIST_TAIL,  "-limit",  0,            "limit result set to N items", 0);
    193195    psMetadataAddBool(listrunArgs, PS_LIST_TAIL, "-simple",  0,          "use the simple output format", false);
     196
     197
     198    // -listssrun
     199    psMetadata *listssrunArgs = psMetadataAlloc();
     200    psMetadataAddS64(listssrunArgs, PS_LIST_TAIL,  "-diff_id", 0,          "search by diff ID", 0);
     201    psMetadataAddStr(listssrunArgs, PS_LIST_TAIL,  "-tess_id",  0,         "search by tessellation ID (LIKE comparison)", NULL);
     202    psMetadataAddS64(listssrunArgs , PS_LIST_TAIL, "-stack_id",  0,        "search by input stack_id", 0);
     203    psMetadataAddS64(listssrunArgs , PS_LIST_TAIL, "-template_stack_id",0, "search by template stack_id", 0);
     204    psMetadataAddBool(listssrunArgs, PS_LIST_TAIL, "-template",  0,        "apply stack selectors to template", false);
     205    psMetadataAddF64(listssrunArgs, PS_LIST_TAIL,  "-mjd_obs_begin", 0,    "search by stack MJD-OBS (>=)", 0);
     206    psMetadataAddF64(listssrunArgs, PS_LIST_TAIL,  "-mjd_obs_end", 0,      "search by stack MJD-OBS(<=)", 0);
     207    psMetadataAddStr(listssrunArgs, PS_LIST_TAIL,  "-filter", 0,           "search by stack filter", NULL);
     208    psMetadataAddStr(listssrunArgs,  PS_LIST_TAIL, "-label",  PS_META_DUPLICATE_OK, "search by diffRun label (LIKE comparison)", NULL);
     209    psMetadataAddStr(listssrunArgs,  PS_LIST_TAIL, "-data_group",  PS_META_DUPLICATE_OK, "search by diffRun data_group (LIKE comparison)", NULL);
     210    psMetadataAddStr(listssrunArgs,  PS_LIST_TAIL, "-dist_group",  PS_META_DUPLICATE_OK, "search by diffRun dist_group (LIKE comparison)", NULL);
     211    psMetadataAddS16(listssrunArgs,  PS_LIST_TAIL, "-diff_mode", 0,        "search for diff_mode", 0);
     212    psMetadataAddStr(listssrunArgs, PS_LIST_TAIL,  "-state",  0,           "search by state", NULL);
     213    pxmagicAddArguments(listssrunArgs);
     214    pxspaceAddArguments(listssrunArgs);
     215
     216    psMetadataAddBool(listssrunArgs, PS_LIST_TAIL, "-pstamp_order",  0,    "order results for postage stamp server", false);
     217
     218    psMetadataAddBool(listssrunArgs, PS_LIST_TAIL, "-all",  0,             "search without arguments", false);
     219    psMetadataAddU64(listssrunArgs, PS_LIST_TAIL,  "-limit",  0,            "limit result set to N items", 0);
     220    psMetadataAddBool(listssrunArgs, PS_LIST_TAIL, "-simple",  0,          "use the simple output format", false);
    194221
    195222
    … …  
    226253    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-comment", 0, "search by comment (LIKE)", NULL);
    227254    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-stack_label", 0, "search by stack label", NULL);
     255    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-stack_data_group", 0, "search by stack data_group", NULL);
    228256    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-warp_label", 0, "search by warp label", NULL);
    229257    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-data_group", 0, "search by data_group", NULL);
    … …  
    247275    psMetadataAddS64(definewarpwarpArgs, PS_LIST_TAIL, "-exp_id", 0, "search by exposure ID", 0);
    248276    psMetadataAddBool(definewarpwarpArgs, PS_LIST_TAIL, "-not-bothways",  0, "only do the single-direction subtraction?", false);
     277    psMetadataAddS64(definewarpwarpArgs, PS_LIST_TAIL,  "-template_exp_id",  0,  "search by template exposure ID", 0);
    249278    psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-filter", 0, "search by filter", NULL);
    250279    psMetadataAddF32(definewarpwarpArgs, PS_LIST_TAIL, "-distance", 0, "limit distance between input and template (deg)", NAN);
    … …  
    292321    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-posang_min",         0, "search by min rotator position angle", NAN);
    293322    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-posang_max",         0, "search by max rotator position angle", NAN);
    294     psMetadataAddF32(definewarpwarpArgs,  PS_LIST_TAIL, "-sun_angle_min",         0, "search by min solar angle", NAN);
    295     psMetadataAddF32(definewarpwarpArgs,  PS_LIST_TAIL, "-sun_angle_max",         0, "search by max solar angle", NAN);
    296     psMetadataAddStr(definewarpwarpArgs,  PS_LIST_TAIL, "-comment",            0, "search by comment field (LIKE comparison)", NULL);
     323    psMetadataAddF32(definewarpwarpArgs,  PS_LIST_TAIL, "-sun_angle_min",      0, "search by min solar angle", NAN);
     324    psMetadataAddF32(definewarpwarpArgs,  PS_LIST_TAIL, "-sun_angle_max",      0, "search by max solar angle", NAN);
     325    psMetadataAddStr(definewarpwarpArgs,  PS_LIST_TAIL, "-input_comment",      0, "search by comment field for input exposure(LIKE comparison)", NULL);
     326    psMetadataAddStr(definewarpwarpArgs,  PS_LIST_TAIL, "-template_comment",   0, "search by comment field for template exposure(LIKE comparison)", NULL);
     327    psMetadataAddU64(definewarpwarpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    297328
    298329    // -definestackstack
    … …  
    362393    psMetadataAddU64(pendingcleanupskyfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    363394
     395    // -revertcleanup
     396    psMetadata *revertcleanupArgs = psMetadataAlloc();
     397    psMetadataAddS64(revertcleanupArgs, PS_LIST_TAIL, "-diff_id", 0,            "search by difftool ID", 0);
     398    psMetadataAddStr(revertcleanupArgs, PS_LIST_TAIL, "-label",  PS_META_DUPLICATE_OK, "search by diffRun label", NULL);
     399    psMetadataAddStr(revertcleanupArgs, PS_LIST_TAIL, "-data_group",  PS_META_DUPLICATE_OK, "search by diffRun data_group", NULL);
     400    psMetadataAddStr(revertcleanupArgs, PS_LIST_TAIL, "-state",  0,            "search by state", NULL);
     401
     402
    364403    // -donecleanup
    365404    psMetadata *donecleanupArgs = psMetadataAlloc();
    … …  
    427466    PXOPT_ADD_MODE("-advance",          "", DIFFTOOL_MODE_ADVANCE,           advanceArgs);
    428467    PXOPT_ADD_MODE("-diffskyfile",      "", DIFFTOOL_MODE_DIFFSKYFILE,       diffskyfileArgs);
    429     PXOPT_ADD_MODE("-listrun",          "", DIFFTOOL_MODE_LISTRUN,           listrunArgs);
    430468    PXOPT_ADD_MODE("-revertdiffskyfile","", DIFFTOOL_MODE_REVERTDIFFSKYFILE, revertdiffskyfileArgs);
    431469    PXOPT_ADD_MODE("-definepoprun",     "", DIFFTOOL_MODE_DEFINEPOPRUN,      definepoprunArgs);
    … …  
    433471    PXOPT_ADD_MODE("-definewarpwarp",   "", DIFFTOOL_MODE_DEFINEWARPWARP,    definewarpwarpArgs);
    434472    PXOPT_ADD_MODE("-definestackstack", "", DIFFTOOL_MODE_DEFINESTACKSTACK,  definestackstackArgs);
     473    PXOPT_ADD_MODE("-listrun",          "list diff runs", DIFFTOOL_MODE_LISTRUN,           listrunArgs);
     474    PXOPT_ADD_MODE("-listssrun",        "list stack-stack diff runs", DIFFTOOL_MODE_LISTSSRUN,           listssrunArgs);
    435475    PXOPT_ADD_MODE("-pendingcleanuprun",     "show runs that need to be cleaned up", DIFFTOOL_MODE_PENDINGCLEANUPRUN,    pendingcleanuprunArgs);
    436476    PXOPT_ADD_MODE("-pendingcleanupskyfile", "show runs that need to be cleaned up", DIFFTOOL_MODE_PENDINGCLEANUPSKYFILE, pendingcleanupskyfileArgs);
     477    PXOPT_ADD_MODE("-revertcleanup",           "revert cleanup runs with errors",     DIFFTOOL_MODE_REVERTCLEANUP,          revertcleanupArgs);
    437478    PXOPT_ADD_MODE("-donecleanup",           "show runs that have been cleaned",     DIFFTOOL_MODE_DONECLEANUP,          donecleanupArgs);
    438479    PXOPT_ADD_MODE("-updatediffskyfile",     "update fault code for a diffskyfile",  DIFFTOOL_MODE_UPDATEDIFFSKYFILE,          updatediffskyfileArgs);

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

    r28936 r29515  
    637637    psFree(where);
    638638
     639    psStringAppend(&query, "\nORDER BY priority DESC, magic_ds_id");
     640
    639641    // treat limit == 0 as "no limit"
    640642    if (limit) {
    … …  
    933935    }
    934936
     937    // treat limit == 0 as "no limit"
     938    if (limit) {
     939        psString limitString = psDBGenerateLimitSQL(limit);
     940        psStringAppend(&query, " %s", limitString);
     941        psFree(limitString);
     942    }
     943
    935944    if (!p_psDBRunQuery(config->dbh, query)) {
    936945        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    950959        return true;
    951960    }
    952     if (!psDBTransaction(config->dbh)) {
    953         psError(PS_ERR_UNKNOWN, false, "database error");
    954         return false;
    955     }
    956961    for (long i = 0; i < psArrayLength(output); i++) {
    957962        psMetadata *row = output->data[i];
    958963
    959964        psS64 magic_ds_id = psMetadataLookupS64(NULL, row, "magic_ds_id");
     965        psS64 magicked =  psMetadataLookupS64(NULL, row, "magicked");
     966        if (!psDBTransaction(config->dbh)) {
     967            psError(PS_ERR_UNKNOWN, false, "database error");
     968            return false;
     969        }
    960970
    961971        // if re_place, set stageRun.magicked
    962972        bool setmagicked = psMetadataLookupBool(NULL, row, "re_place");
    963         if (setmagicked && !setRunMagicked(config, magic_ds_id)) {
    964             psError(PS_ERR_UNKNOWN, false, "failed to change stageRun.magicked for magic_ds_id: %" PRId64,
    965                 magic_ds_id);
    966             if (!psDBRollback(config->dbh)) {
    967                 psError(PS_ERR_UNKNOWN, false, "database error");
     973        if (setmagicked) {
     974            if (magicked <= 0) {
     975                if (!setRunMagicked(config, magic_ds_id)) {
     976                    psError(PS_ERR_UNKNOWN, false, "failed to change stageRun.magicked for magic_ds_id: %" PRId64,
     977                        magic_ds_id);
     978                    if (!psDBRollback(config->dbh)) {
     979                        psError(PS_ERR_UNKNOWN, false, "database error");
     980                    }
     981                    return false;
     982                }
     983            } else {
     984                fprintf(stderr, "run is already marked as destreaked for magic_ds_id %" PRId64 "\n", magic_ds_id);
    968985            }
    969             return false;
    970986        }
    971987
    … …  
    980996            return false;
    981997        }
    982     }
    983     if (!psDBCommit(config->dbh)) {
    984         psError(PS_ERR_UNKNOWN, false, "database error");
    985         return false;
     998        if (!psDBCommit(config->dbh)) {
     999            psError(PS_ERR_UNKNOWN, false, "database error");
     1000            return false;
     1001        }
    9861002    }
    9871003

  • branches/eam_branches/ipp-20100823/ippTools/src/magictool.c

    r28768 r29515  
    5050static bool exposureMode(pxConfig *config);
    5151
    52 static bool setmagicRunState(pxConfig *config, psS64 magic_id, const char *state);
     52static bool setmagicRunState(pxConfig *config, psS64 magic_id, const char *state, psString setString);
    5353static bool parseAndInsertNodeDeps(pxConfig *config, psS64 magic_id, const char *filename);
    5454
    … …  
    131131
    132132    psMetadata *queryWhere = psMetadataAlloc(); // WHERE conditions for everything else
    133     PXOPT_COPY_S64(config->args, queryWhere, "-exp_id", "exp_id", "==");
     133    PXOPT_COPY_S64(config->args, queryWhere, "-exp_id", "rawExp.exp_id", "==");
    134134    PXOPT_COPY_STR(config->args, queryWhere, "-select_filter", "rawExp.filter", "==");
    135135
    … …  
    394394    // required
    395395    PXOPT_LOOKUP_S64(magic_id, config->args, "-magic_id", true, false);
    396     PXOPT_LOOKUP_STR(state, config->args, "-state", true, false);
     396    PXOPT_LOOKUP_STR(state, config->args, "-set_state", true, false);
     397    PXOPT_LOOKUP_S16(fault, config->args, "-set_fault", false, false);
     398    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
     399    PXOPT_LOOKUP_BOOL(clearfault, config->args, "-clearfault", false);
     400
     401    psString setString = NULL;
     402    if (fault || clearfault) {
     403        psStringAppend(&setString, ", fault = %d", fault);
     404    }
     405    if (note) {
     406        psStringAppend(&setString, ", note = '%s'", note);
     407    }
    397408
    398409    if (state) {
    399410        // set detRun.state to state
    400         return setmagicRunState(config, magic_id, state);
     411        return setmagicRunState(config, magic_id, state, setString);
    401412    }
    402413
    … …  
    612623    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
    613624
    614     psString query = psStringCopy("UPDATE magicRun SET fault = 0, state = 'new' WHERE fault != 0");
     625    psString query = psStringCopy("UPDATE magicRun SET fault = 0 WHERE state = 'new' AND fault != 0");
    615626
    616627    if (psListLength(where->list)) {
    … …  
    11711182
    11721183    // optional
    1173     PXOPT_LOOKUP_STR(uri, config->args, "-uri", false, false);
     1184//    PXOPT_LOOKUP_STR(uri, config->args, "-uri", false, false);
     1185    PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", true, false);
    11741186    PXOPT_LOOKUP_S32(streaks, config->args, "-streaks", false, false);
    11751187
    … …  
    11841196    if (!magicMaskInsert(config->dbh,
    11851197                         magic_id,
    1186                          uri,
     1198                         NULL,
     1199                         path_base,
    11871200                         streaks,
    11881201                         fault
    … …  
    13641377}
    13651378
    1366 static bool setmagicRunState(pxConfig *config, psS64 magic_id, const char *state)
     1379static bool setmagicRunState(pxConfig *config, psS64 magic_id, const char *state, psString setString)
    13671380{
    13681381    PS_ASSERT_PTR_NON_NULL(state, false);
    … …  
    13801393        return false;
    13811394    }
    1382 
    1383     char *query = "UPDATE magicRun SET state = '%s' WHERE magic_id = %" PRId64;
    1384     if (!p_psDBRunQueryF(config->dbh, query, state, magic_id)) {
     1395    psString query = NULL;
     1396    psStringAppend(&query, "UPDATE magicRun SET state = '%s'", state);
     1397    if (setString) {
     1398        psStringAppend(&query, setString);
     1399    }
     1400    psStringAppend(&query, " WHERE magic_id = %" PRId64, magic_id);;
     1401
     1402//    char *query = "UPDATE magicRun SET state = '%s' WHERE magic_id = %" PRId64;
     1403    if (!p_psDBRunQuery(config->dbh, query)) {
    13851404        psError(PS_ERR_UNKNOWN, false,
    13861405                "failed to change state for magic_id %" PRId64, magic_id);

  • branches/eam_branches/ipp-20100823/ippTools/src/magictoolConfig.c

    r28039 r29515  
    7979    psMetadata *updaterunArgs = psMetadataAlloc();
    8080    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-magic_id", 0, "define magictool ID (required)", 0);
    81     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0, "set state (required)", NULL);
     81    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state", 0, "set state (required)", NULL);
     82    psMetadataAddS16(updaterunArgs, PS_LIST_TAIL, "-set_fault", 0, "set fault code", 0);
     83    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_note",  0, "define note", NULL);
     84    psMetadataAddBool(updaterunArgs, PS_LIST_TAIL, "-clearfault",  0, "set fault to zero", NULL);
    8285
    8386    // -addinputskyfile
    … …  
    149152    psMetadata *addmaskArgs = psMetadataAlloc();
    150153    psMetadataAddS64(addmaskArgs, PS_LIST_TAIL, "-magic_id", 0, "define magictool ID (required)", 0);
    151     psMetadataAddStr(addmaskArgs, PS_LIST_TAIL, "-uri", 0, "define URI", NULL);
     154    psMetadataAddStr(addmaskArgs, PS_LIST_TAIL, "-path_base", 0, "define path_base (required)", NULL);
    152155    psMetadataAddS32(addmaskArgs, PS_LIST_TAIL, "-streaks", 0, "define number of streaks", 0);
    153156    psMetadataAddS16(addmaskArgs, PS_LIST_TAIL, "-fault", 0, "set fault code", 0);

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

    r28937 r29515  
    4646static bool pendingjobMode(pxConfig *config);
    4747static bool updatejobMode(pxConfig *config);
     48static bool stopdependentjobMode(pxConfig *config);
    4849static bool revertjobMode(pxConfig *config);
    4950static bool addprojectMode(pxConfig *config);
    … …  
    6364    break;
    6465
     66// XXX make this a configurable parameter
     67#define PSTAMP_MAX_JOB_FAULTS 5
     68#define PSTAMP_MAX_DEP_FAULTS 5
    6569
    6670int main(int argc, char **argv)
    … …  
    8993        MODECASE(PSTAMPTOOL_MODE_PENDINGJOB, pendingjobMode);
    9094        MODECASE(PSTAMPTOOL_MODE_UPDATEJOB, updatejobMode);
     95        MODECASE(PSTAMPTOOL_MODE_STOPDEPENDENTJOB, stopdependentjobMode);
    9196        MODECASE(PSTAMPTOOL_MODE_REVERTJOB, revertjobMode);
    9297        MODECASE(PSTAMPTOOL_MODE_ADDPROJECT, addprojectMode);
    … …  
    715720            outputBase,
    716721            options,
    717             dep_id
     722            dep_id,
     723            0   // fault_count
    718724            )) {
    719725        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    877883    PXOPT_LOOKUP_S64(req_id,    config->args, "-req_id", false, false);
    878884    PXOPT_LOOKUP_S64(dep_id,    config->args, "-dep_id", false, false);
    879 
    880     if (!job_id && !req_id && !dep_id) {
    881         psError(PS_ERR_UNKNOWN, true, "at least one of -job_id -req_id or -dep_id is required");
     885    PXOPT_LOOKUP_S32(fault_count, config->args, "-fault_count",  false, false);
     886
     887    if (!job_id && !req_id && !dep_id && !fault_count) {
     888        psError(PS_ERR_UNKNOWN, true, "at least one of -job_id -req_id -dep_id or -fault_count is required");
    882889        return false;
    883890    }
    … …  
    898905    PXOPT_COPY_S32(config->args, where, "-fault",  "pstampJob.fault", "==");
    899906    PXOPT_COPY_STR(config->args, where, "-state",  "pstampJob.state", "==");
     907    PXOPT_COPY_S32(config->args, where, "-fault_count", "pstampJob.fault_count", ">=");
     908    pxAddLabelSearchArgs(config, where, "-label", "pstampRequest.label", "LIKE");
    900909
    901910    psString query = pxDataGet("pstamptool_updatejob.sql");
    … …  
    909918        psStringAppend(&query, "\n %c pstampJob.fault = %d", c, fault);
    910919        c = ',';
     920        psStringAppend(&query, ", pstampJob.fault_count = pstampJob.fault_count+ 1");
    911921    }
    912922   
    … …  
    925935    psU64 affected = psDBAffectedRows(config->dbh);
    926936    psLogMsg("pstamptool", PS_LOG_INFO, "Updated %" PRIu64 " pstampJobs", affected);
     937
     938    return true;
     939}
     940// Terminate jobs which have dependents setting both the pstampDependent and pstampJob.fault
     941static bool stopdependentjobMode(pxConfig *config)
     942{
     943    PS_ASSERT_PTR_NON_NULL(config, false);
     944
     945    PXOPT_LOOKUP_S32(fault,  config->args, "-set_fault",  true, false);
     946
     947    psMetadata *where = psMetadataAlloc();
     948
     949    PXOPT_COPY_S64(config->args, where, "-req_id", "req_id", "==");
     950    PXOPT_COPY_S64(config->args, where, "-job_id", "job_id", "==");
     951    PXOPT_COPY_S64(config->args, where, "-dep_id", "dep_id", "==");
     952    PXOPT_COPY_S32(config->args, where, "-fault",  "pstampDependent.fault", "==");
     953    pxAddLabelSearchArgs(config, where, "-label", "pstampRequest.label", "LIKE");
     954    // if (fault_count) {
     955        PXOPT_COPY_S32(config->args, where, "-fault_count", "pstampDependent.fault_count", ">=");
     956    // }
     957
     958    // XXX: How about selecting by pstampRequest.label? No. That is too dangerous by itself.
     959
     960    psString query = pxDataGet("pstamptool_stopdependentjob.sql");
     961
     962    if (psListLength(where->list)) {
     963        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     964        psStringAppend(&query, " AND %s", whereClause);
     965        psFree(whereClause);
     966    } else {
     967        psFree(where);
     968        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     969        return false;
     970    }
     971    psFree(where);
     972
     973    if (!p_psDBRunQueryF(config->dbh, query, fault, fault)) {
     974        psError(PS_ERR_UNKNOWN, false, "database error");
     975        psFree(query);
     976        return false;
     977    }
     978    psFree(query);
     979
     980    psU64 affected = psDBAffectedRows(config->dbh);
     981    psLogMsg("pstamptool", PS_LOG_INFO, "Updated %" PRIu64 " pstampJobs and pstampDependents", affected);
    927982
    928983    return true;
    … …  
    941996    pxAddLabelSearchArgs(config, where, "-label", "pstampRequest.label", "LIKE");
    942997
     998    PXOPT_LOOKUP_BOOL(clear_fault_count, config->args, "-clear_fault_count", false);
     999
    9431000    PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
     1001
     1002    // XXX: we don't actually use -limit. It doesn't work for UPDATE
     1003    // it's an allowed arg because add_poll_args adds it
    9441004    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    9451005    PXOPT_LOOKUP_S16(fault, config->args, "-fault",  false, false);
    … …  
    9471007    // By default only revert faults < PSTAMP_FIRST_ERROR_CODE which are our "ipp exit codes"
    9481008    // codes larger than that are the pstamp request interface.
    949     // Don't fault those unless -fault waa provided
     1009    // Don't fault those unless -fault was explicitly provided
    9501010    psString faultClause = psStringCopy("");
    9511011    if (!fault) {
    … …  
    9661026    psFree(where);
    9671027
    968     if (!p_psDBRunQueryF(config->dbh, query, faultClause)) {
     1028    // don't keep reverting once the number of faults reaches some value unless
     1029    // a parameter asking us to clear that count is provided
     1030    psString faultCountClause = NULL;
     1031    if (clear_fault_count) {
     1032        psStringAppend(&faultCountClause, "\n, pstampJob.fault_count = 0");
     1033    } else {
     1034        psStringAppend(&query, " AND pstampJob.fault_count < %d", PSTAMP_MAX_JOB_FAULTS);
     1035    }
     1036
     1037    if (!p_psDBRunQueryF(config->dbh, query, faultCountClause, faultClause)) {
     1038        psFree(faultCountClause);
    9691039        psFree(faultClause);
    9701040        psFree(query);
    … …  
    9741044
    9751045    psFree(faultClause);
     1046    psFree(faultCountClause);
     1047    psFree(query);
    9761048
    9771049    return true;
    … …  
    11781250        need_magic,
    11791251        outdir,
    1180         0               // fault
     1252        0,              // fault
     1253        0               // fault_count
    11811254        )) {
    11821255        if (!psDBRollback(config->dbh)) {
    … …  
    13001373        psStringAppend(&query, "%s fault = %d", needComma ? ", " : "", fault);
    13011374        needComma = true;
     1375        psStringAppend(&query, ", pstampDependent.fault_count = pstampDependent.fault_count + 1");
    13021376    }
    13031377    psStringAppend(&query, " WHERE dep_id = %" PRId64, dep_id);
    … …  
    13251399    PXOPT_COPY_S64(config->args, where, "-fault", "pstampDependent.fault", "==");
    13261400    PXOPT_COPY_S64(config->args, where, "-dep_id", "dep_id", "==");
     1401    PXOPT_COPY_S64(config->args, where, "-job_id", "job_id", "==");
     1402    PXOPT_COPY_S64(config->args, where, "-req_id", "req_id", "==");
    13271403    pxAddLabelSearchArgs(config, where, "-label", "pstampRequest.label", "==");
     1404    PXOPT_LOOKUP_BOOL(clear_fault_count, config->args, "-clear_fault_count", false);
     1405
     1406    // XXX: we don't actually use -limit. It doesn't work for UPDATE
     1407    // it's an allowed arg because add_poll_args adds it
     1408    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    13281409
    13291410    if (!psListLength(where->list)) {
    … …  
    13521433    }
    13531434
    1354     if (!p_psDBRunQuery(config->dbh, query)) {
     1435    // don't keep reverting once the number of faults reaches some value unless
     1436    // a parameter asking us to clear that count is provided
     1437    psString faultCountClause = NULL;
     1438    if (clear_fault_count) {
     1439        psStringAppend(&faultCountClause, "\n, pstampDependent.fault_count = 0");
     1440    } else {
     1441        psStringAppend(&faultCountClause, " ");
     1442        psStringAppend(&query, " AND pstampDependent.fault_count < %d", PSTAMP_MAX_DEP_FAULTS);
     1443    }
     1444
     1445    if (!p_psDBRunQueryF(config->dbh, query, faultCountClause)) {
    13551446        psError(PS_ERR_UNKNOWN, false, "database error");
    13561447        psFree(query);

  • branches/eam_branches/ipp-20100823/ippTools/src/pstamptool.h

    r28183 r29515  
    3838    PSTAMPTOOL_MODE_LISTJOB,
    3939    PSTAMPTOOL_MODE_PENDINGJOB,
     40    PSTAMPTOOL_MODE_STOPDEPENDENTJOB,
    4041    PSTAMPTOOL_MODE_JOBRESULT,
    4142    PSTAMPTOOL_MODE_UPDATEJOB,

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

    r28937 r29515  
    167167    psMetadataAddStr(updatejobArgs, PS_LIST_TAIL, "-state", 0,             "current state of jobs to update", 0);
    168168    psMetadataAddS16(updatejobArgs, PS_LIST_TAIL, "-fault", 0,             "current value for job fault", 0);
     169    psMetadataAddStr(updatejobArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by pstampJob label (LIKE comparision)", NULL);
     170    psMetadataAddS32(updatejobArgs, PS_LIST_TAIL, "-fault_count", 0,       "select by fault_count (>=)", 0);
    169171    psMetadataAddStr(updatejobArgs, PS_LIST_TAIL, "-set_state", 0,            "new state", NULL);
    170172    psMetadataAddS16(updatejobArgs, PS_LIST_TAIL, "-set_fault", 0,            "new result", 0);
     173    psMetadataAddU64(updatejobArgs, PS_LIST_TAIL, "-limit", 0,      "not used", 0);
     174
     175    // -stopdependentjob
     176    psMetadata *stopdependentjobArgs = psMetadataAlloc();
     177    psMetadataAddS64(stopdependentjobArgs, PS_LIST_TAIL,  "-req_id", 0,       "req_id of jobs to update", 0);
     178    psMetadataAddS64(stopdependentjobArgs, PS_LIST_TAIL,  "-job_id", 0,       "job_id of jobs to update", 0);
     179    psMetadataAddS64(stopdependentjobArgs, PS_LIST_TAIL,  "-dep_id", 0,       "dep_id of jobs to update", 0);
     180    psMetadataAddS16(stopdependentjobArgs, PS_LIST_TAIL,  "-fault", 0,        "current value for dependent fault", 0);
     181    psMetadataAddS32(stopdependentjobArgs, PS_LIST_TAIL,  "-fault_count", 0,   "select by fault_count (>=)", 0);
     182    psMetadataAddS16(stopdependentjobArgs, PS_LIST_TAIL,  "-set_fault", 0,    "new fault value for job and dependent (required)", 0);
     183    psMetadataAddStr(stopdependentjobArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by pstampJob label (LIKE comparision)", NULL);
     184    psMetadataAddU64(stopdependentjobArgs, PS_LIST_TAIL, "-limit", 0,      "not used", 0);
    171185
    172186    // -revertjob
    … …  
    177191    psMetadataAddS16(revertjobArgs, PS_LIST_TAIL, "-fault",  0,     "fault to revert", 0);
    178192    psMetadataAddStr(revertjobArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by pstampRequest label (LIKE comparision)", NULL);
     193    psMetadataAddBool(revertjobArgs, PS_LIST_TAIL, "-clear_fault_count", 0,       "clear job fault count", false);
    179194    psMetadataAddBool(revertjobArgs, PS_LIST_TAIL, "-all", 0,       "revert all faulted jobs", false);
    180     psMetadataAddU64(revertjobArgs, PS_LIST_TAIL, "-limit", 0,      "limit result set to N items", 0);
     195    psMetadataAddU64(revertjobArgs, PS_LIST_TAIL, "-limit", 0,      "not used", 0);
    181196
    182197    // -getdependent
    … …  
    201216    // -revertdependent
    202217    psMetadata *revertdependentArgs = psMetadataAlloc();
    203     psMetadataAddS64(revertdependentArgs, PS_LIST_TAIL, "-dep_id", 0, "define id for dependent", 0);
     218    psMetadataAddS64(revertdependentArgs, PS_LIST_TAIL, "-dep_id", 0, "search by dep_id for dependent", 0);
     219    psMetadataAddS64(revertdependentArgs, PS_LIST_TAIL, "-job_id", 0, "search by job_ idfor dependent", 0);
     220    psMetadataAddS64(revertdependentArgs, PS_LIST_TAIL, "-req_id", 0, "search by req_id for dependent", 0);
    204221    psMetadataAddStr(revertdependentArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK,   "define label for dependent ", NULL);
    205     psMetadataAddS16(revertdependentArgs, PS_LIST_TAIL, "-fault",  0,   "define fault", 0);
     222    psMetadataAddS16(revertdependentArgs, PS_LIST_TAIL, "-fault",  0, "search by dependent fault", 0);
     223    psMetadataAddBool(revertdependentArgs, PS_LIST_TAIL, "-clear_fault_count", 0,       "clear job fault count", false);
     224    psMetadataAddU64(revertdependentArgs, PS_LIST_TAIL, "-limit", 0,  "limit result set to N items", 0);
    206225
    207226    // -pendingdependent
    … …  
    262281    PXOPT_ADD_MODE("-pendingjob",      "", PSTAMPTOOL_MODE_PENDINGJOB,   pendingjobArgs);
    263282    PXOPT_ADD_MODE("-updatejob",       "", PSTAMPTOOL_MODE_UPDATEJOB,    updatejobArgs);
     283    PXOPT_ADD_MODE("-stopdependentjob", "", PSTAMPTOOL_MODE_STOPDEPENDENTJOB,  stopdependentjobArgs);
    264284    PXOPT_ADD_MODE("-revertjob",       "", PSTAMPTOOL_MODE_REVERTJOB,    revertjobArgs);
    265285

  • branches/eam_branches/ipp-20100823/ippTools/src/pubtool.c

    r28494 r29515  
    340340    }
    341341
    342     if (!p_psDBRunQueryF(config->dbh, query, whereClause, whereClause)) {
     342    if (!p_psDBRunQueryF(config->dbh, query, whereClause, whereClause, whereClause)) {
    343343        psError(PS_ERR_UNKNOWN, false, "Database error");
    344344        psFree(whereClause);

  • branches/eam_branches/ipp-20100823/ippTools/src/stacktool.c

    r28681 r29515  
    901901    psFree(where);
    902902
     903    psStringAppend(&query, "\nORDER by priority DESC, stack_id");
     904
    903905    // treat limit == 0 as "no limit"
    904906    if (limit) {
    … …  
    982984    PXOPT_LOOKUP_STR(hostname, config->args, "-hostname", false, false);
    983985    PXOPT_LOOKUP_F32(good_frac, config->args, "-good_frac", false, false);
     986    PXOPT_LOOKUP_F64(mjd_obs, config->args, "-mjd_obs", false, false);
    984987
    985988    PXOPT_LOOKUP_STR(ver_pslib, config->args, "-ver_pslib", false, false);
    … …  
    10471050                               hostname,
    10481051                               good_frac,
     1052                               mjd_obs,
    10491053                               fault,
    10501054                               software_ver,
    … …  
    10941098    psMetadata *where = psMetadataAlloc();
    10951099    PXOPT_COPY_S64(config->args, where, "-stack_id", "stackSumSkyfile.stack_id", "==");
    1096     PXOPT_COPY_STR(config->args, where, "-tess_id", "stackRun.tess_id", "==");
     1100    PXOPT_COPY_STR(config->args, where, "-tess_id", "stackRun.tess_id", "LIKE");
    10971101    PXOPT_COPY_STR(config->args, where, "-skycell_id", "stackRun.skycell_id", "==");
    10981102    PXOPT_COPY_STR(config->args, where, "-filter", "stackRun.filter", "LIKE");
    … …  
    11001104    PXOPT_COPY_STR(config->args, where, "-data_group", "stackRun.data_group", "LIKE");
    11011105    PXOPT_COPY_S16(config->args, where, "-fault", "stackSumSkyfile.fault", "==");
     1106    PXOPT_COPY_F64(config->args, where, "-mjd_obs_begin", "stackSumSkyfile.mjd_obs", ">=");
     1107    PXOPT_COPY_F64(config->args, where, "-mjd_obs_end", "stackSumSkyfile.mjd_obs", "<=");
     1108
    11021109
    11031110//  The following three selectors are incompatible with the sql so omit them

  • branches/eam_branches/ipp-20100823/ippTools/src/stacktoolConfig.c

    r28681 r29515  
    172172    psMetadataAddStr(addsumskyfileArgs, PS_LIST_TAIL, "-hostname", 0,            "define hostname", 0);
    173173    psMetadataAddF32(addsumskyfileArgs, PS_LIST_TAIL, "-good_frac",  0,            "define %% of good pixels", NAN);
     174    psMetadataAddF64(addsumskyfileArgs, PS_LIST_TAIL, "-mjd_obs",  0,            "define mjd_obs (average mjd_obs of inputs)", NAN);
    174175    psMetadataAddS16(addsumskyfileArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code", 0);
    175176    psMetadataAddS16(addsumskyfileArgs, PS_LIST_TAIL, "-quality",  0,            "set quality", 0);
    … …  
    185186    psMetadata *sumskyfileArgs= psMetadataAlloc();
    186187    psMetadataAddS64(sumskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,            "search by stack ID", 0);
    187     psMetadataAddStr(sumskyfileArgs, PS_LIST_TAIL, "-tess_id", 0,            "search by tess ID", 0);
     188    psMetadataAddStr(sumskyfileArgs, PS_LIST_TAIL, "-tess_id", 0,            "search by tess ID (LIKE comparison)", 0);
    188189    psMetadataAddStr(sumskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0,         "search by skycell ID", 0);
    189190#ifdef notdef
    … …  
    196197    psMetadataAddStr(sumskyfileArgs, PS_LIST_TAIL, "-data_group", 0,        "search by stackRun.data_group (LIKE comparison)", NULL);
    197198    psMetadataAddStr(sumskyfileArgs, PS_LIST_TAIL, "-filter", 0,            "search by filter (LIKE comparison)", NULL);
     199    psMetadataAddF64(sumskyfileArgs, PS_LIST_TAIL, "-mjd_obs_begin",  0,      "search by mjd_obs (average mjd_obs of inputs <=)", NAN);
     200    psMetadataAddF64(sumskyfileArgs, PS_LIST_TAIL, "-mjd_obs_end",  0,      "search by mjd_obs (average mjd_obs of inputs>=)", NAN);
    198201    psMetadataAddS16(sumskyfileArgs, PS_LIST_TAIL, "-fault",  0,            "search by fault code", 0);
    199202    psMetadataAddU64(sumskyfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    … …  
    204207    psMetadata *sassskyfileArgs = psMetadataAlloc();
    205208    psMetadataAddS64(sassskyfileArgs, PS_LIST_TAIL, "-sass_id", 0,           "search by stack association ID", 0);
    206     psMetadataAddStr(sassskyfileArgs, PS_LIST_TAIL, "-tess_id", 0,            "search by tess ID", 0);
     209    psMetadataAddStr(sassskyfileArgs, PS_LIST_TAIL, "-tess_id", 0,            "search by tess ID (LIKE comparison)", 0);
    207210    psMetadataAddStr(sassskyfileArgs, PS_LIST_TAIL, "-projection_cell", 0,         "search by projection cell", 0);
    208211

  • branches/eam_branches/ipp-20100823/ippTools/src/warptool.c

    r28375 r29515  
    5252static bool pendingcleanuprunMode(pxConfig *config);
    5353static bool pendingcleanupwarpMode(pxConfig *config);
     54static bool revertcleanupMode(pxConfig *config);
    5455static bool donecleanupMode(pxConfig *config);
    5556static bool tocleanedskyfileMode(pxConfig *config);
    … …  
    107108        MODECASE(WARPTOOL_MODE_PENDINGCLEANUPRUN,  pendingcleanuprunMode);
    108109        MODECASE(WARPTOOL_MODE_PENDINGCLEANUPSKYFILE, pendingcleanupwarpMode);
     110        MODECASE(WARPTOOL_MODE_REVERTCLEANUP,      revertcleanupMode);
    109111        MODECASE(WARPTOOL_MODE_DONECLEANUP,        donecleanupMode);
    110112        MODECASE(WARPTOOL_MODE_TOCLEANEDSKYFILE,   tocleanedskyfileMode);
    … …  
    18051807
    18061808
     1809static bool revertcleanupMode(pxConfig *config)
     1810{
     1811    PS_ASSERT_PTR_NON_NULL(config, false);
     1812
     1813    psMetadata *where = psMetadataAlloc();
     1814    PXOPT_COPY_S64(config->args, where, "-warp_id",    "warpSkyfile.warp_id", "==");
     1815    pxAddLabelSearchArgs (config, where, "-label",     "warpRun.label", "LIKE");
     1816    pxAddLabelSearchArgs (config, where, "-data_group",   "warpRun.data_group", "LIKE");
     1817
     1818    PXOPT_LOOKUP_STR(state, config->args, "-state", false, false);
     1819
     1820    if (!psListLength(where->list)) {
     1821        psFree(where);
     1822        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     1823        return false;
     1824    }
     1825    if (!state) {
     1826        state = "error_cleaned";
     1827    }
     1828    char *newState = NULL;
     1829    if (!strcmp(state, "error_cleaned")) {
     1830        newState = "goto_cleaned";
     1831    } else if (!strcmp(state, "error_purged")) {
     1832        newState = "goto_purged";
     1833    } else if (!strcmp(state, "error_scrubbed")) {
     1834        newState = "goto_scrubbed";
     1835    } else {
     1836        psError(PXTOOLS_ERR_CONFIG, true, "-state must be either error_cleaned, error_purged, or error_scrubbed");
     1837        return false;
     1838    }
     1839
     1840    psString query = pxDataGet("warptool_revertcleanup.sql");
     1841    if (!query) {
     1842        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1843        return false;
     1844    }
     1845
     1846    if (psListLength(where->list)) {
     1847        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1848        psStringAppend(&query, " AND %s", whereClause);
     1849        psFree(whereClause);
     1850    }
     1851    psFree(where);
     1852
     1853    if (!p_psDBRunQueryF(config->dbh, query, newState, state, state)) {
     1854        psError(PS_ERR_UNKNOWN, false, "database error");
     1855        psFree(query);
     1856        return false;
     1857    }
     1858    psFree(query);
     1859
     1860    int numDeleted = psDBAffectedRows(config->dbh);
     1861
     1862    psLogMsg("warptool", PS_LOG_INFO, "Reverted %d warpRuns and warpSkyfiles", numDeleted);
     1863
     1864    return true;
     1865}
    18071866static bool donecleanupMode(pxConfig *config)
    18081867{

  • branches/eam_branches/ipp-20100823/ippTools/src/warptool.h

    r28375 r29515  
    4848    WARPTOOL_MODE_PENDINGCLEANUPRUN,
    4949    WARPTOOL_MODE_PENDINGCLEANUPSKYFILE,
     50    WARPTOOL_MODE_REVERTCLEANUP,
    5051    WARPTOOL_MODE_DONECLEANUP,
    5152    WARPTOOL_MODE_TOCLEANEDSKYFILE,

  • branches/eam_branches/ipp-20100823/ippTools/src/warptoolConfig.c

    r28375 r29515  
    362362    psMetadataAddU64(pendingcleanupskyfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    363363
     364    // -revertcleanup
     365    psMetadata *revertcleanupArgs = psMetadataAlloc();
     366    psMetadataAddS64(revertcleanupArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warptool ID", 0);
     367    psMetadataAddStr(revertcleanupArgs, PS_LIST_TAIL, "-label",  PS_META_DUPLICATE_OK, "search by warpRun label", NULL);
     368    psMetadataAddStr(revertcleanupArgs, PS_LIST_TAIL, "-data_group",  PS_META_DUPLICATE_OK, "search by warpRun data_group", NULL);
     369    psMetadataAddStr(revertcleanupArgs, PS_LIST_TAIL, "-state",  0,            "search by state", NULL);
     370
    364371    // -donecleanup
    365372    psMetadata *donecleanupArgs = psMetadataAlloc();
    … …  
    451458    PXOPT_ADD_MODE("-pendingcleanuprun",     "show runs that need to be cleaned up", WARPTOOL_MODE_PENDINGCLEANUPRUN,    pendingcleanuprunArgs);
    452459    PXOPT_ADD_MODE("-pendingcleanupskyfile", "show runs that need to be cleaned up", WARPTOOL_MODE_PENDINGCLEANUPSKYFILE, pendingcleanupskyfileArgs);
     460    PXOPT_ADD_MODE("-revertcleanup",         "revert cleanup runs with errors",     WARPTOOL_MODE_REVERTCLEANUP,          revertcleanupArgs);
    453461    PXOPT_ADD_MODE("-donecleanup",           "show runs that have been cleaned",     WARPTOOL_MODE_DONECLEANUP,          donecleanupArgs);
    454462    PXOPT_ADD_MODE("-tocleanedskyfile", "set skyfile as cleaned", WARPTOOL_MODE_TOCLEANEDSKYFILE, tocleanedskyfileArgs);
Note: See TracChangeset for help on using the changeset viewer.