fd8799f4f31fdac7f49576f2b49fbb0d8e034867
[controller.git] / opendaylight / appauth / src / main / java / org / opendaylight / controller / appauth / authorization / Authorization.java
1
2 /*
3  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
4  *
5  * This program and the accompanying materials are made available under the
6  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
7  * and is available at http://www.eclipse.org/legal/epl-v10.html
8  */
9
10 package org.opendaylight.controller.appauth.authorization;
11
12 import java.util.ArrayList;
13 import java.util.HashSet;
14 import java.util.List;
15 import java.util.Map.Entry;
16 import java.util.Set;
17 import java.util.concurrent.ConcurrentMap;
18
19 import org.opendaylight.controller.sal.authorization.AppRoleLevel;
20 import org.opendaylight.controller.sal.authorization.IResourceAuthorization;
21 import org.opendaylight.controller.sal.authorization.Privilege;
22 import org.opendaylight.controller.sal.authorization.Resource;
23 import org.opendaylight.controller.sal.authorization.ResourceGroup;
24 import org.opendaylight.controller.sal.authorization.UserLevel;
25 import org.opendaylight.controller.sal.utils.ServiceHelper;
26 import org.opendaylight.controller.sal.utils.Status;
27 import org.opendaylight.controller.sal.utils.StatusCode;
28 import org.opendaylight.controller.usermanager.IUserManager;
29 import org.slf4j.Logger;
30 import org.slf4j.LoggerFactory;
31
32 /**
33  * This abstract class implements the methods defined by IResourceAuthorization
34  * interface for each application class.
35  */
36 public abstract class Authorization<T> implements IResourceAuthorization {
37 private static final Logger logger = LoggerFactory.getLogger(Authorization.class);
38     private static final String namesRegex = "^[a-zA-Z0-9]+[{\\.|\\_|\\-}[a-zA-Z0-9]]*$";
39     /*
40      * The configured resource groups
41      */
42     protected ConcurrentMap<String, Set<T>> resourceGroups;
43     /*
44      * The configured roles along with their level
45      */
46     protected ConcurrentMap<String, AppRoleLevel> roles;
47     /*
48      * The association of groups to roles
49      */
50     protected ConcurrentMap<String, Set<ResourceGroup>> groupsAuthorizations;
51     /*
52      * The name of the default group. It is the group which contains all the
53      * resources
54      */
55     protected String allResourcesGroupName;
56
57     @Override
58     public Status createRole(String role, AppRoleLevel level) {
59         if (role == null || role.trim().isEmpty()
60                 || !role.matches(Authorization.namesRegex)) {
61             return new Status(StatusCode.BADREQUEST,
62                     "Role name must start with alphanumeric, no special characters.");
63         }
64         if (isControllerRole(role)) {
65             return new Status(StatusCode.NOTALLOWED,
66                     "Controller roles cannot be explicitely "
67                             + "created in App context");
68         }
69         if (isRoleInUse(role)) {
70             return new Status(StatusCode.CONFLICT, "Role already in use");
71         }
72         if (roles.containsKey(role)) {
73             if (roles.get(role).equals(level)) {
74                 return new Status(StatusCode.SUCCESS, "Role is already present");
75             } else {
76                 return new Status(StatusCode.BADREQUEST,
77                         "Role exists and has different level");
78             }
79         }
80
81         return createRoleInternal(role, level);
82     }
83
84     protected Status createRoleInternal(String role, AppRoleLevel level) {
85         roles.put(role, level);
86         groupsAuthorizations.put(role, new HashSet<ResourceGroup>());
87         return new Status(StatusCode.SUCCESS);
88     }
89
90     @Override
91     public Status removeRole(String role) {
92         if (role == null || role.trim().isEmpty()) {
93             return new Status(StatusCode.BADREQUEST, "Role name can't be empty");
94         }
95         if (isControllerRole(role)) {
96             return new Status(StatusCode.NOTALLOWED,
97                     "Controller roles cannot be removed");
98         }
99
100         return removeRoleInternal(role);
101     }
102
103     protected Status removeRoleInternal(String role) {
104         groupsAuthorizations.remove(role);
105         roles.remove(role);
106         return new Status(StatusCode.SUCCESS);
107     }
108
109     @Override
110     public List<String> getRoles() {
111         return new ArrayList<String>(groupsAuthorizations.keySet());
112     }
113
114     @SuppressWarnings("unchecked")
115     @Override
116     public Status createResourceGroup(String groupName, List<Object> resources) {
117         //verify group name not null/empty
118         if (groupName == null || groupName.trim().isEmpty()
119                 || !groupName.matches(Authorization.namesRegex)) {
120             return new Status(StatusCode.BADREQUEST, "Group name must start with alphanumeric, no special characters");
121         }
122         //verify group name is not same as all-resources
123         if (groupName.equals(this.allResourcesGroupName)) {
124             return new Status(StatusCode.NOTALLOWED, "All resource group cannot be created");
125         }
126         //verify group name is unique
127         if (resourceGroups.containsKey(groupName)) {
128             return new Status(StatusCode.CONFLICT, "Group name already exists");
129         }
130
131         //try adding resources, discard if not of type T
132         Set<T> toBeAdded = new HashSet<T>();
133         boolean allAdded = true;
134         for (Object obj : resources) {
135             try {
136                 toBeAdded.add((T) obj);
137             } catch (ClassCastException e) {
138                 allAdded = false;
139             }
140         }
141         resourceGroups.put(groupName, toBeAdded);
142         return (allAdded ? new Status(StatusCode.SUCCESS, "All resources added succesfully") :
143             new Status(StatusCode.SUCCESS, "One or more resources couldn't be added"));
144     }
145
146     public Status addResourceToGroup(String groupName, T resource) {
147         if (groupName == null || groupName.trim().isEmpty()) {
148             return new Status(StatusCode.BADREQUEST, "Invalid group name");
149         }
150
151         Set<T> group = resourceGroups.get(groupName);
152         if (group != null && resource != null) {
153             group.add(resource);
154             // Update cluster
155             resourceGroups.put(groupName, group);
156             return new Status(StatusCode.SUCCESS, "Resource added successfully");
157         }
158
159         return new Status(StatusCode.NOTFOUND, "Group not found or incompatible resource");
160     }
161
162     public Status removeRoleResourceGroupMapping(String groupName) {
163         List<String> affectedRoles = new ArrayList<String>();
164         Status result;
165         for (Entry<String, Set<ResourceGroup>> pairs : groupsAuthorizations.entrySet()) {
166             String role = pairs.getKey();
167             Set<ResourceGroup> groups = pairs.getValue();
168             for (ResourceGroup group : groups) {
169                 if (group.getGroupName().equals(groupName)) {
170                     affectedRoles.add(role);
171                     break;
172                 }
173             }
174         }
175         StringBuffer msg = new StringBuffer();
176         for (String role : affectedRoles) {
177             result = unassignResourceGroupFromRole(groupName, role);
178             if (!result.isSuccess()) {
179                 msg.append(result.getDescription());
180                 msg.append(' ');
181             }
182         }
183
184         if (msg.length() != 0) {
185             return new Status(StatusCode.BADREQUEST, msg.toString());
186         } else {
187             return new Status(StatusCode.SUCCESS);
188         }
189     }
190
191     @Override
192     public Status removeResourceGroup(String groupName) {
193         // Default resource group cannot be deleted
194         if (groupName == null || groupName.trim().isEmpty()) {
195             return new Status(StatusCode.BADREQUEST, "Invalid group name");
196         }
197         if (groupName.equals(this.allResourcesGroupName)) {
198             return new Status(StatusCode.NOTALLOWED,
199                     "All resource group cannot be removed");
200         }
201         resourceGroups.remove(groupName);
202         Status result = removeRoleResourceGroupMapping(groupName);
203
204         return result.isSuccess() ? result :
205             new Status(StatusCode.SUCCESS, "Failed removing group from: " + result.getDescription());
206     }
207
208
209     public Status removeResourceFromGroup(String groupName, T resource) {
210         if (groupName == null || groupName.trim().isEmpty()) {
211             return new Status(StatusCode.BADREQUEST, "Invalid group name");
212         }
213
214         Set<T> group = resourceGroups.get(groupName);
215         if (group != null && group.remove(resource)) {
216             // Update cluster
217             resourceGroups.put(groupName, group);
218             return new Status(StatusCode.SUCCESS, "Resource removed successfully");
219         }
220
221         return new Status(StatusCode.NOTFOUND, "Group/Resource not found");
222     }
223
224
225     /**
226      * Relay the call to user manager
227      */
228     @Override
229     public UserLevel getUserLevel(String userName) {
230         IUserManager userManager = (IUserManager) ServiceHelper
231                 .getGlobalInstance(IUserManager.class, this);
232
233         if (logger.isDebugEnabled()) {
234             logger.debug("User {} has UserLevel {}", userName, userManager.getUserLevel(userName));
235         }
236
237         return (userManager == null) ? UserLevel.NOUSER : userManager
238                 .getUserLevel(userName);
239     }
240
241     @Override
242     public Set<Resource> getAllResourcesforUser(String userName) {
243         Set<Resource> resources = new HashSet<Resource>();
244         IUserManager userManager = (IUserManager) ServiceHelper
245                 .getGlobalInstance(IUserManager.class, this);
246         if (userManager == null) {
247             return new HashSet<Resource>(0);
248         }
249
250         // Get the roles associated with this user
251         List<String> roles = userManager.getUserRoles(userName);
252         if (roles == null) {
253             return resources;
254         }
255
256         for (String role : roles) {
257             // Get our resource groups associated with this role
258             List<ResourceGroup> groups = this.getAuthorizedGroups(role);
259             if (groups.isEmpty()) {
260                 continue;
261             }
262             for (ResourceGroup group : groups) {
263                 // Get the list of resources in this group
264                 List<Object> list = this.getResources(group.getGroupName());
265                 if (list.isEmpty()) {
266                     continue;
267                 }
268                 for (Object resource : list) {
269                     Resource toBeAdded = new Resource(resource,
270                             group.getPrivilege());
271                     /*
272                      * Add the resource to the set if the same resource with
273                      * higher privilege is not present. If the same resource
274                      * with lower privilege is present, remove it. No check on
275                      * same privilege resource as set guarantees no duplicates.
276                      */
277                     Resource existing = higherPrivilegeResourcePresent(
278                             resources, toBeAdded);
279                     if (existing == null) {
280                         resources.add(toBeAdded);
281                     }
282                     existing = lowerPrivilegeResourcePresent(resources,
283                             toBeAdded);
284                     if (existing != null) {
285                         resources.remove(existing);
286                     }
287                 }
288             }
289         }
290
291         if (logger.isDebugEnabled()) {
292             logger.debug("User {} has resources {}", userName, resources);
293         }
294
295         return resources;
296     }
297
298     @Override
299     public List<Resource> getAuthorizedResources(String role) {
300         Set<Resource> resources = new HashSet<Resource>();
301
302         // Get our resource groups associated with this role
303         List<ResourceGroup> groups = this.getAuthorizedGroups(role);
304         if (groups.isEmpty()) {
305             return new ArrayList<Resource>(0);
306         }
307         for (ResourceGroup group : groups) {
308             // Get the list of resources in this group
309             List<Object> list = this.getResources(group.getGroupName());
310             if (list.isEmpty()) {
311                 continue;
312             }
313             for (Object resource : list) {
314                 Resource toBeAdded = new Resource(resource,
315                         group.getPrivilege());
316                 /*
317                  * Add the resource to the set if the same resource with higher
318                  * privilege is not present. If the same resource with lower
319                  * privilege is present, remove it. No check on same privilege
320                  * resource as set guarantees no duplicates.
321                  */
322                 Resource existing = higherPrivilegeResourcePresent(resources,
323                         toBeAdded);
324                 if (existing == null) {
325                     resources.add(toBeAdded);
326                 }
327                 existing = lowerPrivilegeResourcePresent(resources, toBeAdded);
328                 if (existing != null) {
329                     resources.remove(existing);
330                 }
331             }
332         }
333
334         if (logger.isDebugEnabled()) {
335             logger.debug("For the Role {}, Authorized Resources are {}", role, resources);
336         }
337
338         return new ArrayList<Resource>(resources);
339     }
340
341     /**
342      * Given a set of resources and a resource to test, it returns the element
343      * in the set which represent the same resource with a lower privilege
344      * associated to it, if present.
345      *
346      * @param resources
347      * @param resource
348      * @return
349      */
350     private Resource lowerPrivilegeResourcePresent(Set<Resource> resources,
351             Resource resource) {
352
353         if (resource == null || resources == null) {
354             return null;
355         }
356
357         Object resourceElement = resource.getResource();
358         Privilege resourcePrivilege = resource.getPrivilege();
359         for (Resource element : resources) {
360             if (element.getResource().equals(resourceElement)
361                     && element.getPrivilege().ordinal() < resourcePrivilege
362                             .ordinal()) {
363                 return element;
364             }
365         }
366         return null;
367     }
368
369     /**
370      * Given a set of resources and a resource to test, it returns the element
371      * in the set which represents the same resource with an higher privilege,
372      * if present.
373      *
374      * @param resources
375      * @param resource
376      * @return
377      */
378     private Resource higherPrivilegeResourcePresent(Set<Resource> resources,
379             Resource resource) {
380
381         if (resource == null || resources == null) {
382             return null;
383         }
384
385         Object resourceElement = resource.getResource();
386         Privilege resourcePrivilege = resource.getPrivilege();
387         for (Resource element : resources) {
388             if (element.getResource().equals(resourceElement)
389                     && element.getPrivilege().ordinal() > resourcePrivilege
390                             .ordinal()) {
391                 return element;
392             }
393         }
394
395         return null;
396     }
397
398     @Override
399     public Privilege getResourcePrivilege(String userName, Object resource) {
400
401         if (userName == null || userName.trim().isEmpty() || resource == null) {
402             return Privilege.NONE;
403         }
404
405         Set<Resource> hisResources = getAllResourcesforUser(userName);
406         for (Resource element : hisResources) {
407             if (element.getResource().equals(resource)) {
408                 return element.getPrivilege();
409             }
410         }
411
412         return Privilege.NONE;
413     }
414
415     @Override
416     public List<String> getResourceGroups() {
417         return new ArrayList<String>(resourceGroups.keySet());
418     }
419
420     @Override
421     public Status assignResourceGroupToRole(String group, Privilege privilege,
422             String role) {
423         if (group == null || group.trim().isEmpty()) {
424             return new Status(StatusCode.BADREQUEST, "Invalid group name");
425         }
426         if (role == null || role.trim().isEmpty()) {
427             return new Status(StatusCode.BADREQUEST, "Role name can't be empty");
428         }
429         if (isControllerRole(role)) {
430             return new Status(StatusCode.NOTALLOWED,
431                     "No group assignment is accepted for Controller roles");
432         }
433
434         return assignResourceGroupToRoleInternal(group, privilege, role);
435     }
436
437     protected Status assignResourceGroupToRoleInternal(String group, Privilege privilege, String role) {
438         Set<ResourceGroup> roleGroups = groupsAuthorizations.get(role);
439         roleGroups.add(new ResourceGroup(group, privilege));
440         // Update cluster
441         groupsAuthorizations.put(role, roleGroups);
442         return new Status(StatusCode.SUCCESS);
443     }
444
445     @Override
446     public Status assignResourceGroupToRole(String groupName, String roleName) {
447         if (groupName == null || groupName.trim().isEmpty()) {
448             return new Status(StatusCode.BADREQUEST, "Group name can't be empty");
449         }
450         if (roleName == null || roleName.trim().isEmpty()) {
451             return new Status(StatusCode.BADREQUEST, "Role name can't be empty");
452         }
453         // Infer group privilege from role's level
454         Privilege privilege = Privilege.NONE;
455         switch (this.getApplicationRoleLevel(roleName)) {
456         case APPADMIN:
457             privilege = Privilege.WRITE;
458             break;
459         case APPUSER:
460             privilege = Privilege.USE;
461             break;
462         case APPOPERATOR:
463             privilege = Privilege.READ;
464             break;
465         default:
466             break;
467         }
468         return this.assignResourceGroupToRole(groupName, privilege, roleName);
469     }
470
471     @Override
472     public Status unassignResourceGroupFromRole(String group, String role) {
473         if (group == null || group.trim().isEmpty()) {
474             return new Status(StatusCode.BADREQUEST, "Group name can't be empty");
475         }
476         if (role == null || role.trim().isEmpty()) {
477             return new Status(StatusCode.BADREQUEST, "Role name can't be empty");
478         }
479         if (isControllerRole(role)) {
480             return new Status(StatusCode.NOTALLOWED,
481                     "No group assignment change is allowed for "
482                             + "Controller roles");
483         }
484
485         return unassignResourceGroupFromRoleInternal(group, role);
486     }
487
488     protected Status unassignResourceGroupFromRoleInternal(String group, String role) {
489         ResourceGroup target = null;
490         for (ResourceGroup rGroup : groupsAuthorizations.get(role)) {
491             if (rGroup.getGroupName().equals(group)) {
492                 target = rGroup;
493                 break;
494             }
495         }
496         if (target == null) {
497             return new Status(StatusCode.SUCCESS, "Group " + group + " was not assigned to " + role);
498         } else {
499             Set<ResourceGroup> groups = groupsAuthorizations.get(role);
500             groups.remove(target);
501             // Update cluster
502             groupsAuthorizations.put(role, groups);
503             return new Status(StatusCode.SUCCESS);
504
505         }
506     }
507
508     @Override
509     public List<ResourceGroup> getAuthorizedGroups(String role) {
510         return (groupsAuthorizations.containsKey(role)) ? new ArrayList<ResourceGroup>(
511                 groupsAuthorizations.get(role))
512                 : new ArrayList<ResourceGroup>();
513     }
514
515     @Override
516     public List<Object> getResources(String groupName) {
517         return (resourceGroups.containsKey(groupName)) ? new ArrayList<Object>(
518                 resourceGroups.get(groupName)) : new ArrayList<Object>(0);
519     }
520
521     @Override
522     public boolean isApplicationRole(String roleName) {
523         if (roleName == null) {
524             return false;
525         }
526         return roles.containsKey(roleName);
527     }
528
529     @Override
530     public AppRoleLevel getApplicationRoleLevel(String roleName) {
531         if (roleName == null || roleName.trim().isEmpty()) {
532             return AppRoleLevel.NOUSER;
533         }
534
535         if (isControllerRole(roleName)) {
536             if (roleName.equals(UserLevel.NETWORKADMIN.toString()) ||
537                     roleName.equals(UserLevel.SYSTEMADMIN.toString())) {
538                 return AppRoleLevel.APPADMIN;
539             } else {
540                 return AppRoleLevel.APPOPERATOR;
541             }
542         }
543
544         return (roles.containsKey(roleName)) ? roles.get(roleName)
545                 : AppRoleLevel.NOUSER;
546     }
547
548     @Override
549     public AppRoleLevel getUserApplicationLevel(String userName) {
550         List<String> roles = null;
551         IUserManager userManager = (IUserManager) ServiceHelper
552                 .getGlobalInstance(IUserManager.class, this);
553
554         if (userName == null || userName.trim().isEmpty()
555                 || (userManager == null)
556                 || (roles = userManager.getUserRoles(userName)).isEmpty()) {
557             return AppRoleLevel.NOUSER;
558         }
559         AppRoleLevel highestLevel = AppRoleLevel.NOUSER;
560         for (String role : roles) {
561             AppRoleLevel level = getApplicationRoleLevel(role);
562             if (level.ordinal() < highestLevel.ordinal()) {
563                 highestLevel = level;
564             }
565         }
566         return highestLevel;
567     }
568
569     /**
570      * Returns the highest role the specified user has in this application
571      * context
572      *
573      * @param user
574      *            The user name
575      * @return The highest role associated to the user in this application
576      *         context
577      */
578     public String getHighestUserRole(String user) {
579         IUserManager userManager = (IUserManager) ServiceHelper.getGlobalInstance(IUserManager.class, this);
580         String highestRole = "";
581         if (userManager != null && !userManager.getUserRoles(user).isEmpty()) {
582             List<String> roles = userManager.getUserRoles(user);
583             AppRoleLevel highestLevel = AppRoleLevel.NOUSER;
584             for (String role : roles) {
585                 AppRoleLevel current;
586                 if (isApplicationRole(role)
587                         && (current = getApplicationRoleLevel(role)).ordinal() < highestLevel.ordinal()) {
588                     highestRole = role;
589                     highestLevel = current;
590                 }
591             }
592         }
593         return highestRole;
594     }
595
596     private boolean isControllerRole(String role) {
597         return (role.equals(UserLevel.NETWORKADMIN.toString())
598                 || role.equals(UserLevel.SYSTEMADMIN.toString()) || role
599                     .equals(UserLevel.NETWORKOPERATOR.toString()));
600     }
601
602     private boolean isRoleInUse(String role) {
603         IUserManager userManager = (IUserManager) ServiceHelper
604                 .getGlobalInstance(IUserManager.class, this);
605
606         if (userManager == null) {
607             return true;
608         }
609         return userManager.isRoleInUse(role);
610     }
611 }