IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Oct 21, 2010, 2:45:13 PM (16 years ago)
Author:
eugene
Message:

merge changes from trunk

Location:
branches/eam_branches/ipp-20100823/ippTools
Files:
48 edited
5 copied

Legend:

Unmodified
Added
Removed

  • branches/eam_branches/ipp-20100823/ippTools/configure.ac

    r29124 r29515  
    11AC_PREREQ(2.61)
    22
    3 AC_INIT([ipptools], [1.1.63], [ipp-support@ifa.hawaii.edu])
     3AC_INIT([ipptools], [1.1.65], [ipp-support@ifa.hawaii.edu])
    44AC_CONFIG_SRCDIR([autogen.sh])
    55
    … …  
    1818PKG_CHECK_MODULES([PSLIB], [pslib >= 1.1.0])
    1919PKG_CHECK_MODULES([PSMODULES], [psmodules >= 1.1.0])
    20 PKG_CHECK_MODULES([IPPDB], [ippdb >= 1.1.63])
     20PKG_CHECK_MODULES([IPPDB], [ippdb >= 1.1.65])
    2121PKG_CHECK_MODULES([PPSTAMP], [ppstamp >= 0.1.1])
    2222

  • branches/eam_branches/ipp-20100823/ippTools/share/Makefile.am

    r28959 r29515  
    6161        chiptool_pendingimfile.sql \
    6262        chiptool_processedimfile.sql \
     63        chiptool_revertcleanup.sql \
    6364        chiptool_revertprocessedimfile.sql \
    6465        chiptool_revertupdatedimfile.sql \
    … …  
    138139        difftool_inputskyfile.sql \
    139140        difftool_listrun.sql \
     141        difftool_listssrun.sql \
    140142        difftool_pendingcleanuprun.sql \
    141143        difftool_pendingcleanupskyfile.sql \
    142144        difftool_revertdiffskyfile_delete.sql \
    143145        difftool_revertdiffskyfile_updated.sql \
     146        difftool_revertcleanup.sql \
    144147        difftool_setskyfiletoupdate.sql \
    145148        difftool_skyfile.sql \
    … …  
    274277        pstamptool_revertreq.sql \
    275278        pstamptool_revertreq_deletejobs.sql \
     279        pstamptool_stopdependentjob.sql \
    276280        pstamptool_updatejob.sql \
    277281        pxadmin_create_tables.sql \
    … …  
    356360        warptool_revertwarped_delete.sql \
    357361        warptool_revertwarped_updated.sql \
     362        warptool_revertcleanup.sql \
    358363        warptool_runstate.sql \
    359364        warptool_scmap.sql \

  • branches/eam_branches/ipp-20100823/ippTools/share/addtool_find_cam_id.sql

    r26915 r29515  
    22    camRun.*
    33FROM camRun
     4JOIN camProcessedExp
     5    USING(cam_id)
    46JOIN chipRun
    57    USING(chip_id)
    … …  
    1012           FROM addRun
    1113           JOIN camRun USING(cam_id)
    12            JOIN chipRun USING(chip_id)
     14           JOIN chipRun USING(chip_id)
    1315          ) as foo
    1416     ON exp_id = added_exp_id
    … …  
    1719WHERE
    1820    camRun.state = 'full'
     21    AND camProcessedExp.quality = 0
    1922    AND added_exp_id IS NULL
    2023    -- addtool adds checks on exposure being added to the dvodb previously

  • branches/eam_branches/ipp-20100823/ippTools/share/addtool_find_cam_id_dvo.sql

    r28856 r29515  
    11SELECT camRun.* FROM camRun
     2JOIN camProcessedExp USING(cam_id)
    23JOIN chipRun USING(chip_id)
    34JOIN rawExp USING(exp_id)
    4 WHERE camRun.state = 'full'
     5WHERE camRun.state = 'full' and camProcessedExp.quality = 0
    56    AND exp_id NOT IN (SELECT exp_id
    67       FROM addRun

  • branches/eam_branches/ipp-20100823/ippTools/share/chiptool_listrun.sql

    r28586 r29515  
    2929LEFT JOIN camProcessedExp USING(cam_id)
    3030LEFT JOIN magicDSRun
    31     ON stage_id = chip_id AND stage = 'chip' AND magicDSRun.re_place
     31    ON stage_id = chip_id AND stage = 'chip' AND magicDSRun.re_place AND magicDSRun.state != 'drop'

  • branches/eam_branches/ipp-20100823/ippTools/share/chiptool_processedimfile.sql

    r28587 r29515  
    4242    AND chipProcessedImfile.class_id = rawImfile.class_id
    4343LEFT JOIN magicDSRun
    44     ON stage_id = chip_id AND stage = 'chip' AND magicDSRun.re_place
     44    ON stage_id = chip_id AND stage = 'chip' AND magicDSRun.re_place AND magicDSRun.state != 'drop'

  • branches/eam_branches/ipp-20100823/ippTools/share/difftool_listrun.sql

    r27743 r29515  
    1212    diffRun.bothways,
    1313    warp1,
    14     stack1,
    1514    warp2,
    16     stack2,
    1715    -- The following are only valid for warps
    1816    -- XXX This needs to be more clever to handle diffs between stacks
    … …  
    2725    rawInput.exp_name AS exp_name_1,
    2826    rawInput.exp_id AS exp_id_1,
     27    rawInput.comment AS comment_1,
     28    rawInput.dateobs AS dateobs_1,
    2929    chipInput.chip_id AS chip_id_1,
    3030    camInput.cam_id AS cam_id_1,
    … …  
    3434    rawTemplate.exp_name AS exp_name_2,
    3535    rawTemplate.exp_id AS exp_id_2,
     36    rawTemplate.comment AS comment_2,
     37    rawTemplate.dateobs AS dateobs_2,
    3638    chipTemplate.chip_id AS chip_id_2,
    3739    camTemplate.cam_id AS cam_id_2,

  • branches/eam_branches/ipp-20100823/ippTools/share/difftool_todiffskyfile.sql

    r27920 r29515  
    1313    diffRun.bothways,
    1414    diffRun.diff_mode,
    15     diffSkyfile.path_base
     15    diffSkyfile.path_base,
     16    IFNULL(priority, 10000) AS priority
    1617FROM diffRun
    1718JOIN diffInputSkyfile USING(diff_id)
    … …  
    6263    ON diffInputSkyfile.diff_id = diffSkyfile.diff_id
    6364    AND diffInputSkyfile.skycell_id = diffSkyfile.skycell_id
     65LEFT JOIN Label ON Label.label = diffRun.label
    6466WHERE
    6567-- Ready to be processed
    … …  
    7072    AND diffSkyfile.data_state = 'update')
    7173    )
     74    AND (Label.active OR Label.active IS NULL)
    7275-- Ensure input warps are available
    7376    AND (diffInputSkyfile.warp1 IS NULL
    … …  
    9396    AND stackTemplateSkyfile.quality = 0))
    9497
    95 
    96 

  • branches/eam_branches/ipp-20100823/ippTools/share/disttool_pending_camera.sql

    r26567 r29515  
    3030    AND distRun.stage = 'camera'
    3131    AND distComponent.dist_id IS NULL
    32     AND (((chipRun.magicked > 0) AND (camRun.magicked > 0)) OR distRun.no_magic)
     32    AND (((clean OR (chipRun.magicked > 0)) AND (camRun.magicked > 0)) OR distRun.no_magic)
    3333    AND (camRun.state = 'full' OR (distRun.clean AND camRun.state = 'cleaned'))

  • branches/eam_branches/ipp-20100823/ippTools/share/magicdstool_completed_runs.sql

    r25465 r29515  
    11SELECT DISTINCT
    22    magic_ds_id,
     3    magicked,
    34    re_place,
    45    label
    … …  
    78-- raw stage
    89SELECT
    9     magicDSRun.*
     10    magicDSRun.*,
     11    rawExp.magicked
    1012    FROM magicDSRun
    1113    JOIN rawImfile ON stage_id = rawImfile.exp_id
     14    JOIN rawExp using(exp_id)
    1215    LEFT JOIN magicDSFile
    1316        ON magicDSRun.magic_ds_id = magicDSFile.magic_ds_id
    … …  
    2528-- chip stage
    2629SELECT
    27     magicDSRun.*
     30    magicDSRun.*,
     31    chipRun.magicked
    2832    FROM magicDSRun
    29     JOIN chipProcessedImfile ON stage_id = chip_id
     33    JOIN chipRun ON stage_id = chip_id
     34    JOIN chipProcessedImfile USING(chip_id)
    3035    LEFT JOIN magicDSFile
    3136        ON magicDSFile.magic_ds_id = magicDSRun.magic_ds_id
    … …  
    4449-- camera stage
    4550SELECT
    46     magicDSRun.*
     51    magicDSRun.*,
     52    camRun.magicked
    4753    FROM magicDSRun
    48     JOIN camProcessedExp ON stage_id = camProcessedExp.cam_id
     54    JOIN camRun ON stage_id = camRun.cam_id
     55    JOIN camProcessedExp ON camRun.cam_id = camProcessedExp.cam_id
    4956    LEFT JOIN magicDSFile
    5057        ON magicDSFile.magic_ds_id = magicDSRun.magic_ds_id
    … …  
    6168-- warp stage
    6269SELECT
    63     magicDSRun.*
     70    magicDSRun.*,
     71    warpRun.magicked
    6472    FROM magicDSRun
    65     JOIN warpSkyfile on stage_id = warp_id
     73    JOIN warpRun on stage_id = warp_id
     74    JOIN warpSkyfile USING(warp_id)
    6675    LEFT JOIN magicDSFile
    6776        ON magicDSRun.magic_ds_id = magicDSFile.magic_ds_id
    … …  
    8190-- diff stage
    8291SELECT DISTINCT
    83     magicDSRun.*
     92    magicDSRun.*,
     93    diffRun.magicked
    8494    FROM magicDSRun
    8595    JOIN magicRun USING (magic_id)
    8696    JOIN magicInputSkyfile USING(magic_id)
     97    JOIN diffRun
     98        ON magicRun.diff_id = diffRun.diff_id
    8799    JOIN diffSkyfile
    88         ON magicRun.diff_id = diffSkyfile.diff_id
     100        ON diffRun.diff_id = diffSkyfile.diff_id
    89101        AND magicInputSkyfile.node = diffSkyfile.skycell_id
    90102    LEFT JOIN magicDSFile

  • branches/eam_branches/ipp-20100823/ippTools/share/magicdstool_todestreak_camera.sql

    r27945 r29515  
    77    camera,
    88    magicMask.uri AS streaks_uri,
     9    magicMask.path_base AS streaks_path_base,
    910    CAST(NULL AS CHAR(255)) AS inv_streaks_uri,
     11    CAST(NULL AS CHAR(255)) AS inv_streaks_path_base,
    1012    stage,
    1113    stage_id,
    … …  
    1921    recoveryroot,
    2022    re_place,
    21     remove
     23    remove,
     24    IFNULL(Label.priority, 10000) AS priority
    2225FROM magicDSRun
    2326JOIN magicMask USING (magic_id)
    … …  
    2932LEFT JOIN magicDSFile
    3033    ON magicDSRun.magic_ds_id = magicDSFile.magic_ds_id
     34LEFT JOIN Label ON magicDSRun.label = Label.label
    3135WHERE
    3236    magicDSRun.state = 'new'
    … …  
    3842    AND camProcessedExp.quality = 0
    3943    AND magicDSFile.component IS NULL
     44    AND (Label.active OR Label.active IS NULL)

  • branches/eam_branches/ipp-20100823/ippTools/share/magicdstool_todestreak_chip.sql

    r27945 r29515  
    77    camera,
    88    magicMask.uri AS streaks_uri,
     9    magicMask.path_base AS streaks_path_base,
    910    CAST(NULL AS CHAR(255)) AS inv_streaks_uri,
     11    CAST(NULL AS CHAR(255)) AS inv_streaks_path_base,
    1012    stage,
    1113    stage_id,
    … …  
    1921    recoveryroot,
    2022    re_place,
    21     remove
     23    remove,
     24    IFNULL(Label.priority, 10000) AS priority
    2225FROM magicDSRun
    2326JOIN magicMask USING (magic_id)
    … …  
    3134    ON magicDSRun.magic_ds_id = magicDSFile.magic_ds_id
    3235    AND magicDSFile.component = chipProcessedImfile.class_id
     36LEFT JOIN Label
     37    ON magicDSRun.label = Label.label
    3338WHERE
    3439    magicDSRun.state = 'new'
    … …  
    3843    AND chipProcessedImfile.quality = 0
    3944    AND magicDSFile.component IS NULL
     45    AND (Label.active OR Label.active IS NULL)

  • branches/eam_branches/ipp-20100823/ippTools/share/magicdstool_todestreak_diff.sql

    r27945 r29515  
    77    rawExp.camera,
    88    magicMask.uri AS streaks_uri,
     9    magicMask.path_base AS streaks_path_base,
    910    CAST(NULL AS CHAR(255)) AS inv_streaks_uri,
     11    CAST(NULL AS CHAR(255)) AS inv_streaks_path_base,
    1012    stage,
    1113    magicRun.diff_id AS stage_id,
    … …  
    2022    recoveryroot,
    2123    re_place,
    22     remove
     24    remove,
     25    IFNULL(Label.priority, 10000) AS priority
    2326FROM rawExp
    2427JOIN magicRun USING (exp_id)
    … …  
    3336    ON magicDSRun.magic_ds_id = magicDSFile.magic_ds_id
    3437    AND magicDSFile.component = diffSkyfile.skycell_id
     38LEFT JOIN Label ON magicDSRun.label = Label.label
    3539WHERE
    3640    magicDSRun.state = 'new'
    … …  
    4044    AND diffSkyfile.quality = 0
    4145    AND magicDSFile.component IS NULL
     46    AND (Label.active OR Label.active IS NULL)
    4247-- bothways diffSkyfiles
    4348UNION
    … …  
    4954    rawExp.camera,
    5055    magicMask.uri AS streaks_uri,
     56    magicMask.path_base AS streaks_path_base,
    5157    (SELECT uri from magicMask where magic_id = inv_magic_id) AS inv_streaks_uri,
     58    (SELECT path_base from magicMask where magic_id = inv_magic_id) AS inv_streaks_path_base,
    5259    stage,
    5360    magicRun.diff_id AS stage_id,
    … …  
    6269    recoveryroot,
    6370    re_place,
    64     remove
     71    remove,
     72    IFNULL(Label.priority, 10000) AS priority
    6573FROM rawExp
    6674JOIN magicRun USING (exp_id)
    … …  
    7583    ON magicDSRun.magic_ds_id = magicDSFile.magic_ds_id
    7684    AND magicDSFile.component = diffSkyfile.skycell_id
     85LEFT JOIN Label ON magicDSRun.label = Label.label
    7786WHERE
    7887    magicDSRun.state = 'new'
    … …  
    8291    AND diffSkyfile.quality = 0
    8392    AND magicDSFile.component IS NULL
     93    AND (Label.active OR Label.active IS NULL)
    8494) AS magicDSRun
    8595-- we need the following so this query is compatible with the other stages

  • branches/eam_branches/ipp-20100823/ippTools/share/magicdstool_todestreak_raw.sql

    r27945 r29515  
    66    rawExp.camera,
    77    magicMask.uri as streaks_uri,
     8    magicMask.path_base as streaks_path_base,
    89    CAST(NULL AS CHAR(255)) AS inv_streaks_uri,
     10    CAST(NULL AS CHAR(255)) AS inv_streaks_path_base,
    911    stage,
    1012    stage_id,
    … …  
    2022    recoveryroot,
    2123    re_place,
    22     remove
     24    remove,
     25    10000 AS priority
    2326FROM magicDSRun
    2427JOIN magicMask USING (magic_id)

  • branches/eam_branches/ipp-20100823/ippTools/share/magicdstool_todestreak_warp.sql

    r27945 r29515  
    66    camera,
    77    magicMask.uri as streaks_uri,
     8    magicMask.path_base as streaks_path_base,
    89    CAST(NULL AS CHAR(255)) AS inv_streaks_uri,
     10    CAST(NULL AS CHAR(255)) AS inv_streaks_path_base,
    911    stage,
    1012    stage_id,
    … …  
    1921    recoveryroot,
    2022    re_place,
    21     remove
     23    remove,
     24    IFNULL(Label.priority, 10000) AS priority
    2225FROM magicDSRun
    2326JOIN magicMask USING (magic_id)
    … …  
    2932    ON magicDSRun.magic_ds_id = magicDSFile.magic_ds_id
    3033    AND magicDSFile.component = warpSkyfile.skycell_id
     34LEFT JOIN Label ON magicDSRun.label = Label.label
    3135WHERE
    3236    magicDSRun.state = 'new'
    … …  
    3640    AND warpSkyfile.quality = 0
    3741    AND magicDSFile.component IS NULL
     42    AND (Label.active OR Label.active IS NULL)

  • branches/eam_branches/ipp-20100823/ippTools/share/magictool_definebyquery_select.sql

    r28765 r29515  
    1515    FROM diffRun
    1616    JOIN diffInputSkyfile USING(diff_id)
     17    JOIN diffSkyfile USING(diff_id, skycell_id)
    1718    WHERE diffInputSkyfile.warp1 IS NOT NULL
    1819        AND diffRun.exposure = 1
    1920        AND diffRun.magicked = 0
     21        AND diffSkyfile.quality = 0
    2022    -- diff WHERE hook %s
    2123    UNION
    … …  
    2830    FROM diffRun
    2931    JOIN diffInputSkyfile USING(diff_id)
     32    JOIN diffSkyfile USING(diff_id, skycell_id)
    3033    WHERE diffInputSkyfile.warp2 IS NOT NULL
    3134        AND diffRun.exposure = 1
    3235        AND diffRun.bothways = 1
    3336        AND diffRun.magicked = 0
     37        AND diffSkyfile.quality = 0
    3438    -- diff WHERE hook %s
    3539    ) AS diffWarps

  • branches/eam_branches/ipp-20100823/ippTools/share/magictool_revertnode.sql

    r23660 r29515  
    33JOIN magicRun USING(magic_id)
    44WHERE magicNodeResult.fault != 0
     5    AND magicRun.state = 'new'

  • branches/eam_branches/ipp-20100823/ippTools/share/magictool_toprocess_inputs.sql

    r28768 r29515  
    33    magicRun.workdir,
    44    rawExp.exp_id,
     5    rawExp.exp_name,
     6    rawExp.workdir AS raw_workdir,
    57    rawExp.camera,
    68    -- convert magic_id into a boolean value (1 or 0)

  • branches/eam_branches/ipp-20100823/ippTools/share/magictool_toprocess_tree.sql

    r28768 r29515  
    33    magicRun.workdir,
    44    rawExp.exp_id,
     5    rawExp.exp_name,
     6    rawExp.workdir AS raw_workdir,
    57    rawExp.camera,
    68    -- convert magic_id into a boolean value (1 or 0)
    … …  
    1618WHERE
    1719    magicRun.state = 'new'
     20    AND (Label.active OR Label.active IS NULL)
    1821-- WHERE hook %s
    1922ORDER BY

  • branches/eam_branches/ipp-20100823/ippTools/share/magictool_totree.sql

    r28768 r29515  
    1818    AND magicTree.node IS NULL
    1919    AND magicRun.fault = 0
     20    AND (Label.active OR Label.active IS NULL)

  • branches/eam_branches/ipp-20100823/ippTools/share/pstamptool_revertdependent.sql

    r28146 r29515  
    33    JOIN pstampRequest USING(req_id)
    44SET pstampDependent.fault = 0
     5-- fault count hook %s
    56WHERE pstampDependent.state = 'new'
    67    AND (pstampDependent.fault > 0)

  • branches/eam_branches/ipp-20100823/ippTools/share/pstamptool_revertjob.sql

    r26213 r29515  
    22    JOIN pstampRequest USING(req_id)
    33SET pstampJob.fault = 0
     4 -- clear fault count clause goes here %s
    45WHERE  pstampRequest.state = 'run'
    56    AND pstampJob.state = 'run'

  • branches/eam_branches/ipp-20100823/ippTools/share/pstamptool_updatejob.sql

    r27874 r29515  
    1 UPDATE pstampJob LEFT JOIN pstampDependent USING(dep_id)
     1UPDATE pstampJob
     2    JOIN pstampRequest USING(req_id)
     3    LEFT JOIN pstampDependent USING(dep_id)
    24SET

  • branches/eam_branches/ipp-20100823/ippTools/share/pubtool_revert.sql

    r25929 r29515  
    22USING publishDone, publishRun, publishClient
    33WHERE publishDone.pub_id = publishRun.pub_id
     4    AND publishRun.state = 'new'
    45    AND publishRun.client_id = publishClient.client_id
    56    AND publishClient.active = 1

  • branches/eam_branches/ipp-20100823/ippTools/share/pxadmin_create_tables.sql

    r28874 r29515  
    12211221CREATE TABLE magicInputSkyfile (
    12221222        magic_id BIGINT,
    1223         diff_id BIGINT,
    12241223        node VARCHAR(64),
    1225         PRIMARY KEY(magic_id, diff_id, node),
    1226         FOREIGN KEY(magic_id) REFERENCES magicRun(magic_id),
    1227         FOREIGN KEY(diff_id) REFERENCES diffRun(diff_id)
     1224        PRIMARY KEY(magic_id, node),
     1225        FOREIGN KEY(magic_id) REFERENCES magicRun(magic_id)
    12281226) ENGINE=innodb DEFAULT CHARSET=latin1;
    12291227
    … …  
    12531251        magic_id BIGINT,
    12541252        uri VARCHAR(255),
     1253        path_base VARCHAR(255),
    12551254        streaks INT,
    12561255        fault SMALLINT,
    … …  
    14411440        imagedb    VARCHAR(64),
    14421441        rlabel     VARCHAR(64),
     1442        need_magic TINYINT,
    14431443        outdir     VARCHAR(255),
    1444         need_magic TINYINT,
     1444        fault      SMALLINT,
     1445        fault_count INT,
    14451446        PRIMARY KEY(dep_id),
    14461447        KEY(state),
    14471448        KEY(stage),
    1448         KEY(stage_id)
     1449        KEY(stage_id),
     1450        KEY(fault)
    14491451) ENGINE=innodb DEFAULT CHARSET=latin1;
    14501452
    … …  
    18371839    registered TIMESTAMP DEFAULT CURRENT_TIMESTAMP, -- time run was registered
    18381840    note VARCHAR(255),             -- note
     1841    magicked BIGINT NOT NULL DEFAULT 0, -- magic mask applied
    18391842    PRIMARY KEY(diff_phot_id),
    18401843    KEY(diff_id),

  • branches/eam_branches/ipp-20100823/ippTools/share/stacktool_tosum.sql

    r27929 r29515  
    77    stackRun.label,
    88    stackRun.state,
    9     stackSumSkyfile.path_base
     9    stackSumSkyfile.path_base,
     10    IFNULL(Label.priority, 10000) AS priority
    1011FROM stackRun
    1112JOIN stackInputSkyfile USING(stack_id)
    1213JOIN warpRun USING(warp_id)
    1314LEFT JOIN stackSumSkyfile USING(stack_id)
     15LEFT JOIN Label ON Label.label = stackRun.label
    1416WHERE
    1517    ((stackRun.state = 'new' AND stackSumSkyfile.stack_id IS NULL)
    1618    OR (stackRun.state = 'update' AND stackSumSkyfile.fault = 0 AND stackSumSkyfile.quality = 0))
     19    AND (Label.active OR Label.active IS NULL)
    1720    -- WHERE hook %s
    1821GROUP BY stack_id

  • branches/eam_branches/ipp-20100823/ippTools/share/warptool_scmap.sql

    r27737 r29515  
    77    chipRun.state,
    88    chipProcessedImfile.data_state,
     9    chipProcessedImfile.fault AS chip_fault,
    910    chipProcessedImfile.magicked,
    10     rawImfile.magicked AS raw_magicked
     11    rawImfile.magicked AS raw_magicked,
     12    IFNULL(magicDSRun.magic_ds_id, 0) AS magic_ds_id,
     13    IFNULL(magicDSRun.state, 0) AS dsRun_state,
     14    IFNULL(magicDSFile.fault, 0) as dsFile_fault
    1115FROM warpRun
    1216JOIN warpSkyCellMap
    … …  
    2630    ON chipRun.exp_id = rawImfile.exp_id
    2731    AND chipProcessedImfile.class_id = rawImfile.class_id
     32LEFT JOIN magicDSRun
     33    ON chipRun.chip_id = magicDSRun.stage_id AND magicDSRun.stage = 'chip'
     34LEFT JOIN magicDSFile
     35    ON magicDSFile.magic_ds_id = magicDSRun.magic_ds_id
     36        AND chipProcessedImfile.class_id = magicDSFile.component
    2837WHERE
    2938    1

  • branches/eam_branches/ipp-20100823/ippTools/share/warptool_towarped.sql

    r28082 r29515  
    9797        AND warpSkyfile.fault = 0
    9898        AND camRun.state = 'full'
    99         AND chipProcessedImfile.data_state = 'full'
    100         -- if warpSkyfile was magicked previously require inputs to be magicked
    101         -- this blocks processing until all the chip inputs have been destreaked
    102         AND (warpSkyfile.magicked = 0 OR chipProcessedImfile.magicked >= 0)
    10399        AND (Label.active OR Label.active IS NULL)
    104100        -- where hook 2 %s
    105101    GROUP BY warp_id, skycell_id
    106     HAVING COUNT(warpSkyCellMap.class_id) = COUNT(chipProcessedImfile.class_id)
     102    -- if warpSkyfile was magicked previously require inputs to be magicked
     103    -- this blocks processing until all the chip inputs have been destreaked
     104    HAVING COUNT(warpSkyCellMap.class_id) = SUM(IF(chipProcessedImfile.data_state ='full' and (chipRun.magicked = 0 OR chipProcessedImfile.magicked > 0), 1, 0))
    107105    -- limit hook 2 %s
    108106    )

  • branches/eam_branches/ipp-20100823/ippTools/src/addtool.c

    r28856 r29515  
    493493
    494494    // since there is only one exp per 'new' set addRun.state = 'full'
    495     if (!pxaddRunSetState(config, row->add_id, "full")) {
     495    // but check to make sure there are no faults
     496
     497    if (!fault) {
     498      if (!pxaddRunSetState(config, row->add_id, "full")) {
    496499        psError(PS_ERR_UNKNOWN, false, "failed to change addRun.state for add_id: %" PRId64, row->add_id);
    497500        psFree(row);
    498501        psFree(pendingRow);
    499502        return false;
     503      }
    500504    }
    501505    psFree(row);

  • branches/eam_branches/ipp-20100823/ippTools/src/bgtool.c

    r28941 r29515  
    658658    }
    659659
    660     if (!chipBackgroundImfileInsert(config->dbh, chip_bg_id, class_id, path_base, magicked, dtime_script,
     660    if (!chipBackgroundImfileInsert(config->dbh, chip_bg_id, class_id, path_base, "full", magicked, dtime_script,
    661661                                    hostname, quality, fault, ver_code, bg, bg_stdev, maskfrac_npix,
    662662                                    maskfrac_static, maskfrac_dynamic, maskfrac_magic, maskfrac_advisory)) {
    … …  
    14971497    }
    14981498
    1499     if (!warpBackgroundSkyfileInsert(config->dbh, warp_bg_id, skycell_id, path_base, magicked, dtime_script,
     1499    if (!warpBackgroundSkyfileInsert(config->dbh, warp_bg_id, skycell_id, path_base, "full", magicked, dtime_script,
    15001500                                    hostname, quality, fault, ver_code, bg, bg_stdev, maskfrac_npix,
    15011501                                    maskfrac_static, maskfrac_dynamic, maskfrac_magic, maskfrac_advisory)) {

  • branches/eam_branches/ipp-20100823/ippTools/src/chiptool.c

    r28716 r29515  
    5050static bool pendingcleanuprunMode(pxConfig *config);
    5151static bool pendingcleanupimfileMode(pxConfig *config);
     52static bool revertcleanupMode(pxConfig *config);
    5253static bool donecleanupMode(pxConfig *config);
    5354static bool runMode(pxConfig *config);
    … …  
    9495        MODECASE(CHIPTOOL_MODE_PENDINGCLEANUPRUN,       pendingcleanuprunMode);
    9596        MODECASE(CHIPTOOL_MODE_PENDINGCLEANUPIMFILE,    pendingcleanupimfileMode);
     97        MODECASE(CHIPTOOL_MODE_REVERTCLEANUP,           revertcleanupMode);
    9698        MODECASE(CHIPTOOL_MODE_DONECLEANUP,             donecleanupMode);
    9799        MODECASE(CHIPTOOL_MODE_RUN,                     runMode);
    … …  
    859861    }
    860862    psString query_update = pxDataGet("chiptool_revertupdatedimfile.sql");
    861     if (!query) {
     863    if (!query_update) {
    862864        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    863865        psFree(where);
    864866        return false;
    865867    }
     868
    866869
    867870    if (where && psListLength(where->list)) {
    … …  
    886889    }
    887890    psFree(query_update);
     891
     892    return true;
     893}
     894static bool revertcleanupMode(pxConfig *config)
     895{
     896    PS_ASSERT_PTR_NON_NULL(config, false);
     897
     898    psMetadata *where = psMetadataAlloc();
     899    PXOPT_COPY_S64(config->args, where, "-chip_id", "chipRun.chip_id", "==");
     900    pxAddLabelSearchArgs (config, where, "-label", "chipRun.label", "LIKE");
     901    pxAddLabelSearchArgs (config, where, "-data_group", "chipRun.data_group", "LIKE");
     902    PXOPT_LOOKUP_STR(state, config->args, "-state", false, false);
     903
     904    char* newState = NULL;
     905    if (!state) {
     906        state = "error_cleaned";
     907    }
     908    if (!strcmp(state, "error_cleaned")) {
     909        newState = "goto_cleaned";
     910    } else if (!strcmp(state, "error_purged")) {
     911        newState = "goto_purged";
     912    } else if (!strcmp(state, "error_scrubbed")) {
     913        newState = "goto_scrubbed";
     914    } else {
     915        psError(PXTOOLS_ERR_CONFIG, true, "-state must be either error_cleaned, error_purged, or error_scrubbed");
     916        return false;
     917    }
     918
     919    if (!psListLength(where->list)) {
     920        psFree(where);
     921        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     922        return false;
     923    }
     924
     925    psString query = pxDataGet("chiptool_revertcleanup.sql");
     926    if (!query) {
     927        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     928        psFree(where);
     929        return false;
     930    }
     931
     932    if (where && psListLength(where->list)) {
     933        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     934        psStringAppend(&query, " AND %s", whereClause);
     935        psFree(whereClause);
     936    }
     937
     938    psFree(where);
     939
     940    if (!p_psDBRunQueryF(config->dbh, query, newState, state, state)) {
     941        psError(PS_ERR_UNKNOWN, false, "database error");
     942        psFree(query);
     943        return false;
     944    }
     945    psFree(query);
    888946
    889947    return true;

  • branches/eam_branches/ipp-20100823/ippTools/src/chiptool.h

    r27742 r29515  
    4242    CHIPTOOL_MODE_PENDINGCLEANUPRUN,
    4343    CHIPTOOL_MODE_PENDINGCLEANUPIMFILE,
     44    CHIPTOOL_MODE_REVERTCLEANUP,
    4445    CHIPTOOL_MODE_DONECLEANUP,
    4546    CHIPTOOL_MODE_RUN,

  • branches/eam_branches/ipp-20100823/ippTools/src/chiptoolConfig.c

    r28716 r29515  
    290290    psMetadataAddU64(donecleanupArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    291291
     292    // -revertcleanup
     293    psMetadata *revertcleanupArgs = psMetadataAlloc();
     294    psMetadataAddS64(revertcleanupArgs, PS_LIST_TAIL, "-chip_id", 0,            "search by chip ID", 0);
     295    psMetadataAddStr(revertcleanupArgs,  PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by chipRun label (LIKE comparison)", NULL);
     296    psMetadataAddStr(revertcleanupArgs,  PS_LIST_TAIL, "-data_group",  PS_META_DUPLICATE_OK, "search by chipRun data_group (LIKE comparison)", NULL);
     297    psMetadataAddStr(revertcleanupArgs, PS_LIST_TAIL, "-state", 0,             "search by current state", NULL);
     298    psMetadataAddS16(revertcleanupArgs, PS_LIST_TAIL, "-fault",  0,            "search by fault code", 0);
     299
    292300    // -run
    293301    psMetadata *runArgs = psMetadataAlloc();
    … …  
    371379    PXOPT_ADD_MODE("-pendingcleanupimfile", "show runs that need to be cleaned up", CHIPTOOL_MODE_PENDINGCLEANUPIMFILE, pendingcleanupimfileArgs);
    372380    PXOPT_ADD_MODE("-donecleanup",          "show runs that have been cleaned",     CHIPTOOL_MODE_DONECLEANUP,          donecleanupArgs);
     381    PXOPT_ADD_MODE("-revertcleanup",        "show runs that have been cleaned",     CHIPTOOL_MODE_REVERTCLEANUP,        revertcleanupArgs);
    373382    PXOPT_ADD_MODE("-run",                  "show runs",                            CHIPTOOL_MODE_RUN,                  runArgs);
    374383    PXOPT_ADD_MODE("-tocleanedimfile",      "set imfile state to cleaned",          CHIPTOOL_MODE_TOCLEANEDIMFILE,      tocleanedimfileArgs);

  • branches/eam_branches/ipp-20100823/ippTools/src/difftool.c

    r29324 r29515  
    4848static bool pendingcleanuprunMode(pxConfig *config);
    4949static bool pendingcleanupskyfileMode(pxConfig *config);
     50static bool revertcleanupMode(pxConfig *config);
    5051static bool donecleanupMode(pxConfig *config);
    5152static bool updatediffskyfileMode(pxConfig *config);
    … …  
    6061static bool tofullskyfileMode(pxConfig *config);
    6162static bool listrunMode(pxConfig *config);
     63static bool listssrunMode(pxConfig *config);
    6264static bool setskyfiletoupdateMode(pxConfig *config);
    6365
    … …  
    99101        MODECASE(DIFFTOOL_MODE_PENDINGCLEANUPRUN,     pendingcleanuprunMode);
    100102        MODECASE(DIFFTOOL_MODE_PENDINGCLEANUPSKYFILE, pendingcleanupskyfileMode);
     103        MODECASE(DIFFTOOL_MODE_REVERTCLEANUP,         revertcleanupMode);
    101104        MODECASE(DIFFTOOL_MODE_DONECLEANUP,           donecleanupMode);
    102105        MODECASE(DIFFTOOL_MODE_UPDATEDIFFSKYFILE,     updatediffskyfileMode);
    … …  
    108111        MODECASE(DIFFTOOL_MODE_TOFULLSKYFILE,         tofullskyfileMode);
    109112        MODECASE(DIFFTOOL_MODE_LISTRUN,               listrunMode);
     113        MODECASE(DIFFTOOL_MODE_LISTSSRUN,             listssrunMode);
    110114        MODECASE(DIFFTOOL_MODE_SETSKYFILETOUPDATE,    setskyfiletoupdateMode);
    111115
    … …  
    478482    }
    479483    psFree(where);
     484
     485     psStringAppend(&query, "\nORDER by priority DESC, diff_id");
    480486
    481487    // treat limit == 0 as "no limit"
    … …  
    12361242    PXOPT_COPY_F32(config->args, warp2Where,  "-good_frac", "warpSkyfile.good_frac", ">=");
    12371243    PXOPT_COPY_STR(config->args, stackWhere, "-stack_label", "stackRun.label", "==");
     1244    PXOPT_COPY_STR(config->args, stackWhere, "-stack_data_group", "stackRun.data_group", "==");
    12381245
    12391246    PXOPT_LOOKUP_BOOL(bothways, config->args, "-bothways", false);
    … …  
    16091616    PXOPT_COPY_S64(config->args, selectWhere, "-warp_id", "inputWarpRun.warp_id", "==");
    16101617    PXOPT_COPY_S64(config->args, selectWhere, "-exp_id", "inputRawExp.exp_id", "==");
     1618    PXOPT_COPY_S64(config->args, selectWhere, "-template_exp_id", "templateRawExp.exp_id", "==");
    16111619    PXOPT_COPY_STR(config->args, selectWhere, "-filter", "inputRawExp.filter", "==");
    16121620    PXOPT_COPY_STR(config->args, selectWhere, "-obs_mode", "inputRawExp.obs_mode", "==");
    … …  
    16471655    PXOPT_COPY_F32(config->args,   selectWhere, "-sun_angle_min",      "inputRawExp.sun_angle",      ">=");
    16481656    PXOPT_COPY_F32(config->args,   selectWhere, "-sun_angle_max",      "inputRawExp.sun_angle",      "<");
    1649     PXOPT_COPY_STR(config->args,   selectWhere, "-comment",            "inputRawExp.comment",        "LIKE");
     1657    PXOPT_COPY_STR(config->args,   selectWhere, "-input_comment",      "inputRawExp.comment",        "LIKE");
     1658    PXOPT_COPY_STR(config->args,   selectWhere, "-template_comment",   "templateRawExp.comment",     "LIKE");
    16501659
    16511660    PXOPT_LOOKUP_BOOL(not_bothways, config->args, "-not-bothways", false);
    … …  
    16801689
    16811690    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1691    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    16821692    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
    16831693
    … …  
    18391849    long numGood = 0;                   // Number of good rows added
    18401850    for (long i = 0; i < results->n; i++) {
     1851        if (limit && numGood >= limit) {
     1852            break;
     1853        }
    18411854        psMetadata *row = results->data[i]; // Result row from query
    18421855
    … …  
    25352548
    25362549
     2550static bool revertcleanupMode(pxConfig *config)
     2551{
     2552    PS_ASSERT_PTR_NON_NULL(config, false);
     2553
     2554    psMetadata *where = psMetadataAlloc();
     2555    PXOPT_COPY_S64(config->args, where, "-diff_id",    "diffSkyfile.diff_id", "==");
     2556    pxAddLabelSearchArgs (config, where, "-label",     "diffRun.label", "LIKE");
     2557    pxAddLabelSearchArgs (config, where, "-data_group",   "diffRun.data_group", "LIKE");
     2558
     2559    PXOPT_LOOKUP_STR(state, config->args, "-state", false, false);
     2560
     2561    if (!psListLength(where->list)) {
     2562        psFree(where);
     2563        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     2564        return false;
     2565    }
     2566    if (!state) {
     2567        state = "error_cleaned";
     2568    }
     2569    char *newState = NULL;
     2570    if (!strcmp(state, "error_cleaned")) {
     2571        newState = "goto_cleaned";
     2572    } else if (!strcmp(state, "error_purged")) {
     2573        newState = "goto_purged";
     2574    } else if (!strcmp(state, "error_scrubbed")) {
     2575        newState = "goto_scrubbed";
     2576    } else {
     2577        psError(PXTOOLS_ERR_CONFIG, true, "-state must be either error_cleaned, error_purged, or error_scrubbed");
     2578        return false;
     2579    }
     2580
     2581    psString query = pxDataGet("difftool_revertcleanup.sql");
     2582    if (!query) {
     2583        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     2584        return false;
     2585    }
     2586
     2587    if (psListLength(where->list)) {
     2588        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     2589        psStringAppend(&query, " AND %s", whereClause);
     2590        psFree(whereClause);
     2591    }
     2592    psFree(where);
     2593
     2594    if (!p_psDBRunQueryF(config->dbh, query, newState, state, state)) {
     2595        psError(PS_ERR_UNKNOWN, false, "database error");
     2596        psFree(query);
     2597        return false;
     2598    }
     2599    psFree(query);
     2600
     2601    int numDeleted = psDBAffectedRows(config->dbh);
     2602
     2603    psLogMsg("difftool", PS_LOG_INFO, "Reverted %d diffRuns and diffSkyfiles", numDeleted);
     2604
     2605    return true;
     2606}
    25372607static bool donecleanupMode(pxConfig *config)
    25382608{
    … …  
    28772947
    28782948    psMetadata *where = psMetadataAlloc();
    2879     PXOPT_COPY_S64(config->args, where,  "-diff_id", "diffRun.diff_id", "==");
    2880     PXOPT_COPY_STR(config->args, where, "-tess_id", "diffRun.tess_id", "==");
    2881     PXOPT_COPY_S64(config->args, where,  "-magicked", "diffRun.magicked", "==");
    2882     pxAddLabelSearchArgs (config, where, "-label", "diffRun.label", "LIKE");
     2949    PXOPT_COPY_S64(config->args, where,  "-diff_id",    "diffRun.diff_id",  "==");
     2950    PXOPT_COPY_STR(config->args, where,  "-tess_id",    "diffRun.tess_id",  "LIKE");
     2951    PXOPT_COPY_S64(config->args, where,  "-magicked",   "diffRun.magicked", "==");
     2952    PXOPT_COPY_STR(config->args, where,  "-state",      "diffRun.state",    "==");
     2953    pxAddLabelSearchArgs (config, where, "-label",      "diffRun.label", "LIKE");
    28832954    pxAddLabelSearchArgs (config, where, "-data_group", "diffRun.data_group", "LIKE");
    28842955    pxAddLabelSearchArgs (config, where, "-dist_group", "diffRun.dist_group", "LIKE");
    2885 
     2956   
    28862957    PXOPT_LOOKUP_BOOL(template, config->args, "-template", false);
    28872958    if (!template) {
    … …  
    29052976    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    29062977    PXOPT_LOOKUP_BOOL(pstamp_order, config->args, "-pstamp_order", false);
    2907 
     2978    PXOPT_LOOKUP_S16(diff_mode, config->args, "-diff_mode", false, false);
     2979    if (diff_mode) {
     2980      PXOPT_COPY_S16(config->args, where, "-diff_mode", "diffRun.diff_mode", "==");
     2981    }
    29082982
    29092983    psString where2 = NULL;
    … …  
    29833057    return true;
    29843058}
     3059static bool listssrunMode(pxConfig *config)
     3060{
     3061    PS_ASSERT_PTR_NON_NULL(config, false);
     3062
     3063    psMetadata *where = psMetadataAlloc();
     3064    PXOPT_COPY_S64(config->args, where,  "-diff_id",    "diffRun.diff_id",  "==");
     3065    PXOPT_COPY_S64(config->args, where,  "-stack_id",   "stackInput.stack_id",  "==");
     3066    PXOPT_COPY_S64(config->args, where,  "-template_stack_id",  "stackTemplate.stack_id",  "==");
     3067    PXOPT_COPY_STR(config->args, where,  "-tess_id",    "diffRun.tess_id",  "LIKE");
     3068    PXOPT_COPY_STR(config->args, where,  "-state",      "diffRun.state",    "==");
     3069    pxAddLabelSearchArgs (config, where, "-label",      "diffRun.label", "LIKE");
     3070    pxAddLabelSearchArgs (config, where, "-data_group", "diffRun.data_group", "LIKE");
     3071    pxAddLabelSearchArgs (config, where, "-dist_group", "diffRun.dist_group", "LIKE");
     3072
     3073    // lookup these so we don't compare to zero if they are not supplied
     3074    PXOPT_LOOKUP_F64(mjd_obs_begin, config->args, "-mjd_obs_begin", false, false);
     3075    PXOPT_LOOKUP_F64(mjd_obs_end, config->args, "-mjd_obs_end", false, false);
     3076   
     3077    PXOPT_LOOKUP_BOOL(template, config->args, "-template", false);
     3078
     3079    if (!template) {
     3080        if (mjd_obs_begin) {
     3081            PXOPT_COPY_F64(config->args, where, "-mjd_obs_begin", "stackInput.mjd_obs",  ">=");
     3082        }
     3083        if (mjd_obs_end) {
     3084            PXOPT_COPY_F64(config->args, where, "-mjd_obs_end",   "stackInput.mjd_obs",  "<=");
     3085        }
     3086        PXOPT_COPY_STR(config->args, where, "-filter",        "stackInputRun.filter", "LIKE");
     3087    } else {
     3088        if (mjd_obs_begin) {
     3089            PXOPT_COPY_F64(config->args, where, "-mjd_obs_begin", "stackTemplate.mjd_obs",  ">=");
     3090        }
     3091        if (mjd_obs_end) {
     3092            PXOPT_COPY_F64(config->args, where, "-mjd_obs_end",   "stackTemplate.mjd_obs",  "<=");
     3093        }
     3094        PXOPT_COPY_STR(config->args, where, "-filter",        "stackTemplateRun.filter", "LIKE");
     3095    }
     3096
     3097    PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
     3098    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     3099    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     3100    PXOPT_LOOKUP_BOOL(pstamp_order, config->args, "-pstamp_order", false);
     3101
     3102    psString where2 = NULL;
     3103    psString query = pxDataGet("difftool_listssrun.sql");
     3104    if (!query) {
     3105        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     3106        return false;
     3107    }
     3108
     3109    if (psListLength(where->list)) {
     3110        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     3111        psStringAppend(&query, " AND %s", whereClause);
     3112        psFree(whereClause);
     3113    } else if (where2) {
     3114        psStringAppend(&query, " AND %s", where2);
     3115    } else if (!all) {
     3116        psError(PXTOOLS_ERR_CONFIG, true, "search parameters or -all are required");
     3117        return false;
     3118    }
     3119    psFree(where);
     3120
     3121    if (pstamp_order) {
     3122        if (template) {
     3123            psStringAppend(&query, " ORDER BY stackTemplate.stack_id, diff_id DESC");
     3124        } else {
     3125            psStringAppend(&query, " ORDER BY stackInput.stack_id, diff_id DESC");
     3126        }
     3127    }
     3128           
     3129    // treat limit == 0 as "no limit"
     3130    if (limit) {
     3131        psString limitString = psDBGenerateLimitSQL(limit);
     3132        psStringAppend(&query, " %s", limitString);
     3133        psFree(limitString);
     3134    }
     3135
     3136    if (!p_psDBRunQuery(config->dbh, query)) {
     3137        psError(PS_ERR_UNKNOWN, false, "database error");
     3138        psFree(query);
     3139        return false;
     3140    }
     3141    psFree(query);
     3142
     3143    psArray *output = p_psDBFetchResult(config->dbh);
     3144    if (!output) {
     3145        psErrorCode err = psErrorCodeLast();
     3146        switch (err) {
     3147            case PS_ERR_DB_CLIENT:
     3148                psError(PXTOOLS_ERR_SYS, false, "database error");
     3149            case PS_ERR_DB_SERVER:
     3150                psError(PXTOOLS_ERR_PROG, false, "database error");
     3151            default:
     3152                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     3153        }
     3154
     3155        return false;
     3156    }
     3157    if (!psArrayLength(output)) {
     3158        psTrace("difftool", PS_LOG_INFO, "no rows found");
     3159        psFree(output);
     3160        return true;
     3161    }
     3162
     3163    if (psArrayLength(output)) {
     3164        // negative simple so the default is true
     3165        if (!ippdbPrintMetadatas(stdout, output, "diffRun", !simple)) {
     3166            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     3167            psFree(output);
     3168            return false;
     3169        }
     3170    }
     3171
     3172    psFree(output);
     3173
     3174    return true;
     3175}
    29853176// a very specfic function to queue a cleaned warpSkyfile to be updated
    29863177static bool setskyfiletoupdateMode(pxConfig *config)

  • branches/eam_branches/ipp-20100823/ippTools/src/difftool.h

    r28375 r29515  
    4242    DIFFTOOL_MODE_PENDINGCLEANUPRUN,
    4343    DIFFTOOL_MODE_PENDINGCLEANUPSKYFILE,
     44    DIFFTOOL_MODE_REVERTCLEANUP,
    4445    DIFFTOOL_MODE_DONECLEANUP,
    4546    DIFFTOOL_MODE_UPDATEDIFFSKYFILE,
    … …  
    5152    DIFFTOOL_MODE_TOFULLSKYFILE,
    5253    DIFFTOOL_MODE_LISTRUN,
     54    DIFFTOOL_MODE_LISTSSRUN,
    5355    DIFFTOOL_MODE_SETSKYFILETOUPDATE,
    5456} difftoolMode;

  • branches/eam_branches/ipp-20100823/ippTools/src/difftoolConfig.c

    r29324 r29515  
    173173    psMetadata *listrunArgs = psMetadataAlloc();
    174174    psMetadataAddS64(listrunArgs, PS_LIST_TAIL,  "-diff_id", 0,           "search by diff ID", 0);
    175     psMetadataAddStr(listrunArgs, PS_LIST_TAIL,  "-tess_id",  0,          "search by tessellation ID", NULL);
     175    psMetadataAddStr(listrunArgs, PS_LIST_TAIL,  "-tess_id",  0,          "search by tessellation ID (LIKE comparison)", NULL);
    176176    psMetadataAddStr(listrunArgs , PS_LIST_TAIL, "-warp_id",  0,         "search by warp_id", NULL);
    177177    psMetadataAddBool(listrunArgs, PS_LIST_TAIL, "-template",  0,        "apply exposure args to template of bothways diff", false);
    … …  
    184184    psMetadataAddStr(listrunArgs,  PS_LIST_TAIL, "-data_group",  PS_META_DUPLICATE_OK, "search by diffRun data_group (LIKE comparison)", NULL);
    185185    psMetadataAddStr(listrunArgs,  PS_LIST_TAIL, "-dist_group",  PS_META_DUPLICATE_OK, "search by diffRun dist_group (LIKE comparison)", NULL);
     186    psMetadataAddS16(listrunArgs,  PS_LIST_TAIL, "-diff_mode", 0,        "search for diff_mode", 0);
     187    psMetadataAddStr(listrunArgs, PS_LIST_TAIL,  "-state",  0,           "search by state", NULL);
    186188    pxmagicAddArguments(listrunArgs);
    187189    pxspaceAddArguments(listrunArgs);
    … …  
    192194    psMetadataAddU64(listrunArgs, PS_LIST_TAIL,  "-limit",  0,            "limit result set to N items", 0);
    193195    psMetadataAddBool(listrunArgs, PS_LIST_TAIL, "-simple",  0,          "use the simple output format", false);
     196
     197
     198    // -listssrun
     199    psMetadata *listssrunArgs = psMetadataAlloc();
     200    psMetadataAddS64(listssrunArgs, PS_LIST_TAIL,  "-diff_id", 0,          "search by diff ID", 0);
     201    psMetadataAddStr(listssrunArgs, PS_LIST_TAIL,  "-tess_id",  0,         "search by tessellation ID (LIKE comparison)", NULL);
     202    psMetadataAddS64(listssrunArgs , PS_LIST_TAIL, "-stack_id",  0,        "search by input stack_id", 0);
     203    psMetadataAddS64(listssrunArgs , PS_LIST_TAIL, "-template_stack_id",0, "search by template stack_id", 0);
     204    psMetadataAddBool(listssrunArgs, PS_LIST_TAIL, "-template",  0,        "apply stack selectors to template", false);
     205    psMetadataAddF64(listssrunArgs, PS_LIST_TAIL,  "-mjd_obs_begin", 0,    "search by stack MJD-OBS (>=)", 0);
     206    psMetadataAddF64(listssrunArgs, PS_LIST_TAIL,  "-mjd_obs_end", 0,      "search by stack MJD-OBS(<=)", 0);
     207    psMetadataAddStr(listssrunArgs, PS_LIST_TAIL,  "-filter", 0,           "search by stack filter", NULL);
     208    psMetadataAddStr(listssrunArgs,  PS_LIST_TAIL, "-label",  PS_META_DUPLICATE_OK, "search by diffRun label (LIKE comparison)", NULL);
     209    psMetadataAddStr(listssrunArgs,  PS_LIST_TAIL, "-data_group",  PS_META_DUPLICATE_OK, "search by diffRun data_group (LIKE comparison)", NULL);
     210    psMetadataAddStr(listssrunArgs,  PS_LIST_TAIL, "-dist_group",  PS_META_DUPLICATE_OK, "search by diffRun dist_group (LIKE comparison)", NULL);
     211    psMetadataAddS16(listssrunArgs,  PS_LIST_TAIL, "-diff_mode", 0,        "search for diff_mode", 0);
     212    psMetadataAddStr(listssrunArgs, PS_LIST_TAIL,  "-state",  0,           "search by state", NULL);
     213    pxmagicAddArguments(listssrunArgs);
     214    pxspaceAddArguments(listssrunArgs);
     215
     216    psMetadataAddBool(listssrunArgs, PS_LIST_TAIL, "-pstamp_order",  0,    "order results for postage stamp server", false);
     217
     218    psMetadataAddBool(listssrunArgs, PS_LIST_TAIL, "-all",  0,             "search without arguments", false);
     219    psMetadataAddU64(listssrunArgs, PS_LIST_TAIL,  "-limit",  0,            "limit result set to N items", 0);
     220    psMetadataAddBool(listssrunArgs, PS_LIST_TAIL, "-simple",  0,          "use the simple output format", false);
    194221
    195222
    … …  
    226253    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-comment", 0, "search by comment (LIKE)", NULL);
    227254    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-stack_label", 0, "search by stack label", NULL);
     255    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-stack_data_group", 0, "search by stack data_group", NULL);
    228256    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-warp_label", 0, "search by warp label", NULL);
    229257    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-data_group", 0, "search by data_group", NULL);
    … …  
    247275    psMetadataAddS64(definewarpwarpArgs, PS_LIST_TAIL, "-exp_id", 0, "search by exposure ID", 0);
    248276    psMetadataAddBool(definewarpwarpArgs, PS_LIST_TAIL, "-not-bothways",  0, "only do the single-direction subtraction?", false);
     277    psMetadataAddS64(definewarpwarpArgs, PS_LIST_TAIL,  "-template_exp_id",  0,  "search by template exposure ID", 0);
    249278    psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-filter", 0, "search by filter", NULL);
    250279    psMetadataAddF32(definewarpwarpArgs, PS_LIST_TAIL, "-distance", 0, "limit distance between input and template (deg)", NAN);
    … …  
    292321    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-posang_min",         0, "search by min rotator position angle", NAN);
    293322    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-posang_max",         0, "search by max rotator position angle", NAN);
    294     psMetadataAddF32(definewarpwarpArgs,  PS_LIST_TAIL, "-sun_angle_min",         0, "search by min solar angle", NAN);
    295     psMetadataAddF32(definewarpwarpArgs,  PS_LIST_TAIL, "-sun_angle_max",         0, "search by max solar angle", NAN);
    296     psMetadataAddStr(definewarpwarpArgs,  PS_LIST_TAIL, "-comment",            0, "search by comment field (LIKE comparison)", NULL);
     323    psMetadataAddF32(definewarpwarpArgs,  PS_LIST_TAIL, "-sun_angle_min",      0, "search by min solar angle", NAN);
     324    psMetadataAddF32(definewarpwarpArgs,  PS_LIST_TAIL, "-sun_angle_max",      0, "search by max solar angle", NAN);
     325    psMetadataAddStr(definewarpwarpArgs,  PS_LIST_TAIL, "-input_comment",      0, "search by comment field for input exposure(LIKE comparison)", NULL);
     326    psMetadataAddStr(definewarpwarpArgs,  PS_LIST_TAIL, "-template_comment",   0, "search by comment field for template exposure(LIKE comparison)", NULL);
     327    psMetadataAddU64(definewarpwarpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    297328
    298329    // -definestackstack
    … …  
    362393    psMetadataAddU64(pendingcleanupskyfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    363394
     395    // -revertcleanup
     396    psMetadata *revertcleanupArgs = psMetadataAlloc();
     397    psMetadataAddS64(revertcleanupArgs, PS_LIST_TAIL, "-diff_id", 0,            "search by difftool ID", 0);
     398    psMetadataAddStr(revertcleanupArgs, PS_LIST_TAIL, "-label",  PS_META_DUPLICATE_OK, "search by diffRun label", NULL);
     399    psMetadataAddStr(revertcleanupArgs, PS_LIST_TAIL, "-data_group",  PS_META_DUPLICATE_OK, "search by diffRun data_group", NULL);
     400    psMetadataAddStr(revertcleanupArgs, PS_LIST_TAIL, "-state",  0,            "search by state", NULL);
     401
     402
    364403    // -donecleanup
    365404    psMetadata *donecleanupArgs = psMetadataAlloc();
    … …  
    427466    PXOPT_ADD_MODE("-advance",          "", DIFFTOOL_MODE_ADVANCE,           advanceArgs);
    428467    PXOPT_ADD_MODE("-diffskyfile",      "", DIFFTOOL_MODE_DIFFSKYFILE,       diffskyfileArgs);
    429     PXOPT_ADD_MODE("-listrun",          "", DIFFTOOL_MODE_LISTRUN,           listrunArgs);
    430468    PXOPT_ADD_MODE("-revertdiffskyfile","", DIFFTOOL_MODE_REVERTDIFFSKYFILE, revertdiffskyfileArgs);
    431469    PXOPT_ADD_MODE("-definepoprun",     "", DIFFTOOL_MODE_DEFINEPOPRUN,      definepoprunArgs);
    … …  
    433471    PXOPT_ADD_MODE("-definewarpwarp",   "", DIFFTOOL_MODE_DEFINEWARPWARP,    definewarpwarpArgs);
    434472    PXOPT_ADD_MODE("-definestackstack", "", DIFFTOOL_MODE_DEFINESTACKSTACK,  definestackstackArgs);
     473    PXOPT_ADD_MODE("-listrun",          "list diff runs", DIFFTOOL_MODE_LISTRUN,           listrunArgs);
     474    PXOPT_ADD_MODE("-listssrun",        "list stack-stack diff runs", DIFFTOOL_MODE_LISTSSRUN,           listssrunArgs);
    435475    PXOPT_ADD_MODE("-pendingcleanuprun",     "show runs that need to be cleaned up", DIFFTOOL_MODE_PENDINGCLEANUPRUN,    pendingcleanuprunArgs);
    436476    PXOPT_ADD_MODE("-pendingcleanupskyfile", "show runs that need to be cleaned up", DIFFTOOL_MODE_PENDINGCLEANUPSKYFILE, pendingcleanupskyfileArgs);
     477    PXOPT_ADD_MODE("-revertcleanup",           "revert cleanup runs with errors",     DIFFTOOL_MODE_REVERTCLEANUP,          revertcleanupArgs);
    437478    PXOPT_ADD_MODE("-donecleanup",           "show runs that have been cleaned",     DIFFTOOL_MODE_DONECLEANUP,          donecleanupArgs);
    438479    PXOPT_ADD_MODE("-updatediffskyfile",     "update fault code for a diffskyfile",  DIFFTOOL_MODE_UPDATEDIFFSKYFILE,          updatediffskyfileArgs);

  • branches/eam_branches/ipp-20100823/ippTools/src/magicdstool.c

    r28936 r29515  
    637637    psFree(where);
    638638
     639    psStringAppend(&query, "\nORDER BY priority DESC, magic_ds_id");
     640
    639641    // treat limit == 0 as "no limit"
    640642    if (limit) {
    … …  
    933935    }
    934936
     937    // treat limit == 0 as "no limit"
     938    if (limit) {
     939        psString limitString = psDBGenerateLimitSQL(limit);
     940        psStringAppend(&query, " %s", limitString);
     941        psFree(limitString);
     942    }
     943
    935944    if (!p_psDBRunQuery(config->dbh, query)) {
    936945        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    950959        return true;
    951960    }
    952     if (!psDBTransaction(config->dbh)) {
    953         psError(PS_ERR_UNKNOWN, false, "database error");
    954         return false;
    955     }
    956961    for (long i = 0; i < psArrayLength(output); i++) {
    957962        psMetadata *row = output->data[i];
    958963
    959964        psS64 magic_ds_id = psMetadataLookupS64(NULL, row, "magic_ds_id");
     965        psS64 magicked =  psMetadataLookupS64(NULL, row, "magicked");
     966        if (!psDBTransaction(config->dbh)) {
     967            psError(PS_ERR_UNKNOWN, false, "database error");
     968            return false;
     969        }
    960970
    961971        // if re_place, set stageRun.magicked
    962972        bool setmagicked = psMetadataLookupBool(NULL, row, "re_place");
    963         if (setmagicked && !setRunMagicked(config, magic_ds_id)) {
    964             psError(PS_ERR_UNKNOWN, false, "failed to change stageRun.magicked for magic_ds_id: %" PRId64,
    965                 magic_ds_id);
    966             if (!psDBRollback(config->dbh)) {
    967                 psError(PS_ERR_UNKNOWN, false, "database error");
     973        if (setmagicked) {
     974            if (magicked <= 0) {
     975                if (!setRunMagicked(config, magic_ds_id)) {
     976                    psError(PS_ERR_UNKNOWN, false, "failed to change stageRun.magicked for magic_ds_id: %" PRId64,
     977                        magic_ds_id);
     978                    if (!psDBRollback(config->dbh)) {
     979                        psError(PS_ERR_UNKNOWN, false, "database error");
     980                    }
     981                    return false;
     982                }
     983            } else {
     984                fprintf(stderr, "run is already marked as destreaked for magic_ds_id %" PRId64 "\n", magic_ds_id);
    968985            }
    969             return false;
    970986        }
    971987
    … …  
    980996            return false;
    981997        }
    982     }
    983     if (!psDBCommit(config->dbh)) {
    984         psError(PS_ERR_UNKNOWN, false, "database error");
    985         return false;
     998        if (!psDBCommit(config->dbh)) {
     999            psError(PS_ERR_UNKNOWN, false, "database error");
     1000            return false;
     1001        }
    9861002    }
    9871003

  • branches/eam_branches/ipp-20100823/ippTools/src/magictool.c

    r28768 r29515  
    5050static bool exposureMode(pxConfig *config);
    5151
    52 static bool setmagicRunState(pxConfig *config, psS64 magic_id, const char *state);
     52static bool setmagicRunState(pxConfig *config, psS64 magic_id, const char *state, psString setString);
    5353static bool parseAndInsertNodeDeps(pxConfig *config, psS64 magic_id, const char *filename);
    5454
    … …  
    131131
    132132    psMetadata *queryWhere = psMetadataAlloc(); // WHERE conditions for everything else
    133     PXOPT_COPY_S64(config->args, queryWhere, "-exp_id", "exp_id", "==");
     133    PXOPT_COPY_S64(config->args, queryWhere, "-exp_id", "rawExp.exp_id", "==");
    134134    PXOPT_COPY_STR(config->args, queryWhere, "-select_filter", "rawExp.filter", "==");
    135135
    … …  
    394394    // required
    395395    PXOPT_LOOKUP_S64(magic_id, config->args, "-magic_id", true, false);
    396     PXOPT_LOOKUP_STR(state, config->args, "-state", true, false);
     396    PXOPT_LOOKUP_STR(state, config->args, "-set_state", true, false);
     397    PXOPT_LOOKUP_S16(fault, config->args, "-set_fault", false, false);
     398    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
     399    PXOPT_LOOKUP_BOOL(clearfault, config->args, "-clearfault", false);
     400
     401    psString setString = NULL;
     402    if (fault || clearfault) {
     403        psStringAppend(&setString, ", fault = %d", fault);
     404    }
     405    if (note) {
     406        psStringAppend(&setString, ", note = '%s'", note);
     407    }
    397408
    398409    if (state) {
    399410        // set detRun.state to state
    400         return setmagicRunState(config, magic_id, state);
     411        return setmagicRunState(config, magic_id, state, setString);
    401412    }
    402413
    … …  
    612623    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
    613624
    614     psString query = psStringCopy("UPDATE magicRun SET fault = 0, state = 'new' WHERE fault != 0");
     625    psString query = psStringCopy("UPDATE magicRun SET fault = 0 WHERE state = 'new' AND fault != 0");
    615626
    616627    if (psListLength(where->list)) {
    … …  
    11711182
    11721183    // optional
    1173     PXOPT_LOOKUP_STR(uri, config->args, "-uri", false, false);
     1184//    PXOPT_LOOKUP_STR(uri, config->args, "-uri", false, false);
     1185    PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", true, false);
    11741186    PXOPT_LOOKUP_S32(streaks, config->args, "-streaks", false, false);
    11751187
    … …  
    11841196    if (!magicMaskInsert(config->dbh,
    11851197                         magic_id,
    1186                          uri,
     1198                         NULL,
     1199                         path_base,
    11871200                         streaks,
    11881201                         fault
    … …  
    13641377}
    13651378
    1366 static bool setmagicRunState(pxConfig *config, psS64 magic_id, const char *state)
     1379static bool setmagicRunState(pxConfig *config, psS64 magic_id, const char *state, psString setString)
    13671380{
    13681381    PS_ASSERT_PTR_NON_NULL(state, false);
    … …  
    13801393        return false;
    13811394    }
    1382 
    1383     char *query = "UPDATE magicRun SET state = '%s' WHERE magic_id = %" PRId64;
    1384     if (!p_psDBRunQueryF(config->dbh, query, state, magic_id)) {
     1395    psString query = NULL;
     1396    psStringAppend(&query, "UPDATE magicRun SET state = '%s'", state);
     1397    if (setString) {
     1398        psStringAppend(&query, setString);
     1399    }
     1400    psStringAppend(&query, " WHERE magic_id = %" PRId64, magic_id);;
     1401
     1402//    char *query = "UPDATE magicRun SET state = '%s' WHERE magic_id = %" PRId64;
     1403    if (!p_psDBRunQuery(config->dbh, query)) {
    13851404        psError(PS_ERR_UNKNOWN, false,
    13861405                "failed to change state for magic_id %" PRId64, magic_id);

  • branches/eam_branches/ipp-20100823/ippTools/src/magictoolConfig.c

    r28039 r29515  
    7979    psMetadata *updaterunArgs = psMetadataAlloc();
    8080    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-magic_id", 0, "define magictool ID (required)", 0);
    81     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0, "set state (required)", NULL);
     81    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state", 0, "set state (required)", NULL);
     82    psMetadataAddS16(updaterunArgs, PS_LIST_TAIL, "-set_fault", 0, "set fault code", 0);
     83    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_note",  0, "define note", NULL);
     84    psMetadataAddBool(updaterunArgs, PS_LIST_TAIL, "-clearfault",  0, "set fault to zero", NULL);
    8285
    8386    // -addinputskyfile
    … …  
    149152    psMetadata *addmaskArgs = psMetadataAlloc();
    150153    psMetadataAddS64(addmaskArgs, PS_LIST_TAIL, "-magic_id", 0, "define magictool ID (required)", 0);
    151     psMetadataAddStr(addmaskArgs, PS_LIST_TAIL, "-uri", 0, "define URI", NULL);
     154    psMetadataAddStr(addmaskArgs, PS_LIST_TAIL, "-path_base", 0, "define path_base (required)", NULL);
    152155    psMetadataAddS32(addmaskArgs, PS_LIST_TAIL, "-streaks", 0, "define number of streaks", 0);
    153156    psMetadataAddS16(addmaskArgs, PS_LIST_TAIL, "-fault", 0, "set fault code", 0);

  • branches/eam_branches/ipp-20100823/ippTools/src/pstamptool.c

    r28937 r29515  
    4646static bool pendingjobMode(pxConfig *config);
    4747static bool updatejobMode(pxConfig *config);
     48static bool stopdependentjobMode(pxConfig *config);
    4849static bool revertjobMode(pxConfig *config);
    4950static bool addprojectMode(pxConfig *config);
    … …  
    6364    break;
    6465
     66// XXX make this a configurable parameter
     67#define PSTAMP_MAX_JOB_FAULTS 5
     68#define PSTAMP_MAX_DEP_FAULTS 5
    6569
    6670int main(int argc, char **argv)
    … …  
    8993        MODECASE(PSTAMPTOOL_MODE_PENDINGJOB, pendingjobMode);
    9094        MODECASE(PSTAMPTOOL_MODE_UPDATEJOB, updatejobMode);
     95        MODECASE(PSTAMPTOOL_MODE_STOPDEPENDENTJOB, stopdependentjobMode);
    9196        MODECASE(PSTAMPTOOL_MODE_REVERTJOB, revertjobMode);
    9297        MODECASE(PSTAMPTOOL_MODE_ADDPROJECT, addprojectMode);
    … …  
    715720            outputBase,
    716721            options,
    717             dep_id
     722            dep_id,
     723            0   // fault_count
    718724            )) {
    719725        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    877883    PXOPT_LOOKUP_S64(req_id,    config->args, "-req_id", false, false);
    878884    PXOPT_LOOKUP_S64(dep_id,    config->args, "-dep_id", false, false);
    879 
    880     if (!job_id && !req_id && !dep_id) {
    881         psError(PS_ERR_UNKNOWN, true, "at least one of -job_id -req_id or -dep_id is required");
     885    PXOPT_LOOKUP_S32(fault_count, config->args, "-fault_count",  false, false);
     886
     887    if (!job_id && !req_id && !dep_id && !fault_count) {
     888        psError(PS_ERR_UNKNOWN, true, "at least one of -job_id -req_id -dep_id or -fault_count is required");
    882889        return false;
    883890    }
    … …  
    898905    PXOPT_COPY_S32(config->args, where, "-fault",  "pstampJob.fault", "==");
    899906    PXOPT_COPY_STR(config->args, where, "-state",  "pstampJob.state", "==");
     907    PXOPT_COPY_S32(config->args, where, "-fault_count", "pstampJob.fault_count", ">=");
     908    pxAddLabelSearchArgs(config, where, "-label", "pstampRequest.label", "LIKE");
    900909
    901910    psString query = pxDataGet("pstamptool_updatejob.sql");
    … …  
    909918        psStringAppend(&query, "\n %c pstampJob.fault = %d", c, fault);
    910919        c = ',';
     920        psStringAppend(&query, ", pstampJob.fault_count = pstampJob.fault_count+ 1");
    911921    }
    912922   
    … …  
    925935    psU64 affected = psDBAffectedRows(config->dbh);
    926936    psLogMsg("pstamptool", PS_LOG_INFO, "Updated %" PRIu64 " pstampJobs", affected);
     937
     938    return true;
     939}
     940// Terminate jobs which have dependents setting both the pstampDependent and pstampJob.fault
     941static bool stopdependentjobMode(pxConfig *config)
     942{
     943    PS_ASSERT_PTR_NON_NULL(config, false);
     944
     945    PXOPT_LOOKUP_S32(fault,  config->args, "-set_fault",  true, false);
     946
     947    psMetadata *where = psMetadataAlloc();
     948
     949    PXOPT_COPY_S64(config->args, where, "-req_id", "req_id", "==");
     950    PXOPT_COPY_S64(config->args, where, "-job_id", "job_id", "==");
     951    PXOPT_COPY_S64(config->args, where, "-dep_id", "dep_id", "==");
     952    PXOPT_COPY_S32(config->args, where, "-fault",  "pstampDependent.fault", "==");
     953    pxAddLabelSearchArgs(config, where, "-label", "pstampRequest.label", "LIKE");
     954    // if (fault_count) {
     955        PXOPT_COPY_S32(config->args, where, "-fault_count", "pstampDependent.fault_count", ">=");
     956    // }
     957
     958    // XXX: How about selecting by pstampRequest.label? No. That is too dangerous by itself.
     959
     960    psString query = pxDataGet("pstamptool_stopdependentjob.sql");
     961
     962    if (psListLength(where->list)) {
     963        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     964        psStringAppend(&query, " AND %s", whereClause);
     965        psFree(whereClause);
     966    } else {
     967        psFree(where);
     968        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     969        return false;
     970    }
     971    psFree(where);
     972
     973    if (!p_psDBRunQueryF(config->dbh, query, fault, fault)) {
     974        psError(PS_ERR_UNKNOWN, false, "database error");
     975        psFree(query);
     976        return false;
     977    }
     978    psFree(query);
     979
     980    psU64 affected = psDBAffectedRows(config->dbh);
     981    psLogMsg("pstamptool", PS_LOG_INFO, "Updated %" PRIu64 " pstampJobs and pstampDependents", affected);
    927982
    928983    return true;
    … …  
    941996    pxAddLabelSearchArgs(config, where, "-label", "pstampRequest.label", "LIKE");
    942997
     998    PXOPT_LOOKUP_BOOL(clear_fault_count, config->args, "-clear_fault_count", false);
     999
    9431000    PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
     1001
     1002    // XXX: we don't actually use -limit. It doesn't work for UPDATE
     1003    // it's an allowed arg because add_poll_args adds it
    9441004    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    9451005    PXOPT_LOOKUP_S16(fault, config->args, "-fault",  false, false);
    … …  
    9471007    // By default only revert faults < PSTAMP_FIRST_ERROR_CODE which are our "ipp exit codes"
    9481008    // codes larger than that are the pstamp request interface.
    949     // Don't fault those unless -fault waa provided
     1009    // Don't fault those unless -fault was explicitly provided
    9501010    psString faultClause = psStringCopy("");
    9511011    if (!fault) {
    … …  
    9661026    psFree(where);
    9671027
    968     if (!p_psDBRunQueryF(config->dbh, query, faultClause)) {
     1028    // don't keep reverting once the number of faults reaches some value unless
     1029    // a parameter asking us to clear that count is provided
     1030    psString faultCountClause = NULL;
     1031    if (clear_fault_count) {
     1032        psStringAppend(&faultCountClause, "\n, pstampJob.fault_count = 0");
     1033    } else {
     1034        psStringAppend(&query, " AND pstampJob.fault_count < %d", PSTAMP_MAX_JOB_FAULTS);
     1035    }
     1036
     1037    if (!p_psDBRunQueryF(config->dbh, query, faultCountClause, faultClause)) {
     1038        psFree(faultCountClause);
    9691039        psFree(faultClause);
    9701040        psFree(query);
    … …  
    9741044
    9751045    psFree(faultClause);
     1046    psFree(faultCountClause);
     1047    psFree(query);
    9761048
    9771049    return true;
    … …  
    11781250        need_magic,
    11791251        outdir,
    1180         0               // fault
     1252        0,              // fault
     1253        0               // fault_count
    11811254        )) {
    11821255        if (!psDBRollback(config->dbh)) {
    … …  
    13001373        psStringAppend(&query, "%s fault = %d", needComma ? ", " : "", fault);
    13011374        needComma = true;
     1375        psStringAppend(&query, ", pstampDependent.fault_count = pstampDependent.fault_count + 1");
    13021376    }
    13031377    psStringAppend(&query, " WHERE dep_id = %" PRId64, dep_id);
    … …  
    13251399    PXOPT_COPY_S64(config->args, where, "-fault", "pstampDependent.fault", "==");
    13261400    PXOPT_COPY_S64(config->args, where, "-dep_id", "dep_id", "==");
     1401    PXOPT_COPY_S64(config->args, where, "-job_id", "job_id", "==");
     1402    PXOPT_COPY_S64(config->args, where, "-req_id", "req_id", "==");
    13271403    pxAddLabelSearchArgs(config, where, "-label", "pstampRequest.label", "==");
     1404    PXOPT_LOOKUP_BOOL(clear_fault_count, config->args, "-clear_fault_count", false);
     1405
     1406    // XXX: we don't actually use -limit. It doesn't work for UPDATE
     1407    // it's an allowed arg because add_poll_args adds it
     1408    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    13281409
    13291410    if (!psListLength(where->list)) {
    … …  
    13521433    }
    13531434
    1354     if (!p_psDBRunQuery(config->dbh, query)) {
     1435    // don't keep reverting once the number of faults reaches some value unless
     1436    // a parameter asking us to clear that count is provided
     1437    psString faultCountClause = NULL;
     1438    if (clear_fault_count) {
     1439        psStringAppend(&faultCountClause, "\n, pstampDependent.fault_count = 0");
     1440    } else {
     1441        psStringAppend(&faultCountClause, " ");
     1442        psStringAppend(&query, " AND pstampDependent.fault_count < %d", PSTAMP_MAX_DEP_FAULTS);
     1443    }
     1444
     1445    if (!p_psDBRunQueryF(config->dbh, query, faultCountClause)) {
    13551446        psError(PS_ERR_UNKNOWN, false, "database error");
    13561447        psFree(query);

  • branches/eam_branches/ipp-20100823/ippTools/src/pstamptool.h

    r28183 r29515  
    3838    PSTAMPTOOL_MODE_LISTJOB,
    3939    PSTAMPTOOL_MODE_PENDINGJOB,
     40    PSTAMPTOOL_MODE_STOPDEPENDENTJOB,
    4041    PSTAMPTOOL_MODE_JOBRESULT,
    4142    PSTAMPTOOL_MODE_UPDATEJOB,

  • branches/eam_branches/ipp-20100823/ippTools/src/pstamptoolConfig.c

    r28937 r29515  
    167167    psMetadataAddStr(updatejobArgs, PS_LIST_TAIL, "-state", 0,             "current state of jobs to update", 0);
    168168    psMetadataAddS16(updatejobArgs, PS_LIST_TAIL, "-fault", 0,             "current value for job fault", 0);
     169    psMetadataAddStr(updatejobArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by pstampJob label (LIKE comparision)", NULL);
     170    psMetadataAddS32(updatejobArgs, PS_LIST_TAIL, "-fault_count", 0,       "select by fault_count (>=)", 0);
    169171    psMetadataAddStr(updatejobArgs, PS_LIST_TAIL, "-set_state", 0,            "new state", NULL);
    170172    psMetadataAddS16(updatejobArgs, PS_LIST_TAIL, "-set_fault", 0,            "new result", 0);
     173    psMetadataAddU64(updatejobArgs, PS_LIST_TAIL, "-limit", 0,      "not used", 0);
     174
     175    // -stopdependentjob
     176    psMetadata *stopdependentjobArgs = psMetadataAlloc();
     177    psMetadataAddS64(stopdependentjobArgs, PS_LIST_TAIL,  "-req_id", 0,       "req_id of jobs to update", 0);
     178    psMetadataAddS64(stopdependentjobArgs, PS_LIST_TAIL,  "-job_id", 0,       "job_id of jobs to update", 0);
     179    psMetadataAddS64(stopdependentjobArgs, PS_LIST_TAIL,  "-dep_id", 0,       "dep_id of jobs to update", 0);
     180    psMetadataAddS16(stopdependentjobArgs, PS_LIST_TAIL,  "-fault", 0,        "current value for dependent fault", 0);
     181    psMetadataAddS32(stopdependentjobArgs, PS_LIST_TAIL,  "-fault_count", 0,   "select by fault_count (>=)", 0);
     182    psMetadataAddS16(stopdependentjobArgs, PS_LIST_TAIL,  "-set_fault", 0,    "new fault value for job and dependent (required)", 0);
     183    psMetadataAddStr(stopdependentjobArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by pstampJob label (LIKE comparision)", NULL);
     184    psMetadataAddU64(stopdependentjobArgs, PS_LIST_TAIL, "-limit", 0,      "not used", 0);
    171185
    172186    // -revertjob
    … …  
    177191    psMetadataAddS16(revertjobArgs, PS_LIST_TAIL, "-fault",  0,     "fault to revert", 0);
    178192    psMetadataAddStr(revertjobArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by pstampRequest label (LIKE comparision)", NULL);
     193    psMetadataAddBool(revertjobArgs, PS_LIST_TAIL, "-clear_fault_count", 0,       "clear job fault count", false);
    179194    psMetadataAddBool(revertjobArgs, PS_LIST_TAIL, "-all", 0,       "revert all faulted jobs", false);
    180     psMetadataAddU64(revertjobArgs, PS_LIST_TAIL, "-limit", 0,      "limit result set to N items", 0);
     195    psMetadataAddU64(revertjobArgs, PS_LIST_TAIL, "-limit", 0,      "not used", 0);
    181196
    182197    // -getdependent
    … …  
    201216    // -revertdependent
    202217    psMetadata *revertdependentArgs = psMetadataAlloc();
    203     psMetadataAddS64(revertdependentArgs, PS_LIST_TAIL, "-dep_id", 0, "define id for dependent", 0);
     218    psMetadataAddS64(revertdependentArgs, PS_LIST_TAIL, "-dep_id", 0, "search by dep_id for dependent", 0);
     219    psMetadataAddS64(revertdependentArgs, PS_LIST_TAIL, "-job_id", 0, "search by job_ idfor dependent", 0);
     220    psMetadataAddS64(revertdependentArgs, PS_LIST_TAIL, "-req_id", 0, "search by req_id for dependent", 0);
    204221    psMetadataAddStr(revertdependentArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK,   "define label for dependent ", NULL);
    205     psMetadataAddS16(revertdependentArgs, PS_LIST_TAIL, "-fault",  0,   "define fault", 0);
     222    psMetadataAddS16(revertdependentArgs, PS_LIST_TAIL, "-fault",  0, "search by dependent fault", 0);
     223    psMetadataAddBool(revertdependentArgs, PS_LIST_TAIL, "-clear_fault_count", 0,       "clear job fault count", false);
     224    psMetadataAddU64(revertdependentArgs, PS_LIST_TAIL, "-limit", 0,  "limit result set to N items", 0);
    206225
    207226    // -pendingdependent
    … …  
    262281    PXOPT_ADD_MODE("-pendingjob",      "", PSTAMPTOOL_MODE_PENDINGJOB,   pendingjobArgs);
    263282    PXOPT_ADD_MODE("-updatejob",       "", PSTAMPTOOL_MODE_UPDATEJOB,    updatejobArgs);
     283    PXOPT_ADD_MODE("-stopdependentjob", "", PSTAMPTOOL_MODE_STOPDEPENDENTJOB,  stopdependentjobArgs);
    264284    PXOPT_ADD_MODE("-revertjob",       "", PSTAMPTOOL_MODE_REVERTJOB,    revertjobArgs);
    265285

  • branches/eam_branches/ipp-20100823/ippTools/src/pubtool.c

    r28494 r29515  
    340340    }
    341341
    342     if (!p_psDBRunQueryF(config->dbh, query, whereClause, whereClause)) {
     342    if (!p_psDBRunQueryF(config->dbh, query, whereClause, whereClause, whereClause)) {
    343343        psError(PS_ERR_UNKNOWN, false, "Database error");
    344344        psFree(whereClause);

  • branches/eam_branches/ipp-20100823/ippTools/src/stacktool.c

    r28681 r29515  
    901901    psFree(where);
    902902
     903    psStringAppend(&query, "\nORDER by priority DESC, stack_id");
     904
    903905    // treat limit == 0 as "no limit"
    904906    if (limit) {
    … …  
    982984    PXOPT_LOOKUP_STR(hostname, config->args, "-hostname", false, false);
    983985    PXOPT_LOOKUP_F32(good_frac, config->args, "-good_frac", false, false);
     986    PXOPT_LOOKUP_F64(mjd_obs, config->args, "-mjd_obs", false, false);
    984987
    985988    PXOPT_LOOKUP_STR(ver_pslib, config->args, "-ver_pslib", false, false);
    … …  
    10471050                               hostname,
    10481051                               good_frac,
     1052                               mjd_obs,
    10491053                               fault,
    10501054                               software_ver,
    … …  
    10941098    psMetadata *where = psMetadataAlloc();
    10951099    PXOPT_COPY_S64(config->args, where, "-stack_id", "stackSumSkyfile.stack_id", "==");
    1096     PXOPT_COPY_STR(config->args, where, "-tess_id", "stackRun.tess_id", "==");
     1100    PXOPT_COPY_STR(config->args, where, "-tess_id", "stackRun.tess_id", "LIKE");
    10971101    PXOPT_COPY_STR(config->args, where, "-skycell_id", "stackRun.skycell_id", "==");
    10981102    PXOPT_COPY_STR(config->args, where, "-filter", "stackRun.filter", "LIKE");
    … …  
    11001104    PXOPT_COPY_STR(config->args, where, "-data_group", "stackRun.data_group", "LIKE");
    11011105    PXOPT_COPY_S16(config->args, where, "-fault", "stackSumSkyfile.fault", "==");
     1106    PXOPT_COPY_F64(config->args, where, "-mjd_obs_begin", "stackSumSkyfile.mjd_obs", ">=");
     1107    PXOPT_COPY_F64(config->args, where, "-mjd_obs_end", "stackSumSkyfile.mjd_obs", "<=");
     1108
    11021109
    11031110//  The following three selectors are incompatible with the sql so omit them

  • branches/eam_branches/ipp-20100823/ippTools/src/stacktoolConfig.c

    r28681 r29515  
    172172    psMetadataAddStr(addsumskyfileArgs, PS_LIST_TAIL, "-hostname", 0,            "define hostname", 0);
    173173    psMetadataAddF32(addsumskyfileArgs, PS_LIST_TAIL, "-good_frac",  0,            "define %% of good pixels", NAN);
     174    psMetadataAddF64(addsumskyfileArgs, PS_LIST_TAIL, "-mjd_obs",  0,            "define mjd_obs (average mjd_obs of inputs)", NAN);
    174175    psMetadataAddS16(addsumskyfileArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code", 0);
    175176    psMetadataAddS16(addsumskyfileArgs, PS_LIST_TAIL, "-quality",  0,            "set quality", 0);
    … …  
    185186    psMetadata *sumskyfileArgs= psMetadataAlloc();
    186187    psMetadataAddS64(sumskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,            "search by stack ID", 0);
    187     psMetadataAddStr(sumskyfileArgs, PS_LIST_TAIL, "-tess_id", 0,            "search by tess ID", 0);
     188    psMetadataAddStr(sumskyfileArgs, PS_LIST_TAIL, "-tess_id", 0,            "search by tess ID (LIKE comparison)", 0);
    188189    psMetadataAddStr(sumskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0,         "search by skycell ID", 0);
    189190#ifdef notdef
    … …  
    196197    psMetadataAddStr(sumskyfileArgs, PS_LIST_TAIL, "-data_group", 0,        "search by stackRun.data_group (LIKE comparison)", NULL);
    197198    psMetadataAddStr(sumskyfileArgs, PS_LIST_TAIL, "-filter", 0,            "search by filter (LIKE comparison)", NULL);
     199    psMetadataAddF64(sumskyfileArgs, PS_LIST_TAIL, "-mjd_obs_begin",  0,      "search by mjd_obs (average mjd_obs of inputs <=)", NAN);
     200    psMetadataAddF64(sumskyfileArgs, PS_LIST_TAIL, "-mjd_obs_end",  0,      "search by mjd_obs (average mjd_obs of inputs>=)", NAN);
    198201    psMetadataAddS16(sumskyfileArgs, PS_LIST_TAIL, "-fault",  0,            "search by fault code", 0);
    199202    psMetadataAddU64(sumskyfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    … …  
    204207    psMetadata *sassskyfileArgs = psMetadataAlloc();
    205208    psMetadataAddS64(sassskyfileArgs, PS_LIST_TAIL, "-sass_id", 0,           "search by stack association ID", 0);
    206     psMetadataAddStr(sassskyfileArgs, PS_LIST_TAIL, "-tess_id", 0,            "search by tess ID", 0);
     209    psMetadataAddStr(sassskyfileArgs, PS_LIST_TAIL, "-tess_id", 0,            "search by tess ID (LIKE comparison)", 0);
    207210    psMetadataAddStr(sassskyfileArgs, PS_LIST_TAIL, "-projection_cell", 0,         "search by projection cell", 0);
    208211

  • branches/eam_branches/ipp-20100823/ippTools/src/warptool.c

    r28375 r29515  
    5252static bool pendingcleanuprunMode(pxConfig *config);
    5353static bool pendingcleanupwarpMode(pxConfig *config);
     54static bool revertcleanupMode(pxConfig *config);
    5455static bool donecleanupMode(pxConfig *config);
    5556static bool tocleanedskyfileMode(pxConfig *config);
    … …  
    107108        MODECASE(WARPTOOL_MODE_PENDINGCLEANUPRUN,  pendingcleanuprunMode);
    108109        MODECASE(WARPTOOL_MODE_PENDINGCLEANUPSKYFILE, pendingcleanupwarpMode);
     110        MODECASE(WARPTOOL_MODE_REVERTCLEANUP,      revertcleanupMode);
    109111        MODECASE(WARPTOOL_MODE_DONECLEANUP,        donecleanupMode);
    110112        MODECASE(WARPTOOL_MODE_TOCLEANEDSKYFILE,   tocleanedskyfileMode);
    … …  
    18051807
    18061808
     1809static bool revertcleanupMode(pxConfig *config)
     1810{
     1811    PS_ASSERT_PTR_NON_NULL(config, false);
     1812
     1813    psMetadata *where = psMetadataAlloc();
     1814    PXOPT_COPY_S64(config->args, where, "-warp_id",    "warpSkyfile.warp_id", "==");
     1815    pxAddLabelSearchArgs (config, where, "-label",     "warpRun.label", "LIKE");
     1816    pxAddLabelSearchArgs (config, where, "-data_group",   "warpRun.data_group", "LIKE");
     1817
     1818    PXOPT_LOOKUP_STR(state, config->args, "-state", false, false);
     1819
     1820    if (!psListLength(where->list)) {
     1821        psFree(where);
     1822        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     1823        return false;
     1824    }
     1825    if (!state) {
     1826        state = "error_cleaned";
     1827    }
     1828    char *newState = NULL;
     1829    if (!strcmp(state, "error_cleaned")) {
     1830        newState = "goto_cleaned";
     1831    } else if (!strcmp(state, "error_purged")) {
     1832        newState = "goto_purged";
     1833    } else if (!strcmp(state, "error_scrubbed")) {
     1834        newState = "goto_scrubbed";
     1835    } else {
     1836        psError(PXTOOLS_ERR_CONFIG, true, "-state must be either error_cleaned, error_purged, or error_scrubbed");
     1837        return false;
     1838    }
     1839
     1840    psString query = pxDataGet("warptool_revertcleanup.sql");
     1841    if (!query) {
     1842        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1843        return false;
     1844    }
     1845
     1846    if (psListLength(where->list)) {
     1847        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1848        psStringAppend(&query, " AND %s", whereClause);
     1849        psFree(whereClause);
     1850    }
     1851    psFree(where);
     1852
     1853    if (!p_psDBRunQueryF(config->dbh, query, newState, state, state)) {
     1854        psError(PS_ERR_UNKNOWN, false, "database error");
     1855        psFree(query);
     1856        return false;
     1857    }
     1858    psFree(query);
     1859
     1860    int numDeleted = psDBAffectedRows(config->dbh);
     1861
     1862    psLogMsg("warptool", PS_LOG_INFO, "Reverted %d warpRuns and warpSkyfiles", numDeleted);
     1863
     1864    return true;
     1865}
    18071866static bool donecleanupMode(pxConfig *config)
    18081867{

  • branches/eam_branches/ipp-20100823/ippTools/src/warptool.h

    r28375 r29515  
    4848    WARPTOOL_MODE_PENDINGCLEANUPRUN,
    4949    WARPTOOL_MODE_PENDINGCLEANUPSKYFILE,
     50    WARPTOOL_MODE_REVERTCLEANUP,
    5051    WARPTOOL_MODE_DONECLEANUP,
    5152    WARPTOOL_MODE_TOCLEANEDSKYFILE,

  • branches/eam_branches/ipp-20100823/ippTools/src/warptoolConfig.c

    r28375 r29515  
    362362    psMetadataAddU64(pendingcleanupskyfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    363363
     364    // -revertcleanup
     365    psMetadata *revertcleanupArgs = psMetadataAlloc();
     366    psMetadataAddS64(revertcleanupArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warptool ID", 0);
     367    psMetadataAddStr(revertcleanupArgs, PS_LIST_TAIL, "-label",  PS_META_DUPLICATE_OK, "search by warpRun label", NULL);
     368    psMetadataAddStr(revertcleanupArgs, PS_LIST_TAIL, "-data_group",  PS_META_DUPLICATE_OK, "search by warpRun data_group", NULL);
     369    psMetadataAddStr(revertcleanupArgs, PS_LIST_TAIL, "-state",  0,            "search by state", NULL);
     370
    364371    // -donecleanup
    365372    psMetadata *donecleanupArgs = psMetadataAlloc();
    … …  
    451458    PXOPT_ADD_MODE("-pendingcleanuprun",     "show runs that need to be cleaned up", WARPTOOL_MODE_PENDINGCLEANUPRUN,    pendingcleanuprunArgs);
    452459    PXOPT_ADD_MODE("-pendingcleanupskyfile", "show runs that need to be cleaned up", WARPTOOL_MODE_PENDINGCLEANUPSKYFILE, pendingcleanupskyfileArgs);
     460    PXOPT_ADD_MODE("-revertcleanup",         "revert cleanup runs with errors",     WARPTOOL_MODE_REVERTCLEANUP,          revertcleanupArgs);
    453461    PXOPT_ADD_MODE("-donecleanup",           "show runs that have been cleaned",     WARPTOOL_MODE_DONECLEANUP,          donecleanupArgs);
    454462    PXOPT_ADD_MODE("-tocleanedskyfile", "set skyfile as cleaned", WARPTOOL_MODE_TOCLEANEDSKYFILE, tocleanedskyfileArgs);
Note: See TracChangeset for help on using the changeset viewer.