/**
* Creates the associated name of the done file based on the given file name.
*
* <p>This method should only be invoked if a done filename property has been set on this
* endpoint.
*
* @param fileName the file name
* @return name of the associated done file name
*/
protected String createDoneFileName(String fileName) {
String pattern = getDoneFileName();
ObjectHelper.notEmpty(pattern, "doneFileName", pattern);
// we only support ${file:name} or ${file:name.noext} as dynamic placeholders for done files
String path = FileUtil.onlyPath(fileName);
String onlyName = FileUtil.stripPath(fileName);
pattern = pattern.replaceFirst("\\$\\{file:name\\}", onlyName);
pattern = pattern.replaceFirst("\\$simple\\{file:name\\}", onlyName);
pattern = pattern.replaceFirst("\\$\\{file:name.noext\\}", FileUtil.stripExt(onlyName));
pattern = pattern.replaceFirst("\\$simple\\{file:name.noext\\}", FileUtil.stripExt(onlyName));
// must be able to resolve all placeholders supported
if (SimpleLanguage.hasStartToken(pattern)) {
throw new ExpressionIllegalSyntaxException(
fileName + ". Cannot resolve reminder: " + pattern);
}
String answer = pattern;
if (ObjectHelper.isNotEmpty(path) && ObjectHelper.isNotEmpty(pattern)) {
// done file must always be in same directory as the real file name
answer = path + File.separator + pattern;
}
if (getConfiguration().needToNormalize()) {
// must normalize path to cater for Windows and other OS
answer = FileUtil.normalizePath(answer);
}
return answer;
}
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);
}
@Override
public void run() {
ClientMixedOperation<
ReplicationController,
ReplicationControllerList,
DoneableReplicationController,
ClientRollableScallableResource<ReplicationController, DoneableReplicationController>>
w = getEndpoint().getKubernetesClient().replicationControllers();
if (ObjectHelper.isNotEmpty(getEndpoint().getKubernetesConfiguration().getNamespace())) {
w.inNamespace(getEndpoint().getKubernetesConfiguration().getNamespace());
}
if (ObjectHelper.isNotEmpty(getEndpoint().getKubernetesConfiguration().getLabelKey())
&& ObjectHelper.isNotEmpty(getEndpoint().getKubernetesConfiguration().getLabelValue())) {
w.withLabel(
getEndpoint().getKubernetesConfiguration().getLabelKey(),
getEndpoint().getKubernetesConfiguration().getLabelValue());
}
if (ObjectHelper.isNotEmpty(getEndpoint().getKubernetesConfiguration().getResourceName())) {
w.withName(getEndpoint().getKubernetesConfiguration().getResourceName());
}
w.watch(
new Watcher<ReplicationController>() {
@Override
public void eventReceived(
io.fabric8.kubernetes.client.Watcher.Action action,
ReplicationController resource) {
ReplicationControllerEvent rce = new ReplicationControllerEvent(action, resource);
Exchange exchange = getEndpoint().createExchange();
exchange.getIn().setBody(rce.getReplicationController());
exchange
.getIn()
.setHeader(KubernetesConstants.KUBERNETES_EVENT_ACTION, rce.getAction());
exchange
.getIn()
.setHeader(
KubernetesConstants.KUBERNETES_EVENT_TIMESTAMP, System.currentTimeMillis());
try {
processor.process(exchange);
} catch (Exception e) {
getExceptionHandler().handleException("Error during processing", exchange, e);
}
}
@Override
public void onClose(KubernetesClientException cause) {
if (cause != null) {
LOG.error(cause.getMessage(), cause);
}
}
});
}
/** Optional suffix appended to property names before resolution. */
public void setPropertySuffix(String propertySuffix) {
this.propertySuffix = propertySuffix;
this.propertySuffixResolved = propertySuffix;
if (ObjectHelper.isNotEmpty(this.propertySuffix)) {
this.propertySuffixResolved = FilePathResolver.resolvePath(this.propertySuffix);
}
}
protected void outputRoutesToFile() throws IOException, JAXBException {
if (ObjectHelper.isNotEmpty(getRoutesOutputFile())) {
LOG.info("Generating routes as XML in the file named: " + getRoutesOutputFile());
ModelFileGenerator generator = createModelFileGenerator();
generator.marshalRoutesUsingJaxb(getRoutesOutputFile(), getRouteDefinitions());
}
}
private void addDependsOnToRouteBuilder(
Element childElement, ParserContext parserContext, String contextId) {
// setting the depends-on explicitly is required since Spring 3.0
String routeBuilderName = childElement.getAttribute("ref");
if (ObjectHelper.isNotEmpty(routeBuilderName)) {
// set depends-on to the context for a routeBuilder bean
try {
BeanDefinition definition = parserContext.getRegistry().getBeanDefinition(routeBuilderName);
Method getDependsOn = definition.getClass().getMethod("getDependsOn", new Class[] {});
String[] dependsOn = (String[]) getDependsOn.invoke(definition);
if (dependsOn == null || dependsOn.length == 0) {
dependsOn = new String[] {contextId};
} else {
String[] temp = new String[dependsOn.length + 1];
System.arraycopy(dependsOn, 0, temp, 0, dependsOn.length);
temp[dependsOn.length] = contextId;
dependsOn = temp;
}
Method method = definition.getClass().getMethod("setDependsOn", String[].class);
method.invoke(definition, (Object) dependsOn);
} catch (Exception e) {
// Do nothing here
}
}
}
protected String getFabricPath(String name) {
String path = name;
if (ObjectHelper.isNotEmpty(zkRoot)) {
path = zkRoot + "/" + name;
}
return path;
}
/** Returns the endpoint URI or the name of the reference to it */
public Object getUriOrRef() {
if (ObjectHelper.isNotEmpty(uri)) {
return uri;
} else if (endpoint != null) {
return endpoint.getEndpointUri();
}
return ref;
}
/** Does the given context match this camel context */
private boolean matchContext(String context) {
if (ObjectHelper.isNotEmpty(context)) {
if (!camelContext.getName().equals(context)) {
return false;
}
}
return true;
}
/** Get parameters defined in @CsvRecord annotation */
private void initCsvRecordParameters() {
if (separator == null) {
for (Class<?> cl : models) {
// Get annotation @CsvRecord from the class
CsvRecord record = cl.getAnnotation(CsvRecord.class);
// Get annotation @Section from the class
Section section = cl.getAnnotation(Section.class);
if (record != null) {
LOG.debug("Csv record: {}", record);
// Get skipFirstLine parameter
skipFirstLine = record.skipFirstLine();
LOG.debug("Skip First Line parameter of the CSV: {}" + skipFirstLine);
// Get generateHeaderColumnNames parameter
generateHeaderColumnNames = record.generateHeaderColumns();
LOG.debug(
"Generate header column names parameter of the CSV: {}", generateHeaderColumnNames);
// Get Separator parameter
ObjectHelper.notNull(
record.separator(), "No separator has been defined in the @Record annotation");
separator = record.separator();
LOG.debug("Separator defined for the CSV: {}", separator);
// Get carriage return parameter
crlf = record.crlf();
LOG.debug("Carriage return defined for the CSV: {}", crlf);
// Get isOrdered parameter
messageOrdered = record.isOrdered();
LOG.debug("Must CSV record be ordered: {}", messageOrdered);
if (ObjectHelper.isNotEmpty(record.quote())) {
quote = record.quote();
LOG.debug("Quoting columns with: {}", quote);
}
quoting = record.quoting();
LOG.debug("CSV will be quoted: {}", messageOrdered);
autospanLine = record.autospanLine();
LOG.debug("Autospan line in last record: {}", autospanLine);
}
if (section != null) {
// Test if section number is not null
ObjectHelper.notNull(section.number(), "No number has been defined for the section");
// Get section number and add it to the sections
sections.put(cl.getName(), section.number());
}
}
}
}
public boolean retrieveFile(String name, Exchange exchange)
throws GenericFileOperationFailedException {
LOG.trace("retrieveFile({})", name);
if (ObjectHelper.isNotEmpty(endpoint.getLocalWorkDirectory())) {
// local work directory is configured so we should store file content as files in this local
// directory
return retrieveFileToFileInLocalWorkDirectory(name, exchange);
} else {
// store file content directory as stream on the body
return retrieveFileToStreamInBody(name, exchange);
}
}
@Override
public void process(Exchange exchange) throws Exception {
NatsConfiguration config = getEndpoint().getNatsConfiguration();
String body = exchange.getIn().getMandatoryBody(String.class);
LOG.debug("Publishing to topic: {}", config.getTopic());
if (ObjectHelper.isNotEmpty(config.getReplySubject())) {
String replySubject = config.getReplySubject();
connection.publish(config.getTopic(), replySubject, body.getBytes());
} else {
connection.publish(config.getTopic(), body.getBytes());
}
}
private String getInputUri() {
// find the xsd with relative path
if (ObjectHelper.isNotEmpty(relatedURI)) {
try {
ResourceHelper.resolveMandatoryResourceAsInputStream(
camelContext.getClassResolver(), relatedURI);
return relatedURI;
} catch (IOException e) {
// ignore the exception
}
}
// don't use the relative path
return getUri(systemId);
}
protected void addDependsOn(CamelContextFactoryBean factoryBean, BeanDefinitionBuilder builder) {
String dependsOn = factoryBean.getDependsOn();
if (ObjectHelper.isNotEmpty(dependsOn)) {
// comma, whitespace and semi colon is valid separators in Spring depends-on
String[] depends = dependsOn.split(",|;|\\s");
if (depends == null) {
throw new IllegalArgumentException("Cannot separate depends-on, was: " + dependsOn);
} else {
for (String depend : depends) {
depend = depend.trim();
LOG.debug("Adding dependsOn {} to CamelContext({})", depend, factoryBean.getId());
builder.addDependsOn(depend);
}
}
}
}
public void process(Exchange exchange) throws Exception {
// send direct message
String toUsername = te.getProperties().getUser();
if (ObjectHelper.isNotEmpty(
exchange.getIn().getHeader(TwitterConstants.TWITTER_USER, String.class))) {
toUsername = exchange.getIn().getHeader(TwitterConstants.TWITTER_USER, String.class);
}
String text = exchange.getIn().getBody(String.class);
if (toUsername.isEmpty()) {
throw new CamelExchangeException("Username not configured on TwitterEndpoint", exchange);
} else {
log.debug("Sending to: {} message: {}", toUsername, text);
te.getProperties().getTwitter().sendDirectMessage(toUsername, text);
}
}
public static boolean hasProperties(Map<String, Object> properties, String optionPrefix) {
ObjectHelper.notNull(properties, "properties");
if (ObjectHelper.isNotEmpty(optionPrefix)) {
for (Object o : properties.keySet()) {
String name = (String) o;
if (name.startsWith(optionPrefix)) {
return true;
}
}
// no parameters with this prefix
return false;
} else {
return !properties.isEmpty();
}
}
protected void generateDot(String name, CamelContext camelContext, int size) throws IOException {
String outputDir = dotOutputDir;
if (ObjectHelper.isNotEmpty(outputDir)) {
if (size > 1) {
outputDir += "/" + name;
}
RouteDotGenerator generator = new RouteDotGenerator(outputDir);
LOG.info(
"Generating DOT file for routes: "
+ outputDir
+ " for: "
+ camelContext
+ " with name: "
+ name);
generator.drawRoutes(camelContext);
}
}
private void registerEndpoint(
Element childElement, ParserContext parserContext, String contextId) {
String id = childElement.getAttribute("id");
// must have an id to be registered
if (ObjectHelper.isNotEmpty(id)) {
BeanDefinition definition = endpointParser.parse(childElement, parserContext);
definition
.getPropertyValues()
.addPropertyValue("camelContext", new RuntimeBeanReference(contextId));
// Need to add this dependency of CamelContext for Spring 3.0
try {
Method method = definition.getClass().getMethod("setDependsOn", String[].class);
method.invoke(definition, (Object) new String[] {contextId});
} catch (Exception e) {
// Do nothing here
}
parserContext.registerBeanComponent(new BeanComponentDefinition(definition, id));
}
}
/** Configures the given message with the file which sets the body to the file object. */
public void configureMessage(GenericFile<T> file, Message message) {
message.setBody(file);
if (flatten) {
// when flatten the file name should not contain any paths
message.setHeader(Exchange.FILE_NAME, file.getFileNameOnly());
} else {
// compute name to set on header that should be relative to starting directory
String name = file.isAbsolute() ? file.getAbsoluteFilePath() : file.getRelativeFilePath();
// skip leading endpoint configured directory
String endpointPath = getConfiguration().getDirectory() + getFileSeparator();
if (ObjectHelper.isNotEmpty(endpointPath) && name.startsWith(endpointPath)) {
name = ObjectHelper.after(name, endpointPath);
}
// adjust filename
message.setHeader(Exchange.FILE_NAME, name);
}
}
private OutputStream createOutputStream(File file) throws IOException {
OutputStream out = new BufferedOutputStream(new FileOutputStream(file));
if (ObjectHelper.isNotEmpty(strategy.getSpoolChiper())) {
try {
if (ciphers == null) {
ciphers = new CipherPair(strategy.getSpoolChiper());
}
} catch (GeneralSecurityException e) {
throw new IOException(e.getMessage(), e);
}
out =
new CipherOutputStream(out, ciphers.getEncryptor()) {
boolean closed;
public void close() throws IOException {
if (!closed) {
super.close();
closed = true;
}
}
};
}
return out;
}
private List<PropertiesLocation> parseLocations(List<PropertiesLocation> locations) {
List<PropertiesLocation> answer = new ArrayList<>();
for (PropertiesLocation location : locations) {
LOG.trace("Parsing location: {} ", location);
try {
String path = FilePathResolver.resolvePath(location.getPath());
LOG.debug("Parsed location: {} ", path);
if (ObjectHelper.isNotEmpty(path)) {
answer.add(new PropertiesLocation(location.getResolver(), path, location.isOptional()));
}
} catch (IllegalArgumentException e) {
if (!ignoreMissingLocation && !location.isOptional()) {
throw e;
} else {
LOG.debug("Ignored missing location: {}", location);
}
}
}
// must return a not-null answer
return answer;
}
private String[] parseLocations(String[] locations) {
List<String> answer = new ArrayList<String>();
for (String location : locations) {
LOG.trace("Parsing location: {} ", location);
try {
location = FilePathResolver.resolvePath(location);
LOG.debug("Parsed location: {} ", location);
if (ObjectHelper.isNotEmpty(location)) {
answer.add(location);
}
} catch (IllegalArgumentException e) {
if (!ignoreMissingLocation) {
throw e;
} else {
LOG.debug("Ignored missing location: {}", location);
}
}
}
// must return a not-null answer
return answer.toArray(new String[answer.size()]);
}
/**
* Read the REST-DSL definition's and parse that as a Swagger model representation
*
* @param rests the rest-dsl
* @param route optional route path to filter the rest-dsl to only include from the chose route
* @param config the swagger configuration
* @param classResolver class resolver to use
* @return the swagger model
*/
public Swagger read(
List<RestDefinition> rests,
String route,
BeanConfig config,
String camelContextId,
ClassResolver classResolver) {
Swagger swagger = new Swagger();
for (RestDefinition rest : rests) {
if (ObjectHelper.isNotEmpty(route) && !route.equals("/")) {
// filter by route
if (!rest.getPath().equals(route)) {
continue;
}
}
parse(swagger, rest, camelContextId, classResolver);
}
// configure before returning
swagger = config.configure(swagger);
return swagger;
}
@Override
public Processor createProcessor(RouteContext routeContext) throws Exception {
BeanProcessor answer;
Class<?> clazz = bean != null ? bean.getClass() : null;
BeanHolder beanHolder;
if (ObjectHelper.isNotEmpty(ref)) {
if (cache != null && cache) {
// cache the registry lookup which avoids repeat lookup in the registry
beanHolder = new RegistryBean(routeContext.getCamelContext(), ref).createCacheHolder();
} else {
beanHolder = new RegistryBean(routeContext.getCamelContext(), ref);
}
// bean holder will check if the bean exists
bean = beanHolder.getBean();
answer = new BeanProcessor(beanHolder);
} else {
if (bean == null) {
if (beanType == null && beanClass == null) {
throw new IllegalArgumentException("bean, ref or beanType must be provided");
}
// the clazz is either from beanType or beanClass
if (beanType != null) {
try {
clazz =
routeContext.getCamelContext().getClassResolver().resolveMandatoryClass(beanType);
} catch (ClassNotFoundException e) {
throw ObjectHelper.wrapRuntimeCamelException(e);
}
} else {
clazz = beanClass;
}
// create a bean if there is a default public no-arg constructor
if (ObjectHelper.hasDefaultPublicNoArgConstructor(clazz)) {
bean = CamelContextHelper.newInstance(routeContext.getCamelContext(), clazz);
ObjectHelper.notNull(bean, "bean", this);
}
}
// validate the bean type is not from java so you by mistake think its a reference
// to a bean name but the String is being invoke instead
if (bean instanceof String) {
throw new IllegalArgumentException(
"The bean instance is a java.lang.String type: "
+ bean
+ ". We suppose you want to refer to a bean instance by its id instead. Please use beanRef.");
}
// the holder should either be bean or type based
beanHolder =
bean != null
? new ConstantBeanHolder(bean, routeContext.getCamelContext())
: new ConstantTypeBeanHolder(clazz, routeContext.getCamelContext());
answer = new BeanProcessor(beanHolder);
}
// check for method exists
if (method != null) {
answer.setMethod(method);
// check there is a method with the given name, and leverage BeanInfo for that
BeanInfo beanInfo = beanHolder.getBeanInfo();
if (bean != null) {
// there is a bean instance, so check for any methods
if (!beanInfo.hasMethod(method)) {
throw ObjectHelper.wrapRuntimeCamelException(
new MethodNotFoundException(null, bean, method));
}
} else if (clazz != null) {
// there is no bean instance, so check for static methods only
if (!beanInfo.hasStaticMethod(method)) {
throw ObjectHelper.wrapRuntimeCamelException(
new MethodNotFoundException(null, clazz, method, true));
}
}
}
return answer;
}
protected boolean doPollDirectory(
String absolutePath, String dirName, List<GenericFile<FTPFile>> fileList, int depth) {
log.trace("doPollDirectory from absolutePath: {}, dirName: {}", absolutePath, dirName);
depth++;
// remove trailing /
dirName = FileUtil.stripTrailingSeparator(dirName);
// compute dir depending on stepwise is enabled or not
String dir;
if (isStepwise()) {
dir = ObjectHelper.isNotEmpty(dirName) ? dirName : absolutePath;
operations.changeCurrentDirectory(dir);
} else {
dir = absolutePath;
}
log.trace("Polling directory: {}", dir);
List<FTPFile> files = null;
if (isUseList()) {
if (isStepwise()) {
files = operations.listFiles();
} else {
files = operations.listFiles(dir);
}
} else {
// we cannot use the LIST command(s) so we can only poll a named file
// so created a pseudo file with that name
FTPFile file = new FTPFile();
file.setType(FTPFile.FILE_TYPE);
fileExpressionResult = evaluateFileExpression();
if (fileExpressionResult != null) {
file.setName(fileExpressionResult);
files = new ArrayList<FTPFile>(1);
files.add(file);
}
}
if (files == null || files.isEmpty()) {
// no files in this directory to poll
log.trace("No files found in directory: {}", dir);
return true;
} else {
// we found some files
log.trace("Found {} in directory: {}", files.size(), dir);
}
for (FTPFile file : files) {
if (log.isTraceEnabled()) {
log.trace(
"FtpFile[name={}, dir={}, file={}]",
new Object[] {file.getName(), file.isDirectory(), file.isFile()});
}
// check if we can continue polling in files
if (!canPollMoreFiles(fileList)) {
return false;
}
if (file.isDirectory()) {
RemoteFile<FTPFile> remote = asRemoteFile(absolutePath, file, getEndpoint().getCharset());
if (endpoint.isRecursive()
&& depth < endpoint.getMaxDepth()
&& isValidFile(remote, true, files)) {
// recursive scan and add the sub files and folders
String subDirectory = file.getName();
String path = absolutePath + "/" + subDirectory;
boolean canPollMore = pollSubDirectory(path, subDirectory, fileList, depth);
if (!canPollMore) {
return false;
}
}
} else if (file.isFile()) {
RemoteFile<FTPFile> remote = asRemoteFile(absolutePath, file, getEndpoint().getCharset());
if (depth >= endpoint.getMinDepth() && isValidFile(remote, false, files)) {
// matched file so add
fileList.add(remote);
}
} else {
log.debug("Ignoring unsupported remote file type: " + file);
}
}
return true;
}
@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);
}
}
}
}
}
/**
* Processes any custom {@link org.apache.camel.component.http.UrlRewrite}.
*
* @param exchange the exchange
* @param url the url
* @param endpoint the http endpoint
* @param producer the producer
* @return the rewritten url, or <tt>null</tt> to use original url
* @throws Exception is thrown if any error during rewriting url
*/
public static String urlRewrite(
Exchange exchange, String url, HttpEndpoint endpoint, Producer producer) throws Exception {
String answer = null;
String relativeUrl;
if (endpoint.getUrlRewrite() != null) {
// we should use the relative path if possible
String baseUrl;
relativeUrl = endpoint.getHttpUri().toASCIIString();
if (url.startsWith(relativeUrl)) {
baseUrl = url.substring(0, relativeUrl.length());
relativeUrl = url.substring(relativeUrl.length());
} else {
baseUrl = null;
relativeUrl = url;
}
// mark it as null if its empty
if (ObjectHelper.isEmpty(relativeUrl)) {
relativeUrl = null;
}
String newUrl;
if (endpoint.getUrlRewrite() instanceof HttpServletUrlRewrite) {
// its servlet based, so we need the servlet request
HttpServletRequest request = exchange.getIn().getBody(HttpServletRequest.class);
if (request == null) {
HttpMessage msg = exchange.getIn(HttpMessage.class);
if (msg != null) {
request = msg.getRequest();
}
}
if (request == null) {
throw new IllegalArgumentException(
"UrlRewrite "
+ endpoint.getUrlRewrite()
+ " requires the message body to be a"
+ "HttpServletRequest instance, but was: "
+ ObjectHelper.className(exchange.getIn().getBody()));
}
// we need to adapt the context-path to be the path from the endpoint, if it came from a
// http based endpoint
// as eg camel-jetty have hardcoded context-path as / for all its servlets/endpoints
// we have the actual context-path stored as a header with the key CamelServletContextPath
String contextPath = exchange.getIn().getHeader("CamelServletContextPath", String.class);
request = new UrlRewriteHttpServletRequestAdapter(request, contextPath);
newUrl =
((HttpServletUrlRewrite) endpoint.getUrlRewrite())
.rewrite(url, relativeUrl, producer, request);
} else {
newUrl = endpoint.getUrlRewrite().rewrite(url, relativeUrl, producer);
}
if (ObjectHelper.isNotEmpty(newUrl) && newUrl != url) {
// we got a new url back, that can either be a new absolute url
// or a new relative url
if (newUrl.startsWith("http:") || newUrl.startsWith("https:")) {
answer = newUrl;
} else if (baseUrl != null) {
// avoid double // when adding the urls
if (baseUrl.endsWith("/") && newUrl.startsWith("/")) {
answer = baseUrl + newUrl.substring(1);
} else {
answer = baseUrl + newUrl;
}
} else {
// use the new url as is
answer = newUrl;
}
if (LOG.isDebugEnabled()) {
LOG.debug(
"Using url rewrite to rewrite from url {} to {} -> {}",
new Object[] {relativeUrl != null ? relativeUrl : url, newUrl, answer});
}
}
}
return answer;
}
/**
* Perform the work to process the fileExchange
*
* @param exchange fileExchange
* @param target the target filename
* @throws Exception is thrown if some error
*/
protected void processExchange(Exchange exchange, String target) throws Exception {
log.trace("Processing file: {} for exchange: {}", target, exchange);
try {
preWriteCheck();
// should we write to a temporary name and then afterwards rename to real target
boolean writeAsTempAndRename = ObjectHelper.isNotEmpty(endpoint.getTempFileName());
String tempTarget = null;
// remember if target exists to avoid checking twice
Boolean targetExists = null;
if (writeAsTempAndRename) {
// compute temporary name with the temp prefix
tempTarget = createTempFileName(exchange, target);
log.trace("Writing using tempNameFile: {}", tempTarget);
// if we should eager delete target file before deploying temporary file
if (endpoint.getFileExist() != GenericFileExist.TryRename
&& endpoint.isEagerDeleteTargetFile()) {
// cater for file exists option on the real target as
// the file operations code will work on the temp file
// if an existing file already exists what should we do?
targetExists = operations.existsFile(target);
if (targetExists) {
log.trace("EagerDeleteTargetFile, target exists");
if (endpoint.getFileExist() == GenericFileExist.Ignore) {
// ignore but indicate that the file was written
log.trace(
"An existing file already exists: {}. Ignore and do not override it.", target);
return;
} else if (endpoint.getFileExist() == GenericFileExist.Fail) {
throw new GenericFileOperationFailedException(
"File already exist: " + target + ". Cannot write new file.");
} else if (endpoint.isEagerDeleteTargetFile()
&& endpoint.getFileExist() == GenericFileExist.Override) {
// we override the target so we do this by deleting it so the temp file can be renamed
// later
// with success as the existing target file have been deleted
log.trace("Eagerly deleting existing file: {}", target);
if (!operations.deleteFile(target)) {
throw new GenericFileOperationFailedException("Cannot delete file: " + target);
}
}
}
}
// delete any pre existing temp file
if (operations.existsFile(tempTarget)) {
log.trace("Deleting existing temp file: {}", tempTarget);
if (!operations.deleteFile(tempTarget)) {
throw new GenericFileOperationFailedException("Cannot delete file: " + tempTarget);
}
}
}
// write/upload the file
writeFile(exchange, tempTarget != null ? tempTarget : target);
// if we did write to a temporary name then rename it to the real
// name after we have written the file
if (tempTarget != null) {
// if we did not eager delete the target file
if (endpoint.getFileExist() != GenericFileExist.TryRename
&& !endpoint.isEagerDeleteTargetFile()) {
// if an existing file already exists what should we do?
targetExists = operations.existsFile(target);
if (targetExists) {
log.trace("Not using EagerDeleteTargetFile, target exists");
if (endpoint.getFileExist() == GenericFileExist.Ignore) {
// ignore but indicate that the file was written
log.trace(
"An existing file already exists: {}. Ignore and do not override it.", target);
return;
} else if (endpoint.getFileExist() == GenericFileExist.Fail) {
throw new GenericFileOperationFailedException(
"File already exist: " + target + ". Cannot write new file.");
} else if (endpoint.getFileExist() == GenericFileExist.Override) {
// we override the target so we do this by deleting it so the temp file can be renamed
// later
// with success as the existing target file have been deleted
log.trace("Deleting existing file: {}", target);
if (!operations.deleteFile(target)) {
throw new GenericFileOperationFailedException("Cannot delete file: " + target);
}
}
}
}
// now we are ready to rename the temp file to the target file
log.trace("Renaming file: [{}] to: [{}]", tempTarget, target);
boolean renamed = operations.renameFile(tempTarget, target);
if (!renamed) {
throw new GenericFileOperationFailedException(
"Cannot rename file from: " + tempTarget + " to: " + target);
}
}
// any done file to write?
if (endpoint.getDoneFileName() != null) {
String doneFileName = endpoint.createDoneFileName(target);
ObjectHelper.notEmpty(doneFileName, "doneFileName", endpoint);
// create empty exchange with empty body to write as the done file
Exchange empty = new DefaultExchange(exchange);
empty.getIn().setBody("");
log.trace("Writing done file: [{}]", doneFileName);
// delete any existing done file
if (operations.existsFile(doneFileName)) {
if (!operations.deleteFile(doneFileName)) {
throw new GenericFileOperationFailedException(
"Cannot delete existing done file: " + doneFileName);
}
}
writeFile(empty, doneFileName);
}
// let's store the name we really used in the header, so end-users
// can retrieve it
exchange.getIn().setHeader(Exchange.FILE_NAME_PRODUCED, target);
} catch (Exception e) {
handleFailedWrite(exchange, e);
}
postWriteCheck();
}
private boolean doStoreFile(String name, String targetName, Exchange exchange)
throws GenericFileOperationFailedException {
LOG.trace("doStoreFile({})", targetName);
// if an existing file already exists what should we do?
if (endpoint.getFileExist() == GenericFileExist.Ignore
|| endpoint.getFileExist() == GenericFileExist.Fail
|| endpoint.getFileExist() == GenericFileExist.Move) {
boolean existFile = existsFile(targetName);
if (existFile && endpoint.getFileExist() == GenericFileExist.Ignore) {
// ignore but indicate that the file was written
LOG.trace("An existing file already exists: {}. Ignore and do not override it.", name);
return true;
} else if (existFile && endpoint.getFileExist() == GenericFileExist.Fail) {
throw new GenericFileOperationFailedException(
"File already exist: " + name + ". Cannot write new file.");
} else if (existFile && endpoint.getFileExist() == GenericFileExist.Move) {
// move any existing file first
doMoveExistingFile(name, targetName);
}
}
InputStream is = null;
if (exchange.getIn().getBody() == null) {
// Do an explicit test for a null body and decide what to do
if (endpoint.isAllowNullBody()) {
LOG.trace("Writing empty file.");
is = new ByteArrayInputStream(new byte[] {});
} else {
throw new GenericFileOperationFailedException("Cannot write null body to file: " + name);
}
}
try {
if (is == null) {
String charset = endpoint.getCharset();
if (charset != null) {
// charset configured so we must convert to the desired
// charset so we can write with encoding
is =
new ByteArrayInputStream(
exchange.getIn().getMandatoryBody(String.class).getBytes(charset));
LOG.trace("Using InputStream {} with charset {}.", is, charset);
} else {
is = exchange.getIn().getMandatoryBody(InputStream.class);
}
}
final StopWatch watch = new StopWatch();
LOG.debug("About to store file: {} using stream: {}", targetName, is);
if (endpoint.getFileExist() == GenericFileExist.Append) {
LOG.trace("Client appendFile: {}", targetName);
channel.put(is, targetName, ChannelSftp.APPEND);
} else {
LOG.trace("Client storeFile: {}", targetName);
// override is default
channel.put(is, targetName);
}
watch.stop();
if (LOG.isDebugEnabled()) {
LOG.debug(
"Took {} ({} millis) to store file: {} and FTP client returned: true",
new Object[] {TimeUtils.printDuration(watch.taken()), watch.taken(), targetName});
}
// after storing file, we may set chmod on the file
String mode = endpoint.getConfiguration().getChmod();
if (ObjectHelper.isNotEmpty(mode)) {
// parse to int using 8bit mode
int permissions = Integer.parseInt(mode, 8);
LOG.trace("Setting chmod: {} on file: {}", mode, targetName);
channel.chmod(permissions, targetName);
}
return true;
} catch (SftpException e) {
throw new GenericFileOperationFailedException("Cannot store file: " + name, e);
} catch (InvalidPayloadException e) {
throw new GenericFileOperationFailedException("Cannot store file: " + name, e);
} catch (UnsupportedEncodingException e) {
throw new GenericFileOperationFailedException("Cannot store file: " + name, e);
} finally {
IOHelper.close(is, "store: " + name, LOG);
}
}
@SuppressWarnings("deprecation")
public MethodInfo(
CamelContext camelContext,
Class<?> type,
Method method,
List<ParameterInfo> parameters,
List<ParameterInfo> bodyParameters,
boolean hasCustomAnnotation,
boolean hasHandlerAnnotation) {
this.camelContext = camelContext;
this.type = type;
this.method = method;
this.parameters = parameters;
this.bodyParameters = bodyParameters;
this.hasCustomAnnotation = hasCustomAnnotation;
this.hasHandlerAnnotation = hasHandlerAnnotation;
this.parametersExpression = createParametersExpression();
Map<Class<?>, Annotation> collectedMethodAnnotation = collectMethodAnnotations(type, method);
Pattern oneway = findOneWayAnnotation(method);
if (oneway != null) {
pattern = oneway.value();
}
org.apache.camel.RoutingSlip routingSlipAnnotation =
(org.apache.camel.RoutingSlip)
collectedMethodAnnotation.get(org.apache.camel.RoutingSlip.class);
if (routingSlipAnnotation != null && matchContext(routingSlipAnnotation.context())) {
routingSlip = new RoutingSlip(camelContext);
routingSlip.setDelimiter(routingSlipAnnotation.delimiter());
routingSlip.setIgnoreInvalidEndpoints(routingSlipAnnotation.ignoreInvalidEndpoints());
// add created routingSlip as a service so we have its lifecycle managed
try {
camelContext.addService(routingSlip);
} catch (Exception e) {
throw ObjectHelper.wrapRuntimeCamelException(e);
}
}
org.apache.camel.DynamicRouter dynamicRouterAnnotation =
(org.apache.camel.DynamicRouter)
collectedMethodAnnotation.get(org.apache.camel.DynamicRouter.class);
if (dynamicRouterAnnotation != null && matchContext(dynamicRouterAnnotation.context())) {
dynamicRouter = new DynamicRouter(camelContext);
dynamicRouter.setDelimiter(dynamicRouterAnnotation.delimiter());
dynamicRouter.setIgnoreInvalidEndpoints(dynamicRouterAnnotation.ignoreInvalidEndpoints());
// add created dynamicRouter as a service so we have its lifecycle managed
try {
camelContext.addService(dynamicRouter);
} catch (Exception e) {
throw ObjectHelper.wrapRuntimeCamelException(e);
}
}
org.apache.camel.RecipientList recipientListAnnotation =
(org.apache.camel.RecipientList)
collectedMethodAnnotation.get(org.apache.camel.RecipientList.class);
if (recipientListAnnotation != null && matchContext(recipientListAnnotation.context())) {
recipientList = new RecipientList(camelContext, recipientListAnnotation.delimiter());
recipientList.setStopOnException(recipientListAnnotation.stopOnException());
recipientList.setIgnoreInvalidEndpoints(recipientListAnnotation.ignoreInvalidEndpoints());
recipientList.setParallelProcessing(recipientListAnnotation.parallelProcessing());
recipientList.setParallelAggregate(recipientListAnnotation.parallelAggregate());
recipientList.setStreaming(recipientListAnnotation.streaming());
recipientList.setTimeout(recipientListAnnotation.timeout());
recipientList.setShareUnitOfWork(recipientListAnnotation.shareUnitOfWork());
if (ObjectHelper.isNotEmpty(recipientListAnnotation.executorServiceRef())) {
ExecutorService executor =
camelContext
.getExecutorServiceManager()
.newDefaultThreadPool(this, recipientListAnnotation.executorServiceRef());
recipientList.setExecutorService(executor);
}
if (recipientListAnnotation.parallelProcessing()
&& recipientList.getExecutorService() == null) {
// we are running in parallel so we need a thread pool
ExecutorService executor =
camelContext.getExecutorServiceManager().newDefaultThreadPool(this, "@RecipientList");
recipientList.setExecutorService(executor);
}
if (ObjectHelper.isNotEmpty(recipientListAnnotation.strategyRef())) {
AggregationStrategy strategy =
CamelContextHelper.mandatoryLookup(
camelContext, recipientListAnnotation.strategyRef(), AggregationStrategy.class);
recipientList.setAggregationStrategy(strategy);
}
if (ObjectHelper.isNotEmpty(recipientListAnnotation.onPrepareRef())) {
Processor onPrepare =
CamelContextHelper.mandatoryLookup(
camelContext, recipientListAnnotation.onPrepareRef(), Processor.class);
recipientList.setOnPrepare(onPrepare);
}
// add created recipientList as a service so we have its lifecycle managed
try {
camelContext.addService(recipientList);
} catch (Exception e) {
throw ObjectHelper.wrapRuntimeCamelException(e);
}
}
}