Package org.apache.tinkerpop.gremlin.server.handler

Class AbstractSession

  • All Implemented Interfaces:
    AutoCloseable, Runnable, Session
    Direct Known Subclasses:
    MultiTaskSession, SingleTaskSession
    public abstract class AbstractSession
extends Object
implements Session, AutoCloseable
    A base implementation of Session which offers some common functionality that matches typical Gremlin Server request response expectations for script, bytecode and graph operations. The class is designed to be extended but take care in understanding the way that different methods are called as they do depend on one another a bit. It maybe best to examine the source code to determine how best to use this class or to extend from the higher order classes of SingleTaskSession or MultiTaskSession.

    • Field Detail

      • sessionThread

        protected Thread sessionThread
        The session thread is a reference to the thread that is running the session and should be set by an implementation as the first line of the Runnable.run() method.

      • maintainStateAfterException

        protected final boolean maintainStateAfterException

      • aliasesUsedBySession

        protected final Set<String> aliasesUsedBySession

      • sessionTaskStarted

        protected final AtomicBoolean sessionTaskStarted

    • Method Detail

      • cancel

        protected void cancel​(boolean mayInterruptIfRunning)

      • isTransactionManaged

        public boolean isTransactionManaged()

      • getSessionId

        public String getSessionId()
        Description copied from interface: Session
        Gets the identifier for the session.
        Specified by:
        getSessionId in interface Session

      • isBoundTo

        public boolean isBoundTo​(io.netty.channel.Channel channel)
        Description copied from interface: Session
        Determines if the supplied Channel object is the same as the one bound to the Session.
        Specified by:
        isBoundTo in interface Session

      • getActualTimeoutLengthWhenClosed

        public long getActualTimeoutLengthWhenClosed()

      • sendTimeoutResponseForUncommencedTask

        protected abstract void sendTimeoutResponseForUncommencedTask()
        Respond to the client with the specific timeout response for this Session implementation. This is for situations where the Session hasn't started running.

      • setSessionCancelFuture

        public void setSessionCancelFuture​(ScheduledFuture<?> f)
        Description copied from interface: Session
        Sets a reference to the job that will cancel this session if it exceeds its timeout period.
        Specified by:
        setSessionCancelFuture in interface Session

      • setSessionFuture

        public void setSessionFuture​(Future<?> f)
        Description copied from interface: Session
        Sets a reference to the job itself that is running this session.
        Specified by:
        setSessionFuture in interface Session

      • triggerTimeout

        public void triggerTimeout​(long timeout,
                           boolean causedBySession)
        Description copied from interface: Session
        Provides a general way to interrupt the session by way of a timeout.
        Specified by:
        triggerTimeout in interface Session
        Parameters:
        timeout - the length of time that passed for the timeout to have triggered
        causedBySession - determines if the timeout triggered due to a particular request (i.e. false or because of the session lifetime (i.e. true

      • determineIfTemporaryException

        protected Optional<Throwable> determineIfTemporaryException​(Throwable ex)
        Check if any exception in the chain is TemporaryException then we should respond with the right error code so that the client knows to retry.

      • close

        public void close()
        Removes the session from the session list and cancels the future that manages the lifetime of the session.
        Specified by:
        close in interface AutoCloseable

      • fromScript

        protected Iterator<?> fromScript​(SessionTask sessionTask,
                                 String script)
                          throws Exception
        Constructs an Iterator from the results of a script evaluation provided in the SessionTask.
        Parameters:
        sessionTask - The session task which can be used as a context in constructing the Iterator
        script - The script extracted by the calling method from the sessionTask
        Throws:
        Exception

      • fromBytecode

        protected Optional<Iterator<?>> fromBytecode​(SessionTask sessionTask,
                                             Bytecode bytecode)
                                      throws Exception
        Constructs an Iterator from Bytecode provided in the SessionTask. If the Bytecode is found to evalute to a GraphOp then it is processed and an empty Optional is returned.
        Parameters:
        sessionTask - The session task which can be used as a context in constructing the Iterator
        bytecode - The Bytecode extracted by the calling method from the sessionTask
        Throws:
        Exception

      • handleIterator

        protected void handleIterator​(SessionTask sessionTask,
                              Iterator<?> itty)
                       throws InterruptedException
        Provides a generic way of iterating a result set back to the client.
        Parameters:
        sessionTask - The Gremlin Server SessionTask object containing settings, request message, etc.
        itty - The result to iterator
        Throws:
        InterruptedException

      • iterateComplete

        protected void iterateComplete​(SessionTask sessionTask,
                               Iterator<?> itty)
        Called when iteration within handleIterator(SessionTask, Iterator) is on its final pass and the final frame is about to be sent back to the client. This method only gets called on successful iteration of the entire result.

      • startTransaction

        protected void startTransaction​(SessionTask sessionTask)
        Called right before a transaction starts within Runnable.run(). The default implementation checks for open transactions and throws an exception if it finds any and generally assumes auto-transactions are enabled on graphs (i.e. transaction automatically start on read/write).

        Providers who do not follow these sorts of transaction semantics should provide an override to this method.

      • closeTransactionSafely

        protected void closeTransactionSafely​(Transaction.Status status)
        Tries to close the transaction but will catch exceptions and log them. This method is idempotent.

      • closeTransactionSafely

        protected void closeTransactionSafely​(SessionTask sessionTask,
                                      Transaction.Status status)
        Tries to close the transaction but will catch exceptions and log them. This method is idempotent.

      • closeTransaction

        protected void closeTransaction​(SessionTask sessionTask,
                                Transaction.Status status)
        Closes a transaction with commit or rollback. Strict transaction management settings are observed when configured as such in Settings.strictTransactionManagement and when aliases are present on the request in the current SessionTask. If the supplied SessionTask is null then "strict" is bypassed so this form must be called with care. Bypassing is often useful to ensure that all transactions are cleaned up when multiple graphs are referenced. Prefer calling closeTransaction(Transaction.Status) in this case instead. This method is idempotent.