<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<!-- Generated by Apache Maven Doxia Site Renderer 1.4 at 2016-07-11 -->
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
    <title>JIRA Report - JIRA Report</title>




   <link type="text/css" rel="stylesheet" href="https://issues.apache.org/jira/s/cfecdb276f634854f3ef915e2e980c31-CDN/en_UK1d6h2j/6332/190/148/_/download/superbatch/css/batch.css" media="all">
<!--[if lte IE 9]>
<link type="text/css" rel="stylesheet" href="https://issues.apache.org/jira/s/d41d8cd98f00b204e9800998ecf8427e-CDN/en_UK1d6h2j/6332/190/148/_/download/superbatch/css/batch.css?conditionalComment=lte+IE+9" media="all">
<![endif]-->
<link type="text/css" rel="stylesheet" href="https://issues.apache.org/jira/s/d41d8cd98f00b204e9800998ecf8427e-CDN/en_UK1d6h2j/6332/190/5.6.7-jira-1/_/download/batch/com.atlassian.auiplugin:aui-experimental-labels/com.atlassian.auiplugin:aui-experimental-labels.css" media="all">
<link type="text/css" rel="stylesheet" href="https://issues.apache.org/jira/s/cfecdb276f634854f3ef915e2e980c31-CDN/en_UK1d6h2j/6332/190/1.0/_/download/batch/jira.webresources:global-static/jira.webresources:global-static.css" media="all">
<script type="text/javascript" src="https://issues.apache.org/jira/s/2e02a4899696752890e3e282eb958888-CDN/en_UK1d6h2j/6332/190/148/_/download/superbatch/js/batch.js?locale=en-UK" ></script>
<script type="text/javascript" src="https://issues.apache.org/jira/s/5bc11c6fdb89668eb7be3b7ab1f0a098-CDN/en_UK1d6h2j/6332/190/2.0.2/_/download/batch/com.atlassian.jira.jira-tzdetect-plugin:tzdetect-lib/com.atlassian.jira.jira-tzdetect-plugin:tzdetect-lib.js?locale=en-UK" ></script>
    <meta name="Date-Revision-yyyymmdd" content="20160711" />
    <meta http-equiv="Content-Language" content="en" />
        
        </head>

<body id="jira" class="aui-layout aui-theme-default page-type-printable">
<header id="previous-view">
    <nav class="aui-toolbar">
        <div class="toolbar-split toolbar-split-right">
            <ul class="toolbar-group">
                <li class="toolbar-item">
                    <a href="https://issues.apache.org/jira/secure/IssueNavigator.jspa?reset=true&jqlQuery=project+%3D+UIMA+AND+fixVersion+%3D+2.1.0-Ducc+ORDER+BY+key+DESC%2C+priority+DESC%2C+created+ASC" class="toolbar-trigger">Back to previous view</a>
                </li>
            </ul>
        </div>
    </nav>
</header>
<div id="printable-content">
<div class="result-header">
    <h3><a href="https://issues.apache.org/jira/secure/IssueNavigator.jspa?reset=true&jqlQuery=project+%3D+UIMA+AND+fixVersion+%3D+2.1.0-Ducc+ORDER+BY+key+DESC%2C+priority+DESC%2C+created+ASC">ASF JIRA</a></h3>
                        
                    
                    
                    
                    
                                        <div class="searcherValue">
    
            <label class="fieldLabel" for="fieldpid">Project:</label><span id="fieldpid" class="fieldValue">
    
                <a href="https://issues.apache.org/jira/browse/UIMA" title="Browse UIMA project">UIMA</a>                    </span></div>

                    
                                    <div class="searcherValue">
    
            <label class="fieldLabel" for="fieldfixfor">Fix Version:</label><span id="fieldfixfor" class="fieldValue">
    
                                                            2.1.0-Ducc                                        </span></div>





                                        <table id="issuetable"  >
                        <thead>
        <tr class="rowHeader">
            
                                                            <th class="colHeaderLink headerrow-issuetype" data-id="issuetype">
                            T
                                                    </th>
                                                
                                                            <th class="colHeaderLink headerrow-issuekey" data-id="issuekey">
                            Key
                                                    </th>
                                                
                                                            <th class="colHeaderLink headerrow-summary" data-id="summary">
                            Summary
                                                    </th>
                                                
                                                            <th class="colHeaderLink headerrow-resolution" data-id="resolution">
                            Resolution
                                                    </th>
                                                                    </tr>
    </thead>
    <tbody>
                    


             

                <tr id="issuerow12989131" rel="12989131" data-issuekey="UIMA-5011" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-5011" href="https://issues.apache.org/jira/browse/UIMA-5011"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-5011" href="https://issues.apache.org/jira/browse/UIMA-5011">UIMA-5011</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-5011" href="https://issues.apache.org/jira/browse/UIMA-5011">Permissions of dd2spring.xsl are wrong</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12988868" rel="12988868" data-issuekey="UIMA-5009" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-5009" href="https://issues.apache.org/jira/browse/UIMA-5009"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-5009" href="https://issues.apache.org/jira/browse/UIMA-5009">UIMA-5009</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-5009" href="https://issues.apache.org/jira/browse/UIMA-5009">Agent cannot access ducc_get_process_swap_usage.sh</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12988702" rel="12988702" data-issuekey="UIMA-5007" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-5007" href="https://issues.apache.org/jira/browse/UIMA-5007"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-5007" href="https://issues.apache.org/jira/browse/UIMA-5007">UIMA-5007</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-5007" href="https://issues.apache.org/jira/browse/UIMA-5007">Jobs using Java7 fail if DUCC uses Java8</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>



                <tr id="issuerow12987885" rel="12987885" data-issuekey="UIMA-5004" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-5004" href="https://issues.apache.org/jira/browse/UIMA-5004"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-5004" href="https://issues.apache.org/jira/browse/UIMA-5004">UIMA-5004</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-5004" href="https://issues.apache.org/jira/browse/UIMA-5004">A junit test fails with Java 8</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>

                <tr id="issuerow12987582" rel="12987582" data-issuekey="UIMA-5003" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-5003" href="https://issues.apache.org/jira/browse/UIMA-5003"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-5003" href="https://issues.apache.org/jira/browse/UIMA-5003">UIMA-5003</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-5003" href="https://issues.apache.org/jira/browse/UIMA-5003">The internal broker used by DD jobs creates many log4j exceptions </a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12987137" rel="12987137" data-issuekey="UIMA-5002" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-5002" href="https://issues.apache.org/jira/browse/UIMA-5002"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-5002" href="https://issues.apache.org/jira/browse/UIMA-5002">UIMA-5002</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-5002" href="https://issues.apache.org/jira/browse/UIMA-5002">Custom DUCC pingers may want to use a different JDK</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12986889" rel="12986889" data-issuekey="UIMA-5001" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-5001" href="https://issues.apache.org/jira/browse/UIMA-5001"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-5001" href="https://issues.apache.org/jira/browse/UIMA-5001">UIMA-5001</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-5001" href="https://issues.apache.org/jira/browse/UIMA-5001">DUCC properties flag to disable use of ssh for &quot;remote&quot; daemons control</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12986888" rel="12986888" data-issuekey="UIMA-5000" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-5000" href="https://issues.apache.org/jira/browse/UIMA-5000"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-5000" href="https://issues.apache.org/jira/browse/UIMA-5000">UIMA-5000</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-5000" href="https://issues.apache.org/jira/browse/UIMA-5000">DUCC properties flag to disable use of ssh for &quot;remote&quot; daemons control</a>
    </p>
</td>
                                            <td class="resolution">    Duplicate
</td>
                    </tr>


                <tr id="issuerow12985746" rel="12985746" data-issuekey="UIMA-4997" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4997" href="https://issues.apache.org/jira/browse/UIMA-4997"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4997" href="https://issues.apache.org/jira/browse/UIMA-4997">UIMA-4997</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4997" href="https://issues.apache.org/jira/browse/UIMA-4997">DUCC scripts rm_reconfigure and vary_on/off fail with the new ActiveMQ</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12984988" rel="12984988" data-issuekey="UIMA-4996" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4996" href="https://issues.apache.org/jira/browse/UIMA-4996"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4996" href="https://issues.apache.org/jira/browse/UIMA-4996">UIMA-4996</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4996" href="https://issues.apache.org/jira/browse/UIMA-4996">DUCC DB does not shutdown when using Java 1.8 (IBM)</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12984551" rel="12984551" data-issuekey="UIMA-4995" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4995" href="https://issues.apache.org/jira/browse/UIMA-4995"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4995" href="https://issues.apache.org/jira/browse/UIMA-4995">UIMA-4995</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4995" href="https://issues.apache.org/jira/browse/UIMA-4995">Service ping interface fails to restart a single service instance</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12984464" rel="12984464" data-issuekey="UIMA-4994" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4994" href="https://issues.apache.org/jira/browse/UIMA-4994"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4994" href="https://issues.apache.org/jira/browse/UIMA-4994">UIMA-4994</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4994" href="https://issues.apache.org/jira/browse/UIMA-4994">Some DUCC administration scripts do not handle errors well</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12984374" rel="12984374" data-issuekey="UIMA-4993" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4993" href="https://issues.apache.org/jira/browse/UIMA-4993"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4993" href="https://issues.apache.org/jira/browse/UIMA-4993">UIMA-4993</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4993" href="https://issues.apache.org/jira/browse/UIMA-4993">UIMA DUCC: agent uses wrong command to create cgroups</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12984372" rel="12984372" data-issuekey="UIMA-4992" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4992" href="https://issues.apache.org/jira/browse/UIMA-4992"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4992" href="https://issues.apache.org/jira/browse/UIMA-4992">UIMA-4992</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4992" href="https://issues.apache.org/jira/browse/UIMA-4992">UIMA DUCC: modify agent to fetch cgroup location from /proc/mounts</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12983927" rel="12983927" data-issuekey="UIMA-4990" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4990" href="https://issues.apache.org/jira/browse/UIMA-4990"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4990" href="https://issues.apache.org/jira/browse/UIMA-4990">UIMA-4990</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4990" href="https://issues.apache.org/jira/browse/UIMA-4990">DUCC&#39;s all_in_one fails with UIMA 2.8.1</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12982715" rel="12982715" data-issuekey="UIMA-4989" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4989" href="https://issues.apache.org/jira/browse/UIMA-4989"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4989" href="https://issues.apache.org/jira/browse/UIMA-4989">UIMA-4989</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4989" href="https://issues.apache.org/jira/browse/UIMA-4989">UIMA-DUCC: Fix problems found by FindBugs</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12979779" rel="12979779" data-issuekey="UIMA-4979" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4979" href="https://issues.apache.org/jira/browse/UIMA-4979"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4979" href="https://issues.apache.org/jira/browse/UIMA-4979">UIMA-4979</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4979" href="https://issues.apache.org/jira/browse/UIMA-4979">DUCC Resource Manager (RM) remove state publication rate configuration remnants</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12979507" rel="12979507" data-issuekey="UIMA-4975" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4975" href="https://issues.apache.org/jira/browse/UIMA-4975"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4975" href="https://issues.apache.org/jira/browse/UIMA-4975">UIMA-4975</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4975" href="https://issues.apache.org/jira/browse/UIMA-4975">DUCC Web Server (WS) Broker page support for AMQ version 5.13.2</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12979366" rel="12979366" data-issuekey="UIMA-4974" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4974" href="https://issues.apache.org/jira/browse/UIMA-4974"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4974" href="https://issues.apache.org/jira/browse/UIMA-4974">UIMA-4974</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4974" href="https://issues.apache.org/jira/browse/UIMA-4974">DUCC Orchestrator (OR) remove abbreviated state publication remnants</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12978837" rel="12978837" data-issuekey="UIMA-4972" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4972" href="https://issues.apache.org/jira/browse/UIMA-4972"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/task.png" height="16" width="16" border="0" align="absmiddle" alt="Task" title="Task - A task that needs to be done."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4972" href="https://issues.apache.org/jira/browse/UIMA-4972">UIMA-4972</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4972" href="https://issues.apache.org/jira/browse/UIMA-4972">UIMA-DUCC: modify uima-as dd2spring.xsl to remove scope=&quot;singleton&quot;</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12977693" rel="12977693" data-issuekey="UIMA-4966" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4966" href="https://issues.apache.org/jira/browse/UIMA-4966"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/task.png" height="16" width="16" border="0" align="absmiddle" alt="Task" title="Task - A task that needs to be done."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4966" href="https://issues.apache.org/jira/browse/UIMA-4966">UIMA-4966</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4966" href="https://issues.apache.org/jira/browse/UIMA-4966">UIMA-DUCC: Prepare DUCC for 2.1.0 release</a>
    </p>
</td>
                                            <td class="resolution">    <em>Unresolved</em>
</td>
                    </tr>


                <tr id="issuerow12976470" rel="12976470" data-issuekey="UIMA-4964" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4964" href="https://issues.apache.org/jira/browse/UIMA-4964"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4964" href="https://issues.apache.org/jira/browse/UIMA-4964">UIMA-4964</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4964" href="https://issues.apache.org/jira/browse/UIMA-4964">DUCC Web Server (WS) should employ more reliable aliveness detection for database &amp; broker</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12976204" rel="12976204" data-issuekey="UIMA-4961" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4961" href="https://issues.apache.org/jira/browse/UIMA-4961"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4961" href="https://issues.apache.org/jira/browse/UIMA-4961">UIMA-4961</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4961" href="https://issues.apache.org/jira/browse/UIMA-4961">DUCC Web Server (WS) main pages should display alerts and/or messages</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12975837" rel="12975837" data-issuekey="UIMA-4960" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4960" href="https://issues.apache.org/jira/browse/UIMA-4960"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4960" href="https://issues.apache.org/jira/browse/UIMA-4960">UIMA-4960</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4960" href="https://issues.apache.org/jira/browse/UIMA-4960">DUCC Web Server (WS) Jobs page may not show fails (init or run) for kill -9&#39;d JP</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12975476" rel="12975476" data-issuekey="UIMA-4956" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4956" href="https://issues.apache.org/jira/browse/UIMA-4956"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4956" href="https://issues.apache.org/jira/browse/UIMA-4956">UIMA-4956</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4956" href="https://issues.apache.org/jira/browse/UIMA-4956">DUCC Job Driver (JD) should warn in JD log if negative performance numbers are encountered</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12974241" rel="12974241" data-issuekey="UIMA-4953" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4953" href="https://issues.apache.org/jira/browse/UIMA-4953"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4953" href="https://issues.apache.org/jira/browse/UIMA-4953">UIMA-4953</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4953" href="https://issues.apache.org/jira/browse/UIMA-4953">UIMA DUCC: pinger should support failover protocol in broker URL</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12974240" rel="12974240" data-issuekey="UIMA-4952" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4952" href="https://issues.apache.org/jira/browse/UIMA-4952"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4952" href="https://issues.apache.org/jira/browse/UIMA-4952">UIMA-4952</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4952" href="https://issues.apache.org/jira/browse/UIMA-4952">UIMA DUCC: pinger should support failover protocol in broker URL</a>
    </p>
</td>
                                            <td class="resolution">    Duplicate
</td>
                    </tr>


                <tr id="issuerow12972818" rel="12972818" data-issuekey="UIMA-4951" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4951" href="https://issues.apache.org/jira/browse/UIMA-4951"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4951" href="https://issues.apache.org/jira/browse/UIMA-4951">UIMA-4951</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4951" href="https://issues.apache.org/jira/browse/UIMA-4951">DUCC Web Server (WS) remove &quot;estimated&quot; hover from Time Init + Run since it is misleading</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12972814" rel="12972814" data-issuekey="UIMA-4950" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4950" href="https://issues.apache.org/jira/browse/UIMA-4950"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4950" href="https://issues.apache.org/jira/browse/UIMA-4950">UIMA-4950</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4950" href="https://issues.apache.org/jira/browse/UIMA-4950">UIMA DUCC: Agent should log more details when testing for cgroups</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12972812" rel="12972812" data-issuekey="UIMA-4949" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4949" href="https://issues.apache.org/jira/browse/UIMA-4949"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4949" href="https://issues.apache.org/jira/browse/UIMA-4949">UIMA-4949</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4949" href="https://issues.apache.org/jira/browse/UIMA-4949">UIMA DUCC: Agent should filter out error msg generated by cgcreate</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12972810" rel="12972810" data-issuekey="UIMA-4948" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4948" href="https://issues.apache.org/jira/browse/UIMA-4948"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4948" href="https://issues.apache.org/jira/browse/UIMA-4948">UIMA-4948</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4948" href="https://issues.apache.org/jira/browse/UIMA-4948">UIMA-DUCC: Agent should use uptime cmd to collect node average cpu load </a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12972808" rel="12972808" data-issuekey="UIMA-4947" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4947" href="https://issues.apache.org/jira/browse/UIMA-4947"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4947" href="https://issues.apache.org/jira/browse/UIMA-4947">UIMA-4947</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4947" href="https://issues.apache.org/jira/browse/UIMA-4947">UIMA-DUCC: Agent should run cgroup test before attempting cleanup</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12972802" rel="12972802" data-issuekey="UIMA-4946" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4946" href="https://issues.apache.org/jira/browse/UIMA-4946"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4946" href="https://issues.apache.org/jira/browse/UIMA-4946">UIMA-4946</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4946" href="https://issues.apache.org/jira/browse/UIMA-4946">DUCC Web Server (WS) file pager should display grabbable un-encoded name of file</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12972219" rel="12972219" data-issuekey="UIMA-4944" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4944" href="https://issues.apache.org/jira/browse/UIMA-4944"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4944" href="https://issues.apache.org/jira/browse/UIMA-4944">UIMA-4944</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4944" href="https://issues.apache.org/jira/browse/UIMA-4944">Restore Cassandra&#39;s check for old Oracle JVMs &amp; report any failures</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12972151" rel="12972151" data-issuekey="UIMA-4943" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4943" href="https://issues.apache.org/jira/browse/UIMA-4943"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4943" href="https://issues.apache.org/jira/browse/UIMA-4943">UIMA-4943</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4943" href="https://issues.apache.org/jira/browse/UIMA-4943">DUCC Web Server (WS) non-DB case uses default Resource Manager quantum only</a>
    </p>
</td>
                                            <td class="resolution">    Won&#39;t Fix
</td>
                    </tr>


                <tr id="issuerow12971610" rel="12971610" data-issuekey="UIMA-4938" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4938" href="https://issues.apache.org/jira/browse/UIMA-4938"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4938" href="https://issues.apache.org/jira/browse/UIMA-4938">UIMA-4938</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4938" href="https://issues.apache.org/jira/browse/UIMA-4938">DUCC Job Driver (JD) erroneously determines: fewer work items available than expected</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12970481" rel="12970481" data-issuekey="UIMA-4937" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4937" href="https://issues.apache.org/jira/browse/UIMA-4937"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4937" href="https://issues.apache.org/jira/browse/UIMA-4937">UIMA-4937</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4937" href="https://issues.apache.org/jira/browse/UIMA-4937">DUCC Resource Manager (RM) exception running rm_qload command</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12970013" rel="12970013" data-issuekey="UIMA-4935" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4935" href="https://issues.apache.org/jira/browse/UIMA-4935"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4935" href="https://issues.apache.org/jira/browse/UIMA-4935">UIMA-4935</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4935" href="https://issues.apache.org/jira/browse/UIMA-4935">Agent reports some JPs as Starting when they have initialized</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12968772" rel="12968772" data-issuekey="UIMA-4931" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4931" href="https://issues.apache.org/jira/browse/UIMA-4931"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4931" href="https://issues.apache.org/jira/browse/UIMA-4931">UIMA-4931</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4931" href="https://issues.apache.org/jira/browse/UIMA-4931">UIMA-DUCC: Fix ConcurrentModificationException in Agent</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12968080" rel="12968080" data-issuekey="UIMA-4930" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4930" href="https://issues.apache.org/jira/browse/UIMA-4930"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4930" href="https://issues.apache.org/jira/browse/UIMA-4930">UIMA-4930</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4930" href="https://issues.apache.org/jira/browse/UIMA-4930">RM gets an NPE if P and NP classes have the same priority</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12967450" rel="12967450" data-issuekey="UIMA-4928" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4928" href="https://issues.apache.org/jira/browse/UIMA-4928"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4928" href="https://issues.apache.org/jira/browse/UIMA-4928">UIMA-4928</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4928" href="https://issues.apache.org/jira/browse/UIMA-4928">Modifications to a service&#39;s autostart parameter are not saved in the DB</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12967430" rel="12967430" data-issuekey="UIMA-4927" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4927" href="https://issues.apache.org/jira/browse/UIMA-4927"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4927" href="https://issues.apache.org/jira/browse/UIMA-4927">UIMA-4927</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4927" href="https://issues.apache.org/jira/browse/UIMA-4927">Update internal UIMA-AS pinger to not use UIMA-AS</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12967429" rel="12967429" data-issuekey="UIMA-4926" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4926" href="https://issues.apache.org/jira/browse/UIMA-4926"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4926" href="https://issues.apache.org/jira/browse/UIMA-4926">UIMA-4926</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4926" href="https://issues.apache.org/jira/browse/UIMA-4926">No need to prompt for passwords when installing DUCC</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12967413" rel="12967413" data-issuekey="UIMA-4925" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4925" href="https://issues.apache.org/jira/browse/UIMA-4925"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4925" href="https://issues.apache.org/jira/browse/UIMA-4925">UIMA-4925</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4925" href="https://issues.apache.org/jira/browse/UIMA-4925">DUCC Agent adds duplicate VM Arguments</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12967216" rel="12967216" data-issuekey="UIMA-4924" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4924" href="https://issues.apache.org/jira/browse/UIMA-4924"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4924" href="https://issues.apache.org/jira/browse/UIMA-4924">UIMA-4924</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4924" href="https://issues.apache.org/jira/browse/UIMA-4924">Re-activate saving of revisionnumber in jars</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12967195" rel="12967195" data-issuekey="UIMA-4923" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4923" href="https://issues.apache.org/jira/browse/UIMA-4923"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4923" href="https://issues.apache.org/jira/browse/UIMA-4923">UIMA-4923</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4923" href="https://issues.apache.org/jira/browse/UIMA-4923">DUCC Web Server (WS) should not display nodes that have been removed from service on Machines page</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12966393" rel="12966393" data-issuekey="UIMA-4922" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4922" href="https://issues.apache.org/jira/browse/UIMA-4922"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4922" href="https://issues.apache.org/jira/browse/UIMA-4922">UIMA-4922</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4922" href="https://issues.apache.org/jira/browse/UIMA-4922">Invalid changes to the DUCC classes file can cause jobs to fail</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12964470" rel="12964470" data-issuekey="UIMA-4913" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4913" href="https://issues.apache.org/jira/browse/UIMA-4913"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4913" href="https://issues.apache.org/jira/browse/UIMA-4913">UIMA-4913</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4913" href="https://issues.apache.org/jira/browse/UIMA-4913">DUCC RM may crash when the usable memory changes on a machine</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12963592" rel="12963592" data-issuekey="UIMA-4912" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4912" href="https://issues.apache.org/jira/browse/UIMA-4912"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4912" href="https://issues.apache.org/jira/browse/UIMA-4912">UIMA-4912</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4912" href="https://issues.apache.org/jira/browse/UIMA-4912">Preemption may not occur if some nodes are offline or unresponsive</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12963060" rel="12963060" data-issuekey="UIMA-4911" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4911" href="https://issues.apache.org/jira/browse/UIMA-4911"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/task.png" height="16" width="16" border="0" align="absmiddle" alt="Task" title="Task - A task that needs to be done."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4911" href="https://issues.apache.org/jira/browse/UIMA-4911">UIMA-4911</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4911" href="https://issues.apache.org/jira/browse/UIMA-4911">Promote ducc from sandbox to the regular project</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12962721" rel="12962721" data-issuekey="UIMA-4910" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4910" href="https://issues.apache.org/jira/browse/UIMA-4910"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4910" href="https://issues.apache.org/jira/browse/UIMA-4910">UIMA-4910</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4910" href="https://issues.apache.org/jira/browse/UIMA-4910">DUCC work submitted to a reserve class may be placed on an offline or unresponsive node</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12961316" rel="12961316" data-issuekey="UIMA-4909" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4909" href="https://issues.apache.org/jira/browse/UIMA-4909"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4909" href="https://issues.apache.org/jira/browse/UIMA-4909">UIMA-4909</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4909" href="https://issues.apache.org/jira/browse/UIMA-4909">DUCC&#39;s all-in-one can exit without saying why</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12960795" rel="12960795" data-issuekey="UIMA-4908" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4908" href="https://issues.apache.org/jira/browse/UIMA-4908"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4908" href="https://issues.apache.org/jira/browse/UIMA-4908">UIMA-4908</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4908" href="https://issues.apache.org/jira/browse/UIMA-4908">DUCC Agent: detached processes in cgroup container not being killed</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12960784" rel="12960784" data-issuekey="UIMA-4907" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4907" href="https://issues.apache.org/jira/browse/UIMA-4907"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4907" href="https://issues.apache.org/jira/browse/UIMA-4907">UIMA-4907</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4907" href="https://issues.apache.org/jira/browse/UIMA-4907">UIMA DUCC: Agent rogue detector not working correctly</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12960420" rel="12960420" data-issuekey="UIMA-4905" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4905" href="https://issues.apache.org/jira/browse/UIMA-4905"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4905" href="https://issues.apache.org/jira/browse/UIMA-4905">UIMA-4905</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4905" href="https://issues.apache.org/jira/browse/UIMA-4905">UIMA DUCC: Agent not providing Reason for failure if JP exits while initializing</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12960418" rel="12960418" data-issuekey="UIMA-4904" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4904" href="https://issues.apache.org/jira/browse/UIMA-4904"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4904" href="https://issues.apache.org/jira/browse/UIMA-4904">UIMA-4904</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4904" href="https://issues.apache.org/jira/browse/UIMA-4904">UIMA DUCC: On SIGTERM the JP should stop communicating with a JD</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12960416" rel="12960416" data-issuekey="UIMA-4903" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4903" href="https://issues.apache.org/jira/browse/UIMA-4903"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4903" href="https://issues.apache.org/jira/browse/UIMA-4903">UIMA-4903</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4903" href="https://issues.apache.org/jira/browse/UIMA-4903">DUCC Orchestrator (OR) Health Monitor fails to detect too many Job Process failures</a>
    </p>
</td>
                                            <td class="resolution">    Not A Problem
</td>
                    </tr>


                <tr id="issuerow12959773" rel="12959773" data-issuekey="UIMA-4902" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4902" href="https://issues.apache.org/jira/browse/UIMA-4902"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4902" href="https://issues.apache.org/jira/browse/UIMA-4902">UIMA-4902</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4902" href="https://issues.apache.org/jira/browse/UIMA-4902">DUCC Job Driver (JD) add programmability feature to built-in error handler</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12959279" rel="12959279" data-issuekey="UIMA-4898" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4898" href="https://issues.apache.org/jira/browse/UIMA-4898"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4898" href="https://issues.apache.org/jira/browse/UIMA-4898">UIMA-4898</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4898" href="https://issues.apache.org/jira/browse/UIMA-4898">UIMA-DUCC: Agent process killer not working </a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12958944" rel="12958944" data-issuekey="UIMA-4896" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4896" href="https://issues.apache.org/jira/browse/UIMA-4896"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4896" href="https://issues.apache.org/jira/browse/UIMA-4896">UIMA-4896</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4896" href="https://issues.apache.org/jira/browse/UIMA-4896">UIMA-DUCC: instrument JP to log more details on negative performance metrics </a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12958591" rel="12958591" data-issuekey="UIMA-4895" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4895" href="https://issues.apache.org/jira/browse/UIMA-4895"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4895" href="https://issues.apache.org/jira/browse/UIMA-4895">UIMA-4895</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4895" href="https://issues.apache.org/jira/browse/UIMA-4895">DUCC Web Server (WS) Utilization value may exceed 100%</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12958470" rel="12958470" data-issuekey="UIMA-4893" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4893" href="https://issues.apache.org/jira/browse/UIMA-4893"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4893" href="https://issues.apache.org/jira/browse/UIMA-4893">UIMA-4893</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4893" href="https://issues.apache.org/jira/browse/UIMA-4893">DUCC Web Server (WS) Machines page may display wrong memory free value</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12957309" rel="12957309" data-issuekey="UIMA-4892" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4892" href="https://issues.apache.org/jira/browse/UIMA-4892"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4892" href="https://issues.apache.org/jira/browse/UIMA-4892">UIMA-4892</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4892" href="https://issues.apache.org/jira/browse/UIMA-4892">DUCC database creates many frequent snapshots of the OR checkpoint</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12956580" rel="12956580" data-issuekey="UIMA-4890" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4890" href="https://issues.apache.org/jira/browse/UIMA-4890"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4890" href="https://issues.apache.org/jira/browse/UIMA-4890">UIMA-4890</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4890" href="https://issues.apache.org/jira/browse/UIMA-4890">DUCC Active MQ Security</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12956232" rel="12956232" data-issuekey="UIMA-4887" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4887" href="https://issues.apache.org/jira/browse/UIMA-4887"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4887" href="https://issues.apache.org/jira/browse/UIMA-4887">UIMA-4887</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4887" href="https://issues.apache.org/jira/browse/UIMA-4887">DUCC Web Server (WS) Reservations page terminate of Managed Reservation is ineffective</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12955007" rel="12955007" data-issuekey="UIMA-4885" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4885" href="https://issues.apache.org/jira/browse/UIMA-4885"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4885" href="https://issues.apache.org/jira/browse/UIMA-4885">UIMA-4885</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4885" href="https://issues.apache.org/jira/browse/UIMA-4885">UIMA DUCC: default.ducc.properties missing cgroup directory property</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12954979" rel="12954979" data-issuekey="UIMA-4884" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4884" href="https://issues.apache.org/jira/browse/UIMA-4884"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4884" href="https://issues.apache.org/jira/browse/UIMA-4884">UIMA-4884</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4884" href="https://issues.apache.org/jira/browse/UIMA-4884">DUCC standardization of environment variables</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12954969" rel="12954969" data-issuekey="UIMA-4882" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4882" href="https://issues.apache.org/jira/browse/UIMA-4882"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4882" href="https://issues.apache.org/jira/browse/UIMA-4882">UIMA-4882</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4882" href="https://issues.apache.org/jira/browse/UIMA-4882">DUCC Resource Manager (RM) does not adequately expand Job Processes (JPs)</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12954951" rel="12954951" data-issuekey="UIMA-4881" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4881" href="https://issues.apache.org/jira/browse/UIMA-4881"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4881" href="https://issues.apache.org/jira/browse/UIMA-4881">UIMA-4881</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4881" href="https://issues.apache.org/jira/browse/UIMA-4881">UIMA DUCC: Optimize JP handling of no work from the JD</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12954605" rel="12954605" data-issuekey="UIMA-4880" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4880" href="https://issues.apache.org/jira/browse/UIMA-4880"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4880" href="https://issues.apache.org/jira/browse/UIMA-4880">UIMA-4880</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4880" href="https://issues.apache.org/jira/browse/UIMA-4880">DUCC JobDriver doesn&#39;t terminate when fewer than expected work-items found</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12954393" rel="12954393" data-issuekey="UIMA-4879" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4879" href="https://issues.apache.org/jira/browse/UIMA-4879"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4879" href="https://issues.apache.org/jira/browse/UIMA-4879">UIMA-4879</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4879" href="https://issues.apache.org/jira/browse/UIMA-4879">DUCC Job Driver (JD) should terminate Job Process (JP) when workitem timeout occurs</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12953850" rel="12953850" data-issuekey="UIMA-4878" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4878" href="https://issues.apache.org/jira/browse/UIMA-4878"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4878" href="https://issues.apache.org/jira/browse/UIMA-4878">UIMA-4878</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4878" href="https://issues.apache.org/jira/browse/UIMA-4878">UIMA-DUCC: Agent not killing a child process if it fails to stop after SIGTERM</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12953281" rel="12953281" data-issuekey="UIMA-4877" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4877" href="https://issues.apache.org/jira/browse/UIMA-4877"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4877" href="https://issues.apache.org/jira/browse/UIMA-4877">UIMA-4877</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4877" href="https://issues.apache.org/jira/browse/UIMA-4877">UIMA-DUCC: Agent sets the state of process to Running </a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12952894" rel="12952894" data-issuekey="UIMA-4875" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4875" href="https://issues.apache.org/jira/browse/UIMA-4875"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4875" href="https://issues.apache.org/jira/browse/UIMA-4875">UIMA-4875</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4875" href="https://issues.apache.org/jira/browse/UIMA-4875">UIMA-DUCC: Increase JP sleep time if JD has no WIs</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12952578" rel="12952578" data-issuekey="UIMA-4874" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4874" href="https://issues.apache.org/jira/browse/UIMA-4874"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4874" href="https://issues.apache.org/jira/browse/UIMA-4874">UIMA-4874</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4874" href="https://issues.apache.org/jira/browse/UIMA-4874">ducc-mon shows a blank scheduling-class field for some services</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12952174" rel="12952174" data-issuekey="UIMA-4872" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4872" href="https://issues.apache.org/jira/browse/UIMA-4872"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4872" href="https://issues.apache.org/jira/browse/UIMA-4872">UIMA-4872</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4872" href="https://issues.apache.org/jira/browse/UIMA-4872">UIMA-DUCC: Agent should not use duccling to run cgroup commands</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12951627" rel="12951627" data-issuekey="UIMA-4869" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4869" href="https://issues.apache.org/jira/browse/UIMA-4869"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/newfeature.png" height="16" width="16" border="0" align="absmiddle" alt="New Feature" title="New Feature - A new feature of the product, which has yet to be developed."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4869" href="https://issues.apache.org/jira/browse/UIMA-4869">UIMA-4869</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4869" href="https://issues.apache.org/jira/browse/UIMA-4869">Provide script to simplify DUCC installation or migration </a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12951564" rel="12951564" data-issuekey="UIMA-4866" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4866" href="https://issues.apache.org/jira/browse/UIMA-4866"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4866" href="https://issues.apache.org/jira/browse/UIMA-4866">UIMA-4866</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4866" href="https://issues.apache.org/jira/browse/UIMA-4866">UIMA DUCC: Agent rogue detector not working</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12951518" rel="12951518" data-issuekey="UIMA-4864" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4864" href="https://issues.apache.org/jira/browse/UIMA-4864"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4864" href="https://issues.apache.org/jira/browse/UIMA-4864">UIMA-4864</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4864" href="https://issues.apache.org/jira/browse/UIMA-4864">UIMA-DUCC: Agent exits when cgroups cgcreate fails</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12951234" rel="12951234" data-issuekey="UIMA-4862" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4862" href="https://issues.apache.org/jira/browse/UIMA-4862"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4862" href="https://issues.apache.org/jira/browse/UIMA-4862">UIMA-4862</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4862" href="https://issues.apache.org/jira/browse/UIMA-4862">UIMA-DUCC: cgcreate fails sometimes when run concurrently</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12951195" rel="12951195" data-issuekey="UIMA-4861" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4861" href="https://issues.apache.org/jira/browse/UIMA-4861"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4861" href="https://issues.apache.org/jira/browse/UIMA-4861">UIMA-4861</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4861" href="https://issues.apache.org/jira/browse/UIMA-4861">When migrating to DUCC 2.1.0 must handle renamed properties</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12951169" rel="12951169" data-issuekey="UIMA-4860" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4860" href="https://issues.apache.org/jira/browse/UIMA-4860"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4860" href="https://issues.apache.org/jira/browse/UIMA-4860">UIMA-4860</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4860" href="https://issues.apache.org/jira/browse/UIMA-4860">DUCC Web Server (WS) System -&gt; Services and Preferences page improvements</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12949881" rel="12949881" data-issuekey="UIMA-4853" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4853" href="https://issues.apache.org/jira/browse/UIMA-4853"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4853" href="https://issues.apache.org/jira/browse/UIMA-4853">UIMA-4853</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4853" href="https://issues.apache.org/jira/browse/UIMA-4853">UIMA-DUCC: Agent should detect OS level and log it</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12949092" rel="12949092" data-issuekey="UIMA-4838" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4838" href="https://issues.apache.org/jira/browse/UIMA-4838"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4838" href="https://issues.apache.org/jira/browse/UIMA-4838">UIMA-4838</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4838" href="https://issues.apache.org/jira/browse/UIMA-4838">Jenkins on Windows does not support POSIX</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12948918" rel="12948918" data-issuekey="UIMA-4835" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4835" href="https://issues.apache.org/jira/browse/UIMA-4835"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4835" href="https://issues.apache.org/jira/browse/UIMA-4835">UIMA-4835</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4835" href="https://issues.apache.org/jira/browse/UIMA-4835">UIMA-DUCC: update ducc.properties and docs to change units on swap threshold</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12948910" rel="12948910" data-issuekey="UIMA-4834" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4834" href="https://issues.apache.org/jira/browse/UIMA-4834"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4834" href="https://issues.apache.org/jira/browse/UIMA-4834">UIMA-4834</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4834" href="https://issues.apache.org/jira/browse/UIMA-4834">DUCC Web Server (WS) sort fields with decimal points need to be marked as class=&quot;sorttable_numeric&quot;</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12948562" rel="12948562" data-issuekey="UIMA-4832" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4832" href="https://issues.apache.org/jira/browse/UIMA-4832"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4832" href="https://issues.apache.org/jira/browse/UIMA-4832">UIMA-4832</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4832" href="https://issues.apache.org/jira/browse/UIMA-4832">Enable remote JMX access to the DB </a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12948489" rel="12948489" data-issuekey="UIMA-4831" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4831" href="https://issues.apache.org/jira/browse/UIMA-4831"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4831" href="https://issues.apache.org/jira/browse/UIMA-4831">UIMA-4831</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4831" href="https://issues.apache.org/jira/browse/UIMA-4831">UIMA DUCC: create test utility to test cgcreate </a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12948443" rel="12948443" data-issuekey="UIMA-4829" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4829" href="https://issues.apache.org/jira/browse/UIMA-4829"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4829" href="https://issues.apache.org/jira/browse/UIMA-4829">UIMA-4829</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4829" href="https://issues.apache.org/jira/browse/UIMA-4829">When a DUCC pinger hangs it is reported as Available</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12948171" rel="12948171" data-issuekey="UIMA-4827" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4827" href="https://issues.apache.org/jira/browse/UIMA-4827"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4827" href="https://issues.apache.org/jira/browse/UIMA-4827">UIMA-4827</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4827" href="https://issues.apache.org/jira/browse/UIMA-4827">ducc-mon specification tab omits boolean properties</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12947804" rel="12947804" data-issuekey="UIMA-4826" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4826" href="https://issues.apache.org/jira/browse/UIMA-4826"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4826" href="https://issues.apache.org/jira/browse/UIMA-4826">UIMA-4826</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4826" href="https://issues.apache.org/jira/browse/UIMA-4826">UIMA-DUCC: Agent should verify results from ps cmd when detecting rogue processes</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12946991" rel="12946991" data-issuekey="UIMA-4821" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4821" href="https://issues.apache.org/jira/browse/UIMA-4821"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4821" href="https://issues.apache.org/jira/browse/UIMA-4821">UIMA-4821</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4821" href="https://issues.apache.org/jira/browse/UIMA-4821">UIMA-DUCC: change dependency on UIMA-AS to ver.2.6.0</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12946273" rel="12946273" data-issuekey="UIMA-4815" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4815" href="https://issues.apache.org/jira/browse/UIMA-4815"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4815" href="https://issues.apache.org/jira/browse/UIMA-4815">UIMA-4815</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4815" href="https://issues.apache.org/jira/browse/UIMA-4815">DUCC Web Server (WS) System -&gt; Classes and Machines page improvements</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12946165" rel="12946165" data-issuekey="UIMA-4814" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4814" href="https://issues.apache.org/jira/browse/UIMA-4814"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4814" href="https://issues.apache.org/jira/browse/UIMA-4814">UIMA-4814</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4814" href="https://issues.apache.org/jira/browse/UIMA-4814">DUCC Orchestrator (OR) Jenkins build failures</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12945503" rel="12945503" data-issuekey="UIMA-4809" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4809" href="https://issues.apache.org/jira/browse/UIMA-4809"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/newfeature.png" height="16" width="16" border="0" align="absmiddle" alt="New Feature" title="New Feature - A new feature of the product, which has yet to be developed."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4809" href="https://issues.apache.org/jira/browse/UIMA-4809">UIMA-4809</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4809" href="https://issues.apache.org/jira/browse/UIMA-4809">UIMA DUCC: Agent should set cgroups swappiness</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12945042" rel="12945042" data-issuekey="UIMA-4808" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4808" href="https://issues.apache.org/jira/browse/UIMA-4808"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4808" href="https://issues.apache.org/jira/browse/UIMA-4808">UIMA-4808</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4808" href="https://issues.apache.org/jira/browse/UIMA-4808">UIMA-DUCC: assembly declares dependency on old htttpcllient</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12943101" rel="12943101" data-issuekey="UIMA-4805" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4805" href="https://issues.apache.org/jira/browse/UIMA-4805"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4805" href="https://issues.apache.org/jira/browse/UIMA-4805">UIMA-4805</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4805" href="https://issues.apache.org/jira/browse/UIMA-4805">Custom DUCC pingers cannot set the environment</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12941200" rel="12941200" data-issuekey="UIMA-4804" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4804" href="https://issues.apache.org/jira/browse/UIMA-4804"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4804" href="https://issues.apache.org/jira/browse/UIMA-4804">UIMA-4804</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4804" href="https://issues.apache.org/jira/browse/UIMA-4804">Drop unused DB tables until redesigned</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12940651" rel="12940651" data-issuekey="UIMA-4802" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4802" href="https://issues.apache.org/jira/browse/UIMA-4802"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4802" href="https://issues.apache.org/jira/browse/UIMA-4802">UIMA-4802</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4802" href="https://issues.apache.org/jira/browse/UIMA-4802">DUCC Web Server (WS) Terminate button confirmation for Managed Reservation incorrectly displays the word &quot;service&quot;</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12940593" rel="12940593" data-issuekey="UIMA-4801" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4801" href="https://issues.apache.org/jira/browse/UIMA-4801"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4801" href="https://issues.apache.org/jira/browse/UIMA-4801">UIMA-4801</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4801" href="https://issues.apache.org/jira/browse/UIMA-4801">DUCC installation process should automatically generate keystore w/o prompting</a>
    </p>
</td>
                                            <td class="resolution">    Duplicate
</td>
                    </tr>


                <tr id="issuerow12939960" rel="12939960" data-issuekey="UIMA-4800" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4800" href="https://issues.apache.org/jira/browse/UIMA-4800"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4800" href="https://issues.apache.org/jira/browse/UIMA-4800">UIMA-4800</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4800" href="https://issues.apache.org/jira/browse/UIMA-4800">CR error causes NPE in DUCC JD</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12939603" rel="12939603" data-issuekey="UIMA-4799" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4799" href="https://issues.apache.org/jira/browse/UIMA-4799"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4799" href="https://issues.apache.org/jira/browse/UIMA-4799">UIMA-4799</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4799" href="https://issues.apache.org/jira/browse/UIMA-4799">DUCC Orchestrator (OR) Service Instance failures are not captured in any user viewable log</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12938836" rel="12938836" data-issuekey="UIMA-4794" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4794" href="https://issues.apache.org/jira/browse/UIMA-4794"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4794" href="https://issues.apache.org/jira/browse/UIMA-4794">UIMA-4794</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4794" href="https://issues.apache.org/jira/browse/UIMA-4794">DUCC Job Driver (JD) does not assure viability (e.g. existence) of user specified AE</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12937885" rel="12937885" data-issuekey="UIMA-4791" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4791" href="https://issues.apache.org/jira/browse/UIMA-4791"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4791" href="https://issues.apache.org/jira/browse/UIMA-4791">UIMA-4791</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4791" href="https://issues.apache.org/jira/browse/UIMA-4791">DUCC Managed Reservation failure to launch</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12936843" rel="12936843" data-issuekey="UIMA-4787" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4787" href="https://issues.apache.org/jira/browse/UIMA-4787"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4787" href="https://issues.apache.org/jira/browse/UIMA-4787">UIMA-4787</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4787" href="https://issues.apache.org/jira/browse/UIMA-4787">Ducc Agent not collecting Child Process Metrics</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12935737" rel="12935737" data-issuekey="UIMA-4779" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4779" href="https://issues.apache.org/jira/browse/UIMA-4779"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4779" href="https://issues.apache.org/jira/browse/UIMA-4779">UIMA-4779</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4779" href="https://issues.apache.org/jira/browse/UIMA-4779">DUCC Orchestrator (OR) remove Exceptions and WARNs</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12935685" rel="12935685" data-issuekey="UIMA-4777" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4777" href="https://issues.apache.org/jira/browse/UIMA-4777"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/task.png" height="16" width="16" border="0" align="absmiddle" alt="Task" title="Task - A task that needs to be done."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4777" href="https://issues.apache.org/jira/browse/UIMA-4777">UIMA-4777</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4777" href="https://issues.apache.org/jira/browse/UIMA-4777">DUCC Internals Documentation</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12935662" rel="12935662" data-issuekey="UIMA-4776" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4776" href="https://issues.apache.org/jira/browse/UIMA-4776"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4776" href="https://issues.apache.org/jira/browse/UIMA-4776">UIMA-4776</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4776" href="https://issues.apache.org/jira/browse/UIMA-4776">DUCC Web Server (WS) should key machines by IP address not host name</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12935214" rel="12935214" data-issuekey="UIMA-4775" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4775" href="https://issues.apache.org/jira/browse/UIMA-4775"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4775" href="https://issues.apache.org/jira/browse/UIMA-4775">UIMA-4775</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4775" href="https://issues.apache.org/jira/browse/UIMA-4775">DUCC Resource Manager (RM) NPE in JobManagerConverter</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12934891" rel="12934891" data-issuekey="UIMA-4774" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4774" href="https://issues.apache.org/jira/browse/UIMA-4774"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4774" href="https://issues.apache.org/jira/browse/UIMA-4774">UIMA-4774</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4774" href="https://issues.apache.org/jira/browse/UIMA-4774">DUCC Web Server (WS) Pgin and Swap columns for (Managed) Reservations page</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12934876" rel="12934876" data-issuekey="UIMA-4773" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4773" href="https://issues.apache.org/jira/browse/UIMA-4773"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4773" href="https://issues.apache.org/jira/browse/UIMA-4773">UIMA-4773</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4773" href="https://issues.apache.org/jira/browse/UIMA-4773">UIMA DUCC: JP throws BindException on startup if port is not available</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12934128" rel="12934128" data-issuekey="UIMA-4770" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4770" href="https://issues.apache.org/jira/browse/UIMA-4770"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4770" href="https://issues.apache.org/jira/browse/UIMA-4770">UIMA-4770</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4770" href="https://issues.apache.org/jira/browse/UIMA-4770">UIMA DUCC: Agent not resetting process %CPU </a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12932869" rel="12932869" data-issuekey="UIMA-4767" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4767" href="https://issues.apache.org/jira/browse/UIMA-4767"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4767" href="https://issues.apache.org/jira/browse/UIMA-4767">UIMA-4767</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4767" href="https://issues.apache.org/jira/browse/UIMA-4767">java-viaducc: improve default description and DUCC memory handling</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12932834" rel="12932834" data-issuekey="UIMA-4765" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4765" href="https://issues.apache.org/jira/browse/UIMA-4765"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4765" href="https://issues.apache.org/jira/browse/UIMA-4765">UIMA-4765</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4765" href="https://issues.apache.org/jira/browse/UIMA-4765">DUCC Job Driver (JD) should limit size of user supplied work item name</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12932829" rel="12932829" data-issuekey="UIMA-4764" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4764" href="https://issues.apache.org/jira/browse/UIMA-4764"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4764" href="https://issues.apache.org/jira/browse/UIMA-4764">UIMA-4764</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4764" href="https://issues.apache.org/jira/browse/UIMA-4764">Service error status is not cleared after a successful restart</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12932715" rel="12932715" data-issuekey="UIMA-4762" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4762" href="https://issues.apache.org/jira/browse/UIMA-4762"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4762" href="https://issues.apache.org/jira/browse/UIMA-4762">UIMA-4762</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4762" href="https://issues.apache.org/jira/browse/UIMA-4762">DUCC Web Server (WS) cannot use colon : in cookie names in Jetty 8 and beyond</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12932424" rel="12932424" data-issuekey="UIMA-4761" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4761" href="https://issues.apache.org/jira/browse/UIMA-4761"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4761" href="https://issues.apache.org/jira/browse/UIMA-4761">UIMA-4761</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4761" href="https://issues.apache.org/jira/browse/UIMA-4761">UIMA-DUCC; Agent should add its PID to Node Metrics publication</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12932152" rel="12932152" data-issuekey="UIMA-4759" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4759" href="https://issues.apache.org/jira/browse/UIMA-4759"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4759" href="https://issues.apache.org/jira/browse/UIMA-4759">UIMA-4759</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4759" href="https://issues.apache.org/jira/browse/UIMA-4759">Provide a way to run architecture-sensitive code on a heterogeneous DUCC cluster</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12931682" rel="12931682" data-issuekey="UIMA-4757" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4757" href="https://issues.apache.org/jira/browse/UIMA-4757"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4757" href="https://issues.apache.org/jira/browse/UIMA-4757">UIMA-4757</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4757" href="https://issues.apache.org/jira/browse/UIMA-4757">DUCC Job Driver (JD) swallows serialization errors?</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12931664" rel="12931664" data-issuekey="UIMA-4755" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4755" href="https://issues.apache.org/jira/browse/UIMA-4755"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4755" href="https://issues.apache.org/jira/browse/UIMA-4755">UIMA-4755</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4755" href="https://issues.apache.org/jira/browse/UIMA-4755">DUCC Web Server (WS) must assure compiled JSP&#39;s are viable</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12931661" rel="12931661" data-issuekey="UIMA-4753" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4753" href="https://issues.apache.org/jira/browse/UIMA-4753"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4753" href="https://issues.apache.org/jira/browse/UIMA-4753">UIMA-4753</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4753" href="https://issues.apache.org/jira/browse/UIMA-4753">DUCC Web Server (WS) displays misleading job reason</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12931604" rel="12931604" data-issuekey="UIMA-4752" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4752" href="https://issues.apache.org/jira/browse/UIMA-4752"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4752" href="https://issues.apache.org/jira/browse/UIMA-4752">UIMA-4752</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4752" href="https://issues.apache.org/jira/browse/UIMA-4752">ducc-mon won&#39;t display a service registry that has ${DUCC_SERVICE_INSTANCE}</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12930298" rel="12930298" data-issuekey="UIMA-4749" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4749" href="https://issues.apache.org/jira/browse/UIMA-4749"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4749" href="https://issues.apache.org/jira/browse/UIMA-4749">UIMA-4749</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4749" href="https://issues.apache.org/jira/browse/UIMA-4749">DUCC Web Server (WS) support for AMQ 5.12.1</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12929947" rel="12929947" data-issuekey="UIMA-4745" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4745" href="https://issues.apache.org/jira/browse/UIMA-4745"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/task.png" height="16" width="16" border="0" align="absmiddle" alt="Task" title="Task - A task that needs to be done."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4745" href="https://issues.apache.org/jira/browse/UIMA-4745">UIMA-4745</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4745" href="https://issues.apache.org/jira/browse/UIMA-4745">DUCC Doc updates for 2.1</a>
    </p>
</td>
                                            <td class="resolution">    <em>Unresolved</em>
</td>
                    </tr>


                <tr id="issuerow12929939" rel="12929939" data-issuekey="UIMA-4744" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4744" href="https://issues.apache.org/jira/browse/UIMA-4744"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4744" href="https://issues.apache.org/jira/browse/UIMA-4744">UIMA-4744</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4744" href="https://issues.apache.org/jira/browse/UIMA-4744">UIMA DUCC: RM admin channel not started after recent Camel upgrade</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12929908" rel="12929908" data-issuekey="UIMA-4742" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4742" href="https://issues.apache.org/jira/browse/UIMA-4742"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/task.png" height="16" width="16" border="0" align="absmiddle" alt="Task" title="Task - A task that needs to be done."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4742" href="https://issues.apache.org/jira/browse/UIMA-4742">UIMA-4742</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4742" href="https://issues.apache.org/jira/browse/UIMA-4742">DUCC RM: Never deallocate non-preemptable shares </a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12929886" rel="12929886" data-issuekey="UIMA-4741" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4741" href="https://issues.apache.org/jira/browse/UIMA-4741"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4741" href="https://issues.apache.org/jira/browse/UIMA-4741">UIMA-4741</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4741" href="https://issues.apache.org/jira/browse/UIMA-4741">DUCC Web Server (WS) when hovering over Done on jobs page (std) dev is always 0.0</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12929842" rel="12929842" data-issuekey="UIMA-4740" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4740" href="https://issues.apache.org/jira/browse/UIMA-4740"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4740" href="https://issues.apache.org/jira/browse/UIMA-4740">UIMA-4740</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4740" href="https://issues.apache.org/jira/browse/UIMA-4740">DUCC Job Driver (JD) neglects to set current thread classloader</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12928673" rel="12928673" data-issuekey="UIMA-4732" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4732" href="https://issues.apache.org/jira/browse/UIMA-4732"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4732" href="https://issues.apache.org/jira/browse/UIMA-4732">UIMA-4732</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4732" href="https://issues.apache.org/jira/browse/UIMA-4732">DUCC Web Server (WS) broker and database are shown as &quot;down&quot; on Daemons page</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12928329" rel="12928329" data-issuekey="UIMA-4730" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4730" href="https://issues.apache.org/jira/browse/UIMA-4730"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4730" href="https://issues.apache.org/jira/browse/UIMA-4730">UIMA-4730</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4730" href="https://issues.apache.org/jira/browse/UIMA-4730">Upgrade UIMA-DUCC to use new UIMA-AS 2.8.1, Jetty and Camel</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12927281" rel="12927281" data-issuekey="UIMA-4726" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4726" href="https://issues.apache.org/jira/browse/UIMA-4726"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4726" href="https://issues.apache.org/jira/browse/UIMA-4726">UIMA-4726</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4726" href="https://issues.apache.org/jira/browse/UIMA-4726">DUCC Web Server (WS) automatic or manual mode incorrectly displayed</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12923855" rel="12923855" data-issuekey="UIMA-4717" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4717" href="https://issues.apache.org/jira/browse/UIMA-4717"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4717" href="https://issues.apache.org/jira/browse/UIMA-4717">UIMA-4717</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4717" href="https://issues.apache.org/jira/browse/UIMA-4717">ducc-mon fails to display log files if there is a &#39;+&#39; in the filename</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12923754" rel="12923754" data-issuekey="UIMA-4716" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4716" href="https://issues.apache.org/jira/browse/UIMA-4716"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4716" href="https://issues.apache.org/jira/browse/UIMA-4716">UIMA-4716</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4716" href="https://issues.apache.org/jira/browse/UIMA-4716">DUCC Web Server (WS) documentation revisions, cosmetics and minor improvements</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12922790" rel="12922790" data-issuekey="UIMA-4713" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4713" href="https://issues.apache.org/jira/browse/UIMA-4713"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4713" href="https://issues.apache.org/jira/browse/UIMA-4713">UIMA-4713</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4713" href="https://issues.apache.org/jira/browse/UIMA-4713">Update UIMA-DUCC javadoc plugin to build with JDK1.8</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12922735" rel="12922735" data-issuekey="UIMA-4712" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4712" href="https://issues.apache.org/jira/browse/UIMA-4712"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4712" href="https://issues.apache.org/jira/browse/UIMA-4712">UIMA-4712</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4712" href="https://issues.apache.org/jira/browse/UIMA-4712">DUCC RM: Prefer horizontal to vertical stacking for Service and AP allocations.</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12922480" rel="12922480" data-issuekey="UIMA-4711" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4711" href="https://issues.apache.org/jira/browse/UIMA-4711"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4711" href="https://issues.apache.org/jira/browse/UIMA-4711">UIMA-4711</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4711" href="https://issues.apache.org/jira/browse/UIMA-4711">Fix typos and spellings in scripts</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12921249" rel="12921249" data-issuekey="UIMA-4705" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4705" href="https://issues.apache.org/jira/browse/UIMA-4705"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4705" href="https://issues.apache.org/jira/browse/UIMA-4705">UIMA-4705</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4705" href="https://issues.apache.org/jira/browse/UIMA-4705">DUCC should provide the means for a security directory other than the user&#39;s home</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12920163" rel="12920163" data-issuekey="UIMA-4704" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4704" href="https://issues.apache.org/jira/browse/UIMA-4704"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4704" href="https://issues.apache.org/jira/browse/UIMA-4704">UIMA-4704</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4704" href="https://issues.apache.org/jira/browse/UIMA-4704">DUCC Web Server (WS) Machine Page support for Database query to determine status</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12914880" rel="12914880" data-issuekey="UIMA-4696" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4696" href="https://issues.apache.org/jira/browse/UIMA-4696"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4696" href="https://issues.apache.org/jira/browse/UIMA-4696">UIMA-4696</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4696" href="https://issues.apache.org/jira/browse/UIMA-4696">The CLI fixup for pre-2.0 services specifies an incorrect directory</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12914650" rel="12914650" data-issuekey="UIMA-4695" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4695" href="https://issues.apache.org/jira/browse/UIMA-4695"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4695" href="https://issues.apache.org/jira/browse/UIMA-4695">UIMA-4695</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4695" href="https://issues.apache.org/jira/browse/UIMA-4695">java-viaducc should return stderr messages on stderr so will be red in Eclipse</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12914235" rel="12914235" data-issuekey="UIMA-4694" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4694" href="https://issues.apache.org/jira/browse/UIMA-4694"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4694" href="https://issues.apache.org/jira/browse/UIMA-4694">UIMA-4694</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4694" href="https://issues.apache.org/jira/browse/UIMA-4694">DUCC Web Server (WS) Daemons page should have rows for Broker and Database (if config&#39;d)</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12913880" rel="12913880" data-issuekey="UIMA-4693" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4693" href="https://issues.apache.org/jira/browse/UIMA-4693"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4693" href="https://issues.apache.org/jira/browse/UIMA-4693">UIMA-4693</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4693" href="https://issues.apache.org/jira/browse/UIMA-4693">DUCC daemon stop() is called twice</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12911158" rel="12911158" data-issuekey="UIMA-4690" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4690" href="https://issues.apache.org/jira/browse/UIMA-4690"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4690" href="https://issues.apache.org/jira/browse/UIMA-4690">UIMA-4690</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4690" href="https://issues.apache.org/jira/browse/UIMA-4690">DUCC service manager hangs when starting a service that has no available resoures</a>
    </p>
</td>
                                            <td class="resolution">    Cannot Reproduce
</td>
                    </tr>


                <tr id="issuerow12911048" rel="12911048" data-issuekey="UIMA-4689" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4689" href="https://issues.apache.org/jira/browse/UIMA-4689"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4689" href="https://issues.apache.org/jira/browse/UIMA-4689">UIMA-4689</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4689" href="https://issues.apache.org/jira/browse/UIMA-4689">DUCC service will not start if registered with --debug option</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12909976" rel="12909976" data-issuekey="UIMA-4686" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4686" href="https://issues.apache.org/jira/browse/UIMA-4686"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4686" href="https://issues.apache.org/jira/browse/UIMA-4686">UIMA-4686</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4686" href="https://issues.apache.org/jira/browse/UIMA-4686">DUCC User Interface (CLI) should pass properties to DispatcherFactory</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12909753" rel="12909753" data-issuekey="UIMA-4684" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4684" href="https://issues.apache.org/jira/browse/UIMA-4684"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4684" href="https://issues.apache.org/jira/browse/UIMA-4684">UIMA-4684</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4684" href="https://issues.apache.org/jira/browse/UIMA-4684">DUCC daemons log-to-file should never give up</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12908019" rel="12908019" data-issuekey="UIMA-4660" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4660" href="https://issues.apache.org/jira/browse/UIMA-4660"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4660" href="https://issues.apache.org/jira/browse/UIMA-4660">UIMA-4660</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4660" href="https://issues.apache.org/jira/browse/UIMA-4660">Improve DUCC JP connection error handling</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12907506" rel="12907506" data-issuekey="UIMA-4658" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4658" href="https://issues.apache.org/jira/browse/UIMA-4658"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4658" href="https://issues.apache.org/jira/browse/UIMA-4658">UIMA-4658</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4658" href="https://issues.apache.org/jira/browse/UIMA-4658">DUCC User Interface (CLI) processing of host &amp; port should be done by DispatcherFactory</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12906856" rel="12906856" data-issuekey="UIMA-4656" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4656" href="https://issues.apache.org/jira/browse/UIMA-4656"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4656" href="https://issues.apache.org/jira/browse/UIMA-4656">UIMA-4656</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4656" href="https://issues.apache.org/jira/browse/UIMA-4656">Start &amp; stop &amp; check scripts don&#39;t handle the broker the same as other daemons</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12906772" rel="12906772" data-issuekey="UIMA-4655" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4655" href="https://issues.apache.org/jira/browse/UIMA-4655"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4655" href="https://issues.apache.org/jira/browse/UIMA-4655">UIMA-4655</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4655" href="https://issues.apache.org/jira/browse/UIMA-4655">Investigate if JD scheduler releases its extra reservations too frequently </a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12906361" rel="12906361" data-issuekey="UIMA-4654" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4654" href="https://issues.apache.org/jira/browse/UIMA-4654"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4654" href="https://issues.apache.org/jira/browse/UIMA-4654">UIMA-4654</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4654" href="https://issues.apache.org/jira/browse/UIMA-4654">DUCC Web Server (WS) does not respond if $DUCC_HOME/logs/webserver directory is missing</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12905628" rel="12905628" data-issuekey="UIMA-4651" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4651" href="https://issues.apache.org/jira/browse/UIMA-4651"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4651" href="https://issues.apache.org/jira/browse/UIMA-4651">UIMA-4651</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4651" href="https://issues.apache.org/jira/browse/UIMA-4651">Avoid duplicate doc-building code</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12905222" rel="12905222" data-issuekey="UIMA-4649" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4649" href="https://issues.apache.org/jira/browse/UIMA-4649"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/task.png" height="16" width="16" border="0" align="absmiddle" alt="Task" title="Task - A task that needs to be done."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4649" href="https://issues.apache.org/jira/browse/UIMA-4649">UIMA-4649</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4649" href="https://issues.apache.org/jira/browse/UIMA-4649">Automate generation / import of DUCC version into ducc documents and code</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12904639" rel="12904639" data-issuekey="UIMA-4647" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4647" href="https://issues.apache.org/jira/browse/UIMA-4647"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4647" href="https://issues.apache.org/jira/browse/UIMA-4647">UIMA-4647</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4647" href="https://issues.apache.org/jira/browse/UIMA-4647">Allow user description for viaducc/java-viaducc</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12904630" rel="12904630" data-issuekey="UIMA-4646" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4646" href="https://issues.apache.org/jira/browse/UIMA-4646"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4646" href="https://issues.apache.org/jira/browse/UIMA-4646">UIMA-4646</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4646" href="https://issues.apache.org/jira/browse/UIMA-4646">DUCC Job Driver (JD) aggregate generator instance should be separable from job driver instance</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12903747" rel="12903747" data-issuekey="UIMA-4645" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4645" href="https://issues.apache.org/jira/browse/UIMA-4645"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4645" href="https://issues.apache.org/jira/browse/UIMA-4645">UIMA-4645</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4645" href="https://issues.apache.org/jira/browse/UIMA-4645">Fix DUCC Agent process metrics collector logging </a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12903407" rel="12903407" data-issuekey="UIMA-4643" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4643" href="https://issues.apache.org/jira/browse/UIMA-4643"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4643" href="https://issues.apache.org/jira/browse/UIMA-4643">UIMA-4643</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4643" href="https://issues.apache.org/jira/browse/UIMA-4643">DUCC Agent logs exceptions while collecting metrics from dead process </a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12903377" rel="12903377" data-issuekey="UIMA-4642" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4642" href="https://issues.apache.org/jira/browse/UIMA-4642"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4642" href="https://issues.apache.org/jira/browse/UIMA-4642">UIMA-4642</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4642" href="https://issues.apache.org/jira/browse/UIMA-4642">DUCC Web Server (WS) Job Details performance tab Summary line is inconsistent</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12903362" rel="12903362" data-issuekey="UIMA-4641" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4641" href="https://issues.apache.org/jira/browse/UIMA-4641"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4641" href="https://issues.apache.org/jira/browse/UIMA-4641">UIMA-4641</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4641" href="https://issues.apache.org/jira/browse/UIMA-4641">Performance summary min/max values change erractically while job is active</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12902993" rel="12902993" data-issuekey="UIMA-4638" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4638" href="https://issues.apache.org/jira/browse/UIMA-4638"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4638" href="https://issues.apache.org/jira/browse/UIMA-4638">UIMA-4638</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4638" href="https://issues.apache.org/jira/browse/UIMA-4638">DUCC Orchestrator (OR) should not use &quot;dead reckoning&quot; to determine if Reservation is for JDs</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12902748" rel="12902748" data-issuekey="UIMA-4637" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4637" href="https://issues.apache.org/jira/browse/UIMA-4637"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4637" href="https://issues.apache.org/jira/browse/UIMA-4637">UIMA-4637</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4637" href="https://issues.apache.org/jira/browse/UIMA-4637">DUCC Agent should test if CPU control is enabled on startup</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12902741" rel="12902741" data-issuekey="UIMA-4636" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4636" href="https://issues.apache.org/jira/browse/UIMA-4636"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4636" href="https://issues.apache.org/jira/browse/UIMA-4636">UIMA-4636</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4636" href="https://issues.apache.org/jira/browse/UIMA-4636">Reduce DUCC Agent logging while AE parts initialize</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12902687" rel="12902687" data-issuekey="UIMA-4634" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4634" href="https://issues.apache.org/jira/browse/UIMA-4634"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4634" href="https://issues.apache.org/jira/browse/UIMA-4634">UIMA-4634</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4634" href="https://issues.apache.org/jira/browse/UIMA-4634">DUCC Web Server (WS) file size is always zero under Job Details processes tab</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12902492" rel="12902492" data-issuekey="UIMA-4632" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4632" href="https://issues.apache.org/jira/browse/UIMA-4632"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4632" href="https://issues.apache.org/jira/browse/UIMA-4632">UIMA-4632</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4632" href="https://issues.apache.org/jira/browse/UIMA-4632">uima-ducc-vm should autostart DUCC demo from crontab when OS system reboots</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12902417" rel="12902417" data-issuekey="UIMA-4630" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4630" href="https://issues.apache.org/jira/browse/UIMA-4630"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4630" href="https://issues.apache.org/jira/browse/UIMA-4630">UIMA-4630</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4630" href="https://issues.apache.org/jira/browse/UIMA-4630">Performance Metrics check of UIMA-AS version should reject the current level</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12901946" rel="12901946" data-issuekey="UIMA-4628" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4628" href="https://issues.apache.org/jira/browse/UIMA-4628"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4628" href="https://issues.apache.org/jira/browse/UIMA-4628">UIMA-4628</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4628" href="https://issues.apache.org/jira/browse/UIMA-4628">DUCC OR should not be required in daemon&#39;s classpath</a>
    </p>
</td>
                                            <td class="resolution">    Duplicate
</td>
                    </tr>


                <tr id="issuerow12901945" rel="12901945" data-issuekey="UIMA-4627" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4627" href="https://issues.apache.org/jira/browse/UIMA-4627"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4627" href="https://issues.apache.org/jira/browse/UIMA-4627">UIMA-4627</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4627" href="https://issues.apache.org/jira/browse/UIMA-4627">Increase camel log level to WARN.</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12901913" rel="12901913" data-issuekey="UIMA-4625" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4625" href="https://issues.apache.org/jira/browse/UIMA-4625"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4625" href="https://issues.apache.org/jira/browse/UIMA-4625">UIMA-4625</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4625" href="https://issues.apache.org/jira/browse/UIMA-4625">Change the option --process_thread_count to --process_pipeline_count</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12901912" rel="12901912" data-issuekey="UIMA-4624" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4624" href="https://issues.apache.org/jira/browse/UIMA-4624"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4624" href="https://issues.apache.org/jira/browse/UIMA-4624">UIMA-4624</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4624" href="https://issues.apache.org/jira/browse/UIMA-4624">DUCC uima-ducc-user project should not use duplicate class/interface names, to avoid confusion</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12901384" rel="12901384" data-issuekey="UIMA-4617" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4617" href="https://issues.apache.org/jira/browse/UIMA-4617"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4617" href="https://issues.apache.org/jira/browse/UIMA-4617">UIMA-4617</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4617" href="https://issues.apache.org/jira/browse/UIMA-4617">DUCC should not take the --log_directory relative to the user&#39;s home directory</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12901371" rel="12901371" data-issuekey="UIMA-4616" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4616" href="https://issues.apache.org/jira/browse/UIMA-4616"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4616" href="https://issues.apache.org/jira/browse/UIMA-4616">UIMA-4616</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4616" href="https://issues.apache.org/jira/browse/UIMA-4616">The uima-ducc-user jar should added to the head of the user&#39;s classpath</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12901370" rel="12901370" data-issuekey="UIMA-4615" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4615" href="https://issues.apache.org/jira/browse/UIMA-4615"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4615" href="https://issues.apache.org/jira/browse/UIMA-4615">UIMA-4615</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4615" href="https://issues.apache.org/jira/browse/UIMA-4615">Sample descriptors should allow multiple deployments so can have more than 1 pipeline per JP</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12901132" rel="12901132" data-issuekey="UIMA-4612" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4612" href="https://issues.apache.org/jira/browse/UIMA-4612"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4612" href="https://issues.apache.org/jira/browse/UIMA-4612">UIMA-4612</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4612" href="https://issues.apache.org/jira/browse/UIMA-4612">DUCC Orchestrator (OR) externalize max threads per process limit to ducc.properties</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12896233" rel="12896233" data-issuekey="UIMA-4611" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4611" href="https://issues.apache.org/jira/browse/UIMA-4611"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4611" href="https://issues.apache.org/jira/browse/UIMA-4611">UIMA-4611</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4611" href="https://issues.apache.org/jira/browse/UIMA-4611">Upgrade WS version display</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12895463" rel="12895463" data-issuekey="UIMA-4610" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4610" href="https://issues.apache.org/jira/browse/UIMA-4610"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4610" href="https://issues.apache.org/jira/browse/UIMA-4610">UIMA-4610</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4610" href="https://issues.apache.org/jira/browse/UIMA-4610">DuccSchedulerClasses still not thread-safe</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12895207" rel="12895207" data-issuekey="UIMA-4608" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4608" href="https://issues.apache.org/jira/browse/UIMA-4608"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4608" href="https://issues.apache.org/jira/browse/UIMA-4608">UIMA-4608</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4608" href="https://issues.apache.org/jira/browse/UIMA-4608">Add SVN revision number to DUCCs jars </a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12895197" rel="12895197" data-issuekey="UIMA-4607" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4607" href="https://issues.apache.org/jira/browse/UIMA-4607"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4607" href="https://issues.apache.org/jira/browse/UIMA-4607">UIMA-4607</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4607" href="https://issues.apache.org/jira/browse/UIMA-4607">Optionally bundle java source code when building DUCC</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12895170" rel="12895170" data-issuekey="UIMA-4606" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4606" href="https://issues.apache.org/jira/browse/UIMA-4606"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4606" href="https://issues.apache.org/jira/browse/UIMA-4606">UIMA-4606</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4606" href="https://issues.apache.org/jira/browse/UIMA-4606">DUCC Webserver needlessly polls history</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12862849" rel="12862849" data-issuekey="UIMA-4598" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4598" href="https://issues.apache.org/jira/browse/UIMA-4598"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4598" href="https://issues.apache.org/jira/browse/UIMA-4598">UIMA-4598</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4598" href="https://issues.apache.org/jira/browse/UIMA-4598">DUCC JP should adjust performance metrics</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12861843" rel="12861843" data-issuekey="UIMA-4588" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4588" href="https://issues.apache.org/jira/browse/UIMA-4588"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4588" href="https://issues.apache.org/jira/browse/UIMA-4588">UIMA-4588</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4588" href="https://issues.apache.org/jira/browse/UIMA-4588">DUCC JPs, APs, and JDs should not listen for events on admin channel</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12861589" rel="12861589" data-issuekey="UIMA-4587" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4587" href="https://issues.apache.org/jira/browse/UIMA-4587"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4587" href="https://issues.apache.org/jira/browse/UIMA-4587">UIMA-4587</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4587" href="https://issues.apache.org/jira/browse/UIMA-4587">DUCC SM race: rapid unregister/deregister can corrupt state.</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12861547" rel="12861547" data-issuekey="UIMA-4586" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4586" href="https://issues.apache.org/jira/browse/UIMA-4586"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4586" href="https://issues.apache.org/jira/browse/UIMA-4586">UIMA-4586</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4586" href="https://issues.apache.org/jira/browse/UIMA-4586">DUCC Job Driver (JD) should provide individual work item performance breakdowns</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12861374" rel="12861374" data-issuekey="UIMA-4585" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4585" href="https://issues.apache.org/jira/browse/UIMA-4585"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4585" href="https://issues.apache.org/jira/browse/UIMA-4585">UIMA-4585</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4585" href="https://issues.apache.org/jira/browse/UIMA-4585">DUCC Agent CPU percentage is wrong when JP spawn child procs</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12860994" rel="12860994" data-issuekey="UIMA-4582" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4582" href="https://issues.apache.org/jira/browse/UIMA-4582"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4582" href="https://issues.apache.org/jira/browse/UIMA-4582">UIMA-4582</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4582" href="https://issues.apache.org/jira/browse/UIMA-4582">The default for process_per_item_time_max is missing from ducc.properties</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12859912" rel="12859912" data-issuekey="UIMA-4578" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4578" href="https://issues.apache.org/jira/browse/UIMA-4578"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4578" href="https://issues.apache.org/jira/browse/UIMA-4578">UIMA-4578</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4578" href="https://issues.apache.org/jira/browse/UIMA-4578">DUCC Agent not killing child processes  </a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12859910" rel="12859910" data-issuekey="UIMA-4577" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4577" href="https://issues.apache.org/jira/browse/UIMA-4577"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/task.png" height="16" width="16" border="0" align="absmiddle" alt="Task" title="Task - A task that needs to be done."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4577" href="https://issues.apache.org/jira/browse/UIMA-4577">UIMA-4577</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4577" href="https://issues.apache.org/jira/browse/UIMA-4577">DUCC Add support for database</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12859705" rel="12859705" data-issuekey="UIMA-4576" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4576" href="https://issues.apache.org/jira/browse/UIMA-4576"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4576" href="https://issues.apache.org/jira/browse/UIMA-4576">UIMA-4576</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4576" href="https://issues.apache.org/jira/browse/UIMA-4576">Sometimes jobs fail with: Missing the -Dducc.deploy.JdURL property</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12859635" rel="12859635" data-issuekey="UIMA-4575" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4575" href="https://issues.apache.org/jira/browse/UIMA-4575"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4575" href="https://issues.apache.org/jira/browse/UIMA-4575">UIMA-4575</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4575" href="https://issues.apache.org/jira/browse/UIMA-4575">DUCC Agent adds duplicate -Dducc.deploy.components to the cmd line</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12859428" rel="12859428" data-issuekey="UIMA-4574" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4574" href="https://issues.apache.org/jira/browse/UIMA-4574"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4574" href="https://issues.apache.org/jira/browse/UIMA-4574">UIMA-4574</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4574" href="https://issues.apache.org/jira/browse/UIMA-4574">DUCC Job Driver (JD) incorrectly calculates values used for WS performance tab</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12858383" rel="12858383" data-issuekey="UIMA-4569" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4569" href="https://issues.apache.org/jira/browse/UIMA-4569"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/task.png" height="16" width="16" border="0" align="absmiddle" alt="Task" title="Task - A task that needs to be done."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4569" href="https://issues.apache.org/jira/browse/UIMA-4569">UIMA-4569</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4569" href="https://issues.apache.org/jira/browse/UIMA-4569">DUCC RM should report allocations in GB instead of number-of-shares</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12857978" rel="12857978" data-issuekey="UIMA-4564" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4564" href="https://issues.apache.org/jira/browse/UIMA-4564"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4564" href="https://issues.apache.org/jira/browse/UIMA-4564">UIMA-4564</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4564" href="https://issues.apache.org/jira/browse/UIMA-4564">When a monitored job is given the state &quot;Assigned&quot; it terminates the job</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12855633" rel="12855633" data-issuekey="UIMA-4555" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4555" href="https://issues.apache.org/jira/browse/UIMA-4555"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4555" href="https://issues.apache.org/jira/browse/UIMA-4555">UIMA-4555</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4555" href="https://issues.apache.org/jira/browse/UIMA-4555">UIMA-DUCC includes two copies of xstream jar</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12849377" rel="12849377" data-issuekey="UIMA-4539" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4539" href="https://issues.apache.org/jira/browse/UIMA-4539"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4539" href="https://issues.apache.org/jira/browse/UIMA-4539">UIMA-4539</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4539" href="https://issues.apache.org/jira/browse/UIMA-4539">DUCC Web Server (WS) 2.1.0 improvements &amp; small fixes</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12848668" rel="12848668" data-issuekey="UIMA-4532" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4532" href="https://issues.apache.org/jira/browse/UIMA-4532"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4532" href="https://issues.apache.org/jira/browse/UIMA-4532">UIMA-4532</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4532" href="https://issues.apache.org/jira/browse/UIMA-4532">DUCC Orchestrator (OR) expunge use of &quot;shares&quot;</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12844263" rel="12844263" data-issuekey="UIMA-4509" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-4509" href="https://issues.apache.org/jira/browse/UIMA-4509"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/bug.png" height="16" width="16" border="0" align="absmiddle" alt="Bug" title="Bug - A problem which impairs or prevents the functions of the product."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-4509" href="https://issues.apache.org/jira/browse/UIMA-4509">UIMA-4509</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-4509" href="https://issues.apache.org/jira/browse/UIMA-4509">The ducc_perf_stats script no longer works</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12734412" rel="12734412" data-issuekey="UIMA-3989" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-3989" href="https://issues.apache.org/jira/browse/UIMA-3989"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-3989" href="https://issues.apache.org/jira/browse/UIMA-3989">UIMA-3989</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-3989" href="https://issues.apache.org/jira/browse/UIMA-3989">DUCC Web Server (WS) Services page Max Records filter not very useful...</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12674806" rel="12674806" data-issuekey="UIMA-3361" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-3361" href="https://issues.apache.org/jira/browse/UIMA-3361"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/improvement.png" height="16" width="16" border="0" align="absmiddle" alt="Improvement" title="Improvement - An improvement or enhancement to an existing feature or task."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-3361" href="https://issues.apache.org/jira/browse/UIMA-3361">UIMA-3361</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-3361" href="https://issues.apache.org/jira/browse/UIMA-3361">DUCC webserver (WS) Machines Page improvements</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>


                <tr id="issuerow12646029" rel="12646029" data-issuekey="UIMA-2869" class="issuerow">
                                            <td class="issuetype">    <a class="issue-link" data-issue-key="UIMA-2869" href="https://issues.apache.org/jira/browse/UIMA-2869"> <img src="https://issues.apache.org/jira/images/icons/issuetypes/newfeature.png" height="16" width="16" border="0" align="absmiddle" alt="New Feature" title="New Feature - A new feature of the product, which has yet to be developed."></a></td>
                                            <td class="issuekey">

    <a class="issue-link" data-issue-key="UIMA-2869" href="https://issues.apache.org/jira/browse/UIMA-2869">UIMA-2869</a>
</td>
                                            <td class="summary"><p>
                <a class="issue-link" data-issue-key="UIMA-2869" href="https://issues.apache.org/jira/browse/UIMA-2869">DUCC Orchestrator (OR) must reject [or queue] job submissions when JD allocation is full so as to not overcommit CGroup</a>
    </p>
</td>
                                            <td class="resolution">    Fixed
</td>
                    </tr>
                </tbody>
    </table>


























</div>
      </div>
    </div>
    <div class="clear">
      <hr/>
    </div>
    <div id="footer">
      <div class="xright">
              Copyright &#169;  All Rights Reserved.      
                    
                  </div>
      <div class="clear">
        <hr/>
      </div>
    </div>
  </body>
</html>
