/** * 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); } } }