001 /** 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017 package org.apache.camel.impl; 018 019 import java.util.Map; 020 021 import org.apache.camel.CamelContext; 022 import org.apache.camel.Consumer; 023 import org.apache.camel.Endpoint; 024 import org.apache.camel.Exchange; 025 import org.apache.camel.ExchangePattern; 026 import org.apache.camel.PollingConsumer; 027 import org.apache.camel.Processor; 028 import org.apache.camel.Producer; 029 import org.apache.camel.util.ServiceHelper; 030 import org.apache.commons.logging.Log; 031 import org.apache.commons.logging.LogFactory; 032 033 /** 034 * This is an endpoint when sending to it, is intercepted and is routed in a detour 035 * 036 * @version $Revision: 789593 $ 037 */ 038 public class InterceptSendToEndpoint implements Endpoint { 039 040 private static final transient Log LOG = LogFactory.getLog(InterceptSendToEndpoint.class); 041 042 private final Endpoint delegate; 043 private Producer producer; 044 private Processor detour; 045 private boolean skip; 046 047 /** 048 * Intercepts sending to the given endpoint 049 * 050 * @param destination the original endpoint 051 * @param skip <tt>true</tt> to skip sending after the detour to the original endpoint 052 */ 053 public InterceptSendToEndpoint(final Endpoint destination, boolean skip) { 054 this.delegate = destination; 055 this.skip = skip; 056 } 057 058 public void setDetour(Processor detour) { 059 this.detour = detour; 060 } 061 062 public Endpoint getDelegate() { 063 return delegate; 064 } 065 066 public String getEndpointUri() { 067 return delegate.getEndpointUri(); 068 } 069 070 public String getEndpointKey() { 071 return delegate.getEndpointKey(); 072 } 073 074 public Exchange createExchange() { 075 return delegate.createExchange(); 076 } 077 078 public Exchange createExchange(ExchangePattern pattern) { 079 return delegate.createExchange(pattern); 080 } 081 082 public Exchange createExchange(Exchange exchange) { 083 return delegate.createExchange(exchange); 084 } 085 086 public CamelContext getCamelContext() { 087 return delegate.getCamelContext(); 088 } 089 090 public Producer createProducer() throws Exception { 091 producer = delegate.createProducer(); 092 return new Producer() { 093 094 public Endpoint getEndpoint() { 095 return producer.getEndpoint(); 096 } 097 098 public Exchange createExchange() { 099 return producer.createExchange(); 100 } 101 102 public Exchange createExchange(ExchangePattern pattern) { 103 return producer.createExchange(pattern); 104 } 105 106 public Exchange createExchange(Exchange exchange) { 107 return producer.createExchange(exchange); 108 } 109 110 public void process(Exchange exchange) throws Exception { 111 // process the detour so we do the detour routing 112 if (LOG.isDebugEnabled()) { 113 LOG.debug("Sending to endpoint: " + getEndpointUri() + " is intercepted and detoured to: " + detour + " for exchange: " + exchange); 114 } 115 // add header with the real endpoint uri 116 exchange.getIn().setHeader(Exchange.INTERCEPTED_ENDPOINT, delegate.getEndpointUri()); 117 118 detour.process(exchange); 119 // copy OUT to IN 120 if (exchange.hasOut()) { 121 // replace OUT with IN as detour changed something 122 exchange.setIn(exchange.getOut()); 123 exchange.setOut(null); 124 } 125 126 if (!skip) { 127 // route to original destination 128 producer.process(exchange); 129 } else { 130 if (LOG.isDebugEnabled()) { 131 LOG.debug("Stop() means skip sending exchange to original intended destination: " + getEndpointUri() + " for exchange: " + exchange); 132 } 133 } 134 } 135 136 public boolean isSingleton() { 137 return producer.isSingleton(); 138 } 139 140 public void start() throws Exception { 141 ServiceHelper.startService(detour); 142 } 143 144 public void stop() throws Exception { 145 ServiceHelper.stopService(detour); 146 } 147 }; 148 } 149 150 public Consumer createConsumer(Processor processor) throws Exception { 151 return delegate.createConsumer(processor); 152 } 153 154 public PollingConsumer createPollingConsumer() throws Exception { 155 return delegate.createPollingConsumer(); 156 } 157 158 public void configureProperties(Map options) { 159 delegate.configureProperties(options); 160 } 161 162 public void setCamelContext(CamelContext context) { 163 delegate.setCamelContext(context); 164 } 165 166 public boolean isLenientProperties() { 167 return delegate.isLenientProperties(); 168 } 169 170 public boolean isSingleton() { 171 return delegate.isSingleton(); 172 } 173 174 @Override 175 public String toString() { 176 return delegate.toString(); 177 } 178 }