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