How to use

NodeRole

in

org.batfish.role

 /**
  * Gets a {@link NodeRole} object from this bean.
  *
  * <p>Name and regex may be null in the bean. Error handling happens inside the NodeRole
  * constructor.
  */
 public NodeRole toNodeRole() {
  return new NodeRole(name, regex);
 }
}

/** Does this nodeName match any of roles that match our _regex? */
private boolean nodeNameInMatchingRole(String nodeName, Set<NodeRole> roles) {
 for (NodeRole role : roles) {
  if (_regex.matcher(role.getName()).matches() && role.matches(nodeName)) {
   return true;
  }
 }
 return false;
}

/**
 * Instantiate this bean from {@code role} and picking the subset of nodes in {@code fromNodes}
 * that match it.
 */
public NodeRoleBean(NodeRole role, Set<String> fromNodes) {
 name = role.getName();
 regex = role.getRegex();
 nodes = fromNodes.stream().filter(role::matches).collect(ImmutableSet.toImmutableSet());
}

 @Test
 public void matches() {
  NodeRole role = new NodeRole("hello", "a.*");

  assertThat(role.matches("a1"), equalTo(true));
  assertThat(role.matches("b1"), equalTo(false));
 }
}

List<AutocompleteSuggestion> roleSuggestions =
  dimension.getRoles().stream()
    .filter(role -> role.getName().startsWith(rolePrefix))
    .map(
      role ->
        new AutocompleteSuggestion(
          "ROLE:" + dimension.getName() + ":" + role.getName(),
          false,
          "All nodes that belong to this role"))

 @Test
 public void toNodeRole() {
  NodeRoleBean roleBean =
    new NodeRoleBean(new NodeRole("name", "a.*"), ImmutableSet.of("a", "b"));
  NodeRole role = roleBean.toNodeRole();

  assertThat(role, equalTo(new NodeRole("name", "a.*")));
 }
}

/**
 * Create a map from each node name to its set of roles
 *
 * @param nodeNames The universe of nodes that we need to classify
 * @return The created map
 */
public SortedMap<String, SortedSet<String>> createNodeRolesMap(Set<String> nodeNames) {
 SortedMap<String, SortedSet<String>> nodeRolesMap = new TreeMap<>();
 for (String node : nodeNames) {
  for (NodeRole role : _roles) {
   if (role.matches(node)) {
    SortedSet<String> nodeRoles = nodeRolesMap.computeIfAbsent(node, k -> new TreeSet<>());
    nodeRoles.add(role.getName());
   }
  }
 }
 return nodeRolesMap;
}

/** Checks if we properly populate the nodes field */
@Test
public void constructor() {
 NodeRoleBean role = new NodeRoleBean(new NodeRole("name", "a.*"), ImmutableSet.of("a", "b"));
 assertThat(role.nodes, equalTo(ImmutableSet.of("a")));
}

/**
 * Create a map from each role name to the set of nodes that play that role
 *
 * @param nodeNames The universe of nodes that we need to classify
 * @return The created map
 */
public SortedMap<String, SortedSet<String>> createRoleNodesMap(Set<String> nodeNames) {
 SortedMap<String, SortedSet<String>> roleNodesMap = new TreeMap<>();
 for (NodeRole role : _roles) {
  for (String node : nodeNames) {
   if (role.matches(node)) {
    SortedSet<String> roleNodes =
      roleNodesMap.computeIfAbsent(role.getName(), k -> new TreeSet<>());
    roleNodes.add(node);
   }
  }
 }
 return roleNodesMap;
}

private NodeRoleDimension regexToNodeRoleDimension(String regex, String dimName) {
 SortedSet<NodeRole> inferredRoles = new TreeSet<>();
 Set<String> roles = regexToRoleNodesMap(regex, _nodes).keySet();
 for (String role : roles) {
  inferredRoles.add(new NodeRole(role, specializeRegexForRole(role, regex), _caseSensitive));
 }
 return NodeRoleDimension.builder()
   .setName(dimName)
   .setRoles(inferredRoles)
   .setType(Type.AUTO)
   .setRoleRegexes(ImmutableList.of(regex))
   .build();
}

 @Override
 public Set<String> resolve(SpecifierContext ctxt) {
  Optional<NodeRoleDimension> dimension = ctxt.getNodeRoleDimension(_roleDimension);
  Set<NodeRole> roles =
    dimension.isPresent()
      ? dimension.get().getRoles().stream()
        .filter(role -> _rolePattern.matcher(role.getName()).matches())
        .collect(ImmutableSet.toImmutableSet())
      : ImmutableSet.of();

  return ctxt.getConfigs().keySet().stream()
    .filter(node -> roles.stream().anyMatch(role -> role.matches(node)))
    .collect(ImmutableSet.toImmutableSet());
 }
}

    .build();
NodeRole role1 = new NodeRole("match1", "lhr-border.*");
NodeRole role2 = new NodeRole("match2", "svr-border.*");
NodeRole role3 = new NodeRole("dumb0", "lhr-core.*");
SortedSet<NodeRole> roles =
  new ImmutableSortedSet.Builder<>(NodeRole::compareTo)

 @Override
 public Set<Location> resolve(SpecifierContext ctxt) {
  Optional<NodeRoleDimension> dimension = ctxt.getNodeRoleDimension(_roleDimension);
  Set<NodeRole> matchingRoles =
    dimension.isPresent()
      ? dimension.get().getRoles().stream()
        .filter(role -> _rolePattern.matcher(role.getName()).matches())
        .collect(ImmutableSet.toImmutableSet())
      : ImmutableSet.of();

  return ctxt.getConfigs().values().stream()
    .filter(node -> matchingRoles.stream().anyMatch(role -> role.matches(node.getHostname())))
    .flatMap(this::getNodeLocations)
    .collect(ImmutableSet.toImmutableSet());
 }
}

@Test
public void testProperties() {
 String snapshot = "snapshot1";
 String dimension = "someDimension";
 String role = "someRole";
 Set<String> nodes = ImmutableSet.of("a", "b");
 NodeRole nodeRole = new NodeRole(role, "a.*");
 NodeRoleDimension nodeRoleDimension =
   NodeRoleDimension.builder()
     .setName(dimension)
     .setRoles(ImmutableSortedSet.of(nodeRole))
     .build();
 NodeRoleDimensionBean bean = new NodeRoleDimensionBean(nodeRoleDimension, snapshot, nodes);
 assertThat(bean.name, equalTo(dimension));
 assertThat(bean.roles, equalTo(ImmutableSet.of(new NodeRoleBean(nodeRole, nodes))));
 assertThat(bean.snapshot, equalTo(snapshot));
 assertThat(bean.type, equalTo(NodeRoleDimension.Type.CUSTOM));
}

@Test
public void testPutNodeRolesDuplicateDimensions() {
 String network = "someContainer";
 Main.getWorkMgr().initNetwork(network, null);
 String name = "auto0";
 NodeRolesDataBean nodeRolesDataBean =
   new NodeRolesDataBean(
     NodeRolesData.builder()
       .setRoleDimensions(
         ImmutableSortedSet.of(
           NodeRoleDimension.builder()
             .setName(name)
             .setRoles(ImmutableSortedSet.of(new NodeRole("foo", "bar")))
             .build(),
           NodeRoleDimension.builder().setName(name).build()))
       .build(),
     null,
     ImmutableSet.of());
 Response response =
   getNodeRolesTarget(network)
     .put(Entity.entity(nodeRolesDataBean, MediaType.APPLICATION_JSON));
 assertThat(response.getStatus(), equalTo(BAD_REQUEST.getStatusCode()));
}

@Test
public void testNoDuplicateDimensionsSameName() {
 String name = "auto0";
 NodeRolesDataBean nodeRolesDataBean =
   new NodeRolesDataBean(
     NodeRolesData.builder()
       .setRoleDimensions(
         ImmutableSortedSet.of(
           NodeRoleDimension.builder()
             .setName(name)
             .setRoles(ImmutableSortedSet.of(new NodeRole("foo", "bar")))
             .build(),
           NodeRoleDimension.builder().setName(name).build()))
       .build(),
     null,
     ImmutableSet.of());
 assertThat(noDuplicateDimensions(nodeRolesDataBean), equalTo(false));
}

 @Test
 public void testProperties() throws IOException {
  String snapshot = "snapshot1";
  String dimension = "someDimension";
  String role = "someRole";
  Set<String> nodes = ImmutableSet.of("a", "b");
  NodeRole nodeRole = new NodeRole(role, "a.*");
  NodeRoleDimension nodeRoleDimension =
    NodeRoleDimension.builder()
      .setName(dimension)
      .setRoles(ImmutableSortedSet.of(nodeRole))
      .build();
  NodeRolesData data =
    NodeRolesData.builder().setRoleDimensions(ImmutableSortedSet.of(nodeRoleDimension)).build();
  NodeRolesDataBean bean = new NodeRolesDataBean(data, snapshot, nodes);

  assertThat(
    bean.roleDimensions,
    equalTo(ImmutableSet.of(new NodeRoleDimensionBean(nodeRoleDimension, snapshot, nodes))));
  assertThat(bean.defaultDimension, nullValue());
 }
}

private NodeRolesData initNodeRoleData() {
 NodeRoleDimension dim1 =
   NodeRoleDimension.builder()
     .setName("dim10")
     .setRoles(
       new ImmutableSortedSet.Builder<>(NodeRole::compareTo)
         .add(new NodeRole("role1", ".*"))
         .add(new NodeRole("role2", ".*"))
         .build())
     .build();
 NodeRoleDimension dim2 =
   NodeRoleDimension.builder()
     .setName("dim20")
     .setRoles(
       new ImmutableSortedSet.Builder<>(NodeRole::compareTo)
         .add(new NodeRole("role1", ".*"))
         .add(new NodeRole("role2", ".*"))
         .build())
     .build();
 SortedSet<NodeRoleDimension> roleDimensions =
   new ImmutableSortedSet.Builder<>(NodeRoleDimension::compareTo).add(dim1).add(dim2).build();
 return NodeRolesData.builder().setRoleDimensions(roleDimensions).build();
}

@Test
public void testGetNetworkNodeRolesGoodSnapshot() throws IOException {
 String network = "network1";
 String snapshot = "snapshot1";
 String node = "node1";
 _manager.initNetwork(network, null);
 NetworkId networkId = _idManager.getNetworkId(network);
 WorkMgrTestUtils.uploadTestSnapshot(network, snapshot, node, _folder);
 SnapshotId snapshotId = _idManager.getSnapshotId(snapshot, networkId);
 NodeRolesId snapshotNodeRolesId = _idManager.getSnapshotNodeRolesId(networkId, snapshotId);
 NodeRolesData snapshotInferredNodeRoles =
   NodeRolesData.builder()
     .setRoleDimensions(
       ImmutableSortedSet.of(
         NodeRoleDimension.builder()
           .setName("dim1")
           .setRoles(ImmutableSet.of(new NodeRole("role1", node)))
           .build()))
     .build();
 _manager.getStorage().storeNodeRoles(snapshotInferredNodeRoles, snapshotNodeRolesId);
 SnapshotMetadataMgr.updateInitializationStatus(
   networkId, snapshotId, ProcessingStatus.PARSED, null);
 // inferred roles for first snapshot should have been set network-wide
 assertThat(_manager.getNetworkNodeRoles(network), equalTo(snapshotInferredNodeRoles));
}

@Test
public void testGetNetworkNodeRolesNoGoodSnapshots() throws IOException {
 String network = "network1";
 String snapshot = "snapshot1";
 String node = "node1";
 _manager.initNetwork(network, null);
 NetworkId networkId = _idManager.getNetworkId(network);
 WorkMgrTestUtils.uploadTestSnapshot(network, snapshot, node, _folder);
 SnapshotId snapshotId = _idManager.getSnapshotId(snapshot, networkId);
 NodeRolesId snapshotNodeRolesId = _idManager.getSnapshotNodeRolesId(networkId, snapshotId);
 NodeRolesData snapshotInferredNodeRoles =
   NodeRolesData.builder()
     .setRoleDimensions(
       ImmutableSortedSet.of(
         NodeRoleDimension.builder()
           .setName("dim1")
           .setRoles(ImmutableSet.of(new NodeRole("role1", node)))
           .build()))
     .build();
 _manager.getStorage().storeNodeRoles(snapshotInferredNodeRoles, snapshotNodeRolesId);
 SnapshotMetadataMgr.updateInitializationStatus(
   networkId, snapshotId, ProcessingStatus.PARSING_FAIL, null);
 // should return empty node roles since snapshot parsing failed
 assertThat(_manager.getNetworkNodeRoles(network), equalTo(NodeRolesData.builder().build()));
}