[grid] Rename NodeStatus id and uri field for serialization

Author: pujagani

java/server/src/org/openqa/selenium/grid/data/NodeStatus.java

@@ -21,7 +21,11 @@
 import org.openqa.selenium.internal.Require;
 import org.openqa.selenium.json.JsonInput;
 import org.openqa.selenium.json.TypeToken;
+import org.redisson.api.annotation.REntity;
+import org.redisson.api.annotation.RId;
+import org.redisson.api.annotation.RIndex;
 
+import java.io.Serializable;
 import java.net.URI;
 import java.time.Duration;
 import java.time.Instant;
@@ -34,18 +38,24 @@
 import static java.util.Collections.unmodifiableMap;
 import static java.util.Collections.unmodifiableSet;
 
+@REntity
 public class NodeStatus {
 
-  private final NodeId nodeId;
-  private final URI externalUri;
-  private final int maxSessionCount;
-  private final Set<Slot> slots;
-  private final Availability availability;
+  @RId
+  private NodeId nodeId;
+
+  private URI externalUri;
+  private int maxSessionCount;
+  private Set<Slot> slots;
+  private Availability availability;
   private Duration heartbeatPeriod;
-  private final String version;
-  private final Map<String, String> osInfo;
+  private String version;
+  private Map<String, String> osInfo;
   private long touched = System.currentTimeMillis();
 
+  public NodeStatus() {
+  }
+
   public NodeStatus(
     NodeId nodeId,
     URI externalUri,
@@ -69,7 +79,7 @@ public NodeStatus(
 
   public static NodeStatus fromJson(JsonInput input) {
     NodeId nodeId = null;
-    URI uri = null;
+    URI externalUri = null;
     int maxSessions = 0;
     Set<Slot> slots = null;
     Availability availability = null;
@@ -88,7 +98,7 @@ public static NodeStatus fromJson(JsonInput input) {
           heartbeatPeriod = Duration.ofMillis(input.read(Long.class));
           break;
 
-        case "id":
+        case "nodeId":
           nodeId = input.read(NodeId.class);
           break;
 
@@ -101,8 +111,8 @@ public static NodeStatus fromJson(JsonInput input) {
           }.getType());
           break;
 
-        case "uri":
-          uri = input.read(URI.class);
+        case "externalUri":
+          externalUri = input.read(URI.class);
           break;
 
         case "version":
@@ -122,7 +132,7 @@ public static NodeStatus fromJson(JsonInput input) {
 
     return new NodeStatus(
       nodeId,
-      uri,
+      externalUri,
       maxSessions,
       slots,
       availability,
@@ -136,56 +146,100 @@ public boolean hasCapability(Capabilities caps) {
   }
 
   public boolean hasCapacity() {
-    return slots.stream().anyMatch(slot -> !slot.getSession().isPresent());
+    return slots.stream().anyMatch(slot -> slot.getSession() == null);
   }
 
   public boolean hasCapacity(Capabilities caps) {
     return slots.stream()
-      .anyMatch(slot -> !slot.getSession().isPresent() && slot.isSupporting(caps));
+      .anyMatch(slot -> slot.getSession() == null && slot.isSupporting(caps));
+  }
+
+  public int getMaxSessionCount() {
+    return maxSessionCount;
+  }
+
+  public void setMaxSessionCount(int maxSessionCount) {
+    this.maxSessionCount = maxSessionCount;
   }
 
-  public NodeId getId() {
+  public NodeId getNodeId() {
     return nodeId;
   }
 
-  public URI getUri() {
+  public void setNodeId(NodeId nodeId) {
+    this.nodeId = nodeId;
+  }
+
+  public URI getExternalUri() {
     return externalUri;
   }
 
-  public int getMaxSessionCount() {
-    return maxSessionCount;
+  public void setExternalUri(URI externalUri) {
+    this.externalUri = externalUri;
   }
 
   public Set<Slot> getSlots() {
     return slots;
   }
 
+  public void setSlots(Set<Slot> slots) {
+    this.slots = slots;
+  }
+
   public Availability getAvailability() {
     return availability;
   }
 
+  public void setAvailability(Availability availability) {
+    this.availability = availability;
+  }
+
+  public Duration getHeartbeatPeriod() {
+    return heartbeatPeriod;
+  }
+
+  public void setHeartbeatPeriod(Duration heartbeatPeriod) {
+    this.heartbeatPeriod = heartbeatPeriod;
+  }
+
   public String getVersion() {
     return version;
   }
 
+  public void setVersion(String version) {
+    this.version = version;
+  }
+
   public Map<String, String> getOsInfo() {
     return osInfo;
   }
 
+  public void setOsInfo(Map<String, String> osInfo) {
+    this.osInfo = osInfo;
+  }
+
+  public long getTouched() {
+    return touched;
+  }
+
+  public void setTouched(long touched) {
+    this.touched = touched;
+  }
+
   public float getLoad() {
     float inUse = slots.parallelStream()
-      .filter(slot -> slot.getSession().isPresent())
+      .filter(slot -> slot.getSession() != null)
       .count();
 
     return (inUse / (float) maxSessionCount) * 100f;
   }
 
   public long getLastSessionCreated() {
-      return slots.parallelStream()
-        .map(Slot::getLastStarted)
-        .mapToLong(Instant::toEpochMilli)
-        .max()
-        .orElse(0);
+    return slots.parallelStream()
+      .map(Slot::getLastStarted)
+      .mapToLong(Instant::toEpochMilli)
+      .max()
+      .orElse(0);
   }
 
   public Duration heartbeatPeriod() {
@@ -208,11 +262,11 @@ public boolean equals(Object o) {
 
     NodeStatus that = (NodeStatus) o;
     return Objects.equals(this.nodeId, that.nodeId) &&
-           Objects.equals(this.externalUri, that.externalUri) &&
-           this.maxSessionCount == that.maxSessionCount &&
-           Objects.equals(this.slots, that.slots) &&
-           Objects.equals(this.availability, that.availability) &&
-           Objects.equals(this.version, that.version);
+      Objects.equals(this.externalUri, that.externalUri) &&
+      this.maxSessionCount == that.maxSessionCount &&
+      Objects.equals(this.slots, that.slots) &&
+      Objects.equals(this.availability, that.availability) &&
+      Objects.equals(this.version, that.version);
   }
 
   @Override
@@ -222,8 +276,8 @@ public int hashCode() {
 
   private Map<String, Object> toJson() {
     Map<String, Object> toReturn = new TreeMap<>();
-    toReturn.put("id", nodeId);
-    toReturn.put("uri", externalUri);
+    toReturn.put("nodeId", nodeId);
+    toReturn.put("externalUri", externalUri);
     toReturn.put("maxSessions", maxSessionCount);
     toReturn.put("slots", slots);
     toReturn.put("availability", availability);

java/server/src/org/openqa/selenium/grid/distributor/AddNode.java

@@ -62,8 +62,8 @@ public HttpResponse execute(HttpRequest req) {
     Node node = new RemoteNode(
         tracer,
         httpFactory,
-        status.getId(),
-        status.getUri(),
+        status.getNodeId(),
+        status.getExternalUri(),
         registrationSecret,
         status.getSlots().stream().map(Slot::getStereotype).collect(Collectors.toSet()));
 

java/server/src/org/openqa/selenium/grid/distributor/gridmodel/local/LocalGridModel.java

@@ -54,7 +54,6 @@
 public class LocalGridModel implements GridModel {
 
   private static final Logger LOG = Logger.getLogger(LocalGridModel.class.getName());
-  private static final SessionId RESERVED = new SessionId("reserved");
   private final ReadWriteLock lock = new ReentrantReadWriteLock(/* fair */ true);
   private final Map<Availability, Set<NodeStatus>> nodes = new ConcurrentHashMap<>();
   private final EventBus events;
@@ -86,8 +85,8 @@ public void add(NodeStatus node) {
           NodeStatus next = iterator.next();
 
           // If the ID is the same, we're re-adding a node. If the URI is the same a node probably restarted
-          if (next.getId().equals(node.getId()) || next.getUri().equals(node.getUri())) {
-            LOG.info(String.format("Re-adding node with id %s and URI %s.", node.getId(), node.getUri()));
+          if (next.getNodeId().equals(node.getNodeId()) || next.getExternalUri().equals(node.getExternalUri())) {
+            LOG.info(String.format("Re-adding node with id %s and URI %s.", node.getNodeId(), node.getExternalUri()));
             iterator.remove();
           }
         }
@@ -107,7 +106,7 @@ public void refresh(NodeStatus status) {
     Lock writeLock = lock.writeLock();
     writeLock.lock();
     try {
-      AvailabilityAndNode availabilityAndNode = findNode(status.getId());
+      AvailabilityAndNode availabilityAndNode = findNode(status.getNodeId());
 
       if (availabilityAndNode == null) {
         return;
@@ -181,7 +180,7 @@ public void purgeDeadNodes() {
         LOG.info(String.format(
           "Switching nodes %s from UP to DOWN",
           lost.stream()
-            .map(node -> String.format("%s (uri: %s)", node.getId(), node.getUri()))
+            .map(node -> String.format("%s (uri: %s)", node.getNodeId(), node.getExternalUri()))
             .collect(joining(", "))));
         nodes(UP).removeAll(lost);
         nodes(DOWN).addAll(lost);
@@ -190,7 +189,7 @@ public void purgeDeadNodes() {
         LOG.info(String.format(
           "Switching nodes %s from DOWN to UP",
           resurrected.stream()
-            .map(node -> String.format("%s (uri: %s)", node.getId(), node.getUri()))
+            .map(node -> String.format("%s (uri: %s)", node.getNodeId(), node.getExternalUri()))
             .collect(joining(", "))));
         nodes(DOWN).removeAll(resurrected);
         nodes(UP).addAll(resurrected);
@@ -199,7 +198,7 @@ public void purgeDeadNodes() {
         LOG.info(String.format(
           "Removing nodes %s that are DOWN for too long",
           dead.stream()
-            .map(node -> String.format("%s (uri: %s)", node.getId(), node.getUri()))
+            .map(node -> String.format("%s (uri: %s)", node.getNodeId(), node.getExternalUri()))
             .collect(joining(", "))));
         nodes(DOWN).removeAll(dead);
       }
@@ -232,7 +231,7 @@ public Availability setAvailability(NodeId id, Availability availability) {
       LOG.info(String.format(
         "Switching node %s (uri: %s) from %s to %s",
         id,
-        availabilityAndNode.status.getUri(),
+        availabilityAndNode.status.getExternalUri(),
         availabilityAndNode.availability,
         availability));
       return availabilityAndNode.availability;
@@ -267,7 +266,7 @@ public boolean reserve(SlotId slotId) {
       if (!maybeSlot.isPresent()) {
         LOG.warning(String.format(
           "Asked to reserve slot on node %s, but no slot with id %s found",
-          node.status.getId(),
+          node.status.getNodeId(),
           slotId));
         return false;
       }
@@ -300,21 +299,23 @@ public Set<NodeStatus> nodes(Availability availability) {
     return nodes.computeIfAbsent(availability, ignored -> new HashSet<>());
   }
 
-  private AvailabilityAndNode findNode(NodeId id) {
+  @Override
+  public AvailabilityAndNode findNode(NodeId id) {
     for (Map.Entry<Availability, Set<NodeStatus>> entry : nodes.entrySet()) {
       for (NodeStatus nodeStatus : entry.getValue()) {
-        if (id.equals(nodeStatus.getId())) {
+        if (id.equals(nodeStatus.getNodeId())) {
           return new AvailabilityAndNode(entry.getKey(), nodeStatus);
         }
       }
     }
     return null;
   }
 
-  private NodeStatus rewrite(NodeStatus status, Availability availability) {
+  @Override
+  public NodeStatus rewrite(NodeStatus status, Availability availability) {
     return new NodeStatus(
-      status.getId(),
-      status.getUri(),
+      status.getNodeId(),
+      status.getExternalUri(),
       status.getMaxSessionCount(),
       status.getSlots(),
       availability,
@@ -356,7 +357,8 @@ public void release(SessionId id) {
     }
   }
 
-  private void reserve(NodeStatus status, Slot slot) {
+  @Override
+  public void reserve(NodeStatus status, Slot slot) {
     Instant now = Instant.now();
 
     Slot reserved = new Slot(
@@ -365,7 +367,7 @@ private void reserve(NodeStatus status, Slot slot) {
       now,
       new Session(
         RESERVED,
-        status.getUri(),
+        status.getExternalUri(),
         slot.getStereotype(),
         slot.getStereotype(),
         now));
@@ -420,30 +422,21 @@ public void setSession(SlotId slotId, Session session) {
     }
   }
 
-  private void amend(Availability availability, NodeStatus status, Slot slot) {
+  @Override
+  public void amend(Availability availability, NodeStatus status, Slot slot) {
     Set<Slot> newSlots = new HashSet<>(status.getSlots());
     newSlots.removeIf(s -> s.getId().equals(slot.getId()));
     newSlots.add(slot);
 
     nodes(availability).remove(status);
     nodes(availability).add(new NodeStatus(
-      status.getId(),
-      status.getUri(),
+      status.getNodeId(),
+      status.getExternalUri(),
       status.getMaxSessionCount(),
       newSlots,
       status.getAvailability(),
       status.heartbeatPeriod(),
       status.getVersion(),
       status.getOsInfo()));
   }
-
-  private static class AvailabilityAndNode {
-    public final Availability availability;
-    public final NodeStatus status;
-
-    public AvailabilityAndNode(Availability availability, NodeStatus status) {
-      this.availability = availability;
-      this.status = status;
-    }
-  }
 }