/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.sling.jcr.jackrabbit.base.security;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.ConcurrentHashMap;
import javax.jcr.RepositoryException;
import org.apache.jackrabbit.core.security.principal.PrincipalProvider;
import org.apache.jackrabbit.core.security.principal.PrincipalProviderRegistry;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceReference;
import org.osgi.util.tracker.ServiceTracker;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class PrincipalProviderTracker extends ServiceTracker implements PrincipalProviderRegistry{
/**
* Property-Key if the <code>PrincipalProvider</code> configured with
* {@link LoginModuleConfig#PARAM_PRINCIPAL_PROVIDER_CLASS} be registered using the
* specified name instead of the class name which is used by default if the
* name parameter is missing.
*
* @see <a href="https://issues.apache.org/jira/browse/JCR-2629">JCR-2629</a>
*/
private static final String COMPAT_PRINCIPAL_PROVIDER_NAME = "principal_provider.name";
public static final PrincipalProvider[] EMPTY_ARRAY = new PrincipalProvider[0];
private Logger log = LoggerFactory.getLogger(getClass());
private final Map<String, PrincipalProvider> providers = new ConcurrentHashMap<String, PrincipalProvider>();
private final Map<ServiceReference, String> refToNameMapping = new ConcurrentHashMap<ServiceReference, String>();
private PrincipalProvider[] providerArray = EMPTY_ARRAY;
public PrincipalProviderTracker(BundleContext context) {
super(context, PrincipalProvider.class.getName(), null);
}
//~-------------------------------------< ServiceTracker >
@Override
public Object addingService(ServiceReference reference) {
PrincipalProvider provider = (PrincipalProvider) super.addingService(reference);
addProvider(provider,reference);
reloadProviders();
return provider;
}
@Override
public void modifiedService(ServiceReference reference, Object service) {
//Check if the name has changed then re-register the provider
String newName = getProviderName((PrincipalProvider) service,reference);
String oldName = refToNameMapping.get(reference);
if(!equals(newName,oldName)){
if(oldName != null){
providers.remove(oldName);
}
addProvider((PrincipalProvider) service, reference);
reloadProviders();
}
}
@Override
public void removedService(ServiceReference reference, Object service) {
String name = refToNameMapping.remove(reference);
if(name != null){
providers.remove(name);
}
reloadProviders();
}
@Override
public void close() {
super.close();
providers.clear();
refToNameMapping.clear();
providerArray = EMPTY_ARRAY;
}
//~-------------------------------------< PrincipalProviderRegistry >
public PrincipalProvider registerProvider(Properties configuration) throws RepositoryException {
throw new UnsupportedOperationException("The PrincipalProvider are only registered as OSGi services");
}
public PrincipalProvider getDefault() {
throw new UnsupportedOperationException("Default provider is handled via WorkspaceBasedPrincipalProviderRegistry");
}
public PrincipalProvider getProvider(String className) {
return providers.get(className);
}
public PrincipalProvider[] getProviders() {
return providerArray;
}
private void addProvider(PrincipalProvider provider,ServiceReference reference){
String providerName = getProviderName(provider,reference);
if(providers.containsKey(providerName)){
log.warn("Provider with name {} is already registered. PrincipalProvider {} " +
"would not be registered",providerName,reference);
return;
}
providers.put(providerName,provider);
refToNameMapping.put(reference,providerName);
}
private void reloadProviders() {
PrincipalProvider[] providerArray = providers.values().toArray(new PrincipalProvider[providers.size()]);
synchronized (this){
this.providerArray = providerArray;
}
}
private static String getProviderName(PrincipalProvider provider,ServiceReference ref){
String providerName = (String) ref.getProperty(COMPAT_PRINCIPAL_PROVIDER_NAME);
if(providerName == null){
providerName = provider.getClass().getName();
}
return providerName;
}
private static boolean equals(Object object1, Object object2) {
if (object1 == object2) {
return true;
}
if ((object1 == null) || (object2 == null)) {
return false;
}
return object1.equals(object2);
}
}