Esempio n. 1
0
  /* Hook for creating session factory */
  protected ClientSessionFactoryInternal createSessionFactory() throws Exception {
    if (targetNodeID != null
        && (this.reconnectAttemptsSameNode < 0 || retryCount <= this.reconnectAttemptsSameNode)) {
      csf = reconnectOnOriginalNode();
    } else {
      serverLocator.resetToInitialConnectors();
      csf = (ClientSessionFactoryInternal) serverLocator.createSessionFactory();
    }

    // null here means the targetNodeIS is not available yet
    if (csf != null) {
      csf.setReconnectAttempts(0);
    }

    return csf;
  }
  @Test
  public void testNoAutoFailback() throws Exception {
    locator
        .setBlockOnNonDurableSend(true)
        .setBlockOnDurableSend(true)
        .setFailoverOnInitialConnection(true)
        .setReconnectAttempts(-1);

    ClientSessionFactoryInternal sf = createSessionFactoryAndWaitForTopology(locator, 2);

    ClientSession session = sendAndConsume(sf, true);

    CountDownSessionFailureListener listener = new CountDownSessionFailureListener(1, session);

    session.addFailureListener(listener);

    backupServer.stop();

    liveServer.crash();

    backupServer.start();

    assertTrue(listener.getLatch().await(5, TimeUnit.SECONDS));

    ClientProducer producer = session.createProducer(ADDRESS);

    ClientMessage message = session.createMessage(true);

    setBody(0, message);

    producer.send(message);

    session.removeFailureListener(listener);

    Thread t = new Thread(new ServerStarter(liveServer));

    t.start();

    waitForRemoteBackup(sf, 10, false, backupServer.getServer());

    assertTrue(backupServer.isStarted());

    backupServer.crash();

    waitForServerToStart(liveServer.getServer());

    assertTrue(liveServer.isStarted());

    sf.close();

    assertEquals(0, sf.numSessions());

    assertEquals(0, sf.numConnections());
  }
Esempio n. 3
0
  protected void scheduleRetryConnect() {
    if (serverLocator.isClosed()) {
      ActiveMQServerLogger.LOGGER.bridgeLocatorShutdown();
      return;
    }

    if (stopping) {
      ActiveMQServerLogger.LOGGER.bridgeStopping();
      return;
    }

    if (reconnectAttemptsInUse >= 0 && retryCount > reconnectAttemptsInUse) {
      ActiveMQServerLogger.LOGGER.bridgeAbortStart(name, retryCount, reconnectAttempts);
      fail(true);
      return;
    }

    long timeout = (long) (this.retryInterval * Math.pow(this.retryMultiplier, retryCount));
    if (timeout == 0) {
      timeout = this.retryInterval;
    }
    if (timeout > maxRetryInterval) {
      timeout = maxRetryInterval;
    }

    logger.debug(
        "Bridge "
            + this
            + " retrying connection #"
            + retryCount
            + ", maxRetry="
            + reconnectAttemptsInUse
            + ", timeout="
            + timeout);

    scheduleRetryConnectFixedTimeout(timeout);
  }
Esempio n. 4
0
  private ClientSessionFactoryInternal reconnectOnOriginalNode() throws Exception {
    String targetNodeIdUse = targetNodeID;
    TopologyMember nodeUse = targetNode;
    if (targetNodeIdUse != null && nodeUse != null) {
      TransportConfiguration[] configs = new TransportConfiguration[2]; // live and backup
      int numberOfConfigs = 0;

      if (nodeUse.getLive() != null) {
        configs[numberOfConfigs++] = nodeUse.getLive();
      }
      if (nodeUse.getBackup() != null) {
        configs[numberOfConfigs++] = nodeUse.getBackup();
      }

      if (numberOfConfigs > 0) {
        // It will bounce between all the available configs
        int nodeTry = (retryCount - 1) % numberOfConfigs;

        return (ClientSessionFactoryInternal) serverLocator.createSessionFactory(configs[nodeTry]);
      }
    }

    return null;
  }
Esempio n. 5
0
  /* This is called only when the bridge is activated */
  protected void connect() {
    if (stopping) return;

    synchronized (connectionGuard) {
      if (!keepConnecting) return;

      logger.debug(
          "Connecting  "
              + this
              + " to its destination ["
              + nodeUUID.toString()
              + "], csf="
              + this.csf);

      retryCount++;

      try {
        if (csf == null || csf.isClosed()) {
          if (stopping) return;
          csf = createSessionFactory();
          if (csf == null) {
            // Retrying. This probably means the node is not available (for the cluster connection
            // case)
            scheduleRetryConnect();
            return;
          }
          // Session is pre-acknowledge
          session =
              (ClientSessionInternal) csf.createSession(user, password, false, true, true, true, 1);
          sessionConsumer =
              (ClientSessionInternal) csf.createSession(user, password, false, true, true, true, 1);
        }

        if (forwardingAddress != null) {
          ClientSession.AddressQuery query = null;

          try {
            query = session.addressQuery(forwardingAddress);
          } catch (Throwable e) {
            ActiveMQServerLogger.LOGGER.errorQueryingBridge(e, name);
            // This was an issue during startup, we will not count this retry
            retryCount--;

            scheduleRetryConnectFixedTimeout(100);
            return;
          }

          if (forwardingAddress.startsWith(BridgeImpl.JMS_QUEUE_ADDRESS_PREFIX)
              || forwardingAddress.startsWith(BridgeImpl.JMS_TOPIC_ADDRESS_PREFIX)) {
            if (!query.isExists()) {
              ActiveMQServerLogger.LOGGER.errorQueryingBridge(forwardingAddress, retryCount);
              scheduleRetryConnect();
              return;
            }
          } else {
            if (!query.isExists()) {
              ActiveMQServerLogger.LOGGER.bridgeNoBindings(
                  getName(), getForwardingAddress(), getForwardingAddress());
            }
          }
        }

        producer = session.createProducer();
        session.addFailureListener(BridgeImpl.this);

        session.setSendAcknowledgementHandler(BridgeImpl.this);

        afterConnect();

        active = true;

        queue.addConsumer(BridgeImpl.this);
        queue.deliverAsync();

        ActiveMQServerLogger.LOGGER.bridgeConnected(this);

        // We only do this on plain core bridges
        if (isPlainCoreBridge()) {
          serverLocator.addClusterTopologyListener(new TopologyListener());
        }

        keepConnecting = false;
        return;
      } catch (ActiveMQException e) {
        // the session was created while its server was starting, retry it:
        if (e.getType() == ActiveMQExceptionType.SESSION_CREATION_REJECTED) {
          ActiveMQServerLogger.LOGGER.errorStartingBridge(name);

          // We are not going to count this one as a retry
          retryCount--;

          scheduleRetryConnectFixedTimeout(this.retryInterval);
          return;
        } else {
          if (logger.isDebugEnabled()) {
            logger.debug("Bridge " + this + " is unable to connect to destination. Retrying", e);
          }

          scheduleRetryConnect();
        }
      } catch (ActiveMQInterruptedException | InterruptedException e) {
        ActiveMQServerLogger.LOGGER.errorConnectingBridge(e, this);
      } catch (Exception e) {
        ActiveMQServerLogger.LOGGER.errorConnectingBridge(e, this);
        if (csf != null) {
          try {
            csf.close();
            csf = null;
          } catch (Throwable ignored) {
          }
        }
        fail(false);
        scheduleRetryConnect();
      }
    }
  }