package org.apache.blur.manager.clusterstatus;
/**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import java.io.Closeable;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
import org.apache.blur.BlurConfiguration;
import org.apache.blur.log.Log;
import org.apache.blur.log.LogFactory;
import org.apache.blur.lucene.search.FairSimilarity;
import org.apache.blur.server.TableContext;
import org.apache.blur.thirdparty.thrift_0_9_0.TDeserializer;
import org.apache.blur.thirdparty.thrift_0_9_0.TException;
import org.apache.blur.thirdparty.thrift_0_9_0.TSerializer;
import org.apache.blur.thirdparty.thrift_0_9_0.protocol.TJSONProtocol;
import org.apache.blur.thrift.generated.TableDescriptor;
import org.apache.blur.utils.BlurConstants;
import org.apache.blur.utils.BlurUtil;
import org.apache.blur.zookeeper.WatchChildren;
import org.apache.blur.zookeeper.WatchChildren.OnChange;
import org.apache.blur.zookeeper.WatchNodeData;
import org.apache.blur.zookeeper.ZkUtils;
import org.apache.blur.zookeeper.ZooKeeperLockManager;
import org.apache.blur.zookeeper.ZookeeperPathConstants;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.fs.permission.FsPermission;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;
public class ZookeeperClusterStatus extends ClusterStatus {
private static final String TMP = "tmp";
private static final Log LOG = LogFactory.getLog(ZookeeperClusterStatus.class);
public static final String CACHE = "cache";
public static final String COMPLETE = "complete";
public static final String INPROGRESS = "inprogress";
public static final String NEW = "new";
private final ZooKeeper _zk;
private final BlurConfiguration _configuration;
private final AtomicBoolean _running = new AtomicBoolean();
private final ConcurrentMap<String, List<String>> _onlineShardsNodes = new ConcurrentHashMap<String, List<String>>();
private final ConcurrentMap<String, Set<String>> _tablesPerCluster = new ConcurrentHashMap<String, Set<String>>();
private final AtomicReference<Set<String>> _clusters = new AtomicReference<Set<String>>(new HashSet<String>());
private final Map<String, TableDescriptor> _tableDescriptorCache = new ConcurrentHashMap<String, TableDescriptor>();
private final WatchChildren _clusterWatcher;
private final ConcurrentMap<String, WatchChildren> _onlineShardsNodesWatchers = new ConcurrentHashMap<String, WatchChildren>();
private final ConcurrentMap<String, WatchChildren> _tableWatchers = new ConcurrentHashMap<String, WatchChildren>();
private final Map<String, SafeModeCacheEntry> _clusterToSafeMode = new ConcurrentHashMap<String, ZookeeperClusterStatus.SafeModeCacheEntry>();
private final ConcurrentMap<String, WatchNodeData> _enabledWatchNodeExistance = new ConcurrentHashMap<String, WatchNodeData>();
private final Set<Action> _tableStateChange = Collections.newSetFromMap(new ConcurrentHashMap<Action, Boolean>());
private final Configuration _config;
public ZookeeperClusterStatus(ZooKeeper zooKeeper, BlurConfiguration configuration, Configuration config) {
_config = config;
_zk = zooKeeper;
_running.set(true);
_clusterWatcher = new WatchChildren(_zk, ZookeeperPathConstants.getClustersPath());
_clusterWatcher.watch(new Clusters());
_configuration = configuration;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
public ZookeeperClusterStatus(String connectionStr, BlurConfiguration configuration, Configuration config)
throws IOException {
this(new ZooKeeper(connectionStr, 30000, new Watcher() {
@Override
public void process(WatchedEvent event) {
}
}), configuration, config);
}
public ZookeeperClusterStatus(ZooKeeper zooKeeper) throws IOException {
this(zooKeeper, new BlurConfiguration(), new Configuration());
}
public ZookeeperClusterStatus(String connectionStr) throws IOException {
this(connectionStr, new BlurConfiguration(), new Configuration());
}
class Clusters extends OnChange {
@Override
public void action(List<String> clusters) {
_clusters.set(new HashSet<String>(clusters));
for (String cluster : clusters) {
if (!_tableWatchers.containsKey(cluster)) {
String tablesPath = ZookeeperPathConstants.getTablesPath(cluster);
ZkUtils.waitUntilExists(_zk, tablesPath);
WatchChildren clusterWatcher = new WatchChildren(_zk, tablesPath);
clusterWatcher.watch(new Tables(cluster));
_tableWatchers.put(cluster, clusterWatcher);
}
}
List<String> clustersToCloseAndRemove = new ArrayList<String>(clusters);
clustersToCloseAndRemove.removeAll(_tableWatchers.keySet());
for (String cluster : clustersToCloseAndRemove) {
WatchChildren watcher = _tableWatchers.remove(cluster);
if (watcher == null) {
LOG.error("Error watcher is null [" + cluster + "] ");
} else {
watcher.close();
}
}
}
}
class Tables extends OnChange {
private final String _cluster;
private final String _tablesPath;
public Tables(String cluster) {
_cluster = cluster;
_tablesPath = ZookeeperPathConstants.getTablesPath(cluster);
}
@Override
public void action(List<String> tables) {
runActions();
Set<String> newSet = new HashSet<String>(filterTables(_tablesPath, tables));
Set<String> oldSet = _tablesPerCluster.put(_cluster, newSet);
Set<String> newTables = getNewTables(newSet, oldSet);
Set<String> oldTables = getOldTables(newSet, oldSet);
for (String table : oldTables) {
final String clusterTableKey = getClusterTableKey(_cluster, table);
WatchNodeData watch = _enabledWatchNodeExistance.remove(clusterTableKey);
if (watch != null) {
watch.close();
}
_tableDescriptorCache.remove(table);
TableContext.clear(table);
}
for (final String table : newTables) {
final String clusterTableKey = getClusterTableKey(_cluster, table);
WatchNodeData enabledWatcher = new WatchNodeData(_zk, ZookeeperPathConstants.getTablePath(_cluster, table));
enabledWatcher.watch(new WatchNodeData.OnChange() {
@Override
public void action(byte[] data) {
runActions();
_tableDescriptorCache.remove(table);
TableContext.clear(table);
}
});
if (_enabledWatchNodeExistance.putIfAbsent(clusterTableKey, enabledWatcher) != null) {
enabledWatcher.close();
}
}
}
private Set<String> getOldTables(Set<String> newSet, Set<String> oldSet) {
Set<String> oldTables = new HashSet<String>();
if (oldSet != null) {
oldTables.addAll(oldSet);
}
if (newSet != null) {
oldTables.removeAll(newSet);
}
return oldTables;
}
private Set<String> getNewTables(Set<String> newSet, Set<String> oldSet) {
Set<String> newTables = new HashSet<String>(newSet);
if (oldSet != null) {
newTables.removeAll(oldSet);
}
return newTables;
}
}
private String getClusterTableKey(String cluster, String table) {
return cluster + "." + table;
}
private void runActions() {
for (Action action : _tableStateChange) {
action.action();
}
}
@Override
public List<String> getClusterList(boolean useCache) {
if (useCache) {
return new ArrayList<String>(_clusters.get());
}
long s = System.nanoTime();
try {
checkIfOpen();
return _zk.getChildren(ZookeeperPathConstants.getClustersPath(), false);
} catch (KeeperException e) {
throw new RuntimeException(e);
} catch (InterruptedException e) {
throw new RuntimeException(e);
} finally {
long e = System.nanoTime();
LOG.debug("trace getClusterList [" + (e - s) / 1000000.0 + " ms]");
}
}
private void checkIfOpen() {
if (_running.get()) {
return;
}
throw new RuntimeException("not open");
}
@Override
public List<String> getOnlineControllerList() {
long s = System.nanoTime();
try {
checkIfOpen();
return _zk.getChildren(ZookeeperPathConstants.getOnlineControllersPath(), false);
} catch (KeeperException e) {
throw new RuntimeException(e);
} catch (InterruptedException e) {
throw new RuntimeException(e);
} finally {
long e = System.nanoTime();
LOG.debug("trace getOnlineControllerList [" + (e - s) / 1000000.0 + " ms]");
}
}
@Override
public List<String> getControllerServerList() {
return getOnlineControllerList();
}
@Override
public List<String> getOnlineShardServers(boolean useCache, String cluster) {
if (useCache) {
List<String> shards = _onlineShardsNodes.get(cluster);
if (shards != null) {
return shards;
} else {
watchForOnlineShardNodes(cluster);
}
}
long s = System.nanoTime();
try {
checkIfOpen();
String onlineShardsPath = ZookeeperPathConstants.getOnlineShardsPath(cluster);
return _zk.getChildren(onlineShardsPath, false);
} catch (KeeperException e) {
throw new RuntimeException(e);
} catch (InterruptedException e) {
throw new RuntimeException(e);
} finally {
long e = System.nanoTime();
LOG.debug("trace getOnlineShardServers took [" + (e - s) / 1000000.0 + " ms]");
}
}
private void watchForOnlineShardNodes(final String cluster) {
WatchChildren watch = new WatchChildren(_zk, ZookeeperPathConstants.getOnlineShardsPath(cluster));
watch.watch(new OnChange() {
@Override
public void action(List<String> children) {
_onlineShardsNodes.put(cluster, children);
}
});
if (_onlineShardsNodesWatchers.putIfAbsent(cluster, watch) != null) {
// There was already a watch created. Close the extra watcher.
watch.close();
}
}
@Override
public List<String> getShardServerList(String cluster) {
long s = System.nanoTime();
try {
checkIfOpen();
String shardsPath = ZookeeperPathConstants.getOnlineShardsPath(cluster);
return _zk.getChildren(shardsPath, false);
} catch (KeeperException e) {
throw new RuntimeException(e);
} catch (InterruptedException e) {
throw new RuntimeException(e);
} finally {
long e = System.nanoTime();
LOG.debug("trace getShardServerList took [" + (e - s) / 1000000.0 + " ms]");
}
}
@Override
public boolean exists(boolean useCache, String cluster, String table) {
if (useCache) {
Set<String> tables = _tablesPerCluster.get(cluster);
if (tables != null) {
if (tables.contains(table)) {
return true;
}
}
}
try {
checkIfOpen();
if (_zk.exists(ZookeeperPathConstants.getTablePath(cluster, table), false) == null) {
return false;
}
return true;
} catch (KeeperException e) {
throw new RuntimeException(e);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
@Override
public boolean isEnabled(boolean useCache, String cluster, String table) {
TableDescriptor tableDescriptor = getTableDescriptor(useCache, cluster, table);
return tableDescriptor.isEnabled();
}
@Override
public TableDescriptor getTableDescriptor(boolean useCache, String cluster, String table) {
if (useCache) {
TableDescriptor tableDescriptor = _tableDescriptorCache.get(table);
if (tableDescriptor != null) {
return tableDescriptor;
}
}
long s = System.nanoTime();
TableDescriptor tableDescriptor = new TableDescriptor();
try {
checkIfOpen();
String blurTablePath = ZookeeperPathConstants.getTablePath(cluster, table);
byte[] bytes = getData(blurTablePath);
if (bytes == null) {
throw new RuntimeException("Table [" + table + "] in cluster [" + cluster + "] not found.");
}
TDeserializer deserializer = new TDeserializer(new TJSONProtocol.Factory());
deserializer.deserialize(tableDescriptor, bytes);
} catch (TException e) {
throw new RuntimeException(e);
} catch (KeeperException e) {
throw new RuntimeException(e);
} catch (InterruptedException e) {
throw new RuntimeException(e);
} finally {
long e = System.nanoTime();
LOG.debug("trace getTableDescriptor took [" + (e - s) / 1000000.0 + " ms]");
}
tableDescriptor.cluster = cluster;
_tableDescriptorCache.put(table, tableDescriptor);
return tableDescriptor;
}
private byte[] getData(String path) throws KeeperException, InterruptedException {
Stat stat = _zk.exists(path, false);
if (stat == null) {
LOG.debug("Tried to fetch path [{0}] and path is missing", path);
return null;
}
byte[] data = _zk.getData(path, false, stat);
if (data == null) {
LOG.debug("Fetched path [{0}] and data is null", path);
return null;
}
return data;
}
@Override
public List<String> getTableList(boolean useCache, String cluster) {
if (useCache) {
Set<String> tables = _tablesPerCluster.get(cluster);
if (tables != null) {
return new ArrayList<String>(tables);
}
}
long s = System.nanoTime();
try {
checkIfOpen();
String tablesPath = ZookeeperPathConstants.getTablesPath(cluster);
return filterTables(tablesPath, _zk.getChildren(tablesPath, false));
} catch (KeeperException e) {
throw new RuntimeException(e);
} catch (InterruptedException e) {
throw new RuntimeException(e);
} finally {
long e = System.nanoTime();
LOG.debug("trace getTableList took [" + (e - s) / 1000000.0 + " ms]");
}
}
private List<String> filterTables(String tablesPath, List<String> tables) {
try {
List<String> result = new ArrayList<String>();
for (String table : tables) {
String path = tablesPath + "/" + table;
Stat stat = _zk.exists(path, false);
if (stat != null) {
byte[] data = _zk.getData(path, false, stat);
if (data == null) {
LOG.info("Empty table node found at [" + path + "]");
_zk.delete(path, -1);
} else {
result.add(table);
}
}
}
return result;
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public void close() {
if (_running.get()) {
_running.set(false);
close(_clusterWatcher);
close(_onlineShardsNodesWatchers);
close(_tableWatchers);
close(_enabledWatchNodeExistance);
}
}
private void close(ConcurrentMap<String, ? extends Closeable> closableMap) {
Collection<? extends Closeable> values = closableMap.values();
for (Closeable closeable : values) {
close(closeable);
}
}
private void close(Closeable closeable) {
try {
closeable.close();
} catch (IOException e) {
LOG.error("Unknown error while trying to close [{0}]", closeable);
}
}
@Override
public String getCluster(boolean useCache, String table) {
if (useCache) {
for (Entry<String, Set<String>> entry : _tablesPerCluster.entrySet()) {
if (entry.getValue().contains(table)) {
return entry.getKey();
}
}
}
List<String> clusterList = getClusterList(useCache);
for (String cluster : clusterList) {
long s = System.nanoTime();
try {
checkIfOpen();
Stat stat = _zk.exists(ZookeeperPathConstants.getTablePath(cluster, table), false);
if (stat != null) {
// _tableToClusterCache.put(table, cluster);
return cluster;
}
} catch (KeeperException e) {
throw new RuntimeException(e);
} catch (InterruptedException e) {
throw new RuntimeException(e);
} finally {
long e = System.nanoTime();
LOG.debug("trace getCluster took [" + (e - s) / 1000000.0 + " ms]");
}
}
return null;
}
static class SafeModeCacheEntry {
static final long _10_SECONDS = TimeUnit.SECONDS.toMillis(10);
boolean _safeMode;
long _lastCheck;
public SafeModeCacheEntry(boolean safeMode) {
_lastCheck = System.currentTimeMillis();
_safeMode = safeMode;
}
boolean isValid() {
long now = System.currentTimeMillis();
if (_lastCheck + _10_SECONDS < now) {
return false;
}
return true;
}
}
@Override
public boolean isInSafeMode(boolean useCache, String cluster) {
if (useCache) {
SafeModeCacheEntry safeModeCacheEntry = _clusterToSafeMode.get(cluster);
if (safeModeCacheEntry != null && safeModeCacheEntry.isValid()) {
return safeModeCacheEntry._safeMode;
}
}
try {
checkIfOpen();
String safemodePath = ZookeeperPathConstants.getSafemodePath(cluster);
ZooKeeperLockManager zooKeeperLockManager = new ZooKeeperLockManager(_zk, safemodePath);
if (zooKeeperLockManager.getNumberOfLockNodesPresent(cluster) == 0) {
_clusterToSafeMode.put(cluster, new SafeModeCacheEntry(false));
return false;
}
_clusterToSafeMode.put(cluster, new SafeModeCacheEntry(true));
return true;
} catch (KeeperException e) {
throw new RuntimeException(e);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
@Override
public boolean isReadOnly(boolean useCache, String cluster, String table) {
TableDescriptor tableDescriptor = getTableDescriptor(useCache, cluster, table);
return tableDescriptor.isReadOnly();
}
@Override
public void createTable(TableDescriptor tableDescriptor) {
long s = System.nanoTime();
try {
checkIfOpen();
if (tableDescriptor.getSimilarityClass() == null) {
tableDescriptor.setSimilarityClass(FairSimilarity.class.getName());
}
String table = BlurUtil.nullCheck(tableDescriptor.name, "tableDescriptor.name cannot be null.");
String cluster = BlurUtil.nullCheck(tableDescriptor.cluster, "tableDescriptor.cluster cannot be null.");
assignTableUri(tableDescriptor);
assignMapReduceWorkingPath(tableDescriptor);
String uri = BlurUtil.nullCheck(tableDescriptor.tableUri, "tableDescriptor.tableUri cannot be null.");
int shardCount = BlurUtil.zeroCheck(tableDescriptor.shardCount,
"tableDescriptor.shardCount cannot be less than 1");
String blurTablePath = ZookeeperPathConstants.getTablePath(cluster, table);
if (_zk.exists(blurTablePath, false) != null) {
throw new IOException("Table [" + table + "] already exists.");
}
BlurUtil.setupFileSystem(uri, shardCount, _config);
byte[] bytes = serializeTableDescriptor(tableDescriptor);
BlurUtil.createPath(_zk, blurTablePath, bytes);
} catch (IOException e) {
throw new RuntimeException(e);
} catch (KeeperException e) {
throw new RuntimeException(e);
} catch (InterruptedException e) {
throw new RuntimeException(e);
} finally {
long e = System.nanoTime();
LOG.debug("trace createTable took [" + (e - s) / 1000000.0 + " ms]");
}
}
private byte[] serializeTableDescriptor(TableDescriptor td) {
try {
TSerializer serializer = new TSerializer(new TJSONProtocol.Factory());
return serializer.serialize(td);
} catch (TException e) {
throw new RuntimeException(e);
}
}
private void assignTableUri(TableDescriptor tableDescriptor) {
if (tableDescriptor.getTableUri() != null) {
return;
}
String cluster = tableDescriptor.getCluster();
String defaultTableUriPropertyName = BlurConstants.getDefaultTableUriPropertyName(cluster);
String parentPath = _configuration.get(defaultTableUriPropertyName);
if (parentPath == null) {
return;
}
String tableUri = parentPath + "/" + tableDescriptor.getName();
LOG.info("Setting default table uri for table [{0}] of [{1}]", tableDescriptor.getName(), tableUri);
tableDescriptor.setTableUri(tableUri);
}
private void assignMapReduceWorkingPath(TableDescriptor tableDescriptor) throws IOException {
Map<String, String> tableProperties = tableDescriptor.getTableProperties();
String mrIncWorkingPathStr = getProperty(tableProperties, BlurConstants.BLUR_BULK_UPDATE_WORKING_PATH);
if (mrIncWorkingPathStr == null) {
// If not set on the table, try to use cluster default
mrIncWorkingPathStr = _configuration.get(BlurConstants.BLUR_BULK_UPDATE_WORKING_PATH);
if (mrIncWorkingPathStr == null) {
LOG.info("Could not setup map reduce working path for table [{0}]", tableDescriptor.getName());
return;
}
// Add table on the cluster default and add back to the table desc.
mrIncWorkingPathStr = new Path(mrIncWorkingPathStr, tableDescriptor.getName()).toString();
tableDescriptor.putToTableProperties(BlurConstants.BLUR_BULK_UPDATE_WORKING_PATH, mrIncWorkingPathStr);
}
Path mrIncWorkingPath = new Path(mrIncWorkingPathStr);
FileSystem fileSystem = mrIncWorkingPath.getFileSystem(_config);
Path newData = new Path(mrIncWorkingPath, NEW);
Path tmpData = new Path(mrIncWorkingPath, TMP);
Path inprogressData = new Path(mrIncWorkingPath, INPROGRESS);
Path completeData = new Path(mrIncWorkingPath, COMPLETE);
Path fileCache = new Path(mrIncWorkingPath, CACHE);
String permission = getProperty(tableProperties, BlurConstants.BLUR_BULK_UPDATE_WORKING_PATH_PERMISSION);
FsPermission fsPermission;
// Kinda junky coding, but Hadoop1 prevents me from using a better method. @TODO cleanup when only supporting hadoop2.
if (permission == null || permission.isEmpty()) {
fileSystem.mkdirs(mrIncWorkingPath);
fileSystem.mkdirs(newData);
fileSystem.mkdirs(tmpData);
fileSystem.mkdirs(inprogressData);
fileSystem.mkdirs(completeData);
fileSystem.mkdirs(fileCache);
} else {
fsPermission = new FsPermission(permission);
fileSystem.mkdirs(mrIncWorkingPath, fsPermission);
fileSystem.mkdirs(newData, fsPermission);
fileSystem.mkdirs(tmpData, fsPermission);
fileSystem.mkdirs(inprogressData, fsPermission);
fileSystem.mkdirs(completeData, fsPermission);
fileSystem.mkdirs(fileCache, fsPermission);
}
}
private String getProperty(Map<String, String> tableProperties, String name) {
String value = null;
if (tableProperties != null) {
value = tableProperties.get(name);
}
return value;
}
@Override
public void disableTable(String cluster, String table) {
try {
checkIfOpen();
String tablePath = ZookeeperPathConstants.getTablePath(cluster, table);
Stat stat = _zk.exists(tablePath, false);
if (stat == null) {
throw new IOException("Table [" + table + "] does not exist.");
}
TableDescriptor tableDescriptor = getTableDescriptor(false, cluster, table);
if (!tableDescriptor.isEnabled()) {
return;
}
tableDescriptor.setEnabled(false);
byte[] bytes = serializeTableDescriptor(tableDescriptor);
_zk.setData(tablePath, bytes, stat.getVersion());
} catch (IOException e) {
throw new RuntimeException(e);
} catch (InterruptedException e) {
throw new RuntimeException(e);
} catch (KeeperException e) {
throw new RuntimeException(e);
}
}
@Override
public void enableTable(String cluster, String table) {
long s = System.nanoTime();
try {
checkIfOpen();
String tablePath = ZookeeperPathConstants.getTablePath(cluster, table);
Stat stat = _zk.exists(tablePath, false);
if (stat == null) {
throw new IOException("Table [" + table + "] does not exist.");
}
TableDescriptor tableDescriptor = getTableDescriptor(false, cluster, table);
if (tableDescriptor.isEnabled()) {
return;
}
tableDescriptor.setEnabled(true);
byte[] bytes = serializeTableDescriptor(tableDescriptor);
_zk.setData(tablePath, bytes, stat.getVersion());
} catch (IOException e) {
throw new RuntimeException(e);
} catch (InterruptedException e) {
throw new RuntimeException(e);
} catch (KeeperException e) {
throw new RuntimeException(e);
} finally {
long e = System.nanoTime();
LOG.debug("trace enableTable took [" + (e - s) / 1000000.0 + " ms]");
}
}
@Override
public void removeTable(String cluster, String table, boolean deleteIndexFiles) {
long s = System.nanoTime();
try {
checkIfOpen();
TableDescriptor tableDescriptor = getTableDescriptor(true, cluster, table);
String blurTablePath = ZookeeperPathConstants.getTablePath(cluster, table);
if (_zk.exists(blurTablePath, false) == null) {
throw new IOException("Table [" + table + "] does not exist.");
}
if (tableDescriptor.isEnabled()) {
throw new IOException("Table [" + table + "] must be disabled before it can be removed.");
}
String uri = tableDescriptor.getTableUri();
BlurUtil.removeAll(_zk, blurTablePath);
if (deleteIndexFiles) {
BlurUtil.removeIndexFiles(uri, _config);
}
} catch (IOException e) {
throw new RuntimeException(e);
} catch (InterruptedException e) {
throw new RuntimeException(e);
} catch (KeeperException e) {
throw new RuntimeException(e);
} finally {
long e = System.nanoTime();
LOG.debug("trace removeTable took [" + (e - s) / 1000000.0 + " ms]");
}
}
@Override
public boolean isOpen() {
return _running.get();
}
@Override
public void registerActionOnTableStateChange(Action action) {
_tableStateChange.add(action);
}
}