Examples with PipeRunException nl.nn.adapterframework.core.PipeRunException used on opensource projects

Example 16 with PipeRunException

use of nl.nn.adapterframework.core.PipeRunException in project iaf by ibissource.

the class XmlValidator method getSchemas.

@Override
public List<Schema> getSchemas(IPipeLineSession session) throws PipeRunException {
    List<Schema> xsds = new ArrayList<Schema>();
    String schemaLocation = getSchemasId(session);
    if (schemaSessionKey != null) {
        final URL url = ClassUtils.getResourceURL(classLoader, schemaLocation);
        if (url == null) {
            throw new PipeRunException(this, getLogPrefix(session) + "could not find schema at [" + schemaLocation + "]");
        }
        XSD xsd = new XSD();
        xsd.setClassLoader(classLoader);
        xsd.setNoNamespaceSchemaLocation(schemaLocation);
        try {
            xsd.init();
        } catch (ConfigurationException e) {
            throw new PipeRunException(this, "Could not init xsd", e);
        }
        xsds.add(xsd);
        return xsds;
    }
    return null;
}

Example 17 with PipeRunException

use of nl.nn.adapterframework.core.PipeRunException in project iaf by ibissource.

the class XsltPipe method doPipe.

/**
 * Here the actual transforming is done. Under weblogic the transformer object becomes
 * corrupt when a not-well formed xml was handled. The transformer is then re-initialized
 * via the configure() and start() methods.
 */
@Override
public PipeRunResult doPipe(Object input, IPipeLineSession session) throws PipeRunException {
    if (input == null) {
        throw new PipeRunException(this, getLogPrefix(session) + "got null input");
    }
    if (!(input instanceof String)) {
        throw new PipeRunException(this, getLogPrefix(session) + "got an invalid type as input, expected String, got " + input.getClass().getName());
    }
    String stringResult = (String) input;
    // ParameterResolutionContext prc = new ParameterResolutionContext((String)input, session, isNamespaceAware());
    try {
        ParameterResolutionContext prc = getInput(stringResult, session);
        Map parametervalues = null;
        ParameterList parameterList = getParameterList();
        if (parameterList != null) {
            parametervalues = prc.getValueMap(parameterList);
        }
        // stringResult = transformerPool.transform(prc.getInputSource(), parametervalues);
        stringResult = transform(transformerPool, prc.getInputSource(), parametervalues);
        if (isSkipEmptyTags()) {
            log.debug(getLogPrefix(session) + " skipping empty tags from result [" + stringResult + "]");
            // URL xsltSource = ClassUtils.getResourceURL( this, skipEmptyTags_xslt);
            // Transformer transformer = XmlUtils.createTransformer(xsltSource);
            // stringResult = XmlUtils.transformXml(transformer, stringResult);
            ParameterResolutionContext prc_SkipEmptyTags = new ParameterResolutionContext(stringResult, session, true, true);
            stringResult = transformerPoolSkipEmptyTags.transform(prc_SkipEmptyTags.getInputSource(), null);
        }
        if (StringUtils.isEmpty(getSessionKey())) {
            return new PipeRunResult(getForward(), stringResult);
        }
        session.put(getSessionKey(), stringResult);
        return new PipeRunResult(getForward(), input);
    } catch (Exception e) {
        throw new PipeRunException(this, getLogPrefix(session) + " Exception on transforming input", e);
    }
}

Example 18 with PipeRunException

use of nl.nn.adapterframework.core.PipeRunException in project iaf by ibissource.

the class CheckSemaphorePipeProcessor method processPipe.

public PipeRunResult processPipe(PipeLine pipeLine, IPipe pipe, String messageId, Object message, IPipeLineSession pipeLineSession) throws PipeRunException {
    PipeRunResult pipeRunResult;
    Semaphore s = getSemaphore(pipe);
    if (s != null) {
        long waitingDuration = 0;
        try {
            // keep waiting statistics for thread-limited pipes
            long startWaiting = System.currentTimeMillis();
            s.acquire();
            waitingDuration = System.currentTimeMillis() - startWaiting;
            StatisticsKeeper sk = pipeLine.getPipeWaitingStatistics(pipe);
            sk.addValue(waitingDuration);
            pipeRunResult = pipeProcessor.processPipe(pipeLine, pipe, messageId, message, pipeLineSession);
        } catch (InterruptedException e) {
            throw new PipeRunException(pipe, "Interrupted acquiring semaphore", e);
        } finally {
            s.release();
        }
    } else {
        // no restrictions on the maximum number of threads (s==null)
        pipeRunResult = pipeProcessor.processPipe(pipeLine, pipe, messageId, message, pipeLineSession);
    }
    return pipeRunResult;
}

Example 19 with PipeRunException

use of nl.nn.adapterframework.core.PipeRunException in project iaf by ibissource.

the class CorePipeLineProcessor method processPipeLine.

public PipeLineResult processPipeLine(PipeLine pipeLine, String messageId, String message, IPipeLineSession pipeLineSession, String firstPipe) throws PipeRunException {
    // Object is the object that is passed to and returned from Pipes
    Object object = (Object) message;
    PipeRunResult pipeRunResult;
    // the PipeLineResult
    PipeLineResult pipeLineResult = new PipeLineResult();
    if (object == null || (object instanceof String && StringUtils.isEmpty(object.toString()))) {
        if (StringUtils.isNotEmpty(pipeLine.getAdapterToRunBeforeOnEmptyInput())) {
            log.debug("running adapterBeforeOnEmptyInput");
            IAdapter adapter = pipeLine.getAdapter().getConfiguration().getIbisManager().getRegisteredAdapter(pipeLine.getAdapterToRunBeforeOnEmptyInput());
            if (adapter == null) {
                log.warn("adapterToRunBefore with specified name [" + pipeLine.getAdapterToRunBeforeOnEmptyInput() + "] could not be retrieved");
            } else {
                PipeLineResult plr = adapter.processMessage(messageId, message, pipeLineSession);
                if (plr == null || !plr.getState().equals("success")) {
                    throw new PipeRunException(null, "adapterToRunBefore [" + pipeLine.getAdapterToRunBeforeOnEmptyInput() + "] ended with state [" + plr.getState() + "]");
                }
                message = plr.getResult();
                log.debug("input after running adapterBeforeOnEmptyInput [" + message + "]");
                object = (Object) message;
            }
        }
    }
    // ready indicates wether the pipeline processing is complete
    boolean ready = false;
    // get the first pipe to run
    IPipe pipeToRun = pipeLine.getPipe(pipeLine.getFirstPipe());
    boolean inputValidateError = false;
    IPipe inputValidator = pipeLine.getInputValidator();
    if (inputValidator != null) {
        log.debug("validating input");
        PipeRunResult validationResult = pipeProcessor.processPipe(pipeLine, inputValidator, messageId, message, pipeLineSession);
        if (validationResult != null) {
            if (!validationResult.getPipeForward().getName().equals("success")) {
                PipeForward validationForward = validationResult.getPipeForward();
                if (validationForward.getPath() == null) {
                    throw new PipeRunException(pipeToRun, "forward [" + validationForward.getName() + "] of inputValidator has emtpy forward path");
                }
                log.warn("setting first pipe to [" + validationForward.getPath() + "] due to validation fault");
                inputValidateError = true;
                pipeToRun = pipeLine.getPipe(validationForward.getPath());
                if (pipeToRun == null) {
                    throw new PipeRunException(pipeToRun, "forward [" + validationForward.getName() + "], path [" + validationForward.getPath() + "] does not correspond to a pipe");
                }
            }
            Object validatedMessage = validationResult.getResult();
            if (validatedMessage != null) {
                object = validatedMessage;
                message = validatedMessage.toString();
            }
        }
    }
    if (!inputValidateError) {
        IPipe inputWrapper = pipeLine.getInputWrapper();
        if (inputWrapper != null) {
            log.debug("wrapping input");
            PipeRunResult wrapResult = pipeProcessor.processPipe(pipeLine, inputWrapper, messageId, message, pipeLineSession);
            if (wrapResult != null && !wrapResult.getPipeForward().getName().equals("success")) {
                PipeForward wrapForward = wrapResult.getPipeForward();
                if (wrapForward.getPath() == null) {
                    throw new PipeRunException(pipeToRun, "forward [" + wrapForward.getName() + "] of inputWrapper has emtpy forward path");
                }
                log.warn("setting first pipe to [" + wrapForward.getPath() + "] due to wrap fault");
                pipeToRun = pipeLine.getPipe(wrapForward.getPath());
                if (pipeToRun == null) {
                    throw new PipeRunException(pipeToRun, "forward [" + wrapForward.getName() + "], path [" + wrapForward.getPath() + "] does not correspond to a pipe");
                }
            } else {
                message = wrapResult.getResult().toString();
            }
            log.debug("input after wrapping [" + message + "]");
            object = (Object) message;
        }
    }
    pipeLine.getRequestSizeStats().addValue(message.length());
    if (pipeLine.isStoreOriginalMessageWithoutNamespaces()) {
        if (XmlUtils.isWellFormed(message)) {
            String removeNamespaces_xslt = XmlUtils.makeRemoveNamespacesXslt(true, true);
            try {
                String xsltResult = null;
                Transformer transformer = XmlUtils.createTransformer(removeNamespaces_xslt);
                xsltResult = XmlUtils.transformXml(transformer, message);
                pipeLineSession.put("originalMessageWithoutNamespaces", xsltResult);
            } catch (IOException e) {
                throw new PipeRunException(pipeToRun, "cannot retrieve removeNamespaces", e);
            } catch (TransformerConfigurationException te) {
                throw new PipeRunException(pipeToRun, "got error creating transformer from removeNamespaces", te);
            } catch (TransformerException te) {
                throw new PipeRunException(pipeToRun, "got error transforming removeNamespaces", te);
            } catch (DomBuilderException te) {
                throw new PipeRunException(pipeToRun, "caught DomBuilderException", te);
            }
        } else {
            log.warn("original message is not well-formed");
            pipeLineSession.put("originalMessageWithoutNamespaces", message);
        }
    }
    boolean outputValidated = false;
    try {
        while (!ready) {
            pipeRunResult = pipeProcessor.processPipe(pipeLine, pipeToRun, messageId, object, pipeLineSession);
            object = pipeRunResult.getResult();
            if (!(pipeToRun instanceof AbstractPipe)) {
                if (object != null && object instanceof String) {
                    StatisticsKeeper sizeStat = pipeLine.getPipeSizeStatistics(pipeToRun);
                    if (sizeStat != null) {
                        sizeStat.addValue(((String) object).length());
                    }
                }
            }
            PipeForward pipeForward = pipeRunResult.getPipeForward();
            if (pipeForward == null) {
                throw new PipeRunException(pipeToRun, "Pipeline of [" + pipeLine.getOwner().getName() + "] received result from pipe [" + pipeToRun.getName() + "] without a pipeForward");
            }
            // get the next pipe to run
            String nextPath = pipeForward.getPath();
            if ((null == nextPath) || (nextPath.length() == 0)) {
                throw new PipeRunException(pipeToRun, "Pipeline of [" + pipeLine.getOwner().getName() + "] got an path that equals null or has a zero-length value from pipe [" + pipeToRun.getName() + "]. Check the configuration, probably forwards are not defined for this pipe.");
            }
            PipeLineExit plExit = pipeLine.getPipeLineExits().get(nextPath);
            if (null != plExit) {
                boolean outputWrapError = false;
                IPipe outputWrapper = pipeLine.getOutputWrapper();
                if (outputWrapper != null) {
                    log.debug("wrapping PipeLineResult");
                    PipeRunResult wrapResult = pipeProcessor.processPipe(pipeLine, outputWrapper, messageId, object, pipeLineSession);
                    if (wrapResult != null && !wrapResult.getPipeForward().getName().equals("success")) {
                        PipeForward wrapForward = wrapResult.getPipeForward();
                        if (wrapForward.getPath() == null) {
                            throw new PipeRunException(pipeToRun, "forward [" + wrapForward.getName() + "] of outputWrapper has emtpy forward path");
                        }
                        log.warn("setting next pipe to [" + wrapForward.getPath() + "] due to wrap fault");
                        outputWrapError = true;
                        pipeToRun = pipeLine.getPipe(wrapForward.getPath());
                        if (pipeToRun == null) {
                            throw new PipeRunException(pipeToRun, "forward [" + wrapForward.getName() + "], path [" + wrapForward.getPath() + "] does not correspond to a pipe");
                        }
                    } else {
                        log.debug("wrap succeeded");
                        object = wrapResult.getResult();
                    }
                    log.debug("PipeLineResult after wrapping [" + object.toString() + "]");
                }
                if (!outputWrapError) {
                    IPipe outputValidator = pipeLine.getOutputValidator();
                    if ((outputValidator != null) && !outputValidated) {
                        outputValidated = true;
                        log.debug("validating PipeLineResult");
                        PipeRunResult validationResult;
                        validationResult = pipeProcessor.processPipe(pipeLine, outputValidator, messageId, object, pipeLineSession);
                        if (validationResult != null && !validationResult.getPipeForward().getName().equals("success")) {
                            PipeForward validationForward = validationResult.getPipeForward();
                            if (validationForward.getPath() == null) {
                                throw new PipeRunException(pipeToRun, "forward [" + validationForward.getName() + "] of outputValidator has emtpy forward path");
                            }
                            log.warn("setting next pipe to [" + validationForward.getPath() + "] due to validation fault");
                            pipeToRun = pipeLine.getPipe(validationForward.getPath());
                            if (pipeToRun == null) {
                                throw new PipeRunException(pipeToRun, "forward [" + validationForward.getName() + "], path [" + validationForward.getPath() + "] does not correspond to a pipe");
                            }
                        } else {
                            log.debug("validation succeeded");
                            object = validationResult.getResult();
                            ready = true;
                        }
                    } else {
                        ready = true;
                    }
                } else {
                    ready = true;
                }
                if (ready) {
                    String state = plExit.getState();
                    pipeLineResult.setState(state);
                    pipeLineResult.setExitCode(plExit.getExitCode());
                    if (object != null && !plExit.getEmptyResult()) {
                        pipeLineResult.setResult(object.toString());
                    } else {
                        pipeLineResult.setResult(null);
                    }
                    ready = true;
                    if (log.isDebugEnabled()) {
                        // for performance reasons
                        String skString = "";
                        for (Iterator it = pipeLineSession.keySet().iterator(); it.hasNext(); ) {
                            String key = (String) it.next();
                            Object value = pipeLineSession.get(key);
                            skString = skString + "\n " + key + "=[" + value + "]";
                        }
                        log.debug("Available session keys at finishing pipeline of adapter [" + pipeLine.getOwner().getName() + "]:" + skString);
                        log.debug("Pipeline of adapter [" + pipeLine.getOwner().getName() + "] finished processing messageId [" + messageId + "] result: [" + object + "] with exit-state [" + state + "]");
                    }
                }
            } else {
                pipeToRun = pipeLine.getPipe(pipeForward.getPath());
                if (pipeToRun == null) {
                    throw new PipeRunException(null, "Pipeline of adapter [" + pipeLine.getOwner().getName() + "] got an erroneous definition. Pipe to execute [" + pipeForward.getPath() + "] is not defined.");
                }
            }
        }
    } finally {
        for (int i = 0; i < pipeLine.getExitHandlers().size(); i++) {
            IPipeLineExitHandler exitHandler = pipeLine.getExitHandlers().get(i);
            try {
                if (log.isDebugEnabled())
                    log.debug("processing ExitHandler [" + exitHandler.getName() + "]");
                exitHandler.atEndOfPipeLine(messageId, pipeLineResult, pipeLineSession);
            } catch (Throwable t) {
                log.warn("Caught Exception processing ExitHandler [" + exitHandler.getName() + "]", t);
            }
        }
    }
    return pipeLineResult;
}

Example 20 with PipeRunException

use of nl.nn.adapterframework.core.PipeRunException in project iaf by ibissource.

the class MessageSendingPipe method doPipe.

public PipeRunResult doPipe(Object input, IPipeLineSession session) throws PipeRunException {
    String originalMessage = input.toString();
    String result = null;
    String correlationID = session.getMessageId();
    if (getInputWrapper() != null) {
        log.debug(getLogPrefix(session) + "wrapping input");
        PipeRunResult wrapResult = pipeProcessor.processPipe(getPipeLine(), inputWrapper, correlationID, input, session);
        if (wrapResult != null && !wrapResult.getPipeForward().getName().equals(SUCCESS_FORWARD)) {
            return wrapResult;
        } else {
            input = wrapResult.getResult();
        }
        log.debug(getLogPrefix(session) + "input after wrapping [" + input.toString() + "]");
    }
    if (getInputValidator() != null) {
        log.debug(getLogPrefix(session) + "validating input");
        PipeRunResult validationResult = pipeProcessor.processPipe(getPipeLine(), inputValidator, correlationID, input, session);
        if (validationResult != null && !validationResult.getPipeForward().getName().equals(SUCCESS_FORWARD)) {
            return validationResult;
        }
    }
    if (StringUtils.isNotEmpty(getStubFileName())) {
        ParameterList pl = getParameterList();
        result = returnString;
        if (pl != null) {
            ParameterResolutionContext prc = new ParameterResolutionContext((String) input, session);
            Map params;
            try {
                params = prc.getValueMap(pl);
            } catch (ParameterException e1) {
                throw new PipeRunException(this, getLogPrefix(session) + "got exception evaluating parameters", e1);
            }
            String sfn = null;
            if (params != null && params.size() > 0) {
                sfn = (String) params.get(STUBFILENAME);
            }
            if (sfn != null) {
                try {
                    result = Misc.resourceToString(ClassUtils.getResourceURL(classLoader, sfn), SystemUtils.LINE_SEPARATOR);
                    log.info(getLogPrefix(session) + "returning result from dynamic stub [" + sfn + "]");
                } catch (Throwable e) {
                    throw new PipeRunException(this, getLogPrefix(session) + "got exception loading result from stub [" + sfn + "]", e);
                }
            } else {
                log.info(getLogPrefix(session) + "returning result from static stub [" + getStubFileName() + "]");
            }
        } else {
            log.info(getLogPrefix(session) + "returning result from static stub [" + getStubFileName() + "]");
        }
    } else {
        Map threadContext = new HashMap();
        try {
            String messageID = null;
            // sendResult has a messageID for async senders, the result for sync senders
            int retryInterval = getRetryMinInterval();
            String sendResult = null;
            boolean replyIsValid = false;
            int retriesLeft = 0;
            if (getMaxRetries() > 0) {
                retriesLeft = getMaxRetries() + 1;
            } else {
                retriesLeft = 1;
            }
            while (retriesLeft-- >= 1 && !replyIsValid) {
                try {
                    sendResult = sendMessage(input, session, correlationID, getSender(), threadContext);
                    if (retryTp != null) {
                        String retry = retryTp.transform(sendResult, null);
                        if (retry.equalsIgnoreCase("true")) {
                            if (retriesLeft >= 1) {
                                retryInterval = increaseRetryIntervalAndWait(session, retryInterval, "xpathRetry result [" + retry + "], retries left [" + retriesLeft + "]");
                            }
                        } else {
                            replyIsValid = true;
                        }
                    } else {
                        replyIsValid = true;
                    }
                } catch (TimeOutException toe) {
                    if (retriesLeft >= 1) {
                        retryInterval = increaseRetryIntervalAndWait(session, retryInterval, "timeout occured, retries left [" + retriesLeft + "]");
                    } else {
                        throw toe;
                    }
                } catch (SenderException se) {
                    if (retriesLeft >= 1) {
                        retryInterval = increaseRetryIntervalAndWait(session, retryInterval, "exception [" + (se != null ? se.getMessage() : "") + "] occured, retries left [" + retriesLeft + "]");
                    } else {
                        throw se;
                    }
                }
            }
            if (!replyIsValid) {
                throw new PipeRunException(this, getLogPrefix(session) + "invalid reply message is received");
            }
            if (getSender().isSynchronous()) {
                if (log.isInfoEnabled()) {
                    log.info(getLogPrefix(session) + "sent message to [" + getSender().getName() + "] synchronously");
                }
                result = sendResult;
            } else {
                messageID = sendResult;
                if (log.isInfoEnabled()) {
                    log.info(getLogPrefix(session) + "sent message to [" + getSender().getName() + "] messageID [" + messageID + "] correlationID [" + correlationID + "] linkMethod [" + getLinkMethod() + "]");
                }
                // as this will be used with the listener
                if (getLinkMethod().equalsIgnoreCase("MESSAGEID")) {
                    correlationID = sendResult;
                    if (log.isDebugEnabled())
                        log.debug(getLogPrefix(session) + "setting correlationId to listen for to messageId [" + correlationID + "]");
                }
            }
            ITransactionalStorage messageLog = getMessageLog();
            if (messageLog != null) {
                long messageLogStartTime = System.currentTimeMillis();
                String messageTrail = "no audit trail";
                if (auditTrailTp != null) {
                    if (isUseInputForExtract()) {
                        messageTrail = auditTrailTp.transform(originalMessage, null);
                    } else {
                        messageTrail = auditTrailTp.transform((String) input, null);
                    }
                } else {
                    if (StringUtils.isNotEmpty(getAuditTrailSessionKey())) {
                        messageTrail = (String) (session.get(getAuditTrailSessionKey()));
                    }
                }
                String storedMessageID = messageID;
                if (storedMessageID == null) {
                    storedMessageID = "-";
                }
                if (correlationIDTp != null) {
                    if (StringUtils.isNotEmpty(getCorrelationIDSessionKey())) {
                        String sourceString = (String) (session.get(getCorrelationIDSessionKey()));
                        correlationID = correlationIDTp.transform(sourceString, null);
                    } else {
                        if (isUseInputForExtract()) {
                            correlationID = correlationIDTp.transform(originalMessage, null);
                        } else {
                            correlationID = correlationIDTp.transform((String) input, null);
                        }
                    }
                    if (StringUtils.isEmpty(correlationID)) {
                        correlationID = "-";
                    }
                }
                String label = null;
                if (labelTp != null) {
                    if (isUseInputForExtract()) {
                        label = labelTp.transform(originalMessage, null);
                    } else {
                        label = labelTp.transform((String) input, null);
                    }
                }
                if (sender instanceof MailSender) {
                    String messageInMailSafeForm = (String) session.get("messageInMailSafeForm");
                    if (hideRegex != null) {
                        if (getHideMethod().equalsIgnoreCase("FIRSTHALF")) {
                            messageInMailSafeForm = Misc.hideFirstHalf(messageInMailSafeForm, hideRegex);
                        } else {
                            messageInMailSafeForm = Misc.hideAll(messageInMailSafeForm, hideRegex);
                        }
                    }
                    messageLog.storeMessage(storedMessageID, correlationID, new Date(), messageTrail, label, messageInMailSafeForm);
                } else {
                    String message = (String) input;
                    if (hideRegex != null) {
                        if (getHideMethod().equalsIgnoreCase("FIRSTHALF")) {
                            message = Misc.hideFirstHalf(message, hideRegex);
                        } else {
                            message = Misc.hideAll(message, hideRegex);
                        }
                    }
                    messageLog.storeMessage(storedMessageID, correlationID, new Date(), messageTrail, label, message);
                }
                long messageLogEndTime = System.currentTimeMillis();
                long messageLogDuration = messageLogEndTime - messageLogStartTime;
                StatisticsKeeper sk = getPipeLine().getPipeStatistics(messageLog);
                sk.addValue(messageLogDuration);
            }
            if (sender instanceof MailSender) {
                session.remove("messageInMailSafeForm");
            }
            if (getListener() != null) {
                result = listenerProcessor.getMessage(getListener(), correlationID, session);
            } else {
                result = sendResult;
            }
            if (result == null) {
                result = "";
            }
            if (timeoutPending) {
                timeoutPending = false;
                throwEvent(PIPE_CLEAR_TIMEOUT_MONITOR_EVENT);
            }
        } catch (TimeOutException toe) {
            throwEvent(PIPE_TIMEOUT_MONITOR_EVENT);
            if (!timeoutPending) {
                timeoutPending = true;
            }
            PipeForward timeoutForward = findForward(TIMEOUT_FORWARD);
            log.warn(getLogPrefix(session) + "timeout occured");
            if (timeoutForward == null) {
                if (StringUtils.isEmpty(getResultOnTimeOut())) {
                    timeoutForward = findForward(EXCEPTION_FORWARD);
                } else {
                    timeoutForward = getForward();
                }
            }
            if (timeoutForward != null) {
                String resultmsg;
                if (StringUtils.isNotEmpty(getResultOnTimeOut())) {
                    resultmsg = getResultOnTimeOut();
                } else {
                    if (input instanceof String) {
                        resultmsg = new ErrorMessageFormatter().format(getLogPrefix(session), toe, this, (String) input, session.getMessageId(), 0);
                    } else {
                        if (input == null) {
                            input = "null";
                        }
                        resultmsg = new ErrorMessageFormatter().format(getLogPrefix(session), toe, this, input.toString(), session.getMessageId(), 0);
                    }
                }
                return new PipeRunResult(timeoutForward, resultmsg);
            }
            throw new PipeRunException(this, getLogPrefix(session) + "caught timeout-exception", toe);
        } catch (Throwable t) {
            throwEvent(PIPE_EXCEPTION_MONITOR_EVENT);
            PipeForward exceptionForward = findForward(EXCEPTION_FORWARD);
            if (exceptionForward != null) {
                log.warn(getLogPrefix(session) + "exception occured, forwarding to exception-forward [" + exceptionForward.getPath() + "], exception:\n", t);
                String resultmsg;
                if (input instanceof String) {
                    resultmsg = new ErrorMessageFormatter().format(getLogPrefix(session), t, this, (String) input, session.getMessageId(), 0);
                } else {
                    if (input == null) {
                        input = "null";
                    }
                    resultmsg = new ErrorMessageFormatter().format(getLogPrefix(session), t, this, input.toString(), session.getMessageId(), 0);
                }
                return new PipeRunResult(exceptionForward, resultmsg);
            }
            throw new PipeRunException(this, getLogPrefix(session) + "caught exception", t);
        }
    }
    if (!validResult(result)) {
        PipeForward illegalResultForward = findForward(ILLEGAL_RESULT_FORWARD);
        return new PipeRunResult(illegalResultForward, result);
    }
    IPipe outputValidator = getOutputValidator();
    if (outputValidator != null) {
        log.debug(getLogPrefix(session) + "validating response");
        PipeRunResult validationResult;
        validationResult = pipeProcessor.processPipe(getPipeLine(), outputValidator, correlationID, result, session);
        if (validationResult != null && !validationResult.getPipeForward().getName().equals(SUCCESS_FORWARD)) {
            return validationResult;
        }
    }
    if (getOutputWrapper() != null) {
        log.debug(getLogPrefix(session) + "wrapping response");
        PipeRunResult wrapResult = pipeProcessor.processPipe(getPipeLine(), outputWrapper, correlationID, result, session);
        if (wrapResult != null && !wrapResult.getPipeForward().getName().equals(SUCCESS_FORWARD)) {
            return wrapResult;
        }
        result = wrapResult.getResult().toString();
        log.debug(getLogPrefix(session) + "response after wrapping [" + result + "]");
    }
    if (isStreamResultToServlet()) {
        byte[] bytes = Base64.decodeBase64(new String(result));
        try {
            String contentType = (String) session.get("contentType");
            if (StringUtils.isNotEmpty(contentType)) {
                RestListenerUtils.setResponseContentType(session, contentType);
            }
            RestListenerUtils.writeToResponseOutputStream(session, bytes);
        } catch (IOException e) {
            throw new PipeRunException(this, getLogPrefix(session) + "caught exception", e);
        }
        return new PipeRunResult(getForward(), "");
    } else {
        return new PipeRunResult(getForward(), result);
    }
}