1//===-- RunInTerminal.cpp ---------------------------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "RunInTerminal.h"
10#include "JSONUtils.h"
11
12#if !defined(_WIN32)
13#include <sys/stat.h>
14#include <sys/types.h>
15#include <unistd.h>
16#endif
17
18#include <chrono>
19#include <future>
20
21#include "llvm/Support/FileSystem.h"
22
23using namespace llvm;
24
25namespace lldb_dap {
26
27const RunInTerminalMessagePid *RunInTerminalMessage::GetAsPidMessage() const {
28 return static_cast<const RunInTerminalMessagePid *>(this);
29}
30
31const RunInTerminalMessageError *
32RunInTerminalMessage::GetAsErrorMessage() const {
33 return static_cast<const RunInTerminalMessageError *>(this);
34}
35
36RunInTerminalMessage::RunInTerminalMessage(RunInTerminalMessageKind kind)
37 : kind(kind) {}
38
39RunInTerminalMessagePid::RunInTerminalMessagePid(lldb::pid_t pid)
40 : RunInTerminalMessage(eRunInTerminalMessageKindPID), pid(pid) {}
41
42json::Value RunInTerminalMessagePid::ToJSON() const {
43 return json::Object{{.K: "kind", .V: "pid"}, {.K: "pid", .V: static_cast<int64_t>(pid)}};
44}
45
46RunInTerminalMessageError::RunInTerminalMessageError(StringRef error)
47 : RunInTerminalMessage(eRunInTerminalMessageKindError), error(error) {}
48
49json::Value RunInTerminalMessageError::ToJSON() const {
50 return json::Object{{.K: "kind", .V: "error"}, {.K: "value", .V: error}};
51}
52
53RunInTerminalMessageDidAttach::RunInTerminalMessageDidAttach()
54 : RunInTerminalMessage(eRunInTerminalMessageKindDidAttach) {}
55
56json::Value RunInTerminalMessageDidAttach::ToJSON() const {
57 return json::Object{{.K: "kind", .V: "didAttach"}};
58}
59
60static Expected<RunInTerminalMessageUP>
61ParseJSONMessage(const json::Value &json) {
62 if (const json::Object *obj = json.getAsObject()) {
63 if (std::optional<StringRef> kind = obj->getString(K: "kind")) {
64 if (*kind == "pid") {
65 if (std::optional<int64_t> pid = obj->getInteger(K: "pid"))
66 return std::make_unique<RunInTerminalMessagePid>(
67 args: static_cast<lldb::pid_t>(*pid));
68 } else if (*kind == "error") {
69 if (std::optional<StringRef> error = obj->getString(K: "error"))
70 return std::make_unique<RunInTerminalMessageError>(args&: *error);
71 } else if (*kind == "didAttach") {
72 return std::make_unique<RunInTerminalMessageDidAttach>();
73 }
74 }
75 }
76
77 return createStringError(EC: inconvertibleErrorCode(),
78 S: "Incorrect JSON message: " + JSONToString(json));
79}
80
81static Expected<RunInTerminalMessageUP>
82GetNextMessage(FifoFileIO &io, std::chrono::milliseconds timeout) {
83 if (Expected<json::Value> json = io.ReadJSON(timeout))
84 return ParseJSONMessage(json: *json);
85 else
86 return json.takeError();
87}
88
89static Error ToError(const RunInTerminalMessage &message) {
90 if (message.kind == eRunInTerminalMessageKindError)
91 return createStringError(EC: inconvertibleErrorCode(),
92 S: message.GetAsErrorMessage()->error);
93 return createStringError(EC: inconvertibleErrorCode(),
94 S: "Unexpected JSON message: " +
95 JSONToString(json: message.ToJSON()));
96}
97
98RunInTerminalLauncherCommChannel::RunInTerminalLauncherCommChannel(
99 StringRef comm_file)
100 : m_io(comm_file, "debug adapter") {}
101
102Error RunInTerminalLauncherCommChannel::WaitUntilDebugAdapterAttaches(
103 std::chrono::milliseconds timeout) {
104 if (Expected<RunInTerminalMessageUP> message =
105 GetNextMessage(io&: m_io, timeout)) {
106 if (message.get()->kind == eRunInTerminalMessageKindDidAttach)
107 return Error::success();
108 else
109 return ToError(message: *message.get());
110 } else
111 return message.takeError();
112}
113
114Error RunInTerminalLauncherCommChannel::NotifyPid() {
115 return m_io.SendJSON(json: RunInTerminalMessagePid(getpid()).ToJSON());
116}
117
118void RunInTerminalLauncherCommChannel::NotifyError(StringRef error) {
119 if (Error err = m_io.SendJSON(json: RunInTerminalMessageError(error).ToJSON(),
120 timeout: std::chrono::seconds(2)))
121 llvm::errs() << llvm::toString(E: std::move(err)) << "\n";
122}
123
124RunInTerminalDebugAdapterCommChannel::RunInTerminalDebugAdapterCommChannel(
125 StringRef comm_file)
126 : m_io(comm_file, "runInTerminal launcher") {}
127
128// Can't use \a std::future<llvm::Error> because it doesn't compile on Windows
129std::future<lldb::SBError>
130RunInTerminalDebugAdapterCommChannel::NotifyDidAttach() {
131 return std::async(policy: std::launch::async, fn: [&]() {
132 lldb::SBError error;
133 if (llvm::Error err =
134 m_io.SendJSON(json: RunInTerminalMessageDidAttach().ToJSON()))
135 error.SetErrorString(llvm::toString(E: std::move(err)).c_str());
136 return error;
137 });
138}
139
140Expected<lldb::pid_t> RunInTerminalDebugAdapterCommChannel::GetLauncherPid() {
141 if (Expected<RunInTerminalMessageUP> message =
142 GetNextMessage(io&: m_io, timeout: std::chrono::seconds(20))) {
143 if (message.get()->kind == eRunInTerminalMessageKindPID)
144 return message.get()->GetAsPidMessage()->pid;
145 return ToError(message: *message.get());
146 } else {
147 return message.takeError();
148 }
149}
150
151std::string RunInTerminalDebugAdapterCommChannel::GetLauncherError() {
152 // We know there's been an error, so a small timeout is enough.
153 if (Expected<RunInTerminalMessageUP> message =
154 GetNextMessage(io&: m_io, timeout: std::chrono::seconds(1)))
155 return toString(E: ToError(message: *message.get()));
156 else
157 return toString(E: message.takeError());
158}
159
160Expected<std::shared_ptr<FifoFile>> CreateRunInTerminalCommFile() {
161 SmallString<256> comm_file;
162 if (std::error_code EC = sys::fs::getPotentiallyUniqueTempFileName(
163 Prefix: "lldb-dap-run-in-terminal-comm", Suffix: "", ResultPath&: comm_file))
164 return createStringError(EC, S: "Error making unique file name for "
165 "runInTerminal communication files");
166
167 return CreateFifoFile(path: comm_file.str());
168}
169
170} // namespace lldb_dap
171

source code of lldb/tools/lldb-dap/RunInTerminal.cpp