@SuppressWarnings("unchecked") private void updateCache(ListMultimap<String, ? extends Permission> newPermissions, PermissionCache cacheToUpdate) { for (String name : newPermissions.keySet()) { for (Permission permission : newPermissions.get(name)) { cacheToUpdate.put(name, permission); } } }
/** * Updates the internal global permissions cache. * @param globalPerms new global permissions */ private void updateGlobalCache(ListMultimap<String, Permission> globalPerms) { try { Map<String, GlobalPermission> global = initGlobal(conf); for (String name : globalPerms.keySet()) { for (Permission permission : globalPerms.get(name)) { global.put(name, (GlobalPermission) permission); } } globalCache = global; mtime.incrementAndGet(); } catch (Exception e) { // Never happens LOG.error("Error occurred while updating the global cache", e); } }
@Override public Map<ServerName, List<RegionInfo>> roundRobinAssignment( List<RegionInfo> regions, List<ServerName> servers) throws HBaseIOException { Map<ServerName, List<RegionInfo>> assignments = Maps.newHashMap(); ListMultimap<String,RegionInfo> regionMap = ArrayListMultimap.create(); ListMultimap<String,ServerName> serverMap = ArrayListMultimap.create(); generateGroupMaps(regions, servers, regionMap, serverMap); for(String groupKey : regionMap.keySet()) { if (regionMap.get(groupKey).size() > 0) { Map<ServerName, List<RegionInfo>> result = this.internalBalancer.roundRobinAssignment( regionMap.get(groupKey), serverMap.get(groupKey)); if(result != null) { if(result.containsKey(LoadBalancer.BOGUS_SERVER_NAME) && assignments.containsKey(LoadBalancer.BOGUS_SERVER_NAME)){ assignments.get(LoadBalancer.BOGUS_SERVER_NAME).addAll( result.get(LoadBalancer.BOGUS_SERVER_NAME)); } else { assignments.putAll(result); } } } } return assignments; }
@Override public ServerName randomAssignment(RegionInfo region, List<ServerName> servers) throws HBaseIOException { ListMultimap<String,RegionInfo> regionMap = LinkedListMultimap.create(); ListMultimap<String,ServerName> serverMap = LinkedListMultimap.create(); generateGroupMaps(Lists.newArrayList(region), servers, regionMap, serverMap); List<ServerName> filteredServers = serverMap.get(regionMap.keySet().iterator().next()); return this.internalBalancer.randomAssignment(region, filteredServers); }
List<RegionInfo> regionList = groupToRegion.get(key); RSGroupInfo info = rsGroupInfoManager.getRSGroup(key); List<ServerName> candidateList = filterOfflineServers(info, servers);
public void checkMultimapEqual(ListMultimap<String, UserPermission> first, ListMultimap<String, UserPermission> second) { assertEquals(first.size(), second.size()); for (String key : first.keySet()) { List<UserPermission> firstPerms = first.get(key); List<UserPermission> secondPerms = second.get(key); assertNotNull(secondPerms); assertEquals(firstPerms.size(), secondPerms.size()); LOG.info("First permissions: "+firstPerms.toString()); LOG.info("Second permissions: "+secondPerms.toString()); for (UserPermission p : firstPerms) { assertTrue("Permission "+p.toString()+" not found", secondPerms.contains(p)); } } }
private void generateGroupMaps( List<RegionInfo> regions, List<ServerName> servers, ListMultimap<String, RegionInfo> regionMap, ListMultimap<String, ServerName> serverMap) throws HBaseIOException { try { for (RegionInfo region : regions) { String groupName = rsGroupInfoManager.getRSGroupOfTable(region.getTable()); if (groupName == null) { LOG.info("Group not found for table " + region.getTable() + ", using default"); groupName = RSGroupInfo.DEFAULT_GROUP; } regionMap.put(groupName, region); } for (String groupKey : regionMap.keySet()) { RSGroupInfo info = rsGroupInfoManager.getRSGroup(groupKey); serverMap.putAll(groupKey, filterOfflineServers(info, servers)); if(serverMap.get(groupKey).size() < 1) { serverMap.put(groupKey, LoadBalancer.BOGUS_SERVER_NAME); } } } catch(IOException e) { throw new HBaseIOException("Failed to generate group maps", e); } }
AccessControlUtil.toUsersAndPermissions(builder.build()); List<Permission> userPerms = kvPerms.get(user.getShortName()); if (userPerms != null) { results.addAll(userPerms); if (groupNames != null) { for (String group : groupNames) { List<Permission> groupPerms = kvPerms.get(AuthUtil.toGroupEntry(group)); if (results != null) { results.addAll(groupPerms);
List<UserPermission> user1Perms = perms.get("user1"); assertEquals("Should have 1 permission for user1", 1, user1Perms.size()); assertEquals("user1 should have WRITE permission", user1Perms.get(0).getPermission().getActions()); List<UserPermission> user2Perms = perms.get("user2"); assertEquals("Should have 1 permission for user2", 1, user2Perms.size()); assertEquals("user2 should have CREATE permission", user2Perms.get(0).getPermission().getActions()); List<UserPermission> user3Perms = perms.get("user3"); assertEquals("Should have 1 permission for user3", 1, user3Perms.size()); assertEquals("user3 should have ADMIN, READ, CREATE permission",
.get(testUser.getShortName()); assertNotNull(perms); assertFalse(perms.isEmpty());
perms = AccessControlLists.getNamespacePermissions(conf, TEST_NAMESPACE); assertEquals(7, perms.size()); List<UserPermission> namespacePerms = perms.get(userTestNamespace); assertTrue(perms.containsKey(userTestNamespace)); assertEquals(1, namespacePerms.size());
List<UserPermission> userPerms = perms.get("george"); assertNotNull("Should have permissions for george", userPerms); assertEquals("Should have 1 permission for george", 1, userPerms.size()); assertTrue(actions.contains(TablePermission.Action.WRITE)); userPerms = perms.get("hubert"); assertNotNull("Should have permissions for hubert", userPerms); assertEquals("Should have 1 permission for hubert", 1, userPerms.size()); assertFalse(actions.contains(TablePermission.Action.WRITE)); userPerms = perms.get("humphrey"); assertNotNull("Should have permissions for humphrey", userPerms); assertEquals("Should have 1 permission for humphrey", 1, userPerms.size()); 2, allPerms.size()); userPerms = allPerms.get(TEST_TABLE.getName()).get("hubert"); assertNotNull(userPerms); assertEquals(1, userPerms.size()); assertEquals(Permission.Action.READ, permission.getActions()[0]); userPerms = allPerms.get(TEST_TABLE2.getName()).get("hubert"); assertNotNull(userPerms); assertEquals(1, userPerms.size());
@Override public List<V> get(K key) { synchronized (mutex) { return list(delegate().get(key), mutex); } }
@Override public List<V> get(@Nullable K key) { return delegate().get(key); }
@Override public List<V> get(K key) { return Collections.unmodifiableList(delegate().get(key)); }
@Override public Map<ServerName, List<RegionInfo>> roundRobinAssignment( List<RegionInfo> regions, List<ServerName> servers) throws HBaseIOException { Map<ServerName, List<RegionInfo>> assignments = Maps.newHashMap(); ListMultimap<String,RegionInfo> regionMap = ArrayListMultimap.create(); ListMultimap<String,ServerName> serverMap = ArrayListMultimap.create(); generateGroupMaps(regions, servers, regionMap, serverMap); for(String groupKey : regionMap.keySet()) { if (regionMap.get(groupKey).size() > 0) { Map<ServerName, List<RegionInfo>> result = this.internalBalancer.roundRobinAssignment( regionMap.get(groupKey), serverMap.get(groupKey)); if(result != null) { if(result.containsKey(LoadBalancer.BOGUS_SERVER_NAME) && assignments.containsKey(LoadBalancer.BOGUS_SERVER_NAME)){ assignments.get(LoadBalancer.BOGUS_SERVER_NAME).addAll( result.get(LoadBalancer.BOGUS_SERVER_NAME)); } else { assignments.putAll(result); } } } } return assignments; }
@Override public ServerName randomAssignment(RegionInfo region, List<ServerName> servers) throws HBaseIOException { ListMultimap<String,RegionInfo> regionMap = LinkedListMultimap.create(); ListMultimap<String,ServerName> serverMap = LinkedListMultimap.create(); generateGroupMaps(Lists.newArrayList(region), servers, regionMap, serverMap); List<ServerName> filteredServers = serverMap.get(regionMap.keySet().iterator().next()); return this.internalBalancer.randomAssignment(region, filteredServers); }
@Override public ServerName randomAssignment(RegionInfo region, List<ServerName> servers) throws HBaseIOException { ListMultimap<String,RegionInfo> regionMap = LinkedListMultimap.create(); ListMultimap<String,ServerName> serverMap = LinkedListMultimap.create(); generateGroupMaps(Lists.newArrayList(region), servers, regionMap, serverMap); List<ServerName> filteredServers = serverMap.get(regionMap.keySet().iterator().next()); return this.internalBalancer.randomAssignment(region, filteredServers); }
public void checkMultimapEqual(ListMultimap<String,TablePermission> first, ListMultimap<String,TablePermission> second) { assertEquals(first.size(), second.size()); for (String key : first.keySet()) { List<TablePermission> firstPerms = first.get(key); List<TablePermission> secondPerms = second.get(key); assertNotNull(secondPerms); assertEquals(firstPerms.size(), secondPerms.size()); LOG.info("First permissions: "+firstPerms.toString()); LOG.info("Second permissions: "+secondPerms.toString()); for (TablePermission p : firstPerms) { assertTrue("Permission "+p.toString()+" not found", secondPerms.contains(p)); } } }
private void generateGroupMaps( List<RegionInfo> regions, List<ServerName> servers, ListMultimap<String, RegionInfo> regionMap, ListMultimap<String, ServerName> serverMap) throws HBaseIOException { try { for (RegionInfo region : regions) { String groupName = rsGroupInfoManager.getRSGroupOfTable(region.getTable()); if (groupName == null) { LOG.warn("Group for table "+region.getTable()+" is null"); } regionMap.put(groupName, region); } for (String groupKey : regionMap.keySet()) { RSGroupInfo info = rsGroupInfoManager.getRSGroup(groupKey); serverMap.putAll(groupKey, filterOfflineServers(info, servers)); if(serverMap.get(groupKey).size() < 1) { serverMap.put(groupKey, LoadBalancer.BOGUS_SERVER_NAME); } } } catch(IOException e) { throw new HBaseIOException("Failed to generate group maps", e); } }