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