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); }
/** * Gets a {@link ZooCache}. The same object may be returned for multiple calls with the same * arguments. * * @param zooKeepers * comma-separated list of ZooKeeper host[:port]s * @param sessionTimeout * session timeout * @return cache object */ public ZooCache getZooCache(String zooKeepers, int sessionTimeout) { String key = zooKeepers + ":" + sessionTimeout; synchronized (instances) { if (!isEnabled()) { throw new IllegalStateException("\"The Accumulo singleton for zookeeper caching is " + "disabled. This is likely caused by all AccumuloClients being closed"); } ZooCache zc = instances.get(key); if (zc == null) { zc = new ZooCache(zooKeepers, sessionTimeout); instances.put(key, zc); } return zc; } }
/** * 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); }
/** * @param config * Client configuration for specifying connection options. See * {@link ClientConfiguration} which extends Configuration with convenience methods * specific to Accumulo. * @since 1.9.0 */ public ZooKeeperInstance(ClientConfiguration config) { this(config, new ZooCacheFactory()); }
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; }
/** * @param config * Client configuration for specifying connection options. See * {@link ClientConfiguration} which extends Configuration with convenience methods * specific to Accumulo. * @since 1.9.0 */ public ZooKeeperInstance(ClientConfiguration config) { this(config, new ZooCacheFactory()); }
/** * 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); } }
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; }
ZookeeperLockChecker(Instance instance) { this(instance, new ZooCacheFactory()); }
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"); } }
public void process(WatchedEvent arg0) {} }; propCache = zcf.getZooCache(context.getZooKeepers(), context.getZooKeepersSessionTimeOut(), watcher); config = new ZooConfiguration(context, propCache, parent);
RootTabletLocator(TabletServerLockChecker lockChecker) { this(lockChecker, new ZooCacheFactory()); }
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)); }
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(); } }
/** * @param config * Client configuration for specifying connection options. See * {@link ClientConfiguration} which extends Configuration with convenience methods * specific to Accumulo. * @since 1.6.0 * @deprecated since 1.9.0; will be removed in 2.0.0 to eliminate commons config leakage into * Accumulo API; use {@link #ZooKeeperInstance(ClientConfiguration)} instead. */ @Deprecated public ZooKeeperInstance(Configuration config) { this(config, new ZooCacheFactory()); }
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); }
/** * Gets a configuration object for the given instance with the given parent. Repeated calls will * return the same object. * * @param inst * instance; if null, instance is determined from HDFS * @param parent * parent configuration (required) * @return configuration */ public ZooConfiguration getInstance(Instance inst, AccumuloConfiguration parent) { return getInstance(inst, new ZooCacheFactory(), parent); } }
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); }
ZookeeperLockChecker(Instance instance, ZooCacheFactory zcf) { zc = zcf.getZooCache(instance.getZooKeepers(), instance.getZooKeepersSessionTimeOut()); this.root = ZooUtil.getRoot(instance) + Constants.ZTSERVERS; }