1
2
3
4
5
6
7
8
9
10
11 package org.mule.routing.outbound;
12
13 import org.mule.config.i18n.CoreMessages;
14 import org.mule.impl.MuleMessage;
15 import org.mule.impl.endpoint.MuleEndpointURI;
16 import org.mule.umo.UMOException;
17 import org.mule.umo.UMOFilter;
18 import org.mule.umo.UMOMessage;
19 import org.mule.umo.UMOSession;
20 import org.mule.umo.endpoint.EndpointException;
21 import org.mule.umo.endpoint.UMOEndpoint;
22 import org.mule.umo.endpoint.UMOEndpointURI;
23 import org.mule.umo.routing.CouldNotRouteOutboundMessageException;
24 import org.mule.umo.routing.RoutePathNotFoundException;
25 import org.mule.umo.routing.RoutingException;
26 import org.mule.umo.transformer.TransformerException;
27 import org.mule.umo.transformer.UMOTransformer;
28 import org.mule.util.TemplateParser;
29
30 import java.util.HashMap;
31 import java.util.Iterator;
32 import java.util.Map;
33
34
35
36
37
38
39 public class FilteringOutboundRouter extends AbstractOutboundRouter
40 {
41 private UMOTransformer transformer;
42
43 private UMOFilter filter;
44
45 private boolean useTemplates = false;
46
47
48 private TemplateParser parser = TemplateParser.createSquareBracesStyleParser();
49
50 public UMOMessage route(UMOMessage message, UMOSession session, boolean synchronous)
51 throws RoutingException
52 {
53 UMOMessage result = null;
54
55 if (endpoints == null || endpoints.size() == 0)
56 {
57 throw new RoutePathNotFoundException(CoreMessages.noEndpointsForRouter(), message, null);
58 }
59
60 UMOEndpoint ep = getEndpoint(0, message);
61
62 try
63 {
64 if (synchronous)
65 {
66 result = send(session, message, ep);
67 }
68 else
69 {
70 dispatch(session, message, ep);
71 }
72 }
73 catch (UMOException e)
74 {
75 throw new CouldNotRouteOutboundMessageException(message, ep, e);
76 }
77 return result;
78 }
79
80 public UMOFilter getFilter()
81 {
82 return filter;
83 }
84
85 public void setFilter(UMOFilter filter)
86 {
87 this.filter = filter;
88 }
89
90 public boolean isMatch(UMOMessage message) throws RoutingException
91 {
92 if (getFilter() == null)
93 {
94 return true;
95 }
96 if (transformer != null)
97 {
98 try
99 {
100 Object payload = transformer.transform(message.getPayload());
101 message = new MuleMessage(payload, message);
102 }
103 catch (TransformerException e)
104 {
105 throw new RoutingException(
106 CoreMessages.transformFailedBeforeFilter(),
107 message, (UMOEndpoint) endpoints.get(0), e);
108 }
109 }
110 return getFilter().accept(message);
111 }
112
113 public UMOTransformer getTransformer()
114 {
115 return transformer;
116 }
117
118 public void setTransformer(UMOTransformer transformer)
119 {
120 this.transformer = transformer;
121 }
122
123 public void addEndpoint(UMOEndpoint endpoint)
124 {
125 if (!useTemplates && parser.isContainsTemplate(endpoint.getEndpointURI().toString()))
126 {
127 useTemplates = true;
128 }
129 super.addEndpoint(endpoint);
130 }
131
132
133
134
135
136
137
138
139
140
141
142
143 public UMOEndpoint getEndpoint(int index, UMOMessage message)
144 throws CouldNotRouteOutboundMessageException
145 {
146 if (!useTemplates)
147 {
148 return (UMOEndpoint) endpoints.get(index);
149 }
150 else
151 {
152 UMOEndpoint ep = (UMOEndpoint) endpoints.get(index);
153 String uri = ep.getEndpointURI().toString();
154 if (logger.isDebugEnabled())
155 {
156 logger.debug("Uri before parsing is: " + uri);
157 }
158 Map props = new HashMap();
159
160
161 props.putAll(ep.getProperties());
162 for (Iterator iterator = message.getPropertyNames().iterator(); iterator.hasNext();)
163 {
164 String propertyKey = (String) iterator.next();
165 props.put(propertyKey, message.getProperty(propertyKey));
166 }
167 String newUriString = parser.parse(props, uri);
168 if (logger.isDebugEnabled())
169 {
170 logger.debug("Uri after parsing is: " + uri);
171 }
172 try
173 {
174 UMOEndpointURI newUri = new MuleEndpointURI(newUriString);
175 if (!newUri.getScheme().equalsIgnoreCase(ep.getEndpointURI().getScheme()))
176 {
177 throw new CouldNotRouteOutboundMessageException(
178 CoreMessages.schemeCannotChangeForRouter(ep.getEndpointURI().getScheme(),
179 newUri.getScheme()), message, ep);
180 }
181 ep.setEndpointURI(newUri);
182 }
183 catch (EndpointException e)
184 {
185 throw new CouldNotRouteOutboundMessageException(
186 CoreMessages.templateCausedMalformedEndpoint(uri, newUriString),
187 message, ep, e);
188 }
189
190 return ep;
191 }
192 }
193
194 public boolean isUseTemplates()
195 {
196 return useTemplates;
197 }
198
199 public void setUseTemplates(boolean useTemplates)
200 {
201 this.useTemplates = useTemplates;
202 }
203 }