C-JDBC: org.objectweb.cjdbc.controller.connection.RandomWaitPoolConnectionManager Class Reference

If the pool is empty, this methods blocks until a connection is freed or the timeout expires.

00108   {
00109     if (!initialized)
00110     {
00111       logger
00112           .error("Requesting a connection from a non-initialized connection manager");
00113       return null;
00114     }
00115 
00116     long lTimeout = timeout;
00117     synchronized (freeConnections)
00118     {
00119       // We have to do a while loop() because there is a potential race here.
00120       // When freeConnections is notified in releaseConnection, a new thread
00121       // can
00122       // take the lock on freeConnections before we wake up/reacquire the lock
00123       // on freeConnections. Therefore, we could wake up and have no connection
00124       // to take! We ensure that everything is correct with a while statement
00125       // and recomputing the timeout between 2 wakeup.
00126       while (freeConnections.isEmpty())
00127       {
00128         // Wait
00129         try
00130         {
00131           if (lTimeout > 0)
00132           {
00133             long start = System.currentTimeMillis();
00134             // Convert seconds to milliseconds for wait call
00135             freeConnections.wait(timeout);
00136             long end = System.currentTimeMillis();
00137             lTimeout -= end - start;
00138             if (lTimeout <= 0)
00139             {
00140               if (activeConnections.size() == 0)
00141               { // No connection active and backend unreachable, the backend
00142                 // is probably dead
00143                 logger.error("Backend " + backendName
00144                     + " is no more accessible.");
00145                 throw new UnreachableBackendException();
00146               }
00147               if (logger.isWarnEnabled())
00148                 logger.warn("Timeout expired for connection on backend '"
00149                     + backendName
00150                     + "', consider increasing pool size (current size is "
00151                     + poolSize + ") or timeout (current timeout is "
00152                     + (timeout / 1000) + " seconds)");
00153               return null;
00154             }
00155           }
00156           else
00157             freeConnections.wait();
00158         }
00159         catch (InterruptedException e)
00160         {
00161           logger
00162               .error("Wait on freeConnections interrupted in RandomWaitPoolConnectionManager: "
00163                   + e);
00164           return null;
00165         }
00166       }
00167       // Get the connection
00168       try
00169       {
00170         Connection c = (Connection) freeConnections.pop();
00171         activeConnections.add(c);
00172         return c;
00173       }
00174       catch (EmptyStackException e)
00175       {
00176         int missing = poolSize
00177             - (activeConnections.size() + freeConnections.size());
00178         if (missing > 0)
00179         { // Re-allocate missing connections
00180           logger.info("Trying to reallocate " + missing
00181               + " missing connections.");
00182           Connection connectionToBeReturned = null;
00183           while (missing > 0)
00184           {
00185             Connection c = getConnectionFromDriver();
00186             if (c == null)
00187             {
00188               if (missing == poolSize)
00189               {
00190                 String msg = Translate.get("loadbalancer.backend.unreacheable",
00191                     backendName);
00192                 logger.error(msg);
00193                 throw new UnreachableBackendException(msg);
00194               }
00195               logger.warn("Unable to re-allocate " + missing
00196                   + " missing connections.");
00197               break;
00198             }
00199             else
00200             {
00201               if (connectionToBeReturned == null)
00202                 connectionToBeReturned = c;
00203               else
00204                 freeConnections.add(c);
00205             }
00206             missing--;
00207           }
00208           return connectionToBeReturned;
00209         }
00210         if (logger.isErrorEnabled())
00211           logger.error("Failed to get a connection on backend '" + backendName
00212               + "' whereas an idle connection was expected");
00213         return null;
00214       }
00215     }
00216   }


Public Member Functions
	RandomWaitPoolConnectionManager (String backendUrl, String backendName, String login, String password, String driverPath, String driverClassName, int poolSize, int timeout)
int	getTimeout ()
Connection	getConnection () throws UnreachableBackendException
void	releaseConnection (Connection c)
void	deleteConnection (Connection c)
String	getXmlImpl ()
Protected Member Functions
Object	clone () throws CloneNotSupportedException

org.objectweb.cjdbc.controller.connection.RandomWaitPoolConnectionManager Class Reference

Public Member Functions

Protected Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation