How to use

com.netflix.spinnaker.halyard.config.model.v1.node.NodeFilter

constructor

 public ProblemSet validateDeploymentShallow(String deploymentName) {
  NodeFilter filter = new NodeFilter()
    .setDeployment(deploymentName);

  return validateService.validateMatchingFilter(filter);
 }
}

 public ProblemSet validatePersistentStore(String deploymentName, String persistentStoreType) {
  NodeFilter filter = new NodeFilter()
    .setDeployment(deploymentName)
    .setPersistentStore(persistentStoreType);

  return validateService.validateMatchingFilter(filter);
 }
}

 public ProblemSet validateAllNotifications(String deploymentName) {
  NodeFilter filter = new NodeFilter()
    .setDeployment(deploymentName)
    .withAnyNotification();

  return validateService.validateMatchingFilter(filter);
 }
}

 public ProblemSet validateDeploymentEnvironment(String deploymentName) {
  NodeFilter filter = new NodeFilter()
    .setDeployment(deploymentName)
    .setDeploymentEnvironment();

  return validateService.validateMatchingFilter(filter);
 }
}

 public ProblemSet validateFeatures(String deploymentName) {
  NodeFilter filter = new NodeFilter().setDeployment(deploymentName).setFeatures();
  return validateService.validateMatchingFilter(filter);
 }
}

 public ProblemSet validateAllArtifactProviders(String deploymentName) {
  NodeFilter filter = new NodeFilter()
    .setDeployment(deploymentName)
    .withAnyArtifactProvider()
    .withAnyAccount();

  return validateService.validateMatchingFilter(filter);
 }
}

public Security getSecurity(String deploymentName) {
 NodeFilter filter = new NodeFilter().setDeployment(deploymentName).setSecurity();
 return lookupService.getSingularNodeOrDefault(filter,
   Security.class,
   Security::new,
   n -> setSecurity(deploymentName, n));
}

 public ProblemSet validateMetricStore(String deploymentName, String metricStoreType) {
  NodeFilter filter = new NodeFilter().setDeployment(deploymentName).setMetricStores().setMetricStore(metricStoreType);
  return validateService.validateMatchingFilter(filter);
 }
}

public ProblemSet validateCi(String deploymentName, String ciName) {
 NodeFilter filter = new NodeFilter()
   .setDeployment(deploymentName)
   .setCi(ciName)
   .withAnyAccount();
 return validateService.validateMatchingFilter(filter);
}

 public ProblemSet validateAllMasters(String deploymentName, String ciName) {
  NodeFilter filter = new NodeFilter().setDeployment(deploymentName).setCi(ciName).withAnyMaster();
  return validateService.validateMatchingFilter(filter);
 }
}

public ProblemSet validateHaService(String deploymentName, String serviceName) {
 NodeFilter filter = new NodeFilter()
   .setDeployment(deploymentName)
   .setDeploymentEnvironment()
   .setHaService(serviceName);
 return validateService.validateMatchingFilter(filter);
}

 public ProblemSet validateAllHaServices(String deploymentName) {
  NodeFilter filter = new NodeFilter()
    .setDeployment(deploymentName)
    .setDeploymentEnvironment()
    .withAnyHaService();

  return validateService.validateMatchingFilter(filter);
 }
}

 public ProblemSet validateRoleProvider(String deploymentName, String roleProviderName) {
  NodeFilter filter = new NodeFilter().setDeployment(deploymentName).setSecurity().setRoleProvider(roleProviderName);
  return validateService.validateMatchingFilter(filter);
 }
}

public List<ArtifactProvider> getAllArtifactProviders(String deploymentName) {
 NodeFilter filter = new NodeFilter().setDeployment(deploymentName).withAnyArtifactProvider();
 List<ArtifactProvider> matching = lookupService.getMatchingNodesOfType(filter, ArtifactProvider.class);
 if (matching.size() == 0) {
  throw new ConfigNotFoundException(
    new ConfigProblemBuilder(Severity.FATAL, "No providers could be found")
      .build());
 } else {
  return matching;
 }
}

public List<Account> getAllAccounts(String deploymentName, String providerName) {
 NodeFilter filter = new NodeFilter().setDeployment(deploymentName).setProvider(providerName).withAnyAccount();
 List<Account> matchingAccounts = lookupService.getMatchingNodesOfType(filter, Account.class);
 if (matchingAccounts.size() == 0) {
  throw new ConfigNotFoundException(
    new ConfigProblemBuilder(Severity.FATAL, "No accounts could be found").build());
 } else {
  return matchingAccounts;
 }
}

public List<Subscription> getAllSubscriptions(String deploymentName, String pubsubName) {
 NodeFilter filter = new NodeFilter().setDeployment(deploymentName).setPubsub(pubsubName).withAnySubscription();
 List<Subscription> matchingSubscriptions = lookupService.getMatchingNodesOfType(filter, Subscription.class);
 if (matchingSubscriptions.size() == 0) {
  throw new ConfigNotFoundException(
    new ConfigProblemBuilder(Severity.FATAL, "No subscriptions could be found").build());
 } else {
  return matchingSubscriptions;
 }
}

public List<ArtifactAccount> getAllArtifactAccounts(String deploymentName, String providerName) {
 NodeFilter filter = new NodeFilter().setDeployment(deploymentName).setArtifactProvider(providerName).withAnyArtifactAccount();
 List<ArtifactAccount> matchingArtifactAccounts = lookupService.getMatchingNodesOfType(filter, ArtifactAccount.class);
 if (matchingArtifactAccounts.size() == 0) {
  throw new ConfigNotFoundException(
    new ConfigProblemBuilder(Severity.FATAL, "No accounts could be found").build());
 } else {
  return matchingArtifactAccounts;
 }
}

public ProblemSet validateProvider(String deploymentName, String providerName) {
 NodeFilter filter = new NodeFilter()
   .setDeployment(deploymentName)
   .setProvider(providerName)
   .withAnyAccount()
   .setBakeryDefaults()
   .withAnyBaseImage();
 return validateService.validateMatchingFilter(filter);
}

public ProblemSet validatePubsub(String deploymentName, String pubsubName) {
 NodeFilter filter = new NodeFilter()
   .setDeployment(deploymentName)
   .setPubsub(pubsubName)
   .withAnySubscription()
   .setBakeryDefaults()
   .withAnyBaseImage();
 return validateService.validateMatchingFilter(filter);
}

 public HasClustersProvider getHasClustersProvider(String deploymentName, String providerName) {
  NodeFilter filter = new NodeFilter().setDeployment(deploymentName).setProvider(providerName);
  Provider provider = getProvider(deploymentName, providerName);
  if (provider instanceof HasClustersProvider) {
   return (HasClustersProvider) provider;
  } else {
   throw new IllegalConfigException(new ConfigProblemBuilder(Severity.FATAL,
     "Provider \"" + providerName + "\" does not support configuring clusters via Halyard.").build());
  }
 }
}