io.scalecube.services.registry.ServiceRegistryImpl Maven / Gradle / Ivy

Go to download
package io.scalecube.services.registry;

import io.scalecube.services.ServiceEndpoint;
import io.scalecube.services.ServiceReference;
import io.scalecube.services.registry.api.ServiceRegistry;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class ServiceRegistryImpl implements ServiceRegistry {

  private final ConcurrentMap serviceEndpoints = new ConcurrentHashMap<>();

  @Override
  public List listServiceEndpoints() {
    return new ArrayList<>(serviceEndpoints.values());
  }

  @Override
  public List listServiceReferences() {
    return serviceReferenceStream().collect(Collectors.toList());
  }

  @Override
  public List lookupService(String namespace) {
    return lookupService(r -> namespace.equalsIgnoreCase(r.namespace()));
  }

  @Override
  public List lookupService(Predicate filter) {
    // Convert to stream of service references
    Stream stream = serviceReferenceStream();

    // Filter by filter
    if (filter != null) {
      stream = stream.filter(filter);
    }

    // Collect results
    return stream.collect(Collectors.toList());
  }

  @Override
  public boolean registerService(ServiceEndpoint serviceEndpoint) {
    return serviceEndpoints.putIfAbsent(serviceEndpoint.id(), serviceEndpoint) == null;
  }

  @Override
  public ServiceEndpoint unregisterService(String endpointId) {
    return serviceEndpoints.remove(endpointId);
  }

  private Stream serviceReferenceStream() {
    return serviceEndpoints.values().stream().flatMap(
        se -> se.serviceRegistrations().stream().flatMap(
            sr -> sr.methods().stream().map(
                sm -> new ServiceReference(sm, sr, se))));
  }
}