Index: trunk/ippTools/src/faketool.c =================================================================== --- trunk/ippTools/src/faketool.c (revision 17357) +++ trunk/ippTools/src/faketool.c (revision 17357) @@ -0,0 +1,1011 @@ +/* + * faketool.c + * + * Copyright (C) 2006 Joshua Hoblitt + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the Free + * Software Foundation; version 2 of the License. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along with + * program; see the file COPYING. If not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#include +#include +#include +#include +#include + +#include "pxtools.h" +#include "pxdata.h" + +#include "faketool.h" +#include "camtool.h" + +static bool queueMode(pxConfig *config); +static bool updaterunMode(pxConfig *config); +static bool pendingimfileMode(pxConfig *config); +static bool addprocessedimfileMode(pxConfig *config); +static bool processedimfileMode(pxConfig *config); +static bool revertprocessedimfileMode(pxConfig *config); +static bool updateprocessedimfileMode(pxConfig *config); +static bool blockMode(pxConfig *config); +static bool maskedMode(pxConfig *config); +static bool unmaskedMode(pxConfig *config); +static bool unblockMode(pxConfig *config); + +static bool fakeProcessedCompleteExp(pxConfig *config); + +# define MODECASE(caseName, func) \ + case caseName: \ + if (!func(config)) { \ + goto FAIL; \ + } \ + break; + +int main(int argc, char **argv) { + psLibInit(NULL); + + pxConfig *config = faketoolConfig(NULL, argc, argv); + if (!config) { + psError(PXTOOLS_ERR_CONFIG, false, "failed to configure"); + goto FAIL; + } + + switch (config->mode) { + MODECASE(FAKETOOL_MODE_QUEUE, queueMode); + MODECASE(FAKETOOL_MODE_UPDATERUN, updaterunMode); + MODECASE(FAKETOOL_MODE_PENDINGIMFILE, pendingimfileMode); + MODECASE(FAKETOOL_MODE_ADDPROCESSEDIMFILE, addprocessedimfileMode); + MODECASE(FAKETOOL_MODE_PROCESSEDIMFILE, processedimfileMode); + MODECASE(FAKETOOL_MODE_REVERTPROCESSEDIMFILE, revertprocessedimfileMode); + MODECASE(FAKETOOL_MODE_UPDATEPROCESSEDIMFILE,updateprocessedimfileMode); + MODECASE(FAKETOOL_MODE_BLOCK, blockMode); + MODECASE(FAKETOOL_MODE_MASKED, maskedMode); + MODECASE(FAKETOOL_MODE_UNMASKED, unmaskedMode); + MODECASE(FAKETOOL_MODE_UNBLOCK, unblockMode); + default: + psAbort("invalid option (this should not happen)"); + } + + psFree(config); + pmConfigDone(); + psLibFinalize(); + + exit(EXIT_SUCCESS); + +FAIL: + psErrorStackPrint(stderr, "\n"); + int exit_status = pxerrorGetExitStatus(); + + psFree(config); + pmConfigDone(); + psLibFinalize(); + + exit(exit_status); +} + + +static bool queueMode(pxConfig *config) +{ + PS_ASSERT_PTR_NON_NULL(config, NULL); + + PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false); + + psMetadata *where = psMetadataAlloc(); + // convert exp_id into a psS64 + if (exp_id) { + if (!psMetadataAddS64(where, PS_LIST_TAIL, "exp_id", 0, "==", (psS64)atoll(exp_id))) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(where); + return false; + } + } + + PXOPT_COPY_STR(config->args, where, "-exp_name", "exp_name", "=="); + PXOPT_COPY_STR(config->args, where, "-inst", "camera", "=="); + PXOPT_COPY_STR(config->args, where, "-telescope", "telescope", "=="); + PXOPT_COPY_TIME(config->args, where, "-dateobs_begin", "dateobs", ">="); + PXOPT_COPY_TIME(config->args, where, "-dateobs_end", "dateobs", "<="); + PXOPT_COPY_STR(config->args, where, "-exp_tag", "exp_tag", "=="); + PXOPT_COPY_STR(config->args, where, "-filelevel", "filelevel", "=="); + PXOPT_COPY_STR(config->args, where, "-reduction", "reduction", "=="); + PXOPT_COPY_STR(config->args, where, "-filter", "filter", "=="); + PXOPT_COPY_F64(config->args, where, "-airmass_min", "airmass", ">="); + PXOPT_COPY_F64(config->args, where, "-airmass_max", "airmass", "<"); + PXOPT_COPY_F64(config->args, where, "-ra_min", "ra", ">="); + PXOPT_COPY_F64(config->args, where, "-ra_max", "ra", "<"); + PXOPT_COPY_F64(config->args, where, "-decl_min", "decl", ">="); + PXOPT_COPY_F64(config->args, where, "-decl_max", "decl", "<"); + PXOPT_COPY_F32(config->args, where, "-exp_time_min", "exp_time", ">="); + PXOPT_COPY_F32(config->args, where, "-exp_time_max", "exp_time", "<"); + PXOPT_COPY_F32(config->args, where, "-sat_pixel_frac_min", "sat_pixel_frac", ">="); + PXOPT_COPY_F32(config->args, where, "-sat_pixel_frac_max", "sat_pixel_frac", "<"); + PXOPT_COPY_F64(config->args, where, "-bg_min", "bt", ">="); + PXOPT_COPY_F64(config->args, where, "-bg_max", "bt", "<"); + PXOPT_COPY_F64(config->args, where, "-bg_stdev_min", "bg_stdev", ">="); + PXOPT_COPY_F64(config->args, where, "-bg_stdev_max", "bg_stdev", "<"); + PXOPT_COPY_F64(config->args, where, "-bg_mean_stdev_min", "bg_mean_stdev", ">="); + PXOPT_COPY_F64(config->args, where, "-bg_mean_stdev_max", "bg_mean_stdev", "<"); + PXOPT_COPY_F64(config->args, where, "-alt_min", "alt", ">="); + PXOPT_COPY_F64(config->args, where, "-alt_max", "alt", "<"); + PXOPT_COPY_F64(config->args, where, "-az_min", "az", ">="); + PXOPT_COPY_F64(config->args, where, "-az_max", "az", "<"); + PXOPT_COPY_F32(config->args, where, "-ccd_temp_min", "ccd_temp", ">="); + PXOPT_COPY_F32(config->args, where, "-ccd_temp_max", "ccd_temp", "<"); + PXOPT_COPY_F64(config->args, where, "-posang_min", "posang", ">="); + PXOPT_COPY_F64(config->args, where, "-posang_max", "posang", "<"); + PXOPT_COPY_STR(config->args, where, "-object", "object", "=="); + PXOPT_COPY_F32(config->args, where, "-solang_min", "solang", ">="); + PXOPT_COPY_F32(config->args, where, "-solang_max", "solang", "<"); + + if (!psListLength(where->list) + && !psMetadataLookupBool(NULL, config->args, "-all")) { + psFree(where); + psError(PXTOOLS_ERR_DATA, false, "search parameters are required"); + return false; + } + + PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", false, false); + PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false); + PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false); + PXOPT_LOOKUP_STR(expgroup, config->args, "-set_expgroup", false, false); + PXOPT_LOOKUP_STR(dvodb, config->args, "-set_dvodb", false, false); + PXOPT_LOOKUP_STR(tess_id, config->args, "-set_tess_id", false, false); + PXOPT_LOOKUP_STR(end_stage, config->args, "-set_end_stage", false, false); + + // default + PXOPT_COPY_STR(config->args, where, "-exp_type", "exp_type", "=="); + PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false); + + // find the exp_id of all the exposures that we want to queue up. + psString query = pxDataGet("faketool_find_rawexp.sql"); + if (!query) { + psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement"); + psFree(where); + return false; + } + + if (where && psListLength(where->list)) { + psString whereClause = psDBGenerateWhereConditionSQL(where, "rawExp"); + psStringAppend(&query, " AND %s", whereClause); + psFree(whereClause); + } + + psFree(where); + + if (pretend) { + // then stop before running the query + fprintf(stderr, "%s\n", query); + psFree(query); + return true; + } + + if (!p_psDBRunQuery(config->dbh, query)) { + psError(PS_ERR_UNKNOWN, false, "database error"); + psFree(query); + return false; + } + psFree(query); + + psArray *output = p_psDBFetchResult(config->dbh); + if (!output) { + psError(PS_ERR_UNKNOWN, false, "database error"); + return false; + } + if (!psArrayLength(output)) { + psTrace("faketool", PS_LOG_INFO, "no rows found"); + psFree(output); + return true; + } + + // start a transaction so we don't end up with an exp without any associted + // imfiles + if (!psDBTransaction(config->dbh)) { + psError(PS_ERR_UNKNOWN, false, "database error"); + psFree(output); + return false; + } + + // loop over our list of exp_ids + for (long i = 0; i < psArrayLength(output); i++) { + psMetadata *md = output->data[i]; + + bool status; + psS64 exp_id = psMetadataLookupS64(&status, md, "exp_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, false, "failed to lookup value for exp_id"); + psFree(output); + return false; + } + + // queue the exp + if (!pxfakeQueueByExpTag(config, exp_id, workdir, label, reduction, expgroup, dvodb, tess_id, end_stage)) { + if (!psDBRollback(config->dbh)) { + psError(PS_ERR_UNKNOWN, false, "database error"); + } + psError(PS_ERR_UNKNOWN, false, + "failed to trying to queue exp_id: %" PRId64, exp_id); + psFree(output); + return false; + } + } + psFree(output); + + if (!psDBCommit(config->dbh)) { + psError(PS_ERR_UNKNOWN, false, "database error"); + return false; + } + + return true; +} + + +static bool updaterunMode(pxConfig *config) +{ + PS_ASSERT_PTR_NON_NULL(config, NULL); + + psMetadata *where = psMetadataAlloc(); + PXOPT_LOOKUP_STR(fake_id, config->args, "-fake_id", false, false); + // convert fake_id into a psS64 + if (fake_id) { + if (!psMetadataAddS64(where, PS_LIST_TAIL, "fake_id", 0, "==", (psS64)atoll(fake_id))) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fake_id"); + psFree(where); + return false; + } + } + + PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false); + // convert exp_id into a psS64 + if (exp_id) { + if (!psMetadataAddS64(where, PS_LIST_TAIL, "exp_id", 0, "==", (psS64)atoll(exp_id))) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(where); + return false; + } + } + + PXOPT_COPY_STR(config->args, where, "-exp_name", "exp_name", "=="); + PXOPT_COPY_STR(config->args, where, "-inst", "camera", "=="); + PXOPT_COPY_STR(config->args, where, "-telescope", "telescope", "=="); + PXOPT_COPY_TIME(config->args, where, "-dateobs_begin", "dateobs", ">="); + PXOPT_COPY_TIME(config->args, where, "-dateobs_end", "dateobs", "<="); + PXOPT_COPY_STR(config->args, where, "-exp_tag", "exp_tag", "=="); + PXOPT_COPY_STR(config->args, where, "-filelevel", "filelevel", "=="); + PXOPT_COPY_STR(config->args, where, "-reduction", "reduction", "=="); + PXOPT_COPY_STR(config->args, where, "-filter", "filter", "=="); + PXOPT_COPY_F64(config->args, where, "-airmass_min", "airmass", ">="); + PXOPT_COPY_F64(config->args, where, "-airmass_max", "airmass", "<"); + PXOPT_COPY_F64(config->args, where, "-ra_min", "ra", ">="); + PXOPT_COPY_F64(config->args, where, "-ra_max", "ra", "<"); + PXOPT_COPY_F64(config->args, where, "-decl_min", "decl", ">="); + PXOPT_COPY_F64(config->args, where, "-decl_max", "decl", "<"); + PXOPT_COPY_F32(config->args, where, "-exp_time_min", "exp_time", ">="); + PXOPT_COPY_F32(config->args, where, "-exp_time_max", "exp_time", "<"); + PXOPT_COPY_F32(config->args, where, "-sat_pixel_frac_min", "sat_pixel_frac", ">="); + PXOPT_COPY_F32(config->args, where, "-sat_pixel_frac_max", "sat_pixel_frac", "<"); + PXOPT_COPY_F64(config->args, where, "-bg_min", "bt", ">="); + PXOPT_COPY_F64(config->args, where, "-bg_max", "bt", "<"); + PXOPT_COPY_F64(config->args, where, "-bg_stdev_min", "bg_stdev", ">="); + PXOPT_COPY_F64(config->args, where, "-bg_stdev_max", "bg_stdev", "<"); + PXOPT_COPY_F64(config->args, where, "-bg_mean_stdev_min", "bg_mean_stdev", ">="); + PXOPT_COPY_F64(config->args, where, "-bg_mean_stdev_max", "bg_mean_stdev", "<"); + PXOPT_COPY_F64(config->args, where, "-alt_min", "alt", ">="); + PXOPT_COPY_F64(config->args, where, "-alt_max", "alt", "<"); + PXOPT_COPY_F64(config->args, where, "-az_min", "az", ">="); + PXOPT_COPY_F64(config->args, where, "-az_max", "az", "<"); + PXOPT_COPY_F32(config->args, where, "-ccd_temp_min", "ccd_temp", ">="); + PXOPT_COPY_F32(config->args, where, "-ccd_temp_max", "ccd_temp", "<"); + PXOPT_COPY_F64(config->args, where, "-posang_min", "posang", ">="); + PXOPT_COPY_F64(config->args, where, "-posang_max", "posang", "<"); + PXOPT_COPY_STR(config->args, where, "-object", "object", "=="); + PXOPT_COPY_F32(config->args, where, "-solang_min", "solang", ">="); + PXOPT_COPY_F32(config->args, where, "-solang_max", "solang", "<"); + + if (!psListLength(where->list) + && !psMetadataLookupBool(NULL, config->args, "-all")) { + psFree(where); + where = NULL; + psError(PXTOOLS_ERR_DATA, false, "search parameters are required"); + return false; + } + + PXOPT_LOOKUP_STR(state, config->args, "-state", false, false); + PXOPT_LOOKUP_STR(label, config->args, "-label", false, false); + + if ((!state) && (!label)) { + psError(PXTOOLS_ERR_DATA, false, "parameters are required"); + psFree(where); + return false; + } + + if (state) { + // set fakeRun.state to state + if (!pxfakeRunSetStateByQuery(config, where, state)) { + psFree(where); + return false; + } + } + + if (label) { + // set fakeRun.label to label + if (!pxfakeRunSetLabelByQuery(config, where, label)) { + psFree(where); + return false; + } + } + + psFree(where); + + return true; +} + + +static bool pendingimfileMode(pxConfig *config) +{ + PS_ASSERT_PTR_NON_NULL(config, NULL); + + PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false); + PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false); + + psMetadata *where = psMetadataAlloc(); + PXOPT_LOOKUP_STR(fake_id, config->args, "-fake_id", false, false); + // convert fake_id into a psS64 + if (fake_id) { + if (!psMetadataAddS64(where, PS_LIST_TAIL, "fakeRun.fake_id", 0, "==", (psS64)atoll(fake_id))) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fake_id"); + psFree(where); + return false; + } + } + + PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false); + // convert exp_id into a psS64 + if (exp_id) { + if (!psMetadataAddS64(where, PS_LIST_TAIL, "rawExp.exp_id", 0, "==", (psS64)atoll(exp_id))) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(where); + return false; + } + } + + PXOPT_COPY_STR(config->args, where, "-class_id", "rawImfile.class_id", "=="); + PXOPT_COPY_STR(config->args, where, "-inst", "rawExp.telescope", "=="); + PXOPT_COPY_STR(config->args, where, "-filter", "rawExp.filter", "=="); + + psString query = pxDataGet("faketool_pendingimfile.sql"); + if (!query) { + psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement"); + return false; + } + + if (where && psListLength(where->list)) { + psString whereClause = psDBGenerateWhereConditionSQL(where, NULL); + psStringAppend(&query, " AND %s", whereClause); + psFree(whereClause); + } + psFree(where); + + // treat limit == 0 as "no limit" + if (limit) { + psString limitString = psDBGenerateLimitSQL(limit); + psStringAppend(&query, " %s", limitString); + psFree(limitString); + } + + if (!p_psDBRunQuery(config->dbh, query)) { + psError(PS_ERR_UNKNOWN, false, "database error"); + psFree(query); + return false; + } + psFree(query); + + psArray *output = p_psDBFetchResult(config->dbh); + if (!output) { + psError(PS_ERR_UNKNOWN, false, "database error"); + return false; + } + if (!psArrayLength(output)) { + psTrace("faketool", PS_LOG_INFO, "no rows found"); + psFree(output); + return true; + } + + if (!convertIdToStr(output)) { + psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings"); + psFree(output); + return false; + } + + // negative simple so the default is true + if (!ippdbPrintMetadatas(stdout, output, "fakePendingImfile", !simple)) { + psError(PS_ERR_UNKNOWN, false, "failed to print array"); + psFree(output); + return false; + } + + psFree(output); + + return true; +} + + +static bool addprocessedimfileMode(pxConfig *config) +{ + PS_ASSERT_PTR_NON_NULL(config, false); + + // fake_id, ext_tag, class_id are required + PXOPT_LOOKUP_STR(fake_id, config->args, "-fake_id", true, false); + PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", true, false); + PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false); + + // optional + PXOPT_LOOKUP_STR(uri, config->args, "-uri", false, false); + PXOPT_LOOKUP_F32(bg, config->args, "-bg", false, false); + PXOPT_LOOKUP_F32(bg_stdev, config->args, "-bg_stdev", false, false); + PXOPT_LOOKUP_F32(bg_mean_stdev, config->args, "-bg_mean_stdev", false, false); + PXOPT_LOOKUP_F32(bias, config->args, "-bias", false, false); + PXOPT_LOOKUP_F32(bias_stdev, config->args, "-bias_stdev", false, false); + PXOPT_LOOKUP_F32(fringe_0, config->args, "-fringe_0", false, false); + PXOPT_LOOKUP_F32(fringe_1, config->args, "-fringe_1", false, false); + PXOPT_LOOKUP_F32(fringe_2, config->args, "-fringe_2", false, false); + PXOPT_LOOKUP_F32(sigma_ra, config->args, "-sigma_ra", false, false); + PXOPT_LOOKUP_F32(sigma_dec, config->args, "-sigma_dec", false, false); + PXOPT_LOOKUP_F32(ap_resid, config->args, "-ap_resid", false, false); + PXOPT_LOOKUP_F32(ap_resid_stdev, config->args, "-ap_resid_stdev", false, false); + PXOPT_LOOKUP_F32(zp_mean, config->args, "-zp_mean", false, false); + PXOPT_LOOKUP_F32(zp_stdev, config->args, "-zp_stdev", false, false); + PXOPT_LOOKUP_F32(fwhm_major, config->args, "-fwhm_major", false, false); + PXOPT_LOOKUP_F32(fwhm_minor, config->args, "-fwhm_minor", false, false); + PXOPT_LOOKUP_F32(dtime_detrend, config->args, "-dtime_detrend", false, false); + PXOPT_LOOKUP_F32(dtime_photom, config->args, "-dtime_photom", false, false); + PXOPT_LOOKUP_F32(dtime_astrom, config->args, "-dtime_astrom", false, false); + PXOPT_LOOKUP_STR(hostname, config->args, "-hostname", false, false); + PXOPT_LOOKUP_F32(n_stars, config->args, "-n_stars", false, false); + PXOPT_LOOKUP_F32(n_extended, config->args, "-n_extended", false, false); + PXOPT_LOOKUP_F32(n_cr, config->args, "-n_cr", false, false); + PXOPT_LOOKUP_F32(n_astrom, config->args, "-n_astrom", false, false); + PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", false, false); + + // default values + PXOPT_LOOKUP_S16(code, config->args, "-code", false, false); + + if (!psDBTransaction(config->dbh)) { + psError(PS_ERR_UNKNOWN, false, "database error"); + return false; + } + + if (!fakeProcessedImfileInsert(config->dbh, + (psS64)atoll(fake_id), + (psS64)atoll(exp_id), + class_id, + uri, + bg, + bg_stdev, + bg_mean_stdev, + bias, + bias_stdev, + fringe_0, + fringe_1, + fringe_2, + sigma_ra, + sigma_dec, + ap_resid, + ap_resid_stdev, + zp_mean, + zp_stdev, + fwhm_major, + fwhm_minor, + dtime_detrend, + dtime_photom, + dtime_astrom, + hostname, + n_stars, + n_extended, + n_cr, + n_astrom, + path_base, + code + )) { + // rollback + if (!psDBRollback(config->dbh)) { + psError(PS_ERR_UNKNOWN, false, "database error"); + } + psError(PS_ERR_UNKNOWN, false, "database error"); + return false; + } + + // XXX I've decided to make the transaction cover the Exp migration as + // well. Otherwise, if the last imfile in an exp is moved and the exp + // migration fails then the data base is left in a satuation where the exp + // migration can't happen. + + if (!fakeProcessedCompleteExp(config)) { + // rollback + if (!psDBRollback(config->dbh)) { + psError(PS_ERR_UNKNOWN, false, "database error"); + } + psError(PS_ERR_UNKNOWN, false, "database error"); + return false; + } + + if (!psDBCommit(config->dbh)) { + psError(PS_ERR_UNKNOWN, false, "database error"); + return false; + } + + return true; +} + + +static bool processedimfileMode(pxConfig *config) +{ + PS_ASSERT_PTR_NON_NULL(config, NULL); + + PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false); + PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false); + PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false); + + psMetadata *where = psMetadataAlloc(); + PXOPT_LOOKUP_STR(fake_id, config->args, "-fake_id", false, false); + // convert fake_id into a psS64 + if (fake_id) { + if (!psMetadataAddS64(where, PS_LIST_TAIL, "fakeRun.fake_id", 0, "==", (psS64)atoll(fake_id))) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fake_id"); + psFree(where); + return false; + } + } + + PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false); + // convert exp_id into a psS64 + if (exp_id) { + if (!psMetadataAddS64(where, PS_LIST_TAIL, "rawExp.exp_id", 0, "==", (psS64)atoll(exp_id))) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(where); + return false; + } + } + + PXOPT_COPY_STR(config->args, where, "-class_id", "rawImfile.class_id", "=="); + PXOPT_COPY_STR(config->args, where, "-inst", "rawExp.telescope", "=="); + PXOPT_COPY_STR(config->args, where, "-filter", "rawExp.filter", "=="); + + psString query = pxDataGet("faketool_processedimfile.sql"); + if (!query) { + psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement"); + return false; + } + + if (where && psListLength(where->list)) { + psString whereClause = psDBGenerateWhereConditionSQL(where, "fakeProcessedImfile"); + psStringAppend(&query, " AND %s", whereClause); + psFree(whereClause); + } + psFree(where); + + if (faulted) { + // list only faulted rows + psStringAppend(&query, " %s", "AND fakeProcessedImfile.fault != 0"); + } else { + // don't list faulted rows + psStringAppend(&query, " %s", "AND fakeProcessedImfile.fault = 0"); + } + + // treat limit == 0 as "no limit" + if (limit) { + psString limitString = psDBGenerateLimitSQL(limit); + psStringAppend(&query, " %s", limitString); + psFree(limitString); + } + + if (!p_psDBRunQuery(config->dbh, query)) { + psError(PS_ERR_UNKNOWN, false, "database error"); + psFree(query); + return false; + } + psFree(query); + + psArray *output = p_psDBFetchResult(config->dbh); + if (!output) { + psError(PS_ERR_UNKNOWN, false, "database error"); + return false; + } + if (!psArrayLength(output)) { + psTrace("faketool", PS_LOG_INFO, "no rows found"); + psFree(output); + return true; + } + + if (!convertIdToStr(output)) { + psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings"); + psFree(output); + return false; + } + + // negative simple so the default is true + if (!ippdbPrintMetadatas(stdout, output, "fakeProcessedImfile", !simple)) { + psError(PS_ERR_UNKNOWN, false, "failed to print array"); + psFree(output); + return false; + } + + psFree(output); + + return true; +} + +static bool revertprocessedimfileMode(pxConfig *config) +{ + PS_ASSERT_PTR_NON_NULL(config, false); + + psMetadata *where = psMetadataAlloc(); + PXOPT_LOOKUP_STR(fake_id, config->args, "-fake_id", false, false); + // convert fake_id into a psS64 + if (fake_id) { + if (!psMetadataAddS64(where, PS_LIST_TAIL, "fake_id", 0, "==", (psS64)atoll(fake_id))) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fake_id"); + psFree(where); + return false; + } + } + + PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false); + // convert exp_id into a psS64 + if (exp_id) { + if (!psMetadataAddS64(where, PS_LIST_TAIL, "exp_id", 0, "==", (psS64)atoll(exp_id))) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(where); + return false; + } + } + + PXOPT_COPY_STR(config->args, where, "-exp_name", "exp_name", "=="); + PXOPT_COPY_STR(config->args, where, "-inst", "camera", "=="); + PXOPT_COPY_STR(config->args, where, "-telescope", "telescope", "=="); + PXOPT_COPY_TIME(config->args, where, "-dateobs_begin", "dateobs", ">="); + PXOPT_COPY_TIME(config->args, where, "-dateobs_end", "dateobs", "<="); + PXOPT_COPY_STR(config->args, where, "-exp_tag", "exp_tag", "=="); + PXOPT_COPY_STR(config->args, where, "-filelevel", "filelevel", "=="); + PXOPT_COPY_STR(config->args, where, "-reduction", "reduction", "=="); + PXOPT_COPY_STR(config->args, where, "-filter", "filter", "=="); + PXOPT_COPY_F64(config->args, where, "-airmass_min", "airmass", ">="); + PXOPT_COPY_F64(config->args, where, "-airmass_max", "airmass", "<"); + PXOPT_COPY_F64(config->args, where, "-ra_min", "ra", ">="); + PXOPT_COPY_F64(config->args, where, "-ra_max", "ra", "<"); + PXOPT_COPY_F64(config->args, where, "-decl_min", "decl", ">="); + PXOPT_COPY_F64(config->args, where, "-decl_max", "decl", "<"); + PXOPT_COPY_F32(config->args, where, "-exp_time_min", "exp_time", ">="); + PXOPT_COPY_F32(config->args, where, "-exp_time_max", "exp_time", "<"); + PXOPT_COPY_F32(config->args, where, "-sat_pixel_frac_min", "sat_pixel_frac", ">="); + PXOPT_COPY_F32(config->args, where, "-sat_pixel_frac_max", "sat_pixel_frac", "<"); + PXOPT_COPY_F64(config->args, where, "-bg_min", "bt", ">="); + PXOPT_COPY_F64(config->args, where, "-bg_max", "bt", "<"); + PXOPT_COPY_F64(config->args, where, "-bg_stdev_min", "bg_stdev", ">="); + PXOPT_COPY_F64(config->args, where, "-bg_stdev_max", "bg_stdev", "<"); + PXOPT_COPY_F64(config->args, where, "-bg_mean_stdev_min", "bg_mean_stdev", ">="); + PXOPT_COPY_F64(config->args, where, "-bg_mean_stdev_max", "bg_mean_stdev", "<"); + PXOPT_COPY_F64(config->args, where, "-alt_min", "alt", ">="); + PXOPT_COPY_F64(config->args, where, "-alt_max", "alt", "<"); + PXOPT_COPY_F64(config->args, where, "-az_min", "az", ">="); + PXOPT_COPY_F64(config->args, where, "-az_max", "az", "<"); + PXOPT_COPY_F32(config->args, where, "-ccd_temp_min", "ccd_temp", ">="); + PXOPT_COPY_F32(config->args, where, "-ccd_temp_max", "ccd_temp", "<"); + PXOPT_COPY_F64(config->args, where, "-posang_min", "posang", ">="); + PXOPT_COPY_F64(config->args, where, "-posang_max", "posang", "<"); + PXOPT_COPY_STR(config->args, where, "-object", "object", "=="); + PXOPT_COPY_F32(config->args, where, "-solang_min", "solang", ">="); + PXOPT_COPY_F32(config->args, where, "-solang_max", "solang", "<"); + + if (!psListLength(where->list) + && !psMetadataLookupBool(NULL, config->args, "-all")) { + psFree(where); + psError(PXTOOLS_ERR_DATA, false, "search parameters are required"); + return false; + } + + psString query = pxDataGet("faketool_revertprocessedimfile.sql"); + if (!query) { + psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement"); + psFree(where); + return false; + } + + if (where && psListLength(where->list)) { + psString whereClause = psDBGenerateWhereConditionSQL(where, "fakeProcessedImfile"); + psStringAppend(&query, " AND %s", whereClause); + psFree(whereClause); + } + + psFree(where); + + if (!p_psDBRunQuery(config->dbh, query)) { + psError(PS_ERR_UNKNOWN, false, "database error"); + psFree(query); + return false; + } + psFree(query); + + return true; +} + +static bool updateprocessedimfileMode(pxConfig *config) +{ + PS_ASSERT_PTR_NON_NULL(config, false); + + PXOPT_LOOKUP_S16(code, config->args, "-code", true, false); + + if (!pxSetFaultCode(config->dbh, "fakeProcessedImfile", config->where, code)) { + psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag"); + return false; + } + + return true; +} + + +static bool blockMode(pxConfig *config) +{ + PS_ASSERT_PTR_NON_NULL(config, false); + + PXOPT_LOOKUP_STR(label, config->args, "-label", true, false); + + if (!fakeMaskInsert(config->dbh, label)) { + psError(PS_ERR_UNKNOWN, false, "database error"); + return false; + } + + return true; +} + + +static bool maskedMode(pxConfig *config) +{ + PS_ASSERT_PTR_NON_NULL(config, false); + + PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false); + + psMetadata *where = psMetadataAlloc(); + + PXOPT_COPY_STR(config->args, where, "-label", "label", "=="); + + if (where->list->n < 1) { + psFree(where); + where = NULL; + } + + PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false); + + psString query = psStringCopy("SELECT * FROM fakeMask"); + + if (where) { + psString whereClause = psDBGenerateWhereSQL(where, NULL); + psFree(where); + psStringAppend(&query, " %s", whereClause); + psFree(whereClause); + } + + // treat limit == 0 as "no limit" + if (limit) { + psString limitString = psDBGenerateLimitSQL(limit); + psStringAppend(&query, " %s", limitString); + psFree(limitString); + } + + if (!p_psDBRunQuery(config->dbh, query)) { + psError(PS_ERR_UNKNOWN, false, "database error"); + psFree(query); + return false; + } + psFree(query); + + psArray *output = p_psDBFetchResult(config->dbh); + if (!output) { + psError(PS_ERR_UNKNOWN, false, "database error"); + return false; + } + if (!psArrayLength(output)) { + psTrace("faketool", PS_LOG_INFO, "no rows found"); + psFree(output); + return true; + } + + if (!convertIdToStr(output)) { + psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings"); + psFree(output); + return false; + } + + // negative simple so the default is true + if (!ippdbPrintMetadatas(stdout, output, "fakeMask", !simple)) { + psError(PS_ERR_UNKNOWN, false, "failed to print array"); + psFree(output); + return false; + } + + psFree(output); + + return true; +} + +// return the list of labels which are NOT blocked +static bool unmaskedMode(pxConfig *config) +{ + PS_ASSERT_PTR_NON_NULL(config, false); + + PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false); + PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false); + + psMetadata *where = psMetadataAlloc(); + + PXOPT_COPY_STR(config->args, where, "-label", "label", "=="); + + if (where->list->n < 1) { + psFree(where); + where = NULL; + } + + psString query = pxDataGet("faketool_unmasked.sql"); + if (!query) { + psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement"); + return false; + } + + if (where) { + psString whereClause = psDBGenerateWhereSQL(where, "fakeUnmask"); + psFree(where); + psStringAppend(&query, " %s", whereClause); + psFree(whereClause); + } + + // treat limit == 0 as "no limit" + if (limit) { + psString limitString = psDBGenerateLimitSQL(limit); + psStringAppend(&query, " %s", limitString); + psFree(limitString); + } + + if (!p_psDBRunQuery(config->dbh, query)) { + psError(PS_ERR_UNKNOWN, false, "database error"); + psFree(query); + return false; + } + psFree(query); + + psArray *output = p_psDBFetchResult(config->dbh); + if (!output) { + psError(PS_ERR_UNKNOWN, false, "database error"); + return false; + } + if (!psArrayLength(output)) { + psTrace("faketool", PS_LOG_INFO, "no rows found"); + psFree(output); + return true; + } + + if (!convertIdToStr(output)) { + psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings"); + psFree(output); + return false; + } + + // negative simple so the default is true + if (!ippdbPrintMetadatas(stdout, output, "fakeUnmask", !simple)) { + psError(PS_ERR_UNKNOWN, false, "failed to print array"); + psFree(output); + return false; + } + + psFree(output); + + return true; +} + + +static bool unblockMode(pxConfig *config) +{ + PS_ASSERT_PTR_NON_NULL(config, false); + + PXOPT_LOOKUP_STR(label, config->args, "-label", true, false); + + char *query = "DELETE FROM fakeMask WHERE label = '%s'"; + + if (!p_psDBRunQuery(config->dbh, query, label)) { + psError(PS_ERR_UNKNOWN, false, "database error"); + return false; + } + + return true; +} + + +static bool fakeProcessedCompleteExp(pxConfig *config) +{ + PS_ASSERT_PTR_NON_NULL(config, false); + + // look for completed fakePendingExp + // migrate them to fakeProccessedExp & camPendingExp + psString query = pxDataGet("faketool_completely_processed_exp.sql"); + if (!query) { + psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement"); + return false; + } + + if (!p_psDBRunQuery(config->dbh, query)) { + psError(PS_ERR_UNKNOWN, false, "database error"); + psFree(query); + return false; + } + psFree(query); + + psArray *output = p_psDBFetchResult(config->dbh); + if (!output) { + psError(PS_ERR_UNKNOWN, false, "database error"); + return false; + } + if (!psArrayLength(output)) { + psTrace("faketool", PS_LOG_INFO, "no rows found"); + psFree(output); + return true; + } + + for (long i = 0; i < psArrayLength(output); i++) { + psMetadata *row = output->data[i]; + + fakeRunRow *fakeRun = fakeRunObjectFromMetadata(row); + // set fakeRun.state to 'stop' + if (!pxfakeRunSetState(config, fakeRun->fake_id, "stop")) { + psError(PS_ERR_UNKNOWN, false, "failed to change fakeRun.state for fake_id: %" PRId64, fakeRun->fake_id); + psFree(fakeRun); + psFree(output); + return false; + } + + // should we stop here or proceed on to the cam stage? + // NULL for end_stage means go as far as possible + if (fakeRun->end_stage && psStrcasestr(fakeRun->end_stage, "fake")) { + psFree(fakeRun); + continue; + } + // else continue on... + + // camQueueFakeID() can only be run after fakeRun.state has been set to + // stop + if (!pxcamQueueByFakeID(config, + fakeRun->fake_id, + fakeRun->workdir, + fakeRun->label, + fakeRun->reduction, + fakeRun->expgroup, + fakeRun->dvodb, + fakeRun->tess_id, + fakeRun->end_stage + )) { + // rollback + if (!psDBRollback(config->dbh)) { + psError(PS_ERR_UNKNOWN, false, "database error"); + } + psError(PS_ERR_UNKNOWN, false, "failed to queue camPendingExp"); + psFree(fakeRun); + psFree(output); + return false; + } + psFree(fakeRun); + } + + psFree(output); + + return true; +} Index: trunk/ippTools/src/faketoolConfig.c =================================================================== --- trunk/ippTools/src/faketoolConfig.c (revision 17357) +++ trunk/ippTools/src/faketoolConfig.c (revision 17357) @@ -0,0 +1,454 @@ +/* + * faketoolConfig.c + * + * Copyright (C) 2006 Joshua Hoblitt + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the Free + * Software Foundation; version 2 of the License. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along with + * program; see the file COPYING. If not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#include + +#include + +#include "pxtools.h" +#include "faketool.h" + +pxConfig *faketoolConfig(pxConfig *config, int argc, char **argv) +{ + if (!config) { + config = pxConfigAlloc(); + } + + pmConfigReadParamsSet(false); + + config->modules = pmConfigRead(&argc, argv, NULL); + if (! config->modules) { + psError(PS_ERR_UNKNOWN, false, "Can't find site configuration"); + psFree(config); + return NULL; + } + + // -queue + psMetadata *queueArgs = psMetadataAlloc(); + // XXX need to allow multiple exp_ids + psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-exp_id", 0, + "search by exp_id", NULL); + psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-exp_name", 0, + "search by exp_name", NULL); + psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-inst", 0, + "search for camera", NULL); + psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-telescope", 0, + "search for telescope", NULL); + psMetadataAddTime(queueArgs, PS_LIST_TAIL, "-dateobs_begin", 0, + "search for exposures by time (>=)", NULL); + psMetadataAddTime(queueArgs, PS_LIST_TAIL, "-dateobs_end", 0, + "search for exposures by time (<)", NULL); + psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-exp_tag", 0, + "search by exp_tag", NULL); + psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-exp_type", 0, + "search by exp_type", "object"); + psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-filelevel", 0, + "search by filelevel", NULL); + psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-reduction", 0, + "search by reduction class", NULL); + psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-filter", 0, + "search for filter", NULL); + psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-airmass_min", 0, + "define min airmass", NAN); + psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-airmass_max", 0, + "define max airmass", NAN); + psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-ra_min", 0, + "define min", NAN); + psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-ra_max", 0, + "define max", NAN); + psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-decl_min", 0, + "define min", NAN); + psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-decl_max", 0, + "define max", NAN); + psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-exp_time_min", 0, + "define min", NAN); + psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-exp_time_max", 0, + "define max", NAN); + psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-sat_pixel_frac_min", 0, + "define max fraction of saturated pixels", NAN); + psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-sat_pixel_frac_max", 0, + "define min fraction of saturated pixels", NAN); + psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-bg_min", 0, + "define max", NAN); + psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-bg_max", 0, + "define max", NAN); + psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-bg_stdev_min", 0, + "define max", NAN); + psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-bg_stdev_max", 0, + "define max", NAN); + psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-bg_mean_stdev_min", 0, + "define max", NAN); + psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-bg_mean_stdev_max", 0, + "define max", NAN); + psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-alt_min", 0, + "define min", NAN); + psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-alt_max", 0, + "define max", NAN); + psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-az_min", 0, + "define min", NAN); + psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-az_max", 0, + "define max", NAN); + psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-ccd_temp_min", 0, + "define min ccd tempature", NAN); + psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-ccd_temp_max", 0, + "define max ccd tempature", NAN); + psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-posang_min", 0, + "define min rotator position angle", NAN); + psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-posang_max", 0, + "define max rotator position angle", NAN); + psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-object", 0, + "search by exposure object", NULL); + psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-solang_min", 0, + "define min solar angle", NAN); + psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-solang_max", 0, + "define max solar angle", NAN); + psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_workdir", 0, + "define workdir", NULL); + psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_label", 0, + "define label", NULL); + psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_reduction", 0, + "define reduction class", NULL); + psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_expgroup", 0, + "define exposure group", NULL); + psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_dvodb", 0, + "define DVO db", NULL); + psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_tess_id", 0, + "define tessellation identifier", NULL); + psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_end_stage", 0, + "define end stage", NULL); + psMetadataAddBool(queueArgs, PS_LIST_TAIL, "-pretend", 0, + "do not actually modify the database", false); + psMetadataAddBool(queueArgs, PS_LIST_TAIL, "-all", 0, + "allow everything to be queued without search terms", false); + + + // -updaterun + psMetadata *updaterunArgs = psMetadataAlloc(); + psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-fake_id", 0, + "search by fake ID", NULL); + psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_id", 0, + "search by exp_id", NULL); + psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_name", 0, + "search by exp_name", NULL); + psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-inst", 0, + "search for camera", NULL); + psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-telescope", 0, + "search for telescope", NULL); + psMetadataAddTime(updaterunArgs, PS_LIST_TAIL, "-dateobs_begin", 0, + "search for exposures by time (>=)", NULL); + psMetadataAddTime(updaterunArgs, PS_LIST_TAIL, "-dateobs_end", 0, + "search for exposures by time (<)", NULL); + psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_tag", 0, + "search by exp_tag", NULL); + psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_type", 0, + "search by exp_type", "object"); + psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-filelevel", 0, + "search by filelevel", NULL); + psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-reduction", 0, + "search by reduction class", NULL); + psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-filter", 0, + "search for filter", NULL); + psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-airmass_min", 0, + "define min airmass", NAN); + psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-airmass_max", 0, + "define max airmass", NAN); + psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ra_min", 0, + "define min", NAN); + psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ra_max", 0, + "define max", NAN); + psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-decl_min", 0, + "define min", NAN); + psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-decl_max", 0, + "define max", NAN); + psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-exp_time_min", 0, + "define min", NAN); + psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-exp_time_max", 0, + "define max", NAN); + psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-sat_pixel_frac_min", 0, + "define max fraction of saturated pixels", NAN); + psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-sat_pixel_frac_max", 0, + "define min fraction of saturated pixels", NAN); + psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_min", 0, + "define max", NAN); + psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_max", 0, + "define max", NAN); + psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_stdev_min", 0, + "define max", NAN); + psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_stdev_max", 0, + "define max", NAN); + psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_mean_stdev_min", 0, + "define max", NAN); + psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_mean_stdev_max", 0, + "define max", NAN); + psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-alt_min", 0, + "define min", NAN); + psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-alt_max", 0, + "define max", NAN); + psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-az_min", 0, + "define min", NAN); + psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-az_max", 0, + "define max", NAN); + psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ccd_temp_min", 0, + "define min ccd tempature", NAN); + psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ccd_temp_max", 0, + "define max ccd tempature", NAN); + psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-posang_min", 0, + "define min rotator position angle", NAN); + psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-posang_max", 0, + "define max rotator position angle", NAN); + psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-object", 0, + "search by exposure object", NULL); + psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-solang_min", 0, + "define min solar angle", NAN); + psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-solang_max", 0, + "define max solar angle", NAN); + + psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0, + "set state", NULL); + psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label", 0, + "set label", NULL); + psMetadataAddBool(updaterunArgs, PS_LIST_TAIL, "-all", 0, + "allow everything to be queued without search terms", false); + + + // -pendingimfile + psMetadata *pendingimfileArgs = psMetadataAlloc(); + psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-fake_id", 0, + "search by fake ID", NULL); + psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-exp_id", 0, + "search by exposure ID", NULL); + psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-class_id", 0, + "search by class ID", NULL); + psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-inst", 0, + "search by camera of interest", NULL); + psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-filter", 0, + "search by filter of interest", NULL); + psMetadataAddU64(pendingimfileArgs, PS_LIST_TAIL, "-limit", 0, + "limit result set to N items", 0); + psMetadataAddBool(pendingimfileArgs, PS_LIST_TAIL, "-simple", 0, + "use the simple output format", false); + + // -addprocessedimfile + psMetadata *addprocessedimfileArgs = psMetadataAlloc(); + psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-fake_id", 0, + "define fake ID (required)", NULL); + psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-exp_id", 0, + "define exposure ID (required)", NULL); + psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-class_id", 0, + "define class ID (required)", NULL); + psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-uri", 0, + "define URL", NULL); + psMetadataAddF32(addprocessedimfileArgs, PS_LIST_TAIL, "-dtime_fake", 0, + "define elapsed time for detrend (seconds)", NAN); + psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-hostname", 0, + "define hostname", NULL); + psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-path_base", 0, + "define base output location", NULL); + psMetadataAddS16(addprocessedimfileArgs, PS_LIST_TAIL, "-code", 0, + "set fault code", 0); + + // -processedimfile + psMetadata *processedimfileArgs = psMetadataAlloc(); + psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-fake_id", 0, + "define fake ID", NULL); + psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-exp_id", 0, + "define exposure ID", NULL); + psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-class_id", 0, + "define class ID", NULL); + psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-inst", 0, + "define camera of interest", NULL); + psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-filter", 0, + "define filter of interest", NULL); + psMetadataAddU64(processedimfileArgs, PS_LIST_TAIL, "-limit", 0, + "limit result set to N items", 0); + psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-faulted", 0, + "only return imfiles with a fault status set", false); + psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-simple", 0, + "use the simple output format", false); + + // -updateprocessedimfile + psMetadata *updateprocessedimfileArgs = psMetadataAlloc(); + psMetadataAddStr(updateprocessedimfileArgs, PS_LIST_TAIL, "-fake_id", 0, + "search by fake ID", NULL); + psMetadataAddStr(updateprocessedimfileArgs, PS_LIST_TAIL, "-exp_id", 0, + "search by exposure ID", NULL); + psMetadataAddStr(updateprocessedimfileArgs, PS_LIST_TAIL, "-class_id", 0, + "search by class ID", NULL); + psMetadataAddS16(updateprocessedimfileArgs, PS_LIST_TAIL, "-code", 0, + "set fault code (required)", 0); + + // -revertprocessedimfile + psMetadata *revertprocessedimfileArgs = psMetadataAlloc(); + psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-fake_id", 0, + "search by fake ID", NULL); + psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_id", 0, + "search by exp_id", NULL); + psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_name", 0, + "search by exp_name", NULL); + psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-inst", 0, + "search for camera", NULL); + psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-telescope", 0, + "search for telescope", NULL); + psMetadataAddTime(revertprocessedimfileArgs, PS_LIST_TAIL, "-dateobs_begin", 0, + "search for exposures by time (>=)", NULL); + psMetadataAddTime(revertprocessedimfileArgs, PS_LIST_TAIL, "-dateobs_end", 0, + "search for exposures by time (<)", NULL); + psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_tag", 0, + "search by exp_tag", NULL); + psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_type", 0, + "search by exp_type", "object"); + psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-filelevel", 0, + "search by filelevel", NULL); + psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-reduction", 0, + "search by reduction class", NULL); + psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-filter", 0, + "search for filter", NULL); + psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-airmass_min", 0, + "define min airmass", NAN); + psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-airmass_max", 0, + "define max airmass", NAN); + psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-ra_min", 0, + "define min", NAN); + psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-ra_max", 0, + "define max", NAN); + psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-decl_min", 0, + "define min", NAN); + psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-decl_max", 0, + "define max", NAN); + psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_time_min", 0, + "define min", NAN); + psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_time_max", 0, + "define max", NAN); + psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-sat_pixel_frac_min", 0, + "define max fraction of saturated pixels", NAN); + psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-sat_pixel_frac_max", 0, + "define min fraction of saturated pixels", NAN); + psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-bg_min", 0, + "define max", NAN); + psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-bg_max", 0, + "define max", NAN); + psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-bg_stdev_min", 0, + "define max", NAN); + psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-bg_stdev_max", 0, + "define max", NAN); + psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-bg_mean_stdev_min", 0, + "define max", NAN); + psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-bg_mean_stdev_max", 0, + "define max", NAN); + psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-alt_min", 0, + "define min", NAN); + psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-alt_max", 0, + "define max", NAN); + psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-az_min", 0, + "define min", NAN); + psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-az_max", 0, + "define max", NAN); + psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-ccd_temp_min",0, + "define min ccd tempature", NAN); + psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-ccd_temp_max",0, + "define max ccd tempature", NAN); + psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-posang_min", 0, + "define min rotator position angle", NAN); + psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-posang_max", 0, + "define max rotator position angle", NAN); + psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-object", 0, + "search by exposure object", NULL); + psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-solang_min", 0, + "define min solar angle", NAN); + psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-solang_max", 0, + "define max solar angle", NAN); + + psMetadataAddBool(revertprocessedimfileArgs, PS_LIST_TAIL, "-all", 0, + "allow everything to be queued without search terms", false); + psMetadataAddS16(revertprocessedimfileArgs, PS_LIST_TAIL, "-code", 0, + "search by fault code", 0); + + // -block + psMetadata *blockArgs = psMetadataAlloc(); + psMetadataAddStr(blockArgs, PS_LIST_TAIL, "-label", 0, + "name of a label to mask out (required)", NULL); + + // -masked + psMetadata *maskedArgs = psMetadataAlloc(); + psMetadataAddStr(maskedArgs, PS_LIST_TAIL, "-label", 0, + "list blocks for specified label", NULL); + psMetadataAddBool(maskedArgs, PS_LIST_TAIL, "-simple", 0, + "use the simple output format", false); + psMetadataAddU64(maskedArgs, PS_LIST_TAIL, "-limit", 0, + "limit result set to N items", 0); + + // -unmasked + psMetadata *unmaskedArgs = psMetadataAlloc(); + psMetadataAddStr(unmaskedArgs, PS_LIST_TAIL, "-label", 0, + "restrict to specified label", NULL); + psMetadataAddBool(unmaskedArgs, PS_LIST_TAIL, "-simple", 0, + "use the simple output format", false); + psMetadataAddU64(unmaskedArgs, PS_LIST_TAIL, "-limit", 0, + "limit result set to N items", 0); + + // -unblock + psMetadata *unblockArgs = psMetadataAlloc(); + psMetadataAddStr(unblockArgs, PS_LIST_TAIL, "-label", 0, + "name of a label to unmask (required)", NULL); + + psMetadata *argSets = psMetadataAlloc(); + psMetadata *modes = psMetadataAlloc(); + + PXOPT_ADD_MODE("-queue", "create runs from raw exposures", + FAKETOOL_MODE_QUEUE, queueArgs); + PXOPT_ADD_MODE("-updaterun", "change fake run properties", + FAKETOOL_MODE_UPDATERUN, updaterunArgs); + PXOPT_ADD_MODE("-pendingimfile", "show pending imfiles", + FAKETOOL_MODE_PENDINGIMFILE, pendingimfileArgs); + PXOPT_ADD_MODE("-addprocessedimfile", "add a processed imfile", + FAKETOOL_MODE_ADDPROCESSEDIMFILE,addprocessedimfileArgs); + PXOPT_ADD_MODE("-processedimfile", "show processed imfiles", + FAKETOOL_MODE_PROCESSEDIMFILE, processedimfileArgs); + PXOPT_ADD_MODE("-updateprocessedimfile", "change procesed imfile properties", FAKETOOL_MODE_UPDATEPROCESSEDIMFILE, updateprocessedimfileArgs); + PXOPT_ADD_MODE("-revertprocessedimfile", "undo a processed imfile", FAKETOOL_MODE_REVERTPROCESSEDIMFILE, revertprocessedimfileArgs); + PXOPT_ADD_MODE("-block", "set a label block", FAKETOOL_MODE_BLOCK, blockArgs); + PXOPT_ADD_MODE("-masked", "show blocked labels", FAKETOOL_MODE_MASKED, maskedArgs); + PXOPT_ADD_MODE("-unmasked", "", FAKETOOL_MODE_UNMASKED, unmaskedArgs); + PXOPT_ADD_MODE("-unblock", "remove a label block", FAKETOOL_MODE_UNBLOCK, unblockArgs); + + if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) { + psError(PS_ERR_UNKNOWN, true, "option parsing failed"); + psFree(argSets); + psFree(modes); + psFree(config); + return NULL; + } + + psFree(argSets); + psFree(modes); + + // define Database handle, if used + config->dbh = pmConfigDB(config->modules); + if (!config->dbh) { + psError(PS_ERR_UNKNOWN, false, "Can't configure database"); + psFree(config); + return NULL; + } + + return config; +}