<!DOCTYPE html>
<!--
 | Generated by Apache Maven Doxia at May 27, 2013
 | Rendered using Apache Maven Fluido Skin 1.3.0
-->
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <meta name="Date-Revision-yyyymmdd" content="20130527" />
    <meta http-equiv="Content-Language" content="en" />
    <title>Archiva Documentation - Release Notes for Archiva 1.4-M4</title>
    <link rel="stylesheet" href="./css/apache-maven-fluido-1.3.0.min.css" />
    <link rel="stylesheet" href="./css/site.css" />
    <link rel="stylesheet" href="./css/print.css" media="print" />

      
    <script type="text/javascript" src="./js/apache-maven-fluido-1.3.0.min.js"></script>

    
              <!-- Google Analytics -->
    <script type="text/javascript">

      var _gaq = _gaq || [];
      _gaq.push(['_setAccount', 'UA-140879-5']);
      _gaq.push(['_trackPageview']);

      (function() {
        var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
        ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
        var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
      })();

    </script>
    </head>
        <body class="topBarDisabled">
          
                
                    
    
        <div class="container-fluid">
          <div id="banner">
        <div class="pull-left">
                                                  <a href="../../" id="bannerLeft">
                                                                                                <img src="../../images/archiva.png"  alt="Apache Archiva"/>
                </a>
                      </div>
        <div class="pull-right">                  <a href="http://www.apache.org/" id="bannerRight">
                                                                                        <img src="http://www.apache.org/images/asf_logo_wide.png"  alt="Apache Software Foundation"/>
                </a>
      </div>
        <div class="clear"><hr/></div>
      </div>

      <div id="breadcrumbs">
        <ul class="breadcrumb">
                
                    
                              <li class="">
                    <a href="http://www.apache.org/" class="externalLink" title="Apache">
        Apache</a>
        </li>
      <li class="divider ">/</li>
                <li class="">
                    <a href="./" title="Apache Archiva">
        Apache Archiva</a>
        </li>
      <li class="divider ">/</li>
            <li class="">
                    <a href="../../index.html" title="Apache Archiva">
        Apache Archiva</a>
        </li>
      <li class="divider ">/</li>
        <li class="">Release Notes for Archiva 1.4-M4</li>
        
                
                    
                  <li id="publishDate" class="pull-right">Last Published: 2013-05-27</li> <li class="divider pull-right">|</li>
              <li id="projectVersion" class="pull-right">Version: 1.4-M4</li>
            
                            </ul>
      </div>

                  
      <div class="row-fluid">
        <div id="leftColumn" class="span2">
          <div class="well sidebar-nav">
                
                    
                <ul class="nav nav-list">
                    <li class="nav-header">Introduction</li>
                                
      <li>
    
                          <a href="quick-start.html" title="Quick Start">
          <i class="none"></i>
        Quick Start</a>
            </li>
                  
      <li>
    
                          <a href="tour/index.html" title="Feature Tour">
          <i class="none"></i>
        Feature Tour</a>
            </li>
                  
      <li class="active">
    
            <a href="#"><i class="none"></i>Release Notes</a>
          </li>
                  
      <li>
    
                          <a href="../../download.html" title="Downloads">
          <i class="none"></i>
        Downloads</a>
            </li>
                              <li class="nav-header">Users Guide</li>
                                
      <li>
    
                          <a href="userguide/browsing.html" title="Browsing">
          <i class="none"></i>
        Browsing</a>
            </li>
                  
      <li>
    
                          <a href="userguide/searching.html" title="Searching">
          <i class="none"></i>
        Searching</a>
            </li>
                  
      <li>
    
                          <a href="userguide/delete-artifact.html" title="Deleting an Artifact">
          <i class="none"></i>
        Deleting an Artifact</a>
            </li>
                  
      <li>
    
                          <a href="userguide/using-repository.html" title="Using as a repository">
          <i class="none"></i>
        Using as a repository</a>
            </li>
                  
      <li>
    
                          <a href="userguide/deploy.html" title="Deploying to repository">
          <i class="none"></i>
        Deploying to repository</a>
            </li>
                  
      <li>
    
                          <a href="userguide/virtual-repositories.html" title="Configuring Virtual Repositories">
          <i class="none"></i>
        Configuring Virtual Repositories</a>
            </li>
                  
      <li>
    
                          <a href="userguide/rss.html" title="Rss Feeds in Archiva">
          <i class="none"></i>
        Rss Feeds in Archiva</a>
            </li>
                              <li class="nav-header">Administrators Guide</li>
                                                                                                                      
      <li>
    
                          <a href="adminguide/installing.html" title="Installing Archiva">
          <i class="icon-chevron-right"></i>
        Installing Archiva</a>
                  </li>
                  
      <li>
    
                          <a href="adminguide/databases.html" title="Databases">
          <i class="none"></i>
        Databases</a>
            </li>
                  
      <li>
    
                          <a href="adminguide/repositories-content-storage.html" title="Repositories Content Storage">
          <i class="none"></i>
        Repositories Content Storage</a>
            </li>
                                                                                                        
      <li>
    
                          <a href="adminguide/security.html" title="Security">
          <i class="icon-chevron-right"></i>
        Security</a>
                  </li>
                                                                                                                                                                                                                                                                          
      <li>
    
                          <a href="adminguide/configuration.html" title="Archiva Configuration">
          <i class="icon-chevron-right"></i>
        Archiva Configuration</a>
                  </li>
                  
      <li>
    
                          <a href="adminguide/webservices/rest.html" title="REST Apis">
          <i class="none"></i>
        REST Apis</a>
            </li>
                  
      <li>
    
                          <a href="adminguide/configuration-files.html" title="Configuration Files">
          <i class="none"></i>
        Configuration Files</a>
            </li>
                  
      <li>
    
                          <a href="adminguide/system-status.html" title="System Status">
          <i class="none"></i>
        System Status</a>
            </li>
                                                                                                        
      <li>
    
                          <a href="adminguide/logging.html" title="Log Files">
          <i class="icon-chevron-right"></i>
        Log Files</a>
                  </li>
                  
      <li>
    
                          <a href="adminguide/reports.html" title="Reports">
          <i class="none"></i>
        Reports</a>
            </li>
                              <li class="nav-header">Customising Archiva</li>
                                
      <li>
    
                          <a href="customising/writing-consumer.html" title="Writing a Consumer Plugin">
          <i class="none"></i>
        Writing a Consumer Plugin</a>
            </li>
                              <li class="nav-header">More Information</li>
                                
      <li>
    
                          <a href="http://cwiki.apache.org/confluence/display/ARCHIVA/Index" class="externalLink" title="Archiva Wiki">
          <i class="none"></i>
        Archiva Wiki</a>
            </li>
                              <li class="nav-header">ASF</li>
                                
      <li>
    
                          <a href="http://www.apache.org/foundation/how-it-works.html" class="externalLink" title="How Apache Works">
          <i class="none"></i>
        How Apache Works</a>
            </li>
                  
      <li>
    
                          <a href="http://www.apache.org/foundation/" class="externalLink" title="Foundation">
          <i class="none"></i>
        Foundation</a>
            </li>
                  
      <li>
    
                          <a href="http://www.apache.org/foundation/sponsorship.html" class="externalLink" title="Sponsoring Apache">
          <i class="none"></i>
        Sponsoring Apache</a>
            </li>
                  
      <li>
    
                          <a href="http://www.apache.org/foundation/thanks.html" class="externalLink" title="Thanks">
          <i class="none"></i>
        Thanks</a>
            </li>
                              <li class="nav-header">Project Documentation</li>
                                                                                                    
      <li>
    
                          <a href="project-info.html" title="Project Information">
          <i class="icon-chevron-right"></i>
        Project Information</a>
                  </li>
            </ul>
                
                    
                            <form id="search-form" action="http://www.google.com/search" method="get" >
    
  <input value="http://archiva.apache.org/docs/1.4-M4/" name="sitesearch" type="hidden"/>
  <input class="search-query" name="q" id="query" type="text" />
</form>
<script type="text/javascript" src="http://www.google.com/coop/cse/brand?form=search-form"></script>
          
          <hr class="divider" />

           <div id="poweredBy">
                            <div class="clear"></div>
                            <div class="clear"></div>
               
        
        
        <div id="twitter">
    
    <a href="https://twitter.com/archiva" class="twitter-follow-button" data-show-count="false" data-align="left" data-size="medium" data-show-screen-name="true" data-lang="en">Follow archiva</a>
    <script type="text/javascript">!function(d,s,id){var js,fjs=d.getElementsByTagName(s)[0];if(!d.getElementById(id)){js=d.createElement(s);js.id=id;js.src="//platform.twitter.com/widgets.js";fjs.parentNode.insertBefore(js,fjs);}}(document,"script","twitter-wjs");</script>

        </div>
                   <div class="clear"></div>
                             <a href="http://maven.apache.org/" title="Built by Maven" class="poweredBy">
        <img class="builtBy" alt="Built by Maven" src="./images/logos/maven-feather.png" />
      </a>
                  </div>
          </div>
        </div>
        
                        
        <div id="bodyColumn"  class="span10" >
                                  
            <!-- Licensed to the Apache Software Foundation (ASF) under one --><!-- or more contributor license agreements.  See the NOTICE file --><!-- distributed with this work for additional information --><!-- regarding copyright ownership.  The ASF licenses this file --><!-- to you under the Apache License, Version 2.0 (the --><!-- "License"); you may not use this file except in compliance --><!-- with the License.  You may obtain a copy of the License at --><!--  --><!-- http://www.apache.org/licenses/LICENSE-2.0 --><!--  --><!-- Unless required by applicable law or agreed to in writing, --><!-- software distributed under the License is distributed on an --><!-- "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY --><!-- KIND, either express or implied.  See the License for the --><!-- specific language governing permissions and limitations --><!-- under the License. --><div class="section"><h2>Release Notes for Archiva 1.4-M4<a name="Release_Notes_for_Archiva_1.4-M4"></a></h2><p>The Apache Archiva team would like to announce the release of Archiva 1.4-M4. Archiva is <a class="externalLink" href="http://archiva.apache.org/download.html"> available for download from the web site</a>.</p><p>Archiva is an application for managing one or more remote repositories, including administration, artifact handling, browsing and searching.</p><p>If you have any questions, please consult:</p><ul><li>the web site: <a class="externalLink" href="http://archiva.apache.org/">http://archiva.apache.org/</a></li><li>the archiva-user mailing list: <a class="externalLink" href="http://archiva.apache.org/mail-lists.html">http://archiva.apache.org/mail-lists.html</a></li></ul><div class="section"><h3>New in Archiva 1.4-M4<a name="New_in_Archiva_1.4-M4"></a></h3><p>Some new features has been added in 1.4-M4:</p><ul><li>There is now a new webapp UI based on javascript (legacy webapp is still distributed). <b>NOTE</b>: most of the UI issues has been fixed in the new UI only.</li></ul></div><div class="section"><h3>Compatibility Changes<a name="Compatibility_Changes"></a></h3><ul><li>If upgrading from earlier versions of Archiva, the list of libraries in <tt>wrapper.conf</tt> has changed. If you have customized your copy of <tt>wrapper.conf</tt>, please update it for compatibility with the version distributed with the current release.</li><li>As the database storage has been removed, you can remove the JNDI entry for <tt>jdbc/archiva</tt>. After upgrading from a previous version, you will have to run a full scan to populate the new JCR Repository. This will be done on first start of Archiva.<p>Refer to the <a href="./adminguide/upgrade.html"> Upgrading Archiva guide</a> for more information.</p></li></ul></div><div class="section"><h3>Release Notes<a name="Release_Notes"></a></h3><p>The Archiva 1.4-M4 features set can be seen in the <a href="./tour/index.html"> feature tour</a>.</p></div><div class="section"><h3>Changes in Archiva 1.4-M4<a name="Changes_in_Archiva_1.4-M4"></a></h3><p>Released: <b>???</b></p><div class="section"><h4>Improvement<a name="Improvement"></a></h4><ul><li>[MRM-526] - cache-failure policy timeout should be easily configurable</li><li>[MRM-862] - Paginate Dependencies Page</li><li>[MRM-863] - Paginate Used By page</li><li>[MRM-1550] - scanner failed with trying to scan maven indexes</li><li>[MRM-1689] - Ability to delete a specific version of an an artifact from the artifact screen</li><li>[MRM-1693] - exposing index downloaded from remote repositories</li><li>[MRM-1699] - Re implement remember me in new UI</li><li>[MRM-1711] - Add buttons for managing repository group as can be a pain with long list of repositories</li><li>[MRM-1712] - Add buttons for managing proxy connectors rules as can be a pain with long list of repositories</li><li>[MRM-1717] - open loginbox when url need authz</li><li>[MRM-1721] - Chaining user manager implementations</li><li>[MRM-1722] - Use cookie settings from redback for rememberme feature</li><li>[MRM-1723] - Provide tooltips for action icons</li><li>[MRM-1726] - merge &quot;Artifacts&quot; and &quot;Artifacts Content&quot;</li><li>[MRM-1727] - SCM Viewer info should provide a link</li><li>[MRM-1731] - Using cache to search users (and must be configurable dynamically) on per default</li><li>[MRM-1734] - add some filtering for searching in users table</li><li>[MRM-1751] - repogroup merged index ttl configurable per repository group</li><li>[MRM-1752] - Graph visualization for dependencies</li><li>[MRM-1760] - Multiple, incompatible, log name formats</li></ul></div><div class="section"><h4>New Feature<a name="New_Feature"></a></h4><ul><li>[MRM-1707] - Allow different implementation of transfer mechanism in the DefaultRepositoryProxyConnectors class</li><li>[MRM-1714] - using LDAP can be configurable with the ui</li><li>[MRM-1718] - ldap configuration editable with the ui.</li><li>[MRM-1732] - dynamic configuration of users cache</li></ul></div><div class="section"><h4>Bug<a name="Bug"></a></h4><ul><li>[MRM-1334] - problem reports appear due to relative path for Archiva repository</li><li>[MRM-1683] - Automatic generation of REST Api documentation</li><li>[MRM-1684] - feeds link behaviour seems not coherent</li><li>[MRM-1687] - artifact browser isn't sorting all items correctly.</li><li>[MRM-1692] - Archiva should allow PropertyPlaceholderConfigurer in applicationContext.xml</li><li>[MRM-1695] - Users from LDAP does not appear in User List</li><li>[MRM-1697] - Confusing behavior when session is lost</li><li>[MRM-1698] - proxy connector update are not saved</li><li>[MRM-1700] - Authentication for remote repositories doesn't work</li><li>[MRM-1701] - metadatas are not removed when a snapshot is purged</li><li>[MRM-1703] - Cannot delete project with the ui</li><li>[MRM-1705] - Feature to add custom parameters and/or headers when requesting an external repositories</li><li>[MRM-1706] - upgrade bootstrap to 2.2.0</li><li>[MRM-1708] - When using LDAP, users can still edit their details upon login</li><li>[MRM-1709] - Default redback admin does not work anymore when using LDAP in the new UI</li><li>[MRM-1710] - errors are not displayed in modal box when reseting password</li><li>[MRM-1713] - users list when using ldap doesn't work</li><li>[MRM-1720] - hard coded limitation of 30 for pageSize in SearchResultLimits</li><li>[MRM-1724] - Cannot manually delete artifacts via web GUI</li><li>[MRM-1725] - truncated line numbers in File Content</li><li>[MRM-1729] - add MetadataRepository#hasMetadataFacet to prevent slow startup time</li><li>[MRM-1730] - upgrade to spring framework 3.2.0</li><li>[MRM-1736] - map roles to ldap groups</li><li>[MRM-1737] - Improve welcome page</li><li>[MRM-1739] - Document installing Archiva as a Mac OS X service with launchd</li><li>[MRM-1740] - implements LDAP user/roles creation</li><li>[MRM-1744] - updating managed repository fail to correctly update maven index directory</li><li>[MRM-1747] - Fail to start on ibm jdk (was8)</li><li>[MRM-1748] - fail to upload supplied POM file</li><li>[MRM-1753] - Number of artifacts type is not displayed in the statistics view</li><li>[MRM-1754] - DownloadMergedIndexNonDefaultPathTest test fail</li><li>[MRM-1755] - [Patch] Activating the dependency tree tab on snapshot artifact fails with NotSuchMethodException</li><li>[MRM-1757] - Unable to download uploaded artifact from repository</li></ul></div><div class="section"><h4>Task<a name="Task"></a></h4><ul><li>[MRM-1627] - Add documentation for Setup archiva with ldap</li><li>[MRM-1686] - stop support of struts2 webapp</li></ul></div><div class="section"><h4>Wish<a name="Wish"></a></h4><ul><li>[MRM-1745] - path of merged index for group configurable</li></ul></div></div></div><div class="section"><h2>Previous Releases<a name="Previous_Releases"></a></h2><div class="section"><h3>Changes in Archiva 1.3.5<a name="Changes_in_Archiva_1.3.5"></a></h3><p>Released: <b>14 March 2011</b></p><div class="section"><h4>Task<a name="Task"></a></h4><ul><li>[MRM-1460] - Upgrade Archiva to Redback 1.2.7</li></ul></div></div><div class="section"><h3>Changes in Archiva 1.3.4<a name="Changes_in_Archiva_1.3.4"></a></h3><p>Released: <b>9 February 2011</b></p><div class="section"><h4>Task<a name="Task"></a></h4><ul><li>[MRM-1455] - upgrade to Redback 1.2.6</li></ul></div></div><div class="section"><h3>Changes in Archiva 1.3.3<a name="Changes_in_Archiva_1.3.3"></a></h3><p>Released: <b>18 December 2010</b></p><div class="section"><h4>Bug<a name="Bug"></a></h4><ul><li>[MRM-1097] - Error 500 &quot;too many open files&quot;</li><li>[MRM-1369] - Editing user roles in archiva clobbers continuum redback roles</li><li>[MRM-1396] - Purge task problem : Not enough parts to the path</li><li>[MRM-1421] - Archiva repository purge incorrectly purges based on file timestamps even when the snapshot timestamp is known</li><li>[MRM-1443] - repository statistics collection can cause server to hang</li></ul></div><div class="section"><h4>Improvement<a name="Improvement"></a></h4><ul><li>[MRM-1416] - upgrade to Redback 1.2.5</li><li>[MRM-1439] - improve indexing performance</li></ul></div><div class="section"><h4>New Feature<a name="New_Feature"></a></h4><ul><li>[MRM-1440] - system status page</li><li>[MRM-1441] - monitor repository scanning progress</li><li>[MRM-1442] - track time spent in each consumer during a scan, to help diagnose poor scanning performance</li></ul></div><div class="section"><h4>Task<a name="Task"></a></h4><ul><li>[MRM-1445] - disable referrer check by default</li></ul></div></div><div class="section"><h3>Changes in Archiva 1.3.2<a name="Changes_in_Archiva_1.3.2"></a></h3><p>Released: <b>29 November 2010</b></p><div class="section"><h4>Bug<a name="Bug"></a></h4><ul><li>[MRM-1438] - CSRF vulnerability - Archiva doesn't check which form sends credentials</li></ul></div></div><div class="section"><h3>Changes in Archiva 1.3.1<a name="Changes_in_Archiva_1.3.1"></a></h3><p>Released: <b>11 June 2010</b></p><div class="section"><h4>Bug<a name="Bug"></a></h4><ul><li>[MRM-1066] - Shutdown of Tomcat causes Exception when running Archiva Project</li><li>[MRM-1302] - java.util.ConcurrentModificationException while running Archiva 1.2.2</li><li>[MRM-1304] - Query using Group ID field in audit log report uses '/' as a separator instead of '.'</li><li>[MRM-1206] - HTTP ERROR: 500 when adding/deleting artifact, adding repository/legacy support/network proxies with null values</li><li>[MRM-1312] - mda5 and sha are not generated for snapshot jars</li><li>[MRM-1314] - Logo still links to incorrect location</li><li>[MRM-1316] - audit log report does not restrict events to repositories that you are a manager of</li><li>[MRM-1320] - Incorrect Archiva version specified for the &quot;Process All Artifacts&quot; feature in upgrade docs</li><li>[MRM-1321] - Snapshot is linking to oldest version in Archiva GUI</li><li>[MRM-1353] - Build number is always 1 for SNAPSHOT artifacts uploaded via web upload form</li><li>[MRM-1355] - Audit log reports user as 'guest' when deployed via WebDAV</li><li>[MRM-1356] - Content Lenght differs : Chunked request</li><li>[MRM-1373] - Archiva fails when default charset in database is UTF 8</li><li>[MRM-1386] - Start Date and End Date calendar pop-up in Audit Log Report page is broken</li></ul></div><div class="section"><h4>Improvement<a name="Improvement"></a></h4><ul><li>[MRM-621] - Use UTF-8 for better i18n support for page dispaly</li><li>[MRM-1310] - Include Audit Log report in feature tour</li></ul></div><div class="section"><h4>New Feature<a name="New_Feature"></a></h4><ul><li>[MRM-1389] - Add support for NPanday artifact types</li></ul></div></div><div class="section"><h3>Changes in Archiva 1.3<a name="Changes_in_Archiva_1.3"></a></h3><p>Released: <b>13 January 2010</b></p><div class="section"><h4>Bug<a name="Bug"></a></h4><ul><li>[MRM-612] - Repository scanning does not recognize newly added artifacts if they have an old timestamp</li><li>[MRM-636] - war:inplace usage is not compatible with cobertura</li><li>[MRM-747] - Archiva should prevent re-deployment of released or non-snapshot versioned artifacts</li><li>[MRM-1033] - Changing the location of a scanned repository results to the contents of the new location not getting indexed</li><li>[MRM-1228] - Ping service in not working</li><li>[MRM-1229] - SearchService.quickSearch doesn't return the same result as the application</li><li>[MRM-1230] - Type of artifact is allways &quot;pom&quot;</li><li>[MRM-1231] - Not authorized to use method with version parameter</li><li>[MRM-1238] - NPE when updating consumers of known content without setting any of the checkboxes (enabled)</li><li>[MRM-1240] - NPE when updating consumers (not setting any of the checkboxes) of Unprocessed Artifacts and Artifact Cleanup Scanning in Database</li><li>[MRM-1243] - Encoding issues with Archiva UI: add Spring CharacterEncodingFilter</li><li>[MRM-1246] - MetadataUpdaterConsumer didn't run during a repository scan after deleting a version of an artifact.</li><li>[MRM-1249] - Archiva does not respect configuration of the index directory</li><li>[MRM-1250] - Granting the Global Repository Manager/System Administrator role does not automatically assign the Global Repository Observer role</li><li>[MRM-1253] - Artifacts cannot be found using the Search function</li><li>[MRM-1259] - 'index-content' consumer processes all types of files, slowing down the indexing process</li><li>[MRM-1265] - .indexer directory should not be scanned</li><li>[MRM-1266] - results page fails when find artifact returns multiple results</li><li>[MRM-1267] - Hide the sub-topics in documentation menu by default</li><li>[MRM-1268] - X-Forwarded-Host handling when having more than one proxy</li><li>[MRM-1272] - Empty Lucene Index</li><li>[MRM-1274] - SearchService.quickSearch returns artifacts with null as repositoryId</li><li>[MRM-1278] - Wrong repository displayed in Archiva browse</li><li>[MRM-1290] - getDependees always returns results for archiva-test in xmlrpc</li><li>[MRM-1294] - repository scan period is incorrect</li><li>[MRM-1305] - Documentation for setting up archiva with tomcat 6 specifies invalid archiva.xml</li></ul></div><div class="section"><h4>Improvement<a name="Improvement"></a></h4><ul><li>[MRM-1056] - Option to force scanning of an artifact/repository regardless of file dates</li><li>[MRM-1251] - Update documentation - Artifacts not displayed in Archiva GUI after release</li><li>[MRM-1262] - m2eclipse index should only be created at end of indexing run</li><li>[MRM-1264] - reduce memory used by indexing process</li><li>[MRM-1270] - Improve message when a user tries to search and the user does not have access to any repository</li><li>[MRM-1275] - Include other file types for the index consumer instead of just the indexable-content</li></ul></div><div class="section"><h4>New Feature<a name="New_Feature"></a></h4><ul><li>[MRM-1185] - Archiva Reporting Modification Request</li><li>[MRM-1296] - Audit logging report</li></ul></div><div class="section"><h4>Task<a name="Task"></a></h4><ul><li>[MRM-1080] - Update SearchServiceImplTest so that it uses the new search API</li><li>[MRM-1123] - ensure all nexus indexer dependencies are in central or built in to JAR appropriately</li><li>[MRM-1164] - Fix the Selenium tests</li><li>[MRM-1254] - Add more unit tests for searching artifacts</li><li>[MRM-1277] - Create Selenium test for advanced search feature</li><li>[MRM-1281] - remove unused consumers</li><li>[MRM-1289] - need to document changes to wrapper.conf on upgrade</li><li>[MRM-1306] - upgrade to jQuery UI 1.7.2 and jQuery 1.3.2</li><li>[MRM-1309] - Upgrade to Redback 1.2.3</li></ul></div><div class="section"><h4>Test<a name="Test"></a></h4><ul><li>[MRM-1241] - Selenium Tests for Repository Scanning and Database</li><li>[MRM-1257] - Selenium Test for accessing bundled repositories</li></ul></div></div><div class="section"><h3>Changes in Archiva 1.2.2<a name="Changes_in_Archiva_1.2.2"></a></h3><p>Released: <b>27 August 2009</b></p><div class="section"><h4>Bug<a name="Bug"></a></h4><ul><li>[MRM-1002] - Website navigation links don't work as expected</li><li>[MRM-1085] - CLONE -Failing to startup due to invalid bean definition</li><li>[MRM-1141] - archiva-cli no longer works</li><li>[MRM-1151] - Error when processing file nexus-maven-repository-index.zip</li><li>[MRM-1155] - m2eclipse - getting index from archiva 1.2 failed</li><li>[MRM-1168] - A locked user gets HTTP ERROR 500 page when logging in Artifact Repository page</li><li>[MRM-1171] - Archiva 1.2 - Internet Explorer - Search - Anvanced Search - Advanced Search Fields - Add Search Field (green +)</li><li>[MRM-1194] - Archiva doesn't cope with versions in a pom.xml that are properties</li><li>[MRM-1196] - checksums are not updated when artifact is re-uploaded</li><li>[MRM-1197] - Random 400 Error when uploading maven-metadata.xml to Archiva 1.2/1.2.1</li><li>[MRM-1198] - field length for ARCHIVA_SCM.URL is too short</li><li>[MRM-1202] - 404 error when changing password</li><li>[MRM-1204] - org.apache.maven.archiva.repository.project.ProjectModelMerge.merge throws NPE</li><li>[MRM-1212] - create-missing-checksums and metadata-updater sometimes causes deployments to fail for large projects when enabled</li><li>[MRM-1217] - upgrade standalone bundle to Jetty 6.1.19</li><li>[MRM-1220] - disable Struts devMode</li><li>[MRM-1232] - Unable to get artifacts from repositories which requires Repository Manager role using repository group</li><li>[MRM-1234] - Typo in Appearance Page</li><li>[MRM-1236] - Locale selection is broken</li><li>[MRM-1239] - Unable to get artifact-level maven-metadata.xml of artifacts that are only three directory levels deep</li></ul></div><div class="section"><h4>Improvement<a name="Improvement"></a></h4><ul><li>[MRM-1163] - Add some decent logs in webdav for debugging purposes</li><li>[MRM-1191] - Add Archiva log files in documentation</li><li>[MRM-1214] - Web Application Deployment, Troubleshooting</li></ul></div><div class="section"><h4>Task<a name="Task"></a></h4><ul><li>[MRM-1182] - Clarify 'delete released snapshots' functionality</li><li>[MRM-1207] - Make wrapper.log roll each day so it won't get too large</li><li>[MRM-1216] - Logging conflict on startup in Jetty bundle</li><li>[MRM-1218] - upgrade to JSP 2.1</li><li>[MRM-1219] - Missing appenders in log4j configuration</li></ul></div><div class="section"><h4>Test<a name="Test"></a></h4><ul><li>[MRM-1226] - Selenium tests for Repositories and Network Proxies</li></ul></div></div><div class="section"><h3>Changes in Archiva 1.2.1<a name="Changes_in_Archiva_1.2.1"></a></h3><p>Released: <b>24 May 2009</b></p><div class="section"><h4>Bug<a name="Bug"></a></h4><ul><li>[MRM-1143] - Nexus indexer throws NPE on repository scan</li><li>[MRM-1157] - Update from 1.1.3 to 1.2 fails with create table error</li><li>[MRM-1160] - Nexus Indexer throws NPE intermittently on retrieval</li><li>[MRM-1161] - indexing causes NullPointer when getting a SNAPSHOT that has been deployed with maven 2.1</li><li>[MRM-1167] - Quicksearch from the xmlrpc api returns no results</li><li>[MRM-1172] - Invalid version validation error when uploading a jar with a four-part version number</li><li>[MRM-1176] - SQLSyntaxErrorException is thrown when browsing for artifacts after upgrading from 1.3.1 to 1.2</li><li>[MRM-1179] - NPE retrieving artifacts via http/webdav that are proxied</li><li>[MRM-1188] - Index cleanup consumer fails when there is a current indexing task being executed (e.g. during repo scan, during artifact deployment or during proxy)</li></ul></div><div class="section"><h4>Improvement<a name="Improvement"></a></h4><ul><li>[MRM-1165] - Move out upgrade instructions from 'Installing Standalone' into it's own page</li></ul></div></div><div class="section"><h3>Changes in Archiva 1.2<a name="Changes_in_Archiva_1.2"></a></h3><p>Released: <b>22 March 2009</b></p><div class="section"><h4>Sub-task<a name="Sub-task"></a></h4><ul><li>[MRM-1038] - merge versions in search results</li><li>[MRM-1039] - remove metadata files from search results</li><li>[MRM-1040] - for snapshots in search results just show SNAPSHOT, not timestamps</li><li>[MRM-1041] - artifact version list should show basic shared project information rather than having to drill into one version</li><li>[MRM-1042] - snapshot should go to a page that shows a list of versions (go to latest, but list previous snapshots)</li><li>[MRM-1043] - improve appearance and flexibility of Advanced search (maybe change to &quot;add term&quot; buttons on the default search)</li><li>[MRM-1044] - class/package search is still flaky</li><li>[MRM-1046] - Write some decent tests for SearchAction</li></ul></div><div class="section"><h4>Bug<a name="Bug"></a></h4><ul><li>[MRM-609] - Search results contains links with &#160;characters in them on Windows</li><li>[MRM-616] - When running on IBM JDK 1.5: java.security.NoSuchProviderException: no such provider: SUN</li><li>[MRM-731] - variable in url pom are not replaced.</li><li>[MRM-836] - The organization is incorrect when displaying an artifacts's Info via browsing or searching.</li><li>[MRM-842] - Issue tracker is incorrect when displaying an artifacts's Info via browsing or searching.</li><li>[MRM-901] - Repository groups does not display groups that have the same groupId</li><li>[MRM-921] - user management role does not display the user management menu</li><li>[MRM-922] - access to upload page with managed repository role</li><li>[MRM-933] - Incorrect search results hit count (ex. Hits: -6 to 23 of 39) for bytecode search</li><li>[MRM-962] - Upload Artifact action should trim its fields</li><li>[MRM-989] - download-type-javadoc.png is missing</li><li>[MRM-996] - HttpProxyTransferTest fails on Windows</li><li>[MRM-1000] - AdministrationServiceImplTest fails on Windows</li><li>[MRM-1004] - RepositoryServlet tests fail intermittently on Windows</li><li>[MRM-1011] - Organisation link on logo points to somewhere</li><li>[MRM-1013] - Fresh installation of Archiva with LDAP authentication does not survive restart of the servlet container</li><li>[MRM-1020] - Fix the crazy alpaca on Windows</li><li>[MRM-1027] - Indices are not cleaned up when deleting artifact via web services</li><li>[MRM-1028] - Find Artifact doesn't show up in the navigation menu after migration to struts 2</li><li>[MRM-1032] - Pick Report - Repository Statistics: End Date can be set earlier than Start Date</li><li>[MRM-1034] - Browse artifact error does not show correct error message</li><li>[MRM-1047] - Archiva allows deployment by user with expired password</li><li>[MRM-1050] - Unable to remove user</li><li>[MRM-1057] - Archiva user-admin should be able to view useredit after logging in from &quot;Security Alert&quot; page</li><li>[MRM-1062] - Find Artifact broken</li><li>[MRM-1073] - Errors on when upgrading from v1.1.3 to v1.2-M1</li><li>[MRM-1075] - Error 500 when accessing repository url</li><li>[MRM-1076] - NPE in NexusIndexConsumer when executed when an artifact is deployed in the Archiva repository</li><li>[MRM-1092] - Typo in Search results page</li><li>[MRM-1095] - Archiva keeps scanning repositories, even if scanning disabled in the web UI</li><li>[MRM-1096] - No icon for maven-plugin on artifact-details view.</li><li>[MRM-1101] - Audit log shows user guest when deploying files from Maven</li><li>[MRM-1105] - Legacy artifact path not properly stored when entered from Archiva UI</li><li>[MRM-1106] - NPE when starting Archiva</li><li>[MRM-1108] - empty logoLocation can be set for the organisation, but does not show the default logo</li><li>[MRM-1109] - environment checks do not indicate which caused a violation</li><li>[MRM-1110] - some redback log statements are not visible in Archiva logs</li><li>[MRM-1117] - move advanced search out of the 'info' popup on the quick search page</li><li>[MRM-1121] - NPE in browse at artifact level</li><li>[MRM-1122] - reduce verbosity of logging during scanning</li><li>[MRM-1133] - delete artifact role not added on upgrade from previous version</li><li>[MRM-1135] - Cannot remove a whitelist entry containing backslashes</li><li>[MRM-1136] - Archiva don't want to download a snapshot of a maven plugin (merged metadata are empty)</li><li>[MRM-1137] - Cannot upload artifact to WEB UI any more</li><li>[MRM-1138] - Fix java.lang.NullPointerException: configuration can not be null on startup</li><li>[MRM-1139] - war:inplace blindly copies everything (including WEB-INF/lib/**) into the archiva-webapp.</li><li>[MRM-1140] - centralise logging through slf4j</li><li>[MRM-1147] - handling leading / on whitelists is ambiguous</li></ul></div><div class="section"><h4>Improvement<a name="Improvement"></a></h4><ul><li>[MRM-176] - prevent potential out of memory problems in large search results</li><li>[MRM-732] - search should tokenize on a hypthen</li><li>[MRM-737] - Don't list metadata files in the search results</li><li>[MRM-799] - Better handling of artifacts with missing poms</li><li>[MRM-937] - Rename audit.log to archiva-audit.log to avoid conflicts</li><li>[MRM-975] - Refresh of Archiva templates and stylesheets to match site styles</li><li>[MRM-1015] - Move consumer API's from plexus to spring</li><li>[MRM-1016] - Minor usability enhancement for the web app footer</li><li>[MRM-1037] - Search Usability</li><li>[MRM-1074] - Typo of Legacy Support option on the left nav menu</li><li>[MRM-1081] - Archiva model should be updated so that the ARTIFACT table includes repositoryId as a primary key</li><li>[MRM-1084] - Upgrade modello maven plugin to 1.0 to support Java 5 generics</li><li>[MRM-1091] - Upgrade appassembler plugin from 1.0-beta-2 to 1.0</li><li>[MRM-1093] - Log configuration and repository changes made.</li><li>[MRM-1098] - upgrade to wagon 1.0-beta-5</li><li>[MRM-1099] - Updated Archiva User Guide</li><li>[MRM-1130] - add security audit log</li></ul></div><div class="section"><h4>New Feature<a name="New_Feature"></a></h4><ul><li>[MRM-206] - Add xml-rpc search</li><li>[MRM-749] - Support m2eclipse index format creation</li><li>[MRM-913] - Ability to delete an artifact from the web interface</li><li>[MRM-1083] - Add artifact search box to the default decorator</li></ul></div><div class="section"><h4>Task<a name="Task"></a></h4><ul><li>[MRM-938] - Remove 'redback.default.guest' usage in ArchivaXworkUser once this property is removed in redback</li><li>[MRM-991] - Update screenshots in documentation to reflect the changes in the UI</li><li>[MRM-1031] - Upgrade to jackrabbit-webdav 1.5.0</li><li>[MRM-1036] - Add documentation on how to use Archiva web services</li><li>[MRM-1068] - Upgrade to redback-1.2-beta-2</li><li>[MRM-1079] - Update LuceneCleanupRemoveIndexerConsumer to use the new index format</li><li>[MRM-1082] - Upgrade from plexus-maven-plugin to the plexus-component-metadata plugin</li><li>[MRM-1094] - Update docs on search to reflect the search re-vamp for 1.2-M2</li><li>[MRM-1107] - upgrade to Redback 1.2</li></ul></div></div><div class="section"><h3>Changes in Archiva 1.2-M1<a name="Changes_in_Archiva_1.2-M1"></a></h3><p>Released: <b>14 November 2008</b></p><div class="section"><h4>Bug<a name="Bug"></a></h4><ul><li>[MRM-514] - Archiva cannot compile and pass tests on JDK 1.6</li><li>[MRM-615] - When scanning, Archiva doesn't resolve properties/variables of POMs in managed repositories</li><li>[MRM-620] - pom.xml that inherit version from parent show up in reports as &quot;has an invalid project model&quot;</li><li>[MRM-717] - Performance affected using Archiva Repository</li><li>[MRM-844] - &quot;Unable to create ArchivaArtifact with empty version&quot; in dependency tree.</li><li>[MRM-868] - Include sources bundle during deployment (in release:perform)</li><li>[MRM-876] - Archiva does not proxy .asc files</li><li>[MRM-882] - checksum validation reports invalid checksum when checksum is correct</li><li>[MRM-885] - incorrect metadata generated from merge</li><li>[MRM-925] - Access to maven-metadata.xml without &quot;groupId&quot; fails when accessed via a repository group</li><li>[MRM-978] - showArtifactLink tag is broken</li><li>[MRM-981] - artifactIds with numeric characters aren't found in advanced search</li><li>[MRM-986] - archiva.xml is saved in home directory instead of $ARCHIVA_BASE/conf</li></ul></div><div class="section"><h4>Improvement<a name="Improvement"></a></h4><ul><li>[MRM-541] - convenient way to take Archiva proxies &quot;offline&quot;</li><li>[MRM-906] - Proxy repository operations should not be done in place</li><li>[MRM-907] - Remove VersionedReference/ProjectReference/ArtifactReference from RepositoryProxyConnectors</li><li>[MRM-946] - Upgrade to redback 1.1.1</li><li>[MRM-948] - allow plugins to handle deletion of artifacts through repository purge</li><li>[MRM-952] - Patch for several issues while processing poms (effective model, expressions resolving, storing to database)</li><li>[MRM-966] - Update documentation for search feature</li><li>[MRM-977] - Upgrade from Webwork 2 to Struts 2</li><li>[MRM-985] - Document usage of boolean NOT in quick search</li><li>[MRM-987] - switch from prototype to jquery</li><li>[MRM-988] - remove &quot;dav:&quot; from the POM snippet in repositories page</li></ul></div><div class="section"><h4>New Feature<a name="New_Feature"></a></h4><ul><li>[MRM-90] - add advanced search options</li><li>[MRM-124] - web service interface</li></ul></div><div class="section"><h4>Task<a name="Task"></a></h4><ul><li>[MRM-84] - Basic statistics</li></ul></div></div><div class="section"><h3>Changes in Archiva 1.1.3<a name="Changes_in_Archiva_1.1.3"></a></h3><p>Released: <b>9 October 2008</b></p><div class="section"><h4>Bug<a name="Bug"></a></h4><ul><li>[MRM-967] - Security Issue: If repository observer role is enabled for the 'guest' user, an invalid user is able to deploy to that repository</li><li>[MRM-397] - background of the Archiva logo is not transparent in repositories page</li><li>[MRM-580] - does not give error message when one defines an illegal directory for a managed repository</li><li>[MRM-954] - Footer doesn't stretch across repositoryGroups page</li></ul></div></div><div class="section"><h3>Changes in Archiva 1.1.2<a name="Changes_in_Archiva_1.1.2"></a></h3><p>Released: <b>11 September 2008</b></p><div class="section"><h4>Bug<a name="Bug"></a></h4><ul><li>[MRM-765] - should not be possible to create a proxy connector if there are no remote repositories</li><li>[MRM-807] - Deployed dll won't be indexed</li><li>[MRM-834] - Wrong repository url when archiva is used behind Apache with mof_proxy</li><li>[MRM-841] - Introducing a new scannable artifact file type requires restart in order for some consumers to work</li><li>[MRM-880] - Archiva does not start up on Solaris 64-Bit</li><li>[MRM-881] - Failing to startup due to invalid bean definition</li><li>[MRM-893] - Illegal browse operation allow</li><li>[MRM-902] - If path has leading slash when being checked againts whitelists and blacklists causes matching failure</li><li>[MRM-903] - Repository scanning should not stop when encounters error</li><li>[MRM-905] - EL Expression failed with empty/not functions</li><li>[MRM-911] - Archiva checks user's credentials before guest's rights on the repository</li><li>[MRM-912] - rss urls seem to use fixed webcontext &quot;archiva&quot; instead of actual webcontext</li><li>[MRM-915] - NPE with rss links</li><li>[MRM-926] - NPE with search page</li><li>[MRM-932] - Error 500 when clicking the Next or Previous icon of the results of a search, if user is trying to search for java classes, packages or methods.</li><li>[MRM-934] - For bytecode search, only 1 version of the artifact is returned even if there are more than 1 version of that artifact which matched the search</li><li>[MRM-943] - results search option should only be available on results page</li></ul></div><div class="section"><h4>Improvement<a name="Improvement"></a></h4><ul><li>[MRM-839] - change RSS URLs</li><li>[MRM-848] - Pre-configured repositories initially appear to be empty</li><li>[MRM-874] - POM snippet for plugins should be <i>plugin</i> not <i>dependency</i></li></ul><p>The full list of changes can be found <a class="externalLink" href="http://jira.codehaus.org/secure/ReleaseNote.jspa?version=14491&amp;styleName=Text&amp;projectId=10980"> in JIRA</a>.</p></div></div><div class="section"><h3>Changes in Archiva 1.1.1<a name="Changes_in_Archiva_1.1.1"></a></h3><p>Released: <b>11 August 2008</b></p><div class="section"><h4>Bug<a name="Bug"></a></h4><ul><li>[MRM-584] - Newly created user cannot login</li><li>[MRM-631] - network proxy is always used when defined</li><li>[MRM-814] - Invalid cron expressions are accepted in Database Scanning</li><li>[MRM-873] - repository groups - move up/down should not show when it's not possible</li><li>[MRM-883] - RSS syndication java.lang.ArrayIndexOutOfBoundsException</li><li>[MRM-884] - network proxy fails after upgrading to archiva 1.1</li><li>[MRM-888] - add notes on reindexing to the upgrade docs</li><li>[MRM-891] - Unable to use archiva as http source with maven-stage-plugin</li><li>[MRM-892] - Search for java classes and package names is broken</li><li>[MRM-895] - Archiva version doesn't appear on the footer when it is installed on Tomcat</li><li>[MRM-896] - classifier is appended to pom filename after artifact upload</li></ul></div><div class="section"><h4>Improvement<a name="Improvement"></a></h4><ul><li>[MRM-817] - Artifact information screen should indicate the name of repository in which the artifact resides</li></ul><p>The full list of changes can be found <a class="externalLink" href="http://jira.codehaus.org/secure/ReleaseNote.jspa?version=14461&amp;styleName=Text&amp;projectId=10980"> in JIRA</a>.</p></div></div><div class="section"><h3>Changes in Archiva 1.1<a name="Changes_in_Archiva_1.1"></a></h3><p>Released: <b>20 July 2008</b></p><div class="section"><h4>Sub-task<a name="Sub-task"></a></h4><ul><li>[MRM-801] - Create documentation for virtual repositories</li><li>[MRM-861] - Paginate Search Results page</li></ul></div><div class="section"><h4>Bug<a name="Bug"></a></h4><ul><li>[MRM-234] - Moving files between repos through webdav doesn't work</li><li>[MRM-312] - ConcurrentModificationException</li><li>[MRM-523] - Appearance Actions do not work when $<a name="user.home">user.home</a> is invalid.</li><li>[MRM-538] - Browse &gt; Info not synchronised with updated POM contents</li><li>[MRM-550] - proxy connectors - move up/down should not show when it's not possible</li><li>[MRM-584] - Newly created user cannot login</li><li>[MRM-597] - Cannot run Archiva as another user because su is run with option &quot;-&quot; (--login)</li><li>[MRM-602] - add &quot;maintainance&quot; to the feature tour</li><li>[MRM-605] - unit tests fail on archiva 1.0 source distribution</li><li>[MRM-610] - a number of unit tests fail on windows</li><li>[MRM-614] - User validation message has incorrect URL</li><li>[MRM-624] - Failed to install Archiva as windows service</li><li>[MRM-629] - NullPointer when setting corporate POM on a fresh archvia install</li><li>[MRM-638] - some developer reports are appearing in the archiva-docs module and need to be disabled</li><li>[MRM-650] - Deleted metadata files still appear in search results</li><li>[MRM-652] - Invalid html links in &quot;webdav&quot; directory browsing</li><li>[MRM-653] - WebDAV deploy fails with error</li><li>[MRM-658] - org.apache.maven.archiva.repository.content.FilenameParser is unable to determine unique snapshot versions with specific version names</li><li>[MRM-682] - Archiva runs out of heap memory</li><li>[MRM-692] - Repository problem is kept in database even though its related artifact has been already removed</li><li>[MRM-702] - in the standalone bundle, the pid file is written into the installation directory alongside the wrapper, but should be in a temporary location</li><li>[MRM-711] - Security using ldap throws NullPointerException</li><li>[MRM-733] - Error ending component lifecycle</li><li>[MRM-753] - Error while deploying an artifact to archiva</li><li>[MRM-767] - generated LICENSE and NOTICE files need improvement</li><li>[MRM-768] - Cannot proxy maven2 plugin (jaxb) from a maven1 repository (http://download.java.net/maven/1)</li><li>[MRM-769] - CLONE - 507 Insufficient Storage when deploying artifact with webdav</li><li>[MRM-777] - assignments.jsp: missing <i>tr</i><i>/tr</i> group under &quot;Resource Roles&quot;:</li><li>[MRM-778] - DefaultDavServerManager.createServer doesn't create server</li><li>[MRM-780] - Access to indexes files with a browser is not possible</li><li>[MRM-784] - mailing-info on the website points to 'old' maven.apache.org addresses</li><li>[MRM-785] - No message is displayed after a successful artifact upload</li><li>[MRM-789] - Archiva may delete you app server installation</li><li>[MRM-790] - [regression] proxying metadata causes an IO exception in new checksum code</li><li>[MRM-792] - remove references to maven in code</li><li>[MRM-796] - releases always activated in repositories</li><li>[MRM-797] - Delete Released Snapshots doesn't work</li><li>[MRM-800] - Admin user account user lockout via Webdav only?</li><li>[MRM-810] - Uploads done through the Web UI are not reported in the audit log</li><li>[MRM-818] - [Repository Group] Page will be broken if entered identifier is too long</li><li>[MRM-819] - ERROR 404 page when clicking the URL of Repository Group with identifier i.e. &quot;test/test&quot;</li><li>[MRM-820] - 404 when the dav url of an Archiva default repository (internal or snapshots) is accessed</li><li>[MRM-823] - Deleted repository still shows up in the repo group</li><li>[MRM-824] - dependency cleanup</li><li>[MRM-835] - Checksum search appears broken</li><li>[MRM-840] - Wagon HTTP deadlocks under high load</li><li>[MRM-845] - Continuous Loop when you click a repository group link</li><li>[MRM-846] - &quot;Repository Purge By Retention Count&quot; option not working</li><li>[MRM-847] - DependencyTreeGeneratorConsumerTest fails under windows due to line ending</li><li>[MRM-851] - wrong taglib short-name causes deployment error on Geronimo</li><li>[MRM-853] - HTTP Error 500 when uploading artifact with Windows OS</li><li>[MRM-855] - java.lang.NoClassDefFoundError: org/apache/xml/serialize/OutputFormat</li><li>[MRM-856] - Artifact Upload replaces all instances of the name &quot;jar&quot; with &quot;pom&quot; when trying to change the file extension</li><li>[MRM-858] - last-modified header is missing</li><li>[MRM-865] - Upload snapshot should work like a deploy</li><li>[MRM-867] - 500 on HEAD method</li><li>[MRM-869] - many empty folders created in managed repos with proxy connectors when used in a group</li><li>[MRM-870] - addRepositoryToGroup.action =&gt; AbstractMethodError on DeferredDocumentImpl.getXmlStandalone()</li><li>[MRM-871] - jetty.host and jetty.port properties are set by default in jetty.xml preventing user from using other hostname if user is not aware of these properties</li><li>[MRM-872] - empty metadatas frmo a repository group</li></ul></div><div class="section"><h4>Improvement<a name="Improvement"></a></h4><ul><li>[MRM-591] - Reports should show from which repository the defective artifact was found.</li><li>[MRM-651] - Updated consumer plugin to build against the 1.1 apis</li><li>[MRM-654] - Archetype for generation of Consumer plugins</li><li>[MRM-667] - Timeout implementation for Archiva</li><li>[MRM-678] - 404 errors on proxies should be cached</li><li>[MRM-737] - Don't list metadata files in the search results</li><li>[MRM-752] - Trim URL in Remote Repositories</li><li>[MRM-760] - set JSW to auto-restart if it crashes or hangs</li><li>[MRM-773] - Improve RSS feed generation</li><li>[MRM-781] - Removal of Archiva-Webdav implementation in favor of Jackrabbit-webdav</li><li>[MRM-802] - Display the url for the repository group</li><li>[MRM-804] - When uploading artifacts to the repo, they should be added to the index instantly</li><li>[MRM-822] - add org/jvnet/**, com/sun/** to the whitelist for the default java.net repository</li><li>[MRM-829] - Replace Company POM feature with simple Appearence customisation</li><li>[MRM-831] - When deploying artifacts to the repo, they should be added to the index instantly</li><li>[MRM-857] - set a user agent for proxy HTTP requests</li><li>[MRM-859] - Use File.createTempFile() when downloading files from a remote repository</li></ul></div><div class="section"><h4>New Feature<a name="New_Feature"></a></h4><ul><li>[MRM-123] - add RSS view to repository manager</li><li>[MRM-216] - Upload (deploy) artifacts to a repository - via a web form (not using wagon)</li><li>[MRM-694] - Virtual repositories or repository grouping</li><li>[MRM-730] - Index/Search by class, method or package name</li><li>[MRM-751] - Support database connection pooling</li><li>[MRM-774] - Support inclusion of pom file when deploying an artifact via the web upload form</li><li>[MRM-864] - Searching within search results</li></ul></div><div class="section"><h4>Task<a name="Task"></a></h4><ul><li>[MRM-677] - Upgrade archiva to the latest redback (1.0.1)</li><li>[MRM-688] - Replace plexus-runtime with standalone jetty bundle</li><li>[MRM-708] - Migrate from Plexus Logging to Slf4J</li><li>[MRM-754] - Update the screenshots in the docs</li></ul><p>The full list of changes can be found <a class="externalLink" href="http://jira.codehaus.org/secure/ReleaseNote.jspa?version=13861&amp;styleName=Text&amp;projectId=10980"> in JIRA</a>.</p></div></div><div class="section"><h3>Changes in Archiva 1.0.2<a name="Changes_in_Archiva_1.0.2"></a></h3><p>Released: <b>8 April 2008</b></p><div class="section"><h4>Bug<a name="Bug"></a></h4><ul><li>[MRM-159] - should not respond with a 404 if proxying a file results in a remote error</li><li>[MRM-532] - Unable to specify the location of the index files through the web ui</li><li>[MRM-598] - Validation error on new repository creation and other fields under certain conditions</li><li>[MRM-608] - Unable to find project model for [...] if the initial import of the POM failed</li><li>[MRM-617] - Reporting does not work due to bug in client-side JavaScript validation</li><li>[MRM-618] - PLEXUS_BASE does not work for local databases</li><li>[MRM-622] - database not being updated with project model information</li><li>[MRM-626] - ClassCastException when saving proxy connector with property defined</li><li>[MRM-627] - Archiva doesn't download SNAPSHOTs for proxied repositories.</li><li>[MRM-631] - network proxy is always used when defined</li><li>[MRM-642] - archiva-common tests rely on relative paths</li><li>[MRM-655] - The logs are duplicated in the archiva.log and wrapper.log file.</li><li>[MRM-659] - archiva cannot serve ejb artifacts from a maven1 repository</li><li>[MRM-661] - remote repository removals are not saved after restart</li><li>[MRM-664] - Cannot download a strut-module artifact in a Legacy repository</li><li>[MRM-674] - LayoutException when downloading SNAPSHOT test-sources</li><li>[MRM-683] - Archiva version missing from pages and logs</li><li>[MRM-687] - Project model cannot be added to database if it inherits groupId and/or version from parent POM</li><li>[MRM-689] - Incorrect war name in example for tomcat</li><li>[MRM-690] - using undefined appserver.base</li><li>[MRM-691] - Can't get any of the consumers to work without through a NPE</li><li>[MRM-701] - Buggy documentation on &quot;separating the base from the installation&quot;</li><li>[MRM-703] - Artifacts with extensions longer than fours characters breaks repository scanning.</li><li>[MRM-713] - extensionPattern in FilenameParser is incorrect</li><li>[MRM-715] - error adding artifacts to Lucene under some circumstances</li><li>[MRM-719] - NPE during repository scan</li><li>[MRM-725] - /archiva/browse URL does not work on WebSphere</li><li>[MRM-727] - Archiva does not download plugin artifacts in Geronimo</li><li>[MRM-734] - Unable to update metadata - No versions found for reference</li><li>[MRM-746] - unable to include *.xml in artifacts list as it picks up maven-metadata.xml</li><li>[MRM-750] - Adding a network proxy doesn't require an identifier</li><li>[MRM-755] - No content type for .pom files denoted in file &quot;archiva-mime-types.txt&quot; - workaround included</li><li>[MRM-758] - unable to schedule cron expressions that contain a comma</li><li>[MRM-761] - Exception when trying to retrieve a Maven 1 artifact of type zip</li><li>[MRM-762] - Footer doesn't stretch across repositoryScanning and database pages</li><li>[MRM-763] - Default cron expression for database update is invalid</li><li>[MRM-764] - default policies are not selected in the add proxy connector page</li></ul></div><div class="section"><h4>Improvement<a name="Improvement"></a></h4><ul><li>[MRM-504] - Find Artifact page needs more onscreen information/instructions</li><li>[MRM-656] - Admin guide for installing WAR needs updating</li><li>[MRM-666] - Edit Managed Repository page should indicate the repo id being edited</li><li>[MRM-700] - Review the documentation on deploying to Archiva for inconsistent repository ids</li><li>[MRM-720] - Upgrade Lucene from 2.0 to 2.3.1</li></ul></div></div><div class="section"><h3>Changes in Archiva 1.0.1<a name="Changes_in_Archiva_1.0.1"></a></h3><p>Released: <b>4 February 2008</b></p><div class="section"><h4>Bug<a name="Bug"></a></h4><ul><li>[MRM-623] - find artifact self signed certificate will expire soon</li><li>[MRM-628] - In the audit.log file the userid for each action is guest, even though the deploy was performed by admin</li><li>[MRM-630] - http 502 proxy error with browse button after 2 days running</li><li>[MRM-633] - Logging is too verbose</li><li>[MRM-646] - Documentation for configuring for Tomcat is invalid</li><li>[MRM-662] - Repo purge is not deleting artifacts in correct order</li><li>[MRM-668] - Repo browse and search isn't working in trunk and in archiva 1.0.1 release candidate</li><li>[MRM-670] - legacy artifact mapping form needs better validation</li></ul></div><div class="section"><h4>Improvement<a name="Improvement"></a></h4><ul><li>[MRM-594] - add some minimal hook in LegacyPathParser to allow exception management in artifact resolution</li></ul></div><div class="section"><h4>Task<a name="Task"></a></h4><ul><li>[MRM-619] - Update docs/site for some corrections</li></ul></div></div><div class="section"><h3>Archiva 1.0<a name="Archiva_1.0"></a></h3><p>Released: <b>23 November 2007</b></p><p>First production release.</p></div><div class="section"><h3>History<a name="History"></a></h3><p>Archiva was started in November 2005, building a simple framework on top of some existing repository conversion tools within the Maven project. Initial development focused on repository conversion, error reporting, and indexing. From January 2006 a web application was started to visualise the information and to start incorporating functionality from the unmaintained maven-proxy project.</p><p>Development continued through many stops and starts. Initial versions of Archiva were built from source by contributors, and the first alpha version was not released until April 2007. Some significant changes were made to improve performance and functionality in June 2007 and over the next 6 months and a series of alpha and beta releases, a concerted effort was made to release the 1.0 version.</p><p>Archiva became an Apache &quot;top level project&quot; in March 2008.</p></div></div>
                  </div>
            </div>
          </div>

    <hr/>

    <footer>
            <div class="container-fluid">
              <div class="row span12">Copyright &copy;                    2006-2013
                        <a href="http://www.apache.org/">The Apache Software Foundation</a>.
            All Rights Reserved.      
                    
      </div>

                                                                  <?xml version="1.0" encoding="UTF-8"?>
<div class="row span12">Apache Archiva :: Documentation, Archiva :: Documentation, Apache, the Apache feather logo, and the Apache Archiva :: Documentation project logos are trademarks of The Apache Software Foundation.</div>
                                                          <?xml version="1.0" encoding="UTF-8"?>
<div class="row span12">
  <a href="http://archiva.apache.org/docs/1.4-M4/privacy-policy.html">Privacy Policy</a>
</div>
                  
        
          
    
    
                
    <div id="ohloh" class="pull-right">
      <script type="text/javascript" src="http://www.ohloh.net/p/6670/widgets/project_basic_stats.js"></script>
    </div>
        </div>
    </footer>
  </body>
</html>