@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;
}
protected MMObjectNode getGroupOrUserNode(Parameters a) {
MMObjectNode groupOrUser = getNode(a.getString(PARAMETER_GROUPORUSER));
if (groupOrUser == null)
throw new IllegalArgumentException(
"There is no node with id '" + a.get(PARAMETER_GROUPORUSER) + "'");
MMObjectBuilder parent = groupOrUser.getBuilder();
MMObjectBuilder userBuilder = Authenticate.getInstance().getUserProvider().getUserBuilder();
if (!(parent instanceof Groups || userBuilder.getClass().isInstance(parent))) {
throw new IllegalArgumentException(
"Node '" + a.get(PARAMETER_GROUPORUSER) + "' does not represent a group or a user");
}
return groupOrUser;
}
@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:
}
}
/**
* I think in the basic framework this method is never called explicitely, because processing is
* done implicitly by the render
*/
@Override
public void process(
Processor processor, Parameters blockParameters, Parameters frameworkParameters)
throws FrameworkException {
HttpServletRequest request = frameworkParameters.get(Parameter.REQUEST);
State state = State.getState(request);
state.startBlock(frameworkParameters, null);
setBlockParametersForProcess(state, blockParameters);
processor.process(blockParameters);
}
@Override
public Block getRenderingBlock(Parameters frameworkParameters) {
HttpServletRequest request = frameworkParameters.get(Parameter.REQUEST);
State state = State.getState(request);
if (state.isRendering()) {
return state.getBlock();
} else {
return null;
}
}
@SuppressWarnings("unchecked")
@Override
public <C> C setSettingValue(Setting<C> setting, Parameters parameters, C value) {
if (parameters == null)
throw new SecurityException("You should provide Cloud and request parameters");
boolean useSession = parameters.get(USE_REQ);
if (useSession) {
C ret = getSettingValue(setting, parameters);
HttpServletRequest req = parameters.get(Parameter.REQUEST);
req.getSession(true).setAttribute(getKey(setting), value);
return ret;
} else {
Cloud cloud = parameters.get(Parameter.CLOUD);
if (cloud.getUser().getRank() == org.mmbase.security.Rank.ADMIN) {
saveSettingValue(setting, value);
return (C) settingValues.put(setting, value);
} else {
throw new SecurityException("Permission denied");
}
}
}
@SuppressWarnings("unchecked")
@Override
public <C> C getSettingValue(Setting<C> setting, Parameters parameters) {
boolean useSession = parameters != null && parameters.get(USE_REQ);
if (useSession) {
HttpServletRequest req = parameters.get(Parameter.REQUEST);
if (req != null) {
Object v = req.getSession(true).getAttribute(getKey(setting));
if (v != null) {
return setting.getDataType().cast(v, null, null);
}
}
}
if (settingValues.containsKey(setting)) {
return (C) settingValues.get(setting);
} else {
C settingValue = loadSettingValue(setting);
if (settingValue != null) {
settingValues.put(setting, settingValue);
return settingValue;
}
return setting.getDataType().getDefaultValue();
}
}
@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
public Node getUserNode(Parameters frameworkParameters) {
Cloud cloud = frameworkParameters.get(Parameter.CLOUD);
if (cloud == null) {
return null;
} else {
try {
int userNode = cloud.getCloudContext().getAuthentication().getNode(cloud.getUser());
if (cloud.hasNode(userNode)) {
return cloud.getNode(userNode);
} else {
return null;
}
} catch (UnsupportedOperationException uoe) {
// never mind
return null;
}
}
}
/**
* 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();
}
}
