Java Code Examples for org.apache.curator.framework.imps.CuratorFrameworkState#STARTED

@Override
public synchronized boolean start() {
    if (zkClient == null) {
        LOGGER.warn("Start zookeeper registry must be do init first!");
        return false;
    }
    if (zkClient.getState() == CuratorFrameworkState.STARTED) {
        return true;
    }
    try {
        zkClient.start();
    } catch (Throwable t) {
        throw new SofaRpcRuntimeException("Failed to start zookeeper zkClient", t);
    }
    return zkClient.getState() == CuratorFrameworkState.STARTED;
}
 

@Override
public void relinquishLeadership() {
    try {
        if (jobCache != null) {
            jobCache.close();
        }
        LoggerHelper.info("job cache has been closed.");
    } catch (Throwable e) {
        LoggerHelper.warn("job cache close failed.", e);
    }
    LoggerHelper.info("begin stop scheduler manager.");
    schedulerManager.shutdown();
    if (client.getState() == CuratorFrameworkState.STARTED) {
        StandbyNodeData.Data data = new StandbyNodeData.Data(getNodeIp());
        standbyApiFactory.nodeApi().updateNode(nodePath, data);
        LoggerHelper.info(getNodeIp() + " has been shutdown. [" + data + "]");
    }
    LoggerHelper.info("clear node successfully.");
}
 

/**
 * Start the registration of the {@link #candidate} for leader election.
 */
@Override
public synchronized void start() {
	if (!this.running) {
		if (this.client.getState() != CuratorFrameworkState.STARTED) {
			// we want to do curator start here because it needs to
			// be started before leader selector and it gets a little
			// complicated to control ordering via beans so that
			// curator is fully started.
			this.client.start();
		}
		this.leaderSelector = new LeaderSelector(this.client, buildLeaderPath(), new LeaderListener());
		this.leaderSelector.setId(this.candidate.getId());
		this.leaderSelector.autoRequeue();
		this.leaderSelector.start();

		this.running = true;
	}
}
 

@Override
protected void doHealthCheck(Health.Builder builder) throws Exception {
	try {
		CuratorFrameworkState state = this.curator.getState();
		if (state != CuratorFrameworkState.STARTED) {
			builder.down().withDetail("error", "Client not started");
		}
		else if (this.curator.checkExists().forPath("/") == null) {
			builder.down().withDetail("error", "Root for namespace does not exist");
		}
		else {
			builder.up();
		}
		builder.withDetail("connectionString",
				this.curator.getZookeeperClient().getCurrentConnectionString())
				.withDetail("state", state);
	}
	catch (Exception e) {
		builder.down(e);
	}
}
 

@Override
public boolean lock(String lockPath) {
    logger.debug("{} trying to lock {}", client, lockPath);

    // curator closed in some case(like Expired),restart it
    if (curator.getState() != CuratorFrameworkState.STARTED) {
        curator = ZKUtil.getZookeeperClient(KylinConfig.getInstanceFromEnv());
    }

    lockInternal(lockPath);

    String lockOwner;
    try {
        lockOwner = peekLock(lockPath);
        if (client.equals(lockOwner)) {
            logger.info("{} acquired lock at {}", client, lockPath);
            return true;
        } else {
            logger.debug("{} failed to acquire lock at {}, which is held by {}", client, lockPath, lockOwner);
            return false;
        }
    } catch (ZkPeekLockInterruptException zpie) {
        logger.error("{} peek owner of lock interrupt while acquire lock at {}, check to release lock", client,
                lockPath);
        lockOwner = peekLock(lockPath);

        try {
            unlockInternal(lockOwner, lockPath);
        } catch (Exception anyEx) {
            // it's safe to swallow any exception here because here already been interrupted
            logger.warn("Exception caught to release lock when lock operation has been interrupted.", anyEx);
        }
        throw zpie;
    }
}
 

@Override
public void start() {
  if (client.getState() != CuratorFrameworkState.STARTED) {
    client.start();

    if (clusterId != null) {
      client.getConnectionStateListenable().addListener(connectionStateListener);
      checkClusterIdExists(clusterId, "start");
    }
  }
}
 

/** {@inheritDoc} */
@Override public void unregisterAddresses(Collection<InetSocketAddress> addrs) throws IgniteSpiException {

    // if curator is not STARTED, we have nothing to unregister, because we are using ephemeral nodes,
    // which means that our addresses will only be registered in ZK as long as our connection is alive
    if (curator.getState() != CuratorFrameworkState.STARTED)
        return;

    if (log.isInfoEnabled())
        log.info("Unregistering addresses with ZooKeeper IP Finder: " + addrs);

    for (InetSocketAddress addr : addrs) {
        ServiceInstance<IgniteInstanceDetails> si = ourInstances.get(addr);
        if (si == null) {
            log.warning("Asked to unregister address from ZooKeeper IP Finder, but no match was found in local " +
                "instance map for: " + addrs);
            continue;
        }

        try {
            discovery.unregisterService(si);
        }
        catch (Exception e) {
            log.warning("Error while unregistering an address from ZooKeeper IP Finder: " + addr, e);
        }
    }
}
 

/**
 * 关闭连接
 */
public void close() {
    logger.debug("--------zoo close");
    if (curator.getState() == CuratorFrameworkState.STARTED) {
        curator.close();
    }
}
 

/**
 * 关闭注册
 */
@Override
public synchronized void logout() {
    CuratorFramework client = (CuratorFramework) regCenter.getRawClient();
    if (client != null && client.getState() == CuratorFrameworkState.STARTED) {
        // 移除注册节点（最大程度的自动释放资源）
        regCenter.remove(nodePath.getWorkerIdPath());
        // 关闭连接
        regCenter.close();
    }
}
 

/**
 * Constructor
 * 
 * @param framework
 *            {@link CuratorFramework}
 */
public CuratorManager(final CuratorFramework framework) {
    this.framework = checkNotNull(framework);
    // start framework directly to allow other bundles to interact with zookeeper
    // during their run() method.
    if (framework.getState() != CuratorFrameworkState.STARTED) {
        framework.start();
    }
}
 

@Override
public void check(HealthIndicatorCallback healthCallback) {
    CuratorFrameworkState state = curatorService.getCurator().getState();
    if (state == CuratorFrameworkState.STARTED) {
        healthCallback.inform(Health.healthy().build());
    } else {
        healthCallback.inform(Health.unhealthy().withDetail("state", state).build());
    }
}
 

@Override
public void destroy() {
    closePathChildrenCache(INTERFACE_CONFIG_CACHE);
    closePathChildrenCache(INTERFACE_OVERRIDE_CACHE);
    if (zkClient != null && zkClient.getState() == CuratorFrameworkState.STARTED) {
        zkClient.close();
    }
    providerUrls.clear();
    consumerUrls.clear();
}
 

public boolean checkZookeeperState() throws Exception {
    return curator != null && curator.getState() == CuratorFrameworkState.STARTED && curator.getZookeeperClient().isConnected();
}
 

public boolean isStarted(){
	return getState() == CuratorFrameworkState.STARTED;
}
 

public void startCuratorFramework() {
  if (curatorFramework.getState() != CuratorFrameworkState.STARTED) {
    curatorFramework.start();
  }
}
 

private CuratorFramework getAndCheckZkClient() {
    if (zkClient == null || zkClient.getState() != CuratorFrameworkState.STARTED) {
        throw new SofaRpcRuntimeException(LogCodes.getLog(LogCodes.ERROR_ZOOKEEPER_CLIENT_UNAVAILABLE));
    }
    return zkClient;
}
 

@Override
public void stop() throws Exception {
    if (_curator.getState() == CuratorFrameworkState.STARTED) {
        Closeables.close(_curator, true);
    }
}
 

public boolean isStarted() {
    return client.getState() == CuratorFrameworkState.STARTED;
}
 

private CuratorFramework getAndCheckZkClient() {
    if (zkClient == null || zkClient.getState() != CuratorFrameworkState.STARTED) {
        throw new SofaRpcRuntimeException("Zookeeper client is not available");
    }
    return zkClient;
}
 

public boolean isRunning() {
    return curatorFramework != null
            && (curatorFramework.getState() == CuratorFrameworkState.STARTED);
}