1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
|
// Copyright 2022 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// simple_net_client_server demonstrates a minimal DAP network connection
// between a server and client.
#include "dap/io.h"
#include "dap/network.h"
#include "dap/protocol.h"
#include "dap/session.h"
#include <condition_variable>
#include <mutex>
int main(int, char*[]) {
constexpr int kPort = 19021;
// Callback handler for a socket connection to the server
auto onClientConnected =
[&](const std::shared_ptr<dap::ReaderWriter>& socket) {
auto session = dap::Session::create();
session->bind(socket);
// The Initialize request is the first message sent from the client and
// the response reports debugger capabilities.
// https://microsoft.github.io/debug-adapter-protocol/specification#Requests_Initialize
session->registerHandler([&](const dap::InitializeRequest&) {
dap::InitializeResponse response;
printf("Server received initialize request from client\n");
return response;
});
// Signal used to terminate the server session when a DisconnectRequest
// is made by the client.
bool terminate = false;
std::condition_variable cv;
std::mutex mutex; // guards 'terminate'
// The Disconnect request is made by the client before it disconnects
// from the server.
// https://microsoft.github.io/debug-adapter-protocol/specification#Requests_Disconnect
session->registerHandler([&](const dap::DisconnectRequest&) {
// Client wants to disconnect. Set terminate to true, and signal the
// condition variable to unblock the server thread.
std::unique_lock<std::mutex> lock(mutex);
terminate = true;
cv.notify_one();
return dap::DisconnectResponse{};
});
// Wait for the client to disconnect (or reach a 5 second timeout)
// before releasing the session and disconnecting the socket to the
// client.
std::unique_lock<std::mutex> lock(mutex);
cv.wait_for(lock, std::chrono::seconds(5), [&] { return terminate; });
printf("Server closing connection\n");
};
// Error handler
auto onError = [&](const char* msg) { printf("Server error: %s\n", msg); };
// Create the network server
auto server = dap::net::Server::create();
// Start listening on kPort.
// onClientConnected will be called when a client wants to connect.
// onError will be called on any connection errors.
server->start(kPort, onClientConnected, onError);
// Create a socket to the server. This will be used for the client side of the
// connection.
auto client = dap::net::connect("localhost", kPort);
if (!client) {
printf("Couldn't connect to server\n");
return 1;
}
// Attach a session to the client socket.
auto session = dap::Session::create();
session->bind(client);
// Set an initialize request to the server.
auto future = session->send(dap::InitializeRequest{});
printf("Client sent initialize request to server\n");
printf("Waiting for response from server...\n");
// Wait on the response.
auto response = future.get();
printf("Response received from server\n");
printf("Disconnecting...\n");
// Disconnect.
session->send(dap::DisconnectRequest{});
return 0;
}
|
