java - 使用 Jacoco Agent 远程触发 jacoco 执行数据转储

Question

我用的是官方example Socket server为我的 jacocoagent.jar 启动一个套接字服务器来连接。我这样启动我的目标 jar :

java -javaagent:jacocoagent.jar=dumponexit=false,output=tcpclient,address=localhost,port=6300 -jar demo-0.0.1-SNAPSHOT.jar

我修改了服务器代码以添加捕获转储的方法。以下是完整代码:

public class JacocoSocketServer {
    private static final String DESTFILE = "jacoco-server.exec";
    private static final String ADDRESS = "localhost";
    private static final int PORT = 6300;

    private static final Logger LOGGER = Logger.getLogger(JacocoSocketServer.class.getName());
    /**
     * Start the server as a standalone program.
     *
     * @param args
     * @throws IOException
     */
    public static void main(final String[] args) throws IOException {

        LOGGER.log(Level.INFO, "Output file is " + new File(DESTFILE).getAbsolutePath());

        final RemoteControlWriter fileWriter = new RemoteControlWriter(new FileOutputStream(DESTFILE));

        LOGGER.log(Level.INFO, "Starting TCP server on: " + ADDRESS + ":" + PORT);

        final ServerSocket server = new ServerSocket(PORT, 0, InetAddress.getByName(ADDRESS));
        final List<Handler> listHandler = new ArrayList<>();

        Runnable runDumpTimer = () -> {
            while (true) {
                Iterator<Handler> it = listHandler.iterator();
                while (it.hasNext()) {
                    Handler handler = it.next();
                    boolean toRemove = false;
                    String id = handler.getId();
                    try {
                        if (!handler.isAlive()) {
                            LOGGER.log(Level.INFO, String.format("Socket closed, removing handler: %s", id));
                            toRemove = true;
                        } else {
                            handler.captureDump(true, true);
                        }
                    } catch (IOException e) {
                        LOGGER.log(Level.INFO, "Socket error: " + e.getMessage() + ", removing handler: " + id);
                        toRemove = true;
                    } finally {
                        if (toRemove) {
                            it.remove();
                        }
                    }
                }
            }
        };
        Thread threadDumpTimer = new Thread(runDumpTimer, "threadDumpTimer");
        threadDumpTimer.start();
        while (true) {
            Socket socket = server.accept();
            System.out.println("Remote connection detected, openning socket on local port: "
                    + socket.getLocalPort());
            final Handler handler = new Handler(socket, fileWriter);
            listHandler.add(handler);
            new Thread(handler).start();
        }
    }
    private static class Handler
            implements
            Runnable,
            ISessionInfoVisitor,
            IExecutionDataVisitor {
        private final Socket socket;
        private final RemoteControlReader reader;
        private final RemoteControlWriter fileWriter;
        private final RemoteControlWriter remoteWriter;
        private String id;
        public String getId() {
            return id;
        }
        Handler(final Socket socket, final RemoteControlWriter fileWriter) throws IOException {
            this.socket = socket;
            this.fileWriter = fileWriter;
            // Just send a valid header:
            remoteWriter = new RemoteControlWriter(socket.getOutputStream());
            reader = new RemoteControlReader(socket.getInputStream());
            reader.setSessionInfoVisitor(this);
            reader.setExecutionDataVisitor(this);
        }
        public void run() {
            try {
                while (reader.read()) {
                }
                socket.close();
                synchronized (fileWriter) {
                    fileWriter.flush();
                }
            } catch (final IOException e) {
                e.printStackTrace();
            }
        }

        public void visitSessionInfo(final SessionInfo info) {
            id = info.getId();
            LOGGER.log(Level.INFO, String.format("Retrieving execution Data for session: %s", info.getId()));
            synchronized (fileWriter) {
                fileWriter.visitSessionInfo(info);
            }
        }
        public void visitClassExecution(final ExecutionData data) {
            synchronized (fileWriter) {
                fileWriter.visitClassExecution(data);
            }
        }
        void captureDump(boolean dump, boolean reset) throws IOException {
            remoteWriter.visitDumpCommand(dump, reset);
        }
        boolean isAlive() {
            return socket != null
                    && socket.isConnected();
        }
    }
}

上面的代码会无限期地向指定文件写入转储，这显然不是预期的结果。

启动服务器后，我将启动目标 jar，我将在 jar 上运行一些功能测试用例。这些测试用例完成后，我想触发执行数据转储并重置存储，以便下次触发转储时，它只会包含有关相关 session 的数据。

PS:我曾经定期运行服务器以在指定的时间间隔进行转储(因此使用了一些变量名称)，但这不再需要了。

PPS:我已经阅读了以下问题，所有这些问题都与我的要求相似，但我想不出一种方法来远程转储命令数据:

https://groups.google.com/forum/#!msg/jacoco/MUTIM5yS6ZQ/KSA5Og4xBgAJ

https://sourceforge.net/p/eclemma/discussion/614870/thread/083acdaa/

https://groups.google.com/forum/#!topic/jacoco/QAmXUZjviPk

https://groups.google.com/forum/#!msg/jacoco/V7Bmz5r0P24/PdCC5apIoqgJ

Answer 1

我还没做呢。但从我一直在阅读的内容来看，我想做你想做的事情。根据我的阅读，您需要以 tcpserver 模式启动 jacoco 代理，然后让远程客户端启动转储。我在网上找到了这个可能有效的客户端代码:https://github.com/Wageesha95/TCP_Client_JacocoCC/blob/master/src/main/java/client/ExecutionDataClient.java

这里是描述不同输出模式的文档:https://www.eclemma.org/jacoco/trunk/doc/agent.html

tcpserver:代理监听由地址和端口属性指定的 TCP 端口上的传入连接。执行数据写入此 TCP 连接。

所以在 tcpserver 模式下(不是你设置的 tcpclient)你启动应用程序，运行你的测试，然后连接到 tcp 服务器并启动转储。