Example #1
0
  /** @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);
    }
  }
Example #2
0
  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);
   }
 }
Example #4
0
 @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);
   }
 }
Example #5
0
 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;
    }
Example #8
0
  /**
   * 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);
 }
Example #10
0
  /**
   * 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());
  }