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

   1 package org.apache.maven.archiva.web.action.admin.repositories;
   2
   3 /*
   4  * Licensed to the Apache Software Foundation (ASF) under one
   5  * or more contributor license agreements.  See the NOTICE file
   6  * distributed with this work for additional information
   7  * regarding copyright ownership.  The ASF licenses this file
   8  * to you under the Apache License, Version 2.0 (the
   9  * "License"); you may not use this file except in compliance
  10  * with the License.  You may obtain a copy of the License at
  11  *
  12  *   http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  * KIND, either express or implied.  See the License for the
  18  * specific language governing permissions and limitations
  19  * under the License.
  20  */
  21
  22 import com.opensymphony.xwork.Preparable;
  23 import org.apache.commons.io.FileUtils;
  24 import org.apache.commons.lang.StringUtils;
  25 import org.apache.maven.archiva.configuration.Configuration;
  26 import org.apache.maven.archiva.configuration.InvalidConfigurationException;
  27 import org.apache.maven.archiva.configuration.ManagedRepositoryConfiguration;
  28 import org.codehaus.plexus.redback.role.RoleManager;
  29 import org.codehaus.plexus.redback.role.RoleManagerException;
  30 import org.codehaus.plexus.registry.RegistryException;
  31 import org.codehaus.plexus.scheduler.CronExpressionValidator;
  32
  33 import java.io.File;
  34 import java.io.IOException;
  35
  36 /**
  37  * Configures the application repositories.
  38  *
  39  * @plexus.component role="com.opensymphony.xwork.Action" role-hint="configureRepositoryAction"
  40  */
  41 public class ConfigureRepositoryAction
  42     extends AbstractConfigureRepositoryAction
  43     implements Preparable
  44 {
  45     /**
  46      * The model for this action.
  47      */
  48     private AdminRepositoryConfiguration repository;
  49
  50     /**
  51      * @plexus.requirement role-hint="default"
  52      */
  53     protected RoleManager roleManager;
  54
  55     public String add()
  56     {
  57         this.mode = "add";
  58
  59         this.repository.setReleases( true );
  60         this.repository.setIndexed( true );
  61
  62         return INPUT;
  63     }
  64
  65     public String delete()
  66     {
  67         String result = SUCCESS;
  68         if ( StringUtils.equals( mode, "delete-entry" ) || StringUtils.equals( mode, "delete-contents" ) )
  69         {
  70             AdminRepositoryConfiguration existingRepository = repository;
  71             if ( existingRepository == null )
  72             {
  73                 addActionError( "A repository with that id does not exist" );
  74                 return ERROR;
  75             }
  76
  77             // TODO: remove from index too!
  78
  79             try
  80             {
  81                 Configuration configuration = archivaConfiguration.getConfiguration();
  82                 removeRepository( repoid, configuration );
  83                 result = saveConfiguration( configuration );
  84
  85                 if ( result.equals( SUCCESS ) )
  86                 {
  87                     removeRepositoryRoles( existingRepository );
  88                     if ( StringUtils.equals( mode, "delete-contents" ) )
  89                     {
  90                         removeContents( existingRepository );
  91                     }
  92                 }
  93             }
  94             catch ( IOException e )
  95             {
  96                 addActionError( "Unable to delete repository: " + e.getMessage() );
  97                 result = INPUT;
  98             }
  99             catch ( RoleManagerException e )
 100             {
 101                 addActionError( "Unable to delete repository: " + e.getMessage() );
 102                 result = INPUT;
 103             }
 104             catch ( InvalidConfigurationException e )
 105             {
 106                 addActionError( "Unable to delete repository: " + e.getMessage() );
 107                 result = INPUT;
 108             }
 109             catch ( RegistryException e )
 110             {
 111                 addActionError( "Unable to delete repository: " + e.getMessage() );
 112                 result = INPUT;
 113             }
 114         }
 115
 116         return result;
 117     }
 118
 119     public AdminRepositoryConfiguration getRepository()
 120     {
 121         return repository;
 122     }
 123
 124     public void prepare()
 125     {
 126         String id = repoid;
 127         if ( id == null )
 128         {
 129             this.repository = new AdminRepositoryConfiguration();
 130             this.repository.setReleases( false );
 131             this.repository.setIndexed( false );
 132         }
 133
 134         ManagedRepositoryConfiguration repoconfig =
 135             archivaConfiguration.getConfiguration().findManagedRepositoryById( id );
 136         if ( repoconfig != null )
 137         {
 138             this.repository = new AdminRepositoryConfiguration( repoconfig );
 139         }
 140     }
 141
 142     public String save()
 143     {
 144         String repoId = repository.getId();
 145
 146         Configuration configuration = archivaConfiguration.getConfiguration();
 147         boolean containsError = validateFields( configuration );
 148
 149         if ( containsError && StringUtils.equalsIgnoreCase( "add", mode ) )
 150         {
 151             return INPUT;
 152         }
 153         else if ( containsError && StringUtils.equalsIgnoreCase( "edit", this.mode ) )
 154         {
 155             return ERROR;
 156         }
 157
 158         if ( StringUtils.equalsIgnoreCase( "edit", this.mode ) )
 159         {
 160             removeRepository( repoId, configuration );
 161         }
 162
 163         String result;
 164         try
 165         {
 166             addRepository( repository, configuration );
 167             result = saveConfiguration( configuration );
 168         }
 169         catch ( IOException e )
 170         {
 171             addActionError( "I/O Exception: " + e.getMessage() );
 172             result = INPUT;
 173         }
 174         catch ( RoleManagerException e )
 175         {
 176             addActionError( "Role Manager Exception: " + e.getMessage() );
 177             result = INPUT;
 178         }
 179         catch ( InvalidConfigurationException e )
 180         {
 181             addActionError( "Invalid Configuration Exception: " + e.getMessage() );
 182             result = INPUT;
 183         }
 184         catch ( RegistryException e )
 185         {
 186             addActionError( "Configuration Registry Exception: " + e.getMessage() );
 187             result = INPUT;
 188         }
 189
 190         return result;
 191     }
 192
 193     private boolean validateFields( Configuration config )
 194     {
 195         boolean containsError = false;
 196         CronExpressionValidator validator = new CronExpressionValidator();
 197         String repoId = repository.getId();
 198
 199         if ( StringUtils.isBlank( repoId ) )
 200         {
 201             addFieldError( "repository.id", "You must enter a repository identifier." );
 202             containsError = true;
 203         }
 204         //if edit mode, do not validate existence of repoId
 205         else if ( ( config.getManagedRepositoriesAsMap().containsKey( repoId ) ||
 206             config.getRemoteRepositoriesAsMap().containsKey( repoId ) ) &&
 207             !StringUtils.equalsIgnoreCase( mode, "edit" ) )
 208         {
 209             addFieldError( "repository.id",
 210                            "Unable to add new repository with id [" + repoId + "], that id already exists." );
 211             containsError = true;
 212         }
 213
 214         if ( StringUtils.isBlank( repository.getLocation() ) )
 215         {
 216             addFieldError( "repository.location", "You must enter a directory." );
 217             containsError = true;
 218         }
 219         if ( StringUtils.isBlank( repository.getName() ) )
 220         {
 221             addFieldError( "repository.name", "You must enter a repository name." );
 222             containsError = true;
 223         }
 224         if ( !validator.validate( repository.getRefreshCronExpression() ) )
 225         {
 226             addFieldError( "repository.refreshCronExpression", "Invalid cron expression." );
 227             containsError = true;
 228         }
 229
 230         return containsError;
 231     }
 232
 233     private void addRepository( AdminRepositoryConfiguration repository, Configuration configuration )
 234         throws IOException, RoleManagerException
 235     {
 236         // Normalize the path
 237         File file = new File( repository.getLocation() );
 238         repository.setLocation( file.getCanonicalPath() );
 239         if ( !file.exists() )
 240         {
 241             file.mkdirs();
 242             // TODO: error handling when this fails, or is not a directory!
 243         }
 244
 245         configuration.addManagedRepository( repository );
 246
 247         // TODO: double check these are configured on start up
 248         // TODO: belongs in the business logic
 249         roleManager.createTemplatedRole( "archiva-repository-manager", repository.getId() );
 250
 251         roleManager.createTemplatedRole( "archiva-repository-observer", repository.getId() );
 252     }
 253
 254     private void removeContents( AdminRepositoryConfiguration existingRepository )
 255         throws IOException
 256     {
 257         FileUtils.deleteDirectory( new File( existingRepository.getLocation() ) );
 258     }
 259
 260     private void removeRepository( String repoId, Configuration configuration )
 261     {
 262         ManagedRepositoryConfiguration toremove = configuration.findManagedRepositoryById( repoId );
 263         if ( toremove != null )
 264         {
 265             configuration.removeManagedRepository( toremove );
 266         }
 267     }
 268
 269     private void removeRepositoryRoles( ManagedRepositoryConfiguration existingRepository )
 270         throws RoleManagerException
 271     {
 272         roleManager.removeTemplatedRole( "archiva-repository-manager", existingRepository.getId() );
 273         roleManager.removeTemplatedRole( "archiva-repository-observer", existingRepository.getId() );
 274
 275         getLogger().debug( "removed user roles associated with repository " + existingRepository.getId() );
 276     }
 277
 278     public void setRoleManager( RoleManager roleManager )
 279     {
 280         this.roleManager = roleManager;
 281     }
 282 }