| package org.apache.continuum.web.action.admin; |
| |
| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| import com.opensymphony.xwork2.Preparable; |
| import org.apache.continuum.model.repository.LocalRepository; |
| import org.apache.continuum.model.repository.RepositoryPurgeConfiguration; |
| import org.apache.continuum.purge.ContinuumPurgeManager; |
| import org.apache.continuum.purge.PurgeConfigurationService; |
| import org.apache.continuum.repository.RepositoryService; |
| import org.apache.continuum.taskqueue.manager.TaskQueueManager; |
| import org.apache.continuum.web.util.AuditLog; |
| import org.apache.continuum.web.util.AuditLogConstants; |
| import org.apache.maven.continuum.model.project.ProjectGroup; |
| import org.apache.maven.continuum.security.ContinuumRoleConstants; |
| import org.apache.maven.continuum.web.action.ContinuumConfirmAction; |
| import org.codehaus.plexus.redback.rbac.Resource; |
| import org.codehaus.redback.integration.interceptor.SecureAction; |
| import org.codehaus.redback.integration.interceptor.SecureActionBundle; |
| import org.codehaus.redback.integration.interceptor.SecureActionException; |
| |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| |
| /** |
| * @author Maria Catherine Tan |
| * @version $Id$ |
| * @plexus.component role="com.opensymphony.xwork2.Action" role-hint="localRepository" |
| * @since 25 jul 07 |
| */ |
| public class LocalRepositoryAction |
| extends ContinuumConfirmAction |
| implements Preparable, SecureAction |
| { |
| private static final String LAYOUT_DEFAULT = "default"; |
| |
| private static final String LAYOUT_LEGACY = "legacy"; |
| |
| private boolean confirmed; |
| |
| private boolean defaultRepo; |
| |
| private LocalRepository repository; |
| |
| private List<LocalRepository> repositories; |
| |
| private List<ProjectGroup> groups; |
| |
| private List<String> layouts; |
| |
| private Map<String, Boolean> defaultPurgeMap; |
| |
| /** |
| * @plexus.requirement |
| */ |
| private RepositoryService repositoryService; |
| |
| /** |
| * @plexus.requirement |
| */ |
| private PurgeConfigurationService purgeConfigService; |
| |
| public void prepare() |
| throws Exception |
| { |
| super.prepare(); |
| |
| layouts = new ArrayList<String>(); |
| layouts.add( LAYOUT_DEFAULT ); |
| layouts.add( LAYOUT_LEGACY ); |
| } |
| |
| public String input() |
| throws Exception |
| { |
| defaultRepo = false; |
| |
| if ( repository != null && repository.getId() > 0 ) |
| { |
| repository = repositoryService.getLocalRepository( repository.getId() ); |
| |
| if ( repository.getName().equals( "DEFAULT" ) ) |
| { |
| defaultRepo = true; |
| } |
| } |
| |
| return INPUT; |
| } |
| |
| public String list() |
| throws Exception |
| { |
| repositories = repositoryService.getAllLocalRepositories(); |
| |
| defaultPurgeMap = new HashMap<String, Boolean>(); |
| |
| for ( LocalRepository repo : repositories ) |
| { |
| // get default purge config of repository |
| RepositoryPurgeConfiguration purgeConfig = purgeConfigService.getDefaultPurgeConfigurationForRepository( |
| repo.getId() ); |
| |
| if ( purgeConfig == null ) |
| { |
| defaultPurgeMap.put( repo.getName(), Boolean.FALSE ); |
| } |
| else |
| { |
| defaultPurgeMap.put( repo.getName(), Boolean.TRUE ); |
| } |
| } |
| |
| return SUCCESS; |
| } |
| |
| public String save() |
| throws Exception |
| { |
| List<LocalRepository> allRepositories = repositoryService.getAllLocalRepositories(); |
| |
| for ( LocalRepository repo : allRepositories ) |
| { |
| if ( repository.getId() != repo.getId() ) |
| { |
| if ( repository.getName().trim().equals( repo.getName() ) ) |
| { |
| addActionError( getText( "repository.error.name.unique" ) ); |
| } |
| |
| if ( repository.getLocation().trim().equals( repo.getLocation() ) ) |
| { |
| addActionError( getText( "repository.error.location.unique" ) ); |
| } |
| } |
| } |
| |
| if ( repository.getName().trim().equals( "" ) ) |
| { |
| addActionError( getText( "repository.error.name.cannot.be.spaces" ) ); |
| } |
| |
| if ( repository.getLocation().trim().equals( "" ) ) |
| { |
| addActionError( getText( "repository.error.location.cannot.be.spaces" ) ); |
| } |
| |
| if ( hasActionErrors() ) |
| { |
| return INPUT; |
| } |
| |
| // trim repository name and location before saving |
| repository.setName( repository.getName().trim() ); |
| repository.setLocation( repository.getLocation().trim() ); |
| |
| if ( repository.getId() == 0 ) |
| { |
| repository = repositoryService.addLocalRepository( repository ); |
| |
| createDefaultPurgeConfiguration(); |
| } |
| else |
| { |
| // check if repository is in use |
| TaskQueueManager taskQueueManager = getContinuum().getTaskQueueManager(); |
| if ( taskQueueManager.isRepositoryInUse( repository.getId() ) ) |
| { |
| addActionError( getText( "repository.error.save.in.use" ) ); |
| return ERROR; |
| } |
| |
| LocalRepository retrievedRepo = repositoryService.getLocalRepository( repository.getId() ); |
| |
| retrievedRepo.setName( repository.getName() ); |
| retrievedRepo.setLocation( repository.getLocation() ); |
| retrievedRepo.setLayout( repository.getLayout() ); |
| |
| repositoryService.updateLocalRepository( retrievedRepo ); |
| } |
| |
| return SUCCESS; |
| } |
| |
| public String remove() |
| throws Exception |
| { |
| TaskQueueManager taskQueueManager = getContinuum().getTaskQueueManager(); |
| |
| repository = repositoryService.getLocalRepository( repository.getId() ); |
| |
| if ( taskQueueManager.isRepositoryInUse( repository.getId() ) ) |
| { |
| addActionError( getText( "repository.error.remove.in.use", |
| "Unable to remove local repository because it is in use" ) ); |
| } |
| |
| if ( repository.getName().equals( "DEFAULT" ) ) |
| { |
| addActionError( getText( "repository.error.remove.default", "Unable to remove default local repository" ) ); |
| } |
| |
| if ( !hasActionErrors() ) |
| { |
| if ( confirmed ) |
| { |
| repositoryService.removeLocalRepository( repository.getId() ); |
| } |
| else |
| { |
| return CONFIRM; |
| } |
| } |
| |
| return SUCCESS; |
| } |
| |
| public String doPurge() |
| throws Exception |
| { |
| ContinuumPurgeManager purgeManager = getContinuum().getPurgeManager(); |
| TaskQueueManager taskQueueManager = getContinuum().getTaskQueueManager(); |
| |
| // check if repository is in use |
| if ( taskQueueManager.isRepositoryInUse( repository.getId() ) ) |
| { |
| addActionError( getText( "repository.error.purge.in.use", |
| "Unable to purge repository because it is in use" ) ); |
| } |
| |
| if ( !hasActionErrors() ) |
| { |
| // get default purge configuration for repository |
| RepositoryPurgeConfiguration purgeConfig = purgeConfigService.getDefaultPurgeConfigurationForRepository( |
| repository.getId() ); |
| |
| if ( purgeConfig != null ) |
| { |
| purgeManager.purgeRepository( purgeConfig ); |
| |
| AuditLog event = new AuditLog( "Repository id=" + repository.getId(), |
| AuditLogConstants.PURGE_LOCAL_REPOSITORY ); |
| event.setCategory( AuditLogConstants.LOCAL_REPOSITORY ); |
| event.setCurrentUser( getPrincipal() ); |
| event.log(); |
| } |
| } |
| return SUCCESS; |
| } |
| |
| public LocalRepository getRepository() |
| { |
| return this.repository; |
| } |
| |
| public void setRepository( LocalRepository repository ) |
| { |
| this.repository = repository; |
| } |
| |
| public List<LocalRepository> getRepositories() |
| { |
| return this.repositories; |
| } |
| |
| public void setRepositories( List<LocalRepository> repositories ) |
| { |
| this.repositories = repositories; |
| } |
| |
| public List<ProjectGroup> getGroups() |
| { |
| return this.groups; |
| } |
| |
| public void setGroups( List<ProjectGroup> groups ) |
| { |
| this.groups = groups; |
| } |
| |
| public boolean isConfirmed() |
| { |
| return this.confirmed; |
| } |
| |
| public void setConfirmed( boolean confirmed ) |
| { |
| this.confirmed = confirmed; |
| } |
| |
| public boolean isDefaultRepo() |
| { |
| return this.defaultRepo; |
| } |
| |
| public void setDefaultRepo( boolean defaultRepo ) |
| { |
| this.defaultRepo = defaultRepo; |
| } |
| |
| public List<String> getLayouts() |
| { |
| return this.layouts; |
| } |
| |
| public Map<String, Boolean> getDefaultPurgeMap() |
| { |
| return this.defaultPurgeMap; |
| } |
| |
| public void setDefaultPurgeMap( Map<String, Boolean> defaultPurgeMap ) |
| { |
| this.defaultPurgeMap = defaultPurgeMap; |
| } |
| |
| private void createDefaultPurgeConfiguration() |
| throws Exception |
| { |
| RepositoryPurgeConfiguration repoPurge = new RepositoryPurgeConfiguration(); |
| |
| repoPurge.setRepository( repository ); |
| repoPurge.setDefaultPurge( true ); |
| |
| purgeConfigService.addRepositoryPurgeConfiguration( repoPurge ); |
| } |
| |
| public SecureActionBundle getSecureActionBundle() |
| throws SecureActionException |
| { |
| SecureActionBundle bundle = new SecureActionBundle(); |
| bundle.setRequiresAuthentication( true ); |
| bundle.addRequiredAuthorization( ContinuumRoleConstants.CONTINUUM_MANAGE_REPOSITORIES, Resource.GLOBAL ); |
| |
| return bundle; |
| } |
| } |
