org.apache.qpid.jms.jndi.JmsInitialContextFactory Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of qpid-jms-client Show documentation
Show all versions of qpid-jms-client Show documentation
The core JMS Client implementation
/*
* 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.qpid.jms.jndi;
import static org.apache.qpid.jms.JmsConnectionFactory.REMOTE_URI_PROP;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.Collections;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Properties;
import java.util.concurrent.ConcurrentHashMap;
import jakarta.jms.Queue;
import jakarta.jms.Topic;
import javax.naming.Context;
import javax.naming.NamingException;
import javax.naming.spi.InitialContextFactory;
import org.apache.qpid.jms.JmsConnectionFactory;
import org.apache.qpid.jms.JmsQueue;
import org.apache.qpid.jms.JmsTopic;
import org.apache.qpid.jms.provider.ProviderFactory;
import org.apache.qpid.jms.util.VariableExpansion;
public class JmsInitialContextFactory implements InitialContextFactory {
static final String[] DEFAULT_CONNECTION_FACTORY_NAMES = {
"ConnectionFactory", "QueueConnectionFactory", "TopicConnectionFactory" };
static final String CONNECTION_FACTORY_KEY_PREFIX = "connectionfactory.";
static final String QUEUE_KEY_PREFIX = "queue.";
static final String TOPIC_KEY_PREFIX = "topic.";
static final String CONNECTION_FACTORY_DEFAULT_KEY_PREFIX = "default." + CONNECTION_FACTORY_KEY_PREFIX;
static final String CONNECTION_FACTORY_PROPERTY_KEY_PREFIX = "property." + CONNECTION_FACTORY_KEY_PREFIX;
static final String DYNAMIC_QUEUES = "dynamicQueues";
static final String DYNAMIC_TOPICS = "dynamicTopics";
@Override
public Context getInitialContext(Hashtable environment) throws NamingException {
// Copy the environment to ensure we don't modify/reference it, it belongs to the caller.
Hashtable environmentCopy = new Hashtable();
environmentCopy.putAll(environment);
String location = null;
if (environmentCopy.containsKey(Context.PROVIDER_URL)) {
location = (String) environment.get(Context.PROVIDER_URL);
} else {
location = System.getProperty(Context.PROVIDER_URL);
}
// If present, check if PROVIDER_URL is a client URI, by seeing if we find a factory for it.
// If we do, set it as the URI to be used for the default connection factories.
boolean providerUri = false;
if (location != null) {
try {
String expanded = expand(location, environmentCopy);
if (ProviderFactory.findProviderFactory(new URI(expanded)) != null) {
environmentCopy.put(CONNECTION_FACTORY_DEFAULT_KEY_PREFIX + REMOTE_URI_PROP, expanded);
providerUri = true;
}
} catch (IOException | URISyntaxException e) {
// Not a valid URI or didnt find a client factory for it.
}
}
try {
// If it wasnt a client URI, check for *optional* properties file to augment given environment
if (!providerUri && location != null) {
BufferedInputStream inputStream;
try {
URL fileURL = new URL(location);
inputStream = new BufferedInputStream(fileURL.openStream());
} catch (MalformedURLException e) {
inputStream = new BufferedInputStream(new FileInputStream(location));
}
Properties p = new Properties();
try {
p.load(inputStream);
} finally {
inputStream.close();
}
for (Map.Entry entry : p.entrySet()) {
String key = String.valueOf(entry.getKey());
String value = String.valueOf(entry.getValue());
environmentCopy.put(key, value);
}
}
} catch (IOException ioe) {
NamingException ne = new NamingException("Unable to load property file: " + location + ".");
ne.initCause(ioe);
throw ne;
}
// Now inspect the environment and create the bindings for the context
Map bindings = new ConcurrentHashMap();
createConnectionFactories(environmentCopy, bindings);
createQueues(environmentCopy, bindings);
createTopics(environmentCopy, bindings);
// Add sub-contexts for dynamic creation on lookup.
// "dynamicQueues/"
bindings.put(DYNAMIC_QUEUES, new LazyCreateContext() {
private static final long serialVersionUID = 6503881346214855588L;
@Override
protected Object createEntry(String name) {
return new JmsQueue(name);
}
});
// "dynamicTopics/"
bindings.put(DYNAMIC_TOPICS, new LazyCreateContext() {
private static final long serialVersionUID = 2019166796234979615L;
@Override
protected Object createEntry(String name) {
return new JmsTopic(name);
}
});
return createContext(environmentCopy, bindings);
}
private void createConnectionFactories(Hashtable environment, Map bindings) throws NamingException {
Map factories = getConnectionFactoryNamesAndURIs(environment);
Map defaults = getConnectionFactoryDefaults(environment);
for (Entry entry : factories.entrySet()) {
String name = entry.getKey();
String uri = entry.getValue();
JmsConnectionFactory factory = null;
try {
factory = createConnectionFactory(name, uri, defaults, environment);
} catch (Exception e) {
NamingException ne = new NamingException("Exception while creating ConnectionFactory '" + name + "'.");
ne.initCause(e);
throw ne;
}
bindings.put(name, factory);
}
}
// Implementation methods
// -------------------------------------------------------------------------
protected ReadOnlyContext createContext(Hashtable environment, Map bindings) {
return new ReadOnlyContext(environment, bindings);
}
protected JmsConnectionFactory createConnectionFactory(String name, String uri, Map defaults, Hashtable environment) throws URISyntaxException {
Map props = new LinkedHashMap();
// Add the defaults which apply to all connection factories
props.putAll(defaults);
// Add any URI entry for this specific factory name
if (uri != null && !uri.trim().isEmpty()) {
props.put(JmsConnectionFactory.REMOTE_URI_PROP, uri);
}
// Add any factory-specific additional properties
props.putAll(getConnectionFactoryProperties(name, environment));
return createConnectionFactory(props);
}
protected Map getConnectionFactoryNamesAndURIs(Map environment) {
Map factories = new LinkedHashMap();
for (Iterator> iter = environment.entrySet().iterator(); iter.hasNext();) {
Map.Entry entry = iter.next();
String key = String.valueOf(entry.getKey());
if (key.toLowerCase().startsWith(CONNECTION_FACTORY_KEY_PREFIX)) {
String factoryName = key.substring(CONNECTION_FACTORY_KEY_PREFIX.length());
String value = null;
if(entry.getValue() != null) {
value = String.valueOf(entry.getValue());
}
factories.put(factoryName, expand(value, environment));
}
}
if (factories.isEmpty()) {
for (int i = 0; i < DEFAULT_CONNECTION_FACTORY_NAMES.length; i++) {
factories.put(DEFAULT_CONNECTION_FACTORY_NAMES[i], null);
}
}
return factories;
}
protected Map getConnectionFactoryDefaults(Map environment) {
Map map = new LinkedHashMap();
map.put(JmsConnectionFactory.REMOTE_URI_PROP, JmsConnectionFactory.getDefaultRemoteAddress());
for (Iterator> iter = environment.entrySet().iterator(); iter.hasNext();) {
Map.Entry entry = iter.next();
String key = String.valueOf(entry.getKey());
if (key.toLowerCase().startsWith(CONNECTION_FACTORY_DEFAULT_KEY_PREFIX)) {
String jndiName = key.substring(CONNECTION_FACTORY_DEFAULT_KEY_PREFIX.length());
String value = String.valueOf(entry.getValue());
map.put(jndiName, expand(value, environment));
}
}
return Collections.unmodifiableMap(map);
}
protected Map getConnectionFactoryProperties(String factoryName, Map environment) {
Map map = new LinkedHashMap();
final String factoryNameSuffix = factoryName + ".";
for (Iterator> iter = environment.entrySet().iterator(); iter.hasNext();) {
Map.Entry entry = iter.next();
String key = String.valueOf(entry.getKey());
if (key.toLowerCase().startsWith(CONNECTION_FACTORY_PROPERTY_KEY_PREFIX)) {
if(key.substring(CONNECTION_FACTORY_PROPERTY_KEY_PREFIX.length()).startsWith(factoryNameSuffix)) {
String propertyName = key.substring(CONNECTION_FACTORY_PROPERTY_KEY_PREFIX.length() + factoryNameSuffix.length());
String value = String.valueOf(entry.getValue());
map.put(propertyName, expand(value, environment));
}
}
}
return map;
}
protected void createQueues(Hashtable environment, Map bindings) {
for (Iterator> iter = environment.entrySet().iterator(); iter.hasNext();) {
Map.Entry entry = iter.next();
String key = entry.getKey().toString();
if (key.startsWith(QUEUE_KEY_PREFIX)) {
String jndiName = key.substring(QUEUE_KEY_PREFIX.length());
String value = expand(entry.getValue().toString(), environment);
bindings.put(jndiName, createQueue(value));
}
}
}
protected void createTopics(Hashtable environment, Map bindings) {
for (Iterator> iter = environment.entrySet().iterator(); iter.hasNext();) {
Map.Entry entry = iter.next();
String key = entry.getKey().toString();
if (key.startsWith(TOPIC_KEY_PREFIX)) {
String jndiName = key.substring(TOPIC_KEY_PREFIX.length());
String value = expand(entry.getValue().toString(), environment);
bindings.put(jndiName, createTopic(value));
}
}
}
/**
* Factory method to create new Queue instances
*/
protected Queue createQueue(String name) {
return new JmsQueue(name);
}
/**
* Factory method to create new Topic instances
*/
protected Topic createTopic(String name) {
return new JmsTopic(name);
}
/**
* Factory method to create a new connection factory using the given properties
*/
protected JmsConnectionFactory createConnectionFactory(Map properties) {
JmsConnectionFactory factory = new JmsConnectionFactory();
Map unused = factory.setProperties(properties);
if (!unused.isEmpty()) {
String msg =
" Not all properties could be set on the ConnectionFactory."
+ " Check the properties are spelled correctly."
+ " Unused properties=[" + unused + "].";
throw new IllegalArgumentException(msg);
}
return factory;
}
protected static String expand(String input, Map environment) {
return VariableExpansion.expand(input, variable -> {
String resolve = VariableExpansion.SYS_PROP_RESOLVER.resolve(variable);
if (resolve == null) {
resolve = VariableExpansion.ENV_VAR_RESOLVER.resolve(variable);
if (resolve == null) {
Object o = environment.get(variable);
if (o != null) {
resolve = String.valueOf(o);
}
}
}
return resolve;
});
}
}