Package org.pipecraft.pipes.async.inter

Class AsyncTimeoutPipe<T>

  • Type Parameters:
    T - The item data type
    All Implemented Interfaces:
    Closeable, AutoCloseable, BasePipe
    public class AsyncTimeoutPipe<T>
extends AsyncPipe<T>
    An async pipe enforcing a timeout on completion of its async input pipe. The timeout is reported as a TimeoutPipeException being reported in the notifyError(e) method.
    Author:
    Eyal Schneider

    • Constructor Detail

      • AsyncTimeoutPipe

        public AsyncTimeoutPipe​(AsyncPipe<T> input,
                        Duration timeout,
                        ScheduledExecutorService schedExector)
        constructor
        Parameters:
        input - The input pipe
        timeout - The time given to the input pipe to terminate, starting from the moment the input pipe is started
        schedExector - The scheduled executor used for checkout timeout

    • Method Detail

      • start

        public void start()
           throws PipeException,
                  InterruptedException
        Description copied from interface: BasePipe
        Performs pre-processing prior to item flow throw the pipe. Implementations must call the same method for all their input pipes before accessing their items. This is typically done here.
        Throws:
        PipeException - In case of pipe errors in this pipe or somewhere up-stream.
        InterruptedException - In case that the operation has been interrupted by another thread.

      • getProgress

        public float getProgress()
        Returns:
        The pipe flow progress, as a floating number between 0.0 and 1.0. Important implementation rules: 1) Calling this method before start() call is complete isn't allowed and has an undefined behavior. 2) Implementation should do best effort to provide an estimate of the progress this pipe has made (0.0 - 1.0) 3) When the pipe is fully consumed, getProgress() should return 1.0. 4) Results must be monotonous, i.e. results of consecutive calls may never be decreasing. 5) Thread safety: progress may be maintained by some thread/s but monitoring by other threads. Implementations must be thread safe.