libre.sh/keycloak-scim
3
0
Fork 0
Code Issues 15 Pull requests Releases 1 Packages Activity Actions

Fix spelling error in field and classname

Browse source 
It's always a converter, unless electricity is involved.

Closes #10573
This commit is contained in:
Alexander Schwartz 2022-03-08 16:02:14 +01:00 committed by Bruno Oliveira da Silva
parent 7335abaf08
commit 18f391d8c4
15 changed files with 110 additions and 110 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

23
model/map-hot-rod/src/main/java/org/keycloak/models/map/storage/hotRod/HotRodMapStorage.java
View file

@ -29,7 +29,7 @@ import org.keycloak.models.map.common.DeepCloner;
import org.keycloak.models.map.storage.hotRod.common.AbstractHotRodEntity;
import org.keycloak.models.map.storage.hotRod.common.HotRodEntityDelegate;
import org.keycloak.models.map.storage.hotRod.common.HotRodEntityDescriptor;
import org.keycloak.models.map.common.StringKeyConvertor;
import org.keycloak.models.map.common.StringKeyConverter;
import org.keycloak.models.map.storage.MapKeycloakTransaction;
import org.keycloak.models.map.storage.MapStorage;
import org.keycloak.models.map.storage.QueryParameters;
@ -39,7 +39,6 @@ import org.keycloak.models.map.storage.chm.MapFieldPredicates;
import org.keycloak.models.map.storage.chm.MapModelCriteriaBuilder;
import org.keycloak.storage.SearchableModelField;
import java.util.Arrays;
import java.util.Map;
import java.util.Objects;
import java.util.Spliterators;
@ -57,14 +56,14 @@ public class HotRodMapStorage<K, E extends AbstractHotRodEntity, V extends HotRo
private static final Logger LOG = Logger.getLogger(HotRodMapStorage.class);
private final RemoteCache<K, E> remoteCache;
private final StringKeyConvertor<K> keyConvertor;
private final StringKeyConverter<K> keyConverter;
private final HotRodEntityDescriptor<E, V> storedEntityDescriptor;
private final Function<E, V> delegateProducer;
private final DeepCloner cloner;
public HotRodMapStorage(RemoteCache<K, E> remoteCache, StringKeyConvertor<K> keyConvertor, HotRodEntityDescriptor<E, V> storedEntityDescriptor, DeepCloner cloner) {
public HotRodMapStorage(RemoteCache<K, E> remoteCache, StringKeyConverter<K> keyConverter, HotRodEntityDescriptor<E, V> storedEntityDescriptor, DeepCloner cloner) {
this.remoteCache = remoteCache;
this.keyConvertor = keyConvertor;
this.keyConverter = keyConverter;
this.storedEntityDescriptor = storedEntityDescriptor;
this.cloner = cloner;
this.delegateProducer = storedEntityDescriptor.getHotRodDelegateProvider();
@ -72,10 +71,10 @@ public class HotRodMapStorage<K, E extends AbstractHotRodEntity, V extends HotRo
@Override
public V create(V value) {
K key = keyConvertor.fromStringSafe(value.getId());
K key = keyConverter.fromStringSafe(value.getId());
if (key == null) {
key = keyConvertor.yieldNewUniqueKey();
value = cloner.from(keyConvertor.keyToString(key), value);
key = keyConverter.yieldNewUniqueKey();
value = cloner.from(keyConverter.keyToString(key), value);
}
remoteCache.putIfAbsent(key, value.getHotRodEntity());
@ -86,19 +85,19 @@ public class HotRodMapStorage<K, E extends AbstractHotRodEntity, V extends HotRo
@Override
public V read(String key) {
Objects.requireNonNull(key, "Key must be non-null");
K k = keyConvertor.fromStringSafe(key);
K k = keyConverter.fromStringSafe(key);
return delegateProducer.apply(remoteCache.get(k));
}
@Override
public V update(V value) {
K key = keyConvertor.fromStringSafe(value.getId());
K key = keyConverter.fromStringSafe(value.getId());
return delegateProducer.apply(remoteCache.replace(key, value.getHotRodEntity()));
}
@Override
public boolean delete(String key) {
K k = keyConvertor.fromStringSafe(key);
K k = keyConverter.fromStringSafe(key);
return remoteCache.remove(k) != null;
}
@ -193,6 +192,6 @@ public class HotRodMapStorage<K, E extends AbstractHotRodEntity, V extends HotRo
@Override
public MapKeycloakTransaction<V, M> createTransaction(KeycloakSession session) {
Map<SearchableModelField<? super M>, MapModelCriteriaBuilder.UpdatePredicatesFunc<K, V, M>> fieldPredicates = MapFieldPredicates.getPredicates((Class<M>) storedEntityDescriptor.getModelTypeClass());
return new ConcurrentHashMapKeycloakTransaction<>(this, keyConvertor, cloner, fieldPredicates);
return new ConcurrentHashMapKeycloakTransaction<>(this, keyConverter, cloner, fieldPredicates);
}
}

4
model/map-hot-rod/src/main/java/org/keycloak/models/map/storage/hotRod/HotRodMapStorageProvider.java
View file

@ -22,7 +22,7 @@ import org.keycloak.models.map.common.DeepCloner;
import org.keycloak.models.map.storage.hotRod.common.AbstractHotRodEntity;
import org.keycloak.models.map.storage.hotRod.common.HotRodEntityDelegate;
import org.keycloak.models.map.storage.hotRod.common.HotRodEntityDescriptor;
import org.keycloak.models.map.common.StringKeyConvertor;
import org.keycloak.models.map.common.StringKeyConverter;
import org.keycloak.models.map.storage.hotRod.connections.HotRodConnectionProvider;
import org.keycloak.models.map.storage.MapStorage;
import org.keycloak.models.map.storage.MapStorageProvider;
@ -49,7 +49,7 @@ public class HotRodMapStorageProvider implements MapStorageProvider {
@SuppressWarnings("unchecked")
public <E extends AbstractHotRodEntity, V extends HotRodEntityDelegate<E> & AbstractEntity, M> HotRodMapStorage<String, E, V, M> getHotRodStorage(Class<M> modelType, MapStorageProviderFactory.Flag... flags) {
HotRodEntityDescriptor<E, V> entityDescriptor = (HotRodEntityDescriptor<E, V>) factory.getEntityDescriptor(modelType);
return new HotRodMapStorage<>(connectionProvider.getRemoteCache(entityDescriptor.getCacheName()), StringKeyConvertor.StringKey.INSTANCE, entityDescriptor, cloner);
return new HotRodMapStorage<>(connectionProvider.getRemoteCache(entityDescriptor.getCacheName()), StringKeyConverter.StringKey.INSTANCE, entityDescriptor, cloner);
}
@Override

8
model/map-jpa/src/main/java/org/keycloak/models/map/storage/jpa/JpaMapKeycloakTransaction.java
View file

@ -32,8 +32,8 @@ import javax.persistence.criteria.Selection;
import org.keycloak.connections.jpa.JpaKeycloakTransaction;
import static org.keycloak.models.jpa.PaginationUtils.paginateQuery;
import org.keycloak.models.map.common.AbstractEntity;
import org.keycloak.models.map.common.StringKeyConvertor;
import org.keycloak.models.map.common.StringKeyConvertor.UUIDKey;
import org.keycloak.models.map.common.StringKeyConverter;
import org.keycloak.models.map.common.StringKeyConverter.UUIDKey;
import org.keycloak.models.map.storage.MapKeycloakTransaction;
import org.keycloak.models.map.storage.QueryParameters;
import static org.keycloak.models.map.storage.jpa.JpaMapStorageProviderFactory.CLONER;
@ -60,7 +60,7 @@ public abstract class JpaMapKeycloakTransaction<RE extends JpaRootEntity, E exte
JpaRootEntity jpaEntity = entityType.cast(CLONER.from(mapEntity));
CLONER.from(mapEntity);
if (mapEntity.getId() == null) {
jpaEntity.setId(StringKeyConvertor.UUIDKey.INSTANCE.yieldNewUniqueKey().toString());
jpaEntity.setId(StringKeyConverter.UUIDKey.INSTANCE.yieldNewUniqueKey().toString());
}
setEntityVersion(jpaEntity);
em.persist(jpaEntity);
@ -71,7 +71,7 @@ public abstract class JpaMapKeycloakTransaction<RE extends JpaRootEntity, E exte
@SuppressWarnings("unchecked")
public E read(String key) {
if (key == null) return null;
UUID uuid = StringKeyConvertor.UUIDKey.INSTANCE.fromStringSafe(key);
UUID uuid = StringKeyConverter.UUIDKey.INSTANCE.fromStringSafe(key);
if (uuid == null) return null;
return (E) em.find(entityType, uuid);
}

4
model/map-jpa/src/main/java/org/keycloak/models/map/storage/jpa/group/JpaGroupModelCriteriaBuilder.java
View file

@ -30,7 +30,7 @@ import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import org.keycloak.models.GroupModel;
import org.keycloak.models.map.common.StringKeyConvertor;
import org.keycloak.models.map.common.StringKeyConverter;
import org.keycloak.models.map.storage.CriterionNotSupportedException;
import org.keycloak.models.map.storage.jpa.group.entity.JpaGroupEntity;
import org.keycloak.models.map.storage.jpa.JpaModelCriteriaBuilder;
@ -114,7 +114,7 @@ public class JpaGroupModelCriteriaBuilder extends JpaModelCriteriaBuilder<JpaGro
CriteriaBuilder.In<UUID> in = cb.in(root.get("id"));
for (Object id : collectionValues) {
try {
in.value(StringKeyConvertor.UUIDKey.INSTANCE.fromString(Objects.toString(id, null)));
in.value(StringKeyConverter.UUIDKey.INSTANCE.fromString(Objects.toString(id, null)));
} catch (IllegalArgumentException e) {
throw new CriterionNotSupportedException(modelField, op, id + " id is not in uuid format.", e);
}

2
model/map-jpa/src/main/java/org/keycloak/models/map/storage/jpa/role/JpaRoleModelCriteriaBuilder.java
View file

@ -32,7 +32,7 @@ import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import org.keycloak.models.RoleModel;
import org.keycloak.models.RoleModel.SearchableFields;
import org.keycloak.models.map.common.StringKeyConvertor.UUIDKey;
import org.keycloak.models.map.common.StringKeyConverter.UUIDKey;
import org.keycloak.models.map.storage.CriterionNotSupportedException;
import org.keycloak.models.map.storage.jpa.JpaModelCriteriaBuilder;
import org.keycloak.models.map.storage.jpa.role.entity.JpaRoleEntity;

21
model/map-ldap/src/main/java/org/keycloak/models/map/storage/ldap/MapModelCriteriaBuilderAssumingEqualForField.java
View file

@ -18,7 +18,8 @@
package org.keycloak.models.map.storage.ldap;
import org.keycloak.models.map.common.AbstractEntity;
import org.keycloak.models.map.common.StringKeyConvertor;
import org.keycloak.models.map.common.StringKeyConverter;
import org.keycloak.models.map.common.StringKeyConverter;
import org.keycloak.models.map.storage.chm.MapModelCriteriaBuilder;
import org.keycloak.storage.SearchableModelField;
@ -28,16 +29,16 @@ import java.util.function.Predicate;
public class MapModelCriteriaBuilderAssumingEqualForField<K, V extends AbstractEntity, M> extends MapModelCriteriaBuilder<K, V, M> {
private final Map<SearchableModelField<? super M>, UpdatePredicatesFunc<K, V, M>> fieldPredicates;
private final StringKeyConvertor<K> keyConvertor;
private final StringKeyConverter<K> keyConverter;
private final SearchableModelField<? super M> modelFieldThatShouldCompareToTrueForEqual;
public MapModelCriteriaBuilderAssumingEqualForField(StringKeyConvertor<K> keyConvertor, Map<SearchableModelField<? super M>, UpdatePredicatesFunc<K, V, M>> fieldPredicates, SearchableModelField<? super M> modelFieldThatShouldCompareToTrueForEqual) {
this(keyConvertor, fieldPredicates, ALWAYS_TRUE, ALWAYS_TRUE, modelFieldThatShouldCompareToTrueForEqual);
public MapModelCriteriaBuilderAssumingEqualForField(StringKeyConverter<K> keyConverter, Map<SearchableModelField<? super M>, UpdatePredicatesFunc<K, V, M>> fieldPredicates, SearchableModelField<? super M> modelFieldThatShouldCompareToTrueForEqual) {
this(keyConverter, fieldPredicates, ALWAYS_TRUE, ALWAYS_TRUE, modelFieldThatShouldCompareToTrueForEqual);
}
protected MapModelCriteriaBuilderAssumingEqualForField(StringKeyConvertor<K> keyConvertor, Map<SearchableModelField<? super M>, UpdatePredicatesFunc<K, V, M>> fieldPredicates, Predicate<? super K> indexReadFilter, Predicate<? super V> sequentialReadFilter, SearchableModelField<? super M> modelFieldThatShouldCompareToTrueForEqual) {
super(keyConvertor, fieldPredicates, indexReadFilter, sequentialReadFilter);
this.keyConvertor = keyConvertor;
protected MapModelCriteriaBuilderAssumingEqualForField(StringKeyConverter<K> keyConverter, Map<SearchableModelField<? super M>, UpdatePredicatesFunc<K, V, M>> fieldPredicates, Predicate<? super K> indexReadFilter, Predicate<? super V> sequentialReadFilter, SearchableModelField<? super M> modelFieldThatShouldCompareToTrueForEqual) {
super(keyConverter, fieldPredicates, indexReadFilter, sequentialReadFilter);
this.keyConverter = keyConverter;
this.modelFieldThatShouldCompareToTrueForEqual = modelFieldThatShouldCompareToTrueForEqual;
this.fieldPredicates = fieldPredicates;
}
@ -46,7 +47,7 @@ public class MapModelCriteriaBuilderAssumingEqualForField<K, V extends AbstractE
public MapModelCriteriaBuilder<K, V, M> compare(SearchableModelField<? super M> modelField, Operator op, Object... values) {
if (modelField == modelFieldThatShouldCompareToTrueForEqual && op == Operator.EQ) {
return instantiateNewInstance(
keyConvertor,
keyConverter,
fieldPredicates,
ALWAYS_TRUE,
ALWAYS_TRUE);
@ -55,7 +56,7 @@ public class MapModelCriteriaBuilderAssumingEqualForField<K, V extends AbstractE
}
@Override
protected MapModelCriteriaBuilder<K, V, M> instantiateNewInstance(StringKeyConvertor<K> keyConvertor, Map<SearchableModelField<? super M>, UpdatePredicatesFunc<K, V, M>> fieldPredicates, Predicate<? super K> indexReadFilter, Predicate<? super V> sequentialReadFilter) {
return new MapModelCriteriaBuilderAssumingEqualForField<>(keyConvertor, fieldPredicates, indexReadFilter, sequentialReadFilter, modelFieldThatShouldCompareToTrueForEqual);
protected MapModelCriteriaBuilder<K, V, M> instantiateNewInstance(StringKeyConverter<K> keyConverter, Map<SearchableModelField<? super M>, UpdatePredicatesFunc<K, V, M>> fieldPredicates, Predicate<? super K> indexReadFilter, Predicate<? super V> sequentialReadFilter) {
return new MapModelCriteriaBuilderAssumingEqualForField<>(keyConverter, fieldPredicates, indexReadFilter, sequentialReadFilter, modelFieldThatShouldCompareToTrueForEqual);
}
}

4
model/map-ldap/src/main/java/org/keycloak/models/map/storage/ldap/role/LdapRoleMapKeycloakTransaction.java
View file

@ -22,7 +22,7 @@ import org.keycloak.models.ModelException;
import org.keycloak.models.RoleModel;
import org.keycloak.models.map.common.DeepCloner;
import org.keycloak.models.map.common.StreamUtils;
import org.keycloak.models.map.common.StringKeyConvertor;
import org.keycloak.models.map.common.StringKeyConverter;
import org.keycloak.models.map.role.MapRoleEntity;
import org.keycloak.models.map.storage.ModelCriteriaBuilder;
@ -56,7 +56,7 @@ import java.util.stream.Stream;
public class LdapRoleMapKeycloakTransaction extends LdapMapKeycloakTransaction<LdapMapRoleEntityFieldDelegate, MapRoleEntity, RoleModel> {
private final KeycloakSession session;
private final StringKeyConvertor<String> keyConverter = new StringKeyConvertor.StringKey();
private final StringKeyConverter<String> keyConverter = new StringKeyConverter.StringKey();
private final Set<String> deletedKeys = new HashSet<>();
private final LdapMapRoleMapperConfig roleMapperConfig;
private final LdapMapConfig ldapMapConfig;

10
model/map/src/main/java/org/keycloak/models/map/common/StringKeyConvertor.java → model/map/src/main/java/org/keycloak/models/map/common/StringKeyConverter.java
View file

@ -24,7 +24,7 @@ import java.util.UUID;
*
* @author hmlnarik
*/
public interface StringKeyConvertor<K> {
public interface StringKeyConverter<K> {
/**
* Returns String representation of the key from native representation
@ -37,7 +37,7 @@ public interface StringKeyConvertor<K> {
/**
* Returns a new unique primary key for the storage that
* this {@code StringKeyConvertor} belongs to. The uniqueness
* this {@link StringKeyConverter} belongs to. The uniqueness
* needs to be guaranteed by e.g. using database sequences or
* using a random value that is proved sufficiently improbable
* to be repeated.
@ -70,7 +70,7 @@ public interface StringKeyConvertor<K> {
}
}
public static class UUIDKey implements StringKeyConvertor<UUID> {
class UUIDKey implements StringKeyConverter<UUID> {
public static final UUIDKey INSTANCE = new UUIDKey();
@ -85,7 +85,7 @@ public interface StringKeyConvertor<K> {
}
}
public static class StringKey implements StringKeyConvertor<String> {
class StringKey implements StringKeyConverter<String> {
public static final StringKey INSTANCE = new StringKey();
@ -100,7 +100,7 @@ public interface StringKeyConvertor<K> {
}
}
public static class ULongKey implements StringKeyConvertor<Long> {
class ULongKey implements StringKeyConverter<Long> {
public static final ULongKey INSTANCE = new ULongKey();

22
model/map/src/main/java/org/keycloak/models/map/storage/chm/ConcurrentHashMapKeycloakTransaction.java
View file

@ -16,7 +16,7 @@
*/
package org.keycloak.models.map.storage.chm;
import org.keycloak.models.map.common.StringKeyConvertor;
import org.keycloak.models.map.common.StringKeyConverter;
import org.keycloak.models.map.common.AbstractEntity;
import org.keycloak.models.map.common.DeepCloner;
import org.keycloak.models.map.common.UpdatableEntity;
@ -44,7 +44,7 @@ public class ConcurrentHashMapKeycloakTransaction<K, V extends AbstractEntity &
protected boolean rollback;
protected final Map<String, MapTaskWithValue> tasks = new LinkedHashMap<>();
protected final ConcurrentHashMapCrudOperations<V, M> map;
protected final StringKeyConvertor<K> keyConvertor;
protected final StringKeyConverter<K> keyConverter;
protected final DeepCloner cloner;
protected final Map<SearchableModelField<? super M>, UpdatePredicatesFunc<K, V, M>> fieldPredicates;
@ -52,9 +52,9 @@ public class ConcurrentHashMapKeycloakTransaction<K, V extends AbstractEntity &
CREATE, UPDATE, DELETE,
}
public ConcurrentHashMapKeycloakTransaction(ConcurrentHashMapCrudOperations<V, M> map, StringKeyConvertor<K> keyConvertor, DeepCloner cloner, Map<SearchableModelField<? super M>, UpdatePredicatesFunc<K, V, M>> fieldPredicates) {
public ConcurrentHashMapKeycloakTransaction(ConcurrentHashMapCrudOperations<V, M> map, StringKeyConverter<K> keyConverter, DeepCloner cloner, Map<SearchableModelField<? super M>, UpdatePredicatesFunc<K, V, M>> fieldPredicates) {
this.map = map;
this.keyConvertor = keyConvertor;
this.keyConverter = keyConverter;
this.cloner = cloner;
this.fieldPredicates = fieldPredicates;
}
@ -99,7 +99,7 @@ public class ConcurrentHashMapKeycloakTransaction<K, V extends AbstractEntity &
}
private MapModelCriteriaBuilder<K, V, M> createCriteriaBuilder() {
return new MapModelCriteriaBuilder<K, V, M>(keyConvertor, fieldPredicates);
return new MapModelCriteriaBuilder<K, V, M>(keyConverter, fieldPredicates);
}
/**
@ -220,8 +220,8 @@ public class ConcurrentHashMapKeycloakTransaction<K, V extends AbstractEntity &
public V create(V value) {
String key = value.getId();
if (key == null) {
K newKey = keyConvertor.yieldNewUniqueKey();
key = keyConvertor.keyToString(newKey);
K newKey = keyConverter.yieldNewUniqueKey();
key = keyConverter.keyToString(newKey);
value = cloner.from(key, value);
} else {
value = cloner.from(value);
@ -257,7 +257,7 @@ public class ConcurrentHashMapKeycloakTransaction<K, V extends AbstractEntity &
public long delete(QueryParameters<M> queryParameters) {
log.tracef("Adding operation DELETE_BULK");
K artificialKey = keyConvertor.yieldNewUniqueKey();
K artificialKey = keyConverter.yieldNewUniqueKey();
// Remove all tasks that create / update / delete objects deleted by the bulk removal.
final BulkDeleteOperation bdo = new BulkDeleteOperation(queryParameters);
@ -272,14 +272,14 @@ public class ConcurrentHashMapKeycloakTransaction<K, V extends AbstractEntity &
}
}
tasks.put(keyConvertor.keyToString(artificialKey), bdo);
tasks.put(keyConverter.keyToString(artificialKey), bdo);
return res + bdo.getCount();
}
private Stream<V> createdValuesStream(Predicate<? super K> keyFilter, Predicate<? super V> entityFilter) {
return this.tasks.entrySet().stream()
.filter(me -> keyFilter.test(keyConvertor.fromStringSafe(me.getKey())))
.filter(me -> keyFilter.test(keyConverter.fromStringSafe(me.getKey())))
.map(Map.Entry::getValue)
.filter(v -> v.containsCreate() && ! v.isReplace())
.map(MapTaskWithValue::getValue)
@ -411,7 +411,7 @@ public class ConcurrentHashMapKeycloakTransaction<K, V extends AbstractEntity &
Predicate<? super V> entityFilter = mmcb.getEntityFilter();
Predicate<? super K> keyFilter = mmcb.getKeyFilter();
return v -> v == null || ! (keyFilter.test(keyConvertor.fromStringSafe(v.getId())) && entityFilter.test(v));
return v -> v == null || ! (keyFilter.test(keyConverter.fromStringSafe(v.getId())) && entityFilter.test(v));
}
@Override

28
model/map/src/main/java/org/keycloak/models/map/storage/chm/ConcurrentHashMapStorage.java
View file

@ -16,7 +16,7 @@
*/
package org.keycloak.models.map.storage.chm;
import org.keycloak.models.map.common.StringKeyConvertor;
import org.keycloak.models.map.common.StringKeyConverter;
import org.keycloak.models.KeycloakSession;
import org.keycloak.models.map.storage.MapKeycloakTransaction;
import org.keycloak.models.map.common.AbstractEntity;
@ -54,22 +54,22 @@ public class ConcurrentHashMapStorage<K, V extends AbstractEntity & UpdatableEnt
protected final ConcurrentMap<K, V> store = new ConcurrentHashMap<>();
protected final Map<SearchableModelField<? super M>, UpdatePredicatesFunc<K, V, M>> fieldPredicates;
protected final StringKeyConvertor<K> keyConvertor;
protected final StringKeyConverter<K> keyConverter;
protected final DeepCloner cloner;
@SuppressWarnings("unchecked")
public ConcurrentHashMapStorage(Class<M> modelClass, StringKeyConvertor<K> keyConvertor, DeepCloner cloner) {
public ConcurrentHashMapStorage(Class<M> modelClass, StringKeyConverter<K> keyConverter, DeepCloner cloner) {
this.fieldPredicates = MapFieldPredicates.getPredicates(modelClass);
this.keyConvertor = keyConvertor;
this.keyConverter = keyConverter;
this.cloner = cloner;
}
@Override
public V create(V value) {
K key = keyConvertor.fromStringSafe(value.getId());
K key = keyConverter.fromStringSafe(value.getId());
if (key == null) {
key = keyConvertor.yieldNewUniqueKey();
value = cloner.from(keyConvertor.keyToString(key), value);
key = keyConverter.yieldNewUniqueKey();
value = cloner.from(keyConverter.keyToString(key), value);
}
store.putIfAbsent(key, value);
return value;
@ -78,19 +78,19 @@ public class ConcurrentHashMapStorage<K, V extends AbstractEntity & UpdatableEnt
@Override
public V read(String key) {
Objects.requireNonNull(key, "Key must be non-null");
K k = keyConvertor.fromStringSafe(key);
K k = keyConverter.fromStringSafe(key);
return store.get(k);
}
@Override
public V update(V value) {
K key = getKeyConvertor().fromStringSafe(value.getId());
K key = getKeyConverter().fromStringSafe(value.getId());
return store.replace(key, value);
}
@Override
public boolean delete(String key) {
K k = getKeyConvertor().fromStringSafe(key);
K k = getKeyConverter().fromStringSafe(key);
return store.remove(k) != null;
}
@ -129,15 +129,15 @@ public class ConcurrentHashMapStorage<K, V extends AbstractEntity & UpdatableEnt
@SuppressWarnings("unchecked")
public MapKeycloakTransaction<V, M> createTransaction(KeycloakSession session) {
MapKeycloakTransaction<V, M> sessionTransaction = session.getAttribute("map-transaction-" + hashCode(), MapKeycloakTransaction.class);
return sessionTransaction == null ? new ConcurrentHashMapKeycloakTransaction<>(this, keyConvertor, cloner, fieldPredicates) : sessionTransaction;
return sessionTransaction == null ? new ConcurrentHashMapKeycloakTransaction<>(this, keyConverter, cloner, fieldPredicates) : sessionTransaction;
}
public MapModelCriteriaBuilder<K, V, M> createCriteriaBuilder() {
return new MapModelCriteriaBuilder<>(keyConvertor, fieldPredicates);
return new MapModelCriteriaBuilder<>(keyConverter, fieldPredicates);
}
public StringKeyConvertor<K> getKeyConvertor() {
return keyConvertor;
public StringKeyConverter<K> getKeyConverter() {
return keyConverter;
}
@Override

24
model/map/src/main/java/org/keycloak/models/map/storage/chm/ConcurrentHashMapStorageProviderFactory.java
View file

@ -28,7 +28,7 @@ import org.keycloak.models.map.authorization.entity.MapResourceEntityImpl;
import org.keycloak.models.map.authorization.entity.MapResourceServerEntityImpl;
import org.keycloak.models.map.authorization.entity.MapScopeEntity;
import org.keycloak.models.map.authorization.entity.MapScopeEntityImpl;
import org.keycloak.models.map.common.StringKeyConvertor;
import org.keycloak.models.map.common.StringKeyConverter;
import org.keycloak.component.AmphibianProviderFactory;
import org.keycloak.Config.Scope;
import org.keycloak.common.Profile;
@ -90,13 +90,13 @@ public class ConcurrentHashMapStorageProviderFactory implements AmphibianProvide
private final ConcurrentHashMap<String, ConcurrentHashMapStorage<?,?,?>> storages = new ConcurrentHashMap<>();
private final Map<String, StringKeyConvertor> keyConvertors = new HashMap<>();
private final Map<String, StringKeyConverter> keyConverters = new HashMap<>();
private File storageDirectory;
private String suffix;
private StringKeyConvertor defaultKeyConvertor;
private StringKeyConverter defaultKeyConverter;
private final static DeepCloner CLONER = new DeepCloner.Builder()
.genericCloner(Serialization::from)
@ -130,11 +130,11 @@ public class ConcurrentHashMapStorageProviderFactory implements AmphibianProvide
.constructor(MapAuthenticationSessionEntity.class, MapAuthenticationSessionEntityImpl::new)
.build();
private static final Map<String, StringKeyConvertor> KEY_CONVERTORS = new HashMap<>();
private static final Map<String, StringKeyConverter> KEY_CONVERTERS = new HashMap<>();
static {
KEY_CONVERTORS.put("uuid", StringKeyConvertor.UUIDKey.INSTANCE);
KEY_CONVERTORS.put("string", StringKeyConvertor.StringKey.INSTANCE);
KEY_CONVERTORS.put("ulong", StringKeyConvertor.ULongKey.INSTANCE);
KEY_CONVERTERS.put("uuid", StringKeyConverter.UUIDKey.INSTANCE);
KEY_CONVERTERS.put("string", StringKeyConverter.StringKey.INSTANCE);
KEY_CONVERTERS.put("ulong", StringKeyConverter.ULongKey.INSTANCE);
}
@Override
@ -152,9 +152,9 @@ public class ConcurrentHashMapStorageProviderFactory implements AmphibianProvide
}
final String keyType = config.get("keyType", "uuid");
defaultKeyConvertor = getKeyConvertor(keyType);
defaultKeyConverter = getKeyConverter(keyType);
for (String name : getModelNames()) {
keyConvertors.put(name, getKeyConvertor(config.get("keyType." + name, keyType)));
keyConverters.put(name, getKeyConverter(config.get("keyType." + name, keyType)));
}
final String dir = config.get("dir");
@ -178,8 +178,8 @@ public class ConcurrentHashMapStorageProviderFactory implements AmphibianProvide
}
}
private StringKeyConvertor getKeyConvertor(final String keyType) throws IllegalArgumentException {
StringKeyConvertor res = KEY_CONVERTORS.get(keyType);
private StringKeyConverter getKeyConverter(final String keyType) throws IllegalArgumentException {
StringKeyConverter res = KEY_CONVERTERS.get(keyType);
if (res == null) {
throw new IllegalArgumentException("Unknown key type: " + keyType);
}
@ -216,7 +216,7 @@ public class ConcurrentHashMapStorageProviderFactory implements AmphibianProvide
@SuppressWarnings("unchecked")
private <K, V extends AbstractEntity & UpdatableEntity, M> ConcurrentHashMapStorage<K, V, M> loadMap(String mapName,
Class<M> modelType, EnumSet<Flag> flags) {
final StringKeyConvertor kc = keyConvertors.getOrDefault(mapName, defaultKeyConvertor);
final StringKeyConverter kc = keyConverters.getOrDefault(mapName, defaultKeyConverter);
Class<?> valueType = ModelEntityUtil.getEntityType(modelType);
LOG.debugf("Initializing new map storage: %s", mapName);

32
model/map/src/main/java/org/keycloak/models/map/storage/chm/MapModelCriteriaBuilder.java
View file

@ -16,7 +16,7 @@
*/
package org.keycloak.models.map.storage.chm;
import org.keycloak.models.map.common.StringKeyConvertor;
import org.keycloak.models.map.common.StringKeyConverter;
import org.keycloak.models.map.common.AbstractEntity;
import org.keycloak.storage.SearchableModelField;
import java.util.Map;
@ -44,14 +44,14 @@ public class MapModelCriteriaBuilder<K, V extends AbstractEntity, M> implements
private final Predicate<? super K> keyFilter;
private final Predicate<? super V> entityFilter;
private final Map<SearchableModelField<? super M>, UpdatePredicatesFunc<K, V, M>> fieldPredicates;
private final StringKeyConvertor<K> keyConvertor;
private final StringKeyConverter<K> keyConverter;
public MapModelCriteriaBuilder(StringKeyConvertor<K> keyConvertor, Map<SearchableModelField<? super M>, UpdatePredicatesFunc<K, V, M>> fieldPredicates) {
this(keyConvertor, fieldPredicates, ALWAYS_TRUE, ALWAYS_TRUE);
public MapModelCriteriaBuilder(StringKeyConverter<K> keyConverter, Map<SearchableModelField<? super M>, UpdatePredicatesFunc<K, V, M>> fieldPredicates) {
this(keyConverter, fieldPredicates, ALWAYS_TRUE, ALWAYS_TRUE);
}
protected MapModelCriteriaBuilder(StringKeyConvertor<K> keyConvertor, Map<SearchableModelField<? super M>, UpdatePredicatesFunc<K, V, M>> fieldPredicates, Predicate<? super K> indexReadFilter, Predicate<? super V> sequentialReadFilter) {
this.keyConvertor = keyConvertor;
protected MapModelCriteriaBuilder(StringKeyConverter<K> keyConverter, Map<SearchableModelField<? super M>, UpdatePredicatesFunc<K, V, M>> fieldPredicates, Predicate<? super K> indexReadFilter, Predicate<? super V> sequentialReadFilter) {
this.keyConverter = keyConverter;
this.fieldPredicates = fieldPredicates;
this.keyFilter = indexReadFilter;
this.entityFilter = sequentialReadFilter;
@ -73,7 +73,7 @@ public class MapModelCriteriaBuilder<K, V extends AbstractEntity, M> implements
public final MapModelCriteriaBuilder<K, V, M> and(MapModelCriteriaBuilder<K, V, M>... builders) {
Predicate<? super K> resIndexFilter = Stream.of(builders).map(MapModelCriteriaBuilder.class::cast).map(MapModelCriteriaBuilder::getKeyFilter).reduce(keyFilter, Predicate::and);
Predicate<V> resEntityFilter = Stream.of(builders).map(MapModelCriteriaBuilder.class::cast).map(MapModelCriteriaBuilder::getEntityFilter).reduce(entityFilter, Predicate::and);
return instantiateNewInstance(keyConvertor, fieldPredicates, resIndexFilter, resEntityFilter);
return instantiateNewInstance(keyConverter, fieldPredicates, resIndexFilter, resEntityFilter);
}
@SafeVarargs
@ -83,7 +83,7 @@ public class MapModelCriteriaBuilder<K, V extends AbstractEntity, M> implements
Predicate<? super K> resIndexFilter = Stream.of(builders).map(MapModelCriteriaBuilder.class::cast).map(MapModelCriteriaBuilder::getKeyFilter).reduce(ALWAYS_FALSE, Predicate::or);
Predicate<V> resEntityFilter = Stream.of(builders).map(MapModelCriteriaBuilder.class::cast).map(MapModelCriteriaBuilder::getEntityFilter).reduce(ALWAYS_FALSE, Predicate::or);
return instantiateNewInstance(
keyConvertor,
keyConverter,
fieldPredicates,
v -> keyFilter.test(v) && resIndexFilter.test(v),
v -> entityFilter.test(v) && resEntityFilter.test(v)
@ -96,7 +96,7 @@ public class MapModelCriteriaBuilder<K, V extends AbstractEntity, M> implements
Predicate<? super V> resEntityFilter = builder.getEntityFilter() == ALWAYS_TRUE ? ALWAYS_TRUE : builder.getEntityFilter().negate();
return instantiateNewInstance(
keyConvertor,
keyConverter,
fieldPredicates,
v -> keyFilter.test(v) && resIndexFilter.test(v),
v -> entityFilter.test(v) && resEntityFilter.test(v)
@ -123,7 +123,7 @@ public class MapModelCriteriaBuilder<K, V extends AbstractEntity, M> implements
case EXISTS:
case NOT_EXISTS:
case IN:
return instantiateNewInstance(keyConvertor, fieldPredicates, this.keyFilter.and(CriteriaOperator.predicateFor(op, convertedValues)), this.entityFilter);
return instantiateNewInstance(keyConverter, fieldPredicates, this.keyFilter.and(CriteriaOperator.predicateFor(op, convertedValues)), this.entityFilter);
default:
throw new AssertionError("Invalid operator: " + op);
}
@ -137,11 +137,11 @@ public class MapModelCriteriaBuilder<K, V extends AbstractEntity, M> implements
for (int i = 0; i < values.length; i ++) {
Object v = values[i];
if (v instanceof String) {
res[i] = keyConvertor.fromStringSafe((String) v);
res[i] = keyConverter.fromStringSafe((String) v);
} else if (v instanceof Stream) {
res[i] = ((Stream<?>) v).map(o -> (o instanceof String) ? keyConvertor.fromStringSafe((String) o) : o);
res[i] = ((Stream<?>) v).map(o -> (o instanceof String) ? keyConverter.fromStringSafe((String) o) : o);
} else if (v instanceof Collection) {
res[i] = ((List<?>) v).stream().map(o -> (o instanceof String) ? keyConvertor.fromStringSafe((String) o) : o).collect(Collectors.toList());
res[i] = ((List<?>) v).stream().map(o -> (o instanceof String) ? keyConverter.fromStringSafe((String) o) : o).collect(Collectors.toList());
} else if (v == null) {
res[i] = null;
} else {
@ -165,7 +165,7 @@ public class MapModelCriteriaBuilder<K, V extends AbstractEntity, M> implements
final Predicate<V> p = v -> valueComparator.test(getter.apply(v));
resEntityFilter = p.and(entityFilter);
}
return instantiateNewInstance(keyConvertor, fieldPredicates, this.keyFilter, resEntityFilter);
return instantiateNewInstance(keyConverter, fieldPredicates, this.keyFilter, resEntityFilter);
}
/**
@ -174,7 +174,7 @@ public class MapModelCriteriaBuilder<K, V extends AbstractEntity, M> implements
* Subclasses can override this method to instantiate a new instance of their subclass. This allows this class to
* be extendable.
*/
protected MapModelCriteriaBuilder<K, V, M> instantiateNewInstance(StringKeyConvertor<K> keyConvertor, Map<SearchableModelField<? super M>, UpdatePredicatesFunc<K, V, M>> fieldPredicates, Predicate<? super K> indexReadFilter, Predicate<? super V> sequentialReadFilter) {
return new MapModelCriteriaBuilder<>(keyConvertor, fieldPredicates, indexReadFilter, sequentialReadFilter);
protected MapModelCriteriaBuilder<K, V, M> instantiateNewInstance(StringKeyConverter<K> keyConverter, Map<SearchableModelField<? super M>, UpdatePredicatesFunc<K, V, M>> fieldPredicates, Predicate<? super K> indexReadFilter, Predicate<? super V> sequentialReadFilter) {
return new MapModelCriteriaBuilder<>(keyConverter, fieldPredicates, indexReadFilter, sequentialReadFilter);
}
}

12
model/map/src/main/java/org/keycloak/models/map/storage/chm/UserSessionConcurrentHashMapStorage.java
View file

@ -16,7 +16,7 @@
*/
package org.keycloak.models.map.storage.chm;
import org.keycloak.models.map.common.StringKeyConvertor;
import org.keycloak.models.map.common.StringKeyConverter;
import org.keycloak.models.AuthenticatedClientSessionModel;
import org.keycloak.models.KeycloakSession;
import org.keycloak.models.UserSessionModel;
@ -52,13 +52,13 @@ public class UserSessionConcurrentHashMapStorage<K> extends ConcurrentHashMapSto
private final MapKeycloakTransaction<MapAuthenticatedClientSessionEntity, AuthenticatedClientSessionModel> clientSessionTr;
public Transaction(MapKeycloakTransaction<MapAuthenticatedClientSessionEntity, AuthenticatedClientSessionModel> clientSessionTr,
StringKeyConvertor<K> keyConvertor,
StringKeyConverter<K> keyConverter,
DeepCloner cloner,
Map<SearchableModelField<? super UserSessionModel>,
UpdatePredicatesFunc<K,
MapUserSessionEntity,
UserSessionModel>> fieldPredicates) {
super(UserSessionConcurrentHashMapStorage.this, keyConvertor, cloner, fieldPredicates);
super(UserSessionConcurrentHashMapStorage.this, keyConverter, cloner, fieldPredicates);
this.clientSessionTr = clientSessionTr;
}
@ -83,8 +83,8 @@ public class UserSessionConcurrentHashMapStorage<K> extends ConcurrentHashMapSto
@SuppressWarnings("unchecked")
public UserSessionConcurrentHashMapStorage(ConcurrentHashMapStorage<K, MapAuthenticatedClientSessionEntity, AuthenticatedClientSessionModel> clientSessionStore,
StringKeyConvertor<K> keyConvertor, DeepCloner cloner) {
super(UserSessionModel.class, keyConvertor, cloner);
StringKeyConverter<K> keyConverter, DeepCloner cloner) {
super(UserSessionModel.class, keyConverter, cloner);
this.clientSessionStore = clientSessionStore;
}
@ -92,6 +92,6 @@ public class UserSessionConcurrentHashMapStorage<K> extends ConcurrentHashMapSto
@SuppressWarnings("unchecked")
public MapKeycloakTransaction<MapUserSessionEntity, UserSessionModel> createTransaction(KeycloakSession session) {
MapKeycloakTransaction<MapUserSessionEntity, UserSessionModel> sessionTransaction = session.getAttribute("map-transaction-" + hashCode(), MapKeycloakTransaction.class);
return sessionTransaction == null ? new Transaction(clientSessionStore.createTransaction(session), clientSessionStore.getKeyConvertor(), cloner, fieldPredicates) : sessionTransaction;
return sessionTransaction == null ? new Transaction(clientSessionStore.createTransaction(session), clientSessionStore.getKeyConverter(), cloner, fieldPredicates) : sessionTransaction;
}
}

10
testsuite/integration-arquillian/tests/base/src/main/java/org/keycloak/testsuite/updaters/ServerResourceUpdater.java
View file

@ -124,21 +124,21 @@ public abstract class ServerResourceUpdater<T extends ServerResourceUpdater, Res
* @param <V> Type of the objects required by add/remove functions (e.g. IDs)
* @param from Initial collection
* @param to Target collection
* @param client2ServerConvertorGenerator Producer of the convertor. If not needed, just use {@code () -> Functions::identity}.
* @param client2ServerConverterGenerator Producer of the converter. If not needed, just use {@code () -> Functions::identity}.
* This is intentionally a lazy-evaluated function variable because the conversion map often needs to be obtained from the
* server which can be slow operation. This function is called only if the two collections differ.
* @param add Function to add
* @param remove Function to remove
*/
public static <T, V> void updateViaAddRemove(Collection<T> from, Collection<T> to, Supplier<Function<T, V>> client2ServerConvertorGenerator, Consumer<V> add, Consumer<V> remove) {
public static <T, V> void updateViaAddRemove(Collection<T> from, Collection<T> to, Supplier<Function<T, V>> client2ServerConverterGenerator, Consumer<V> add, Consumer<V> remove) {
if (Objects.equals(from, to)) {
return;
}
Function<T, V> client2ServerConvertor = client2ServerConvertorGenerator.get();
Function<T, V> client2ServerConverter = client2ServerConverterGenerator.get();
Set<V> current = from == null ? Collections.EMPTY_SET : from.stream().map(client2ServerConvertor).collect(Collectors.toSet());
Set<V> expected = to == null ? Collections.EMPTY_SET : to.stream().map(client2ServerConvertor).collect(Collectors.toSet());
Set<V> current = from == null ? Collections.EMPTY_SET : from.stream().map(client2ServerConverter).collect(Collectors.toSet());
Set<V> expected = to == null ? Collections.EMPTY_SET : to.stream().map(client2ServerConverter).collect(Collectors.toSet());
expected.stream()
.filter(role -> ! current.contains(role))

16
testsuite/model/src/test/java/org/keycloak/testsuite/model/ConcurrentHashMapStorageTest.java
View file

@ -29,7 +29,7 @@ import org.keycloak.models.map.client.MapClientProviderFactory;
import org.keycloak.models.map.storage.MapStorage;
import org.keycloak.models.map.storage.MapStorageProvider;
import org.keycloak.models.map.storage.MapStorageProviderFactory;
import org.keycloak.models.map.common.StringKeyConvertor;
import org.keycloak.models.map.common.StringKeyConverter;
import org.keycloak.models.map.storage.chm.ConcurrentHashMapStorage;
import org.keycloak.models.map.storage.chm.ConcurrentHashMapStorageProviderFactory;
import org.keycloak.models.utils.KeycloakModelUtils;
@ -93,9 +93,9 @@ public class ConcurrentHashMapStorageTest extends KeycloakModelTest {
assertThat(storage1, notNullValue());
assertThat(storage2, notNullValue());
final StringKeyConvertor<K> kcMain = storageMain.getKeyConvertor();
final StringKeyConvertor<K1> kc1 = storage1.getKeyConvertor();
final StringKeyConvertor<K2> kc2 = storage2.getKeyConvertor();
final StringKeyConverter<K> kcMain = storageMain.getKeyConverter();
final StringKeyConverter<K1> kc1 = storage1.getKeyConverter();
final StringKeyConverter<K2> kc2 = storage2.getKeyConverter();
String idMain = kcMain.keyToString(kcMain.yieldNewUniqueKey());
String id1 = kc1.keyToString(kc1.yieldNewUniqueKey());
@ -155,7 +155,7 @@ public class ConcurrentHashMapStorageTest extends KeycloakModelTest {
assertClientsPersisted(component1Id, component2Id, idMain, id1, id2);
}
private <K,K1> void assertClientDoesNotExist(ConcurrentHashMapStorage<K, MapClientEntity, ClientModel> storage, String id, final StringKeyConvertor<K1> kc, final StringKeyConvertor<K> kcStorage) {
private <K,K1> void assertClientDoesNotExist(ConcurrentHashMapStorage<K, MapClientEntity, ClientModel> storage, String id, final StringKeyConverter<K1> kc, final StringKeyConverter<K> kcStorage) {
// Assert that the other stores do not contain the to-be-created clients (if they use compatible key format)
try {
assertThat(storage.read(id), nullValue());
@ -174,9 +174,9 @@ public class ConcurrentHashMapStorageTest extends KeycloakModelTest {
@SuppressWarnings("unchecked")
ConcurrentHashMapStorage<K2, MapClientEntity, ClientModel> storage2 = (ConcurrentHashMapStorage<K2, MapClientEntity, ClientModel>) (MapStorage) session.getComponentProvider(MapStorageProvider.class, component2Id).getStorage(ClientModel.class);
final StringKeyConvertor<K> kcMain = storageMain.getKeyConvertor();
final StringKeyConvertor<K1> kc1 = storage1.getKeyConvertor();
final StringKeyConvertor<K2> kc2 = storage2.getKeyConvertor();
final StringKeyConverter<K> kcMain = storageMain.getKeyConverter();
final StringKeyConverter<K1> kc1 = storage1.getKeyConverter();
final StringKeyConverter<K2> kc2 = storage2.getKeyConverter();
// Assert that the stores contain the created clients
assertThat(storageMain.read(idMain), notNullValue());