Exception handling
==================

Client exceptions
-----------------

The exceptions which can be received by a client due to a remote call on
the OMERO server are all defined in
:blitz_source:`src/main/slice/omero/ServerErrors.ice`
(included below). This file contains two separate hierarchies rooted at
``Ice::Exception`` and ``omero::ServerError``. 

For a better understanding of how to handle exceptions, please read both
of the ``*.ice`` files carefully, and see |OmeroClients| for examples of exception
handling.

::

    /*
     *   $Id$
     *
     *   Copyright 2007 Glencoe Software, Inc. All rights reserved.
     *   Use is subject to license terms supplied in LICENSE.txt
     *
     */
    #ifndef OMERO_SERVERERRORS_ICE
    #define OMERO_SERVERERRORS_ICE
    #include <Glacier2/Session.ice>
    /**
     * Exceptions thrown by OMERO server components. Exceptions thrown client side
     * are available defined in each language binding separately, but will usually
     * subclass from "ClientError"
     *
     * including examples of what a appropriate try/catch block would look like.
     *
     * <p>
     * All exceptions that are thrown by a remote call (any call on a *Prx instance)
     * will be either a subclass of [Ice::UserException] or [Ice::LocalException].
     * <a href="https://doc.zeroc.com/display/Ice/Run-Time+Exceptions#Run-TimeExceptions-InheritanceHierarchyforExceptions">Inheritance Hierarchy for Exceptions</a>
     * from the Ice manual shows the entire exception hierarchy. The exceptions described in
     * this file will subclass from [Ice::UserException]. Other Ice-runtime exceptions subclass
     * from [Ice::LocalException].
     * </p>
     *
     * <pre>
     *
     * OMERO Specific:
     * ===============
     *  ServerError (root server exception)
     *   |
     *   |_ InternalException (server bug)
     *   |
     *   |_ ResourceError (non-recoverable)
     *   |  \_ NoProcessorAvailable
     *   |
     *   |_ ConcurrencyException (recoverable)
     *   |  |_ ConcurrentModification (data was changed)
     *   |  |_ OptimisticLockException (changed data conflicts)
     *   |  |_ LockTimeout (took too long to acquire lock)
     *   |  |_ TryAgain (some processing required before server is ready)
     *   |  \_ TooManyUsersException
     *   |     \_ DatabaseBusyException
     *   |
     *   |_ ApiUsageException (misuse of services)
     *   |   |_ OverUsageException (too much)
     *   |   |_ QueryException (bad query string)
     *   |   \_ ValidationException (bad data)
     *   |
     *   |_ SecurityViolation (some no-no)
     *   |   \_ GroupSecurityViolation
     *   |      |_ PermissionMismatchGroupSecurityViolation
     *   |      \_ ReadOnlyGroupSecurityViolation
     *   |
     *   \_SessionException
     *      |_ RemovedSessionException (accessing a non-extant session)
     *      |_ SessionTimeoutException (session timed out; not yet removed)
     *      \_ ShutdownInProgress      (session on this server will most likely be destroyed)
     * </pre>
     *
     *
     * <p>
     * However, in addition to [Ice::LocalException] subclasses, the Ice runtime also
     * defines subclasses of [Ice::UserException]. In some cases, OMERO subclasses
     * from these exceptions. The subclasses shown below are not exhaustive, but show those
     * which an application's exception handler may want to deal with.
     * </p>
     *
     *
     * <pre>
     *  Ice::Exception (root of all Ice exceptions)
     *   |
     *   |_ Ice::UserException (super class of all application exceptions)
     *   |  |
     *   |  |_ Glacier2::CannotCreateSessionException (1 of 2 exceptions throwable by createSession)
     *   |  |   |_ omero::AuthenticationException (bad login)
     *   |  |   |_ omero::ExpiredCredentialException (old password)
     *   |  |   |_ omero::WrappedCreateSessionException (any other server error during createSession)
     *   |  |   \_ omero::licenses::NoAvailableLicensesException (see tools/licenses/resources/omero/LicensesAPI.ice)
     *   |  |
     *   |  \_ Glacier2::PermissionDeniedException (other of 2 exceptions throwable by createSession)
     *   |
     *   \_ Ice::LocalException (should generally be considered fatal. See exceptions below)
     *       |
     *       |_ Ice::ProtocolException (something went wrong on the wire. Wrong version?)
     *       |
     *       |_ Ice::RequestFailedException
     *       |   |_ ObjectNotExistException (Service timeout or similar?)
     *       |   \_ OperationNotExistException (Improper use of uncheckedCast?)
     *       |
     *       |_ Ice::UknownException (server threw an unexpected exception. Bug!)
     *       |
     *       \_ Ice::TimeoutException
     *           \_ Ice::ConnectTimeoutException (Couldn't establish a connection. Retry?)
     *
     * </pre>
     *
     **/
    module omero
    {
      /*
       * Base exception. Equivalent to the ome.conditions.RootException.
       * RootException must be split into a ServerError and a ClientError
       * base-class since the two systems are more strictly split by the
       * Ice-runtime than is done in RMI/Java.
       */
      exception ServerError
        {
          string serverStackTrace;
          string serverExceptionClass;
          string message;
        };
      // SESSION EXCEPTIONS --------------------------------
      /**
       * Base session exception, though in the OMERO.blitz
       * implementation, all exceptions thrown by the Glacier2
       * must subclass CannotCreateSessionException. See below.
       */
      exception SessionException extends ServerError
        {
        };
      /**
       * Session has been removed. Either it was closed, or it
       * timed out and one "SessionTimeoutException" has already
       * been thrown.
       */
      exception RemovedSessionException extends SessionException
        {
        };
      /**
       * Session has timed out and will be removed.
       */
      exception SessionTimeoutException extends SessionException
        {
        };
      /**
       * Server is in the progress of shutting down which will
       * typically lead to the current session being closed.
       */
      exception ShutdownInProgress extends SessionException
        {
        };
      // SESSION EXCEPTIONS (Glacier2) ---------------------
      /**
       * createSession() is a two-phase process. First, a PermissionsVerifier is
       * called which must return true; then a SessionManager is called to create
       * the session (ServiceFactory). If the PermissionsVerifier returns false,
       * then PermissionDeniedException will be thrown. This, however, cannot be
       * subclassed and so string parsing must be used.
       */
      /**
       * Thrown when the information provided omero.createSession() or more
       * specifically Glacier2.RouterPrx.createSession() is incorrect. This
       * does -not- subclass from the omero.ServerError class because the
       * Ice Glacier2::SessionManager interface can only throw CCSEs.
       */
      exception AuthenticationException extends Glacier2::CannotCreateSessionException
        {
        };
      /**
       * Thrown when the password for a user has expried. Use: ISession.changeExpiredCredentials()
       * and login as guest. This does -not- subclass from the omero.ServerError class because the
       * Ice Glacier2::SessionManager interface can only throw CCSEs.
       */
      exception ExpiredCredentialException extends Glacier2::CannotCreateSessionException
        {
        };
      /**
       * Thrown when any other server exception causes the session creation to fail.
       * Since working with the static information of Ice exceptions is not as easy
       * as with classes, here we use booleans to represent what has gone wrong.
       */
      exception WrappedCreateSessionException extends Glacier2::CannotCreateSessionException
        {
          bool    concurrency;
          long    backOff;    /* Only used if ConcurrencyException */
          string  type;       /* Ice static type information */
        };
      // OTHER SERVER EXCEPTIONS ------------------------------
      /**
       * Programmer error. Ideally should not be thrown.
       */
      exception InternalException extends ServerError
        {
        };
      // RESOURCE
      /**
       * Unrecoverable error. The resource being accessed is not available.
       */
      exception ResourceError extends ServerError
        {
        };
      /**
       * A script cannot be executed because no matching processor
       * was found.
       */
      exception NoProcessorAvailable extends ResourceError
        {
            /**
             * Number of processors that responded to the inquiry.
             * If 1 or more, then the given script was not acceptable
             * (e.g. non-official) and a specialized processor may need
             * to be started.
             **/
            int processorCount;
        };
      // CONCURRENCY
      /**
       * Recoverable error caused by simultaneous access of some form.
       */
      exception ConcurrencyException extends ServerError
        {
           long backOff; /* Backoff in milliseconds */
        };
      /**
       * Currently unused.
       */
      exception ConcurrentModification extends ConcurrencyException
        {
        };
      /**
       * Too many simultaneous database users. This implies that a
       * connection to the database could not be acquired, no data
       * was saved or modifed. Clients may want to wait the given
       * backOff period, and retry.
       */
      exception DatabaseBusyException extends ConcurrencyException
        {
        };
      /**
       * Conflicting changes to the same piece of data.
       */
      exception OptimisticLockException extends ConcurrencyException
        {
        };
      /**
       * Lock cannot be acquired and has timed out.
       */
      exception LockTimeout extends ConcurrencyException
        {
            int seconds; /* Informational field on how long timeout was */
        };
      /**
       * Background processing needed before server is ready
       */
      exception TryAgain extends ConcurrencyException
        {
        };
      exception MissingPyramidException extends ConcurrencyException
       {
            long pixelsID;
       };
      // API USAGE
      exception ApiUsageException extends ServerError
        {
        };
      exception OverUsageException extends ApiUsageException
        {
        };
      /**
       *
       */
      exception QueryException extends ApiUsageException
        {
        };
      exception ValidationException extends ApiUsageException
        {
        };
      // SECURITY
      exception SecurityViolation extends ServerError
        {
        };
      exception GroupSecurityViolation extends SecurityViolation
        {
        };
      exception PermissionMismatchGroupSecurityViolation extends SecurityViolation
        {
        };
      exception ReadOnlyGroupSecurityViolation extends SecurityViolation
        {
        };
      // OMEROFS
        /**
         * OmeroFSError
         *
         * Just one catch-all UserException for the present. It could be
         * subclassed to provide a finer grained level if necessary.
         *
         * It should be fitted into or subsumed within the above hierarchy
         **/
        exception OmeroFSError extends ServerError
          {
            string reason;
          };
    };
    #endif // OMERO_SERVERERRORS_ICE

Server exceptions
-----------------

Due to the strict API boundary enforced by Ice, the client and server
exception hierarchies, though related, are distinct. The discussion
below is possibly of interest for server developers only. Client
developers should refer to the information and examples under |OmeroClients|.

Interceptor
~~~~~~~~~~~

Exception handling in the OMERO is centralized in an
:doc:`/developers/Server/Aop` interceptor (:server_source:`source
code <src/main/java/ome/services/util/ServiceHandler.java>`).
All exceptions thrown by code are caught in a
``try {} catch (Throwable t) {}`` block. Exceptions which do not subclass
:model_source:`ome.conditions.RootException <src/main/java/ome/conditions/RootException.java>`
are wrapped in an
:model_source:`ome.conditions.InternalException <src/main/java/ome/conditions/InternalException.java>`.

The only exceptions to this are any interceptors which may be run before
the exception handler is run. The order of interceptors is defined in
:server_source:`services.xml <src/main/resources/ome/services/services.xml>`.

Hierarchy
~~~~~~~~~

The current exception hierarchy (package
:model_sourcedir:`ome.conditions <src/main/java/ome/conditions>`)
used is as follows:

-  RootException

   -  InternalException - should not reach the client; Bug! Contact
      administrator e.g. NullPointerException, assertion failed, etc.
   -  ResourceError - fatal error in server, e.g. OutOfMemory, disk
      space full, the database is in illegal state, etc.
   -  DataAccessException

      -  SecurityViolation - do not do that! E.g. edit locked project,
         create new user.
      -  OptimisticLockException - re-load and compare e.g. "someone
         else has already updated this project"
      -  ApiUsageException - something wrong with how you did things
         e.g. IllegalStateException, object uninitialized, etc.
      -  ValidationException - something wrong with what you sent; sends
         list of fields, etc.; edit and retry, e.g. no "?" in image
         names.

where the colors indicate:

Abstract

FixAndRetryConditions

RetryConditions

NoRecourseConditions

Any other exception which reaches the client should be considered an
``OutOfServiceException``, meaning that something is (hopefully only)
temporarily wrong with the server, e.g. no connection, server down,
server restarting. But since this cannot be caught since the server cannot
be reached, there is no way to guarantee that a real
``OutOfServiceException`` is thrown.

Moving forward
--------------

``FixAndRetryConditions`` need to have information about what should be
fixed, like a Validation object which lists fields with error messages.
A ``RetryCondition`` could have a back-off value to prevent too frequent
retries.

Questions
~~~~~~~~~

-  What data should be available in the exceptions?
-  What other logic do we want on our exceptions, keeping in mind they
   will have to be re-implemented in all target languages?
