org.keycloak.storage.ldap.mappers.membership.group.GroupTreeResolver 連携図

クラス
class	Group

class	GroupTreeEntry

class	GroupTreeResolveException

公開メンバ関数
List< GroupTreeEntry >	resolveGroupTree (List< Group > groups, boolean ignoreMissingGroups) throws GroupTreeResolveException

非公開メンバ関数
Map< String, List< String > >	getParentsTree (List< Group > groups, boolean ignoreMissingGroups) throws GroupTreeResolveException

GroupTreeEntry	resolveGroupTree (String groupName, Map< String, Group > asMap, Set< String > visitedGroups, List< String > currentSubtree) throws GroupTreeResolveException

静的非公開変数類
static final Logger	logger = Logger.getLogger(GroupTreeResolver.class)

詳解

著者: Marek Posolda

関数詳解

◆ getParentsTree()

Map<String, List<String> > org.keycloak.storage.ldap.mappers.membership.group.GroupTreeResolver.getParentsTree	(	List< Group >	groups,
		boolean	ignoreMissingGroups
	)		throws GroupTreeResolveException

inlineprivate

                                                                                                                                        {
         Map<String, List<String>> result = new TreeMap<>();
 
         for (Group group : groups) {
             result.put(group.getGroupName(), new LinkedList<String>());
         }
 
         for (Group group : groups) {
             Iterator<String> iterator = group.getChildrenNames().iterator();
             while (iterator.hasNext()) {
                 String child = iterator.next();
                 List<String> list = result.get(child);
                 if (list != null) {
                     list.add(group.getGroupName());
                 } else if (ignoreMissingGroups) {
                     // Need to remove the missing group
                     iterator.remove();
                     logger.debug("Group '" + child + "' referenced as member of group '" + group.getGroupName() + "' doesn't exists. Ignoring.");
                 } else {
                     throw new GroupTreeResolveException("Group '" + child + "' referenced as member of group '" + group.getGroupName() + "' doesn't exists");
                 }
             }
         }
         return result;
     }

◆ resolveGroupTree() [1/2]

List<GroupTreeEntry> org.keycloak.storage.ldap.mappers.membership.group.GroupTreeResolver.resolveGroupTree	(	List< Group >	groups,
		boolean	ignoreMissingGroups
	)		throws GroupTreeResolveException

inline

Fully resolves list of group trees to be used in Keycloak. The input is group info (usually from LDAP) where each "Group" object contains just it's name and direct children.

The operation also performs validation as rules for LDAP are less strict than for Keycloak (In LDAP, the recursion is possible and multiple parents of single group is also allowed)

引数

groups
ignoreMissingGroups

戻り値

例外

GroupTreeResolveException

                                                                                                                                    {
         // 1- Get parents of each group
         Map<String, List<String>> parentsTree = getParentsTree(groups, ignoreMissingGroups);
 
         // 2 - Get rootGroups (groups without parent) and check if there is no group with multiple parents
         List<String> rootGroups = new LinkedList<>();
         for (Map.Entry<String, List<String>> group : parentsTree.entrySet()) {
             int parentCount = group.getValue().size();
             if (parentCount == 0) {
                 rootGroups.add(group.getKey());
             } else if (parentCount > 1) {
                 throw new GroupTreeResolveException("Group '" + group.getKey() + "' detected to have multiple parents. This is not allowed in Keycloak. Parents are: " + group.getValue());
             }
         }
 
         // 3 - Just convert to map for easier retrieval
         Map<String, Group> asMap = new TreeMap<>();
         for (Group group : groups) {
             asMap.put(group.getGroupName(), group);
         }
 
         // 4 - Now we have rootGroups. Let's resolve them
         List<GroupTreeEntry> finalResult = new LinkedList<>();
         Set<String> visitedGroups = new TreeSet<>();
         for (String rootGroupName : rootGroups) {
             List<String> subtree = new LinkedList<>();
             subtree.add(rootGroupName);
             GroupTreeEntry groupTree = resolveGroupTree(rootGroupName, asMap, visitedGroups, subtree);
             finalResult.add(groupTree);
         }
 
 
         // 5 - Check recursion
         if (visitedGroups.size() != asMap.size()) {
             // Recursion detected. Try to find where it is
             for (Map.Entry<String, Group> entry : asMap.entrySet()) {
                 String groupName = entry.getKey();
                 if (!visitedGroups.contains(groupName)) {
                     List<String> subtree = new LinkedList<>();
                     subtree.add(groupName);
 
                     Set<String> newVisitedGroups = new TreeSet<>();
                     resolveGroupTree(groupName, asMap, newVisitedGroups, subtree);
                     visitedGroups.addAll(newVisitedGroups);
                 }
             }
 
             // Shouldn't happen
             throw new GroupTreeResolveException("Illegal state: Recursion detected, but wasn't able to find it");
         }
 
         return finalResult;
     }

◆ resolveGroupTree() [2/2]

GroupTreeEntry org.keycloak.storage.ldap.mappers.membership.group.GroupTreeResolver.resolveGroupTree	(	String	groupName,
		Map< String, Group >	asMap,
		Set< String >	visitedGroups,
		List< String >	currentSubtree
	)		throws GroupTreeResolveException

inlineprivate

                                                                                                                                                                                  {
         if (visitedGroups.contains(groupName)) {
             throw new GroupTreeResolveException("Recursion detected when trying to resolve group '" + groupName + "'. Whole recursion path: " + currentSubtree);
         }
 
         visitedGroups.add(groupName);
 
         Group group = asMap.get(groupName);
 
         List<GroupTreeEntry> children = new LinkedList<>();
         GroupTreeEntry result =  new GroupTreeEntry(group.getGroupName(), children);
 
         for (String childrenName : group.getChildrenNames()) {
             List<String> subtreeCopy = new LinkedList<>(currentSubtree);
             subtreeCopy.add(childrenName);
             GroupTreeEntry childEntry = resolveGroupTree(childrenName, asMap, visitedGroups, subtreeCopy);
             children.add(childEntry);
         }
 
         return result;
     }

メンバ詳解

◆ logger

final Logger org.keycloak.storage.ldap.mappers.membership.group.GroupTreeResolver.logger = Logger.getLogger(GroupTreeResolver.class)

staticprivate

このクラス詳解は次のファイルから抽出されました:

D:/AppData/doxygen/keycloak/src/keycloak/src/main/java/org/keycloak/storage/ldap/mappers/membership/group/GroupTreeResolver.java

クラス

公開メンバ関数

非公開メンバ関数