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

   1 package org.apache.archiva.web.security;
   2 /*
   3  * Licensed to the Apache Software Foundation (ASF) under one
   4  * or more contributor license agreements.  See the NOTICE file
   5  * distributed with this work for additional information
   6  * regarding copyright ownership.  The ASF licenses this file
   7  * to you under the Apache License, Version 2.0 (the
   8  * "License"); you may not use this file except in compliance
   9  * with the License.  You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing,
  14  * software distributed under the License is distributed on an
  15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  16  * KIND, either express or implied.  See the License for the
  17  * specific language governing permissions and limitations
  18  * under the License.
  19  */
  20
  21 import org.apache.archiva.admin.model.RepositoryAdminException;
  22 import org.apache.archiva.admin.model.runtime.RedbackRuntimeConfigurationAdmin;
  23 import org.apache.archiva.components.cache.Cache;
  24 import org.apache.archiva.redback.rbac.AbstractRBACManager;
  25 import org.apache.archiva.redback.rbac.Operation;
  26 import org.apache.archiva.redback.rbac.Permission;
  27 import org.apache.archiva.redback.rbac.RBACManager;
  28 import org.apache.archiva.redback.rbac.RbacManagerException;
  29 import org.apache.archiva.redback.rbac.RbacObjectInvalidException;
  30 import org.apache.archiva.redback.rbac.RbacObjectNotFoundException;
  31 import org.apache.archiva.redback.rbac.Resource;
  32 import org.apache.archiva.redback.rbac.Role;
  33 import org.apache.archiva.redback.rbac.UserAssignment;
  34 import org.apache.commons.lang3.StringUtils;
  35 import org.springframework.context.ApplicationContext;
  36 import org.springframework.stereotype.Service;
  37
  38 import javax.inject.Inject;
  39 import javax.inject.Named;
  40 import java.util.ArrayList;
  41 import java.util.Collection;
  42 import java.util.HashMap;
  43 import java.util.LinkedHashMap;
  44 import java.util.List;
  45 import java.util.Map;
  46 import java.util.Set;
  47
  48 /**
  49  * @author Olivier Lamy
  50  * @since 1.4-M4
  51  */
  52 @Service( "rbacManager#archiva" )
  53 public class ArchivaRbacManager
  54     extends AbstractRBACManager
  55     implements RBACManager
  56 {
  57
  58     private Map<String, RBACManager> rbacManagersPerId;
  59
  60     @Inject
  61     private ApplicationContext applicationContext;
  62
  63     @Inject
  64     private RedbackRuntimeConfigurationAdmin redbackRuntimeConfigurationAdmin;
  65
  66     @Inject
  67     @Named( value = "cache#operations" )
  68     private Cache<String, Operation> operationsCache;
  69
  70     @Inject
  71     @Named( value = "cache#permissions" )
  72     private Cache<String, Permission> permissionsCache;
  73
  74     @Inject
  75     @Named( value = "cache#resources" )
  76     private Cache<String, Resource> resourcesCache;
  77
  78     @Inject
  79     @Named( value = "cache#roles" )
  80     private Cache<String, Role> rolesCache;
  81
  82     @Inject
  83     @Named( value = "cache#rolesById" )
  84     private Cache<String, Role> rolesByIdCache;
  85
  86     @Inject
  87     @Named( value = "cache#userAssignments" )
  88     private Cache<String, UserAssignment> userAssignmentsCache;
  89
  90     @Inject
  91     @Named( value = "cache#userPermissions" )
  92     private Cache<String, Map<String, List<Permission>>> userPermissionsCache;
  93
  94     @Inject
  95     @Named( value = "cache#effectiveRoleSet" )
  96     private Cache<String, Set<Role>> effectiveRoleSetCache;
  97
  98     @Override
  99     public void initialize()
 100     {
 101         try
 102         {
 103             List<String> rbacManagerIds =
 104                 redbackRuntimeConfigurationAdmin.getRedbackRuntimeConfiguration().getRbacManagerImpls();
 105
 106             clearCaches();
 107
 108             if ( rbacManagerIds.isEmpty() )
 109             {
 110                 rbacManagerIds.add( RedbackRuntimeConfigurationAdmin.DEFAULT_RBAC_MANAGER_IMPL );
 111             }
 112
 113             log.info( "use rbacManagerIds: '{}'", rbacManagerIds );
 114
 115             this.rbacManagersPerId = new LinkedHashMap<>( rbacManagerIds.size() );
 116
 117             for ( String id : rbacManagerIds )
 118             {
 119                 if ( StringUtils.equalsIgnoreCase( "jdo", id ))
 120                 {
 121                     id = RedbackRuntimeConfigurationAdmin.DEFAULT_RBAC_MANAGER_IMPL;
 122                 }
 123                 RBACManager rbacManager = applicationContext.getBean( "rbacManager#" + id, RBACManager.class );
 124                 rbacManagersPerId.put( id, rbacManager );
 125             }
 126
 127         }
 128         catch ( RepositoryAdminException e )
 129         {
 130
 131             log.error( e.getMessage(), e );
 132             throw new RuntimeException( e.getMessage(), e );
 133         }
 134     }
 135
 136     private void clearCaches() {
 137         resourcesCache.clear();
 138         operationsCache.clear();
 139         permissionsCache.clear();
 140         rolesCache.clear();
 141         rolesByIdCache.clear();
 142         userAssignmentsCache.clear();
 143         userPermissionsCache.clear();
 144         effectiveRoleSetCache.clear();
 145     }
 146
 147     protected RBACManager getRbacManagerForWrite()
 148     {
 149         for ( RBACManager rbacManager : this.rbacManagersPerId.values() )
 150         {
 151             if ( !rbacManager.isReadOnly() )
 152             {
 153                 log.debug("Writable Rbac manager {}", rbacManager.getDescriptionKey());
 154                 return rbacManager;
 155             }
 156         }
 157         return this.rbacManagersPerId.isEmpty() ? applicationContext.getBean(
 158             "rbacManager#" + RedbackRuntimeConfigurationAdmin.DEFAULT_RBAC_MANAGER_IMPL, RBACManager.class ) //
 159             : this.rbacManagersPerId.values().iterator().next();
 160     }
 161
 162     @Override
 163     public Role createRole( String name )
 164     {
 165         return getRbacManagerForWrite().createRole( name );
 166     }
 167
 168     @Override
 169     public Role createRole( String id, String name )
 170     {
 171         return getRbacManagerForWrite( ).createRole( id, name );
 172     }
 173
 174     @Override
 175     public Role saveRole( Role role )
 176         throws RbacObjectInvalidException, RbacManagerException
 177     {
 178         Exception lastException = null;
 179         boolean allFailed = true;
 180         for ( RBACManager rbacManager : rbacManagersPerId.values() )
 181         {
 182             try
 183             {
 184                 if ( !rbacManager.isReadOnly() )
 185                 {
 186                     role = rbacManager.saveRole( role );
 187                     allFailed = false;
 188                 }
 189             }
 190             catch ( Exception e )
 191             {
 192                 lastException = e;
 193             }
 194         }
 195         if ( lastException != null && allFailed )
 196         {
 197             throw new RbacManagerException( lastException.getMessage(), lastException );
 198         }
 199         return role;
 200     }
 201
 202     @Override
 203     public void saveRoles( Collection<Role> roles )
 204         throws RbacObjectInvalidException, RbacManagerException
 205     {
 206         Exception lastException = null;
 207         boolean allFailed = true;
 208         for ( RBACManager rbacManager : rbacManagersPerId.values() )
 209         {
 210             try
 211             {
 212                 if ( !rbacManager.isReadOnly() )
 213                 {
 214                     rbacManager.saveRoles( roles );
 215                     allFailed = false;
 216                 }
 217             }
 218             catch ( Exception e )
 219             {
 220                 lastException = e;
 221             }
 222         }
 223         if ( lastException != null && allFailed )
 224         {
 225             throw new RbacManagerException( lastException.getMessage(), lastException );
 226         }
 227     }
 228
 229     @Override
 230     public Role getRole( String roleName )
 231         throws RbacObjectNotFoundException, RbacManagerException
 232     {
 233
 234         Role el = rolesCache.get( roleName );
 235         if ( el != null )
 236         {
 237             return el;
 238         }
 239
 240         Exception lastException = null;
 241         for ( RBACManager rbacManager : rbacManagersPerId.values() )
 242         {
 243             try
 244             {
 245                 Role role = rbacManager.getRole( roleName );
 246                 if ( role != null )
 247                 {
 248                     rolesCache.put( role.getName(), role );
 249                     rolesByIdCache.put( role.getId( ), role );
 250                     return role;
 251                 }
 252             }
 253             catch ( Exception e )
 254             {
 255                 lastException = e;
 256             }
 257         }
 258         log.debug( "cannot find role for name: ‘{}", roleName );
 259         if ( lastException != null )
 260         {
 261             throw new RbacManagerException( lastException.getMessage(), lastException );
 262         }
 263         throw new RbacObjectNotFoundException( "Role not found " + roleName );
 264     }
 265
 266     @Override
 267     public Role getRoleById( String id ) throws RbacObjectNotFoundException, RbacManagerException
 268     {
 269         Role el = rolesByIdCache.get( id );
 270         if ( el != null )
 271         {
 272             return el;
 273         }
 274
 275         Exception lastException = null;
 276         for ( RBACManager rbacManager : rbacManagersPerId.values() )
 277         {
 278             try
 279             {
 280                 Role role = rbacManager.getRoleById( id );
 281                 if ( role != null )
 282                 {
 283                     rolesCache.put( role.getName(), role );
 284                     rolesByIdCache.put( role.getId( ), role );
 285                     return role;
 286                 }
 287             }
 288             catch ( Exception e )
 289             {
 290                 lastException = e;
 291             }
 292         }
 293         log.debug( "cannot find role for id: ‘{}", id );
 294         if ( lastException != null )
 295         {
 296             throw new RbacManagerException( lastException.getMessage(), lastException );
 297         }
 298         throw new RbacObjectNotFoundException( "Role not found " + id );
 299     }
 300
 301     @Override
 302     public List<Role> getAllRoles()
 303         throws RbacManagerException
 304     {
 305         Map<String, Role> allRoles = new HashMap<>();
 306         boolean allFailed = true;
 307         Exception lastException = null;
 308         for ( RBACManager rbacManager : rbacManagersPerId.values() )
 309         {
 310             try
 311             {
 312                 List<? extends Role> roles = rbacManager.getAllRoles();
 313                 for ( Role role : roles )
 314                 {
 315                     allRoles.put( role.getName(), role );
 316                 }
 317                 allFailed = false;
 318             }
 319             catch ( Exception e )
 320             {
 321                 lastException = e;
 322             }
 323         }
 324
 325         if ( lastException != null && allFailed )
 326         {
 327             throw new RbacManagerException( lastException.getMessage(), lastException );
 328         }
 329
 330         return new ArrayList<>( allRoles.values() );
 331     }
 332
 333     @Override
 334     public void removeRole( Role role )
 335         throws RbacObjectNotFoundException, RbacObjectInvalidException, RbacManagerException
 336     {
 337         boolean allFailed = true;
 338         Exception lastException = null;
 339         for ( RBACManager rbacManager : rbacManagersPerId.values() )
 340         {
 341             try
 342             {
 343                 rbacManager.removeRole( role );
 344                 rolesCache.remove( role.getName() );
 345                 rolesByIdCache.remove( role.getId( ) );
 346                 allFailed = false;
 347             }
 348             catch ( Exception e )
 349             {
 350                 lastException = e;
 351             }
 352         }
 353
 354         if ( lastException != null && allFailed )
 355         {
 356             throw new RbacManagerException( lastException.getMessage(), lastException );
 357         }
 358     }
 359
 360     @Override
 361     public Permission createPermission( String name )
 362         throws RbacManagerException
 363     {
 364         return getRbacManagerForWrite().createPermission( name );
 365     }
 366
 367     @Override
 368     public Permission createPermission( String name, String operationName, String resourceIdentifier )
 369         throws RbacManagerException
 370     {
 371         return getRbacManagerForWrite().createPermission( name, operationName, resourceIdentifier );
 372     }
 373
 374     @Override
 375     public Permission savePermission( Permission permission )
 376         throws RbacObjectInvalidException, RbacManagerException
 377     {
 378         boolean allFailed = true;
 379         Exception lastException = null;
 380         for ( RBACManager rbacManager : rbacManagersPerId.values() )
 381         {
 382             try
 383             {
 384                 if ( rbacManager.isReadOnly() )
 385                 {
 386                     permission = rbacManager.savePermission( permission );
 387                     allFailed = false;
 388                 }
 389             }
 390             catch ( Exception e )
 391             {
 392                 lastException = e;
 393             }
 394         }
 395
 396         if ( lastException != null && allFailed )
 397         {
 398             throw new RbacManagerException( lastException.getMessage(), lastException );
 399         }
 400
 401         return permission;
 402     }
 403
 404     @Override
 405     public Permission getPermission( String permissionName )
 406         throws RbacObjectNotFoundException, RbacManagerException
 407     {
 408
 409         Permission el = permissionsCache.get( permissionName );
 410         if ( el != null )
 411         {
 412             return el;
 413         }
 414
 415         Exception lastException = null;
 416         for ( RBACManager rbacManager : rbacManagersPerId.values() )
 417         {
 418             try
 419             {
 420                 Permission p = rbacManager.getPermission( permissionName );
 421                 if ( p != null )
 422                 {
 423                     permissionsCache.put( permissionName, p );
 424                     return p;
 425                 }
 426             }
 427             catch ( Exception e )
 428             {
 429                 lastException = e;
 430             }
 431         }
 432
 433         if ( lastException != null )
 434         {
 435             throw new RbacManagerException( lastException.getMessage(), lastException );
 436         }
 437         return null;
 438     }
 439
 440     @Override
 441     public List<Permission> getAllPermissions()
 442         throws RbacManagerException
 443     {
 444         Map<String, Permission> allPermissions = new HashMap<>();
 445         boolean allFailed = true;
 446         Exception lastException = null;
 447         for ( RBACManager rbacManager : rbacManagersPerId.values() )
 448         {
 449             try
 450             {
 451                 List<? extends Permission> permissions = rbacManager.getAllPermissions();
 452                 for ( Permission p : permissions )
 453                 {
 454                     allPermissions.put( p.getName(), p );
 455                 }
 456                 allFailed = false;
 457             }
 458             catch ( Exception e )
 459             {
 460                 lastException = e;
 461             }
 462         }
 463
 464         if ( lastException != null && allFailed )
 465         {
 466             throw new RbacManagerException( lastException.getMessage(), lastException );
 467         }
 468         return new ArrayList<>( allPermissions.values() );
 469     }
 470
 471     @Override
 472     public void removePermission( Permission permission )
 473         throws RbacObjectNotFoundException, RbacObjectInvalidException, RbacManagerException
 474     {
 475         boolean allFailed = true;
 476         Exception lastException = null;
 477         for ( RBACManager rbacManager : rbacManagersPerId.values() )
 478         {
 479             try
 480             {
 481                 rbacManager.removePermission( permission );
 482                 permissionsCache.remove( permission.getName() );
 483                 allFailed = false;
 484             }
 485             catch ( Exception e )
 486             {
 487                 lastException = e;
 488             }
 489         }
 490
 491         if ( lastException != null && allFailed )
 492         {
 493             throw new RbacManagerException( lastException.getMessage(), lastException );
 494         }
 495     }
 496
 497     @Override
 498     public Operation createOperation( String name )
 499         throws RbacManagerException
 500     {
 501         return getRbacManagerForWrite().createOperation( name );
 502     }
 503
 504     @Override
 505     public Operation saveOperation( Operation operation )
 506         throws RbacObjectInvalidException, RbacManagerException
 507     {
 508         boolean allFailed = true;
 509         Exception lastException = null;
 510         for ( RBACManager rbacManager : rbacManagersPerId.values() )
 511         {
 512             try
 513             {
 514                 if ( !rbacManager.isReadOnly() )
 515                 {
 516                     operation = rbacManager.saveOperation( operation );
 517                     allFailed = false;
 518                 }
 519             }
 520             catch ( Exception e )
 521             {
 522                 lastException = e;
 523             }
 524         }
 525
 526         if ( lastException != null && allFailed )
 527         {
 528             throw new RbacManagerException( lastException.getMessage(), lastException );
 529         }
 530         return operation;
 531     }
 532
 533     @Override
 534     public Operation getOperation( String operationName )
 535         throws RbacObjectNotFoundException, RbacManagerException
 536     {
 537
 538         Operation el = operationsCache.get( operationName );
 539         if ( el != null )
 540         {
 541             return el;
 542         }
 543
 544         Exception lastException = null;
 545         for ( RBACManager rbacManager : rbacManagersPerId.values() )
 546         {
 547             try
 548             {
 549                 Operation o = rbacManager.getOperation( operationName );
 550                 if ( o != null )
 551                 {
 552                     operationsCache.put( operationName, o );
 553                     return o;
 554                 }
 555             }
 556             catch ( Exception e )
 557             {
 558                 lastException = e;
 559             }
 560         }
 561
 562         if ( lastException != null )
 563         {
 564             throw new RbacManagerException( lastException.getMessage(), lastException );
 565         }
 566         return null;
 567     }
 568
 569     @Override
 570     public List<Operation> getAllOperations()
 571         throws RbacManagerException
 572     {
 573         Map<String, Operation> allOperations = new HashMap<>();
 574         boolean allFailed = true;
 575         Exception lastException = null;
 576         for ( RBACManager rbacManager : rbacManagersPerId.values() )
 577         {
 578             try
 579             {
 580                 List<? extends Operation> operations = rbacManager.getAllOperations();
 581                 for ( Operation o : operations )
 582                 {
 583                     allOperations.put( o.getName(), o );
 584                 }
 585                 allFailed = false;
 586             }
 587             catch ( Exception e )
 588             {
 589                 lastException = e;
 590             }
 591         }
 592
 593         if ( lastException != null && allFailed )
 594         {
 595             throw new RbacManagerException( lastException.getMessage(), lastException );
 596         }
 597         return new ArrayList<>( allOperations.values() );
 598     }
 599
 600     @Override
 601     public void removeOperation( Operation operation )
 602         throws RbacObjectNotFoundException, RbacObjectInvalidException, RbacManagerException
 603     {
 604         boolean allFailed = true;
 605         Exception lastException = null;
 606         for ( RBACManager rbacManager : rbacManagersPerId.values() )
 607         {
 608             try
 609             {
 610                 rbacManager.removeOperation( operation );
 611                 operationsCache.remove( operation.getName() );
 612                 allFailed = false;
 613             }
 614             catch ( Exception e )
 615             {
 616                 lastException = e;
 617             }
 618         }
 619
 620         if ( lastException != null && allFailed )
 621         {
 622             throw new RbacManagerException( lastException.getMessage(), lastException );
 623         }
 624     }
 625
 626     @Override
 627     public Resource createResource( String identifier )
 628         throws RbacManagerException
 629     {
 630         return getRbacManagerForWrite().createResource( identifier );
 631     }
 632
 633     @Override
 634     public Resource saveResource( Resource resource )
 635         throws RbacObjectInvalidException, RbacManagerException
 636     {
 637         boolean allFailed = true;
 638         Exception lastException = null;
 639         for ( RBACManager rbacManager : rbacManagersPerId.values() )
 640         {
 641             try
 642             {
 643                 if ( !rbacManager.isReadOnly() )
 644                 {
 645                     resource = rbacManager.saveResource( resource );
 646                     allFailed = false;
 647                 }
 648             }
 649             catch ( Exception e )
 650             {
 651                 lastException = e;
 652             }
 653         }
 654
 655         if ( lastException != null && allFailed )
 656         {
 657             throw new RbacManagerException( lastException.getMessage(), lastException );
 658         }
 659         return resource;
 660     }
 661
 662     @Override
 663     public Resource getResource( String resourceIdentifier )
 664         throws RbacObjectNotFoundException, RbacManagerException
 665     {
 666
 667         Resource el = resourcesCache.get( resourceIdentifier );
 668         if ( el != null )
 669         {
 670             return el;
 671         }
 672
 673         Exception lastException = null;
 674         for ( RBACManager rbacManager : rbacManagersPerId.values() )
 675         {
 676             try
 677             {
 678                 Resource r = rbacManager.getResource( resourceIdentifier );
 679                 if ( r != null )
 680                 {
 681                     resourcesCache.put( resourceIdentifier, r );
 682                     return r;
 683                 }
 684             }
 685             catch ( Exception e )
 686             {
 687                 lastException = e;
 688             }
 689         }
 690
 691         if ( lastException != null )
 692         {
 693             throw new RbacManagerException( lastException.getMessage(), lastException );
 694         }
 695         return null;
 696     }
 697
 698     @Override
 699     public List<Resource> getAllResources()
 700         throws RbacManagerException
 701     {
 702         Map<String, Resource> allResources = new HashMap<>();
 703         boolean allFailed = true;
 704         Exception lastException = null;
 705         for ( RBACManager rbacManager : rbacManagersPerId.values() )
 706         {
 707             try
 708             {
 709                 List<? extends Resource> resources = rbacManager.getAllResources();
 710                 for ( Resource r : resources )
 711                 {
 712                     allResources.put( r.getIdentifier(), r );
 713                 }
 714                 allFailed = false;
 715             }
 716             catch ( Exception e )
 717             {
 718                 lastException = e;
 719             }
 720         }
 721
 722         if ( lastException != null && allFailed )
 723         {
 724             throw new RbacManagerException( lastException.getMessage(), lastException );
 725         }
 726         return new ArrayList<>( allResources.values() );
 727     }
 728
 729     @Override
 730     public void removeResource( Resource resource )
 731         throws RbacObjectNotFoundException, RbacObjectInvalidException, RbacManagerException
 732     {
 733         boolean allFailed = true;
 734         Exception lastException = null;
 735         for ( RBACManager rbacManager : rbacManagersPerId.values() )
 736         {
 737             try
 738             {
 739                 rbacManager.removeResource( resource );
 740                 resourcesCache.remove( resource.getIdentifier() );
 741                 allFailed = false;
 742             }
 743             catch ( Exception e )
 744             {
 745                 lastException = e;
 746             }
 747         }
 748
 749         if ( lastException != null && allFailed )
 750         {
 751             throw new RbacManagerException( lastException.getMessage(), lastException );
 752         }
 753     }
 754
 755     @Override
 756     public UserAssignment createUserAssignment( String principal )
 757         throws RbacManagerException
 758     {
 759         return getRbacManagerForWrite().createUserAssignment( principal );
 760     }
 761
 762     @Override
 763     public UserAssignment saveUserAssignment( UserAssignment userAssignment )
 764         throws RbacObjectInvalidException, RbacManagerException
 765     {
 766         boolean allFailed = true;
 767         Exception lastException = null;
 768         for ( RBACManager rbacManager : rbacManagersPerId.values() )
 769         {
 770             try
 771             {
 772                 if ( !rbacManager.isReadOnly() )
 773                 {
 774                     userAssignment = rbacManager.saveUserAssignment( userAssignment );
 775                     allFailed = false;
 776                 }
 777             }
 778             catch ( Exception e )
 779             {
 780                 lastException = e;
 781             }
 782         }
 783
 784         if ( lastException != null && allFailed )
 785         {
 786             throw new RbacManagerException( lastException.getMessage(), lastException );
 787         }
 788         return userAssignment;
 789     }
 790
 791     @Override
 792     public UserAssignment getUserAssignment( String principal )
 793         throws RbacObjectNotFoundException, RbacManagerException
 794     {
 795         UserAssignment el = userAssignmentsCache.get( principal );
 796         if ( el != null )
 797         {
 798             return el;
 799         }
 800         UserAssignment ua = null;
 801         Exception lastException = null;
 802         for ( RBACManager rbacManager : rbacManagersPerId.values() )
 803         {
 804             try
 805             {
 806                 if ( ua == null )
 807                 {
 808                     ua = rbacManager.getUserAssignment( principal );
 809                 }
 810                 else
 811                 {
 812                     UserAssignment userAssignment = rbacManager.getUserAssignment( principal );
 813                     if ( userAssignment != null )
 814                     {
 815                         for ( String roleName : userAssignment.getRoleNames() )
 816                         {
 817                             ua.addRoleName( roleName );
 818                         }
 819                     }
 820                 }
 821             }
 822             catch ( Exception e )
 823             {
 824                 lastException = e;
 825             }
 826         }
 827
 828         if ( ua != null )
 829         {
 830             userAssignmentsCache.put( principal, ua );
 831             return ua;
 832         }
 833
 834         if ( lastException != null )
 835         {
 836             throw new RbacManagerException( lastException.getMessage(), lastException );
 837         }
 838         return null;
 839     }
 840
 841     @Override
 842     public boolean userAssignmentExists( String principal )
 843     {
 844
 845         for ( RBACManager rbacManager : rbacManagersPerId.values() )
 846         {
 847             try
 848             {
 849                 boolean exists = rbacManager.userAssignmentExists( principal );
 850                 if ( exists )
 851                 {
 852                     return true;
 853                 }
 854             }
 855             catch ( Exception e )
 856             {
 857                 // no op
 858             }
 859         }
 860
 861         return false;
 862     }
 863
 864     @Override
 865     public boolean userAssignmentExists( UserAssignment assignment )
 866     {
 867         for ( RBACManager rbacManager : rbacManagersPerId.values() )
 868         {
 869             try
 870             {
 871                 boolean exists = rbacManager.userAssignmentExists( assignment );
 872                 if ( exists )
 873                 {
 874                     return true;
 875                 }
 876             }
 877             catch ( Exception e )
 878             {
 879                 // no op
 880             }
 881         }
 882
 883         return false;
 884     }
 885
 886     @Override
 887     public List<UserAssignment> getAllUserAssignments()
 888         throws RbacManagerException
 889     {
 890         Map<String, UserAssignment> allUserAssignments = new HashMap<>();
 891         boolean allFailed = true;
 892         Exception lastException = null;
 893         for ( RBACManager rbacManager : rbacManagersPerId.values() )
 894         {
 895             try
 896             {
 897                 List<? extends UserAssignment> userAssignments = rbacManager.getAllUserAssignments();
 898                 for ( UserAssignment ua : userAssignments )
 899                 {
 900                     UserAssignment userAssignment = allUserAssignments.get( ua.getPrincipal() );
 901                     if ( userAssignment != null )
 902                     {
 903                         for ( String roleName : ua.getRoleNames() )
 904                         {
 905                             userAssignment.addRoleName( roleName );
 906                         }
 907                     }
 908                     allUserAssignments.put( ua.getPrincipal(), ua );
 909                 }
 910                 allFailed = false;
 911             }
 912             catch ( Exception e )
 913             {
 914                 lastException = e;
 915             }
 916         }
 917
 918         if ( lastException != null && allFailed )
 919         {
 920             throw new RbacManagerException( lastException.getMessage(), lastException );
 921         }
 922         return new ArrayList<>( allUserAssignments.values() );
 923     }
 924
 925     @Override
 926     public List<UserAssignment> getUserAssignmentsForRoles( Collection<String> roleNames )
 927         throws RbacManagerException
 928     {
 929         List<UserAssignment> allUserAssignments = new ArrayList<>();
 930         boolean allFailed = true;
 931         Exception lastException = null;
 932         for ( RBACManager rbacManager : rbacManagersPerId.values() )
 933         {
 934             try
 935             {
 936                 List<? extends UserAssignment> userAssignments = rbacManager.getUserAssignmentsForRoles( roleNames );
 937
 938                 allUserAssignments.addAll( userAssignments );
 939
 940                 allFailed = false;
 941             }
 942             catch ( Exception e )
 943             {
 944                 lastException = e;
 945             }
 946         }
 947
 948         if ( lastException != null && allFailed )
 949         {
 950             throw new RbacManagerException( lastException.getMessage(), lastException );
 951         }
 952         return allUserAssignments;
 953     }
 954
 955     @Override
 956     public void removeUserAssignment( UserAssignment userAssignment )
 957         throws RbacObjectNotFoundException, RbacObjectInvalidException, RbacManagerException
 958     {
 959         boolean allFailed = true;
 960         Exception lastException = null;
 961         for ( RBACManager rbacManager : rbacManagersPerId.values() )
 962         {
 963             try
 964             {
 965                 rbacManager.removeUserAssignment( userAssignment );
 966                 userAssignmentsCache.remove( userAssignment.getPrincipal() );
 967                 allFailed = false;
 968             }
 969             catch ( Exception e )
 970             {
 971                 lastException = e;
 972             }
 973         }
 974
 975         if ( lastException != null && allFailed )
 976         {
 977             throw new RbacManagerException( lastException.getMessage(), lastException );
 978         }
 979     }
 980
 981     @Override
 982     public boolean roleExists( String name )
 983         throws RbacManagerException
 984     {
 985         Role r = rolesCache.get( name );
 986         if ( r != null )
 987         {
 988             return true;
 989         }
 990
 991         boolean allFailed = true;
 992         Exception lastException = null;
 993         for ( RBACManager rbacManager : rbacManagersPerId.values() )
 994         {
 995             try
 996             {
 997                 boolean exists = rbacManager.roleExists( name );
 998                 if ( exists )
 999                 {
1000                     return true;
1001                 }
1002             }
1003             catch ( Exception e )
1004             {
1005                 lastException = e;
1006             }
1007         }
1008
1009         if ( lastException != null && allFailed )
1010         {
1011             throw new RbacManagerException( lastException.getMessage(), lastException );
1012         }
1013         return false;
1014     }
1015
1016     @Override
1017     public boolean roleExists( Role role )
1018         throws RbacManagerException
1019     {
1020         return roleExists( role.getName() );
1021     }
1022
1023     @Override
1024     public void eraseDatabase()
1025     {
1026         log.warn( "eraseDatabase not implemented" );
1027     }
1028
1029     @Override
1030     public boolean isFinalImplementation()
1031     {
1032         return false;
1033     }
1034
1035     @Override
1036     public String getDescriptionKey()
1037     {
1038         return "archiva.redback.rbacmanager.archiva";
1039     }
1040
1041     @Override
1042     public boolean isReadOnly()
1043     {
1044         return false;
1045     }
1046 }