/** * Gets a watched {@link ZooCache}. If the watcher is null, then the same (unwatched) object may * be returned for multiple calls with the same remaining arguments. * * @param zooKeepers * comma-separated list of ZooKeeper host[:port]s * @param sessionTimeout * session timeout * @param watcher * watcher (optional) * @return cache object */ public ZooCache getZooCache(String zooKeepers, int sessionTimeout, Watcher watcher) { if (watcher == null) { // reuse return getZooCache(zooKeepers, sessionTimeout); } return new ZooCache(zooKeepers, sessionTimeout, watcher); }
public ZooLock(String zookeepers, int timeInMillis, String scheme, byte[] auth, String path) { this(new ZooCacheFactory().getZooCache(zookeepers, timeInMillis), ZooReaderWriter.getInstance(zookeepers, timeInMillis, scheme, auth), path); }
/** * Return the cached ZooCache for provided context. ZooCache is initially created with a watcher * that will clear the TableMap cache for that instance when WatchedEvent occurs. */ private static ZooCache getZooCache(final ClientContext context) { SecurityManager sm = System.getSecurityManager(); if (sm != null) { sm.checkPermission(TABLES_PERMISSION); } final String uuid = context.getInstanceID(); try { return instanceToZooCache.get(uuid, () -> { final String zks = context.getZooKeepers(); final int timeOut = context.getZooKeepersSessionTimeOut(); return new ZooCacheFactory().getZooCache(zks, timeOut, watchedEvent -> instanceToMapCache.invalidate(uuid)); }); } catch (ExecutionException e) { throw new RuntimeException(e); } }
ServerInfo(SiteConfiguration siteConfig, String instanceName, String zooKeepers, int zooKeepersSessionTimeOut) { SingletonManager.setMode(Mode.SERVER); this.siteConfig = siteConfig; this.hadoopConf = new Configuration(); this.instanceName = instanceName; this.zooKeepers = zooKeepers; this.zooKeepersSessionTimeOut = zooKeepersSessionTimeOut; try { volumeManager = VolumeManagerImpl.get(siteConfig, hadoopConf); } catch (IOException e) { throw new IllegalStateException(e); } zooCache = new ZooCacheFactory().getZooCache(zooKeepers, zooKeepersSessionTimeOut); String instanceNamePath = Constants.ZROOT + Constants.ZINSTANCES + "/" + instanceName; byte[] iidb = zooCache.get(instanceNamePath); if (iidb == null) { throw new RuntimeException("Instance name " + instanceName + " does not exist in zookeeper. " + "Run \"accumulo org.apache.accumulo.server.util.ListInstances\" to see a list."); } instanceID = new String(iidb, UTF_8); if (zooCache.get(Constants.ZROOT + "/" + instanceID) == null) { if (instanceName == null) { throw new RuntimeException("Instance id " + instanceID + " does not exist in zookeeper"); } throw new RuntimeException("Instance id " + instanceID + " pointed to by the name " + instanceName + " does not exist in zookeeper"); } }
ServerInfo(SiteConfiguration config) { SingletonManager.setMode(Mode.SERVER); siteConfig = config; hadoopConf = new Configuration(); try { volumeManager = VolumeManagerImpl.get(siteConfig, hadoopConf); } catch (IOException e) { throw new IllegalStateException(e); } Path instanceIdPath = ServerUtil.getAccumuloInstanceIdPath(volumeManager); instanceID = ZooUtil.getInstanceIDFromHdfs(instanceIdPath, config, hadoopConf); zooKeepers = config.get(Property.INSTANCE_ZK_HOST); zooKeepersSessionTimeOut = (int) config.getTimeInMillis(Property.INSTANCE_ZK_TIMEOUT); zooCache = new ZooCacheFactory().getZooCache(zooKeepers, zooKeepersSessionTimeOut); instanceName = InstanceOperationsImpl.lookupInstanceName(zooCache, UUID.fromString(instanceID)); }
private synchronized ZooCachePropertyAccessor getPropCacheAccessor() { if (propCacheAccessor == null) { synchronized (propCaches) { PropCacheKey key = new PropCacheKey(context.getInstanceID(), tableId.canonicalID()); ZooCache propCache = propCaches.get(key); if (propCache == null) { propCache = zcf.getZooCache(context.getZooKeepers(), context.getZooKeepersSessionTimeOut(), new TableConfWatcher(context)); propCaches.put(key, propCache); } propCacheAccessor = new ZooCachePropertyAccessor(propCache); } } return propCacheAccessor; }
private synchronized ZooCachePropertyAccessor getPropCacheAccessor() { if (propCacheAccessor == null) { synchronized (propCaches) { PropCacheKey key = new PropCacheKey(context.getInstanceID(), namespaceId.canonicalID()); ZooCache propCache = propCaches.get(key); if (propCache == null) { propCache = zcf.getZooCache(context.getZooKeepers(), context.getZooKeepersSessionTimeOut(), new NamespaceConfWatcher(context)); propCaches.put(key, propCache); } propCacheAccessor = new ZooCachePropertyAccessor(propCache); } } return propCacheAccessor; }
public void process(WatchedEvent arg0) {} }; propCache = zcf.getZooCache(context.getZooKeepers(), context.getZooKeepersSessionTimeOut(), watcher); config = new ZooConfiguration(context, propCache, parent);
ZooKeeperInstance(ClientConfiguration config, ZooCacheFactory zcf) { checkArgument(config != null, "config is null"); // Enable singletons before before getting a zoocache SingletonManager.setMode(Mode.CONNECTOR); this.clientConf = config; this.instanceId = clientConf.get(ClientConfiguration.ClientProperty.INSTANCE_ID); this.instanceName = clientConf.get(ClientConfiguration.ClientProperty.INSTANCE_NAME); if ((instanceId == null) == (instanceName == null)) throw new IllegalArgumentException( "Expected exactly one of instanceName and instanceId to be set; " + (instanceName == null ? "neither" : "both") + " were set"); this.zooKeepers = clientConf.get(ClientConfiguration.ClientProperty.INSTANCE_ZK_HOST); this.zooKeepersSessionTimeOut = (int) ConfigurationTypeHelper .getTimeInMillis(clientConf.get(ClientConfiguration.ClientProperty.INSTANCE_ZK_TIMEOUT)); zooCache = zcf.getZooCache(zooKeepers, zooKeepersSessionTimeOut); if (instanceName != null) { // Validates that the provided instanceName actually exists getInstanceID(); } }
public ClientContext(SingletonReservation reservation, ClientInfo info, AccumuloConfiguration serverConf) { this.info = info; this.hadoopConf = info.getHadoopConf(); zooCache = new ZooCacheFactory().getZooCache(info.getZooKeepers(), info.getZooKeepersSessionTimeOut()); this.serverConf = serverConf; timeoutSupplier = memoizeWithExpiration( () -> getConfiguration().getTimeInMillis(Property.GENERAL_RPC_TIMEOUT)); sslSupplier = memoizeWithExpiration(() -> SslConnectionParams.forClient(getConfiguration())); saslSupplier = memoizeWithExpiration( () -> SaslConnectionParams.from(getConfiguration(), getCredentials().getToken())); this.singletonReservation = Objects.requireNonNull(reservation); this.tableops = new TableOperationsImpl(this); this.namespaceops = new NamespaceOperationsImpl(this, tableops); }
/** * Gets a watched {@link ZooCache}. If the watcher is null, then the same (unwatched) object may * be returned for multiple calls with the same remaining arguments. * * @param zooKeepers * comma-seprated list of ZooKeeper host[:port]s * @param sessionTimeout * session timeout * @param watcher * watcher (optional) * @return cache object */ public ZooCache getZooCache(String zooKeepers, int sessionTimeout, Watcher watcher) { if (watcher == null) { // reuse return getZooCache(zooKeepers, sessionTimeout); } return new ZooCache(zooKeepers, sessionTimeout, watcher); }
private static ZooCache getZooCache(Instance instance) { SecurityManager sm = System.getSecurityManager(); if (sm != null) { sm.checkPermission(TABLES_PERMISSION); } return new ZooCacheFactory().getZooCache(instance.getZooKeepers(), instance.getZooKeepersSessionTimeOut()); }
public ZooLock(String zookeepers, int timeInMillis, String scheme, byte[] auth, String path) { this(new ZooCacheFactory().getZooCache(zookeepers, timeInMillis), ZooReaderWriter.getInstance(zookeepers, timeInMillis, scheme, auth), path); }
@Override public ZooCache call() { final String zks = instance.getZooKeepers(); final int timeOut = instance.getZooKeepersSessionTimeOut(); return new ZooCacheFactory().getZooCache(zks, timeOut, new Watcher() { @Override public void process(WatchedEvent watchedEvent) { instanceToMapCache.invalidate(uuid); } }); } });
ZookeeperLockChecker(Instance instance, ZooCacheFactory zcf) { zc = zcf.getZooCache(instance.getZooKeepers(), instance.getZooKeepersSessionTimeOut()); this.root = ZooUtil.getRoot(instance) + Constants.ZTSERVERS; }
private HdfsZooInstance() { zooCache = new ZooCacheFactory().getZooCache(site.get(Property.INSTANCE_ZK_HOST), (int) site.getTimeInMillis(Property.INSTANCE_ZK_TIMEOUT)); }
@Override public void invalidateCache(Instance instance, String server) { ZooCache zooCache = zcf.getZooCache(instance.getZooKeepers(), instance.getZooKeepersSessionTimeOut()); String root = ZooUtil.getRoot(instance) + Constants.ZTSERVERS; zooCache.clear(root + "/" + server); }
private void waitForGCLock(Connector conn) throws InterruptedException { // Check if the GC process has the lock before wasting our retry attempts ZooKeeperInstance zki = (ZooKeeperInstance) conn.getInstance(); ZooCacheFactory zcf = new ZooCacheFactory(); ZooCache zcache = zcf.getZooCache(zki.getZooKeepers(), zki.getZooKeepersSessionTimeOut()); String zkPath = ZooUtil.getRoot(conn.getInstance()) + Constants.ZGC_LOCK; log.info("Looking for GC lock at {}", zkPath); byte[] data = ZooLock.getLockData(zcache, zkPath, null); while (null == data) { log.info("Waiting for GC ZooKeeper lock to be acquired"); Thread.sleep(1000); data = ZooLock.getLockData(zcache, zkPath, null); } }
private synchronized ZooCachePropertyAccessor getPropCacheAccessor() { if (propCacheAccessor == null) { synchronized (propCaches) { PropCacheKey key = new PropCacheKey(instance.getInstanceID(), tableId); ZooCache propCache = propCaches.get(key); if (propCache == null) { propCache = zcf.getZooCache(instance.getZooKeepers(), instance.getZooKeepersSessionTimeOut(), new TableConfWatcher(instance)); propCaches.put(key, propCache); } propCacheAccessor = new ZooCachePropertyAccessor(propCache); } } return propCacheAccessor; }
private synchronized ZooCachePropertyAccessor getPropCacheAccessor() { if (propCacheAccessor == null) { synchronized (propCaches) { PropCacheKey key = new PropCacheKey(inst.getInstanceID(), namespaceId); ZooCache propCache = propCaches.get(key); if (propCache == null) { propCache = zcf.getZooCache(inst.getZooKeepers(), inst.getZooKeepersSessionTimeOut(), new NamespaceConfWatcher(inst)); propCaches.put(key, propCache); } propCacheAccessor = new ZooCachePropertyAccessor(propCache); } } return propCacheAccessor; }