Index: trunk/ippTools/src/labeltool.c =================================================================== --- trunk/ippTools/src/labeltool.c (revision 28074) +++ trunk/ippTools/src/labeltool.c (revision 28074) @@ -0,0 +1,392 @@ +/* + * magictool.c + * + * Copyright (C) 2006-2007 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 HAVB_CONFIG_H +#include +#endif + +#include +#include +#include +#include +#include + +#include "pxtools.h" +#include "labeltool.h" + +static bool definelabelMode(pxConfig *config); +static bool updatelabelMode(pxConfig *config); +static bool deletelabelMode(pxConfig *config); +static bool listlabelMode(pxConfig *config); + +# define MODECASE(caseName, func) \ + case caseName: \ + if (!func(config)) { \ + goto FAIL; \ + } \ + break; + +int main(int argc, char **argv) +{ + psLibInit(NULL); + + pxConfig *config = labeltoolConfig(NULL, argc, argv); + if (!config) { + psError(PXTOOLS_ERR_CONFIG, false, "failed to configure"); + goto FAIL; + } + + switch (config->mode) { + MODECASE(LABELTOOL_MODE_DEFINELABEL, definelabelMode); + MODECASE(LABELTOOL_MODE_UPDATELABEL, updatelabelMode); + MODECASE(LABELTOOL_MODE_DELETELABEL, deletelabelMode); + MODECASE(LABELTOOL_MODE_LISTLABEL, listlabelMode); + 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 definelabelMode(pxConfig *config) +{ +#ifdef notyet + PS_ASSERT_PTR_NON_NULL(config, false); + + // required + PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false); + PXOPT_LOOKUP_S64(exp_id, config->args, "-exp_id", true, false); + PXOPT_LOOKUP_S64(diff_id, config->args, "-diff_id", false, false); + + // optional + PXOPT_LOOKUP_BOOL(inverse, config->args, "-inverse", false); + PXOPT_LOOKUP_STR(label, config->args, "-label", false, false); + PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false); + PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false); + PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false); + + magicRunRow *run = magicRunRowAlloc( + 0, // ID + exp_id, + diff_id ? diff_id : PS_MAX_S64, + inverse, + "reg", // state + workdir, + "dirty", // workdir_state + label, + NULL, // data_group + dvodb, + registered, + 0, // fault + NULL + ); + + if (!run) { + psError(PS_ERR_UNKNOWN, false, "failed to alloc magicRun object"); + return false; + } + if (!magicRunInsertObject(config->dbh, run)) { + psError(PS_ERR_UNKNOWN, false, "database error"); + psFree(run); + return false; + } + + // get the assigned magic_id + psS64 magic_id = psDBLastInsertID(config->dbh); + run->magic_id = magic_id; + + if (!magicRunPrintObject(stdout, run, !simple)) { + psError(PS_ERR_UNKNOWN, false, "failed to print object"); + psFree(run); + return false; + } + + psFree(run); + + return magic_id; +#else + + return false; +#endif +} + + +static bool updatelabelMode(pxConfig *config) +{ + return false; +#ifdef notyet + PS_ASSERT_PTR_NON_NULL(config, false); + + psMetadata *where = psMetadataAlloc(); + PXOPT_COPY_S64(config->args, where, "-magic_id", "magic_id", "=="); + PXOPT_COPY_S64(config->args, where, "-diff_id", "diff_id", "=="); + PXOPT_COPY_STR(config->args, where, "-node", "node", "=="); + + PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false); + PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false); + + // find all rawImfiles matching the default query + psString query = pxDataGet("magictool_inputskyfile.sql"); + if (!query) { + psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement"); + return false; + } + + if (psListLength(where->list)) { + psString whereClause = psDBGenerateWhereConditionSQL(where, "magicInputSkyfile"); + 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) { + psErrorCode err = psErrorCodeLast(); + switch (err) { + case PS_ERR_DB_CLIENT: + psError(PXTOOLS_ERR_SYS, false, "database error"); + case PS_ERR_DB_SERVER: + psError(PXTOOLS_ERR_PROG, false, "database error"); + default: + psError(PXTOOLS_ERR_PROG, false, "unknown error"); + } + + return false; + } + if (!psArrayLength(output)) { + psTrace("magictool", PS_LOG_INFO, "no rows found"); + psFree(output); + return true; + } + + if (psArrayLength(output)) { + // negative simple so the default is true + if (!ippdbPrintMetadatas(stdout, output, "magicInputSkyfile", !simple)) { + psError(PS_ERR_UNKNOWN, false, "failed to print array"); + psFree(output); + return false; + } + } + + psFree(output); + + return true; +#endif +} + +static bool deletelabelMode(pxConfig *config) +{ + return false; +#ifdef notdef + PS_ASSERT_PTR_NON_NULL(config, false); + + psMetadata *where = psMetadataAlloc(); + PXOPT_COPY_S64(config->args, where, "-magic_id", "magicRun.magic_id", "=="); + pxAddLabelSearchArgs (config, where, "-label", "magicRun.label", "=="); + + PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false); + PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false); + + // look for "inputs" that need to processed + psString query = pxDataGet("magictool_totree.sql"); + if (!query) { + psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement"); + return false; + } + + if (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) { + psErrorCode err = psErrorCodeLast(); + switch (err) { + case PS_ERR_DB_CLIENT: + psError(PXTOOLS_ERR_SYS, false, "database error"); + case PS_ERR_DB_SERVER: + psError(PXTOOLS_ERR_PROG, false, "database error"); + default: + psError(PXTOOLS_ERR_PROG, false, "unknown error"); + } + + return false; + } + if (!psArrayLength(output)) { + psTrace("magictool", PS_LOG_INFO, "no rows found"); + psFree(output); + return true; + } + + if (psArrayLength(output)) { + // negative simple so the default is true + if (!ippdbPrintMetadatas(stdout, output, "totree", !simple)) { + psError(PS_ERR_UNKNOWN, false, "failed to print array"); + psFree(output); + return false; + } + } + + psFree(output); + + return true; +#endif +} + +static bool listlabelMode(pxConfig *config) +{ + PS_ASSERT_PTR_NON_NULL(config, false); + PS_ASSERT_PTR_NON_NULL(config, false); + + psMetadata *where = psMetadataAlloc(); + PXOPT_COPY_STR(config->args, where, "-label", "label", "LIKE"); + + PXOPT_LOOKUP_BOOL(active, config->args, "-active", false); + PXOPT_LOOKUP_BOOL(inactive, config->args, "-inactive", false); + if (active && inactive) { + psError(PS_ERR_UNKNOWN, true, "only one of -active and inactive may be supplied"); + return false; + } + PXOPT_LOOKUP_BOOL(lowtohigh, config->args, "-lowtohigh", false); + PXOPT_LOOKUP_BOOL(hightolow, config->args, "-hightolow", false); + if (lowtohigh && hightolow) { + psError(PS_ERR_UNKNOWN, true, "only one of -lowtohigh and -hightolow may be supplied"); + return false; + } + + PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false); + PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false); + + // find all rawImfiles matching the default query + psString query = psStringCopy("SELECT * FROM Label\n"); + + char *sep = " WHERE "; + if (psListLength(where->list)) { + psString whereClause = psDBGenerateWhereConditionSQL(where, NULL); + psStringAppend(&query, " WHERE %s", whereClause); + psFree(whereClause); + sep = " AND "; + } + psFree(where); + + if (active) { + psStringAppend(&query, "%s active\n", sep); + sep = " AND "; + } else if (inactive) { + psStringAppend(&query, "%s NOT active\n", sep); + sep = " AND "; + } + + if (lowtohigh || hightolow) { + char *order = lowtohigh ? "" : "DESC"; + psStringAppend(&query, "\nORDER BY priority %s\n", order); + } + + // 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) { + psErrorCode err = psErrorCodeLast(); + switch (err) { + case PS_ERR_DB_CLIENT: + psError(PXTOOLS_ERR_SYS, false, "database error"); + case PS_ERR_DB_SERVER: + psError(PXTOOLS_ERR_PROG, false, "database error"); + default: + psError(PXTOOLS_ERR_PROG, false, "unknown error"); + } + + return false; + } + if (!psArrayLength(output)) { + psTrace("labeltool", PS_LOG_INFO, "no rows found"); + psFree(output); + return true; + } + + if (psArrayLength(output)) { + // negative simple so the default is true + if (!ippdbPrintMetadatas(stdout, output, "Label", !simple)) { + psError(PS_ERR_UNKNOWN, false, "failed to print array"); + psFree(output); + return false; + } + } + + psFree(output); + + return true; +} Index: trunk/ippTools/src/labeltool.h =================================================================== --- trunk/ippTools/src/labeltool.h (revision 28074) +++ trunk/ippTools/src/labeltool.h (revision 28074) @@ -0,0 +1,35 @@ +/* + * labeltool.h + * + * Copyright (C) 2010 IfA + * + * 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 LABELTOOL_H +#define LABELTOOL_H 1 + +#include "pxtools.h" + +typedef enum { + LABELTOOL_MODE_NONE = 0x0, + LABELTOOL_MODE_DEFINELABEL, + LABELTOOL_MODE_UPDATELABEL, + LABELTOOL_MODE_DELETELABEL, + LABELTOOL_MODE_LISTLABEL, +} labeltoolMode; + +pxConfig *labeltoolConfig(pxConfig *config, int argc, char **argv); + +#endif // LABELTOOL_H Index: trunk/ippTools/src/labeltoolConfig.c =================================================================== --- trunk/ippTools/src/labeltoolConfig.c (revision 28074) +++ trunk/ippTools/src/labeltoolConfig.c (revision 28074) @@ -0,0 +1,113 @@ +/* + * labeltoolConfig.c + * + * Copyright (C) 2007 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 "labeltool.h" + +pxConfig *labeltoolConfig(pxConfig *config, int argc, char **argv) +{ + if (!config) { + config = pxConfigAlloc(); + } + + pmConfigReadParamsSet(false); + + // setup site config + config->modules = pmConfigRead(&argc, argv, NULL); + if (!config->modules) { + psError(psErrorCodeLast(), false, "Can't find site configuration"); + psFree(config); + return NULL; + } + + psTime *now = psTimeGetNow(PS_TIME_TAI); + + // -definelabel + psMetadata *definelabelArgs = psMetadataAlloc(); + psMetadataAddStr(definelabelArgs, PS_LIST_TAIL, "-set_label", 0, "define label (required)", NULL); + psMetadataAddS64(definelabelArgs, PS_LIST_TAIL, "-set_priority", 0, "define priority (required)", 0); + psMetadataAddBool(definelabelArgs, PS_LIST_TAIL, "-set_inactive", 0, "set label inactive", false); + psMetadataAddStr(definelabelArgs, PS_LIST_TAIL, "-set_comment", 0, "define label comment", NULL); + + // -updatelabel + psMetadata *updatelabelArgs = psMetadataAlloc(); + psMetadataAddStr(updatelabelArgs, PS_LIST_TAIL, "-label", 0, "search by label (LIKE comparison) (required)", NULL); + psMetadataAddStr(updatelabelArgs, PS_LIST_TAIL, "-set_label", 0, "define label", NULL); + psMetadataAddS64(updatelabelArgs, PS_LIST_TAIL, "-set_priority", 0, "define priority", 0); + psMetadataAddBool(updatelabelArgs, PS_LIST_TAIL, "-set_active", 0, "set label active", false); + psMetadataAddBool(updatelabelArgs, PS_LIST_TAIL, "-set_inactive", 0, "set label inactive", false); + psMetadataAddStr(updatelabelArgs, PS_LIST_TAIL, "-set_comment", 0, "define label comment", NULL); + + // -deletelabel + psMetadata *deletelabelArgs = psMetadataAlloc(); + psMetadataAddStr(deletelabelArgs, PS_LIST_TAIL, "-label", 0, "label to delete (required)", NULL); + + // -listlabel + psMetadata *listlabelArgs = psMetadataAlloc(); + psMetadataAddStr(listlabelArgs, PS_LIST_TAIL, "-label", 0, "search by label (LIKE comparison)", NULL); + psMetadataAddBool(listlabelArgs, PS_LIST_TAIL, "-hightolow", 0, "order by priority high to low", false); + psMetadataAddBool(listlabelArgs, PS_LIST_TAIL, "-lowtohigh", 0, "order by priority low to high", false); + psMetadataAddBool(listlabelArgs, PS_LIST_TAIL, "-active", 0, "list active labels", false); + psMetadataAddBool(listlabelArgs, PS_LIST_TAIL, "-inactive", 0, "list inactive labels", false); + psMetadataAddU64(listlabelArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0); + psMetadataAddBool(listlabelArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false); + + + + psFree(now); + + psMetadata *argSets = psMetadataAlloc(); + psMetadata *modes = psMetadataAlloc(); + + PXOPT_ADD_MODE("-definelabel", "", LABELTOOL_MODE_DEFINELABEL, definelabelArgs); + PXOPT_ADD_MODE("-updatelabel", "", LABELTOOL_MODE_UPDATELABEL, updatelabelArgs); + PXOPT_ADD_MODE("-deletelabel", "", LABELTOOL_MODE_DELETELABEL, deletelabelArgs); + PXOPT_ADD_MODE("-listlabel", "", LABELTOOL_MODE_LISTLABEL, listlabelArgs); + + 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 + // do this last so we don't setup a connection before CLI options are + // validated + config->dbh = psMemIncrRefCounter(pmConfigDB(config->modules)); + if (!config->dbh) { + psError(PS_ERR_UNKNOWN, false, "Can't configure database"); + psFree(config); + return NULL; + } + + return config; +}