Performance: Cache RoleMaps produced by RoleMap#newMatchingRoleMap()

src/main/java/com/michelin/cio/hudson/plugins/rolestrategy/RoleMap.java

@@ -86,6 +86,16 @@ public class RoleMap {
           .expireAfterWrite(Settings.USER_DETAILS_CACHE_EXPIRATION_TIME_SEC, TimeUnit.SECONDS)
           .build();
 
+  /**
+   * {@link RoleMap}s are created again and again using {@link RoleMap#newMatchingRoleMap(String)}
+   * for different permissions for the same {@code itemNamePrefix}, so cache them and avoid wasting time
+   * matching regular expressions.
+   */
+  private final Cache<String, RoleMap> matchingRoleMapCache = CacheBuilder.newBuilder()
+          .softValues()
+          .maximumSize(2048)
+          .expireAfterWrite(1, TimeUnit.HOURS)
+          .build();
 
   RoleMap() {
     this.grantedRoles = new ConcurrentSkipListMap<Role, Set<String>>();
@@ -193,8 +203,8 @@ public SidACL getACL(RoleType roleType, AccessControlled controlledItem) {
   public void addRole(Role role) {
       if (this.getRole(role.getName()) == null) {
           this.grantedRoles.put(role, new CopyOnWriteArraySet<>());
+          matchingRoleMapCache.invalidateAll();
       }
-
   }
 
   /**
@@ -215,11 +225,10 @@ public void assignRole(Role role, String sid) {
    * @since 2.6.0
    */
   public void unAssignRole(Role role, String sid) {
-    if (this.hasRole(role)) {
-      if (this.grantedRoles.get(role).contains(sid)) {
-        this.grantedRoles.get(role).remove(sid);
+      Set<String> sids = grantedRoles.get(role);
+      if (sids != null) {
+        sids.remove(sid);
       }
-    }
   }
 
   /**
@@ -294,6 +303,7 @@ public Role getRole(String name) {
    */
   public void removeRole(Role role){
       this.grantedRoles.remove(role);
+      matchingRoleMapCache.invalidateAll();
   }
 
 
@@ -354,50 +364,31 @@ public Set<String> getSidsForRole(String roleName) {
   }
 
   /**
-   * Create a sub-map of the current {@link RoleMap} containing only the
-   * {@link Role}s matching the given pattern.
-   * @param namePattern The pattern to match
-   * @return A {@link RoleMap} containing only {@link Role}s matching the given name
+   * Create a sub-map of this {@link RoleMap} containing {@link Role}s that are applicable
+   * on the given {@code itemNamePrefix}.
+   *
+   * @param itemNamePrefix the name of the {@link hudson.model.AbstractItem} or {@link hudson.model.Computer}
+   * @return A {@link RoleMap} containing roles that are applicable on the itemNamePrefix
    */
+  public RoleMap newMatchingRoleMap(String itemNamePrefix) {
+    RoleMap cachedRoleMap = matchingRoleMapCache.getIfPresent(itemNamePrefix);
+    if (cachedRoleMap != null) {
+      return cachedRoleMap;
+    }
 
-  public RoleMap newMatchingRoleMap(String namePattern) {
     SortedMap<Role, Set<String>> roleMap = new TreeMap<>();
     new RoleWalker() {
       public void perform(Role current) {
-        Matcher m = current.getPattern().matcher(namePattern);
+        Matcher m = current.getPattern().matcher(itemNamePrefix);
         if (m.matches()) {
           roleMap.put(current, grantedRoles.get(current));
         }
       }
     };
-    return new RoleMap(roleMap);
-  }
-
-  /**
-   * Get all the roles holding the given permission.
-   * @param permission The permission you want to check
-   * @return A Set of Roles holding the given permission
-   */
-  private Set<Role> getRolesHavingPermission(final Permission permission) {
-    final Set<Role> roles = new HashSet<>();
-    final Set<Permission> permissions = new HashSet<>();
-    Permission p = permission;
-
-    // Get the implying permissions
-    for (; p!=null; p=p.impliedBy) {
-      permissions.add(p);
-    }
-    // Walk through the roles, and only add the roles having the given permission,
-    // or a permission implying the given permission
-    new RoleWalker() {
-      public void perform(Role current) {
-        if (current.hasAnyPermission(permissions)) {
-          roles.add(current);
-        }
-      }
-    };
 
-    return roles;
+    RoleMap newMatchingRoleMap = new RoleMap(roleMap);
+    matchingRoleMapCache.put(itemNamePrefix, newMatchingRoleMap);
+    return newMatchingRoleMap;
   }
 
   /**