import org.openqa.grid.internal.RemoteProxy; //导入依赖的package包/类
/**
 * return the platform for the proxy. It should be the same for all slots of the proxy, so checking that.
 * @return Either the platform name, "Unknown", "mixed OS", or "not specified".
 */
public static String getPlatform(RemoteProxy proxy) {
  Platform res = null;
  if (proxy.getTestSlots().size() == 0) {
    return "Unknown";
  } else {
    res = getPlatform(proxy.getTestSlots().get(0));

  }

  for (TestSlot slot : proxy.getTestSlots()) {
    Platform tmp = getPlatform(slot);
    if (tmp != res) {
      return "mixed OS";
    } else {
      res = tmp;
    }
  }
  if (res == null) {
    return "not specified";
  } else {
    return res.toString();
  }
}
 

import org.openqa.grid.internal.RemoteProxy; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public int getNumInProgressTests(ProxySet proxySet, AutomationRunRequest runRequest) {
    int inProgressTests = 0;
    for(RemoteProxy proxy : proxySet) {
        for(TestSlot testSlot : proxy.getTestSlots() ) {
            TestSession session = testSlot.getSession();
            if(session != null) {
                if(runRequest.matchesCapabilities(session.getRequestedCapabilities())) {
                    inProgressTests++;
                }
            }
        }
    }
    return inProgressTests;
}
 

import org.openqa.grid.internal.RemoteProxy; //导入依赖的package包/类
/**
 * Returns true if the specified node is empty and has no runs on it, and false otherwise
 * @param instanceToFind
 * @return
 */
public boolean isNodeCurrentlyEmpty(String instanceToFind) {
    ProxySet proxySet = getProxySet();
    for(RemoteProxy proxy : proxySet){
        List<TestSlot> slots = proxy.getTestSlots();
        Object instanceId = proxy.getConfig().get(AutomationConstants.INSTANCE_ID);
        // If the instance id's do not match, this means this is not the node we are looking for
        // and we should continue on to the next one
        if(!instanceToFind.equals(instanceId)) {
            continue;
        }
        // Now that we found the matching node, iterate over all its test slots to see if any sessions are running
        for (TestSlot testSlot : slots) {
            // If we find a running session, this means the node is occupied, so we should return false
            if(testSlot.getSession() != null) {
                return false;
            }
        }
        // If we reached this point, this means we found our target node AND it had no sessions, meaning the node was empty
        return true;
    }
    // If we didn't find a matching node, we're going to say the nodes is empty so we can terminate it
    log.warn("No matching node was found in the proxy set.  Instance id: " + instanceToFind);
    return true;
}
 

import org.openqa.grid.internal.RemoteProxy; //导入依赖的package包/类
private JSONObject getResponse() throws IOException, JSONException {
  JSONObject requestJSON = new JSONObject();
  ProxySet proxies = this.getRegistry().getAllProxies();
  Iterator<RemoteProxy> iterator = proxies.iterator();
  JSONArray busyProxies = new JSONArray();
  JSONArray freeProxies = new JSONArray();
  while (iterator.hasNext()) {
    RemoteProxy eachProxy = iterator.next();
    if (eachProxy.isBusy()) {
      busyProxies.put(eachProxy.getOriginalRegistrationRequest().getAssociatedJSON());
    } else {
      freeProxies.put(eachProxy.getOriginalRegistrationRequest().getAssociatedJSON());
    }
  }
  requestJSON.put("BusyProxies", busyProxies);
  requestJSON.put("FreeProxies", freeProxies);

  return requestJSON;
}
 

import org.openqa.grid.internal.RemoteProxy; //导入依赖的package包/类
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp)
		throws ServletException, IOException {
      SeleniumBasedRequest request = new OurRegistrationRequest(req, getRegistry());
      
      Map<String, Object> capabilities = request.extractDesiredCapability();
      String proxyId = (String)capabilities.get("proxyId");
      RemoteProxy proxyById = getRegistry().getProxyById(proxyId);
      
      if(proxyById == null) {
    	  resp.sendError(HttpStatus.SC_BAD_REQUEST, "Remote proxy not found: " + proxyId);
    	  return;
      }
      
      TestSession session = proxyById.getNewSession(capabilities);
      
      if(session == null) {
    	  log.warning("Test slot requested on proxy is unavailable. Proxy: " + proxyId + " capabilities: " + capabilities);
    	  resp.sendError(429, "Test Slot Unavailable");
    	  return;
      }
      
      session.forward(request, resp, true);
      	      
      if(session.getExternalKey() != null) {
    	  log.info("Created session successfully for proxy " + proxyId + " - cleaning up session");
    	  session.sendDeleteSessionRequest();
    	  
    	  // This will log a warning, about couldn't find a session
    	  getRegistry().terminate(session, SessionTerminationReason.CLIENT_STOPPED_SESSION);
      }
      else {
    	  log.warning("Could not create session on proxy for " + proxyId);
      }

}
 

import org.openqa.grid.internal.RemoteProxy; //导入依赖的package包/类
@Override
public void doWork() {
    log.info("Looking for unregistered nodes");
    ProxySet proxySet = getProxySet();
    if(proxySet != null && proxySet.size() > 0) {
        for(RemoteProxy proxy : proxySet) {
            Map<String,Object> config = proxy.getConfig();
            // If the config has an instanceId in it, this means this node was dynamically started and we should
            // track it if we are not already
            if(config.containsKey(AutomationConstants.INSTANCE_ID)) {
                String instanceId = (String)config.get(AutomationConstants.INSTANCE_ID);
                AutomationRunContext context = AutomationContext.getContext();
                // If this node is already in our context, that means we are already tracking this node to terminate
                if(!context.nodeExists(instanceId)) {
                    Date createdDate = getDate(config);
                    // If we couldn't parse the date out, we are sort of out of luck
                    if(createdDate == null) {
                        break;
                    }
                    proxy.getConfig();
                    String uuid = (String)config.get(AutomationConstants.UUID);
                    int threadCount = (Integer)config.get(AutomationConstants.CONFIG_MAX_SESSION);
                    String browser = (String)config.get(AutomationConstants.CONFIG_BROWSER);
                    String os = (String)config.get(AutomationConstants.CONFIG_OS);
                    AutomationDynamicNode node = new AutomationDynamicNode(uuid,instanceId,browser,os,createdDate,threadCount);
                    log.info("Unregistered dynamic node found: " + node);
                    context.addNode(node);
                }
            }
        }
    }
}
 

import org.openqa.grid.internal.RemoteProxy; //导入依赖的package包/类
private JSONObject getResponse() throws IOException, JSONException {
  JSONObject requestJSON = new JSONObject();
  ProxySet proxies = this.getRegistry().getAllProxies();
  Iterator<RemoteProxy> iterator = proxies.iterator();
  JSONArray p = new JSONArray();
  while (iterator.hasNext()) {
    RemoteProxy eachProxy = iterator.next();
    p.put(eachProxy.getOriginalRegistrationRequest().getAssociatedJSON());
  }
  requestJSON.put("Proxies", p);

  return requestJSON;
}
 

import org.openqa.grid.internal.RemoteProxy; //导入依赖的package包/类
public ProxiedTestSlot(RemoteProxy proxy, SeleniumProtocol protocol, Map<String, Object> capabilities) {
    super(proxy, protocol, capabilities);
}
 

import org.openqa.grid.internal.RemoteProxy; //导入依赖的package包/类
public WebProxyHtmlRendererBeta(RemoteProxy proxy) {
  this.proxy = proxy;
}
 

import org.openqa.grid.internal.RemoteProxy; //导入依赖的package包/类
public WebProxyJsonRenderer(RemoteProxy proxy) {
    this.proxy = proxy;
}
 

import org.openqa.grid.internal.RemoteProxy; //导入依赖的package包/类
private String getIcon(Map<String, Object> capabilities,RemoteProxy proxy) {
    return BrowserNameUtils.getConsoleIconPath(new DesiredCapabilities(capabilities),
            proxy.getRegistry());
}
 

import org.openqa.grid.internal.RemoteProxy; //导入依赖的package包/类
/**
 * Clean up any requests with no remaining running tests.
 *
 * @param  proxySet
 */
public void cleanUpRunRequests(final ProxySet proxySet) {
    AutomationRunContext context = AutomationContext.getContext();
    Set<String> uuidsToRemove = new HashSet<String>();
    synchronized (requests) {
        Iterator<String> requestsIterator = requests.keySet().iterator();
        if (requestsIterator.hasNext()) {

            // Grab our current date to use on all the requests we check
            while (requestsIterator.hasNext()) {
                String targetUuid = requestsIterator.next();
                AutomationRunRequest request = requests.get(targetUuid);
                if (!isRunOld(request)) {
                    log.info(String.format("Run [%s] is not at least [%d] seconds old.  Will not analyze.",
                            targetUuid, AutomationRunContext.CLEANUP_LIFE_LENGTH_IN_SECONDS));
                    continue;
                }

                boolean uuidFound = false;
                for (RemoteProxy proxy : proxySet) {
                    List<TestSlot> slots = proxy.getTestSlots();

                    // Once we find at least one test run with the given UUID, we want to break out
                    // as we are looking for runs with NO running tests with a matching UUID
                    for (int i = 0; !uuidFound && i < slots.size(); i++) {
                        TestSession testSession = slots.get(i).getSession();
                        if (testSession != null) {

                            // Check the session UUID instead of the node UUID as the node UUID is going to be the
                            // test run UUID that caused
                            // the node to be started, but will not necessarily be the run that is currently
                            // running on the node
                            Object sessionUuid = testSession.getRequestedCapabilities().get(
                                    AutomationConstants.UUID);
                            if (targetUuid.equals(sessionUuid)) {
                                uuidFound = true;
                                break;
                            }
                        }
                    }

                    // If we found the UUID on this node, we don't need to check any other nodes as we only need
                    // to know about
                    // at least run test still running in order to know we don't need to remove this run
                    if (uuidFound) {
                        break;
                    }
                }

                // If we didn't find a test belonging to this uuid, go ahead and remove the run
                if (!uuidFound) {
                    log.info(String.format(
                            "Tracked test run [%s] found with no running tests.  Adding to set for removal.",
                            targetUuid));
                    uuidsToRemove.add(targetUuid);
                }
                // Otherwise go ahead and continue to look at our other registered runs
                else {
                    continue;
                }
            }
        }
    }

    if (uuidsToRemove.size() == 0) {
        log.warn("No runs found to clean up");
    }

    for (String uuidToRemove : uuidsToRemove) {
        log.warn(String.format("Removing run because it has no more running test slots. UUID [%s]", uuidToRemove));
        context.deleteRun(uuidToRemove);
    }
}
 

import org.openqa.grid.internal.RemoteProxy; //导入依赖的package包/类
@Override
public int compareTo(RemoteProxy remoteProxy) {
    return 0;
}