IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 25835


Ignore:
Timestamp:
Oct 14, 2009, 11:06:18 AM (17 years ago)
Author:
bills
Message:

Add data_group, dist_group, and note to the pipeline. These new columns will be used
for some of the tasks that label was used previously.

Location:
trunk
Files:
1 added
73 edited

Legend:

Unmodified
Added
Removed

  • trunk/dbconfig/add.md

    r25816 r25835  
    33    add_id          S64     0       # Primary Key AUTO_INCREMENT
    44    cam_id          S64     0       # Key INDEX(add_id,cam_id) fkey(cam_id) ref camRun(cam_id)
    5     state           STR     64      # key
     5    state           STR     64      # Key
    66    workdir         STR     255
    77    workdir_state   STR     64
    88    reduction       STR     64
    99    label           STR     64
     10    data_group      STR     64      # Key
    1011    dvodb           STR     255
     12    note            STR     255
    1113    image_only      BOOL    f
    1214END

  • trunk/dbconfig/cam.md

    r24681 r25835  
    66    workdir_state STR       64      # key
    77    label       STR         64      # key
     8    data_group  STR         64      # key
     9    dist_group  STR         64      # key
    810    reduction   STR         64
    911    expgroup    STR         64      # key
    … …  
    1214    end_stage   STR         64      # Key
    1315    magicked    S64         0
     16    note        STR         255
    1417END
    1518

  • trunk/dbconfig/chip.md

    r24552 r25835  
    66    workdir_state STR       64      # Key
    77    label       STR         64      # Key
     8    data_group  STR         64      # Key
     9    dist_group  STR         64      # Key
    810    reduction   STR         64      # Reduction class
    911    expgroup    STR         64      # Key
    … …  
    1214    end_stage   STR         64      # Key
    1315    magicked    S64         0
     16    note        STR         255
    1417END
    1518

  • trunk/dbconfig/config.md

    r25421 r25835  
    22    pkg_name        STR     ippdb
    33    pkg_namespace   STR     ippdb
    4     pkg_version     STR     1.1.55
     4    pkg_version     STR     1.1.56
    55END

  • trunk/dbconfig/diff.md

    r24552 r25835  
    66    workdir     STR         255
    77    label       STR         64      # Key
     8    data_group  STR         64
     9    dist_group  STR         64
    810    reduction   STR         64      # Reduction class
    911    dvodb       STR         255
    … …  
    1315    exposure    BOOL        f
    1416    magicked    S64         0
     17    note        STR         255
    1518END
    1619

  • trunk/dbconfig/dist.md

    r25513 r25835  
    11distTarget METADATA
    22    target_id   S64        0       # Primary Key
    3     label       STR        64
     3    dist_group  STR        64
    44    filter      STR        64
    55    stage       STR        64
    … …  
    2222    time_stamp  UTC         0001-01-01T00:00:00Z
    2323    fault       S16         0
     24    note        STR         255
    2425END
    2526

  • trunk/dbconfig/fake.md

    r19930 r25835  
    55    workdir     STR         255
    66    label       STR         64      # Key
     7    data_group  STR         64      # Key
     8    dist_group  STR         64      # Key
    79    reduction   STR         64      # Reduction class
    810    expgroup    STR         64      # Key
    … …  
    1113    end_stage   STR         64      # Key
    1214    epoch       UTC         0001-01-01T00:00:00Z
     15    note        STR         255
    1316END
    1417

  • trunk/dbconfig/magic.md

    r25014 r25835  
    1111    workdir_state STR       255     # Key
    1212    label       STR         64      # key
     13    data_group  STR         64
    1314    dvodb       STR         255
    1415    registered  TAI         NULL
    1516    fault       S16         0       # Key
     17    note        STR         255
    1618END
    1719
    … …  
    5355    cam_id      S64         0
    5456    label       STR         64      # key
     57    data_group  STR         64      # key
    5558    outroot     STR         255
    5659    recoveryroot    STR     255
    5760    re_place    BOOL        f
    5861    remove      BOOL        f
     62    fault       S16         0       # Key
     63    note        STR         255
    5964END
    6065

  • trunk/dbconfig/stack.md

    r23688 r25835  
    66    workdir     STR         255
    77    label       STR         64      # Key
     8    data_group  STR         64      # Key
     9    dist_group  STR         64      # Key
    810    reduction   STR         64      # Reduction class
    911    dvodb       STR         255
    … …  
    1214    tess_id     STR         64      # Key
    1315    filter      STR         64
     16    note        STR         255
    1417END
    1518

  • trunk/dbconfig/warp.md

    r24552 r25835  
    1717    workdir_state STR       64      # Key
    1818    label       STR         64      # key
     19    data_group  STR         64
     20    dist_group  STR         64
    1921    dvodb       STR         255
    2022    tess_id     STR         64
    … …  
    2325    registered  TAI         NULL
    2426    magicked    S64         0
     27    note        STR         255
    2528END
    2629

  • trunk/ippScripts/scripts/camera_exp.pl

    r25816 r25835  
    354354#    $fpaCommand .= " -dtime_addstar $dtime_addstar";
    355355} else {
    356     $fpaCommand .= " -updaterun -state full";
     356    $fpaCommand .= " -updaterun -set_state full";
    357357}
    358358$fpaCommand .= " -dbname $dbname" if defined $dbname;

  • trunk/ippScripts/scripts/ipp_cleanup.pl

    r25801 r25835  
    488488        # No skycells were found for some reason.
    489489        # Not technically an "error," but a "you told me to do X, and I can't. Please fix this yourself."
    490         my $command = "$stacktool -updaterun -stack_id $stage_id -state $error_state";
     490        my $command = "$stacktool -updaterun -stack_id $stage_id -set_state $error_state";
    491491        $command .= " -dbname $dbname" if defined $dbname;
    492492       
    … …  
    561561            my $command = "$stacktool -stack_id $stage_id";
    562562            if ($mode eq "goto_purged") {
    563                 $command .= " -updaterun -state purged";
     563                $command .= " -updaterun -set_state purged";
    564564            }
    565565            elsif ($mode eq "goto_cleaned") {
    566                 $command .= " -updaterun -state cleaned";
     566                $command .= " -updaterun -set_state cleaned";
    567567            }
    568568            elsif ($mode eq "goto_scrubbed") {
    569                 $command .= " -updaterun -state scrubbed";
     569                $command .= " -updaterun -set_state scrubbed";
    570570            }
    571571            $command .= " -dbname $dbname" if defined $dbname;
    … …  
    589589
    590590        } else {
    591             my $command = "$stacktool -updaterun  -stack_id $stage_id -state $error_state";
     591            my $command = "$stacktool -updaterun  -stack_id $stage_id -set_state $error_state";
    592592            $command .= " -dbname $dbname" if defined $dbname;
    593593           
    … …  
    624624        # No skycells were found for some reason.
    625625        # Not technically an "error," but a "you told me to do X, and I can't. Please fix this yourself."
    626         my $command = "$difftool -updaterun -diff_id $stage_id -state $error_state";
     626        my $command = "$difftool -updaterun -diff_id $stage_id -set_state $error_state";
    627627        $command .= " -dbname $dbname" if defined $dbname;
    628628       
    … …  
    741741
    742742        } else {
    743             my $command = "$difftool -updaterun -diff_id $stage_id -state $error_state";
     743            my $command = "$difftool -updaterun -diff_id $stage_id -set_state $error_state";
    744744
    745745            $command .= " -dbname $dbname" if defined $dbname;

  • trunk/ippScripts/scripts/stack_skycell.pl

    r25551 r25835  
    304304            $command .= (" -dtime_script " . ((DateTime->now->mjd - $mjd_start) * 86400));
    305305        } else {
    306             $mode = "-updaterun -state full";
     306            $mode = "-updaterun -set_state full";
    307307        }
    308308        $command .= " $mode -stack_id $stack_id";

  • trunk/ippTasks/simtest.basic.auto

    r24174 r25835  
    4747  name       STR OBJECT-i
    4848  check      STR "detselect -dbname @DBNAME@ -search    -inst @CAMERA@ -filter i -det_type FLAT"
    49   launch     STR "chiptool  -dbname @DBNAME@ -updaterun -inst @CAMERA@ -filter i -label wait -set_label proc"
     49  launch     STR "chiptool  -dbname @DBNAME@ -updaterun -inst @CAMERA@ -filter i -label wait -set_label proc -set_data_group simtest_i -set_dist_group simtest"
    5050  block      STR NONE
    5151END
    … …  
    5454  name       STR OBJECT-r
    5555  check      STR "detselect -dbname @DBNAME@ -search    -inst @CAMERA@ -filter r -det_type FLAT"
    56   launch     STR "chiptool  -dbname @DBNAME@ -updaterun -inst @CAMERA@ -filter r -label wait -set_label proc"
     56  launch     STR "chiptool  -dbname @DBNAME@ -updaterun -inst @CAMERA@ -filter r -label wait -set_label proc -set_data_group simtest_r -set_dist_group simtest"
    5757  block      STR NONE
    5858END
    … …  
    6161automate METADATA
    6262  name       STR STACK
    63   regular    STR "stacktool -definebyquery -all -label proc -workdir file://@CWD@/stack -min_new 4 -min_frac 2 -select_good_frac_min 0.2 -dbname @DBNAME@"
     63  regular    STR "stacktool -definebyquery -set_label proc -set_data_group simtest_r -set_dist_group simtest -set_workdir file://@CWD@/stack -min_new 4 -min_frac 2 -select_good_frac_min 0.2 -dbname @DBNAME@"
    6464END
    6565
    … …  
    6767automate METADATA
    6868  name       STR DIFF
    69   regular    STR "difftool -definewarpstack -label proc -workdir file://@CWD@/diff -good_frac 0.2 -dbname @DBNAME@"
     69  regular    STR "difftool -definewarpstack -set_label proc -set_workdir file://@CWD@/diff -good_frac 0.2 -dbname @DBNAME@"
    7070END
    7171

  • trunk/ippTasks/simtest.stack.auto

    r24098 r25835  
    6161automate METADATA
    6262  name       STR STACK
    63   regular    STR "stacktool -definebyquery -all -label proc -workdir file://@CWD@/stack -min_new 4 -min_frac 2 -select_good_frac_min 0.2 -dbname @DBNAME@"
     63  regular    STR "stacktool -definebyquery -label proc -workdir file://@CWD@/stack -min_new 4 -min_frac 2 -select_good_frac_min 0.2 -dbname @DBNAME@"
    6464END
    6565

  • trunk/ippTools/configure.ac

    r25421 r25835  
    1818PKG_CHECK_MODULES([PSLIB], [pslib >= 1.1.0])
    1919PKG_CHECK_MODULES([PSMODULES], [psmodules >= 1.1.0])
    20 PKG_CHECK_MODULES([IPPDB], [ippdb >= 1.1.55])
     20PKG_CHECK_MODULES([IPPDB], [ippdb >= 1.1.56])
    2121
    2222PXTOOLS_CFLAGS="${PSLIB_CFLAGS=} ${PSMODULES_CFLAGS=} ${IPPDB_CFLAGS=}"

  • trunk/ippTools/share/addtool_queue_cam_id.sql

    r25816 r25835  
    88        '%s',           -- reduction
    99        '%s',           -- label
     10        '%s',           -- data_group
    1011        '%s',           -- dvodb
     12        '%s',           -- note
    1113        %d              -- image_only
    1214    FROM camRun

  • trunk/ippTools/share/camtool_queue_chip_id.sql

    r24681 r25835  
    99        '%s',           -- workdir_state
    1010        '%s',           -- label
     11        '%s',           -- data_group
     12        '%s',           -- dist_group
    1113        '%s',           -- reduction
    1214        '%s',           -- expgroup
    … …  
    1416        '%s',           -- tess_id
    1517        '%s',           -- end_stage
    16         0               -- magicked
     18        0,              -- magicked
     19        '%s'           -- note
    1720    FROM chipRun
    1821    WHERE

  • trunk/ippTools/share/chiptool_completely_processed_exp.sql

    r23688 r25835  
    77    workdir_state,
    88    label,
     9    data_group,
     10    dist_group,
    911    reduction,
    1012    expgroup,
    … …  
    1214    tess_id,
    1315    end_stage,
    14     all_files_magicked as magicked
     16    all_files_magicked as magicked,
     17    note
    1518FROM
    1619    (SELECT

  • trunk/ippTools/share/disttool_definebyquery_camera.sql

    r25513 r25835  
    44    rawExp.exp_name as run_tag,
    55    camRun.magicked,
    6     distTarget.label,
     6    camRun.label,
     7    distTarget.dist_group,
    78    distTarget.target_id,
    89    distTarget.clean
    … …  
    1213JOIN distTarget ON distTarget.stage = 'camera'
    1314    AND rawExp.filter = distTarget.filter
    14     AND camRun.label  = distTarget.label
     15    AND camRun.dist_group  = distTarget.dist_group
    1516JOIN rcInterest USING(target_id)
    1617LEFT JOIN distRun ON distRun.stage = 'camera'

  • trunk/ippTools/share/disttool_definebyquery_chip.sql

    r25513 r25835  
    55    rawExp.exp_name as run_tag,
    66    chipRun.label,
     7    chipRun.dist_group,
    78    distTarget.target_id,
    89    distTarget.clean
    … …  
    1011JOIN rawExp USING(exp_id)
    1112JOIN distTarget ON distTarget.stage = 'chip'
    12     AND chipRun.label = distTarget.label
     13    AND chipRun.dist_group = distTarget.dist_group
    1314    AND rawExp.filter = distTarget.filter
    1415JOIN rcInterest USING(target_id)

  • trunk/ippTools/share/disttool_definebyquery_diff.sql

    r25513 r25835  
    44    diffRun.magicked,
    55    rawExp.exp_name as run_tag,
    6     distTarget.label,
     6    diffRun.label,
     7    distTarget.dist_group,
    78    distTarget.target_id,
    89    distTarget.clean
    … …  
    1516JOIN rawExp USING(exp_id)
    1617JOIN distTarget ON distTarget.stage = 'diff'
    17     AND diffRun.label = distTarget.label
     18    AND diffRun.dist_group = distTarget.dist_group
    1819    AND distTarget.filter = rawExp.filter
    1920JOIN rcInterest USING(target_id)

  • trunk/ippTools/share/disttool_definebyquery_fake.sql

    r25542 r25835  
    44    CAST(0 AS SIGNED) AS magicked,
    55    rawExp.exp_name as run_tag,
    6     distTarget.label,
     6    fakeRun.label,
     7    distTarget.dist_group,
    78    distTarget.target_id,
    89    distTarget.clean
    … …  
    1112JOIN chipRun USING(chip_id)
    1213JOIN rawExp USING(exp_id)
    13 JOIN distTarget ON distTarget.stage = 'fake' AND fakeRun.label = distTarget.label
     14JOIN distTarget ON distTarget.stage = 'fake' AND fakeRun.dist_group = distTarget.dist_group
    1415    AND rawExp.filter = distTarget.filter
    1516JOIN rcInterest USING(target_id)

  • trunk/ippTools/share/disttool_definebyquery_raw.sql

    r25513 r25835  
    44    rawExp.exp_name AS run_tag,
    55    rawExp.magicked,
    6     distTarget.label,
     6    chipRun.label,
     7    distTarget.dist_group,
    78    distTarget.target_id,
    89    distTarget.clean
    910FROM rawExp
    1011JOIN chipRun USING(exp_id)
    11 JOIN distTarget ON distTarget.label = chipRun.label AND distTarget.stage = 'raw'
     12JOIN distTarget ON distTarget.dist_group = chipRun.dist_group AND distTarget.stage = 'raw'
    1213    AND rawExp.filter = distTarget.filter
    1314JOIN rcInterest USING(target_id)

  • trunk/ippTools/share/disttool_definebyquery_stack.sql

    r25542 r25835  
    55    -- run tag in the form 'stack.$skycell_id.$stack_id'
    66    CONCAT_WS('.', 'stack', stackRun.skycell_id, convert(stackRun.stack_id, CHAR)) as run_tag,
    7     distTarget.label,
     7    stackRun.label,
     8    distTarget.dist_group,
    89    distTarget.target_id,
    910    distTarget.clean
    … …  
    1112JOIN stackSumSkyfile USING(stack_id)
    1213JOIN distTarget ON distTarget.stage = 'stack'
    13     AND stackRun.label = distTarget.label
     14    AND stackRun.dist_group = distTarget.dist_group
    1415    AND stackRun.filter = distTarget.filter
    1516JOIN rcInterest USING(target_id)

  • trunk/ippTools/share/disttool_definebyquery_warp.sql

    r25513 r25835  
    44    warpRun.magicked,
    55    rawExp.exp_name as run_tag,
    6     distTarget.label,
     6    warpRun.label,
     7    distTarget.dist_group,
    78    distTarget.target_id,
    89    distTarget.clean
    … …  
    1314JOIN rawExp USING(exp_id)
    1415JOIN distTarget ON distTarget.stage = 'warp'
    15     AND warpRun.label = distTarget.label
     16    AND warpRun.dist_group = distTarget.dist_group
    1617    AND rawExp.filter = distTarget.filter
    1718JOIN rcInterest USING(target_id)

  • trunk/ippTools/share/disttool_defineinterest.sql

    r25493 r25835  
    11INSERT INTO rcInterest
    2     SELECT 0, dest_id, target_id, '@STATE@'
     2    SELECT 0, rcDestination.dest_id, distTarget.target_id, '@STATE@'
    33    FROM distTarget
    44        JOIN rcDestination

  • trunk/ippTools/share/disttool_pending_camera.sql

    r25429 r25835  
    22    distRun.dist_id,
    33    distRun.label,
     4    distTarget.dist_group,
    45    stage,
    56    stage_id,
    … …  
    1617    chipRun.magicked
    1718FROM distRun
     19JOIN distTarget USING(target_id, stage)
    1820JOIN camRun ON camRun.cam_id = distRun.stage_id
    1921JOIN camProcessedExp USING(cam_id)

  • trunk/ippTools/share/disttool_pending_chip.sql

    r25429 r25835  
    22    distRun.dist_id,
    33    distRun.label,
     4    distTarget.dist_group,
    45    stage,
    56    stage_id,
    … …  
    1617    chipProcessedImfile.magicked
    1718FROM distRun
     19JOIN distTarget USING(target_id, stage)
    1820JOIN chipRun ON chipRun.chip_id = distRun.stage_id
    1921JOIN rawExp using(exp_id)

  • trunk/ippTools/share/disttool_pending_diff.sql

    r25429 r25835  
    22    distRun.dist_id,
    33    distRun.label,
     4    distTarget.dist_group,
    45    stage,
    56    stage_id,
    … …  
    1819    diffSkyfile.magicked
    1920FROM distRun
     21JOIN distTarget USING(target_id, stage)
    2022JOIN diffRun ON stage_id = diff_id
    2123JOIN diffSkyfile using(diff_id)

  • trunk/ippTools/share/disttool_pending_fake.sql

    r25429 r25835  
    22    distRun.dist_id,
    33    distRun.label,
     4    distTarget.dist_group,
    45    stage,
    56    stage_id,
    … …  
    1617    0
    1718FROM distRun
     19JOIN distTarget USING(target_id, stage)
    1820JOIN fakeRun ON fakeRun.fake_id = distRun.stage_id
    1921JOIN fakeProcessedImfile USING(fake_id)

  • trunk/ippTools/share/disttool_pending_raw.sql

    r25429 r25835  
    22    distRun.dist_id,
    33    distRun.label,
     4    distTarget.dist_group,
    45    stage,
    56    stage_id,
    … …  
    1617    rawImfile.magicked
    1718FROM distRun
     19JOIN distTarget USING(target_id, stage)
    1820JOIN rawExp ON rawExp.exp_id = stage_id
    1921JOIN rawImfile USING(exp_id)
    … …  
    3537    distRun.dist_id,
    3638    distRun.label,
     39    distTarget.dist_group,
    3740    stage,
    3841    stage_id,
    … …  
    4952    rawExp.magicked
    5053FROM distRun
     54JOIN distTarget USING(target_id, stage)
    5155JOIN rawExp ON exp_id = stage_id
    5256LEFT JOIN distComponent

  • trunk/ippTools/share/disttool_pending_stack.sql

    r25429 r25835  
    22    distRun.dist_id,
    33    distRun.label,
     4    distTarget.dist_group,
    45    stage,
    56    stage_id,
    … …  
    1819    0 AS magicked
    1920FROM distRun
     21JOIN distTarget USING(target_id, stage)
    2022JOIN stackRun
    2123    ON stage_id = stack_id

  • trunk/ippTools/share/disttool_pending_warp.sql

    r25429 r25835  
    22    distRun.dist_id,
    33    distRun.label,
     4    distTarget.dist_group,
    45    stage,
    56    stage_id,
    … …  
    1617    warpSkyfile.magicked
    1718FROM distRun
     19JOIN distTarget USING(target_id, stage)
    1820JOIN warpRun ON stage_id = warp_id
    1921JOIN warpSkyfile using(warp_id)

  • trunk/ippTools/share/disttool_pendingfileset.sql

    r25674 r25835  
    44    distRun.stage,
    55    stage_id,
    6     distTarget.label,
     6    distTarget.dist_group,
    77    distTarget.filter,
    88    CONCAT_WS('.', distRun.outroot, CONVERT(distRun.dist_id, CHAR)) as dist_dir,

  • trunk/ippTools/share/faketool_completely_processed_exp.sql

    r20608 r25835  
    66    workdir,
    77    label,
     8    data_group,
     9    dist_group,
    810    reduction,
    911    expgroup,
    … …  
    1113    tess_id,
    1214    end_stage,
    13     epoch
     15    epoch,
     16    note
    1417FROM
    1518    (SELECT

  • trunk/ippTools/share/faketool_queue_cam_id.sql

    r19092 r25835  
    66        '%s',           -- workdir
    77        '%s',           -- label
     8        '%s',           -- data_group
     9        '%s',           -- dist_group
    810        '%s',           -- reduction
    911        '%s',           -- expgroup
    … …  
    1113        '%s',           -- tess_id
    1214        '%s',           -- end_stage
    13         NULL            -- epoch
     15        NULL,           -- epoch
     16        '%s'            -- note
    1417    FROM camRun
    1518    WHERE

  • trunk/ippTools/share/pxadmin_create_tables.sql

    r25816 r25835  
    261261    workdir_state VARCHAR(64),
    262262    label VARCHAR(64),
     263    data_group VARCHAR(64),
     264    dist_group VARCHAR(64),
    263265    reduction VARCHAR(64),
    264      expgroup VARCHAR(64),
     266    expgroup VARCHAR(64),
    265267    dvodb VARCHAR(255),
    266268    tess_id VARCHAR(64),
    267269    end_stage VARCHAR(64),
    268270    magicked BIGINT,
     271    note VARCHAR(255),
    269272    PRIMARY KEY(chip_id),
    270273    KEY(chip_id), KEY(exp_id),
    … …  
    272275    KEY(workdir_state),
    273276    KEY(label),
     277    KEY(data_group),
     278    KEY(dist_group),
    274279    KEY(expgroup),
    275280    KEY(end_stage),
    … …  
    367372    workdir_state VARCHAR(64),
    368373    label VARCHAR(64),
     374    data_group VARCHAR(64),
     375    dist_group VARCHAR(64),
    369376    reduction VARCHAR(64),
    370377    expgroup VARCHAR(64),
    … …  
    373380    end_stage VARCHAR(64),
    374381    magicked BIGINT,
     382    note VARCHAR(255),
    375383    PRIMARY KEY(cam_id),
    376384    KEY(cam_id),
    … …  
    379387    KEY(workdir_state),
    380388    KEY(label),
     389    KEY(data_group),
     390    KEY(dist_group),
    381391    KEY(expgroup),
    382392    KEY(end_stage),
    … …  
    466476    reduction VARCHAR(64),
    467477    label VARCHAR(64),
     478    data_group VARCHAR(64),
    468479    dvodb VARCHAR(255),
     480    note  VARCHAR(255),
    469481    image_only TINYINT,
    470482    PRIMARY KEY(add_id),
    … …  
    474486    KEY(workdir_state),
    475487    KEY(label),
     488    KEY(data_group),
    476489    INDEX(add_id, cam_id),
    477490    FOREIGN KEY(cam_id) REFERENCES camRun(cam_id)
    … …  
    498511    workdir VARCHAR(255),
    499512    label VARCHAR(64),
     513    data_group VARCHAR(64),
     514    dist_group VARCHAR(64),
    500515    reduction VARCHAR(64),
    501516    expgroup VARCHAR(64),
    … …  
    504519    end_stage VARCHAR(64),
    505520    epoch TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
     521    note VARCHAR(255),
    506522    PRIMARY KEY(fake_id),
    507523    KEY(cam_id),
    508524    KEY(state),
    509525    KEY(label),
     526    KEY(data_group),
     527    KEY(dist_group),
    510528    KEY(expgroup),
    511529    KEY(end_stage),
    … …  
    834852    workdir_state VARCHAR(64),
    835853    label VARCHAR(64),
     854    data_group VARCHAR(64),
     855    dist_group VARCHAR(64),
    836856    dvodb VARCHAR(255),
    837857    tess_id VARCHAR(64),
    … …  
    840860    registered DATETIME,
    841861    magicked BIGINT,
     862    note VARCHAR(255),
    842863    PRIMARY KEY(warp_id),
    843864    KEY(warp_id),
    … …  
    847868    KEY(workdir_state),
    848869    KEY(label),
     870    KEY(data_group),
     871    KEY(dist_group),
    849872    KEY(end_stage),
    850873    INDEX(warp_id, fake_id),
    … …  
    910933        workdir VARCHAR(255),
    911934        label VARCHAR(64),
     935        data_group VARCHAR(64),
     936        dist_group VARCHAR(64),
    912937        reduction VARCHAR(64),
    913938        dvodb VARCHAR(255),
    … …  
    916941        tess_id VARCHAR(64),
    917942        filter VARCHAR(64),
     943        note VARCHAR(255),
    918944        PRIMARY KEY(stack_id),
    919945        KEY(stack_id),
    … …  
    921947        KEY(skycell_id),
    922948        KEY(tess_id),
    923         KEY(label)
     949        KEY(label),
     950        KEY(data_group),
     951        KEY(dist_group)
    924952) ENGINE=innodb DEFAULT CHARSET=latin1;
    925953
    … …  
    9731001        workdir VARCHAR(255),
    9741002        label VARCHAR(64),
     1003        data_group VARCHAR(64),
     1004        dist_group VARCHAR(64),
    9751005        reduction VARCHAR(64),
    9761006        dvodb VARCHAR(255),
    … …  
    9801010        exposure TINYINT DEFAULT 0,
    9811011        magicked BIGINT,
     1012        note VARCHAR(255),
    9821013        PRIMARY KEY(diff_id),
    9831014        KEY(diff_id),
    9841015        KEY(state),
    9851016        KEY(tess_id),
    986         KEY(label)
     1017        KEY(label),
     1018        KEY(data_group),
     1019        KEY(dist_group)
    9871020) ENGINE=innodb DEFAULT CHARSET=latin1;
    9881021
    … …  
    10551088        workdir_state VARCHAR(255),
    10561089        label VARCHAR(64),
     1090        data_group VARCHAR(64),
    10571091        dvodb VARCHAR(255),
    10581092        registered DATETIME,
    10591093        fault SMALLINT,
     1094        note VARCHAR(255),
    10601095        PRIMARY KEY(magic_id),
    10611096        KEY(magic_id),
    … …  
    10631098        KEY(workdir_state),
    10641099        KEY(label),
     1100        KEY(data_group),
    10651101        KEY(fault),
    10661102        FOREIGN KEY(exp_id)  REFERENCES rawExp(exp_id),
    … …  
    11181154        cam_id BIGINT,
    11191155        label VARCHAR(64),
     1156        data_group VARCHAR(64),
    11201157        outroot VARCHAR(255),
    11211158        recoveryroot VARCHAR(255),
    11221159        re_place TINYINT,
    11231160        remove TINYINT,
     1161        fault SMALLINT,
     1162        note VARCHAR(255),
    11241163        PRIMARY KEY(magic_ds_id),
    11251164        KEY(magic_ds_id),
    … …  
    11271166        KEY(magic_id),
    11281167        KEY(label),
     1168        KEY(fault),
    11291169        FOREIGN KEY(magic_id) REFERENCES magicRun(magic_id),
    11301170        FOREIGN KEY(inv_magic_id) REFERENCES magicRun(magic_id)
    … …  
    13031343    time_stamp  TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    13041344    fault       SMALLINT,
     1345    note        VARCHAR(255),
    13051346    PRIMARY KEY(dist_id),
    13061347    KEY(state),

  • trunk/ippTools/src/addtool.c

    r25816 r25835  
    111111    PXOPT_LOOKUP_STR(dvodb,       config->args, "-set_dvodb", false, false);
    112112    PXOPT_LOOKUP_STR(label,       config->args, "-set_label", false, false);
     113    PXOPT_LOOKUP_STR(data_group,  config->args, "-set_data_group", false, false);
    113114    PXOPT_LOOKUP_STR(reduction,   config->args, "-set_reduction", false, false);
     115    PXOPT_LOOKUP_STR(note,        config->args, "-set_note", false, false);
    114116    PXOPT_LOOKUP_BOOL(image_only, config->args, "-image_only", false);
    115117    PXOPT_LOOKUP_BOOL(pretend,    config->args, "-pretend", false);
    … …  
    216218                               reduction   ? reduction : row->reduction,
    217219                               label       ? label     : row->label,
     220                               data_group  ? data_group : (label ? label : row->label),
    218221                               dvodb       ? dvodb     : row->dvodb,
     222                               note        ? note      : NULL,
    219223                               image_only
    220224        )) {
    … …  
    253257    PXOPT_COPY_STR(config->args, where, "-reduction", "addRun.reduction", "==");
    254258
    255     if (!psListLength(where->list)
    256         && !psMetadataLookupBool(NULL, config->args, "-all")) {
     259    if (!psListLength(where->list)) {
    257260        psFree(where);
    258261        psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
    … …  
    260263    }
    261264
     265    psString query = psStringCopy("UPDATE addRun JOIN camRun USING(cam_id) JOIN chipRun USING(chip_id) JOIN rawExp USING(exp_id)");
     266
     267    // pxUpdateRun gets parameters from config->args and runs the update query
     268    bool result = pxUpdateRun(config, where, &query, false);
     269
     270    psFree(query);
     271    psFree(where);
     272
     273    return result;
     274
     275
     276#ifdef notdef
    262277    PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
    263278    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
    … …  
    288303
    289304    return true;
     305#endif
    290306}
    291307

  • trunk/ippTools/src/addtoolConfig.c

    r25816 r25835  
    6161    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-pretend",           0, "do not actually modify the database", false);
    6262    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple",            0, "use the simple output format", false);
     63
     64    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_data_group", 0,   "define new data_group", NULL);
     65    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_dist_group", 0,   "define new dist_group", NULL);
     66    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_note", 0,         "define new note", NULL);
    6367    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-all",               0, "allow everything to be queued without search terms", false);
    6468
    … …  
    7478    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state",              0, "set state", NULL);
    7579    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_label",              0, "set label", NULL);
    76 
     80    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_data_group", 0,   "define new data_group", NULL);
     81    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_dist_group", 0,   "define new dist_group", NULL);
     82    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_note", 0,         "define new note", NULL);
    7783    // -pendingexp
    7884    psMetadata *pendingexpArgs = psMetadataAlloc();

  • trunk/ippTools/src/camtool.c

    r25330 r25835  
    121121    PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", false, false);
    122122    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
     123    PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
     124    PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false);
    123125    PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false);
    124126    PXOPT_LOOKUP_STR(expgroup, config->args, "-set_expgroup", false, false);
    … …  
    126128    PXOPT_LOOKUP_STR(tess_id, config->args, "-set_tess_id", false, false);
    127129    PXOPT_LOOKUP_STR(end_stage, config->args, "-set_end_stage", false, false);
     130    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
    128131
    129132    // find the exp_id of all the exposures that we want to queue up.
    … …  
    212215                    workdir     ? workdir   : row->workdir,
    213216                    label       ? label     : row->label,
     217                    data_group  ? data_group: row->data_group,
     218                    dist_group  ? dist_group: row->dist_group,
    214219                    reduction   ? reduction : row->reduction,
    215220                    expgroup    ? expgroup  : row->expgroup,
    216221                    dvodb       ? dvodb     : row->dvodb,
    217222                    tess_id     ? tess_id   : row->tess_id,
    218                     end_stage   ? end_stage : row->end_stage
     223                    end_stage   ? end_stage : row->end_stage,
     224                    note
    219225        )) {
    220226            if (!psDBRollback(config->dbh)) {
    … …  
    251257    PXOPT_COPY_STR(config->args, where, "-reduction", "camRun.reduction", "==");
    252258
    253     if (!psListLength(where->list)
    254         && !psMetadataLookupBool(NULL, config->args, "-all")) {
     259    if (!psListLength(where->list)) {
    255260        psFree(where);
    256261        psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
    257262        return false;
    258263    }
    259 
    260     PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
    261     PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
    262 
    263     if ((!state) && (!label)) {
    264         psError(PXTOOLS_ERR_DATA, false, "parameters are required");
    265         psFree(where);
    266         return false;
    267     }
    268 
    269     if (state) {
    270         // set camRun.state to state
    271         if (!pxcamRunSetStateByQuery(config, where, state)) {
    272             psFree(where);
    273             return false;
    274         }
    275     }
    276 
    277     if (label) {
    278         // set camRun.label to label
    279         if (!pxcamRunSetLabelByQuery(config, where, label)) {
    280             psFree(where);
    281             return false;
    282         }
    283     }
    284 
     264    psString query = psStringCopy("UPDATE camRun JOIN chipRun USING(chip_id) JOIN rawExp USING(exp_id)");
     265
     266    // pxUpdateRun gets parameters from config->args and updates
     267    bool result = pxUpdateRun(config, where, &query, true);
     268    if (!result) {
     269        psError(PXTOOLS_ERR_DATA, false, "pxUpdateRun failed");
     270    }
     271
     272    psFree(query);
    285273    psFree(where);
    286274
    287     return true;
     275    return result;
    288276}
    289277
    … …  
    642630            pendingRow->workdir,
    643631            pendingRow->label,
     632            pendingRow->data_group,
     633            pendingRow->dist_group,
    644634            pendingRow->reduction,
    645635            pendingRow->expgroup,
    646636            pendingRow->dvodb,
    647637            pendingRow->tess_id,
    648             pendingRow->end_stage
     638            pendingRow->end_stage,
     639            NULL    // note does not propagate
    649640    )) {
    650641        // rollback
    … …  
    656647        return false;
    657648    }
    658 
    659 /*     if (!pxaddQueueByCamID(config, */
    660 /*                         pendingRow->cam_id, */
    661 /*                         pendingRow->workdir, */
    662 /*                         pendingRow->label, */
    663 /*                         pendingRow->reduction, */
    664 /*                         pendingRow->dvodb */
    665 /*     )) { */
    666 /*         // rollback */
    667 /*         if (!psDBRollback(config->dbh)) { */
    668 /*             psError(PS_ERR_UNKNOWN, false, "database error"); */
    669 /*         } */
    670 /*         psError(PS_ERR_UNKNOWN, false, "failed to queue new addRun"); */
    671 /*         psFree(pendingRow); */
    672 /*         return false; */
    673 /*     } */
    674649
    675650    psFree(pendingRow);

  • trunk/ippTools/src/camtoolConfig.c

    r24681 r25835  
    6262    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_tess_id",        0, "define tess ID", NULL);
    6363    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_end_stage",      0, "define end stage", NULL);
    64     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-all",               0, "allow everything to be queued without search terms", false);
     64    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_data_group",     0, "define data group", NULL);
     65    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_dist_group",     0, "define dist group", NULL);
     66    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_note",           0, "define note", NULL);
    6567
    6668    // -updaterun
    … …  
    7779    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state",          0, "set state", NULL);
    7880    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_label",          0, "set label", NULL);
    79 
     81    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_data_group", 0,   "define new data_group", NULL);
     82    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_dist_group", 0,   "define new dist_group", NULL);
     83    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_note", 0,         "define new note", NULL);
    8084    // -pendingexp
    8185    psMetadata *pendingexpArgs = psMetadataAlloc();

  • trunk/ippTools/src/chiptool.c

    r25822 r25835  
    146146    PXOPT_LOOKUP_STR(tess_id, config->args, "-set_tess_id", false, false);
    147147    PXOPT_LOOKUP_STR(end_stage, config->args, "-set_end_stage", false, false);
     148    PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false);
     149    PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
     150    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
    148151
    149152    // default
    … …  
    265268                                 workdir     ? workdir   : raw_workdir,
    266269                                 label       ? label     : raw_label,
     270                                 data_group  ? data_group : (label ? label : raw_label),
     271                                 dist_group,
    267272                                 reduction   ? reduction : raw_reduction,
    268273                                 // expgroup    ? expgroup  : raw_expgroup,
    … …  
    271276                                 dvodb       ? dvodb     : raw_dvodb,
    272277                                 tess_id     ? tess_id   : raw_tess_id,
    273                                  end_stage   ? end_stage : raw_end_stage
     278                                 end_stage   ? end_stage : raw_end_stage,
     279                                 note
    274280                                 )) {
    275281            if (!psDBRollback(config->dbh)) {
    … …  
    303309    PXOPT_COPY_STR(config->args,  where, "-label",   "chipRun.label",   "==");
    304310    PXOPT_COPY_STR(config->args,  where, "-state",   "chipRun.state",   "==");
    305 
    306     if (!psListLength(where->list) &&
    307         !psMetadataLookupBool(NULL, config->args, "-all")) {
     311    PXOPT_COPY_STR(config->args,  where, "-data_group", "chipRun.data_group",   "==");
     312    PXOPT_COPY_STR(config->args,  where, "-dist_group", "chipRun.dist_group",   "==");
     313
     314    if (!psListLength(where->list)) {
    308315        psFree(where);
    309         where = NULL;
    310316        psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
    311317        return false;
    312318    }
    313 
    314     PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
    315     PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
    316 
    317     if ((!state) && (!label)) {
    318         psError(PXTOOLS_ERR_DATA, false, "parameters are required");
    319         psFree(where);
    320         return false;
    321     }
    322 
    323     if (state) {
    324         // set chipRun.state to state
    325         if (!pxchipRunSetStateByQuery(config, where, state)) {
    326             psFree(where);
    327             return false;
    328         }
    329     }
    330 
    331     if (label) {
    332         // set chipRun.label to label
    333         if (!pxchipRunSetLabelByQuery(config, where, label)) {
    334             psFree(where);
    335             return false;
    336         }
    337     }
    338 
     319    psString query = psStringCopy("UPDATE chipRun JOIN rawExp USING(exp_id)");
     320
     321    // pxUpdateRun gets parameters from config->args and updates
     322    bool result = pxUpdateRun(config, where, &query, true);
     323    if (!result) {
     324        psError(PXTOOLS_ERR_DATA, false, "pxUpdateRun failed");
     325    }
     326
     327    psFree(query);
    339328    psFree(where);
    340329
    341     return true;
     330    return result;
    342331}
    343332
    … …  
    12581247                    chipRun->workdir,
    12591248                    chipRun->label,
     1249                    chipRun->data_group,
     1250                    chipRun->dist_group,
    12601251                    chipRun->reduction,
    12611252                    chipRun->expgroup,
    12621253                    chipRun->dvodb,
    12631254                    chipRun->tess_id,
    1264                     chipRun->end_stage
     1255                    chipRun->end_stage,
     1256                    NULL    // note does not propagate
    12651257        )) {
    12661258           if (!psDBRollback(config->dbh)) {

  • trunk/ippTools/src/chiptoolConfig.c

    r25822 r25835  
    5858    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_tess_id",  0,            "define tessellation identifier", NULL);
    5959    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_end_stage",  0,            "define end stage", NULL);
     60    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_data_group",  0,      "define data group", NULL);
     61    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_dist_group",  0,      "define distribution group", NULL);
     62    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_note",  0,           "define note", NULL);
    6063    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-pretend",  0,            "do not actually modify the database", false);
    6164    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    62     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);
    6365
    6466    // -updaterun
    … …  
    6769    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-chip_id",              0,            "search by chip ID", 0);
    6870    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,            "search by state", NULL);
    69     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label",  0,          "search by label", NULL);
     71    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label",  0,           "search by label", NULL);
     72    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-data_group",  0,      "search by data_group", NULL);
     73    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-dist_group",  0,      "search by dist_group", NULL);
    7074    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state", 0,        "set state", NULL);
    7175    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_label", 0,        "set label", NULL);
    72     psMetadataAddBool(updaterunArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);
     76    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_data_group", 0,   "set data group", NULL);
     77    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_dist_group", 0,   "set dist group", NULL);
     78    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_note", 0,         "set note", NULL);
    7379
    7480    // -pendingimfile

  • trunk/ippTools/src/difftool.c

    r25800 r25835  
    5151
    5252static bool setdiffRunState(pxConfig *config, psS64 diff_id, const char *state, psS64 magicked);
    53 static bool setdiffRunStateByLabel(pxConfig *config, const char* label, const char *state);
    5453static bool change_skyfile_data_state(pxConfig *config, psString data_state, psString run_state);
    5554static bool tocleanedskyfileMode(pxConfig *config);
    … …  
    126125
    127126    // required options
    128     PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false);
     127    PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", true, false);
    129128    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", true, false);
    130129    PXOPT_LOOKUP_BOOL(bothways, config->args, "-bothways", false);
    131130    PXOPT_LOOKUP_BOOL(exposure, config->args, "-exposure", false);
    132     PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
    133     PXOPT_LOOKUP_STR(reduction, config->args, "-reduction", false, false);
     131    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
     132    PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
     133    PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false);
     134    PXOPT_LOOKUP_STR(reduction, config->args, "-rset_eduction", false, false);
     135    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
    134136
    135137    // default
    … …  
    142144            workdir,
    143145            label,
     146            data_group ? data_group : label,
     147            dist_group,
    144148            reduction,
    145149            NULL,       // dvodb
    … …  
    148152            bothways,
    149153            exposure,
    150             false
     154            false,
     155            note
    151156    );
    152157    if (!run) {
    … …  
    179184    PS_ASSERT_PTR_NON_NULL(config, false);
    180185
     186    psMetadata *where = psMetadataAlloc();
     187
     188    PXOPT_COPY_S64(config->args, where, "-diff_id",  "stack_id",   "==");
     189    PXOPT_COPY_STR(config->args, where, "-label",     "label",     "==");
     190    PXOPT_COPY_STR(config->args, where, "-state",     "state",     "==");
     191    if (!psListLength(where->list)) {
     192        psFree(where);
     193        psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     194        return false;
     195    }
     196
     197    psString query = psStringCopy("UPDATE diffRun");
     198
     199    // pxUpdateRun gets parameters from config->args and updates
     200    bool result = pxUpdateRun(config, where, &query, true);
     201
     202    psFree(query);
     203    psFree(where);
     204
     205    return result;
     206
     207#ifdef notdef
    181208    // required options
    182209    PXOPT_LOOKUP_S64(diff_id, config->args, "-diff_id", false, false);
    … …  
    197224
    198225    return false;
     226#endif
    199227}
    200228
    … …  
    907935
    908936
     937#ifdef notdef
    909938static bool setdiffRunStateByLabel(pxConfig *config, const char *label, const char *state) {
    910939  PS_ASSERT_PTR_NON_NULL(state,false);
    … …  
    925954  return true;
    926955}
     956#endif
    927957
    928958// Generate a single populated run
    … …  
    932962                         const char *tess_id, // Tessellation identifier
    933963                         const char *label, // label
     964                         const char *data_group, // data_group
     965                         const char *dist_group, // dist_group
    934966                         const char *reduction, // reduction
     967                         const char *note,      // note
    935968                         psS64 input_warp_id, // Warp identifier for input image, PS_MAX_S64 for none
    936969                         psS64 input_stack_id, // Stack identifier for input image, PS_MAX_S64 for none
    … …  
    963996            workdir,
    964997            label,
     998            data_group ? data_group : label,
     999            dist_group,
    9651000            reduction,
    9661001            NULL,       // dvodb
    … …  
    9691004            false,
    9701005            false,
    971             0       // magicked
     1006            0,       // magicked
     1007            note
    9721008    );
    9731009
    … …  
    10431079    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", true, false); // required options
    10441080    PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
     1081    PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
     1082    PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false);
    10451083    PXOPT_LOOKUP_STR(reduction, config->args, "-reduction", false, false);
    10461084    PXOPT_LOOKUP_S64(template_warp_id, config->args, "-template_warp_id", false, false);
    … …  
    10491087    PXOPT_LOOKUP_S64(input_stack_id, config->args, "-input_stack_id", false, false);
    10501088    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1089    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
    10511090
    10521091    if (template_stack_id && template_warp_id) {
    … …  
    10721111    psArray *list = psArrayAllocEmpty(16); // List of runs, to print
    10731112
    1074     if (!populatedrun(list, workdir, skycell_id, tess_id, label, reduction,
     1113    if (!populatedrun(list, workdir, skycell_id, tess_id, label, data_group ? data_group : label, dist_group, reduction, note,
    10751114                      input_warp_id ? input_warp_id : PS_MAX_S64,
    10761115                      input_stack_id ? input_stack_id : PS_MAX_S64,
    … …  
    11111150    PXOPT_COPY_STR(config->args, stackWhere, "-stack_label", "stackRun.label", "==");
    11121151
    1113     PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false); // required options
    1114     PXOPT_LOOKUP_STR(reduction, config->args, "-reduction", false, false); // option
    1115     PXOPT_LOOKUP_STR(label, config->args, "-label", false, false); // option
    1116     PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
     1152    PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", true, false); // required option
     1153    PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false); // option
     1154    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false); // option
     1155    PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
     1156    PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false);
     1157    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
     1158    PXOPT_LOOKUP_TIME(registered, config->args, "-set_registered", false, false);
     1159
    11171160    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    11181161    PXOPT_LOOKUP_BOOL(newTemplates, config->args, "-new-templates", false);
    … …  
    13501393                workdir,
    13511394                label,
     1395                data_group ? data_group : label,
     1396                dist_group,
    13521397                reduction,
    13531398                NULL,       // dvodb
    … …  
    13561401                false,                  // bothways
    13571402                true,                   // exposure
    1358                 0       // magicked
     1403                0,       // magicked
     1404                note
    13591405        );
    13601406
    … …  
    14251471    }
    14261472
    1427     if (!diffRunPrintObjects(stdout, list, !simple)) {
     1473    if (numGood && !diffRunPrintObjects(stdout, list, !simple)) {
    14281474        psError(PS_ERR_UNKNOWN, false, "failed to print object");
    14291475        psFree(list);
    … …  
    15061552
    15071553    // Settings to apply to defined run
    1508     PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false); // required options
    1509     PXOPT_LOOKUP_STR(reduction, config->args, "-reduction", false, false); // option
    1510     PXOPT_LOOKUP_STR(label, config->args, "-label", false, false); // option
    1511     PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
     1554    PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", true, false); // required options
     1555    PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false); // option
     1556    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false); // option
     1557    PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false); // option
     1558    PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false); // option
     1559    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false); // option
     1560    PXOPT_LOOKUP_TIME(registered, config->args, "-set_registered", false, false);
     1561
    15121562    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    15131563    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
    … …  
    16931743        }
    16941744
    1695         diffRunRow *run = diffRunRowAlloc(0, "reg", workdir, label, reduction, NULL, registered,
    1696                                           tess_id, true, true, false); // Run to insert
     1745        diffRunRow *run = diffRunRowAlloc(0, "reg", workdir, label, data_group ? data_group : label, dist_group, reduction, NULL, registered,
     1746                                          tess_id, true, true, false, note); // Run to insert
    16971747        if (!diffRunInsertObject(config->dbh, run)) {
    16981748            psError(PS_ERR_UNKNOWN, false, "database error");

  • trunk/ippTools/src/difftoolConfig.c

    r25800 r25835  
    4747    // -definerun
    4848    psMetadata *definerunArgs = psMetadataAlloc();
    49     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-workdir", 0,            "define workdir (required)", NULL);
     49    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_workdir", 0,         "define workdir (required)", NULL);
    5050    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-tess_id",  0,            "define tessellation ID (required)", NULL);
    51     psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-bothways",  0,            "do the subtraction both ways?", false);
    52     psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-exposure",  0,            "subtraction for entire exposure?", false);
    53     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-label",  0,            "define label", NULL);
    54     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-reduction",  0,            "define reduction class", NULL);
    55     psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
     51    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-bothways",  0,          "do the subtraction both ways?", false);
     52    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-exposure",  0,          "subtraction for entire exposure?", false);
     53    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_label",  0,          "define label", NULL);
     54    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_reduction",  0,      "define reduction class", NULL);
     55    psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-set_registered",  0,    "time detrend run was registered", now);
     56    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_data_group",  0,     "define data group", NULL);
     57    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_dist_group",  0,     "define dist group", NULL);
     58    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_note",  0,           "define note", NULL);
    5659    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    5760
    … …  
    6164    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,            "set state (required)", NULL);
    6265    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label", 0,            "define by label instead of diff ID", 0);
    63    
     66    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_label", 0,        "define new value for label", 0);
     67    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state", 0,        "define new state", NULL);
     68    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_data_group", 0,   "define new data_group", NULL);
     69    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_dist_group", 0,   "define new dist_group", NULL);
     70    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_note", 0,         "define new note", NULL);
     71
    6472    // -addinputskyfile
    6573    psMetadata *addinputskyfileArgs = psMetadataAlloc();
    … …  
    175183    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-warp_label", 0, "search by warp label", NULL);
    176184    psMetadataAddF32(definewarpstackArgs, PS_LIST_TAIL, "-good_frac", 0, "minimum good fraction of skycell", NAN);
    177     psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-workdir", 0, "define workdir (required)", NULL);
    178     psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-label",  0, "define label", NULL);
    179     psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-reduction",  0, "define reduction class", NULL);
    180     psMetadataAddTime(definewarpstackArgs, PS_LIST_TAIL, "-registered", 0, "time detrend run was registered", now);
     185    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-set_workdir", 0, "define workdir (required)", NULL);
     186    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-set_label",  0, "define label", NULL);
     187    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-set_reduction",  0, "define reduction class", NULL);
     188    psMetadataAddTime(definewarpstackArgs, PS_LIST_TAIL, "-set_registered", 0, "time detrend run was registered", now);
     189    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-set_data_group",  0,     "define data group", NULL);
     190    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-set_dist_group",  0,     "define dist group", NULL);
     191    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-set_note",  0,           "define note", NULL);
    181192    psMetadataAddBool(definewarpstackArgs, PS_LIST_TAIL, "-new-templates", 0, "also search for diffs with new template", false);
    182193    psMetadataAddBool(definewarpstackArgs, PS_LIST_TAIL, "-rerun", 0, "define new run even if one exists", false);
    … …  
    198209    psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-template_label", 0, "search by warp label for template", NULL);
    199210    psMetadataAddF32(definewarpwarpArgs, PS_LIST_TAIL, "-good_frac", 0, "minimum good fraction of skycell", NAN);
    200     psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-workdir", 0, "define workdir (required)", NULL);
    201     psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-label",  0, "define label", NULL);
    202     psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-reduction",  0, "define reduction class", NULL);
    203     psMetadataAddTime(definewarpwarpArgs, PS_LIST_TAIL, "-registered", 0, "time detrend run was registered", now);
     211    psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-set_workdir", 0, "define workdir (required)", NULL);
     212    psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-set_label",  0, "define label", NULL);
     213    psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-set_reduction",  0, "define reduction class", NULL);
     214    psMetadataAddTime(definewarpwarpArgs, PS_LIST_TAIL, "-set_registered", 0, "time detrend run was registered", now);
     215    psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-set_data_group",  0,     "define data group", NULL);
     216    psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-set_dist_group",  0,     "define dist group", NULL);
     217    psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-set_note",  0,           "define note", NULL);
    204218    psMetadataAddBool(definewarpwarpArgs, PS_LIST_TAIL, "-rerun", 0, "define new run even if one exists", false);
    205219    psMetadataAddBool(definewarpwarpArgs, PS_LIST_TAIL, "-available", 0, "define new run even if warpRun has some faults", false);

  • trunk/ippTools/src/disttool.c

    r25567 r25835  
    3232
    3333static bool definebyqueryMode(pxConfig *config);
    34 static bool definerunMode(pxConfig *config);
    3534static bool updaterunMode(pxConfig *config);
    3635static bool revertrunMode(pxConfig *config);
    … …  
    7978    switch (config->mode) {
    8079        MODECASE(DISTTOOL_MODE_DEFINEBYQUERY, definebyqueryMode);
    81         MODECASE(DISTTOOL_MODE_DEFINERUN, definerunMode);
    8280        MODECASE(DISTTOOL_MODE_UPDATERUN, updaterunMode);
    8381        MODECASE(DISTTOOL_MODE_REVERTRUN, revertrunMode);
    … …  
    123121}
    124122
    125 static bool definerunMode(pxConfig *config)
    126 {
    127     PS_ASSERT_PTR_NON_NULL(config, false);
    128 
    129     // required
    130     PXOPT_LOOKUP_STR(stage, config->args, "-stage", true, false);
    131     PXOPT_LOOKUP_S64(stage_id, config->args, "-stage_id",  true, false);
    132     PXOPT_LOOKUP_STR(outroot, config->args, "-outroot", true, false);
    133     PXOPT_LOOKUP_S64(target_id, config->args, "-target_id",  true, false);
    134 
    135     // optional
    136     PXOPT_LOOKUP_BOOL(clean, config->args, "-clean", false);
    137     PXOPT_LOOKUP_BOOL(no_magic, config->args, "-no_magic", false);
    138     PXOPT_LOOKUP_STR(set_label, config->args, "-set_label", false, false);
    139 
    140     // TODO: check that stage has an expected value
    141     // XXX: all of the following concerns will be managed properly by definebyquery
    142 
    143     // TODO: should we check that stage_id actually exists for stage
    144     // in magicdstool we queue off of a magic_id so the stage_id, exp_id, and cam_id get looked up
    145     // when the run is queued
    146 
    147     if (!distRunInsert(config->dbh,
    148             0,          // dist_id
    149             target_id,
    150             stage,
    151             stage_id,
    152             0,
    153             set_label,
    154             outroot,
    155             clean,
    156             no_magic,
    157             "new",
    158             NULL,       // time_stamp
    159             0           // fault
    160             )) {
    161         psError(PS_ERR_UNKNOWN, false, "database error");
    162         return false;
    163     }
    164 
    165     return true;
    166 }
    167123
    168124static bool definebyqueryMode(pxConfig *config)
    … …  
    178134    PXOPT_LOOKUP_BOOL(no_magic, config->args, "-no_magic", false);
    179135    PXOPT_LOOKUP_STR(set_label, config->args, "-set_label", false, false);
     136    PXOPT_LOOKUP_STR(set_note, config->args, "-set_note", false, false);
     137
    180138    PXOPT_LOOKUP_S64(limit, config->args, "-limit", false, false);
    181139    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    191149
    192150    PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
     151    PXOPT_LOOKUP_STR(dist_group, config->args, "-dist_group", false, false);
    193152
    194153    psString query = NULL;
    … …  
    209168            psStringAppend(&query, " AND (chipRun.label = '%s')", label);
    210169        }
     170        if (dist_group) {
     171            psStringAppend(&query, " AND (chipRun.dist_group = '%s')", dist_group);
     172        }
    211173    } else if (!strcmp(stage, "chip")) {
    212174        magicRunType = "chipRun";
    … …  
    222184            psStringAppend(&query, " AND (chipRun.label = '%s')", label);
    223185        }
     186        if (dist_group) {
     187            psStringAppend(&query, " AND (chipRun.dist_group = '%s')", dist_group);
     188        }
    224189    } else if (!strcmp(stage, "camera")) {
    225190        magicRunType = "camRun";    // This is used below to set the magicked business
    … …  
    235200            psStringAppend(&query, " AND (camRun.label = '%s')", label);
    236201        }
     202        if (dist_group) {
     203            psStringAppend(&query, " AND (camRun.dist_group = '%s')", dist_group);
     204        }
    237205    } else if (!strcmp(stage, "fake")) {
    238206        magicRunType = "fakeRun";
    … …  
    246214        if (label) {
    247215            psStringAppend(&query, " AND (fakeRun.label = '%s')", label);
     216        }
     217        if (dist_group) {
     218            psStringAppend(&query, " AND (fakeRun.dist_group = '%s')", dist_group);
    248219        }
    249220        // fake stage doesn't require magic
    … …  
    262233            psStringAppend(&query, " AND (warpRun.label = '%s')", label);
    263234        }
     235        if (dist_group) {
     236            psStringAppend(&query, " AND (warpRun.dist_group = '%s')", dist_group);
     237        }
    264238
    265239    } else if (!strcmp(stage, "diff")) {
    … …  
    276250            psStringAppend(&query, " AND (diffRun.label = '%s')", label);
    277251        }
     252        if (dist_group) {
     253            psStringAppend(&query, " AND (diffRun.dist_group = '%s')", dist_group);
     254        }
    278255
    279256    } else if (!strcmp(stage, "stack")) {
    … …  
    288265        if (label) {
    289266            psStringAppend(&query, " AND (stackRun.label = '%s')", label);
     267        }
     268        if (dist_group) {
     269            psStringAppend(&query, " AND (stackRun.dist_group = '%s')", dist_group);
    290270        }
    291271        // stack stage doesn't require magic
    … …  
    371351        psS64 magic_ds_id = psMetadataLookupS64(NULL, md, "magicked");
    372352        psS64 target_id = psMetadataLookupS64(NULL, md, "target_id");
    373         psString target_label = psMetadataLookupStr(NULL, md, "label");
     353        psString stage_label = psMetadataLookupStr(NULL, md, "label");
    374354        bool clean = psMetadataLookupBool(NULL, md, "clean");
    375355
    … …  
    381361            new_label = set_label;
    382362        } else {
    383             new_label = target_label;
     363            new_label = stage_label;
    384364        }
    385365        distRunRow *row = distRunRowAlloc(
    … …  
    395375                "new",
    396376                NULL,   // time_stamp
    397                 0       // fault
     377                0,       // fault
     378                set_note    // note does not propagate
    398379                );
    399380
    … …  
    12391220
    12401221    // required
    1241     PXOPT_LOOKUP_STR(label, config->args, "-label", true, false);
     1222    PXOPT_LOOKUP_STR(dist_group, config->args, "-dist_group", true, false);
    12421223    PXOPT_LOOKUP_STR(filter, config->args, "-filter", true, false);
    12431224    PXOPT_LOOKUP_STR(stage, config->args, "-stage", true, false);
    … …  
    12501231    distTargetRow *row = distTargetRowAlloc(
    12511232            0,          // target_id
    1252             label,
     1233            dist_group,
    12531234            filter,
    12541235            stage,
    … …  
    12871268    psMetadata *where = psMetadataAlloc();
    12881269    PXOPT_COPY_S64(config->args, where, "-target_id", "target_id", "==");
    1289     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     1270    PXOPT_COPY_STR(config->args, where, "-dist_group", "dist_group", "==");
    12901271    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "==");
    12911272    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
    … …  
    13231304    psMetadata *where = psMetadataAlloc();
    13241305    PXOPT_COPY_S64(config->args, where, "-target_id", "target_id", "==");
    1325     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     1306    PXOPT_COPY_STR(config->args, where, "-dist_group", "dist_group", "LIKE");
    13261307    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "==");
    13271308    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
    … …  
    15181499    PXOPT_LOOKUP_S64(target_id, config->args,    "-target_id", false, false);
    15191500    PXOPT_LOOKUP_STR(stage, config->args,        "-stage", false, false);
    1520     PXOPT_LOOKUP_STR(label, config->args,        "-label", false, false);
     1501    PXOPT_LOOKUP_STR(dist_group, config->args,   "-dist_group", false, false);
    15211502    PXOPT_LOOKUP_STR(filter, config->args,       "-filter", false, false);
    15221503    PXOPT_LOOKUP_BOOL(clean, config->args,       "-clean", false);
    … …  
    15281509            error = true;
    15291510        }
    1530         if (!label) {
    1531             psError(PS_ERR_UNKNOWN, !error, "label is required if target_id is not supplied");
     1511        if (!dist_group) {
     1512            psError(PS_ERR_UNKNOWN, !error, "dist_group is required if target_id is not supplied");
    15321513            error = true;
    15331514        }
    … …  
    15391520    // optional
    15401521    PXOPT_LOOKUP_S64(limit, config->args, "-limit", false, false);
    1541     PXOPT_LOOKUP_STR(state, config->args,        "-set_state", false, false);
     1522    PXOPT_LOOKUP_STR(state, config->args,  "-set_state", false, false);
    15421523    if (state) {
    15431524        if (strcmp(state, "enabled") && strcmp(state, "disabled")) {
    … …  
    15551536    PXOPT_COPY_STR(config->args, where, "-dest_name", "rcDestination.name", "==");
    15561537    PXOPT_COPY_S64(config->args, where, "-target_id", "target_id", "==");
    1557     PXOPT_COPY_STR(config->args, where, "-label", "label", "LIKE");
     1538    PXOPT_COPY_STR(config->args, where, "-dist_group", "dist_group", "LIKE");
    15581539    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "LIKE");
    15591540    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
    … …  
    16581639    PXOPT_COPY_S64(config->args, where, "-target_id", "target_id", "==");
    16591640    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
    1660     PXOPT_COPY_STR(config->args, where, "-label", "label", "LIKE");
     1641    PXOPT_COPY_STR(config->args, where, "-dist_group", "dist_group", "LIKE");
    16611642    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "LIKE");
    16621643    PXOPT_COPY_STR(config->args, where, "-state", "state", "==");

  • trunk/ippTools/src/disttool.h

    r25510 r25835  
    2626    DISTTOOL_MODE_NONE      = 0x0,
    2727    DISTTOOL_MODE_DEFINEBYQUERY,
    28     DISTTOOL_MODE_DEFINERUN,
    2928    DISTTOOL_MODE_UPDATERUN,
    3029    DISTTOOL_MODE_REVERTRUN,

  • trunk/ippTools/src/disttoolConfig.c

    r25567 r25835  
    5050    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-no_magic", 0, "magic is not needed", false);
    5151    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_label",    0, "define label for run", NULL);
     52    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_note",    0, "select by dist_group", NULL);
    5253
    5354    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-dry_run", 0, "don't queue runs just display what would be selected", false);
    … …  
    5859    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-chip_id",       0, "define chip_id", 0);
    5960    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-magic_ds_id",   0, "define chip_id", 0);
    60     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label",         0, "select by label", NULL);
     61    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label",         0, "select by run label", NULL);
     62    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-dist_group",    0, "select by dist_group", NULL);
    6163
    6264    psMetadataAddU64(definebyqueryArgs, PS_LIST_TAIL, "-limit",  0,  "limit result set to N items", 0);
    6365    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    64 
    65     // -definerun
    66     psMetadata *definerunArgs = psMetadataAlloc();
    67     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-stage",         0, "define stage for bundle (required)", NULL);
    68     psMetadataAddS64(definerunArgs, PS_LIST_TAIL, "-stage_id", 0, "define stage_id (required)", 0);
    69     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-outroot",  0, "define output destination (required)", NULL);
    70     psMetadataAddS64(definerunArgs, PS_LIST_TAIL, "-target_id", 0, "define target_id (required)", 0);
    71     psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-clean", 0,   "build clean distribution bundle", false);
    72     psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-no_magic", 0, "magic is not needed", false);
    73     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_label",    0, "define label for run", NULL);
    7466
    7567    // -updaterun
    … …  
    139131    psMetadataAddS64(pendingfilesetArgs, PS_LIST_TAIL, "-dist_id", 0, "define dist_id", 0);
    140132    psMetadataAddStr(pendingfilesetArgs, PS_LIST_TAIL, "-label",   PS_META_DUPLICATE_OK, "limit results to label", NULL);
     133    psMetadataAddStr(pendingfilesetArgs, PS_LIST_TAIL, "-dist_group",   PS_META_DUPLICATE_OK, "limit results to dist_group", NULL);
    141134    psMetadataAddStr(pendingfilesetArgs, PS_LIST_TAIL, "-stage",   0, "limit results to runs for stage", NULL);
    142135    psMetadataAddU64(pendingfilesetArgs, PS_LIST_TAIL, "-limit",   0,  "limit result set to N items", 0);
    … …  
    219212    // -definetarget
    220213    psMetadata *definetargetArgs = psMetadataAlloc();
    221     psMetadataAddStr(definetargetArgs, PS_LIST_TAIL, "-label",     0, "define label (required)", NULL);
     214    psMetadataAddStr(definetargetArgs, PS_LIST_TAIL, "-dist_group", 0, "define dist_group (required)", NULL);
    222215    psMetadataAddStr(definetargetArgs, PS_LIST_TAIL, "-filter",     0, "define filter (required)", NULL);
    223216    psMetadataAddStr(definetargetArgs, PS_LIST_TAIL, "-stage",     0, "define stage (required)", NULL);
    … …  
    230223    psMetadataAddS64(updatetargetArgs, PS_LIST_TAIL, "-target_id", 0, "define target_id", 0);
    231224    psMetadataAddStr(updatetargetArgs, PS_LIST_TAIL, "-stage",     0, "define stage", NULL);
    232     psMetadataAddStr(updatetargetArgs, PS_LIST_TAIL, "-set_state", 0, "define state", NULL);
    233     psMetadataAddStr(updatetargetArgs, PS_LIST_TAIL, "-label",     0, "define label", NULL);
     225    psMetadataAddStr(updatetargetArgs, PS_LIST_TAIL, "-dist_group", 0, "define dist_group", NULL);
    234226    psMetadataAddStr(updatetargetArgs, PS_LIST_TAIL, "-filter",    0, "define filter", NULL);
     227
     228    psMetadataAddStr(updatetargetArgs, PS_LIST_TAIL, "-set_state", 0, "define new state", NULL);
    235229
    236230    // -listtarget
    237231    psMetadata *listtargetArgs = psMetadataAlloc();
    238232    psMetadataAddS64(listtargetArgs, PS_LIST_TAIL, "-target_id", 0, "list target with target_id", 0);
    239     psMetadataAddStr(listtargetArgs, PS_LIST_TAIL, "-label",  0, "list targets for label", NULL);
     233    psMetadataAddStr(listtargetArgs, PS_LIST_TAIL, "-dist_group",  0, "list targets for dist_group", NULL);
    240234    psMetadataAddStr(listtargetArgs, PS_LIST_TAIL, "-filter",    0, "define filter", NULL);
    241235    psMetadataAddStr(listtargetArgs, PS_LIST_TAIL, "-stage",     0, "list targets for stage", NULL);
    … …  
    252246    psMetadataAddS64(defineinterestArgs, PS_LIST_TAIL, "-target_id", 0, "define target_id", 0);
    253247    psMetadataAddStr(defineinterestArgs, PS_LIST_TAIL, "-stage",     0, "define stage", NULL);
    254     psMetadataAddStr(defineinterestArgs, PS_LIST_TAIL, "-label",     0, "define label", NULL);
     248    psMetadataAddStr(defineinterestArgs, PS_LIST_TAIL, "-dist_group",     0, "define dist_group", NULL);
    255249    psMetadataAddStr(defineinterestArgs, PS_LIST_TAIL, "-filter",    0, "define filter (LIKE comparison)", NULL);
    256250    psMetadataAddBool(defineinterestArgs, PS_LIST_TAIL,"-clean",     0, "list clean targets", false);
    … …  
    271265    psMetadataAddS64(listinterestsArgs, PS_LIST_TAIL, "-int_id", 0, "list interests with int_id", 0);
    272266    psMetadataAddStr(listinterestsArgs, PS_LIST_TAIL, "-dest_name",  0, "list interests for destinationn name)", NULL);
    273     psMetadataAddStr(listinterestsArgs, PS_LIST_TAIL, "-label",  0, "list interests for label (LIKE comparison)", NULL);
     267    psMetadataAddStr(listinterestsArgs, PS_LIST_TAIL, "-dist_group",  0, "list interests for dist_group (LIKE comparison)", NULL);
    274268    psMetadataAddStr(listinterestsArgs, PS_LIST_TAIL, "-filter",    0, "list interests by filter (LIKE comparison)", NULL);
    275269    psMetadataAddStr(listinterestsArgs, PS_LIST_TAIL, "-stage",     0, "list interests for stage", NULL);
    … …  
    284278
    285279    PXOPT_ADD_MODE("-definebyquery",    "", DISTTOOL_MODE_DEFINEBYQUERY, definebyqueryArgs);
    286     PXOPT_ADD_MODE("-definerun",    "", DISTTOOL_MODE_DEFINERUN, definerunArgs);
    287280    PXOPT_ADD_MODE("-updaterun",    "", DISTTOOL_MODE_UPDATERUN, updaterunArgs);
    288281    PXOPT_ADD_MODE("-revertrun",    "", DISTTOOL_MODE_REVERTRUN, revertrunArgs);

  • trunk/ippTools/src/faketool.c

    r25324 r25835  
    177177    PXOPT_LOOKUP_STR(tess_id, config->args, "-set_tess_id", false, false);
    178178    PXOPT_LOOKUP_STR(end_stage, config->args, "-set_end_stage", false, false);
     179    PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
     180    PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false);
     181    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
    179182
    180183    // default
    … …  
    265268
    266269        // queue the exp
    267         if (!pxfakeQueueByCamID(config, cam_id, workdir, label, reduction, expgroup, dvodb, tess_id, end_stage)) {
     270        if (!pxfakeQueueByCamID(config, cam_id, workdir, label, data_group ? data_group : label, dist_group, reduction, expgroup, dvodb, tess_id, end_stage, note)) {
    268271            if (!psDBRollback(config->dbh)) {
    269272                psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    330333    PXOPT_COPY_F32(config->args, where, "-sun_angle_max", "sun_angle", "<");
    331334    PXOPT_COPY_STR(config->args, where, "-label", "fakeRun.label", "==");
    332 
    333     if (!psListLength(where->list)
    334         && !psMetadataLookupBool(NULL, config->args, "-all")) {
     335    PXOPT_COPY_STR(config->args, where, "-data_group", "fakeRun.data_group", "==");
     336    PXOPT_COPY_STR(config->args, where, "-dist_group", "fakeRun.dist_group", "==");
     337
     338    if (!psListLength(where->list)) {
    335339        psFree(where);
    336340        where = NULL;
    … …  
    339343    }
    340344
    341     PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
    342     PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
    343 
    344     if ((!state) && (!label)) {
    345         psError(PXTOOLS_ERR_DATA, false, "parameters are required");
    346         psFree(where);
    347         return false;
    348     }
    349 
    350     if (state) {
    351         // set fakeRun.state to state
    352         if (!pxfakeRunSetStateByQuery(config, where, state)) {
    353             psFree(where);
    354             return false;
    355         }
    356     }
    357 
    358     if (label) {
    359         // set fakeRun.label to label
    360         if (!pxfakeRunSetLabelByQuery(config, where, label)) {
    361             psFree(where);
    362             return false;
    363         }
    364     }
    365 
     345    psString query = psStringCopy("UPDATE fakeRun JOIN camRun USING(cam_id) JOIN chipRun USING(chip_id) JOIN rawExp USING(exp_id)");
     346
     347    // pxUpdateRun gets parameters from config->args and updates
     348    bool result = pxUpdateRun(config, where, &query, true);
     349    if (!result) {
     350        psError(PXTOOLS_ERR_DATA, false, "pxUpdateRun failed");
     351    }
     352
     353    psFree(query);
    366354    psFree(where);
    367355
    368     return true;
     356    return result;
    369357}
    370358
    … …  
    11621150                                 fakeRun->workdir,
    11631151                                 fakeRun->label,
     1152                                 fakeRun->data_group,
     1153                                 fakeRun->dist_group,
    11641154                                 fakeRun->dvodb,
    11651155                                 fakeRun->tess_id,
    11661156                                 fakeRun->reduction,
    1167                                  fakeRun->end_stage
     1157                                 fakeRun->end_stage,
     1158                                 NULL // note does not propagate
    11681159        )) {
    11691160            psError(PS_ERR_UNKNOWN, false, "failed to queue warpRun");

  • trunk/ippTools/src/faketoolConfig.c

    r25324 r25835  
    9393    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_tess_id",  0,            "define tessellation identifier", NULL);
    9494    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_end_stage",  0,            "define end stage", NULL);
     95    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_dist_group",  0,           "define dist group", NULL);
     96    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_data_group",  0,           "define data group", NULL);
     97    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_note",  0,                 "define note", NULL);
    9598    psMetadataAddBool(queueArgs, PS_LIST_TAIL, "-pretend",  0,            "do not actually modify the database", false);
    9699    psMetadataAddBool(queueArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);
    … …  
    143146    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state", 0,            "set state", NULL);
    144147    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_label", 0,            "set label", NULL);
    145     psMetadataAddBool(updaterunArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);
     148    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_data_group", 0,   "define new data_group", NULL);
     149    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_dist_group", 0,   "define new dist_group", NULL);
     150    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_note", 0,         "define new note", NULL);
    146151
    147152    // -pendingexp

  • trunk/ippTools/src/flatcorr.c

    r25816 r25835  
    133133    PXOPT_LOOKUP_STR(tess_id, config->args, "-set_tess_id", false, false);
    134134    PXOPT_LOOKUP_STR(region, config->args, "-set_region", false, false);
     135    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
    135136
    136137    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
    … …  
    235236
    236237        // queue the exp : force this to stop at the chip stage
    237         psS64 chip_id = pxchipQueueByExpTag(config, exp_id, workdir, label, reduction, expgroup, dvodb, tess_id, "chip");
     238        psS64 chip_id = pxchipQueueByExpTag(config, exp_id, workdir, label, label, NULL, reduction, expgroup, dvodb, tess_id, "chip", note);
    238239        if (!chip_id) {
    239240            if (!psDBRollback(config->dbh)) {
    … …  
    523524                row->workdir,
    524525                row->label,
     526                row->data_group,
     527                row->dist_group,
    525528                row->reduction,
    526529                row->expgroup,
    527530                row->dvodb,
    528531                row->tess_id,
    529                 "camera")) {
     532                "camera",
     533                NULL // note does not propragate
     534                )) {
    530535            if (!psDBRollback(config->dbh)) {
    531536                psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    658663                row->reduction,
    659664                row->label,
     665                row->data_group,
    660666                row->dvodb,
     667                NULL,       // note is not propagated
    661668                0)) {
    662669            if (!psDBRollback(config->dbh)) {

  • trunk/ippTools/src/magicdstool.c

    r25822 r25835  
    3333
    3434static bool definebyqueryMode(pxConfig *config);
    35 static psS64 definerunMode(pxConfig *config);
    3635static bool updaterunMode(pxConfig *config);
    3736static bool todestreakMode(pxConfig *config);
    … …  
    4645
    4746static bool setmagicDSRunState(pxConfig *config, psS64 magic_id, psMetadata *where, const char *state);
    48 static bool magicDSGetIDs(pxConfig *config, psString stage, psS64 magic_id, psS64 *stage_id, psS64 *cam_id);
    4947
    5048# define MODECASE(caseName, func) \
    … …  
    6765    switch (config->mode) {
    6866        MODECASE(MAGICDSTOOL_MODE_DEFINEBYQUERY,       definebyqueryMode);
    69         MODECASE(MAGICDSTOOL_MODE_DEFINERUN,           definerunMode);
    7067        MODECASE(MAGICDSTOOL_MODE_UPDATERUN,           updaterunMode);
    7168        MODECASE(MAGICDSTOOL_MODE_TODESTREAK,          todestreakMode);
    … …  
    110107    PXOPT_LOOKUP_BOOL(noreplace, config->args, "-noreplace", false);
    111108    PXOPT_LOOKUP_STR(set_label, config->args, "-set_label", false, false);
     109    PXOPT_LOOKUP_STR(set_data_group, config->args, "-set_data_group", false, false);
     110    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
    112111    PXOPT_LOOKUP_BOOL(rerun, config->args, "-rerun", false);
    113112    PXOPT_LOOKUP_BOOL(dry_run, config->args, "-dry_run", false);
    … …  
    248247        psS64 cam_id = psMetadataLookupS64(NULL, row, "cam_id");
    249248        psString magicRunLabel = psMetadataLookupStr(NULL, row, "label");
     249        psString magicRunDataGroup = psMetadataLookupStr(NULL, row, "data_group");
    250250        psString magicRunWorkdir = psMetadataLookupStr(NULL, row, "workdir");
    251251       
    … …  
    269269                cam_id,
    270270                set_label ? set_label : magicRunLabel,
     271                set_data_group ? set_data_group : magicRunDataGroup,
    271272                outroot,
    272273                recoveryroot,
    273274                noreplace ? 0 :1,   // re_place
    274                 0); // remove
     275                0,      // remove
     276                0,      // fault
     277                note);  // remove
    275278
    276279        psFree(outroot);
    … …  
    315318}
    316319
    317 static psS64 definerunMode(pxConfig *config)
    318 {
    319     PS_ASSERT_PTR_NON_NULL(config, false);
    320 
    321     // required
    322     PXOPT_LOOKUP_S64(magic_id, config->args, "-magic_id", true, false);
    323     PXOPT_LOOKUP_STR(stage, config->args, "-stage", true, false);
    324     PXOPT_LOOKUP_STR(outroot, config->args, "-outroot", true, false);
    325 
    326     // optional
    327     PXOPT_LOOKUP_STR(recoveryroot, config->args, "-recoveryroot", false, false);
    328     PXOPT_LOOKUP_BOOL(re_place, config->args, "-replace", false);
    329     PXOPT_LOOKUP_BOOL(remove, config->args, "-remove", false);
    330     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    331     PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
    332 
    333     psS64 stage_id = 0, cam_id = 0;
    334 
    335     if (!magicDSGetIDs(config, stage, magic_id, &stage_id, &cam_id)) {
    336         psError(PS_ERR_UNKNOWN, false, "failed to get ids");
    337         return false;
    338     }
    339 
    340     magicDSRunRow *run = magicDSRunRowAlloc(
    341             0,          // ID
    342             magic_id,
    343             0,          // inv_magic_id
    344             "new",      // state
    345             stage,
    346             stage_id,
    347             cam_id,
    348             label,
    349             outroot,
    350             recoveryroot,
    351             re_place,
    352             remove
    353     );
    354 
    355     if (!run) {
    356         psError(PS_ERR_UNKNOWN, false, "failed to alloc magicRun object");
    357         return false;
    358     }
    359     if (!magicDSRunInsertObject(config->dbh, run)) {
    360         psError(PS_ERR_UNKNOWN, false, "database error");
    361         psFree(run);
    362         return false;
    363     }
    364 
    365     psS64 magic_ds_id = psDBLastInsertID(config->dbh);
    366     run->magic_ds_id = magic_ds_id;
    367 
    368     if (!magicDSRunPrintObject(stdout, run, !simple)) {
    369             psError(PS_ERR_UNKNOWN, false, "failed to print object");
    370             psFree(run);
    371             return false;
    372     }
    373 
    374     psFree(run);
    375 
    376     return magic_id;
    377 }
    378 
    379320
    380321static bool updaterunMode(pxConfig *config)
    … …  
    696637}
    697638
    698 static bool magicDSGetIDs(pxConfig *config, psString stage, psS64 magic_id, psS64 *stage_id, psS64 *cam_id)
    699 {
    700     PS_ASSERT_PTR_NON_NULL(config, false);
    701     PS_ASSERT_PTR_NON_NULL(stage, false);
    702     PS_ASSERT_PTR_NON_NULL(stage_id, false);
    703     PS_ASSERT_PTR_NON_NULL(cam_id, false);
    704 
    705     int stageNum = ippStringToStage(stage);;
    706     if (stageNum == IPP_STAGE_NONE) {
    707         psError(PXTOOLS_ERR_DATA, false, "%s is not a valid value for stage", stage);
    708         return false;
    709     }
    710 
    711     psString query = pxDataGet("magicdstool_getrunids.sql");
    712     if (!query) {
    713         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    714         return false;
    715     }
    716 
    717     if (!p_psDBRunQueryF(config->dbh, query, magic_id)) {
    718         psError(PS_ERR_UNKNOWN, false, "database error");
    719         psFree(query);
    720         return false;
    721     }
    722     psFree(query);
    723 
    724     psArray *output = p_psDBFetchResult(config->dbh);
    725     if (!output) {
    726         psError(PS_ERR_UNKNOWN, false, "database error");
    727         return false;
    728     }
    729     if (!psArrayLength(output)) {
    730         psTrace("magicdstool", PS_LOG_INFO, "no rows found");
    731         psFree(output);
    732         return true;
    733     }
    734     if (psArrayLength(output) > 1) {
    735         psError(PS_ERR_UNKNOWN, true, "unexpected number of rows found %ld for magic_id %" PRId64,
    736             psArrayLength(output), magic_id);
    737         return false;
    738     }
    739     psMetadata *row = output->data[0];
    740 
    741     *cam_id = psMetadataLookupS64(NULL, row, "cam_id");
    742     switch (stageNum) {
    743     case IPP_STAGE_RAW:
    744         *stage_id = psMetadataLookupS64(NULL, row, "exp_id");
    745         break;
    746     case IPP_STAGE_CHIP:
    747         *stage_id = psMetadataLookupS64(NULL, row, "chip_id");
    748         break;
    749     case IPP_STAGE_CAMERA:
    750         *stage_id = *cam_id;
    751         return true;
    752     case IPP_STAGE_WARP:
    753         *stage_id = psMetadataLookupS64(NULL, row, "warp_id");
    754         break;
    755     case IPP_STAGE_DIFF:
    756         *stage_id = psMetadataLookupS64(NULL, row, "diff_id");
    757         break;
    758     }
    759 
    760     return true;
    761 }
    762639
    763640static bool advancerunMode(pxConfig *config)

  • trunk/ippTools/src/magicdstool.h

    r25822 r25835  
    2626    MAGICDSTOOL_MODE_NONE           = 0x0,
    2727    MAGICDSTOOL_MODE_DEFINEBYQUERY,
    28     MAGICDSTOOL_MODE_DEFINERUN,
    2928    MAGICDSTOOL_MODE_UPDATERUN,
    3029    MAGICDSTOOL_MODE_TODESTREAK,

  • trunk/ippTools/src/magicdstoolConfig.c

    r25822 r25835  
    6868    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple",  0, "use the simple output format", false);
    6969    psMetadataAddU64(definebyqueryArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
    70 
    71     // -definerun
    72     psMetadata *definerunArgs = psMetadataAlloc();
    73     psMetadataAddS64(definerunArgs, PS_LIST_TAIL, "-magic_id", 0, "define magic_id (required)", 0);
    74     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-stage", 0, "define stage for run (required)", NULL);
    75     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-outroot", 0, "define output directory (required)", NULL);
    76     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-recoveryroot", 0, "define recovery directory", NULL);
    77     psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-noreplace", 0, "do not replace the input wit with the destreaked versions", false);
    78 //    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-remove", 0, "use the simple output format", false);
    79     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-label", 0, "define label", NULL);
    80     psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    8170
    8271    // -updaterun
    … …  
    172161    PXOPT_ADD_MODE("-definebyquery",       "create magic de-streak runs from magic runs",
    173162                    MAGICDSTOOL_MODE_DEFINEBYQUERY,     definebyqueryArgs);
    174     PXOPT_ADD_MODE("-definerun",           "create one magic de-streak run for one magic run",
    175                     MAGICDSTOOL_MODE_DEFINERUN,         definerunArgs);
    176163    PXOPT_ADD_MODE("-updaterun",           "update state of magic de-streak run",
    177164                    MAGICDSTOOL_MODE_UPDATERUN,         updaterunArgs);

  • trunk/ippTools/src/magictool.c

    r25772 r25835  
    117117    // Optional
    118118    PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
     119    PXOPT_LOOKUP_STR(data_group, config->args, "-data_group", false, false);
     120    PXOPT_LOOKUP_STR(note, config->args, "-note", false, false);
    119121    PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false);
    120122    PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    … …  
    236238
    237239        // create a new magicRun for this group
    238         magicRunRow *run = magicRunRowAlloc(0, exp_id, diff_id, inverse, "new", workdir, "dirty", label,
    239                                             dvodb, registered, 0);
     240        magicRunRow *run = magicRunRowAlloc(0,
     241                                            exp_id,
     242                                            diff_id,
     243                                            inverse,
     244                                            "new",      // state
     245                                            workdir,
     246                                            "dirty",    // workdir_state
     247                                            label,
     248                                            data_group,
     249                                            dvodb,
     250                                            registered,
     251                                            0,          // fault
     252                                            note);
    240253        if (!run) {
    241254            psAbort("failed to alloc magicRun object");
    … …  
    331344            "dirty",    // workdir_state
    332345            label,
     346            NULL,       // data_group
    333347            dvodb,
    334348            registered,
    335             0
     349            0,          // fault
     350            NULL
    336351    );
    337352

  • trunk/ippTools/src/pxadd.c

    r25816 r25835  
    127127                       char *reduction,
    128128                       char *label,
     129                       char *data_group,
    129130                       char *dvodb,
     131                       char *note,
    130132                       bool image_only)
    131133{
    … …  
    152154                         reduction? reduction : "NULL",
    153155                         label    ? label     : "NULL",
     156                         data_group ? data_group     : "NULL",
    154157                         dvodb    ? dvodb     : "NULL",
     158                         note     ? note     : "NULL",
    155159                         image_only,
    156160                         (long long) cam_id

  • trunk/ippTools/src/pxadd.h

    r25816 r25835  
    3535                       char *reduction,
    3636                       char *label,
     37                       char *data_group,
    3738                       char *dvodb,
     39                       char *note,
    3840                       bool image_only);
    3941

  • trunk/ippTools/src/pxcam.c

    r24866 r25835  
    141141}
    142142
    143 
    144 bool pxcamRunSetStateByQuery(pxConfig *config, psMetadata *where, const char *state)
    145 {
    146     PS_ASSERT_PTR_NON_NULL(config, false);
    147     PS_ASSERT_PTR_NON_NULL(state, false);
    148 
    149     // check that state is a valid string value
    150     if (!pxIsValidState(state)) {
    151         psError(PS_ERR_UNKNOWN, false,
    152                 "invalid chipRun state: %s", state);
    153         return false;
    154     }
    155 
    156     psString query = psStringCopy("UPDATE camRun JOIN chipRun USING(chip_id) JOIN rawExp USING(exp_id) SET camRun.state = '%s'");
    157 
    158     if (where) {
    159         psString whereClause = psDBGenerateWhereSQL(where, NULL);
    160         psStringAppend(&query, " %s", whereClause);
    161         psFree(whereClause);
    162     }
    163 
    164     if (!p_psDBRunQueryF(config->dbh, query, state)) {
    165         psFree(query);
    166         psError(PS_ERR_UNKNOWN, false, "database error");
    167         return false;
    168     }
    169 
    170     psFree(query);
    171 
    172     return true;
    173 }
    174 
    175 
    176 bool pxcamRunSetLabel(pxConfig *config, psS64 cam_id, const char *label)
    177 {
    178     PS_ASSERT_PTR_NON_NULL(config, false);
    179     // note label == NULL should be explicitly allowed
    180 
    181     char *query = "UPDATE camRun SET camRun.label = '%s' WHERE cam_id = %" PRId64;
    182     if (!p_psDBRunQueryF(config->dbh, query, label, cam_id)) {
    183         psError(PS_ERR_UNKNOWN, false,
    184                 "failed to change state for cam_id %" PRId64, cam_id);
    185         return false;
    186     }
    187 
    188     return true;
    189 }
    190 
    191 bool pxcamRunSetLabelByQuery(pxConfig *config, psMetadata *where, const char *label)
    192 {
    193     PS_ASSERT_PTR_NON_NULL(config, false);
    194     // note label == NULL should be explicitly allowed
    195 
    196     psString query = psStringCopy("UPDATE camRun JOIN chipRun USING(chip_id) JOIN rawExp USING(exp_id) SET camRun.label = '%s'");
    197 
    198     if (where) {
    199         psString whereClause = psDBGenerateWhereSQL(where, NULL);
    200         psStringAppend(&query, " %s", whereClause);
    201         psFree(whereClause);
    202     }
    203 
    204     if (!p_psDBRunQueryF(config->dbh, query, label)) {
    205         psFree(query);
    206         psError(PS_ERR_UNKNOWN, false, "database error");
    207         return false;
    208     }
    209 
    210     psFree(query);
    211 
    212     return true;
    213 }
    214 
    215 
    216143bool pxcamQueueByChipID(pxConfig *config,
    217144                    psS64 chip_id,
    218145                    char *workdir,
    219146                    char *label,
     147                    char *data_group,
     148                    char *dist_group,
    220149                    char *recipe,
    221150                    char *expgroup,
    222151                    char *dvodb,
    223152                    char *tess_id,
    224                     char *end_stage)
     153                    char *end_stage,
     154                    char *note)
    225155{
    226156    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    245175                "dirty", //workdir_state
    246176                label    ? label    : "NULL",
     177                data_group ? data_group : "NULL",
     178                dist_group ? dist_group : "NULL",
    247179                recipe   ? recipe   : "NULL",
    248180                expgroup ? expgroup : "NULL",
    … …  
    250182                tess_id  ? tess_id  : "NULL",
    251183                end_stage ? end_stage : "NULL",
     184                note     ? note     : "NULL",
    252185                (long long)chip_id
    253186    )) {

  • trunk/ippTools/src/pxcam.h

    r24681 r25835  
    2626
    2727bool pxcamRunSetState(pxConfig *config, psS64 cam_id, const char *state, psS64 magicked);
    28 bool pxcamRunSetStateByQuery(pxConfig *config, psMetadata *where, const char *state);
    29 bool pxcamRunSetLabel(pxConfig *config, psS64 cam_id, const char *label);
    30 bool pxcamRunSetLabelByQuery(pxConfig *config, psMetadata *where, const char *label);
    31 
    3228bool pxcamSetSearchArgs (psMetadata *md);
    3329bool pxcamGetSearchArgs (pxConfig *config, psMetadata *where);
    … …  
    3733                        char *workdir,
    3834                        char *label,
     35                        char *data_group,
     36                        char *dist_group,
    3937                        char *recipe,
    4038                        char *expgroup,
    4139                        char *dvodb,
    4240                        char *tess_id,
    43                         char *end_stage);
     41                        char *end_stage,
     42                        char *note);
    4443
    4544#endif // PXCAM_H

  • trunk/ippTools/src/pxchip.c

    r25800 r25835  
    192192}
    193193
    194 bool pxchipRunSetLabel(pxConfig *config, psS64 chip_id, const char *label)
    195 {
    196     PS_ASSERT_PTR_NON_NULL(config, false);
    197     // note label == NULL should be explicitly allowed
    198 
    199     char *query = "UPDATE chipRun SET label = '%s' WHERE chip_id = %" PRId64;
    200     if (!p_psDBRunQueryF(config->dbh, query, label, chip_id)) {
    201         psError(PS_ERR_UNKNOWN, false,
    202                 "failed to change state for chip_id %" PRId64, chip_id);
    203         return false;
    204     }
    205 
    206     return true;
    207 }
    208 
    209 
    210 bool pxchipRunSetLabelByQuery(pxConfig *config, psMetadata *where, const char *label)
    211 {
    212     PS_ASSERT_PTR_NON_NULL(config, false);
    213     // note label == NULL should be explicitly allowed
    214 
    215     psString query = psStringCopy("UPDATE chipRun JOIN rawExp USING(exp_id) SET label = '%s'");
    216 
    217     if (where && psListLength(where->list) > 0) {
    218         psString whereClause = psDBGenerateWhereSQL(where, NULL);
    219         psStringAppend(&query, " %s", whereClause);
    220         psFree(whereClause);
    221     }
    222 
    223     if (!p_psDBRunQueryF(config->dbh, query, label)) {
    224         psFree(query);
    225         psError(PS_ERR_UNKNOWN, false, "database error");
    226         return false;
    227     }
    228 
    229     psFree(query);
    230 
    231     return true;
    232 }
    233 
    234194bool pxchipProcessedImfileSetStateByQuery(pxConfig *config, psMetadata *where, const char *state)
    235195{
    … …  
    276236                         const char *workdir,
    277237                         const char *label,
     238                         const char *data_group,
     239                         const char *dist_group,
    278240                         const char *reduction,
    279241                         const char *expgroup,
    280242                         const char *dvodb,
    281243                         const char *tess_id,
    282                          const char *end_stage)
     244                         const char *end_stage,
     245                         const char *note)
    283246{
    284247    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    298261            "dirty",    // workdir_state
    299262            label,
     263            data_group,
     264            dist_group,
    300265            reduction,
    301266            expgroup,
    … …  
    303268            tess_id,
    304269            end_stage,
    305             0           // magicked
     270            0,          // magicked
     271            note
    306272            )
    307273    ) {

  • trunk/ippTools/src/pxchip.h

    r25800 r25835  
    2828
    2929bool pxchipRunSetState(pxConfig *config, psS64 chip_id, const char *state, const bool magicked);
    30 bool pxchipRunSetStateByQuery(pxConfig *config, psMetadata *where, const char *state);
    31 bool pxchipRunSetLabel(pxConfig *config, psS64 chip_id, const char *label);
    32 bool pxchipRunSetLabelByQuery(pxConfig *config, psMetadata *where, const char *label);
    33 
    3430bool pxchipProcessedImfileSetStateByQuery(pxConfig *config, psMetadata *where, const char *state);
    3531
    … …  
    3834                         const char *workdir,
    3935                         const char *label,
     36                         const char *data_group,
     37                         const char *dist_group,
    4038                         const char *reduction,
    4139                         const char *expgroup,
    4240                         const char *dvodb,
    4341                         const char *tess_id,
    44                          const char *end_stage);
     42                         const char *end_stage,
     43                         const char *note);
    4544
    4645

  • trunk/ippTools/src/pxfake.c

    r21402 r25835  
    5151}
    5252
    53 
    54 bool pxfakeRunSetStateByQuery(pxConfig *config, psMetadata *where, const char *state)
    55 {
    56     PS_ASSERT_PTR_NON_NULL(config, false);
    57     PS_ASSERT_PTR_NON_NULL(state, false);
    58 
    59     // check that state is a valid string value
    60     if (!pxIsValidState(state)) {
    61         psError(PS_ERR_UNKNOWN, false,
    62                 "invalid fakeRun state: %s", state);
    63         return false;
    64     }
    65 
    66     psString query = psStringCopy("UPDATE fakeRun JOIN camRun USING(cam_id) JOIN chipRun USING(chip_id) JOIN rawExp USING(exp_id) SET fakeRun.state = '%s'");
    67 
    68     if (where) {
    69         psString whereClause = psDBGenerateWhereSQL(where, NULL);
    70         psStringAppend(&query, " %s", whereClause);
    71         psFree(whereClause);
    72     }
    73 
    74     if (!p_psDBRunQueryF(config->dbh, query, state)) {
    75         psFree(query);
    76         psError(PS_ERR_UNKNOWN, false, "database error");
    77         return false;
    78     }
    79 
    80     psFree(query);
    81 
    82     return true;
    83 }
    84 
    85 
    86 bool pxfakeRunSetLabel(pxConfig *config, psS64 fake_id, const char *label)
    87 {
    88     PS_ASSERT_PTR_NON_NULL(config, false);
    89     // note label == NULL should be explicitly allowed
    90 
    91     char *query = "UPDATE fakeRun SET fakeRun.label = '%s' WHERE fake_id = %" PRId64;
    92     if (!p_psDBRunQueryF(config->dbh, query, label, fake_id)) {
    93         psError(PS_ERR_UNKNOWN, false,
    94                 "failed to change state for fake_id %" PRId64, fake_id);
    95         return false;
    96     }
    97 
    98     return true;
    99 }
    100 
    101 
    102 bool pxfakeRunSetLabelByQuery(pxConfig *config, psMetadata *where, const char *label)
    103 {
    104     PS_ASSERT_PTR_NON_NULL(config, false);
    105     // note label == NULL should be explicitly allowed
    106 
    107     psString query = psStringCopy("UPDATE fakeRun JOIN camRun USING(cam_id) JOIN chipRun USING(chip_id) JOIN rawExp USING(exp_id) SET fakeRun.label = '%s'");
    108 
    109     if (where) {
    110         psString whereClause = psDBGenerateWhereSQL(where, NULL);
    111         psStringAppend(&query, " %s", whereClause);
    112         psFree(whereClause);
    113     }
    114 
    115     if (!p_psDBRunQueryF(config->dbh, query, label)) {
    116         psFree(query);
    117         psError(PS_ERR_UNKNOWN, false, "database error");
    118         return false;
    119     }
    120 
    121     psFree(query);
    122 
    123     return true;
    124 }
    125 
    126 
    12753psS64 pxfakeQueueByCamID(pxConfig *config,
    12854                    psS64 cam_id,
    12955                    char *workdir,
    13056                    char *label,
     57                    char *data_group,
     58                    char *dist_group,
    13159                    char *reduction,
    13260                    char *expgroup,
    13361                    char *dvodb,
    13462                    char *tess_id,
    135                     char *end_stage)
     63                    char *end_stage,
     64                    char *note)
    13665{
    13766    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    15786                workdir  ? workdir  : "NULL",
    15887                label    ? label    : "NULL",
     88                data_group ? data_group : "NULL",
     89                dist_group ? dist_group : "NULL",
    15990                reduction? reduction: "NULL",
    16091                expgroup ? expgroup : "NULL",
    … …  
    16293                tess_id  ? tess_id  : "NULL",
    16394                end_stage ? end_stage : "NULL",
     95                note     ? note     : "NULL",
    16496                (long long)cam_id
    16597    )) {

  • trunk/ippTools/src/pxfake.h

    r17938 r25835  
    2626
    2727bool pxfakeRunSetState(pxConfig *config, psS64 fake_id, const char *state);
    28 bool pxfakeRunSetStateByQuery(pxConfig *config, psMetadata *where, const char *state);
    29 bool pxfakeRunSetLabel(pxConfig *config, psS64 fake_id, const char *label);
    30 bool pxfakeRunSetLabelByQuery(pxConfig *config, psMetadata *where, const char *label);
    31 
    3228
    3329psS64 pxfakeQueueByCamID(pxConfig *config,
    … …  
    3531                    char *workdir,
    3632                    char *label,
     33                    char *data_group,
     34                    char *dist_group,
    3735                    char *reduction,
    3836                    char *expgroup,
    3937                    char *dvodb,
    4038                    char *tess_id,
    41                     char *end_stage);
     39                    char *end_stage,
     40                    char *note);
    4241
    4342

  • trunk/ippTools/src/pxtools.c

    r25324 r25835  
    108108    return true;
    109109}
     110
     111// shared code for updating the various strings for a Run
     112bool pxUpdateRun(pxConfig *config, psMetadata *where, psString *pQuery, bool has_dist_group)
     113{
     114    PS_ASSERT_PTR_NON_NULL(config, false);
     115    PS_ASSERT_PTR_NON_NULL(where, false);
     116    PS_ASSERT_PTR_NON_NULL(pQuery, false);
     117    PS_ASSERT_PTR_NON_NULL(*pQuery, false);
     118
     119    // make sure that -state is not the only selection parameter
     120    PXOPT_LOOKUP_STR(where_state, config->args, "-state", false, false);
     121    if (where_state && (psListLength(where->list) < 2)) {
     122        psError(PXTOOLS_ERR_DATA, true, "selection by -state alone is not allowed");
     123        return false;
     124    }
     125
     126    PXOPT_LOOKUP_STR(state, config->args,       "-set_state", false, false);
     127    PXOPT_LOOKUP_STR(label, config->args,       "-set_label", false, false);
     128    PXOPT_LOOKUP_STR(data_group, config->args,  "-set_data_group", false, false);
     129    PXOPT_LOOKUP_STR(note, config->args,        "-set_note", false, false);
     130
     131    psString dist_group = NULL;
     132    if (has_dist_group) {
     133        PXOPT_LOOKUP_STR(tmp_dist_group, config->args,  "-set_dist_group", false, false);
     134        dist_group = tmp_dist_group;
     135    }
     136
     137    if ((!state) && (!label) && (!data_group) && (has_dist_group && !dist_group) && !(note)) {
     138        psError(PXTOOLS_ERR_DATA, false, "parameters are required");
     139        return false;
     140    }
     141
     142    if (state && ! pxIsValidState(state)) {
     143        psError(PXTOOLS_ERR_DATA, false, "pxIsValidState failed");
     144        return false;
     145    }
     146
     147    // first paramter is added with "SET param = 'value'"
     148    // subseqent ones with ", param = 'value'"
     149    char *separator = " SET ";
     150    char *comma = ",";
     151
     152#   define addColumn(_val) \
     153        do { \
     154            if (_val) { \
     155                psStringAppend(pQuery, "%s %s = '%s'", separator, #_val, _val); \
     156                separator = comma; \
     157            } \
     158        } while (0)
     159
     160    addColumn(state);
     161    addColumn(data_group);
     162    if (has_dist_group) {
     163        addColumn(dist_group);
     164    }
     165    addColumn(note);
     166    addColumn(label);
     167
     168    psString whereClause =  psDBGenerateWhereSQL(where, NULL);
     169    psStringAppend(pQuery, " %s", whereClause);
     170    psFree(whereClause);
     171
     172    if (!p_psDBRunQuery(config->dbh, *pQuery)) {
     173        psError(PS_ERR_UNKNOWN, false, "database error");
     174        return false;
     175    }
     176
     177    return true;
     178}

  • trunk/ippTools/src/pxtools.h

    r25774 r25835  
    6363bool pxGetOptions(FILE *stream, int argc, char **argv, pxConfig *config, psMetadata *modes, psMetadata *argSets);
    6464
     65bool pxUpdateRun(pxConfig *config, psMetadata *where, psString *pQuery, bool has_dist_group);
     66
    6567#define PXOPT_ADD_MODE(option, comment, modeval, argset) \
    6668{ \

  • trunk/ippTools/src/pxwarp.c

    r24487 r25835  
    2929#include "pxwarp.h"
    3030
    31 bool pxwarpRunSetState(pxConfig *config, psS64 warp_id, const char *state)
    32 {
    33     PS_ASSERT_PTR_NON_NULL(config, false);
    34     PS_ASSERT_PTR_NON_NULL(state, false);
    35 
    36     // check that state is a valid string value
    37     if (!pxIsValidState(state)) {
    38         psError(PS_ERR_UNKNOWN, false, "invalid warpRun state: %s", state);
    39         return false;
    40     }
    41 
    42     char *query = "UPDATE warpRun SET state = '%s' WHERE warp_id = %" PRId64;
    43     if (!p_psDBRunQueryF(config->dbh, query, state, warp_id)) {
    44         psError(PS_ERR_UNKNOWN, false,
    45                 "failed to change state for warp_id %" PRId64, warp_id);
    46         return false;
    47     }
    48 
    49     return true;
    50 }
    51 
    52 
    53 bool pxwarpRunSetStateByQuery(pxConfig *config, psMetadata *where, const char *state)
    54 {
    55     PS_ASSERT_PTR_NON_NULL(config, false);
    56     PS_ASSERT_PTR_NON_NULL(state, false);
    57 
    58     // check that state is a valid string value
    59     if (!pxIsValidState(state)) {
    60         psError(PS_ERR_UNKNOWN, false, "invalid warpRun state: %s", state);
    61         return false;
    62     }
    63 
    64     psString query = psStringCopy("UPDATE warpRun JOIN fakeRun USING(fake_id) JOIN camRun USING(cam_id) JOIN chipRun USING(chip_id) JOIN rawExp USING(exp_id) SET warpRun.state = '%s'");
    65 
    66     if (where) {
    67         psString whereClause = psDBGenerateWhereSQL(where, NULL);
    68         if (whereClause && strlen(whereClause) > 0) {
    69             psStringAppend(&query, " %s", whereClause);
    70         }
    71         psFree(whereClause);
    72     }
    73 
    74     if (!p_psDBRunQueryF(config->dbh, query, state)) {
    75         psFree(query);
    76         psError(PS_ERR_UNKNOWN, false, "database error");
    77         return false;
    78     }
    79 
    80     psFree(query);
    81 
    82     return true;
    83 }
    84 
    85 
    86 bool pxwarpRunSetLabel(pxConfig *config, psS64 warp_id, const char *label)
    87 {
    88     PS_ASSERT_PTR_NON_NULL(config, false);
    89     // note label == NULL should be explicitly allowed
    90 
    91     char *query = "UPDATE warpRun SET warpRun.label = '%s' WHERE warp_id = %" PRId64;
    92     if (!p_psDBRunQueryF(config->dbh, query, label, warp_id)) {
    93         psError(PS_ERR_UNKNOWN, false,
    94                 "failed to change label for warp_id %" PRId64, warp_id);
    95         return false;
    96     }
    97 
    98     return true;
    99 }
    100 
    101 
    102 bool pxwarpRunSetLabelByQuery(pxConfig *config, psMetadata *where, const char *label)
    103 {
    104     PS_ASSERT_PTR_NON_NULL(config, false);
    105     // note label == NULL should be explicitly allowed
    106 
    107     psString query = psStringCopy("UPDATE warpRun JOIN fakeRun USING(fake_id) JOIN camRun USING(cam_id) JOIN chipRun USING(chip_id) JOIN rawExp USING(exp_id) SET warpRun.label = '%s'");
    108 
    109     if (where) {
    110         psString whereClause = psDBGenerateWhereSQL(where, NULL);
    111         psStringAppend(&query, " %s", whereClause);
    112         psFree(whereClause);
    113     }
    114 
    115     if (!p_psDBRunQueryF(config->dbh, query, label)) {
    116         psFree(query);
    117         psError(PS_ERR_UNKNOWN, false, "database error");
    118         return false;
    119     }
    120 
    121     psFree(query);
    122 
    123     return true;
    124 }
    125 
    126 
    12731bool pxwarpQueueByFakeID(pxConfig *config,
    12832                         psS64 fake_id,
    12933                         const char *workdir,
    13034                         const char *label,
     35                         const char *data_group,
     36                         const char *dist_group,
    13137                         const char *dvodb,
    13238                         const char *tess_id,
    13339                         const char *reduction,
    134                          const char *end_stage)
     40                         const char *end_stage,
     41                         const char *note)
    13542{
    13643    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    14552        "dirty",    // workdir_state
    14653        label,
     54        data_group,
     55        dist_group,
    14756        dvodb,
    14857        tess_id,
    149                        reduction,
     58        reduction,
    15059        end_stage,
    15160        NULL,      // registered
    152         0          // magicked zero when created will get updated when warpRun goes to 'full'
     61        0,         // magicked set to zero when created may get updated when warpRun goes to 'full'
     62        NULL        // note
    15363    )) {
    15464        psError(PS_ERR_UNKNOWN, false, "database error");

  • trunk/ippTools/src/pxwarp.h

    r24487 r25835  
    2525#include "pxtools.h"
    2626
    27 bool pxwarpRunSetState(pxConfig *config, psS64 warp_id, const char *state);
    28 bool pxwarpRunSetStateByQuery(pxConfig *config, psMetadata *where, const char *state);
    29 bool pxwarpRunSetLabel(pxConfig *config, psS64 warp_id, const char *label);
    30 bool pxwarpRunSetLabelByQuery(pxConfig *config, psMetadata *where, const char *label);
    31 
    3227bool pxwarpQueueByFakeID(pxConfig *config,
    3328                         psS64 fake_id,
    3429                         const char *workdir,
    3530                         const char *label,
     31                         const char *data_group,
     32                         const char *dist_group,
    3633                         const char *dvodb,
    3734                         const char *tess_id,
    3835                         const char *reduction,
    39                          const char *end_stage);
     36                         const char *end_stage,
     37                         const char *note);
    4038
    4139#endif // PXWARP_H

  • trunk/ippTools/src/regtool.c

    r25778 r25835  
    885885                workdir,
    886886                label,
     887                NULL,       // data_group
     888                NULL,       // dist_group
    887889                reduction,
    888                 NULL, // expgroup
     890                NULL,       // expgroup
    889891                dvodb,
    890892                tess_id,
    891                 end_stage
     893                end_stage,
     894                NULL        // note
    892895    )) {
    893896        // rollback

  • trunk/ippTools/src/stacktool.c

    r25800 r25835  
    4848
    4949static bool setstackRunState(pxConfig *config, psS64 stack_id, const char *state);
    50 static bool setstackRunStateByLabel(pxConfig *config, const char *label, const char *state);
    5150
    5251# define MODECASE(caseName, func) \
    … …  
    110109
    111110    // required options
    112     PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false);
    113     PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
    114     PXOPT_LOOKUP_STR(reduction, config->args, "-reduction", false, false);
    115     PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false);
     111    PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", true, false);
     112
     113    // optional
     114    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
     115    PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
     116    PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false);
     117    PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false);
     118    PXOPT_LOOKUP_STR(dvodb, config->args, "-set_dvodb", false, false);
     119    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
     120    PXOPT_LOOKUP_TIME(registered, config->args, "-set_registered", false, false);
    116121
    117122    psMetadata *where = psMetadataAlloc();
    … …  
    161166    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    162167    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
    163     PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    164 
    165     if (!psListLength(where->list) &&
    166         !psMetadataLookupBool(NULL, config->args, "-all")) {
     168
     169    if (!psListLength(where->list)) {
    167170        psFree(where);
    168171        psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
    … …  
    346349            workdir,
    347350            label,
     351            data_group ? data_group : label,
     352            dist_group,
    348353            reduction,
    349354            dvodb,
    … …  
    351356            skycell_id,
    352357            tess_id,
    353             filter);
     358            filter,
     359            note);
    354360
    355361        if (!stackRunInsertObject(config->dbh, run)) {
    … …  
    469475
    470476    // required options
    471     PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false);
     477    PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", true, false);
    472478    PXOPT_LOOKUP_STR(skycell_id, config->args, "-skycell_id", true, false);
    473479    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", true, false);
    … …  
    476482    // default
    477483    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    478     PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
     484    PXOPT_LOOKUP_TIME(registered, config->args, "-set_registered", false, false);
    479485
    480486    // options
    481     PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
    482     PXOPT_LOOKUP_STR(reduction, config->args, "-reduction", false, false);
    483     PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false);
     487    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
     488    PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
     489    PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false);
     490    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
     491    PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false);
     492    PXOPT_LOOKUP_STR(dvodb, config->args, "-set_dvodb", false, false);
    484493
    485494    // we have to support multipe exp_ids
    … …  
    496505        workdir,
    497506        label,
     507        data_group ? data_group : label,
     508        dist_group,
    498509        reduction,
    499510        dvodb,
    … …  
    501512        skycell_id,
    502513        tess_id,
    503         filter);
     514        filter,
     515        note);
    504516
    505517    if (!run) {
    … …  
    570582    PS_ASSERT_PTR_NON_NULL(config, false);
    571583
     584#ifdef notdef
    572585    PXOPT_LOOKUP_S64(stack_id, config->args, "-stack_id", false, false);
    573586    PXOPT_LOOKUP_STR(state, config->args, "-state", true, false);
    574587    PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
    575 
     588#endif
     589    psMetadata *where = psMetadataAlloc();
     590    PXOPT_COPY_S64(config->args, where, "-stack_id",  "stack_id",   "==");
     591    PXOPT_COPY_STR(config->args, where, "-label",     "label",     "==");
     592    PXOPT_COPY_STR(config->args, where, "-state",     "state",     "==");
     593    if (!psListLength(where->list)) {
     594        psFree(where);
     595        psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     596        return false;
     597    }
     598
     599    psString query = psStringCopy("UPDATE stackRun");
     600
     601    // pxUpdateRun gets parameters from config->args and updates
     602    bool result = pxUpdateRun(config, where, &query, true);
     603
     604    psFree(query);
     605    psFree(where);
     606
     607    return result;
     608
     609#ifdef notdef
    576610    // Hack-y work around to make stacktool more like the other tools, without breaking other stuff (hopefully).
    577611
    … …  
    587621    psError(PS_ERR_UNKNOWN, false, "Required options not found.");
    588622    return false;
     623#endif
    589624}
    590625
    … …  
    10151050}
    10161051
     1052#ifdef notdef
    10171053static bool setstackRunStateByLabel(pxConfig *config, const char *label, const char *state)
    10181054{
    … …  
    10341070    return true;
    10351071}
     1072#endif
    10361073
    10371074static bool pendingcleanuprunMode(pxConfig *config)

  • trunk/ippTools/src/stacktoolConfig.c

    r25800 r25835  
    4747    // -definebyquery
    4848    psMetadata *definebyqueryArgs = psMetadataAlloc();
    49     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-workdir", 0, "define workdir (required)", NULL);
    50     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label", 0, "define label", NULL);
    51     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-reduction", 0, "define reduction", NULL);
    52     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-dvodb", 0, "define dvodb", NULL);
    53     psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-registered", 0, "time detrend run was registered", now);
     49    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_workdir", 0, "define workdir (required)", NULL);
     50    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_label", 0, "define label", NULL);
     51    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_data_group", 0, "define data group", NULL);
     52    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_dist_group", 0, "define dist group", NULL);
     53    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_note", 0, "define note", NULL);
     54    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_reduction", 0, "define reduction", NULL);
     55    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_dvodb", 0, "define dvodb", NULL);
     56    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-set_registered", 0, "time detrend run was registered", now);
    5457    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_skycell_id", 0, "search for skycell_id", NULL);
    5558    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_good_frac_min", 0, "define min good_frac", 0.0);
    … …  
    8487    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_iq_m4_max", 0, "define max iq_m4", NAN);
    8588    psMetadataAddS32(definebyqueryArgs, PS_LIST_TAIL, "-random", 0, "use this number of random elements", 0);
    86     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-all", 0, "allow everything to be queued without search terms", false);
    8789    psMetadataAddS32(definebyqueryArgs, PS_LIST_TAIL, "-min_num", 0, "minimum number of inputs", 0);
    8890    psMetadataAddS32(definebyqueryArgs, PS_LIST_TAIL, "-min_new", 0, "minimum number of new inputs", 0);
    … …  
    9395    // -definerun
    9496    psMetadata *definerunArgs = psMetadataAlloc();
    95     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-workdir", 0,            "define workdir (required)", NULL);
    96     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-label", 0, "define label", NULL);
    97     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-reduction", 0, "define reduction", NULL);
    98     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-dvodb", 0, "define dvodb", NULL);
    99     psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
     97    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_workdir", 0,            "define workdir (required)", NULL);
     98    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_label", 0, "define label", NULL);
     99    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_reduction", 0, "define reduction", NULL);
     100    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_dvodb", 0, "define dvodb", NULL);
     101    psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-set_registered",  0,            "time detrend run was registered", now);
    100102    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-skycell_id",  0,            "define skycell ID (required)", NULL);
    101103    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-tess_id",  0,            "define tessellation ID (required)", NULL);
    … …  
    106108    // -updaterun
    107109    psMetadata *updaterunArgs = psMetadataAlloc();
    108     psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-stack_id", 0,            "define stack ID (required)", 0);
    109     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,            "set state (required)", NULL);
    110     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label", 0,            "define by label instead of stack ID", 0);
     110    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-stack_id", 0,         "search by stack ID", 0);
     111    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,            "search by state", NULL);
     112    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label", 0,            "search by label", 0);
     113    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_label", 0,        "define new value for label", 0);
     114    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state", 0,        "define new state", NULL);
     115    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_data_group", 0,   "define new data_group", NULL);
     116    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_dist_group", 0,   "define new dist_group", NULL);
     117    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_note", 0,         "define new note", NULL);
    111118   
    112119    // -addinputskyfile

  • trunk/ippTools/src/warptool.c

    r25822 r25835  
    141141    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false); // required
    142142    PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
     143    PXOPT_LOOKUP_STR(data_group, config->args, "-data_group", false, false);
     144    PXOPT_LOOKUP_STR(dist_group, config->args, "-dist_group", false, false);
     145    PXOPT_LOOKUP_STR(note, config->args, "-note", false, false);
    143146    PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false);
    144147    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", true, false); // required (no default TESS)
    … …  
    162165            "dirty",    // workdir_state
    163166            label,
     167            data_group ? data_group : label,
     168            dist_group,
    164169            dvodb,
    165170            tess_id,
    … …  
    167172            end_stage,
    168173            registered,
    169             0       // magicked
     174            0,       // magicked
     175            note
    170176    );
    171177    if (!warpRun) {
    … …  
    253259    PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", false, false);
    254260    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
     261    PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
     262    PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false);
    255263    PXOPT_LOOKUP_STR(dvodb, config->args, "-set_dvodb", false, false);
    256264    PXOPT_LOOKUP_STR(tess_id, config->args, "-set_tess_id", false, false);
    257265    PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false);
    258266    PXOPT_LOOKUP_STR(end_stage, config->args, "-set_end_stage", false, false);
     267    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
    259268
    260269    PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    … …  
    342351                                 workdir     ? workdir   : row->workdir,
    343352                                 label       ? label     : row->label,
     353                                 data_group  ? data_group: row->data_group,
     354                                 dist_group  ? dist_group: row->dist_group,
    344355                                 dvodb       ? dvodb     : row->dvodb,
    345356                                 tess_id     ? tess_id   : row->tess_id,
    346357                                 reduction   ? reduction : row->reduction,
    347                                  end_stage   ? end_stage : row->end_stage))
     358                                 end_stage   ? end_stage : row->end_stage,
     359                                 note))
    348360          {
    349361            psError(PS_ERR_UNKNOWN, false, "failed to trying to queue fake_id: %" PRId64, row->fake_id);
    … …  
    373385    PXOPT_COPY_STR(config->args, where, "-label",     "warpRun.label",     "==");
    374386    PXOPT_COPY_STR(config->args, where, "-state",     "warpRun.state",     "==");
    375 
    376     if (!psListLength(where->list)
    377         && !psMetadataLookupBool(NULL, config->args, "-all")) {
     387    PXOPT_COPY_STR(config->args, where, "-data_group","warpRun.data_group",     "==");
     388    PXOPT_COPY_STR(config->args, where, "-dist_group","warpRun.dist_group",     "==");
     389
     390    if (!psListLength(where->list)) {
    378391        psFree(where);
    379         where = NULL;
    380392        psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
    381393        return false;
    382394    }
    383 
    384     PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
    385     PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
    386 
    387     if ((!state) && (!label)) {
    388         psError(PXTOOLS_ERR_DATA, false, "parameters (-state or -label) are required");
    389         psFree(where);
    390         return false;
    391     }
    392 
    393     if (state) {
    394         // set warpRun.state to state
    395         if (!pxwarpRunSetStateByQuery(config, where, state)) {
    396             psFree(where);
    397             return false;
    398         }
    399     }
    400 
    401     if (label) {
    402         // set chipRun.label to label
    403         if (!pxwarpRunSetLabelByQuery(config, where, label)) {
    404             psFree(where);
    405             return false;
    406         }
    407     }
    408 
     395   
     396    psString query = psStringCopy("UPDATE warpRun JOIN fakeRun USING(fake_id) JOIN camRun USING(cam_id) JOIN chipRun USING(chip_id) JOIN rawExp USING(exp_id)");
     397
     398    // pxUpdateRun gets parameters from config->args and updates
     399    bool result = pxUpdateRun(config, where, &query, true);
     400
     401    psFree(query);
    409402    psFree(where);
    410403
    411     return true;
    412 }
    413 
     404    return result;
     405}
    414406
    415407static bool expMode(pxConfig *config)

  • trunk/ippTools/src/warptoolConfig.c

    r25822 r25835  
    100100    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_reduction",      0, "define reduction class", NULL);
    101101    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_end_stage",      0, "define end stage", NULL);
    102     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-all",               0, "allow everything to be queued without search terms", false);
     102    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_data_group",     0, "define data group", NULL);
     103    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_dist_group",     0, "define dist group", NULL);
     104    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_note",           0, "define note", NULL);
    103105
    104106    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
    … …  
    117119    psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
    118120    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     121    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_end_stage",      0, "define end stage", NULL);
     122    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_data_group",     0, "define data group", NULL);
     123    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_dist_group",     0, "define dist group", NULL);
     124    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_note",           0, "define note", NULL);
    119125
    120126    // -updaterun
    … …  
    128134    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,      "search by warpRun state", NULL);
    129135    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label", 0,      "search by warpRun label", NULL);
    130     psMetadataAddBool(updaterunArgs, PS_LIST_TAIL, "-all",  0,      "allow everything to be queued without search terms", false);
    131     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state", 0,  "set state", NULL);
    132     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_label", 0,  "set label", NULL);
    133 
     136    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-data_group", 0, "search by warpRun data_group", NULL);
     137    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-dist_group", 0, "search by warpRun dist_group", NULL);
     138
     139    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state", 0,        "define new state", NULL);
     140    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_label", 0,        "define new value for label", 0);
     141    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_data_group", 0,   "define new data_group", NULL);
     142    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_dist_group", 0,   "define new dist_group", NULL);
     143    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_note", 0,         "define new note", NULL);
    134144    // -exp
    135145    psMetadata *expArgs = psMetadataAlloc();
Note: See TracChangeset for help on using the changeset viewer.