@Override public boolean execute() throws Exception { LOGGER.info("Connecting to Zookeeper at address: {}", _zkAddress); ZkClient zkClient = new ZkClient(_zkAddress, 5000); String helixClusterName = "/" + _clusterName; LOGGER.info("Executing command: " + toString()); if (!zkClient.exists(helixClusterName)) { LOGGER.error("Cluster {} does not exist.", _clusterName); return false; } zkClient.deleteRecursive(helixClusterName); return true; } }
protected void startController(ControllerConf config) { Assert.assertNotNull(config); Assert.assertNull(_controllerStarter); _controllerPort = Integer.valueOf(config.getControllerPort()); _controllerBaseApiUrl = "http://localhost:" + _controllerPort; _controllerRequestURLBuilder = ControllerRequestURLBuilder.baseUrl(_controllerBaseApiUrl); _controllerDataDir = config.getDataDir(); String helixClusterName = getHelixClusterName(); config.setHelixClusterName(helixClusterName); String zkStr = config.getZkStr(); _zkClient = new ZkClient(zkStr); if (_zkClient.exists("/" + helixClusterName)) { _zkClient.deleteRecursive("/" + helixClusterName); } startControllerStarter(config); _helixManager = _helixResourceManager.getHelixZkManager(); _helixAdmin = _helixResourceManager.getHelixAdmin(); _propertyStore = _helixResourceManager.getPropertyStore(); }
/** * sync exists */ @Override public boolean exists(String path, int options) { return _zkClient.exists(path); }
@Override public void run() { zkClient.exists(TEST_ROOT); } });
public static void updateIfExists(ZkClient client, String path, final ZNRecord record, boolean mergeOnUpdate) { if (client.exists(path)) { DataUpdater<Object> updater = new DataUpdater<Object>() { @Override public Object update(Object currentData) { return record; } }; client.updateDataSerialized(path, updater); } }
public static void subtract(ZkClient client, String path, final ZNRecord recordTosubtract) { int retryCount = 0; while (retryCount < RETRYLIMIT) { try { if (client.exists(path)) { DataUpdater<ZNRecord> updater = new DataUpdater<ZNRecord>() { @Override public ZNRecord update(ZNRecord currentData) { currentData.subtract(recordTosubtract); return currentData; } }; client.updateDataSerialized(path, updater); break; } } catch (Exception e) { retryCount = retryCount + 1; logger.warn("Exception trying to createOrReplace " + path + ". Will retry.", e); } } } }
public static void createOrReplace(ZkClient client, String path, final ZNRecord record, final boolean persistent) { int retryCount = 0; while (retryCount < RETRYLIMIT) { try { if (client.exists(path)) { DataUpdater<Object> updater = new DataUpdater<Object>() { @Override public Object update(Object currentData) { return record; } }; client.updateDataSerialized(path, updater); } else { CreateMode mode = (persistent) ? CreateMode.PERSISTENT : CreateMode.EPHEMERAL; client.create(path, record, mode); } break; } catch (Exception e) { retryCount = retryCount + 1; logger.warn("Exception trying to createOrReplace " + path + " Exception:" + e.getMessage() + ". Will retry."); } } }
public static void createOrUpdate(ZkClient client, String path, final ZNRecord record, final boolean persistent, final boolean mergeOnUpdate) { int retryCount = 0; while (retryCount < RETRYLIMIT) { try { if (client.exists(path)) { DataUpdater<ZNRecord> updater = new DataUpdater<ZNRecord>() { @Override public ZNRecord update(ZNRecord currentData) { if (currentData != null && mergeOnUpdate) { currentData.update(record); return currentData; } return record; } }; client.updateDataSerialized(path, updater); } else { CreateMode mode = (persistent) ? CreateMode.PERSISTENT : CreateMode.EPHEMERAL; client.create(path, record, mode); } break; } catch (Exception e) { retryCount = retryCount + 1; logger.warn("Exception trying to update " + path + " Exception:" + e.getMessage() + ". Will retry."); } } }
public static boolean isInstanceSetup(ZkClient zkclient, String clusterName, String instanceName, InstanceType type) { if (type == InstanceType.PARTICIPANT || type == InstanceType.CONTROLLER_PARTICIPANT) { ArrayList<String> requiredPaths = new ArrayList<>(); requiredPaths.add(PropertyPathBuilder.instanceConfig(clusterName, instanceName)); requiredPaths.add(PropertyPathBuilder.instanceMessage(clusterName, instanceName)); requiredPaths.add(PropertyPathBuilder.instanceCurrentState(clusterName, instanceName)); requiredPaths.add(PropertyPathBuilder.instanceStatusUpdate(clusterName, instanceName)); requiredPaths.add(PropertyPathBuilder.instanceError(clusterName, instanceName)); boolean isValid = true; for (String path : requiredPaths) { if (!zkclient.exists(path)) { isValid = false; logger.error("Invalid instance setup, missing znode path: {}", path); } } if (isValid) { // Create the instance history node if it does not exist. // This is for back-compatibility. String historyPath = PropertyPathBuilder.instanceHistory(clusterName, instanceName); if (!zkclient.exists(historyPath)) { zkclient.createPersistent(historyPath, true); } } return isValid; } return true; }
public static String getInstancePropertyNameListAsString(ZkClient zkClient, String clusterName, String instanceName, PropertyType instanceProperty, String key, MediaType mediaType) throws JsonGenerationException, JsonMappingException, IOException { String path = PropertyPathBuilder.instanceProperty(clusterName, instanceName, instanceProperty, key); if (zkClient.exists(path)) { List<String> recordNames = zkClient.getChildren(path); return ObjectToJson(recordNames); } return ObjectToJson(new ArrayList<String>()); }
@Override public void addResource(String clusterName, String resourceName, IdealState idealstate) { logger.info("Add resource {} in cluster {}.", resourceName, clusterName); String stateModelRef = idealstate.getStateModelDefRef(); String stateModelDefPath = PropertyPathBuilder.stateModelDef(clusterName, stateModelRef); if (!_zkClient.exists(stateModelDefPath)) { throw new HelixException( "State model " + stateModelRef + " not found in the cluster STATEMODELDEFS path"); } String idealStatePath = PropertyPathBuilder.idealState(clusterName); String resourceIdealStatePath = idealStatePath + "/" + resourceName; if (_zkClient.exists(resourceIdealStatePath)) { throw new HelixException("Skip the operation. Resource ideal state directory already exists:" + resourceIdealStatePath); } ZKUtil.createChildren(_zkClient, idealStatePath, idealstate.getRecord()); }
@Override public void dropInstance(String clusterName, InstanceConfig instanceConfig) { logger.info("Drop instance {} from cluster {}.", instanceConfig.getInstanceName(), clusterName); String instanceName = instanceConfig.getInstanceName(); String instanceConfigPath = PropertyPathBuilder.instanceConfig(clusterName, instanceName); if (!_zkClient.exists(instanceConfigPath)) { throw new HelixException( "Node " + instanceName + " does not exist in config for cluster " + clusterName); } String instancePath = PropertyPathBuilder.instance(clusterName, instanceName); if (!_zkClient.exists(instancePath)) { throw new HelixException( "Node " + instanceName + " does not exist in instances for cluster " + clusterName); } String liveInstancePath = PropertyPathBuilder.liveInstance(clusterName, instanceName); if (_zkClient.exists(liveInstancePath)) { throw new HelixException( "Node " + instanceName + " is still alive for cluster " + clusterName + ", can't drop."); } // delete config path String instanceConfigsPath = PropertyPathBuilder.instanceConfig(clusterName); ZKUtil.dropChildren(_zkClient, instanceConfigsPath, instanceConfig.getRecord()); // delete instance path _zkClient.deleteRecursively(instancePath); }
@Override public void addStateModelDef(String clusterName, String stateModelDef, StateModelDefinition stateModel, boolean recreateIfExists) { logger .info("Add StateModelDef {} in cluster {} with StateModel {}.", stateModelDef, clusterName, stateModel == null ? "NULL" : stateModel.toString()); if (!ZKUtil.isClusterSetup(clusterName, _zkClient)) { throw new HelixException("cluster " + clusterName + " is not setup yet"); } String stateModelDefPath = PropertyPathBuilder.stateModelDef(clusterName); String stateModelPath = stateModelDefPath + "/" + stateModelDef; if (_zkClient.exists(stateModelPath)) { if (recreateIfExists) { logger.info( "Operation.State Model directory exists:" + stateModelPath + ", remove and recreate."); _zkClient.deleteRecursively(stateModelPath); } else { logger.info("Skip the operation. State Model directory exists:" + stateModelPath); return; } } HelixDataAccessor accessor = new ZKHelixDataAccessor(clusterName, new ZkBaseDataAccessor<ZNRecord>(_zkClient)); Builder keyBuilder = accessor.keyBuilder(); accessor.setProperty(keyBuilder.stateModelDef(stateModelDef), stateModel); }
@Override public InstanceConfig getInstanceConfig(String clusterName, String instanceName) { logger.info("Get instance config for instance {} from cluster {}.", instanceName, clusterName); String instanceConfigPath = PropertyPathBuilder.instanceConfig(clusterName, instanceName); if (!_zkClient.exists(instanceConfigPath)) { throw new HelixException( "instance" + instanceName + " does not exist in cluster " + clusterName); } HelixDataAccessor accessor = new ZKHelixDataAccessor(clusterName, new ZkBaseDataAccessor<ZNRecord>(_zkClient)); Builder keyBuilder = accessor.keyBuilder(); return accessor.getProperty(keyBuilder.instanceConfig(instanceName)); }
while (retryCount < RETRYLIMIT) { try { if (client.exists(path)) { DataUpdater<ZNRecord> updater = new DataUpdater<ZNRecord>() { @Override
public static void asyncCreateOrMerge(ZkClient client, String path, final ZNRecord record, final boolean persistent, final boolean mergeOnUpdate) { try { if (client.exists(path)) { if (mergeOnUpdate) { ZNRecord curRecord = client.readData(path);
@Test public void testZkSessionExpiry() throws Exception { String className = TestHelper.getTestClassName(); String methodName = TestHelper.getTestMethodName(); String clusterName = className + "_" + methodName; System.out.println("START " + clusterName + " at " + new Date(System.currentTimeMillis())); ZkClient client = new ZkClient(ZK_ADDR, HelixZkClient.DEFAULT_SESSION_TIMEOUT, HelixZkClient.DEFAULT_CONNECTION_TIMEOUT, new ZNRecordSerializer()); String path = String.format("/%s", clusterName); client.createEphemeral(path); String oldSessionId = ZkTestHelper.getSessionId(client); ZkTestHelper.expireSession(client); String newSessionId = ZkTestHelper.getSessionId(client); Assert.assertNotSame(newSessionId, oldSessionId); Assert.assertFalse(client.exists(path), "Ephemeral znode should be gone after session expiry"); client.close(); System.out.println("END " + clusterName + " at " + new Date(System.currentTimeMillis())); }
@Override public boolean setInstanceConfig(String clusterName, String instanceName, InstanceConfig newInstanceConfig) { logger.info("Set instance config for instance {} to cluster {} with new InstanceConfig {}.", instanceName, clusterName, newInstanceConfig == null ? "NULL" : newInstanceConfig.toString()); String instanceConfigPath = PropertyPathBuilder.getPath(PropertyType.CONFIGS, clusterName, HelixConfigScope.ConfigScopeProperty.PARTICIPANT.toString(), instanceName); if (!_zkClient.exists(instanceConfigPath)) { throw new HelixException( "instance" + instanceName + " does not exist in cluster " + clusterName); } HelixDataAccessor accessor = new ZKHelixDataAccessor(clusterName, new ZkBaseDataAccessor<ZNRecord>(_zkClient)); PropertyKey instanceConfigPropertyKey = accessor.keyBuilder().instanceConfig(instanceName); InstanceConfig currentInstanceConfig = accessor.getProperty(instanceConfigPropertyKey); if (!newInstanceConfig.getHostName().equals(currentInstanceConfig.getHostName()) || !newInstanceConfig.getPort().equals(currentInstanceConfig.getPort())) { throw new HelixException( "Hostname and port cannot be changed, current hostname: " + currentInstanceConfig .getHostName() + " and port: " + currentInstanceConfig.getPort() + " is different from new hostname: " + newInstanceConfig.getHostName() + "and new port: " + newInstanceConfig.getPort()); } return accessor.setProperty(instanceConfigPropertyKey, newInstanceConfig); }
@Override public void addInstance(String clusterName, InstanceConfig instanceConfig) { logger.info("Add instance {} to cluster {}.", instanceConfig.getInstanceName(), clusterName); if (!ZKUtil.isClusterSetup(clusterName, _zkClient)) { throw new HelixException("cluster " + clusterName + " is not setup yet"); } String instanceConfigsPath = PropertyPathBuilder.instanceConfig(clusterName); String nodeId = instanceConfig.getId(); String instanceConfigPath = instanceConfigsPath + "/" + nodeId; if (_zkClient.exists(instanceConfigPath)) { throw new HelixException("Node " + nodeId + " already exists in cluster " + clusterName); } ZKUtil.createChildren(_zkClient, instanceConfigsPath, instanceConfig.getRecord()); _zkClient.createPersistent(PropertyPathBuilder.instanceMessage(clusterName, nodeId), true); _zkClient.createPersistent(PropertyPathBuilder.instanceCurrentState(clusterName, nodeId), true); _zkClient.createPersistent(PropertyPathBuilder.instanceError(clusterName, nodeId), true); _zkClient.createPersistent(PropertyPathBuilder.instanceStatusUpdate(clusterName, nodeId), true); _zkClient.createPersistent(PropertyPathBuilder.instanceHistory(clusterName, nodeId), true); }