import org.openqa.grid.internal.TestSession; //导入依赖的package包/类
@Override
public TestSession getNewSession(Map<String, Object> requestedCapability) {

    if (counter.get() > ConfigReader.getInstance().getMaxSession()) {
        LOG.info("Waiting for remote nodes to be available");
        return null;
    }

    if (LOG.isLoggable(Level.FINE)) {
        LOG.fine(String.format("Trying to create a new session on node %s", this));
    }

    // any slot left for the given app ?
    for (TestSlot testslot : getTestSlots()) {
        TestSession session = testslot.getNewSession(requestedCapability);
        if (session != null) {
            return session;
        }
    }
    return null;
}
 

import org.openqa.grid.internal.TestSession; //导入依赖的package包/类
@Override
public void beforeCommand(TestSession session, HttpServletRequest request, HttpServletResponse response) {
    RequestType type = identifyRequestType(request);
    if (type == START_SESSION) {
        try {
            if (processTestSession(session)) {
                startServerForTestSession(session);
            } else {
                String msg = "Missing target mapping. Available mappings are " +
                    ConfigReader.getInstance().getMapping();
                throw new IllegalStateException(msg);
            }
        } catch (Exception e) {
            getRegistry().terminate(session, SessionTerminationReason.CREATIONFAILED);
            LOG.severe("Failed creating a session. Root cause :" + e.getMessage());
            throw e;
        }
    }
    super.beforeCommand(session, request, response);
}
 

import org.openqa.grid.internal.TestSession; //导入依赖的package包/类
@Override
public void beforeSession(TestSession session) {
    super.beforeSession(session);
    HttpPost r = new HttpPost(serviceUrl + "?command=start");
    try {
        HttpResponse response = client.execute(remoteHost, r);
        if(response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
            log.warning("Could not start video reporting: " + EntityUtils.toString(response.getEntity()));
            return;
        }
        log.info("Started recording for new session on node: " + getId());

    } catch (Exception e) {
        log.warning("Could not start video reporting due to exception: " + e.getMessage());
        e.printStackTrace();
    }
    finally {
        r.releaseConnection();
    }
}
 

import org.openqa.grid.internal.TestSession; //导入依赖的package包/类
@Override
public void afterSession(TestSession session) {
    super.afterSession(session);
    HttpPost r = new HttpPost(serviceUrl + "?command=stop");
    try {
        HttpResponse response = client.execute(remoteHost, r);
        if(response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
            log.warning("Could not stop video reporting: " + EntityUtils.toString(response.getEntity()));
            return;
        }
        log.info("Stopped recording for new session on node: " + getId());

    } catch (Exception e) {
        log.warning("Could not stop video reporting due to exception: " + e.getMessage());
        e.printStackTrace();
    }
    finally {
        r.releaseConnection();
    }
}
 

import org.openqa.grid.internal.TestSession; //导入依赖的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.TestSession; //导入依赖的package包/类
@Override
public void afterCommand(TestSession session, HttpServletRequest request, HttpServletResponse response) {
    super.afterCommand(session, request, response);
    RequestType type = identifyRequestType(request);
    if (type == STOP_SESSION) {
        stopServerForTestSession(session);
        if (LOG.isLoggable(Level.INFO)) {
            LOG.info(String.format("Counter value after decrementing : %d", counter.decrementAndGet()));
        }
    }
}
 

import org.openqa.grid.internal.TestSession; //导入依赖的package包/类
private void startServerForTestSession(TestSession session) {
    try {
        SpawnedServer server = SpawnedServer.spawnInstance(session);
        String key = "http://" + server.getHost() + ":" + server.getPort();
        URL url = new URL(key);
        servers.put(key, server);
        ((ProxiedTestSlot) session.getSlot()).setRemoteURL(url);
        if (LOG.isLoggable(Level.INFO)) {
            LOG.info(String.format("Forwarding session to :%s", session.getSlot().getRemoteURL()));
            LOG.info(String.format("Counter value after incrementing : %d", counter.incrementAndGet()));
        }
    } catch (Exception e) {
        throw new GridException(e.getMessage(), e);
    }
}
 

import org.openqa.grid.internal.TestSession; //导入依赖的package包/类
private void stopServerForTestSession(TestSession session) {
    URL url = session.getSlot().getRemoteURL();
    String key = String.format("%s://%s:%d", url.getProtocol(), url.getHost(), url.getPort());
    SpawnedServer localServer = servers.get(key);
    if (localServer != null) {
        localServer.shutdown();
        servers.remove(key);
    }
}
 

import org.openqa.grid.internal.TestSession; //导入依赖的package包/类
public static SpawnedServer spawnInstance(TestSession session) throws Exception {
    SpawnedServer server = new SpawnedServer();
    AtomicInteger attempts = new AtomicInteger(0);
    String browser = (String) session.getRequestedCapabilities().get(CapabilityType.BROWSER_NAME);
    server.server = newInstance(browser);
    int port = server.server.startServer(session);

    do {
        TimeUnit.SECONDS.sleep(2);
    } while (!server.server.isServerRunning() && attempts.incrementAndGet() <= 5);
    if (LOG.isLoggable(Level.WARNING)) {
        LOG.warning(String.format("***Server started on [%d]****", port));
    }
    return server;
}
 

import org.openqa.grid.internal.TestSession; //导入依赖的package包/类
@Override
public int startServer(TestSession session) throws ServerException {
    try {
        String browser = (String) session.getRequestedCapabilities().get(CapabilityType.BROWSER_NAME);
        String image = ConfigReader.getInstance().getMapping().get(browser).getTarget();
        containerInfo = DockerHelper.startContainerFor(image, isPrivileged(), getDeviceInfos());
        return containerInfo.getPort();
    } catch (DockerException | InterruptedException e) {
        throw new ServerException(e.getMessage(), e);
    }
}
 

import org.openqa.grid.internal.TestSession; //导入依赖的package包/类
@Override
public int startServer(TestSession session) throws ServerException {
    port = PortProber.findFreePort();
    String[] args = getArgs(port);
    if (LOG.isLoggable(Level.INFO)) {
        LOG.info(String.format("Spawning a Selenium server using the arguments [%s]", Arrays.toString(args)));
    }
    ProcessBuilder pb = new ProcessBuilder(getArgs(port));
    try {
        this.process = pb.start();
        return port;
    } catch (Exception e) {
        throw new ServerException(e.getMessage(), e);
    }
}
 

import org.openqa.grid.internal.TestSession; //导入依赖的package包/类
public void afterSession(TestSession session) {
	if (this.hasRecordingStarted == true) {
		final String key = session.getInternalKey();
		HttpGetHelper helper = new HttpGetHelper(String.format(
				STOP_RECORDING_STRING, nodeUrl, key));
		try {
			helper.execute();
			hasRecordingStarted = false;
		} catch (Exception err) {
			System.out
					.println("Error occurred while stopping the recording "
							+ err.getMessage());
		}
	}
}
 

import org.openqa.grid.internal.TestSession; //导入依赖的package包/类
public URL getRemoteHostForSession(String sessionId) {
    for (TestSession activeSession : registry.getActiveSessions()) {
        if (sessionId.equals(activeSession.getExternalKey().getKey())) {
            return activeSession.getSlot().getProxy().getRemoteHost();
        }
    }
    throw new IllegalArgumentException("Invalid sessionId. No active session is present for id:" + sessionId);
}
 

import org.openqa.grid.internal.TestSession; //导入依赖的package包/类
public void refreshTimeout(String sessionId) {
    for (TestSession activeSession : registry.getActiveSessions()) {
        if (sessionId.equals(activeSession.getExternalKey().getKey())) {
            refreshTimeout(activeSession);
        }
    }
}
 

import org.openqa.grid.internal.TestSession; //导入依赖的package包/类
@Before
public void setUp() {
    seleniumSessions = new SeleniumSessions(registry);
    activeSession = spy(new TestSession(null, null, Clock.systemDefaultZone()));

    when(activeSession.getExternalKey()).thenReturn(externalSessionKey);
    when(externalSessionKey.getKey()).thenReturn("sessionId");
    when(registry.getActiveSessions()).thenReturn(Sets.newHashSet(activeSession));
}
 

import org.openqa.grid.internal.TestSession; //导入依赖的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.TestSession; //导入依赖的package包/类
@Override
public void afterSession(TestSession session) {
	super.afterSession(session);
	
	Map<String, Object> capabilities = session.getSlot().getCapabilities();

	if(session.getExternalKey() == null && workingCapabilities.contains(capabilities)) {
		// session creation failed on a slot we thought was working - we should do something about this
		System.out.println("Session creation failed, re-testing configuration: " + capabilities);
		setCapabilityAsBroken(capabilities);
		RemoteNodeTester.testRemoteNode(this, capabilities);
	}
}
 

import org.openqa.grid.internal.TestSession; //导入依赖的package包/类
private JSONObject render(TestSlot slot) throws JSONException {
    JSONObject json = new JSONObject();
    json.put("capabilities", slot.getCapabilities());
    TestSession session = slot.getSession();

    if (session != null) {
        json.put("session", render(session));
        json.put("busy", true);
    } else {
        json.put("busy", false);
    }

    return json;
}
 

import org.openqa.grid.internal.TestSession; //导入依赖的package包/类
public CommandReporter(String remoteHostName, InfluxDB influxdb, String database, TestSession session, ContentSnoopingRequest request, HttpServletResponse response, ReportType type) {
    super(remoteHostName, influxdb, database);
    this.type = type;
    this.request = request;
    this.session = session;
    this.response = response;
}
 

import org.openqa.grid.internal.TestSession; //导入依赖的package包/类
protected void process(HttpServletRequest request, HttpServletResponse response) throws IOException 
  {
response.setContentType("application/json");
   response.setCharacterEncoding("UTF-8");
   response.setStatus(HttpStatus.SC_NOT_FOUND);

String id = request.getParameter("session");
if(id != null)
{
	TestSession session = this.getRegistry().getExistingSession(ExternalSessionKey.fromString(id));
	if(session != null)
	{
		Map<String, Object> cap = session.getSlot().getCapabilities();
		if(cap.containsKey("udid"))
		{
			RemoteDevice device = new RemoteDevice(); 
			device.setName((String) cap.get("deviceName"));
			device.setOs((String) cap.get("platformName"));
			device.setOsVersion((String) cap.get("platformVersion"));
			device.setType((String) cap.get("deviceType"));
			device.setUdid((String) cap.get("udid"));
			
			STFDevice stfDevice = STF.getDevice(device.getUdid());
			if(stfDevice != null)
			{
				device.setRemoteURL((String) stfDevice.getRemoteConnectUrl());
			}
			
			response.setStatus(HttpStatus.SC_OK);
			response.getWriter().print(new ObjectMapper().writeValueAsString(device));
		    response.getWriter().close();
		}
	}
}
  }