/**
* 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.camel.blueprint;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import org.apache.aries.blueprint.ExtendedBeanMetadata;
import org.apache.aries.blueprint.ext.AbstractPropertyPlaceholder;
import org.apache.aries.blueprint.ext.PropertyPlaceholder;
import org.apache.camel.component.properties.DefaultPropertiesParser;
import org.apache.camel.component.properties.PropertiesComponent;
import org.apache.camel.component.properties.PropertiesParser;
import org.apache.camel.util.ObjectHelper;
import org.osgi.service.blueprint.container.BlueprintContainer;
import org.osgi.service.blueprint.reflect.ComponentMetadata;
/**
* Blueprint {@link PropertiesParser} which supports looking up
* property placeholders from the Blueprint Property Placeholder Service.
* <p/>
* This implementation will sit on top of any existing configured
* {@link PropertiesParser} and will delegate to those in case Blueprint could not
* resolve the property.
*/
public class BlueprintPropertiesParser extends DefaultPropertiesParser {
private final PropertiesComponent propertiesComponent;
private final BlueprintContainer container;
private final PropertiesParser delegate;
private final Set<AbstractPropertyPlaceholder> placeholders = new LinkedHashSet<AbstractPropertyPlaceholder>();
private Method method;
public BlueprintPropertiesParser(PropertiesComponent propertiesComponent, BlueprintContainer container, PropertiesParser delegate) {
this.propertiesComponent = propertiesComponent;
this.container = container;
this.delegate = delegate;
}
/**
* Lookup the ids of the Blueprint property placeholder services in the
* Blueprint container.
*
* @return the ids, will be an empty array if none found.
*/
public String[] lookupPropertyPlaceholderIds() {
List<String> ids = new ArrayList<String>();
for (Object componentId : container.getComponentIds()) {
String id = (String) componentId;
ComponentMetadata meta = container.getComponentMetadata(id);
if (meta instanceof ExtendedBeanMetadata) {
Class<?> clazz = ((ExtendedBeanMetadata) meta).getRuntimeClass();
if (clazz != null && AbstractPropertyPlaceholder.class.isAssignableFrom(clazz)) {
ids.add(id);
}
}
}
return ids.toArray(new String[ids.size()]);
}
/**
* Adds the given Blueprint property placeholder service with the given id
*
* @param id id of the Blueprint property placeholder service to add.
*/
public void addPropertyPlaceholder(String id) {
Object component = container.getComponentInstance(id);
if (component instanceof AbstractPropertyPlaceholder) {
AbstractPropertyPlaceholder placeholder = (AbstractPropertyPlaceholder) component;
placeholders.add(placeholder);
log.debug("Adding Blueprint PropertyPlaceholder: {}", id);
if (method == null) {
try {
method = AbstractPropertyPlaceholder.class.getDeclaredMethod("getProperty", String.class);
method.setAccessible(true);
} catch (NoSuchMethodException e) {
throw new IllegalStateException("Cannot add blueprint property placeholder: " + id
+ " as the method getProperty is not accessible", e);
}
}
}
}
@Override
public String parseProperty(String key, String value, Properties properties) {
log.trace("Parsing property key: {} with value: {}", key, value);
String answer = null;
// prefer any override properties
// this logic is special for BlueprintPropertiesParser as we otherwise prefer
// to use the AbstractPropertyPlaceholder from OSGi blueprint config admins
// service to lookup otherwise
if (key != null && propertiesComponent.getOverrideProperties() != null) {
answer = (String) propertiesComponent.getOverrideProperties().get(key);
}
// lookup key in blueprint and return its value
if (answer == null && key != null) {
for (AbstractPropertyPlaceholder placeholder : placeholders) {
boolean isDefault = false;
if (placeholders.size() > 1) {
// okay we have multiple placeholders and we want to return the answer that
// is not the default placeholder if there is multiple keys
if (placeholder instanceof PropertyPlaceholder) {
Map map = ((PropertyPlaceholder) placeholder).getDefaultProperties();
isDefault = map != null && map.containsKey(key);
}
log.trace("Blueprint property key: {} is part of default properties: {}", key, isDefault);
}
try {
String candidate = (String) ObjectHelper.invokeMethod(method, placeholder, key);
if (candidate != null) {
if (answer == null || !isDefault) {
log.trace("Blueprint parsed candidate property key: {} as value: {}", key, answer);
answer = candidate;
}
}
} catch (Exception ex) {
// Here we just catch the exception and try to use other candidate
}
}
log.debug("Blueprint parsed property key: {} as value: {}", key, answer);
}
// if there is a delegate then let it parse the current answer as it may be jasypt which
// need to decrypt values
if (delegate != null) {
String delegateAnswer = delegate.parseProperty(key, answer != null ? answer : value, properties);
if (delegateAnswer != null) {
answer = delegateAnswer;
log.debug("Delegate property parser parsed the property key: {} as value: {}", key, answer);
}
}
if (answer == null) {
throw new IllegalArgumentException("Property placeholder key: " + key + " not found");
}
log.trace("Returning parsed property key: {} as value: {}", key, answer);
return answer;
}
}