source.dussan.org Git - archiva.git/blob

   1 package org.apache.archiva.admin.repository.group;
   2 /*
   3  * Licensed to the Apache Software Foundation (ASF) under one
   4  * or more contributor license agreements.  See the NOTICE file
   5  * distributed with this work for additional information
   6  * regarding copyright ownership.  The ASF licenses this file
   7  * to you under the Apache License, Version 2.0 (the
   8  * "License"); you may not use this file except in compliance
   9  * with the License.  You may obtain a copy of the License at
  10  *
  11  *   http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing,
  14  * software distributed under the License is distributed on an
  15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  16  * KIND, either express or implied.  See the License for the
  17  * specific language governing permissions and limitations
  18  * under the License.
  19  */
  20
  21 import org.apache.archiva.admin.model.AuditInformation;
  22 import org.apache.archiva.admin.model.RepositoryAdminException;
  23 import org.apache.archiva.admin.model.beans.ManagedRepository;
  24 import org.apache.archiva.admin.model.beans.RepositoryGroup;
  25 import org.apache.archiva.admin.model.group.RepositoryGroupAdmin;
  26 import org.apache.archiva.admin.model.managed.ManagedRepositoryAdmin;
  27 import org.apache.archiva.admin.repository.AbstractRepositoryAdmin;
  28 import org.apache.archiva.audit.AuditEvent;
  29 import org.apache.archiva.configuration.Configuration;
  30 import org.apache.archiva.configuration.RepositoryGroupConfiguration;
  31 import org.apache.commons.lang.StringUtils;
  32 import org.slf4j.Logger;
  33 import org.slf4j.LoggerFactory;
  34 import org.springframework.stereotype.Service;
  35
  36 import javax.annotation.PostConstruct;
  37 import javax.inject.Inject;
  38 import java.io.File;
  39 import java.util.ArrayList;
  40 import java.util.Arrays;
  41 import java.util.HashMap;
  42 import java.util.List;
  43 import java.util.Map;
  44 import java.util.regex.Matcher;
  45 import java.util.regex.Pattern;
  46
  47 /**
  48  * @author Olivier Lamy
  49  */
  50 @Service("repositoryGroupAdmin#default")
  51 public class DefaultRepositoryGroupAdmin
  52     extends AbstractRepositoryAdmin
  53     implements RepositoryGroupAdmin
  54 {
  55
  56     private Logger log = LoggerFactory.getLogger( getClass() );
  57
  58     private static final Pattern REPO_GROUP_ID_PATTERN = Pattern.compile( "[A-Za-z0-9\\._\\-]+" );
  59
  60     @Inject
  61     private ManagedRepositoryAdmin managedRepositoryAdmin;
  62
  63     private File groupsDirectory;
  64
  65     @PostConstruct
  66     public void initialize()
  67     {
  68         String appServerBase = getRegistry().getString( "appserver.base" );
  69         groupsDirectory = new File( appServerBase + File.separatorChar + "groups" );
  70         if ( !groupsDirectory.exists() )
  71         {
  72             groupsDirectory.mkdirs();
  73         }
  74     }
  75
  76     @Override
  77     public File getMergedIndexDirectory( String repositoryGroupId )
  78     {
  79         return new File( groupsDirectory, repositoryGroupId );
  80     }
  81
  82     public List<RepositoryGroup> getRepositoriesGroups()
  83         throws RepositoryAdminException
  84     {
  85         List<RepositoryGroup> repositoriesGroups =
  86             new ArrayList<RepositoryGroup>( getArchivaConfiguration().getConfiguration().getRepositoryGroups().size() );
  87
  88         for ( RepositoryGroupConfiguration repositoryGroupConfiguration : getArchivaConfiguration().getConfiguration().getRepositoryGroups() )
  89         {
  90             repositoriesGroups.add( new RepositoryGroup( repositoryGroupConfiguration.getId(), new ArrayList<String>(
  91                 repositoryGroupConfiguration.getRepositories() ) ).mergedIndexPath(
  92                 repositoryGroupConfiguration.getMergedIndexPath() ).mergedIndexTtl(
  93                 repositoryGroupConfiguration.getMergedIndexTtl() ) );
  94         }
  95
  96         return repositoriesGroups;
  97     }
  98
  99     public RepositoryGroup getRepositoryGroup( String repositoryGroupId )
 100         throws RepositoryAdminException
 101     {
 102         List<RepositoryGroup> repositoriesGroups = getRepositoriesGroups();
 103         for ( RepositoryGroup repositoryGroup : repositoriesGroups )
 104         {
 105             if ( StringUtils.equals( repositoryGroupId, repositoryGroup.getId() ) )
 106             {
 107                 return repositoryGroup;
 108             }
 109         }
 110         return null;
 111     }
 112
 113     public Boolean addRepositoryGroup( RepositoryGroup repositoryGroup, AuditInformation auditInformation )
 114         throws RepositoryAdminException
 115     {
 116         validateRepositoryGroup( repositoryGroup, false );
 117         validateManagedRepositoriesExists( repositoryGroup.getRepositories() );
 118
 119         RepositoryGroupConfiguration repositoryGroupConfiguration = new RepositoryGroupConfiguration();
 120         repositoryGroupConfiguration.setId( repositoryGroup.getId() );
 121         repositoryGroupConfiguration.setRepositories( repositoryGroup.getRepositories() );
 122         repositoryGroupConfiguration.setMergedIndexPath( repositoryGroup.getMergedIndexPath() );
 123         repositoryGroupConfiguration.setMergedIndexTtl( repositoryGroup.getMergedIndexTtl() );
 124         Configuration configuration = getArchivaConfiguration().getConfiguration();
 125         configuration.addRepositoryGroup( repositoryGroupConfiguration );
 126         saveConfiguration( configuration );
 127         triggerAuditEvent( repositoryGroup.getId(), null, AuditEvent.ADD_REPO_GROUP, auditInformation );
 128         return Boolean.TRUE;
 129     }
 130
 131     public Boolean deleteRepositoryGroup( String repositoryGroupId, AuditInformation auditInformation )
 132         throws RepositoryAdminException
 133     {
 134         Configuration configuration = getArchivaConfiguration().getConfiguration();
 135         RepositoryGroupConfiguration repositoryGroupConfiguration =
 136             configuration.getRepositoryGroupsAsMap().get( repositoryGroupId );
 137         if ( repositoryGroupConfiguration == null )
 138         {
 139             throw new RepositoryAdminException(
 140                 "repositoryGroup with id " + repositoryGroupId + " doesn't not exists so cannot remove" );
 141         }
 142         configuration.removeRepositoryGroup( repositoryGroupConfiguration );
 143         triggerAuditEvent( repositoryGroupId, null, AuditEvent.DELETE_REPO_GROUP, auditInformation );
 144         return Boolean.TRUE;
 145     }
 146
 147     public Boolean updateRepositoryGroup( RepositoryGroup repositoryGroup, AuditInformation auditInformation )
 148         throws RepositoryAdminException
 149     {
 150         return updateRepositoryGroup( repositoryGroup, auditInformation, true );
 151     }
 152
 153     private Boolean updateRepositoryGroup( RepositoryGroup repositoryGroup, AuditInformation auditInformation,
 154                                            boolean triggerAuditEvent )
 155         throws RepositoryAdminException
 156     {
 157         validateRepositoryGroup( repositoryGroup, true );
 158         validateManagedRepositoriesExists( repositoryGroup.getRepositories() );
 159         Configuration configuration = getArchivaConfiguration().getConfiguration();
 160
 161         RepositoryGroupConfiguration repositoryGroupConfiguration =
 162             configuration.getRepositoryGroupsAsMap().get( repositoryGroup.getId() );
 163
 164         configuration.removeRepositoryGroup( repositoryGroupConfiguration );
 165
 166         repositoryGroupConfiguration.setRepositories( repositoryGroup.getRepositories() );
 167         repositoryGroupConfiguration.setMergedIndexPath( repositoryGroup.getMergedIndexPath() );
 168         repositoryGroupConfiguration.setMergedIndexTtl( repositoryGroup.getMergedIndexTtl() );
 169         configuration.addRepositoryGroup( repositoryGroupConfiguration );
 170
 171         saveConfiguration( configuration );
 172         if ( triggerAuditEvent )
 173         {
 174             triggerAuditEvent( repositoryGroup.getId(), null, AuditEvent.MODIFY_REPO_GROUP, auditInformation );
 175         }
 176         return Boolean.TRUE;
 177     }
 178
 179
 180     public Boolean addRepositoryToGroup( String repositoryGroupId, String repositoryId,
 181                                          AuditInformation auditInformation )
 182         throws RepositoryAdminException
 183     {
 184         RepositoryGroup repositoryGroup = getRepositoryGroup( repositoryGroupId );
 185         if ( repositoryGroup == null )
 186         {
 187             throw new RepositoryAdminException(
 188                 "repositoryGroup with id " + repositoryGroupId + " doesn't not exists so cannot add repository to it" );
 189         }
 190
 191         if ( repositoryGroup.getRepositories().contains( repositoryId ) )
 192         {
 193             throw new RepositoryAdminException(
 194                 "repositoryGroup with id " + repositoryGroupId + " already contain repository with id" + repositoryId );
 195         }
 196         validateManagedRepositoriesExists( Arrays.asList( repositoryId ) );
 197
 198         repositoryGroup.addRepository( repositoryId );
 199         updateRepositoryGroup( repositoryGroup, auditInformation, false );
 200         triggerAuditEvent( repositoryGroup.getId(), null, AuditEvent.ADD_REPO_TO_GROUP, auditInformation );
 201         return Boolean.TRUE;
 202     }
 203
 204     public Boolean deleteRepositoryFromGroup( String repositoryGroupId, String repositoryId,
 205                                               AuditInformation auditInformation )
 206         throws RepositoryAdminException
 207     {
 208         RepositoryGroup repositoryGroup = getRepositoryGroup( repositoryGroupId );
 209         if ( repositoryGroup == null )
 210         {
 211             throw new RepositoryAdminException( "repositoryGroup with id " + repositoryGroupId
 212                                                     + " doesn't not exists so cannot remove repository from it" );
 213         }
 214
 215         if ( !repositoryGroup.getRepositories().contains( repositoryId ) )
 216         {
 217             throw new RepositoryAdminException(
 218                 "repositoryGroup with id " + repositoryGroupId + " doesn't not contains repository with id"
 219                     + repositoryId );
 220         }
 221
 222         repositoryGroup.removeRepository( repositoryId );
 223         updateRepositoryGroup( repositoryGroup, auditInformation, false );
 224         triggerAuditEvent( repositoryGroup.getId(), null, AuditEvent.DELETE_REPO_FROM_GROUP, auditInformation );
 225         return Boolean.TRUE;
 226     }
 227
 228     public Map<String, RepositoryGroup> getRepositoryGroupsAsMap()
 229         throws RepositoryAdminException
 230     {
 231         List<RepositoryGroup> repositoriesGroups = getRepositoriesGroups();
 232         Map<String, RepositoryGroup> map = new HashMap<String, RepositoryGroup>( repositoriesGroups.size() );
 233         for ( RepositoryGroup repositoryGroup : repositoriesGroups )
 234         {
 235             map.put( repositoryGroup.getId(), repositoryGroup );
 236         }
 237         return map;
 238     }
 239
 240     public Map<String, List<String>> getGroupToRepositoryMap()
 241         throws RepositoryAdminException
 242     {
 243
 244         java.util.Map<String, java.util.List<String>> map = new java.util.HashMap<String, java.util.List<String>>();
 245
 246         for ( ManagedRepository repo : getManagedRepositoryAdmin().getManagedRepositories() )
 247         {
 248             for ( RepositoryGroup group : getRepositoriesGroups() )
 249             {
 250                 if ( !group.getRepositories().contains( repo.getId() ) )
 251                 {
 252                     String groupId = group.getId();
 253                     java.util.List<String> repos = map.get( groupId );
 254                     if ( repos == null )
 255                     {
 256                         repos = new ArrayList<String>();
 257                         map.put( groupId, repos );
 258                     }
 259                     repos.add( repo.getId() );
 260                 }
 261             }
 262         }
 263         return map;
 264     }
 265
 266     public Map<String, List<String>> getRepositoryToGroupMap()
 267         throws RepositoryAdminException
 268     {
 269         java.util.Map<String, java.util.List<String>> map = new java.util.HashMap<String, java.util.List<String>>();
 270
 271         for ( RepositoryGroup group : getRepositoriesGroups() )
 272         {
 273             for ( String repositoryId : group.getRepositories() )
 274             {
 275                 java.util.List<String> groups = map.get( repositoryId );
 276                 if ( groups == null )
 277                 {
 278                     groups = new ArrayList<String>();
 279                     map.put( repositoryId, groups );
 280                 }
 281                 groups.add( group.getId() );
 282             }
 283         }
 284         return map;
 285     }
 286
 287     public Boolean validateRepositoryGroup( RepositoryGroup repositoryGroup, boolean updateMode )
 288         throws RepositoryAdminException
 289     {
 290         String repoGroupId = repositoryGroup.getId();
 291         if ( StringUtils.isBlank( repoGroupId ) )
 292         {
 293             throw new RepositoryAdminException( "repositoryGroup id cannot be empty" );
 294         }
 295
 296         if ( repoGroupId.length() > 100 )
 297         {
 298             throw new RepositoryAdminException(
 299                 "Identifier [" + repoGroupId + "] is over the maximum limit of 100 characters" );
 300
 301         }
 302
 303         Matcher matcher = REPO_GROUP_ID_PATTERN.matcher( repoGroupId );
 304         if ( !matcher.matches() )
 305         {
 306             throw new RepositoryAdminException(
 307                 "Invalid character(s) found in identifier. Only the following characters are allowed: alphanumeric, '.', '-' and '_'" );
 308         }
 309
 310         if ( repositoryGroup.getMergedIndexTtl() <= 0 )
 311         {
 312             throw new RepositoryAdminException( "Merged Index TTL must be greater than 0." );
 313         }
 314
 315         Configuration configuration = getArchivaConfiguration().getConfiguration();
 316
 317         if ( configuration.getRepositoryGroupsAsMap().containsKey( repoGroupId ) )
 318         {
 319             if ( !updateMode )
 320             {
 321                 throw new RepositoryAdminException( "Unable to add new repository group with id [" + repoGroupId
 322                                                         + "], that id already exists as a repository group." );
 323             }
 324         }
 325         else if ( configuration.getManagedRepositoriesAsMap().containsKey( repoGroupId ) )
 326         {
 327             throw new RepositoryAdminException( "Unable to add new repository group with id [" + repoGroupId
 328                                                     + "], that id already exists as a managed repository." );
 329         }
 330         else if ( configuration.getRemoteRepositoriesAsMap().containsKey( repoGroupId ) )
 331         {
 332             throw new RepositoryAdminException( "Unable to add new repository group with id [" + repoGroupId
 333                                                     + "], that id already exists as a remote repository." );
 334         }
 335
 336         return Boolean.TRUE;
 337     }
 338
 339     private void validateManagedRepositoriesExists( List<String> managedRepositoriesIds )
 340         throws RepositoryAdminException
 341     {
 342         for ( String id : managedRepositoriesIds )
 343         {
 344             if ( getManagedRepositoryAdmin().getManagedRepository( id ) == null )
 345             {
 346                 throw new RepositoryAdminException(
 347                     "managedRepository with id " + id + " not exists so cannot be used in a repositoryGroup" );
 348             }
 349         }
 350     }
 351
 352     public ManagedRepositoryAdmin getManagedRepositoryAdmin()
 353     {
 354         return managedRepositoryAdmin;
 355     }
 356
 357     public void setManagedRepositoryAdmin( ManagedRepositoryAdmin managedRepositoryAdmin )
 358     {
 359         this.managedRepositoryAdmin = managedRepositoryAdmin;
 360     }
 361 }