/**
* A real node-function (using the node argument). Returns the next newer node of same type. Also
* a nice example on the difference between core and bridge.
*/
public Object successor() {
if (node == null) throw new IllegalArgumentException("successor is a node-function");
if (cloud != null) {
log.debug("Using bridge (security restrictions will be honoured)");
NodeManager nm = node.getNodeManager();
NodeQuery q = nm.createQuery();
StepField field = q.getStepField(nm.getField("number"));
q.setConstraint(
q.createConstraint(
field, FieldCompareConstraint.GREATER, Integer.valueOf(node.getNumber())));
q.addSortOrder(field, SortOrder.ORDER_ASCENDING);
q.setMaxNumber(1);
NodeIterator i = nm.getList(q).nodeIterator();
return i.hasNext() ? i.nextNode() : null;
} else {
log.debug("Using core.");
throw new UnsupportedOperationException("Core implementation was dropped. See source code.");
/* This is how it would go with core objects
MMObjectBuilder builder = MMBase.getMMBase().getBuilder(node.getNodeManager().getName());
NodeSearchQuery query = new NodeSearchQuery(builder);
StepField field = query.getField(builder.getField("number"));
BasicFieldValueConstraint cons = new BasicFieldValueConstraint(field, node.getNumber());
cons.setOperator(FieldCompareConstraint.GREATER);
query.setConstraint(cons);
query.addSortOrder(field);
query.setMaxNumber(1);
try {
java.util.Iterator<MMObjectNode> i = builder.getNodes(query).iterator();
return i.hasNext() ? i.next() : null;
} catch (Exception e) {
return null;
}
*/
}
}
@Override
public String getFunctionValue(final Node node, final Parameters parameters) {
if (log.isDebugEnabled()) {
log.debug("node #" + node.getNumber());
log.debug("params: " + parameters);
}
String status = getDownloadStatus(node);
int timeout = 5;
if (parameters.get(TIMEOUT) != null) {
timeout = parameters.get(TIMEOUT);
}
if (status == null) {
Action action = ActionRepository.getInstance().get("streams", "download_media");
if (action == null) {
throw new IllegalStateException("Action could not be found");
}
if (node.getCloud().may(action, null)) {
synchronized (runningJobs) {
Future<?> future = runningJobs.get(node.getNumber());
if (future == null) {
setDownloadStatus(node, "busy: " + System.currentTimeMillis());
future = submit(node, parameters);
ThreadPools.identify(
future,
DownloadFunction.class.getName()
+ " downloading... for #"
+ node.getNumber()
+ " - status: "
+ getDownloadStatus(node));
String fname = ThreadPools.getString(future);
log.info("Future name: " + fname);
try {
status = (String) future.get(timeout, TimeUnit.SECONDS);
log.info("status: " + status);
} catch (TimeoutException te) {
status = ThreadPools.getString(future);
log.info("TimeoutException: " + status);
} catch (Exception e) {
log.error(e);
}
} else {
status = ThreadPools.getString(future);
}
}
log.info("status: " + status);
return status;
} else {
throw new org.mmbase.security.SecurityException("Not allowed");
}
}
return status;
}
/** @javadoc */
public void handleChanged(String buildername, int number) {
// method checks if this really something valid
// and we should signal a new version
boolean dirty = false;
for (VersionCacheWhenNode whennode : whens) {
List<String> types = whennode.getTypes();
// check if im known in the types part
if (types.contains(buildername)) {
// is there only 1 builder type ?
if (log.isDebugEnabled()) log.debug("types=" + types.toString());
if (types.size() == 1) {
dirty = true;
} else {
// so multiple prepare a multilevel !
List<String> nodes = whennode.getNodes();
List<String> fields = new Vector<String>();
fields.add(buildername + ".number");
List<String> ordervec = new Vector<String>();
List<String> dirvec = new Vector<String>();
List<MMObjectNode> vec =
mmb.getClusterBuilder()
.searchMultiLevelVector(
nodes,
fields,
"YES",
types,
buildername + ".number==" + number,
ordervec,
dirvec);
if (log.isDebugEnabled()) log.debug("VEC=" + vec);
if (vec != null && vec.size() > 0) {
dirty = true;
}
}
}
}
if (dirty) {
// add one to the version of this counter
int version = versionnode.getIntValue("version");
versionnode.setValue("version", version + 1);
versionnode.commit();
if (log.isDebugEnabled()) log.debug("Changed = " + (version + 1));
}
}
@Override
public void render(Parameters blockParameters, Writer w, RenderHints hints)
throws FrameworkException {
log.debug("Error rendering " + blockParameters);
switch (getType()) {
case BODY:
try {
decorateIntro(hints, w, "error");
w.write("<h1>" + error.status);
w.write(": ");
CharTransformer escape = new Xml(Xml.ESCAPE);
w.write(escape.transform(error.exception.getMessage()));
w.write(" ");
w.write(escape.transform(url));
w.write("</h1>");
w.write("<pre>");
HttpServletRequest request = blockParameters.get(Parameter.REQUEST);
error.getErrorReport(w, request, escape);
w.write("</pre>");
decorateOutro(hints, w);
} catch (IOException eio) {
throw new FrameworkException(eio.getMessage(), eio);
}
break;
default:
}
}
@Override
public String getInternalUrl(String page, Map<String, ?> params, Parameters frameworkParameters)
throws FrameworkException {
if (log.isDebugEnabled()) {
log.debug("calling urlConverter " + urlConverter);
}
return urlConverter.getInternalUrl(page, params, frameworkParameters).getUrl();
}
/**
* Handles a pages/mirror service request. Places a page in the file2copy queue, so it will be
* sent to a mirror site by the FileCopier.
*
* @param filenode the filenet node that contains the service request
* @param status the current status of the node
* @param ctype the type of change on that node ("c" : node was changed)
* @return <code>true</code>
*/
public boolean handleMirror(MMObjectNode filenode, int status, String ctype) {
switch (status) {
case Netfiles.STATUS_REQUEST: // Request
// register the node as being On Its Way
filenode.setValue("status", Netfiles.STATUS_ON_ITS_WAY);
filenode.commit();
String filename = filenode.getStringValue("filename");
String dstserver = filenode.getStringValue("mmserver");
// recover the correct source/dest properties for this mirror
//
// why does it say "demoserver" ??
//
String sshpath = getProperty("demoserver", "sshpath");
log.debug("sshpath=" + sshpath);
String srcpath = getProperty("demoserver", "path");
log.debug("srcpath=" + srcpath);
String dstuser = getProperty(dstserver, "user");
log.debug("dstuser="******"host");
log.debug("dsthost=" + dsthost);
String dstpath = getProperty(dstserver, "path");
log.debug("dstpath=" + dstpath);
/* this code can be dropped as it is handled in FileCopier
SCPcopy scpcopy=new SCPcopy(sshpath,dstuser,dsthost,dstpath);
synchronized(syncobj) {
scpcopy.copy(srcpath,filename);
}
*/
// create a new file2copy object and add it to the queue,
// so the FileCopier thread will handle it.
files2copy.append(new aFile2Copy(dstuser, dsthost, dstpath, srcpath, filename, sshpath));
// register the node as being Done
filenode.setValue("status", Netfiles.STATUS_DONE);
filenode.commit();
break;
case Netfiles.STATUS_ON_ITS_WAY: // On its way
break;
case Netfiles.STATUS_DONE: // Done
break;
}
return true;
}
public ModelAndView getModelAndView(HttpServletRequest request, ResultContainer result) {
Map<String, Object> model = new HashMap<String, Object>();
model.put("idmap", result.getIdMap());
ModelAndView errorMandv = new ModelAndView(errorPage);
List<GlobalError> globalErrors = result.getGlobalErrors();
if (result.hasGlobalErrors()) {
errorMandv.addObject(GlobalError.MODEL_MAPPING_KEY, globalErrors);
log.debug("request has global errors, so the return page is: " + errorPage);
return errorMandv;
}
if (result.hasFieldErrors()) {
model.put(FieldError.MODEL_MAPPING_KEY, result.getFieldErrors());
// Field errors are not displayed in the error page but in the referrer page (the form)
}
// has a new object been created?
// String newObject = result.getNewObjects();
// set the new object in the request (why?)
// if (newObject != null) {
// request.setAttribute("newObject", newObject);
// if (log.isDebugEnabled()) {
// log.debug("object number " + newObject);
// }
// }
final String callerPage = request.getHeader("referer");
if (callerPage == null) {
// this is an error for this view resolver
globalErrors.add(new GlobalError("error.no.referrer.header", result.getLocale()));
log.error("REFERRER NOT SET! This request's redirection wil fail.");
errorMandv.addObject(GlobalError.MODEL_MAPPING_KEY, globalErrors);
return errorMandv;
}
// add the node number of the new object to the referer url.
// if (result.getNewObject().size() > 0) {
// if (log.isDebugEnabled()) {
// log.debug("new object created.");
// }
// String newNodeNr = result.getNewObject().get(0);
// //newPage = newPage.substring(0, newPage.indexOf("?") + 1) + "nodenr=" +
// newNodeNr;
// String newPage = new URLParamMap(callerPage).addParam("nodenr", newNodeNr,
// true).toString();
// }
URLParamMap u = new URLParamMap(callerPage);
if (result.getExtraParams().size() > 0) {
for (String param : result.getExtraParams().keySet()) {
u.addParam(param, result.getExtraParams().get(param), true);
}
}
RedirectView redirectView = new RedirectView(u.toString());
return new ModelAndView(redirectView, model);
}
@Override
public CloseableIterator<JdbcEntry> getSubCursor(String identifier) {
if (isSub) {
log.debug("Using getSubCursor for " + identifier);
return getSqlCursor(getSql(identifier));
} else {
return getSqlCursor(getFindSql(identifier));
}
}
/**
* Schedules a service-request on a file. Only "pages/main" services are handled. The
* service-request is later handled through the {@link #probeCall} method.
*
* @param service the service to be performed
* @param subservice the subservice to be performed
* @param filename the filename to service
* @return <code>true</code> if maintenance was performed, <code>false</code> otherwise
*/
public boolean fileChange(String service, String subservice, String filename) {
log.debug("frontend change -> " + filename);
log.service("s=" + service + " sub=" + subservice + "file=" + filename);
// jump to correct subhandles based on the subservice
if (subservice.equals("main")) {
handleMainCheck(service, subservice, filename);
}
return true;
}
@SuppressWarnings("unchecked")
protected void setBlockParametersForRender(State state, Parameters blockParameters) {
ServletRequest request = state.getRequest();
String prefix = getPrefix(state);
log.debug("prefix " + prefix);
blockParameters.setAutoCasting(true);
for (Map.Entry<String, String[]> entry :
((Map<String, String[]>) request.getParameterMap()).entrySet()) {
String key = entry.getKey();
if (key.startsWith(prefix)) {
log.trace("setting" + entry);
blockParameters.setIfDefined(key.substring(prefix.length()), entry.getValue());
}
}
if (log.isDebugEnabled()) {
log.debug("Set " + blockParameters);
}
}
/**
* Recalculate a page. Invokes the SCAN parser (which will re-cache the page through the scancache
* module) Only works for SCAN.
*
* @param url of the page to cache
*/
public void calcPage(String url) {
scanparser m = (scanparser) Vwms.getMMBase().getModule("SCANPARSER");
url = url.substring(0, url.length() - 5);
url = url.replace(':', '?');
log.debug("getPage=" + url);
if (m != null) {
scanpage sp = new scanpage();
m.calcPage(url, sp, 0);
}
}
/** @since MMBase-1.6.2 */
private void readCache(boolean buildersInitialized) {
log.debug("Reading in typerels");
typeRelNodes = new TypeRelSet();
parentTypeRelNodes = new TypeRelSet();
inverseTypeRelNodes = new InverseTypeRelSet();
TypeDef typeDef = mmb.getTypeDef();
typeDef.init();
// Find all typerel nodes
List<MMObjectNode> alltypes = getNodes();
for (MMObjectNode typerel : alltypes) {
addCacheEntry(typerel, buildersInitialized);
}
log.debug(
"Done reading typerel cache "
+ (buildersInitialized ? "(considered inheritance)" : "")
+ ": "
+ typeRelNodes);
}
@Override
public String getProcessUrl(
String path, Map<String, ?> parameters, Parameters frameworkParameters, boolean escapeAmps)
throws FrameworkException {
HttpServletRequest request =
BasicUrlConverter.getUserRequest(frameworkParameters.get(Parameter.REQUEST));
State state = State.getState(request);
frameworkParameters.set(ACTION, state.getId());
Url url = urlConverter.getProcessUrl(path, parameters, frameworkParameters, escapeAmps);
if (url == Url.NOT) {
log.debug("Fall back url");
return fallbackConverter
.getProcessUrl(path, parameters, frameworkParameters, escapeAmps)
.getUrl();
} else {
log.debug("Url converter url " + url);
return url.getUrl();
}
}
@Override
protected void label(URLComposer uc) {
for (Map.Entry<String, BitrateInfo> entry : bitrates.entrySet()) {
int bitrate = uc.getSource().getIntValue("bitrate");
if (entry.getValue().matches(bitrate)) {
log.debug("" + bitrate + " matched " + entry);
if (overwrite || !uc.getInfo().containsKey(key)) {
uc.getInfo().put(key, entry.getKey());
}
}
}
}
@Override
public String getUrl(
String path, Map<String, ?> parameters, Parameters frameworkParameters, boolean escapeAmps)
throws FrameworkException {
Url link = urlConverter.getUrl(path, parameters, frameworkParameters, escapeAmps);
log.debug("got " + link + " from " + urlConverter);
if (link == Url.NOT) {
return fallbackConverter.getUrl(path, parameters, frameworkParameters, escapeAmps).getUrl();
} else {
return link.getUrl();
}
}
protected boolean executeOnlyIf(Connection con, String q) throws SQLException {
if (q == null) return true;
Statement stmt = null;
try {
stmt = con.createStatement();
q = q.replace("$PREFIX", getPrefix());
LOG.debug(" Executing query " + q);
ResultSet rs = stmt.executeQuery(q);
rs.next();
boolean res = rs.getBoolean(1);
LOG.debug("Result: " + res);
return res;
} catch (SQLException sqe) {
LOG.error(sqe.getMessage() + " from " + q);
throw sqe;
} finally {
try {
if (stmt != null) {
stmt.close();
}
} catch (Exception g) {
}
}
}
@Override
public String extract(InputStream input) throws Exception {
log.debug("extract stream");
String result = null;
DefaultStyledDocument styledDoc = new DefaultStyledDocument();
try {
new RTFEditorKit().read(input, styledDoc, 0);
result = styledDoc.getText(0, styledDoc.getLength());
} catch (IOException e) {
throw new Exception("Cannot extract text from a RTF document", e);
} catch (BadLocationException e) {
throw new Exception("Cannot extract text from a RTF document", e);
}
return result;
}
@Override
public void configure(DocumentReader reader, Element element) {
bitrates.clear();
try {
for (Element bitrate :
DocumentReader.getChildElements(reader.getElementByPath(element, CONFIG_TAG))) {
BitrateInfo bri = new BitrateInfo(bitrate);
log.debug("Adding BitrateInfo " + bri);
bitrates.put(bri.getName(), bri);
}
} catch (Exception ex) {
log.error("Error in filter.xml:" + ex, ex);
}
log.info("Configured bit rate labeler " + bitrates);
FilterUtils.propertiesConfigure(this, reader, element);
}
@Override
public void render(Parameters blockParameters, Writer w, RenderHints hints)
throws FrameworkException {
if (decorate) {
try {
decorateIntro(hints, w, null);
} catch (IOException ioe) {
throw new FrameworkException(ioe);
}
}
String name = getResource();
ResourceLoader loader = ResourceLoader.Type.valueOf(resourceType.toUpperCase()).get();
try {
InputStream is = loader.getResourceAsStream(name);
if (is == null)
throw new FrameworkException(
"No such resource " + loader.getResource(name) + " in " + loader);
if (xsl == null) {
Reader r = loader.getReader(is, name);
char[] buf = new char[1000];
int c;
while ((c = r.read(buf, 0, 1000)) > 0) {
w.write(buf, 0, c);
}
} else {
/// convert using the xsl and spit out that.
URL x = ResourceLoader.getConfigurationRoot().getResource(xsl);
Utils.xslTransform(blockParameters, loader.getResource(name), is, w, x);
}
} catch (IOException ioe) {
throw new FrameworkException(ioe);
} catch (javax.xml.transform.TransformerException te) {
throw new FrameworkException(te.getMessage(), te);
} catch (RuntimeException e) {
log.debug(e.getMessage(), e);
throw e;
} finally {
if (decorate) {
try {
decorateOutro(hints, w);
} catch (IOException ioe) {
throw new FrameworkException(ioe);
}
}
}
}
@Override
public org.mmbase.bridge.Node getNode(final Cloud userCloud, final Document doc) {
String docId = doc.get("number");
if (docId == null) {
throw new IllegalArgumentException("No number found in " + doc);
}
LazyMap m = nodeCache.get(docId); //
if (m == null) {
Map<String, String> keys = new HashMap<String, String>();
for (String keyWord : keyWords) {
keys.put(keyWord, doc.get(keyWord));
}
m = new LazyMap(docId, keys);
nodeCache.put(docId, m);
}
org.mmbase.bridge.Node node =
new MapNode<String>(
m,
new MapNodeManager(userCloud, m) {
@Override
public boolean hasField(String name) {
if (JdbcIndexDefinition.this.key.equals(name)) return true;
return super.hasField(name);
}
@Override
public org.mmbase.bridge.Field getField(String name) {
if (map == null && JdbcIndexDefinition.this.key.equals(name)) {
org.mmbase.core.CoreField fd =
org.mmbase.core.util.Fields.createField(
name,
org.mmbase.core.util.Fields.classToType(Object.class),
org.mmbase.bridge.Field.TYPE_UNKNOWN,
org.mmbase.bridge.Field.STATE_VIRTUAL,
null);
return new org.mmbase.bridge.implementation.BasicField(fd, this);
} else {
return super.getField(name);
}
}
});
if (log.isDebugEnabled()) {
log.debug("Returning node for " + node);
}
return node;
}
/**
* Schedules a netfile object to be send to its mirror sites. The routine searches the appropriate
* netfile node, and sets its status to 'request'. If a node does not exits, a new node is
* created. In the latter case, the system also creates mirrornodes for each mirrorsite associated
* with this service.
*
* @param service the service to be performed
* @param subservice the subservice to be performed
* @param filename the filename to service
*/
public void handleMainCheck(String service, String subservice, String filename) {
log.debug("Reached handleMainCheck");
Netfiles bul = (Netfiles) Vwms.getMMBase().getMMObject("netfiles");
Enumeration e =
bul.search(
"WHERE filename='"
+ filename
+ "' AND service='"
+ service
+ "' AND subservice='"
+ subservice
+ "'");
if (e.hasMoreElements()) {
MMObjectNode mainnode = (MMObjectNode) e.nextElement();
mainnode.setValue("status", Netfiles.STATUS_REQUEST);
mainnode.commit();
} else {
MMObjectNode mainnode = bul.getNewNode("system");
mainnode.setValue("filename", filename);
mainnode.setValue("mmserver", Vwms.getMMBase().getMachineName());
mainnode.setValue("service", service);
mainnode.setValue("subservice", subservice);
mainnode.setValue("status", Netfiles.STATUS_REQUEST);
mainnode.setValue("filesize", -1);
bul.insert("system", mainnode);
Enumeration f = getMirrorNodes(service).elements();
while (f.hasMoreElements()) {
MMObjectNode n2 = (MMObjectNode) f.nextElement();
// hack hack also have to create mirror nodes !
mainnode = bul.getNewNode("system");
mainnode.setValue("filename", filename);
mainnode.setValue("mmserver", n2.getStringValue("name"));
mainnode.setValue("service", service);
mainnode.setValue("subservice", "mirror");
mainnode.setValue("status", Netfiles.STATUS_DONE);
mainnode.setValue("filesize", -1);
bul.insert("system", mainnode);
}
}
}
public void run() {
Connection con = null;
Statement stmt = null;
try {
DataSource ds = getDataSource();
con = ds.getConnection();
if (executeOnlyIf(con, onlyIfQuery)) {
stmt = con.createStatement();
if (query != null) {
executeQuery(stmt, query);
} else if (update != null) {
executeUpdate(stmt, update);
} else {
throw new IllegalStateException("Both query and update properties are unset");
}
} else {
LOG.debug("Skipped because of " + onlyIfQuery);
}
} catch (RuntimeException e) {
throw e;
} catch (Throwable t) {
if (ignore.matcher(t.getMessage()).matches()) {
LOG.info("Ignoring " + t.getMessage());
} else {
throw new RuntimeException(t.getMessage(), t);
}
} finally {
try {
if (stmt != null) {
stmt.close();
}
} catch (Exception g) {
}
try {
if (con != null) {
con.close();
}
} catch (Exception g) {
}
}
}
/*
* (non-Javadoc)
* @see org.mmbase.module.core.MMObjectBuilder#notify(org.mmbase.core.event.NodeEvent)
*/
@Override
public void notify(NodeEvent event) {
if (log.isDebugEnabled()) {
log.debug(
"Changed "
+ event.getMachine()
+ " "
+ event.getNodeNumber()
+ " "
+ event.getBuilderName()
+ " "
+ NodeEvent.newTypeToOldType(event.getType()));
}
if (tableName.equals(event.getBuilderName())) {
if (event.getType() == Event.TYPE_NEW) {
MMObjectNode typeRelNode = getNode(event.getNodeNumber());
if (typeRelNode != null) {
Set<MMObjectNode> newTypeRels = addCacheEntry(typeRelNode, true);
log.service("Added to typerelcache: " + newTypeRels);
} else {
log.warn("Could not found typerel node with number " + event.getNodeNumber());
}
} else {
// something else changed in a typerel node? reread the complete typeRelNodes Set
log.service(
"Received '" + event + "' which is about typrels. Now re-reading the entire cache");
readCache();
}
// also, clear all query-caches, because result may change by this. See MMB-348
for (Cache qc : CacheManager.getMap().values()) {
if (qc instanceof QueryResultCache) {
qc.clear();
}
}
}
super.notify(event);
}
/**
* Basic Framework implicitely also processes, i'm not sure if we should require any framework to
* do that (perhaps we could say, that the render method must process, if that is necessary, and
* not yet done).
*/
@Override
public void render(
Renderer renderer,
Parameters blockParameters,
Parameters frameworkParameters,
Writer w,
WindowState windowState)
throws FrameworkException {
ServletRequest request = frameworkParameters.get(Parameter.REQUEST);
if (request == null) {
throw new IllegalArgumentException("No request object given");
}
State state = State.getState(request);
if (state
.isRendering()) { // mm:component used during rending of a component, that's fine, but use a
// new State.
state = new State(request);
log.debug("Alreadying rendering, taking a new state for sub-block-rendering: " + state);
}
log.debug("Rendering " + renderer.getBlock() + " " + renderer);
Object prevHints = request.getAttribute(RenderHints.KEY);
try {
request.setAttribute(COMPONENT_CLASS_KEY, getComponentClass());
request.setAttribute(COMPONENT_CURRENTUSER_KEY, getUserNode(frameworkParameters));
Renderer actualRenderer = state.startBlock(frameworkParameters, renderer);
if (!actualRenderer.equals(renderer)) {
Parameters newBlockParameters = actualRenderer.getBlock().createParameters();
newBlockParameters.setAllIfDefined(blockParameters);
blockParameters = newBlockParameters;
}
state.setAction(request.getParameter(ACTION.getName()));
if (state.needsProcess()) {
log.service("Performing action on " + actualRenderer.getBlock());
Processor processor = actualRenderer.getBlock().getProcessor();
state.process(processor);
log.service("Processing " + actualRenderer.getBlock() + " " + processor);
setBlockParametersForProcess(state, blockParameters);
processor.process(blockParameters);
state.endProcess();
}
state.render(actualRenderer);
setBlockParametersForRender(state, blockParameters);
RenderHints hints =
new RenderHints(
actualRenderer,
windowState,
state.getId(),
getComponentClass(),
RenderHints.Mode.NORMAL);
request.setAttribute(RenderHints.KEY, hints);
actualRenderer.render(blockParameters, w, hints);
request.setAttribute("org.mmbase.framework.hints", hints);
} catch (FrameworkException fe) {
log.debug(fe);
URI uri = renderer.getUri();
Renderer error =
new ErrorRenderer(
renderer.getType(),
renderer.getBlock(),
(uri != null) ? uri.toString() : null,
500,
fe);
RenderHints hints =
new RenderHints(
error, windowState, state.getId(), getComponentClass(), RenderHints.Mode.NORMAL);
error.render(blockParameters, w, hints);
} finally {
request.setAttribute(RenderHints.KEY, prevHints);
state.endBlock();
}
}
/**
* Addes one typerel cache entries, plus inherited relations (if builder are initialized)
*
* @return A Set with the added entries, which can be used for logging or so, or can be
* disregarded
* @since MMBase-1.6.2
*/
protected TypeRelSet addCacheEntry(
final MMObjectNode typeRel, final boolean buildersInitialized) {
if (typeRel == null) {
throw new IllegalArgumentException("typeRel cannot be null");
}
final TypeRelSet added =
new TypeRelSet(); // store temporary, which will enable nice logging of what happened
// Start to add the actual definition, this is then afterwards again,
// except if one of the builders could not be found
added.add(typeRel);
if (mmb == null) {
throw new IllegalStateException("mmb is null");
}
final RelDef reldef = mmb.getRelDef();
if (reldef == null) {
throw new IllegalStateException("No reldef found");
}
final MMObjectNode reldefNode = reldef.getNode(typeRel.getIntValue("rnumber"));
if (reldefNode == null) {
throw new RuntimeException(
"Could not find reldef-node for rnumber= " + typeRel.getIntValue("rnumber"));
}
final boolean bidirectional = (!InsRel.usesdir) || (reldefNode.getIntValue("dir") > 1);
INHERITANCE:
if (buildersInitialized) { // handle inheritance, which is
// not possible during
// initialization of MMBase.
final TypeDef typeDef = mmb.getTypeDef();
final String sourceBuilderName = typeDef.getValue(typeRel.getIntValue("snumber"));
final MMObjectBuilder sourceBuilder =
sourceBuilderName != null ? mmb.getBuilder(sourceBuilderName) : null;
final String destinationBuilderName = typeDef.getValue(typeRel.getIntValue("dnumber"));
final MMObjectBuilder destinationBuilder =
destinationBuilderName != null ? mmb.getBuilder(destinationBuilderName) : null;
if (sourceBuilder == null) {
if (destinationBuilder == null) {
log.info(
"Both source and destination of "
+ typeRel
+ " are not active builders. Cannot follow descendants.");
} else {
log.info(
"The source of relation type "
+ typeRel
+ " is not an active builder. Cannot follow descendants.");
}
break INHERITANCE;
}
if (destinationBuilder == null) {
log.warn(
"The destination of relation type "
+ typeRel
+ " is not an active builder. Cannot follow descendants.");
break INHERITANCE;
}
final int rnumber = typeRel.getIntValue("rnumber");
final List<MMObjectBuilder> sources =
new ArrayList<MMObjectBuilder>(sourceBuilder.getDescendants());
sources.add(sourceBuilder);
final List<MMObjectBuilder> destinations =
new ArrayList<MMObjectBuilder>(destinationBuilder.getDescendants());
destinations.add(destinationBuilder);
for (MMObjectBuilder s : sources) {
for (MMObjectBuilder d : destinations) {
MMObjectNode vnode = new VirtualTypeRelNode(s.getNumber(), d.getNumber(), rnumber);
added.add(vnode);
}
}
// seek all parents and store typerels for them
// this cache is used by contains(INCLUDE_PARENTS /
// INCLUDE_PARENTS_AND_DESCENDANTS));
MMObjectBuilder sourceParent = sourceBuilder;
while (sourceParent != null) {
MMObjectBuilder destinationParent = destinationBuilder;
while (destinationParent != null) {
MMObjectNode vnode =
new VirtualTypeRelNode(
sourceParent.getNumber(), destinationParent.getNumber(), rnumber);
parentTypeRelNodes.add(vnode);
destinationParent = destinationParent.getParentBuilder();
}
sourceParent = sourceParent.getParentBuilder();
}
added.add(typeRel); // replaces the ones added in the 'inheritance'
// loop (so now not any more Virtual)
}
for (MMObjectNode node : added) {
if (!node.isVirtual()) {
// make sure 'real' nodes replace virtual nodes. (real and virtual nodes are equal, so will
// not be added to set otherwise)
// This is especially essential whey you use STRICT in contains
typeRelNodes.remove(node);
if (bidirectional) inverseTypeRelNodes.remove(node);
}
typeRelNodes.add(node);
if (bidirectional) inverseTypeRelNodes.add(node);
}
if (log.isDebugEnabled()) {
log.debug("Added to typerelcache: " + added);
}
return added;
}
@Override
public void onChange(String resource) {
try {
LOG.debug("Reading " + resource);
HashMap<CommandExecutor.Method, Stage> newexecutorsMap =
new HashMap<CommandExecutor.Method, Stage>();
Document document = getResourceLoader().getDocument(resource);
Map<Stage, Integer> totals = new EnumMap<Stage, Integer>(Stage.class);
if (document != null) {
org.w3c.dom.NodeList ellist = document.getDocumentElement().getChildNodes();
Stage prevStage = Stage.RECOGNIZER;
for (int i = 0; i <= ellist.getLength(); i++) {
if (ellist.item(i) instanceof Element) {
Element el = (Element) ellist.item(i);
if (el.getTagName().equals("localhost")) {
int max = Integer.parseInt(el.getAttribute("max_simultaneous_transcoders"));
Stage s = Stage.valueOf(el.getAttribute("stage").toUpperCase());
Integer t = totals.get(s);
if (t == null) t = 0;
t += max;
totals.put(s, t);
for (int j = 1; j <= max; j++) {
newexecutorsMap.put(new CommandExecutor.Method(), s);
}
} else if (el.getTagName().equals("server")) {
int max = Integer.parseInt(el.getAttribute("max_simultaneous_transcoders"));
Stage s = Stage.valueOf(el.getAttribute("stage").toUpperCase());
Integer t = totals.get(s);
if (t == null) t = 0;
t += max;
totals.put(s, t);
String host = el.getAttribute("host");
int port = Integer.parseInt(el.getAttribute("port"));
for (int j = 1; j <= max; j++) {
newexecutorsMap.put(new CommandExecutor.Method(host, port), s);
}
}
}
}
for (Map.Entry<Stage, Integer> e : totals.entrySet()) {
threadPools.get(e.getKey()).setCorePoolSize(e.getValue());
threadPools.get(e.getKey()).setMaximumPoolSize(e.getValue());
}
} else {
LOG.warn("No " + resource);
}
synchronized (executorsMap) {
executorsMap.clear();
executorsMap.putAll(newexecutorsMap);
}
LOG.service(
"Reading of configuration file "
+ resource
+ " successfull. Executors "
+ executorsMap
+ ". Max simultaneous transcoders: "
+ totals);
} catch (Exception e) {
LOG.error(
e.getClass()
+ " "
+ e.getMessage()
+ " In "
+ resource
+ " Executors now "
+ executorsMap
+ " (not changed)",
e);
}
}
private Boolean sendMail(HttpServletRequest req, Node node, String email) {
boolean send = false;
Cloud cloud = node.getCloud();
String emailbuilder = "email";
try {
Module sendmail = cloud.getCloudContext().getModule("sendmail");
emailbuilder = sendmail.getProperty("emailbuilder");
} catch (NotFoundException nfe) {
log.warn("No email module " + nfe);
}
if (cloud.hasNodeManager(emailbuilder)) {
NodeManager nm = cloud.getNodeManager(emailbuilder);
Node message = nm.createNode();
String host = req.getHeader("host");
if (host == null || "".equals(host)) {
try {
host = java.net.InetAddress.getLocalHost().getHostName();
} catch (UnknownHostException uhe) {
log.warn("No host: " + uhe);
}
}
String from = "downloader@" + host;
// do a quick check if we've got something more or less valid
Pattern p = Pattern.compile(".+@.+\\.[a-z]+");
Matcher m = p.matcher(from);
if (!m.matches()) {
from = "*****@*****.**";
}
String mediaTitle = node.getStringValue("title");
String mediaUrl = getProperty(node, URL_KEY);
StringBuilder body = new StringBuilder();
body.append("*This is an automated message / Dit is een geautomatiseerd bericht*");
body.append("\n\n*English*");
body.append("\n\nDear,");
body.append("\n\nWe have received your file belonging to media item titled '")
.append(mediaTitle)
.append("'. ");
body.append("In about 1 hour, you can find your submission at: ");
body.append("http://").append(host).append("/media/").append(node.getNumber());
body.append("\n\nKind regards,");
body.append("\n\n").append(host);
body.append("\n\n\n*Nederlands*");
body.append("\n\nBeste,");
body.append("\n\nWe hebben je bestand voor het media item met de titel '")
.append(mediaTitle)
.append("' ontvangen. ");
body.append("Je kunt je bijdrage hier over circa een uur terugvinden: ");
body.append("http://").append(host).append("/media/").append(node.getNumber());
body.append("\n\nMet vriendelijke groet,");
body.append("\n\n").append(host);
message.setValue("from", from);
message.setValue("to", email);
message.setValue("subject", "Download complete / Download voltooid");
message.setValue("body", body.toString());
message.commit();
Function mail = message.getFunction("mail");
Parameters mail_params = mail.createParameters();
mail_params.set("type", "oneshot");
mail.getFunctionValue(mail_params);
if (log.isDebugEnabled()) {
log.debug("Message download ready send to: " + email);
}
send = true;
} else {
log.warn("Can not send message - no emailbuilder installed.");
}
return send;
}
public Writer getErrorReport(
Writer to, final HttpServletRequest request, CharTransformer escape) throws IOException {
final Writer logMsg = new StringWriter();
final Writer tee = new org.mmbase.util.ChainedWriter(to, logMsg);
Writer msg = tee;
LinkedList<Throwable> stack = getStack();
String ticket = new Date().toString();
Map<String, String> props;
try {
props = org.mmbase.util.ApplicationContextReader.getProperties("mmbase_errorpage");
} catch (javax.naming.NamingException ne) {
props = Collections.emptyMap();
log.info(ne);
}
if (request != null) {
{
msg.append("Headers\n----------\n");
// request properties
for (Object name : Collections.list(request.getHeaderNames())) {
msg.append(
escape.transform(
name + ": " + escape.transform(request.getHeader((String) name)) + "\n"));
}
}
{
msg.append("\nAttributes\n----------\n");
Pattern p = requestIgnore;
if (p == null && props.get("request_ignore") != null) {
p = Pattern.compile(props.get("request_ignore"));
}
for (Object name : Collections.list(request.getAttributeNames())) {
if (p == null || !p.matcher((String) name).matches()) {
msg.append(
escape.transform(name + ": " + request.getAttribute((String) name) + "\n"));
}
}
}
if (Boolean.TRUE.equals(showSession)
|| (showSession == null && !"false".equals(props.get("show_session")))) {
HttpSession ses = request.getSession(false);
if (ses != null) {
msg.append("\nSession\n----------\n");
Pattern p = sessionIgnore;
if (p == null && props.get("session_ignore") != null) {
p = Pattern.compile(props.get("session_ignore"));
}
for (Object name : Collections.list(ses.getAttributeNames())) {
if (p == null || !p.matcher((String) name).matches()) {
msg.append(escape.transform(name + ": " + ses.getAttribute((String) name) + "\n"));
}
}
}
}
}
msg.append("\n");
msg.append("Misc. properties\n----------\n");
if (request != null) {
msg.append("method: ").append(escape.transform(request.getMethod())).append("\n");
msg.append("querystring: ").append(escape.transform(request.getQueryString())).append("\n");
msg.append("requesturl: ")
.append(escape.transform(request.getRequestURL().toString()))
.append("\n");
}
if (Boolean.TRUE.equals(showMMBaseVersion)
|| (showMMBaseVersion == null && !"false".equals(props.get("show_mmbase_version")))) {
msg.append("mmbase version: ").append(org.mmbase.Version.get()).append("\n");
}
msg.append("status: ").append("").append(String.valueOf(status)).append("\n\n");
if (request != null) {
msg.append("Parameters\n----------\n");
// request parameters
Enumeration en = request.getParameterNames();
while (en.hasMoreElements()) {
String name = (String) en.nextElement();
msg.append(name)
.append(": ")
.append(escape.transform(request.getParameter(name)))
.append("\n");
}
}
msg.append("\nException ")
.append(ticket)
.append("\n----------\n\n")
.append(
exception != null
? (escape.transform(exception.getClass().getName()))
: "NO EXCEPTION")
.append(": ");
int wroteCauses = 0;
while (!stack.isEmpty()) {
Throwable t = stack.removeFirst();
// add stack stacktraces
if (t != null) {
if (stack.isEmpty()) { // write last message always
msg = tee;
}
String message = t.getMessage();
if (msg != tee) {
to.append("\n=== skipped(see log) : ")
.append(escape.transform(t.getClass().getName()))
.append(": ")
.append(message)
.append("\n");
}
msg.append("\n\n").append(escape.transform(t.getClass().getName() + ": " + message));
StackTraceElement[] stackTrace = t.getStackTrace();
for (StackTraceElement e : stackTrace) {
msg.append("\n at ").append(escape.transform(e.toString()));
}
if (!stack.isEmpty()) {
msg.append("\n-------caused:\n");
}
wroteCauses++;
if (wroteCauses >= MAX_CAUSES) {
msg = logMsg;
}
}
}
// write errors to log
if (status == 500) {
try {
if (props.get("to") != null && props.get("to").length() > 0) {
javax.naming.Context initCtx = new javax.naming.InitialContext();
javax.naming.Context envCtx = (javax.naming.Context) initCtx.lookup("java:comp/env");
Object mailSession = envCtx.lookup("mail/Session");
Class sessionClass = Class.forName("javax.mail.Session");
Class recipientTypeClass = Class.forName("javax.mail.Message$RecipientType");
Class messageClass = Class.forName("javax.mail.internet.MimeMessage");
Object mail = messageClass.getConstructor(sessionClass).newInstance(mailSession);
messageClass
.getMethod("addRecipients", recipientTypeClass, String.class)
.invoke(mail, recipientTypeClass.getDeclaredField("TO").get(null), props.get("to"));
messageClass.getMethod("setSubject", String.class).invoke(mail, ticket);
mail.getClass().getMethod("setText", String.class).invoke(mail, logMsg.toString());
Class.forName("javax.mail.Transport")
.getMethod("send", Class.forName("javax.mail.Message"))
.invoke(null, mail);
tee.append("\nmailed to (").append(String.valueOf(props)).append(")");
}
} catch (Exception nnfe) {
tee.append("\nnot mailed (").append(String.valueOf(nnfe)).append(")");
if (log.isDebugEnabled()) {
log.debug(nnfe.getMessage(), nnfe);
}
}
log.error("TICKET " + ticket + ":\n" + logMsg);
}
return to;
}
/** Constructor for the PageMaster VWM. */
public PageMaster() {
log.debug("ready for action");
}
CloseableIterator<JdbcEntry> getSqlCursor(final String sql) {
try {
long start = System.currentTimeMillis();
final Connection con = getDirectConnection();
log.debug("About to execute " + sql + " (" + directConnections + ")");
final Statement statement = con.createStatement();
final ResultSet results = statement.executeQuery(sql);
if (log.isDebugEnabled()) {
log.debug("Executed " + sql + " in " + (System.currentTimeMillis() - start) + " ms");
}
final ResultSetMetaData meta = results.getMetaData();
return new CloseableIterator<JdbcEntry>() {
boolean hasNext = results.isBeforeFirst();
int i = 0;
@Override
public boolean hasNext() {
return hasNext;
}
@Override
public JdbcEntry next() {
if (!hasNext) {
throw new NoSuchElementException();
}
try {
results.next();
hasNext = !results.isLast();
} catch (java.sql.SQLException sqe) {
log.error(sqe);
hasNext = false;
}
JdbcEntry entry = new JdbcEntry(meta, results, sql);
i++;
if (log.isServiceEnabled()) {
if (i % 100 == 0) {
log.service("jdbc cursor " + i + " (now at id=" + entry.getIdentifier() + ")");
} else if (log.isDebugEnabled()) {
log.trace("jdbc cursor " + i + " (now at id=" + entry.getIdentifier() + ")");
}
}
return entry;
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
@Override
public void close() {
log.debug("Closing " + con);
try {
if (results != null) results.close();
if (statement != null) statement.close();
if (con != null) con.close();
} catch (Exception e) {
log.error(e);
}
}
};
} catch (Exception e) {
throw new RuntimeException(e.getMessage(), e);
}
}
