IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 25493


Ignore:
Timestamp:
Sep 23, 2009, 10:22:33 AM (17 years ago)
Author:
bills
Message:

In distribution server merge rcDSProduct into rcDestination. It was illogical for
a product to be shared by multiple destinations.
In defineinterest define by query to allow destination names and target parameters
to be used. Much more administrator friendly.
Add a label to pstampRequest. Not used yet.
Split reverting of faults in distRuns from faults building components.

Location:
trunk
Files:
2 added
14 edited
2 moved

Legend:

Unmodified
Added
Removed

  • trunk/dbconfig/changes.txt

    r25421 r25493  
    12601260-- Vesion 1.1.56
    12611261
    1262 
     1262-- Merge the rcDSProduct and rcDestination tables
     1263
     1264ALTER TABLE rcDestination ADD COLUMN dbname varchar(64) AFTER last_fileset;
     1265ALTER TABLE rcDestination ADD COLUMN dbhost varchar(64) AFTER dbname;
     1266
     1267UPDATE rcDestination JOIN rcDSProduct USING(prod_id)
     1268    SET rcDestination.name = rcDSProduct.name,
     1269        rcDestination.dbname = rcDSProduct.dbname,
     1270        rcDestination.dbhost = rcDSProduct.dbhost;
     1271
     1272ALTER TABLE rcDestination DROP foreign key rcDestination_ibfk_1 ;
     1273ALTER TABLE rcDestination DROP key prod_id;
     1274ALTER TABLE rcDestination DROP COLUMN prod_id;
     1275
     1276-- change references to rcDSProduct in rcDSFileset to reference rcDestination
     1277
     1278ALTER TABLE rcDSFileset DROP foreign key rcDSFileset_ibfk_2;
     1279ALTER TABLE rcDSFileset DROP key prod_id;
     1280ALTER TABLE rcDSFileset CHANGE COLUMN prod_id dest_id BIGINT NOT NULL DEFAULT '0';
     1281ALTER TABLE rcDSFileset ADD KEY (dest_id);
     1282ALTER TABLE rcDSFileset ADD FOREIGN KEY (dest_id) REFERENCES rcDestination(dest_id);
     1283
     1284-- finally drop the obsolete table
     1285DROP TABLE rcDSProduct;
     1286
     1287-- The following changes should have been made to the gpc1 database ages ago
     1288-- do not apply if these columns exist
     1289ALTER TABLE pstampRequest DROP COLUMN outFileset;
     1290ALTER TABLE pstampRequest ADD COLUMN name VARCHAR(64) UNIQUE AFTER state;
     1291ALTER TABLE pstampRequest ADD COLUMN reqType VARCHAR(16) AFTER name;
     1292ALTER TABLE pstampRequest ADD COLUMN outProduct VARCHAR(64) after reqType;
     1293ALTER TABLE pstampRequest ADD COLUMN fault SMALLINT AFTER uri;
     1294-- end of old changes
     1295
     1296-- This change is new
     1297ALTER TABLE pstampRequest ADD COLUMN label VARCHAR(64) AFTER reqType;

  • trunk/dbconfig/pstamp.md

    r24967 r25493  
    2424    name        STR         64      # UNIQUE
    2525    reqType     STR         16
     26    label       STR         64
    2627    outProduct  STR         64
    2728    uri         STR         255

  • trunk/dbconfig/rc.md

    r23999 r25493  
    1 rcDSProduct METADATA
    2     prod_id     S64        0       # Primary Key
    3     name        STR        64
    4     dbname      STR        64
    5     dbhost      STR        64
     1rcDestination METADATA
     2    dest_id     S64         0       # Primary Key
     3    name        STR         64
     4    status_uri  STR         255
     5    comment     STR         255
     6    last_fileset STR        255
     7    dbname      STR         64
     8    dbhost      STR         64
     9    state       STR         64      # Key
    610END
    711
    … …  
    913    fs_id       S64        0       # Primary Key
    1014    dist_id     S64        0       # fkey(dist_id) ref distRun(dist_id)
    11     prod_id     S64        0       # fkey(prod_id) ref rcDSProduct(prod_id)
     15    dest_id     S64        0       # fkey(dest_id) ref rcDestination(dest_id)
    1216    name        STR        255
    1317    state       STR        64
    … …  
    1519END
    1620
    17 rcDestination METADATA
    18     dest_id     S64         0       # Primary Key
    19     prod_id     S64         0       # fkey(prod_id) ref rcDSProduct(prod_id)
    20     name        STR         64
    21     status_uri  STR         255
    22     comment     STR         255
    23     last_fileset STR        255
    24     state       STR         64      # Key
    25 END
    2621
    2722rcInterest METADATA

  • trunk/ippTools/share/Makefile.am

    r25429 r25493  
    110110     disttool_definebyquery_stack.sql \
    111111     disttool_definebyquery_warp.sql \
     112     disttool_defineinterest.sql \
     113     disttool_listinterest.sql \
    112114     disttool_pending_camera.sql \
    113115     disttool_pending_chip.sql \
    … …  
    122124     disttool_queuercrun.sql \
    123125     disttool_revertrcrun.sql \
    124      disttool_revertrun_update.sql \
    125      disttool_revertrun_delete.sql \
     126     disttool_revertrun.sql \
     127     disttool_revertcomponent.sql \
    126128     disttool_revertfileset.sql \
    127129     disttool_toadvance.sql \

  • trunk/ippTools/share/disttool_pendingfileset.sql

    r24422 r25493  
    55    stage_id,
    66    CONCAT_WS('.', distRun.outroot, CONVERT(distRun.dist_id, CHAR)) as dist_dir,
    7     rcDSProduct.name AS product_name,
    8     rcDSProduct.prod_id,
    9     rcDSProduct.dbname AS ds_dbname,
    10     rcDSProduct.dbhost AS ds_dbhost
     7    rcDestination.name AS product_name,
     8    rcDestination.prod_id,
     9    rcDestination.dbname AS ds_dbname,
     10    rcDestination.dbhost AS ds_dbhost
    1111FROM rcDestination
    1212JOIN rcInterest USING(dest_id)
    1313JOIN distTarget USING(target_id)
    14 JOIN rcDSProduct USING(prod_id)
    1514JOIN distRun USING(target_id)
    16 LEFT JOIN rcDSFileset USING(prod_id, dist_id)
     15LEFT JOIN rcDSFileset USING(dest_id, dist_id)
    1716WHERE distRun.state = 'full'
    1817    AND rcDestination.state = 'enabled'

  • trunk/ippTools/share/disttool_queuercrun.sql

    r23912 r25493  
    1313JOIN rcInterest USING(dest_id)
    1414JOIN distTarget USING(target_id)
    15 JOIN rcDSProduct USING(prod_id)
    1615JOIN distRun USING(target_id, stage)
    17 JOIN rcDSFileset USING(prod_id, dist_id)
     16JOIN rcDSFileset USING(dest_id, dist_id)
    1817LEFT JOIN rcRun using(fs_id, dest_id)
    1918WHERE rcRun.rc_id IS NULL

  • trunk/ippTools/share/disttool_revertcomponent.sql

  • trunk/ippTools/share/disttool_revertrun.sql

  • trunk/ippTools/share/disttool_updatercrun.sql

    r23912 r25493  
    11UPDATE rcRun
    22JOIN rcDestination USING(dest_id)
    3 JOIN rcDSProduct USING(prod_id)
    4 JOIN rcDSFileset using(prod_id, fs_id)
     3JOIN rcDSFileset using(dest_id, fs_id)
    54SET
    65    -- set hook %s

  • trunk/ippTools/share/pxadmin_create_tables.sql

    r25479 r25493  
    12321232        name VARCHAR(64) UNIQUE,
    12331233        reqType VARCHAR(16),
     1234        label VARCHAR(64),
    12341235        outProduct VARCHAR(64),
    12351236        uri VARCHAR(255),
    … …  
    12971298
    12981299
    1299 CREATE TABLE rcDSProduct (
    1300     prod_id     BIGINT AUTO_INCREMENT,
    1301     name        VARCHAR(64),
    1302     dbname      VARCHAR(64),
    1303     dbhost      VARCHAR(64),
    1304     PRIMARY KEY(prod_id)
    1305 )  ENGINE=innodb DEFAULT CHARSET=latin1;
    1306 
    13071300CREATE TABLE rcDestination (
    13081301    dest_id     BIGINT AUTO_INCREMENT,
    1309     prod_id     BIGINT,
    13101302    name        VARCHAR(64),
    13111303    status_uri  VARCHAR(255),
    13121304    comment     VARCHAR(255),
    13131305    last_fileset VARCHAR(255),
     1306    dbname      VARCHAR(64),
     1307    dbhost      VARCHAR(64),
    13141308    state       VARCHAR(64),
    1315     PRIMARY KEY(dest_id),
    1316     FOREIGN KEY(prod_id) REFERENCES rcDSProduct(prod_id)
     1309    PRIMARY KEY(dest_id)
    13171310)  ENGINE=innodb DEFAULT CHARSET=latin1;
    1318 
    13191311
    13201312CREATE TABLE rcInterest (
    … …  
    13321324    fs_id       BIGINT AUTO_INCREMENT,
    13331325    dist_id     BIGINT,
    1334     prod_id     BIGINT,
     1326    dest_id     BIGINT,
    13351327    name        VARCHAR(255),
    13361328    state       VARCHAR(64),
    13371329    registered  TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    13381330    fault       SMALLINT DEFAULT 0,
    1339     PRIMARY KEY(dist_id, prod_id),
     1331    PRIMARY KEY(dist_id, dest_id),
    13401332    KEY(fs_id),
    13411333    FOREIGN KEY(dist_id) REFERENCES distRun(dist_id),
    1342     FOREIGN KEY(prod_id) REFERENCES rcDSProduct(prod_id)
    1343 --    KEY(dist_id, prod_id)
     1334    FOREIGN KEY(dest_id) REFERENCES rcDestination(dest_id)
    13441335)  ENGINE=innodb DEFAULT CHARSET=latin1;
    13451336

  • trunk/ippTools/share/rcserver_updatercrun.sql

    r23912 r25493  
    11UPDATE rcRun
    22JOIN rcDestination USING(dest_id)
    3 JOIN rcDSProduct USING(prod_id)
    4 JOIN rcDSFileset using(prod_id, fs_id)
     3JOIN rcDSFileset using(dest_id, fs_id)
    54SET
    6 rcRun.fault= 42, rcDestination.last_fileset = 'o4741g0236o.chip.14519.33.1'
    7 
    8 
    9 

  • trunk/ippTools/src/disttool.c

    r25460 r25493  
    3737static bool pendingcomponentMode(pxConfig *config);
    3838static bool addprocessedcomponentMode(pxConfig *config);
     39static bool revertcomponentMode(pxConfig *config);
    3940static bool processedcomponentMode(pxConfig *config);
    4041static bool toadvanceMode(pxConfig *config);
    … …  
    5152static bool listtargetMode(pxConfig *config);
    5253
    53 static bool definedsproductMode(pxConfig *config);
    54 static bool updatedsproductMode(pxConfig *config);
    55 
    5654static bool definedestinationMode(pxConfig *config);
    5755static bool updatedestinationMode(pxConfig *config);
    … …  
    5957static bool defineinterestMode(pxConfig *config);
    6058static bool updateinterestMode(pxConfig *config);
     59static bool listinterestMode(pxConfig *config);
    6160
    6261# define MODECASE(caseName, func) \
    … …  
    8685        MODECASE(DISTTOOL_MODE_ADDPROCESSEDCOMPONENT, addprocessedcomponentMode);
    8786        MODECASE(DISTTOOL_MODE_PROCESSEDCOMPONENT, processedcomponentMode);
     87        MODECASE(DISTTOOL_MODE_REVERTCOMPONENT, revertcomponentMode);
    8888        MODECASE(DISTTOOL_MODE_TOADVANCE, toadvanceMode);
    8989        MODECASE(DISTTOOL_MODE_PENDINGFILESET, pendingfilesetMode);
    … …  
    9797        MODECASE(DISTTOOL_MODE_UPDATETARGET, updatetargetMode);
    9898        MODECASE(DISTTOOL_MODE_LISTTARGET, listtargetMode);
    99         MODECASE(DISTTOOL_MODE_DEFINEDSPRODUCT, definedsproductMode);
    100         MODECASE(DISTTOOL_MODE_UPDATEDSPRODUCT, updatedsproductMode);
    10199        MODECASE(DISTTOOL_MODE_DEFINEDESTINATION, definedestinationMode);
    102100        MODECASE(DISTTOOL_MODE_UPDATEDESTINATION, updatedestinationMode);
    103101        MODECASE(DISTTOOL_MODE_DEFINEINTEREST, defineinterestMode);
    104102        MODECASE(DISTTOOL_MODE_UPDATEINTEREST, updateinterestMode);
     103        MODECASE(DISTTOOL_MODE_LISTINTEREST, listinterestMode);
    105104        default:
    106105            psAbort("invalid option (this should not happen)");
    … …  
    500499    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
    501500
    502     // we need to disambiguate fault so make a copy of the where list before adding fault
    503     psMetadata *whereComponent = psMetadataCopy(NULL, where);
    504501    PXOPT_COPY_S16(config->args, where,  "-fault", "distRun.fault", "==");
    505     PXOPT_COPY_S16(config->args, whereComponent, "-fault", "distComponent.fault", "==");
    506502
    507503    // It might be useful to be able to query by the parameters of the underlying runs
    … …  
    513509    }
    514510
    515     if (!psDBTransaction(config->dbh)) {
    516         psError(PS_ERR_UNKNOWN, false, "database error");
     511    psString query = pxDataGet("disttool_revertrun.sql");
     512    if (!query) {
     513        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     514        if (!psDBRollback(config->dbh)) {
     515            psError(PS_ERR_UNKNOWN, false, "database error");
     516        }
     517        return false;
     518    }
     519
     520    if (psListLength(where->list)) {
     521        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     522        psStringAppend(&query, " AND %s", whereClause);
     523        psFree(whereClause);
     524    }
     525    psFree(where);
     526
     527    if (!p_psDBRunQuery(config->dbh, query)) {
     528        psError(PS_ERR_UNKNOWN, false, "database error");
     529        psFree(query);
     530        return false;
     531    }
     532
     533    int numUpdated = psDBAffectedRows(config->dbh);
     534
     535    psLogMsg("disttool", PS_LOG_INFO, "Updated %d dist runs", numUpdated);
     536
     537    return true;
     538}
     539
     540static bool revertcomponentMode(pxConfig *config)
     541{
     542    psMetadata *where = psMetadataAlloc();
     543    PXOPT_COPY_S64(config->args, where, "-dist_id", "distRun.dist_id", "==");
     544    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");;
     545    PXOPT_COPY_STR(config->args, where, "-component", "component", "==");;
     546    PXOPT_COPY_S64(config->args, where, "-stage_id", "stage_id", "==");
     547    PXOPT_COPY_STR(config->args, where, "-state", "state", "==");
     548    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     549
     550    PXOPT_COPY_S16(config->args, where,  "-fault", "distComponent.fault", "==");
     551
     552    // It might be useful to be able to query by the parameters of the underlying runs
     553
     554    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    517555        psFree(where);
    518         return false;
    519     }
    520 
    521     // Update state to 'new'
    522     int numUpdated;                     // Number updated
    523     {
    524         psString query = pxDataGet("disttool_revertrun_update.sql");
    525         if (!query) {
    526             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    527             if (!psDBRollback(config->dbh)) {
    528                 psError(PS_ERR_UNKNOWN, false, "database error");
    529             }
    530             return false;
    531         }
    532 
    533         if (psListLength(where->list)) {
    534             psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    535             psStringAppend(&query, " AND %s", whereClause);
    536             psFree(whereClause);
    537         }
    538 
    539         if (!p_psDBRunQuery(config->dbh, query)) {
    540             psError(PS_ERR_UNKNOWN, false, "database error");
    541             psFree(query);
    542             if (!psDBRollback(config->dbh)) {
    543                 psError(PS_ERR_UNKNOWN, false, "database error");
    544             }
    545             return false;
    546         }
    547         psFree(query);
    548 
    549         numUpdated = psDBAffectedRows(config->dbh);
    550     }
    551 
    552     psLogMsg("disttool", PS_LOG_INFO, "Updated %d dist runs", numUpdated);
    553 
    554     // Delete product
    555     int numDeleted;                     // Number deleted
    556     {
    557         psString query = pxDataGet("disttool_revertrun_delete.sql");
    558         if (!query) {
    559             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    560             if (!psDBRollback(config->dbh)) {
    561                 psError(PS_ERR_UNKNOWN, false, "database error");
    562             }
    563             return false;
    564         }
    565 
    566         if (psListLength(whereComponent->list)) {
    567             psString whereClause = psDBGenerateWhereConditionSQL(whereComponent, NULL);
    568             psStringAppend(&query, " AND %s", whereClause);
    569             psFree(whereClause);
    570         }
    571 
    572         if (!p_psDBRunQuery(config->dbh, query)) {
    573             psError(PS_ERR_UNKNOWN, false, "database error");
    574             psFree(query);
    575             if (!psDBRollback(config->dbh)) {
    576                 psError(PS_ERR_UNKNOWN, false, "database error");
    577             }
    578             return false;
    579         }
    580         psFree(query);
    581 
    582         numDeleted = psDBAffectedRows(config->dbh);
    583     }
     556        psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     557        return false;
     558    }
     559
     560    psString query = pxDataGet("disttool_revertcomponent.sql");
     561    if (!query) {
     562        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     563        psFree(where);
     564        return false;
     565    }
     566
     567    if (psListLength(where->list)) {
     568        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     569        psStringAppend(&query, " AND %s", whereClause);
     570        psFree(whereClause);
     571    }
     572    psFree(where);
     573
     574    if (!p_psDBRunQuery(config->dbh, query)) {
     575        psError(PS_ERR_UNKNOWN, false, "database error");
     576        psFree(query);
     577        return false;
     578    }
     579
     580    int numDeleted = psDBAffectedRows(config->dbh);
    584581
    585582    psLogMsg("disttool", PS_LOG_INFO, "Deleted %d distComponents", numDeleted);
    586 
    587     psFree(where);
    588     psFree(whereComponent);
    589 
    590     if (!psDBCommit(config->dbh)) {
    591         psError(PS_ERR_UNKNOWN, false, "database error");
    592         return false;
    593     }
    594583
    595584    return true;
    … …  
    14131402}
    14141403
    1415 static bool definedsproductMode(pxConfig *config)
     1404static bool definedestinationMode(pxConfig *config)
    14161405{
    14171406    PS_ASSERT_PTR_NON_NULL(config, false);
    14181407
    14191408    // required
    1420     PXOPT_LOOKUP_STR(name, config->args,   "-name", true, false);
    1421     PXOPT_LOOKUP_STR(dbname, config->args, "-ds_dbname", true, false);
    1422     PXOPT_LOOKUP_STR(dbhost, config->args, "-ds_dbhost", true, false);
    1423 
    1424     // XXX: should we insure that these names do not contatin any whitespace?
    1425 
    1426     rcDSProductRow *row = rcDSProductRowAlloc(
    1427             0,          // prod_id
    1428             name,
    1429             dbname,
    1430             dbhost
    1431             );
    1432            
    1433     if (!row) {
    1434         psError(PS_ERR_UNKNOWN, false, "failed to allocate rcDSProduct object");
    1435         return false;
    1436     }
    1437    if (!rcDSProductInsertObject(config->dbh, row)) {
    1438         psError(PS_ERR_UNKNOWN, false, "database error");
    1439         psFree(row);
    1440         return false;
    1441     }
    1442 
    1443     // get the assigned target_id
    1444     row->prod_id = psDBLastInsertID(config->dbh);
    1445 
    1446     if (!rcDSProductPrintObject(stdout, row, true)) {
    1447         psError(PS_ERR_UNKNOWN, false, "failed to print object");
    1448         psFree(row);
    1449         return false;
    1450     }
    1451 
    1452     psFree(row);
    1453 
    1454     return true;
    1455 }
    1456 static bool updatedsproductMode(pxConfig *config)
    1457 {
    1458     PS_ASSERT_PTR_NON_NULL(config, false);
    1459 
    1460     psMetadata *where = psMetadataAlloc();
    1461     PXOPT_COPY_S64(config->args, where, "-prod_id", "prod_id", "==");
    1462 
    1463     PXOPT_LOOKUP_STR(dbname, config->args, "-ds_dbname", false, false);
    1464     PXOPT_LOOKUP_STR(dbhost, config->args, "-ds_dbhost", false, false);
    1465 
    1466     if (!(dbname || dbhost)) {
    1467         psError(PS_ERR_UNKNOWN, true, "one or more of dbname or dbhost is required");
    1468         psFree(where);
    1469         return false;
    1470     }
    1471     psString query = psStringCopy("UPDATE rcDSProduct SET");
    1472     psString sep = "";
    1473     if (dbname) {
    1474         psStringAppend(&query, " dbname = '%s'", dbname);
    1475         sep = ",";
    1476     }
    1477     if (dbhost) {
    1478         psStringAppend(&query, " %s dbhost = '%s'", sep, dbhost);
    1479     }
    1480 
    1481     if (psListLength(where->list)) {
    1482         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    1483         psStringAppend(&query, " WHERE %s", whereClause);
    1484         psFree(whereClause);
    1485     } else {
    1486         psError(PS_ERR_UNKNOWN, true, "search parameters are required");
    1487         psFree(where);
    1488         psFree(query);
    1489         return false;
    1490     }
    1491     psFree(where);
    1492 
    1493     if (!p_psDBRunQuery(config->dbh, query)) {
    1494         psError(PS_ERR_UNKNOWN, false, "database error");
    1495         psFree(query);
    1496         return false;
    1497     }
    1498     psFree(query);
    1499 
    1500     return true;
    1501 }
    1502 
    1503 static bool definedestinationMode(pxConfig *config)
    1504 {
    1505     PS_ASSERT_PTR_NON_NULL(config, false);
    1506 
    1507     // required
    1508     PXOPT_LOOKUP_S64(prod_id, config->args,      "-prod_id", true, false);
    15091409    PXOPT_LOOKUP_STR(name, config->args,         "-name", true, false);
     1410    PXOPT_LOOKUP_STR(dbname, config->args,       "-ds_dbname", true, false);
     1411    PXOPT_LOOKUP_STR(dbhost, config->args,       "-ds_dbhost", true, false);
    15101412
    15111413    // optional
    … …  
    15191421    rcDestinationRow *row = rcDestinationRowAlloc(
    15201422            0,          // dest_id
    1521             prod_id,
    15221423            name,
    15231424            status_uri,
    15241425            comment,
    15251426            last_fileset,
     1427            dbname,
     1428            dbhost,
    15261429            state ? state : "enabled"
    15271430            );
    … …  
    16111514    PS_ASSERT_PTR_NON_NULL(config, false);
    16121515
    1613     // required
    1614     PXOPT_LOOKUP_S64(dest_id, config->args,      "-dest_id", true, false);
    1615     PXOPT_LOOKUP_S64(target_id, config->args,    "-target_id", true, false);
     1516    // one of these is required
     1517    PXOPT_LOOKUP_S64(dest_id, config->args,      "-dest_id", false, false);
     1518    PXOPT_LOOKUP_STR(dest_name, config->args,    "-dest_name", false, false);
     1519    if (!dest_id && !dest_name) {
     1520        psError(PS_ERR_UNKNOWN, true, "either dest_id or dest_name is required");
     1521        return false;
     1522    }
     1523
     1524    // either target_id or stage and label are required
     1525    PXOPT_LOOKUP_S64(target_id, config->args,    "-target_id", false, false);
     1526    PXOPT_LOOKUP_STR(stage, config->args,        "-stage", false, false);
     1527    PXOPT_LOOKUP_STR(label, config->args,        "-label", false, false);
     1528    PXOPT_LOOKUP_STR(filter, config->args,       "-filter", false, false);
     1529    PXOPT_LOOKUP_BOOL(clean, config->args,       "-clean", false);
     1530
     1531    if (!target_id) {
     1532        bool error = false;
     1533        if (!stage) {
     1534            psError(PS_ERR_UNKNOWN, true, "stage is required if target_id is not supplied");
     1535            error = true;
     1536        }
     1537        if (!label) {
     1538            psError(PS_ERR_UNKNOWN, !error, "label is required if target_id is not supplied");
     1539            error = true;
     1540        }
     1541        if (error) {
     1542            return false;
     1543        }
     1544    }
    16161545
    16171546    // optional
     1547    PXOPT_LOOKUP_S64(limit, config->args, "-limit", false, false);
    16181548    PXOPT_LOOKUP_STR(state, config->args,        "-set_state", false, false);
    1619 
    1620     // XXX: should we insure that these names do not contatin any whitespace?
    1621 
    1622     rcInterestRow *row = rcInterestRowAlloc(
    1623             0,          // int_id
    1624             dest_id,
    1625             target_id,
    1626             state ? state : "enabled"
    1627             );
    1628            
    1629     if (!row) {
    1630         psError(PS_ERR_UNKNOWN, false, "failed to allocate rcInterest object");
    1631         return false;
    1632     }
    1633    if (!rcInterestInsertObject(config->dbh, row)) {
    1634         psError(PS_ERR_UNKNOWN, false, "database error");
    1635         psFree(row);
    1636         return false;
    1637     }
    1638 
    1639     // get the assigned target_id
    1640     row->int_id = psDBLastInsertID(config->dbh);
    1641 
    1642     if (!rcInterestPrintObject(stdout, row, true)) {
    1643         psError(PS_ERR_UNKNOWN, false, "failed to print object");
    1644         psFree(row);
    1645         return false;
    1646     }
    1647 
    1648     psFree(row);
     1549    if (state) {
     1550        if (strcmp(state, "enabled") && strcmp(state, "disabled")) {
     1551            psError(PS_ERR_PROGRAMMING, true, "state must be enabled or disabled");
     1552            return false;
     1553        }
     1554    } else {
     1555        // default state
     1556        state = "enabled";
     1557    }
     1558
     1559    // now that we've done all of our argument checking, copy the values to where
     1560    psMetadata *where = psMetadataAlloc();
     1561    PXOPT_COPY_S64(config->args, where, "-dest_id", "dest_id", "==");
     1562    PXOPT_COPY_STR(config->args, where, "-dest_name", "rcDestination.name", "==");
     1563    PXOPT_COPY_S64(config->args, where, "-target_id", "target_id", "==");
     1564    PXOPT_COPY_STR(config->args, where, "-label", "label", "LIKE");
     1565    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "LIKE");
     1566    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
     1567
     1568    psString query = pxDataGet("disttool_defineinterest.sql");
     1569
     1570    if (!psListLength(where->list)) {
     1571        // can't get here
     1572        psError(PS_ERR_PROGRAMMING, true, "search parameters are required");
     1573        psFree(where);
     1574        psFree(query);
     1575        return false;
     1576    }
     1577    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1578    psStringAppend(&query, " AND %s", whereClause);
     1579    psFree(whereClause);
     1580    psFree(where);
     1581    if (clean) {
     1582        psStringAppend(&query, " AND (distTarget.clean)");
     1583    } else {
     1584        psStringAppend(&query, " AND (!distTarget.clean)");
     1585    }
     1586    if (limit) {
     1587        psString limitString = psDBGenerateLimitSQL(limit);
     1588        psStringAppend(&query, " %s", limitString);
     1589        psFree(limitString);
     1590    }
     1591    {
     1592        // psStringSubstitute fails unless the input is a psString which it determines by
     1593        // comparing the memory blocks free function to an expected value.
     1594        // pxDataGet uses psSlurp which leaves a different free function on the memory block.
     1595        // To work around this make a copy of the query before doing the substitution.
     1596        psString queryCopy = psStringCopy(query);
     1597        psFree(query);
     1598        query = queryCopy;
     1599    }
     1600    // change the @STATE@ in the sql file to our state
     1601    if (!psStringSubstitute(&query, state, "@STATE@")) {
     1602        psError(PS_ERR_UNKNOWN, false, "failed to substitute state string");
     1603        return false;
     1604    }
     1605
     1606    if (!p_psDBRunQuery(config->dbh, query)) {
     1607        psError(PS_ERR_UNKNOWN, false, "database error");
     1608        psFree(query);
     1609        return false;
     1610    }
     1611    psFree(query);
     1612    int numInserted = psDBAffectedRows(config->dbh);
     1613    printf("inserted %d rows into rcInterest\n", numInserted);
    16491614
    16501615    return true;
    … …  
    16901655    return true;
    16911656}
    1692 
     1657static bool listinterestMode(pxConfig *config)
     1658{
     1659    PS_ASSERT_PTR_NON_NULL(config, false);
     1660
     1661    psMetadata *where = psMetadataAlloc();
     1662    PXOPT_COPY_S64(config->args, where, "-int_id", "int_id", "==");
     1663    PXOPT_COPY_S64(config->args, where, "-dest_id", "dest_id", "==");
     1664    PXOPT_COPY_STR(config->args, where, "-dest_name", "name", "==");
     1665    PXOPT_COPY_S64(config->args, where, "-target_id", "target_id", "==");
     1666    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
     1667    PXOPT_COPY_STR(config->args, where, "-label", "label", "LIKE");
     1668    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "LIKE");
     1669    PXOPT_COPY_STR(config->args, where, "-state", "state", "==");
     1670
     1671    PXOPT_LOOKUP_BOOL(clean, config->args, "-clean", false);
     1672    PXOPT_LOOKUP_BOOL(full, config->args, "-full", false);
     1673
     1674    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1675    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1676
     1677    if (clean && full) {
     1678        psError(PS_ERR_UNKNOWN, false, "can't select both -clean and -full");
     1679        return false;
     1680    }
     1681
     1682    psString query = pxDataGet("disttool_listinterest.sql");
     1683
     1684    if (psListLength(where->list)) {
     1685        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1686        psStringAppend(&query, " WHERE %s", whereClause);
     1687        psFree(whereClause);
     1688        if (clean) {
     1689            psStringAppend(&query, " AND (clean)");
     1690        } else if (full) {
     1691            psStringAppend(&query, " AND (!clean)");
     1692        }
     1693    } else if (clean) {
     1694        psStringAppend(&query, " WHERE clean");
     1695    } else if (full) {
     1696        psStringAppend(&query, " WHERE !clean");
     1697    }
     1698    psFree(where);
     1699
     1700    // treat limit == 0 as "no limit"
     1701    if (limit) {
     1702        psString limitString = psDBGenerateLimitSQL(limit);
     1703        psStringAppend(&query, " %s", limitString);
     1704        psFree(limitString);
     1705    }
     1706
     1707    if (!p_psDBRunQuery(config->dbh, query)) {
     1708        psError(PS_ERR_UNKNOWN, false, "database error");
     1709        psFree(query);
     1710        if (!psDBRollback(config->dbh)) {
     1711            psError(PS_ERR_UNKNOWN, false, "database error");
     1712        }
     1713        return false;
     1714    }
     1715    psFree(query);
     1716
     1717    psArray *output = p_psDBFetchResult(config->dbh);
     1718    if (!output) {
     1719        psError(PS_ERR_UNKNOWN, false, "database error");
     1720        return false;
     1721    }
     1722    if (!psArrayLength(output)) {
     1723        psTrace("disttool", PS_LOG_INFO, "no rows found");
     1724        psFree(output);
     1725        return true;
     1726    }
     1727
     1728    if (!ippdbPrintMetadatas(stdout, output, "rcInterest", !simple)) {
     1729        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1730        psFree(output);
     1731        return false;
     1732    }
     1733
     1734    psFree(output);
     1735
     1736    return true;
     1737}

  • trunk/ippTools/src/disttool.h

    r24001 r25493  
    3131    DISTTOOL_MODE_PENDINGCOMPONENT,
    3232    DISTTOOL_MODE_ADDPROCESSEDCOMPONENT,
     33    DISTTOOL_MODE_REVERTCOMPONENT,
    3334    DISTTOOL_MODE_PROCESSEDCOMPONENT,
    3435    DISTTOOL_MODE_TOADVANCE,
    … …  
    4243    DISTTOOL_MODE_DEFINEDESTINATION,
    4344    DISTTOOL_MODE_UPDATEDESTINATION,
    44     DISTTOOL_MODE_DEFINEDSPRODUCT,
    45     DISTTOOL_MODE_UPDATEDSPRODUCT,
    4645    DISTTOOL_MODE_DEFINETARGET,
    4746    DISTTOOL_MODE_UPDATETARGET,
    … …  
    4948    DISTTOOL_MODE_DEFINEINTEREST,
    5049    DISTTOOL_MODE_UPDATEINTEREST,
     50    DISTTOOL_MODE_LISTINTEREST,
    5151} disttoolMode;
    5252

  • trunk/ippTools/src/disttoolConfig.c

    r25429 r25493  
    111111    psMetadataAddS32(addprocessedcomponentArgs, PS_LIST_TAIL, "-fault", 0, "define fault code", 0);
    112112
     113    // -revertcomponent
     114    psMetadata *revertcomponentArgs = psMetadataAlloc();
     115    psMetadataAddS64(revertcomponentArgs, PS_LIST_TAIL, "-dist_id", 0, "define dist_id", 0);
     116    psMetadataAddStr(revertcomponentArgs, PS_LIST_TAIL, "-component", 0, "define component", NULL);
     117    psMetadataAddStr(revertcomponentArgs, PS_LIST_TAIL, "-stage",    0, "define stage", NULL);
     118    psMetadataAddS64(revertcomponentArgs, PS_LIST_TAIL, "-stage_id", 0, "define stage_id", 0);
     119    psMetadataAddStr(revertcomponentArgs, PS_LIST_TAIL, "-state",    0, "define state", NULL);
     120    psMetadataAddStr(revertcomponentArgs, PS_LIST_TAIL, "-label",    0, "define label", NULL);
     121    psMetadataAddS16(revertcomponentArgs, PS_LIST_TAIL, "-fault", 0, "define fault code", 0);
     122    psMetadataAddBool(revertcomponentArgs, PS_LIST_TAIL, "-all",    0, "revert all faulted runs", NULL);
     123
    113124    // -processedcomponent
    114125    psMetadata *processedcomponentArgs = psMetadataAlloc();
    … …  
    189200    psMetadataAddBool(revertrcrunArgs, PS_LIST_TAIL, "-all",     0, "revert all faulted runs", NULL);
    190201
    191     // -definedsproduct
    192     psMetadata *definedsproductArgs = psMetadataAlloc();
    193     psMetadataAddStr(definedsproductArgs, PS_LIST_TAIL, "-name",  0, "define product name", NULL);
    194     psMetadataAddStr(definedsproductArgs, PS_LIST_TAIL, "-ds_dbname",0, "define data store database name", NULL);
    195     psMetadataAddStr(definedsproductArgs, PS_LIST_TAIL, "-ds_dbhost",0, "define data store database host", NULL);
    196 
    197     // -updatedsproduct
    198     // does this mode make sense?
    199     psMetadata *updatedsproductArgs = psMetadataAlloc();
    200     psMetadataAddS64(updatedsproductArgs, PS_LIST_TAIL, "-prod_id",   0, "select by prod_id", 0);
    201     // can't select by name because it isn't necssarily unique
    202     psMetadataAddStr(updatedsproductArgs, PS_LIST_TAIL, "-ds_dbname",0, "define data store database name", NULL);
    203     psMetadataAddStr(updatedsproductArgs, PS_LIST_TAIL, "-ds_dbhost",0, "define data store database host", NULL);
    204 
    205202    // -definedestination
    206203    psMetadata *definedestinationArgs = psMetadataAlloc();
    207     psMetadataAddS64(definedestinationArgs, PS_LIST_TAIL, "-prod_id",     0, "define prod_id (required)", 0);
    208204    psMetadataAddStr(definedestinationArgs, PS_LIST_TAIL, "-name",        0, "define destination name (required)", NULL);
     205    psMetadataAddStr(definedestinationArgs, PS_LIST_TAIL, "-ds_dbname",0, "define data store database name (required)", NULL);
     206    psMetadataAddStr(definedestinationArgs, PS_LIST_TAIL, "-ds_dbhost",0, "define data store database host (required)", NULL);
    209207    psMetadataAddStr(definedestinationArgs, PS_LIST_TAIL, "-status_uri",  0, "define status_uri", NULL);
    210208    psMetadataAddStr(definedestinationArgs, PS_LIST_TAIL, "-comment",     0, "define comment", NULL);
    … …  
    215213    psMetadata *updatedestinationArgs = psMetadataAlloc();
    216214    psMetadataAddS64(updatedestinationArgs, PS_LIST_TAIL, "-dest_id",     0, "define dest_id", 0);
    217     psMetadataAddS64(updatedestinationArgs, PS_LIST_TAIL, "-prod_id",     0, "define prod_id", 0);
    218215    psMetadataAddStr(updatedestinationArgs, PS_LIST_TAIL, "-name",        0, "define destination name", NULL);
    219216    psMetadataAddStr(updatedestinationArgs, PS_LIST_TAIL, "-status_uri",  0, "define status_uri", NULL);
    220217    psMetadataAddStr(updatedestinationArgs, PS_LIST_TAIL, "-comment",     0, "define comment", NULL);
    221 //  last_fileset gets updated by -updatercrun
    222 //  psMetadataAddStr(updatedestinationArgs, PS_LIST_TAIL, "-set_last_fileset",0, "define last_fileset", NULL);
    223218    psMetadataAddStr(updatedestinationArgs, PS_LIST_TAIL, "-set_state",   0, "define state", NULL);
    224219
    … …  
    254249    // -defineinterest
    255250    psMetadata *defineinterestArgs = psMetadataAlloc();
    256     psMetadataAddS64(defineinterestArgs, PS_LIST_TAIL, "-dest_id",   0, "define dest_id (required)", 0);
    257     psMetadataAddS64(defineinterestArgs, PS_LIST_TAIL, "-target_id", 0, "define target_id (required)", 0);
     251    psMetadataAddS64(defineinterestArgs, PS_LIST_TAIL, "-dest_id",   0, "define dest_id", 0);
     252    psMetadataAddStr(defineinterestArgs, PS_LIST_TAIL, "-dest_name", 0, "define destination name (LIKE comparison)", NULL);
     253    psMetadataAddS64(defineinterestArgs, PS_LIST_TAIL, "-target_id", 0, "define target_id", 0);
     254    psMetadataAddStr(defineinterestArgs, PS_LIST_TAIL, "-stage",     0, "define stage", NULL);
     255    psMetadataAddStr(defineinterestArgs, PS_LIST_TAIL, "-label",     0, "define label", NULL);
     256    psMetadataAddStr(defineinterestArgs, PS_LIST_TAIL, "-filter",    0, "define filter (LIKE comparison)", NULL);
     257    psMetadataAddBool(defineinterestArgs, PS_LIST_TAIL,"-clean",     0, "list clean targets", false);
    258258    psMetadataAddStr(defineinterestArgs, PS_LIST_TAIL, "-set_state", 0, "define state", NULL);
     259    psMetadataAddU64(defineinterestArgs, PS_LIST_TAIL, "-limit",     0, "limit number of targets listed to N", 0);
    259260
    260261    // -updateinterest
    … …  
    265266    psMetadataAddStr(updateinterestArgs, PS_LIST_TAIL, "-set_state", 0, "define state (required)", NULL);
    266267
     268    // -listinterest
     269    psMetadata *listinterestArgs = psMetadataAlloc();
     270    psMetadataAddS64(listinterestArgs, PS_LIST_TAIL, "-target_id", 0, "list interests with target_id", 0);
     271    psMetadataAddS64(listinterestArgs, PS_LIST_TAIL, "-dest_id", 0, "list interests with dest_id", 0);
     272    psMetadataAddS64(listinterestArgs, PS_LIST_TAIL, "-int_id", 0, "list interests with int_id", 0);
     273    psMetadataAddStr(listinterestArgs, PS_LIST_TAIL, "-dest_name",  0, "list interests for destinationn name)", NULL);
     274    psMetadataAddStr(listinterestArgs, PS_LIST_TAIL, "-label",  0, "list interests for label (LIKE comparison)", NULL);
     275    psMetadataAddStr(listinterestArgs, PS_LIST_TAIL, "-filter",    0, "list interests by filter (LIKE comparison)", NULL);
     276    psMetadataAddStr(listinterestArgs, PS_LIST_TAIL, "-stage",     0, "list interests for stage", NULL);
     277    psMetadataAddBool(listinterestArgs, PS_LIST_TAIL,"-clean",     0, "list clean interests", false);
     278    psMetadataAddBool(listinterestArgs, PS_LIST_TAIL,"-full",      0, "list full interests", false);
     279    psMetadataAddStr(listinterestArgs, PS_LIST_TAIL, "-state",     0, "list interests in state", NULL);
     280    psMetadataAddU64(listinterestArgs, PS_LIST_TAIL, "-limit",     0, "limit number of interests listed to N", 0);
     281    psMetadataAddBool(listinterestArgs, PS_LIST_TAIL, "-simple",  0, "use the simple output format", false);
     282
    267283    psMetadata *argSets = psMetadataAlloc();
    268284    psMetadata *modes = psMetadataAlloc();
    … …  
    272288    PXOPT_ADD_MODE("-updaterun",    "", DISTTOOL_MODE_UPDATERUN, updaterunArgs);
    273289    PXOPT_ADD_MODE("-revertrun",    "", DISTTOOL_MODE_REVERTRUN, revertrunArgs);
    274     PXOPT_ADD_MODE("-pendingcomponent",       "", DISTTOOL_MODE_PENDINGCOMPONENT,    pendingcomponentArgs);
    275     PXOPT_ADD_MODE("-addprocessedcomponent",      "", DISTTOOL_MODE_ADDPROCESSEDCOMPONENT, addprocessedcomponentArgs);
     290    PXOPT_ADD_MODE("-pendingcomponent",   "", DISTTOOL_MODE_PENDINGCOMPONENT,    pendingcomponentArgs);
     291    PXOPT_ADD_MODE("-addprocessedcomponent", "", DISTTOOL_MODE_ADDPROCESSEDCOMPONENT, addprocessedcomponentArgs);
     292    PXOPT_ADD_MODE("-revertcomponent",    "", DISTTOOL_MODE_REVERTCOMPONENT, revertcomponentArgs);
    276293    PXOPT_ADD_MODE("-processedcomponent", "", DISTTOOL_MODE_PROCESSEDCOMPONENT, processedcomponentArgs);
    277294    PXOPT_ADD_MODE("-toadvance",          "", DISTTOOL_MODE_TOADVANCE, toadvanceArgs);
    … …  
    284301    PXOPT_ADD_MODE("-pendingdest",        "", DISTTOOL_MODE_PENDINGDEST, pendingdestArgs);
    285302
    286     PXOPT_ADD_MODE("-definedsproduct",    "", DISTTOOL_MODE_DEFINEDSPRODUCT, definedsproductArgs);
    287     PXOPT_ADD_MODE("-updatedsproduct",    "", DISTTOOL_MODE_UPDATEDSPRODUCT, updatedsproductArgs);
    288 //  PXOPT_ADD_MODE("-listdsproduct",      "", DISTTOOL_MODE_LISTDSPRODUCT, updatedsproductArgs);
    289 
    290303    PXOPT_ADD_MODE("-definedestination",  "", DISTTOOL_MODE_DEFINEDESTINATION, definedestinationArgs);
    291304    PXOPT_ADD_MODE("-updatedestination",  "", DISTTOOL_MODE_UPDATEDESTINATION, updatedestinationArgs);
    … …  
    298311    PXOPT_ADD_MODE("-defineinterest",     "", DISTTOOL_MODE_DEFINEINTEREST, defineinterestArgs);
    299312    PXOPT_ADD_MODE("-updateinterest",     "", DISTTOOL_MODE_UPDATEINTEREST, updateinterestArgs);
    300 //  PXOPT_ADD_MODE("-listinterest",       "", DISTTOOL_MODE_LISTINTEREST, listinterestArgs);
     313    PXOPT_ADD_MODE("-listinterest",       "", DISTTOOL_MODE_LISTINTEREST, listinterestArgs);
    301314
    302315    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • trunk/ippTools/src/pstamptool.c

    r25461 r25493  
    228228    PXOPT_LOOKUP_STR(uri,         config->args, "-uri",   true, false);
    229229    PXOPT_LOOKUP_STR(name,        config->args, "-name",  false, false);
     230    PXOPT_LOOKUP_STR(label,       config->args, "-label",  false, false);
    230231    PXOPT_LOOKUP_S64(ds_id,       config->args, "-ds_id", false, false);
    231232
    … …  
    236237        name,
    237238        NULL,   // reqType
     239        label,
    238240        NULL,   // outProduct
    239241        uri,   

  • trunk/ippTools/src/pstamptoolConfig.c

    r25461 r25493  
    6363    // -addreq
    6464    psMetadata *addreqArgs = psMetadataAlloc();
    65     psMetadataAddStr(addreqArgs, PS_LIST_TAIL, "-uri", 0,     "define request file uri (required)", NULL);
    66     psMetadataAddS64(addreqArgs, PS_LIST_TAIL, "-ds_id", 0,   "define request ds_id", 0);
     65    psMetadataAddStr(addreqArgs, PS_LIST_TAIL, "-uri", 0,    "define request file uri (required)", NULL);
     66    psMetadataAddS64(addreqArgs, PS_LIST_TAIL, "-ds_id", 0,  "define request ds_id", 0);
    6767    psMetadataAddStr(addreqArgs, PS_LIST_TAIL, "-name", 0,   "define request name", NULL);
     68    psMetadataAddStr(addreqArgs, PS_LIST_TAIL, "-label", 0,  "define request label", NULL);
    6869
    6970    // -pendingreq
Note: See TracChangeset for help on using the changeset viewer.