Java tutorial
/** * 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.component.kestrel; import java.net.URI; import java.util.HashMap; import java.util.Map; import net.spy.memcached.ConnectionFactory; import net.spy.memcached.ConnectionFactoryBuilder; import net.spy.memcached.FailureMode; import net.spy.memcached.MemcachedClient; import org.apache.camel.CamelContext; import org.apache.camel.RuntimeCamelException; import org.apache.camel.impl.DefaultComponent; import org.apache.camel.util.ServiceHelper; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; /** * Camel component which offers queueing over the Memcached protocol * as supported by Kestrel. */ public class KestrelComponent extends DefaultComponent { private static final transient Log LOG = LogFactory.getLog(KestrelComponent.class); private KestrelConfiguration configuration; private ConnectionFactory memcachedConnectionFactory; /** * We cache the memcached clients by queue for reuse */ private final Map<String, MemcachedClient> memcachedClientCache = new HashMap<String, MemcachedClient>(); public KestrelComponent() { configuration = new KestrelConfiguration(); } public KestrelComponent(KestrelConfiguration configuration) { this.configuration = configuration; } public KestrelComponent(CamelContext context) { super(context); configuration = new KestrelConfiguration(); } @Override protected void doStart() throws Exception { super.doStart(); ConnectionFactoryBuilder builder = new ConnectionFactoryBuilder(); // We never want spymemcached to time out builder.setOpTimeout(9999999); // Retry upon failure builder.setFailureMode(FailureMode.Retry); memcachedConnectionFactory = builder.build(); } public KestrelConfiguration getConfiguration() { return configuration; } public void setConfiguration(KestrelConfiguration configuration) { this.configuration = configuration; } @SuppressWarnings("unchecked") protected KestrelEndpoint createEndpoint(String uri, String remaining, Map parameters) throws Exception { // Copy the configuration as each endpoint can override defaults KestrelConfiguration config = getConfiguration().copy(); // Parse the URI, expected to be in one of the following formats: // 1. Use the base KestrelConfiguration for host addresses: // kestrel://queue[?parameters] // kestrel:///queue[?parameters] // 2. Override the host, but use the default port: // kestrel://host/queue[?parameters] // 3. Override the host and port: // kestrel://host:port/queue[?parameters] // 4. Supply a list of host addresses: // kestrel://host[:port],host[:port]/queue[?parameters] URI u = new URI(uri); String queue; String[] addresses = null; if (u.getPath() == null || "".equals(u.getPath())) { // This would be the case when they haven't specified any explicit // address(es), and the queue ends up in the "authority" portion of // the URI. For example: // kestrel://queue[?parameters] queue = u.getAuthority(); } else if (u.getAuthority() == null || "".equals(u.getAuthority())) { // The "path" was present without an authority, such as: // kestrel:///queue[?parameters] queue = u.getPath(); } else { // Both "path" and "authority" were present in the URI, which // means both address(es) and the queue were specified, i.e.: // kestrel://host/queue[?parameters] // kestrel://host:port/queue[?parameters] // kestrel://host[:port],host[:port]/queue[?parameters] addresses = u.getAuthority().split(","); queue = u.getPath(); } // Trim off any slash(es), i.e. "/queue/" -> "queue" while (queue.startsWith("/")) { queue = queue.substring(1); } while (queue.endsWith("/")) { queue = queue.substring(0, queue.length() - 1); } if ("".equals(queue)) { // This would be the case if the URI didn't include a path, or if // the path was just "/" or something...throw an exception. throw new IllegalArgumentException("Queue not specified in endpoint URI: " + uri); } if (addresses != null && addresses.length > 0) { // Override the addresses on the copied config config.setAddresses(addresses); } else { // Explicit address(es) weren't specified on the URI, which is // no problem...just default the addresses to whatever was set on // the base KestrelConfiguration. And since we've already copied // the config, there's nothing else we need to do there. But let's // make sure the addresses field was indeed set on the base config. if (config.getAddresses() == null) { throw new IllegalArgumentException("Addresses not set in base configuration or endpoint: " + uri); } } LOG.info("Creating endpoint for queue \"" + queue + "\" on " + config.getAddressesAsString() + ", parameters=" + parameters); // Finally, override config with any supplied URI parameters setProperties(config, parameters); // Create the endpoint for the given queue with the config we built return new KestrelEndpoint(uri, this, config, queue); } public MemcachedClient getMemcachedClient(KestrelConfiguration config, String queue) { String key = config.getAddressesAsString() + "/" + queue; MemcachedClient memcachedClient = memcachedClientCache.get(key); if (memcachedClient != null) { return memcachedClient; } synchronized (memcachedClientCache) { if ((memcachedClient = memcachedClientCache.get(key)) == null) { LOG.info("Creating MemcachedClient for " + key); try { memcachedClient = new MemcachedClient(memcachedConnectionFactory, config.getInetSocketAddresses()); } catch (Exception e) { throw new RuntimeCamelException("Failed to connect to " + key, e); } memcachedClientCache.put(key, memcachedClient); } } return memcachedClient; } public void closeMemcachedClient(String key, MemcachedClient memcachedClient) { try { if (LOG.isDebugEnabled()) { LOG.debug("Closing client connection to " + key); } memcachedClient.shutdown(); memcachedClientCache.remove(key); } catch (Exception e) { LOG.warn("Failed to close client connection to " + key, e); } } @Override protected synchronized void doStop() throws Exception { // Use a copy so we can clear the memcached client cache eagerly Map<String, MemcachedClient> copy; synchronized (memcachedClientCache) { copy = new HashMap<String, MemcachedClient>(memcachedClientCache); memcachedClientCache.clear(); } for (Map.Entry<String, MemcachedClient> entry : copy.entrySet()) { closeMemcachedClient(entry.getKey(), entry.getValue()); } super.doStop(); } }