IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Mar 30, 2012, 2:49:37 PM (14 years ago)
Author:
eugene
Message:

merge changes from trunk

Location:
branches/eam_branches/ipp-20111122/ippTools/src
Files:
27 edited
5 copied

Legend:

Unmodified
Added
Removed

  • branches/eam_branches/ipp-20111122/ippTools/src

  • branches/eam_branches/ipp-20111122/ippTools/src/Makefile.am

    r32511 r33638  
    2929        diffphottool \
    3030        minidvodbtool \
     31        mergetool \
    3132        laptool \
    3233        vptool
    … …  
    4344        pxmagic.h \
    4445        pxminidvodb.h \
     46        pxmerge.h \
    4547        pxregister.h \
    4648        pxspace.h \
    … …  
    7981        diffphottool.h \
    8082        minidvodbtool.h \
     83        mergetool.h \
    8184        laptool.h \
    8285        vptool.h
    … …  
    98101        pxmagic.c \
    99102        pxminidvodb.c \
     103        pxmerge.c \
    100104        pxregister.c \
    101105        pxspace.c \
    … …  
    294298    minidvodbtoolConfig.c
    295299
     300mergetool_CFLAGS = $(PSLIB_CFLAGS) $(PSMODULES_CFLAGS) $(IPPDB_CFLAGS)
     301mergetool_LDADD = $(PSLIB_LIBS) $(PSMODULES_LIBS) $(IPPDB_LIBS) libpxtools.la
     302mergetool_SOURCES = \
     303    mergetool.c \
     304    mergetoolConfig.c
     305
    296306laptool_CFLAGS = $(PSLIB_CFLAGS) $(PSMODULES_CFLAGS) $(IPPDB_CFLAGS)
    297307laptool_LDADD = $(PSLIB_LIBS) $(PSMODULES_LIBS) $(IPPDB_LIBS) libpxtools.la

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

    r32851 r33638  
    141141    pxAddLabelSearchArgs (config, where, "-data_group","staticskyRun.data_group", "=="); // define using camRun label
    142142    PXOPT_COPY_STR(config->args, where,  "-reduction", "staticskyyRun.reduction", "==");
    143     pxAddLabelSearchArgs (config, where, "-filter",     "stackRun.filter", "=="); // define using camRun label
    144     }
    145         if (strcmp(stage, "staticsky_multi")== 0) {
    146 
    147     pxAddLabelSearchArgs (config, where, "-label",     "staticskyRun.label", "=="); // define using camRun label
    148     pxAddLabelSearchArgs (config, where, "-data_group","staticskyRun.data_group", "=="); // define using camRun label
    149     PXOPT_COPY_STR(config->args, where,  "-reduction", "staticskyyRun.reduction", "==");
    150143    //no filter here
    151144    }
    … …  
    227220    }
    228221    }
     222 
    229223    if (strcmp(stage,"staticsky") == 0) {
    230     if (dvodb ) {
    231       psTrace("addtool.c", PS_LOG_INFO, "dvodb argument found (%s) using addtool_find_sky_id_dvo.sql\n%s\n", dvodb,stage);
    232         // find the cam_id of all the exposures that we want to queue up.
    233         bare_query = pxDataGet("addtool_find_sky_id_dvo.sql");
    234         // user supplied dvodb
    235         psStringAppend(&dvodb_string, "addRun.dvodb = '%s'", dvodb);
    236     } else {
    237       psTrace("addtool.c", PS_LOG_INFO, "dvodb argument not found using addtool_find_sky_id.sql\n%s\n",stage);
    238         // find the cam_id of all the exposures that we want to queue up.
    239         bare_query = pxDataGet("addtool_find_sky_id.sql");
    240         // inherit dvodb from camRun, avoid matching NULL
    241         psStringAppend(&dvodb_string, "(staticskyRun.dvodb IS NOT NULL AND previous_dvodb = staticskyRun.dvodb)");
    242     }
    243     }
    244 
    245     if (strcmp(stage,"staticsky_multi") == 0) {
    246224      if (dvodb ) {
    247225        psTrace("addtool.c", PS_LOG_INFO, "dvodb argument found (%s) using addtool_find_sky_id_multi_dvo.sql\n%s\n", dvodb,stage);
    … …  
    292270    } else {
    293271      //This picks only the unmagicked/uncensored ones
    294       if (strcmp(stage,"cam") == 0) {
    295         psStringAppend(&query, " AND (camRun.magicked = 0)");
    296       }
     272      //if (strcmp(stage,"cam") == 0) {
     273        //we can now properly handle the magicked case in ippScripts, so we queue camRuns in any magic state now if -uncensored.
     274        //psStringAppend(&query, " AND (camRun.magicked = 0)");
     275        //}
    297276      if (strcmp(stage,"stack") == 0) {
    298277        psStringAppend(&query, " AND (stackRun.magicked = 0)");
    … …  
    309288        psStringAppend(&query, " GROUP BY stack_id");
    310289      }
     290      //   if (strcmp(stage,"staticsky") == 0) {
     291      //   psStringAppend(&query, " GROUP BY stack_id");
     292      // }
    311293    if (strcmp(stage,"staticsky") == 0) {
    312         psStringAppend(&query, " GROUP BY stack_id");
    313       }
    314     if (strcmp(stage,"staticsky_multi") == 0) {
    315294      psStringAppend(&query, " GROUP BY sky_id");  //some reason it needs this
    316295      }
    … …  
    401380    }
    402381    }
     382   
    403383    if (strcmp(stage,"staticsky") == 0) {
    404     for (long i = 0; i < psArrayLength(output); i++) {
    405         psMetadata *md = output->data[i];
    406 
    407         staticskyRunRow *row = staticskyRunObjectFromMetadata(md);
    408        
    409         if (!row) {
    410             psError(PS_ERR_UNKNOWN, false, "failed to convert metadata into camRun");
    411             psFree(output);
    412             return false;
    413         }
    414 
    415         if (!dvodb) {  //there's no staticsky.dvodb
    416             psError(PS_ERR_UNKNOWN, false, "cannot queue addstar run without a defined dvodb: label: %s, sky_id %" PRId64, row->label, row->sky_id);
    417             psFree(output);
    418             return false;
    419         }
    420         if (!workdir && !row->workdir) {
    421             psError(PS_ERR_UNKNOWN, false, "cannot queue addstar run without a defined workdir: label: %s, sky_id %" PRId64, row->label, row->sky_id);
    422             psFree(output);
    423             return false;
    424         }
    425 
    426         psFree(row);
    427     }
    428     }
    429     if (strcmp(stage,"staticsky_multi") == 0) {
    430384    for (long i = 0; i < psArrayLength(output); i++) {
    431385        psMetadata *md = output->data[i];
    … …  
    565519    }
    566520      }
     521   
    567522    if (strcmp(stage,"staticsky") == 0) {
    568     for (long i = 0; i < psArrayLength(output); i++) {
    569         psMetadata *md = output->data[i];
    570         psS64 stage_id =0;
    571        
    572         staticskyRunRow *row = staticskyRunObjectFromMetadata(md);
    573         stage_id = row->sky_id;
    574        
    575         if (!row) {
    576             psError(PS_ERR_UNKNOWN, false, "failed to convert metadata into camRun");
    577             psFree(output);
    578             return false;
    579         }
    580 
    581         // queue the exp
    582         if (!pxaddQueueByCamID(config,
    583                                stage,
    584                                stage_id,
    585                                0,
    586                                workdir     ? workdir   : row->workdir,
    587                                reduction   ? reduction : row->reduction,
    588                                label       ? label     : row->label,
    589                                data_group  ? data_group : (row->data_group ? row->data_group :  (label ? label : row->label)),
    590                                dvodb       ? dvodb     : NULL,
    591                                note        ? note      : NULL,
    592                                image_only,
    593                                minidvodb,
    594                                minidvodb_group,
    595                                minidvodb_name
    596         )) {
    597             if (!psDBRollback(config->dbh)) {
    598                 psError(PS_ERR_UNKNOWN, false, "database error sfg");
    599             }
    600             psError(PS_ERR_UNKNOWN, false,
    601                     "failed to trying to queue stage %s %" PRId64,stage, stage_id);
    602             psFree(row);
    603             psFree(output);
    604             return false;
    605         }
    606         psFree(row);
    607     }
    608       }
    609 
    610     if (strcmp(stage,"staticsky_multi") == 0) {
    611523    for (long i = 0; i < psArrayLength(output); i++) {
    612524        psMetadata *md = output->data[i];
    … …  
    704616    query = psStringCopy("UPDATE addRun JOIN staticskyRun on sky_id = stage_id");
    705617    }
    706     if (strcmp(stage, "staticsky_multi")==0) {
    707     query = psStringCopy("UPDATE addRun JOIN staticskyRun on sky_id = stage_id");
    708     }
     618   
    709619
    710620    // pxUpdateRun gets parameters from config->args and runs the update query
    … …  
    744654    }
    745655    if (strcmp(stage, "staticsky")==0) {
    746     query = pxDataGet("addtool_find_pendingexp_staticsky.sql");
    747     }
    748     if (strcmp(stage, "staticsky_multi")==0) {
    749656    query = pxDataGet("addtool_find_pendingexp_staticsky_multi.sql");
    750657    }
    … …  
    767674      psStringAppend(&query, " GROUP BY %s", "stack_id");
    768675    }
     676    //if (strcmp(stage, "staticsky") == 0) {
     677    //  //this group by is needed to join against all the warps (to get camera)
     678    //  psStringAppend(&query, " GROUP BY %s", "sky_id");
     679    //}
    769680    if (strcmp(stage, "staticsky") == 0) {
    770       //this group by is needed to join against all the warps (to get camera)
    771       psStringAppend(&query, " GROUP BY %s", "sky_id");
    772     }
    773     if (strcmp(stage, "staticsky_multi") == 0) {
    774681      //this group by is needed to join against all the warps (to get camera)
    775682      psStringAppend(&query, " GROUP BY %s", "sky_id, stage_extra1");
    … …  
    824731    PXOPT_LOOKUP_STR(minidvodb_name, config->args, "-minidvodb_name", false, false);
    825732    PXOPT_LOOKUP_S16(fault,         config->args, "-fault", false, false);
    826 
     733    PXOPT_LOOKUP_S64(stage_extra1, config->args, "-stage_extra1", false, false);
    827734    // generate restrictions
    828735    psMetadata *where = psMetadataAlloc();
    … …  
    902809      }
    903810    }
    904 
     811    //if there is a stage_extra1, set it in addRun (it's not known until it is processed)
     812    if (stage_extra1) {
     813      psString setExtra = NULL;
     814      psStringAppend (&setExtra, "UPDATE addRun set stage_extra1 = %" PRId64, stage_extra1);
     815      psStringAppend (&setExtra, " where add_id = %" PRId64, row->add_id);
     816
     817      if (!p_psDBRunQuery(config->dbh, setExtra)) {
     818        if (!psDBRollback(config->dbh)) {
     819          psError(PS_ERR_UNKNOWN, false, "database error");
     820        }
     821        psError(PS_ERR_UNKNOWN, false, "database error");
     822
     823        return false;
     824      }
     825    }
    905826
    906827
    … …  
    962883    }
    963884    if (strcmp (stage,"staticsky") == 0) {
    964     query = pxDataGet("addtool_find_processedexp_staticsky.sql");
    965     }
    966     if (strcmp (stage,"staticsky_multi") == 0) {
    967885    query = pxDataGet("addtool_find_processedexp_staticsky_multi.sql");
    968886    }
    … …  
    1049967    PXOPT_COPY_S64(config->args, where, "-add_id",    "addRun.add_id",         "==");
    1050968    PXOPT_COPY_S64(config->args, where, "-stage_id",    "addRun.stage_id",         "==");
    1051     PXOPT_LOOKUP_STR(stage,       config->args, "-stage", false, false);
     969    PXOPT_LOOKUP_STR(stage,       config->args, "-stage", true, false);
    1052970    pxcamGetSearchArgs (config, where);
    1053971    pxAddLabelSearchArgs (config, where, "-label",    "addRun.label",     "==");
    … …  
    1075993         query = pxDataGet("addtool_revertprocessedexp_stack.sql");
    1076994      }
    1077      if (strcmp(stage, "staticsky") == 0) {
    1078          query = pxDataGet("addtool_revertprocessedexp_staticsky.sql");
    1079       }
    1080    if (strcmp(stage, "staticsky_multi") == 0) {
     995    if (strcmp(stage, "staticsky") == 0) {
    1081996         query = pxDataGet("addtool_revertprocessedexp_staticsky_multi.sql");
    1082997      }
    … …  
    12211136
    12221137  PXOPT_LOOKUP_STR(minidvodb_group, config->args, "-set_minidvodb_group", true, false);
    1223   PXOPT_LOOKUP_STR(mergedvodb_path, config->args, "-set_mergedvodb_path", true, false);
    1224 
    1225   //optional
     1138    //optional
    12261139  PXOPT_LOOKUP_STR(minidvodb_name, config->args, "-set_minidvodb_name", false, false);
    12271140  PXOPT_LOOKUP_STR(minidvodb_path, config->args, "-set_minidvodb_path", false, false);
    … …  
    12381151  if (minidvodb_path) {
    12391152    minidvodbpath = minidvodb_path;
     1153  } else {
     1154    psError(PS_ERR_UNKNOWN, false, "require minidvodb_path");
     1155    return false;
    12401156  }
    12411157
    … …  
    12451161            minidvodb_group,
    12461162            minidvodbpath,
    1247             mergedvodb_path,
    1248             "new",
     1163            "new",
    12491164            0
    12501165            )) {
    … …  
    12681183    psStringAppend(&minidvodb_name, "%s.%" PRIu64,minidvodb_group,minidvodb_id);
    12691184  }
    1270 
    1271   if (!minidvodb_path) {
    1272     psStringAppend(&minidvodb_path,"%s/%s",mergedvodb_path,minidvodb_name);
    1273   }
    1274 
    12751185  if (minidvodb_path) {
    12761186    psStringAppend(&minidvodb_path,"/%s",minidvodb_name);
    … …  
    13041214    PXOPT_COPY_STR(config->args, where, "-state",     "state", "==");
    13051215    PXOPT_COPY_STR(config->args, where, "-minidvodb_path", "minidvodb_path", "==");
    1306     PXOPT_COPY_STR(config->args, where, "-mergedvodb_path", "mergedvodb_path", "==");
    13071216    PXOPT_COPY_STR(config->args, where, "-minidvodb_group",     "minidvodb_group", "==");
    13081217
    … …  
    13101219    PXOPT_LOOKUP_STR(minidvodb_path,  config->args, "-set_minidvodb_path", false, false);
    13111220    PXOPT_LOOKUP_STR(state,  config->args, "-set_state", false, false);
    1312     PXOPT_LOOKUP_STR(mergedvodb_path,  config->args, "-set_mergedvodb_path", false, false);
    13131221    PXOPT_LOOKUP_STR(minidvodb_group,  config->args, "-set_minidvodb_group", false, false);
    13141222
    … …  
    13451253    }
    13461254
    1347     if (mergedvodb_path) {
    1348       if (cnt) {
    1349         psStringAppend(&query, "%s", comma);
    1350       }
    1351       psStringAppend(&query, " mergedvodb_path = '%s'", mergedvodb_path);
    1352       cnt++;
    1353     }
    1354 
    13551255    if (minidvodb_group) {
    13561256      if (cnt) {
    … …  
    13961296  }
    13971297
    1398   psString firstquery = psStringCopy("SELECT * from  minidvodbRun where state = 'new' and minidvodb_name is NOT NULL and minidvodb_group IS NOT NULL and minidvodb_path IS NOT NULL and mergedvodb_path IS NOT NULL");
     1298  psString firstquery = psStringCopy("SELECT * from  minidvodbRun where state = 'new' and minidvodb_name is NOT NULL and minidvodb_group IS NOT NULL and minidvodb_path IS NOT NULL");
    13991299
    14001300  psString firstwhereClause = psDBGenerateWhereConditionSQL(where, NULL);
    … …  
    14441344
    14451345  //now flip new -> active
    1446   psString query2 = psStringCopy("UPDATE minidvodbRun SET state = 'active' WHERE state = 'new' AND minidvodb_name is NOT NULL and minidvodb_group IS NOT NULL and minidvodb_path IS NOT NULL and mergedvodb_path IS NOT NULL ");
     1346  psString query2 = psStringCopy("UPDATE minidvodbRun SET state = 'active' WHERE state = 'new' AND minidvodb_name is NOT NULL and minidvodb_group IS NOT NULL and minidvodb_path IS NOT NULL ");
    14471347  psStringAppend(&query2, " AND minidvodb_group = '%s' limit 1;", minidvodb_group);
    14481348  if (!p_psDBRunQuery(config->dbh, query2)) {
    … …  
    14801380  PXOPT_COPY_STR(config->args, where, "-minidvodb_name", "minidvodbRun.minidvodb_name", "==");
    14811381  PXOPT_COPY_STR(config->args, where, "-state", "minidvodbRun.state", "==");
    1482 
    1483 
     1382  PXOPT_LOOKUP_STR(minidvodb_group,  config->args, "-minidvodb_group", false, false);
     1383 
    14841384  PXOPT_LOOKUP_U64(limit,      config->args, "-limit", false, false);
    14851385  PXOPT_LOOKUP_BOOL(all_addrun_states, config->args, "-all_addrun_states", false);
    … …  
    14931393  }
    14941394
    1495   psString query = pxDataGet("addtool_checkminidvodbaddrun.sql");
    1496 
    1497   if (!query) {
     1395  if (!minidvodb_group) {
     1396    psError(PXTOOLS_ERR_CONFIG, false, "minidvodb_group  required");
     1397    return false;
     1398  }
     1399
     1400
     1401  psString bare_query = pxDataGet("addtool_checkminidvodbaddrun.sql");
     1402 
     1403  if (!bare_query) {
    14981404        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    14991405        return false;
    15001406  }
    15011407
    1502 
     1408  psString where_string = NULL;
    15031409  if (psListLength(where->list)) {
    15041410    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    1505         psStringAppend(&query, " WHERE %s", whereClause);
     1411        psStringAppend(&where_string, " WHERE %s", whereClause);
    15061412        psFree(whereClause);
    1507   }
    1508 
     1413        //search params are defined above
     1414  }
     1415
     1416  psString query = NULL;
     1417  psStringAppend(&query, bare_query, minidvodb_group);
     1418  psStringAppend(&query, where_string);
     1419
     1420
     1421
     1422
     1423 
    15091424  if (!all_addrun_states) {
    15101425    psStringAppend(&query, " AND (cnt2 = cnt) ");
    … …  
    15191434
    15201435  if (!p_psDBRunQuery(config->dbh, query)) {
    1521     psError(PS_ERR_UNKNOWN, false, "database error");
     1436    psError(PS_ERR_UNKNOWN, false, "database error,\n\n%s", query);
    15221437    psFree(query);
    15231438    return false;
    … …  
    16211536    // required
    16221537  PXOPT_LOOKUP_U64(minidvodb_id, config->args, "-minidvodb_id", true, false);
    1623   PXOPT_LOOKUP_STR(mergedvodb_path, config->args, "-mergedvodb_path", true, false);
    16241538  PXOPT_LOOKUP_STR(minidvodb_group, config->args, "-minidvodb_group", true, false);
    16251539
    16261540    // optional
    1627   PXOPT_LOOKUP_U64(merge_order,     config->args, "-merge_order", false, false);
    16281541  PXOPT_LOOKUP_F32(dtime_relphot, config->args, "-dtime_relphot", false, false);
    16291542  PXOPT_LOOKUP_F32(dtime_resort, config->args, "-dtime_resort", false, false);
    1630   PXOPT_LOOKUP_F32(dtime_merge, config->args, "-dtime_merge", false, false);
    1631   PXOPT_LOOKUP_F32(dtime_verify, config->args, "-dtime_verify", false, false);
    16321543  PXOPT_LOOKUP_F32(dtime_script, config->args, "-dtime_script", false, false);
    16331544 
    … …  
    16801591  minidvodbProcessedRow *row = minidvodbProcessedRowAlloc(
    16811592               pendingRow->minidvodb_id,
    1682                merge_order,
    16831593               dtime_resort,
    16841594               dtime_relphot,
    1685                dtime_verify,
    1686                dtime_merge,
    16871595               dtime_script,
    16881596               epoch,
    1689                mergedvodb_path,
    16901597               fault
    16911598               );
    … …  
    17021609  }
    17031610
    1704 
    1705 
    1706 
    1707   //this finds the # of merged things (for the merge order)
    1708   psString query3 = NULL;
    1709   psStringAppend(&query3, "select count(*) from minidvodbRun join minidvodbProcessed using (minidvodb_id) where state = 'merged' and minidvodb_group = '%s';", minidvodb_group);
    1710 
    1711   if (!p_psDBRunQuery(config->dbh, query3)) {
    1712     // rollback
    1713     if (!psDBRollback(config->dbh)) {
    1714       psError(PS_ERR_UNKNOWN, false, "database error");
    1715     }
    1716     psError(PS_ERR_UNKNOWN, false, "database error");
    1717     psFree(query3);
    1718     return false;
    1719   }
    1720   psArray *output2 = p_psDBFetchResult(config->dbh);
    1721   if (!output2) {
    1722     psError(PS_ERR_UNKNOWN, false, "database error");
    1723     return false;
    1724   }
    1725   if (!psArrayLength(output2)) {
    1726     psTrace("addtool", PS_LOG_INFO, "no rows found");
    1727     psFree(output);
    1728     return true;
    1729   }
    1730   bool status;
    1731   psS64 m_order = psMetadataLookupS64(&status, output2->data[0], "count(*)");
    1732   if (!status) {
    1733 
    1734     psAbort("failed to lookup value for count column");
    1735     return false;
    1736   }
    1737   psString final = NULL;
    1738   psStringAppend(&final, "%" PRIu64, m_order);
    1739     //return false;
    1740   psFree(query3);
    1741   psFree(output2);
    1742 
    1743 
    1744 
    1745   //update the merge_order
    1746 
    1747   psString query4 = NULL;
    1748   psStringAppend(&query4, "update minidvodbProcessed set merge_order = %"PRIu64,m_order);
    1749   psStringAppend(&query4," where minidvodb_id = %" PRIu64,  minidvodb_id);
    1750   //printf("%s", query4);
    1751   if (!p_psDBRunQuery(config->dbh, query4)) {
    1752     // rollback
    1753     if (!psDBRollback(config->dbh)) {
    1754       psError(PS_ERR_UNKNOWN, false, "database error");
    1755     }
    1756     psError(PS_ERR_UNKNOWN, false, "database error");
    1757     psFree(query4);
    1758     return false;
    1759   }
    1760   //
    1761 psFree(query4);
    1762 
    1763 
    1764 
    1765 // since there is only one exp per 'new' set mindvodbRun.state = 'merged'
    1766 
    17671611  psString query2 = NULL ;
    17681612  psStringAppend(&query2, "UPDATE minidvodbRun SET state = 'merged' WHERE minidvodb_id = %'" PRIu64, row->minidvodb_id);
    … …  
    17771621    return false;
    17781622  }
    1779 
    1780 
    1781 
    1782 
    1783 
    1784 
    1785 
    1786 
    17871623  psFree(row);
    17881624  psFree(pendingRow);
    … …  
    17971633    return false;
    17981634  }
    1799 
    1800 
    1801   //print the merge_order (why not!)
    1802   printf("%s", final);
    1803   psFree(final);
    1804 
    18051635  return true;
    18061636}
    … …  
    19611791
    19621792  PXOPT_LOOKUP_U64(minidvodb_id,  config->args, "-minidvodb_id", true, false);
    1963   PXOPT_LOOKUP_U64(merge_order,  config->args, "-set_merge_order", false, false);
    19641793  PXOPT_LOOKUP_S16(fault,  config->args, "-set_fault", false, false);
    19651794  PXOPT_LOOKUP_F32(dtime_relphot,  config->args, "-set_dtime_relphot", false, false);
    19661795  PXOPT_LOOKUP_F32(dtime_resort,  config->args, "-set_dtime_resort", false, false);
    1967   PXOPT_LOOKUP_F32(dtime_merge,  config->args, "-set_dtime_merge", false, false);
    1968 PXOPT_LOOKUP_F32(dtime_verify,  config->args, "-set_dtime_verify", false, false);
    19691796PXOPT_LOOKUP_F32(dtime_script,  config->args, "-set_dtime_script", false, false);
    19701797  PXOPT_COPY_S64(config->args, where, "-minidvodb_id",     "minidvodbProcessed.minidvodb_id", "==");
    … …  
    19861813  }
    19871814
    1988   if (merge_order) {
    1989     if (cnt) {
    1990       psStringAppend(&query, "%s", comma);
    1991     }
    1992 
    1993     psStringAppend(&query, " merge_order = %" PRId64, merge_order);
    1994     cnt++;
    1995   }
    1996 
    19971815  if (dtime_relphot) {
    19981816    if (cnt) {
    … …  
    20111829  }
    20121830
    2013   if (dtime_merge) {
    2014     if (cnt) {
    2015       psStringAppend(&query, "%s", comma);
    2016     }
    2017     psStringAppend(&query, " dtime_merge = %f", dtime_merge);
    2018     cnt++;
    2019  }
    2020 if (dtime_verify) {
    2021     if (cnt) {
    2022       psStringAppend(&query, "%s", comma);
    2023     }
    2024     psStringAppend(&query, " dtime_verify = %f", dtime_verify);
    2025     cnt++;
    2026  }
    2027 if (dtime_script) {
     1831  if (dtime_script) {
    20281832    if (cnt) {
    20291833      psStringAppend(&query, "%s", comma);

  • branches/eam_branches/ipp-20111122/ippTools/src/addtoolConfig.c

    r31680 r33638  
    115115    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-dtime_addstar", 0, "define elapsed time for DVO insertion (seconds)", NAN);
    116116    psMetadataAddS16(addprocessedexpArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code", 0);
     117psMetadataAddS64(addprocessedexpArgs, PS_LIST_TAIL, "-stage_extra1",  0,            "set stage_extra1", 0);
     118
    117119
    118120    // -processedexp
    … …  
    165167    psMetadataAddStr(addminidvodbrunArgs, PS_LIST_TAIL, "-set_minidvodb_group",        0, "define minidvodb_group (required)", NULL);
    166168    psMetadataAddStr(addminidvodbrunArgs, PS_LIST_TAIL, "-set_minidvodb_path",        0, "define path for minidvodb", NULL);
    167     psMetadataAddStr(addminidvodbrunArgs, PS_LIST_TAIL, "-set_mergedvodb_path",        0, "define path for the merged dvodb (required)", NULL);
    168169    psMetadataAddStr(addminidvodbrunArgs, PS_LIST_TAIL, "-set_state",        0, "define state", NULL);
    169170
    … …  
    174175    psMetadataAddStr(updateminidvodbrunArgs, PS_LIST_TAIL, "-minidvodb_name",        0, "search by minidvodb_name (LIKE)", NULL);
    175176    psMetadataAddStr(updateminidvodbrunArgs, PS_LIST_TAIL, "-minidvodb_path",        0, "search by path for minidvodb", NULL);
    176     psMetadataAddStr(updateminidvodbrunArgs, PS_LIST_TAIL, "-mergedvodb_path",        0, "search by path for the merged dvodb", NULL);
    177177    psMetadataAddStr(updateminidvodbrunArgs, PS_LIST_TAIL, "-state",        0, "search by state", NULL);
    178178    psMetadataAddStr(updateminidvodbrunArgs, PS_LIST_TAIL, "-set_minidvodb_name",        0, "define minidvodb_name", NULL);
    179179    psMetadataAddStr(updateminidvodbrunArgs, PS_LIST_TAIL, "-set_minidvodb_path",        0, "define path for minidvodb", NULL);
    180     psMetadataAddStr(updateminidvodbrunArgs, PS_LIST_TAIL, "-set_mergedvodb_path",        0, "define path for minidvodb", NULL);
    181180    psMetadataAddStr(updateminidvodbrunArgs, PS_LIST_TAIL, "-set_minidvodb_group",        0, "define path for the merged dvodb", NULL);
    182181    psMetadataAddStr(updateminidvodbrunArgs, PS_LIST_TAIL, "-set_state",        0, "define state", NULL);
    … …  
    205204    psMetadata *addminidvodbprocessedArgs = psMetadataAlloc();
    206205    psMetadataAddU64(addminidvodbprocessedArgs, PS_LIST_TAIL, "-minidvodb_id", 0,    "define minidvodb_id (required)", 0);
    207     psMetadataAddU64(addminidvodbprocessedArgs, PS_LIST_TAIL, "-merge_order",    0,    "define merge order", 0);
    208206    psMetadataAddF32(addminidvodbprocessedArgs, PS_LIST_TAIL, "-dtime_relphot",  0,    "define elapsed time for relphot (seconds)", NAN);
    209207    psMetadataAddF32(addminidvodbprocessedArgs, PS_LIST_TAIL, "-dtime_resort", 0,    "define elapsed time for resort (seconds)", NAN);
    210     psMetadataAddF32(addminidvodbprocessedArgs, PS_LIST_TAIL, "-dtime_verify",    0,    "define elapsed time for DVO verify (seconds)", NAN);
    211     psMetadataAddF32(addminidvodbprocessedArgs, PS_LIST_TAIL, "-dtime_merge",    0,    "define elapsed time for DVO merge (seconds)", NAN);
    212208    psMetadataAddF32(addminidvodbprocessedArgs, PS_LIST_TAIL, "-dtime_script",    0,    "define elapsed time for script (seconds)", NAN);
    213209    psMetadataAddTime(addminidvodbprocessedArgs, PS_LIST_TAIL, "-epoch",         0,    "time merge is finished", NULL);
    214     psMetadataAddStr(addminidvodbprocessedArgs, PS_LIST_TAIL, "-mergedvodb_path",0,    "path of merged dvodb", NULL);
    215210    psMetadataAddStr(addminidvodbprocessedArgs, PS_LIST_TAIL, "-minidvodb_group",0,    "minidvodb_group", NULL);
    216211    psMetadataAddS16(addminidvodbprocessedArgs, PS_LIST_TAIL, "-fault",          0,    "set fault code", 0);
    … …  
    232227    psMetadataAddStr(updateminidvodbprocessedArgs, PS_LIST_TAIL, "-minidvodb_name",        0, "search by minidvodb_name", NULL);
    233228    psMetadataAddS16(updateminidvodbprocessedArgs, PS_LIST_TAIL, "-set_fault",  0,            "set fault code", 0);
    234     psMetadataAddU64(updateminidvodbprocessedArgs, PS_LIST_TAIL, "-set_merge_order",    0,    "define merge order", 0);
    235229    psMetadataAddF32(updateminidvodbprocessedArgs, PS_LIST_TAIL, "-set_dtime_relphot",  0,    "define elapsed time for relphot (seconds)", 0);
    236230    psMetadataAddF32(updateminidvodbprocessedArgs, PS_LIST_TAIL, "-set_dtime_resort", 0,    "define elapsed time for resort (seconds)", 0);
    237     psMetadataAddF32(updateminidvodbprocessedArgs, PS_LIST_TAIL, "-set_dtime_verify",    0,    "define elapsed time for DVO verify (seconds)", 0);
    238     psMetadataAddF32(updateminidvodbprocessedArgs, PS_LIST_TAIL, "-set_dtime_merge",    0,    "define elapsed time for DVO merge (seconds)", 0);
    239231    psMetadataAddF32(updateminidvodbprocessedArgs, PS_LIST_TAIL, "-set_dtime_script",    0,    "define elapsed time for script (seconds)", 0);
    240232    psMetadata *argSets = psMetadataAlloc();

  • branches/eam_branches/ipp-20111122/ippTools/src/camtool.c

    r30907 r33638  
    112112    PXOPT_COPY_STR(config->args, where, "-reduction", "chipRun.reduction", "==");
    113113    PXOPT_COPY_STR(config->args, where, "-data_group", "chipRun.data_group", "==");
     114    PXOPT_COPY_STR(config->args, where, "-obs_mode", "rawExp.obs_mode", "==");
    114115
    115116    if (!psListLength(where->list) &&

  • branches/eam_branches/ipp-20111122/ippTools/src/camtoolConfig.c

    r30907 r33638  
    5555    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-reduction",          0, "search by chipRun reduction class", NULL);
    5656    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-data_group",         0, "search by chipRun data_group", NULL);
     57    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-obs_mode",           0, "search by rawExp obs_mode", NULL);
    5758
    5859    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_workdir",        0, "define workdir", NULL);

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

    r32653 r33638  
    198198        GET_VALUE (psS64,    S64, exp_id,        "exp_id");
    199199        GET_VALUE (psString, Str, raw_workdir,   "workdir");
     200#ifdef notyet
     201        GET_VALUE (psString, Str, old_workdir,   "old_workdir");
     202        GET_VALUE (psString, Str, old_data_group, "old_data_group");
     203#else   
     204        const char *old_workdir = NULL;
     205        const char *old_data_group = NULL;
     206#endif
    200207        GET_VALUE (psString, Str, raw_label,     "label");
    201208        GET_VALUE (psString, Str, raw_reduction, "reduction");
    … …  
    213220        if (!pxchipQueueByExpTag(config,
    214221                                 exp_id,
    215                                  workdir     ? workdir   : raw_workdir,
     222                                 workdir     ? workdir   : (old_workdir ? old_workdir : raw_workdir),
    216223                                 label       ? label     : raw_label,
    217                                  data_group  ? data_group : (label ? label : raw_label),
     224                                 data_group  ? data_group : (old_data_group ? old_data_group : (label ? label : raw_label)),
    218225                                 dist_group,
    219226                                 reduction   ? reduction : raw_reduction,
    … …  
    345352    pxAddLabelSearchArgs (config, where, "-label", "chipOld.label", "LIKE");
    346353    pxAddLabelSearchArgs (config, where, "-data_group", "chipOld.data_group", "LIKE");
     354    PXOPT_COPY_STR(config->args,  where, "-state",   "chipOld.state",   "==");
    347355
    348356    // psListLength(where->list) is at least 1 because exp_type defaults to "object"
    … …  
    354362    }
    355363
    356     PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", true, false);
     364    PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", false, false);
    357365    PXOPT_LOOKUP_STR(label, config->args, "-set_label", true, false);
    358366    PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false);
    … …  
    468476    PXOPT_COPY_S64(config->args, where, "-chip_id", "chipRun.chip_id", "==");
    469477    pxAddLabelSearchArgs (config, where, "-label", "chipRun.label", "==");
     478    PXOPT_COPY_STR(config->args, where, "-class_id", "rawImfile.class_id", "==");
    470479
    471480    psString query = pxDataGet("chiptool_pendingimfile.sql");
    … …  
    10061015    PXOPT_COPY_S64(config->args, where, "-chip_id", "chipProcessedImfile.chip_id", "==");
    10071016    PXOPT_COPY_STR(config->args, where, "-class_id", "chipProcessedImfile.class_id", "==");
    1008     PXOPT_LOOKUP_S64(chip_id, config->args, "-chip_id", true, false);
     1017    PXOPT_COPY_S64(config->args, where, "-cam_id", "cam_id", "==");
     1018
     1019    PXOPT_LOOKUP_S64(cam_id, config->args, "-cam_id", false, false);
     1020    // if cam_id is not supplied chip_id is required
     1021    PXOPT_LOOKUP_S64(chip_id, config->args, "-chip_id", cam_id ? false : true, false);
    10091022    PXOPT_LOOKUP_S64(class_id, config->args, "-class_id", true, false);
    10101023    PXOPT_LOOKUP_S16(quality, config->args, "-set_quality", true, false);
    … …  
    10171030    if (psListLength(where->list) == 0) {
    10181031        // won't get here
    1019         psError(PXTOOLS_ERR_CONFIG, true, "-chip_id and -class_id are required");
     1032        psError(PXTOOLS_ERR_CONFIG, true, "-chip_id (or -cam_id) and -class_id are required");
    10201033        return false;
    10211034    }
    … …  
    20242037        return false;
    20252038    }
    2026 
    20272039    psFree(setHook);
    20282040    psFree(query);
     2041
     2042    // if we are updating a whole chipRun set lingering chips with poor quality to full data_state
     2043    if (!class_id) {
     2044        query = "UPDATE chipProcessedImfile SET data_state ='full', fault = 0 WHERE chip_id = %" PRId64 " AND quality != 0 AND (data_state ='cleaned' OR data_state = 'update')";
     2045       
     2046        if (!p_psDBRunQueryF(config->dbh, query, chip_id)) {
     2047            psError(PS_ERR_UNKNOWN, false, "database error");
     2048            return false;
     2049        }
     2050    }
    20292051
    20302052    return true;

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

    r32577 r33638  
    7272
    7373    psMetadataAddStr(definecopyArgs, PS_LIST_TAIL, "-exp_type", PS_META_REPLACE, "search by exp_type", "object");
    74 
    75     psMetadataAddStr(definecopyArgs, PS_LIST_TAIL, "-set_workdir", 0, "define workdir (required)", NULL);
     74    psMetadataAddStr(definecopyArgs, PS_LIST_TAIL, "-state", 0, "search by chipRun.state", NULL);
     75
     76    psMetadataAddStr(definecopyArgs, PS_LIST_TAIL, "-set_workdir", 0, "define workdir", NULL);
    7677    psMetadataAddStr(definecopyArgs, PS_LIST_TAIL, "-set_label", 0, "define label (required)", NULL);
    7778    psMetadataAddStr(definecopyArgs, PS_LIST_TAIL, "-set_reduction", 0, "define reduction class", NULL);
    … …  
    111112    psMetadataAddS64(pendingimfileArgs, PS_LIST_TAIL, "-chip_id",  0,            "search by chip ID", 0);
    112113    psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-label",  PS_META_DUPLICATE_OK, "search by label", 0);
     114    psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-class_id",  0,          "search by class_id", 0);
    113115    pxchipSetSearchArgs(pendingimfileArgs);
    114116    psMetadataAddU64(pendingimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    … …  
    240242    // -dropprocessedimfile
    241243    psMetadata *dropprocessedimfileArgs = psMetadataAlloc();
    242     psMetadataAddS64(dropprocessedimfileArgs, PS_LIST_TAIL, "-chip_id",  0,            "search by chip ID (required)", 0);
     244    psMetadataAddS64(dropprocessedimfileArgs, PS_LIST_TAIL, "-chip_id",  0,            "search by chip ID", 0);
     245    psMetadataAddS64(dropprocessedimfileArgs, PS_LIST_TAIL, "-cam_id",  0,            "search by cam ID", 0);
    243246    psMetadataAddStr(dropprocessedimfileArgs,  PS_LIST_TAIL, "-class_id",           0, "search by class ID (required)", NULL);
    244247    psMetadataAddS16(dropprocessedimfileArgs, PS_LIST_TAIL, "-set_quality",  0,        "set quality (required)", 0);

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

    r32609 r33638  
    19811981            psString finishQuery = NULL;
    19821982            psStringAppend( &finishQuery,
    1983                 "UPDATE diffRun set state ='full', note = 'dummy run - no overlap' WHERE diff_id = %" PRId64,
     1983                "UPDATE diffRun set state ='full', dist_group = NULL, note = 'dummy run - no overlap' WHERE diff_id = %" PRId64,
    19841984                run->diff_id);
    19851985            if (!p_psDBRunQuery(config->dbh, finishQuery)) {

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

    r32851 r33638  
    3434static bool updaterunMode(pxConfig *config);
    3535static bool revertrunMode(pxConfig *config);
    36 static bool rerunMode(pxConfig *config);
     36static bool startoverMode(pxConfig *config);
    3737static bool pendingcomponentMode(pxConfig *config);
    3838static bool addprocessedcomponentMode(pxConfig *config);
     39static bool updateprocessedcomponentMode(pxConfig *config);
     40static bool revertcomponentMode(pxConfig *config);
    3941static bool revertcomponentMode(pxConfig *config);
    4042static bool processedcomponentMode(pxConfig *config);
    … …  
    8486        MODECASE(DISTTOOL_MODE_UPDATERUN, updaterunMode);
    8587        MODECASE(DISTTOOL_MODE_REVERTRUN, revertrunMode);
    86         MODECASE(DISTTOOL_MODE_RERUN, rerunMode);
     88        MODECASE(DISTTOOL_MODE_STARTOVER, startoverMode);
    8789        MODECASE(DISTTOOL_MODE_PENDINGCOMPONENT, pendingcomponentMode);
    8890        MODECASE(DISTTOOL_MODE_ADDPROCESSEDCOMPONENT, addprocessedcomponentMode);
     91        MODECASE(DISTTOOL_MODE_UPDATEPROCESSEDCOMPONENT, updateprocessedcomponentMode);
    8992        MODECASE(DISTTOOL_MODE_PROCESSEDCOMPONENT, processedcomponentMode);
    9093        MODECASE(DISTTOOL_MODE_REVERTCOMPONENT, revertcomponentMode);
    … …  
    165168
    166169    PXOPT_LOOKUP_BOOL(single, config->args, "-singlefilter", false);
     170    PXOPT_LOOKUP_BOOL(rerun, config->args, "-rerun", false);
    167171
    168172    if (use_alternate) {
    … …  
    404408            psStringAppend(&query, " AND (camRun.state = 'full')");
    405409        }
     410    }
     411    if (!rerun) {
     412        psStringAppend(&query, " AND (distRun.dist_id IS NULL)");
    406413    }
    407414
    … …  
    643650}
    644651
    645 static bool rerunMode(pxConfig *config)
     652static bool startoverMode(pxConfig *config)
    646653{
    647654    psMetadata *where = psMetadataAlloc();
    … …  
    653660
    654661    // require data_group or dist_id to be supplied
    655     PXOPT_LOOKUP_STR(data_group, config->args, "-data_group", true, false);
     662    PXOPT_LOOKUP_STR(data_group, config->args, "-data_group", false, false);
    656663    PXOPT_LOOKUP_S64(dist_id, config->args, "-dist_id", false, false);
    657664    if (!data_group && !dist_id) {
    … …  
    969976    return true;
    970977}
     978static bool updateprocessedcomponentMode(pxConfig *config)
     979{
     980
     981    // required values
     982    PXOPT_LOOKUP_S64(dist_id, config->args, "-dist_id", true, false);
     983    PXOPT_LOOKUP_STR(component, config->args, "-component", true, false);
     984
     985    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
     986    PXOPT_LOOKUP_BOOL(clearfault, config->args, "-clearfault", false);
     987    PXOPT_LOOKUP_S32(bytes, config->args, "-bytes", false, false);
     988    PXOPT_LOOKUP_STR(md5sum, config->args, "-md5sum", false, false);
     989    PXOPT_LOOKUP_STR(outdir, config->args, "-outdir", false, false);
     990    PXOPT_LOOKUP_STR(name, config->args, "-name", false, false);
     991
     992    bool setfault = clearfault || fault;
     993
     994    if (!bytes && !md5sum && !outdir && !name && !setfault && !fault) {
     995        psError(PS_ERR_UNKNOWN, true, "at least one of bytes md5sum outdir name fault or setfault is required");
     996        return false;
     997    }
     998
     999    char *sep = "";
     1000    psString query = psStringCopy("UPDATE distComponent SET ");
     1001    if (setfault) {
     1002        psStringAppend(&query, "%s fault = %d", sep, fault ? 1 : 0);
     1003        sep = ", ";
     1004    }
     1005    if (bytes) {
     1006        psStringAppend(&query, "%s bytes = %d", sep, bytes);
     1007        sep = ", ";
     1008    }
     1009    if (md5sum) {
     1010        psStringAppend(&query, "%s md5sum = '%s'", sep, md5sum);
     1011        sep = ", ";
     1012    }
     1013    if (outdir) {
     1014        psStringAppend(&query, "%s outdir = '%s'", sep, outdir);
     1015        sep = ", ";
     1016    }
     1017    if (name) {
     1018        psStringAppend(&query, "%s name = '%s'", sep, name);
     1019        sep = ", ";
     1020    }
     1021
     1022    psStringAppend(&query, "\nWHERE dist_id = %"PRId64 " AND component = '%s'",
     1023        dist_id, component);
     1024
     1025    if (!p_psDBRunQuery(config->dbh, query)) {
     1026        psError(PS_ERR_UNKNOWN, false, "database error");
     1027        psFree(query);
     1028        return false;
     1029    }
     1030    psFree(query);
     1031
     1032    return true;
     1033}
    9711034
    9721035static bool toadvanceMode(pxConfig *config)
    … …  
    10481111    psMetadata *where = psMetadataAlloc();
    10491112    PXOPT_COPY_S64(config->args, where, "-dist_id", "dist_id", "==");
     1113    PXOPT_COPY_STR(config->args, where, "-component", "component", "==");
    10501114
    10511115    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    21852249    psMetadata *where = psMetadataAlloc();
    21862250    PXOPT_COPY_S64(config->args, where, "-fs_id", "fs_id", "==");
     2251    PXOPT_COPY_S64(config->args, where, "-dist_id", "dist_id", "==");
    21872252
    21882253    if (!psListLength(where->list)) {

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

    r28938 r33638  
    2828    DISTTOOL_MODE_UPDATERUN,
    2929    DISTTOOL_MODE_REVERTRUN,
    30     DISTTOOL_MODE_RERUN,
     30    DISTTOOL_MODE_STARTOVER,
    3131    DISTTOOL_MODE_PENDINGCOMPONENT,
    3232    DISTTOOL_MODE_ADDPROCESSEDCOMPONENT,
    3333    DISTTOOL_MODE_REVERTCOMPONENT,
    3434    DISTTOOL_MODE_PROCESSEDCOMPONENT,
     35    DISTTOOL_MODE_UPDATEPROCESSEDCOMPONENT,
    3536    DISTTOOL_MODE_TOADVANCE,
    3637    DISTTOOL_MODE_PENDINGCLEANUP,

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

    r32696 r33638  
    6565    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-singlefilter", 0, "select single filter runs (sky stage only)", false);
    6666
     67    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-rerun", 0, "queue a new distRun even if one already exists", false);
    6768    psMetadataAddU64(definebyqueryArgs, PS_LIST_TAIL, "-limit",  0,  "limit result set to N items", 0);
    6869    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    … …  
    8788    psMetadataAddS16(updaterunArgs, PS_LIST_TAIL, "-fault",      0, "define fault code", 0);
    8889
    89     // -rerun
    90     psMetadata *rerunArgs = psMetadataAlloc();
    91     psMetadataAddStr(rerunArgs, PS_LIST_TAIL, "-data_group",    0, "define data_group (required)", NULL);
    92     psMetadataAddS64(rerunArgs, PS_LIST_TAIL, "-dist_id", 0, "search by dist_id", 0);
    93     psMetadataAddStr(rerunArgs, PS_LIST_TAIL, "-stage",    0, "search by stage", NULL);
    94     psMetadataAddS64(rerunArgs, PS_LIST_TAIL, "-stage_id", 0, "search by stage_id", 0);
    95     psMetadataAddStr(rerunArgs, PS_LIST_TAIL, "-label",    0, "search by label", NULL);
    96     psMetadataAddStr(rerunArgs, PS_LIST_TAIL, "-set_label",    0, "define new label", NULL);
    97     psMetadataAddBool(rerunArgs, PS_LIST_TAIL, "-pretend", 0, "don't queue runs just display what would be selected", false);
    98     psMetadataAddU64(rerunArgs, PS_LIST_TAIL, "-limit",  0,  "limit result set to N items", 0);
    99     psMetadataAddBool(rerunArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     90    // -startover
     91    psMetadata *startoverArgs = psMetadataAlloc();
     92    psMetadataAddStr(startoverArgs, PS_LIST_TAIL, "-data_group",    0, "define data_group", NULL);
     93    psMetadataAddS64(startoverArgs, PS_LIST_TAIL, "-dist_id", 0, "search by dist_id", 0);
     94    psMetadataAddStr(startoverArgs, PS_LIST_TAIL, "-stage",    0, "search by stage", NULL);
     95    psMetadataAddS64(startoverArgs, PS_LIST_TAIL, "-stage_id", 0, "search by stage_id", 0);
     96    psMetadataAddStr(startoverArgs, PS_LIST_TAIL, "-label",    0, "search by label", NULL);
     97    psMetadataAddStr(startoverArgs, PS_LIST_TAIL, "-set_label",    0, "define new label", NULL);
     98    psMetadataAddBool(startoverArgs, PS_LIST_TAIL, "-pretend", 0, "don't queue runs just display what would be selected", false);
     99    psMetadataAddU64(startoverArgs, PS_LIST_TAIL, "-limit",  0,  "limit result set to N items", 0);
     100    psMetadataAddBool(startoverArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    100101
    101102    // -revertrun
    … …  
    151152    psMetadata *processedcomponentArgs = psMetadataAlloc();
    152153    psMetadataAddS64(processedcomponentArgs, PS_LIST_TAIL, "-dist_id", 0, "define dist_id", 0);
     154    psMetadataAddStr(processedcomponentArgs, PS_LIST_TAIL, "-component", 0, "define component", NULL);
    153155    psMetadataAddU64(processedcomponentArgs, PS_LIST_TAIL, "-limit",  0,  "limit result set to N items", 0);
    154156    psMetadataAddBool(processedcomponentArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     157
     158    // -updateprocessedcomponentArgs
     159    psMetadata *updateprocessedcomponentArgs = psMetadataAlloc();
     160    psMetadataAddS64(updateprocessedcomponentArgs, PS_LIST_TAIL, "-dist_id", 0, "define dist_id", 0);
     161    psMetadataAddStr(updateprocessedcomponentArgs, PS_LIST_TAIL, "-component", 0, "define component (required)", NULL);
     162    psMetadataAddStr(updateprocessedcomponentArgs, PS_LIST_TAIL, "-outdir", 0, "define output directory", NULL);
     163    psMetadataAddStr(updateprocessedcomponentArgs, PS_LIST_TAIL, "-name", 0, "define file name", NULL);
     164    psMetadataAddS32(updateprocessedcomponentArgs, PS_LIST_TAIL, "-bytes", 0, "define file size", 0);
     165    psMetadataAddStr(updateprocessedcomponentArgs, PS_LIST_TAIL, "-md5sum", 0, "define stage for bundle", NULL);
     166    psMetadataAddS32(updateprocessedcomponentArgs, PS_LIST_TAIL, "-fault", 0, "define fault code", 0);
     167    psMetadataAddBool(updateprocessedcomponentArgs, PS_LIST_TAIL, "-clearfault", 0, "set fault to zero", false);
    155168
    156169    // -toadvance
    … …  
    180193    psMetadata *updatefilesetArgs = psMetadataAlloc();
    181194    psMetadataAddS64(updatefilesetArgs, PS_LIST_TAIL, "-fs_id", 0, "define fs_id", 0);
    182 //    psMetadataAddS64(updatefilesetArgs, PS_LIST_TAIL, "-dist_id", 0, "define dist_id", 0);
     195    psMetadataAddS64(updatefilesetArgs, PS_LIST_TAIL, "-dist_id", 0, "define dist_id", 0);
    183196    psMetadataAddStr(updatefilesetArgs, PS_LIST_TAIL, "-set_state",0, "new value for state", NULL);
    184197    psMetadataAddS32(updatefilesetArgs, PS_LIST_TAIL, "-fault",   0, "define fault code", 0);
    … …  
    343356    PXOPT_ADD_MODE("-definebyquery",    "define distribution run", DISTTOOL_MODE_DEFINEBYQUERY, definebyqueryArgs);
    344357    PXOPT_ADD_MODE("-updaterun",    "update distRun", DISTTOOL_MODE_UPDATERUN, updaterunArgs);
    345     PXOPT_ADD_MODE("-rerun",        "reprocess a cleaned distribution run", DISTTOOL_MODE_RERUN, rerunArgs);
     358    PXOPT_ADD_MODE("-startover",        "reprocess a cleaned distribution run", DISTTOOL_MODE_STARTOVER, startoverArgs);
    346359    PXOPT_ADD_MODE("-revertrun",    "revert distRun.faults", DISTTOOL_MODE_REVERTRUN, revertrunArgs);
    347360    PXOPT_ADD_MODE("-pendingcomponent",   "", DISTTOOL_MODE_PENDINGCOMPONENT,    pendingcomponentArgs);
    348361    PXOPT_ADD_MODE("-addprocessedcomponent", "", DISTTOOL_MODE_ADDPROCESSEDCOMPONENT, addprocessedcomponentArgs);
     362    PXOPT_ADD_MODE("-updateprocessedcomponent", "", DISTTOOL_MODE_UPDATEPROCESSEDCOMPONENT, updateprocessedcomponentArgs);
    349363    PXOPT_ADD_MODE("-revertcomponent",    "revert faulted components", DISTTOOL_MODE_REVERTCOMPONENT, revertcomponentArgs);
    350364    PXOPT_ADD_MODE("-processedcomponent", "", DISTTOOL_MODE_PROCESSEDCOMPONENT, processedcomponentArgs);

  • branches/eam_branches/ipp-20111122/ippTools/src/faketool.c

    r32743 r33638  
    335335    PXOPT_COPY_F32(config->args, where, "-sun_angle_max", "sun_angle", "<");
    336336    PXOPT_COPY_STR(config->args, where, "-label", "fakeRun.label", "==");
     337    PXOPT_COPY_STR(config->args, where, "-state", "fakeRun.state", "==");
    337338    PXOPT_COPY_STR(config->args, where, "-data_group", "fakeRun.data_group", "==");
    338339    PXOPT_COPY_STR(config->args, where, "-dist_group", "fakeRun.dist_group", "==");

  • branches/eam_branches/ipp-20111122/ippTools/src/laptool.c

    r32422 r33638  
    390390
    391391  PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     392  PXOPT_LOOKUP_U64(limit,   config->args, "-limit",  false, false);
    392393 
    393394  psMetadata *where = psMetadataAlloc();
    … …  
    411412    psStringAppend(&query, " WHERE %s", whereClause);
    412413    psFree(whereClause);
     414  }
     415  if (limit) {
     416    psString limitString = psDBGenerateLimitSQL(limit);
     417    psStringAppend(&query, "\n %s", limitString);
     418    psFree(limitString);
    413419  }
    414420 

  • branches/eam_branches/ipp-20111122/ippTools/src/laptoolConfig.c

    r32422 r33638  
    7474  ADD_OPT(Str, pendingrunArgs, "-fault",                      "search by LAP run fault", NULL);
    7575  ADD_OPT(Bool,pendingrunArgs, "-simple",                     "use the simple output format", false);
     76  ADD_OPT(U64, pendingrunArgs, "-limit",                      "limit result set to N items", 0);
    7677
    7778  // -listrun
    … …  
    8687  ADD_OPT(Str, listrunArgs, "-fault",                      "search by LAP run fault", NULL);
    8788  ADD_OPT(Bool,listrunArgs, "-simple",                     "use the simple output format", false);
     89  ADD_OPT(U64, listrunArgs, "-limit",                      "limit result set to N items", 0);
    8890
    8991  // -updaterun

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

    r32668 r33638  
    779779    case IPP_STAGE_CAMERA:
    780780        query = NULL;
    781         clearRunQuery = "UPDATE chipBackgroundRun SET magicked = 0 where chip_bg_id = %" PRId64;
     781        clearRunQuery = "UPDATE camRun SET magicked = 0 where cam_id = %" PRId64;
    782782        break;
    783783    case IPP_STAGE_WARP:
    … …  
    12421242        } else if (!strcmp(state, "failed_cleanup")) {
    12431243            new_state = "goto_cleaned";
     1244        } else if (!strcmp(state, "failed_restore")) {
     1245            new_state = "goto_restored";
    12441246        } else {
    12451247            psError(PS_ERR_UNKNOWN, true, "unexpected value for state: %s", state);
    … …  
    14101412          (strcmp(state, "drop") == 0) ||
    14111413          (strcmp(state, "wait") == 0) ||
     1414          (strcmp(state, "failed_restore") == 0) ||
    14121415          (strcmp(state, "failed_revert") == 0) ||
    14131416          (strcmp(state, "failed_revert_ud") == 0) ||

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

  • branches/eam_branches/ipp-20111122/ippTools/src/minidvodbtool.c

    r29528 r33638  
    8989    psMetadata *where = psMetadataAlloc();
    9090    pxcamGetSearchArgs (config, where);
    91     PXOPT_COPY_S64(config->args, where,  "-minidvodb_id",    "minidvodbRun.minidvodbRun_id", "==");
     91    PXOPT_COPY_S64(config->args, where,  "-minidvodb_id",    "minidvodbRun.minidvodb_id", "==");
    9292    pxAddLabelSearchArgs (config, where, "-minidvodb_group",     "minidvodbRun.minidvodb_group", "=="); // define using camRun label
    9393   

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

    r32851 r33638  
    704704    PXOPT_LOOKUP_S16(fault,       config->args, "-fault",      false, false);
    705705    PXOPT_LOOKUP_S64(exp_id,      config->args, "-exp_id",     false, false);
    706     PXOPT_LOOKUP_S64(options,     config->args, "-options",     false, false);
     706    PXOPT_LOOKUP_S64(options,     config->args, "-options",    false, false);
    707707    PXOPT_LOOKUP_S64(dep_id,      config->args, "-dep_id",     false, false);
     708    PXOPT_LOOKUP_S64(parent_id,   config->args, "-parent_id",  false, false);
     709    PXOPT_LOOKUP_BOOL(is_parent,  config->args, "-is_parent",  false);
    708710
    709711    // unless the job is being inserted with stop state require outputBase
    … …  
    716718    if (!strcmp(job_type, "get_image") || !strcmp(job_type, "detect_query") || !strcmp(job_type, "none")) {
    717719        stampJob = false;
     720    } else if (!strcmp(job_type, "child")) {
     721        // job_type child's only action is to resolve a dependent
     722        // XXX: IS this necessary?
     723        if (!dep_id) {
     724            psError(PS_ERR_UNKNOWN, true, "dep_id required for child job\n");
     725            return false;
     726        }
     727        if (is_parent) {
     728            psError(PS_ERR_UNKNOWN, true, "job type child can not be a parent job\n");
     729            return false;
     730        }
     731        stampJob = false;
     732    } else if (!strcmp(job_type, "mosaic")) {
     733        stampJob = false;
     734        is_parent = true;
    718735    } else if (!strcmp(job_type, "stamp")) {
    719736        stampJob = true;
    … …  
    723740    }
    724741    if (!pstampJobInsert(config->dbh,
    725             0, // job_id
     742            0,          // job_id
    726743            req_id,
    727744            rownum,
    … …  
    733750            options,
    734751            dep_id,
    735             0   // fault_count
     752            0,          // fault_count
     753            parent_id,
     754            is_parent
    736755            )) {
    737756        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    761780    PXOPT_COPY_S64(config->args, where, "-req_id", "req_id", "==");
    762781    PXOPT_COPY_S64(config->args, where, "-dep_id", "dep_id", "==");
     782    PXOPT_COPY_STR(config->args, where, "-jobType", "jobType", "==");
    763783    PXOPT_COPY_S64(config->args, where, "-fault",  "fault", "==");
    764784
    … …  
    842862
    843863    // use psDBGenerateWhereSQL because the SQL yields an intermediate table
     864    psString whereStr = NULL;
    844865    if (psListLength(where->list)) {
    845866        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    846         psStringAppend(&query, " AND %s", whereClause);
     867        psStringAppend(&whereStr, "\n AND %s", whereClause);
    847868        psFree(whereClause);
     869    } else {
     870        psStringAppend(&whereStr, "%s", "");
    848871    }
    849872    psFree(where);
    … …  
    858881    }
    859882
    860     if (!p_psDBRunQuery(config->dbh, query)) {
    861         psError(PS_ERR_UNKNOWN, false, "database error");
    862         psFree(query);
    863         return false;
    864     }
     883    if (!p_psDBRunQueryF(config->dbh, query, whereStr, whereStr)) {
     884        psError(PS_ERR_UNKNOWN, false, "database error");
     885        psFree(whereStr);
     886        psFree(query);
     887        return false;
     888    }
     889    psFree(whereStr);
    865890    psFree(query);
    866891
    … …  
    956981
    957982    PXOPT_LOOKUP_S32(fault,  config->args, "-set_fault",  true, false);
     983    PXOPT_LOOKUP_STR(state,  config->args, "-set_state",  false, false);
    958984
    959985    psMetadata *where = psMetadataAlloc();
    … …  
    9861012    psFree(where);
    9871013
    988     if (!p_psDBRunQueryF(config->dbh, query, fault, fault)) {
     1014    if (!p_psDBRunQueryF(config->dbh, query, fault, fault, state)) {
    9891015        psError(PS_ERR_UNKNOWN, false, "database error");
    9901016        psFree(query);

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

    r32851 r33638  
    144144    psMetadataAddS64(addjobArgs, PS_LIST_TAIL, "-options", 0,          "define options", 0);
    145145    psMetadataAddS64(addjobArgs, PS_LIST_TAIL, "-dep_id", 0,           "define job dep_id", 0);
     146    psMetadataAddS64(addjobArgs, PS_LIST_TAIL, "-parent_id", 0,        "define parent's job_id", 0);
     147    psMetadataAddBool(addjobArgs, PS_LIST_TAIL, "-is_parent", 0,       "define whether job has children", false);
    146148    psMetadataAddS16(addjobArgs, PS_LIST_TAIL, "-fault", 0,            "define job result", 0);
    147149
    … …  
    152154    psMetadataAddS64(listjobArgs, PS_LIST_TAIL, "-dep_id", 0,          "select by dependent ID", 0);
    153155    psMetadataAddS16(listjobArgs, PS_LIST_TAIL, "-fault", 0,           "select by fault", 0);
     156    psMetadataAddStr(listjobArgs, PS_LIST_TAIL, "-jobType", 0,         "select by jobType", 0);
    154157    psMetadataAddU64(listjobArgs, PS_LIST_TAIL, "-limit",  0,          "limit result set to N items", 0);
    155158    psMetadataAddBool(listjobArgs, PS_LIST_TAIL, "-simple", 0,         "use the simple output format", false);
    … …  
    186189    psMetadataAddS32(stopdependentjobArgs, PS_LIST_TAIL,  "-fault_count", 0,   "select by fault_count (>=)", 0);
    187190    psMetadataAddS16(stopdependentjobArgs, PS_LIST_TAIL,  "-set_fault", 0,    "new fault value for job and dependent (required)", 0);
     191    psMetadataAddStr(stopdependentjobArgs, PS_LIST_TAIL, "-set_state", 0,            "new pstampDependent.state", "new");
    188192    psMetadataAddStr(stopdependentjobArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by pstampJob label (LIKE comparision)", NULL);
    189193    psMetadataAddU64(stopdependentjobArgs, PS_LIST_TAIL, "-limit", 0,      "not used", 0);

  • branches/eam_branches/ipp-20111122/ippTools/src/pxadd.c

    r32851 r33638  
    157157      }
    158158      if (strcmp(stage,"staticsky") == 0) {
    159         query = pxDataGet("addtool_queue_sky_id.sql");
    160         psMemSetPersistent(query, true);
    161       }
    162       if (strcmp(stage,"staticsky_multi") == 0) {
    163159        query = pxDataGet("addtool_queue_sky_id_multi.sql");
    164160        psMemSetPersistent(query, true);

  • branches/eam_branches/ipp-20111122/ippTools/src/pxchip.c

    r28258 r33638  
    7171    psMetadataAddF32(md,  PS_LIST_TAIL, "-sun_angle_min",      0, "search by min solar angle", NAN);
    7272    psMetadataAddF32(md,  PS_LIST_TAIL, "-sun_angle_max",      0, "search by max solar angle", NAN);
    73     psMetadataAddStr(md,  PS_LIST_TAIL, "-object",             0, "search by exposure object", NULL);
     73    psMetadataAddStr(md,  PS_LIST_TAIL, "-object",             0, "search by exposure object (LIKE comparison)", NULL);
    7474    psMetadataAddStr(md,  PS_LIST_TAIL, "-comment",            0, "search by comment field (LIKE comparison)", NULL);
    7575    psMetadataAddStr(md,  PS_LIST_TAIL, "-obs_mode",           0, "search by observation mode", NULL);

  • branches/eam_branches/ipp-20111122/ippTools/src/pztool.c

    r31445 r33638  
    338338        }
    339339
    340         psStringAppend(&query, " ORDER BY dateobs");
    341         if (desc) {
    342             psStringAppend(&query, " DESC");
    343         }
     340/*         psStringAppend(&query, " ORDER BY dateobs"); */
     341/*         if (desc) { */
     342/*             psStringAppend(&query, " DESC"); */
     343/*         } */
    344344
    345345        // request the full "limit" from each known camera and throw away any

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

    r31690 r33638  
    3838static bool resultMode(pxConfig *config);
    3939static bool revertMode(pxConfig *config);
    40 static bool updateresult(pxConfig *config);
     40static bool updateresultMode(pxConfig *config);
    4141static bool exportrunMode(pxConfig *config);
    4242static bool importrunMode(pxConfig *config);
     43
     44static bool defineskycalrunMode(pxConfig *config);
     45static bool updateskycalrunMode(pxConfig *config);
     46static bool pendingskycalrunMode(pxConfig *config);
     47static bool addskycalresultMode(pxConfig *config);
     48static bool skycalresultMode(pxConfig *config);
     49static bool revertskycalresultMode(pxConfig *config);
     50static bool updateskycalresultMode(pxConfig *config);
    4351
    4452static bool setstaticskyRunState(pxConfig *config, psS64 sky_id, const char *state);
    … …  
    6977        MODECASE(STATICSKYTOOL_MODE_RESULT,            resultMode);
    7078        MODECASE(STATICSKYTOOL_MODE_REVERT,            revertMode);
    71         MODECASE(STATICSKYTOOL_MODE_UPDATERESULT,      updateresult);
     79        MODECASE(STATICSKYTOOL_MODE_UPDATERESULT,      updateresultMode);
    7280        MODECASE(STATICSKYTOOL_MODE_EXPORTRUN,         exportrunMode);
    7381        MODECASE(STATICSKYTOOL_MODE_IMPORTRUN,         importrunMode);
     82        MODECASE(STATICSKYTOOL_MODE_DEFINESKYCALRUN,   defineskycalrunMode);
     83        MODECASE(STATICSKYTOOL_MODE_UPDATESKYCALRUN,   updateskycalrunMode);
     84        MODECASE(STATICSKYTOOL_MODE_PENDINGSKYCALRUN,  pendingskycalrunMode);
     85        MODECASE(STATICSKYTOOL_MODE_ADDSKYCALRESULT,   addskycalresultMode);
     86        MODECASE(STATICSKYTOOL_MODE_UPDATESKYCALRESULT,updateskycalresultMode);
     87        MODECASE(STATICSKYTOOL_MODE_REVERTSKYCALRESULT,revertskycalresultMode);
     88        MODECASE(STATICSKYTOOL_MODE_SKYCALRESULT,      skycalresultMode);
    7489        default:
    7590            psAbort("invalid option (this should not happen)");
    … …  
    97112{
    98113    PS_ASSERT_PTR_NON_NULL(config, false);
    99 
    100     // required options
    101     PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", true, false);
     114    PXOPT_LOOKUP_STR(workdir,     config->args, "-set_workdir", true, false);
     115    PXOPT_LOOKUP_STR(label,       config->args, "-set_label", true, false);
    102116
    103117    // optional
    104     PXOPT_LOOKUP_STR(label,       config->args, "-set_label", true, false);
    105118    PXOPT_LOOKUP_STR(data_group,  config->args, "-set_data_group", false, false);
    106119    PXOPT_LOOKUP_STR(dist_group,  config->args, "-set_dist_group", false, false);
    … …  
    111124    psMetadata *whereMD = psMetadataAlloc();
    112125
    113     PXOPT_COPY_STR(config->args, whereMD, "-select_skycell_id",    "stackRun.skycell_id",       "==");
     126    PXOPT_COPY_S64(config->args, whereMD, "-select_stack_id",      "stackRun.stack_id",         "==");
     127    PXOPT_COPY_STR(config->args, whereMD, "-select_skycell_id",    "stackRun.skycell_id",       "LIKE");
    114128    PXOPT_COPY_STR(config->args, whereMD, "-select_tess_id",       "stackRun.tess_id",          "==");
    115129    PXOPT_COPY_F32(config->args, whereMD, "-select_good_frac_min", "stackSumSkyfile.good_frac", ">=");
    … …  
    621635    PXOPT_COPY_STR(config->args, where, "-label",      "staticskyRun.label", "==");
    622636    PXOPT_COPY_STR(config->args, where, "-data_group", "staticskyRun.data_group", "LIKE");
     637    PXOPT_COPY_STR(config->args, where, "-tess_id", "stackRun.tess_id", "LIKE");
     638    PXOPT_COPY_STR(config->args, where, "-skycell_id", "stackRun.skycell_id", "LIKE");
    623639    PXOPT_COPY_S16(config->args, where, "-fault",      "staticskyResult.fault", "==");
     640    PXOPT_LOOKUP_S32(num_filters, config->args, "-num_filters", false, false);
    624641
    625642    PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
    … …  
    645662    psFree(where);
    646663
     664    psStringAppend(&query, "\nGROUP BY sky_id");
     665    if (num_filters) {
     666        psStringAppend(&query, "\nHAVING COUNT(filter) >= %d", num_filters);
     667    }
     668       
     669
    647670    // treat limit == 0 as "no limit"
    648671    if (limit) {
    649672        psString limitString = psDBGenerateLimitSQL(limit);
    650         psStringAppend(&query, " %s", limitString);
     673        psStringAppend(&query, "\n%s", limitString);
    651674        psFree(limitString);
    652675    }
    … …  
    735758}
    736759
    737 static bool updateresult(pxConfig *config)
     760static bool updateresultMode(pxConfig *config)
    738761{
    739762    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    9781001# endif
    9791002
     1003static bool defineskycalrunMode(pxConfig *config)
     1004{
     1005    PS_ASSERT_PTR_NON_NULL(config, false);
     1006
     1007    // required options
     1008    // none required. We get workdir, etc from staticskyRun if not provided
     1009
     1010    // optional
     1011    PXOPT_LOOKUP_STR(label,       config->args, "-set_label", false, false);
     1012    PXOPT_LOOKUP_STR(workdir,     config->args, "-set_workdir", false, false);
     1013    PXOPT_LOOKUP_STR(data_group,  config->args, "-set_data_group", false, false);
     1014    PXOPT_LOOKUP_STR(dist_group,  config->args, "-set_dist_group", false, false);
     1015    PXOPT_LOOKUP_STR(reduction,   config->args, "-set_reduction", false, false);
     1016    PXOPT_LOOKUP_STR(note,        config->args, "-set_note", false, false);
     1017    PXOPT_LOOKUP_TIME(registered, config->args, "-set_registered", false, false);
     1018
     1019    psMetadata *whereMD = psMetadataAlloc();
     1020
     1021    PXOPT_COPY_S64(config->args, whereMD, "-select_sky_id",        "staticskyRun.sky_id",       "==");
     1022    PXOPT_COPY_S64(config->args, whereMD, "-select_stack_id",      "stackRun.stack_id",         "==");
     1023    PXOPT_COPY_STR(config->args, whereMD, "-select_skycell_id",    "stackRun.skycell_id",       "==");
     1024    PXOPT_COPY_STR(config->args, whereMD, "-select_tess_id",       "stackRun.tess_id",          "==");
     1025    PXOPT_COPY_F32(config->args, whereMD, "-select_good_frac_min", "stackSumSkyfile.good_frac", ">=");
     1026    pxAddLabelSearchArgs(config, whereMD, "-select_label",         "stackRun.label",            "LIKE");
     1027    pxAddLabelSearchArgs(config, whereMD, "-select_data_group",    "stackRun.data_group",       "LIKE");
     1028    pxAddLabelSearchArgs(config, whereMD, "-select_filter",        "stackRun.filter",           "LIKE");
     1029
     1030    PXOPT_LOOKUP_BOOL(rerun, config->args, "-rerun", false);
     1031    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1032    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
     1033
     1034    psString query = pxDataGet("staticskytool_defineskycalrun.sql");
     1035    if (!query) {
     1036        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1037        psFree(whereMD);
     1038        return false;
     1039    }
     1040
     1041    if (!psListLength(whereMD->list)) {
     1042        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     1043        psFree(whereMD);
     1044        return false;
     1045    }
     1046
     1047    psString whereClause = psDBGenerateWhereConditionSQL(whereMD, NULL);
     1048    psStringAppend(&query, "\nAND %s", whereClause);
     1049    psFree(whereClause);
     1050    psFree(whereMD);
     1051
     1052    if (!rerun) {
     1053        if (label)  {
     1054            psStringAppend(&query, "\nAND (skycalRun.label IS NULL OR skycalRun.label = '%s')", label);
     1055        }
     1056        psStringAppend(&query, "\nAND skycal_id IS NULL");
     1057    }
     1058
     1059    if (!p_psDBRunQuery(config->dbh, query)) {
     1060        psError(PS_ERR_UNKNOWN, false, "database error");
     1061        psFree(query);
     1062        return false;
     1063    }
     1064    psFree(query);
     1065
     1066    // we now have a list of (tess_id, skycell_id) that (potentially) meet out needs
     1067    // we now need to loop over all of these and for each pair, select the best set of
     1068    // inputs
     1069
     1070    psArray *output = p_psDBFetchResult(config->dbh);
     1071    if (!output) {
     1072        psErrorCode err = psErrorCodeLast();
     1073        switch (err) {
     1074            case PS_ERR_DB_CLIENT:
     1075                psError(PXTOOLS_ERR_SYS, false, "database error");
     1076            case PS_ERR_DB_SERVER:
     1077                psError(PXTOOLS_ERR_PROG, false, "database error");
     1078            default:
     1079                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     1080        }
     1081        return false;
     1082    }
     1083    if (!psArrayLength(output)) {
     1084        psWarning("staticskytool: no rows found");
     1085        psFree(output);
     1086        return true;
     1087    }
     1088    if (pretend) {
     1089        // negative simple so the default is true
     1090        if (!ippdbPrintMetadatas(stdout, output, "skycalRun", !simple)) {
     1091            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1092            psFree(output);
     1093            return false;
     1094        }
     1095        psFree(output);
     1096        return true;
     1097    }
     1098
     1099    for (long i = 0; i < output->n; i++) {
     1100        psMetadata *row = output->data[i]; // Row from select
     1101        bool status;
     1102
     1103        psS64 sky_id = psMetadataLookupS64(&status, row, "sky_id");
     1104        psS64 stack_id = psMetadataLookupS64(&status, row, "stack_id");
     1105        psString sky_workdir = psMetadataLookupStr(&status, row, "workdir");
     1106        psString sky_label =  psMetadataLookupStr(&status, row, "label");
     1107        psString sky_data_group =  psMetadataLookupStr(&status, row, "data_group");
     1108
     1109        // create a staticskyRun
     1110        if (!skycalRunInsert(config->dbh,
     1111                                0x0,         // skycal_id
     1112                                sky_id,
     1113                                stack_id,
     1114                                "new",       // state
     1115                                workdir ? workdir : sky_workdir,
     1116                                label ? label : sky_label,
     1117                                data_group ? data_group : sky_data_group,
     1118                                dist_group,
     1119                                reduction,
     1120                                registered,
     1121                                note
     1122                )
     1123            ) {
     1124            psError(PS_ERR_UNKNOWN, false, "database error");
     1125            psFree(output);
     1126            return false;
     1127        }
     1128
     1129    }
     1130    psFree(output);
     1131    return true;
     1132}
     1133
     1134static bool updateskycalrunMode(pxConfig *config)
     1135{
     1136#ifdef notyet
     1137    PS_ASSERT_PTR_NON_NULL(config, false);
     1138
     1139    psMetadata *where = psMetadataAlloc();
     1140    PXOPT_COPY_S64(config->args, where, "-sky_id",  "sky_id",   "==");
     1141    PXOPT_COPY_STR(config->args, where, "-label",   "label",    "==");
     1142    PXOPT_COPY_STR(config->args, where, "-state",   "state",    "==");
     1143    if (!psListLength(where->list)) {
     1144        psFree(where);
     1145        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     1146        return false;
     1147    }
     1148
     1149    psString query = psStringCopy("UPDATE staticskyRun");
     1150
     1151    // pxUpdateRun gets parameters from config->args and updates
     1152    bool result = pxUpdateRun(config, where, &query, "staticskyRun", "sky_id", "staticskyResult", true, false);
     1153    psFree(query);
     1154    psFree(where);
     1155
     1156    return result;
     1157#endif
     1158    return false;
     1159}
     1160static bool pendingskycalrunMode(pxConfig *config)
     1161{
     1162    PS_ASSERT_PTR_NON_NULL(config, false);
     1163
     1164    psMetadata *whereMD = psMetadataAlloc();
     1165    PXOPT_COPY_S64(config->args, whereMD, "-skycal_id", "skycal_id", "==");
     1166    PXOPT_COPY_S64(config->args, whereMD, "-sky_id", "sky_id", "==");
     1167    pxAddLabelSearchArgs (config, whereMD, "-label", "skycalRun.label", "==");
     1168    PXOPT_COPY_STR(config->args, whereMD, "-filter", "stackRun.filter", "LIKE");
     1169
     1170    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1171    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1172
     1173    psString query = pxDataGet("staticskytool_pendingskycalrun.sql");
     1174    if (!query) {
     1175        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1176        return false;
     1177    }
     1178
     1179    if (!psListLength(whereMD->list)) {
     1180        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     1181        psFree(whereMD);
     1182        return false;
     1183    }
     1184
     1185    psString whereClause = psDBGenerateWhereConditionSQL(whereMD, NULL);
     1186    psStringAppend(&query, "\n AND %s", whereClause);
     1187    psFree(whereClause);
     1188    psFree(whereMD);
     1189
     1190    // treat limit == 0 as "no limit"
     1191    if (limit) {
     1192        psString limitString = psDBGenerateLimitSQL(limit);
     1193        psStringAppend(&query, "\n%s", limitString);
     1194        psFree(limitString);
     1195    }
     1196
     1197    // the where clause is required and matches the WHERE hook format string
     1198    if (!p_psDBRunQuery(config->dbh, query)) {
     1199        psError(PS_ERR_UNKNOWN, false, "database error");
     1200        psFree(query);
     1201        return false;
     1202    }
     1203    psFree(query);
     1204
     1205    psArray *output = p_psDBFetchResult(config->dbh);
     1206    if (!output) {
     1207        psErrorCode err = psErrorCodeLast();
     1208        switch (err) {
     1209            case PS_ERR_DB_CLIENT:
     1210                psError(PXTOOLS_ERR_SYS, false, "database error");
     1211            case PS_ERR_DB_SERVER:
     1212                psError(PXTOOLS_ERR_PROG, false, "database error");
     1213            default:
     1214                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     1215        }
     1216
     1217        return false;
     1218    }
     1219    if (!psArrayLength(output)) {
     1220        psTrace("staticskytool", PS_LOG_INFO, "no rows found");
     1221        psFree(output);
     1222        return true;
     1223    }
     1224
     1225    if (psArrayLength(output)) {
     1226        // negative simple so the default is true
     1227        if (!ippdbPrintMetadatas(stdout, output, "pendingskycalRun", !simple)) {
     1228            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1229            psFree(output);
     1230            return false;
     1231        }
     1232    }
     1233
     1234    psFree(output);
     1235    return true;
     1236}
     1237
     1238static bool addskycalresultMode(pxConfig *config)
     1239{
     1240    PS_ASSERT_PTR_NON_NULL(config, false);
     1241
     1242    // required
     1243    PXOPT_LOOKUP_S64(skycal_id, config->args, "-skycal_id", true, false);
     1244
     1245    // optional
     1246    PXOPT_LOOKUP_F32(sigma_ra, config->args,  "-sigma_ra", false, false);
     1247    PXOPT_LOOKUP_F32(sigma_dec, config->args, "-sigma_dec", false, false);
     1248
     1249    PXOPT_LOOKUP_F32(zpt_obs, config->args,   "-zpt_obs", false, false);
     1250    PXOPT_LOOKUP_F32(zpt_stdev, config->args, "-zpt_stdev", false, false);
     1251
     1252
     1253    PXOPT_LOOKUP_F32(dtime_script, config->args,   "-dtime_script", false, false);
     1254    PXOPT_LOOKUP_F32(dtime_astrom, config->args,   "-dtime_astrom", false, false);
     1255
     1256    PXOPT_LOOKUP_STR(hostname, config->args,    "-hostname", false, false);
     1257//    PXOPT_LOOKUP_S32(n_stars, config->args,     "-n_stars", false, false);
     1258    PXOPT_LOOKUP_S32(n_astrom, config->args,    "-n_astrom", false, false);
     1259
     1260    PXOPT_LOOKUP_STR(path_base, config->args,   "-path_base", false, false);
     1261    PXOPT_LOOKUP_S16(fault, config->args,       "-fault", false, false);
     1262    PXOPT_LOOKUP_S16(quality, config->args,     "-quality", false, false);
     1263
     1264    PXOPT_LOOKUP_STR(ver_pslib, config->args,   "-ver_pslib", false, false);
     1265    PXOPT_LOOKUP_STR(ver_psmodules, config->args, "-ver_psmodules", false, false);
     1266    PXOPT_LOOKUP_STR(ver_psphot, config->args,  "-ver_psphot", false, false);
     1267    PXOPT_LOOKUP_STR(ver_psastro, config->args, "-ver_psastro", false, false);
     1268    PXOPT_LOOKUP_STR(ver_ppstats, config->args, "-ver_ppstats", false, false);
     1269
     1270    psString software_ver = NULL;
     1271    if ((ver_pslib)&&(ver_psmodules)) {
     1272      software_ver = pxMergeCodeVersions(ver_pslib,ver_psmodules);
     1273    }
     1274    if (ver_psphot) {
     1275      software_ver = pxMergeCodeVersions(software_ver,ver_psphot);
     1276    }
     1277    if (ver_psastro) {
     1278      software_ver = pxMergeCodeVersions(software_ver,ver_psastro);
     1279    }
     1280    if (ver_ppstats) {
     1281      software_ver = pxMergeCodeVersions(software_ver,ver_ppstats);
     1282    }
     1283
     1284    if (!psDBTransaction(config->dbh)) {
     1285        psError(PS_ERR_UNKNOWN, false, "database error");
     1286        return false;
     1287    }
     1288
     1289    skycalResultRow *row = skycalResultRowAlloc(
     1290        skycal_id,
     1291        path_base,
     1292        dtime_script,
     1293        dtime_astrom,
     1294        sigma_ra,
     1295        sigma_dec,
     1296        n_astrom,
     1297        zpt_obs,
     1298        zpt_stdev,
     1299        quality,
     1300        software_ver,
     1301        hostname,
     1302        fault
     1303        );
     1304
     1305    if (!skycalResultInsertObject(config->dbh, row)) {
     1306        // rollback
     1307        if (!psDBRollback(config->dbh)) {
     1308            psError(PS_ERR_UNKNOWN, false, "database error");
     1309        }
     1310        psError(PS_ERR_UNKNOWN, false, "database error");
     1311        psFree(row);
     1312        return false;
     1313    }
     1314
     1315    psFree(row);
     1316
     1317    if (fault) {
     1318        if (!psDBCommit(config->dbh)) {
     1319            psError(PS_ERR_UNKNOWN, false, "database error");
     1320            return false;
     1321        }
     1322        return true;
     1323    }
     1324
     1325    psString query = "UPDATE skycalRun SET state = 'full' WHERE skycal_id = %" PRId64;
     1326    if (!p_psDBRunQueryF(config->dbh, query, skycal_id)) {
     1327        psError(PS_ERR_UNKNOWN, false, "database error");
     1328        return false;
     1329    }
     1330    if (!psDBCommit(config->dbh)) {
     1331        psError(PS_ERR_UNKNOWN, false, "database error");
     1332        return false;
     1333    }
     1334
     1335    return true;
     1336}
     1337static bool updateskycalresultMode(pxConfig *config)
     1338{
     1339    PS_ASSERT_PTR_NON_NULL(config, false);
     1340
     1341    PXOPT_LOOKUP_S16(fault, config->args, "-set_fault", true, false);
     1342    PXOPT_LOOKUP_S16(quality, config->args, "-set_quality", false, false);
     1343
     1344    psMetadata *where = psMetadataAlloc();
     1345    PXOPT_COPY_S64(config->args, where, "-skycal_id",   "skycal_id",   "==");
     1346
     1347    if (!pxSetFaultCode(config->dbh, "skycalResult", where, fault, quality)) {
     1348        psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
     1349        psFree (where);
     1350        return false;
     1351    }
     1352    psFree (where);
     1353    return true;
     1354}
     1355static bool skycalresultMode(pxConfig *config)
     1356{
     1357    PS_ASSERT_PTR_NON_NULL(config, false);
     1358
     1359    psMetadata *where = psMetadataAlloc();
     1360    PXOPT_COPY_S64(config->args, where, "-skycal_id",  "skycalRun.skycal_id", "==");
     1361    PXOPT_COPY_S64(config->args, where, "-sky_id",     "skycalRun.sky_id", "==");
     1362    PXOPT_COPY_S64(config->args, where, "-stack_id",   "skycalRun.stack_id", "==");
     1363    PXOPT_COPY_STR(config->args, where, "-tess_id",    "stackRun.tess_id", "LIKE");
     1364    PXOPT_COPY_STR(config->args, where, "-skycell_id", "stackRun.skycell_id", "LIKE");
     1365    PXOPT_COPY_STR(config->args, where, "-filter",     "stackRun.filter", "LIKE");
     1366    PXOPT_COPY_STR(config->args, where, "-label",      "skycalRun.label", "==");
     1367    PXOPT_COPY_STR(config->args, where, "-data_group", "skycalRun.data_group", "LIKE");
     1368    PXOPT_COPY_S16(config->args, where, "-fault",      "skycalResult.fault", "==");
     1369
     1370    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1371    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1372
     1373    psString query = pxDataGet("staticskytool_skycalresult.sql");
     1374    if (!query) {
     1375        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1376        return false;
     1377    }
     1378
     1379    if (!psListLength(where->list)) {
     1380        psError(PXTOOLS_ERR_CONFIG, true, "search parameters are required");
     1381        return false;
     1382    }
     1383    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1384    psStringAppend(&query, " WHERE %s", whereClause);
     1385    psFree(whereClause);
     1386    psFree(where);
     1387
     1388    // treat limit == 0 as "no limit"
     1389    if (limit) {
     1390        psString limitString = psDBGenerateLimitSQL(limit);
     1391        psStringAppend(&query, " %s", limitString);
     1392        psFree(limitString);
     1393    }
     1394
     1395    if (!p_psDBRunQuery(config->dbh, query)) {
     1396        psError(PS_ERR_UNKNOWN, false, "database error");
     1397        psFree(query);
     1398        return false;
     1399    }
     1400    psFree(query);
     1401
     1402    psArray *output = p_psDBFetchResult(config->dbh);
     1403    if (!output) {
     1404        psErrorCode err = psErrorCodeLast();
     1405        switch (err) {
     1406            case PS_ERR_DB_CLIENT:
     1407                psError(PXTOOLS_ERR_SYS, false, "database error");
     1408            case PS_ERR_DB_SERVER:
     1409                psError(PXTOOLS_ERR_PROG, false, "database error");
     1410            default:
     1411                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     1412        }
     1413
     1414        return false;
     1415    }
     1416    if (!psArrayLength(output)) {
     1417        psTrace("staticskytool", PS_LOG_INFO, "no rows found");
     1418        psFree(output);
     1419        return true;
     1420    }
     1421
     1422    if (psArrayLength(output)) {
     1423        if (!ippdbPrintMetadatas(stdout, output, "staticskyResult", !simple)) {
     1424            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1425            psFree(output);
     1426            return false;
     1427        }
     1428    }
     1429
     1430    psFree(output);
     1431
     1432    return true;
     1433}
     1434static bool revertskycalresultMode(pxConfig *config)
     1435{
     1436    PS_ASSERT_PTR_NON_NULL(config, false);
     1437
     1438    psMetadata *where = psMetadataAlloc();
     1439    PXOPT_COPY_S64(config->args, where, "-skycal_id", "staticskyResult.sky_id", "==");
     1440    pxAddLabelSearchArgs(config, where, "-label", "staticskyRun.label", "==");
     1441    pxAddLabelSearchArgs(config, where, "-data_group", "staticskyRun.data_group", "==");
     1442    pxAddLabelSearchArgs(config, where, "-filter", "stackRun.filter", "==");
     1443    PXOPT_COPY_S16(config->args, where, "-fault", "staticskyResult.fault", "==");
     1444
     1445    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
     1446        psFree(where);
     1447        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     1448        return false;
     1449    }
     1450
     1451    // Delete product
     1452    psString delete = pxDataGet("staticskytool_revertskycal.sql");
     1453    if (!delete) {
     1454        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1455        return false;
     1456    }
     1457
     1458    if (psListLength(where->list)) {
     1459        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1460        psStringAppend(&delete, " AND %s", whereClause);
     1461        psFree(whereClause);
     1462    }
     1463
     1464    if (!p_psDBRunQuery(config->dbh, delete)) {
     1465        psError(PS_ERR_UNKNOWN, false, "database error");
     1466        psFree(delete);
     1467        psFree(where);
     1468        return false;
     1469    }
     1470    psFree(delete);
     1471
     1472    int numRows = psDBAffectedRows(config->dbh); // Number of row affected
     1473    psLogMsg("staticskytool", PS_LOG_INFO, "Deleted %d rows", numRows);
     1474
     1475    psFree(where);
     1476    return true;
     1477}

  • branches/eam_branches/ipp-20111122/ippTools/src/staticskytool.h

    r27546 r33638  
    3434    STATICSKYTOOL_MODE_UPDATERESULT,
    3535    STATICSKYTOOL_MODE_EXPORTRUN,
    36     STATICSKYTOOL_MODE_IMPORTRUN
     36    STATICSKYTOOL_MODE_IMPORTRUN,
     37
     38    STATICSKYTOOL_MODE_DEFINESKYCALRUN,
     39    STATICSKYTOOL_MODE_PENDINGSKYCALRUN,
     40    STATICSKYTOOL_MODE_UPDATESKYCALRUN,
     41    STATICSKYTOOL_MODE_ADDSKYCALRESULT,
     42    STATICSKYTOOL_MODE_UPDATESKYCALRESULT,
     43    STATICSKYTOOL_MODE_SKYCALRESULT,
     44    STATICSKYTOOL_MODE_REVERTSKYCALRESULT,
    3745} staticskytoolMode;
    3846

  • branches/eam_branches/ipp-20111122/ippTools/src/staticskytoolConfig.c

    r31687 r33638  
    4848    // XXX need a 'ra_min,max', 'dec_min,max' : to do this, we need a table of skycell boundaries
    4949    psMetadata *definebyqueryArgs = psMetadataAlloc();
     50    psMetadataAddS64(definebyqueryArgs,  PS_LIST_TAIL, "-select_stack_id", 0, "search for stack_id", 0);
    5051    psMetadataAddStr(definebyqueryArgs,  PS_LIST_TAIL, "-select_skycell_id", 0, "search for skycell_id", NULL);
    5152    psMetadataAddStr(definebyqueryArgs,  PS_LIST_TAIL, "-select_tess_id", 0, "search for tess_id", NULL);
    … …  
    107108    psMetadata *resultArgs= psMetadataAlloc();
    108109    psMetadataAddS64(resultArgs, PS_LIST_TAIL, "-sky_id", 0, "search by staticsky ID", 0);
    109     // psMetadataAddStr(resultArgs, PS_LIST_TAIL, "-tess_id", 0, "search by tess ID", 0);
    110     // psMetadataAddStr(resultArgs, PS_LIST_TAIL, "-skycell_id", 0, "search by skycell ID", 0);
     110    psMetadataAddStr(resultArgs, PS_LIST_TAIL, "-tess_id", 0, "search by tess ID (LIKE comparison)", 0);
     111    psMetadataAddStr(resultArgs, PS_LIST_TAIL, "-skycell_id", 0, "search by skycell ID (LIKE comparison)", 0);
    111112    psMetadataAddStr(resultArgs, PS_LIST_TAIL, "-label", 0, "search by label", NULL);
    112113    psMetadataAddStr(resultArgs, PS_LIST_TAIL, "-data_group", 0, "search by data_group (LIKE comparison)", NULL);
     114    psMetadataAddS16(resultArgs, PS_LIST_TAIL, "-num_filters", 0, "search by number of filters in the inputs (>=)", 0);
    113115    psMetadataAddS16(resultArgs, PS_LIST_TAIL, "-fault", 0, "search by fault code", 0);
    114116    psMetadataAddU64(resultArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
    … …  
    138140    psMetadata *importrunArgs = psMetadataAlloc();
    139141    psMetadataAddStr(importrunArgs, PS_LIST_TAIL, "-infile", 0, "import from this file (required)", NULL);
    140 
     142 
     143    // -defineskycalrun
     144    psMetadata *defineskycalrunArgs = psMetadataAlloc();
     145    psMetadataAddS64(defineskycalrunArgs,  PS_LIST_TAIL, "-select_sky_id", 0, "search for sky_id", 0);
     146    psMetadataAddS64(defineskycalrunArgs,  PS_LIST_TAIL, "-select_stack_id", 0, "search for stack_id", 0);
     147    psMetadataAddStr(defineskycalrunArgs,  PS_LIST_TAIL, "-select_skycell_id", 0, "search for skycell_id", NULL);
     148    psMetadataAddStr(defineskycalrunArgs,  PS_LIST_TAIL, "-select_tess_id", 0, "search for tess_id", NULL);
     149    psMetadataAddF32(defineskycalrunArgs,  PS_LIST_TAIL, "-select_good_frac_min", 0, "define min good_frac", 0.0);
     150    psMetadataAddStr(defineskycalrunArgs,  PS_LIST_TAIL, "-select_label", PS_META_DUPLICATE_OK, "search by stackRun label (LIKE comparison, multiple OK)", NULL);
     151    psMetadataAddStr(defineskycalrunArgs,  PS_LIST_TAIL, "-select_data_group", PS_META_DUPLICATE_OK, "search by stackRun data_group (LIKE comparison, multiple OK)", NULL);
     152    psMetadataAddStr(defineskycalrunArgs,  PS_LIST_TAIL, "-select_filter", PS_META_DUPLICATE_OK, "search by filter (LIKE comparison, multiple OK)", NULL);
     153    psMetadataAddStr(defineskycalrunArgs,  PS_LIST_TAIL, "-set_workdir", 0, "define workdir", NULL);
     154    psMetadataAddStr(defineskycalrunArgs,  PS_LIST_TAIL, "-set_label", 0, "define label", NULL);
     155    psMetadataAddStr(defineskycalrunArgs,  PS_LIST_TAIL, "-set_data_group", 0, "define data group", NULL);
     156    psMetadataAddStr(defineskycalrunArgs,  PS_LIST_TAIL, "-set_dist_group", 0, "define dist group", NULL);
     157    psMetadataAddStr(defineskycalrunArgs,  PS_LIST_TAIL, "-set_note", 0, "define note", NULL);
     158    psMetadataAddStr(defineskycalrunArgs,  PS_LIST_TAIL, "-set_reduction", 0, "define reduction", NULL);
     159    psMetadataAddTime(defineskycalrunArgs, PS_LIST_TAIL, "-set_registered", 0, "time detrend run was registered", now);
     160    psMetadataAddBool(defineskycalrunArgs, PS_LIST_TAIL, "-rerun",  0, "queue new run even if one already exists for inputs", false);
     161    psMetadataAddBool(defineskycalrunArgs, PS_LIST_TAIL, "-pretend",  0, "do not actually modify the database", false);
     162    psMetadataAddBool(defineskycalrunArgs, PS_LIST_TAIL, "-check_inputs",  0, "list inputs, do not modify database", false);
     163    psMetadataAddBool(defineskycalrunArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     164
     165    // -updateskycalrun
     166    psMetadata *updateskycalrunArgs = psMetadataAlloc();
     167    psMetadataAddS64(updateskycalrunArgs, PS_LIST_TAIL, "-sky_id", 0, "search by stack ID", 0);
     168    psMetadataAddStr(updateskycalrunArgs, PS_LIST_TAIL, "-state", 0, "search by state", NULL);
     169    psMetadataAddStr(updateskycalrunArgs, PS_LIST_TAIL, "-label", 0, "search by label", 0);
     170    psMetadataAddStr(updateskycalrunArgs, PS_LIST_TAIL, "-set_label", 0, "define new value for label", NULL);
     171    psMetadataAddStr(updateskycalrunArgs, PS_LIST_TAIL, "-set_state", 0, "define new state", NULL);
     172    psMetadataAddStr(updateskycalrunArgs, PS_LIST_TAIL, "-set_data_group", 0, "define new data_group", NULL);
     173    psMetadataAddStr(updateskycalrunArgs, PS_LIST_TAIL, "-set_dist_group", 0, "define new dist_group", NULL);
     174    psMetadataAddStr(updateskycalrunArgs, PS_LIST_TAIL, "-set_note", 0, "define new note", NULL);
     175
     176    // -pendingskycalrun
     177    psMetadata *pendingskycalrunArgs = psMetadataAlloc();
     178    psMetadataAddS64(pendingskycalrunArgs, PS_LIST_TAIL, "-skycal_id", 0, "search by skycal ID", 0);
     179    psMetadataAddS64(pendingskycalrunArgs, PS_LIST_TAIL, "-sky_id", 0, "search by staticsky ID", 0);
     180    psMetadataAddStr(pendingskycalrunArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by label", NULL);
     181    psMetadataAddStr(pendingskycalrunArgs, PS_LIST_TAIL, "-filter", 0, "search by filter", NULL);
     182    psMetadataAddU64(pendingskycalrunArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
     183    psMetadataAddBool(pendingskycalrunArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     184
     185
     186    // -addskycalresult
     187    psMetadata *addskycalresultArgs = psMetadataAlloc();
     188    psMetadataAddS64(addskycalresultArgs, PS_LIST_TAIL, "-skycal_id", 0,            "define camtool ID (required)", 0);
     189    psMetadataAddF32(addskycalresultArgs, PS_LIST_TAIL, "-sigma_ra", 0,            "define exposure E ra", NAN);
     190    psMetadataAddF32(addskycalresultArgs, PS_LIST_TAIL, "-sigma_dec", 0,            "define exposure E dec", NAN);
     191    psMetadataAddF32(addskycalresultArgs, PS_LIST_TAIL, "-zpt_obs", 0,   "define observed zero point", 0);
     192    psMetadataAddF32(addskycalresultArgs, PS_LIST_TAIL, "-zpt_stdev", 0,   "define observed zero point stdandard deviation", 0);
     193
     194    psMetadataAddF32(addskycalresultArgs, PS_LIST_TAIL, "-dtime_script", 0, "define elapsed time in script (seconds)", NAN);
     195    psMetadataAddF32(addskycalresultArgs, PS_LIST_TAIL, "-dtime_astrom", 0, "define elapsed time for astrometry (seconds)", NAN);
     196
     197    psMetadataAddStr(addskycalresultArgs, PS_LIST_TAIL, "-hostname", 0,            "define hostname", NULL);
     198    // psMetadataAddS32(addskycalresultArgs, PS_LIST_TAIL, "-n_stars", 0,            "define number of stars", 0);
     199    psMetadataAddS32(addskycalresultArgs, PS_LIST_TAIL, "-n_astrom", 0,            "define number of astrometry reference objects", 0);
     200
     201    psMetadataAddStr(addskycalresultArgs, PS_LIST_TAIL, "-path_base", 0,            "define base output location", NULL);
     202    psMetadataAddS16(addskycalresultArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code", 0);
     203    psMetadataAddS16(addskycalresultArgs, PS_LIST_TAIL, "-quality",  0,            "set quality", 0);
     204
     205    psMetadataAddStr(addskycalresultArgs, PS_LIST_TAIL, "-ver_pslib", 0, "define psLib version", NULL);
     206    psMetadataAddStr(addskycalresultArgs, PS_LIST_TAIL, "-ver_psmodules", 0, "define psModules version", NULL);
     207    psMetadataAddStr(addskycalresultArgs, PS_LIST_TAIL, "-ver_psphot", 0, "define psphot version", NULL);
     208    psMetadataAddStr(addskycalresultArgs, PS_LIST_TAIL, "-ver_psastro", 0, "define psastro version", NULL);
     209    psMetadataAddStr(addskycalresultArgs, PS_LIST_TAIL, "-ver_ppstats", 0, "define ppStats version", NULL);
     210    psMetadataAddStr(addskycalresultArgs, PS_LIST_TAIL, "-ver_streaks", 0, "define streaksremove version", NULL);
     211
     212    // -revertskycal
     213    psMetadata *revertskycalArgs= psMetadataAlloc();
     214    psMetadataAddS64(revertskycalArgs, PS_LIST_TAIL, "-skycal_id", 0, "search by staticsky ID", 0);
     215    psMetadataAddStr(revertskycalArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by label", 0);
     216    psMetadataAddStr(revertskycalArgs, PS_LIST_TAIL, "-data_group", PS_META_DUPLICATE_OK, "search by data_group", 0);
     217    psMetadataAddStr(revertskycalArgs, PS_LIST_TAIL, "-filter", PS_META_DUPLICATE_OK, "search by filter", 0);
     218    psMetadataAddS16(revertskycalArgs, PS_LIST_TAIL, "-fault", 0, "search by fault code", 0);
     219    psMetadataAddBool(revertskycalArgs, PS_LIST_TAIL, "-all", 0, "allow no search terms", false);
     220
     221    // -updateskycalresult
     222    psMetadata *updateskycalresultArgs = psMetadataAlloc();
     223    psMetadataAddS64(updateskycalresultArgs, PS_LIST_TAIL, "-skycal_id", 0, "define staticksky ID (required)", 0);
     224    psMetadataAddS16(updateskycalresultArgs, PS_LIST_TAIL, "-set_fault", 0, "set fault code (required)", 0);
     225    psMetadataAddS16(updateskycalresultArgs, PS_LIST_TAIL, "-set_quality", 0, "set quality code", 0);
     226
     227    // -skycalresult
     228    psMetadata *skycalresultArgs= psMetadataAlloc();
     229    psMetadataAddS64(skycalresultArgs, PS_LIST_TAIL, "-skycal_id", 0, "search by skycal ID", 0);
     230    psMetadataAddS64(skycalresultArgs, PS_LIST_TAIL, "-sky_id", 0, "search by staticsky ID", 0);
     231    psMetadataAddS64(skycalresultArgs, PS_LIST_TAIL, "-stack_id", 0, "search by stack ID", 0);
     232    psMetadataAddStr(skycalresultArgs, PS_LIST_TAIL, "-tess_id", 0, "search by tess ID (LIKE comparison)", 0);
     233    psMetadataAddStr(skycalresultArgs, PS_LIST_TAIL, "-skycell_id", 0, "search by skycell ID (LIKE comparison)", 0);
     234    psMetadataAddStr(skycalresultArgs, PS_LIST_TAIL, "-filter", 0, "search by filter (LIKE comparison)", 0);
     235    psMetadataAddStr(skycalresultArgs, PS_LIST_TAIL, "-label", 0, "search by label (LIKE comparison)", NULL);
     236    psMetadataAddStr(skycalresultArgs, PS_LIST_TAIL, "-data_group", 0, "search by data_group (LIKE comparison)", NULL);
     237    psMetadataAddS16(skycalresultArgs, PS_LIST_TAIL, "-fault", 0, "search by fault code", 0);
     238    psMetadataAddU64(skycalresultArgs, PS_LIST_TAIL, "-limit", 0, "limit skycalresult set to N items", 0);
     239    psMetadataAddBool(skycalresultArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    141240
    142241    psFree(now);
    … …  
    155254    PXOPT_ADD_MODE("-exportrun",     "Export run",           STATICSKYTOOL_MODE_EXPORTRUN,     exportrunArgs);
    156255    PXOPT_ADD_MODE("-importrun",     "Import run",           STATICSKYTOOL_MODE_IMPORTRUN,     importrunArgs);
     256    PXOPT_ADD_MODE("-defineskycalrun", "Define a new skycalrun", STATICSKYTOOL_MODE_DEFINESKYCALRUN, defineskycalrunArgs);
     257    PXOPT_ADD_MODE("-updateskycalrun", "Update a skycalrun", STATICSKYTOOL_MODE_UPDATESKYCALRUN,     updateskycalrunArgs);
     258    PXOPT_ADD_MODE("-pendingskycalrun", "Get skcal runs to do",       STATICSKYTOOL_MODE_PENDINGSKYCALRUN,          pendingskycalrunArgs);
     259    PXOPT_ADD_MODE("-addskycalresult", "add skycal result",       STATICSKYTOOL_MODE_ADDSKYCALRESULT, addskycalresultArgs);
     260    PXOPT_ADD_MODE("-revertskycal",  "revert faulted skycal run", STATICSKYTOOL_MODE_REVERTSKYCALRESULT, revertskycalArgs);
     261    PXOPT_ADD_MODE("-updateskycal",  "revert faulted skycal run", STATICSKYTOOL_MODE_UPDATESKYCALRESULT, updateskycalresultArgs);
     262    PXOPT_ADD_MODE("-skycalresult",  "Get result of skycal run",  STATICSKYTOOL_MODE_SKYCALRESULT, skycalresultArgs);
    157263
    158264    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

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

    r32551 r33638  
    25812581    psFree(query);
    25822582
    2583     return true;
    2584 }
     2583    if (!skycell_id) {
     2584        // If we are updateing a whole warpRun set skycells with bad quality to 'full'
     2585        query = "UPDATE warpSkyfile SET data_state ='full', fault = 0 WHERE warp_id = %" PRId64 " AND quality != 0 AND (data_state != 'full')";
     2586        if (!p_psDBRunQueryF(config->dbh, query, warp_id)) {
     2587            psError(PS_ERR_UNKNOWN, false, "database error");
     2588            return false;
     2589        }
     2590    }
     2591
     2592    return true;
     2593}
Note: See TracChangeset for help on using the changeset viewer.