private TriggerKey createTriggerKey(String uri, String remaining, QuartzEndpoint endpoint) throws Exception { // Parse uri for trigger name and group URI u = new URI(uri); String path = ObjectHelper.after(u.getPath(), "/"); String host = u.getHost(); // host can be null if the uri did contain invalid host characters such as an underscore if (host == null) { host = ObjectHelper.before(remaining, "/"); } // Trigger group can be optional, if so set it to this context's unique name String name; String group; if (ObjectHelper.isNotEmpty(path) && ObjectHelper.isNotEmpty(host)) { group = host; name = path; } else { String camelContextName = getCamelContext().getManagementName(); group = camelContextName == null ? "Camel" : "Camel_" + camelContextName; name = host; } if (prefixJobNameWithEndpointId) { name = endpoint.getId() + "_" + name; } return new TriggerKey(name, group); }
public String getEndpointKey() { if (isLenientProperties()) { // only use the endpoint uri without parameters as the properties is // lenient String uri = getEndpointUri(); if (uri.indexOf('?') != -1) { return ObjectHelper.before(uri, "?"); } else { return uri; } } else { // use the full endpoint uri return getEndpointUri(); } }
public static String getCharsetFromContentType(String contentType) { if (contentType != null) { // find the charset and set it to the Exchange int index = contentType.indexOf("charset="); if (index > 0) { String charset = contentType.substring(index + 8); // there may be another parameter after a semi colon, so skip that if (charset.contains(";")) { charset = ObjectHelper.before(charset, ";"); } return IOHelper.normalizeCharset(charset); } } return null; }
/** * Gets the destination name which was configured from the endpoint uri. * * @return the destination name resolved from the endpoint uri */ public String getEndpointConfiguredDestinationName() { String remainder = ObjectHelper.after(getEndpointKey(), "//"); if (remainder != null && remainder.contains("@")) { remainder = remainder.substring(remainder.indexOf('@')); } if (remainder != null && remainder.contains("?")) { // remove parameters remainder = ObjectHelper.before(remainder, "?"); } if (ObjectHelper.isEmpty(remainder)) { return remainder; } return remainder; }
@Override protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception { SparkConfiguration config = getSparkConfiguration().copy(); setProperties(config, parameters); SparkEndpoint answer = new SparkEndpoint(uri, this); answer.setSparkConfiguration(config); answer.setSparkBinding(getSparkBinding()); setProperties(answer, parameters); if (!remaining.contains(":")) { throw new IllegalArgumentException("Invalid syntax. Must be spark-rest:verb:path"); } String verb = ObjectHelper.before(remaining, ":"); String path = ObjectHelper.after(remaining, ":"); answer.setVerb(verb); answer.setPath(path); return answer; }
/** * Get the operation(s) with the given name. We can have multiple when methods is overloaded. * * <p>Shorthand method names for getters is supported, so you can pass in eg 'name' and Camel will * can find the real 'getName' method instead. * * @param methodName the method name * @return the found method, or <tt>null</tt> if not found */ private List<MethodInfo> getOperations(String methodName) { // do not use qualifier for name if (methodName.contains("(")) { methodName = ObjectHelper.before(methodName, "("); } List<MethodInfo> answer = operations.get(methodName); if (answer != null) { return answer; } // now try all getters to see if any of those matched the methodName for (Method method : methodMap.keySet()) { if (IntrospectionSupport.isGetter(method)) { String shorthandMethodName = IntrospectionSupport.getGetterShorthandName(method); // if the two names matches then see if we can find it using that name if (methodName != null && methodName.equals(shorthandMethodName)) { return operations.get(method.getName()); } } } return null; }
/** * Checks whether the given http status code is within the ok range * * @param statusCode the status code * @param okStatusCodeRange the ok range (inclusive) * @return <tt>true</tt> if ok, <tt>false</tt> otherwise */ public static boolean isStatusCodeOk(int statusCode, String okStatusCodeRange) { int from = Integer.valueOf(ObjectHelper.before(okStatusCodeRange, "-")); int to = Integer.valueOf(ObjectHelper.after(okStatusCodeRange, "-")); return statusCode >= from && statusCode <= to; }
@Override public void populateCamelHeaders( HttpRequest request, Map<String, Object> headers, Exchange exchange, NettyHttpConfiguration configuration) throws Exception { LOG.trace("populateCamelHeaders: {}", request); // NOTE: these headers is applied using the same logic as camel-http/camel-jetty to be // consistent headers.put(Exchange.HTTP_METHOD, request.getMethod().getName()); // strip query parameters from the uri String s = request.getUri(); if (s.contains("?")) { s = ObjectHelper.before(s, "?"); } // we want the full path for the url, as the client may provide the url in the HTTP headers as // absolute or relative, eg // /foo // http://servername/foo String http = configuration.isSsl() ? "https://" : "http://"; if (!s.startsWith(http)) { if (configuration.getPort() != 80) { s = http + configuration.getHost() + ":" + configuration.getPort() + s; } else { s = http + configuration.getHost() + s; } } headers.put(Exchange.HTTP_URL, s); // uri is without the host and port URI uri = new URI(request.getUri()); // uri is path and query parameters headers.put(Exchange.HTTP_URI, uri.getPath()); headers.put(Exchange.HTTP_QUERY, uri.getQuery()); headers.put(Exchange.HTTP_RAW_QUERY, uri.getRawQuery()); // strip the starting endpoint path so the path is relative to the endpoint uri String path = uri.getPath(); if (configuration.getPath() != null && path.startsWith(configuration.getPath())) { path = path.substring(configuration.getPath().length()); } headers.put(Exchange.HTTP_PATH, path); if (LOG.isTraceEnabled()) { LOG.trace("HTTP-Method {}", request.getMethod().getName()); LOG.trace("HTTP-Uri {}", request.getUri()); } for (String name : request.headers().names()) { // mapping the content-type if (name.toLowerCase(Locale.US).equals("content-type")) { name = Exchange.CONTENT_TYPE; } if (name.toLowerCase(Locale.US).equals("authorization")) { String value = request.headers().get(name); // store a special header that this request was authenticated using HTTP Basic if (value != null && value.trim().startsWith("Basic")) { if (headerFilterStrategy != null && !headerFilterStrategy.applyFilterToExternalHeaders( NettyHttpConstants.HTTP_AUTHENTICATION, "Basic", exchange)) { NettyHttpHelper.appendHeader(headers, NettyHttpConstants.HTTP_AUTHENTICATION, "Basic"); } } } // add the headers one by one, and use the header filter strategy List<String> values = request.headers().getAll(name); Iterator<?> it = ObjectHelper.createIterator(values); while (it.hasNext()) { Object extracted = it.next(); Object decoded = shouldUrlDecodeHeader(configuration, name, extracted, "UTF-8"); LOG.trace("HTTP-header: {}", extracted); if (headerFilterStrategy != null && !headerFilterStrategy.applyFilterToExternalHeaders(name, decoded, exchange)) { NettyHttpHelper.appendHeader(headers, name, decoded); } } } // add uri parameters as headers to the Camel message if (request.getUri().contains("?")) { String query = ObjectHelper.after(request.getUri(), "?"); Map<String, Object> uriParameters = URISupport.parseQuery(query, false, true); for (Map.Entry<String, Object> entry : uriParameters.entrySet()) { String name = entry.getKey(); Object values = entry.getValue(); Iterator<?> it = ObjectHelper.createIterator(values); while (it.hasNext()) { Object extracted = it.next(); Object decoded = shouldUrlDecodeHeader(configuration, name, extracted, "UTF-8"); LOG.trace("URI-Parameter: {}", extracted); if (headerFilterStrategy != null && !headerFilterStrategy.applyFilterToExternalHeaders(name, decoded, exchange)) { NettyHttpHelper.appendHeader(headers, name, decoded); } } } } // if body is application/x-www-form-urlencoded then extract the body as query string and append // as headers // if it is a bridgeEndpoint we need to skip this part of work if (request.getMethod().getName().equals("POST") && request.headers().get(Exchange.CONTENT_TYPE) != null && request .headers() .get(Exchange.CONTENT_TYPE) .startsWith(NettyHttpConstants.CONTENT_TYPE_WWW_FORM_URLENCODED) && !configuration.isBridgeEndpoint()) { String charset = "UTF-8"; // Push POST form params into the headers to retain compatibility with DefaultHttpBinding String body = request.getContent().toString(Charset.forName(charset)); if (ObjectHelper.isNotEmpty(body)) { for (String param : body.split("&")) { String[] pair = param.split("=", 2); if (pair.length == 2) { String name = shouldUrlDecodeHeader(configuration, "", pair[0], charset); String value = shouldUrlDecodeHeader(configuration, name, pair[1], charset); if (headerFilterStrategy != null && !headerFilterStrategy.applyFilterToExternalHeaders(name, value, exchange)) { NettyHttpHelper.appendHeader(headers, name, value); } } else { throw new IllegalArgumentException( "Invalid parameter, expected to be a pair but was " + param); } } } } }
private MethodInvocation createInvocation(Object pojo, Exchange exchange, Method explicitMethod) throws AmbiguousMethodCallException, MethodNotFoundException { MethodInfo methodInfo = null; // find the explicit method to invoke if (explicitMethod != null) { for (List<MethodInfo> infos : operations.values()) { for (MethodInfo info : infos) { if (explicitMethod.equals(info.getMethod())) { return info.createMethodInvocation(pojo, exchange); } } } throw new MethodNotFoundException(exchange, pojo, explicitMethod.getName()); } String methodName = exchange.getIn().getHeader(Exchange.BEAN_METHOD_NAME, String.class); if (methodName != null) { // do not use qualifier for name String name = methodName; if (methodName.contains("(")) { name = ObjectHelper.before(methodName, "("); // the must be a ending parenthesis if (!methodName.endsWith(")")) { throw new IllegalArgumentException( "Method should end with parenthesis, was " + methodName); } } boolean emptyParameters = methodName.endsWith("()"); // special for getClass, as we want the user to be able to invoke this method // for example to log the class type or the likes if ("class".equals(name) || "getClass".equals(name)) { try { Method method = pojo.getClass().getMethod("getClass"); methodInfo = new MethodInfo( exchange.getContext(), pojo.getClass(), method, Collections.<ParameterInfo>emptyList(), Collections.<ParameterInfo>emptyList(), false, false); } catch (NoSuchMethodException e) { throw new MethodNotFoundException(exchange, pojo, "getClass"); } // special for length on an array type } else if ("length".equals(name) && pojo.getClass().isArray()) { try { // need to use arrayLength method from ObjectHelper as Camel's bean OGNL support is method // invocation based // and not for accessing fields. And hence we need to create a MethodInfo instance with a // method to call // and therefore use arrayLength from ObjectHelper to return the array length field. Method method = ObjectHelper.class.getMethod("arrayLength", Object[].class); ParameterInfo pi = new ParameterInfo( 0, Object[].class, null, ExpressionBuilder.mandatoryBodyExpression(Object[].class, true)); List<ParameterInfo> lpi = new ArrayList<ParameterInfo>(1); lpi.add(pi); methodInfo = new MethodInfo( exchange.getContext(), pojo.getClass(), method, lpi, lpi, false, false); // Need to update the message body to be pojo for the invocation exchange.getIn().setBody(pojo); } catch (NoSuchMethodException e) { throw new MethodNotFoundException(exchange, pojo, "getClass"); } } else { List<MethodInfo> methods = getOperations(name); if (methods != null && methods.size() == 1) { // only one method then choose it methodInfo = methods.get(0); // validate that if we want an explicit no-arg method, then that's what we get if (emptyParameters && methodInfo.hasParameters()) { throw new MethodNotFoundException(exchange, pojo, methodName, "(with no parameters)"); } } else if (methods != null) { // there are more methods with that name so we cannot decide which to use // but first let's try to choose a method and see if that complies with the name // must use the method name which may have qualifiers methodInfo = chooseMethod(pojo, exchange, methodName); // validate that if we want an explicit no-arg method, then that's what we get if (emptyParameters) { if (methodInfo == null || methodInfo.hasParameters()) { // we could not find a no-arg method with that name throw new MethodNotFoundException(exchange, pojo, methodName, "(with no parameters)"); } } if (methodInfo == null || (name != null && !name.equals(methodInfo.getMethod().getName()))) { throw new AmbiguousMethodCallException(exchange, methods); } } else { // a specific method was given to invoke but not found throw new MethodNotFoundException(exchange, pojo, methodName); } } } if (methodInfo == null) { // no name or type methodInfo = chooseMethod(pojo, exchange, null); } if (methodInfo == null) { methodInfo = defaultMethod; } if (methodInfo != null) { LOG.trace("Chosen method to invoke: {} on bean: {}", methodInfo, pojo); return methodInfo.createMethodInvocation(pojo, exchange); } LOG.debug("Cannot find suitable method to invoke on bean: {}", pojo); return null; }
private boolean matchMethod(Method method, String methodName) { if (methodName == null) { return true; } if (methodName.contains("(") && !methodName.endsWith(")")) { throw new IllegalArgumentException( "Name must have both starting and ending parenthesis, was: " + methodName); } // do not use qualifier for name matching String name = methodName; if (name.contains("(")) { name = ObjectHelper.before(name, "("); } // must match name if (name != null && !name.equals(method.getName())) { return false; } // is it a method with no parameters boolean noParameters = methodName.endsWith("()"); if (noParameters) { return method.getParameterTypes().length == 0; } // match qualifier types which is used to select among overloaded methods String types = ObjectHelper.between(methodName, "(", ")"); if (ObjectHelper.isNotEmpty(types)) { // we must qualify based on types to match method String[] parameters = StringQuoteHelper.splitSafeQuote(types, ','); Iterator<?> it = ObjectHelper.createIterator(parameters); for (int i = 0; i < method.getParameterTypes().length; i++) { if (it.hasNext()) { Class<?> parameterType = method.getParameterTypes()[i]; String qualifyType = (String) it.next(); if (ObjectHelper.isEmpty(qualifyType)) { continue; } // trim the type qualifyType = qualifyType.trim(); if ("*".equals(qualifyType)) { // * is a wildcard so we accept and match that parameter type continue; } if (BeanHelper.isValidParameterValue(qualifyType)) { // its a parameter value, so continue to next parameter // as we should only check for FQN/type parameters continue; } // if qualify type indeed is a class, then it must be assignable with the parameter type Boolean assignable = BeanHelper.isAssignableToExpectedType( getCamelContext().getClassResolver(), qualifyType, parameterType); // the method will return null if the qualifyType is not a class if (assignable != null && !assignable) { return false; } } else { // there method has more parameters than was specified in the method name qualifiers return false; } } // if the method has no more types then we can only regard it as matched // if there are no more qualifiers if (it.hasNext()) { return false; } } // the method matched return true; }