Package org.frankframework.core

Class PipeLine

java.lang.Object
org.frankframework.core.TransactionAttributes
org.frankframework.core.PipeLine
All Implemented Interfaces:
ICacheEnabled<String,String>, ConfigurationAware, FrankElement, HasApplicationContext, HasName, HasTransactionAttribute, IConfigurable, IScopeProvider, ConfigurableLifecycle, org.springframework.beans.factory.Aware, org.springframework.context.ApplicationContextAware, org.springframework.context.Lifecycle, org.springframework.context.Phased, org.springframework.context.SmartLifecycle
@Category(BASIC) @FrankDocGroup(OTHER) public class PipeLine extends TransactionAttributes implements ICacheEnabled<String,String>, FrankElement, ConfigurationAware, ConfigurableLifecycle
Required in each Adapter to transform incoming messages. A pipeline is a sequence of pipes. A pipeline also defines its allowed end states using the <Exits> tag.

The pipes in a PipeLine may not be executed in sequential order, see PipeForward.

A pipeline gathers statistics about the messages it processes.

In the AppConstants there may be a property named log.logIntermediaryResults (true/false) which indicates whether the intermediary results (between calling pipes) have to be logged.

Transaction control

THE FOLLOWING TO BE UPDATED, attribute 'transacted' replaced by 'transactionAttribute' If transacted is set to true, messages will be processed under transaction control. Processing by XA-compliant pipes (i.e. Pipes that implement the IXAEnabled-interface, set their transacted-attribute to true and use XA-compliant resources) will then either be committed or rolled back in one transaction. If transacted is set to true, either an existing transaction (started by a transactional receiver) is joined, or new one is created (if the message processing request is not initiated by a receiver under transaction control. Messages are only committed or rolled back by the Pipeline if it started the transaction itself. If the pipeline joined an existing transaction, the commit or rollback is left to the object that started the transaction, i.e. the receiver. In the latter case the pipeline can indicate to the receiver that the transaction should be rolled back (by calling UserTransaction.setRollBackOnly()). The choice whether to either commit (by Pipeline or Receiver) or rollback (by Pipeline or Receiver) is made as follows: If the processing of the message concluded without exceptions and the status of the transaction is STATUS_ACTIVE (i.e. normal) the transaction will be committed. Otherwise it will be rolled back, or marked for roll back by the calling party.
Author:
Johan Verrips

  • Field Details

  • Constructor Details

    • PipeLine

      public PipeLine()

  • Method Details

    • setApplicationContext

      public final void setApplicationContext(@Nonnull org.springframework.context.ApplicationContext context)
      Specified by:
      setApplicationContext in interface org.springframework.context.ApplicationContextAware

    • getName

      public String getName()
      Used by MetricsInitializer and ConfigurationWarnings. When null either the ClassName or nothing is used. See PipeLineTest#testDuplicateExits, which right now does not add a name to the ConfigurationWarnings. Ideally it copies over the adapter name.
      Specified by:
      getName in interface HasName

    • getPipe

      public IPipe getPipe(String pipeName)

    • getPipe

      public IPipe getPipe(int index)

    • configure

      public void configure() throws ConfigurationException
      Configures the pipes of this Pipeline and does some basic checks. It also registers the PipeLineSession object at the pipes.
      Specified by:
      configure in interface IConfigurable
      Overrides:
      configure in class TransactionAttributes
      Throws:
      ConfigurationException - in case it was not able to configure the component.
      See Also:

    • configure

      public void configure(IPipe pipe) throws ConfigurationException
      Throws:
      ConfigurationException

    • findExitByState

      public Optional<PipeLineExit> findExitByState(PipeLine.ExitState state)

    • getPipeLineSize

      public int getPipeLineSize()
      Returns:
      the number of pipes in the pipeline

    • getPipeStatistics

      @Nonnull public io.micrometer.core.instrument.DistributionSummary getPipeStatistics(IPipe pipe)

    • getPipeWaitStatistics

      @Nonnull public io.micrometer.core.instrument.DistributionSummary getPipeWaitStatistics(IPipe pipe)

    • getPipeSizeInStatistics

      @Nonnull public io.micrometer.core.instrument.DistributionSummary getPipeSizeInStatistics(IPipe pipe)

    • getPipeSizeOutStatistics

      @Nonnull public io.micrometer.core.instrument.DistributionSummary getPipeSizeOutStatistics(IPipe pipe)

    • process

      public PipeLineResult process(@Nonnull String messageId, @Nonnull Message message, @Nonnull PipeLineSession pipeLineSession) throws PipeRunException
      The process method does the processing of a message.
      It retrieves the first pipe to execute from the firstPipe field, the call results in a PipRunResult, containing the next pipe to activate. While processing the process method keeps statistics.
      Parameters:
      messageId - A unique id for this message, used for logging purposes.
      message - The message as received from the Listener
      Returns:
      the result of the processing.
      Throws:
      PipeRunException - when something went wrong in the pipes.

    • resolveForward

      public IForwardTarget resolveForward(IPipe pipe, PipeForward forward) throws PipeRunException
      Find the destination of the forward, i.e. the object (Pipe or PipeLineExit) where the forward points to.
      Throws:
      PipeRunException

    • start

      public void start()
      Specified by:
      start in interface ConfigurableLifecycle
      Specified by:
      start in interface org.springframework.context.Lifecycle

    • isRunning

      public boolean isRunning()
      Specified by:
      isRunning in interface org.springframework.context.Lifecycle

    • getPhase

      public int getPhase()
      Specified by:
      getPhase in interface ConfigurableLifecycle
      Specified by:
      getPhase in interface org.springframework.context.Phased
      Specified by:
      getPhase in interface org.springframework.context.SmartLifecycle

    • startPipe

      protected void startPipe(String type, IPipe pipe)

    • stop

      public void stop()
      Close the pipeline. This will call the stop() method of all registered Pipes
      Specified by:
      stop in interface org.springframework.context.Lifecycle
      See Also:

    • findGlobalForward

      @Nullable public PipeForward findGlobalForward(String forward)

    • getAllPipeLineExits

      public Map<String,PipeLineExit> getAllPipeLineExits()

    • stopPipe

      protected void stopPipe(String type, IPipe pipe)

    • toString

      public String toString()
      Overrides:
      toString in class Object
      Returns:
      an enumeration of all pipenames in the pipeline and the startpipe and endpath
      See Also:

    • setInputValidator

      public void setInputValidator(IValidator inputValidator)
      Request validator, or combined validator for request and response

    • setOutputValidator

      public void setOutputValidator(IValidator outputValidator)
      Optional pipe to validate the response. Can be specified if the response cannot be validated by the request validator

    • setInputWrapper

      public void setInputWrapper(IWrapperPipe inputWrapper)
      Optional pipe to extract the request message from its envelope

    • setOutputWrapper

      public void setOutputWrapper(IWrapperPipe outputWrapper)
      Optional pipe to wrap the response message in an envelope

    • setPipeLineExits

      public void setPipeLineExits(PipeLineExits exits)
      PipeLine exits. If no exits are specified, a default one is created with name="READY" and state="SUCCESS"

    • addPipeLineExit

      @Deprecated public void addPipeLineExit(PipeLineExit exit)
      Deprecated.
      PipeLine exits.

    • setGlobalForwards

      public void setGlobalForwards(PipeForwards forwards)
      Optional global forwards that will be added to every pipe, when the forward name has not been explicitly set. For example the <forward name="exception" path="error_exception" />, which will add the exception forward to every pipe in the pipeline.

    • addForward

      @Deprecated public void addForward(PipeForward forward)
      Deprecated.

    • setLocker

      public void setLocker(Locker locker)
      Optional Locker, to avoid parallel execution of the PipeLine by multiple threads on multiple servers. The Pipeline is NOT executed (and is considered to have ended successfully) when the lock cannot be obtained, e.g. in case another thread, may be in another server, holds the lock and does not release it in a timely manner. If only the number of threads executing this PipeLine needs to be limited, the attribute maxThreads can be set instead, avoiding the database overhead.

    • setCache

      public void setCache(ICache<String,String> cache)
      Cache of results
      Specified by:
      setCache in interface ICacheEnabled<String,String>

    • addPipe

      @Mandatory public void addPipe(IPipe pipe) throws ConfigurationException
      Register a Pipe at this pipeline. The name is also put in the globalForwards table (with forward-name=pipename and forward-path=pipename, so that pipe can look for a specific pipe-name. If already a globalForward exists under that name, the pipe is NOT added, allowing globalForwards to prevail.
      Throws:
      ConfigurationException
      See Also:

    • setFirstPipe

      public void setFirstPipe(String pipeName)
      Name of the first pipe to execute when a message is to be processed.
      Default value
      first pipe of the pipeline

    • setMaxThreads

      public void setMaxThreads(int newMaxThreads)
      Maximum number of threads that may execute this Pipeline simultaneously, use 0 to disable limit
      Default value
      0

    • setStoreOriginalMessageWithoutNamespaces

      public void setStoreOriginalMessageWithoutNamespaces(boolean b)
      If set true the original message without namespaces (and prefixes) is stored under the session key originalMessageWithoutNamespaces
      Default value
      false

    • setMessageSizeWarn

      public void setMessageSizeWarn(String s)
      If messageSizeWarn>=0 and the size of the input or result pipe message exceeds the value specified a warning message is logged. You can specify the value with the suffixes KB, MB or GB
      Default value
      application default (30MB)

    • getMessageSizeWarnNum

      public long getMessageSizeWarnNum()

    • setTransformNullMessage

      public void setTransformNullMessage(String s)
      when specified and null is received as a message the message is changed to the specified value

    • setAdapterToRunBeforeOnEmptyInput

      @Deprecated @ConfigurationWarning("Please use an XmlIf-pipe and call a sub-adapter to retrieve a new/different response") public void setAdapterToRunBeforeOnEmptyInput(String s)
      Deprecated.
      when specified and an empty message is received the specified adapter is run before passing the message (response from specified adapter) to the pipeline

    • setExpectsSessionKeys

      public void setExpectsSessionKeys(String expectsSessionKeys)
      The pipeline of this adapter expects to use the following session keys to be set on call. This is for adapters that are called as sub-adapters from other adapters. This serves both for documentation, so callers can see what session keys to set on call, and for verification that those session keys are present.
      Parameters:
      expectsSessionKeys - Session keys to set on call of the pipeline, comma-separated.