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 ManagedRepositoryConfiguration 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.setScanned( 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             ManagedRepositoryConfiguration existingRepository = repository;
  71             if ( existingRepository == null )
  72             {
  73                 addActionError( "A repository with that id does not exist" );
  74                 return ERROR;
  75             }
  76
  77             try
  78             {
  79                 Configuration configuration = archivaConfiguration.getConfiguration();
  80                 removeRepository( repoid, configuration );
  81                 result = saveConfiguration( configuration );
  82
  83                 if ( result.equals( SUCCESS ) )
  84                 {
  85                     removeRepositoryRoles( existingRepository );
  86                     if ( StringUtils.equals( mode, "delete-contents" ) )
  87                     {
  88                         removeContents( existingRepository );
  89                     }
  90                 }
  91             }
  92             catch ( IOException e )
  93             {
  94                 addActionError( "Unable to delete repository: " + e.getMessage() );
  95                 result = INPUT;
  96             }
  97             catch ( RoleManagerException e )
  98             {
  99                 addActionError( "Unable to delete repository: " + e.getMessage() );
 100                 result = INPUT;
 101             }
 102             catch ( InvalidConfigurationException e )
 103             {
 104                 addActionError( "Unable to delete repository: " + e.getMessage() );
 105                 result = INPUT;
 106             }
 107             catch ( RegistryException e )
 108             {
 109                 addActionError( "Unable to delete repository: " + e.getMessage() );
 110                 result = INPUT;
 111             }
 112         }
 113
 114         return result;
 115     }
 116
 117     public ManagedRepositoryConfiguration getRepository()
 118     {
 119         return repository;
 120     }
 121
 122     public void prepare()
 123     {
 124         String id = repoid;
 125         if ( id == null )
 126         {
 127             this.repository = new ManagedRepositoryConfiguration();
 128             this.repository.setReleases( false );
 129             this.repository.setScanned( false );
 130         }
 131         else
 132         {
 133             repository = archivaConfiguration.getConfiguration().findManagedRepositoryById( id );
 134         }
 135     }
 136
 137     public String save()
 138     {
 139         String repoId = repository.getId();
 140
 141         Configuration configuration = archivaConfiguration.getConfiguration();
 142         boolean containsError = validateFields( configuration );
 143
 144         if ( containsError && StringUtils.equalsIgnoreCase( "add", mode ) )
 145         {
 146             return INPUT;
 147         }
 148         else if ( containsError && StringUtils.equalsIgnoreCase( "edit", this.mode ) )
 149         {
 150             return ERROR;
 151         }
 152
 153         if ( StringUtils.equalsIgnoreCase( "edit", this.mode ) )
 154         {
 155             removeRepository( repoId, configuration );
 156         }
 157
 158         String result;
 159         try
 160         {
 161             addRepository( repository, configuration );
 162             result = saveConfiguration( configuration );
 163         }
 164         catch ( IOException e )
 165         {
 166             addActionError( "I/O Exception: " + e.getMessage() );
 167             result = INPUT;
 168         }
 169         catch ( RoleManagerException e )
 170         {
 171             addActionError( "Role Manager Exception: " + e.getMessage() );
 172             result = INPUT;
 173         }
 174         catch ( InvalidConfigurationException e )
 175         {
 176             addActionError( "Invalid Configuration Exception: " + e.getMessage() );
 177             result = INPUT;
 178         }
 179         catch ( RegistryException e )
 180         {
 181             addActionError( "Configuration Registry Exception: " + e.getMessage() );
 182             result = INPUT;
 183         }
 184
 185         return result;
 186     }
 187
 188     private boolean validateFields( Configuration config )
 189     {
 190         boolean containsError = false;
 191         CronExpressionValidator validator = new CronExpressionValidator();
 192         String repoId = repository.getId();
 193
 194         if ( StringUtils.isBlank( repoId ) )
 195         {
 196             addFieldError( "repository.id", "You must enter a repository identifier." );
 197             containsError = true;
 198         }
 199         //if edit mode, do not validate existence of repoId
 200         else if ( ( config.getManagedRepositoriesAsMap().containsKey( repoId ) ||
 201             config.getRemoteRepositoriesAsMap().containsKey( repoId ) ) &&
 202             !StringUtils.equalsIgnoreCase( mode, "edit" ) )
 203         {
 204             addFieldError( "repository.id",
 205                            "Unable to add new repository with id [" + repoId + "], that id already exists." );
 206             containsError = true;
 207         }
 208
 209         if ( StringUtils.isBlank( repository.getLocation() ) )
 210         {
 211             addFieldError( "repository.location", "You must enter a directory." );
 212             containsError = true;
 213         }
 214         if ( StringUtils.isBlank( repository.getName() ) )
 215         {
 216             addFieldError( "repository.name", "You must enter a repository name." );
 217             containsError = true;
 218         }
 219         if ( !validator.validate( repository.getRefreshCronExpression() ) )
 220         {
 221             addFieldError( "repository.refreshCronExpression", "Invalid cron expression." );
 222             containsError = true;
 223         }
 224
 225         return containsError;
 226     }
 227
 228     private void addRepository( ManagedRepositoryConfiguration repository, Configuration configuration )
 229         throws IOException, RoleManagerException
 230     {
 231         // Normalize the path
 232         File file = new File( repository.getLocation() );
 233         repository.setLocation( file.getCanonicalPath() );
 234         if ( !file.exists() )
 235         {
 236             file.mkdirs();
 237         }
 238         if ( !file.exists() || !file.isDirectory() )
 239         {
 240             throw new IOException( "unable to add repository - can not create the root directory: " + file );
 241         }
 242
 243         configuration.addManagedRepository( repository );
 244
 245         // TODO: double check these are configured on start up
 246         // TODO: belongs in the business logic
 247         roleManager.createTemplatedRole( "archiva-repository-manager", repository.getId() );
 248
 249         roleManager.createTemplatedRole( "archiva-repository-observer", repository.getId() );
 250     }
 251
 252     private void removeContents( ManagedRepositoryConfiguration existingRepository )
 253         throws IOException
 254     {
 255         FileUtils.deleteDirectory( new File( existingRepository.getLocation() ) );
 256     }
 257
 258     private void removeRepository( String repoId, Configuration configuration )
 259     {
 260         ManagedRepositoryConfiguration toremove = configuration.findManagedRepositoryById( repoId );
 261         if ( toremove != null )
 262         {
 263             configuration.removeManagedRepository( toremove );
 264         }
 265     }
 266
 267     private void removeRepositoryRoles( ManagedRepositoryConfiguration existingRepository )
 268         throws RoleManagerException
 269     {
 270         roleManager.removeTemplatedRole( "archiva-repository-manager", existingRepository.getId() );
 271         roleManager.removeTemplatedRole( "archiva-repository-observer", existingRepository.getId() );
 272
 273         getLogger().debug( "removed user roles associated with repository " + existingRepository.getId() );
 274     }
 275
 276     public void setRoleManager( RoleManager roleManager )
 277     {
 278         this.roleManager = roleManager;
 279     }
 280 }