Java ConnectionState.CONNECTED属性代码示例

@Override
public void stateChanged(CuratorFramework client, ConnectionState newState) {
    if (newState == ConnectionState.CONNECTED) {
        isConnected.set(true);
        if (!isFirstConnection.get()) {
            for (ConnectionStateListener listener : listenerStateProxy.getListeners()) {
                listener.stateChanged(client, ConnectionState.RECONNECTED);
            }
        }
        return;
    }

    if (newState == ConnectionState.LOST) {
        isConnected.set(false);
        isFirstConnection.set(false);
        retryConnection();
    }
}
 

@Override
public void destroy() {
    if (connectionState == ConnectionState.CONNECTED) {
        for (ServiceDescription service : services.values()) {
            String path = pathForProvider(service.getName(), service.getId());
            try {
                client.delete().forPath(path);
            } catch (Exception ignore) {
                // ignore
            }
        }
    }
    services.clear();

    client.getConnectionStateListenable().removeListener(connectionStateListener);
    client.close();
}
 

@Override
public void stateChanged(CuratorFramework client, ConnectionState newState)
{
    if ( (newState == ConnectionState.RECONNECTED) || (newState == ConnectionState.CONNECTED) )
    {
        try
        {
            log.debug("Re-registering due to reconnection");
            reRegisterServices();
        }
        catch (InterruptedException ex)
        {
            Thread.currentThread().interrupt();
        }
        catch ( Exception e )
        {
            log.error("Could not re-register instances after reconnection", e);
        }
    }
}
 

@Override
public void stateChanged(CuratorFramework client, ConnectionState newState) {
  if(newState == ConnectionState.CONNECTED) {
    ZKClusterCoordinator.this.initialConnection.countDown();
    client.getConnectionStateListenable().removeListener(this);
  }
}
 

@Override
public boolean isConnected() {
    return client != null && client.isStarted() &&
            currentConnectionState != null &&
            (currentConnectionState == ConnectionState.CONNECTED ||
            currentConnectionState == ConnectionState.RECONNECTED);
}
 

private void checkConnection() throws KeeperException.ConnectionLossException {
    if (client != null &&
            currentConnectionState != null &&
            currentConnectionState != ConnectionState.CONNECTED &&
            currentConnectionState != ConnectionState.RECONNECTED) {

        KeeperException.ConnectionLossException exception = new KeeperException.ConnectionLossException();
        Metrics.reportZookeeperConnectionIssue(exception);
        throw exception;
    }
}
 

@Override
public void stateChanged(CuratorFramework client, ConnectionState newState) {
  if(newState == ConnectionState.CONNECTED) {
    ZKClusterClient.this.initialConnection.countDown();
    client.getConnectionStateListenable().removeListener(this);
  }
}
 

@Override
public void listen(ServiceDescription description) throws Exception {
    if (connectionState != ConnectionState.CONNECTED) {
        listenServices.add(description);
    } else {
        internalListen(description);
    }
}
 

@Override
public void register(ServiceDescription service) throws Exception {
    services.put(service.getId(), service);
    if (connectionState == ConnectionState.CONNECTED) {
        internalRegister(service);
    }
}
 

@Override
  public void stateChanged(CuratorFramework client, ConnectionState newState) {
      if (newState == ConnectionState.CONNECTED) {
          if (registration == null) {
              registration = bundleContext.registerService(CuratorFramework.class, curator, null);
          }
      }
      for (ConnectionStateListener listener : connectionStateListeners) {
          listener.stateChanged(client, newState);
      }
      if (newState == ConnectionState.LOST) {
          run();
      }
}
 

public void stateChanged(CuratorFramework curatorFramework, ConnectionState connectionState) {
    log.info("Connection to Zookeeper toggled to state " + connectionState.toString());
    connected = connectionState == ConnectionState.CONNECTED || connectionState == ConnectionState.RECONNECTED;
    if (connectionState == ConnectionState.LOST) {
        log.error("Connection to Zookeeper toggled to state " + connectionState.toString());
        this.handleZookeeperConnectionFailed();
    } else if (connectionState == ConnectionState.RECONNECTED) {
        log.info("Reconnected to zookeeper, forcing lock scavenge");
        forceLockScavenge();
    } else {
        log.info("Connection to Zookeeper toggled to state " + connectionState.toString());
    }
}
 

@Override
public void start()
{
    log.info("Starting");
    if ( !state.compareAndSet(CuratorFrameworkState.LATENT, CuratorFrameworkState.STARTED) )
    {
        throw new IllegalStateException("Cannot be started more than once");
    }

    try
    {
        connectionStateManager.start(); // ordering dependency - must be called before client.start()

        final ConnectionStateListener listener = new ConnectionStateListener()
        {
            @Override
            public void stateChanged(CuratorFramework client, ConnectionState newState)
            {
                if ( ConnectionState.CONNECTED == newState || ConnectionState.RECONNECTED == newState )
                {
                    logAsErrorConnectionErrors.set(true);
                }
            }
        };

        this.getConnectionStateListenable().addListener(listener);

        client.start();

        executorService = Executors.newSingleThreadScheduledExecutor(threadFactory);
        executorService.submit(new Callable<Object>()
        {
            @Override
            public Object call() throws Exception
            {
                backgroundOperationsLoop();
                return null;
            }
        });

        if ( ensembleTracker != null )
        {
            ensembleTracker.start();
        }

        log.info(schemaSet.toDocumentation());
    }
    catch ( Exception e )
    {
        ThreadUtils.checkInterrupted(e);
        handleBackgroundOperationException(null, e);
    }
}
 

@Test
public void testListenerConnectedAtStart() throws Exception
{
    server.stop();

    Timing timing = new Timing(2);
    CuratorFramework client = CuratorFrameworkFactory.newClient(server.getConnectString(), timing.session(), timing.connection(), new RetryNTimes(0, 0));
    try
    {
        client.start();
        AsyncCuratorFramework async = AsyncCuratorFramework.wrap(client);

        final CountDownLatch connectedLatch = new CountDownLatch(1);
        final AtomicBoolean firstListenerAction = new AtomicBoolean(true);
        final AtomicReference<ConnectionState> firstListenerState = new AtomicReference<>();
        ConnectionStateListener listener = (client1, newState) ->
        {
            if ( firstListenerAction.compareAndSet(true, false) )
            {
                firstListenerState.set(newState);
                System.out.println("First listener state is " + newState);
            }
            if ( newState == ConnectionState.CONNECTED )
            {
                connectedLatch.countDown();
            }
        };
        client.getConnectionStateListenable().addListener(listener);

        // due to CURATOR-72, this was causing a LOST event to precede the CONNECTED event
        async.create().forPath("/foo");

        server.restart();

        Assert.assertTrue(timing.awaitLatch(connectedLatch));
        Assert.assertFalse(firstListenerAction.get());
        ConnectionState firstconnectionState = firstListenerState.get();
        Assert.assertEquals(firstconnectionState, ConnectionState.CONNECTED, "First listener state MUST BE CONNECTED but is " + firstconnectionState);
    }
    finally
    {
        CloseableUtils.closeQuietly(client);
    }
}