IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 33003


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
Files:
4 added
17 edited

Legend:

Unmodified
Added
Removed

  • branches/haf_add201112/dbconfig/minidvodb.md

    r30912 r33003  
    44    minidvodb_group STR    64
    55    minidvodb_path  STR    255
    6     mergedvodb_path STR    255
    76    state           STR    64
    87    creation_date   UTC    0001-01-01T00:00:00Z
    … …  
    1110minidvodbProcessed METADATA
    1211    minidvodb_id    S64    0
    13     merge_order     S64    0
    1412    dtime_resort    F32    0.0
    1513    dtime_relphot   F32    0.0
    16     dtime_verify    F32    0.0
    17     dtime_merge     F32    0.0
    1814    dtime_script    F32    0.0
    1915    epoch           UTC    0001-01-01T00:00:00Z
    20     mergedvodb_path STR    255
    2116    fault           S16    0
    2217END

  • branches/haf_add201112/ippScripts/scripts/minidvodb_createdb.pl

    r28377 r33003  
    226226    $fpaCommand .= " -set_minidvodb_group $minidvodb_group";
    227227    $fpaCommand .= " -set_minidvodb_path  $minidvodbReal" if defined $minidvodbReal;
    228     $fpaCommand .= " -set_mergedvodb_path $dvodbReal";
    229228    $fpaCommand .= " -dbname $dbname" if defined $dbname;
    230229

  • branches/haf_add201112/ippTasks/mergedvodb.pro

    r32987 r33003  
    190190    stderr $LOGDIR/mergedvodb.merge.run.log
    191191
    192     $run = mergedvodb_merge.pl --camera GPC1 --mergedvodb $MERGEDVODB_PATH --minidvodb $MINIDVODB_PATH --mergedvodb $MERGEDVODB --merged_id $MERGE_ID
     192    $run = mergedvodb_merge.pl --camera GPC1 --mergedvodb_path $MERGEDVODB_PATH --minidvodb_path $MINIDVODB_PATH --merged_id $MERGE_ID
    193193   
    194194  if ($DB:n == 0)

  • branches/haf_add201112/ippTasks/minidvodb.pro

    r29634 r33003  
    1111if (not($?haveminidvodbBooks))
    1212 book create MINIDVODB
    13  book create MINIDVODB_MERGE
     13 book create MINIDVODB_PREMERGE
    1414 book create MINIDVODB_CREATE
    1515 book create MINIDVODB_ACTIVE   
    … …  
    2020
    2121$MINIDVODB_WAIT_DB = 0
    22 $MINIDVODB_MERGE_DB = 0
     22$MINIDVODB_PREMERGE_DB = 0
    2323$MINIDVODB_CREATE_DB = 0
    2424$MINIDVODB_ACTIVE_DB = 0
    2525
    2626book init minidvodbWaitlist
    27 book init minidvodbMergelist
     27book init minidvodbPreMergelist
    2828book init minidvodbCreatelist
    2929book init minidvodbActivelist
    … …  
    5454end
    5555
    56 macro minidvodb.merge.status
    57   book listbook minidvodbMergelist
    58 end
    59 
    60 macro minidvodb.merge.reset
    61   book init minidvodbMergelist
     56macro minidvodb.premerge.status
     57  book listbook minidvodbPreMergelist
     58end
     59
     60macro minidvodb.premerge.reset
     61  book init minidvodbPreMergelist
    6262end
    6363
    … …  
    112112##these merge the dbs
    113113
    114 macro minidvodb.merge.on
    115   task minidvodb.merge.load
     114macro minidvodb.premerge.on
     115  task minidvodb.premerge.load
    116116    active true
    117117  end
    118   task minidvodb.merge.run
     118  task minidvodb.premerge.run
    119119    active true
    120120  end 
    121121end
    122 macro minidvodb.merge.off
    123   task minidvodb.merge.load
     122macro minidvodb.premerge.off
     123  task minidvodb.premerge.load
    124124    active false
    125125  end
    126   task minidvodb.merge.run
     126  task minidvodb.premerge.run
    127127    active false
    128128  end 
    … …  
    142142  book setword MINIDVODB $1 STATE PENDING
    143143  #merge 
    144   book newpage MINIDVODB_MERGE $1
    145   book setword MINIDVODB_MERGE $1 MINIDVODB_GROUP $1
    146   book setword MINIDVODB_MERGE $1 DVODB $3
    147   book setword MINIDVODB_MERGE $1 STATE PENDING
     144  book newpage MINIDVODB_PREMERGE $1
     145  book setword MINIDVODB_PREMERGE $1 MINIDVODB_GROUP $1
     146  book setword MINIDVODB_PREMERGE $1 DVODB $3
     147  book setword MINIDVODB_PREMERGE $1 STATE PENDING
    148148  #active 
    149149  book newpage MINIDVODB_ACTIVE $1
    … …  
    168168  end
    169169  book delpage MINIDVODB $1
    170   book delpage MINIDVODB_MERGE $1
     170  book delpage MINIDVODB_PREMERGE $1
    171171  book delpage MINIDVODB_CREATE $1 
    172172  book delpage MINIDVODB_ACTIVE $1
    … …  
    180180  echo "minidvodb wait"
    181181  book listbook MINIDVODB
    182   echo "minidvodb merge"
    183   book listbook MINIDVODB_MERGE
     182  echo "minidvodb premerge"
     183  book listbook MINIDVODB_PREMERGE
    184184  echo "minidvodb create"
    185185  book listbook MINIDVODB_CREATE
    … …  
    339339
    340340
    341 task           minidvodb.merge.load
     341task           minidvodb.premerge.load
    342342  host         local
    343343
    … …  
    348348
    349349  stdout NULL
    350   stderr $LOGDIR/minidvodb.merge.load.log
     350  stderr $LOGDIR/minidvodb.premerge.load.log
    351351
    352352  task.exec
    353     book npages MINIDVODB_MERGE -var N
     353    book npages MINIDVODB_PREMERGE -var N
    354354    if ($N == 0)
    355355#      echo "No labels for processing"
    … …  
    357357    endif
    358358
    359     book getpage MINIDVODB_MERGE 0 -var minidvodb_group -key STATE NEW
     359    book getpage MINIDVODB_PREMERGE 0 -var minidvodb_group -key STATE NEW
    360360    if ("$minidvodb_group" == "NULL")
    361361      # All labels have been done --- reset
    362362#      echo "Resetting labels"
    363363      for i 0 $N
    364         book getpage MINIDVODB_MERGE $i -var minidvodb_group
    365         book setword MINIDVODB_MERGE $minidvodb_group STATE NEW
     364        book getpage MINIDVODB_PREMERGE $i -var minidvodb_group
     365        book setword MINIDVODB_PREMERGE $minidvodb_group STATE NEW
    366366      end
    367       book getpage MINIDVODB_MERGE 0 -var minidvodb_group -key STATE NEW
     367      book getpage MINIDVODB_PREMERGE 0 -var minidvodb_group -key STATE NEW
    368368
    369369      # Select different database
    … …  
    372372    end
    373373    #finds the minidvodbs in a state of 'to_be_merged'
    374     book setword MINIDVODB_MERGE $minidvodb_group STATE DONE
     374    book setword MINIDVODB_PREMERGE $minidvodb_group STATE DONE
    375375    $run = addtool -listminidvodbrun -state to_be_merged -limit 1
    376376    $run = $run -minidvodb_group $minidvodb_group
    … …  
    392392  task.exit    0
    393393    # convert 'stdout' to book format
    394     ipptool2book stdout minidvodbMergelist -key minidvodb_id -uniq -setword dbname $options:0 -setword pantaskState INIT
     394    ipptool2book stdout minidvodbPreMergelist -key minidvodb_id -uniq -setword dbname $options:0 -setword pantaskState INIT
    395395    if ($VERBOSE > 2)
    396       book listbook minidvodbMergelist
     396      book listbook minidvodbPreMergelist
    397397    end
    398398    # delete existing entries in the appropriate pantaskStates
    399     process_cleanup minidvodbMergelist
     399    process_cleanup minidvodbPreMergelist
    400400  end
    401401
    … …  
    418418
    419419
    420 task           minidvodb.merge.run
     420task           minidvodb.premerge.run
    421421  periods      -poll $RUNPOLL
    422422  periods      -exec $RUNEXEC
    … …  
    432432    periods -exec $RUNEXEC
    433433
    434     book npages minidvodbMergelist -var N
     434    book npages minidvodbPreMergelist -var N
    435435    if ($N == 0) break
    436436   
    437437    # look for new images in minidvodbWaitlist (pantaskState == INIT)
    438     book getpage minidvodbMergelist 0 -var pageName -key pantaskState INIT
     438    book getpage minidvodbPreMergelist 0 -var pageName -key pantaskState INIT
    439439    if ("$pageName" == "NULL") break
    440440
    441     book setword minidvodbMergelist $pageName pantaskState RUN
    442     book getword minidvodbMergelist $pageName minidvodb_id -var MINIDVODB_ID
    443     book getword minidvodbMergelist $pageName minidvodb_group -var MINIDVODB_GROUP
    444     book getword minidvodbMergelist $pageName mergedvodb_path -var MERGEDVODB_PATH
    445     book getword minidvodbMergelist $pageName minidvodb_path -var MINIDVODB_PATH
    446     book getword minidvodbMergelist $pageName state -var STATE
    447     stdout $LOGDIR/minidvodb.merge.run.log
    448     stderr $LOGDIR/minidvodb.merge.run.log
    449 
    450     $run = minidvodb_merge.pl --camera GPC1 --mergedvodb $MERGEDVODB_PATH --minidvodb $MINIDVODB_PATH --minidvodb_group $MINIDVODB_GROUP --minidvodb_id $MINIDVODB_ID
     441    book setword minidvodbPreMergelist $pageName pantaskState RUN
     442    book getword minidvodbPreMergelist $pageName minidvodb_id -var MINIDVODB_ID
     443    book getword minidvodbPreMergelist $pageName minidvodb_group -var MINIDVODB_GROUP
     444    book getword minidvodbPreMergelist $pageName minidvodb_path -var MINIDVODB_PATH
     445    book getword minidvodbPreMergelist $pageName state -var STATE
     446    stdout $LOGDIR/minidvodb.premerge.run.log
     447    stderr $LOGDIR/minidvodb.premerge.run.log
     448
     449    $run = minidvodb_premerge.pl --camera GPC1 --minidvodb $MINIDVODB_PATH --minidvodb_group $MINIDVODB_GROUP --minidvodb_id $MINIDVODB_ID
    451450   
    452451  if ($DB:n == 0)
    … …  
    472471  # default exit status
    473472    task.exit    default
    474     process_exit minidvodbMergelist $options:0 $JOB_STATUS
     473    process_exit minidvodbPreMergelist $options:0 $JOB_STATUS
    475474  end
    476475
    … …  
    482481    # Set a fault code in the database
    483482   
    484     process_exit minidvodbMergelist $options:0 $EXIT_CRASH_ERR
     483    process_exit minidvodbPreMergelist $options:0 $EXIT_CRASH_ERR
    485484  end
    486485
    … …  
    488487    task.exit    timeout
    489488        showcommand timeout
    490     book setword minidvodbMergelist $options:0 pantaskState TIMEOUT
     489    book setword minidvodbPreMergelist $options:0 pantaskState TIMEOUT
    491490  end
    492491end

  • branches/haf_add201112/ippTools/share/Makefile.am

    r32979 r33003  
    311311        minidvodbtool_revertminidvodbcopy.sql \
    312312        mergetool_find_minidvodb_id.sql \
     313        mergetool_find_mergedvodbcopy.sql \
     314        mergetool_find_merge_id_dvo.sql \
    313315        mergetool_find_pendingmergeprocess.sql \
    314316        mergetool_find_pending_merge.sql \
    315317        mergetool_find_processed.sql \
     318        mergetool_queue_mergecopy_id.sql \
    316319        mergetool_queue_merge_id.sql \
     320        mergetool_revertmergedvodbcopy.sql \
    317321        mergetool_revertmergedvodbprocessed.sql \
    318322        pstamptool_completedreq.sql \

  • branches/haf_add201112/ippTools/share/addtool_find_minidvodbrun2.sql

    r28181 r33003  
    11-- this selects the minidvodbs that have complete addRuns
    2 SELECT minidvodb_name, minidvodb_path, mergedvodb_path, state, minidbg
     2SELECT minidvodb_name, minidvodb_path, state, minidbg
    33AS minidvodb_group
    44FROM minidvodbRun

  • branches/haf_add201112/ippTools/share/addtool_queue_minidvodbrun.sql

    r28181 r33003  
    44    minidvodb_name,
    55    minidvodb_path,
    6     mergedvodb_path,
    76    'new'
    87

  • branches/haf_add201112/ippTools/share/mergetool_find_pending_merge.sql

    r32980 r33003  
    11SELECT
    22    mergedvodbRun.*
    3 FROM mergedvodbRun
     3    minidvodbRun.minidvodb_path
     4FROM minidvodbRun
     5JOIN mergedvodbRun
     6    USING(minidvodb_id)
    47LEFT JOIN mergedvodbProcessed
    58    USING(merge_id)

  • branches/haf_add201112/ippTools/share/minidvodbtool_find_minidvodb_id_dvo.sql

    r29528 r33003  
    11SELECT minidvodbRun.* FROM minidvodbRun
    22JOIN minidvodbProcessed USING(minidvodb_id)
    3 WHERE minidvodbRun.state = 'merged'
     3WHERE minidvodbRun.state = 'merged'     
     4      AND minidvodbProcessed.fault = 0
    45    AND minidvodb_id NOT IN (SELECT minidvodb_id
    56       FROM minidvodbCopy

  • 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.