/** @see org.geotools.arcsde.session.ISessionPool#getSession(boolean) */ public ISession getSession(final boolean transactional) throws IOException, UnavailableConnectionException { checkOpen(); try { Session connection = null; if (transactional) { LOGGER.finest("Borrowing session from pool for transactional access"); connection = (Session) pool.borrowObject(); } else { synchronized (openSessionsNonTransactional) { try { if (LOGGER.isLoggable(Level.FINER)) { LOGGER.finer("Grabbing session from pool on " + Thread.currentThread().getName()); } connection = (Session) pool.borrowObject(); if (LOGGER.isLoggable(Level.FINER)) { LOGGER.finer("Got session from the pool on " + Thread.currentThread().getName()); } } catch (NoSuchElementException e) { if (LOGGER.isLoggable(Level.FINER)) { LOGGER.finer("No available sessions in the pool, falling back to queued session"); } connection = openSessionsNonTransactional.remove(); } openSessionsNonTransactional.add(connection); if (LOGGER.isLoggable(Level.FINER)) { LOGGER.finer( "Got session from the in use queue on " + Thread.currentThread().getName()); } } } connection.markActive(); return connection; } catch (NoSuchElementException e) { LOGGER.log( Level.WARNING, "Out of connections: " + e.getMessage() + ". Config: " + this.config); throw new UnavailableConnectionException(config.getMaxConnections(), this.config); } catch (SeException se) { ArcSdeException sdee = new ArcSdeException(se); LOGGER.log(Level.WARNING, "ArcSDE error getting connection for " + config, sdee); throw sdee; } catch (Exception e) { LOGGER.log(Level.WARNING, "Unknown problem getting connection: " + e.getMessage(), e); throw (IOException) new IOException("Unknown problem fetching connection from connection pool").initCause(e); } }
protected void doTransform( MuleMessage message, String outputEncoding, Source sourceDoc, Result result) throws Exception { DefaultErrorListener errorListener = new DefaultErrorListener(this); javax.xml.transform.Transformer transformer = null; try { transformer = (javax.xml.transform.Transformer) transformerPool.borrowObject(); transformer.setErrorListener(errorListener); transformer.setOutputProperty(OutputKeys.ENCODING, outputEncoding); // set transformation parameters if (contextProperties != null) { for (Entry<String, Object> parameter : contextProperties.entrySet()) { String key = parameter.getKey(); transformer.setParameter( key, evaluateTransformParameter(key, parameter.getValue(), message)); } } transformer.transform(sourceDoc, result); if (errorListener.isError()) { throw errorListener.getException(); } } finally { if (transformer != null) { transformerPool.returnObject(transformer); } } }
public Parser get() { try { return (Parser) pool.borrowObject(); } catch (Exception e) { throw new RuntimeException("Error borrowing a parser from the pool", e); } }
@SuppressWarnings("unchecked") public T getResource() { try { return (T) internalPool.borrowObject(); } catch (Exception e) { throw new JedisConnectionException("Could not get a resource from the pool", e); } }
public <T> T createProxy(Class<T> serviceClass) { NettyClient nettyClient = null; try { nettyClient = nettyClientPool.borrowObject(); return nettyClient.createProxy(serviceClass); } catch (Exception e) { logger.error(e.getMessage(), e); throw new NettyException(e.getMessage(), e); } finally { if (nettyClient != null) { try { nettyClientPool.returnObject(nettyClient); } catch (Exception e) { logger.error(e.getMessage(), e); throw new NettyException(e.getMessage(), e); } } } }
private static RServices tryBorrowAWorker(int attempts, long wait, TimeUnit timeUnit) { for (int i = 0; i < attempts; i++) { log.debug("Borrow attempt: {}", i); try { RServices rServices = (RServices) workerPool.borrowObject(); log.debug("Borrowed {} from the pool", rServices.getServantName()); return rServices; } catch (TimeoutException e) { log.debug("RServices pool is probably busy..", e); log.info("No free workers in the pool currently. Waiting for {} {}...", wait, timeUnit); } catch (Exception e) { log.error("Failed to borrow RServices worker", e); return null; } waitFor(timeUnit.toMillis(wait)); } log.error("Could not borrow RServices after " + attempts + " attempts"); return null; }
@SuppressWarnings("unchecked") public Void call() throws Exception { // LOG.debug("ORIGIN " + origin); int oi = stopIndices.get(origin); // origin index // first check for walking transfers // LOG.debug(" Walk"); BinHeap<State> heap; try { heap = (BinHeap<State>) heapPool.borrowObject(); } catch (Exception e) { throw new RuntimeException(e); } BasicShortestPathTree spt = new BasicShortestPathTree(500000); State s0 = new State(origin, options); spt.add(s0); heap.insert(s0, s0.getWeight()); while (!heap.empty()) { double w = heap.peek_min_key(); State u = heap.extract_min(); if (!spt.visit(u)) continue; Vertex uVertex = u.getVertex(); // LOG.debug("heap extract " + u + " weight " + w); if (w > MAX_WEIGHT) break; if (uVertex instanceof TransitStop) { int di = stopIndices.get(uVertex); // dest index table[oi][di] = (float) w; // LOG.debug(" Dest " + u + " w=" + w); } for (Edge e : uVertex.getOutgoing()) { if (!(e instanceof PreBoardEdge)) { State v = e.optimisticTraverse(u); if (v != null && spt.add(v)) heap.insert(v, v.getWeight()); } } } // then check what is accessible in one transit trip heap.reset(); // recycle heap spt = new BasicShortestPathTree(50000); // first handle preboard edges Queue<Vertex> q = new ArrayDeque<Vertex>(100); q.add(origin); while (!q.isEmpty()) { Vertex u = q.poll(); for (Edge e : u.getOutgoing()) { if (e instanceof PatternBoard) { Vertex v = ((PatternBoard) e).getToVertex(); // give onboard vertices same index as their // corresponding station stopIndices.put(v, oi); StateEditor se = (new State(u, options)).edit(e); se.incrementWeight(OPTIMISTIC_BOARD_COST); s0 = se.makeState(); spt.add(s0); heap.insert(s0, s0.getWeight()); // _log.debug(" board " + tov); } else if (e instanceof FreeEdge) { // handle preboard Vertex v = ((FreeEdge) e).getToVertex(); // give onboard vertices same index as their // corresponding station stopIndices.put(v, oi); q.add(v); } } } // all boarding edges for this stop have now been traversed // LOG.debug(" Transit"); while (!heap.empty()) { // check for transit stops when pulling off of heap // and continue when one is found // this is enough to prevent reboarding // need to mark closed vertices because otherwise cycles may // appear (interlining...) double w = heap.peek_min_key(); State u = heap.extract_min(); if (!spt.visit(u)) continue; // LOG.debug(" Extract " + u + " w=" + w); Vertex uVertex = u.getVertex(); if (uVertex instanceof TransitStop) { int di = stopIndices.get(uVertex); // dest index if (table[oi][di] > w) { table[oi][di] = (float) w; // LOG.debug(" Dest " + u + "w=" + w); } continue; } for (Edge e : uVertex.getOutgoing()) { // LOG.debug(" Edge " + e); State v = e.optimisticTraverse(u); if (v != null && spt.add(v)) heap.insert(v, v.getWeight()); // else LOG.debug(" (skip)"); } } heapPool.returnObject(heap); incrementCount(); return null; }
/** * Creates a new SessionPool object for the given config. * * @param config holds connection options such as server, user and password, as well as tuning * options as maximum number of connections allowed * @throws IOException If connection could not be established * @throws NullPointerException If config is null */ protected SessionPool(ArcSDEConnectionConfig config) throws IOException { if (config == null) { throw new NullPointerException("parameter config can't be null"); } this.config = config; LOGGER.fine("populating ArcSDE connection pool"); this.seConnectionFactory = createConnectionFactory(); final int minConnections = config.getMinConnections().intValue(); final int maxConnections = config.getMaxConnections().intValue(); if (minConnections > maxConnections) { throw new IllegalArgumentException("pool.minConnections > pool.maxConnections"); } { // configure connection pool Config poolCfg = new Config(); // pool upper limit poolCfg.maxActive = config.getMaxConnections().intValue(); // minimum number of idle objects. MAKE SURE this is 0, otherwise the pool will start // trying to create connections permanently even if there's a connection failure, // ultimately leading to the exhaustion of resources poolCfg.minIdle = 0; // how many connections may be idle at any time? -1 = no limit. We're running an // eviction thread to take care of idle connections (see minEvictableIdleTimeMillis and // timeBetweenEvictionRunsMillis) poolCfg.maxIdle = -1; // When reached the pool upper limit, block and wait for an idle connection for maxWait // milliseconds before failing poolCfg.maxWait = config.getConnTimeOut().longValue(); if (poolCfg.maxWait > 0) { poolCfg.whenExhaustedAction = GenericObjectPool.WHEN_EXHAUSTED_BLOCK; } else { poolCfg.whenExhaustedAction = GenericObjectPool.WHEN_EXHAUSTED_FAIL; } // check connection health at borrowObject()? poolCfg.testOnBorrow = true; // check connection health at returnObject()? poolCfg.testOnReturn = false; // check periodically the health of idle connections and discard them if can't be // validated? poolCfg.testWhileIdle = false; // check health of idle connections every 30 seconds // /poolCfg.timeBetweenEvictionRunsMillis = 30000; // drop connections that have been idle for at least 5 minutes poolCfg.minEvictableIdleTimeMillis = 5 * 60 * 1000; pool = new GenericObjectPool(seConnectionFactory, poolCfg); LOGGER.fine("Created ArcSDE connection pool for " + config); } ISession[] preload = new ISession[minConnections]; try { for (int i = 0; i < minConnections; i++) { preload[i] = (ISession) pool.borrowObject(); if (i == 0) { SeRelease seRelease = preload[i].getRelease(); String sdeDesc = seRelease.getDesc(); int major = seRelease.getMajor(); int minor = seRelease.getMinor(); int bugFix = seRelease.getBugFix(); String desc = "ArcSDE " + major + "." + minor + "." + bugFix + " " + sdeDesc; LOGGER.fine("Connected to " + desc); } } for (int i = 0; i < minConnections; i++) { pool.returnObject(preload[i]); } } catch (Exception e) { close(); if (e instanceof IOException) { throw (IOException) e; } throw (IOException) new IOException().initCause(e); } }
@Before public void setup() throws Exception { mService.setMessagePusher(mMessagePusher); when(mPool.borrowObject()).thenReturn(mConnection); }
/** * TODO time out is actually double as it waits for the producer and then waits for the response. * Use an atomic long to manage the countdown */ @Override public void sendMessage( final Exchange exchange, final AsyncCallback callback, final MessageProducerResources producer, final ReleaseProducerCallback releaseProducerCallback) throws Exception { Message request = getEndpoint().getBinding().makeJmsMessage(exchange, producer.getSession()); String correlationId = exchange.getIn().getHeader(JmsConstants.JMS_CORRELATION_ID, String.class); if (correlationId == null) { // we append the 'Camel-' prefix to know it was generated by us correlationId = GENERATED_CORRELATION_ID_PREFIX + getUuidGenerator().generateUuid(); } Object responseObject = null; Exchanger<Object> messageExchanger = new Exchanger<Object>(); JmsMessageHelper.setCorrelationId(request, correlationId); EXCHANGERS.put(correlationId, messageExchanger); MessageConsumerResources consumer = consumers.borrowObject(); JmsMessageHelper.setJMSReplyTo(request, consumer.getReplyToDestination()); consumers.returnObject(consumer); producer.getMessageProducer().send(request); // Return the producer to the pool so another waiting producer // can move forward // without waiting on us to complete the exchange try { releaseProducerCallback.release(producer); } catch (Exception exception) { // thrown if the pool is full. safe to ignore. } try { responseObject = messageExchanger.exchange(null, getResponseTimeOut(), TimeUnit.MILLISECONDS); EXCHANGERS.remove(correlationId); } catch (InterruptedException e) { log.debug("Exchanger was interrupted while waiting on response", e); exchange.setException(e); } catch (TimeoutException e) { log.debug("Exchanger timed out while waiting on response", e); exchange.setException(e); } if (exchange.getException() == null) { if (responseObject instanceof Throwable) { exchange.setException((Throwable) responseObject); } else if (responseObject instanceof Message) { Message message = (Message) responseObject; SjmsMessage response = new SjmsMessage(message, consumer.getSession(), getEndpoint().getBinding()); // the JmsBinding is designed to be "pull-based": it will populate the Camel message on // demand // therefore, we link Exchange and OUT message before continuing, so that the JmsBinding has // full access // to everything it may need, and can populate headers, properties, etc. accordingly (solves // CAMEL-6218). exchange.setOut(response); } else { exchange.setException(new CamelException("Unknown response type: " + responseObject)); } } callback.done(isSynchronous()); }