IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 29441


Ignore:
Timestamp:
Oct 15, 2010, 7:31:09 PM (16 years ago)
Author:
heather
Message:

minidvodbtool now works

Location:
branches/haf_branches/ipp.rsync.20101015/ippTools
Files:
2 added
5 edited

Legend:

Unmodified
Added
Removed

  • branches/haf_branches/ipp.rsync.20101015/ippTools/share/Makefile.am

    r29440 r29441  
    265265        magicdstool_torevert_diff.sql \
    266266        minidvodbtool_find_minidvodb_id_dvo.sql \
     267        minidvodbtool_find_minidvodbcopy.sql \
    267268        minidvodbtool_revertminidvodbcopy.sql \
    268269        pstamptool_completedreq.sql \

  • branches/haf_branches/ipp.rsync.20101015/ippTools/share/minidvodbtool_revertminidvodbcopy.sql

    r29440 r29441  
    1 DELETE minidvodbCopy
    2     SET state = 'new',
    3     SET fault = 0
     1UPDATE minidvodbCopy
     2 --   SET minidvodbCopy.state = 'new',
     3    SET minidvodbCopy.fault = 0
    44WHERE
    55    minidvodbCopy.state = 'new'
    66    AND minidvodbCopy.fault >0   
    7 AND addRun.state = 'new'
     7

  • branches/haf_branches/ipp.rsync.20101015/ippTools/src/minidvodbtool.c

    r29440 r29441  
    3232
    3333static bool definebyqueryMode(pxConfig *config);
    34 static bool addminidvodbcopyMode(pxConfig *config);
    3534static bool listminidvodbcopyMode(pxConfig *config);
    3635static bool revertminidvodbcopyMode(pxConfig *config);
    … …  
    5857    switch (config->mode) {
    5958        MODECASE(ADDTOOL_MODE_DEFINEBYQUERY,        definebyqueryMode);
    60         MODECASE(ADDTOOL_MODE_ADDMINIDVODBCOPY, addminidvodbcopyMode);
    6159        MODECASE(ADDTOOL_MODE_LISTMINIDVODBCOPY, listminidvodbcopyMode);
    6260        MODECASE(ADDTOOL_MODE_REVERTMINIDVODBCOPY, revertminidvodbcopyMode);
    … …  
    252250
    253251
    254 static bool addminidvodbcopyMode(pxConfig *config) {
    255 
    256   PS_ASSERT_PTR_NON_NULL(config, false);
    257 
    258     // required
    259   PXOPT_LOOKUP_U64(minidvodb_id, config->args, "-minidvodb_id", true, false);
    260   PXOPT_LOOKUP_STR(mergedvodb_path, config->args, "-mergedvodb_path", true, false);
    261   PXOPT_LOOKUP_STR(minidvodb_group, config->args, "-minidvodb_group", true, false);
    262 
    263     // optional
    264   PXOPT_LOOKUP_U64(merge_order,     config->args, "-merge_order", false, false);
    265   PXOPT_LOOKUP_F32(dtime_relphot, config->args, "-dtime_relphot", false, false);
    266   PXOPT_LOOKUP_F32(dtime_resort, config->args, "-dtime_resort", false, false);
    267   PXOPT_LOOKUP_F32(dtime_merge, config->args, "-dtime_merge", false, false);
    268   PXOPT_LOOKUP_TIME(epoch, config->args, "-epoch", false, false);
    269   PXOPT_LOOKUP_S16(fault,         config->args, "-fault", false, false);
    270     //generate restrictions
    271   psMetadata *where = psMetadataAlloc();
    272   PXOPT_COPY_S64(config->args, where, "-minidvodb_id",   "minidvodbRun.minidvodb_id",   "==");
    273 
    274 
    275   if (!psDBTransaction(config->dbh)) {
    276     psError(PS_ERR_UNKNOWN, false, "database error");
    277     return false;
    278   }
    279 
    280 
    281   psString query = pxDataGet("addtool_find_pendingmergeprocess.sql");
    282   if (!query) {
    283     psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    284     return false;
    285   }
    286   // use psDBGenerateWhereSQL because the SQL yields an intermediate table
    287   if (psListLength(where->list)) {
    288     psString whereClaus = psDBGenerateWhereConditionSQL(where, NULL);
    289     psStringAppend(&query, " AND %s", whereClaus);
    290     psFree(whereClaus);
    291   }
    292   psFree(where);
    293 
    294   if (!p_psDBRunQuery(config->dbh, query)) {
    295     psError(PS_ERR_UNKNOWN, false, "database error");
    296     psFree(query);
    297     return false;
    298   }
    299   psFree(query);
    300 
    301   psArray *output = p_psDBFetchResult(config->dbh);
    302   if (!output) {
    303     psError(PS_ERR_UNKNOWN, false, "database error");
    304     return false;
    305   }
    306   if (!psArrayLength(output)) {
    307     psTrace("addtool", PS_LOG_INFO, "no rows found");
    308     psFree(output);
    309     return true;
    310   }
    311   /*
    312   minidvodbRunRow *pendingRow = minidvodbRunObjectFromMetadata(output->data[0]);
    313   psFree(output); */
    314   /* minidvodbCopyRow *row = minidvodbCopyRowAlloc(
    315                pendingRow->minidvodb_id,
    316                merge_order,
    317                dtime_resort,
    318                dtime_relphot,
    319                dtime_merge,
    320                epoch,
    321                mergedvodb_path,
    322                fault
    323                );
    324 
    325   if (!minidvodbCopyInsertObject(config->dbh, row)) {
    326     // rollback
    327     if (!psDBRollback(config->dbh)) {
    328       psError(PS_ERR_UNKNOWN, false, "database error");
    329     }
    330     psError(PS_ERR_UNKNOWN, false, "database error");
    331     psFree(row);
    332     psFree(pendingRow);
    333     return false;
    334   }
    335 
    336 
    337   */
    338   /*
    339   //this finds the # of merged things (for the merge order)
    340   psString query3 = NULL;
    341   psStringAppend(&query3, "select count(*) from minidvodbRun join minidvodbCopy using (minidvodb_id) where state = 'merged' and minidvodb_group = '%s';", minidvodb_group);
    342 
    343   if (!p_psDBRunQuery(config->dbh, query3)) {
    344     // rollback
    345     if (!psDBRollback(config->dbh)) {
    346       psError(PS_ERR_UNKNOWN, false, "database error");
    347     }
    348     psError(PS_ERR_UNKNOWN, false, "database error");
    349     psFree(query3);
    350     return false;
    351   }
    352   psArray *output2 = p_psDBFetchResult(config->dbh);
    353   if (!output2) {
    354     psError(PS_ERR_UNKNOWN, false, "database error");
    355     return false;
    356   }
    357   if (!psArrayLength(output2)) {
    358     psTrace("addtool", PS_LOG_INFO, "no rows found");
    359     psFree(output);
    360     return true;
    361   }
    362   bool status;
    363   psS64 m_order = psMetadataLookupS64(&status, output2->data[0], "count(*)");
    364   if (!status) {
    365 
    366     psAbort("failed to lookup value for count column");
    367     return false;
    368   }
    369   psString final = NULL;
    370   psStringAppend(&final, "%" PRIu64, m_order);
    371     //return false;
    372   psFree(query3);
    373   psFree(output2);
    374 
    375 
    376 
    377   //update the merge_order
    378 
    379   psString query4 = NULL;
    380   psStringAppend(&query4, "update minidvodbCopy set merge_order = %"PRIu64,m_order);
    381   psStringAppend(&query4," where minidvodb_id = %" PRIu64,  minidvodb_id);
    382   printf("%s", query4);
    383   if (!p_psDBRunQuery(config->dbh, query4)) {
    384     // rollback
    385     if (!psDBRollback(config->dbh)) {
    386       psError(PS_ERR_UNKNOWN, false, "database error");
    387     }
    388     psError(PS_ERR_UNKNOWN, false, "database error");
    389     psFree(query4);
    390     return false;
    391   }
    392   //
    393 psFree(query4);
    394 
    395 
    396 
    397 // since there is only one exp per 'new' set mindvodbRun.state = 'merged'
    398 
    399   psString query2 = NULL ;
    400   psStringAppend(&query2, "UPDATE minidvodbRun SET state = 'merged' WHERE minidvodb_id = %'" PRIu64, row->minidvodb_id);
    401 
    402   if (!p_psDBRunQuery(config->dbh, query2)) {
    403     // rollback
    404     if (!psDBRollback(config->dbh)) {
    405       psError(PS_ERR_UNKNOWN, false, "database error");
    406     }
    407     psError(PS_ERR_UNKNOWN, false, "database error");
    408     psFree(query2);
    409     return false;
    410   }
    411 
    412 
    413 
    414 
    415 
    416 
    417 
    418 
    419   psFree(row);
    420   psFree(pendingRow);
    421 
    422 
    423 
    424 
    425 
    426   //commit the changes
    427   if (!psDBCommit(config->dbh)) {
    428     psError(PS_ERR_UNKNOWN, false, "database error");
    429     return false;
    430   }
    431 
    432 
    433   //print the merge_order (why not!)
    434   printf("%s", final);
    435   psFree(final);
    436   */
    437   return true;
    438 }
    439 
    440 
    441 
    442252static bool listminidvodbcopyMode(pxConfig *config) {
    443253  psMetadata *where = psMetadataAlloc();
    444254  PXOPT_COPY_S64(config->args, where, "-minidvodb_id", "minidvodbCopy.minidvodb_id", "==");
    445   PXOPT_COPY_STR(config->args, where, "-minidvodb_name", "minidvodbCopy.minidvodb_name", "==");
    446   PXOPT_COPY_STR(config->args, where, "-minidvodb_group", "minidvodbCopy.minidvodb_group", "==");
     255  PXOPT_COPY_STR(config->args, where, "-minidvodbcopy_id", "minidvodbCopy.minidvodbcopy_id", "==");
     256  PXOPT_COPY_STR(config->args, where, "-destination_host", "minidvodbCopy.destination_host", "==");
    447257  PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    448258  PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    454264    }
    455265
    456   psString query = pxDataGet("addtool_find_minidvodbcopy.sql");
     266  psString query = pxDataGet("minidvodbtool_find_minidvodbcopy.sql");
    457267    if (!query) {
    458268        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    … …  
    486296
    487297    // order by epoch
    488     psStringAppend(&query, " ORDER BY minidvodb_id");
     298    psStringAppend(&query, " ORDER BY minidvodbcopy_id");
    489299
    490300    // treat limit == 0 as "no limit"
    … …  
    496306
    497307    if (!p_psDBRunQuery(config->dbh, query)) {
    498       psError(PS_ERR_UNKNOWN, false, "database error ");
     308      psError(PS_ERR_UNKNOWN, false, "database error %s ", query);
    499309        psFree(query);
    500310        return false;
    … …  
    531341  PS_ASSERT_PTR_NON_NULL(config, false);
    532342  PXOPT_COPY_S64(config->args, where, "-minidvodbcopy_id", "minidvodbCopy.minidvodbcopy_id", "==");
    533   PXOPT_COPY_STR(config->args, where, "-destination_host", "destination host", "==");
     343  PXOPT_COPY_S64(config->args, where, "-minidvodb_id", "minidvodbCopy.minidvodb_id", "==");
     344  PXOPT_COPY_STR(config->args, where, "-destination_host", "destination_host", "==");
    534345
    535346  if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    … …  
    546357
    547358  {
    548     psString query = pxDataGet("addtool_revertminidvodbcopy.sql");
     359    psString query = pxDataGet("minidvodbtool_revertminidvodbcopy.sql");
    549360    if (!query) {
    550361      // rollback
    … …  
    567378      // rollback
    568379      if (!psDBRollback(config->dbh)) {
    569         psError(PS_ERR_UNKNOWN, false, "database error");
     380        psError(PS_ERR_UNKNOWN, false, "database error %s", query);
    570381      }
    571       psError(PS_ERR_UNKNOWN, false, "database error");
     382      psError(PS_ERR_UNKNOWN, false, "database error %s", query );
    572383      psFree(query);
    573384      psFree(where);
    … …  
    621432  psString comma = ",";
    622433  if (set_fault) {
    623     psStringAppend(&query, " fault = %d", set_fault);
     434    psStringAppend(&query, " minidvodbCopy.fault = %d", set_fault);
    624435  cnt++;
    625436  }
    … …  
    630441    }
    631442
    632     psStringAppend(&query, " minidvodb_rsync_path = %s" , set_rsync_path);
     443    psStringAppend(&query, " minidvodbCopy.minidvodb_rsync_path = '%s'" , set_rsync_path);
    633444    cnt++;
    634445  }
    … …  
    639450    }
    640451
    641     psStringAppend(&query, " destination_host = %s" , set_host);
     452    psStringAppend(&query, " minidvodbCopy.destination_host = '%s'" , set_host);
    642453    cnt++;
    643454  }
    … …  
    649460    }
    650461
    651     psStringAppend(&query, " state = %s" , set_state);
     462    psStringAppend(&query, " minidvodbCopy.state = '%s'" , set_state);
    652463    cnt++;
    653464  }
    … …  
    657468      psStringAppend(&query, "%s", comma);
    658469    }
    659     psStringAppend(&query, " dtime = %f", dtime);
     470    psStringAppend(&query, " minidvodbCopy.dtime = %f", dtime);
    660471    cnt++;
    661472  }
    … …  
    667478
    668479  if (!p_psDBRunQuery(config->dbh, query)) {
    669    psError(PS_ERR_UNKNOWN, false, "database error");
     480    psError(PS_ERR_UNKNOWN, false, "database error %s", query);
    670481   psFree(query);
    671482   return false;

  • branches/haf_branches/ipp.rsync.20101015/ippTools/src/minidvodbtool.h

    r29435 r29441  
    2626    ADDTOOL_MODE_NONE      = 0x0,
    2727    ADDTOOL_MODE_DEFINEBYQUERY,
    28     ADDTOOL_MODE_ADDMINIDVODBCOPY,
    2928    ADDTOOL_MODE_LISTMINIDVODBCOPY,
    3029    ADDTOOL_MODE_REVERTMINIDVODBCOPY,

  • branches/haf_branches/ipp.rsync.20101015/ippTools/src/minidvodbtoolConfig.c

    r29440 r29441  
    6060    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple",            0, "use the simple output format", false);
    6161   
    62     psMetadata *addminidvodbcopyArgs = psMetadataAlloc();
    63     psMetadataAddU64(addminidvodbcopyArgs, PS_LIST_TAIL, "-minidvodb_id", 0,    "define minidvodb_id (required)", 0);
    64     psMetadataAddU64(addminidvodbcopyArgs, PS_LIST_TAIL, "-merge_order",    0,    "define merge order", 0);
    65     psMetadataAddF32(addminidvodbcopyArgs, PS_LIST_TAIL, "-dtime_relphot",  0,    "define elapsed time for relphot (seconds)", NAN);
    66     psMetadataAddF32(addminidvodbcopyArgs, PS_LIST_TAIL, "-dtime_resort", 0,    "define elapsed time for resort (seconds)", NAN);
    67     psMetadataAddF32(addminidvodbcopyArgs, PS_LIST_TAIL, "-dtime_merge",    0,    "define elapsed time for DVO merge (seconds)", NAN);
    68     psMetadataAddTime(addminidvodbcopyArgs, PS_LIST_TAIL, "-epoch",         0,    "time merge is finished", NULL);
    69     psMetadataAddStr(addminidvodbcopyArgs, PS_LIST_TAIL, "-mergedvodb_path",0,    "path of merged dvodb", NULL);
    70     psMetadataAddStr(addminidvodbcopyArgs, PS_LIST_TAIL, "-minidvodb_group",0,    "minidvodb_group", NULL);
    71     psMetadataAddS16(addminidvodbcopyArgs, PS_LIST_TAIL, "-fault",          0,    "set fault code", 0);
    72 
    7362    psMetadata *listminidvodbcopyArgs = psMetadataAlloc();
    7463    psMetadataAddU64(listminidvodbcopyArgs, PS_LIST_TAIL, "-minidvodb_id",        0, "search by minidvodb_id", 0);
    75     psMetadataAddStr(listminidvodbcopyArgs, PS_LIST_TAIL, "-minidvodb_name",        0, "search by minidvodb_name", NULL);
    76     psMetadataAddStr(listminidvodbcopyArgs, PS_LIST_TAIL, "-minidvodb_group",        0, "search by minidvodb.minidvodb_group", NULL);
     64    psMetadataAddStr(listminidvodbcopyArgs, PS_LIST_TAIL, "-minidvodbcopy_id",        0, "search by minidvodb_name", NULL);
     65    psMetadataAddStr(listminidvodbcopyArgs, PS_LIST_TAIL, "-destination_host",        0, "search by minidvodb.minidvodb_group", NULL);
    7766    psMetadataAddU64(listminidvodbcopyArgs, PS_LIST_TAIL, "-limit",        0, "limit to N items", 0);
    7867    psMetadataAddBool(listminidvodbcopyArgs, PS_LIST_TAIL, "-simple",        0, "simple output", false);
    … …  
    8170    psMetadata *revertminidvodbcopyArgs = psMetadataAlloc();
    8271    psMetadataAddU64(revertminidvodbcopyArgs, PS_LIST_TAIL, "-minidvodbcopy_id",        0, "search by minidvodbcopy_id", 0);
    83     psMetadataAddStr(revertminidvodbcopyArgs, PS_LIST_TAIL, "-destination host",        0, "search by destination_host", NULL);
     72    psMetadataAddU64(revertminidvodbcopyArgs, PS_LIST_TAIL, "-minidvodb_id",        0, "search by minidvodb_id", 0);
     73    psMetadataAddStr(revertminidvodbcopyArgs, PS_LIST_TAIL, "-destination_host",        0, "search by destination_host", NULL);
    8474
    8575    psMetadata *updateminidvodbcopyArgs = psMetadataAlloc();
    … …  
    10393
    10494    PXOPT_ADD_MODE("-definebyquery",        "create runs from cam stage",           ADDTOOL_MODE_DEFINEBYQUERY, definebyqueryArgs);
    105     PXOPT_ADD_MODE("-addminidvodbcopy","add a copy minidvodb",            ADDTOOL_MODE_ADDMINIDVODBCOPY,  addminidvodbcopyArgs);
    106     PXOPT_ADD_MODE("-listminidvodbcopy","list copy minidvodbs",           ADDTOOL_MODE_LISTMINIDVODBCOPY, listminidvodbcopyArgs);
     95       PXOPT_ADD_MODE("-listminidvodbcopy","list copy minidvodbs",           ADDTOOL_MODE_LISTMINIDVODBCOPY, listminidvodbcopyArgs);
    10796    PXOPT_ADD_MODE("-revertminidvodbcopy","revert copy minidvobs",        ADDTOOL_MODE_REVERTMINIDVODBCOPY,     revertminidvodbcopyArgs);
    10897    PXOPT_ADD_MODE("-updateminidvodbcopy","change minidvodb copy properties",ADDTOOL_MODE_UPDATEMINIDVODBCOPY,  updateminidvodbcopyArgs);
Note: See TracChangeset for help on using the changeset viewer.