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     // TODO: rename to confirmDelete
  84     public String confirm()
  85     {
  86         return INPUT;
  87     }
  88
  89     public String delete()
  90     {
  91         String result = SUCCESS;
  92         if ( StringUtils.equals( mode, "delete-entry" ) || StringUtils.equals( mode, "delete-contents" ) )
  93         {
  94             AdminRepositoryConfiguration existingRepository = repository;
  95             if ( existingRepository == null )
  96             {
  97                 addActionError( "A repository with that id does not exist" );
  98                 return ERROR;
  99             }
 100
 101             // TODO: remove from index too!
 102
 103             try
 104             {
 105                 Configuration configuration = archivaConfiguration.getConfiguration();
 106                 removeRepository( repoid, configuration );
 107                 result = saveConfiguration( configuration );
 108
 109                 if ( result.equals( SUCCESS ) )
 110                 {
 111                     removeRepositoryRoles( existingRepository );
 112                     if ( StringUtils.equals( mode, "delete-contents" ) )
 113                     {
 114                         removeContents( existingRepository );
 115                     }
 116                 }
 117             }
 118             catch ( IOException e )
 119             {
 120                 addActionError( "Unable to delete repository: " + e.getMessage() );
 121                 result = INPUT;
 122             }
 123             catch ( RoleManagerException e )
 124             {
 125                 addActionError( "Unable to delete repository: " + e.getMessage() );
 126                 result = INPUT;
 127             }
 128             catch ( InvalidConfigurationException e )
 129             {
 130                 addActionError( "Unable to delete repository: " + e.getMessage() );
 131                 result = INPUT;
 132             }
 133             catch ( RegistryException e )
 134             {
 135                 addActionError( "Unable to delete repository: " + e.getMessage() );
 136                 result = INPUT;
 137             }
 138         }
 139
 140         return result;
 141     }
 142
 143     public String edit()
 144     {
 145         this.mode = "edit";
 146
 147         return INPUT;
 148     }
 149
 150     public String getMode()
 151     {
 152         return this.mode;
 153     }
 154
 155     public String getRepoid()
 156     {
 157         return repoid;
 158     }
 159
 160     public AdminRepositoryConfiguration getRepository()
 161     {
 162         return repository;
 163     }
 164
 165     public SecureActionBundle getSecureActionBundle()
 166         throws SecureActionException
 167     {
 168         SecureActionBundle bundle = new SecureActionBundle();
 169
 170         bundle.setRequiresAuthentication( true );
 171         bundle.addRequiredAuthorization( ArchivaRoleConstants.OPERATION_MANAGE_CONFIGURATION, Resource.GLOBAL );
 172
 173         return bundle;
 174     }
 175
 176     public void prepare()
 177     {
 178         String id = repoid;
 179         if ( id == null )
 180         {
 181             this.repository = new AdminRepositoryConfiguration();
 182             this.repository.setReleases( false );
 183             this.repository.setIndexed( false );
 184         }
 185
 186         // TODO! others?
 187         ManagedRepositoryConfiguration repoconfig =
 188             archivaConfiguration.getConfiguration().findManagedRepositoryById( id );
 189         if ( repoconfig != null )
 190         {
 191             this.repository = new AdminRepositoryConfiguration( repoconfig );
 192         }
 193     }
 194
 195     public String save()
 196     {
 197         String repoId = repository.getId();
 198
 199         Configuration configuration = archivaConfiguration.getConfiguration();
 200         boolean containsError = validateFields( configuration );
 201
 202         if ( containsError && StringUtils.equalsIgnoreCase( "add", mode ) )
 203         {
 204             return INPUT;
 205         }
 206         else if ( containsError && StringUtils.equalsIgnoreCase( "edit", this.mode ) )
 207         {
 208             return ERROR;
 209         }
 210
 211         if ( StringUtils.equalsIgnoreCase( "edit", this.mode ) )
 212         {
 213             removeRepository( repoId, configuration );
 214         }
 215
 216         String result;
 217         try
 218         {
 219             addRepository( repository, configuration );
 220             result = saveConfiguration( configuration );
 221         }
 222         catch ( IOException e )
 223         {
 224             addActionError( "I/O Exception: " + e.getMessage() );
 225             result = INPUT;
 226         }
 227         catch ( RoleManagerException e )
 228         {
 229             addActionError( "Role Manager Exception: " + e.getMessage() );
 230             result = INPUT;
 231         }
 232         catch ( InvalidConfigurationException e )
 233         {
 234             addActionError( "Invalid Configuration Exception: " + e.getMessage() );
 235             result = INPUT;
 236         }
 237         catch ( RegistryException e )
 238         {
 239             addActionError( "Configuration Registry Exception: " + e.getMessage() );
 240             result = INPUT;
 241         }
 242
 243         return result;
 244     }
 245
 246     private boolean validateFields( Configuration config )
 247     {
 248         boolean containsError = false;
 249         CronExpressionValidator validator = new CronExpressionValidator();
 250         String repoId = repository.getId();
 251
 252         if ( StringUtils.isBlank( repoId ) )
 253         {
 254             addFieldError( "repository.id", "You must enter a repository identifier." );
 255             containsError = true;
 256         }
 257         //if edit mode, do not validate existence of repoId
 258         else if ( ( config.getManagedRepositoriesAsMap().containsKey( repoId ) ||
 259             config.getRemoteRepositoriesAsMap().containsKey( repoId ) ) &&
 260             !StringUtils.equalsIgnoreCase( mode, "edit" ) )
 261         {
 262             addFieldError( "repository.id",
 263                            "Unable to add new repository with id [" + repoId + "], that id already exists." );
 264             containsError = true;
 265         }
 266
 267         // TODO! split
 268         if ( StringUtils.isBlank( repository.getLocation() ) )
 269         {
 270             addFieldError( "repository.location", "You must enter a directory." );
 271             containsError = true;
 272         }
 273         if ( StringUtils.isBlank( repository.getName() ) )
 274         {
 275             addFieldError( "repository.name", "You must enter a repository name." );
 276             containsError = true;
 277         }
 278         if ( !validator.validate( repository.getRefreshCronExpression() ) )
 279         {
 280             addFieldError( "repository.refreshCronExpression", "Invalid cron expression." );
 281             containsError = true;
 282         }
 283
 284         return containsError;
 285     }
 286
 287     public void setMode( String mode )
 288     {
 289         this.mode = mode;
 290     }
 291
 292     public void setRepoid( String repoid )
 293     {
 294         this.repoid = repoid;
 295     }
 296
 297     private void addRepository( AdminRepositoryConfiguration repository, Configuration configuration )
 298         throws IOException, RoleManagerException
 299     {
 300         // Normalize the path
 301         File file = new File( repository.getLocation() );
 302         repository.setLocation( file.getCanonicalPath() );
 303         if ( !file.exists() )
 304         {
 305             file.mkdirs();
 306             // TODO: error handling when this fails, or is not a directory!
 307         }
 308
 309         // TODO! others
 310         configuration.addManagedRepository( repository );
 311
 312         // TODO: double check these are configured on start up
 313         // TODO: belongs in the business logic
 314         roleManager.createTemplatedRole( "archiva-repository-manager", repository.getId() );
 315
 316         roleManager.createTemplatedRole( "archiva-repository-observer", repository.getId() );
 317     }
 318
 319     private void removeContents( AdminRepositoryConfiguration existingRepository )
 320         throws IOException
 321     {
 322         FileUtils.deleteDirectory( new File( existingRepository.getLocation() ) );
 323     }
 324
 325     private void removeRepository( String repoId, Configuration configuration )
 326     {
 327         // TODO! what about others?
 328         ManagedRepositoryConfiguration toremove = configuration.findManagedRepositoryById( repoId );
 329         if ( toremove != null )
 330         {
 331             configuration.removeManagedRepository( toremove );
 332         }
 333     }
 334
 335     private void removeRepositoryRoles( ManagedRepositoryConfiguration existingRepository )
 336         throws RoleManagerException
 337     {
 338         roleManager.removeTemplatedRole( "archiva-repository-manager", existingRepository.getId() );
 339         roleManager.removeTemplatedRole( "archiva-repository-observer", existingRepository.getId() );
 340
 341         getLogger().debug( "removed user roles associated with repository " + existingRepository.getId() );
 342     }
 343
 344     private String saveConfiguration( Configuration configuration )
 345         throws IOException, InvalidConfigurationException, RegistryException
 346     {
 347         try
 348         {
 349             archivaConfiguration.save( configuration );
 350             addActionMessage( "Successfully saved configuration" );
 351         }
 352         catch ( IndeterminateConfigurationException e )
 353         {
 354             addActionError( e.getMessage() );
 355             return INPUT;
 356         }
 357
 358         return SUCCESS;
 359     }
 360
 361     public void setRoleManager( RoleManager roleManager )
 362     {
 363         this.roleManager = roleManager;
 364     }
 365
 366     public void setArchivaConfiguration( ArchivaConfiguration archivaConfiguration )
 367     {
 368         this.archivaConfiguration = archivaConfiguration;
 369     }
 370
 371 }