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

   1 package org.apache.maven.archiva.web.startup;
   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 java.util.ArrayList;
  23 import java.util.List;
  24 import java.util.Map;
  25 import java.util.Map.Entry;
  26
  27 import org.apache.commons.collections.CollectionUtils;
  28 import org.apache.maven.archiva.common.ArchivaException;
  29 import org.apache.maven.archiva.configuration.ArchivaConfiguration;
  30 import org.apache.maven.archiva.configuration.ConfigurationNames;
  31 import org.apache.maven.archiva.configuration.ManagedRepositoryConfiguration;
  32 import org.apache.maven.archiva.security.ArchivaRoleConstants;
  33 import org.apache.maven.archiva.security.ArchivaXworkUser;
  34 import org.codehaus.plexus.redback.rbac.RBACManager;
  35 import org.codehaus.plexus.redback.rbac.RbacManagerException;
  36 import org.codehaus.plexus.redback.rbac.UserAssignment;
  37 import org.codehaus.plexus.redback.role.RoleManager;
  38 import org.codehaus.plexus.redback.role.RoleManagerException;
  39 import org.codehaus.plexus.redback.system.check.EnvironmentCheck;
  40 import org.codehaus.plexus.redback.users.UserManager;
  41 import org.codehaus.plexus.registry.Registry;
  42 import org.codehaus.plexus.registry.RegistryListener;
  43 import org.slf4j.Logger;
  44 import org.slf4j.LoggerFactory;
  45
  46 /**
  47  * ConfigurationSynchronization
  48  *
  49  * @version $Id$
  50  * @plexus.component role="org.apache.maven.archiva.web.startup.SecuritySynchronization"
  51  * role-hint="default"
  52  */
  53 public class SecuritySynchronization
  54     implements RegistryListener
  55 {
  56     private Logger log = LoggerFactory.getLogger( SecuritySynchronization.class );
  57
  58     /**
  59      * @plexus.requirement role-hint="default"
  60      */
  61     private RoleManager roleManager;
  62
  63     /**
  64      * @plexus.requirement role-hint="cached"
  65      */
  66     private RBACManager rbacManager;
  67
  68     /**
  69      * @plexus.requirement role="org.codehaus.plexus.redback.system.check.EnvironmentCheck"
  70      */
  71     private Map<String, EnvironmentCheck> checkers;
  72
  73     /**
  74      * @plexus.requirement
  75      */
  76     private ArchivaConfiguration archivaConfiguration;
  77
  78     /**
  79      * @plexus.requirement
  80      */
  81     private ArchivaXworkUser archivaXworkUser;
  82
  83     public void afterConfigurationChange( Registry registry, String propertyName, Object propertyValue )
  84     {
  85         if ( ConfigurationNames.isManagedRepositories( propertyName ) )
  86         {
  87             synchConfiguration( archivaConfiguration.getConfiguration().getManagedRepositories() );
  88         }
  89     }
  90
  91     public void beforeConfigurationChange( Registry registry, String propertyName, Object propertyValue )
  92     {
  93         /* do nothing */
  94     }
  95
  96     private void synchConfiguration( List<ManagedRepositoryConfiguration> repos )
  97     {
  98         // NOTE: Remote Repositories do not have roles or security placed around them.
  99
 100         for ( ManagedRepositoryConfiguration repoConfig : repos )
 101         {
 102             // manage roles for repositories
 103             try
 104             {
 105                 if ( !roleManager.templatedRoleExists( ArchivaRoleConstants.TEMPLATE_REPOSITORY_OBSERVER,
 106                                                        repoConfig.getId() ) )
 107                 {
 108                     roleManager.createTemplatedRole( ArchivaRoleConstants.TEMPLATE_REPOSITORY_OBSERVER,
 109                                                      repoConfig.getId() );
 110                 }
 111
 112                 if ( !roleManager.templatedRoleExists( ArchivaRoleConstants.TEMPLATE_REPOSITORY_MANAGER,
 113                                                        repoConfig.getId() ) )
 114                 {
 115                     roleManager.createTemplatedRole( ArchivaRoleConstants.TEMPLATE_REPOSITORY_MANAGER,
 116                                                      repoConfig.getId() );
 117                 }
 118             }
 119             catch ( RoleManagerException e )
 120             {
 121                 // Log error.
 122                 log.error( "Unable to create roles for configured repositories: " + e.getMessage(), e );
 123             }
 124         }
 125     }
 126
 127     public void startup()
 128         throws ArchivaException
 129     {
 130         executeEnvironmentChecks();
 131
 132         synchConfiguration( archivaConfiguration.getConfiguration().getManagedRepositories() );
 133         archivaConfiguration.addChangeListener( this );
 134
 135         if ( archivaConfiguration.isDefaulted() )
 136         {
 137             assignRepositoryObserverToGuestUser( archivaConfiguration.getConfiguration().getManagedRepositories() );
 138         }
 139     }
 140
 141     private void executeEnvironmentChecks()
 142         throws ArchivaException
 143     {
 144         if ( ( checkers == null ) || CollectionUtils.isEmpty( checkers.values() ) )
 145         {
 146             throw new ArchivaException(
 147                 "Unable to initialize the Redback Security Environment, " + "no Environment Check components found." );
 148         }
 149
 150         List<String> violations = new ArrayList<String>();
 151
 152         for ( Entry<String, EnvironmentCheck> entry : checkers.entrySet() )
 153         {
 154             EnvironmentCheck check = entry.getValue();
 155             List<String> v = new ArrayList<String>();
 156             check.validateEnvironment( v );
 157             log.info( "Environment Check: " + entry.getKey() + " -> " + v.size() + " violation(s)" );
 158             for ( String s : v )
 159             {
 160                 violations.add( "[" + entry.getKey() + "] " + s );
 161             }
 162         }
 163
 164         if ( CollectionUtils.isNotEmpty( violations ) )
 165         {
 166             StringBuffer msg = new StringBuffer();
 167             msg.append( "EnvironmentCheck Failure.\n" );
 168             msg.append( "======================================================================\n" );
 169             msg.append( " ENVIRONMENT FAILURE !! \n" );
 170             msg.append( "\n" );
 171
 172             for ( String violation : violations )
 173             {
 174                 msg.append( violation ).append( "\n" );
 175             }
 176
 177             msg.append( "\n" );
 178             msg.append( "======================================================================" );
 179             log.error( msg.toString() );
 180
 181             throw new ArchivaException( "Unable to initialize Redback Security Environment, [" + violations.size() +
 182                 "] violation(s) encountered, See log for details." );
 183         }
 184     }
 185
 186     private void assignRepositoryObserverToGuestUser( List<ManagedRepositoryConfiguration> repos )
 187     {
 188         for ( ManagedRepositoryConfiguration repoConfig : repos )
 189         {
 190             String repoId = repoConfig.getId();
 191
 192             String principal = UserManager.GUEST_USERNAME;
 193
 194             try
 195             {
 196                 UserAssignment ua;
 197
 198                 if ( rbacManager.userAssignmentExists( principal ) )
 199                 {
 200                     ua = rbacManager.getUserAssignment( principal );
 201                 }
 202                 else
 203                 {
 204                     ua = rbacManager.createUserAssignment( principal );
 205                 }
 206
 207                 ua.addRoleName( ArchivaRoleConstants.toRepositoryObserverRoleName( repoId ) );
 208                 rbacManager.saveUserAssignment( ua );
 209             }
 210             catch ( RbacManagerException e )
 211             {
 212                 log.warn(
 213                     "Unable to add role [" + ArchivaRoleConstants.toRepositoryObserverRoleName( repoId ) + "] to " +
 214                         principal + " user.", e );
 215             }
 216         }
 217     }
 218 }