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.AuditInformation;
  22 import org.apache.archiva.admin.repository.AbstractRepositoryAdmin;
  23 import org.apache.archiva.admin.repository.RepositoryAdminException;
  24 import org.apache.archiva.admin.repository.managed.ManagedRepository;
  25 import org.apache.archiva.admin.repository.managed.ManagedRepositoryAdmin;
  26 import org.apache.archiva.audit.AuditEvent;
  27 import org.apache.commons.lang.StringUtils;
  28 import org.apache.maven.archiva.configuration.Configuration;
  29 import org.apache.maven.archiva.configuration.RepositoryGroupConfiguration;
  30 import org.slf4j.Logger;
  31 import org.slf4j.LoggerFactory;
  32 import org.springframework.stereotype.Service;
  33
  34 import javax.inject.Inject;
  35 import java.util.ArrayList;
  36 import java.util.Arrays;
  37 import java.util.HashMap;
  38 import java.util.List;
  39 import java.util.Map;
  40 import java.util.regex.Matcher;
  41 import java.util.regex.Pattern;
  42
  43 /**
  44  * @author Olivier Lamy
  45  */
  46 @Service( "repositoryGroupAdmin#default" )
  47 public class DefaultRepositoryGroupAdmin
  48     extends AbstractRepositoryAdmin
  49     implements RepositoryGroupAdmin
  50 {
  51
  52     private Logger log = LoggerFactory.getLogger( getClass() );
  53
  54     private static final Pattern REPO_GROUP_ID_PATTERN = Pattern.compile( "[A-Za-z0-9\\._\\-]+" );
  55
  56     @Inject
  57     private ManagedRepositoryAdmin managedRepositoryAdmin;
  58
  59     public List<RepositoryGroup> getRepositoriesGroups()
  60         throws RepositoryAdminException
  61     {
  62         List<RepositoryGroup> repositoriesGroups = new ArrayList<RepositoryGroup>();
  63
  64         for ( RepositoryGroupConfiguration repositoryGroupConfiguration : getArchivaConfiguration().getConfiguration().getRepositoryGroups() )
  65         {
  66             repositoriesGroups.add( new RepositoryGroup( repositoryGroupConfiguration.getId(), new ArrayList<String>(
  67                 repositoryGroupConfiguration.getRepositories() ) ) );
  68         }
  69
  70         return repositoriesGroups;
  71     }
  72
  73     public RepositoryGroup getRepositoryGroup( String repositoryGroupId )
  74         throws RepositoryAdminException
  75     {
  76         List<RepositoryGroup> repositoriesGroups = getRepositoriesGroups();
  77         for ( RepositoryGroup repositoryGroup : repositoriesGroups )
  78         {
  79             if ( StringUtils.equals( repositoryGroupId, repositoryGroup.getId() ) )
  80             {
  81                 return repositoryGroup;
  82             }
  83         }
  84         return null;
  85     }
  86
  87     public Boolean addRepositoryGroup( RepositoryGroup repositoryGroup, AuditInformation auditInformation )
  88         throws RepositoryAdminException
  89     {
  90         validateRepositoryGroup( repositoryGroup, false );
  91         validateManagedRepositoriesExists( repositoryGroup.getRepositories() );
  92         RepositoryGroupConfiguration repositoryGroupConfiguration = new RepositoryGroupConfiguration();
  93         repositoryGroupConfiguration.setId( repositoryGroup.getId() );
  94         repositoryGroupConfiguration.setRepositories( repositoryGroup.getRepositories() );
  95         Configuration configuration = getArchivaConfiguration().getConfiguration();
  96         configuration.addRepositoryGroup( repositoryGroupConfiguration );
  97         saveConfiguration( configuration );
  98         triggerAuditEvent( repositoryGroup.getId(), null, AuditEvent.ADD_REPO_GROUP, auditInformation );
  99         return Boolean.TRUE;
 100     }
 101
 102     public Boolean deleteRepositoryGroup( String repositoryGroupId, AuditInformation auditInformation )
 103         throws RepositoryAdminException
 104     {
 105         Configuration configuration = getArchivaConfiguration().getConfiguration();
 106         RepositoryGroupConfiguration repositoryGroupConfiguration =
 107             configuration.getRepositoryGroupsAsMap().get( repositoryGroupId );
 108         if ( repositoryGroupConfiguration == null )
 109         {
 110             throw new RepositoryAdminException(
 111                 "repositoryGroup with id " + repositoryGroupId + " doesn't not exists so cannot remove" );
 112         }
 113         configuration.removeRepositoryGroup( repositoryGroupConfiguration );
 114         triggerAuditEvent( repositoryGroupId, null, AuditEvent.DELETE_REPO_GROUP, auditInformation );
 115         return Boolean.TRUE;
 116     }
 117
 118     public Boolean updateRepositoryGroup( RepositoryGroup repositoryGroup, AuditInformation auditInformation )
 119         throws RepositoryAdminException
 120     {
 121         return updateRepositoryGroup( repositoryGroup, auditInformation, true );
 122     }
 123
 124     private Boolean updateRepositoryGroup( RepositoryGroup repositoryGroup, AuditInformation auditInformation,
 125                                            boolean triggerAuditEvent )
 126         throws RepositoryAdminException
 127     {
 128         validateRepositoryGroup( repositoryGroup, true );
 129         validateManagedRepositoriesExists( repositoryGroup.getRepositories() );
 130         Configuration configuration = getArchivaConfiguration().getConfiguration();
 131
 132         RepositoryGroupConfiguration repositoryGroupConfiguration =
 133             configuration.getRepositoryGroupsAsMap().get( repositoryGroup.getId() );
 134
 135         configuration.removeRepositoryGroup( repositoryGroupConfiguration );
 136
 137         repositoryGroupConfiguration.setRepositories( repositoryGroup.getRepositories() );
 138         configuration.addRepositoryGroup( repositoryGroupConfiguration );
 139
 140         saveConfiguration( configuration );
 141         if ( triggerAuditEvent )
 142         {
 143             triggerAuditEvent( repositoryGroup.getId(), null, AuditEvent.MODIFY_REPO_GROUP, auditInformation );
 144         }
 145         return Boolean.TRUE;
 146     }
 147
 148
 149     public Boolean addRepositoryToGroup( String repositoryGroupId, String repositoryId,
 150                                          AuditInformation auditInformation )
 151         throws RepositoryAdminException
 152     {
 153         RepositoryGroup repositoryGroup = getRepositoryGroup( repositoryGroupId );
 154         if ( repositoryGroup == null )
 155         {
 156             throw new RepositoryAdminException(
 157                 "repositoryGroup with id " + repositoryGroupId + " doesn't not exists so cannot add repository to it" );
 158         }
 159
 160         if ( repositoryGroup.getRepositories().contains( repositoryId ) )
 161         {
 162             throw new RepositoryAdminException(
 163                 "repositoryGroup with id " + repositoryGroupId + " already contain repository with id" + repositoryId );
 164         }
 165         validateManagedRepositoriesExists( Arrays.asList( repositoryId ) );
 166
 167         repositoryGroup.addRepository( repositoryId );
 168         updateRepositoryGroup( repositoryGroup, auditInformation, false );
 169         triggerAuditEvent( repositoryGroup.getId(), null, AuditEvent.ADD_REPO_TO_GROUP, auditInformation );
 170         return Boolean.TRUE;
 171     }
 172
 173     public Boolean deleteRepositoryFromGroup( String repositoryGroupId, String repositoryId,
 174                                               AuditInformation auditInformation )
 175         throws RepositoryAdminException
 176     {
 177         RepositoryGroup repositoryGroup = getRepositoryGroup( repositoryGroupId );
 178         if ( repositoryGroup == null )
 179         {
 180             throw new RepositoryAdminException( "repositoryGroup with id " + repositoryGroupId
 181                                                     + " doesn't not exists so cannot remove repository from it" );
 182         }
 183
 184         if ( !repositoryGroup.getRepositories().contains( repositoryId ) )
 185         {
 186             throw new RepositoryAdminException(
 187                 "repositoryGroup with id " + repositoryGroupId + " doesn't not contains repository with id"
 188                     + repositoryId );
 189         }
 190
 191         repositoryGroup.removeRepository( repositoryId );
 192         updateRepositoryGroup( repositoryGroup, auditInformation, false );
 193         triggerAuditEvent( repositoryGroup.getId(), null, AuditEvent.DELETE_REPO_FROM_GROUP, auditInformation );
 194         return Boolean.TRUE;
 195     }
 196
 197     public Map<String, RepositoryGroup> getRepositoryGroupsAsMap()
 198         throws RepositoryAdminException
 199     {
 200         List<RepositoryGroup> repositoriesGroups = getRepositoriesGroups();
 201         Map<String, RepositoryGroup> map = new HashMap<String, RepositoryGroup>( repositoriesGroups.size() );
 202         for ( RepositoryGroup repositoryGroup : repositoriesGroups )
 203         {
 204             map.put( repositoryGroup.getId(), repositoryGroup );
 205         }
 206         return map;
 207     }
 208
 209     public Map<String, List<String>> getGroupToRepositoryMap()
 210         throws RepositoryAdminException
 211     {
 212
 213         java.util.Map<String, java.util.List<String>> map = new java.util.HashMap<String, java.util.List<String>>();
 214
 215         for ( ManagedRepository repo : getManagedRepositoryAdmin().getManagedRepositories() )
 216         {
 217             for ( RepositoryGroup group : getRepositoriesGroups() )
 218             {
 219                 if ( !group.getRepositories().contains( repo.getId() ) )
 220                 {
 221                     String groupId = group.getId();
 222                     java.util.List<String> repos = map.get( groupId );
 223                     if ( repos == null )
 224                     {
 225                         repos = new java.util.ArrayList<String>();
 226                         map.put( groupId, repos );
 227                     }
 228                     repos.add( repo.getId() );
 229                 }
 230             }
 231         }
 232         return map;
 233     }
 234
 235     public Map<String, List<String>> getRepositoryToGroupMap()
 236         throws RepositoryAdminException
 237     {
 238         java.util.Map<String, java.util.List<String>> map = new java.util.HashMap<String, java.util.List<String>>();
 239
 240         for ( RepositoryGroup group : getRepositoriesGroups() )
 241         {
 242             for ( String repositoryId : group.getRepositories() )
 243             {
 244                 java.util.List<String> groups = map.get( repositoryId );
 245                 if ( groups == null )
 246                 {
 247                     groups = new java.util.ArrayList<String>();
 248                     map.put( repositoryId, groups );
 249                 }
 250                 groups.add( group.getId() );
 251             }
 252         }
 253         return map;
 254     }
 255
 256     public Boolean validateRepositoryGroup( RepositoryGroup repositoryGroup, boolean updateMode )
 257         throws RepositoryAdminException
 258     {
 259         String repoGroupId = repositoryGroup.getId();
 260         if ( StringUtils.isBlank( repoGroupId ) )
 261         {
 262             throw new RepositoryAdminException( "repositoryGroup id cannot be empty" );
 263         }
 264
 265         if ( repoGroupId.length() > 100 )
 266         {
 267             throw new RepositoryAdminException(
 268                 "Identifier [" + repoGroupId + "] is over the maximum limit of 100 characters" );
 269
 270         }
 271
 272         Matcher matcher = REPO_GROUP_ID_PATTERN.matcher( repoGroupId );
 273         if ( !matcher.matches() )
 274         {
 275             throw new RepositoryAdminException(
 276                 "Invalid character(s) found in identifier. Only the following characters are allowed: alphanumeric, '.', '-' and '_'" );
 277         }
 278
 279         Configuration configuration = getArchivaConfiguration().getConfiguration();
 280
 281         if ( configuration.getRepositoryGroupsAsMap().containsKey( repoGroupId ) )
 282         {
 283             if ( !updateMode )
 284             {
 285                 throw new RepositoryAdminException( "Unable to add new repository group with id [" + repoGroupId
 286                                                         + "], that id already exists as a repository group." );
 287             }
 288         }
 289         else if ( configuration.getManagedRepositoriesAsMap().containsKey( repoGroupId ) )
 290         {
 291             throw new RepositoryAdminException( "Unable to add new repository group with id [" + repoGroupId
 292                                                     + "], that id already exists as a managed repository." );
 293         }
 294         else if ( configuration.getRemoteRepositoriesAsMap().containsKey( repoGroupId ) )
 295         {
 296             throw new RepositoryAdminException( "Unable to add new repository group with id [" + repoGroupId
 297                                                     + "], that id already exists as a remote repository." );
 298         }
 299
 300         return Boolean.TRUE;
 301     }
 302
 303     private void validateManagedRepositoriesExists( List<String> managedRepositoriesIds )
 304         throws RepositoryAdminException
 305     {
 306         for ( String id : managedRepositoriesIds )
 307         {
 308             if ( getManagedRepositoryAdmin().getManagedRepository( id ) == null )
 309             {
 310                 throw new RepositoryAdminException(
 311                     "managedRepository with id " + id + " not exists so cannot be used in a repositoryGroup" );
 312             }
 313         }
 314     }
 315
 316     public ManagedRepositoryAdmin getManagedRepositoryAdmin()
 317     {
 318         return managedRepositoryAdmin;
 319     }
 320
 321     public void setManagedRepositoryAdmin( ManagedRepositoryAdmin managedRepositoryAdmin )
 322     {
 323         this.managedRepositoryAdmin = managedRepositoryAdmin;
 324     }
 325 }