@Override
protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters)
throws Exception {
URI url = new URI(uri);
// must use copy as each endpoint can have different options
MailConfiguration config = getConfiguration().copy();
// only configure if we have a url with a known protocol
config.configure(url);
configureAdditionalJavaMailProperties(config, parameters);
MailEndpoint endpoint = new MailEndpoint(uri, this, config);
endpoint.setContentTypeResolver(contentTypeResolver);
setProperties(endpoint.getConfiguration(), parameters);
Map<String, Object> sstParams =
IntrospectionSupport.extractProperties(parameters, "searchTerm.");
if (!sstParams.isEmpty()) {
// use SimpleSearchTerm as POJO to store the configuration and then convert that to the actual
// SearchTerm
SimpleSearchTerm sst = new SimpleSearchTerm();
setProperties(sst, sstParams);
SearchTerm st = MailConverters.toSearchTerm(sst, getCamelContext().getTypeConverter());
endpoint.setSearchTerm(st);
}
// sanity check that we know the mail server
ObjectHelper.notEmpty(config.getHost(), "host");
ObjectHelper.notEmpty(config.getProtocol(), "protocol");
return endpoint;
}
public void register() throws Exception {
ObjectHelper.notEmpty(alias, "alias", this);
ObjectHelper.notEmpty(servletName, "servletName", this);
HttpContext actualHttpContext =
(httpContext == null) ? httpService.createDefaultHttpContext() : httpContext;
final Dictionary<String, String> initParams = new Hashtable<String, String>();
initParams.put("matchOnUriPrefix", matchOnUriPrefix ? "true" : "false");
initParams.put("servlet-name", servletName);
httpService.registerServlet(alias, servlet, initParams, actualHttpContext);
alreadyRegistered = true;
}
protected void createJmxConnector(String host) throws IOException {
ObjectHelper.notEmpty(serviceUrlPath, "serviceUrlPath");
ObjectHelper.notNull(registryPort, "registryPort");
try {
registry = LocateRegistry.createRegistry(registryPort);
LOG.debug("Created JMXConnector RMI registry on port {}", registryPort);
} catch (RemoteException ex) {
// The registry may had been created, we could get the registry instead
}
// must start with leading slash
String path = serviceUrlPath.startsWith("/") ? serviceUrlPath : "/" + serviceUrlPath;
// Create an RMI connector and start it
final JMXServiceURL url;
if (connectorPort > 0) {
url =
new JMXServiceURL(
"service:jmx:rmi://"
+ host
+ ":"
+ connectorPort
+ "/jndi/rmi://"
+ host
+ ":"
+ registryPort
+ path);
} else {
url = new JMXServiceURL("service:jmx:rmi:///jndi/rmi://" + host + ":" + registryPort + path);
}
cs = JMXConnectorServerFactory.newJMXConnectorServer(url, null, server);
// use async thread for starting the JMX Connector
// (no need to use a thread pool or enlist in JMX as this thread is terminated when the JMX
// connector has been started)
String threadName =
camelContext.getExecutorServiceManager().resolveThreadName("JMXConnector: " + url);
Thread thread =
getCamelContext()
.getExecutorServiceManager()
.newThread(
threadName,
new Runnable() {
public void run() {
try {
LOG.debug("Staring JMX Connector thread to listen at: {}", url);
cs.start();
LOG.info("JMX Connector thread started and listening at: {}", url);
} catch (IOException ioe) {
LOG.warn(
"Could not start JMXConnector thread at: "
+ url
+ ". JMX Connector not in use.",
ioe);
}
}
});
thread.start();
}
/**
* Is the given file a done file?
*
* <p>This method should only be invoked if a done filename property has been set on this
* endpoint.
*
* @param fileName the file name
* @return <tt>true</tt> if its a done file, <tt>false</tt> otherwise
*/
protected boolean isDoneFile(String fileName) {
String pattern = getDoneFileName();
ObjectHelper.notEmpty(pattern, "doneFileName", pattern);
if (!SimpleLanguage.hasStartToken(pattern)) {
// no tokens, so just match names directly
return pattern.equals(fileName);
}
// the static part of the pattern, is that a prefix or suffix?
// its a prefix if ${ start token is not at the start of the pattern
boolean prefix = pattern.indexOf("${") > 0;
// remove dynamic parts of the pattern so we only got the static part left
pattern = pattern.replaceFirst("\\$\\{file:name\\}", "");
pattern = pattern.replaceFirst("\\$simple\\{file:name\\}", "");
pattern = pattern.replaceFirst("\\$\\{file:name.noext\\}", "");
pattern = pattern.replaceFirst("\\$simple\\{file:name.noext\\}", "");
// must be able to resolve all placeholders supported
if (SimpleLanguage.hasStartToken(pattern)) {
throw new ExpressionIllegalSyntaxException(
fileName + ". Cannot resolve reminder: " + pattern);
}
if (prefix) {
return fileName.startsWith(pattern);
} else {
return fileName.endsWith(pattern);
}
}
/**
* 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;
}
@Override
protected void doStart() throws Exception {
super.doStart();
ObjectHelper.notEmpty(host, "host", this);
this.repository = getCamelContext().getRegistry().lookupByNameAndType(host, Repository.class);
if (repository == null) {
throw new RuntimeCamelException("No JCR repository defined under '" + host + "'");
}
if (username != null && password != null) {
this.credentials = new SimpleCredentials(username, password.toCharArray());
}
}
/**
* Validates this endpoint if its configured properly.
*
* @throws Exception is thrown if endpoint is invalid configured for its mandatory options
*/
protected void afterPropertiesSet() throws Exception {
RemoteFileConfiguration config = getConfiguration();
ObjectHelper.notEmpty(config.getHost(), "host");
ObjectHelper.notEmpty(config.getProtocol(), "protocol");
}
public static boolean setProperties(
Object target, Map<String, Object> properties, String optionPrefix) throws Exception {
ObjectHelper.notEmpty(optionPrefix, "optionPrefix");
return setProperties(target, properties, optionPrefix, false);
}
/**
* 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();
}
public void poll(
long streamPosition, final String streamType, final int limit, final EventCallback callback)
throws BoxServerException, AuthFatalFailureException, BoxRestException {
// get BoxClient Event Manager
final IBoxEventsManager eventsManager = cachedBoxClient.getBoxClient().getEventsManager();
// get current stream position if requested
if (BoxEventRequestObject.STREAM_POSITION_NOW == streamPosition) {
streamPosition = getCurrentStreamPosition(eventsManager, streamPosition);
}
// validate parameters
ObjectHelper.notNull(streamPosition, "streamPosition");
ObjectHelper.notEmpty(streamType, "streamType");
ObjectHelper.notNull(callback, "eventCallback");
httpClient = new DefaultHttpClient(cachedBoxClient.getClientConnectionManager(), httpParams);
// start polling thread
LOG.info("Started event polling thread for " + cachedBoxClient);
final long startStreamPosition = streamPosition;
pollFuture =
executorService.submit(
new Runnable() {
@Override
public void run() {
final ObjectMapper mapper = new ObjectMapper();
long currentStreamPosition = startStreamPosition;
BoxRealTimeServer realTimeServer = null;
boolean retry = false;
int retries = 0;
int maxRetries = 1;
while (!done) {
try {
// set to true if no exceptions thrown
retry = false;
if (realTimeServer == null) {
// get RTS URL
realTimeServer = getBoxRealTimeServer(currentStreamPosition, eventsManager);
// update HTTP timeout
final int requestTimeout =
Integer.parseInt(realTimeServer.getExtraData(RETRY_TIMEOUT).toString());
final HttpParams params = httpClient.getParams();
HttpConnectionParams.setSoTimeout(params, requestTimeout * 1000);
// update maxRetries
maxRetries =
Integer.parseInt(realTimeServer.getExtraData(MAX_RETRIES).toString());
}
// create HTTP request for RTS
httpGet = getPollRequest(realTimeServer.getUrl(), currentStreamPosition);
// execute RTS poll
HttpResponse httpResponse = null;
try {
httpResponse = httpClient.execute(httpGet, (HttpContext) null);
} catch (SocketTimeoutException e) {
LOG.debug("Poll timed out, retrying for " + cachedBoxClient);
}
if (httpResponse != null) {
// parse response
final StatusLine statusLine = httpResponse.getStatusLine();
if (statusLine != null && statusLine.getStatusCode() == HttpStatus.SC_OK) {
final HttpEntity entity = httpResponse.getEntity();
@SuppressWarnings("unchecked")
Map<String, String> rtsResponse =
mapper.readValue(entity.getContent(), Map.class);
final String message = rtsResponse.get(MESSAGE);
if (NEW_CHANGE.equals(message)) {
// get events
final BoxEventRequestObject requestObject =
BoxEventRequestObject.getEventsRequestObject(currentStreamPosition);
requestObject.setStreamType(streamType);
requestObject.setLimit(limit);
final BoxEventCollection events = eventsManager.getEvents(requestObject);
// notify callback
callback.onEvent(events);
// update stream position
currentStreamPosition = events.getNextStreamPosition();
} else if (RECONNECT.equals(message) || MAX_RETRIES.equals(message)) {
LOG.debug("Long poll reconnect for " + cachedBoxClient);
realTimeServer = null;
} else if (OUT_OF_DATE.equals(message)) {
// update currentStreamPosition
LOG.debug("Long poll out of date for " + cachedBoxClient);
currentStreamPosition =
getCurrentStreamPosition(
eventsManager, BoxEventRequestObject.STREAM_POSITION_NOW);
realTimeServer = null;
} else {
throw new RuntimeCamelException("Unknown poll response " + message);
}
} else {
String msg = "Unknown error";
if (statusLine != null) {
msg =
String.format(
"Error polling events for %s: code=%s, message=%s",
cachedBoxClient,
statusLine.getStatusCode(),
statusLine.getReasonPhrase());
}
throw new RuntimeCamelException(msg);
}
}
// keep polling
retry = true;
} catch (InterruptedException e) {
LOG.debug(
"Interrupted event polling thread for {}, exiting...", cachedBoxClient);
} catch (BoxSDKException e) {
callback.onException(e);
} catch (RuntimeCamelException e) {
callback.onException(e);
} catch (SocketException e) {
// TODO handle connection aborts!!!
LOG.debug("Socket exception while event polling for {}", cachedBoxClient);
retry = true;
realTimeServer = null;
} catch (Exception e) {
callback.onException(
new RuntimeCamelException(
"Error while polling for " + cachedBoxClient + ": " + e.getMessage(),
e));
} finally {
// are we done yet?
if (!retry) {
done = true;
} else {
if (realTimeServer != null && (++retries > maxRetries)) {
// make another option call
realTimeServer = null;
}
}
}
}
LOG.info("Stopped event polling thread for " + cachedBoxClient);
}
});
}