IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Oct 18, 2009, 10:23:28 AM (17 years ago)
Author:
eugene
Message:

updated vysos branch from trunk

Location:
branches/eam_branches/20090820
Files:
49 edited
2 copied

Legend:

Unmodified
Added
Removed

  • branches/eam_branches/20090820

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

    r25766 r25870  
    3434        pxmagic.h \
    3535        pxregister.h \
     36        pxspace.h \
    3637        pxtag.h \
    3738        pxtools.h \
    … …  
    7879        pxmagic.c \
    7980        pxregister.c \
     81        pxspace.c \
    8082        pxtag.c \
    8183        pxtools.c \

  • branches/eam_branches/20090820/ippTools/src/addtool.c

    r25766 r25870  
    4040static bool maskedMode(pxConfig *config);
    4141static bool unblockMode(pxConfig *config);
    42 static bool pendingcleanuprunMode(pxConfig *config);
    43 static bool pendingcleanupexpMode(pxConfig *config);
    44 static bool donecleanupMode(pxConfig *config);
    45 static bool exportrunMode(pxConfig *config);
    46 static bool importrunMode(pxConfig *config);
    4742
    4843# define MODECASE(caseName, func) \
    … …  
    7469        MODECASE(ADDTOOL_MODE_MASKED,               maskedMode);
    7570        MODECASE(ADDTOOL_MODE_UNBLOCK,              unblockMode);
    76         MODECASE(ADDTOOL_MODE_PENDINGCLEANUPRUN,    pendingcleanuprunMode);
    77         MODECASE(ADDTOOL_MODE_PENDINGCLEANUPEXP,    pendingcleanupexpMode);
    78         MODECASE(ADDTOOL_MODE_DONECLEANUP,          donecleanupMode);
    79         MODECASE(ADDTOOL_MODE_EXPORTRUN,            exportrunMode);
    80         MODECASE(ADDTOOL_MODE_IMPORTRUN,            importrunMode);
    8171        default:
    8272            psAbort("invalid option (this should not happen)");
    … …  
    10696
    10797    psMetadata *where = psMetadataAlloc();
    108     pxaddGetSearchArgs (config, where);
    109     pxAddLabelSearchArgs (config, where, "-label", "addRun.label", "==");
    110     PXOPT_COPY_STR(config->args, where, "-reduction", "addRun.reduction", "==");
     98    pxcamGetSearchArgs (config, where);
     99    PXOPT_COPY_S64(config->args, where,  "-cam_id",    "camRun.cam_id", "==");
     100    pxAddLabelSearchArgs (config, where, "-label",     "camRun.label", "==");
     101    PXOPT_COPY_STR(config->args, where,  "-reduction", "camRun.reduction", "==");
    111102
    112103    if (!psListLength(where->list) &&
    … …  
    117108    }
    118109
    119     PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", false, false);
    120     PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
    121     PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false);
    122     PXOPT_LOOKUP_STR(dvodb, config->args, "-set_dvodb", false, false);
     110    PXOPT_LOOKUP_STR(workdir,     config->args, "-set_workdir", false, false);
     111    PXOPT_LOOKUP_STR(dvodb,       config->args, "-set_dvodb", false, false);
     112    PXOPT_LOOKUP_STR(label,       config->args, "-set_label", false, false);
     113    PXOPT_LOOKUP_STR(data_group,  config->args, "-set_data_group", false, false);
     114    PXOPT_LOOKUP_STR(reduction,   config->args, "-set_reduction", false, false);
     115    PXOPT_LOOKUP_STR(note,        config->args, "-set_note", false, false);
     116    PXOPT_LOOKUP_BOOL(image_only, config->args, "-image_only", false);
     117    PXOPT_LOOKUP_BOOL(pretend,    config->args, "-pretend", false);
     118    PXOPT_LOOKUP_BOOL(simple,     config->args, "-simple", false);
    123119
    124120    // find the cam_id of all the exposures that we want to queue up.
    … …  
    130126    }
    131127
    132     // use psDBGenerateWhereSQL because the SQL yields an intermediate table
     128    // use psDBGenerateWhereConditionSQL because the SQL ends in a WHERE
    133129    if (where && psListLength(where->list)) {
    134130        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    … …  
    136132        psFree(whereClause);
    137133    }
    138 
    139134    psFree(where);
    140135
    … …  
    155150        psFree(output);
    156151        return true;
     152    }
     153
     154    if (pretend) {
     155        // negative simple so the default is true
     156        if (!ippdbPrintMetadatas(stdout, output, "addRun", !simple)) {
     157            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     158            psFree(output);
     159            return false;
     160        }
     161        psFree(output);
     162        return true;
     163    }
     164
     165    // loop over our list of camRun rows to check the supplied and selected dvodb and workdir values:
     166    for (long i = 0; i < psArrayLength(output); i++) {
     167        psMetadata *md = output->data[i];
     168
     169        camRunRow *row = camRunObjectFromMetadata(md);
     170        if (!row) {
     171            psError(PS_ERR_UNKNOWN, false, "failed to convert metadata into camRun");
     172            psFree(output);
     173            return false;
     174        }
     175
     176        if (!dvodb && !row->dvodb) {
     177            psError(PS_ERR_UNKNOWN, false, "cannot queue addstar run without a defined dvodb: label: %s, cam_id %" PRId64, row->label, row->cam_id);
     178            psFree(output);
     179            return false;
     180        }
     181        if (!workdir && !row->workdir) {
     182            psError(PS_ERR_UNKNOWN, false, "cannot queue addstar run without a defined workdir: label: %s, cam_id %" PRId64, row->label, row->cam_id);
     183            psFree(output);
     184            return false;
     185        }
     186
     187        psFree(row);
    157188    }
    158189
    … …  
    170201    // old values in place (i.e., passing the values through).
    171202
    172 
    173     // loop over our list of addRun rows
     203    // loop over our list of camRun rows
    174204    for (long i = 0; i < psArrayLength(output); i++) {
    175205        psMetadata *md = output->data[i];
    176206
    177         addRunRow *row = addRunObjectFromMetadata(md);
     207        camRunRow *row = camRunObjectFromMetadata(md);
    178208        if (!row) {
    179             psError(PS_ERR_UNKNOWN, false, "failed to convert metadata into addRun");
     209            psError(PS_ERR_UNKNOWN, false, "failed to convert metadata into camRun");
    180210            psFree(output);
    181211            return false;
    … …  
    186216                               row->cam_id,
    187217                               workdir     ? workdir   : row->workdir,
     218                               reduction   ? reduction : row->reduction,
    188219                               label       ? label     : row->label,
    189                                "RECIPE",
    190                                dvodb       ? dvodb     : row->dvodb
    191                                
     220                               data_group  ? data_group : (label ? label : row->label),
     221                               dvodb       ? dvodb     : row->dvodb,
     222                               note        ? note      : NULL,
     223                               image_only
    192224        )) {
    193225            if (!psDBRollback(config->dbh)) {
    … …  
    218250
    219251    psMetadata *where = psMetadataAlloc();
    220     pxaddGetSearchArgs (config, where);
    221252    PXOPT_COPY_S64(config->args, where, "-add_id",    "addRun.add_id", "==");
     253    PXOPT_COPY_S64(config->args, where, "-cam_id",    "camRun.cam_id", "==");
     254    pxcamGetSearchArgs (config, where); // most search arguments based on camera
    222255    PXOPT_COPY_STR(config->args, where, "-label",     "addRun.label", "==");
    223256    PXOPT_COPY_STR(config->args, where, "-state",     "addRun.state", "==");
    224257    PXOPT_COPY_STR(config->args, where, "-reduction", "addRun.reduction", "==");
    225258
    226     if (!psListLength(where->list)
    227         && !psMetadataLookupBool(NULL, config->args, "-all")) {
     259    if (!psListLength(where->list)) {
    228260        psFree(where);
    229261        psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
    … …  
    231263    }
    232264
     265    psString query = psStringCopy("UPDATE addRun JOIN camRun USING(cam_id) JOIN chipRun USING(chip_id) JOIN rawExp USING(exp_id)");
     266
     267    // pxUpdateRun gets parameters from config->args and runs the update query
     268    bool result = pxUpdateRun(config, where, &query, "addRun", false);
     269
     270    psFree(query);
     271    psFree(where);
     272
     273    return result;
     274
     275
     276#ifdef notdef
    233277    PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
    234278    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
    … …  
    259303
    260304    return true;
     305#endif
    261306}
    262307
    … …  
    267312
    268313    psMetadata *where = psMetadataAlloc();
    269     pxaddGetSearchArgs (config, where);
    270314    PXOPT_COPY_S64(config->args, where, "-add_id",    "addRun.add_id", "==");
     315    PXOPT_COPY_S64(config->args, where, "-cam_id",    "camRun.cam_id", "==");
     316    pxcamGetSearchArgs (config, where);
    271317    pxAddLabelSearchArgs (config, where, "-label", "addRun.label", "==");
    272318    PXOPT_COPY_STR(config->args, where, "-reduction", "addRun.reduction", "==");
    273 
    274319    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    275320    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    325370}
    326371
    327 /* static bool pendingimfileMode(pxConfig *config) */
    328 /* { */
    329 /*     PS_ASSERT_PTR_NON_NULL(config, false); */
    330 
    331 /*     psMetadata *where = psMetadataAlloc(); */
    332 /*     pxaddGetSearchArgs (config, where); */
    333 /*     PXOPT_COPY_S64(config->args, where, "-add_id",    "addRun.add_id",                "=="); */
    334 /*     pxAddLabelSearchArgs (config, where, "-label",    "addRun.label",                 "=="); */
    335 /*     PXOPT_COPY_STR(config->args, where, "-reduction", "addRun.reduction",             "=="); */
    336 /*     PXOPT_COPY_S64(config->args, where, "-chip_id",   "addRun.chip_id",              "=="); */
    337 /*     PXOPT_COPY_STR(config->args, where, "-class_id",  "addProcessedExp.class_id", "=="); */
    338 
    339 /*     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false); */
    340 
    341 /*     psString query = pxDataGet("addtool_find_pendingimfile.sql"); */
    342 /*     if (!query) { */
    343 /*         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement"); */
    344 /*         return false; */
    345 /*     } */
    346 
    347 /*     // use psDBGenerateWhereSQL because the SQL yields an intermediate table */
    348 /*     if (psListLength(where->list)) { */
    349 /*         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL); */
    350 /*         psStringAppend(&query, " AND %s", whereClause); */
    351 /*         psFree(whereClause); */
    352 /*     } */
    353 /*     psFree(where); */
    354 
    355 /*     if (!p_psDBRunQuery(config->dbh, query)) { */
    356 /*         psError(PS_ERR_UNKNOWN, false, "database error"); */
    357 /*         psFree(query); */
    358 /*         return false; */
    359 /*     } */
    360 /*     psFree(query); */
    361 
    362 /*     psArray *output = p_psDBFetchResult(config->dbh); */
    363 /*     if (!output) { */
    364 /*         psError(PS_ERR_UNKNOWN, false, "database error"); */
    365 /*         return false; */
    366 /*     } */
    367 /*     if (!psArrayLength(output)) { */
    368 /*         psTrace("addtool", PS_LOG_INFO, "no rows found"); */
    369 /*         psFree(output); */
    370 /*         return true; */
    371 /*     } */
    372 
    373 /*     // negate simple so the default is true */
    374 /*     if (!ippdbPrintMetadatas(stdout, output, "addProcessedExp", !simple)) { */
    375 /*         psError(PS_ERR_UNKNOWN, false, "failed to print array"); */
    376 /*         psFree(output); */
    377 /*         return false; */
    378 /*     } */
    379 
    380 /*     psFree(output); */
    381 
    382 /*     return true; */
    383 /* } */
    384 
    385372static bool addprocessedexpMode(pxConfig *config)
    386373{
    … …  
    391378
    392379    // optional
    393     PXOPT_LOOKUP_F32(dtime_addstar, config->args,  "-dtime_addstar", false, false);
    394 
    395     PXOPT_LOOKUP_S32(n_stars, config->args,        "-n_stars", false, false);
    396 
    397     PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", false, false);
    398 
    399     PXOPT_LOOKUP_S64(magicked, config->args, "-magicked", false, false);
     380    PXOPT_LOOKUP_STR(path_base,     config->args, "-path_base", false, false);
     381    PXOPT_LOOKUP_F32(dtime_addstar, config->args, "-dtime_addstar", false, false);
     382    PXOPT_LOOKUP_S16(fault,         config->args, "-fault", false, false);
    400383
    401384    // generate restrictions
    … …  
    446429        pendingRow->add_id,
    447430        dtime_addstar,
    448         n_stars,
    449431        path_base,
    450         0
     432        fault
    451433        );
    452434
    … …  
    463445
    464446    // since there is only one exp per 'new' set addRun.state = 'full'
    465     if (!pxaddRunSetState(config, row->add_id, "full", magicked)) {
     447    if (!pxaddRunSetState(config, row->add_id, "full")) {
    466448        psError(PS_ERR_UNKNOWN, false, "failed to change addRun.state for add_id: %" PRId64, row->add_id);
    467449        psFree(row);
    … …  
    469451        return false;
    470452    }
    471 
    472     // NULL for end_stage means go as far as possible
    473     // EAM : skip here if fault != 0
    474     // Also, we can run fake even if tess_id is not defined
    475 /*     if (fault || (pendingRow->end_stage && psStrcasestr(pendingRow->end_stage, "add"))) { */
    476 /*         psFree(row); */
    477 /*         psFree(pendingRow); */
    478 /*         if (!psDBCommit(config->dbh)) { */
    479 /*             psError(PS_ERR_UNKNOWN, false, "database error"); */
    480 /*             return false; */
    481 /*         } */
    482 /*         return true; */
    483 /*     } */
    484453    psFree(row);
    485     // else continue on...
    486 
    487 /*     if (!pxfakeQueueByAddID(config, */
    488 /*             pendingRow->add_id, */
    489 /*             pendingRow->workdir, */
    490 /*             pendingRow->label, */
    491 /*             pendingRow->reduction, */
    492 /*             pendingRow->expgroup, */
    493 /*             pendingRow->dvodb, */
    494 /*             pendingRow->tess_id, */
    495 /*             pendingRow->end_stage */
    496 /*     )) { */
    497 /*         // rollback */
    498 /*         if (!psDBRollback(config->dbh)) { */
    499 /*             psError(PS_ERR_UNKNOWN, false, "database error"); */
    500 /*         } */
    501 /*         psError(PS_ERR_UNKNOWN, false, "failed to queue new fakeRun"); */
    502 /*         psFree(pendingRow); */
    503 /*         return false; */
    504 /*     } */
    505454    psFree(pendingRow);
    506455
    … …  
    517466{
    518467    PS_ASSERT_PTR_NON_NULL(config, false);
     468
     469    // generate restrictions
     470    psMetadata *where = psMetadataAlloc();
     471    PXOPT_COPY_S64(config->args, where, "-add_id",    "addRun.add_id",    "==");
     472    PXOPT_COPY_S64(config->args, where, "-cam_id",    "camRun.cam_id",    "==");
     473    pxcamGetSearchArgs (config, where);
     474    pxAddLabelSearchArgs (config, where, "-label",    "addRun.label",     "==");
     475    PXOPT_COPY_STR(config->args, where, "-reduction", "addRun.reduction", "==");
    519476
    520477    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    521478    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    522479    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    523 
    524     // generate restrictions
    525     psMetadata *where = psMetadataAlloc();
    526     pxaddGetSearchArgs (config, where);
    527     PXOPT_COPY_S64(config->args, where, "-add_id",    "addRun.add_id",    "==");
    528     pxAddLabelSearchArgs (config, where, "-label",    "addRun.label",     "==");
    529     PXOPT_COPY_STR(config->args, where, "-reduction", "addRun.reduction", "==");
    530480
    531481    if (!psListLength(where->list) &&
    … …  
    613563
    614564    psMetadata *where = psMetadataAlloc();
    615     pxaddGetSearchArgs (config, where);
    616565    PXOPT_COPY_S64(config->args, where, "-add_id",    "addRun.add_id",         "==");
     566    PXOPT_COPY_S64(config->args, where, "-cam_id",    "camRun.cam_id",         "==");
     567    pxcamGetSearchArgs (config, where);
    617568    pxAddLabelSearchArgs (config, where, "-label",    "addRun.label",     "==");
    618569    PXOPT_COPY_STR(config->args, where, "-reduction", "addRun.reduction",      "==");
    619 /*     PXOPT_COPY_S16(config->args, where, "-fault", "addProcessedExp.fault", "=="); */
    620570
    621571    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    … …  
    705655    PS_ASSERT_PTR_NON_NULL(config, false);
    706656
    707     PXOPT_LOOKUP_S16(fault, config->args, "-fault", true, false);
    708 
    709657    psMetadata *where = psMetadataAlloc();
    710658    PXOPT_COPY_S64(config->args, where, "-add_id",   "add_id",   "==");
    711659    PXOPT_COPY_S64(config->args, where, "-cam_id",  "cam_id",  "==");
    712 /*     PXOPT_COPY_STR(config->args, where, "-class",    "class",    "=="); */
    713 /*     PXOPT_COPY_STR(config->args, where, "-class_id", "class_id", "=="); */
     660    PXOPT_LOOKUP_S16(fault, config->args, "-fault", true, false);
    714661
    715662    if (!pxSetFaultCode(config->dbh, "addProcessedExp", where, fault)) {
    … …  
    777724}
    778725
    779 
    780726static bool unblockMode(pxConfig *config)
    781727{
    … …  
    793739    return true;
    794740}
    795 
    796 static bool pendingcleanuprunMode(pxConfig *config)
    797 {
    798     PS_ASSERT_PTR_NON_NULL(config, NULL);
    799 
    800     PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    801     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    802 
    803     psMetadata *where = psMetadataAlloc();
    804     pxAddLabelSearchArgs (config, where, "-label", "addRun.label", "==");
    805 
    806     psString query = pxDataGet("addtool_pendingcleanuprun.sql");
    807     if (!query) {
    808         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    809         return false;
    810     }
    811 
    812     if (where && psListLength(where->list)) {
    813         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    814         psStringAppend(&query, " AND %s", whereClause);
    815         psFree(whereClause);
    816     }
    817     psFree(where);
    818 
    819     // treat limit == 0 as "no limit"
    820     if (limit) {
    821         psString limitString = psDBGenerateLimitSQL(limit);
    822         psStringAppend(&query, " %s", limitString);
    823         psFree(limitString);
    824     }
    825 
    826     if (!p_psDBRunQuery(config->dbh, query)) {
    827         psError(PS_ERR_UNKNOWN, false, "database error");
    828         psFree(query);
    829         return false;
    830     }
    831     psFree(query);
    832 
    833     psArray *output = p_psDBFetchResult(config->dbh);
    834     if (!output) {
    835         psError(PS_ERR_UNKNOWN, false, "database error");
    836         return false;
    837     }
    838     if (!psArrayLength(output)) {
    839         psTrace("addtool", PS_LOG_INFO, "no rows found");
    840         psFree(output);
    841         return true;
    842     }
    843 
    844     // negative simple so the default is true
    845     if (!ippdbPrintMetadatas(stdout, output, "addPendingCleanupRun", !simple)) {
    846         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    847         psFree(output);
    848         return false;
    849     }
    850 
    851     psFree(output);
    852 
    853     return true;
    854 }
    855 
    856 
    857 static bool pendingcleanupexpMode(pxConfig *config)
    858 {
    859     PS_ASSERT_PTR_NON_NULL(config, NULL);
    860 
    861     PXOPT_LOOKUP_S64(add_id, config->args, "-add_id", false, false);
    862     PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    863     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    864 
    865     psMetadata *where = psMetadataAlloc();
    866     if (add_id) {
    867         PXOPT_COPY_S64(config->args, where, "-add_id", "add_id", "==");
    868     }
    869     pxAddLabelSearchArgs (config, where, "-label", "label", "==");
    870 
    871     psString query = pxDataGet("addtool_pendingcleanupexp.sql");
    872     if (!query) {
    873         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    874         return false;
    875     }
    876 
    877     if (where && psListLength(where->list)) {
    878         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    879         psStringAppend(&query, " AND %s", whereClause);
    880         psFree(whereClause);
    881     }
    882     psFree(where);
    883 
    884     // treat limit == 0 as "no limit"
    885     if (limit) {
    886         psString limitString = psDBGenerateLimitSQL(limit);
    887         psStringAppend(&query, " %s", limitString);
    888         psFree(limitString);
    889     }
    890 
    891     if (!p_psDBRunQuery(config->dbh, query)) {
    892         psError(PS_ERR_UNKNOWN, false, "database error");
    893         psFree(query);
    894         return false;
    895     }
    896     psFree(query);
    897 
    898     psArray *output = p_psDBFetchResult(config->dbh);
    899     if (!output) {
    900         psError(PS_ERR_UNKNOWN, false, "database error");
    901         return false;
    902     }
    903     if (!psArrayLength(output)) {
    904         psTrace("chiptool", PS_LOG_INFO, "no rows found");
    905         psFree(output);
    906         return true;
    907     }
    908 
    909     // negative simple so the default is true
    910     if (!ippdbPrintMetadatas(stdout, output, "addPendingCleanupExp", !simple)) {
    911         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    912         psFree(output);
    913         return false;
    914     }
    915 
    916     psFree(output);
    917 
    918     return true;
    919 }
    920 
    921 
    922 static bool donecleanupMode(pxConfig *config)
    923 {
    924     PS_ASSERT_PTR_NON_NULL(config, NULL);
    925 
    926     PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    927     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    928 
    929     psMetadata *where = psMetadataAlloc();
    930     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
    931 
    932     psString query = pxDataGet("addtool_donecleanup.sql");
    933     if (!query) {
    934         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    935         return false;
    936     }
    937 
    938     if (where && psListLength(where->list)) {
    939         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    940         psStringAppend(&query, " AND %s", whereClause);
    941         psFree(whereClause);
    942     }
    943     psFree(where);
    944 
    945     // treat limit == 0 as "no limit"
    946     if (limit) {
    947         psString limitString = psDBGenerateLimitSQL(limit);
    948         psStringAppend(&query, " %s", limitString);
    949         psFree(limitString);
    950     }
    951 
    952     if (!p_psDBRunQuery(config->dbh, query)) {
    953         psError(PS_ERR_UNKNOWN, false, "database error");
    954         psFree(query);
    955         return false;
    956     }
    957     psFree(query);
    958 
    959     psArray *output = p_psDBFetchResult(config->dbh);
    960     if (!output) {
    961         psError(PS_ERR_UNKNOWN, false, "database error");
    962         return false;
    963     }
    964     if (!psArrayLength(output)) {
    965         psTrace("addtool", PS_LOG_INFO, "no rows found");
    966         psFree(output);
    967         return true;
    968     }
    969 
    970     // negative simple so the default is true
    971     if (!ippdbPrintMetadatas(stdout, output, "addDoneCleanup", !simple)) {
    972         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    973         psFree(output);
    974         return false;
    975     }
    976 
    977     psFree(output);
    978 
    979     return true;
    980 }
    981 
    982 bool exportrunMode(pxConfig *config)
    983 {
    984   typedef struct ExportTable {
    985     char tableName[80];
    986     char sqlFilename[80];
    987   } ExportTable;
    988 
    989   int numExportTables = 2;
    990 
    991   PS_ASSERT_PTR_NON_NULL(config, NULL);
    992 
    993   PXOPT_LOOKUP_S64(det_id, config->args, "-add_id", true,  false);
    994   PXOPT_LOOKUP_STR(outfile, config->args, "-outfile", true,  false);
    995   PXOPT_LOOKUP_U64(limit,   config->args, "-limit",   false, false);
    996   PXOPT_LOOKUP_BOOL(clean, config->args, "-clean", false);
    997 
    998   FILE *f = fopen (outfile, "w");
    999   if (f == NULL) {
    1000     psError(PS_ERR_UNKNOWN, false, "failed to open output file");
    1001     return false;
    1002   }
    1003 
    1004   psMetadata *where = psMetadataAlloc();
    1005   PXOPT_COPY_S64(config->args, where, "-add_id", "add_id", "==");
    1006 
    1007   ExportTable tables [] = {
    1008     {"addRun", "addtool_export_run.sql"},
    1009     {"addProcessedExp", "addtool_export_processed_exp.sql"},
    1010   };
    1011 
    1012   for (int i=0; i < numExportTables; i++) {
    1013     psString query = pxDataGet(tables[i].sqlFilename);
    1014     if (!query) {
    1015       psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1016       return false;
    1017     }
    1018 
    1019     if (where && psListLength(where->list)) {
    1020       psString whereClause = psDBGenerateWhereSQL(where, NULL);
    1021       psStringAppend(&query, " %s", whereClause);
    1022       psFree(whereClause);
    1023     }
    1024 
    1025     // treat limit == 0 as "no limit"
    1026     if (limit) {
    1027       psString limitString = psDBGenerateLimitSQL(limit);
    1028       psStringAppend(&query, " %s", limitString);
    1029       psFree(limitString);
    1030     }
    1031 
    1032     if (!p_psDBRunQuery(config->dbh, query)) {
    1033       psError(PS_ERR_UNKNOWN, false, "database error");
    1034       psFree(query);
    1035       return false;
    1036     }
    1037     psFree(query);
    1038 
    1039     psArray *output = p_psDBFetchResult(config->dbh);
    1040     if (!output) {
    1041       psError(PS_ERR_UNKNOWN, false, "database error");
    1042       return false;
    1043     }
    1044     if (!psArrayLength(output)) {
    1045       psError(PS_ERR_UNKNOWN, true, "no rows found");
    1046       psFree(output);
    1047       return false;
    1048     }
    1049 
    1050     if (clean) {
    1051         if (!strcmp(tables[i].tableName, "addRun")) {
    1052             if (!pxSetStateCleaned("addRun", "state", output)) {
    1053                 psFree(output);
    1054                 psError(PS_ERR_UNKNOWN, false, "pxSetStateClean failed for table %s",  tables[i].tableName);
    1055                 return false;
    1056             }
    1057         }
    1058     }
    1059 
    1060     // we must write the export table in non-simple (true) format
    1061     if (!ippdbPrintMetadatas(f, output, tables[i].tableName, true)) {
    1062       psError(PS_ERR_UNKNOWN, false, "failed to print array");
    1063       psFree(output);
    1064       return false;
    1065     }
    1066     psFree(output);
    1067   }
    1068 
    1069   fclose (f);
    1070 
    1071   return true;
    1072 }
    1073 
    1074 bool importrunMode(pxConfig *config)
    1075 {
    1076   unsigned int nFail;
    1077 
    1078   PS_ASSERT_PTR_NON_NULL(config, NULL);
    1079 
    1080   PXOPT_LOOKUP_STR(infile, config->args, "-infile", true,  false);
    1081 
    1082   psMetadata *input = psMetadataConfigRead (NULL, &nFail, infile, false);
    1083 
    1084   fprintf (stdout, "---- input ----\n");
    1085   psMetadataPrint (stderr, input, 1);
    1086 
    1087   psMetadataItem *item = psMetadataLookup (input, "addRun");
    1088   psAssert (item, "entry not in input?");
    1089   psAssert (item->type == PS_DATA_METADATA_MULTI, "entry not multi?");
    1090 
    1091   psMetadataItem *entry = psListGet (item->data.list, 0);
    1092   assert (entry);
    1093   assert (entry->type == PS_DATA_METADATA);
    1094   addRunRow *addRun = addRunObjectFromMetadata (entry->data.md);
    1095   addRunInsertObject (config->dbh, addRun);
    1096 
    1097   // fprintf (stdout, "---- add run ----\n");
    1098   // psMetadataPrint (stderr, entry->data.md, 1);
    1099 
    1100   item = psMetadataLookup (input, "addProcessedExp");
    1101   psAssert (item, "entry not in input?");
    1102   psAssert (item->type == PS_DATA_METADATA_MULTI, "entry not multi?");
    1103 
    1104   for (int i = 0; i < item->data.list->n; i++) {
    1105     psMetadataItem *entry = psListGet (item->data.list, i);
    1106     assert (entry);
    1107     assert (entry->type == PS_DATA_METADATA);
    1108     addProcessedExpRow *addProcessedExp = addProcessedExpObjectFromMetadata (entry->data.md);
    1109     addProcessedExpInsertObject (config->dbh, addProcessedExp);
    1110 
    1111     // fprintf (stdout, "---- row %d ----\n", i);
    1112     // psMetadataPrint (stderr, entry->data.md, 1);
    1113   }
    1114 
    1115   return true;
    1116 }

  • branches/eam_branches/20090820/ippTools/src/addtoolConfig.c

    r25766 r25870  
    4848
    4949    // -definebyquery
    50     // XXX need to allow multiple chip_ids
    51     // XXX need to allow multiple exp_ids
    5250    psMetadata *definebyqueryArgs = psMetadataAlloc();
     51    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-cam_id",             0, "search by cam_id", 0);
    5352    pxcamSetSearchArgs(definebyqueryArgs);
    54     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by chipRun label", NULL);
    55     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-reduction",          0, "search by chipRun reduction class", NULL);
     53    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by camRun label", NULL);
     54    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-reduction",          0, "search by camRun reduction class", NULL);
    5655
    5756    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_workdir",        0, "define workdir", NULL);
    … …  
    5958    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_reduction",      0, "define reduction class", NULL);
    6059    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_dvodb",          0, "define DVO db", NULL);
     60    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-image_only",        0, "addstar image metadata but not detections", false);
     61    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-pretend",           0, "do not actually modify the database", false);
     62    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple",            0, "use the simple output format", false);
     63
     64    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_data_group", 0,   "define new data_group", NULL);
     65    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_dist_group", 0,   "define new dist_group", NULL);
     66    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_note", 0,         "define new note", NULL);
    6167    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-all",               0, "allow everything to be queued without search terms", false);
    6268
    6369    // -updaterun
    64     // XXX need to allow multiple add_ids
    65     // XXX need to allow multiple chip_ids
    66     // XXX need to allow multiple exp_ids
    6770    psMetadata *updaterunArgs = psMetadataAlloc();
     71    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-add_id",                 0, "search by add_id", 0);
     72    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-cam_id",                 0, "search by cam_id", 0);
    6873    pxcamSetSearchArgs(updaterunArgs);
    69     psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-add_id",             0, "search by add_id", 0);
    70     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label",              0, "search by camRun label", NULL);
    71     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state",              0, "search by camRun state", NULL);
    72     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-reduction",          0, "search by camRun reduction class", NULL);
    73     psMetadataAddBool(updaterunArgs, PS_LIST_TAIL, "-all",               0, "allow everything to be queued without search terms", false);
    74     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state",          0, "set state", NULL);
    75     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_label",          0, "set label", NULL);
    76 
     74    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label",                  0, "search by addRun label", NULL);
     75    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state",                  0, "search by addRun state", NULL);
     76    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-reduction",              0, "search by addRun reduction class", NULL);
     77    psMetadataAddBool(updaterunArgs, PS_LIST_TAIL, "-all",                   0, "allow everything to be queued without search terms", false);
     78    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state",              0, "set state", NULL);
     79    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_label",              0, "set label", NULL);
     80    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_data_group", 0,   "define new data_group", NULL);
     81    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_dist_group", 0,   "define new dist_group", NULL);
     82    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_note", 0,         "define new note", NULL);
    7783    // -pendingexp
    7884    psMetadata *pendingexpArgs = psMetadataAlloc();
    79     pxcamSetSearchArgs(pendingexpArgs);
    8085    psMetadataAddS64(pendingexpArgs, PS_LIST_TAIL, "-add_id",            0, "search by add_id", 0);
    8186    psMetadataAddS64(pendingexpArgs, PS_LIST_TAIL, "-cam_id",            0, "search by cam_id", 0);
    82     psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by camRun label", NULL);
    83     psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-reduction",         0, "search by camRun reduction class", NULL);
     87    pxcamSetSearchArgs(pendingexpArgs);
     88    psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by addRun label", NULL);
     89    psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-reduction",         0, "search by addRun reduction class", NULL);
    8490    psMetadataAddU64(pendingexpArgs, PS_LIST_TAIL, "-limit",             0, "limit result set to N items", 0);
    8591    psMetadataAddBool(pendingexpArgs, PS_LIST_TAIL, "-simple",           0, "use the simple output format", false);
    86 
    87     // XXX is this used? psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-class",    0,            "search by class", NULL);
    8892
    8993    // -addprocessedexp
    9094    psMetadata *addprocessedexpArgs = psMetadataAlloc();
    9195    psMetadataAddS64(addprocessedexpArgs, PS_LIST_TAIL, "-add_id", 0,            "define addtool ID (required)", 0);
     96    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-path_base", 0,            "define base output location", NULL);
     97    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-dtime_addstar", 0, "define elapsed time for DVO insertion (seconds)", NAN);
     98    psMetadataAddS16(addprocessedexpArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code", 0);
    9299
    93     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-dtime_addstar", 0, "define elapsed time for DVO insertion (seconds)", NAN);
    94     psMetadataAddS32(addprocessedexpArgs, PS_LIST_TAIL, "-n_stars", 0,            "define number of stars", 0);
    95 
    96     psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-path_base", 0,            "define base output location", NULL);
    97     psMetadataAddS64(addprocessedexpArgs, PS_LIST_TAIL, "-magicked", 0,             "set magicked", 0);
    98100    // -processedexp
    99101    psMetadata *processedexpArgs = psMetadataAlloc();
     102    psMetadataAddS64(processedexpArgs, PS_LIST_TAIL, "-add_id",   0,            "search by add_id", 0);
     103    psMetadataAddS64(processedexpArgs, PS_LIST_TAIL, "-cam_id",   0,            "search by cam_id", 0);
    100104    pxcamSetSearchArgs(processedexpArgs);
    101     psMetadataAddS64(processedexpArgs, PS_LIST_TAIL, "-add_id",   0,            "search by add_id", 0);
    102105    psMetadataAddStr(processedexpArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by addRun label", NULL);
    103106    psMetadataAddStr(processedexpArgs, PS_LIST_TAIL, "-reduction",0,            "search by addRun reduction class", NULL);
    104107
    105108    psMetadataAddU64(processedexpArgs, PS_LIST_TAIL, "-limit",    0,            "limit result set to N items", 0);
     109    psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     110    psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-faulted", 0,            "only return imfiles with a fault status set", false);
    106111    psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-all",     0,            "list everything without restriction", false);
    107     psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    108 /*     psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-faulted", 0,            "only return imfiles with a fault status set", false); */
    109112
    110113    // -revertprocessedexp
    111     // XXX need to allow multiple add_ids
    112     // XXX need to allow multiple chip_ids
    113     // XXX need to allow multiple exp_ids
    114114    psMetadata *revertprocessedexpArgs = psMetadataAlloc();
     115    psMetadataAddS64(revertprocessedexpArgs, PS_LIST_TAIL, "-add_id",   0,            "search by add_id", 0);
     116    psMetadataAddS64(revertprocessedexpArgs, PS_LIST_TAIL, "-cam_id",   0,            "search by cam_id", 0);
    115117    pxcamSetSearchArgs(revertprocessedexpArgs);
    116     psMetadataAddS64(revertprocessedexpArgs, PS_LIST_TAIL, "-add_id",   0,            "search by add_id", 0);
    117118    psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-label",    PS_META_DUPLICATE_OK, "search by addRun label", NULL);
    118119    psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-reduction",0,            "search by addRun reduction class", NULL);
    … …  
    121122
    122123    // -updateprocessedexp
    123     // XXX allow full search options?
    124124    psMetadata *updateprocessedexpArgs = psMetadataAlloc();
    125125    psMetadataAddS64(updateprocessedexpArgs, PS_LIST_TAIL, "-add_id", 0,            "search by addtool ID", 0);
    126126    psMetadataAddS64(updateprocessedexpArgs, PS_LIST_TAIL, "-cam_id",  0,            "search by camtool ID", 0);
     127    psMetadataAddS16(updateprocessedexpArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code", 0);
    127128
    128129    // -block
    … …  
    137138    psMetadata *unblockArgs = psMetadataAlloc();
    138139    psMetadataAddStr(unblockArgs, PS_LIST_TAIL, "-label",  0,            "name of a label to unmask (required)", NULL);
    139 
    140     // -pendingcleanuprun
    141     // XXX allow full search options?
    142     psMetadata *pendingcleanuprunArgs = psMetadataAlloc();
    143     psMetadataAddStr(pendingcleanuprunArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "list blocks for specified label", NULL);
    144     psMetadataAddBool(pendingcleanuprunArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    145     psMetadataAddU64(pendingcleanuprunArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    146 
    147     // -pendingcleanupexp
    148     // XXX allow full search options?
    149     psMetadata *pendingcleanupexpArgs = psMetadataAlloc();
    150     psMetadataAddStr(pendingcleanupexpArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "list blocks for specified label", NULL);
    151     psMetadataAddS64(pendingcleanupexpArgs, PS_LIST_TAIL, "-add_id", 0,            "search by addstar ID", 0);
    152     psMetadataAddBool(pendingcleanupexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    153     psMetadataAddU64(pendingcleanupexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    154 
    155     // -donecleanup
    156     psMetadata *donecleanupArgs = psMetadataAlloc();
    157     psMetadataAddStr(donecleanupArgs, PS_LIST_TAIL, "-label",  0,            "list blocks for specified label", NULL);
    158     psMetadataAddBool(donecleanupArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    159     psMetadataAddU64(donecleanupArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    160 
    161     // -exportrun
    162     psMetadata *exportrunArgs = psMetadataAlloc();
    163     psMetadataAddS64(exportrunArgs, PS_LIST_TAIL, "-add_id", 0,          "export this addstar ID (required)", 0);
    164     psMetadataAddStr(exportrunArgs, PS_LIST_TAIL, "-outfile", 0,          "export to this file (required)", NULL);
    165     psMetadataAddU64(exportrunArgs, PS_LIST_TAIL, "-limit",   0,          "limit result set to N items", 0);
    166     psMetadataAddBool(exportrunArgs, PS_LIST_TAIL, "-clean",  0,          "export tables as cleaned", false);
    167 
    168     // -importrun
    169     psMetadata *importrunArgs = psMetadataAlloc();
    170     psMetadataAddStr(importrunArgs, PS_LIST_TAIL, "-infile",  0,          "import from this file (required)", NULL);
    171 
    172140
    173141    psMetadata *argSets = psMetadataAlloc();
    … …  
    184152    PXOPT_ADD_MODE("-masked",               "show blocked labels",                  ADDTOOL_MODE_MASKED,        maskedArgs);
    185153    PXOPT_ADD_MODE("-unblock",              "remove a label block",                 ADDTOOL_MODE_UNBLOCK,       unblockArgs);
    186     PXOPT_ADD_MODE("-pendingcleanuprun",    "show runs that need to be cleaned up", ADDTOOL_MODE_PENDINGCLEANUPRUN, pendingcleanuprunArgs);
    187     PXOPT_ADD_MODE("-pendingcleanupexp",    "show exps for cleanup runs",           ADDTOOL_MODE_PENDINGCLEANUPEXP, pendingcleanupexpArgs);
    188     PXOPT_ADD_MODE("-donecleanup",          "show runs that have been cleaned",     ADDTOOL_MODE_DONECLEANUP,       donecleanupArgs);
    189     PXOPT_ADD_MODE("-exportrun",            "export run for import on other database", ADDTOOL_MODE_EXPORTRUN, exportrunArgs);
    190     PXOPT_ADD_MODE("-importrun",            "import run from metadata file",           ADDTOOL_MODE_IMPORTRUN, importrunArgs);
    191154
    192155    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • branches/eam_branches/20090820/ippTools/src/camtool.c

    r25766 r25870  
    121121    PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", false, false);
    122122    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
     123    PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
     124    PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false);
    123125    PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false);
    124126    PXOPT_LOOKUP_STR(expgroup, config->args, "-set_expgroup", false, false);
    … …  
    126128    PXOPT_LOOKUP_STR(tess_id, config->args, "-set_tess_id", false, false);
    127129    PXOPT_LOOKUP_STR(end_stage, config->args, "-set_end_stage", false, false);
     130    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
    128131
    129132    // find the exp_id of all the exposures that we want to queue up.
    … …  
    212215                    workdir     ? workdir   : row->workdir,
    213216                    label       ? label     : row->label,
     217                    data_group  ? data_group: row->data_group,
     218                    dist_group  ? dist_group: row->dist_group,
    214219                    reduction   ? reduction : row->reduction,
    215220                    expgroup    ? expgroup  : row->expgroup,
    216221                    dvodb       ? dvodb     : row->dvodb,
    217222                    tess_id     ? tess_id   : row->tess_id,
    218                     end_stage   ? end_stage : row->end_stage
     223                    end_stage   ? end_stage : row->end_stage,
     224                    note
    219225        )) {
    220226            if (!psDBRollback(config->dbh)) {
    … …  
    251257    PXOPT_COPY_STR(config->args, where, "-reduction", "camRun.reduction", "==");
    252258
    253     if (!psListLength(where->list)
    254         && !psMetadataLookupBool(NULL, config->args, "-all")) {
     259    if (!psListLength(where->list)) {
    255260        psFree(where);
    256261        psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
    257262        return false;
    258263    }
    259 
    260     PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
    261     PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
    262 
    263     if ((!state) && (!label)) {
    264         psError(PXTOOLS_ERR_DATA, false, "parameters are required");
    265         psFree(where);
    266         return false;
    267     }
    268 
    269     if (state) {
    270         // set camRun.state to state
    271         if (!pxcamRunSetStateByQuery(config, where, state)) {
    272             psFree(where);
    273             return false;
    274         }
    275     }
    276 
    277     if (label) {
    278         // set camRun.label to label
    279         if (!pxcamRunSetLabelByQuery(config, where, label)) {
    280             psFree(where);
    281             return false;
    282         }
    283     }
    284 
     264    psString query = psStringCopy("UPDATE camRun JOIN chipRun USING(chip_id) JOIN rawExp USING(exp_id)");
     265
     266    // pxUpdateRun gets parameters from config->args and updates
     267    bool result = pxUpdateRun(config, where, &query, "camRun", true);
     268    if (!result) {
     269        psError(PXTOOLS_ERR_DATA, false, "pxUpdateRun failed");
     270    }
     271
     272    psFree(query);
    285273    psFree(where);
    286274
    287     return true;
     275    return result;
    288276}
    289277
    … …  
    642630            pendingRow->workdir,
    643631            pendingRow->label,
     632            pendingRow->data_group,
     633            pendingRow->dist_group,
    644634            pendingRow->reduction,
    645635            pendingRow->expgroup,
    646636            pendingRow->dvodb,
    647637            pendingRow->tess_id,
    648             pendingRow->end_stage
     638            pendingRow->end_stage,
     639            NULL    // note does not propagate
    649640    )) {
    650641        // rollback
    … …  
    656647        return false;
    657648    }
    658 
    659 /*     if (!pxaddQueueByCamID(config, */
    660 /*                         pendingRow->cam_id, */
    661 /*                         pendingRow->workdir, */
    662 /*                         pendingRow->label, */
    663 /*                         pendingRow->reduction, */
    664 /*                         pendingRow->dvodb */
    665 /*     )) { */
    666 /*         // rollback */
    667 /*         if (!psDBRollback(config->dbh)) { */
    668 /*             psError(PS_ERR_UNKNOWN, false, "database error"); */
    669 /*         } */
    670 /*         psError(PS_ERR_UNKNOWN, false, "failed to queue new addRun"); */
    671 /*         psFree(pendingRow); */
    672 /*         return false; */
    673 /*     } */
    674649
    675650    psFree(pendingRow);
    … …  
    11721147  }
    11731148
     1149  if (!pxExportVersion(config, f)) {
     1150    psError(PS_ERR_UNKNOWN, false, "failed to write dbversion output file");
     1151    return false;
     1152  }
     1153
    11741154  psMetadata *where = psMetadataAlloc();
    11751155  PXOPT_COPY_S64(config->args, where, "-cam_id", "cam_id", "==");
    … …  
    12521232  psMetadata *input = psMetadataConfigRead (NULL, &nFail, infile, false);
    12531233
    1254   fprintf (stdout, "---- input ----\n");
     1234#ifdef notdef
     1235  fprintf (stderr, "---- input ----\n");
    12551236  psMetadataPrint (stderr, input, 1);
     1237#endif
     1238
     1239  if (!pxCheckImportVersion(config, input)) {
     1240      psError(PS_ERR_UNKNOWN, false, "pxCheckImportVersion failed");
     1241      return false;
     1242  }
    12561243
    12571244  psMetadataItem *item = psMetadataLookup (input, "camRun");

  • branches/eam_branches/20090820/ippTools/src/camtoolConfig.c

    r24681 r25870  
    6262    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_tess_id",        0, "define tess ID", NULL);
    6363    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_end_stage",      0, "define end stage", NULL);
    64     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-all",               0, "allow everything to be queued without search terms", false);
     64    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_data_group",     0, "define data group", NULL);
     65    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_dist_group",     0, "define dist group", NULL);
     66    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_note",           0, "define note", NULL);
    6567
    6668    // -updaterun
    … …  
    7779    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state",          0, "set state", NULL);
    7880    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_label",          0, "set label", NULL);
    79 
     81    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_data_group", 0,   "define new data_group", NULL);
     82    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_dist_group", 0,   "define new dist_group", NULL);
     83    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_note", 0,         "define new note", NULL);
    8084    // -pendingexp
    8185    psMetadata *pendingexpArgs = psMetadataAlloc();

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

    r25766 r25870  
    5757static bool exportrunMode(pxConfig *config);
    5858static bool importrunMode(pxConfig *config);
     59static bool runstateMode(pxConfig *config);
    5960
    6061# define MODECASE(caseName, func) \
    … …  
    9798        MODECASE(CHIPTOOL_MODE_EXPORTRUN,               exportrunMode);
    9899        MODECASE(CHIPTOOL_MODE_IMPORTRUN,               importrunMode);
     100        MODECASE(CHIPTOOL_MODE_RUNSTATE,                runstateMode);
    99101        default:
    100102            psAbort("invalid option (this should not happen)");
    … …  
    144146    PXOPT_LOOKUP_STR(tess_id, config->args, "-set_tess_id", false, false);
    145147    PXOPT_LOOKUP_STR(end_stage, config->args, "-set_end_stage", false, false);
     148    PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false);
     149    PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
     150    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
    146151
    147152    // default
    … …  
    263268                                 workdir     ? workdir   : raw_workdir,
    264269                                 label       ? label     : raw_label,
     270                                 data_group  ? data_group : (label ? label : raw_label),
     271                                 dist_group,
    265272                                 reduction   ? reduction : raw_reduction,
    266273                                 // expgroup    ? expgroup  : raw_expgroup,
    … …  
    269276                                 dvodb       ? dvodb     : raw_dvodb,
    270277                                 tess_id     ? tess_id   : raw_tess_id,
    271                                  end_stage   ? end_stage : raw_end_stage
     278                                 end_stage   ? end_stage : raw_end_stage,
     279                                 note
    272280                                 )) {
    273281            if (!psDBRollback(config->dbh)) {
    … …  
    301309    PXOPT_COPY_STR(config->args,  where, "-label",   "chipRun.label",   "==");
    302310    PXOPT_COPY_STR(config->args,  where, "-state",   "chipRun.state",   "==");
    303 
    304     if (!psListLength(where->list) &&
    305         !psMetadataLookupBool(NULL, config->args, "-all")) {
     311    PXOPT_COPY_STR(config->args,  where, "-data_group", "chipRun.data_group",   "==");
     312    PXOPT_COPY_STR(config->args,  where, "-dist_group", "chipRun.dist_group",   "==");
     313
     314    if (!psListLength(where->list)) {
    306315        psFree(where);
    307         where = NULL;
    308316        psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
    309317        return false;
    310318    }
    311 
    312     PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
    313     PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
    314 
    315     if ((!state) && (!label)) {
    316         psError(PXTOOLS_ERR_DATA, false, "parameters are required");
    317         psFree(where);
    318         return false;
    319     }
    320 
    321     if (state) {
    322         // set chipRun.state to state
    323         if (!pxchipRunSetStateByQuery(config, where, state)) {
    324             psFree(where);
    325             return false;
    326         }
    327     }
    328 
    329     if (label) {
    330         // set chipRun.label to label
    331         if (!pxchipRunSetLabelByQuery(config, where, label)) {
    332             psFree(where);
    333             return false;
    334         }
    335     }
    336 
     319    psString query = psStringCopy("UPDATE chipRun JOIN rawExp USING(exp_id)");
     320
     321    // pxUpdateRun gets parameters from config->args and updates
     322    bool result = pxUpdateRun(config, where, &query, "chipRun", true);
     323    if (!result) {
     324        psError(PXTOOLS_ERR_DATA, false, "pxUpdateRun failed");
     325    }
     326
     327    psFree(query);
    337328    psFree(where);
    338329
    339     return true;
     330    return result;
    340331}
    341332
    … …  
    605596    PXOPT_COPY_S64(config->args, where, "-magicked", "chipProcessedImfile.magicked", "==");
    606597
    607     PXOPT_LOOKUP_U64(magicked, config->args, "-magicked", false, false);
    608     PXOPT_LOOKUP_BOOL(destreaked, config->args,     "-destreaked", false);
    609     PXOPT_LOOKUP_BOOL(not_destreaked, config->args, "-not_destreaked", false);
    610 
    611     if (!psListLength(where->list) &&
    612         !psMetadataLookupBool(NULL, config->args, "-all")) {
    613         psFree(where);
    614         psError(PXTOOLS_ERR_DATA, false, "search parameters (or -all) are required");
     598    psString where2 = NULL;
     599    pxmagicAddWhere(config, &where2, "chipProcessedImfile");
     600    // add cuts on ra and decl if supplied
     601    if (!pxspaceAddWhere(config, &where2, "rawExp")) {
     602        psError(PXTOOLS_ERR_DATA, false, "pxSpaceAddWhere failed");
    615603        return false;
    616604    }
    … …  
    622610    }
    623611
    624     if (where && psListLength(where->list)) {
     612    if (psListLength(where->list)) {
    625613        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    626614        psStringAppend(&query, " WHERE %s", whereClause);
    627615        psFree(whereClause);
     616    } else if (psMetadataLookupBool(NULL, config->args, "-all") || (faulted || where2)) {
     617        psStringAppend(&query, " WHERE chipRun.chip_id IS NOT NULL %s", where2 ? where2 : "");
     618    } else {
     619        psFree(where);
     620        psError(PXTOOLS_ERR_DATA, false, "search parameters (or -all) are required");
     621        return false;
    628622    }
    629623    psFree(where);
    … …  
    635629        // don't list faulted rows
    636630        psStringAppend(&query, " %s", "AND chipProcessedImfile.fault = 0");
    637     }
    638     if (not_destreaked) {
    639         if (destreaked) {
    640             psError(PXTOOLS_ERR_DATA, true, "providing -not_destreaked and -destreaked makes no sense");
    641             return false;
    642         }
    643         if (magicked) {
    644             psError(PXTOOLS_ERR_DATA, true, "providing -not_destreaked and -magicked makes no sense");
    645             return false;
    646         }
    647         psStringAppend(&query, " AND chipProcessedImfile.magicked = 0");
    648     }
    649     if (destreaked) {
    650         psStringAppend(&query, " AND chipProcessedImfile.magicked != 0");
    651631    }
    652632
    … …  
    739719    PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "==");
    740720    PXOPT_COPY_STR(config->args, where, "-class_id", "class_id", "==");
    741     PXOPT_LOOKUP_S16(fault, config->args, "-fault", true, false);
    742 
    743     if (!pxSetFaultCode(config->dbh, "chipProcessedImfile", where, fault)) {
     721    PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, NULL);
     722       
     723    if (!state) {
     724      PXOPT_LOOKUP_S16(fault, config->args, "-fault", true, false);
     725     
     726      if (!pxSetFaultCode(config->dbh, "chipProcessedImfile", where, fault)) {
    744727        psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    745728        return false;
    746     }
    747     psFree(where);
    748 
     729      }
     730      psFree(where);
     731    }
     732    else {
     733      if (!pxchipProcessedImfileSetStateByQuery(config,where,state)) {
     734        psError(PS_ERR_UNKNOWN, false, "failed to set chipProcessedImfile state");
     735        return(false);
     736      }
     737    }
     738
     739     
    749740    return true;
    750741}
    … …  
    11141105
    11151106    psMetadata *where = psMetadataAlloc();
     1107    pxchipGetSearchArgs (config, where); // chipRun, chipProcessedImfile, rawExp
     1108    PXOPT_COPY_S64(config->args, where, "-chip_id", "chipRun.chip_id", "==");
     1109    PXOPT_COPY_STR(config->args, where, "-reduction", "chipRun.reduction", "==");
    11161110    pxAddLabelSearchArgs (config, where, "-label", "label", "==");
    11171111    PXOPT_COPY_STR(config->args, where, "-state", "state", "==");
    … …  
    12531247                    chipRun->workdir,
    12541248                    chipRun->label,
     1249                    chipRun->data_group,
     1250                    chipRun->dist_group,
    12551251                    chipRun->reduction,
    12561252                    chipRun->expgroup,
    12571253                    chipRun->dvodb,
    12581254                    chipRun->tess_id,
    1259                     chipRun->end_stage
     1255                    chipRun->end_stage,
     1256                    NULL    // note does not propagate
    12601257        )) {
    12611258           if (!psDBRollback(config->dbh)) {
    … …  
    13801377  }
    13811378
     1379  if (!pxExportVersion(config, f)) {
     1380    psError(PS_ERR_UNKNOWN, false, "failed to write dbversion output file");
     1381    return false;
     1382  }
     1383
    13821384  psMetadata *where = psMetadataAlloc();
    13831385  PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "==");
    … …  
    14711473    psVector *identifiers = psVectorAllocEmpty(16, PS_TYPE_U64); // Identifiers inserted
    14721474
     1475    psMetadataIterator *iter = psMetadataIteratorAlloc(input, PS_LIST_HEAD, NULL);       // Iterator
     1476
     1477    if (!pxCheckImportVersion(config, input)) {
     1478        psError(PS_ERR_UNKNOWN, false, "pxCheckImportVersion failed");
     1479        return false;
     1480    }
     1481    // first item is the dbversion, skip it
     1482    psMetadataItem *dbversion =  psMetadataGetAndIncrement(iter);
     1483    (void) dbversion;
     1484
    14731485    if (!psDBTransaction(config->dbh)) {
    14741486        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    14761488    }
    14771489
    1478     psMetadataIterator *iter = psMetadataIteratorAlloc(input, PS_LIST_HEAD, NULL);       // Iterator
    14791490    psMetadataItem *item;               // Item from iteration
    14801491    while ((item = psMetadataGetAndIncrement(iter))) {
    … …  
    15051516    return true;
    15061517}
     1518
     1519static bool runstateMode(pxConfig *config)
     1520{
     1521    PS_ASSERT_PTR_NON_NULL(config, false);
     1522
     1523    psMetadata *where = psMetadataAlloc();
     1524    PXOPT_COPY_S64(config->args, where, "-chip_id",    "chipRun.chip_id", "==");
     1525    PXOPT_COPY_S64(config->args, where, "-exp_id",     "rawExp.exp_id", "==");
     1526    PXOPT_COPY_STR(config->args, where, "-exp_name",   "rawExp.exp_name", "==");
     1527    pxAddLabelSearchArgs (config, where, "-label",     "chipRun.label", "LIKE");
     1528
     1529//    PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
     1530    PXOPT_LOOKUP_BOOL(no_magic, config->args, "-no_magic", false);
     1531
     1532    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1533    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1534
     1535    psString query = pxDataGet("chiptool_runstate.sql");
     1536    if (!query) {
     1537        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1538        return false;
     1539    }
     1540
     1541    if (psListLength(where->list)) {
     1542        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1543        psStringAppend(&query, " WHERE %s", whereClause);
     1544        psFree(whereClause);
     1545    } else {
     1546        psError(PXTOOLS_ERR_DATA, true, "search parameters or -all are required");
     1547        return false;
     1548    }
     1549    psFree(where);
     1550
     1551    // treat limit == 0 as "no limit"
     1552    if (limit) {
     1553        psString limitString = psDBGenerateLimitSQL(limit);
     1554        psStringAppend(&query, " %s", limitString);
     1555        psFree(limitString);
     1556    }
     1557
     1558    if (!p_psDBRunQuery(config->dbh, query)) {
     1559        psError(PS_ERR_UNKNOWN, false, "database error");
     1560        psFree(query);
     1561        return false;
     1562    }
     1563    psFree(query);
     1564
     1565    psArray *output = p_psDBFetchResult(config->dbh);
     1566    if (!output) {
     1567        psErrorCode err = psErrorCodeLast();
     1568        switch (err) {
     1569            case PS_ERR_DB_CLIENT:
     1570                psError(PXTOOLS_ERR_SYS, false, "database error");
     1571            case PS_ERR_DB_SERVER:
     1572                psError(PXTOOLS_ERR_PROG, false, "database error");
     1573            default:
     1574                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     1575        }
     1576
     1577        return false;
     1578    }
     1579    if (!psArrayLength(output)) {
     1580        psTrace("chiptool", PS_LOG_INFO, "no rows found");
     1581        psFree(output);
     1582        return true;
     1583    }
     1584
     1585    if (psArrayLength(output)) {
     1586        // negative simple so the default is true
     1587        if (!ippdbPrintMetadatas(stdout, output, "chipRunState", !simple)) {
     1588            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1589            psFree(output);
     1590            return false;
     1591        }
     1592    }
     1593
     1594    psFree(output);
     1595
     1596    return true;
     1597}

  • branches/eam_branches/20090820/ippTools/src/chiptool.h

    r25766 r25870  
    4747    CHIPTOOL_MODE_TOSCRUBBEDIMFILE,
    4848    CHIPTOOL_MODE_EXPORTRUN,
    49     CHIPTOOL_MODE_IMPORTRUN
     49    CHIPTOOL_MODE_IMPORTRUN,
     50    CHIPTOOL_MODE_RUNSTATE
    5051} chiptoolMode;
    5152

  • branches/eam_branches/20090820/ippTools/src/chiptoolConfig.c

    r25766 r25870  
    5858    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_tess_id",  0,            "define tessellation identifier", NULL);
    5959    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_end_stage",  0,            "define end stage", NULL);
     60    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_data_group",  0,      "define data group", NULL);
     61    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_dist_group",  0,      "define distribution group", NULL);
     62    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_note",  0,           "define note", NULL);
    6063    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-pretend",  0,            "do not actually modify the database", false);
    6164    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    62     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);
    6365
    6466    // -updaterun
    … …  
    6769    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-chip_id",              0,            "search by chip ID", 0);
    6870    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,            "search by state", NULL);
    69     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label",  0,          "search by label", NULL);
     71    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label",  0,           "search by label", NULL);
     72    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-data_group",  0,      "search by data_group", NULL);
     73    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-dist_group",  0,      "search by dist_group", NULL);
    7074    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state", 0,        "set state", NULL);
    7175    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_label", 0,        "set label", NULL);
    72     psMetadataAddBool(updaterunArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);
     76    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_data_group", 0,   "set data group", NULL);
     77    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_dist_group", 0,   "set dist group", NULL);
     78    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_note", 0,         "set note", NULL);
    7379
    7480    // -pendingimfile
    … …  
    158164    psMetadataAddStr(processedimfileArgs,  PS_LIST_TAIL, "-reduction",          0, "search by reduction class", NULL);
    159165    psMetadataAddStr(processedimfileArgs,  PS_LIST_TAIL, "-label",  PS_META_DUPLICATE_OK, "search by chipRun label (LIKE comparison)", NULL);
    160 
    161     psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-destreaked",  0,      "search for destreaked images", false);
    162     psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-not_destreaked",  0,  "search for images that have not been destreaked", false);
    163     psMetadataAddS64(processedimfileArgs, PS_LIST_TAIL, "-magicked",  0,        "search by magicked value", 0);
     166    pxmagicAddArguments(processedimfileArgs);
     167
    164168    psMetadataAddU64(processedimfileArgs,  PS_LIST_TAIL, "-limit",  0,           "limit result set to N items", 0);
    165169    psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-all",  0,            "list everything without search terms", false);
    166170    psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-faulted",  0,        "only return imfiles with a fault status set", false);
    167171    psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-simple",  0,         "use the simple output format", false);
     172
     173    pxspaceAddArguments(processedimfileArgs);
    168174
    169175    // -revertprocessedimfile
    … …  
    182188    psMetadataAddStr(updateprocessedimfileArgs,  PS_LIST_TAIL, "-class_id",           0, "search by class ID", NULL);
    183189    psMetadataAddS16(updateprocessedimfileArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code (required)", 0);
    184 
     190    psMetadataAddStr(updateprocessedimfileArgs, PS_LIST_TAIL, "-set_state", 0,         "set state", NULL);
    185191    // -block
    186192    psMetadata *blockArgs = psMetadataAlloc();
    … …  
    229235    psMetadataAddU64(runArgs, PS_LIST_TAIL, "-limit",  0,       "limit result set to N items", 0);
    230236    psMetadataAddStr(runArgs, PS_LIST_TAIL, "-state", 0,        "search by state (required)", NULL);
     237    pxchipSetSearchArgs(runArgs);
     238    psMetadataAddS64(runArgs, PS_LIST_TAIL, "-chip_id",  0,         "search by  chip ID", 0);
     239    psMetadataAddStr(runArgs,  PS_LIST_TAIL, "-reduction",          0, "search by reduction class", NULL);
    231240
    232241    // -advanceexp
    … …  
    268277    psMetadataAddStr(importrunArgs, PS_LIST_TAIL, "-infile",  0,          "import from this file (required)", NULL);
    269278
     279    // -runstate
     280    psMetadata *runstateArgs = psMetadataAlloc();
     281    psMetadataAddS64(runstateArgs, PS_LIST_TAIL, "-chip_id", 0,           "search by chip ID", 0);
     282    psMetadataAddS64(runstateArgs, PS_LIST_TAIL, "-exp_id", 0,            "search by exposure tag", 0);
     283    psMetadataAddStr(runstateArgs, PS_LIST_TAIL, "-exp_name", 0,          "search by exposure tag", 0);
     284    psMetadataAddStr(runstateArgs, PS_LIST_TAIL,  "-label",  PS_META_DUPLICATE_OK, "search by warpRun label", NULL);
     285    psMetadataAddBool(runstateArgs, PS_LIST_TAIL, "-no_magic",  0,        "magic is not necessary for result", false);
     286
     287    psMetadataAddU64(runstateArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     288    psMetadataAddBool(runstateArgs, PS_LIST_TAIL, "-simple",  0,          "use the simple output format", false);
     289
    270290    psMetadata *argSets = psMetadataAlloc();
    271291    psMetadata *modes = psMetadataAlloc();
    … …  
    278298    PXOPT_ADD_MODE("-updateprocessedimfile","change procesed imfile properties",    CHIPTOOL_MODE_UPDATEPROCESSEDIMFILE,updateprocessedimfileArgs);
    279299    PXOPT_ADD_MODE("-revertprocessedimfile","undo a processed imfile",              CHIPTOOL_MODE_REVERTPROCESSEDIMFILE,revertprocessedimfileArgs);
     300    PXOPT_ADD_MODE("-runstate",             "list the states of chip run",          CHIPTOOL_MODE_RUNSTATE,             runstateArgs);
    280301    PXOPT_ADD_MODE("-advanceexp",           "advance completed exposures",          CHIPTOOL_MODE_ADVANCEEXP,           advanceexpArgs);
    281302    PXOPT_ADD_MODE("-block",                "set a label block",                    CHIPTOOL_MODE_BLOCK,                blockArgs);

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

    r25766 r25870  
    5151
    5252static bool setdiffRunState(pxConfig *config, psS64 diff_id, const char *state, psS64 magicked);
     53static bool change_skyfile_data_state(pxConfig *config, psString data_state, psString run_state);
     54static bool tocleanedskyfileMode(pxConfig *config);
     55static bool topurgedskyfileMode(pxConfig *config);
     56static bool toscrubbedskyfileMode(pxConfig *config);
     57
     58
    5359
    5460# define MODECASE(caseName, func) \
    … …  
    8894        MODECASE(DIFFTOOL_MODE_EXPORTRUN,             exportrunMode);
    8995        MODECASE(DIFFTOOL_MODE_IMPORTRUN,             importrunMode);
     96        MODECASE(DIFFTOOL_MODE_TOCLEANEDSKYFILE,   tocleanedskyfileMode);
     97        MODECASE(DIFFTOOL_MODE_TOPURGEDSKYFILE,    topurgedskyfileMode);
     98        MODECASE(DIFFTOOL_MODE_TOSCRUBBEDSKYFILE,  toscrubbedskyfileMode);
     99
    90100        default:
    91101            psAbort("invalid option (this should not happen)");
    … …  
    115125
    116126    // required options
    117     PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false);
     127    PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", true, false);
    118128    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", true, false);
    119129    PXOPT_LOOKUP_BOOL(bothways, config->args, "-bothways", false);
    120130    PXOPT_LOOKUP_BOOL(exposure, config->args, "-exposure", false);
    121     PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
    122     PXOPT_LOOKUP_STR(reduction, config->args, "-reduction", false, false);
     131    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
     132    PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
     133    PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false);
     134    PXOPT_LOOKUP_STR(reduction, config->args, "-rset_eduction", false, false);
     135    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
    123136
    124137    // default
    … …  
    131144            workdir,
    132145            label,
     146            data_group ? data_group : label,
     147            dist_group,
    133148            reduction,
    134149            NULL,       // dvodb
    … …  
    137152            bothways,
    138153            exposure,
    139             false
     154            false,
     155            note
    140156    );
    141157    if (!run) {
    … …  
    168184    PS_ASSERT_PTR_NON_NULL(config, false);
    169185
     186    psMetadata *where = psMetadataAlloc();
     187
     188    PXOPT_COPY_S64(config->args, where, "-diff_id",  "stack_id",   "==");
     189    PXOPT_COPY_STR(config->args, where, "-label",     "label",     "==");
     190    PXOPT_COPY_STR(config->args, where, "-state",     "state",     "==");
     191    if (!psListLength(where->list)) {
     192        psFree(where);
     193        psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     194        return false;
     195    }
     196
     197    psString query = psStringCopy("UPDATE diffRun");
     198
     199    // pxUpdateRun gets parameters from config->args and updates
     200    bool result = pxUpdateRun(config, where, &query, "diffRun", true);
     201
     202    psFree(query);
     203    psFree(where);
     204
     205    return result;
     206
     207#ifdef notdef
    170208    // required options
    171     PXOPT_LOOKUP_S64(diff_id, config->args, "-diff_id", true, false);
     209    PXOPT_LOOKUP_S64(diff_id, config->args, "-diff_id", false, false);
    172210    PXOPT_LOOKUP_STR(state, config->args, "-state", true, false);
    173 
    174     if (state) {
     211    PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
     212   
     213    // Copy of my hacky work around from stacktool.c
     214    if ((state)&&(diff_id)) {
    175215        // set detRun.state to state
    176216        return setdiffRunState(config, diff_id, state, false);
    177217    }
    178218
    179     return true;
     219    if ((state)&&(label)) {
     220      return setdiffRunStateByLabel(config, label, state);
     221    }
     222
     223    psError(PS_ERR_UNKNOWN, false, "Required options not found.");
     224
     225    return false;
     226#endif
    180227}
    181228
    … …  
    692739    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    693740
    694     PXOPT_LOOKUP_U64(magicked, config->args,        "-magicked", false, false);
    695     PXOPT_LOOKUP_BOOL(destreaked, config->args,     "-destreaked", false);
    696     PXOPT_LOOKUP_BOOL(not_destreaked, config->args, "-not_destreaked", false);
    697 
     741
     742    psString where2 = NULL;
     743    pxmagicAddWhere(config, &where2, "diffSkyfile");
     744    pxspaceAddWhere(config, &where2, template ? "rawTemplate" : "rawInput");
    698745    psString query = pxDataGet("difftool_skyfile.sql");
    699746    if (!query) {
    … …  
    706753        psStringAppend(&query, " WHERE %s", whereClause);
    707754        psFree(whereClause);
     755    } else if (where2) {
     756        psStringAppend(&query, " WHERE diffRun.diff_id is not null %s", where2);
    708757    } else if (!all) {
    709758        psError(PXTOOLS_ERR_DATA, true, "search parameters or -all are required");
     759        return false;
    710760    }
    711761    psFree(where);
    712 
    713     if (not_destreaked) {
    714         if (destreaked) {
    715             psError(PXTOOLS_ERR_DATA, true, "providing -not_destreaked and -destreaked makes no sense");
    716             return false;
    717         }
    718         if (magicked) {
    719             psError(PXTOOLS_ERR_DATA, true, "providing -not_destreaked and -magicked makes no sense");
    720             return false;
    721         }
    722         psStringAppend(&query, " AND diffSkyfile.magicked = 0");
    723     }
    724     if (destreaked) {
    725         psStringAppend(&query, " AND diffSkyfile.magicked != 0");
    726     }
    727 
    728762
    729763    // treat limit == 0 as "no limit"
    … …  
    878912    }
    879913
    880     char *query = "UPDATE diffRun SET state = '%s', magicked = %" PRId64 " WHERE diff_id = %"PRId64;
    881 
    882     if (!p_psDBRunQueryF(config->dbh, query, state, magicked, diff_id)) {
     914    if (magicked) {
     915      char *query = "UPDATE diffRun SET state = '%s', magicked = %" PRId64 " WHERE diff_id = %"PRId64;
     916     
     917      if (!p_psDBRunQueryF(config->dbh, query, state, magicked, diff_id)) {
    883918        psError(PS_ERR_UNKNOWN, false,
    884919                "failed to change state for diff_id %"PRId64, diff_id);
    885920        return false;
    886     }
    887 
     921      }
     922    }
     923    else {
     924      char *query = "UPDATE diffRun SET state = '%s' WHERE diff_id = %"PRId64;
     925     
     926      if (!p_psDBRunQueryF(config->dbh, query, state, diff_id)) {
     927        psError(PS_ERR_UNKNOWN, false,
     928                "failed to change state for diff_id %"PRId64, diff_id);
     929        return false;
     930      }
     931    }
     932   
    888933    return true;
    889934}
     935
     936
     937#ifdef notdef
     938static bool setdiffRunStateByLabel(pxConfig *config, const char *label, const char *state) {
     939  PS_ASSERT_PTR_NON_NULL(state,false);
     940
     941  // check that state is a valid string value
     942  if (!pxIsValidState(state)) {
     943    psError(PS_ERR_UNKNOWN, false, "invalid diffRun state: %s", state);
     944    return false;
     945  }
     946
     947  char *query = "UPDATE diffRun SET state = '%s' WHERE label = '%s'";
     948  if (!p_psDBRunQueryF(config->dbh,query,state,label)) {
     949    psError(PS_ERR_UNKNOWN, false,
     950            "failed to change state for label %s", label);
     951    return(false);
     952  }
     953
     954  return true;
     955}
     956#endif
    890957
    891958// Generate a single populated run
    … …  
    895962                         const char *tess_id, // Tessellation identifier
    896963                         const char *label, // label
     964                         const char *data_group, // data_group
     965                         const char *dist_group, // dist_group
    897966                         const char *reduction, // reduction
     967                         const char *note,      // note
    898968                         psS64 input_warp_id, // Warp identifier for input image, PS_MAX_S64 for none
    899969                         psS64 input_stack_id, // Stack identifier for input image, PS_MAX_S64 for none
    … …  
    926996            workdir,
    927997            label,
     998            data_group ? data_group : label,
     999            dist_group,
    9281000            reduction,
    9291001            NULL,       // dvodb
    … …  
    9321004            false,
    9331005            false,
    934             0       // magicked
     1006            0,       // magicked
     1007            note
    9351008    );
    9361009
    … …  
    10061079    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", true, false); // required options
    10071080    PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
     1081    PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
     1082    PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false);
    10081083    PXOPT_LOOKUP_STR(reduction, config->args, "-reduction", false, false);
    10091084    PXOPT_LOOKUP_S64(template_warp_id, config->args, "-template_warp_id", false, false);
    … …  
    10121087    PXOPT_LOOKUP_S64(input_stack_id, config->args, "-input_stack_id", false, false);
    10131088    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1089    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
    10141090
    10151091    if (template_stack_id && template_warp_id) {
    … …  
    10351111    psArray *list = psArrayAllocEmpty(16); // List of runs, to print
    10361112
    1037     if (!populatedrun(list, workdir, skycell_id, tess_id, label, reduction,
     1113    if (!populatedrun(list, workdir, skycell_id, tess_id, label, data_group ? data_group : label, dist_group, reduction, note,
    10381114                      input_warp_id ? input_warp_id : PS_MAX_S64,
    10391115                      input_stack_id ? input_stack_id : PS_MAX_S64,
    … …  
    10741150    PXOPT_COPY_STR(config->args, stackWhere, "-stack_label", "stackRun.label", "==");
    10751151
    1076     PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false); // required options
    1077     PXOPT_LOOKUP_STR(reduction, config->args, "-reduction", false, false); // option
    1078     PXOPT_LOOKUP_STR(label, config->args, "-label", false, false); // option
    1079     PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
     1152    PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", true, false); // required option
     1153    PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false); // option
     1154    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false); // option
     1155    PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
     1156    PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false);
     1157    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
     1158    PXOPT_LOOKUP_TIME(registered, config->args, "-set_registered", false, false);
     1159
    10801160    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    10811161    PXOPT_LOOKUP_BOOL(newTemplates, config->args, "-new-templates", false);
    … …  
    13131393                workdir,
    13141394                label,
     1395                data_group ? data_group : label,
     1396                dist_group,
    13151397                reduction,
    13161398                NULL,       // dvodb
    … …  
    13191401                false,                  // bothways
    13201402                true,                   // exposure
    1321                 0       // magicked
     1403                0,       // magicked
     1404                note
    13221405        );
    13231406
    … …  
    13881471    }
    13891472
    1390     if (!diffRunPrintObjects(stdout, list, !simple)) {
     1473    if (numGood && !diffRunPrintObjects(stdout, list, !simple)) {
    13911474        psError(PS_ERR_UNKNOWN, false, "failed to print object");
    13921475        psFree(list);
    … …  
    14691552
    14701553    // Settings to apply to defined run
    1471     PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false); // required options
    1472     PXOPT_LOOKUP_STR(reduction, config->args, "-reduction", false, false); // option
    1473     PXOPT_LOOKUP_STR(label, config->args, "-label", false, false); // option
    1474     PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
     1554    PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", true, false); // required options
     1555    PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false); // option
     1556    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false); // option
     1557    PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false); // option
     1558    PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false); // option
     1559    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false); // option
     1560    PXOPT_LOOKUP_TIME(registered, config->args, "-set_registered", false, false);
     1561
    14751562    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    14761563    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
    … …  
    16561743        }
    16571744
    1658         diffRunRow *run = diffRunRowAlloc(0, "reg", workdir, label, reduction, NULL, registered,
    1659                                           tess_id, true, true, false); // Run to insert
     1745        diffRunRow *run = diffRunRowAlloc(0, "reg", workdir, label, data_group ? data_group : label, dist_group, reduction, NULL, registered,
     1746                                          tess_id, true, true, false, note); // Run to insert
    16601747        if (!diffRunInsertObject(config->dbh, run)) {
    16611748            psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    17381825
    17391826    psMetadata *where = psMetadataAlloc();
    1740     pxAddLabelSearchArgs (config, where, "-label", "diffRun.label", "==");
     1827    pxAddLabelSearchArgs (config, where, "-label", "label", "==");
    17411828
    17421829    psString query = pxDataGet("difftool_pendingcleanuprun.sql");
    … …  
    17601847    }
    17611848
     1849    //    fprintf(stderr,"%s",query);
    17621850    if (!p_psDBRunQuery(config->dbh, query)) {
    17631851        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    19312019
    19322020    return true;
     2021}
     2022
     2023static bool change_skyfile_data_state(pxConfig *config, psString data_state, psString run_state) {
     2024  PS_ASSERT_PTR_NON_NULL(config, false);
     2025
     2026  // diff_id, skycell_id are required
     2027  PXOPT_LOOKUP_S64(diff_id, config->args, "-diff_id", true, false);
     2028  PXOPT_LOOKUP_STR(skycell_id, config->args, "-skycell_id", true, false);
     2029
     2030  psString query = pxDataGet("difftool_change_skyfile_data_state.sql");
     2031
     2032  if (!psDBTransaction(config->dbh)) {
     2033    psError(PS_ERR_UNKNOWN, false, "database error");
     2034    return(false);
     2035  }
     2036
     2037  // Uses the unconstrained (diffRun.state [NEED NOT EQUAL] run_state) version from warptool.c
     2038
     2039  if (!p_psDBRunQueryF(config->dbh, query, data_state, diff_id, skycell_id)) {
     2040    psError(PS_ERR_UNKNOWN, false, "database error");
     2041    // rollback
     2042    if (!psDBRollback(config->dbh)) {
     2043      psError(PS_ERR_UNKNOWN, false, "database error");
     2044    }
     2045    psError(PS_ERR_UNKNOWN, false, "database error");
     2046    return(false);
     2047  }
     2048  psFree(query);
     2049
     2050  query = pxDataGet("difftool_change_run_state.sql");
     2051  if (!p_psDBRunQueryF(config->dbh, query, data_state, diff_id, data_state)) {
     2052    // rollback
     2053    if (!psDBRollback(config->dbh)) {
     2054      psError(PS_ERR_UNKNOWN, false, "database error");
     2055    }
     2056    psError(PS_ERR_UNKNOWN, false, "database error");
     2057    return(false);
     2058  }
     2059
     2060  if (!psDBCommit(config->dbh)) {
     2061    psError(PS_ERR_UNKNOWN, false, "database error");
     2062    return(false);
     2063  }
     2064 
     2065  return(true);
     2066}
     2067
     2068static bool tocleanedskyfileMode(pxConfig *config) {
     2069  return change_skyfile_data_state(config, "cleaned","goto_cleaned");
     2070}
     2071static bool topurgedskyfileMode(pxConfig *config) {
     2072  return change_skyfile_data_state(config, "purged", "goto_purged");
     2073}
     2074static bool toscrubbedskyfileMode(pxConfig *config) {
     2075  return change_skyfile_data_state(config, "scrubbed", "goto_scrubbed");
    19332076}
    19342077
    … …  
    19562099  }
    19572100
     2101  if (!pxExportVersion(config, f)) {
     2102    psError(PS_ERR_UNKNOWN, false, "failed to write dbversion output file");
     2103    return false;
     2104  }
    19582105  psMetadata *where = psMetadataAlloc();
    19592106  PXOPT_COPY_S64(config->args, where, "-diff_id", "diff_id", "==");
    … …  
    20472194  psMetadata *input = psMetadataConfigRead (NULL, &nFail, infile, false);
    20482195
    2049   fprintf (stdout, "---- input ----\n");
     2196#ifdef notdef
     2197  fprintf (stderr, "---- input ----\n");
    20502198  psMetadataPrint (stderr, input, 1);
    2051 
     2199#endif
     2200
     2201  if (!pxCheckImportVersion(config, input)) {
     2202      psError(PS_ERR_UNKNOWN, false, "pxCheckImportVersion failed");
     2203      return false;
     2204  }
    20522205  psMetadataItem *item = psMetadataLookup (input, "diffRun");
    20532206  psAssert (item, "entry not in input?");

  • branches/eam_branches/20090820/ippTools/src/difftool.h

    r25766 r25870  
    4242    DIFFTOOL_MODE_UPDATEDIFFSKYFILE,
    4343    DIFFTOOL_MODE_EXPORTRUN,
    44     DIFFTOOL_MODE_IMPORTRUN
     44    DIFFTOOL_MODE_IMPORTRUN,
     45    DIFFTOOL_MODE_TOCLEANEDSKYFILE,
     46    DIFFTOOL_MODE_TOPURGEDSKYFILE,
     47    DIFFTOOL_MODE_TOSCRUBBEDSKYFILE
     48   
    4549} difftoolMode;
    4650

  • branches/eam_branches/20090820/ippTools/src/difftoolConfig.c

    r25766 r25870  
    4747    // -definerun
    4848    psMetadata *definerunArgs = psMetadataAlloc();
    49     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-workdir", 0,            "define workdir (required)", NULL);
     49    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_workdir", 0,         "define workdir (required)", NULL);
    5050    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-tess_id",  0,            "define tessellation ID (required)", NULL);
    51     psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-bothways",  0,            "do the subtraction both ways?", false);
    52     psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-exposure",  0,            "subtraction for entire exposure?", false);
    53     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-label",  0,            "define label", NULL);
    54     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-reduction",  0,            "define reduction class", NULL);
    55     psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
     51    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-bothways",  0,          "do the subtraction both ways?", false);
     52    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-exposure",  0,          "subtraction for entire exposure?", false);
     53    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_label",  0,          "define label", NULL);
     54    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_reduction",  0,      "define reduction class", NULL);
     55    psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-set_registered",  0,    "time detrend run was registered", now);
     56    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_data_group",  0,     "define data group", NULL);
     57    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_dist_group",  0,     "define dist group", NULL);
     58    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_note",  0,           "define note", NULL);
    5659    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    5760
    5861    // -updaterun
    5962    psMetadata *updaterunArgs = psMetadataAlloc();
    60     psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-diff_id", 0,            "define diff ID (required)", 0);
    61     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,            "set state (required)", NULL);
     63    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-diff_id", 0,          "define diff ID", 0);
     64    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,            "set state", NULL);
     65    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label", 0,            "define by label instead of diff ID", 0);
     66    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_label", 0,        "define new value for label", 0);
     67    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state", 0,        "define new state", NULL);
     68    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_data_group", 0,   "define new data_group", NULL);
     69    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_dist_group", 0,   "define new dist_group", NULL);
     70    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_note", 0,         "define new note", NULL);
    6271
    6372    // -addinputskyfile
    … …  
    134143    psMetadataAddTime(diffskyfileArgs, PS_LIST_TAIL, "-dateobs_end", 0,      "search for exposures by time (<=)", NULL);
    135144    psMetadataAddStr(diffskyfileArgs, PS_LIST_TAIL,  "-filter", 0,           "search for filter", NULL);
    136     psMetadataAddS64(diffskyfileArgs, PS_LIST_TAIL,  "-magicked", 0,         "search by magicked value", 0);
    137     psMetadataAddBool(diffskyfileArgs, PS_LIST_TAIL, "-destreaked",  0,      "search for destreaked images", false);
    138     psMetadataAddBool(diffskyfileArgs, PS_LIST_TAIL, "-not_destreaked",  0,  "search for images that are not destreaked", false);
    139145    psMetadataAddStr(diffskyfileArgs,  PS_LIST_TAIL, "-label",  PS_META_DUPLICATE_OK, "search by diffRun label (LIKE comparison)", NULL);
    140146    psMetadataAddS16(diffskyfileArgs, PS_LIST_TAIL,  "-fault",  0,           "search by fault code", 0);
     147    pxmagicAddArguments(diffskyfileArgs);
     148    pxspaceAddArguments(diffskyfileArgs);
    141149
    142150    psMetadataAddBool(diffskyfileArgs, PS_LIST_TAIL, "-all",  0,             "search without arguments", false);
    … …  
    175183    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-warp_label", 0, "search by warp label", NULL);
    176184    psMetadataAddF32(definewarpstackArgs, PS_LIST_TAIL, "-good_frac", 0, "minimum good fraction of skycell", NAN);
    177     psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-workdir", 0, "define workdir (required)", NULL);
    178     psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-label",  0, "define label", NULL);
    179     psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-reduction",  0, "define reduction class", NULL);
    180     psMetadataAddTime(definewarpstackArgs, PS_LIST_TAIL, "-registered", 0, "time detrend run was registered", now);
     185    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-set_workdir", 0, "define workdir (required)", NULL);
     186    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-set_label",  0, "define label", NULL);
     187    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-set_reduction",  0, "define reduction class", NULL);
     188    psMetadataAddTime(definewarpstackArgs, PS_LIST_TAIL, "-set_registered", 0, "time detrend run was registered", now);
     189    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-set_data_group",  0,     "define data group", NULL);
     190    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-set_dist_group",  0,     "define dist group", NULL);
     191    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-set_note",  0,           "define note", NULL);
    181192    psMetadataAddBool(definewarpstackArgs, PS_LIST_TAIL, "-new-templates", 0, "also search for diffs with new template", false);
    182193    psMetadataAddBool(definewarpstackArgs, PS_LIST_TAIL, "-rerun", 0, "define new run even if one exists", false);
    … …  
    198209    psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-template_label", 0, "search by warp label for template", NULL);
    199210    psMetadataAddF32(definewarpwarpArgs, PS_LIST_TAIL, "-good_frac", 0, "minimum good fraction of skycell", NAN);
    200     psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-workdir", 0, "define workdir (required)", NULL);
    201     psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-label",  0, "define label", NULL);
    202     psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-reduction",  0, "define reduction class", NULL);
    203     psMetadataAddTime(definewarpwarpArgs, PS_LIST_TAIL, "-registered", 0, "time detrend run was registered", now);
     211    psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-set_workdir", 0, "define workdir (required)", NULL);
     212    psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-set_label",  0, "define label", NULL);
     213    psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-set_reduction",  0, "define reduction class", NULL);
     214    psMetadataAddTime(definewarpwarpArgs, PS_LIST_TAIL, "-set_registered", 0, "time detrend run was registered", now);
     215    psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-set_data_group",  0,     "define data group", NULL);
     216    psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-set_dist_group",  0,     "define dist group", NULL);
     217    psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-set_note",  0,           "define note", NULL);
    204218    psMetadataAddBool(definewarpwarpArgs, PS_LIST_TAIL, "-rerun", 0, "define new run even if one exists", false);
    205219    psMetadataAddBool(definewarpwarpArgs, PS_LIST_TAIL, "-available", 0, "define new run even if warpRun has some faults", false);
    … …  
    259273    psMetadataAddS16(updatediffskyfileArgs, PS_LIST_TAIL, "-fault", 0,         "set fault code (required)", 0);
    260274
     275    // -tocleanedskyfile
     276    psMetadata *tocleanedskyfileArgs = psMetadataAlloc();
     277    psMetadataAddS64(tocleanedskyfileArgs, PS_LIST_TAIL, "-diff_id", 0, "difftool ID to update", 0);
     278    psMetadataAddStr(tocleanedskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0, "skycell ID to update", NULL);
     279
     280    // -topurgedskyfile
     281    psMetadata *topurgedskyfileArgs = psMetadataAlloc();
     282    psMetadataAddS64(topurgedskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,    "difftool ID to update", 0);
     283    psMetadataAddStr(topurgedskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0, "skycell ID to update", NULL);
     284
     285    // -toscrubbedskyfile
     286    psMetadata *toscrubbedskyfileArgs = psMetadataAlloc();
     287    psMetadataAddS64(toscrubbedskyfileArgs, PS_LIST_TAIL, "-diff_id", 0, "difftool ID to update", 0);
     288    psMetadataAddStr(toscrubbedskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0, "skycell ID to update", NULL);
     289
    261290    // -exportrun
    262291    psMetadata *exportrunArgs = psMetadataAlloc();
    … …  
    296325    PXOPT_ADD_MODE("-importrun",            "import run from metadata file",           DIFFTOOL_MODE_IMPORTRUN, importrunArgs);
    297326
     327    PXOPT_ADD_MODE("-tocleanedskyfile", "set skyfile as cleaned", DIFFTOOL_MODE_TOCLEANEDSKYFILE, tocleanedskyfileArgs);
     328    PXOPT_ADD_MODE("-topurgedskyfile", "set skyfile as purged", DIFFTOOL_MODE_TOPURGEDSKYFILE, topurgedskyfileArgs);
     329    PXOPT_ADD_MODE("-toscrubbedskyfile", "set skyfile as scrubbed", DIFFTOOL_MODE_TOSCRUBBEDSKYFILE, toscrubbedskyfileArgs);
     330   
    298331    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {
    299332        psError(PS_ERR_UNKNOWN, true, "option parsing failed");

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

    r25766 r25870  
    3232
    3333static bool definebyqueryMode(pxConfig *config);
    34 static bool definerunMode(pxConfig *config);
    3534static bool updaterunMode(pxConfig *config);
    3635static bool revertrunMode(pxConfig *config);
    … …  
    7978    switch (config->mode) {
    8079        MODECASE(DISTTOOL_MODE_DEFINEBYQUERY, definebyqueryMode);
    81         MODECASE(DISTTOOL_MODE_DEFINERUN, definerunMode);
    8280        MODECASE(DISTTOOL_MODE_UPDATERUN, updaterunMode);
    8381        MODECASE(DISTTOOL_MODE_REVERTRUN, revertrunMode);
    … …  
    123121}
    124122
    125 static bool definerunMode(pxConfig *config)
    126 {
    127     PS_ASSERT_PTR_NON_NULL(config, false);
    128 
    129     // required
    130     PXOPT_LOOKUP_STR(stage, config->args, "-stage", true, false);
    131     PXOPT_LOOKUP_S64(stage_id, config->args, "-stage_id",  true, false);
    132     PXOPT_LOOKUP_STR(outroot, config->args, "-outroot", true, false);
    133     PXOPT_LOOKUP_S64(target_id, config->args, "-target_id",  true, false);
    134 
    135     // optional
    136     PXOPT_LOOKUP_BOOL(clean, config->args, "-clean", false);
    137     PXOPT_LOOKUP_BOOL(no_magic, config->args, "-no_magic", false);
    138     PXOPT_LOOKUP_STR(set_label, config->args, "-set_label", false, false);
    139 
    140     // TODO: check that stage has an expected value
    141     // XXX: all of the following concerns will be managed properly by definebyquery
    142 
    143     // TODO: should we check that stage_id actually exists for stage
    144     // in magicdstool we queue off of a magic_id so the stage_id, exp_id, and cam_id get looked up
    145     // when the run is queued
    146 
    147     if (!distRunInsert(config->dbh,
    148             0,          // dist_id
    149             target_id,
    150             stage,
    151             stage_id,
    152             0,
    153             set_label,
    154             outroot,
    155             clean,
    156             no_magic,
    157             "new",
    158             NULL,       // time_stamp
    159             0           // fault
    160             )) {
    161         psError(PS_ERR_UNKNOWN, false, "database error");
    162         return false;
    163     }
    164 
    165     return true;
    166 }
    167123
    168124static bool definebyqueryMode(pxConfig *config)
    … …  
    178134    PXOPT_LOOKUP_BOOL(no_magic, config->args, "-no_magic", false);
    179135    PXOPT_LOOKUP_STR(set_label, config->args, "-set_label", false, false);
     136    PXOPT_LOOKUP_STR(set_note, config->args, "-set_note", false, false);
     137
    180138    PXOPT_LOOKUP_S64(limit, config->args, "-limit", false, false);
    181139    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    191149
    192150    PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
     151    PXOPT_LOOKUP_STR(dist_group, config->args, "-dist_group", false, false);
    193152
    194153    psString query = NULL;
    … …  
    209168            psStringAppend(&query, " AND (chipRun.label = '%s')", label);
    210169        }
     170        if (dist_group) {
     171            psStringAppend(&query, " AND (chipRun.dist_group = '%s')", dist_group);
     172        }
    211173    } else if (!strcmp(stage, "chip")) {
    212174        magicRunType = "chipRun";
    … …  
    222184            psStringAppend(&query, " AND (chipRun.label = '%s')", label);
    223185        }
     186        if (dist_group) {
     187            psStringAppend(&query, " AND (chipRun.dist_group = '%s')", dist_group);
     188        }
    224189    } else if (!strcmp(stage, "camera")) {
    225190        magicRunType = "camRun";    // This is used below to set the magicked business
    … …  
    235200            psStringAppend(&query, " AND (camRun.label = '%s')", label);
    236201        }
     202        if (dist_group) {
     203            psStringAppend(&query, " AND (camRun.dist_group = '%s')", dist_group);
     204        }
    237205    } else if (!strcmp(stage, "fake")) {
    238206        magicRunType = "fakeRun";
    … …  
    246214        if (label) {
    247215            psStringAppend(&query, " AND (fakeRun.label = '%s')", label);
     216        }
     217        if (dist_group) {
     218            psStringAppend(&query, " AND (fakeRun.dist_group = '%s')", dist_group);
    248219        }
    249220        // fake stage doesn't require magic
    … …  
    262233            psStringAppend(&query, " AND (warpRun.label = '%s')", label);
    263234        }
     235        if (dist_group) {
     236            psStringAppend(&query, " AND (warpRun.dist_group = '%s')", dist_group);
     237        }
    264238
    265239    } else if (!strcmp(stage, "diff")) {
    … …  
    276250            psStringAppend(&query, " AND (diffRun.label = '%s')", label);
    277251        }
     252        if (dist_group) {
     253            psStringAppend(&query, " AND (diffRun.dist_group = '%s')", dist_group);
     254        }
    278255
    279256    } else if (!strcmp(stage, "stack")) {
    … …  
    288265        if (label) {
    289266            psStringAppend(&query, " AND (stackRun.label = '%s')", label);
     267        }
     268        if (dist_group) {
     269            psStringAppend(&query, " AND (stackRun.dist_group = '%s')", dist_group);
    290270        }
    291271        // stack stage doesn't require magic
    … …  
    371351        psS64 magic_ds_id = psMetadataLookupS64(NULL, md, "magicked");
    372352        psS64 target_id = psMetadataLookupS64(NULL, md, "target_id");
    373         psString target_label = psMetadataLookupStr(NULL, md, "label");
     353        psString stage_label = psMetadataLookupStr(NULL, md, "label");
    374354        bool clean = psMetadataLookupBool(NULL, md, "clean");
    375355
    … …  
    381361            new_label = set_label;
    382362        } else {
    383             new_label = target_label;
     363            new_label = stage_label;
    384364        }
    385365        distRunRow *row = distRunRowAlloc(
    … …  
    395375                "new",
    396376                NULL,   // time_stamp
    397                 0       // fault
     377                0,       // fault
     378                set_note    // note does not propagate
    398379                );
    399380
    … …  
    12391220
    12401221    // required
    1241     PXOPT_LOOKUP_STR(label, config->args, "-label", true, false);
     1222    PXOPT_LOOKUP_STR(dist_group, config->args, "-dist_group", true, false);
    12421223    PXOPT_LOOKUP_STR(filter, config->args, "-filter", true, false);
    12431224    PXOPT_LOOKUP_STR(stage, config->args, "-stage", true, false);
    … …  
    12501231    distTargetRow *row = distTargetRowAlloc(
    12511232            0,          // target_id
    1252             label,
     1233            dist_group,
    12531234            filter,
    12541235            stage,
    … …  
    12871268    psMetadata *where = psMetadataAlloc();
    12881269    PXOPT_COPY_S64(config->args, where, "-target_id", "target_id", "==");
    1289     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     1270    PXOPT_COPY_STR(config->args, where, "-dist_group", "dist_group", "==");
    12901271    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "==");
    12911272    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
    … …  
    13231304    psMetadata *where = psMetadataAlloc();
    13241305    PXOPT_COPY_S64(config->args, where, "-target_id", "target_id", "==");
    1325     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     1306    PXOPT_COPY_STR(config->args, where, "-dist_group", "dist_group", "LIKE");
    13261307    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "==");
    13271308    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
    … …  
    15181499    PXOPT_LOOKUP_S64(target_id, config->args,    "-target_id", false, false);
    15191500    PXOPT_LOOKUP_STR(stage, config->args,        "-stage", false, false);
    1520     PXOPT_LOOKUP_STR(label, config->args,        "-label", false, false);
     1501    PXOPT_LOOKUP_STR(dist_group, config->args,   "-dist_group", false, false);
    15211502    PXOPT_LOOKUP_STR(filter, config->args,       "-filter", false, false);
    15221503    PXOPT_LOOKUP_BOOL(clean, config->args,       "-clean", false);
    … …  
    15281509            error = true;
    15291510        }
    1530         if (!label) {
    1531             psError(PS_ERR_UNKNOWN, !error, "label is required if target_id is not supplied");
     1511        if (!dist_group) {
     1512            psError(PS_ERR_UNKNOWN, !error, "dist_group is required if target_id is not supplied");
    15321513            error = true;
    15331514        }
    … …  
    15391520    // optional
    15401521    PXOPT_LOOKUP_S64(limit, config->args, "-limit", false, false);
    1541     PXOPT_LOOKUP_STR(state, config->args,        "-set_state", false, false);
     1522    PXOPT_LOOKUP_STR(state, config->args,  "-set_state", false, false);
    15421523    if (state) {
    15431524        if (strcmp(state, "enabled") && strcmp(state, "disabled")) {
    … …  
    15551536    PXOPT_COPY_STR(config->args, where, "-dest_name", "rcDestination.name", "==");
    15561537    PXOPT_COPY_S64(config->args, where, "-target_id", "target_id", "==");
    1557     PXOPT_COPY_STR(config->args, where, "-label", "label", "LIKE");
     1538    PXOPT_COPY_STR(config->args, where, "-dist_group", "dist_group", "LIKE");
    15581539    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "LIKE");
    15591540    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
    … …  
    16581639    PXOPT_COPY_S64(config->args, where, "-target_id", "target_id", "==");
    16591640    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
    1660     PXOPT_COPY_STR(config->args, where, "-label", "label", "LIKE");
     1641    PXOPT_COPY_STR(config->args, where, "-dist_group", "dist_group", "LIKE");
    16611642    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "LIKE");
    16621643    PXOPT_COPY_STR(config->args, where, "-state", "state", "==");

  • branches/eam_branches/20090820/ippTools/src/disttool.h

    r25766 r25870  
    2626    DISTTOOL_MODE_NONE      = 0x0,
    2727    DISTTOOL_MODE_DEFINEBYQUERY,
    28     DISTTOOL_MODE_DEFINERUN,
    2928    DISTTOOL_MODE_UPDATERUN,
    3029    DISTTOOL_MODE_REVERTRUN,

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

    r25766 r25870  
    5050    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-no_magic", 0, "magic is not needed", false);
    5151    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_label",    0, "define label for run", NULL);
     52    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_note",    0, "select by dist_group", NULL);
    5253
    5354    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-dry_run", 0, "don't queue runs just display what would be selected", false);
    … …  
    5859    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-chip_id",       0, "define chip_id", 0);
    5960    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-magic_ds_id",   0, "define chip_id", 0);
    60     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label",         0, "select by label", NULL);
     61    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label",         0, "select by run label", NULL);
     62    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-dist_group",    0, "select by dist_group", NULL);
    6163
    6264    psMetadataAddU64(definebyqueryArgs, PS_LIST_TAIL, "-limit",  0,  "limit result set to N items", 0);
    6365    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    64 
    65     // -definerun
    66     psMetadata *definerunArgs = psMetadataAlloc();
    67     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-stage",         0, "define stage for bundle (required)", NULL);
    68     psMetadataAddS64(definerunArgs, PS_LIST_TAIL, "-stage_id", 0, "define stage_id (required)", 0);
    69     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-outroot",  0, "define output destination (required)", NULL);
    70     psMetadataAddS64(definerunArgs, PS_LIST_TAIL, "-target_id", 0, "define target_id (required)", 0);
    71     psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-clean", 0,   "build clean distribution bundle", false);
    72     psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-no_magic", 0, "magic is not needed", false);
    73     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_label",    0, "define label for run", NULL);
    7466
    7567    // -updaterun
    … …  
    139131    psMetadataAddS64(pendingfilesetArgs, PS_LIST_TAIL, "-dist_id", 0, "define dist_id", 0);
    140132    psMetadataAddStr(pendingfilesetArgs, PS_LIST_TAIL, "-label",   PS_META_DUPLICATE_OK, "limit results to label", NULL);
     133    psMetadataAddStr(pendingfilesetArgs, PS_LIST_TAIL, "-dist_group",   PS_META_DUPLICATE_OK, "limit results to dist_group", NULL);
    141134    psMetadataAddStr(pendingfilesetArgs, PS_LIST_TAIL, "-stage",   0, "limit results to runs for stage", NULL);
    142135    psMetadataAddU64(pendingfilesetArgs, PS_LIST_TAIL, "-limit",   0,  "limit result set to N items", 0);
    … …  
    219212    // -definetarget
    220213    psMetadata *definetargetArgs = psMetadataAlloc();
    221     psMetadataAddStr(definetargetArgs, PS_LIST_TAIL, "-label",     0, "define label (required)", NULL);
     214    psMetadataAddStr(definetargetArgs, PS_LIST_TAIL, "-dist_group", 0, "define dist_group (required)", NULL);
    222215    psMetadataAddStr(definetargetArgs, PS_LIST_TAIL, "-filter",     0, "define filter (required)", NULL);
    223216    psMetadataAddStr(definetargetArgs, PS_LIST_TAIL, "-stage",     0, "define stage (required)", NULL);
    … …  
    230223    psMetadataAddS64(updatetargetArgs, PS_LIST_TAIL, "-target_id", 0, "define target_id", 0);
    231224    psMetadataAddStr(updatetargetArgs, PS_LIST_TAIL, "-stage",     0, "define stage", NULL);
    232     psMetadataAddStr(updatetargetArgs, PS_LIST_TAIL, "-set_state", 0, "define state", NULL);
    233     psMetadataAddStr(updatetargetArgs, PS_LIST_TAIL, "-label",     0, "define label", NULL);
     225    psMetadataAddStr(updatetargetArgs, PS_LIST_TAIL, "-dist_group", 0, "define dist_group", NULL);
    234226    psMetadataAddStr(updatetargetArgs, PS_LIST_TAIL, "-filter",    0, "define filter", NULL);
     227
     228    psMetadataAddStr(updatetargetArgs, PS_LIST_TAIL, "-set_state", 0, "define new state", NULL);
    235229
    236230    // -listtarget
    237231    psMetadata *listtargetArgs = psMetadataAlloc();
    238232    psMetadataAddS64(listtargetArgs, PS_LIST_TAIL, "-target_id", 0, "list target with target_id", 0);
    239     psMetadataAddStr(listtargetArgs, PS_LIST_TAIL, "-label",  0, "list targets for label", NULL);
     233    psMetadataAddStr(listtargetArgs, PS_LIST_TAIL, "-dist_group",  0, "list targets for dist_group", NULL);
    240234    psMetadataAddStr(listtargetArgs, PS_LIST_TAIL, "-filter",    0, "define filter", NULL);
    241235    psMetadataAddStr(listtargetArgs, PS_LIST_TAIL, "-stage",     0, "list targets for stage", NULL);
    … …  
    252246    psMetadataAddS64(defineinterestArgs, PS_LIST_TAIL, "-target_id", 0, "define target_id", 0);
    253247    psMetadataAddStr(defineinterestArgs, PS_LIST_TAIL, "-stage",     0, "define stage", NULL);
    254     psMetadataAddStr(defineinterestArgs, PS_LIST_TAIL, "-label",     0, "define label", NULL);
     248    psMetadataAddStr(defineinterestArgs, PS_LIST_TAIL, "-dist_group",     0, "define dist_group", NULL);
    255249    psMetadataAddStr(defineinterestArgs, PS_LIST_TAIL, "-filter",    0, "define filter (LIKE comparison)", NULL);
    256250    psMetadataAddBool(defineinterestArgs, PS_LIST_TAIL,"-clean",     0, "list clean targets", false);
    … …  
    271265    psMetadataAddS64(listinterestsArgs, PS_LIST_TAIL, "-int_id", 0, "list interests with int_id", 0);
    272266    psMetadataAddStr(listinterestsArgs, PS_LIST_TAIL, "-dest_name",  0, "list interests for destinationn name)", NULL);
    273     psMetadataAddStr(listinterestsArgs, PS_LIST_TAIL, "-label",  0, "list interests for label (LIKE comparison)", NULL);
     267    psMetadataAddStr(listinterestsArgs, PS_LIST_TAIL, "-dist_group",  0, "list interests for dist_group (LIKE comparison)", NULL);
    274268    psMetadataAddStr(listinterestsArgs, PS_LIST_TAIL, "-filter",    0, "list interests by filter (LIKE comparison)", NULL);
    275269    psMetadataAddStr(listinterestsArgs, PS_LIST_TAIL, "-stage",     0, "list interests for stage", NULL);
    … …  
    284278
    285279    PXOPT_ADD_MODE("-definebyquery",    "", DISTTOOL_MODE_DEFINEBYQUERY, definebyqueryArgs);
    286     PXOPT_ADD_MODE("-definerun",    "", DISTTOOL_MODE_DEFINERUN, definerunArgs);
    287280    PXOPT_ADD_MODE("-updaterun",    "", DISTTOOL_MODE_UPDATERUN, updaterunArgs);
    288281    PXOPT_ADD_MODE("-revertrun",    "", DISTTOOL_MODE_REVERTRUN, revertrunArgs);

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

    r25766 r25870  
    177177    PXOPT_LOOKUP_STR(tess_id, config->args, "-set_tess_id", false, false);
    178178    PXOPT_LOOKUP_STR(end_stage, config->args, "-set_end_stage", false, false);
     179    PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
     180    PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false);
     181    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
    179182
    180183    // default
    … …  
    265268
    266269        // queue the exp
    267         if (!pxfakeQueueByCamID(config, cam_id, workdir, label, reduction, expgroup, dvodb, tess_id, end_stage)) {
     270        if (!pxfakeQueueByCamID(config, cam_id, workdir, label, data_group ? data_group : label, dist_group, reduction, expgroup, dvodb, tess_id, end_stage, note)) {
    268271            if (!psDBRollback(config->dbh)) {
    269272                psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    330333    PXOPT_COPY_F32(config->args, where, "-sun_angle_max", "sun_angle", "<");
    331334    PXOPT_COPY_STR(config->args, where, "-label", "fakeRun.label", "==");
    332 
    333     if (!psListLength(where->list)
    334         && !psMetadataLookupBool(NULL, config->args, "-all")) {
     335    PXOPT_COPY_STR(config->args, where, "-data_group", "fakeRun.data_group", "==");
     336    PXOPT_COPY_STR(config->args, where, "-dist_group", "fakeRun.dist_group", "==");
     337
     338    if (!psListLength(where->list)) {
    335339        psFree(where);
    336340        where = NULL;
    … …  
    339343    }
    340344
    341     PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
    342     PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
    343 
    344     if ((!state) && (!label)) {
    345         psError(PXTOOLS_ERR_DATA, false, "parameters are required");
    346         psFree(where);
    347         return false;
    348     }
    349 
    350     if (state) {
    351         // set fakeRun.state to state
    352         if (!pxfakeRunSetStateByQuery(config, where, state)) {
    353             psFree(where);
    354             return false;
    355         }
    356     }
    357 
    358     if (label) {
    359         // set fakeRun.label to label
    360         if (!pxfakeRunSetLabelByQuery(config, where, label)) {
    361             psFree(where);
    362             return false;
    363         }
    364     }
    365 
     345    psString query = psStringCopy("UPDATE fakeRun JOIN camRun USING(cam_id) JOIN chipRun USING(chip_id) JOIN rawExp USING(exp_id)");
     346
     347    // pxUpdateRun gets parameters from config->args and updates
     348    bool result = pxUpdateRun(config, where, &query, "fakeRun", true);
     349    if (!result) {
     350        psError(PXTOOLS_ERR_DATA, false, "pxUpdateRun failed");
     351    }
     352
     353    psFree(query);
    366354    psFree(where);
    367355
    368     return true;
     356    return result;
    369357}
    370358
    … …  
    11621150                                 fakeRun->workdir,
    11631151                                 fakeRun->label,
     1152                                 fakeRun->data_group,
     1153                                 fakeRun->dist_group,
    11641154                                 fakeRun->dvodb,
    11651155                                 fakeRun->tess_id,
    11661156                                 fakeRun->reduction,
    1167                                  fakeRun->end_stage
     1157                                 fakeRun->end_stage,
     1158                                 NULL // note does not propagate
    11681159        )) {
    11691160            psError(PS_ERR_UNKNOWN, false, "failed to queue warpRun");
    … …  
    12791270    return false;
    12801271  }
    1281 
     1272  if (!pxExportVersion(config, f)) {
     1273    psError(PS_ERR_UNKNOWN, false, "failed to write dbversion output file");
     1274    return false;
     1275  }
    12821276  psMetadata *where = psMetadataAlloc();
    12831277  PXOPT_COPY_S64(config->args, where, "-fake_id", "fake_id", "==");
    … …  
    13601354  psMetadata *input = psMetadataConfigRead (NULL, &nFail, infile, false);
    13611355
    1362   fprintf (stdout, "---- input ----\n");
     1356#ifdef notdef
     1357  fprintf (stderr, "---- input ----\n");
    13631358  psMetadataPrint (stderr, input, 1);
    1364 
     1359#endif
     1360
     1361  if (!pxCheckImportVersion(config, input)) {
     1362      psError(PS_ERR_UNKNOWN, false, "pxCheckImportVersion failed");
     1363      return false;
     1364  }
    13651365  psMetadataItem *item = psMetadataLookup (input, "fakeRun");
    13661366  psAssert (item, "entry not in input?");

  • branches/eam_branches/20090820/ippTools/src/faketoolConfig.c

    r25766 r25870  
    9393    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_tess_id",  0,            "define tessellation identifier", NULL);
    9494    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_end_stage",  0,            "define end stage", NULL);
     95    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_dist_group",  0,           "define dist group", NULL);
     96    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_data_group",  0,           "define data group", NULL);
     97    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_note",  0,                 "define note", NULL);
    9598    psMetadataAddBool(queueArgs, PS_LIST_TAIL, "-pretend",  0,            "do not actually modify the database", false);
    9699    psMetadataAddBool(queueArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);
    … …  
    139142    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-sun_angle_min",  0,            "define min solar angle", NAN);
    140143    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-sun_angle_max",  0,            "define max solar angle", NAN);
     144    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0, "search by state", NULL);
    141145    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label", 0, "search by label", NULL);
     146    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-data_group", 0, "search by data_group", NULL);
     147    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-dist_group", 0, "search by data_group", NULL);
    142148
    143149    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state", 0,            "set state", NULL);
    144150    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_label", 0,            "set label", NULL);
    145     psMetadataAddBool(updaterunArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);
     151    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_data_group", 0,   "define new data_group", NULL);
     152    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_dist_group", 0,   "define new dist_group", NULL);
     153    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_note", 0,         "define new note", NULL);
    146154
    147155    // -pendingexp

  • branches/eam_branches/20090820/ippTools/src/flatcorr.c

    r24140 r25870  
    3333#include "pxtools.h"
    3434#include "pxchip.h"
     35#include "pxcam.h"
     36#include "pxadd.h"
    3537#include "flatcorr.h"
    3638
    … …  
    3840static bool definerunMode(pxConfig *config);
    3941static bool addchipMode(pxConfig *config);
     42static bool dropchipMode(pxConfig *config);
    4043static bool addcameraMode(pxConfig *config);
    41 static bool dropchipMode(pxConfig *config);
    4244static bool dropcameraMode(pxConfig *config);
     45static bool advancecameraMode(pxConfig *config);
     46static bool advanceaddstarMode(pxConfig *config);
    4347static bool pendingprocessMode(pxConfig *config);
    4448static bool addprocessMode(pxConfig *config);
    … …  
    4650static bool inputexpMode(pxConfig *config);
    4751static bool inputimfileMode(pxConfig *config);
    48 static bool exportrunMode(pxConfig *config);
    49 static bool importrunMode(pxConfig *config);
    5052
    5153static bool setflatcorrRunState(pxConfig *config, psS64 corr_id, const char *state);
    … …  
    7274        MODECASE(FLATCORR_MODE_DEFINERUN,      definerunMode);
    7375        MODECASE(FLATCORR_MODE_ADDCHIP,        addchipMode);
     76        MODECASE(FLATCORR_MODE_DROPCHIP,       dropchipMode);
    7477        MODECASE(FLATCORR_MODE_ADDCAMERA,      addcameraMode);
    75         MODECASE(FLATCORR_MODE_DROPCHIP,       dropchipMode);
    7678        MODECASE(FLATCORR_MODE_DROPCAMERA,     dropcameraMode);
     79        MODECASE(FLATCORR_MODE_ADVANCECAMERA,  advancecameraMode);
     80        MODECASE(FLATCORR_MODE_ADVANCEADDSTAR, advanceaddstarMode);
    7781        MODECASE(FLATCORR_MODE_PENDINGPROCESS, pendingprocessMode);
    7882        MODECASE(FLATCORR_MODE_ADDPROCESS,     addprocessMode);
    … …  
    8084        MODECASE(FLATCORR_MODE_INPUTEXP,       inputexpMode);
    8185        MODECASE(FLATCORR_MODE_INPUTIMFILE,    inputimfileMode);
    82         MODECASE(FLATCORR_MODE_EXPORTRUN,      exportrunMode);
    83         MODECASE(FLATCORR_MODE_IMPORTRUN,      importrunMode);
    8486        default:
    8587            psAbort("invalid option (this should not happen)");
    … …  
    131133    PXOPT_LOOKUP_STR(tess_id, config->args, "-set_tess_id", false, false);
    132134    PXOPT_LOOKUP_STR(region, config->args, "-set_region", false, false);
     135    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
    133136
    134137    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
    … …  
    233236
    234237        // queue the exp : force this to stop at the chip stage
    235         psS64 chip_id = pxchipQueueByExpTag(config, exp_id, workdir, label, reduction, expgroup, dvodb, tess_id, "chip");
     238        psS64 chip_id = pxchipQueueByExpTag(config, exp_id, workdir, label, label, NULL, reduction, expgroup, dvodb, tess_id, "chip", note);
    236239        if (!chip_id) {
    237240            if (!psDBRollback(config->dbh)) {
    … …  
    297300    // start a transaction so we don't end up with an exp without any associted
    298301    // imfiles
    299     if (!psDBTransaction(config->dbh)) {
    300         psError(PS_ERR_UNKNOWN, false, "database error");
    301         return false;
    302     }
     302    // if (!psDBTransaction(config->dbh)) {
     303    //     psError(PS_ERR_UNKNOWN, false, "database error");
     304    //     return false;
     305    // }
    303306
    304307    // create a new flatcorrRun
    … …  
    333336    row->corr_id = corr_id;
    334337
     338    // if (!psDBCommit(config->dbh)) {
     339    //     psError(PS_ERR_UNKNOWN, false, "database error");
     340    //     return false;
     341    // }
     342
    335343    flatcorrRunPrintObject (stdout, row, !simple);
    336344    return true;
    … …  
    378386}
    379387
     388static bool addcameraMode(pxConfig *config)
     389{
     390    PS_ASSERT_PTR_NON_NULL(config, false);
     391
     392    // required
     393    PXOPT_LOOKUP_S64(corr_id, config->args, "-corr_id", true, false);
     394    PXOPT_LOOKUP_S64(chip_id, config->args, "-chip_id", true, false);
     395    PXOPT_LOOKUP_S64(cam_id, config->args, "-cam_id", true, false);
     396
     397    // add a flatcorrCamLink (initial state has include = TRUE)
     398    // XXX should add checks that the chip_id and corr_id are in ChipLink
     399    if (!flatcorrCamLinkInsert(config->dbh, corr_id, chip_id, cam_id, 1)) {
     400        psError(PS_ERR_UNKNOWN, false, "database error");
     401        return false;
     402    }
     403
     404    return true;
     405}
     406
     407static bool dropcameraMode(pxConfig *config)
     408{
     409    PS_ASSERT_PTR_NON_NULL(config, false);
     410
     411    // required
     412    PXOPT_LOOKUP_S64(corr_id, config->args, "-corr_id", true, false);
     413    PXOPT_LOOKUP_S64(cam_id, config->args, "-cam_id", true, false);
     414
     415    // UPDATE flatcorrCamLink set include = 0 where corr_id = %lld AND cam_id = %lld
     416    psString query = pxDataGet("flatcorr_dropcamera.sql");
     417    if (!query) {
     418        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     419        return false;
     420    }
     421
     422    if (!p_psDBRunQueryF(config->dbh, query, (long long) corr_id, (long long) cam_id)) {
     423        psError(PS_ERR_UNKNOWN, false, "database error");
     424        psFree(query);
     425        return false;
     426    }
     427
     428    return true;
     429}
     430
    380431// select the flatcorr chip runs that have completed and for which there is no camera entry
    381432// queue a new camera run for them
    382 static bool addcameraMode(pxConfig *config)
     433static bool advancecameraMode(pxConfig *config)
    383434{
    384435    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    387438    PXOPT_LOOKUP_BOOL(limit,   config->args, "-limit",   false);
    388439    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
     440
     441    psMetadata *where = psMetadataAlloc();
     442    pxAddLabelSearchArgs (config, where, "-label", "flatcorrRun.label", "==");
    389443
    390444    psString query = pxDataGet("flatcorr_chiprundone.sql");
    … …  
    393447        return false;
    394448    }
     449
     450    if (where && psListLength(where->list)) {
     451        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     452        psStringAppend(&query, " AND %s", whereClause);
     453        psFree(whereClause);
     454    }
     455    psFree(where);
    395456
    396457    // treat limit == 0 as "no limit"
    … …  
    463524                row->workdir,
    464525                row->label,
     526                row->data_group,
     527                row->dist_group,
    465528                row->reduction,
    466529                row->expgroup,
    467530                row->dvodb,
    468531                row->tess_id,
    469                 "camera")) {
     532                "camera",
     533                NULL // note does not propragate
     534                )) {
    470535            if (!psDBRollback(config->dbh)) {
    471536                psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    502567}
    503568
    504 static bool dropcameraMode(pxConfig *config)
    505 {
    506     PS_ASSERT_PTR_NON_NULL(config, false);
    507 
    508     // required
    509     PXOPT_LOOKUP_S64(corr_id, config->args, "-corr_id", true, false);
    510     PXOPT_LOOKUP_S64(cam_id, config->args, "-cam_id", true, false);
    511 
    512     // UPDATE flatcorrCamLink set include = 0 where corr_id = %lld AND cam_id = %lld
    513     psString query = pxDataGet("flatcorr_dropcamera.sql");
    514     if (!query) {
    515         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    516         return false;
    517     }
    518 
    519     if (!p_psDBRunQueryF(config->dbh, query, (long long) corr_id, (long long) cam_id)) {
    520         psError(PS_ERR_UNKNOWN, false, "database error");
    521         psFree(query);
    522         return false;
    523     }
    524 
    525     return true;
    526 }
    527 
    528 // select the flatcorr chip runs that have completed and for which there is no camera entry
    529 // queue a new camera run for them
    530 static bool pendingprocessMode(pxConfig *config)
     569// Select the flatcorr camera runs that have completed and for which there is no addstar
     570// entry.  Queue a new addstar run for them
     571static bool advanceaddstarMode(pxConfig *config)
    531572{
    532573    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    534575    PXOPT_LOOKUP_BOOL(simple,  config->args, "-simple",  false);
    535576    PXOPT_LOOKUP_BOOL(limit,   config->args, "-limit",   false);
     577    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
    536578
    537579    psMetadata *where = psMetadataAlloc();
    538     pxAddLabelSearchArgs (config, where, "-label", "label", "==");
    539 
    540     psString query = pxDataGet("flatcorr_pendingprocess.sql");
     580    pxAddLabelSearchArgs (config, where, "-label", "flatcorrRun.label", "==");
     581
     582    psString query = pxDataGet("flatcorr_camerarundone.sql");
    541583    if (!query) {
    542584        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    … …  
    575617    }
    576618
     619    if (pretend) {
     620        // negative simple so the default is true
     621        if (!ippdbPrintMetadatas(stdout, output, "flatcorr_addcamera", !simple)) {
     622            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     623            psFree(output);
     624            return false;
     625        }
     626    }
     627
     628    // start a transaction so we don't end up with an exp without any associted
     629    // imfiles
     630    if (!psDBTransaction(config->dbh)) {
     631        psError(PS_ERR_UNKNOWN, false, "database error");
     632        psFree(output);
     633        return false;
     634    }
     635
     636    // loop over our list of chipRun rows
     637    for (long i = 0; i < psArrayLength(output); i++) {
     638        psMetadata *md = output->data[i];
     639
     640        bool status;
     641        psS64 corr_id = psMetadataLookupS64(&status, md, "corr_id");
     642        if (!status) {
     643            if (!psDBRollback(config->dbh)) {
     644                psError(PS_ERR_UNKNOWN, false, "database error");
     645            }
     646            psError(PS_ERR_UNKNOWN, false, "failed to lookup value for corr_id");
     647            psFree(output);
     648            return false;
     649        }
     650
     651        camRunRow *row = camRunObjectFromMetadata(md);
     652        if (!row) {
     653            psError(PS_ERR_UNKNOWN, false, "failed to convert metadata into chipRun");
     654            psFree(output);
     655            return false;
     656        }
     657
     658        // queue the exp : force image_only to be false (flatcorr is meaningless with just image info)
     659        if (!pxaddQueueByCamID(
     660                config,
     661                row->cam_id,
     662                row->workdir,
     663                row->reduction,
     664                row->label,
     665                row->data_group,
     666                row->dvodb,
     667                NULL,       // note is not propagated
     668                0)) {
     669            if (!psDBRollback(config->dbh)) {
     670                psError(PS_ERR_UNKNOWN, false, "database error");
     671            }
     672            psError(PS_ERR_UNKNOWN, false,
     673                    "failed to trying to queue cam_id: %" PRId64, row->cam_id);
     674            psFree(row);
     675            psFree(output);
     676            return false;
     677        }
     678
     679        // figure out the ID of the flatcorrRun we just created
     680        psS64 add_id = psDBLastInsertID(config->dbh);
     681
     682        // add the addRun entry to the flatcorrAddstarLink table (include is TRUE)
     683        if (!flatcorrAddstarLinkInsert(config->dbh, corr_id, row->cam_id, add_id, 1)) {
     684            if (!psDBRollback(config->dbh)) {
     685                psError(PS_ERR_UNKNOWN, false, "database error");
     686            }
     687            psError(PS_ERR_UNKNOWN, false, "database error");
     688            return false;
     689        }
     690        psFree(row);
     691    }
     692    psFree(output);
     693
     694    if (!psDBCommit(config->dbh)) {
     695        psError(PS_ERR_UNKNOWN, false, "database error");
     696        return false;
     697    }
     698
     699    return false;
     700}
     701
     702// select the flatcorr chip runs that have completed and for which there is no camera entry
     703// queue a new camera run for them
     704static bool pendingprocessMode(pxConfig *config)
     705{
     706    PS_ASSERT_PTR_NON_NULL(config, false);
     707
     708    PXOPT_LOOKUP_BOOL(simple,  config->args, "-simple",  false);
     709    PXOPT_LOOKUP_BOOL(limit,   config->args, "-limit",   false);
     710
     711    psMetadata *where = psMetadataAlloc();
     712    pxAddLabelSearchArgs (config, where, "-label", "label", "==");
     713
     714    psString query = pxDataGet("flatcorr_pendingprocess.sql");
     715    if (!query) {
     716        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     717        return false;
     718    }
     719
     720    if (where && psListLength(where->list)) {
     721        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     722        psStringAppend(&query, " AND %s", whereClause);
     723        psFree(whereClause);
     724    }
     725    psFree(where);
     726
     727    // treat limit == 0 as "no limit"
     728    if (limit) {
     729        psString limitString = psDBGenerateLimitSQL(limit);
     730        psStringAppend(&query, " %s", limitString);
     731        psFree(limitString);
     732    }
     733
     734    if (!p_psDBRunQuery(config->dbh, query)) {
     735        psError(PS_ERR_UNKNOWN, false, "database error");
     736        psFree(query);
     737        return false;
     738    }
     739
     740    psArray *output = p_psDBFetchResult(config->dbh);
     741    if (!output) {
     742        psError(PS_ERR_UNKNOWN, false, "database error");
     743        return false;
     744    }
     745    if (!psArrayLength(output)) {
     746        psTrace("flatcorr", PS_LOG_INFO, "no rows found");
     747        psFree(output);
     748        return true;
     749    }
     750
    577751    if (!ippdbPrintMetadatas(stdout, output, "flatcorrPending", !simple)) {
    578752        psError(PS_ERR_UNKNOWN, false, "failed to print array");
    579753        psFree(output);
    580754        return false;
     755    }
     756
     757    return true;
     758}
     759
     760// XXX need a fault state
     761static bool addprocessMode(pxConfig *config)
     762{
     763    PS_ASSERT_PTR_NON_NULL(config, false);
     764
     765    PXOPT_LOOKUP_S64(corr_id, config->args, "-corr_id", true, false);
     766    PXOPT_LOOKUP_STR(hostname, config->args, "-hostname", false, false);
     767    PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
     768
     769    char *query = "UPDATE flatcorrRun SET state = 'full', hostname = '%s', fault = '%hd' WHERE corr_id = %" PRId64;
     770
     771    if (!p_psDBRunQueryF(config->dbh, query, hostname, code, corr_id)) {
     772        psError(PS_ERR_UNKNOWN, false, "failed to change state for corr_id %" PRId64, corr_id);
     773        return false;
     774    }
     775
     776    return true;
     777}
     778
     779static bool updaterunMode(pxConfig *config)
     780{
     781    PS_ASSERT_PTR_NON_NULL(config, false);
     782
     783    PXOPT_LOOKUP_S64(corr_id, config->args, "-corr_id", true, false);
     784    PXOPT_LOOKUP_STR(state, config->args, "-state", true, false);
     785
     786    if (!setflatcorrRunState(config, corr_id, state)) {
     787        if (!psDBRollback(config->dbh)) {
     788            psError(PS_ERR_UNKNOWN, false, "database error");
     789        }
     790        psError(PS_ERR_UNKNOWN, false, "failed to set run state");
     791        return false;
    581792    }
    582793
    … …  
    688899}
    689900
    690 // XXX need a fault state
    691 static bool addprocessMode(pxConfig *config)
    692 {
    693     PS_ASSERT_PTR_NON_NULL(config, false);
    694 
    695     PXOPT_LOOKUP_S64(corr_id, config->args, "-corr_id", true, false);
    696     PXOPT_LOOKUP_STR(hostname, config->args, "-hostname", false, false);
    697     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    698 
    699     char *query = "UPDATE flatcorrRun SET state = 'full', hostname = '%s', fault = '%hd' WHERE corr_id = %" PRId64;
    700 
    701     if (!p_psDBRunQueryF(config->dbh, query, hostname, code, corr_id)) {
    702         psError(PS_ERR_UNKNOWN, false, "failed to change state for corr_id %" PRId64, corr_id);
    703         return false;
    704     }
    705 
    706     return true;
    707 }
    708 
    709 static bool updaterunMode(pxConfig *config)
    710 {
    711     PS_ASSERT_PTR_NON_NULL(config, false);
    712 
    713     PXOPT_LOOKUP_S64(corr_id, config->args, "-corr_id", true, false);
    714     PXOPT_LOOKUP_STR(state, config->args, "-state", true, false);
    715 
    716     if (!setflatcorrRunState(config, corr_id, state)) {
    717         if (!psDBRollback(config->dbh)) {
    718             psError(PS_ERR_UNKNOWN, false, "database error");
    719         }
    720         psError(PS_ERR_UNKNOWN, false, "failed to set run state");
    721         return false;
    722     }
    723 
    724     return true;
    725 }
    726 
    727901static bool setflatcorrRunState(pxConfig *config, psS64 corr_id, const char *state)
    728902{
    … …  
    748922    return true;
    749923}
    750 
    751 bool exportrunMode(pxConfig *config)
    752 {
    753   typedef struct ExportTable {
    754     char tableName[80];
    755     char sqlFilename[80];
    756   } ExportTable;
    757  
    758   int numExportTables = 3;
    759 
    760   PS_ASSERT_PTR_NON_NULL(config, NULL);
    761 
    762   PXOPT_LOOKUP_S64(det_id, config->args, "-corr_id", true,  false);
    763   PXOPT_LOOKUP_STR(outfile, config->args, "-outfile", true,  false);
    764   PXOPT_LOOKUP_U64(limit,   config->args, "-limit",   false, false);
    765 
    766   FILE *f = fopen (outfile, "w");
    767   if (f == NULL) {
    768     psError(PS_ERR_UNKNOWN, false, "failed to open output file");
    769     return false;
    770   }
    771 
    772   psMetadata *where = psMetadataAlloc();
    773   PXOPT_COPY_S64(config->args, where, "-corr_id", "corr_id", "==");
    774 
    775   ExportTable tables [] = {
    776     {"flatcorrRun", "flatcorr_export_run.sql"},
    777     {"flatcorrCamLink", "flatcorr_export_cam_link.sql"},
    778     {"flatcorrChipLink", "flatcorr_export_chip_link.sql"},
    779   };
    780 
    781   for (int i=0; i < numExportTables; i++) {
    782     psString query = pxDataGet(tables[i].sqlFilename);
    783     if (!query) {
    784       psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    785       return false;
    786     }
    787 
    788     if (where && psListLength(where->list)) {
    789       psString whereClause = psDBGenerateWhereSQL(where, NULL);
    790       psStringAppend(&query, " %s", whereClause);
    791       psFree(whereClause);
    792     }
    793 
    794     // treat limit == 0 as "no limit"
    795     if (limit) {
    796       psString limitString = psDBGenerateLimitSQL(limit);
    797       psStringAppend(&query, " %s", limitString);
    798       psFree(limitString);
    799     }
    800 
    801     if (!p_psDBRunQuery(config->dbh, query)) {
    802       psError(PS_ERR_UNKNOWN, false, "database error");
    803       psFree(query);
    804       return false;
    805     }
    806     psFree(query);
    807 
    808     psArray *output = p_psDBFetchResult(config->dbh);
    809     if (!output) {
    810       psError(PS_ERR_UNKNOWN, false, "database error");
    811       return false;
    812     }
    813     if (!psArrayLength(output)) {
    814       psTrace("regtool", PS_LOG_INFO, "no rows found");
    815       psFree(output);
    816       return true;
    817     }
    818 
    819     // we must write the export table in non-simple (true) format
    820     if (!ippdbPrintMetadatas(f, output, tables[i].tableName, true)) {
    821       psError(PS_ERR_UNKNOWN, false, "failed to print array");
    822       psFree(output);
    823       return false;
    824     }
    825     psFree(output);
    826   }
    827 
    828     fclose (f);
    829 
    830     return true;
    831 }
    832 
    833 bool importrunMode(pxConfig *config)
    834 {
    835   unsigned int nFail;
    836   psMetadataItem *item, *entry;
    837  
    838   int numImportTables = 3;
    839  
    840   char tables[3] [80] = {"flatcorrRun", "flatcorrCamLink", "flatcorrChipLink"};
    841 
    842   PS_ASSERT_PTR_NON_NULL(config, NULL);
    843  
    844   PXOPT_LOOKUP_STR(infile, config->args, "-infile", true,  false);
    845 
    846   psMetadata *input = psMetadataConfigRead (NULL, &nFail, infile, false);
    847 
    848   fprintf (stdout, "---- input ----\n");
    849   psMetadataPrint (stderr, input, 1);
    850 
    851   for (int i = 0; i < numImportTables; i++) {
    852     item = psMetadataLookup (input, tables[i]);
    853     psAssert (item, "entry not in input?");
    854     psAssert (item->type == PS_DATA_METADATA_MULTI, "entry not multi?");
    855    
    856     entry = psListGet (item->data.list, 0);
    857     assert (entry);
    858     assert (entry->type == PS_DATA_METADATA);
    859  
    860     switch (i) {
    861       case 0:
    862       {
    863         flatcorrRunRow *flatcorrRun = flatcorrRunObjectFromMetadata (entry->data.md);
    864         flatcorrRunInsertObject (config->dbh, flatcorrRun);
    865 
    866         // fprintf (stdout, "---- flatcorr run ----\n");
    867         // psMetadataPrint (stderr, entry->data.md, 1);
    868         break;
    869       }
    870       case 1:
    871       {
    872         flatcorrCamLinkRow *flatcorrCamLink = flatcorrCamLinkObjectFromMetadata (entry->data.md);
    873         flatcorrCamLinkInsertObject (config->dbh, flatcorrCamLink);
    874 
    875         // fprintf (stdout, "---- flatcorr cam link ----\n");
    876         // psMetadataPrint (stderr, entry->data.md, 1);
    877         break;
    878       }
    879       case 2:
    880       {
    881         flatcorrChipLinkRow *flatcorrChipLink = flatcorrChipLinkObjectFromMetadata (entry->data.md);
    882         flatcorrChipLinkInsertObject (config->dbh, flatcorrChipLink);
    883 
    884         // fprintf (stdout, "---- flatcorr chip link ----\n");
    885         // psMetadataPrint (stderr, entry->data.md, 1);
    886         break;
    887       }
    888     }
    889   }
    890   return true;
    891 }

  • branches/eam_branches/20090820/ippTools/src/flatcorr.h

    r23310 r25870  
    2828    FLATCORR_MODE_DEFINERUN,
    2929    FLATCORR_MODE_ADDCHIP,
     30    FLATCORR_MODE_DROPCHIP,
    3031    FLATCORR_MODE_ADDCAMERA,
    31     FLATCORR_MODE_DROPCHIP,
    3232    FLATCORR_MODE_DROPCAMERA,
     33    FLATCORR_MODE_ADVANCECAMERA,
     34    FLATCORR_MODE_ADVANCEADDSTAR,
    3335    FLATCORR_MODE_PENDINGPROCESS,
    3436    FLATCORR_MODE_ADDPROCESS,
    … …  
    3638    FLATCORR_MODE_INPUTEXP,
    3739    FLATCORR_MODE_INPUTIMFILE,
    38     FLATCORR_MODE_EXPORTRUN,
    39     FLATCORR_MODE_IMPORTRUN
    4040} flatcorrMode;
    4141

  • branches/eam_branches/20090820/ippTools/src/flatcorrConfig.c

    r24140 r25870  
    6565    // -definerun
    6666    psMetadata *definerunArgs = psMetadataAlloc();
     67    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-inst", 0, "define camera", NULL);
     68    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-telescope", 0, "define telescope", NULL);
    6769    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-det_type",     0,            "define detrend type to be generated", NULL);
    6870    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_workdir",  0,            "define workdir", NULL);
    … …  
    8890    // -addcamera
    8991    psMetadata *addcameraArgs = psMetadataAlloc();
    90     psMetadataAddU64 (addcameraArgs, PS_LIST_TAIL, "-limit",   0, "limit result set to N items", 0);
    91     psMetadataAddBool(addcameraArgs, PS_LIST_TAIL, "-simple",  0, "use the simple output format", false);
    92     psMetadataAddBool(addcameraArgs, PS_LIST_TAIL, "-pretend", 0, "use the simple output format", false);
     92    psMetadataAddS64(addcameraArgs, PS_LIST_TAIL, "-corr_id", 0,            "define Flat Correction ID (required)", 0);
     93    psMetadataAddS64(addcameraArgs, PS_LIST_TAIL, "-chip_id", 0,            "define Chip ID (required)", 0);
     94    psMetadataAddS64(addcameraArgs, PS_LIST_TAIL, "-cam_id", 0,             "define Camera ID (required)", 0);
    9395
    9496    // -dropcamera
    … …  
    9698    psMetadataAddS64(dropcameraArgs, PS_LIST_TAIL, "-corr_id", 0,      "define Flat Correction ID (required)", 0);
    9799    psMetadataAddS64(dropcameraArgs, PS_LIST_TAIL, "-cam_id", 0,       "define Camera ID (required)", 0);
     100
     101    // -advancecamera
     102    psMetadata *advancecameraArgs = psMetadataAlloc();
     103    psMetadataAddU64 (advancecameraArgs, PS_LIST_TAIL, "-limit",   0, "limit result set to N items", 0);
     104    psMetadataAddBool(advancecameraArgs, PS_LIST_TAIL, "-simple",  0, "use the simple output format", false);
     105    psMetadataAddBool(advancecameraArgs, PS_LIST_TAIL, "-pretend", 0, "use the simple output format", false);
     106    psMetadataAddStr(advancecameraArgs,  PS_LIST_TAIL, "-label",  PS_META_DUPLICATE_OK, "search by label", NULL);
     107
     108    // -advanceaddstar
     109    psMetadata *advanceaddstarArgs = psMetadataAlloc();
     110    psMetadataAddU64 (advanceaddstarArgs, PS_LIST_TAIL, "-limit",   0, "limit result set to N items", 0);
     111    psMetadataAddBool(advanceaddstarArgs, PS_LIST_TAIL, "-simple",  0, "use the simple output format", false);
     112    psMetadataAddBool(advanceaddstarArgs, PS_LIST_TAIL, "-pretend", 0, "use the simple output format", false);
     113    psMetadataAddStr(advanceaddstarArgs,  PS_LIST_TAIL, "-label",  PS_META_DUPLICATE_OK, "search by label", NULL);
    98114
    99115    // -pendingprocess
    … …  
    142158    psMetadata *modes = psMetadataAlloc();
    143159
    144     PXOPT_ADD_MODE("-definebyquery",  "create a new, populated flat correction run",       FLATCORR_MODE_DEFINEBYQUERY,  definebyqueryArgs);
    145     PXOPT_ADD_MODE("-definerun",      "create a new, empty flat correction run",           FLATCORR_MODE_DEFINERUN,      definerunArgs);
    146     PXOPT_ADD_MODE("-addchip",        "add a chip to a flat correction run",               FLATCORR_MODE_ADDCHIP,        addchipArgs);
    147     PXOPT_ADD_MODE("-addcamera",      "migrate completed chips to camera stage analysis", FLATCORR_MODE_ADDCAMERA,      addcameraArgs);
    148     PXOPT_ADD_MODE("-dropchip",       "drop a chip from a flat correction run",            FLATCORR_MODE_DROPCHIP,       dropchipArgs);
    149     PXOPT_ADD_MODE("-dropcamera",     "drop an exposure (camera stage analysis)",          FLATCORR_MODE_DROPCAMERA,     dropcameraArgs);
    150     PXOPT_ADD_MODE("-pendingprocess", "show flat correction runs needing to be processed", FLATCORR_MODE_PENDINGPROCESS, pendingprocessArgs);
    151     PXOPT_ADD_MODE("-addprocess",     "report completed flat correction analysis",         FLATCORR_MODE_ADDPROCESS,     addprocessArgs);
    152     PXOPT_ADD_MODE("-updaterun",      "change a flat calibration run's state",             FLATCORR_MODE_UPDATERUN,      updaterunArgs);
    153     PXOPT_ADD_MODE("-inputexp",       "list exposures for a correction run",               FLATCORR_MODE_INPUTEXP,       inputexpArgs);
    154     PXOPT_ADD_MODE("-inputimfile",    "list imfiles for a chip run",                       FLATCORR_MODE_INPUTIMFILE,    inputimfileArgs);
    155     PXOPT_ADD_MODE("-exportrun",            "export run for import on other database", FLATCORR_MODE_EXPORTRUN, exportrunArgs);
    156     PXOPT_ADD_MODE("-importrun",            "import run from metadata file",           FLATCORR_MODE_IMPORTRUN, importrunArgs);
     160    PXOPT_ADD_MODE("-definebyquery",  "create a new, populated flat correction run",         FLATCORR_MODE_DEFINEBYQUERY,  definebyqueryArgs);
     161    PXOPT_ADD_MODE("-definerun",      "create a new, empty flat correction run",             FLATCORR_MODE_DEFINERUN,      definerunArgs);
     162    PXOPT_ADD_MODE("-addchip",        "add an existing chip run to a flat correction run",   FLATCORR_MODE_ADDCHIP,        addchipArgs);
     163    PXOPT_ADD_MODE("-addcamera",      "add an existing camera run to a flat correction run", FLATCORR_MODE_ADDCAMERA,      addcameraArgs);
     164    PXOPT_ADD_MODE("-advancecamera",  "migrate completed chips to camera stage analysis",    FLATCORR_MODE_ADVANCECAMERA,  advancecameraArgs);
     165    PXOPT_ADD_MODE("-advanceaddstar", "migrate completed exposures to addstar processing",   FLATCORR_MODE_ADVANCEADDSTAR,  advanceaddstarArgs);
     166    PXOPT_ADD_MODE("-dropchip",       "drop a chip from a flat correction run",              FLATCORR_MODE_DROPCHIP,       dropchipArgs);
     167    PXOPT_ADD_MODE("-dropcamera",     "drop an exposure (camera stage analysis)",            FLATCORR_MODE_DROPCAMERA,     dropcameraArgs);
     168    PXOPT_ADD_MODE("-pendingprocess", "show flat correction runs needing to be processed",   FLATCORR_MODE_PENDINGPROCESS, pendingprocessArgs);
     169    PXOPT_ADD_MODE("-addprocess",     "report completed flat correction analysis",           FLATCORR_MODE_ADDPROCESS,     addprocessArgs);
     170    PXOPT_ADD_MODE("-updaterun",      "change a flat calibration run's state",               FLATCORR_MODE_UPDATERUN,      updaterunArgs);
     171    PXOPT_ADD_MODE("-inputexp",       "list exposures for a correction run",                 FLATCORR_MODE_INPUTEXP,       inputexpArgs);
     172    PXOPT_ADD_MODE("-inputimfile",    "list imfiles for a chip run",                         FLATCORR_MODE_INPUTIMFILE,    inputimfileArgs);
    157173
    158174    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

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

    r25766 r25870  
    3333
    3434static bool definebyqueryMode(pxConfig *config);
    35 static psS64 definerunMode(pxConfig *config);
    3635static bool updaterunMode(pxConfig *config);
    3736static bool todestreakMode(pxConfig *config);
    … …  
    4342static bool torevertMode(pxConfig *config);
    4443static bool completedrevertMode(pxConfig *config);
    45 
    46 static bool setmagicDSRunState(pxConfig *config, psS64 magic_id, const char *state);
    47 static bool magicDSGetIDs(pxConfig *config, psString stage, psS64 magic_id, psS64 *stage_id, psS64 *cam_id);
     44static bool tocleanupMode(pxConfig *config);
     45
     46static bool setmagicDSRunState(pxConfig *config, psS64 magic_id, psMetadata *where, const char *state);
    4847
    4948# define MODECASE(caseName, func) \
    … …  
    6665    switch (config->mode) {
    6766        MODECASE(MAGICDSTOOL_MODE_DEFINEBYQUERY,       definebyqueryMode);
    68         MODECASE(MAGICDSTOOL_MODE_DEFINERUN,           definerunMode);
    6967        MODECASE(MAGICDSTOOL_MODE_UPDATERUN,           updaterunMode);
    7068        MODECASE(MAGICDSTOOL_MODE_TODESTREAK,          todestreakMode);
    … …  
    7674        MODECASE(MAGICDSTOOL_MODE_TOREVERT,            torevertMode);
    7775        MODECASE(MAGICDSTOOL_MODE_COMPLETEDREVERT,     completedrevertMode);
     76        MODECASE(MAGICDSTOOL_MODE_TOCLEANUP,           tocleanupMode);
    7877        default:
    7978            psAbort("invalid option (this should not happen)");
    … …  
    108107    PXOPT_LOOKUP_BOOL(noreplace, config->args, "-noreplace", false);
    109108    PXOPT_LOOKUP_STR(set_label, config->args, "-set_label", false, false);
     109    PXOPT_LOOKUP_STR(set_data_group, config->args, "-set_data_group", false, false);
     110    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
    110111    PXOPT_LOOKUP_BOOL(rerun, config->args, "-rerun", false);
    111112    PXOPT_LOOKUP_BOOL(dry_run, config->args, "-dry_run", false);
    … …  
    246247        psS64 cam_id = psMetadataLookupS64(NULL, row, "cam_id");
    247248        psString magicRunLabel = psMetadataLookupStr(NULL, row, "label");
     249        psString magicRunDataGroup = psMetadataLookupStr(NULL, row, "data_group");
    248250        psString magicRunWorkdir = psMetadataLookupStr(NULL, row, "workdir");
    249251       
    … …  
    267269                cam_id,
    268270                set_label ? set_label : magicRunLabel,
     271                set_data_group ? set_data_group : magicRunDataGroup,
    269272                outroot,
    270273                recoveryroot,
    271274                noreplace ? 0 :1,   // re_place
    272                 0); // remove
     275                0,      // remove
     276                0,      // fault
     277                note);  // remove
    273278
    274279        psFree(outroot);
    … …  
    313318}
    314319
    315 static psS64 definerunMode(pxConfig *config)
     320
     321static bool updaterunMode(pxConfig *config)
    316322{
    317323    PS_ASSERT_PTR_NON_NULL(config, false);
    318324
    319325    // required
    320     PXOPT_LOOKUP_S64(magic_id, config->args, "-magic_id", true, false);
    321     PXOPT_LOOKUP_STR(stage, config->args, "-stage", true, false);
    322     PXOPT_LOOKUP_STR(outroot, config->args, "-outroot", true, false);
    323 
    324     // optional
    325     PXOPT_LOOKUP_STR(recoveryroot, config->args, "-recoveryroot", false, false);
    326     PXOPT_LOOKUP_BOOL(re_place, config->args, "-replace", false);
    327     PXOPT_LOOKUP_BOOL(remove, config->args, "-remove", false);
    328     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    329     PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
    330 
    331     psS64 stage_id = 0, cam_id = 0;
    332 
    333     if (!magicDSGetIDs(config, stage, magic_id, &stage_id, &cam_id)) {
    334         psError(PS_ERR_UNKNOWN, false, "failed to get ids");
    335         return false;
    336     }
    337 
    338     magicDSRunRow *run = magicDSRunRowAlloc(
    339             0,          // ID
    340             magic_id,
    341             0,          // inv_magic_id
    342             "new",      // state
    343             stage,
    344             stage_id,
    345             cam_id,
    346             label,
    347             outroot,
    348             recoveryroot,
    349             re_place,
    350             remove
    351     );
    352 
    353     if (!run) {
    354         psError(PS_ERR_UNKNOWN, false, "failed to alloc magicRun object");
    355         return false;
    356     }
    357     if (!magicDSRunInsertObject(config->dbh, run)) {
    358         psError(PS_ERR_UNKNOWN, false, "database error");
    359         psFree(run);
    360         return false;
    361     }
    362 
    363     psS64 magic_ds_id = psDBLastInsertID(config->dbh);
    364     run->magic_ds_id = magic_ds_id;
    365 
    366     if (!magicDSRunPrintObject(stdout, run, !simple)) {
    367             psError(PS_ERR_UNKNOWN, false, "failed to print object");
    368             psFree(run);
    369             return false;
    370     }
    371 
    372     psFree(run);
    373 
    374     return magic_id;
    375 }
    376 
    377 
    378 static bool updaterunMode(pxConfig *config)
    379 {
    380     PS_ASSERT_PTR_NON_NULL(config, false);
    381 
    382     // required
    383     PXOPT_LOOKUP_S64(magic_ds_id, config->args, "-magic_ds_id", true, false);
    384     PXOPT_LOOKUP_STR(state, config->args, "-state", true, false);
    385 
    386     if (state) {
    387         // set detRun.state to state
    388         return setmagicDSRunState(config, magic_ds_id, state);
    389     }
    390 
    391     return true;
     326    PXOPT_LOOKUP_STR(state, config->args, "-set_state", true, false);
     327
     328    PXOPT_LOOKUP_S64(magic_ds_id, config->args, "-magic_ds_id", false, false);
     329    if (magic_ds_id) {
     330
     331        return setmagicDSRunState(config, magic_ds_id, NULL, state);
     332
     333    } else if (!strcmp(state, "full")) {
     334        psError(PS_ERR_UNKNOWN, true, "magic_ds_id is required to update run state to full");
     335        return false;
     336    }
     337    // we can transition by query as well
     338
     339    psMetadata *where = psMetadataAlloc();
     340    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     341    PXOPT_COPY_S64(config->args, where, "-stage_id", "stage_id", "==");
     342    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
     343
     344
     345    if (psListLength(where->list) < 2) {
     346        psError(PS_ERR_UNKNOWN, true, "at least 2 search arguments are required");
     347        return false;
     348    }
     349
     350
     351    PXOPT_LOOKUP_BOOL(noreplace, config->args, "-noreplace", false);
     352    if (!noreplace) {
     353        psMetadataAddS32(where, PS_LIST_TAIL, "re_place", 0, ">", 0);
     354    }
     355    bool result = setmagicDSRunState(config, magic_ds_id, where, state);
     356    psFree(where);
     357
     358    return result;
    392359}
    393360
    … …  
    670637}
    671638
    672 static bool magicDSGetIDs(pxConfig *config, psString stage, psS64 magic_id, psS64 *stage_id, psS64 *cam_id)
    673 {
    674     PS_ASSERT_PTR_NON_NULL(config, false);
    675     PS_ASSERT_PTR_NON_NULL(stage, false);
    676     PS_ASSERT_PTR_NON_NULL(stage_id, false);
    677     PS_ASSERT_PTR_NON_NULL(cam_id, false);
    678 
    679     int stageNum = ippStringToStage(stage);;
    680     if (stageNum == IPP_STAGE_NONE) {
    681         psError(PXTOOLS_ERR_DATA, false, "%s is not a valid value for stage", stage);
    682         return false;
    683     }
    684 
    685     psString query = pxDataGet("magicdstool_getrunids.sql");
    686     if (!query) {
    687         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    688         return false;
    689     }
    690 
    691     if (!p_psDBRunQueryF(config->dbh, query, magic_id)) {
    692         psError(PS_ERR_UNKNOWN, false, "database error");
    693         psFree(query);
    694         return false;
    695     }
    696     psFree(query);
    697 
    698     psArray *output = p_psDBFetchResult(config->dbh);
    699     if (!output) {
    700         psError(PS_ERR_UNKNOWN, false, "database error");
    701         return false;
    702     }
    703     if (!psArrayLength(output)) {
    704         psTrace("magicdstool", PS_LOG_INFO, "no rows found");
    705         psFree(output);
    706         return true;
    707     }
    708     if (psArrayLength(output) > 1) {
    709         psError(PS_ERR_UNKNOWN, true, "unexpected number of rows found %ld for magic_id %" PRId64,
    710             psArrayLength(output), magic_id);
    711         return false;
    712     }
    713     psMetadata *row = output->data[0];
    714 
    715     *cam_id = psMetadataLookupS64(NULL, row, "cam_id");
    716     switch (stageNum) {
    717     case IPP_STAGE_RAW:
    718         *stage_id = psMetadataLookupS64(NULL, row, "exp_id");
    719         break;
    720     case IPP_STAGE_CHIP:
    721         *stage_id = psMetadataLookupS64(NULL, row, "chip_id");
    722         break;
    723     case IPP_STAGE_CAMERA:
    724         *stage_id = *cam_id;
    725         return true;
    726     case IPP_STAGE_WARP:
    727         *stage_id = psMetadataLookupS64(NULL, row, "warp_id");
    728         break;
    729     case IPP_STAGE_DIFF:
    730         *stage_id = psMetadataLookupS64(NULL, row, "diff_id");
    731         break;
    732     }
    733 
    734     return true;
    735 }
    736639
    737640static bool advancerunMode(pxConfig *config)
    … …  
    796699
    797700        // set magicDSRun.state to 'full'
    798         if (!setmagicDSRunState(config, magic_ds_id, "full")) {
     701        if (!setmagicDSRunState(config, magic_ds_id, NULL, "full")) {
    799702            psError(PS_ERR_UNKNOWN, false, "failed to change magicDSRun.state for magic_ds_id: %" PRId64,
    800703                magic_ds_id);
    … …  
    994897}
    995898
    996 static bool setmagicDSRunState(pxConfig *config, psS64 magic_ds_id, const char *state)
    997 {
    998     PS_ASSERT_PTR_NON_NULL(state, false);
    999 
    1000     // check that state is a valid string value
     899static bool validDSRunState(const char *state)
     900{
    1001901    if (!((strcmp(state, "new") == 0) ||
    1002902          (strcmp(state, "full") == 0) ||
    1003903          (strcmp(state, "restored") == 0) ||
    1004904          (strcmp(state, "censored") == 0) ||
    1005           (strcmp(state, "purged") == 0) ||
     905          (strcmp(state, "cleaned") == 0) ||
    1006906          (strcmp(state, "goto_restored") == 0) ||
    1007907          (strcmp(state, "goto_censored") == 0) ||
    1008           (strcmp(state, "goto_purged") == 0))
     908          (strcmp(state, "goto_cleaned") == 0))
    1009909        ) {
     910        return false;
     911    } else {
     912        return true;
     913    }
     914}
     915
     916static bool setmagicDSRunState(pxConfig *config, psS64 magic_ds_id, psMetadata *where, const char *state)
     917{
     918    PS_ASSERT_PTR_NON_NULL(state, false);
     919
     920    if (!validDSRunState(state)) {
    1010921        psError(PS_ERR_UNKNOWN, false,
    1011922                "invalid magicDSRun state: %s", state);
    … …  
    1013924    }
    1014925
    1015     char *query = "UPDATE magicDSRun SET state = '%s' WHERE magic_ds_id = %" PRId64;
    1016     if (!p_psDBRunQueryF(config->dbh, query, state, magic_ds_id)) {
     926    psString query = psStringCopy("UPDATE magicDSRun SET state = '%s'");
     927    if (magic_ds_id) {
     928        psStringAppend(&query, " WHERE magic_ds_id = %" PRId64, magic_ds_id);
     929    } else if (where && psListLength(where->list)) {
     930        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     931        psStringAppend(&query, " WHERE %s", whereClause);
     932        psFree(whereClause);
     933    } else {
     934        psError(PS_ERR_UNKNOWN, true, "search arugments are required");
     935        return false;
     936    }
     937
     938    if (!p_psDBRunQueryF(config->dbh, query, state)) {
    1017939        psError(PS_ERR_UNKNOWN, false,
    1018940                "failed to change state for magic_id %" PRId64, magic_ds_id);
    … …  
    11781100
    11791101
     1102static bool tocleanupMode(pxConfig *config)
     1103{
     1104    PS_ASSERT_PTR_NON_NULL(config, false);
     1105
     1106    psMetadata *where = psMetadataAlloc();
     1107
     1108    PXOPT_COPY_S64(config->args, where, "-stage", "stage", "==");
     1109    PXOPT_COPY_S64(config->args, where, "-magic_ds_id", "magic_ds_id", "==");
     1110    PXOPT_COPY_S64(config->args, where, "-magic_id", "magic_id", "==");
     1111    pxAddLabelSearchArgs (config, where, "-label", "magicDSRun.label", "==");
     1112
     1113    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1114    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1115
     1116    psString query = pxDataGet("magicdstool_tocleanup.sql");
     1117    if (!query) {
     1118        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1119        return false;
     1120    }
     1121
     1122    if (psListLength(where->list)) {
     1123        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1124        psStringAppend(&query, " AND %s", whereClause);
     1125        psFree(whereClause);
     1126    }
     1127    psFree(where);
     1128
     1129    // treat limit == 0 as "no limit"
     1130    if (limit) {
     1131        psString limitString = psDBGenerateLimitSQL(limit);
     1132        psStringAppend(&query, " %s", limitString);
     1133        psFree(limitString);
     1134    }
     1135
     1136    if (!p_psDBRunQuery(config->dbh, query)) {
     1137        psError(PS_ERR_UNKNOWN, false, "database error");
     1138        psFree(query);
     1139        return false;
     1140    }
     1141    psFree(query);
     1142
     1143    psArray *output = p_psDBFetchResult(config->dbh);
     1144    if (!output) {
     1145        psErrorCode err = psErrorCodeLast();
     1146        switch (err) {
     1147            case PS_ERR_DB_CLIENT:
     1148                psError(PXTOOLS_ERR_SYS, false, "database error");
     1149            case PS_ERR_DB_SERVER:
     1150                psError(PXTOOLS_ERR_PROG, false, "database error");
     1151            default:
     1152                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     1153        }
     1154
     1155        return false;
     1156    }
     1157    if (!psArrayLength(output)) {
     1158        psTrace("magicdstool", PS_LOG_INFO, "no rows found");
     1159        psFree(output);
     1160        return true;
     1161    }
     1162
     1163    if (psArrayLength(output)) {
     1164        // negative simple so the default is true
     1165        if (!ippdbPrintMetadatas(stdout, output, "tocleanup", !simple)) {
     1166            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1167            psFree(output);
     1168            return false;
     1169        }
     1170    }
     1171
     1172    psFree(output);
     1173
     1174    return true;
     1175}

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

    r25766 r25870  
    2626    MAGICDSTOOL_MODE_NONE           = 0x0,
    2727    MAGICDSTOOL_MODE_DEFINEBYQUERY,
    28     MAGICDSTOOL_MODE_DEFINERUN,
    2928    MAGICDSTOOL_MODE_UPDATERUN,
    3029    MAGICDSTOOL_MODE_TODESTREAK,
    … …  
    3635    MAGICDSTOOL_MODE_TOREVERT,
    3736    MAGICDSTOOL_MODE_COMPLETEDREVERT,
     37    MAGICDSTOOL_MODE_TOCLEANUP,
    3838} MAGICDStoolMode;
    3939

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

    r25766 r25870  
    5454    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-noreplace", 0, "do not replace input files with the destreaked versions", false);
    5555    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_label",    0, "define label", NULL);
     56    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_data_group", 0, "define data_group", NULL);
     57    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_note", 0, "define note", NULL);
    5658
    5759    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by magicRun.label", NULL);
    … …  
    6971    psMetadataAddU64(definebyqueryArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
    7072
    71     // -definerun
    72     psMetadata *definerunArgs = psMetadataAlloc();
    73     psMetadataAddS64(definerunArgs, PS_LIST_TAIL, "-magic_id", 0, "define magic_id (required)", 0);
    74     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-stage", 0, "define stage for run (required)", NULL);
    75     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-outroot", 0, "define output directory (required)", NULL);
    76     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-recoveryroot", 0, "define recovery directory", NULL);
    77     psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-noreplace", 0, "do not replace the input wit with the destreaked versions", false);
    78 //    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-remove", 0, "use the simple output format", false);
    79     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-label", 0, "define label", NULL);
    80     psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    81 
    8273    // -updaterun
    8374    psMetadata *updaterunArgs = psMetadataAlloc();
    84     psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-magic_ds_id", 0, "define magictool ID (required)", 0);
    85     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0, "set state (required)", NULL);
     75    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state", 0, "set state (required)", NULL);
     76    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-magic_ds_id", 0, "define magictool ID", 0);
     77    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-stage",     0, "define stage", NULL);
     78    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-stage_id", 0, "define stage_id", 0);
     79    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label",     0, "define label", NULL);
     80    psMetadataAddBool(updaterunArgs, PS_LIST_TAIL, "-noreplace", 0, "only update runs with replace not set", false);
    8681
    8782    // -addinputskyfile
    … …  
    153148    psMetadataAddU64(advancerunArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
    154149
     150    // -tocleanup
     151    psMetadata *tocleanupArgs = psMetadataAlloc();
     152    psMetadataAddS64(tocleanupArgs, PS_LIST_TAIL, "-magic_ds_id", 0, "search by magic Destreak ID", 0);
     153    psMetadataAddS64(tocleanupArgs, PS_LIST_TAIL, "-magic_id", 0, "search by magic ID", 0);
     154    psMetadataAddStr(tocleanupArgs, PS_LIST_TAIL, "-stage", 0, "define output directory", NULL);
     155    psMetadataAddStr(tocleanupArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "define label", NULL);
     156    psMetadataAddU64(tocleanupArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
     157    psMetadataAddBool(tocleanupArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    155158    psFree(now);
    156159
    … …  
    160163    PXOPT_ADD_MODE("-definebyquery",       "create magic de-streak runs from magic runs",
    161164                    MAGICDSTOOL_MODE_DEFINEBYQUERY,     definebyqueryArgs);
    162     PXOPT_ADD_MODE("-definerun",           "create one magic de-streak run for one magic run",
    163                     MAGICDSTOOL_MODE_DEFINERUN,         definerunArgs);
    164165    PXOPT_ADD_MODE("-updaterun",           "update state of magic de-streak run",
    165166                    MAGICDSTOOL_MODE_UPDATERUN,         updaterunArgs);
    … …  
    181182    PXOPT_ADD_MODE("-completedrevert", "change state for runs that have finished reverting",
    182183                    MAGICDSTOOL_MODE_COMPLETEDREVERT, completedrevertArgs);
     184    PXOPT_ADD_MODE("-tocleanup", "destreak runs to clean up",
     185                    MAGICDSTOOL_MODE_TOCLEANUP, tocleanupArgs);
    183186
    184187

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

    r25766 r25870  
    117117    // Optional
    118118    PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
     119    PXOPT_LOOKUP_STR(data_group, config->args, "-data_group", false, false);
     120    PXOPT_LOOKUP_STR(note, config->args, "-note", false, false);
    119121    PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false);
    120122    PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    … …  
    236238
    237239        // create a new magicRun for this group
    238         magicRunRow *run = magicRunRowAlloc(0, exp_id, diff_id, inverse, "new", workdir, "dirty", label,
    239                                             dvodb, registered, 0);
     240        magicRunRow *run = magicRunRowAlloc(0,
     241                                            exp_id,
     242                                            diff_id,
     243                                            inverse,
     244                                            "new",      // state
     245                                            workdir,
     246                                            "dirty",    // workdir_state
     247                                            label,
     248                                            data_group ? data_group : label,
     249                                            dvodb,
     250                                            registered,
     251                                            0,          // fault
     252                                            note);
    240253        if (!run) {
    241254            psAbort("failed to alloc magicRun object");
    … …  
    331344            "dirty",    // workdir_state
    332345            label,
     346            NULL,       // data_group
    333347            dvodb,
    334348            registered,
    335             0
     349            0,          // fault
     350            NULL
    336351    );
    337352
    … …  
    14491464    // Now queue any destreaked files to be re-verted
    14501465
    1451     // note: on failure magicRestoreStage issues the rollback
    1452     if (!magicRestoreStage(config, "raw", whereClause, "goto_censored")) {
     1466    // note: on failure pxmagicRestoreStage issues the rollback
     1467    if (!pxmagicRestoreStage(config, "raw", whereClause, "goto_censored")) {
    14531468        psFree(whereClause);
    14541469        return false;
    14551470    }
    1456     if (!magicRestoreStage(config, "chip", whereClause, "goto_censored")) {
     1471    if (!pxmagicRestoreStage(config, "chip", whereClause, "goto_censored")) {
    14571472        psFree(whereClause);
    14581473        return false;
    14591474    }
    1460     if (!magicRestoreStage(config, "camera", whereClause, "goto_censored")) {
     1475    if (!pxmagicRestoreStage(config, "camera", whereClause, "goto_censored")) {
    14611476        psFree(whereClause);
    14621477        return false;
    14631478    }
    1464     if (!magicRestoreStage(config, "warp", whereClause, "goto_censored")) {
     1479    if (!pxmagicRestoreStage(config, "warp", whereClause, "goto_censored")) {
    14651480        psFree(whereClause);
    14661481        return false;
    14671482    }
    1468     if (!magicRestoreStage(config, "diff", whereClause, "goto_censored")) {
     1483    if (!pxmagicRestoreStage(config, "diff", whereClause, "goto_censored")) {
    14691484        psFree(whereClause);
    14701485        return false;

  • branches/eam_branches/20090820/ippTools/src/pstamptool.c

    r25766 r25870  
    4848static bool projectMode(pxConfig *config);
    4949static bool modprojectMode(pxConfig *config);
     50static bool getdependentMode(pxConfig *config);
     51static bool pendingdependentMode(pxConfig *config);
     52static bool updatedependentMode(pxConfig *config);
    5053
    5154# define MODECASE(caseName, func) \
    … …  
    8588        MODECASE(PSTAMPTOOL_MODE_MODPROJECT, modprojectMode);
    8689        MODECASE(PSTAMPTOOL_MODE_PROJECT, projectMode);
     90        MODECASE(PSTAMPTOOL_MODE_GETDEPENDENT, getdependentMode);
     91        MODECASE(PSTAMPTOOL_MODE_PENDINGDEPENDENT, pendingdependentMode);
     92        MODECASE(PSTAMPTOOL_MODE_UPDATEDEPENDENT, updatedependentMode);
    8793        default:
    8894            psAbort("invalid option (this should not happen)");
    … …  
    545551    PXOPT_LOOKUP_S64(exp_id,      config->args, "-exp_id",     false, false);
    546552    PXOPT_LOOKUP_S64(options,     config->args, "-options",     false, false);
     553    PXOPT_LOOKUP_S64(dep_id,      config->args, "-dep_id",     false, false);
    547554
    548555    // unless the job is being inserted with stop state require outputBase
    … …  
    570577            exp_id,
    571578            outputBase,
    572             options
     579            options,
     580            dep_id
    573581            )) {
    574582        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    896904}
    897905
     906static bool getdependentMode(pxConfig *config)
     907{
     908    PS_ASSERT_PTR_NON_NULL(config, false);
     909
     910    PXOPT_LOOKUP_STR(stage,       config->args, "-stage",   true, false);
     911    PXOPT_LOOKUP_S64(stage_id,    config->args, "-stage_id", true, false);
     912    PXOPT_LOOKUP_STR(imagedb,     config->args, "-imagedb",  true, false);
     913    PXOPT_LOOKUP_STR(rlabel,      config->args, "-rlabel",  false, false);
     914    PXOPT_LOOKUP_BOOL(no_magic,   config->args, "-no_magic", false);
     915    PXOPT_LOOKUP_BOOL(no_create,  config->args, "-no_create", false);
     916
     917    psString query = pxDataGet("pstamptool_pendingdependent.sql");
     918    if (!query) {
     919        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     920        return false;
     921    }
     922    if (!p_psDBRunQuery(config->dbh, query)) {
     923        psError(PS_ERR_UNKNOWN, false, "database error");
     924        psFree(query);
     925        return false;
     926    }
     927    psFree(query);
     928
     929    psArray *output = p_psDBFetchResult(config->dbh);
     930    if (!output) {
     931        psError(PS_ERR_UNKNOWN, false, "database error");
     932        return false;
     933    }
     934    if (psArrayLength(output)) {
     935        psMetadata *dep = output->data[0];
     936        psS64 dep_id = psMetadataLookupS64(NULL, dep, "dep_id");
     937        if (!dep_id) {
     938            psError(PS_ERR_UNKNOWN, false, "database error");
     939            return false;
     940        }
     941        printf("%" PRId64 "\n", dep_id);
     942        return true;
     943    }
     944    if (no_create) {
     945        return true;
     946    }
     947    // no existing dependent that matches, insert one
     948
     949    if (!pstampDependentInsert(
     950        config->dbh,
     951        0,              // dep_id
     952        "new",          // state
     953        stage,
     954        stage_id,
     955        imagedb,
     956        rlabel,
     957        no_magic
     958        )) {
     959        psError(PS_ERR_UNKNOWN, false, "failed to insert pstampDependent");
     960        return false;
     961    }
     962
     963    psS64 dep_id = psDBLastInsertID(config->dbh);
     964
     965    printf("%" PRId64 "\n", dep_id);
     966
     967    return true;
     968}
     969
     970static bool pendingdependentMode(pxConfig *config)
     971{
     972    PS_ASSERT_PTR_NON_NULL(config, false);
     973
     974    psMetadata *where = psMetadataAlloc();
     975
     976    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     977    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     978
     979    psString query = pxDataGet("pstamptool_pendingdependent.sql");
     980    if (!query) {
     981        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     982        return false;
     983    }
     984
     985    if (psListLength(where->list)) {
     986        psString whereClause = psDBGenerateWhereConditionSQL(where, "pstampDependent");
     987        psStringAppend(&query, " AND %s", whereClause);
     988        psFree(whereClause);
     989    }
     990    psFree(where);
     991
     992    // treat limit == 0 as "no limit"
     993    if (limit) {
     994        psString limitString = psDBGenerateLimitSQL(limit);
     995        psStringAppend(&query, " %s", limitString);
     996        psFree(limitString);
     997    }
     998
     999    if (!p_psDBRunQuery(config->dbh, query)) {
     1000        psError(PS_ERR_UNKNOWN, false, "database error");
     1001        psFree(query);
     1002        return false;
     1003    }
     1004    psFree(query);
     1005
     1006    psArray *output = p_psDBFetchResult(config->dbh);
     1007    if (!output) {
     1008        psError(PS_ERR_UNKNOWN, false, "database error");
     1009        return false;
     1010    }
     1011    if (!psArrayLength(output)) {
     1012        psTrace("pstamptool", PS_LOG_INFO, "no rows found");
     1013        psFree(output);
     1014        return true;
     1015    }
     1016
     1017    // negative simple so the default is true
     1018    if (!ippdbPrintMetadatas(stdout, output, "pstampDependent", !simple)) {
     1019        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1020        psFree(output);
     1021        return false;
     1022    }
     1023
     1024    psFree(output);
     1025
     1026    return true;
     1027}
     1028static bool updatedependentMode(pxConfig *config)
     1029{
     1030    PS_ASSERT_PTR_NON_NULL(config, false);
     1031
     1032    PXOPT_LOOKUP_S64(dep_id,    config->args, "-dep_id", true, false);
     1033    PXOPT_LOOKUP_STR(state,     config->args, "-set_state",  true, false);
     1034
     1035    char *query ="UPDATE pstampDependent"
     1036        " SET state = '%s'"
     1037        " WHERE dep_id = %" PRId64;
     1038   
     1039    if (!p_psDBRunQueryF(config->dbh, query, state, dep_id)) {
     1040        psError(PS_ERR_UNKNOWN, false, "database error");
     1041        psFree(query);
     1042        return false;
     1043    }
     1044
     1045    psU64 affected = psDBAffectedRows(config->dbh);
     1046    if (affected != 1) {
     1047        psError(PS_ERR_UNKNOWN, false, "should have affected one row but %"
     1048                                        PRIu64 " rows were modified", affected);
     1049        return false;
     1050    }
     1051
     1052    return true;
     1053}

  • branches/eam_branches/20090820/ippTools/src/pstamptool.h

    r25766 r25870  
    4343    PSTAMPTOOL_MODE_MODPROJECT,
    4444    PSTAMPTOOL_MODE_PROJECT,
     45    PSTAMPTOOL_MODE_GETDEPENDENT,
     46    PSTAMPTOOL_MODE_PENDINGDEPENDENT,
     47    PSTAMPTOOL_MODE_UPDATEDEPENDENT,
    4548} pstamptoolMode;
    4649

  • branches/eam_branches/20090820/ippTools/src/pstamptoolConfig.c

    r25766 r25870  
    112112    psMetadataAddS64(addjobArgs, PS_LIST_TAIL, "-exp_id", 0,           "define exposure id", 0);
    113113    psMetadataAddS64(addjobArgs, PS_LIST_TAIL, "-options", 0,          "define options", 0);
     114    psMetadataAddS64(addjobArgs, PS_LIST_TAIL, "-dep_id", 0,           "define job dep_id", 0);
    114115    psMetadataAddS16(addjobArgs, PS_LIST_TAIL, "-fault", 0,            "define job result", 0);
    115116
    … …  
    143144    psMetadataAddBool(revertjobArgs, PS_LIST_TAIL, "-all", 0,       "revert all faulted jobs", false);
    144145    psMetadataAddU64(revertjobArgs, PS_LIST_TAIL, "-limit", 0,      "limit result set to N items", 0);
     146
     147    // -getdependent
     148    psMetadata *getdependentArgs = psMetadataAlloc();
     149    psMetadataAddS64(getdependentArgs, PS_LIST_TAIL, "-stage_id", 0, "define id for dependent run (required)", 0);
     150    psMetadataAddStr(getdependentArgs, PS_LIST_TAIL, "-stage", 0,    "define stage for dependent run (required)", NULL);
     151    psMetadataAddStr(getdependentArgs, PS_LIST_TAIL, "-imagedb", 0,  "define imagedb for depenent run (required)", NULL);
     152    psMetadataAddStr(getdependentArgs, PS_LIST_TAIL, "-rlabel", 0,   "define label for dependent run", NULL);
     153    psMetadataAddBool(getdependentArgs,PS_LIST_TAIL, "-no_magic", 0, "define no_magic", false);
     154    psMetadataAddBool(getdependentArgs,PS_LIST_TAIL, "-no_create", 0, "if no run exists do not create one", false);
     155
     156    // -updatedependent
     157    psMetadata *updatedependentArgs = psMetadataAlloc();
     158    psMetadataAddS64(updatedependentArgs, PS_LIST_TAIL, "-dep_id", 0, "define id for dependent run (required)", 0);
     159    psMetadataAddStr(updatedependentArgs, PS_LIST_TAIL, "-set_state", 0, "new value for state (required)", NULL);
     160
     161    // -pendingdependent
     162    psMetadata *pendingdependentArgs = psMetadataAlloc();
     163    psMetadataAddS64(pendingdependentArgs, PS_LIST_TAIL, "-stage_id", 0, "define id for dependent run", 0);
     164    psMetadataAddStr(pendingdependentArgs, PS_LIST_TAIL, "-stage", 0,    "define stage for dependent run", NULL);
     165    psMetadataAddStr(pendingdependentArgs, PS_LIST_TAIL, "-imagedb", 0,  "define imagedb for depenent run", NULL);
     166    psMetadataAddStr(pendingdependentArgs, PS_LIST_TAIL, "-rlabel", 0,   "define label for dependent run", NULL);
     167    psMetadataAddBool(pendingdependentArgs,PS_LIST_TAIL, "-no_magic", 0, "define no_magic", false);
     168    psMetadataAddBool(pendingdependentArgs,PS_LIST_TAIL, "-no_create", 0, "if no run exists do not create one", false);
     169    psMetadataAddU64(pendingdependentArgs, PS_LIST_TAIL, "-limit",  0,    "limit result set to N items", 0);
     170    psMetadataAddBool(pendingdependentArgs, PS_LIST_TAIL, "-simple", 0,   "use the simple output format", false);
    145171
    146172    // -addproject
    … …  
    189215    PXOPT_ADD_MODE("-moddatastore",    "", PSTAMPTOOL_MODE_MODDATASTORE, moddatastoreArgs);
    190216
     217    PXOPT_ADD_MODE("-getdependent",    "", PSTAMPTOOL_MODE_GETDEPENDENT, getdependentArgs);
     218    PXOPT_ADD_MODE("-updatedependent", "", PSTAMPTOOL_MODE_UPDATEDEPENDENT, updatedependentArgs);
     219    PXOPT_ADD_MODE("-pendingdependent","", PSTAMPTOOL_MODE_PENDINGDEPENDENT, pendingdependentArgs);
     220
    191221    PXOPT_ADD_MODE("-addproject",      "", PSTAMPTOOL_MODE_ADDPROJECT, addprojectArgs);
    192222    PXOPT_ADD_MODE("-modproject",      "", PSTAMPTOOL_MODE_MODPROJECT, modprojectArgs);

  • branches/eam_branches/20090820/ippTools/src/pxadd.c

    r25766 r25870  
    2929#include "pxadd.h"
    3030
    31 bool pxaddSetSearchArgs (psMetadata *md) {
    32 
    33     psMetadataAddS64(md,  PS_LIST_TAIL, "-add_id",            0, "search by add_id", 0);
    34     psMetadataAddS64(md,  PS_LIST_TAIL, "-cam_id",             0, "search by cam_id", 0);
    35 
    36 /*     psMetadataAddStr(md,  PS_LIST_TAIL, "-exp_name",           0, "search by exp_name", NULL); */
    37 /*     psMetadataAddStr(md,  PS_LIST_TAIL, "-inst",               0, "search for camera", NULL); */
    38 /*     psMetadataAddStr(md,  PS_LIST_TAIL, "-telescope",          0, "search for telescope", NULL); */
    39 /*     psMetadataAddTime(md, PS_LIST_TAIL, "-dateobs_begin",      0, "search for exposures by time (>=)", NULL); */
    40 /*     psMetadataAddTime(md, PS_LIST_TAIL, "-dateobs_end",        0, "search for exposures by time (<)", NULL); */
    41 /*     psMetadataAddStr(md,  PS_LIST_TAIL, "-exp_tag",            0, "search by exp_tag", NULL); */
    42 /*     psMetadataAddStr(md,  PS_LIST_TAIL, "-exp_type",           0, "search by exp_type", NULL); */
    43 /*     psMetadataAddStr(md,  PS_LIST_TAIL, "-comment",            0, "search by comment", NULL); */
    44 /*     psMetadataAddStr(md,  PS_LIST_TAIL, "-filelevel",          0, "search by filelevel", NULL); */
    45 /*     psMetadataAddStr(md,  PS_LIST_TAIL, "-filter",             0, "search for filter", NULL); */
    46 /*     psMetadataAddF64(md,  PS_LIST_TAIL, "-airmass_min",        0, "define min airmass", NAN); */
    47 /*     psMetadataAddF64(md,  PS_LIST_TAIL, "-airmass_max",        0, "define max airmass", NAN); */
    48 /*     psMetadataAddF64(md,  PS_LIST_TAIL, "-ra_min",             0, "define min RA (degrees) ", NAN); */
    49 /*     psMetadataAddF64(md,  PS_LIST_TAIL, "-ra_max",             0, "define max RA (degrees) ", NAN); */
    50 /*     psMetadataAddF64(md,  PS_LIST_TAIL, "-decl_min",           0, "define min DEC (degrees)", NAN); */
    51 /*     psMetadataAddF64(md,  PS_LIST_TAIL, "-decl_max",           0, "define max DEC (degrees)", NAN); */
    52 /*     psMetadataAddF32(md,  PS_LIST_TAIL, "-exp_time_min",       0, "define min exposure time", NAN); */
    53 /*     psMetadataAddF32(md,  PS_LIST_TAIL, "-exp_time_max",       0, "define max exposure time", NAN); */
    54 /*     psMetadataAddF32(md,  PS_LIST_TAIL, "-sat_pixel_frac_min", 0, "define max fraction of saturated pixels", NAN); */
    55 /*     psMetadataAddF32(md,  PS_LIST_TAIL, "-sat_pixel_frac_max", 0, "define max fraction of saturated pixels", NAN); */
    56 /*     psMetadataAddF64(md,  PS_LIST_TAIL, "-bg_min",             0, "define min background", NAN); */
    57 /*     psMetadataAddF64(md,  PS_LIST_TAIL, "-bg_max",             0, "define max background", NAN); */
    58 /*     psMetadataAddF64(md,  PS_LIST_TAIL, "-bg_stdev_min",       0, "define min background standard deviation", NAN); */
    59 /*     psMetadataAddF64(md,  PS_LIST_TAIL, "-bg_stdev_max",       0, "define max background standard deviation", NAN); */
    60 /*     psMetadataAddF64(md,  PS_LIST_TAIL, "-bg_mean_stdev_min",  0, "define min background mean standard deviation (across imfiles)", NAN); */
    61 /*     psMetadataAddF64(md,  PS_LIST_TAIL, "-bg_mean_stdev_max",  0, "define max background mean standard deviation (across imfiles)", NAN); */
    62 /*     psMetadataAddF64(md,  PS_LIST_TAIL, "-alt_min",            0, "define min altitude", NAN); */
    63 /*     psMetadataAddF64(md,  PS_LIST_TAIL, "-alt_max",            0, "define max altitude", NAN); */
    64 /*     psMetadataAddF64(md,  PS_LIST_TAIL, "-az_min",             0, "define min azimuth ", NAN); */
    65 /*     psMetadataAddF64(md,  PS_LIST_TAIL, "-az_max",             0, "define max azimuth ", NAN); */
    66 /*     psMetadataAddF32(md,  PS_LIST_TAIL, "-ccd_temp_min",       0, "define min ccd tempature", NAN); */
    67 /*     psMetadataAddF32(md,  PS_LIST_TAIL, "-ccd_temp_max",       0, "define max ccd tempature", NAN); */
    68 /*     psMetadataAddF64(md,  PS_LIST_TAIL, "-posang_min",         0, "define min rotator position angle", NAN); */
    69 /*     psMetadataAddF64(md,  PS_LIST_TAIL, "-posang_max",         0, "define max rotator position angle", NAN); */
    70 /*     psMetadataAddStr(md,  PS_LIST_TAIL, "-object",             0, "search by exposure object", NULL); */
    71 /*     psMetadataAddF32(md,  PS_LIST_TAIL, "-sun_angle_min",      0, "define min solar angle", NAN); */
    72 /*     psMetadataAddF32(md,  PS_LIST_TAIL, "-sun_angle_max",      0, "define max solar angle", NAN); */
    73 
    74     return true;
    75 }
    76 
    77 bool pxaddGetSearchArgs (pxConfig *config, psMetadata *where) {
    78 
    79     PXOPT_COPY_S64(config->args,     where, "-add_id",             "addRun.add_id",        "==");
    80 /*     PXOPT_COPY_S64(config->args,     where, "-cam_id",             "camRun.cam_id",        "=="); */
    81 /*     PXOPT_COPY_S64(config->args,   where, "-chip_id",            "chipRun.chip_id",   "=="); */
    82 /*     PXOPT_COPY_S64(config->args,   where, "-exp_id",             "rawExp.exp_id",     "=="); */
    83 /*     PXOPT_COPY_STR(config->args,   where, "-exp_name",           "rawExp.exp_name",   "=="); */
    84 /*     PXOPT_COPY_STR(config->args,   where, "-inst",               "rawExp.camera",     "=="); */
    85 /*     PXOPT_COPY_STR(config->args,   where, "-telescope",          "rawExp.telescope",  "=="); */
    86 /*     PXOPT_COPY_TIME(config->args,  where, "-dateobs_begin",      "rawExp.dateobs",    ">="); */
    87 /*     PXOPT_COPY_TIME(config->args,  where, "-dateobs_end",        "rawExp.dateobs",    "<="); */
    88 /*     PXOPT_COPY_STR(config->args,   where, "-exp_tag",            "rawExp.exp_tag",    "=="); */
    89 /*     PXOPT_COPY_STR(config->args,   where, "-exp_type",           "rawExp.exp_type",   "=="); */
    90 /*     PXOPT_COPY_STR(config->args,   where, "-comment",            "rawExp.comment",    "LIKE"); */
    91 /*     PXOPT_COPY_STR(config->args,   where, "-filelevel",          "rawExp.filelevel",  "=="); */
    92 /*     PXOPT_COPY_STR(config->args,   where, "-filter",             "rawExp.filter",         "=="); */
    93 /*     PXOPT_COPY_F64(config->args,   where, "-airmass_min",        "rawExp.airmass",        ">="); */
    94 /*     PXOPT_COPY_F64(config->args,   where, "-airmass_max",        "rawExp.airmass",        "<"); */
    95 /*     PXOPT_COPY_RADEC(config->args, where, "-ra_min",             "rawExp.ra",             ">="); */
    96 /*     PXOPT_COPY_RADEC(config->args, where, "-ra_max",             "rawExp.ra",             "<"); */
    97 /*     PXOPT_COPY_RADEC(config->args, where, "-decl_min",           "rawExp.decl",           ">="); */
    98 /*     PXOPT_COPY_RADEC(config->args, where, "-decl_max",           "rawExp.decl",           "<"); */
    99 /*     PXOPT_COPY_F32(config->args,   where, "-exp_time_min",       "rawExp.exp_time",       ">="); */
    100 /*     PXOPT_COPY_F32(config->args,   where, "-exp_time_max",       "rawExp.exp_time",       "<"); */
    101 /*     PXOPT_COPY_F32(config->args,   where, "-sat_pixel_frac_min", "rawExp.sat_pixel_frac", ">="); */
    102 /*     PXOPT_COPY_F32(config->args,   where, "-sat_pixel_frac_max", "rawExp.sat_pixel_frac", "<"); */
    103 /*     PXOPT_COPY_F64(config->args,   where, "-bg_min",             "rawExp.bg",             ">="); */
    104 /*     PXOPT_COPY_F64(config->args,   where, "-bg_max",             "rawExp.bg",             "<"); */
    105 /*     PXOPT_COPY_F64(config->args,   where, "-bg_stdev_min",       "rawExp.bg_stdev",       ">="); */
    106 /*     PXOPT_COPY_F64(config->args,   where, "-bg_stdev_max",       "rawExp.bg_stdev",       "<"); */
    107 /*     PXOPT_COPY_F64(config->args,   where, "-bg_mean_stdev_min",  "rawExp.bg_mean_stdev",  ">="); */
    108 /*     PXOPT_COPY_F64(config->args,   where, "-bg_mean_stdev_max",  "rawExp.bg_mean_stdev",  "<"); */
    109 /*     PXOPT_COPY_F64(config->args,   where, "-alt_min",            "rawExp.alt",            ">="); */
    110 /*     PXOPT_COPY_F64(config->args,   where, "-alt_max",            "rawExp.alt",            "<"); */
    111 /*     PXOPT_COPY_F64(config->args,   where, "-az_min",             "rawExp.az",             ">="); */
    112 /*     PXOPT_COPY_F64(config->args,   where, "-az_max",             "rawExp.az",             "<"); */
    113 /*     PXOPT_COPY_F32(config->args,   where, "-ccd_temp_min",       "rawExp.ccd_temp",       ">="); */
    114 /*     PXOPT_COPY_F32(config->args,   where, "-ccd_temp_max",       "rawExp.ccd_temp",       "<"); */
    115 /*     PXOPT_COPY_F64(config->args,   where, "-posang_min",         "rawExp.posang",         ">="); */
    116 /*     PXOPT_COPY_F64(config->args,   where, "-posang_max",         "rawExp.posang",         "<"); */
    117 /*     PXOPT_COPY_STR(config->args,   where, "-object",             "rawExp.object",         "=="); */
    118 /*     PXOPT_COPY_F32(config->args,   where, "-sun_angle_min",      "rawExp.sun_angle",      ">="); */
    119 /*     PXOPT_COPY_F32(config->args,   where, "-sun_angle_max",      "rawExp.sun_angle",      "<"); */
    120 
    121     return true;
    122 }
    123 
    124 bool pxaddRunSetState(pxConfig *config, psS64 add_id, const char *state, psS64 magicked)
     31bool pxaddRunSetState(pxConfig *config, psS64 add_id, const char *state)
    12532{
    12633    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    13441    }
    13542
    136     char *query = "UPDATE addRun SET state = '%s', magicked = %" PRId64 " WHERE add_id = %" PRId64;
    137     if (!p_psDBRunQueryF(config->dbh, query, state, magicked, add_id)) {
    138         psError(PS_ERR_UNKNOWN, false,
    139                 "failed to change state for add_id %" PRId64, add_id);
     43    char *query = "UPDATE addRun SET state = '%s' WHERE add_id = %" PRId64;
     44    if (!p_psDBRunQueryF(config->dbh, query, state, add_id)) {
     45        psError(PS_ERR_UNKNOWN, false, "failed to change state for add_id %" PRId64, add_id);
    14046        return false;
    14147    }
    … …  
    216122}
    217123
    218 // Need to think more about this to see what we want it to do. BROKEN
    219124bool pxaddQueueByCamID(pxConfig *config,
    220125                       psS64 cam_id,
    221126                       char *workdir,
     127                       char *reduction,
    222128                       char *label,
    223                        char *recipe,
    224                        char *dvodb)
     129                       char *data_group,
     130                       char *dvodb,
     131                       char *note,
     132                       bool image_only)
    225133{
    226134    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    236144        }
    237145    }
    238     //    fprintf(stderr,"%s",query);
     146
    239147    // queue the exp
    240     // XXX chip_id is being cast here work around psS64 have a different type
    241     // different on 32/64
     148    // Note: cam_id is being cast here work around psS64 have a different type different
     149    // on 32/64
    242150    if (!p_psDBRunQueryF(config->dbh, query,
    243151                         "new", // state
    244                          workdir  ? workdir  : "NULL",
     152                         workdir  ? workdir   : "NULL",
    245153                         "dirty", //workdir_state
    246                          label    ? label    : "NULL",
    247                          dvodb    ? dvodb    : "NULL",
    248                          (long long)cam_id
     154                         reduction? reduction : "NULL",
     155                         label    ? label     : "NULL",
     156                         data_group ? data_group     : "NULL",
     157                         dvodb    ? dvodb     : "NULL",
     158                         note     ? note     : "NULL",
     159                         image_only,
     160                         (long long) cam_id
    249161    )) {
    250162        psError(PS_ERR_UNKNOWN, false, "database error");

  • branches/eam_branches/20090820/ippTools/src/pxadd.h

    r25766 r25870  
    2525#include "pxtools.h"
    2626
    27 bool pxaddRunSetState(pxConfig *config, psS64 add_id, const char *state, psS64 magicked);
     27bool pxaddRunSetState(pxConfig *config, psS64 add_id, const char *state);
    2828bool pxaddRunSetStateByQuery(pxConfig *config, psMetadata *where, const char *state);
    2929bool pxaddRunSetLabel(pxConfig *config, psS64 add_id, const char *label);
    3030bool pxaddRunSetLabelByQuery(pxConfig *config, psMetadata *where, const char *label);
    3131
    32 bool pxaddSetSearchArgs (psMetadata *md);
    33 bool pxaddGetSearchArgs (pxConfig *config, psMetadata *where);
    34 
    35 // Likely BROKEN
    3632bool pxaddQueueByCamID(pxConfig *config,
    37                         psS64 cam_id,
    38                         char *workdir,
    39                         char *label,
    40                         char *recipe,
    41                         char *dvodb);
    42 
     33                       psS64 cam_id,
     34                       char *workdir,
     35                       char *reduction,
     36                       char *label,
     37                       char *data_group,
     38                       char *dvodb,
     39                       char *note,
     40                       bool image_only);
    4341
    4442#endif // PXADD_H

  • branches/eam_branches/20090820/ippTools/src/pxadmin.c

    r23310 r25870  
    22 * pxadmin.c
    33 *
    4  * Copyright (C) 2006-2008  Joshua Hoblitt
     4 * Copyright (C) 2006-2009  Joshua Hoblitt
    55 *
    66 * This program is free software; you can redistribute it and/or modify it
    … …  
    3131bool createMirrorMode(pxConfig *config);
    3232bool deleteMode(pxConfig *config);
     33static bool insert_dbversion(pxConfig * config, const char *versionString);
    3334static bool runMultipleStatments(pxConfig *config, const char *query);
    3435
    … …  
    113114    psFree(query);
    114115
     116    if (!insert_dbversion(config, PACKAGE_VERSION)) {
     117        psError(PS_ERR_UNKNOWN, false, "failed to set database version");
     118        return false;
     119    }
     120
    115121    // COMMIT
    116122    if (!psDBCommit(config->dbh)) {
    … …  
    148154    }
    149155    psFree(query);
     156
     157    if (!insert_dbversion(config, PACKAGE_VERSION)) {
     158        psError(PS_ERR_UNKNOWN, false, "failed to set database version");
     159        return false;
     160    }
    150161
    151162    // COMMIT
    … …  
    262273    return true;
    263274}
     275
     276#ifdef notdef
     277static bool update_dbversion(pxConfig * config, const char *versionString)
     278{
     279    psString query = pxDataGet("pxadmin_update_version.sql");
     280    if (!query) {
     281        psError(PS_ERR_UNKNOWN, false, "failed to retrieve SQL statement");
     282        psFree(query);
     283        return false;
     284    }
     285    if (!p_psDBRunQueryF(config->dbh, query, versionString)) {
     286        psError(PS_ERR_UNKNOWN, false, "database error");
     287        psFree(query);
     288        return false;
     289    }
     290    return true;
     291}
     292#endif
     293static bool insert_dbversion(pxConfig * config, const char *versionString)
     294{
     295    psString query = "INSERT INTO dbversion VALUES('%s', CURRENT_TIMESTAMP())";
     296    if (!query) {
     297        psError(PS_ERR_UNKNOWN, false, "failed to retrieve SQL statement");
     298        psFree(query);
     299        return false;
     300    }
     301    if (!p_psDBRunQueryF(config->dbh, query, versionString)) {
     302        psError(PS_ERR_UNKNOWN, false, "database error");
     303        psFree(query);
     304        return false;
     305    }
     306    return true;
     307}

  • branches/eam_branches/20090820/ippTools/src/pxcam.c

    r24866 r25870  
    141141}
    142142
    143 
    144 bool pxcamRunSetStateByQuery(pxConfig *config, psMetadata *where, const char *state)
    145 {
    146     PS_ASSERT_PTR_NON_NULL(config, false);
    147     PS_ASSERT_PTR_NON_NULL(state, false);
    148 
    149     // check that state is a valid string value
    150     if (!pxIsValidState(state)) {
    151         psError(PS_ERR_UNKNOWN, false,
    152                 "invalid chipRun state: %s", state);
    153         return false;
    154     }
    155 
    156     psString query = psStringCopy("UPDATE camRun JOIN chipRun USING(chip_id) JOIN rawExp USING(exp_id) SET camRun.state = '%s'");
    157 
    158     if (where) {
    159         psString whereClause = psDBGenerateWhereSQL(where, NULL);
    160         psStringAppend(&query, " %s", whereClause);
    161         psFree(whereClause);
    162     }
    163 
    164     if (!p_psDBRunQueryF(config->dbh, query, state)) {
    165         psFree(query);
    166         psError(PS_ERR_UNKNOWN, false, "database error");
    167         return false;
    168     }
    169 
    170     psFree(query);
    171 
    172     return true;
    173 }
    174 
    175 
    176 bool pxcamRunSetLabel(pxConfig *config, psS64 cam_id, const char *label)
    177 {
    178     PS_ASSERT_PTR_NON_NULL(config, false);
    179     // note label == NULL should be explicitly allowed
    180 
    181     char *query = "UPDATE camRun SET camRun.label = '%s' WHERE cam_id = %" PRId64;
    182     if (!p_psDBRunQueryF(config->dbh, query, label, cam_id)) {
    183         psError(PS_ERR_UNKNOWN, false,
    184                 "failed to change state for cam_id %" PRId64, cam_id);
    185         return false;
    186     }
    187 
    188     return true;
    189 }
    190 
    191 bool pxcamRunSetLabelByQuery(pxConfig *config, psMetadata *where, const char *label)
    192 {
    193     PS_ASSERT_PTR_NON_NULL(config, false);
    194     // note label == NULL should be explicitly allowed
    195 
    196     psString query = psStringCopy("UPDATE camRun JOIN chipRun USING(chip_id) JOIN rawExp USING(exp_id) SET camRun.label = '%s'");
    197 
    198     if (where) {
    199         psString whereClause = psDBGenerateWhereSQL(where, NULL);
    200         psStringAppend(&query, " %s", whereClause);
    201         psFree(whereClause);
    202     }
    203 
    204     if (!p_psDBRunQueryF(config->dbh, query, label)) {
    205         psFree(query);
    206         psError(PS_ERR_UNKNOWN, false, "database error");
    207         return false;
    208     }
    209 
    210     psFree(query);
    211 
    212     return true;
    213 }
    214 
    215 
    216143bool pxcamQueueByChipID(pxConfig *config,
    217144                    psS64 chip_id,
    218145                    char *workdir,
    219146                    char *label,
     147                    char *data_group,
     148                    char *dist_group,
    220149                    char *recipe,
    221150                    char *expgroup,
    222151                    char *dvodb,
    223152                    char *tess_id,
    224                     char *end_stage)
     153                    char *end_stage,
     154                    char *note)
    225155{
    226156    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    245175                "dirty", //workdir_state
    246176                label    ? label    : "NULL",
     177                data_group ? data_group : "NULL",
     178                dist_group ? dist_group : "NULL",
    247179                recipe   ? recipe   : "NULL",
    248180                expgroup ? expgroup : "NULL",
    … …  
    250182                tess_id  ? tess_id  : "NULL",
    251183                end_stage ? end_stage : "NULL",
     184                note     ? note     : "NULL",
    252185                (long long)chip_id
    253186    )) {

  • branches/eam_branches/20090820/ippTools/src/pxcam.h

    r24681 r25870  
    2626
    2727bool pxcamRunSetState(pxConfig *config, psS64 cam_id, const char *state, psS64 magicked);
    28 bool pxcamRunSetStateByQuery(pxConfig *config, psMetadata *where, const char *state);
    29 bool pxcamRunSetLabel(pxConfig *config, psS64 cam_id, const char *label);
    30 bool pxcamRunSetLabelByQuery(pxConfig *config, psMetadata *where, const char *label);
    31 
    3228bool pxcamSetSearchArgs (psMetadata *md);
    3329bool pxcamGetSearchArgs (pxConfig *config, psMetadata *where);
    … …  
    3733                        char *workdir,
    3834                        char *label,
     35                        char *data_group,
     36                        char *dist_group,
    3937                        char *recipe,
    4038                        char *expgroup,
    4139                        char *dvodb,
    4240                        char *tess_id,
    43                         char *end_stage);
     41                        char *end_stage,
     42                        char *note);
    4443
    4544#endif // PXCAM_H

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

    r24866 r25870  
    192192}
    193193
    194 
    195 bool pxchipRunSetLabel(pxConfig *config, psS64 chip_id, const char *label)
     194bool pxchipProcessedImfileSetStateByQuery(pxConfig *config, psMetadata *where, const char *state)
    196195{
    197196    PS_ASSERT_PTR_NON_NULL(config, false);
    198     // note label == NULL should be explicitly allowed
    199 
    200     char *query = "UPDATE chipRun SET label = '%s' WHERE chip_id = %" PRId64;
    201     if (!p_psDBRunQueryF(config->dbh, query, label, chip_id)) {
    202         psError(PS_ERR_UNKNOWN, false,
    203                 "failed to change state for chip_id %" PRId64, chip_id);
    204         return false;
    205     }
    206 
    207     return true;
    208 }
    209 
    210 
    211 bool pxchipRunSetLabelByQuery(pxConfig *config, psMetadata *where, const char *label)
    212 {
    213     PS_ASSERT_PTR_NON_NULL(config, false);
    214     // note label == NULL should be explicitly allowed
    215 
    216     psString query = psStringCopy("UPDATE chipRun JOIN rawExp USING(exp_id) SET label = '%s'");
     197    PS_ASSERT_PTR_NON_NULL(state, false);
     198
     199    // check that state is a valid string value
     200    if (!pxIsValidState(state)) {
     201        psError(PS_ERR_UNKNOWN, false, "invalid chipProcessedImfile state: %s", state);
     202        return false;
     203    }
     204
     205/*     if (!strcmp(state, "full")) { */
     206/*         // There are states that need to be met for a run to be set to full that we don't */
     207/*         // check here. */
     208/*         // for example all of the run's Imfiles must have chipProcessedImfile.data_state == "full" */
     209/*         // chipRun.magicked = (SUM(!chipProcessedImfile.magicked) = 0) */
     210/*         // so don't do allow setting the state to full */
     211/*         psError(PS_ERR_UNKNOWN, true, "cannot use -updaterun so set chipRun state to full"); */
     212/*         return false; */
     213/*     } */
     214
     215    psString query = psStringCopy("UPDATE chipProcessedImfile JOIN chipRun USING(chip_id) JOIN rawExp ON chipRun.exp_id = rawExp.exp_id SET state = '%s'");
    217216
    218217    if (where && psListLength(where->list) > 0) {
    … …  
    222221    }
    223222
    224     if (!p_psDBRunQueryF(config->dbh, query, label)) {
     223    if (!p_psDBRunQueryF(config->dbh, query, state)) {
    225224        psFree(query);
    226225        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    232231    return true;
    233232}
    234 
    235233
    236234psS64 pxchipQueueByExpTag(pxConfig *config,
    … …  
    238236                         const char *workdir,
    239237                         const char *label,
     238                         const char *data_group,
     239                         const char *dist_group,
    240240                         const char *reduction,
    241241                         const char *expgroup,
    242242                         const char *dvodb,
    243243                         const char *tess_id,
    244                          const char *end_stage)
     244                         const char *end_stage,
     245                         const char *note)
    245246{
    246247    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    260261            "dirty",    // workdir_state
    261262            label,
     263            data_group,
     264            dist_group,
    262265            reduction,
    263266            expgroup,
    … …  
    265268            tess_id,
    266269            end_stage,
    267             0           // magicked
     270            0,          // magicked
     271            note
    268272            )
    269273    ) {

  • branches/eam_branches/20090820/ippTools/src/pxchip.h

    r23381 r25870  
    2525#include "pxtools.h"
    2626
     27
     28
    2729bool pxchipRunSetState(pxConfig *config, psS64 chip_id, const char *state, const bool magicked);
    28 bool pxchipRunSetStateByQuery(pxConfig *config, psMetadata *where, const char *state);
    29 bool pxchipRunSetLabel(pxConfig *config, psS64 chip_id, const char *label);
    30 bool pxchipRunSetLabelByQuery(pxConfig *config, psMetadata *where, const char *label);
     30bool pxchipProcessedImfileSetStateByQuery(pxConfig *config, psMetadata *where, const char *state);
    3131
    3232psS64 pxchipQueueByExpTag(pxConfig *config,
    … …  
    3434                         const char *workdir,
    3535                         const char *label,
     36                         const char *data_group,
     37                         const char *dist_group,
    3638                         const char *reduction,
    3739                         const char *expgroup,
    3840                         const char *dvodb,
    3941                         const char *tess_id,
    40                          const char *end_stage);
     42                         const char *end_stage,
     43                         const char *note);
    4144
    4245

  • branches/eam_branches/20090820/ippTools/src/pxfake.c

    r21402 r25870  
    5151}
    5252
    53 
    54 bool pxfakeRunSetStateByQuery(pxConfig *config, psMetadata *where, const char *state)
    55 {
    56     PS_ASSERT_PTR_NON_NULL(config, false);
    57     PS_ASSERT_PTR_NON_NULL(state, false);
    58 
    59     // check that state is a valid string value
    60     if (!pxIsValidState(state)) {
    61         psError(PS_ERR_UNKNOWN, false,
    62                 "invalid fakeRun state: %s", state);
    63         return false;
    64     }
    65 
    66     psString query = psStringCopy("UPDATE fakeRun JOIN camRun USING(cam_id) JOIN chipRun USING(chip_id) JOIN rawExp USING(exp_id) SET fakeRun.state = '%s'");
    67 
    68     if (where) {
    69         psString whereClause = psDBGenerateWhereSQL(where, NULL);
    70         psStringAppend(&query, " %s", whereClause);
    71         psFree(whereClause);
    72     }
    73 
    74     if (!p_psDBRunQueryF(config->dbh, query, state)) {
    75         psFree(query);
    76         psError(PS_ERR_UNKNOWN, false, "database error");
    77         return false;
    78     }
    79 
    80     psFree(query);
    81 
    82     return true;
    83 }
    84 
    85 
    86 bool pxfakeRunSetLabel(pxConfig *config, psS64 fake_id, const char *label)
    87 {
    88     PS_ASSERT_PTR_NON_NULL(config, false);
    89     // note label == NULL should be explicitly allowed
    90 
    91     char *query = "UPDATE fakeRun SET fakeRun.label = '%s' WHERE fake_id = %" PRId64;
    92     if (!p_psDBRunQueryF(config->dbh, query, label, fake_id)) {
    93         psError(PS_ERR_UNKNOWN, false,
    94                 "failed to change state for fake_id %" PRId64, fake_id);
    95         return false;
    96     }
    97 
    98     return true;
    99 }
    100 
    101 
    102 bool pxfakeRunSetLabelByQuery(pxConfig *config, psMetadata *where, const char *label)
    103 {
    104     PS_ASSERT_PTR_NON_NULL(config, false);
    105     // note label == NULL should be explicitly allowed
    106 
    107     psString query = psStringCopy("UPDATE fakeRun JOIN camRun USING(cam_id) JOIN chipRun USING(chip_id) JOIN rawExp USING(exp_id) SET fakeRun.label = '%s'");
    108 
    109     if (where) {
    110         psString whereClause = psDBGenerateWhereSQL(where, NULL);
    111         psStringAppend(&query, " %s", whereClause);
    112         psFree(whereClause);
    113     }
    114 
    115     if (!p_psDBRunQueryF(config->dbh, query, label)) {
    116         psFree(query);
    117         psError(PS_ERR_UNKNOWN, false, "database error");
    118         return false;
    119     }
    120 
    121     psFree(query);
    122 
    123     return true;
    124 }
    125 
    126 
    12753psS64 pxfakeQueueByCamID(pxConfig *config,
    12854                    psS64 cam_id,
    12955                    char *workdir,
    13056                    char *label,
     57                    char *data_group,
     58                    char *dist_group,
    13159                    char *reduction,
    13260                    char *expgroup,
    13361                    char *dvodb,
    13462                    char *tess_id,
    135                     char *end_stage)
     63                    char *end_stage,
     64                    char *note)
    13665{
    13766    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    15786                workdir  ? workdir  : "NULL",
    15887                label    ? label    : "NULL",
     88                data_group ? data_group : "NULL",
     89                dist_group ? dist_group : "NULL",
    15990                reduction? reduction: "NULL",
    16091                expgroup ? expgroup : "NULL",
    … …  
    16293                tess_id  ? tess_id  : "NULL",
    16394                end_stage ? end_stage : "NULL",
     95                note     ? note     : "NULL",
    16496                (long long)cam_id
    16597    )) {

  • branches/eam_branches/20090820/ippTools/src/pxfake.h

    r17938 r25870  
    2626
    2727bool pxfakeRunSetState(pxConfig *config, psS64 fake_id, const char *state);
    28 bool pxfakeRunSetStateByQuery(pxConfig *config, psMetadata *where, const char *state);
    29 bool pxfakeRunSetLabel(pxConfig *config, psS64 fake_id, const char *label);
    30 bool pxfakeRunSetLabelByQuery(pxConfig *config, psMetadata *where, const char *label);
    31 
    3228
    3329psS64 pxfakeQueueByCamID(pxConfig *config,
    … …  
    3531                    char *workdir,
    3632                    char *label,
     33                    char *data_group,
     34                    char *dist_group,
    3735                    char *reduction,
    3836                    char *expgroup,
    3937                    char *dvodb,
    4038                    char *tess_id,
    41                     char *end_stage);
     39                    char *end_stage,
     40                    char *note);
    4241
    4342

  • branches/eam_branches/20090820/ippTools/src/pxmagic.c

    r25766 r25870  
    2929#include "pxmagic.h"
    3030
    31 bool magicRestoreStage(pxConfig *config, psString stage, psString whereClause, psString newState)
     31bool pxmagicRestoreStage(pxConfig *config, psString stage, psString whereClause, psString newState)
    3232{
    3333    psString queryFile = NULL;
    … …  
    6666    return true;
    6767}
     68
     69bool pxmagicAddWhere(pxConfig *config, psString *out, psString table)
     70{
     71    PXOPT_LOOKUP_U64(magicked, config->args, "-magicked", false, false);
     72    PXOPT_LOOKUP_BOOL(destreaked, config->args,     "-destreaked", false);
     73    PXOPT_LOOKUP_BOOL(not_destreaked, config->args, "-not_destreaked", false);
     74
     75    if (not_destreaked) {
     76        if (destreaked) {
     77            psError(PXTOOLS_ERR_DATA, true, "providing -not_destreaked and -destreaked makes no sense");
     78            return false;
     79        }
     80        if (magicked) {
     81            psError(PXTOOLS_ERR_DATA, true, "providing -not_destreaked and -magicked makes no sense");
     82            return false;
     83        }
     84        psStringAppend(out, " AND %s.magicked = 0", table);
     85    }
     86    if (destreaked) {
     87        psStringAppend(out, " AND %s.magicked != 0", table);
     88    }
     89    return true;
     90}
     91
     92void pxmagicAddArguments(psMetadata *md)
     93{
     94    psMetadataAddBool(md, PS_LIST_TAIL, "-destreaked",  0,      "search for destreaked images", false);
     95    psMetadataAddBool(md, PS_LIST_TAIL, "-not_destreaked",  0,  "search for images that have not been destreaked", false);
     96    psMetadataAddS64(md, PS_LIST_TAIL,  "-magicked", 0,         "search by magicked value", 0);
     97}

  • branches/eam_branches/20090820/ippTools/src/pxmagic.h

    r25766 r25870  
    2525#include "pxtools.h"
    2626
    27 extern bool magicRestoreStage(pxConfig *config, psString stage, psString whereClause, psString newState);
     27extern bool pxmagicRestoreStage(pxConfig *config, psString stage, psString whereClause, psString newState);
     28
     29extern bool pxmagicAddWhere(pxConfig *config, psString *string, psString table);
     30extern void pxmagicAddArguments(psMetadata *md);
    2831
    2932#endif // PXMAGIC_H

  • branches/eam_branches/20090820/ippTools/src/pxtools.c

    r25766 r25870  
    108108    return true;
    109109}
     110
     111// shared code for updating the various strings for a Run
     112bool pxUpdateRun(pxConfig *config, psMetadata *where, psString *pQuery, psString table, bool has_dist_group)
     113{
     114    PS_ASSERT_PTR_NON_NULL(config, false);
     115    PS_ASSERT_PTR_NON_NULL(where, false);
     116    PS_ASSERT_PTR_NON_NULL(pQuery, false);
     117    PS_ASSERT_PTR_NON_NULL(*pQuery, false);
     118
     119    // make sure that -state is not the only selection parameter
     120    PXOPT_LOOKUP_STR(where_state, config->args, "-state", false, false);
     121    if (where_state && (psListLength(where->list) < 2)) {
     122        psError(PXTOOLS_ERR_DATA, true, "selection by -state alone is not allowed");
     123        return false;
     124    }
     125
     126    PXOPT_LOOKUP_STR(state, config->args,       "-set_state", false, false);
     127    PXOPT_LOOKUP_STR(label, config->args,       "-set_label", false, false);
     128    PXOPT_LOOKUP_STR(data_group, config->args,  "-set_data_group", false, false);
     129    PXOPT_LOOKUP_STR(note, config->args,        "-set_note", false, false);
     130
     131    psString dist_group = NULL;
     132    if (has_dist_group) {
     133        PXOPT_LOOKUP_STR(tmp_dist_group, config->args,  "-set_dist_group", false, false);
     134        dist_group = tmp_dist_group;
     135    }
     136
     137    if ((!state) && (!label) && (!data_group) && (has_dist_group && !dist_group) && !(note)) {
     138        psError(PXTOOLS_ERR_DATA, false, "parameters are required");
     139        return false;
     140    }
     141
     142    if (state && ! pxIsValidState(state)) {
     143        psError(PXTOOLS_ERR_DATA, false, "pxIsValidState failed");
     144        return false;
     145    }
     146
     147    // first paramter is added with "SET param = 'value'"
     148    // subseqent ones with ", param = 'value'"
     149    char *separator = " SET ";
     150    char *comma = ",";
     151
     152#   define addColumn(_tab, _val) \
     153        do { \
     154            if (_val) { \
     155                psStringAppend(pQuery, "%s %s.%s = '%s'", separator, _tab, #_val, _val); \
     156                separator = comma; \
     157            } \
     158        } while (0)
     159
     160    addColumn(table, state);
     161    addColumn(table, data_group);
     162    if (has_dist_group) {
     163        addColumn(table, dist_group);
     164    }
     165    addColumn(table, note);
     166    addColumn(table, label);
     167
     168    psString whereClause =  psDBGenerateWhereSQL(where, NULL);
     169    psStringAppend(pQuery, " %s", whereClause);
     170    psFree(whereClause);
     171
     172    if (!p_psDBRunQuery(config->dbh, *pQuery)) {
     173        psError(PS_ERR_UNKNOWN, false, "database error");
     174        return false;
     175    }
     176
     177    return true;
     178}
     179
     180bool pxLookupVersion(pxConfig *config, psArray **pArray)
     181{
     182    const char *query = "SELECT * FROM dbversion";
     183
     184    if (!p_psDBRunQuery(config->dbh, query)) {
     185        psError(PS_ERR_UNKNOWN, false, "database error");
     186        return false;
     187    }
     188
     189    psArray *output = p_psDBFetchResult(config->dbh);
     190    if (!output) {
     191        psError(PS_ERR_UNKNOWN, false, "database error");
     192        return false;
     193    }
     194    if (!psArrayLength(output)) {
     195        psFree(output);
     196        psError(PS_ERR_UNKNOWN, true, "no rows in dbversion");
     197        return false;
     198    }
     199    if (psArrayLength(output) > 1) {
     200        psError(PS_ERR_UNKNOWN, true, "unexpected number of rows found in dbversion: %" PRId64,
     201                psArrayLength(output));
     202        return false;
     203    }
     204    *pArray = output;
     205
     206    return true;
     207}
     208
     209psString pxGetDBVersion(pxConfig *config)
     210{
     211    PS_ASSERT_PTR_NON_NULL(config, NULL);
     212
     213    psArray *array = NULL;
     214    if (!pxLookupVersion(config, &array)) {
     215        psError(PS_ERR_UNKNOWN, false, "pxLookupVersion failed");
     216        return NULL;
     217    }
     218    psMetadata *md = array->data[0];
     219    if (!md) {
     220        psError(PS_ERR_UNKNOWN, true, "output of pxLookupVersion is null");
     221        return NULL;
     222    }
     223   
     224    psString version = psMetadataLookupStr(NULL, md, "schema_version");
     225
     226    return version;
     227}
     228
     229bool pxExportVersion(pxConfig *config, FILE *file)
     230{
     231    PS_ASSERT_PTR_NON_NULL(config, NULL);
     232    PS_ASSERT_PTR_NON_NULL(file, NULL);
     233
     234    psArray *array = NULL;
     235    if (!pxLookupVersion(config, &array) || !array) {
     236        psError(PS_ERR_UNKNOWN, false, "pxLookupVersion failed");
     237        return false;
     238    }
     239    if (!ippdbPrintMetadatas(file, array, "dbversion", true)) {
     240        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     241        psFree(array);
     242        return false;
     243    }
     244    return true;
     245}
     246
     247bool pxCheckImportVersion(pxConfig *config, psMetadata *input)
     248{
     249    PS_ASSERT_PTR_NON_NULL(config, NULL);
     250    PS_ASSERT_PTR_NON_NULL(input, NULL);
     251
     252    // This code was adapted from the way camtool parses the structures.
     253    // Is this really the way to do it?
     254    psMetadataItem *multi_item =  psMetadataLookup(input, "dbversion");
     255    if (!multi_item || (multi_item->type != PS_DATA_METADATA_MULTI)) {
     256        psError(PS_ERR_UNKNOWN, true, "dbversion multi not found in input");
     257        return false;
     258    }
     259   
     260    psMetadataItem *dbversion = psListGet(multi_item->data.list, 0);
     261    if (!dbversion) {
     262        psError(PS_ERR_UNKNOWN, true, "dbversion not found in input");
     263        return false;
     264    }
     265
     266    if (!strcmp(dbversion->name, "dbversion")) {
     267        // horray
     268        psMetadata *md = dbversion->data.md;
     269        psString schema_version = pxGetDBVersion(config);
     270        if (!schema_version) {
     271            psError(PS_ERR_UNKNOWN, false, "pxGetDBVersion failed");
     272            return false;
     273        }
     274       
     275        psString import_version = psMetadataLookupStr(NULL, md, "schema_version");
     276        if (import_version && strcmp(import_version, schema_version)) {
     277            psError(PS_ERR_UNKNOWN, true, "input file schema_version: %s does not match data base: %s",
     278                import_version, schema_version);
     279            return false;
     280        } else if (!import_version) {
     281            psError(PS_ERR_UNKNOWN, true, "input file schema_version is NULL");
     282            return false;
     283        } else {
     284            // YIPPEE this file is the same version
     285        }
     286    } else {
     287        psError(PS_ERR_UNKNOWN, true, "Unexpected config dump format");
     288        return false;
     289    }
     290
     291    return true;
     292}

  • branches/eam_branches/20090820/ippTools/src/pxtools.h

    r25766 r25870  
    4747#include "pxtree.h"
    4848#include "pxmagic.h"
     49#include "pxspace.h"
    4950
    5051# define MAX_ROWS 10e9
    … …  
    5657
    5758bool pxSetFaultCode(psDB *dbh, const char *tableName, psMetadata *where, psS16 code);
     59bool pxExportVersion(pxConfig *config, FILE *f);
     60bool pxCheckImportVersion(pxConfig *config, psMetadata *md);
    5861
    5962psExit pxerrorGetExitStatus(void);
    … …  
    6164void pxUsage(FILE *stream, int argc, char **argv, const char *modeName, psMetadata *argSet);
    6265bool pxGetOptions(FILE *stream, int argc, char **argv, pxConfig *config, psMetadata *modes, psMetadata *argSets);
     66
     67bool pxUpdateRun(pxConfig *config, psMetadata *where, psString *pQuery, psString table, bool has_dist_group);
    6368
    6469#define PXOPT_ADD_MODE(option, comment, modeval, argset) \

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

    r24487 r25870  
    2929#include "pxwarp.h"
    3030
    31 bool pxwarpRunSetState(pxConfig *config, psS64 warp_id, const char *state)
    32 {
    33     PS_ASSERT_PTR_NON_NULL(config, false);
    34     PS_ASSERT_PTR_NON_NULL(state, false);
    35 
    36     // check that state is a valid string value
    37     if (!pxIsValidState(state)) {
    38         psError(PS_ERR_UNKNOWN, false, "invalid warpRun state: %s", state);
    39         return false;
    40     }
    41 
    42     char *query = "UPDATE warpRun SET state = '%s' WHERE warp_id = %" PRId64;
    43     if (!p_psDBRunQueryF(config->dbh, query, state, warp_id)) {
    44         psError(PS_ERR_UNKNOWN, false,
    45                 "failed to change state for warp_id %" PRId64, warp_id);
    46         return false;
    47     }
    48 
    49     return true;
    50 }
    51 
    52 
    53 bool pxwarpRunSetStateByQuery(pxConfig *config, psMetadata *where, const char *state)
    54 {
    55     PS_ASSERT_PTR_NON_NULL(config, false);
    56     PS_ASSERT_PTR_NON_NULL(state, false);
    57 
    58     // check that state is a valid string value
    59     if (!pxIsValidState(state)) {
    60         psError(PS_ERR_UNKNOWN, false, "invalid warpRun state: %s", state);
    61         return false;
    62     }
    63 
    64     psString query = psStringCopy("UPDATE warpRun JOIN fakeRun USING(fake_id) JOIN camRun USING(cam_id) JOIN chipRun USING(chip_id) JOIN rawExp USING(exp_id) SET warpRun.state = '%s'");
    65 
    66     if (where) {
    67         psString whereClause = psDBGenerateWhereSQL(where, NULL);
    68         if (whereClause && strlen(whereClause) > 0) {
    69             psStringAppend(&query, " %s", whereClause);
    70         }
    71         psFree(whereClause);
    72     }
    73 
    74     if (!p_psDBRunQueryF(config->dbh, query, state)) {
    75         psFree(query);
    76         psError(PS_ERR_UNKNOWN, false, "database error");
    77         return false;
    78     }
    79 
    80     psFree(query);
    81 
    82     return true;
    83 }
    84 
    85 
    86 bool pxwarpRunSetLabel(pxConfig *config, psS64 warp_id, const char *label)
    87 {
    88     PS_ASSERT_PTR_NON_NULL(config, false);
    89     // note label == NULL should be explicitly allowed
    90 
    91     char *query = "UPDATE warpRun SET warpRun.label = '%s' WHERE warp_id = %" PRId64;
    92     if (!p_psDBRunQueryF(config->dbh, query, label, warp_id)) {
    93         psError(PS_ERR_UNKNOWN, false,
    94                 "failed to change label for warp_id %" PRId64, warp_id);
    95         return false;
    96     }
    97 
    98     return true;
    99 }
    100 
    101 
    102 bool pxwarpRunSetLabelByQuery(pxConfig *config, psMetadata *where, const char *label)
    103 {
    104     PS_ASSERT_PTR_NON_NULL(config, false);
    105     // note label == NULL should be explicitly allowed
    106 
    107     psString query = psStringCopy("UPDATE warpRun JOIN fakeRun USING(fake_id) JOIN camRun USING(cam_id) JOIN chipRun USING(chip_id) JOIN rawExp USING(exp_id) SET warpRun.label = '%s'");
    108 
    109     if (where) {
    110         psString whereClause = psDBGenerateWhereSQL(where, NULL);
    111         psStringAppend(&query, " %s", whereClause);
    112         psFree(whereClause);
    113     }
    114 
    115     if (!p_psDBRunQueryF(config->dbh, query, label)) {
    116         psFree(query);
    117         psError(PS_ERR_UNKNOWN, false, "database error");
    118         return false;
    119     }
    120 
    121     psFree(query);
    122 
    123     return true;
    124 }
    125 
    126 
    12731bool pxwarpQueueByFakeID(pxConfig *config,
    12832                         psS64 fake_id,
    12933                         const char *workdir,
    13034                         const char *label,
     35                         const char *data_group,
     36                         const char *dist_group,
    13137                         const char *dvodb,
    13238                         const char *tess_id,
    13339                         const char *reduction,
    134                          const char *end_stage)
     40                         const char *end_stage,
     41                         const char *note)
    13542{
    13643    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    14552        "dirty",    // workdir_state
    14653        label,
     54        data_group,
     55        dist_group,
    14756        dvodb,
    14857        tess_id,
    149                        reduction,
     58        reduction,
    15059        end_stage,
    15160        NULL,      // registered
    152         0          // magicked zero when created will get updated when warpRun goes to 'full'
     61        0,         // magicked set to zero when created may get updated when warpRun goes to 'full'
     62        NULL        // note
    15363    )) {
    15464        psError(PS_ERR_UNKNOWN, false, "database error");

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

    r24487 r25870  
    2525#include "pxtools.h"
    2626
    27 bool pxwarpRunSetState(pxConfig *config, psS64 warp_id, const char *state);
    28 bool pxwarpRunSetStateByQuery(pxConfig *config, psMetadata *where, const char *state);
    29 bool pxwarpRunSetLabel(pxConfig *config, psS64 warp_id, const char *label);
    30 bool pxwarpRunSetLabelByQuery(pxConfig *config, psMetadata *where, const char *label);
    31 
    3227bool pxwarpQueueByFakeID(pxConfig *config,
    3328                         psS64 fake_id,
    3429                         const char *workdir,
    3530                         const char *label,
     31                         const char *data_group,
     32                         const char *dist_group,
    3633                         const char *dvodb,
    3734                         const char *tess_id,
    3835                         const char *reduction,
    39                          const char *end_stage);
     36                         const char *end_stage,
     37                         const char *note);
    4038
    4139#endif // PXWARP_H

  • branches/eam_branches/20090820/ippTools/src/regtool.c

    r25766 r25870  
    334334    PXOPT_COPY_TIME(config->args, where, "-dateobs_end",   "dateobs",  "<=");
    335335    PXOPT_COPY_STR(config->args, where,  "-filter",        "filter", "==");
     336    PXOPT_COPY_STR(config->args, where,  "-exp_type",      "exp_type", "==");
     337    PXOPT_COPY_STR(config->args, where,  "-obs_mode",      "obs_mode", "==");
    336338    PXOPT_COPY_S64(config->args, where,  "-magicked",      "magicked", "==");
    337 
    338     PXOPT_LOOKUP_S64(magicked, config->args, "-magicked", false, false);
    339     PXOPT_LOOKUP_BOOL(destreaked, config->args,     "-destreaked", false);
    340     PXOPT_LOOKUP_BOOL(not_destreaked, config->args, "-not_destreaked", false);
    341339
    342340    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    343341    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    344342    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     343    PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
    345344    PXOPT_LOOKUP_BOOL(ordered_by_date, config->args, "-ordered_by_date", false);
     345
     346    // build where string for some parameters that don't fit PXOPT_COPY*
     347    psString where2 = NULL;
     348    if (!pxmagicAddWhere(config, &where2, "rawImfile")) {
     349        psError(PXTOOLS_ERR_DATA, false, "pxSpaceAddWhere failed");
     350        return false;
     351    }
     352    if (!pxspaceAddWhere(config, &where2, "rawImfile")) {
     353        psError(PXTOOLS_ERR_DATA, false, "pxSpaceAddWhere failed");
     354        return false;
     355    }
    346356
    347357    psString query = pxDataGet("regtool_processedimfile.sql");
    … …  
    356366        psStringAppend(&query, " AND %s", whereClause);
    357367        psFree(whereClause);
     368    } else if (!all && !where2) {
     369        psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     370        return false;
    358371    }
    359372    psFree(where);
     373    if (where2) {
     374        psStringAppend(&query, " %s", where2);
     375        psFree(where2);
     376    }
    360377
    361378    if (faulted) {
    … …  
    366383        psStringAppend(&query, " %s", "AND rawImfile.fault = 0");
    367384    }
    368 
    369     if (not_destreaked) {
    370         if (destreaked) {
    371             psError(PXTOOLS_ERR_DATA, true, "providing -not_destreaked and -destreaked makes no sense");
    372             return false;
    373         }
    374         if (magicked) {
    375             psError(PXTOOLS_ERR_DATA, true, "providing -not_destreaked and -magicked makes no sense");
    376             return false;
    377         }
    378         psStringAppend(&query, " AND rawImfile.magicked = 0");
    379     }
    380     if (destreaked) {
    381         psStringAppend(&query, " AND rawImfile.magicked != 0");
    382     }
    383 
    384385
    385386    // add the ORDER BY statement if desired
    … …  
    884885                workdir,
    885886                label,
     887                NULL,       // data_group
     888                NULL,       // dist_group
    886889                reduction,
    887                 NULL, // expgroup
     890                NULL,       // expgroup
    888891                dvodb,
    889892                tess_id,
    890                 end_stage
     893                end_stage,
     894                NULL        // note
    891895    )) {
    892896        // rollback

  • branches/eam_branches/20090820/ippTools/src/regtoolConfig.c

    r25766 r25870  
    137137    ADD_OPT(Str,  processedimfileArgs, "-class_id",  "search by class ID",                    NULL);
    138138    ADD_OPT(Str,  processedimfileArgs, "-filter",  "search by filter",                        NULL);
     139    ADD_OPT(Str,  processedimfileArgs, "-obs_mode",  "search by obs_mod",                        NULL);
     140    ADD_OPT(Str,  processedimfileArgs, "-exp_type",  "search by exposure type",                        NULL);
    139141    ADD_OPT(Time, processedimfileArgs, "-dateobs_begin", "search for exposures by time (>=)", NULL);
    140142    ADD_OPT(Time, processedimfileArgs, "-dateobs_end", "search for exposures by time (<)", NULL);
    141     ADD_OPT(S64,  processedimfileArgs, "-magicked",    "search by magicked value",            0);
    142     ADD_OPT(Bool, processedimfileArgs, "-destreaked",   "only return imfiles that have been destreaked", false);
    143     ADD_OPT(Bool, processedimfileArgs, "-not_destreaked", "only return imfiles that have not been destreaked", false);
    144143    ADD_OPT(U64,  processedimfileArgs, "-limit",     "limit result set to N items",           0);
    145144    ADD_OPT(Bool, processedimfileArgs, "-faulted",   "only return imfiles with a fault status set", false);
     145    ADD_OPT(Bool, processedimfileArgs, "-all",   "list without search arguments", false);
    146146    ADD_OPT(Bool, processedimfileArgs, "-simple",    "use the simple output format",          false);
    147147    ADD_OPT(Bool, processedimfileArgs, "-ordered_by_date", "force output to be in DATE order", false);
     148    pxspaceAddArguments(processedimfileArgs);
     149    pxmagicAddArguments(processedimfileArgs);
    148150
    149151    // -revertprocessedimfile

  • branches/eam_branches/20090820/ippTools/src/stacktool.c

    r25766 r25870  
    109109
    110110    // required options
    111     PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false);
    112     PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
    113     PXOPT_LOOKUP_STR(reduction, config->args, "-reduction", false, false);
    114     PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false);
     111    PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", true, false);
     112
     113    // optional
     114    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
     115    PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
     116    PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false);
     117    PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false);
     118    PXOPT_LOOKUP_STR(dvodb, config->args, "-set_dvodb", false, false);
     119    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
     120    PXOPT_LOOKUP_TIME(registered, config->args, "-set_registered", false, false);
    115121
    116122    psMetadata *where = psMetadataAlloc();
    … …  
    160166    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    161167    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
    162     PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    163 
    164     if (!psListLength(where->list) &&
    165         !psMetadataLookupBool(NULL, config->args, "-all")) {
     168
     169    if (!psListLength(where->list)) {
    166170        psFree(where);
    167171        psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
    … …  
    345349            workdir,
    346350            label,
     351            data_group ? data_group : label,
     352            dist_group,
    347353            reduction,
    348354            dvodb,
    … …  
    350356            skycell_id,
    351357            tess_id,
    352             filter);
     358            filter,
     359            note);
    353360
    354361        if (!stackRunInsertObject(config->dbh, run)) {
    … …  
    468475
    469476    // required options
    470     PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false);
     477    PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", true, false);
    471478    PXOPT_LOOKUP_STR(skycell_id, config->args, "-skycell_id", true, false);
    472479    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", true, false);
    … …  
    475482    // default
    476483    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    477     PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
     484    PXOPT_LOOKUP_TIME(registered, config->args, "-set_registered", false, false);
    478485
    479486    // options
    480     PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
    481     PXOPT_LOOKUP_STR(reduction, config->args, "-reduction", false, false);
    482     PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false);
     487    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
     488    PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
     489    PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false);
     490    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
     491    PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false);
     492    PXOPT_LOOKUP_STR(dvodb, config->args, "-set_dvodb", false, false);
    483493
    484494    // we have to support multipe exp_ids
    … …  
    495505        workdir,
    496506        label,
     507        data_group ? data_group : label,
     508        dist_group,
    497509        reduction,
    498510        dvodb,
    … …  
    500512        skycell_id,
    501513        tess_id,
    502         filter);
     514        filter,
     515        note);
    503516
    504517    if (!run) {
    … …  
    569582    PS_ASSERT_PTR_NON_NULL(config, false);
    570583
    571     PXOPT_LOOKUP_S64(stack_id, config->args, "-stack_id", true, false);
     584#ifdef notdef
     585    PXOPT_LOOKUP_S64(stack_id, config->args, "-stack_id", false, false);
    572586    PXOPT_LOOKUP_STR(state, config->args, "-state", true, false);
    573 
    574     if (state) {
     587    PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
     588#endif
     589    psMetadata *where = psMetadataAlloc();
     590    PXOPT_COPY_S64(config->args, where, "-stack_id",  "stack_id",   "==");
     591    PXOPT_COPY_STR(config->args, where, "-label",     "label",     "==");
     592    PXOPT_COPY_STR(config->args, where, "-state",     "state",     "==");
     593    if (!psListLength(where->list)) {
     594        psFree(where);
     595        psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     596        return false;
     597    }
     598
     599    psString query = psStringCopy("UPDATE stackRun");
     600
     601    // pxUpdateRun gets parameters from config->args and updates
     602    bool result = pxUpdateRun(config, where, &query, "stackRun", true);
     603
     604    psFree(query);
     605    psFree(where);
     606
     607    return result;
     608
     609#ifdef notdef
     610    // Hack-y work around to make stacktool more like the other tools, without breaking other stuff (hopefully).
     611
     612    if ((state)&&(stack_id)) {
    575613        // set detRun.state to state
    576614        return setstackRunState(config, stack_id, state);
    577615    }
    578616
    579     return true;
     617    if ((state)&&(label)) {
     618      return setstackRunStateByLabel(config, label, state);
     619    }
     620
     621    psError(PS_ERR_UNKNOWN, false, "Required options not found.");
     622    return false;
     623#endif
    580624}
    581625
    … …  
    10061050}
    10071051
     1052#ifdef notdef
     1053static bool setstackRunStateByLabel(pxConfig *config, const char *label, const char *state)
     1054{
     1055    PS_ASSERT_PTR_NON_NULL(state, false);
     1056
     1057    // check that state is a valid string value
     1058    if (!pxIsValidState(state)) {
     1059        psError(PS_ERR_UNKNOWN, false, "invalid stackRun state: %s", state);
     1060        return false;
     1061    }
     1062
     1063    char *query = "UPDATE stackRun SET state = '%s' WHERE label = '%s'";
     1064    if (!p_psDBRunQueryF(config->dbh, query, state, label)) {
     1065        psError(PS_ERR_UNKNOWN, false,
     1066                "failed to change state for label %s", label);
     1067        return false;
     1068    }
     1069
     1070    return true;
     1071}
     1072#endif
     1073
    10081074static bool pendingcleanuprunMode(pxConfig *config)
    10091075{
    … …  
    12311297  }
    12321298
     1299  if (!pxExportVersion(config, f)) {
     1300    psError(PS_ERR_UNKNOWN, false, "failed to write dbversion output file");
     1301    return false;
     1302  }
    12331303  psMetadata *where = psMetadataAlloc();
    12341304  PXOPT_COPY_S64(config->args, where, "-stack_id", "stack_id", "==");
    … …  
    13171387  psMetadata *input = psMetadataConfigRead (NULL, &nFail, infile, false);
    13181388
    1319   fprintf (stdout, "---- input ----\n");
     1389#ifdef notdef
     1390  fprintf (stderr, "---- input ----\n");
    13201391  psMetadataPrint (stderr, input, 1);
    1321 
     1392#endif
     1393
     1394  if (!pxCheckImportVersion(config, input)) {
     1395      psError(PS_ERR_UNKNOWN, false, "pxCheckImportVersion failed");
     1396      return false;
     1397  }
    13221398  psMetadataItem *item = psMetadataLookup (input, "stackRun");
    13231399  psAssert (item, "entry not in input?");

  • branches/eam_branches/20090820/ippTools/src/stacktoolConfig.c

    r25766 r25870  
    4747    // -definebyquery
    4848    psMetadata *definebyqueryArgs = psMetadataAlloc();
    49     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-workdir", 0, "define workdir (required)", NULL);
    50     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label", 0, "define label", NULL);
    51     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-reduction", 0, "define reduction", NULL);
    52     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-dvodb", 0, "define dvodb", NULL);
    53     psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-registered", 0, "time detrend run was registered", now);
     49    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_workdir", 0, "define workdir (required)", NULL);
     50    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_label", 0, "define label", NULL);
     51    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_data_group", 0, "define data group", NULL);
     52    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_dist_group", 0, "define dist group", NULL);
     53    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_note", 0, "define note", NULL);
     54    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_reduction", 0, "define reduction", NULL);
     55    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_dvodb", 0, "define dvodb", NULL);
     56    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-set_registered", 0, "time detrend run was registered", now);
    5457    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_skycell_id", 0, "search for skycell_id", NULL);
    5558    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_good_frac_min", 0, "define min good_frac", 0.0);
    … …  
    8487    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_iq_m4_max", 0, "define max iq_m4", NAN);
    8588    psMetadataAddS32(definebyqueryArgs, PS_LIST_TAIL, "-random", 0, "use this number of random elements", 0);
    86     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-all", 0, "allow everything to be queued without search terms", false);
    8789    psMetadataAddS32(definebyqueryArgs, PS_LIST_TAIL, "-min_num", 0, "minimum number of inputs", 0);
    8890    psMetadataAddS32(definebyqueryArgs, PS_LIST_TAIL, "-min_new", 0, "minimum number of new inputs", 0);
    … …  
    9395    // -definerun
    9496    psMetadata *definerunArgs = psMetadataAlloc();
    95     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-workdir", 0,            "define workdir (required)", NULL);
    96     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-label", 0, "define label", NULL);
    97     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-reduction", 0, "define reduction", NULL);
    98     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-dvodb", 0, "define dvodb", NULL);
    99     psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
     97    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_workdir", 0,            "define workdir (required)", NULL);
     98    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_label", 0, "define label", NULL);
     99    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_reduction", 0, "define reduction", NULL);
     100    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_dvodb", 0, "define dvodb", NULL);
     101    psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-set_registered",  0,            "time detrend run was registered", now);
    100102    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-skycell_id",  0,            "define skycell ID (required)", NULL);
    101103    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-tess_id",  0,            "define tessellation ID (required)", NULL);
    … …  
    106108    // -updaterun
    107109    psMetadata *updaterunArgs = psMetadataAlloc();
    108     psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-stack_id", 0,            "define stack ID (required)", 0);
    109     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,            "set state (required)", NULL);
    110 
     110    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-stack_id", 0,         "search by stack ID", 0);
     111    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,            "search by state", NULL);
     112    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label", 0,            "search by label", 0);
     113    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_label", 0,        "define new value for label", 0);
     114    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state", 0,        "define new state", NULL);
     115    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_data_group", 0,   "define new data_group", NULL);
     116    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_dist_group", 0,   "define new dist_group", NULL);
     117    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_note", 0,         "define new note", NULL);
     118   
    111119    // -addinputskyfile
    112120    psMetadata *addinputskyfileArgs = psMetadataAlloc();

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

    r25766 r25870  
    5858static bool exportrunMode(pxConfig *config);
    5959static bool importrunMode(pxConfig *config);
     60static bool runstateMode(pxConfig *config);
    6061
    6162static bool parseAndInsertSkyCellMap(pxConfig *config, const char *mapfile);
    … …  
    108109        MODECASE(WARPTOOL_MODE_EXPORTRUN,          exportrunMode);
    109110        MODECASE(WARPTOOL_MODE_IMPORTRUN,          importrunMode);
     111        MODECASE(WARPTOOL_MODE_RUNSTATE,           runstateMode);
    110112
    111113        default:
    … …  
    139141    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false); // required
    140142    PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
     143    PXOPT_LOOKUP_STR(data_group, config->args, "-data_group", false, false);
     144    PXOPT_LOOKUP_STR(dist_group, config->args, "-dist_group", false, false);
     145    PXOPT_LOOKUP_STR(note, config->args, "-note", false, false);
    141146    PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false);
    142147    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", true, false); // required (no default TESS)
    … …  
    160165            "dirty",    // workdir_state
    161166            label,
     167            data_group ? data_group : label,
     168            dist_group,
    162169            dvodb,
    163170            tess_id,
    … …  
    165172            end_stage,
    166173            registered,
    167             0       // magicked
     174            0,       // magicked
     175            note
    168176    );
    169177    if (!warpRun) {
    … …  
    251259    PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", false, false);
    252260    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
     261    PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
     262    PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false);
    253263    PXOPT_LOOKUP_STR(dvodb, config->args, "-set_dvodb", false, false);
    254264    PXOPT_LOOKUP_STR(tess_id, config->args, "-set_tess_id", false, false);
    255265    PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false);
    256266    PXOPT_LOOKUP_STR(end_stage, config->args, "-set_end_stage", false, false);
     267    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
    257268
    258269    PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    … …  
    340351                                 workdir     ? workdir   : row->workdir,
    341352                                 label       ? label     : row->label,
     353                                 data_group  ? data_group: row->data_group,
     354                                 dist_group  ? dist_group: row->dist_group,
    342355                                 dvodb       ? dvodb     : row->dvodb,
    343356                                 tess_id     ? tess_id   : row->tess_id,
    344357                                 reduction   ? reduction : row->reduction,
    345                                  end_stage   ? end_stage : row->end_stage))
     358                                 end_stage   ? end_stage : row->end_stage,
     359                                 note))
    346360          {
    347361            psError(PS_ERR_UNKNOWN, false, "failed to trying to queue fake_id: %" PRId64, row->fake_id);
    … …  
    371385    PXOPT_COPY_STR(config->args, where, "-label",     "warpRun.label",     "==");
    372386    PXOPT_COPY_STR(config->args, where, "-state",     "warpRun.state",     "==");
    373 
    374     if (!psListLength(where->list)
    375         && !psMetadataLookupBool(NULL, config->args, "-all")) {
     387    PXOPT_COPY_STR(config->args, where, "-data_group","warpRun.data_group",     "==");
     388    PXOPT_COPY_STR(config->args, where, "-dist_group","warpRun.dist_group",     "==");
     389
     390    if (!psListLength(where->list)) {
    376391        psFree(where);
    377         where = NULL;
    378392        psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
    379393        return false;
    380394    }
    381 
    382     PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
    383     PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
    384 
    385     if ((!state) && (!label)) {
    386         psError(PXTOOLS_ERR_DATA, false, "parameters (-state or -label) are required");
    387         psFree(where);
    388         return false;
    389     }
    390 
    391     if (state) {
    392         // set warpRun.state to state
    393         if (!pxwarpRunSetStateByQuery(config, where, state)) {
    394             psFree(where);
    395             return false;
    396         }
    397     }
    398 
    399     if (label) {
    400         // set chipRun.label to label
    401         if (!pxwarpRunSetLabelByQuery(config, where, label)) {
    402             psFree(where);
    403             return false;
    404         }
    405     }
    406 
     395   
     396    psString query = psStringCopy("UPDATE warpRun JOIN fakeRun USING(fake_id) JOIN camRun USING(cam_id) JOIN chipRun USING(chip_id) JOIN rawExp USING(exp_id)");
     397
     398    // pxUpdateRun gets parameters from config->args and updates
     399    bool result = pxUpdateRun(config, where, &query, "warpRun", true);
     400
     401    psFree(query);
    407402    psFree(where);
    408403
    409     return true;
    410 }
    411 
     404    return result;
     405}
    412406
    413407static bool expMode(pxConfig *config)
    … …  
    12041198    pxAddLabelSearchArgs (config, where, "-label",   "warpRun.label", "LIKE");
    12051199
    1206     PXOPT_LOOKUP_U64(magicked, config->args, "-magicked", false, false);
    1207     PXOPT_LOOKUP_BOOL(destreaked, config->args,     "-destreaked", false);
    1208     PXOPT_LOOKUP_BOOL(not_destreaked, config->args, "-not_destreaked", false);
    1209 
    12101200    PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
    12111201
    … …  
    12201210    }
    12211211
     1212    // generate where strings for arguments that require extra processing
     1213    // beyond PXOPT_COPY*
     1214    psString where2 = NULL;
     1215    if (!pxmagicAddWhere(config, &where2, "warpSkyfile")) {
     1216        psError(PXTOOLS_ERR_DATA, false, "pxMagicAddWhere failed");
     1217        return false;
     1218    }
     1219    if (!pxspaceAddWhere(config, &where2, "rawExp")) {
     1220        psError(PXTOOLS_ERR_DATA, false, "pxSpaceAddWhere failed");
     1221        return false;
     1222    }
     1223
    12221224    if (psListLength(where->list)) {
    12231225        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    12241226        psStringAppend(&query, " AND %s", whereClause);
    12251227        psFree(whereClause);
    1226     } else if (!all) {
     1228    } else if (!all && !where2) {
    12271229        psError(PXTOOLS_ERR_DATA, true, "search parameters or -all are required");
    12281230        return false;
    … …  
    12301232    psFree(where);
    12311233
    1232     if (not_destreaked) {
    1233         if (destreaked) {
    1234             psError(PXTOOLS_ERR_DATA, true, "providing -not_destreaked and -destreaked makes no sense");
    1235             return false;
    1236         }
    1237         if (magicked) {
    1238             psError(PXTOOLS_ERR_DATA, true, "providing -not_destreaked and -magicked makes no sense");
    1239             return false;
    1240         }
    1241         psStringAppend(&query, " AND warpSkyfile.magicked = 0");
    1242     }
    1243     if (destreaked) {
    1244         psStringAppend(&query, " AND warpSkyfile.magicked != 0");
     1234    if (where2) {
     1235        psStringAppend(&query, " %s", where2);
    12451236    }
    12461237
    … …  
    17121703    PXOPT_LOOKUP_STR(skycell_id, config->args, "-skycell_id", true, false);
    17131704    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
    1714 
    1715     psString query = pxDataGet("warptool_updateskyfile.sql");
    1716 
    1717     if (!p_psDBRunQueryF(config->dbh, query, fault, warp_id, skycell_id)) {
    1718         psError(PS_ERR_UNKNOWN, false, "database error");
    1719         return false;
    1720     }
    1721     psFree(query);
     1705    PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
     1706
     1707    if (!state) {
     1708      psString query = pxDataGet("warptool_updateskyfile.sql");
     1709     
     1710      if (!p_psDBRunQueryF(config->dbh, query, fault, warp_id, skycell_id)) {
     1711        psError(PS_ERR_UNKNOWN, false, "database error");
     1712        return false;
     1713      }
     1714      psFree(query);
     1715    }
     1716    else {
     1717      if (strcmp(state,"error_cleaned") == 0) {
     1718        change_skyfile_data_state(config,"error_cleaned","goto_cleaned");
     1719      }
     1720      else if (strcmp(state, "error_scrubbed") == 0) {
     1721        change_skyfile_data_state(config,"error_scrubbed","goto_scrubbed");
     1722      }
     1723      else if (strcmp(state, "error_purged") == 0) {
     1724        change_skyfile_data_state(config,"error_purged","goto_purged");
     1725      }
     1726      else {
     1727        psError(PS_ERR_UNKNOWN, false, "unhandled state given");
     1728        return(false);
     1729      }
     1730    }
    17221731
    17231732    return true;
    … …  
    17441753    }
    17451754
     1755    if (!pxExportVersion(config, f)) {
     1756        psError(PS_ERR_UNKNOWN, false, "failed to write dbversion output file");
     1757        return false;
     1758    }
    17461759    psMetadata *where = psMetadataAlloc();
    17471760    PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
    … …  
    18361849  psMetadata *input = psMetadataConfigRead (NULL, &nFail, infile, false);
    18371850
    1838   fprintf (stdout, "---- input ----\n");
     1851#ifdef notdef
     1852  fprintf (stderr, "---- input ----\n");
    18391853  psMetadataPrint (stderr, input, 1);
     1854#endif
     1855
     1856  if (!pxCheckImportVersion(config, input)) {
     1857      psError(PS_ERR_UNKNOWN, false, "pxCheckImportVersion failed");
     1858      return false;
     1859  }
    18401860
    18411861  psMetadataItem *item = psMetadataLookup (input, "warpRun");
    … …  
    19001920  return true;
    19011921}
     1922
     1923static bool runstateMode(pxConfig *config)
     1924{
     1925    PS_ASSERT_PTR_NON_NULL(config, false);
     1926
     1927    psMetadata *where = psMetadataAlloc();
     1928    PXOPT_COPY_S64(config->args, where, "-warp_id",    "warpRun.warp_id", "==");
     1929    PXOPT_COPY_S64(config->args, where, "-exp_id",     "rawExp.exp_id", "==");
     1930    PXOPT_COPY_STR(config->args, where, "-exp_name",   "rawExp.exp_name", "==");
     1931    pxAddLabelSearchArgs (config, where, "-label",     "warpRun.label", "LIKE");
     1932
     1933//    PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
     1934    PXOPT_LOOKUP_BOOL(no_magic, config->args, "-no_magic", false);
     1935
     1936    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1937    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1938
     1939    psString query = pxDataGet("warptool_runstate.sql");
     1940    if (!query) {
     1941        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1942        return false;
     1943    }
     1944
     1945    if (psListLength(where->list)) {
     1946        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1947        psStringAppend(&query, " WHERE %s", whereClause);
     1948        psFree(whereClause);
     1949    } else {
     1950        psError(PXTOOLS_ERR_DATA, true, "search parameters or -all are required");
     1951        return false;
     1952    }
     1953    psFree(where);
     1954
     1955    // treat limit == 0 as "no limit"
     1956    if (limit) {
     1957        psString limitString = psDBGenerateLimitSQL(limit);
     1958        psStringAppend(&query, " %s", limitString);
     1959        psFree(limitString);
     1960    }
     1961
     1962    if (!p_psDBRunQuery(config->dbh, query)) {
     1963        psError(PS_ERR_UNKNOWN, false, "database error");
     1964        psFree(query);
     1965        return false;
     1966    }
     1967    psFree(query);
     1968
     1969    psArray *output = p_psDBFetchResult(config->dbh);
     1970    if (!output) {
     1971        psErrorCode err = psErrorCodeLast();
     1972        switch (err) {
     1973            case PS_ERR_DB_CLIENT:
     1974                psError(PXTOOLS_ERR_SYS, false, "database error");
     1975            case PS_ERR_DB_SERVER:
     1976                psError(PXTOOLS_ERR_PROG, false, "database error");
     1977            default:
     1978                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     1979        }
     1980
     1981        return false;
     1982    }
     1983    if (!psArrayLength(output)) {
     1984        psTrace("warptool", PS_LOG_INFO, "no rows found");
     1985        psFree(output);
     1986        return true;
     1987    }
     1988
     1989    if (psArrayLength(output)) {
     1990        // negative simple so the default is true
     1991        if (!ippdbPrintMetadatas(stdout, output, "warpRunState", !simple)) {
     1992            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1993            psFree(output);
     1994            return false;
     1995        }
     1996    }
     1997
     1998    psFree(output);
     1999
     2000    return true;
     2001}

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

    r25766 r25870  
    5353    WARPTOOL_MODE_UPDATESKYFILE,
    5454    WARPTOOL_MODE_EXPORTRUN,
    55     WARPTOOL_MODE_IMPORTRUN
     55    WARPTOOL_MODE_IMPORTRUN,
     56    WARPTOOL_MODE_RUNSTATE,
    5657} warptoolMode;
    5758

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

    r25766 r25870  
    100100    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_reduction",      0, "define reduction class", NULL);
    101101    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_end_stage",      0, "define end stage", NULL);
    102     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-all",               0, "allow everything to be queued without search terms", false);
     102    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_data_group",     0, "define data group", NULL);
     103    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_dist_group",     0, "define dist group", NULL);
     104    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_note",           0, "define note", NULL);
    103105
    104106    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
    … …  
    117119    psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
    118120    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     121    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_end_stage",      0, "define end stage", NULL);
     122    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_data_group",     0, "define data group", NULL);
     123    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_dist_group",     0, "define dist group", NULL);
     124    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_note",           0, "define note", NULL);
    119125
    120126    // -updaterun
    … …  
    128134    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,      "search by warpRun state", NULL);
    129135    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label", 0,      "search by warpRun label", NULL);
    130     psMetadataAddBool(updaterunArgs, PS_LIST_TAIL, "-all",  0,      "allow everything to be queued without search terms", false);
    131     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state", 0,  "set state", NULL);
    132     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_label", 0,  "set label", NULL);
    133 
     136    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-data_group", 0, "search by warpRun data_group", NULL);
     137    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-dist_group", 0, "search by warpRun dist_group", NULL);
     138
     139    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state", 0,        "define new state", NULL);
     140    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_label", 0,        "define new value for label", 0);
     141    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_data_group", 0,   "define new data_group", NULL);
     142    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_dist_group", 0,   "define new dist_group", NULL);
     143    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_note", 0,         "define new note", NULL);
    134144    // -exp
    135145    psMetadata *expArgs = psMetadataAlloc();
    … …  
    218228    psMetadataAddTime(warpedArgs, PS_LIST_TAIL, "-dateobs_end", 0,      "search for exposures by time (<=)", NULL);
    219229    psMetadataAddStr(warpedArgs, PS_LIST_TAIL,  "-filter", 0,           "search for exposures by filter", NULL);
    220     psMetadataAddBool(warpedArgs, PS_LIST_TAIL, "-destreaked",  0,      "search for destreaked images", false);
    221     psMetadataAddBool(warpedArgs, PS_LIST_TAIL, "-not_destreaked",  0,  "search for images that have not been destreaked", false);
    222     psMetadataAddS64(warpedArgs, PS_LIST_TAIL,  "-magicked", 0,         "search by magicked value", 0);
    223230    psMetadataAddS16(warpedArgs, PS_LIST_TAIL,  "-fault",  0,           "search by fault code", 0);
    224231    psMetadataAddStr(warpedArgs, PS_LIST_TAIL,  "-label",  PS_META_DUPLICATE_OK, "search by warpRun label", NULL);
     232    // add magic related arguments
     233    pxmagicAddArguments(warpedArgs);
     234    // add arguments for spatial search
     235    pxspaceAddArguments(warpedArgs);
    225236
    226237    psMetadataAddBool(warpedArgs, PS_LIST_TAIL, "-all",  0,             "search without arguments", false);
    … …  
    304315    psMetadataAddStr(updateskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0, "skycell ID to update", NULL);
    305316    psMetadataAddS16(updateskyfileArgs, PS_LIST_TAIL, "-fault",  0,      "new fault code", 0);
    306 
     317    psMetadataAddStr(updateskyfileArgs, PS_LIST_TAIL, "-set_state", 0,   "set state", 0);
     318   
    307319    // -exportrun
    308320    psMetadata *exportrunArgs = psMetadataAlloc();
    … …  
    315327    psMetadata *importrunArgs = psMetadataAlloc();
    316328    psMetadataAddStr(importrunArgs, PS_LIST_TAIL, "-infile",  0,          "import from this file (required)", NULL);
     329
     330    // -runstate
     331    psMetadata *runstateArgs = psMetadataAlloc();
     332    psMetadataAddS64(runstateArgs, PS_LIST_TAIL, "-warp_id", 0,           "search by warptool ID", 0);
     333//    psMetadataAddStr(runstateArgs, PS_LIST_TAIL, "-tess_id",  0,          "search by tessellation ID", NULL);
     334    psMetadataAddS64(runstateArgs, PS_LIST_TAIL, "-exp_id", 0,            "search by exposure tag", 0);
     335    psMetadataAddStr(runstateArgs, PS_LIST_TAIL, "-exp_name", 0,          "search by exposure tag", 0);
     336    psMetadataAddStr(runstateArgs, PS_LIST_TAIL,  "-label",  PS_META_DUPLICATE_OK, "search by warpRun label", NULL);
     337    psMetadataAddBool(runstateArgs, PS_LIST_TAIL, "-no_magic",  0,        "magic is not necessary for result", false);
     338
     339    psMetadataAddU64(runstateArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     340    psMetadataAddBool(runstateArgs, PS_LIST_TAIL, "-simple",  0,          "use the simple output format", false);
    317341
    318342
    … …  
    334358    PXOPT_ADD_MODE("-advancerun",      "", WARPTOOL_MODE_ADVANCERUN,     advancerunArgs);
    335359    PXOPT_ADD_MODE("-warped",          "", WARPTOOL_MODE_WARPED,         warpedArgs);
     360    PXOPT_ADD_MODE("-runstate",        "", WARPTOOL_MODE_RUNSTATE,       runstateArgs);
    336361    PXOPT_ADD_MODE("-revertwarped",    "", WARPTOOL_MODE_REVERTWARPED,   revertwarpedArgs);
    337362    PXOPT_ADD_MODE("-block",                 "set a label block",                    WARPTOOL_MODE_BLOCK,          blockArgs);
Note: See TracChangeset for help on using the changeset viewer.