Java Code Examples for org.apache.curator.utils.PathUtils#validatePath()

public void usingWatcher(ZookeeperWatcherType watcherType, String path) throws Exception {
    if (watcherType == null) {
        throw new ZookeeperException("Watcher type is null");
    }

    PathUtils.validatePath(path);

    this.watcherType = watcherType;
    this.path = path;

    switch (watcherType) {
        case EXISTS:
            usingWatcher(client.checkExists().usingWatcher(this), path);
            break;
        case GET_CHILDREN:
            usingWatcher(client.getChildren().usingWatcher(this), path);
            break;
        case GET_DATA:
            usingWatcher(client.getData().usingWatcher(this), path);
            break;
    }
}
 

@Override
/** {@inheritDoc} */
public void ensurePath(final String path, final boolean excludingLast) throws KeeperException {
  PathUtils.validatePath(path);

  assertClusterIdFlagTrue();

  final String[] parts = path.substring(1).split(Pattern.quote("/"));

  final int end = excludingLast ? parts.length - 1 : parts.length;
  String current = "";
  for (int i = 0; i < end; i++) {
    current += "/" + parts[i];
    if (exists(current) == null) {
      create(current);
    }
  }
}
 

NamespaceImpl(CuratorFrameworkImpl client, String namespace)
{
    if ( namespace != null )
    {
        try
        {
            PathUtils.validatePath("/" + namespace);
        }
        catch ( IllegalArgumentException e )
        {
            throw new IllegalArgumentException("Invalid namespace: " + namespace + ", " + e.getMessage());
        }
    }

    this.client = client;
    this.namespace = namespace;
    ensurePathNeeded = new AtomicBoolean(namespace != null);
}
 

public Stat getPathStat(String path) throws Exception {
    validateStartedStatus();
    PathUtils.validatePath(path);

    ExistsBuilder builder = client.checkExists();
    if (builder == null) {
        return null;
    }

    Stat stat = builder.forPath(path);

    return stat;
}
 

/**
 * @param client the client
 * @param path path to store queue nodes
 */
public SimpleDistributedQueue(CuratorFramework client, String path)
{
    this.client = client;
    this.path = PathUtils.validatePath(path);
    ensureContainers = new EnsureContainers(client, path);
}
 

/**
 * @param client curator client
 * @param path the full path to the node to cache
 * @param dataIsCompressed if true, data in the path is compressed
 */
public NodeCache(CuratorFramework client, String path, boolean dataIsCompressed)
{
    this.client = client.newWatcherRemoveCuratorFramework();
    this.path = PathUtils.validatePath(path);
    this.dataIsCompressed = dataIsCompressed;
}
 

@VisibleForTesting
protected SharedValue(WatcherRemoveCuratorFramework client, String path, byte[] seedValue, CuratorWatcher watcher)
{
    this.client = client;
    this.path = PathUtils.validatePath(path);
    this.seedValue = Arrays.copyOf(seedValue, seedValue.length);
    // inject watcher for testing
    this.watcher = watcher;
    currentValue = new AtomicReference<VersionedValue<byte[]>>(new VersionedValue<byte[]>(UNINITIALIZED_VERSION, Arrays.copyOf(seedValue, seedValue.length)));
}
 

public void createPath(String path, Serializable object, CreateMode mode) throws Exception {
    validateStartedStatus();
    PathUtils.validatePath(path);

    byte[] data = getData(object);

    client.create().creatingParentsIfNeeded().withMode(mode).forPath(path, data);
}
 

/**
 * @param client curztor client
 * @param path the full path to the node to cache
 * @param dataIsCompressed if true, data in the path is compressed
 */
public NodeCache(CuratorFramework client, String path, boolean dataIsCompressed)
{
    this.client = client;
    this.path = PathUtils.validatePath(path);
    this.dataIsCompressed = dataIsCompressed;
}
 

public ChildData(String path, Stat stat, byte[] data)
{
    this.path = PathUtils.validatePath(path);
    this.stat = stat;
    this.data = data;
}
 

QueueSafety(String lockPath, BlockingQueue<T> queue)
{
    this.lockPath = PathUtils.validatePath(lockPath);
    this.consumer = null;
    this.queue = queue;
}
 

public void createPath(String path) throws Exception {
    validateStartedStatus();
    PathUtils.validatePath(path);

    client.create().creatingParentsIfNeeded().forPath(path, null);
}
 

public void setPath(String path) {
    this.path = PathUtils.validatePath(path);
}
 

GetDataOperation(PathChildrenCache cache, String fullPath)
{
    this.cache = cache;
    this.fullPath = PathUtils.validatePath(fullPath);
}
 

public void createPath(String path, byte[] data, CreateMode mode) throws Exception {
    validateStartedStatus();
    PathUtils.validatePath(path);

    client.create().creatingParentsIfNeeded().withMode(mode).forPath(path, data);
}
 

Advertiser(CuratorFramework client, String groupPath, String memberToken) {
  this.client = requireNonNull(client);
  this.groupPath = PathUtils.validatePath(groupPath);
  this.memberToken = MorePreconditions.checkNotBlank(memberToken);
}
 

/**
 * Creates in mutex promotion mode. The optimistic lock will be tried first using
 * the given retry policy. If the increment does not succeed, a {@link InterProcessMutex} will be tried
 * with its own retry policy
 *
 * @param client the client
 * @param path path to hold the value
 * @param retryPolicy the retry policy to use
 * @param promotedToLock the arguments for the mutex promotion
 */
public DistributedAtomicValue(CuratorFramework client, String path, RetryPolicy retryPolicy, PromotedToLock promotedToLock)
{
    this.client = client;
    this.path = PathUtils.validatePath(path);
    this.retryPolicy = retryPolicy;
    this.promotedToLock = promotedToLock;
    mutex = (promotedToLock != null) ? new InterProcessMutex(client, promotedToLock.getPath()) : null;
}
 

/**
 * Creates a {@code SingletonService} backed by Curator.
 *
 * @param client A client to interact with a ZooKeeper ensemble.
 * @param groupPath The root ZooKeeper path service members advertise their presence under.
 * @param memberToken A token used to form service member node names.
 */
CuratorSingletonService(CuratorFramework client, String groupPath, String memberToken) {
  advertiser = new Advertiser(client, groupPath, memberToken);
  this.client = client;
  this.groupPath = PathUtils.validatePath(groupPath);
}
 

/**
 * Set the path for the mutex lock (required)
 *
 * @param path path
 * @return this
 */
public Builder          lockPath(String path)
{
    instance = new PromotedToLock(PathUtils.validatePath(path), instance.maxLockTime, instance.maxLockTimeUnit, instance.retryPolicy);
    return this;
}
 

/**
 * <p>Without a lock set, queue items are removed before being sent to the queue consumer. This can result in message
 * loss if the consumer fails to complete the message or the process dies.</p>
 *
 * <p>Use a lock to make the message recoverable. A lock is held while
 * the message is being processed - this prevents other processes from taking the message. The message will not be removed
 * from the queue until the consumer functor returns. Thus, if there is a failure or the process dies,
 * the message will get sent to another process. There is a small performance penalty for this behavior however.
 *
 * @param path path for the lock
 * @return this
 */
public QueueBuilder<T>  lockPath(String path)
{
    lockPath = PathUtils.validatePath(path);
    return this;
}