IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 27936


Ignore:
Timestamp:
May 12, 2010, 3:36:38 PM (16 years ago)
Author:
heather
Message:

changes to addtool (initial ones, to save them for now).

Location:
branches/haf_branches/ipp.20100512/ippTools
Files:
4 added
5 edited

Legend:

Unmodified
Added
Removed

  • branches/haf_branches/ipp.20100512/ippTools/share/Makefile.am

    r27874 r27936  
    77     addtool_find_cam_id.sql \
    88     addtool_find_pendingexp.sql \
     9     addtool_find_pendingmergeprocess.sql \
    910     addtool_find_processedexp.sql \
     11     addtool_find_minidvodbrun.sql \
     12     addtool_find_minidvodbrun2.sql \
    1013     addtool_pendingcleanupexp.sql \
    1114     addtool_pendingcleanuprun.sql \
    1215     addtool_queue_cam_id.sql \
     16     addtool_queue_minidvodbrun.sql \
    1317     addtool_reset_faulted_runs.sql \
    1418     addtool_revertprocessedexp.sql \

  • branches/haf_branches/ipp.20100512/ippTools/share/addtool_find_processedexp.sql

    r25789 r27936  
    22    addProcessedExp.*,
    33    addRun.workdir
    4 FROM addRun
    5 JOIN camProcessedExp
     4FROM addProcessedExp
     5JOIN addRun
     6    USING(add_id)
     7JOIN camRun
    68    USING(cam_id)
    79JOIN chipRun

  • branches/haf_branches/ipp.20100512/ippTools/src/addtool.c

    r27773 r27936  
    4040static bool maskedMode(pxConfig *config);
    4141static bool unblockMode(pxConfig *config);
     42static bool addminidvodbrunMode(pxConfig *config);
     43static bool updateminidvodbrunMode(pxConfig *config);
     44static bool listminidvodbrunMode(pxConfig *config);
     45static bool addminidvodbprocessedMode(pxConfig *config);
     46static bool listminidvodbprocessedMode(pxConfig *config);
     47static bool revertminidvodbprocessedMode(pxConfig *config);
     48static bool updateminidvodbprocessedMode(pxConfig *config);
     49
     50
    4251
    4352# define MODECASE(caseName, func) \
    … …  
    6978        MODECASE(ADDTOOL_MODE_MASKED,               maskedMode);
    7079        MODECASE(ADDTOOL_MODE_UNBLOCK,              unblockMode);
     80        MODECASE(ADDTOOL_MODE_ADDMINIDVODBRUN,      addminidvodbrunMode);
     81        MODECASE(ADDTOOL_MODE_UPDATEMINIDVODBRUN,   updateminidvodbrunMode);
     82        MODECASE(ADDTOOL_MODE_LISTMINIDVODBRUN,     listminidvodbrunMode);
     83        MODECASE(ADDTOOL_MODE_ADDMINIDVODBPROCESSED,addminidvodbprocessedMode);
     84        MODECASE(ADDTOOL_MODE_LISTMINIDVODBPROCESSED,listminidvodbprocessedMode);
     85        MODECASE(ADDTOOL_MODE_REVERTMINIDVODBPROCESSED,revertminidvodbprocessedMode);
     86        MODECASE(ADDTOOL_MODE_UPDATEMINIDVODBPROCESSED,updateminidvodbprocessedMode);
     87
    7188        default:
    7289            psAbort("invalid option (this should not happen)");
    … …  
    374391    PXOPT_LOOKUP_STR(path_base,     config->args, "-path_base", false, false);
    375392    PXOPT_LOOKUP_F32(dtime_addstar, config->args, "-dtime_addstar", false, false);
     393    PXOPT_LOOKUP_STR(dvodb_path, config->args, "-dvodb_path", false, false);
    376394    PXOPT_LOOKUP_S16(fault,         config->args, "-fault", false, false);
    377395
    … …  
    424442        dtime_addstar,
    425443        path_base,
     444        dvodb_path,
    426445        fault
    427446        );
    … …  
    522541
    523542    if (!p_psDBRunQuery(config->dbh, query)) {
    524         psError(PS_ERR_UNKNOWN, false, "database error");
     543      psError(PS_ERR_UNKNOWN, false, "database error %s ", query);
    525544        psFree(query);
    526545        return false;
    … …  
    733752    return true;
    734753}
     754
     755static bool addminidvodbrunMode(pxConfig *config)
     756{
     757  PS_ASSERT_PTR_NON_NULL(config, NULL);
     758 
     759  // required
     760
     761 
     762
     763  PXOPT_LOOKUP_STR(minidvodb_name, config->args, "-set_minidvodb_name", true, false);
     764  PXOPT_LOOKUP_STR(minidvodb_path, config->args, "-set_minidvodb_path", true, false);
     765  PXOPT_LOOKUP_STR(mergedvodb_path, config->args, "-set_mergedvodb_path", true, false);
     766  psMetadata *where = psMetadataAlloc();
     767
     768  PXOPT_COPY_S64(config->args, where, "-set_minidvodb_name",  "minidvodb_name", "==");
     769  PXOPT_COPY_S64(config->args, where, "-set_minidvodb_path",  "minidvodb_path", "==");
     770  PXOPT_COPY_STR(config->args, where, "-set_mergedvodb_path",  "mergedvodb_path", "==");
     771  //PXOPT_COPY_S255(config->args, where, "-set_state",  "state", "==");
     772
     773  //generate restrictions
     774  //psString query = pxDataGet("addtool_queue_minidvodbrun.sql");
     775  //if (!query) {
     776  //    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     777  //    return false;
     778  // }
     779
     780  //if ((!minidvodb_name) && (!minidvodb_path) && (!mergedvodb_path) ) {
     781  // psError(PXTOOLS_ERR_SYS, false, "need minidvodb_path, mergedvodb_path, and minidvodb_name");
     782  //}
     783
     784    psString query =  NULL;
     785    psStringAppend(&query, "INSERT INTO minidvodbRun SET minidvodb_name = '%s' ,",minidvodb_name);
     786    psStringAppend(&query, "minidvodb_path = '%s' ,",minidvodb_path);
     787    psStringAppend(&query, "mergedvodb_path = '%s' , state = 'new';",mergedvodb_path);
     788   
     789   
     790if (!query) {
     791      psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     792      return false;
     793   }
     794
     795    if (!p_psDBRunQuery(config->dbh, query)) {
     796      psError(PS_ERR_UNKNOWN, false, "database error %s", query);
     797        psFree(query);
     798        return false;
     799    }
     800    psFree(query);
     801
     802psArray *output = p_psDBFetchResult(config->dbh);
     803    if (!output) {
     804        psError(PS_ERR_UNKNOWN, false, "database error");
     805        return false;
     806    }
     807    if (!psArrayLength(output)) {
     808        psTrace("addtool", PS_LOG_INFO, "no rows found");
     809        psFree(output);
     810        return true;
     811    }
     812if (!psDBTransaction(config->dbh)) {
     813        psError(PS_ERR_UNKNOWN, false, "database error");
     814        psFree(output);
     815        return false;
     816    }
     817
     818return true;
     819}
     820
     821static bool updateminidvodbrunMode(pxConfig *config) {
     822  PS_ASSERT_PTR_NON_NULL(config, false);
     823
     824    psMetadata *where = psMetadataAlloc();
     825   
     826    PXOPT_COPY_STR(config->args, where, "-minidvodb_name",     "minidvodb_name", "==");
     827    PXOPT_COPY_STR(config->args, where, "-state",     "state", "==");
     828    PXOPT_COPY_STR(config->args, where, "-minidvodb_path", "minidvodb_path", "==");
     829    PXOPT_COPY_STR(config->args, where, "-mergedvodb_path", "mergedvodb_path", "==");
     830    PXOPT_LOOKUP_STR(minidvodb_name,  config->args, "-set_minidvodb_name", false, false);
     831    PXOPT_LOOKUP_STR(minidvodb_path,  config->args, "-set_minidvodb_path", false, false);
     832    PXOPT_LOOKUP_STR(state,  config->args, "-set_state", false, false);
     833    PXOPT_LOOKUP_STR(mergedvodb_path,  config->args, "-set_mergedvodb_path", false, false);
     834
     835
     836
     837
     838    if (!psListLength(where->list)) {
     839        psFree(where);
     840        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     841        return false;
     842    }
     843
     844    psString query = psStringCopy("UPDATE minidvodbRun SET ");
     845    int cnt = 0;
     846    psString comma = ",";
     847    if (minidvodb_name) {
     848  psStringAppend(&query, " minidvodb_name = '%s'", minidvodb_name);
     849  cnt++;
     850 }
     851
     852if (minidvodb_path) {
     853  if (cnt) {
     854    psStringAppend(&query,comma);
     855  }
     856
     857  psStringAppend(&query, " minidvodb_path = '%s'", minidvodb_path);
     858 cnt++;
     859}
     860
     861if (state) {
     862if (cnt) {
     863    psStringAppend(&query,comma);
     864  }
     865  psStringAppend(&query, " state = '%s'", state);
     866 cnt++;
     867 }
     868
     869if (mergedvodb_path) {
     870if (cnt) {
     871    psStringAppend(&query,comma);
     872  }
     873  psStringAppend(&query, " mergedvodb_path = '%s'", mergedvodb_path);
     874cnt++;
     875 }
     876
     877
     878
     879    // pxUpdateRun gets parameters from config->args and runs the update query
     880   
     881    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     882    psStringAppend(&query, " WHERE %s", whereClause);
     883
     884 if (!p_psDBRunQuery(config->dbh, query)) {
     885        psError(PS_ERR_UNKNOWN, false, "database error");
     886        psFree(query);
     887        return false;
     888    }
     889
     890
     891
     892    psFree(query);
     893    psFree(where);
     894
     895    return true;
     896
     897
     898}
     899
     900static bool listminidvodbrunMode(pxConfig *config) {
     901    PS_ASSERT_PTR_NON_NULL(config, false);
     902    psMetadata *where = psMetadataAlloc();
     903   
     904    PXOPT_LOOKUP_BOOL(finished_addrun, config->args, "-finished_addrun", false);
     905    if (finished_addrun) { //too many selects, and I couldn't figure out how to rename it
     906      PXOPT_COPY_STR(config->args, where, "-minidvodb_name", "minidbn", "==");
     907      PXOPT_COPY_STR(config->args, where, "-minidvodb_group", "minidbg", "==");
     908    } else {
     909      PXOPT_COPY_STR(config->args, where, "-minidvodb_name", "minidvodbRun.minidvodb_name", "==");
     910      PXOPT_COPY_STR(config->args, where, "-minidvodb_group", "addRun.minidvodb_group", "==");
     911    }
     912    PXOPT_COPY_STR(config->args, where, "-state", "minidvodbRun.state", "==");
     913    PXOPT_LOOKUP_U64(limit,      config->args, "-limit", false, false);
     914 
     915 
     916
     917 if (!psListLength(where->list)) {
     918        psFree(where);
     919        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     920        return false;
     921    }
     922
     923 //there is a different starting query, depending on if it is limited to list minidvodbs with finished addRun processing or not.
     924 psString query = NULL;
     925psString query1 = pxDataGet("addtool_find_minidvodbrun.sql");
     926psString query2 = pxDataGet("addtool_find_minidvodbrun2.sql");
     927 if (finished_addrun) {
     928   psStringAppend(&query, "%s",query2);
     929 } else {
     930   psStringAppend(&query, "%s",query1);
     931 }
     932 //psString query = pxDataGet("addtool_find_minidvodbrun.sql");
     933    if (!query) {
     934        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     935        return false;
     936    }
     937
     938
     939   
     940    if (finished_addrun) { //finished addrun does not need the WHERE
     941      if (psListLength(where->list)) {
     942        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     943        psStringAppend(&query, " AND %s", whereClause);
     944        psFree(whereClause);
     945    } } else {
     946      if (psListLength(where->list)) {
     947        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     948        psStringAppend(&query, " WHERE %s", whereClause);
     949        psFree(whereClause);
     950      }
     951    }
     952   
     953if (!finished_addrun) {
     954  //finished_addrun does not need this
     955    psStringAppend(&query, " %s", " GROUP BY minidvodbRun.minidvodb_name ");
     956 }
     957
     958
     959if (limit) {
     960        psString limitString = psDBGenerateLimitSQL(limit);
     961        psStringAppend(&query, " %s", limitString);
     962        psFree(limitString);
     963    }
     964
     965// psError(PS_ERR_UNKNOWN, false, "%s", query);
     966//return false;
     967 
     968    if (!p_psDBRunQuery(config->dbh, query)) {
     969      psError(PS_ERR_UNKNOWN, false, "database error %s", query);
     970        psFree(query);
     971        return false;
     972    }
     973    psFree(query);
     974psArray *output = p_psDBFetchResult(config->dbh);
     975    if (!output) {
     976        psError(PS_ERR_UNKNOWN, false, "database error");
     977        return false;
     978    }
     979    if (!psArrayLength(output)) {
     980        psTrace("addtool", PS_LOG_INFO, "no rows found");
     981        psFree(output);
     982        return true;
     983    }
     984
     985   if (!ippdbPrintMetadatas(stdout, output, "minidvodbRun", 1)) {
     986        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     987        psFree(output);
     988        return false;
     989    }
     990
     991    psFree(output);
     992
     993   
     994
     995return true;
     996}
     997
     998static bool addminidvodbprocessedMode(pxConfig *config) {
     999
     1000PS_ASSERT_PTR_NON_NULL(config, false);
     1001
     1002    // required
     1003 PXOPT_LOOKUP_STR(minidvodb_name, config->args, "-minidvodb_name", true, false);
     1004
     1005    // optional
     1006    PXOPT_LOOKUP_U64(merge_order,     config->args, "-merge_order", false, false);
     1007    PXOPT_LOOKUP_F32(dtime_relphot, config->args, "-dtime_relphot", false, false);
     1008PXOPT_LOOKUP_F32(dtime_resort, config->args, "-dtime_resort", false, false);
     1009PXOPT_LOOKUP_F32(dtime_merge, config->args, "-dtime_merge", false, false);
     1010    PXOPT_LOOKUP_TIME(epoch, config->args, "-epoch", false, false);
     1011PXOPT_LOOKUP_STR(mergedvodb_path, config->args, "-mergedvodb_path", false, false);
     1012    PXOPT_LOOKUP_S16(fault,         config->args, "-fault", false, false);
     1013    //generate restrictions
     1014psMetadata *where = psMetadataAlloc();
     1015PXOPT_COPY_STR(config->args, where, "-minidvodb_name",   "minidvodbRun.minidvodb_name",   "==");
     1016
     1017    psString query = pxDataGet("addtool_find_pendingmergeprocess.sql");
     1018    if (!query) {
     1019      psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1020      return false;
     1021    }
     1022    // use psDBGenerateWhereSQL because the SQL yields an intermediate table
     1023    if (psListLength(where->list)) {
     1024        psString whereClaus = psDBGenerateWhereConditionSQL(where, NULL);
     1025        psStringAppend(&query, " AND %s", whereClaus);
     1026        psFree(whereClaus);
     1027    }
     1028    psFree(where);
     1029   
     1030    if (!p_psDBRunQuery(config->dbh, query)) {
     1031      psError(PS_ERR_UNKNOWN, false, "database error");
     1032      psFree(query);
     1033      return false;
     1034    }
     1035    psFree(query);
     1036   
     1037    psArray *output = p_psDBFetchResult(config->dbh);
     1038    if (!output) {
     1039      psError(PS_ERR_UNKNOWN, false, "database error");
     1040      return false;
     1041    }
     1042    if (!psArrayLength(output)) {
     1043      psTrace("addtool", PS_LOG_INFO, "no rows found");
     1044      psFree(output);
     1045      return true;
     1046    }
     1047   
     1048    if (!psDBTransaction(config->dbh)) {
     1049        psError(PS_ERR_UNKNOWN, false, "database error");
     1050        psFree(output);
     1051        return false;
     1052    }
     1053        minidvodbRunRow *pendingRow = minidvodbRunObjectFromMetadata(output->data[0]);
     1054        psFree(output);
     1055        minidvodbProcessedRow *row = minidvodbProcessedRowAlloc(
     1056               pendingRow->minidvodb_name,
     1057               merge_order,
     1058               dtime_resort,
     1059               dtime_relphot,
     1060               dtime_merge,
     1061               epoch,
     1062               mergedvodb_path,
     1063               fault
     1064               );
     1065       
     1066        if (!minidvodbProcessedInsertObject(config->dbh, row)) {
     1067          // rollback
     1068        if (!psDBRollback(config->dbh)) {
     1069          psError(PS_ERR_UNKNOWN, false, "database error");
     1070        }
     1071        psError(PS_ERR_UNKNOWN, false, "database error");
     1072        psFree(row);
     1073        psFree(pendingRow);
     1074        return false;
     1075        }
     1076
     1077    // since there is only one exp per 'new' set addRun.state = 'full'
     1078    //if (!pxminidvodbRunSetState(config, row->minidvodb_name, "merged")) {
     1079    //  psError(PS_ERR_UNKNOWN, false, "failed to change minidvodbRun.state for minidvodb_name: %" PRId64, row->minidvodb_name);
     1080    //  psFree(row);
     1081    //   psFree(pendingRow);
     1082    //    return false;
     1083    // }
     1084        psFree(row);
     1085        psFree(pendingRow);
     1086       
     1087        if (!psDBCommit(config->dbh)) {
     1088          psError(PS_ERR_UNKNOWN, false, "database error");
     1089          return false;
     1090        }
     1091       
     1092
     1093
     1094
     1095        return true;
     1096    }
     1097   
     1098static bool listminidvodbprocessedMode(pxConfig *config) {
     1099return true;
     1100}
     1101
     1102static bool revertminidvodbprocessedMode(pxConfig *config) {
     1103return true;
     1104}
     1105
     1106static bool updateminidvodbprocessedMode(pxConfig *config) {
     1107return true;
     1108}
     1109
     1110

  • branches/haf_branches/ipp.20100512/ippTools/src/addtool.h

    r25299 r27936  
    3939    ADDTOOL_MODE_DONECLEANUP,
    4040    ADDTOOL_MODE_EXPORTRUN,
    41     ADDTOOL_MODE_IMPORTRUN
     41    ADDTOOL_MODE_IMPORTRUN,
     42    ADDTOOL_MODE_ADDMINIDVODBRUN,
     43    ADDTOOL_MODE_UPDATEMINIDVODBRUN,
     44    ADDTOOL_MODE_LISTMINIDVODBRUN,
     45    ADDTOOL_MODE_ADDMINIDVODBPROCESSED,
     46    ADDTOOL_MODE_LISTMINIDVODBPROCESSED,
     47    ADDTOOL_MODE_REVERTMINIDVODBPROCESSED,
     48    ADDTOOL_MODE_UPDATEMINIDVODBPROCESSED
    4249} addtoolMode;
    4350

  • branches/haf_branches/ipp.20100512/ippTools/src/addtoolConfig.c

    r27773 r27936  
    142142    psMetadataAddStr(unblockArgs, PS_LIST_TAIL, "-label",  0,            "name of a label to unmask (required)", NULL);
    143143
     144    // -addminidvodbruns
     145    psMetadata *addminidvodbrunArgs = psMetadataAlloc();
     146    psMetadataAddStr(addminidvodbrunArgs, PS_LIST_TAIL, "-set_minidvodb_name",        0, "define minidvodb_name", NULL);
     147    psMetadataAddStr(addminidvodbrunArgs, PS_LIST_TAIL, "-set_minidvodb_path",        0, "define path for minidvodb", NULL);
     148    psMetadataAddStr(addminidvodbrunArgs, PS_LIST_TAIL, "-set_mergedvodb_path",        0, "define path for the merged dvodb", NULL);
     149    psMetadataAddStr(addminidvodbrunArgs, PS_LIST_TAIL, "-set_state",        0, "define state", NULL);
     150
     151    // -updateminidvodbruns
     152    psMetadata *updateminidvodbrunArgs = psMetadataAlloc();
     153psMetadataAddStr(updateminidvodbrunArgs, PS_LIST_TAIL, "-minidvodb_name",        0, "search by minidvodb_name", NULL);
     154    psMetadataAddStr(updateminidvodbrunArgs, PS_LIST_TAIL, "-minidvodb_path",        0, "search by path for minidvodb", NULL);
     155    psMetadataAddStr(updateminidvodbrunArgs, PS_LIST_TAIL, "-mergedvodb_path",        0, "search by path for the merged dvodb", NULL);
     156    psMetadataAddStr(updateminidvodbrunArgs, PS_LIST_TAIL, "-state",        0, "search by state", NULL);
     157psMetadataAddStr(updateminidvodbrunArgs, PS_LIST_TAIL, "-set_minidvodb_name",        0, "define minidvodb_name", NULL);
     158    psMetadataAddStr(updateminidvodbrunArgs, PS_LIST_TAIL, "-set_minidvodb_path",        0, "define path for minidvodb", NULL);
     159    psMetadataAddStr(updateminidvodbrunArgs, PS_LIST_TAIL, "-set_mergedvodb_path",        0, "define path for the merged dvodb", NULL);
     160    psMetadataAddStr(updateminidvodbrunArgs, PS_LIST_TAIL, "-set_state",        0, "define state", NULL);
     161    // -listminidvodbrunArgs
     162    psMetadata *listminidvodbrunArgs = psMetadataAlloc();
     163    psMetadataAddStr(listminidvodbrunArgs, PS_LIST_TAIL, "-minidvodb_name",        0, "search by minidvodb_name", NULL);
     164    psMetadataAddStr(listminidvodbrunArgs, PS_LIST_TAIL, "-minidvodb_group",        0, "search by addRun.minidvodb_group", NULL);
     165    psMetadataAddStr(listminidvodbrunArgs, PS_LIST_TAIL, "-state",        0, "search by state", NULL);
     166    psMetadataAddU64(listminidvodbrunArgs, PS_LIST_TAIL, "-limit",        0, "limit to N items", 0);
     167    psMetadataAddBool(listminidvodbrunArgs, PS_LIST_TAIL, "-simple",        0, "simple output", false);
     168    psMetadataAddBool(listminidvodbrunArgs, PS_LIST_TAIL, "-finished_addrun",        0, "limit to minidvodbs with completed addRuns (none in new state)", false);
     169
     170
     171    psMetadata *addminidvodbprocessedArgs = psMetadataAlloc();
     172    psMetadataAddStr(addminidvodbprocessedArgs, PS_LIST_TAIL, "-minidvodb_name", 0,    "define minidvodb_name (required)", NULL);
     173    psMetadataAddU64(addminidvodbprocessedArgs, PS_LIST_TAIL, "-merge_order",    0,    "define merge order", 0);
     174    psMetadataAddF32(addminidvodbprocessedArgs, PS_LIST_TAIL, "-dtime_relphot",  0,    "define elapsed time for relphot (seconds)", NAN);
     175    psMetadataAddF32(addminidvodbprocessedArgs, PS_LIST_TAIL, "-dtime_resort", 0,    "define elapsed time for resort (seconds)", NAN);
     176    psMetadataAddF32(addminidvodbprocessedArgs, PS_LIST_TAIL, "-dtime_merge",    0,    "define elapsed time for DVO merge (seconds)", NAN);
     177    psMetadataAddTime(addminidvodbprocessedArgs, PS_LIST_TAIL, "-epoch",         0,    "time merge is finished", NULL);
     178    psMetadataAddStr(addminidvodbprocessedArgs, PS_LIST_TAIL, "-mergedvodb_path",0,    "path of merged dvodb", NULL);
     179    psMetadataAddS16(addminidvodbprocessedArgs, PS_LIST_TAIL, "-fault",          0,    "set fault code", 0);
     180
     181
     182
     183    psMetadata *listminidvodbprocessedArgs = psMetadataAlloc();
     184    psMetadata *revertminidvodbprocessedArgs = psMetadataAlloc();
     185    psMetadata *updateminidvodbprocessedArgs = psMetadataAlloc();
     186   
     187
     188
    144189    psMetadata *argSets = psMetadataAlloc();
    145190    psMetadata *modes = psMetadataAlloc();
    … …  
    154199    PXOPT_ADD_MODE("-block",                "set a label block",                    ADDTOOL_MODE_BLOCK,         blockArgs);
    155200    PXOPT_ADD_MODE("-masked",               "show blocked labels",                  ADDTOOL_MODE_MASKED,        maskedArgs);
    156     PXOPT_ADD_MODE("-unblock",              "remove a label block",                 ADDTOOL_MODE_UNBLOCK,       unblockArgs);
     201    PXOPT_ADD_MODE("-addminidvodbrun",      "create minidvodbs ",                   ADDTOOL_MODE_ADDMINIDVODBRUN, addminidvodbrunArgs);
     202    PXOPT_ADD_MODE("-updateminidvodbrun",   "change minidvodb properties",          ADDTOOL_MODE_UPDATEMINIDVODBRUN,     updateminidvodbrunArgs);
     203    PXOPT_ADD_MODE("-listminidvodbrun",     "list minidvodbs",                      ADDTOOL_MODE_LISTMINIDVODBRUN,       listminidvodbrunArgs);
     204    PXOPT_ADD_MODE("-addminidvodbprocessed","add a processed minidvodb",            ADDTOOL_MODE_ADDMINIDVODBPROCESSED,  addminidvodbprocessedArgs);
     205    PXOPT_ADD_MODE("-listminidvodbprocessed","list processed minidvodbs",           ADDTOOL_MODE_LISTMINIDVODBPROCESSED, listminidvodbprocessedArgs);
     206    PXOPT_ADD_MODE("-revertminidvodbprocessed","revert processed minidvobs",        ADDTOOL_MODE_REVERTMINIDVODBPROCESSED,     revertminidvodbprocessedArgs);
     207    PXOPT_ADD_MODE("-updateminidvodbprocessed","change processed minidvodb properties",ADDTOOL_MODE_UPDATEMINIDVODBPROCESSED,  updateminidvodbprocessedArgs);
     208 
     209 
     210   
     211
    157212
    158213    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {
Note: See TracChangeset for help on using the changeset viewer.