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.ArchivaConfiguration;
  26 import org.apache.maven.archiva.configuration.Configuration;
  27 import org.apache.maven.archiva.configuration.IndeterminateConfigurationException;
  28 import org.apache.maven.archiva.configuration.InvalidConfigurationException;
  29 import org.apache.maven.archiva.configuration.ManagedRepositoryConfiguration;
  30 import org.apache.maven.archiva.security.ArchivaRoleConstants;
  31 import org.codehaus.plexus.redback.rbac.Resource;
  32 import org.codehaus.plexus.redback.role.RoleManager;
  33 import org.codehaus.plexus.redback.role.RoleManagerException;
  34 import org.codehaus.plexus.redback.xwork.interceptor.SecureAction;
  35 import org.codehaus.plexus.redback.xwork.interceptor.SecureActionBundle;
  36 import org.codehaus.plexus.redback.xwork.interceptor.SecureActionException;
  37 import org.codehaus.plexus.registry.RegistryException;
  38 import org.codehaus.plexus.scheduler.CronExpressionValidator;
  39 import org.codehaus.plexus.xwork.action.PlexusActionSupport;
  40
  41 import java.io.File;
  42 import java.io.IOException;
  43
  44 /**
  45  * Configures the application repositories.
  46  *
  47  * @plexus.component role="com.opensymphony.xwork.Action" role-hint="configureRepositoryAction"
  48  */
  49 public class ConfigureRepositoryAction
  50     extends PlexusActionSupport
  51     implements Preparable, SecureAction
  52 {
  53     /**
  54      * @plexus.requirement role-hint="default"
  55      */
  56     private RoleManager roleManager;
  57
  58     /**
  59      * @plexus.requirement
  60      */
  61     private ArchivaConfiguration archivaConfiguration;
  62
  63     private String repoid;
  64
  65     // TODO! consider removing? was just meant to be for delete...
  66     private String mode;
  67
  68     /**
  69      * The model for this action.
  70      */
  71     private AdminRepositoryConfiguration repository;
  72
  73     public String add()
  74     {
  75         this.mode = "add";
  76
  77         this.repository.setReleases( true );
  78         this.repository.setIndexed( true );
  79
  80         return INPUT;
  81     }
  82
  83     public String confirm()
  84     {
  85         return INPUT;
  86     }
  87
  88     public String delete()
  89     {
  90         String result = SUCCESS;
  91         if ( StringUtils.equals( mode, "delete-entry" ) || StringUtils.equals( mode, "delete-contents" ) )
  92         {
  93             AdminRepositoryConfiguration existingRepository = repository;
  94             if ( existingRepository == null )
  95             {
  96                 addActionError( "A repository with that id does not exist" );
  97                 return ERROR;
  98             }
  99
 100             // TODO: remove from index too!
 101
 102             try
 103             {
 104                 removeRepository( repoid, archivaConfiguration.getConfiguration() );
 105                 result = saveConfiguration( archivaConfiguration.getConfiguration() );
 106
 107                 if ( result.equals( SUCCESS ) )
 108                 {
 109                     removeRepositoryRoles( existingRepository );
 110                     if ( StringUtils.equals( mode, "delete-contents" ) )
 111                     {
 112                         removeContents( existingRepository );
 113                     }
 114                 }
 115             }
 116             catch ( IOException e )
 117             {
 118                 addActionError( "Unable to delete repository: " + e.getMessage() );
 119                 result = INPUT;
 120             }
 121             catch ( RoleManagerException e )
 122             {
 123                 addActionError( "Unable to delete repository: " + e.getMessage() );
 124                 result = INPUT;
 125             }
 126             catch ( InvalidConfigurationException e )
 127             {
 128                 addActionError( "Unable to delete repository: " + e.getMessage() );
 129                 result = INPUT;
 130             }
 131             catch ( RegistryException e )
 132             {
 133                 addActionError( "Unable to delete repository: " + e.getMessage() );
 134                 result = INPUT;
 135             }
 136         }
 137
 138         return result;
 139     }
 140
 141     public String edit()
 142     {
 143         this.mode = "edit";
 144
 145         return INPUT;
 146     }
 147
 148     public String getMode()
 149     {
 150         return this.mode;
 151     }
 152
 153     public String getRepoid()
 154     {
 155         return repoid;
 156     }
 157
 158     public AdminRepositoryConfiguration getRepository()
 159     {
 160         return repository;
 161     }
 162
 163     public SecureActionBundle getSecureActionBundle()
 164         throws SecureActionException
 165     {
 166         SecureActionBundle bundle = new SecureActionBundle();
 167
 168         bundle.setRequiresAuthentication( true );
 169         bundle.addRequiredAuthorization( ArchivaRoleConstants.OPERATION_MANAGE_CONFIGURATION, Resource.GLOBAL );
 170
 171         return bundle;
 172     }
 173
 174     public void prepare()
 175     {
 176         String id = repoid;
 177         if ( id == null )
 178         {
 179             this.repository = new AdminRepositoryConfiguration();
 180             this.repository.setReleases( false );
 181             this.repository.setIndexed( false );
 182         }
 183
 184         // TODO! others?
 185         ManagedRepositoryConfiguration repoconfig =
 186             archivaConfiguration.getConfiguration().findManagedRepositoryById( id );
 187         if ( repoconfig != null )
 188         {
 189             this.repository = new AdminRepositoryConfiguration( repoconfig );
 190         }
 191     }
 192
 193     public String save()
 194     {
 195         String repoId = repository.getId();
 196
 197         Configuration configuration = archivaConfiguration.getConfiguration();
 198         boolean containsError = validateFields( configuration );
 199
 200         if ( containsError && StringUtils.equalsIgnoreCase( "add", mode ) )
 201         {
 202             return INPUT;
 203         }
 204         else if ( containsError && StringUtils.equalsIgnoreCase( "edit", this.mode ) )
 205         {
 206             return ERROR;
 207         }
 208
 209         if ( StringUtils.equalsIgnoreCase( "edit", this.mode ) )
 210         {
 211             removeRepository( repoId, configuration );
 212         }
 213
 214         String result;
 215         try
 216         {
 217             addRepository( repository, configuration );
 218             result = saveConfiguration( configuration );
 219         }
 220         catch ( IOException e )
 221         {
 222             addActionError( "I/O Exception: " + e.getMessage() );
 223             result = INPUT;
 224         }
 225         catch ( RoleManagerException e )
 226         {
 227             addActionError( "Role Manager Exception: " + e.getMessage() );
 228             result = INPUT;
 229         }
 230         catch ( InvalidConfigurationException e )
 231         {
 232             addActionError( "Invalid Configuration Exception: " + e.getMessage() );
 233             result = INPUT;
 234         }
 235         catch ( RegistryException e )
 236         {
 237             addActionError( "Configuration Registry Exception: " + e.getMessage() );
 238             result = INPUT;
 239         }
 240
 241         return result;
 242     }
 243
 244     private boolean validateFields( Configuration config )
 245     {
 246         boolean containsError = false;
 247         CronExpressionValidator validator = new CronExpressionValidator();
 248         String repoId = repository.getId();
 249
 250         if ( StringUtils.isBlank( repoId ) )
 251         {
 252             addFieldError( "repository.id", "You must enter a repository identifier." );
 253             containsError = true;
 254         }
 255         //if edit mode, do not validate existence of repoId
 256         else if ( ( config.getManagedRepositoriesAsMap().containsKey( repoId ) ||
 257             config.getRemoteRepositoriesAsMap().containsKey( repoId ) ) &&
 258             !StringUtils.equalsIgnoreCase( mode, "edit" ) )
 259         {
 260             addFieldError( "repository.id",
 261                            "Unable to add new repository with id [" + repoId + "], that id already exists." );
 262             containsError = true;
 263         }
 264
 265         // TODO! split
 266         if ( StringUtils.isBlank( repository.getLocation() ) )
 267         {
 268             addFieldError( "repository.url", "You must enter a directory." );
 269             containsError = true;
 270         }
 271         if ( StringUtils.isBlank( repository.getName() ) )
 272         {
 273             addFieldError( "repository.name", "You must enter a repository name." );
 274             containsError = true;
 275         }
 276         if ( !validator.validate( repository.getRefreshCronExpression() ) )
 277         {
 278             addFieldError( "repository.refreshCronExpression", "Invalid cron expression." );
 279             containsError = true;
 280         }
 281
 282         return containsError;
 283     }
 284
 285     public void setMode( String mode )
 286     {
 287         this.mode = mode;
 288     }
 289
 290     public void setRepoid( String repoid )
 291     {
 292         this.repoid = repoid;
 293     }
 294
 295     public void setRepository( AdminRepositoryConfiguration repository )
 296     {
 297         this.repository = repository;
 298     }
 299
 300     private void addRepository( AdminRepositoryConfiguration repository, Configuration configuration )
 301         throws IOException, RoleManagerException
 302     {
 303         // Fix the URL entry (could possibly be a filesystem path)
 304 /* TODO! reinstate
 305         String rawUrlEntry = repository.getUrl();
 306         if ( !rawUrlEntry.startsWith( "http://" ) )
 307         {
 308             repository.setUrl( PathUtil.toUrl( rawUrlEntry ) );
 309         }
 310
 311         if ( repository.isManaged() )
 312         {
 313             // Normalize the path
 314             File file = new File( repository.getDirectory() );
 315             repository.setDirectory( file.getCanonicalPath() );
 316             if ( !file.exists() )
 317             {
 318                 file.mkdirs();
 319                 // TODO: error handling when this fails, or is not a directory!
 320             }
 321         }
 322 */
 323
 324         // TODO! others
 325         configuration.addManagedRepository( repository );
 326
 327         // TODO: double check these are configured on start up
 328         // TODO: belongs in the business logic
 329         roleManager.createTemplatedRole( "archiva-repository-manager", repository.getId() );
 330
 331         roleManager.createTemplatedRole( "archiva-repository-observer", repository.getId() );
 332     }
 333
 334     private void removeContents( AdminRepositoryConfiguration existingRepository )
 335         throws IOException
 336     {
 337         FileUtils.deleteDirectory( new File( existingRepository.getLocation() ) );
 338     }
 339
 340     private void removeRepository( String repoId, Configuration configuration )
 341     {
 342         // TODO! what about others?
 343         ManagedRepositoryConfiguration toremove = configuration.findManagedRepositoryById( repoId );
 344         if ( toremove != null )
 345         {
 346             configuration.removeManagedRepository( toremove );
 347         }
 348     }
 349
 350     private void removeRepositoryRoles( ManagedRepositoryConfiguration existingRepository )
 351         throws RoleManagerException
 352     {
 353         roleManager.removeTemplatedRole( "archiva-repository-manager", existingRepository.getId() );
 354         roleManager.removeTemplatedRole( "archiva-repository-observer", existingRepository.getId() );
 355
 356         getLogger().debug( "removed user roles associated with repository " + existingRepository.getId() );
 357     }
 358
 359     private String saveConfiguration( Configuration configuration )
 360         throws IOException, InvalidConfigurationException, RegistryException
 361     {
 362         try
 363         {
 364             archivaConfiguration.save( configuration );
 365             addActionMessage( "Successfully saved configuration" );
 366         }
 367         catch ( IndeterminateConfigurationException e )
 368         {
 369             addActionError( e.getMessage() );
 370             return INPUT;
 371         }
 372
 373         return SUCCESS;
 374     }
 375
 376     public void setRoleManager( RoleManager roleManager )
 377     {
 378         this.roleManager = roleManager;
 379     }
 380
 381     public void setArchivaConfiguration( ArchivaConfiguration archivaConfiguration )
 382     {
 383         this.archivaConfiguration = archivaConfiguration;
 384     }
 385
 386 }