Index: /branches/eam_branch_20080719/ippTools/share/pxadmin_create_tables.sql =================================================================== --- /branches/eam_branch_20080719/ippTools/share/pxadmin_create_tables.sql (revision 18642) +++ /branches/eam_branch_20080719/ippTools/share/pxadmin_create_tables.sql (revision 18643) @@ -642,5 +642,5 @@ CREATE TABLE detResidExp (det_id BIGINT, iteration INT, exp_id BIGINT, recipe VARCHAR(64), bg DOUBLE, bg_stdev DOUBLE, bg_mean_stdev DOUBLE, bg_skewness DOUBLE, bg_kurtosis DOUBLE, bin_stdev DOUBLE, fringe_0 DOUBLE, fringe_1 DOUBLE, fringe_2 DOUBLE, fringe_resid_0 DOUBLE, fringe_resid_1 DOUBLE, fringe_resid_2 DOUBLE, user_1 DOUBLE, user_2 DOUBLE, user_3 DOUBLE, user_4 DOUBLE, user_5 DOUBLE, path_base VARCHAR(255), accept TINYINT, fault SMALLINT NOT NULL, PRIMARY KEY(det_id, iteration, exp_id), KEY(fault), INDEX(det_id, iteration), FOREIGN KEY (det_id, iteration, exp_id) REFERENCES detInputExp(det_id, iteration, exp_id), FOREIGN KEY (det_id, iteration, exp_id) REFERENCES detResidImfile(det_id, iteration, exp_id)) ENGINE=innodb DEFAULT CHARSET=latin1; -CREATE TABLE detRunSummary (det_id BIGINT, iteration INT, bg DOUBLE, bg_stdev DOUBLE, bg_mean_stdev DOUBLE, accept TINYINT, fault SMALLINT NOT NULL, PRIMARY KEY(det_id, iteration), KEY(fault), FOREIGN KEY (det_id, iteration) REFERENCES detInputExp(det_id, iteration), FOREIGN KEY (det_id, iteration) REFERENCES detResidExp(det_id, iteration)) ENGINE=innodb DEFAULT CHARSET=latin1; +CREATE TABLE detRunSummary (det_id BIGINT, iteration INT, data_state VARHAR(64), bg DOUBLE, bg_stdev DOUBLE, bg_mean_stdev DOUBLE, accept TINYINT, fault SMALLINT NOT NULL, PRIMARY KEY(det_id, iteration), KEY(fault), FOREIGN KEY (det_id, iteration) REFERENCES detInputExp(det_id, iteration), FOREIGN KEY (det_id, iteration) REFERENCES detResidExp(det_id, iteration)) ENGINE=innodb DEFAULT CHARSET=latin1; CREATE TABLE detRegisteredImfile (det_id BIGINT, iteration INT, class_id VARCHAR(64), uri VARCHAR(255), bg DOUBLE, bg_stdev DOUBLE, bg_mean_stdev DOUBLE, user_1 DOUBLE, user_2 DOUBLE, user_3 DOUBLE, user_4 DOUBLE, user_5 DOUBLE, path_base VARCHAR(255), fault SMALLINT NOT NULL, PRIMARY KEY(det_id, iteration, class_id), KEY(fault), FOREIGN KEY (det_id, iteration) REFERENCES detRun(det_id, iteration)) ENGINE=innodb DEFAULT CHARSET=latin1; Index: /branches/eam_branch_20080719/ippTools/src/Makefile.am =================================================================== --- /branches/eam_branch_20080719/ippTools/src/Makefile.am (revision 18642) +++ /branches/eam_branch_20080719/ippTools/src/Makefile.am (revision 18643) @@ -46,5 +46,4 @@ flatcorr.h \ faketool.h \ - guidetool.h \ magictool.h \ pstamptool.h \ @@ -109,10 +108,4 @@ regtoolConfig.c -guidetool_CFLAGS = $(PSLIB_CFLAGS) $(PSMODULES_CFLAGS) $(IPPDB_CFLAGS) -guidetool_LDADD = $(PSLIB_LIBS) $(PSMODULES_LIBS) $(IPPDB_LIBS) libpxtools.la -guidetool_SOURCES = \ - guidetool.c \ - guidetoolConfig.c - chiptool_CFLAGS = $(PSLIB_CFLAGS) $(PSMODULES_CFLAGS) $(IPPDB_CFLAGS) chiptool_LDADD = $(PSLIB_LIBS) $(PSMODULES_LIBS) $(IPPDB_LIBS) libpxtools.la Index: /branches/eam_branch_20080719/ippTools/src/dettool.c =================================================================== --- /branches/eam_branch_20080719/ippTools/src/dettool.c (revision 18642) +++ /branches/eam_branch_20080719/ippTools/src/dettool.c (revision 18643) @@ -77,4 +77,6 @@ MODECASE(DETTOOL_MODE_PROCESSEDIMFILE, processedimfileMode); MODECASE(DETTOOL_MODE_REVERTPROCESSEDIMFILE, revertprocessedimfileMode); + MODECASE(DETTOOL_MODE_PENDINGCLEANUP_PROCESSEDIMFILE, pendingcleanup_processedimfileMode); + MODECASE(DETTOOL_MODE_DONECLEANUP_PROCESSEDIMFILE, donecleanup_processedimfileMode); // exp MODECASE(DETTOOL_MODE_TOPROCESSEDEXP, toprocessedexpMode); @@ -82,4 +84,6 @@ MODECASE(DETTOOL_MODE_PROCESSEDEXP, processedexpMode); MODECASE(DETTOOL_MODE_REVERTPROCESSEDEXP, revertprocessedexpMode); + MODECASE(DETTOOL_MODE_PENDINGCLEANUP_PROCESSEDEXP, pendingcleanup_processedexpMode); + MODECASE(DETTOOL_MODE_DONECLEANUP_PROCESSEDEXP, donecleanup_processedexpMode); // stacked MODECASE(DETTOOL_MODE_TOSTACKED, tostackedMode); @@ -87,4 +91,6 @@ MODECASE(DETTOOL_MODE_STACKED, stackedMode); MODECASE(DETTOOL_MODE_REVERTSTACKED, revertstackedMode); + MODECASE(DETTOOL_MODE_PENDINGCLEANUP_STACKED, pendingcleanup_stackedMode); + MODECASE(DETTOOL_MODE_DONECLEANUP_STACKED, donecleanup_stackedMode); // normalizedstat MODECASE(DETTOOL_MODE_TONORMALIZEDSTAT, tonormalizedstatMode); @@ -92,4 +98,6 @@ MODECASE(DETTOOL_MODE_NORMALIZEDSTAT, normalizedstatMode); MODECASE(DETTOOL_MODE_REVERTNORMALIZEDSTAT, revertnormalizedstatMode); + MODECASE(DETTOOL_MODE_PENDINGCLEANUP_NORMALIZEDSTAT, pendingcleanup_normalizedstatMode); + MODECASE(DETTOOL_MODE_DONECLEANUP_NORMALIZEDSTAT, donecleanup_normalizedstatMode); // normalizedimfile MODECASE(DETTOOL_MODE_TONORMALIZE, tonormalizeMode); @@ -97,4 +105,6 @@ MODECASE(DETTOOL_MODE_NORMALIZEDIMFILE, normalizedimfileMode); MODECASE(DETTOOL_MODE_REVERTNORMALIZEDIMFILE, revertnormalizedimfileMode); + MODECASE(DETTOOL_MODE_PENDINGCLEANUP_NORMALIZEDIMFILE, pendingcleanup_normalizedimfileMode); + MODECASE(DETTOOL_MODE_DONECLEANUP_NORMALIZEDIMFILE, donecleanup_normalizedimfileMode); // normalizedexp MODECASE(DETTOOL_MODE_TONORMALIZEDEXP, tonormalizedexpMode); @@ -102,4 +112,6 @@ MODECASE(DETTOOL_MODE_NORMALIZEDEXP, normalizedexpMode); MODECASE(DETTOOL_MODE_REVERTNORMALIZEDEXP, revertnormalizedexpMode); + MODECASE(DETTOOL_MODE_PENDINGCLEANUP_NORMALIZEDEXP, pendingcleanup_normalizedexpMode); + MODECASE(DETTOOL_MODE_DONECLEANUP_NORMALIZEDEXP, donecleanup_normalizedexpMode); // residimfile MODECASE(DETTOOL_MODE_TORESIDIMFILE, toresidimfileMode); @@ -107,4 +119,6 @@ MODECASE(DETTOOL_MODE_RESIDIMFILE, residimfileMode); MODECASE(DETTOOL_MODE_REVERTRESIDIMFILE,revertresidimfileMode); + MODECASE(DETTOOL_MODE_PENDINGCLEANUP_RESIDIMFILE, pendingcleanup_residimfileMode); + MODECASE(DETTOOL_MODE_DONECLEANUP_RESIDIMFILE, donecleanup_residimfileMode); // residexp MODECASE(DETTOOL_MODE_TORESIDEXP, toresidexpMode); @@ -113,4 +127,6 @@ MODECASE(DETTOOL_MODE_REVERTRESIDEXP, revertresidexpMode); MODECASE(DETTOOL_MODE_UPDATERESIDEXP, updateresidexpMode); + MODECASE(DETTOOL_MODE_PENDINGCLEANUP_RESIDEXP, pendingcleanup_residexpMode); + MODECASE(DETTOOL_MODE_DONECLEANUP_RESIDEXP, donecleanup_residexpMode); // detrunsummary MODECASE(DETTOOL_MODE_TODETRUNSUMMARY, todetrunsummaryMode); Index: /branches/eam_branch_20080719/ippTools/src/dettool.h =================================================================== --- /branches/eam_branch_20080719/ippTools/src/dettool.h (revision 18642) +++ /branches/eam_branch_20080719/ippTools/src/dettool.h (revision 18643) @@ -41,36 +41,61 @@ DETTOOL_MODE_INPUT, DETTOOL_MODE_RAW, + DETTOOL_MODE_TOPROCESSEDIMFILE, DETTOOL_MODE_ADDPROCESSEDIMFILE, DETTOOL_MODE_PROCESSEDIMFILE, DETTOOL_MODE_REVERTPROCESSEDIMFILE, + DETTOOL_MODE_PENDINGCLEANUP_PROCESSEDIMFILE, + DETTOOL_MODE_DONECLEANUP_PROCESSEDIMFILE, + DETTOOL_MODE_TOPROCESSEDEXP, DETTOOL_MODE_ADDPROCESSEDEXP, DETTOOL_MODE_PROCESSEDEXP, DETTOOL_MODE_REVERTPROCESSEDEXP, + DETTOOL_MODE_PENDINGCLEANUP_PROCESSEDEXP, + DETTOOL_MODE_DONECLEANUP_PROCESSEDEXP, + DETTOOL_MODE_TOSTACKED, DETTOOL_MODE_ADDSTACKED, DETTOOL_MODE_STACKED, DETTOOL_MODE_REVERTSTACKED, + DETTOOL_MODE_PENDINGCLEANUP_STACKED, + DETTOOL_MODE_DONECLEANUP_STACKED, + DETTOOL_MODE_TONORMALIZEDSTAT, DETTOOL_MODE_ADDNORMALIZEDSTAT, DETTOOL_MODE_NORMALIZEDSTAT, DETTOOL_MODE_REVERTNORMALIZEDSTAT, + DETTOOL_MODE_PENDINGCLEANUP_NORMALIZEDSTAT, + DETTOOL_MODE_DONECLEANUP_NORMALIZEDSTAT, + DETTOOL_MODE_TONORMALIZE, DETTOOL_MODE_ADDNORMALIZEDIMFILE, DETTOOL_MODE_NORMALIZEDIMFILE, DETTOOL_MODE_REVERTNORMALIZEDIMFILE, + DETTOOL_MODE_PENDINGCLEANUP_NORMALIZEDIMFILE, + DETTOOL_MODE_DONECLEANUP_NORMALIZEDIMFILE, + DETTOOL_MODE_TONORMALIZEDEXP, DETTOOL_MODE_ADDNORMALIZEDEXP, DETTOOL_MODE_NORMALIZEDEXP, DETTOOL_MODE_REVERTNORMALIZEDEXP, + DETTOOL_MODE_PENDINGCLEANUP_NORMALIZEDEXP, + DETTOOL_MODE_DONECLEANUP_NORMALIZEDEXP, + DETTOOL_MODE_TORESIDIMFILE, DETTOOL_MODE_ADDRESIDIMFILE, DETTOOL_MODE_RESIDIMFILE, DETTOOL_MODE_REVERTRESIDIMFILE, + DETTOOL_MODE_PENDINGCLEANUP_RESIDIMFILE, + DETTOOL_MODE_DONECLEANUP_RESIDIMFILE, + DETTOOL_MODE_TORESIDEXP, DETTOOL_MODE_ADDRESIDEXP, DETTOOL_MODE_RESIDEXP, DETTOOL_MODE_REVERTRESIDEXP, + DETTOOL_MODE_PENDINGCLEANUP_RESIDEXP, + DETTOOL_MODE_DONECLEANUP_RESIDEXP, + DETTOOL_MODE_TODETRUNSUMMARY, DETTOOL_MODE_ADDDETRUNSUMMARY, @@ -101,4 +126,6 @@ bool processedimfileMode(pxConfig *config); bool revertprocessedimfileMode(pxConfig *config); +bool pendingcleanup_processedimfileMode(pxConfig *config); +bool donecleanup_processedimfileMode(pxConfig *config); // processedexp @@ -107,4 +134,6 @@ bool processedexpMode(pxConfig *config); bool revertprocessedexpMode(pxConfig *config); +bool pendingcleanup_processedexpMode(pxConfig *config); +bool donecleanup_processedexpMode(pxConfig *config); // stackedimfile @@ -113,4 +142,6 @@ bool stackedMode(pxConfig *config); bool revertstackedMode(pxConfig *config); +bool pendingcleanup_stackedMode(pxConfig *config); +bool donecleanup_stackedMode(pxConfig *config); // normalizedstat @@ -119,4 +150,6 @@ bool normalizedstatMode(pxConfig *config); bool revertnormalizedstatMode(pxConfig *config); +bool pendingcleanup_normalizedstatMode(pxConfig *config); +bool donecleanup_normalizedstatMode(pxConfig *config); // normalizedimfile @@ -125,4 +158,6 @@ bool normalizedimfileMode(pxConfig *config); bool revertnormalizedimfileMode(pxConfig *config); +bool pendingcleanup_normalizedimfileMode(pxConfig *config); +bool donecleanup_normalizedimfileMode(pxConfig *config); // normalizedexp @@ -131,4 +166,6 @@ bool normalizedexpMode(pxConfig *config); bool revertnormalizedexpMode(pxConfig *config); +bool pendingcleanup_normalizedexpMode(pxConfig *config); +bool donecleanup_normalizedexpMode(pxConfig *config); // residimfile @@ -137,4 +174,6 @@ bool residimfileMode(pxConfig *config); bool revertresidimfileMode(pxConfig *config); +bool pendingcleanup_residimfileMode(pxConfig *config); +bool donecleanup_residimfileMode(pxConfig *config); // residexp @@ -144,4 +183,6 @@ bool revertresidexpMode(pxConfig *config); bool updateresidexpMode(pxConfig *config); +bool pendingcleanup_residexpMode(pxConfig *config); +bool donecleanup_residexpMode(pxConfig *config); // detrunsummary Index: /branches/eam_branch_20080719/ippTools/src/dettool_normalizedexp.c =================================================================== --- /branches/eam_branch_20080719/ippTools/src/dettool_normalizedexp.c (revision 18642) +++ /branches/eam_branch_20080719/ippTools/src/dettool_normalizedexp.c (revision 18643) @@ -248,2 +248,128 @@ return true; } + +bool pendingcleanup_normalizedexpMode(pxConfig *config) +{ + PS_ASSERT_PTR_NON_NULL(config, NULL); + + PXOPT_LOOKUP_S64(chip_id, config->args, "-chip_id", false, false); + PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false); + PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false); + + psMetadata *where = psMetadataAlloc(); + if (chip_id) { + PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "=="); + } + PXOPT_COPY_STR(config->args, where, "-label", "label", "=="); + + psString query = pxDataGet("dettool_pendingcleanup_normalizedexp.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("dettool", PS_LOG_INFO, "no rows found"); + psFree(output); + return true; + } + + // negative simple so the default is true + if (!ippdbPrintMetadatas(stdout, output, "detPendingCleanup_normalizedexp", !simple)) { + psError(PS_ERR_UNKNOWN, false, "failed to print array"); + psFree(output); + return false; + } + + psFree(output); + + return true; +} + + +bool donecleanup_normalizedexpMode(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_COPY_STR(config->args, where, "-label", "label", "=="); + + psString query = pxDataGet("dettool_donecleanup_normalizedexp.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("dettool", PS_LOG_INFO, "no rows found"); + psFree(output); + return true; + } + + // negative simple so the default is true + if (!ippdbPrintMetadatas(stdout, output, "detDoneCleanup_normalizedexp", !simple)) { + psError(PS_ERR_UNKNOWN, false, "failed to print array"); + psFree(output); + return false; + } + + psFree(output); + + return true; +} + Index: /branches/eam_branch_20080719/ippTools/src/dettool_normalizedimfile.c =================================================================== --- /branches/eam_branch_20080719/ippTools/src/dettool_normalizedimfile.c (revision 18642) +++ /branches/eam_branch_20080719/ippTools/src/dettool_normalizedimfile.c (revision 18643) @@ -228,2 +228,128 @@ return true; } + +bool pendingcleanup_normalizedimfileMode(pxConfig *config) +{ + PS_ASSERT_PTR_NON_NULL(config, NULL); + + PXOPT_LOOKUP_S64(chip_id, config->args, "-chip_id", false, false); + PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false); + PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false); + + psMetadata *where = psMetadataAlloc(); + if (chip_id) { + PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "=="); + } + PXOPT_COPY_STR(config->args, where, "-label", "label", "=="); + + psString query = pxDataGet("dettool_pendingcleanup_normalizedimfile.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("dettool", PS_LOG_INFO, "no rows found"); + psFree(output); + return true; + } + + // negative simple so the default is true + if (!ippdbPrintMetadatas(stdout, output, "detPendingCleanup_normalizedimfile", !simple)) { + psError(PS_ERR_UNKNOWN, false, "failed to print array"); + psFree(output); + return false; + } + + psFree(output); + + return true; +} + + +bool donecleanup_normalizedimfileMode(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_COPY_STR(config->args, where, "-label", "label", "=="); + + psString query = pxDataGet("dettool_donecleanup_normalizedimfile.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("dettool", PS_LOG_INFO, "no rows found"); + psFree(output); + return true; + } + + // negative simple so the default is true + if (!ippdbPrintMetadatas(stdout, output, "detDoneCleanup_normalizedimfile", !simple)) { + psError(PS_ERR_UNKNOWN, false, "failed to print array"); + psFree(output); + return false; + } + + psFree(output); + + return true; +} + Index: /branches/eam_branch_20080719/ippTools/src/dettool_normalizedstat.c =================================================================== --- /branches/eam_branch_20080719/ippTools/src/dettool_normalizedstat.c (revision 18642) +++ /branches/eam_branch_20080719/ippTools/src/dettool_normalizedstat.c (revision 18643) @@ -208,2 +208,128 @@ return true; } + +bool pendingcleanup_normalizedstatMode(pxConfig *config) +{ + PS_ASSERT_PTR_NON_NULL(config, NULL); + + PXOPT_LOOKUP_S64(chip_id, config->args, "-chip_id", false, false); + PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false); + PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false); + + psMetadata *where = psMetadataAlloc(); + if (chip_id) { + PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "=="); + } + PXOPT_COPY_STR(config->args, where, "-label", "label", "=="); + + psString query = pxDataGet("dettool_pendingcleanup_normalizedstat.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("dettool", PS_LOG_INFO, "no rows found"); + psFree(output); + return true; + } + + // negative simple so the default is true + if (!ippdbPrintMetadatas(stdout, output, "detPendingCleanup_normalizedstat", !simple)) { + psError(PS_ERR_UNKNOWN, false, "failed to print array"); + psFree(output); + return false; + } + + psFree(output); + + return true; +} + + +bool donecleanup_normalizedstatMode(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_COPY_STR(config->args, where, "-label", "label", "=="); + + psString query = pxDataGet("dettool_donecleanup_normalizedstat.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("dettool", PS_LOG_INFO, "no rows found"); + psFree(output); + return true; + } + + // negative simple so the default is true + if (!ippdbPrintMetadatas(stdout, output, "detDoneCleanup_normalizedstat", !simple)) { + psError(PS_ERR_UNKNOWN, false, "failed to print array"); + psFree(output); + return false; + } + + psFree(output); + + return true; +} + Index: /branches/eam_branch_20080719/ippTools/src/dettool_processedexp.c =================================================================== --- /branches/eam_branch_20080719/ippTools/src/dettool_processedexp.c (revision 18642) +++ /branches/eam_branch_20080719/ippTools/src/dettool_processedexp.c (revision 18643) @@ -260,2 +260,127 @@ } +bool pendingcleanup_processedexpMode(pxConfig *config) +{ + PS_ASSERT_PTR_NON_NULL(config, NULL); + + PXOPT_LOOKUP_S64(chip_id, config->args, "-chip_id", false, false); + PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false); + PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false); + + psMetadata *where = psMetadataAlloc(); + if (chip_id) { + PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "=="); + } + PXOPT_COPY_STR(config->args, where, "-label", "label", "=="); + + psString query = pxDataGet("dettool_pendingcleanup_processedexp.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("dettool", PS_LOG_INFO, "no rows found"); + psFree(output); + return true; + } + + // negative simple so the default is true + if (!ippdbPrintMetadatas(stdout, output, "detPendingCleanup_processedexp", !simple)) { + psError(PS_ERR_UNKNOWN, false, "failed to print array"); + psFree(output); + return false; + } + + psFree(output); + + return true; +} + + +bool donecleanup_processedexpMode(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_COPY_STR(config->args, where, "-label", "label", "=="); + + psString query = pxDataGet("dettool_donecleanup_processedexp.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("dettool", PS_LOG_INFO, "no rows found"); + psFree(output); + return true; + } + + // negative simple so the default is true + if (!ippdbPrintMetadatas(stdout, output, "detDoneCleanup_processedexp", !simple)) { + psError(PS_ERR_UNKNOWN, false, "failed to print array"); + psFree(output); + return false; + } + + psFree(output); + + return true; +} + Index: /branches/eam_branch_20080719/ippTools/src/dettool_processedimfile.c =================================================================== --- /branches/eam_branch_20080719/ippTools/src/dettool_processedimfile.c (revision 18642) +++ /branches/eam_branch_20080719/ippTools/src/dettool_processedimfile.c (revision 18643) @@ -293,2 +293,128 @@ return true; } + +bool pendingcleanup_processedimfileMode(pxConfig *config) +{ + PS_ASSERT_PTR_NON_NULL(config, NULL); + + PXOPT_LOOKUP_S64(chip_id, config->args, "-chip_id", false, false); + PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false); + PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false); + + psMetadata *where = psMetadataAlloc(); + if (chip_id) { + PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "=="); + } + PXOPT_COPY_STR(config->args, where, "-label", "label", "=="); + + psString query = pxDataGet("dettool_pendingcleanup_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, 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("dettool", PS_LOG_INFO, "no rows found"); + psFree(output); + return true; + } + + // negative simple so the default is true + if (!ippdbPrintMetadatas(stdout, output, "detPendingCleanup_processedimfile", !simple)) { + psError(PS_ERR_UNKNOWN, false, "failed to print array"); + psFree(output); + return false; + } + + psFree(output); + + return true; +} + + +bool donecleanup_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); + + psMetadata *where = psMetadataAlloc(); + PXOPT_COPY_STR(config->args, where, "-label", "label", "=="); + + psString query = pxDataGet("dettool_donecleanup_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, 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("dettool", PS_LOG_INFO, "no rows found"); + psFree(output); + return true; + } + + // negative simple so the default is true + if (!ippdbPrintMetadatas(stdout, output, "detDoneCleanup_processedimfile", !simple)) { + psError(PS_ERR_UNKNOWN, false, "failed to print array"); + psFree(output); + return false; + } + + psFree(output); + + return true; +} + Index: /branches/eam_branch_20080719/ippTools/src/dettool_residexp.c =================================================================== --- /branches/eam_branch_20080719/ippTools/src/dettool_residexp.c (revision 18642) +++ /branches/eam_branch_20080719/ippTools/src/dettool_residexp.c (revision 18643) @@ -343,2 +343,128 @@ return true; } + +bool pendingcleanup_residexpMode(pxConfig *config) +{ + PS_ASSERT_PTR_NON_NULL(config, NULL); + + PXOPT_LOOKUP_S64(chip_id, config->args, "-chip_id", false, false); + PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false); + PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false); + + psMetadata *where = psMetadataAlloc(); + if (chip_id) { + PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "=="); + } + PXOPT_COPY_STR(config->args, where, "-label", "label", "=="); + + psString query = pxDataGet("dettool_pendingcleanup_residexp.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("dettool", PS_LOG_INFO, "no rows found"); + psFree(output); + return true; + } + + // negative simple so the default is true + if (!ippdbPrintMetadatas(stdout, output, "detPendingCleanup_residexp", !simple)) { + psError(PS_ERR_UNKNOWN, false, "failed to print array"); + psFree(output); + return false; + } + + psFree(output); + + return true; +} + + +bool donecleanup_residexpMode(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_COPY_STR(config->args, where, "-label", "label", "=="); + + psString query = pxDataGet("dettool_donecleanup_residexp.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("dettool", PS_LOG_INFO, "no rows found"); + psFree(output); + return true; + } + + // negative simple so the default is true + if (!ippdbPrintMetadatas(stdout, output, "detDoneCleanup_residexp", !simple)) { + psError(PS_ERR_UNKNOWN, false, "failed to print array"); + psFree(output); + return false; + } + + psFree(output); + + return true; +} + Index: /branches/eam_branch_20080719/ippTools/src/dettool_residimfile.c =================================================================== --- /branches/eam_branch_20080719/ippTools/src/dettool_residimfile.c (revision 18642) +++ /branches/eam_branch_20080719/ippTools/src/dettool_residimfile.c (revision 18643) @@ -258,2 +258,128 @@ return true; } + +bool pendingcleanup_residimfileMode(pxConfig *config) +{ + PS_ASSERT_PTR_NON_NULL(config, NULL); + + PXOPT_LOOKUP_S64(chip_id, config->args, "-chip_id", false, false); + PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false); + PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false); + + psMetadata *where = psMetadataAlloc(); + if (chip_id) { + PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "=="); + } + PXOPT_COPY_STR(config->args, where, "-label", "label", "=="); + + psString query = pxDataGet("dettool_pendingcleanup_residimfile.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("dettool", PS_LOG_INFO, "no rows found"); + psFree(output); + return true; + } + + // negative simple so the default is true + if (!ippdbPrintMetadatas(stdout, output, "detPendingCleanup_residimfile", !simple)) { + psError(PS_ERR_UNKNOWN, false, "failed to print array"); + psFree(output); + return false; + } + + psFree(output); + + return true; +} + + +bool donecleanup_residimfileMode(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_COPY_STR(config->args, where, "-label", "label", "=="); + + psString query = pxDataGet("dettool_donecleanup_residimfile.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("dettool", PS_LOG_INFO, "no rows found"); + psFree(output); + return true; + } + + // negative simple so the default is true + if (!ippdbPrintMetadatas(stdout, output, "detDoneCleanup_residimfile", !simple)) { + psError(PS_ERR_UNKNOWN, false, "failed to print array"); + psFree(output); + return false; + } + + psFree(output); + + return true; +} + Index: /branches/eam_branch_20080719/ippTools/src/dettool_stack.c =================================================================== --- /branches/eam_branch_20080719/ippTools/src/dettool_stack.c (revision 18642) +++ /branches/eam_branch_20080719/ippTools/src/dettool_stack.c (revision 18643) @@ -314,2 +314,128 @@ return true; } + +bool pendingcleanup_stackedMode(pxConfig *config) +{ + PS_ASSERT_PTR_NON_NULL(config, NULL); + + PXOPT_LOOKUP_S64(chip_id, config->args, "-chip_id", false, false); + PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false); + PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false); + + psMetadata *where = psMetadataAlloc(); + if (chip_id) { + PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "=="); + } + PXOPT_COPY_STR(config->args, where, "-label", "label", "=="); + + psString query = pxDataGet("dettool_pendingcleanup_stacked.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("dettool", PS_LOG_INFO, "no rows found"); + psFree(output); + return true; + } + + // negative simple so the default is true + if (!ippdbPrintMetadatas(stdout, output, "detPendingCleanup_stacked", !simple)) { + psError(PS_ERR_UNKNOWN, false, "failed to print array"); + psFree(output); + return false; + } + + psFree(output); + + return true; +} + + +bool donecleanup_stackedMode(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_COPY_STR(config->args, where, "-label", "label", "=="); + + psString query = pxDataGet("dettool_donecleanup_stacked.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("dettool", PS_LOG_INFO, "no rows found"); + psFree(output); + return true; + } + + // negative simple so the default is true + if (!ippdbPrintMetadatas(stdout, output, "detDoneCleanup_stacked", !simple)) { + psError(PS_ERR_UNKNOWN, false, "failed to print array"); + psFree(output); + return false; + } + + psFree(output); + + return true; +} + Index: /branches/eam_branch_20080719/ippTools/src/difftool.c =================================================================== --- /branches/eam_branch_20080719/ippTools/src/difftool.c (revision 18642) +++ /branches/eam_branch_20080719/ippTools/src/difftool.c (revision 18643) @@ -41,4 +41,7 @@ static bool definepoprunMode(pxConfig *config); static bool definebyqueryMode(pxConfig *config); +static bool pendingcleanuprunMode(pxConfig *config); +static bool pendingcleanupskyfileMode(pxConfig *config); +static bool donecleanupMode(pxConfig *config); static bool setdiffRunState(pxConfig *config, psS64 diff_id, const char *state); @@ -62,14 +65,17 @@ switch (config->mode) { - MODECASE(DIFFTOOL_MODE_DEFINERUN, definerunMode); - MODECASE(DIFFTOOL_MODE_UPDATERUN, updaterunMode); - MODECASE(DIFFTOOL_MODE_ADDINPUTSKYFILE, addinputskyfileMode); - MODECASE(DIFFTOOL_MODE_INPUTSKYFILE, inputskyfileMode); - MODECASE(DIFFTOOL_MODE_TODIFFSKYFILE, todiffskyfileMode); - MODECASE(DIFFTOOL_MODE_ADDDIFFSKYFILE, adddiffskyfileMode); - MODECASE(DIFFTOOL_MODE_DIFFSKYFILE, diffskyfileMode); - MODECASE(DIFFTOOL_MODE_REVERTDIFFSKYFILE, revertdiffskyfileMode); - MODECASE(DIFFTOOL_MODE_DEFINEPOPRUN, definepoprunMode); - MODECASE(DIFFTOOL_MODE_DEFINEBYQUERY, definebyqueryMode); + MODECASE(DIFFTOOL_MODE_DEFINERUN, definerunMode); + MODECASE(DIFFTOOL_MODE_UPDATERUN, updaterunMode); + MODECASE(DIFFTOOL_MODE_ADDINPUTSKYFILE, addinputskyfileMode); + MODECASE(DIFFTOOL_MODE_INPUTSKYFILE, inputskyfileMode); + MODECASE(DIFFTOOL_MODE_TODIFFSKYFILE, todiffskyfileMode); + MODECASE(DIFFTOOL_MODE_ADDDIFFSKYFILE, adddiffskyfileMode); + MODECASE(DIFFTOOL_MODE_DIFFSKYFILE, diffskyfileMode); + MODECASE(DIFFTOOL_MODE_REVERTDIFFSKYFILE, revertdiffskyfileMode); + MODECASE(DIFFTOOL_MODE_DEFINEPOPRUN, definepoprunMode); + MODECASE(DIFFTOOL_MODE_DEFINEBYQUERY, definebyqueryMode); + MODECASE(DIFFTOOL_MODE_PENDINGCLEANUPRUN, pendingcleanuprunMode); + MODECASE(DIFFTOOL_MODE_PENDINGCLEANUPSKYFILE, pendingcleanupskyfileMode); + MODECASE(DIFFTOOL_MODE_DONECLEANUP, donecleanupMode); default: psAbort("invalid option (this should not happen)"); @@ -923,2 +929,188 @@ return true; } + +static bool pendingcleanuprunMode(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_COPY_STR(config->args, where, "-label", "label", "=="); + + psString query = pxDataGet("difftool_pendingcleanuprun.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("difftool", PS_LOG_INFO, "no rows found"); + psFree(output); + return true; + } + + // negative simple so the default is true + if (!ippdbPrintMetadatas(stdout, output, "diffPendingCleanupRun", !simple)) { + psError(PS_ERR_UNKNOWN, false, "failed to print array"); + psFree(output); + return false; + } + + psFree(output); + + return true; +} + + +static bool pendingcleanupskyfileMode(pxConfig *config) +{ + PS_ASSERT_PTR_NON_NULL(config, NULL); + + PXOPT_LOOKUP_S64(diff_id, config->args, "-diff_id", false, false); + PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false); + PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false); + + psMetadata *where = psMetadataAlloc(); + if (diff_id) { + PXOPT_COPY_S64(config->args, where, "-diff_id", "diff_id", "=="); + } + PXOPT_COPY_STR(config->args, where, "-label", "label", "=="); + + psString query = pxDataGet("difftool_pendingcleanupskyfile.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("difftool", PS_LOG_INFO, "no rows found"); + psFree(output); + return true; + } + + // negative simple so the default is true + if (!ippdbPrintMetadatas(stdout, output, "diffPendingCleanupSkyfile", !simple)) { + psError(PS_ERR_UNKNOWN, false, "failed to print array"); + psFree(output); + return false; + } + + psFree(output); + + return true; +} + + +static bool donecleanupMode(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_COPY_STR(config->args, where, "-label", "label", "=="); + + psString query = pxDataGet("difftool_donecleanup.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("difftool", PS_LOG_INFO, "no rows found"); + psFree(output); + return true; + } + + // negative simple so the default is true + if (!ippdbPrintMetadatas(stdout, output, "diffDoneCleanup", !simple)) { + psError(PS_ERR_UNKNOWN, false, "failed to print array"); + psFree(output); + return false; + } + + psFree(output); + + return true; +} Index: /branches/eam_branch_20080719/ippTools/src/difftool.h =================================================================== --- /branches/eam_branch_20080719/ippTools/src/difftool.h (revision 18642) +++ /branches/eam_branch_20080719/ippTools/src/difftool.h (revision 18643) @@ -35,4 +35,7 @@ DIFFTOOL_MODE_DEFINEPOPRUN, DIFFTOOL_MODE_DEFINEBYQUERY, + DIFFTOOL_MODE_PENDINGCLEANUPRUN, + DIFFTOOL_MODE_PENDINGCLEANUPSKYFILE, + DIFFTOOL_MODE_DONECLEANUP, } difftoolMode; Index: anches/eam_branch_20080719/ippTools/src/guidetool.c =================================================================== --- /branches/eam_branch_20080719/ippTools/src/guidetool.c (revision 18642) +++ (revision ) @@ -1,221 +1,0 @@ -/* - * guidetool.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 "pxtools.h" -#include "guidetool.h" - -static bool pendingMode(pxConfig *config); -static bool defineMode(pxConfig *config); -static guidePendingExpRow *rawScienceToguidePendingExp(pxConfig *config, rawScienceExpRow *exp); - -int main(int argc, char **argv) -{ - pxConfig *config = guidetoolConfig(NULL, argc, argv); - - switch (config->mode) { - case PX_MODE_PENDING: - if (!pendingMode(config)) { - goto FAIL; - } - break; - case PX_MODE_DEFINE: - if (!defineMode(config)) { - goto FAIL; - } - break; - default: - psAbort("invalid option (this should not happen)"); - } - - exit(EXIT_SUCCESS); - -FAIL: - psFree(config); - exit(EXIT_FAILURE); -} - -static bool pendingMode(pxConfig *config) -{ - PS_ASSERT_PTR_NON_NULL(config, false); - - psMetadata *where = psMetadataAlloc(); - PXOPT_COPY_STR(config->args, where, "-exp_id", "exp_id", "=="); - PXOPT_COPY_STR(config->args, where, "-inst", "camera", "=="); - PXOPT_COPY_STR(config->args, where, "-telescope", "telescope", "=="); - PXOPT_COPY_STR(config->args, where, "-exp_type", "exp_type", "=="); - PXOPT_COPY_S32(config->args, where, "-imfiles", "imfiles", "=="); - PXOPT_COPY_STR(config->args, where, "-filter", "filter", "=="); - PXOPT_COPY_STR(config->args, where, "-recip", "recipe", "=="); - PXOPT_COPY_S32(config->args, where, "-guide_version", "guide_version", "=="); - if (!psListLength(where->list)) { - psFree (where); - where = NULL; - } - - // return all guidePendingExp rows unless there CLI search options - psArray *guidePendingExp = guidePendingExpSelectRowObjects(config->dbh, where, 0); - psFree (where); - - if (!guidePendingExp) { - psError(PS_ERR_UNKNOWN, false, "no guidePendingExp found"); - return false; - } - psMetadata *output = psMetadataAlloc(); - - for (long i = 0; i < psArrayLength(guidePendingExp); i++) { - psMetadata *md = guidePendingExpMetadataFromObject(guidePendingExp->data[i]); - psMetadataAddMetadata(output, PS_LIST_TAIL, "guidePendingExp", - PS_META_DUPLICATE_OK, NULL, md); - psFree(md); - } - - psString str = psMetadataConfigFormat(output); - psFree(output); - - fprintf(stdout, "%s\n", str); - psFree(str); - - return true; -} - -static bool defineMode(pxConfig *config) -{ - PS_ASSERT_PTR_NON_NULL(config, false); - - psMetadata *where = psMetadataAlloc(); - PXOPT_COPY_STR(config->args, where, "-exp_id", "exp_id", "=="); - PXOPT_COPY_STR(config->args, where, "-inst", "camera", "=="); - PXOPT_COPY_STR(config->args, where, "-telescope", "telescope", "=="); - PXOPT_COPY_STR(config->args, where, "-exp_type", "exp_type", "=="); - PXOPT_COPY_S32(config->args, where, "-imfiles", "imfiles", "=="); - PXOPT_COPY_STR(config->args, where, "-filter", "filter", "=="); - if (!psListLength(where->list)) { - psFree (where); - where = NULL; - } - - // return all rawScienceExp rows unless there CLI search options - psArray *rawScienceExps = rawScienceExpSelectRowObjects(config->dbh, where, 0); - psFree (where); - - if (!rawScienceExps) { - psError(PS_ERR_UNKNOWN, false, "no rawScienceExp rows found"); - return true; - } - - // insert the rawScienceExps into guidePendingExp - // XXX for the being we're going to skip checking for duplicate entries - // XXX this will have to implimented unless duplicate key insertion - // XXX support is implimented in psDB - for (long i = 0; i < psArrayLength(rawScienceExps); i++) { - guidePendingExpRow * new = rawScienceToguidePendingExp( - config, rawScienceExps->data[i]); - if (!guidePendingExpInsertObject(config->dbh, new)) { - psError(PS_ERR_UNKNOWN, false, "dbh access failed"); - return false; - } - psFree(new); - } - - return true; -} - -static guidePendingExpRow *rawScienceToguidePendingExp(pxConfig *config, rawScienceExpRow *exp) -{ - PS_ASSERT_PTR_NON_NULL(config, NULL); - PS_ASSERT_PTR_NON_NULL(exp, NULL); - - bool status = false; - psString filter = psMetadataLookupStr(&status, config->args, "-filter"); - if (!status) { - psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -filter"); - return false; - } - if (!filter) { - psError(PS_ERR_UNKNOWN, true, "-filter is required"); - return false; - } - psF32 airmass = psMetadataLookupF32(&status, config->args, "-airmass"); - if (!status) { - psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -airmass"); - return false; - } - if (!airmass) { - psError(PS_ERR_UNKNOWN, true, "-airmass is required"); - return false; - } - psF64 ra = psMetadataLookupF64(&status, config->args, "-ra"); - if (!status) { - psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ra"); - return false; - } - if (!ra) { - psError(PS_ERR_UNKNOWN, true, "-airmass is required"); - return false; - } - psF64 dec = psMetadataLookupF64(&status, config->args, "-dec"); - if (!status) { - psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -dec"); - return false; - } - if (!dec) { - psError(PS_ERR_UNKNOWN, true, "-dec is required"); - return false; - } - psF32 exp_time = psMetadataLookupF32(&status, config->args, "-exp_time"); - if (!status) { - psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_time"); - return false; - } - if (!exp_time) { - psError(PS_ERR_UNKNOWN, true, "-exp_time is required"); - return false; - } - psF64 background = psMetadataLookupF64(&status, config->args, "-background"); - if (!status) { - psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -background"); - return false; - } - if (!exp_time) { - psError(PS_ERR_UNKNOWN, true, "-background is required"); - return false; - } - - return guidePendingExpRowAlloc( - exp->exp_id, - exp->camera, - exp->telescope, - exp->exp_type, - exp->imfiles, - filter, - airmass, - ra, - dec, - exp_time, - background, - "my recipe", - 0xff // XXX calc version number - ); -} Index: anches/eam_branch_20080719/ippTools/src/guidetool.h =================================================================== --- /branches/eam_branch_20080719/ippTools/src/guidetool.h (revision 18642) +++ (revision ) @@ -1,27 +1,0 @@ -/* - * guidetool.h - * - * 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. - */ - -#ifndef GUIDETOOL_H -#define GUIDETOOL_H 1 - -#include "pxtools.h" - -pxConfig *guidetoolConfig(pxConfig *config, int argc, char **argv); - -#endif // GUIDETOOL_H Index: anches/eam_branch_20080719/ippTools/src/guidetoolConfig.c =================================================================== --- /branches/eam_branch_20080719/ippTools/src/guidetoolConfig.c (revision 18642) +++ (revision ) @@ -1,140 +1,0 @@ -/* - * guidetoolConfig.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 "pxtools.h" - -// this function can not fail -- exits on error - -pxConfig *guidetoolConfig(pxConfig *config, int argc, char **argv) { - if (!config) { - config = pxConfigAlloc(); - } - - pmConfigReadParamsSet(false); - - // setup site config - config->modules = pmConfigRead(&argc, argv); - if (!config->modules) { - psError(PS_ERR_UNKNOWN, false, "Can't find site configuration"); - exit(EXIT_FAILURE); - } - - // CLI options - // modes - psMetadata *args = psMetadataAlloc(); - psMetadataAddStr(args , PS_LIST_TAIL, "-pending", 0, - "examine pending image table, write ppImage output", NULL); - psMetadataAddStr(args , PS_LIST_TAIL, "-define", 0, - "update pending image table", NULL); - - // -pending search - psMetadata *pendingArgs = psMetadataAlloc(); - psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-exp_id", 0, "define exposure ID", NULL); - psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-inst", 0, "define camera of interest", NULL); - psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-telescope", 0, "define telescope of interest", NULL); - psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-exp_type", 0, "define exposure type", NULL); - psMetadataAddS32(pendingArgs, PS_LIST_TAIL, "-imfiles", 0, "define number of imfiles", 0); - psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-filter", 0, "define filter of interest", NULL); - psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-recipe", 0, "define recipe of interest", NULL); - psMetadataAddS32(pendingArgs, PS_LIST_TAIL, "-guide_version", 0, "define guide_version of interest", 0); - - // -define inputs - psMetadata *defineArgs = psMetadataAlloc(); - psMetadataAddStr(defineArgs, PS_LIST_TAIL, "-exp_id", 0, "define class", NULL); - psMetadataAddStr(defineArgs, PS_LIST_TAIL, "-inst", 0, "define camera of interest", NULL); - psMetadataAddStr(defineArgs, PS_LIST_TAIL, "-telescope", 0, "define camera of interest", NULL); - psMetadataAddStr(defineArgs, PS_LIST_TAIL, "-exp_type", 0, "define class", NULL); - psMetadataAddS32(defineArgs, PS_LIST_TAIL, "-imfiles", 0, "define number of imfiles", 0); - psMetadataAddStr(defineArgs, PS_LIST_TAIL, "-filter", 0, "define filter of interest", NULL); - // these two are inputs NOT search parameters - psMetadataAddStr(defineArgs, PS_LIST_TAIL, "-recipe", 0, "define recipe of interest", NULL); - psMetadataAddS32(defineArgs, PS_LIST_TAIL, "-guide_version", 0, "define guide_version of interest", 0); - - // find which mode we're running under - int N = 0; - config->mode = PX_MODE_NONE; - if ((N = psArgumentGet (argc, argv, "-pending"))) { - psArgumentRemove (N, &argc, argv); - if (config->mode) { - psError(PS_ERR_UNKNOWN, true, "only one mode selection is allowed"); - } - config->mode = PX_MODE_PENDING; - } - if ((N = psArgumentGet (argc, argv, "-define"))) { - psArgumentRemove (N, &argc, argv); - if (config->mode) { - psError(PS_ERR_UNKNOWN, true, "only one mode selection is allowed"); - } - config->mode = PX_MODE_DEFINE; - } - - // parse CLI for these options - switch (config->mode) { - case PX_MODE_PENDING: - config->args = psMemIncrRefCounter(pendingArgs); - break; - case PX_MODE_DEFINE: - config->args = psMemIncrRefCounter(defineArgs); - break; - default: - config->args = psMemIncrRefCounter(args); - } - - bool argErr = false; - if (config->mode == PX_MODE_NONE) { - argErr = true; - fprintf (stderr, "mode argument is required\n"); - } else if (! psArgumentParse(config->args, &argc, argv) || argc != 1) { - argErr = true; - fprintf (stderr, "error parsing arguments\n"); - } - - if (argErr) { - printf("\nPan-STARRS Guide Star Tool\n"); - printf("Usage: %s []\n\n", argv[0]); - printf(" : -pending | -define\n\n"); - fprintf (stdout, "-pending "); - psArgumentHelp(pendingArgs); - fprintf (stdout, "-define "); - psArgumentHelp(defineArgs); - psFree(args); - psFree(pendingArgs); - psFree(defineArgs); - exit(EXIT_FAILURE); - } - - psFree(args); - psFree(pendingArgs); - psFree(defineArgs); - - // define Database handle, if used - config->dbh = psMemIncrRefCounter(pmConfigDB(config->modules)); - if (!config->dbh) { - psError(PS_ERR_UNKNOWN, false, "Can't configure database"); - exit(EXIT_FAILURE); - } - - return config; -} Index: /branches/eam_branch_20080719/ippTools/src/stacktool.c =================================================================== --- /branches/eam_branch_20080719/ippTools/src/stacktool.c (revision 18642) +++ /branches/eam_branch_20080719/ippTools/src/stacktool.c (revision 18643) @@ -40,4 +40,7 @@ static bool sumskyfileMode(pxConfig *config); static bool revertsumskyfileMode(pxConfig *config); +static bool pendingcleanuprunMode(pxConfig *config); +static bool pendingcleanupskyfileMode(pxConfig *config); +static bool donecleanupMode(pxConfig *config); static bool setstackRunState(pxConfig *config, psS64 stack_id, const char *state); @@ -61,13 +64,16 @@ switch (config->mode) { - MODECASE(STACKTOOL_MODE_DEFINEBYQUERY, definebyqueryMode); - MODECASE(STACKTOOL_MODE_DEFINERUN, definerunMode); - MODECASE(STACKTOOL_MODE_UPDATERUN, updaterunMode); - MODECASE(STACKTOOL_MODE_ADDINPUTSKYFILE, addinputskyfileMode); - MODECASE(STACKTOOL_MODE_INPUTSKYFILE, inputskyfileMode); - MODECASE(STACKTOOL_MODE_TOSUM, tosumMode); - MODECASE(STACKTOOL_MODE_ADDSUMSKYFILE, addsumskyfileMode); - MODECASE(STACKTOOL_MODE_SUMSKYFILE, sumskyfileMode); - MODECASE(STACKTOOL_MODE_REVERTSUMSKYFILE, revertsumskyfileMode); + MODECASE(STACKTOOL_MODE_DEFINEBYQUERY, definebyqueryMode); + MODECASE(STACKTOOL_MODE_DEFINERUN, definerunMode); + MODECASE(STACKTOOL_MODE_UPDATERUN, updaterunMode); + MODECASE(STACKTOOL_MODE_ADDINPUTSKYFILE, addinputskyfileMode); + MODECASE(STACKTOOL_MODE_INPUTSKYFILE, inputskyfileMode); + MODECASE(STACKTOOL_MODE_TOSUM, tosumMode); + MODECASE(STACKTOOL_MODE_ADDSUMSKYFILE, addsumskyfileMode); + MODECASE(STACKTOOL_MODE_SUMSKYFILE, sumskyfileMode); + MODECASE(STACKTOOL_MODE_REVERTSUMSKYFILE, revertsumskyfileMode); + MODECASE(STACKTOOL_MODE_PENDINGCLEANUPRUN, pendingcleanuprunMode); + MODECASE(STACKTOOL_MODE_PENDINGCLEANUPSKYFILE, pendingcleanupskyfileMode); + MODECASE(STACKTOOL_MODE_DONECLEANUP, donecleanupMode); default: psAbort("invalid option (this should not happen)"); @@ -802,2 +808,187 @@ return true; } + +static bool pendingcleanuprunMode(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_COPY_STR(config->args, where, "-label", "label", "=="); + + psString query = pxDataGet("stacktool_pendingcleanuprun.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("stacktool", PS_LOG_INFO, "no rows found"); + psFree(output); + return true; + } + + // negative simple so the default is true + if (!ippdbPrintMetadatas(stdout, output, "stackPendingCleanupRun", !simple)) { + psError(PS_ERR_UNKNOWN, false, "failed to print array"); + psFree(output); + return false; + } + + psFree(output); + + return true; +} + +static bool pendingcleanupskyfileMode(pxConfig *config) +{ + PS_ASSERT_PTR_NON_NULL(config, NULL); + + PXOPT_LOOKUP_S64(stack_id, config->args, "-stack_id", false, false); + PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false); + PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false); + + psMetadata *where = psMetadataAlloc(); + if (stack_id) { + PXOPT_COPY_S64(config->args, where, "-stack_id", "stack_id", "=="); + } + PXOPT_COPY_STR(config->args, where, "-label", "label", "=="); + + psString query = pxDataGet("stacktool_pendingcleanupskyfile.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("stacktool", PS_LOG_INFO, "no rows found"); + psFree(output); + return true; + } + + // negative simple so the default is true + if (!ippdbPrintMetadatas(stdout, output, "stackPendingCleanupSkyfile", !simple)) { + psError(PS_ERR_UNKNOWN, false, "failed to print array"); + psFree(output); + return false; + } + + psFree(output); + + return true; +} + + +static bool donecleanupMode(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_COPY_STR(config->args, where, "-label", "label", "=="); + + psString query = pxDataGet("stacktool_donecleanup.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("stacktool", PS_LOG_INFO, "no rows found"); + psFree(output); + return true; + } + + // negative simple so the default is true + if (!ippdbPrintMetadatas(stdout, output, "stackDoneCleanup", !simple)) { + psError(PS_ERR_UNKNOWN, false, "failed to print array"); + psFree(output); + return false; + } + + psFree(output); + + return true; +} Index: /branches/eam_branch_20080719/ippTools/src/stacktool.h =================================================================== --- /branches/eam_branch_20080719/ippTools/src/stacktool.h (revision 18642) +++ /branches/eam_branch_20080719/ippTools/src/stacktool.h (revision 18643) @@ -34,4 +34,7 @@ STACKTOOL_MODE_SUMSKYFILE, STACKTOOL_MODE_REVERTSUMSKYFILE, + STACKTOOL_MODE_PENDINGCLEANUPRUN, + STACKTOOL_MODE_PENDINGCLEANUPSKYFILE, + STACKTOOL_MODE_DONECLEANUP, } stacktoolMode;