IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Dec 22, 2011, 2:21:40 PM (15 years ago)
Author:
heather
Message:

whoo hooo! mergetool changes, now to test on maui

Location:
branches/haf_add201112/ippTools/src
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • branches/haf_add201112/ippTools/src/addtool.c

    r32832 r33003  
    12211221
    12221222  PXOPT_LOOKUP_STR(minidvodb_group, config->args, "-set_minidvodb_group", true, false);
    1223   PXOPT_LOOKUP_STR(mergedvodb_path, config->args, "-set_mergedvodb_path", true, false);
    1224 
    1225   //optional
     1223    //optional
    12261224  PXOPT_LOOKUP_STR(minidvodb_name, config->args, "-set_minidvodb_name", false, false);
    12271225  PXOPT_LOOKUP_STR(minidvodb_path, config->args, "-set_minidvodb_path", false, false);
    … …  
    12381236  if (minidvodb_path) {
    12391237    minidvodbpath = minidvodb_path;
     1238  } else {
     1239    psError(PS_ERR_UNKNOWN, false, "require minidvodb_path");
     1240    return false;
    12401241  }
    12411242
    … …  
    12451246            minidvodb_group,
    12461247            minidvodbpath,
    1247             mergedvodb_path,
    1248             "new",
     1248            "new",
    12491249            0
    12501250            )) {
    … …  
    12681268    psStringAppend(&minidvodb_name, "%s.%" PRIu64,minidvodb_group,minidvodb_id);
    12691269  }
    1270 
    1271   if (!minidvodb_path) {
    1272     psStringAppend(&minidvodb_path,"%s/%s",mergedvodb_path,minidvodb_name);
    1273   }
    1274 
    12751270  if (minidvodb_path) {
    12761271    psStringAppend(&minidvodb_path,"/%s",minidvodb_name);
    … …  
    13041299    PXOPT_COPY_STR(config->args, where, "-state",     "state", "==");
    13051300    PXOPT_COPY_STR(config->args, where, "-minidvodb_path", "minidvodb_path", "==");
    1306     PXOPT_COPY_STR(config->args, where, "-mergedvodb_path", "mergedvodb_path", "==");
    13071301    PXOPT_COPY_STR(config->args, where, "-minidvodb_group",     "minidvodb_group", "==");
    13081302
    … …  
    13101304    PXOPT_LOOKUP_STR(minidvodb_path,  config->args, "-set_minidvodb_path", false, false);
    13111305    PXOPT_LOOKUP_STR(state,  config->args, "-set_state", false, false);
    1312     PXOPT_LOOKUP_STR(mergedvodb_path,  config->args, "-set_mergedvodb_path", false, false);
    13131306    PXOPT_LOOKUP_STR(minidvodb_group,  config->args, "-set_minidvodb_group", false, false);
    13141307
    … …  
    13451338    }
    13461339
    1347     if (mergedvodb_path) {
    1348       if (cnt) {
    1349         psStringAppend(&query, "%s", comma);
    1350       }
    1351       psStringAppend(&query, " mergedvodb_path = '%s'", mergedvodb_path);
    1352       cnt++;
    1353     }
    1354 
    13551340    if (minidvodb_group) {
    13561341      if (cnt) {
    … …  
    13961381  }
    13971382
    1398   psString firstquery = psStringCopy("SELECT * from  minidvodbRun where state = 'new' and minidvodb_name is NOT NULL and minidvodb_group IS NOT NULL and minidvodb_path IS NOT NULL and mergedvodb_path IS NOT NULL");
     1383  psString firstquery = psStringCopy("SELECT * from  minidvodbRun where state = 'new' and minidvodb_name is NOT NULL and minidvodb_group IS NOT NULL and minidvodb_path IS NOT NULL");
    13991384
    14001385  psString firstwhereClause = psDBGenerateWhereConditionSQL(where, NULL);
    … …  
    14441429
    14451430  //now flip new -> active
    1446   psString query2 = psStringCopy("UPDATE minidvodbRun SET state = 'active' WHERE state = 'new' AND minidvodb_name is NOT NULL and minidvodb_group IS NOT NULL and minidvodb_path IS NOT NULL and mergedvodb_path IS NOT NULL ");
     1431  psString query2 = psStringCopy("UPDATE minidvodbRun SET state = 'active' WHERE state = 'new' AND minidvodb_name is NOT NULL and minidvodb_group IS NOT NULL and minidvodb_path IS NOT NULL ");
    14471432  psStringAppend(&query2, " AND minidvodb_group = '%s' limit 1;", minidvodb_group);
    14481433  if (!p_psDBRunQuery(config->dbh, query2)) {
    … …  
    16211606    // required
    16221607  PXOPT_LOOKUP_U64(minidvodb_id, config->args, "-minidvodb_id", true, false);
    1623   PXOPT_LOOKUP_STR(mergedvodb_path, config->args, "-mergedvodb_path", true, false);
    16241608  PXOPT_LOOKUP_STR(minidvodb_group, config->args, "-minidvodb_group", true, false);
    16251609
    16261610    // optional
    1627   PXOPT_LOOKUP_U64(merge_order,     config->args, "-merge_order", false, false);
    16281611  PXOPT_LOOKUP_F32(dtime_relphot, config->args, "-dtime_relphot", false, false);
    16291612  PXOPT_LOOKUP_F32(dtime_resort, config->args, "-dtime_resort", false, false);
    1630   PXOPT_LOOKUP_F32(dtime_merge, config->args, "-dtime_merge", false, false);
    1631   PXOPT_LOOKUP_F32(dtime_verify, config->args, "-dtime_verify", false, false);
    16321613  PXOPT_LOOKUP_F32(dtime_script, config->args, "-dtime_script", false, false);
    16331614 
    … …  
    16801661  minidvodbProcessedRow *row = minidvodbProcessedRowAlloc(
    16811662               pendingRow->minidvodb_id,
    1682                merge_order,
    16831663               dtime_resort,
    16841664               dtime_relphot,
    1685                dtime_verify,
    1686                dtime_merge,
    16871665               dtime_script,
    16881666               epoch,
    1689                mergedvodb_path,
    16901667               fault
    16911668               );
    … …  
    17021679  }
    17031680
    1704 
    1705 
    1706 
    1707   //this finds the # of merged things (for the merge order)
    1708   psString query3 = NULL;
    1709   psStringAppend(&query3, "select count(*) from minidvodbRun join minidvodbProcessed using (minidvodb_id) where state = 'merged' and minidvodb_group = '%s';", minidvodb_group);
    1710 
    1711   if (!p_psDBRunQuery(config->dbh, query3)) {
    1712     // rollback
    1713     if (!psDBRollback(config->dbh)) {
    1714       psError(PS_ERR_UNKNOWN, false, "database error");
    1715     }
    1716     psError(PS_ERR_UNKNOWN, false, "database error");
    1717     psFree(query3);
    1718     return false;
    1719   }
    1720   psArray *output2 = p_psDBFetchResult(config->dbh);
    1721   if (!output2) {
    1722     psError(PS_ERR_UNKNOWN, false, "database error");
    1723     return false;
    1724   }
    1725   if (!psArrayLength(output2)) {
    1726     psTrace("addtool", PS_LOG_INFO, "no rows found");
    1727     psFree(output);
    1728     return true;
    1729   }
    1730   bool status;
    1731   psS64 m_order = psMetadataLookupS64(&status, output2->data[0], "count(*)");
    1732   if (!status) {
    1733 
    1734     psAbort("failed to lookup value for count column");
    1735     return false;
    1736   }
    1737   psString final = NULL;
    1738   psStringAppend(&final, "%" PRIu64, m_order);
    1739     //return false;
    1740   psFree(query3);
    1741   psFree(output2);
    1742 
    1743 
    1744 
    1745   //update the merge_order
    1746 
    1747   psString query4 = NULL;
    1748   psStringAppend(&query4, "update minidvodbProcessed set merge_order = %"PRIu64,m_order);
    1749   psStringAppend(&query4," where minidvodb_id = %" PRIu64,  minidvodb_id);
    1750   //printf("%s", query4);
    1751   if (!p_psDBRunQuery(config->dbh, query4)) {
    1752     // rollback
    1753     if (!psDBRollback(config->dbh)) {
    1754       psError(PS_ERR_UNKNOWN, false, "database error");
    1755     }
    1756     psError(PS_ERR_UNKNOWN, false, "database error");
    1757     psFree(query4);
    1758     return false;
    1759   }
    1760   //
    1761 psFree(query4);
    1762 
    1763 
    1764 
    1765 // since there is only one exp per 'new' set mindvodbRun.state = 'merged'
    1766 
    17671681  psString query2 = NULL ;
    17681682  psStringAppend(&query2, "UPDATE minidvodbRun SET state = 'merged' WHERE minidvodb_id = %'" PRIu64, row->minidvodb_id);
    … …  
    17771691    return false;
    17781692  }
    1779 
    1780 
    1781 
    1782 
    1783 
    1784 
    1785 
    1786 
    17871693  psFree(row);
    17881694  psFree(pendingRow);
    … …  
    17971703    return false;
    17981704  }
    1799 
    1800 
    1801   //print the merge_order (why not!)
    1802   printf("%s", final);
    1803   psFree(final);
    1804 
    18051705  return true;
    18061706}
    … …  
    19611861
    19621862  PXOPT_LOOKUP_U64(minidvodb_id,  config->args, "-minidvodb_id", true, false);
    1963   PXOPT_LOOKUP_U64(merge_order,  config->args, "-set_merge_order", false, false);
    19641863  PXOPT_LOOKUP_S16(fault,  config->args, "-set_fault", false, false);
    19651864  PXOPT_LOOKUP_F32(dtime_relphot,  config->args, "-set_dtime_relphot", false, false);
    19661865  PXOPT_LOOKUP_F32(dtime_resort,  config->args, "-set_dtime_resort", false, false);
    1967   PXOPT_LOOKUP_F32(dtime_merge,  config->args, "-set_dtime_merge", false, false);
    1968 PXOPT_LOOKUP_F32(dtime_verify,  config->args, "-set_dtime_verify", false, false);
    19691866PXOPT_LOOKUP_F32(dtime_script,  config->args, "-set_dtime_script", false, false);
    19701867  PXOPT_COPY_S64(config->args, where, "-minidvodb_id",     "minidvodbProcessed.minidvodb_id", "==");
    … …  
    19861883  }
    19871884
    1988   if (merge_order) {
    1989     if (cnt) {
    1990       psStringAppend(&query, "%s", comma);
    1991     }
    1992 
    1993     psStringAppend(&query, " merge_order = %" PRId64, merge_order);
    1994     cnt++;
    1995   }
    1996 
    19971885  if (dtime_relphot) {
    19981886    if (cnt) {
    … …  
    20111899  }
    20121900
    2013   if (dtime_merge) {
    2014     if (cnt) {
    2015       psStringAppend(&query, "%s", comma);
    2016     }
    2017     psStringAppend(&query, " dtime_merge = %f", dtime_merge);
    2018     cnt++;
    2019  }
    2020 if (dtime_verify) {
    2021     if (cnt) {
    2022       psStringAppend(&query, "%s", comma);
    2023     }
    2024     psStringAppend(&query, " dtime_verify = %f", dtime_verify);
    2025     cnt++;
    2026  }
    2027 if (dtime_script) {
     1901  if (dtime_script) {
    20281902    if (cnt) {
    20291903      psStringAppend(&query, "%s", comma);

  • branches/haf_add201112/ippTools/src/addtoolConfig.c

    r31680 r33003  
    165165    psMetadataAddStr(addminidvodbrunArgs, PS_LIST_TAIL, "-set_minidvodb_group",        0, "define minidvodb_group (required)", NULL);
    166166    psMetadataAddStr(addminidvodbrunArgs, PS_LIST_TAIL, "-set_minidvodb_path",        0, "define path for minidvodb", NULL);
    167     psMetadataAddStr(addminidvodbrunArgs, PS_LIST_TAIL, "-set_mergedvodb_path",        0, "define path for the merged dvodb (required)", NULL);
    168167    psMetadataAddStr(addminidvodbrunArgs, PS_LIST_TAIL, "-set_state",        0, "define state", NULL);
    169168
    … …  
    174173    psMetadataAddStr(updateminidvodbrunArgs, PS_LIST_TAIL, "-minidvodb_name",        0, "search by minidvodb_name (LIKE)", NULL);
    175174    psMetadataAddStr(updateminidvodbrunArgs, PS_LIST_TAIL, "-minidvodb_path",        0, "search by path for minidvodb", NULL);
    176     psMetadataAddStr(updateminidvodbrunArgs, PS_LIST_TAIL, "-mergedvodb_path",        0, "search by path for the merged dvodb", NULL);
    177175    psMetadataAddStr(updateminidvodbrunArgs, PS_LIST_TAIL, "-state",        0, "search by state", NULL);
    178176    psMetadataAddStr(updateminidvodbrunArgs, PS_LIST_TAIL, "-set_minidvodb_name",        0, "define minidvodb_name", NULL);
    179177    psMetadataAddStr(updateminidvodbrunArgs, PS_LIST_TAIL, "-set_minidvodb_path",        0, "define path for minidvodb", NULL);
    180     psMetadataAddStr(updateminidvodbrunArgs, PS_LIST_TAIL, "-set_mergedvodb_path",        0, "define path for minidvodb", NULL);
    181178    psMetadataAddStr(updateminidvodbrunArgs, PS_LIST_TAIL, "-set_minidvodb_group",        0, "define path for the merged dvodb", NULL);
    182179    psMetadataAddStr(updateminidvodbrunArgs, PS_LIST_TAIL, "-set_state",        0, "define state", NULL);
    … …  
    205202    psMetadata *addminidvodbprocessedArgs = psMetadataAlloc();
    206203    psMetadataAddU64(addminidvodbprocessedArgs, PS_LIST_TAIL, "-minidvodb_id", 0,    "define minidvodb_id (required)", 0);
    207     psMetadataAddU64(addminidvodbprocessedArgs, PS_LIST_TAIL, "-merge_order",    0,    "define merge order", 0);
    208204    psMetadataAddF32(addminidvodbprocessedArgs, PS_LIST_TAIL, "-dtime_relphot",  0,    "define elapsed time for relphot (seconds)", NAN);
    209205    psMetadataAddF32(addminidvodbprocessedArgs, PS_LIST_TAIL, "-dtime_resort", 0,    "define elapsed time for resort (seconds)", NAN);
    210     psMetadataAddF32(addminidvodbprocessedArgs, PS_LIST_TAIL, "-dtime_verify",    0,    "define elapsed time for DVO verify (seconds)", NAN);
    211     psMetadataAddF32(addminidvodbprocessedArgs, PS_LIST_TAIL, "-dtime_merge",    0,    "define elapsed time for DVO merge (seconds)", NAN);
    212206    psMetadataAddF32(addminidvodbprocessedArgs, PS_LIST_TAIL, "-dtime_script",    0,    "define elapsed time for script (seconds)", NAN);
    213207    psMetadataAddTime(addminidvodbprocessedArgs, PS_LIST_TAIL, "-epoch",         0,    "time merge is finished", NULL);
    214     psMetadataAddStr(addminidvodbprocessedArgs, PS_LIST_TAIL, "-mergedvodb_path",0,    "path of merged dvodb", NULL);
    215208    psMetadataAddStr(addminidvodbprocessedArgs, PS_LIST_TAIL, "-minidvodb_group",0,    "minidvodb_group", NULL);
    216209    psMetadataAddS16(addminidvodbprocessedArgs, PS_LIST_TAIL, "-fault",          0,    "set fault code", 0);
    … …  
    232225    psMetadataAddStr(updateminidvodbprocessedArgs, PS_LIST_TAIL, "-minidvodb_name",        0, "search by minidvodb_name", NULL);
    233226    psMetadataAddS16(updateminidvodbprocessedArgs, PS_LIST_TAIL, "-set_fault",  0,            "set fault code", 0);
    234     psMetadataAddU64(updateminidvodbprocessedArgs, PS_LIST_TAIL, "-set_merge_order",    0,    "define merge order", 0);
    235227    psMetadataAddF32(updateminidvodbprocessedArgs, PS_LIST_TAIL, "-set_dtime_relphot",  0,    "define elapsed time for relphot (seconds)", 0);
    236228    psMetadataAddF32(updateminidvodbprocessedArgs, PS_LIST_TAIL, "-set_dtime_resort", 0,    "define elapsed time for resort (seconds)", 0);
    237     psMetadataAddF32(updateminidvodbprocessedArgs, PS_LIST_TAIL, "-set_dtime_verify",    0,    "define elapsed time for DVO verify (seconds)", 0);
    238     psMetadataAddF32(updateminidvodbprocessedArgs, PS_LIST_TAIL, "-set_dtime_merge",    0,    "define elapsed time for DVO merge (seconds)", 0);
    239229    psMetadataAddF32(updateminidvodbprocessedArgs, PS_LIST_TAIL, "-set_dtime_script",    0,    "define elapsed time for script (seconds)", 0);
    240230    psMetadata *argSets = psMetadataAlloc();

  • branches/haf_add201112/ippTools/src/mergetool.c

    r32980 r33003  
    3737static bool revertmergedMode(pxConfig *config);
    3838static bool updatemergedMode(pxConfig *config);
     39static bool definebyquerymergecopyMode(pxConfig *config);
     40static bool listmergedvodbcopyMode(pxConfig *config);
     41static bool revertmergedvodbcopyMode(pxConfig *config);
     42static bool updatemergedvodbcopyMode(pxConfig *config);
    3943
    4044
    … …  
    6569        MODECASE(MERGETOOL_MODE_REVERTMERGED, revertmergedMode);
    6670        MODECASE(MERGETOOL_MODE_UPDATEMERGED, updatemergedMode);
     71        MODECASE(MERGETOOL_MODE_DEFINEBYQUERYMERGECOPY,        definebyquerymergecopyMode);
     72        MODECASE(MERGETOOL_MODE_LISTMERGEDVODBCOPY, listmergedvodbcopyMode);
     73        MODECASE(MERGETOOL_MODE_REVERTMERGEDVODBCOPY, revertmergedvodbcopyMode);
     74        MODECASE(MERGETOOL_MODE_UPDATEMERGEDVODBCOPY, updatemergedvodbcopyMode);
    6775
    6876
    … …  
    803811}
    804812
    805 
    806 
    807 
    808 
    809 
    810 
     813static bool definebyquerymergecopyMode(pxConfig *config)
     814{
     815    PS_ASSERT_PTR_NON_NULL(config, NULL);
     816
     817    psMetadata *where = psMetadataAlloc();
     818    PXOPT_COPY_S64(config->args, where,  "-merge_id",    "mergedvodbRun.merge_id", "==");
     819    pxAddLabelSearchArgs (config, where, "-mergedvodb",     "mergedvodbRun.mergedvodb", "=="); // define using camRun label
     820   
     821
     822
     823    if (!psListLength(where->list)) {
     824        psFree(where);
     825        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     826        return false;
     827    }
     828
     829    PXOPT_LOOKUP_STR(destination_host,     config->args, "-set_destination_host", false, false);
     830    PXOPT_LOOKUP_STR(mergedvodb_rsync_path, config->args, "-set_mergedvodb_rsync_path", false, false);
     831    PXOPT_LOOKUP_BOOL(pretend,    config->args, "-pretend", false);
     832    PXOPT_LOOKUP_BOOL(simple,     config->args, "-simple", false);
     833    PXOPT_LOOKUP_BOOL(last_merged, config->args, "-last_merged", false);
     834    // prevent queueing an addRun if a given exposure has already been added to
     835    // the given dvo database
     836    psString dvodb_string = NULL;
     837    psString bare_query = NULL;
     838    if (destination_host) {
     839      psTrace("mergedvodbtool.c", PS_LOG_INFO, "destination_host argument found (%s) using mergedvodbtool_find_merge_id_dvo.sql\n", destination_host);
     840        // find the cam_id of all the exposures that we want to queue up.
     841        bare_query = pxDataGet("mergedvodbtool_find_merge_id_dvo.sql");
     842        // user supplied dvodb
     843        psStringAppend(&dvodb_string, "mergedvodbCopy.destination_host = '%s'", destination_host);
     844    } else {
     845      psError(PS_ERR_UNKNOWN, false, "cannot queue mergedvodbcopy run without a defined destination_host");
     846       
     847            return false;
     848         }
     849
     850   if (!bare_query) {
     851        psError(PXTOOLS_ERR_SYS, false, "failed to retrieve SQL statement");
     852        psFree(where);
     853        return false;
     854    }
     855    // Take the bare query and add the dvodb selector
     856    psString query = NULL;
     857    psStringAppend(&query, bare_query, dvodb_string);
     858    psFree(dvodb_string);
     859    psFree(bare_query);
     860
     861    // use psDBGenerateWhereConditionSQL because the SQL ends in a WHERE
     862    if (where && psListLength(where->list)) {
     863        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     864        psStringAppend(&query, " AND %s", whereClause);
     865        psFree(whereClause);
     866    } else {
     867        psError(PS_ERR_UNKNOWN, true, "search parameters are required");
     868        return false;
     869    }
     870    if (last_merged) {
     871      psStringAppend(&query, " ORDER BY merge_order DESC LIMIT 1");
     872    }
     873
     874    psFree(where);
     875
     876   if (!p_psDBRunQuery(config->dbh, query)) {
     877        psError(PS_ERR_UNKNOWN, false, "database error");
     878        psFree(query);
     879        return false;
     880    }
     881    psFree(query);
     882
     883    psArray *output = p_psDBFetchResult(config->dbh);
     884    if (!output) {
     885        psError(PS_ERR_UNKNOWN, false, "database error");
     886        return false;
     887    }
     888   if (!psArrayLength(output)) {
     889        psTrace("addtool", PS_LOG_INFO, "no rows found");
     890        psFree(output);
     891        return true;
     892    }
     893
     894    if (pretend) {
     895        // negative simple so the default is true
     896        if (!ippdbPrintMetadatas(stdout, output, "mergedvodbCopy", !simple)) {
     897            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     898            psFree(output);
     899            return false;
     900        }
     901        psFree(output);
     902        return true;
     903    }
     904
     905    // loop over our list of camRun rows to check the supplied and selected dvodb and workdir values:
     906    for (long i = 0; i < psArrayLength(output); i++) {
     907        psMetadata *md = output->data[i];
     908
     909        mergedvodbRunRow *row = mergedvodbRunObjectFromMetadata(md);
     910        if (!row) {
     911            psError(PS_ERR_UNKNOWN, false, "failed to convert metadata into mergedvodbRun");
     912            psFree(output);
     913            return false;
     914        }
     915
     916        if (!mergedvodb_rsync_path) {
     917            psError(PS_ERR_UNKNOWN, false, "cannot queue mergedvodbcopy run without a defined mergedvodb_rsync_path: merge_id %" PRId64, row->merge_id);
     918            psFree(output);
     919            return false;
     920        }
     921        if (!destination_host) {
     922            psError(PS_ERR_UNKNOWN, false, "cannot queue mergedvodbcopy run without a defined destination_host: merge_id %" PRId64, row->merge_id);
     923            psFree(output);
     924            return false;
     925        }
     926
     927        psFree(row);
     928    }
     929
     930    // start a transaction so we don't end up with an exp without any associted
     931    // imfiles
     932    if (!psDBTransaction(config->dbh)) {
     933        psError(PS_ERR_UNKNOWN, false, "database error");
     934        psFree(output);
     935        return false;
     936    }
     937
     938  for (long i = 0; i < psArrayLength(output); i++) {
     939        psMetadata *md = output->data[i];
     940
     941        mergedvodbRunRow *row = mergedvodbRunObjectFromMetadata(md);
     942        if (!row) {
     943            psError(PS_ERR_UNKNOWN, false, "failed to convert metadata into camRun");
     944            psFree(output);
     945            return false;
     946        }
     947
     948        // queue the exp
     949        if (!pxaddQueueByMergeID(config,
     950                               row->merge_id,
     951                                     destination_host ? destination_host : "NULL",
     952                                     mergedvodb_rsync_path ?mergedvodb_rsync_path : "NULL"
     953        )) {
     954            if (!psDBRollback(config->dbh)) {
     955                psError(PS_ERR_UNKNOWN, false, "database error sfg");
     956            }
     957            psError(PS_ERR_UNKNOWN, false,
     958                    "failed to trying to queue merge_id: %" PRId64, row->merge_id);
     959            psFree(row);
     960            psFree(output);
     961            return false;
     962        }
     963        psFree(row);
     964    }
     965    psFree(output);
     966
     967    if (!psDBCommit(config->dbh)) {
     968        psError(PS_ERR_UNKNOWN, false, "database error");
     969        return false;
     970    }
     971
     972    return true;
     973}
     974
     975
     976static bool listmergedvodbcopyMode(pxConfig *config) {
     977  psMetadata *where = psMetadataAlloc();
     978  PXOPT_COPY_S64(config->args, where, "-merge_id", "mergedvodbCopy.merge_id", "==");
     979  PXOPT_COPY_STR(config->args, where, "-mergedvodbcopy_id", "mergedvodbCopy.mergedvodbcopy_id", "==");
     980  PXOPT_COPY_STR(config->args, where, "-destination_host", "mergedvodbCopy.destination_host", "==");
     981  PXOPT_COPY_STR(config->args, where, "-mergedvodb", "mergedvodbRun.mergedvodb", "==");
     982  PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     983  PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     984  PXOPT_LOOKUP_BOOL(pending, config->args, "-pending", false);
     985  PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
     986  if (!psListLength(where->list)) {
     987        psFree(where);
     988        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     989        return false;
     990    }
     991
     992  psString query = pxDataGet("mergedvodbtool_find_mergedvodbcopy.sql");
     993    if (!query) {
     994        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     995        return false;
     996    }
     997
     998if (psListLength(where->list)) {
     999        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1000        psStringAppend(&query, " WHERE %s", whereClause);
     1001        psFree(whereClause);
     1002    }
     1003
     1004// we either add AND (condition) or WHERE (condition):
     1005    if (where->list && faulted) {
     1006        // list only faulted rows
     1007        psStringAppend(&query, " %s", " AND mergedvodbCopy.fault != 0");
     1008    }
     1009    if (where->list && !faulted) {
     1010        // don't list faulted rows
     1011        psStringAppend(&query, " %s", " AND mergedvodbCopy.fault = 0");
     1012    }
     1013    if (!where->list && faulted) {
     1014
     1015       // list only faulted rows
     1016        psStringAppend(&query, " %s", " AND mergedvodbCopy.fault != 0");
     1017    }
     1018    if (where->list && !faulted) {
     1019        // don't list faulted rows
     1020        psStringAppend(&query, " %s", " AND mergedvodbCopy.fault = 0");
     1021    }
     1022    if (!where->list && faulted) {
     1023        // list only faulted rows
     1024        psStringAppend(&query, " %s", " WHERE mergedvodbCopy.fault != 0");
     1025    }
     1026    if (!where->list && !faulted) {
     1027        // don't list faulted rows
     1028        psStringAppend(&query, " %s", " WHERE mergedvodbCopy.fault = 0");
     1029    }
     1030    psFree(where);
     1031
     1032    if (pending) {
     1033       //add the cuts for pending (state new, no faults)
     1034      psStringAppend(&query, " %s", " AND mergedvodbCopy.state = 'new' AND mergedvodbCopy.fault = 0 AND mergedvodbCopy.destination_host IS NOT NULL AND mergedvodbCopy.mergedvodb_rsync_path IS NOT NULL");
     1035    }
     1036
     1037
     1038    // order by epoch
     1039    psStringAppend(&query, " ORDER BY mergedvodbcopy_id");
     1040
     1041    // treat limit == 0 as "no limit"
     1042    if (limit) {
     1043        psString limitString = psDBGenerateLimitSQL(limit);
     1044        psStringAppend(&query, " %s", limitString);
     1045        psFree(limitString);
     1046    }
     1047
     1048    if (!p_psDBRunQuery(config->dbh, query)) {
     1049      psError(PS_ERR_UNKNOWN, false, "database error %s ", query);
     1050        psFree(query);
     1051        return false;
     1052    }
     1053    psFree(query);
     1054
     1055    psArray *output = p_psDBFetchResult(config->dbh);
     1056    if (!output) {
     1057        psError(PS_ERR_UNKNOWN, false, "database error");
     1058        return false;
     1059    }
     1060    if (!psArrayLength(output)) {
     1061        psTrace("addtool", PS_LOG_INFO, "no rows found");
     1062        psFree(output);
     1063        return true;
     1064    }
     1065
     1066    // negate simple so the default is true
     1067    if (!ippdbPrintMetadatas(stdout, output, "mergedvodbCopy", !simple)) {
     1068        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1069        psFree(output);
     1070        return false;
     1071    }
     1072
     1073    psFree(output);
     1074
     1075return true;
     1076}
     1077
     1078static bool revertmergedvodbcopyMode(pxConfig *config) {
     1079  psMetadata *where = psMetadataAlloc();
     1080  PS_ASSERT_PTR_NON_NULL(config, false);
     1081  PXOPT_COPY_S64(config->args, where, "-mergedvodbcopy_id", "mergedvodbCopy.mergedvodbcopy_id", "==");
     1082  PXOPT_COPY_S64(config->args, where, "-merge_id", "mergedvodbCopy.merge_id", "==");
     1083  PXOPT_COPY_STR(config->args, where, "-destination_host", "destination_host", "==");
     1084  PXOPT_COPY_S16(config->args, where, "-fault", "mergedvodbCopy.fault", "==");
     1085
     1086  if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
     1087    psFree(where);
     1088    psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     1089    return false;
     1090  }
     1091
     1092  if (!psDBTransaction(config->dbh)) {
     1093      psError(PS_ERR_UNKNOWN, false, "database error");
     1094      psFree(where);
     1095      return false;
     1096  }
     1097
     1098  {
     1099    psString query = pxDataGet("mergedvodbtool_revertmergedvodbcopy.sql");
     1100    if (!query) {
     1101      // rollback
     1102      if (!psDBRollback(config->dbh)) {
     1103        psError(PS_ERR_UNKNOWN, false, "database error");
     1104      }
     1105      psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1106      psFree(where);
     1107      return false;
     1108    }
     1109
     1110    // use psDBGenerateWhereConditionalSQL with AND ... because the SQL ends in a WHERE
     1111    if (where && psListLength(where->list)) {
     1112      psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1113      psStringAppend(&query, " AND %s", whereClause);
     1114      psFree(whereClause);
     1115    }
     1116   if (!p_psDBRunQuery(config->dbh, query)) {
     1117      // rollback
     1118      if (!psDBRollback(config->dbh)) {
     1119        psError(PS_ERR_UNKNOWN, false, "database error %s", query);
     1120      }
     1121      psError(PS_ERR_UNKNOWN, false, "database error %s", query );
     1122      psFree(query);
     1123      psFree(where);
     1124            return false;
     1125    }
     1126    psFree(query);
     1127  }
     1128  psFree(where);
     1129
     1130  if (!psDBCommit(config->dbh)) {
     1131    psError(PS_ERR_UNKNOWN, false, "database error");
     1132    return false;
     1133  }
     1134
     1135  return true;
     1136}
     1137
     1138static bool updatemergedvodbcopyMode(pxConfig *config) {
     1139  PS_ASSERT_PTR_NON_NULL(config, false);
     1140  psMetadata *where = psMetadataAlloc();
     1141  PXOPT_LOOKUP_U64(mergedvodbcopy_id,  config->args, "-mergedvodbcopy_id", false, false);
     1142  PXOPT_LOOKUP_U64(merge_id,  config->args, "-merge_id", false, false);
     1143  PXOPT_LOOKUP_STR(state,  config->args, "-state", false, false);
     1144  PXOPT_LOOKUP_STR(host,  config->args, "-host", false, false);
     1145  PXOPT_LOOKUP_STR(rsync_path,  config->args, "-mergedvodb_rsync_path", false, false);
     1146  PXOPT_LOOKUP_S16(fault,  config->args, "-fault", false, false);
     1147 
     1148  PXOPT_LOOKUP_S16(set_fault,  config->args, "-set_fault", false, false);
     1149  PXOPT_LOOKUP_STR(set_rsync_path,  config->args, "-set_mergedvodb_rsync_path", false, false);
     1150  PXOPT_LOOKUP_STR(set_host,  config->args, "-set_destination_host", false, false);
     1151  PXOPT_LOOKUP_STR(set_state,  config->args, "-set_state", false, false);
     1152  PXOPT_LOOKUP_F32(dtime,  config->args, "-set_dtime", false, false);
     1153  PXOPT_COPY_S64(config->args, where, "-mergedvodbcopy_id",     "mergedvodbCopy.mergedvodbcopy_id", "==");
     1154  PXOPT_COPY_S64(config->args, where, "-merge_id",     "mergedvodbCopy.merge_id", "==");
     1155 
     1156  PXOPT_COPY_STR(config->args, where, "-state",     "mergedvodbCopy.state", "==");
     1157  PXOPT_COPY_STR(config->args, where, "-host",     "mergedvodbCopy.destination_host", "==");
     1158  PXOPT_COPY_STR(config->args, where, "-mergedvodb_rsync_path",     "mergedvodbCopy.mergedvodb_rsync_path", "==");
     1159
     1160
     1161  if (!psListLength(where->list)) {
     1162    psFree(where);
     1163    psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     1164    return false;
     1165  }
     1166
     1167  psString query = psStringCopy("UPDATE mergedvodbCopy JOIN mergedvodbRun USING (merge_id) SET ");
     1168  int cnt = 0;
     1169  psString comma = ",";
     1170  if (set_fault) {
     1171    psStringAppend(&query, " mergedvodbCopy.fault = %d", set_fault);
     1172  cnt++;
     1173  }
     1174  if (set_rsync_path) {
     1175    if (cnt) {
     1176      psStringAppend(&query, "%s", comma);
     1177    }
     1178
     1179    psStringAppend(&query, " mergedvodbCopy.mergedvodb_rsync_path = '%s'" , set_rsync_path);
     1180    cnt++;
     1181  }
     1182
     1183  if (set_host) {
     1184    if (cnt) {
     1185      psStringAppend(&query, "%s", comma);
     1186    }
     1187
     1188    psStringAppend(&query, " mergedvodbCopy.destination_host = '%s'" , set_host);
     1189    cnt++;
     1190  }
     1191
     1192
     1193  if (set_state) {
     1194    if (cnt) {
     1195      psStringAppend(&query, "%s", comma);
     1196    }
     1197
     1198    psStringAppend(&query, " mergedvodbCopy.state = '%s'" , set_state);
     1199    cnt++;
     1200  }
     1201
     1202  if (dtime) {
     1203    if (cnt) {
     1204      psStringAppend(&query, "%s", comma);
     1205    }
     1206    psStringAppend(&query, " mergedvodbCopy.dtime = %f", dtime);
     1207    cnt++;
     1208  }
     1209
     1210    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1211  psStringAppend(&query, " WHERE %s", whereClause);
     1212
     1213
     1214  if (!p_psDBRunQuery(config->dbh, query)) {
     1215    psError(PS_ERR_UNKNOWN, false, "database error %s", query);
     1216   psFree(query);
     1217   return false;
     1218  }
     1219
     1220  psFree(query);
     1221  psFree(where);
     1222
     1223  return true;
     1224}
     1225
     1226
     1227

  • branches/haf_add201112/ippTools/src/mergetool.h

    r32980 r33003  
    11/*
    2  * addtool.h
     2 * mergetool.h
    33 *
    4  * Copyright (C) 2006  Joshua Hoblitt, Christopher Waters
    54 *
    65 * This program is free software; you can redistribute it and/or modify it
    … …  
    3130  MERGETOOL_MODE_LISTMERGED,
    3231  MERGETOOL_MODE_REVERTMERGED,
    33   MERGETOOL_MODE_UPDATEMERGED
     32  MERGETOOL_MODE_UPDATEMERGED,
     33  MERGETOOL_MODE_DEFINEBYQUERYMERGECOPY,
     34  MERGETOOL_MODE_LISTMERGEDVODBCOPY,
     35  MERGETOOL_MODE_REVERTMERGEDVODBCOPY,
     36  MERGETOOL_MODE_UPDATEMERGEDVODBCOPY
    3437} mergetoolMode;
    3538

  • branches/haf_add201112/ippTools/src/mergetoolConfig.c

    r32980 r33003  
    111111    psMetadataAddF32(updatemergedArgs, PS_LIST_TAIL, "-set_dtime_script",    0,    "define elapsed time for script (seconds)", 0);
    112112    psMetadataAddStr(updatemergedArgs, PS_LIST_TAIL, "-set_state",        0, "change the state", NULL);
     113  // -definebyquerymergecopy
     114    psMetadata *definebyquerymergecopyArgs = psMetadataAlloc();
     115    psMetadataAddS64(definebyquerymergecopyArgs, PS_LIST_TAIL, "-merge_id",             0, "search by merge_id", 0);
     116    psMetadataAddStr(definebyquerymergecopyArgs, PS_LIST_TAIL, "-mergedvodb", PS_META_DUPLICATE_OK, "search by mergedvodb", NULL);
     117    psMetadataAddStr(definebyquerymergecopyArgs, PS_LIST_TAIL, "-set_mergedvodb_rsync_path",        0, "define workdir", NULL);
     118    psMetadataAddStr(definebyquerymergecopyArgs, PS_LIST_TAIL, "-set_destination_host",          0, "set destination host", NULL);
     119    psMetadataAddBool(definebyquerymergecopyArgs, PS_LIST_TAIL, "-pretend",           0, "do not actually modify the database", false);
     120    psMetadataAddBool(definebyquerymergecopyArgs, PS_LIST_TAIL, "-simple",            0, "use the simple output format", false);
     121    psMetadataAddBool(definebyquerymergecopyArgs, PS_LIST_TAIL, "-last_merged",            0, "if multiple minidvodbs have been dvomerged between rsyncs, then only queue the most recent merged dvodb for copying", false);
     122
     123   psMetadata *listmergedvodbcopyArgs = psMetadataAlloc();
     124    psMetadataAddU64(listmergedvodbcopyArgs, PS_LIST_TAIL, "-merge_id",        0, "search by mergedvodb_id", 0);
     125    psMetadataAddStr(listmergedvodbcopyArgs, PS_LIST_TAIL, "-mergedvodbcopy_id",        0, "search by mergedvodbcopy_id", NULL);
     126    psMetadataAddStr(listmergedvodbcopyArgs, PS_LIST_TAIL, "-mergedvodb",         0, "search by mergedvodbRun.mergedvodb", NULL);
     127    psMetadataAddStr(listmergedvodbcopyArgs, PS_LIST_TAIL, "-destination_host",        0, "search by mergedvodbCopy.destination_host", NULL);
     128    psMetadataAddBool(listmergedvodbcopyArgs, PS_LIST_TAIL, "-pending",        0, "limit to pending items", false);
     129    psMetadataAddU64(listmergedvodbcopyArgs, PS_LIST_TAIL, "-limit",        0, "limit to N items", 0);
     130    psMetadataAddBool(listmergedvodbcopyArgs, PS_LIST_TAIL, "-simple",        0, "simple output", false);
     131    psMetadataAddBool(listmergedvodbcopyArgs, PS_LIST_TAIL, "-faulted",        0, "limit to faulted state", false);
     132
     133    psMetadata *revertmergedvodbcopyArgs = psMetadataAlloc();
     134    psMetadataAddU64(revertmergedvodbcopyArgs, PS_LIST_TAIL, "-mergedvodbcopy_id",        0, "search by mergedvodbcopy_id", 0);
     135    psMetadataAddU64(revertmergedvodbcopyArgs, PS_LIST_TAIL, "-merge_id",        0, "search by merge_id", 0);
     136    psMetadataAddStr(revertmergedvodbcopyArgs, PS_LIST_TAIL, "-destination_host",        0, "search by destination_host", NULL);
     137    psMetadataAddS16(revertmergedvodbcopyArgs, PS_LIST_TAIL, "-fault",        0, "search by mergedvodbCopyfault", 0);
     138    psMetadata *updatemergedvodbcopyArgs = psMetadataAlloc();
     139    psMetadataAddU64(updatemergedvodbcopyArgs, PS_LIST_TAIL, "-mergedvodbcopy_id",        0, "search by mergedvodbcopy_id", 0);
     140    psMetadataAddU64(updatemergedvodbcopyArgs, PS_LIST_TAIL, "-merge_id",        0, "search by merge_id", 0);
     141    psMetadataAddStr(updatemergedvodbcopyArgs, PS_LIST_TAIL, "-state",        0, "search by state", NULL);
     142    psMetadataAddStr(updatemergedvodbcopyArgs, PS_LIST_TAIL, "-host",        0, "search by host", NULL);
     143    psMetadataAddStr(updatemergedvodbcopyArgs, PS_LIST_TAIL, "-mergedvodb_rsync_path",        0, "search by rsync", NULL);
     144    psMetadataAddS16(updatemergedvodbcopyArgs, PS_LIST_TAIL, "-fault",  0,            "search by fault code", 0);
     145 
     146
     147    psMetadataAddS16(updatemergedvodbcopyArgs, PS_LIST_TAIL, "-set_fault",  0,            "set fault code", 0);
     148 
     149    psMetadataAddF32(updatemergedvodbcopyArgs, PS_LIST_TAIL, "-set_dtime",  0,    "set elapsed time for transfer", 0);
     150    psMetadataAddStr(updatemergedvodbcopyArgs, PS_LIST_TAIL, "-set_mergedvodb_rsync_path",        0, "change the mergedvodb_rsync_path", NULL);
     151    psMetadataAddStr(updatemergedvodbcopyArgs, PS_LIST_TAIL, "-set_destination_host",        0, "change the host", NULL);
     152    psMetadataAddStr(updatemergedvodbcopyArgs, PS_LIST_TAIL, "-set_state",        0, "change the state", NULL);
     153
     154
     155
     156
     157
    113158
    114159    psMetadata *argSets = psMetadataAlloc();
    … …  
    122167    PXOPT_ADD_MODE("-revertmerged","revert merged dvodbs",        MERGETOOL_MODE_REVERTMERGED,     revertmergedArgs);
    123168    PXOPT_ADD_MODE("-updatemerged","change merged dvodb properties",MERGETOOL_MODE_UPDATEMERGED,  updatemergedArgs);
    124  
     169 PXOPT_ADD_MODE("-definebyquerymergecopy",   "create runs from mergedvodbRun",  MERGETOOL_MODE_DEFINEBYQUERYMERGECOPY, definebyquerymergecopyArgs);
     170 PXOPT_ADD_MODE("-listmergedvodbcopy","list copy mergedvodbs", MERGETOOL_MODE_LISTMERGEDVODBCOPY, listmergedvodbcopyArgs);
     171    PXOPT_ADD_MODE("-revertmergedvodbcopy","revert copy mergedvobs",MERGETOOL_MODE_REVERTMERGEDVODBCOPY,     revertmergedvodbcopyArgs);
     172    PXOPT_ADD_MODE("-updatemergedvodbcopy","change mergedvodb copy properties",MERGETOOL_MODE_UPDATEMERGEDVODBCOPY,  updatemergedvodbcopyArgs);
     173
    125174
    126175

  • branches/haf_add201112/ippTools/src/minidvodbtool.c

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

  • branches/haf_add201112/ippTools/src/pxmerge.c

    r32980 r33003  
    4747        }
    4848    }
     49    if (!p_psDBRunQueryF(config->dbh,"INSERT INTO mergedvodbRun SELECT         0,   minidvodb_id, '%s', '%s', 'new', NULL FROM minidvodbRun     WHERE    minidvodbRun.minidvodb_id = %lld and minidvodbRun.state = 'merged'", mergedvodb, mergedvodb_path, (long long) minidvodb_id))
     50    {
     51      psError(PS_ERR_UNKNOWN, false, "database error %s", query);
     52        return false;
     53    }
     54    // just to be safe, we should have changed at least one row
     55    if (psDBAffectedRows(config->dbh) < 1) {
     56        psError(PS_ERR_UNKNOWN, false,
     57                "no rows affected - should have changed at least one row \n%s", query);
     58        return false;
     59    }
     60    return true;
     61}
    4962
    50     // queue the exp
    51     // Note: cam_id is being cast here work around psS64 have a different type different
    52     // on 32/64
    53     //if (!p_psDBRunQueryF(config->dbh, query,
    54     //                   minidvodb_rsync_path   ? minidvodb_rsync_path     : "NULL",
    55     //                   destination_host  ? destination_host   : "NULL",
    56     //                           0,  //fault
    57                            //                    "new", // state
    58     //                   "NULL",
    59                                                    //                      0, //dtime
    60                        
    61                                                                              //                    (long long) minidvodb_id
    62     //    ))
    63     if (!p_psDBRunQueryF(config->dbh,"INSERT INTO mergedvodbRun SELECT         0,   minidvodb_id, '%s', '%s', 'new', NULL FROM minidvodbRun     WHERE    minidvodbRun.minidvodb_id = %lld and minidvodbRun.state = 'merged'", mergedvodb, mergedvodb_path, (long long) minidvodb_id))
     63bool pxaddQueueByMergeID(pxConfig *config,
     64                       psS64 merge_id,
     65                       char *destination_host,
     66                       char *mergedvodb_rsync_path
     67  )
     68{
     69    PS_ASSERT_PTR_NON_NULL(config, false);
     70
     71    // load the SQL to enqueue our exp_ids from disk once
     72    static psString query = NULL;
     73    if (!query) {
     74        query = pxDataGet("mergetool_queue_mergecopy_id.sql");
     75        psMemSetPersistent(query, true);
     76        if (!query) {
     77            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     78            return false;
     79        }
     80    }
     81
     82    if (!p_psDBRunQueryF(config->dbh,"INSERT INTO mergedvodbCopy SELECT         0,   merge_id, '%s', '%s', 0, 'new', NULL, 0 FROM mergedvodbRun     WHERE    mergedvodbRun.merge_id = %lld and (mergedvodbRun.state = 'merged' or mergedvodbRun.state = 'full')", mergedvodb_rsync_path, destination_host, (long long) merge_id))
    6483
    6584    {

  • branches/haf_add201112/ippTools/src/pxmerge.h

    r32980 r33003  
    3232                       );
    3333
     34bool pxaddQueueByMergeID(pxConfig *config,
     35                       psS64 merge_id,
     36                       char *destination_host,
     37                       char *mergedvodb_rsync_path
     38                       );
     39
     40
    3441#endif // PXMERGE_H
Note: See TracChangeset for help on using the changeset viewer.