How to use

ZkPathsConfig

in

org.apache.druid.server.initialization

public CoordinatorServerViewTest()
{
 jsonMapper = TestHelper.makeJsonMapper();
 zkPathsConfig = new ZkPathsConfig();
 inventoryPath = zkPathsConfig.getLiveSegmentsPath();
}

public String getCoordinatorPath()
{
 return (null == coordinatorPath) ? defaultPath("coordinator") : coordinatorPath;
}

@Override
public boolean equals(Object other)
{
 if (null == other) {
  return false;
 }
 if (this == other) {
  return true;
 }
 if (!(other instanceof ZkPathsConfig)) {
  return false;
 }
 ZkPathsConfig otherConfig = (ZkPathsConfig) other;
 if (this.getBase().equals(otherConfig.getBase()) &&
   this.getAnnouncementsPath().equals(otherConfig.getAnnouncementsPath()) &&
   this.getConnectorPath().equals(otherConfig.getConnectorPath()) &&
   this.getLiveSegmentsPath().equals(otherConfig.getLiveSegmentsPath()) &&
   this.getCoordinatorPath().equals(otherConfig.getCoordinatorPath()) &&
   this.getLoadQueuePath().equals(otherConfig.getLoadQueuePath()) &&
   this.getPropertiesPath().equals(otherConfig.getPropertiesPath()) &&
   this.getServedSegmentsPath().equals(otherConfig.getServedSegmentsPath())) {
  return true;
 }
 return false;
}

@Inject
public BatchServerInventoryView(
  final ZkPathsConfig zkPaths,
  final CuratorFramework curator,
  final ObjectMapper jsonMapper,
  final Predicate<Pair<DruidServerMetadata, DataSegment>> defaultFilter
)
{
 super(
   log,
   zkPaths.getAnnouncementsPath(),
   zkPaths.getLiveSegmentsPath(),
   curator,
   jsonMapper,
   new TypeReference<Set<DataSegment>>()
   {
   }
 );
 this.defaultFilter = Preconditions.checkNotNull(defaultFilter);
}

@Inject
public SingleServerInventoryView(
  final ZkPathsConfig zkPaths,
  final CuratorFramework curator,
  final ObjectMapper jsonMapper,
  final Predicate<Pair<DruidServerMetadata, DataSegment>> defaultFilter
)
{
 super(
   log,
   zkPaths.getAnnouncementsPath(),
   zkPaths.getServedSegmentsPath(),
   curator,
   jsonMapper,
   new TypeReference<DataSegment>()
   {
   }
 );
 Preconditions.checkNotNull(defaultFilter);
 this.defaultFilter = defaultFilter;
}

final String loadQueueLocation = ZKPaths.makePath(zkPaths.getLoadQueuePath(), me.getName());
final String servedSegmentsLocation = ZKPaths.makePath(zkPaths.getServedSegmentsPath(), me.getName());
final String liveSegmentsLocation = ZKPaths.makePath(zkPaths.getLiveSegmentsPath(), me.getName());

public BrokerServerViewTest()
{
 jsonMapper = TestHelper.makeJsonMapper();
 zkPathsConfig = new ZkPathsConfig();
}

this.server = server;
this.liveSegmentLocation = ZKPaths.makePath(zkPaths.getLiveSegmentsPath(), server.getName());
segmentTransformer = new Function<DataSegment, DataSegment>()

 public LoadQueuePeon giveMePeon(ImmutableDruidServer server)
 {
  if ("http".equalsIgnoreCase(config.getLoadQueuePeonType())) {
   return new HttpLoadQueuePeon(server.getURL(), jsonMapper, httpClient, config, peonExec, callbackExec);
  } else {
   return new CuratorLoadQueuePeon(
     curator,
     ZKPaths.makePath(zkPaths.getLoadQueuePath(), server.getName()),
     jsonMapper,
     peonExec,
     callbackExec,
     config
   );
  }
 }
}

 private String makeAnnouncementPath()
 {
  return ZKPaths.makePath(config.getAnnouncementsPath(), server.getName());
 }
}

.addBinding(CURATOR_KEY)
.toProvider(new DruidLeaderSelectorProvider(
  (zkPathsConfig) -> ZKPaths.makePath(zkPathsConfig.getCoordinatorPath(), "_COORDINATOR"))
.toProvider(
  new DruidLeaderSelectorProvider(
    (zkPathsConfig) -> ZKPaths.makePath(zkPathsConfig.getOverlordPath(), "_OVERLORD")

@Override
public DruidNodeDiscovery getForNodeType(NodeType nodeType)
{
 Preconditions.checkState(lifecycleLock.awaitStarted(1, TimeUnit.MILLISECONDS));
 return nodeTypeWatchers.computeIfAbsent(
   nodeType,
   nType -> {
    log.info("Creating NodeTypeWatcher for nodeType [%s].", nType);
    NodeTypeWatcher nodeTypeWatcher = new NodeTypeWatcher(
      listenerExecutor,
      curatorFramework,
      config.getInternalDiscoveryPath(),
      jsonMapper,
      nType
    );
    nodeTypeWatcher.start();
    log.info("Created NodeTypeWatcher for nodeType [%s].", nType);
    return nodeTypeWatcher;
   }
 );
}

public String defaultPath(final String subPath)
{
 return ZKPaths.makePath(getBase(), subPath);
}

@Override
public boolean equals(Object o)
{
 if (this == o) {
  return true;
 }
 if (o == null || getClass() != o.getClass()) {
  return false;
 }
 IndexerZkConfig that = (IndexerZkConfig) o;
 if (announcementsPath != null
   ? !announcementsPath.equals(that.announcementsPath)
   : that.announcementsPath != null) {
  return false;
 }
 if (base != null ? !base.equals(that.base) : that.base != null) {
  return false;
 }
 if (statusPath != null ? !statusPath.equals(that.statusPath) : that.statusPath != null) {
  return false;
 }
 if (tasksPath != null ? !tasksPath.equals(that.tasksPath) : that.tasksPath != null) {
  return false;
 }
 if (zkPathsConfig != null ? !zkPathsConfig.equals(that.zkPathsConfig) : that.zkPathsConfig != null) {
  return false;
 }
 return true;
}

final String loadQueueLocation = ZKPaths.makePath(zkPaths.getLoadQueuePath(), me.getName());
final String servedSegmentsLocation = ZKPaths.makePath(zkPaths.getServedSegmentsPath(), me.getName());
final String liveSegmentsLocation = ZKPaths.makePath(zkPaths.getLiveSegmentsPath(), me.getName());

protected void setupZNodeForServer(DruidServer server, ZkPathsConfig zkPathsConfig, ObjectMapper jsonMapper)
 final String announcementsPath = zkPathsConfig.getAnnouncementsPath();
 final String inventoryPath = zkPathsConfig.getLiveSegmentsPath();

public CuratorDruidCoordinatorTest()
{
 jsonMapper = TestHelper.makeJsonMapper();
 zkPathsConfig = new ZkPathsConfig();
}

protected void announceSegmentForServer(
  DruidServer druidServer,
  DataSegment segment,
  ZkPathsConfig zkPathsConfig,
  ObjectMapper jsonMapper
)
{
 final String segmentAnnouncementPath =
   ZKPaths.makePath(zkPathsConfig.getLiveSegmentsPath(), druidServer.getHost(), segment.getId().toString());
 try {
  curator.create()
      .compressed()
      .withMode(CreateMode.EPHEMERAL)
      .forPath(segmentAnnouncementPath, jsonMapper.writeValueAsBytes(ImmutableSet.of(segment)));
 }
 catch (KeeperException.NodeExistsException e) {
  try {
   curator.setData()
       .forPath(segmentAnnouncementPath, jsonMapper.writeValueAsBytes(ImmutableSet.of(segment)));
  }
  catch (Exception e1) {
   Throwables.propagate(e1);
  }
 }
 catch (Exception e) {
  Throwables.propagate(e);
 }
}

zkCoordinator.start();
String segmentZkPath = ZKPaths.makePath(zkPaths.getLoadQueuePath(), me.getName(), segment.getId().toString());

@Inject
public SingleServerInventoryView(
  final ZkPathsConfig zkPaths,
  final CuratorFramework curator,
  final ObjectMapper jsonMapper,
  final Predicate<Pair<DruidServerMetadata, DataSegment>> defaultFilter
)
{
 super(
   log,
   zkPaths.getAnnouncementsPath(),
   zkPaths.getServedSegmentsPath(),
   curator,
   jsonMapper,
   new TypeReference<DataSegment>()
   {
   }
 );
 Preconditions.checkNotNull(defaultFilter);
 this.defaultFilter = defaultFilter;
}