这是本节的多页打印视图。点击此处打印.

高级功能

要获得高级功能的所有详细信息, 了解其工作原理, 以及如何设置自己的功能, 请浏览以下部分.

1: 可观测性
2: GraphQL查询支持
3: Grid端点
4: 自定义Node
5: 外部数据存储

1 - 可观测性

Page being translated from English to Chinese. Do you speak Chinese? Help us to translate it by sending us pull requests!

Selenium Grid

Grid aids in scaling and distributing tests by executing tests on various browser and operating system combinations.

Observability

Observability has three pillars: traces, metrics and logs. Since Selenium Grid 4 is designed to be fully distributed, observability will make it easier to understand and debug the internals.

Distributed tracing

A single request or transaction spans multiple services and components. Tracing tracks the request lifecycle as each service executes the request. It is useful in debugging in an error scenario. Some key terms used in tracing context are:

Trace Tracing allows one to trace a request through multiple services, starting from its origin to its final destination. This request’s journey helps in debugging, monitoring the end-to-end flow, and identifying failures. A trace depicts the end-to-end request flow. Each trace has a unique id as its identifier.

Span Each trace is made up of timed operations called spans. A span has a start and end time and it represents operations done by a service. The granularity of span depends on how it is instrumented. Each span has a unique identifier. All spans within a trace have the same trace id.

Span Attributes Span attributes are key-value pairs which provide additional information about each span.

Events Events are timed-stamped logs within a span. They provide additional context to the existing spans. Events also contain key-value pairs as event attributes.

Event logging

Logging is essential to debug an application. Logging is often done in a human-readable format. But for machines to search and analyze the logs, it has to have a well-defined format. Structured logging is a common practice of recording logs consistently in a fixed format. It commonly contains fields like:

Timestamp
Logging level
Logger class
Log message (This is further broken down into fields relevant to the operation where the log was recorded)

Logs and events are closely related. Events encapsulate all the possible information available to do a single unit of work. Logs are essentially subsets of an event. At the crux, both aid in debugging. Refer following resources for detailed understanding:

Grid Observability

Selenium server is instrumented with tracing using OpenTelemetry. Every request to the server is traced from start to end. Each trace consists of a series of spans as a request is executed within the server. Most spans in the Selenium server consist of two events:

Normal event - records all information about a unit of work and marks successful completion of the work.
Error event - records all information till the error occurs and then records the error information. Marks an exception event.

Running Selenium server

Visualizing Traces

All spans, events and their respective attributes are part of a trace. Tracing works while running the server in all of the above-mentioned modes.

By default, tracing is enabled in the Selenium server. Selenium server exports the traces via two exporters:

Console - Logs all traces and their included spans at FINE level. By default, Selenium server prints logs at INFO level and above. The log-level flag can be used to pass a logging level of choice while running the Selenium Grid jar/s.

java -jar selenium-server-4.0.0-<selenium-version>.jar standalone --log-level FINE

Jaeger UI - OpenTelemetry provides the APIs and SDKs to instrument traces in the code. Whereas Jaeger is a tracing backend, that aids in collecting the tracing telemetry data and providing querying, filtering and visualizing features for the data.

Detailed instructions of visualizing traces using Jaeger UI can be obtained by running the command :

java -jar selenium-server-4.0.0-<selenium-version>.jar info tracing

A very good example and scripts to run the server and send traces to Jaeger

Leveraging event logs

Tracing has to be enabled for event logging as well, even if one does not wish to export traces to visualize them.
By default, tracing is enabled. No additional parameters need to be passed to see logs on the console. All events within a span are logged at FINE level. Error events are logged at WARN level.

All event logs have the following fields :

Field	Field value	Description
Event time	eventId	Timestamp of the event record in epoch nanoseconds.
Trace Id	tracedId	Each trace is uniquely identified by a trace id.
Span Id	spanId	Each span within a trace is uniquely identified by a span id.
Span Kind	spanKind	Span kind is a property of span indicating the type of span. It helps in understanding the nature of the unit of work done by the Span.
Event name	eventName	This maps to the log message.
Event attributes	eventAttributes	This forms the crux of the event logs, based on the operation executed, it has JSON formatted key-value pairs. This also includes a handler class attribute, to show the logger class.

Sample log

FINE [LoggingOptions$1.lambda$export$1] - {
  "traceId": "fc8aef1d44b3cc8bc09eb8e581c4a8eb",
  "spanId": "b7d3b9865d3ddd45",
  "spanKind": "INTERNAL",
  "eventTime": 1597819675128886121,
  "eventName": "Session request execution complete",
  "attributes": {
    "http.status_code": 200,
    "http.handler_class": "org.openqa.selenium.grid.router.HandleSession",
    "http.url": "\u002fsession\u002fdd35257f104bb43fdfb06242953f4c85",
    "http.method": "DELETE",
    "session.id": "dd35257f104bb43fdfb06242953f4c85"
  }
}

In addition to the above fields, based on OpenTelemetry specification error logs consist of :

Field	Field value	Description
Exception type	exception.type	The class name of the exception.
Exception message	exception.message	Reason for the exception.
Exception stacktrace	exception.stacktrace	Prints the call stack at the point of time when the exception was thrown. Helps in understanding the origin of the exception.

Sample error log

WARN [LoggingOptions$1.lambda$export$1] - {
  "traceId": "7efa5ea57e02f89cdf8de586fe09f564",
  "spanId": "914df6bc9a1f6e2b",
  "spanKind": "INTERNAL",
  "eventTime": 1597820253450580272,
  "eventName": "exception",
  "attributes": {
    "exception.type": "org.openqa.selenium.ScriptTimeoutException",
    "exception.message": "Unable to execute request: java.sql.SQLSyntaxErrorException: Table 'mysql.sessions_mappa' doesn't exist ..." (full message will be printed),
    "exception.stacktrace": "org.openqa.selenium.ScriptTimeoutException: java.sql.SQLSyntaxErrorException: Table 'mysql.sessions_mappa' doesn't exist\nBuild info: version: '4.0.0-alpha-7', revision: 'Unknown'\nSystem info: host: 'XYZ-MacBook-Pro.local', ip: 'fe80:0:0:0:10d5:b63a:bdc6:1aff%en0', os.name: 'Mac OS X', os.arch: 'x86_64', os.version: '10.13.6', java.version: '11.0.7'\nDriver info: driver.version: unknown ...." (full stack will be printed),
    "http.handler_class": "org.openqa.selenium.grid.distributor.remote.RemoteDistributor",
    "http.url": "\u002fsession",
    "http.method": "POST"
  }
}

Note: Logs are pretty printed above for readability. Pretty printing for logs is turned off in Selenium server.

The steps above should set you up for seeing traces and logs.

References

2 - GraphQL查询支持

GraphQL 是一种用于API的查询语言, 也是用于使用现有数据完成这些查询的运行时. 其仅仅是使用户能够准确地获取所需.

枚举

枚举是表示字段的可能值的集合.

例如, Node对象具有一个称为status的字段. 状态是一个枚举 (特别是Status类型) , 因为它可能是UP , DRAINING 或 UNAVAILABLE.

标量

标量是基本类型的值: Int, Float, String, Boolean, 或 ID.

在调用GraphQL API时, 必须指定嵌套子字段, 直到只返回标量.

模式的结构

网格模式的结构如下:

{
    session(id: "<session-id>") : {
        id,
        capabilities,
        startTime,
        uri,
        nodeId,
        nodeUri,
        sessionDurationMillis
        slot : {
            id,
            stereotype,
            lastStarted
        }
    }
    grid: {
        uri,
        totalSlots,
        nodeCount,
        maxSession,
        sessionCount,
        version,
        sessionQueueSize
    }
    sessionsInfo: {
        sessionQueueRequests,
        sessions: [
            {
                id,
                capabilities,
                startTime,
                uri,
                nodeId,
                nodeUri,
                sessionDurationMillis
                slot : {
                    id,
                    stereotype,
                    lastStarted
                }
            }
        ]
    }
    nodesInfo: {
        nodes : [
            {
                id,
                uri,
                status,
                maxSession,
                slotCount,
                sessions: [
                    {
                        id,
                        capabilities,
                        startTime,
                        uri,
                        nodeId,
                        nodeUri,
                        sessionDurationMillis
                        slot : {
                            id,
                            stereotype,
                            lastStarted
                        }
                    }
                ],
                sessionCount,
                stereotypes,
                version,
                osInfo: {
                    arch,
                    name,
                    version
                }
            }
        ]
    }
}

查询 GraphQL

查询GraphQL的最佳方法是使用curl请求. GraphQL允许您仅获取所需的数据, 仅此而已.

下面给出了一些GraphQL查询的示例. 您可以根据需要构建自己的查询.

查询网格中 `maxSession` 和 `sessionCount` 的数量:

curl -X POST -H "Content-Type: application/json" --data '{"query": "{ grid { maxSession, sessionCount } }"}' -s <LINK_TO_GRAPHQL_ENDPOINT>

通常在本地机器上 <LINK_TO_GRAPHQL_ENDPOINT> 会是 http://localhost:4444/graphql

查询全部会话、及节点以及网格的详情 :

curl -X POST -H "Content-Type: application/json" --data '{"query":"{ grid { uri, maxSession, sessionCount }, nodesInfo { nodes { id, uri, status, sessions { id, capabilities, startTime, uri, nodeId, nodeUri, sessionDurationMillis, slot { id, stereotype, lastStarted } }, slotCount, sessionCount }} }"}' -s <LINK_TO_GRAPHQL_ENDPOINT>

查询以获取当前网格的会话总数 :

curl -X POST -H "Content-Type: application/json" --data '{"query":"{ grid { sessionCount } }"}' -s <LINK_TO_GRAPHQL_ENDPOINT>

查询以获取网格中的最大会话数量 :

curl -X POST -H "Content-Type: application/json" --data '{"query":"{ grid { maxSession } }"}' -s <LINK_TO_GRAPHQL_ENDPOINT>

查询以获取网格中所有节点的全部会话详情 :

curl -X POST -H "Content-Type: application/json" --data '{"query":"{ sessionsInfo { sessions { id, capabilities, startTime, uri, nodeId, nodeId, sessionDurationMillis } } }"}' -s <LINK_TO_GRAPHQL_ENDPOINT>

查询以获取网格中每个节点中所有会话的插槽信息 :

curl -X POST -H "Content-Type: application/json" --data '{"query":"{ sessionsInfo { sessions { id, slot { id, stereotype, lastStarted } } } }"}' -s <LINK_TO_GRAPHQL_ENDPOINT>

查询以获取给定会话的会话信息查询以获取给定会话的会话信息 :

curl -X POST -H "Content-Type: application/json" --data '{"query":"{ session (id: \"<session-id>\") { id, capabilities, startTime, uri, nodeId, nodeUri, sessionDurationMillis, slot { id, stereotype, lastStarted } } } "}' -s <LINK_TO_GRAPHQL_ENDPOINT>

查询网格中每个节点的功能 :

curl -X POST -H "Content-Type: application/json" --data '{"query": "{ nodesInfo { nodes { stereotypes } } }"}' -s <LINK_TO_GRAPHQL_ENDPOINT>

查询网格中每个节点的状态 :

curl -X POST -H "Content-Type: application/json" --data '{"query": "{ nodesInfo { nodes { status } } }"}' -s <LINK_TO_GRAPHQL_ENDPOINT>

查询每个节点和网格的 URI :

curl -X POST -H "Content-Type: application/json" --data '{"query": "{ nodesInfo { nodes { uri } } }"}' -s <LINK_TO_GRAPHQL_ENDPOINT>

Query for getting the current requests in the New Session Queue:

curl -X POST -H "Content-Type: application/json" --data '{"query":"{ sessionsInfo { sessionQueueRequests } }"}' -s <LINK_TO_GRAPHQL_ENDPOINT>

Query for getting the New Session Queue size :

curl -X POST -H "Content-Type: application/json" --data '{"query":"{ grid { sessionQueueSize } }"}' -s <LINK_TO_GRAPHQL_ENDPOINT>

3 - Grid端点

Grid

Grid 状态

Grid状态提供Grid的当前状态. 它包含每个注册节点的详细信息. 对于每个节点, 状态包括有关节点可用性、会话和插槽的信息.

curl --request GET 'http://localhost:4444/status'

删除会话

删除会话会终止 WebDriver 会话、退出驱动程序并将其从活动会话映射中删除。任何使用删除的会话标识或重新使用驱动程序实例的请求都会出错。

curl --request DELETE 'http://localhost:4444/session/<session-id>'

我应该使用哪一个URL?

在 Standalone 模式下, Grid URL是独立服务器的地址.

在 Hub-Node 模式下, Grid URL是集线器服务器的地址.

在完全分布式模式下, Grid URL是路由服务器的地址.

以上所有模式的默认URL皆为http://localhost:4444.

分发器

删除节点

要从网格中删除节点，请使用下面列出的 curl 命令。该命令不会停止正在该节点上运行的任何会话。除非显式终止, 否则节点将继续运行。分发器不再知道该节点，因此任何匹配的新会话请求都不会转发到该节点。

在 Standalone 模式下，分发器 URL 是独立服务器地址。

在 Hub-Node 模式下, 分发器 URL 是 Hub 服务器的地址。

curl --request DELETE 'http://localhost:4444/se/grid/distributor/node/<node-id>' --header 'X-REGISTRATION-SECRET: <secret> '

在完全分布式模式下, URL是分发器的地址。

curl --request DELETE 'http://localhost:4444/se/grid/distributor/node/<node-id>' --header 'X-REGISTRATION-SECRET: <secret>'

如果在设置Grid时未配置注册密码, 则使用

curl --request DELETE 'http://<Router-URL>/se/grid/distributor/node/<node-id>' --header 'X-REGISTRATION-SECRET;'

释放节点

节点释放命令用于优雅地关闭节点。在所有正在进行的会话结束后，会停止该节点。并且，它不会接受任何新的会话请求。

在 Standalone 模式下，分发器 URL 是独立服务器地址。

在 Hub-Node 模式下, 分发器 URL 是 Hub 服务器的地址。

curl --request POST 'http://localhost:4444/se/grid/distributor/node/<node-id>/drain' --header 'X-REGISTRATION-SECRET: <secret> '

在完全分布式模式下, URL是分发服务器的地址。

curl --request POST 'http://localhost:4444/se/grid/distributor/node/<node-id>/drain' --header 'X-REGISTRATION-SECRET: <secret>'

如果在设置Grid时未配置注册密码, 则使用

curl --request POST 'http://<Router-URL>/se/grid/distributor/node/<node-id>/drain' --header 'X-REGISTRATION-SECRET;'

节点

本节中的端点适用于 Hub-Node 模式和节点独立运行的完全分布式网格模式。在一个节点的情况下, 默认节点的URL为 http://localhost:5555 。如果有多个节点,请使用 Grid 状态获取所有节点的详细信息并查找节点地址。

状态

节点状态本质上是节点的健康检查。分发程序会定期 ping 节点状态，并相应地更新 Grid 模型。状态包括有关可用性、会话和插槽的信息。

curl --request GET 'http://localhost:5555/status'

释放

分发器将释放命令传递给由node-id标识的相应节点。要直接释放节点,请使用下面列出的curl命令。两个端点都有效并产生相同的结果。释放会等待持续中的会话完成后才停止节点。

curl --request POST 'http://localhost:5555/se/grid/node/drain' --header 'X-REGISTRATION-SECRET: <secret>'

如果在设置Grid时未配置注册密码,则使用

curl --request POST 'http://<node-URL>/se/grid/node/drain' --header 'X-REGISTRATION-SECRET;'

检查会话所有者

要检查会话是否属于某一节点, 请使用下面列出的curl命令.

curl --request GET 'http://localhost:5555/se/grid/node/owner/<session-id>' --header 'X-REGISTRATION-SECRET: <secret>'

如果在设置Grid时未配置注册密码, 则使用

curl --request GET 'http://<node-URL>/se/grid/node/owner/<session-id>' --header 'X-REGISTRATION-SECRET;'

如果会话属于该节点, 则返回true, 否则返回false。

删除会话

删除会话会终止 WebDriver 会话、退出驱动程序并将其从活动会话映射中删除。任何使用删除的会话标识或重新使用驱动程序实例的请求都会出错。

curl --request DELETE 'http://localhost:5555/se/grid/node/session/<session-id>' --header 'X-REGISTRATION-SECRET: <secret>'

如果在设置Grid时未配置注册密码, 则使用

curl --request DELETE 'http://<node-URL>/se/grid/node/session/<session-id>' --header 'X-REGISTRATION-SECRET;'

新会话队列

清除新会话队列

新会话请求队列保存新会话请求。要清除队列，请使用下面列出的 curl 命令。清除队列会拒绝队列中的所有请求。对于每个此类请求，服务器都会向相应的客户端返回错误响应。清除命令的结果是被删除请求的总数。

在 Standalone 模式下, 队列URL是独立服务器的地址。在 Hub-Node 模式下, 队列URL是集线器服务器的地址。

curl --request DELETE 'http://localhost:4444/se/grid/newsessionqueue/queue' --header 'X-REGISTRATION-SECRET: <secret>'

在完全分布式模式下, 队列URL是新会话队列服务器的地址。

curl --request DELETE 'http://localhost:4444/se/grid/newsessionqueue/queue' --header 'X-REGISTRATION-SECRET: <secret>'

如果在设置Grid时未配置注册密码, 则使用

curl --request DELETE 'http://<Router-URL>/se/grid/newsessionqueue/queue' --header 'X-REGISTRATION-SECRET;'

获取新会话队列请求

新会话请求队列保存新会话请求。要获取队列中的当前请求, 请使用下面列出的curl命令。响应会返回队列中的请求总数以及请求内容。

在 Standalone 模式下, 队列URL是独立服务器的地址。在 Hub-Node 模式下, 队列URL是集线器服务器的地址。

curl --request GET 'http://localhost:4444/se/grid/newsessionqueue/queue'

在完全分布式模式下, 队列URL是新会话队列服务器的地址。

curl --request GET 'http://localhost:4444/se/grid/newsessionqueue/queue'

4 - 自定义Node

如何自定义节点

有时候我们希望根据自己的需求自定义Node。

例如，我们可能希望在会话开始执行前做一些额外的设置，在会话完成后做一些清理工作。

可以按照以下步骤进行：

创建一个类，继承自 org.openqa.selenium.grid.node.Node
在新建的类中添加一个静态方法（工厂方法），其签名如下：
public static Node create(Config config)。其中：
- Node 类型为 org.openqa.selenium.grid.node.Node
- Config 类型为 org.openqa.selenium.grid.config.Config
在工厂方法中，包含创建新类的逻辑。
要将自定义逻辑接入 hub，启动 node 时通过参数 --node-implementation 传入上述类的完整类名。

下面我们来看一个完整的示例：

作为 uber jar 的自定义 Node

使用你喜欢的构建工具 (Maven|Gradle) 创建一个示例项目。
在项目中添加如下依赖：
- org.seleniumhq.selenium/selenium-grid
将你的自定义 Node 添加到项目中。
构建一个 uber jar，以便通过 java -jar 命令启动 Node。
现在使用如下命令启动 Node：

java -jar custom_node-server.jar node \
--node-implementation org.seleniumhq.samples.DecoratedLoggingNode

注意： 如果你使用 Maven 作为构建工具，建议使用 maven-shade-plugin 而不是 maven-assembly-plugin，因为 maven-assembly-plugin 在合并多个 Service Provider Interface 文件 (META-INF/services) 时可能存在问题。

作为普通 jar 的自定义 Node

使用你喜欢的构建工具 (Maven|Gradle) 创建一个示例项目。
在项目中添加如下依赖：
- org.seleniumhq.selenium/selenium-grid
将你的自定义 Node 添加到项目中。
使用构建工具构建项目 jar 包。
现在使用如下命令启动 Node：

java -jar selenium-server-4.6.0.jar \
--ext custom_node-1.0-SNAPSHOT.jar node \
--node-implementation org.seleniumhq.samples.DecoratedLoggingNode

下面是一个示例：当Node有相关活动（会话创建、会话删除、WebDriver 命令执行等）时，仅在控制台打印一些消息。

自定义Node示例

package org.seleniumhq.samples;

import java.net.URI;
import java.util.UUID;
import org.openqa.selenium.Capabilities;
import org.openqa.selenium.NoSuchSessionException;
import org.openqa.selenium.WebDriverException;
import org.openqa.selenium.grid.config.Config;
import org.openqa.selenium.grid.data.CreateSessionRequest;
import org.openqa.selenium.grid.data.CreateSessionResponse;
import org.openqa.selenium.grid.data.NodeId;
import org.openqa.selenium.grid.data.NodeStatus;
import org.openqa.selenium.grid.data.Session;
import org.openqa.selenium.grid.log.LoggingOptions;
import org.openqa.selenium.grid.node.HealthCheck;
import org.openqa.selenium.grid.node.Node;
import org.openqa.selenium.grid.node.local.LocalNodeFactory;
import org.openqa.selenium.grid.security.Secret;
import org.openqa.selenium.grid.security.SecretOptions;
import org.openqa.selenium.grid.server.BaseServerOptions;
import org.openqa.selenium.internal.Either;
import org.openqa.selenium.remote.SessionId;
import org.openqa.selenium.remote.http.HttpRequest;
import org.openqa.selenium.remote.http.HttpResponse;
import org.openqa.selenium.remote.tracing.Tracer;

public class DecoratedLoggingNode extends Node {

  private Node node;

  protected DecoratedLoggingNode(Tracer tracer, NodeId nodeId, URI uri, Secret registrationSecret, Duration sessionTimeout) {
    super(tracer, nodeId, uri, registrationSecret, sessionTimeout);
  }

  public static Node create(Config config) {
    LoggingOptions loggingOptions = new LoggingOptions(config);
    BaseServerOptions serverOptions = new BaseServerOptions(config);
    URI uri = serverOptions.getExternalUri();
    SecretOptions secretOptions = new SecretOptions(config);
    NodeOptions nodeOptions = new NodeOptions(config);
    Duration sessionTimeout = nodeOptions.getSessionTimeout();

    // Refer to the foot notes for additional context on this line.
    Node node = LocalNodeFactory.create(config);

    DecoratedLoggingNode wrapper = new DecoratedLoggingNode(loggingOptions.getTracer(),
        node.getId(),
        uri,
        secretOptions.getRegistrationSecret(),
        sessionTimeout);
    wrapper.node = node;
    return wrapper;
  }

  @Override
  public Either<WebDriverException, CreateSessionResponse> newSession(
      CreateSessionRequest sessionRequest) {
    System.out.println("Before newSession()");
    try {
      return this.node.newSession(sessionRequest);
    } finally {
      System.out.println("After newSession()");
    }
  }

  @Override
  public HttpResponse executeWebDriverCommand(HttpRequest req) {
    try {
      System.out.println("Before executeWebDriverCommand(): " + req.getUri());
      return node.executeWebDriverCommand(req);
    } finally {
      System.out.println("After executeWebDriverCommand()");
    }
  }

  @Override
  public Session getSession(SessionId id) throws NoSuchSessionException {
    try {
      System.out.println("Before getSession()");
      return node.getSession(id);
    } finally {
      System.out.println("After getSession()");
    }
  }

  @Override
  public HttpResponse uploadFile(HttpRequest req, SessionId id) {
    try {
      System.out.println("Before uploadFile()");
      return node.uploadFile(req, id);
    } finally {
      System.out.println("After uploadFile()");
    }
  }

  @Override
  public void stop(SessionId id) throws NoSuchSessionException {
    try {
      System.out.println("Before stop()");
      node.stop(id);
    } finally {
      System.out.println("After stop()");
    }
  }

  @Override
  public boolean isSessionOwner(SessionId id) {
    try {
      System.out.println("Before isSessionOwner()");
      return node.isSessionOwner(id);
    } finally {
      System.out.println("After isSessionOwner()");
    }
  }

  @Override
  public boolean isSupporting(Capabilities capabilities) {
    try {
      System.out.println("Before isSupporting");
      return node.isSupporting(capabilities);
    } finally {
      System.out.println("After isSupporting()");
    }
  }

  @Override
  public NodeStatus getStatus() {
    try {
      System.out.println("Before getStatus()");
      return node.getStatus();
    } finally {
      System.out.println("After getStatus()");
    }
  }

  @Override
  public HealthCheck getHealthCheck() {
    try {
      System.out.println("Before getHealthCheck()");
      return node.getHealthCheck();
    } finally {
      System.out.println("After getHealthCheck()");
    }
  }

  @Override
  public void drain() {
    try {
      System.out.println("Before drain()");
      node.drain();
    } finally {
      System.out.println("After drain()");
    }

  }

  @Override
  public boolean isReady() {
    try {
      System.out.println("Before isReady()");
      return node.isReady();
    } finally {
      System.out.println("After isReady()");
    }
  }
}

注释：

在上述示例中，Node node = LocalNodeFactory.create(config); 这一行显式创建了一个 LocalNode。

org.openqa.selenium.grid.node.Node 主要有两种面向用户的实现。

这些类是学习如何构建自定义 Node 以及了解 Node 内部机制的良好起点。

org.openqa.selenium.grid.node.local.LocalNode - 用于表示长时间运行的 Node，也是默认实现。启动 node 时会自动接入。
- 可通过 LocalNodeFactory.create(config); 创建，其中：
  - LocalNodeFactory 属于 org.openqa.selenium.grid.node.local
  - Config 属于 org.openqa.selenium.grid.config
org.openqa.selenium.grid.node.k8s.OneShotNode - 这是一个特殊的参考实现，节点在服务完一个测试会话后会自动关闭。该类目前未包含在任何预构建的 maven 包中。
- 你可以在这里查看源码。
- 参考这里了解本地构建方法。
- 可通过 OneShotNode.create(config) 创建，其中：
  - OneShotNode 属于 org.openqa.selenium.grid.node.k8s
  - Config 属于 org.openqa.selenium.grid.config

5 - 外部数据存储

简介

Selenium Grid 支持将正在运行的会话相关信息持久化到外部数据存储中。外部数据存储可以由你选择的数据库或 Redis 缓存系统提供支持。

配置

Coursier - 作为依赖解析器，用于按需下载 Maven 构件并将其添加到类路径中。
Docker - 用于管理 PostgreSQL 和 Redis 容器。

基于数据库的会话映射

本示例使用 PostgreSQL 数据库。

我们将通过 Docker Compose 文件启动一个 PostgreSQL 数据库容器。

步骤

如果你已有可用的 PostgreSQL 数据库实例，可以跳过此步骤。

创建名为 init.sql 的 SQL 文件，内容如下：

CREATE TABLE IF NOT EXISTS sessions_map(
    session_ids varchar(256),
    session_caps text,
    session_uri varchar(256),
    session_stereotype text,
    session_start varchar(256)
 );

在 init.sql 所在目录中创建名为 docker-compose.yml 的文件，内容如下：

version: '3.8'
services:
  db:
    image: postgres:9.6-bullseye
    restart: always
    environment:
      - POSTGRES_USER=seluser
      - POSTGRES_PASSWORD=seluser
      - POSTGRES_DB=selenium_sessions
    ports:
      - "5432:5432"
    volumes:
    - ./init.sql:/docker-entrypoint-initdb.d/init.sql

现在可以运行以下命令启动数据库容器：

docker-compose up -d

数据库名称为 selenium_sessions，用户名和密码均为 seluser。

如果你使用的是已经运行的 PostgreSQL 数据库实例，只需创建名为 selenium_sessions 的数据库，并使用上面的 SQL 语句创建 sessions_map 表。

创建名为 sessions.toml 的 Selenium Grid 配置文件，内容如下：

[sessions]
implementation = "org.openqa.selenium.grid.sessionmap.jdbc.JdbcBackedSessionMap"
jdbc-url = "jdbc:postgresql://localhost:5432/selenium_sessions"
jdbc-user = "seluser"
jdbc-password = "seluser"

_注意：_如果你使用的是已有的 PostgreSQL 数据库实例，请将 localhost:5432 替换为该实例的实际主机名和端口号。

下面的简单 shell 脚本（命名为 distributed.sh）用于启动分布式 Grid：

SE_VERSION=<current_selenium_version>
JAR_NAME=selenium-server-${SE_VERSION}.jar
PUBLISH="--publish-events tcp://localhost:4442"
SUBSCRIBE="--subscribe-events tcp://localhost:4443"
SESSIONS="--sessions http://localhost:5556"
SESSIONS_QUEUE="--sessionqueue http://localhost:5559"
echo 'Starting Event Bus'
java -jar $JAR_NAME event-bus $PUBLISH $SUBSCRIBE --port 5557 &
echo 'Starting New Session Queue'
java -jar $JAR_NAME sessionqueue --port 5559 &
echo 'Starting Sessions Map'
java -jar $JAR_NAME \
--ext $(coursier fetch -p org.seleniumhq.selenium:selenium-session-map-jdbc:${SE_VERSION} org.postgresql:postgresql:42.3.1) \
sessions $PUBLISH $SUBSCRIBE --port 5556 --config sessions.toml &
echo 'Starting Distributor'
java -jar $JAR_NAME  distributor $PUBLISH $SUBSCRIBE $SESSIONS $SESSIONS_QUEUE --port 5553 --bind-bus false &
echo 'Starting Router'
java -jar $JAR_NAME router $SESSIONS --distributor http://localhost:5553 $SESSIONS_QUEUE --port 4444 &
echo 'Starting Node'
java -jar $JAR_NAME node $PUBLISH $SUBSCRIBE &

此时，当前目录应包含以下文件：
- docker-compose.yml
- init.sql
- sessions.toml
- distributed.sh
现在可以运行 distributed.sh 脚本启动 Grid 并快速运行测试。此时，Grid 会将会话信息存储到 PostgreSQL 数据库中。

在某台机器上启动 SessionMap 的命令如下：

export SE_VERSION=<current_selenium_version>
java -jar selenium-server-${SE_VERSION}.jar \
--ext $(coursier fetch -p org.seleniumhq.selenium:selenium-session-map-jdbc:${SE_VERSION} org.postgresql:postgresql:42.3.1) \
sessions --publish-events tcp://localhost:4442 \
--subscribe-events tcp://localhost:4443 \
--port 5556 --config sessions.toml

为便于说明，上述脚本中的变量名已替换为实际值。
请将 localhost 替换为运行事件总线的机器的实际主机名。
传递给 coursier 的参数是 Maven 坐标，即 GAV（Group、Artifact、Version）：
- selenium-session-map-jdbc 用于将会话信息存储到数据库中。
- postgresql 用于连接 PostgreSQL 数据库。
sessions.toml 是前面创建的配置文件。

基于 Redis 的会话映射

我们将通过 Docker Compose 文件启动一个 Redis 缓存容器。

步骤

如果你已有可用的 Redis 缓存实例，可以跳过此步骤。

创建名为 docker-compose.yml 的文件，内容如下：

version: '3.8'
services:
  redis:
    image: redis:bullseye
    restart: always
    ports:
      - "6379:6379"

现在可以运行以下命令启动 Redis 容器：

docker-compose up -d

创建名为 sessions.toml 的 Selenium Grid 配置文件，内容如下：

[sessions]
scheme = "redis"
implementation = "org.openqa.selenium.grid.sessionmap.redis.RedisBackedSessionMap"
hostname = "localhost"
port = 6379

_注意：_如果你使用的是已有的 Redis 缓存实例，请将 localhost 和 6379 替换为该实例的实际主机名和端口号。

下面的简单 shell 脚本（命名为 distributed.sh）用于启动分布式 Grid：

SE_VERSION=<current_selenium_version>
JAR_NAME=selenium-server-${SE_VERSION}.jar
PUBLISH="--publish-events tcp://localhost:4442"
SUBSCRIBE="--subscribe-events tcp://localhost:4443"
SESSIONS="--sessions http://localhost:5556"
SESSIONS_QUEUE="--sessionqueue http://localhost:5559"
echo 'Starting Event Bus'
java -jar $JAR_NAME event-bus $PUBLISH $SUBSCRIBE --port 5557 &
echo 'Starting New Session Queue'
java -jar $JAR_NAME sessionqueue --port 5559 &
echo 'Starting Session Map'
java -jar $JAR_NAME \
--ext $(coursier fetch -p org.seleniumhq.selenium:selenium-session-map-redis:${SE_VERSION}) \
sessions $PUBLISH $SUBSCRIBE --port 5556 --config sessions.toml &
echo 'Starting Distributor'
java -jar $JAR_NAME  distributor $PUBLISH $SUBSCRIBE $SESSIONS $SESSIONS_QUEUE --port 5553 --bind-bus false &
echo 'Starting Router'
java -jar $JAR_NAME router $SESSIONS --distributor http://localhost:5553 $SESSIONS_QUEUE --port 4444 &
echo 'Starting Node'
java -jar $JAR_NAME node $PUBLISH $SUBSCRIBE &

此时，当前目录应包含以下文件：
- docker-compose.yml
- sessions.toml
- distributed.sh
现在可以运行 distributed.sh 脚本启动 Grid 并快速运行测试。此时，Grid 会将会话信息存储到 Redis 实例中。你也可以使用 Redis GUI（例如 TablePlus）查看会话信息。请确保在测试中设置断点，因为测试运行结束后，这些值会被删除。

在某台机器上启动 SessionMap 的命令如下：

export SE_VERSION=<current_selenium_version>
java -jar selenium-server-${SE_VERSION}.jar \
--ext $(coursier fetch -p org.seleniumhq.selenium:selenium-session-map-redis:${SE_VERSION}) \
sessions --publish-events tcp://localhost:4442 \
--subscribe-events tcp://localhost:4443 \
--port 5556 --config sessions.toml

为便于说明，上述脚本中的变量名已替换为实际值。
请将 localhost 替换为运行事件总线的机器的实际主机名。
传递给 coursier 的参数是 Maven 坐标，即 GAV（Group、Artifact、Version）：
- selenium-session-map-redis 用于将会话信息存储到 Redis 缓存中。
sessions.toml 是前面创建的配置文件。

高级功能

1 - 可观测性

Table of Contents

Selenium Grid

Observability

Distributed tracing

Event logging

Grid Observability

Visualizing Traces

Leveraging event logs

References

2 - GraphQL查询支持

枚举

标量

模式的结构

查询 GraphQL

查询网格中 maxSession 和 sessionCount 的数量:

查询全部会话、及节点以及网格的详情 :

查询以获取当前网格的会话总数 :

查询以获取网格中的最大会话数量 :

查询以获取网格中所有节点的全部会话详情 :

查询以获取网格中每个节点中所有会话的插槽信息 :

查询以获取给定会话的会话信息查询以获取给定会话的会话信息 :

查询网格中每个节点的功能 :

查询网格中每个节点的状态 :

查询每个节点和网格的 URI :

Query for getting the current requests in the New Session Queue:

Query for getting the New Session Queue size :

3 - Grid端点

Grid

Grid 状态

删除会话

我应该使用哪一个URL?

分发器

删除节点

释放节点

节点

状态

释放

检查会话所有者

删除会话

新会话队列

清除新会话队列

获取新会话队列请求

4 - 自定义Node

如何自定义节点

作为 uber jar 的自定义 Node

作为普通 jar 的自定义 Node

5 - 外部数据存储

目录

简介

配置

基于数据库的会话映射

步骤

基于 Redis 的会话映射

步骤

Development Partners

Selenium Level Sponsors

Support the Selenium Project

查询网格中 `maxSession` 和 `sessionCount` 的数量: