This is an archive of the discontinued LLVM Phabricator instance.

Differential D50452

[WIP] clangd XPC adapter
AbandonedPublic

Authored by jkorous on Aug 8 2018, 8:20 AM.

Details

Reviewers
arphaman
sammccall
ilya-biryukov
simark
Summary

Based on our internal discussions we decided to change our direction with XPC support for clangd. We did some extra measurements and found out that JSON serialized over XPC is good enough for our use-case. We also took into consideration that we'd have to deal with support for multiple workspaces in near future.

Probably the simplest solution is to keep XPC completely out of clangd binary and use one clangd instance per workspace. This design means it's the least intrusive change, it's rather simple (compared to adding support for multiple workspaces to clangd itself) and robust (compared to threads-based implementation). Long-term it's hopefully also going to be less maintenance-demanding since it's dependent only on LSP and not it's implementation.

The patch is nearly finished - I just wanted to get some feedback on the design early on (before finishing doxygen annotations, documentation, etc.).

Our approach to testing for the future is to reuse existing clangd lit tests and just send messages through our XPC code. For the time being there's just a single minimal testcase.

Diff Detail

Revision Contents

PathSize
test/
7 lines
4 lines
1 line
1 line
clangd/
unittests/
clangd/
2 lines
clangd/
xpc/
10 lines
xpc/
17 lines
6 lines
cmake/
28 lines
30 lines
modules/
81 lines
framework/
12 lines
5 lines
test-client/
25 lines
103 lines
tool/
5 lines
35 lines
338 lines
84 lines
378 lines
172 lines
49 lines

Diff 159717

CMakeLists.txt

Show All 10 Linesif (CMAKE_CFG_INTDIR STREQUAL ".")
set(LLVM_BUILD_MODE ".") set(LLVM_BUILD_MODE ".")
else () else ()
set(LLVM_BUILD_MODE "%(build_mode)s") set(LLVM_BUILD_MODE "%(build_mode)s")
endif () endif ()
string(REPLACE ${CMAKE_CFG_INTDIR} ${LLVM_BUILD_MODE} CLANG_TOOLS_DIR ${LLVM_RUNTIME_OUTPUT_INTDIR}) string(REPLACE ${CMAKE_CFG_INTDIR} ${LLVM_BUILD_MODE} CLANG_TOOLS_DIR ${LLVM_RUNTIME_OUTPUT_INTDIR})
llvm_canonicalize_cmake_booleans( llvm_canonicalize_cmake_booleans(
CLANG_ENABLE_STATIC_ANALYZER) CLANG_ENABLE_STATIC_ANALYZER
CLANGD_BUILD_XPC)
configure_lit_site_cfg( configure_lit_site_cfg(
${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg
) )
configure_lit_site_cfg( configure_lit_site_cfg(
${CMAKE_CURRENT_SOURCE_DIR}/Unit/lit.site.cfg.in ${CMAKE_CURRENT_SOURCE_DIR}/Unit/lit.site.cfg.in
Show All 39 Lines list(APPEND CLANG_TOOLS_TEST_DEPS
c-index-test c-index-test
# clang-tidy tests require it. # clang-tidy tests require it.
clang-headers clang-headers
clang-tidy clang-tidy
) )
endif() endif()
if(CLANGD_BUILD_XPC)
list(APPEND CLANG_TOOLS_TEST_DEPS clangd-xpc-test-client)
endif()
set(llvm_utils set(llvm_utils
FileCheck count not FileCheck count not
) )
foreach(t ${llvm_utils}) foreach(t ${llvm_utils})
if(TARGET ${t}) if(TARGET ${t})
list(APPEND CLANG_TOOLS_TEST_DEPS ${t}) list(APPEND CLANG_TOOLS_TEST_DEPS ${t})
endif() endif()
Show All 9 Lines

Features.inc.in

  • This file was added.
#define CLANGD_BUILD_XPC @CLANGD_BUILD_XPC@

clangd/CMakeLists.txt

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Linestarget_link_libraries(ClangdTests
clangIndex clangIndex
clangLex clangLex
clangSema clangSema
clangTooling clangTooling
clangToolingCore clangToolingCore
clangToolingInclusions clangToolingInclusions
LLVMSupport LLVMSupport
LLVMTestingSupport LLVMTestingSupport
) )
No newline at end of file

clangd/xpc/initialize.test

  • This file was added.
# RUN: clangd-xpc-test-client < %s | FileCheck %s
# REQUIRES: clangd-xpc-support
{"jsonrpc":"2.0","id":0,"method":"initialize","params":{"processId":123,"rootUri":"test:///workspace","capabilities":{},"trace":"off"}}
# CHECK-DAG: {"id":0,"jsonrpc":"2.0","result":{"capabilities":{"codeActionProvider":true,"completionProvider":{"resolveProvider":false,"triggerCharacters":[".",">",":"]},"definitionProvider":true,"documentFormattingProvider":true,"documentHighlightProvider":true,"documentOnTypeFormattingProvider":{"firstTriggerCharacter":"}","moreTriggerCharacter":[]},"documentRangeFormattingProvider":true,"documentSymbolProvider":true,"executeCommandProvider":{"commands":["clangd.applyFix"]},"hoverProvider":true,"renameProvider":true,"signatureHelpProvider":{"triggerCharacters":["(",","]},"textDocumentSync":2,"workspaceSymbolProvider":true}}}
{"jsonrpc":"2.0","id":3,"method":"shutdown"}
# CHECK-DAG: {"id":3,"jsonrpc":"2.0","result":null}
{"jsonrpc":"2.0","method":"exit"}

lit.cfg

Show First 20 Lines • Show All 111 Lines • ▼ Show 20 Lines
# Exclude MSYS due to transforming '/' to 'X:/mingwroot/'. # Exclude MSYS due to transforming '/' to 'X:/mingwroot/'.
if not platform.system() in ['Windows'] or not execute_external: if not platform.system() in ['Windows'] or not execute_external:
config.available_features.add('shell-preserves-root') config.available_features.add('shell-preserves-root')
# ANSI escape sequences in non-dumb terminal # ANSI escape sequences in non-dumb terminal
if platform.system() not in ['Windows']: if platform.system() not in ['Windows']:
config.available_features.add('ansi-escape-sequences') config.available_features.add('ansi-escape-sequences')
# XPC support for Clangd.
if config.clangd_xpc_support:
config.available_features.add('clangd-xpc-support')
if config.clang_staticanalyzer: if config.clang_staticanalyzer:
config.available_features.add('static-analyzer') config.available_features.add('static-analyzer')
check_clang_tidy = os.path.join( check_clang_tidy = os.path.join(
config.test_source_root, "clang-tidy", "check_clang_tidy.py") config.test_source_root, "clang-tidy", "check_clang_tidy.py")
config.substitutions.append( config.substitutions.append(
('%check_clang_tidy', ('%check_clang_tidy',
'%s %s' % (config.python_executable, check_clang_tidy)) ) '%s %s' % (config.python_executable, check_clang_tidy)) )
clang_tidy_diff = os.path.join( clang_tidy_diff = os.path.join(
Show All 12 Lines

lit.site.cfg.in

@LIT_SITE_CFG_IN_HEADER@ @LIT_SITE_CFG_IN_HEADER@
import sys import sys
config.llvm_tools_dir = "@LLVM_TOOLS_DIR@" config.llvm_tools_dir = "@LLVM_TOOLS_DIR@"
config.llvm_libs_dir = "@LLVM_LIBS_DIR@" config.llvm_libs_dir = "@LLVM_LIBS_DIR@"
config.lit_tools_dir = "@LLVM_LIT_TOOLS_DIR@" config.lit_tools_dir = "@LLVM_LIT_TOOLS_DIR@"
config.clang_tools_binary_dir = "@CLANG_TOOLS_BINARY_DIR@" config.clang_tools_binary_dir = "@CLANG_TOOLS_BINARY_DIR@"
config.clang_tools_dir = "@CLANG_TOOLS_DIR@" config.clang_tools_dir = "@CLANG_TOOLS_DIR@"
config.clang_libs_dir = "@SHLIBDIR@" config.clang_libs_dir = "@SHLIBDIR@"
config.python_executable = "@PYTHON_EXECUTABLE@" config.python_executable = "@PYTHON_EXECUTABLE@"
config.target_triple = "@TARGET_TRIPLE@" config.target_triple = "@TARGET_TRIPLE@"
config.clang_staticanalyzer = @CLANG_ENABLE_STATIC_ANALYZER@ config.clang_staticanalyzer = @CLANG_ENABLE_STATIC_ANALYZER@
config.clangd_xpc_support = @CLANGD_BUILD_XPC@
# Support substitution of the tools and libs dirs with user parameters. This is # Support substitution of the tools and libs dirs with user parameters. This is
# used when we can't determine the tool dir at configuration time. # used when we can't determine the tool dir at configuration time.
try: try:
config.clang_tools_dir = config.clang_tools_dir % lit_config.params config.clang_tools_dir = config.clang_tools_dir % lit_config.params
config.llvm_tools_dir = config.llvm_tools_dir % lit_config.params config.llvm_tools_dir = config.llvm_tools_dir % lit_config.params
config.llvm_libs_dir = config.llvm_libs_dir % lit_config.params config.llvm_libs_dir = config.llvm_libs_dir % lit_config.params
except KeyError: except KeyError:
e = sys.exc_info()[1] e = sys.exc_info()[1]
key, = e.args key, = e.args
lit_config.fatal("unable to find %r parameter, use '--param=%s=VALUE'" % (key,key)) lit_config.fatal("unable to find %r parameter, use '--param=%s=VALUE'" % (key,key))
@LIT_SITE_CFG_IN_FOOTER@ @LIT_SITE_CFG_IN_FOOTER@
# Let the main config do the real work. # Let the main config do the real work.
lit_config.load_config(config, "@CLANG_TOOLS_SOURCE_DIR@/test/lit.cfg") lit_config.load_config(config, "@CLANG_TOOLS_SOURCE_DIR@/test/lit.cfg")

xpc/CMakeLists.txt

  • This file was added.
set(CLANGD_XPC_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
set(CLANGD_XPC_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}")
list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules")
include(CreateClangdXPCFramework)
add_subdirectory(framework)
add_subdirectory(test-client)
add_subdirectory(tool)
include_directories(
${CMAKE_CURRENT_SOURCE_DIR}/../
)
set(LLVM_LINK_COMPONENTS
Support
)
No newline at end of file

xpc/README.txt

  • This file was added.
This directory contains:
- the XPC transport layer (alternative transport layer to JSON-RPC)
- XPC framework wrapper that wraps around Clangd to make it a valid XPC service
- XPC test-client
MacOS only. Feature is guarded by CLANGD_BUILD_XPC, including whole xpc/ dir.
No newline at end of file

xpc/cmake/Info.plist.in

  • This file was added.
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>CFBundleDevelopmentRegion</key>
<string>English</string>
<key>CFBundleExecutable</key>
<string>${CLANGD_XPC_FRAMEWORK_NAME}</string>
<key>CFBundleIconFile</key>
<string></string>
<key>CFBundleIdentifier</key>
<string>org.llvm.${CLANGD_XPC_FRAMEWORK_NAME}</string>
<key>CFBundleInfoDictionaryVersion</key>
<string>6.0</string>
<key>CFBundleName</key>
<string>${CLANGD_XPC_FRAMEWORK_NAME}</string>
<key>CFBundlePackageType</key>
<string>FMWK</string>
<key>CFBundleSignature</key>
<string>????</string>
<key>CFBundleVersion</key>
<string></string>
<key>CFBundleShortVersionString</key>
<string>1.0</string>
<key>CSResourcesFileMapped</key>
<true/>
</dict>
</plist>

xpc/cmake/XPCServiceInfo.plist.in

  • This file was added.
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>CFBundleExecutable</key>
<string>clangd-xpc-adapter</string>
<key>CFBundleIdentifier</key>
<string>${CLANGD_XPC_SERVICE_BUNDLE_NAME}</string>
<key>CFBundleInfoDictionaryVersion</key>
<string>6.0</string>
<key>CFBundleName</key>
<string>${CLANGD_XPC_SERVICE_NAME}</string>
<key>CFBundlePackageType</key>
<string>XPC!</string>
<key>CFBundleVersion</key>
<string></string>
<key>CFBundleShortVersionString</key>
<string>1.0</string>
<key>XPCService</key>
<dict>
<key>ServiceType</key>
<string>Application</string>
<key>EnvironmentVariables</key>
<dict>
<key>CLANGD_PATH</key>
<string>${CLANGD_PATH_IN_CLANGDXPC_SERVICE}</string>
</dict>
</dict>
</dict>
</plist>

xpc/cmake/modules/CreateClangdXPCFramework.cmake

  • This file was added.
# Creates the ClangdXPC framework.
macro(create_clangd_xpc_framework target name)
set(CLANGD_FRAMEWORK_LOCATION "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${name}.framework")
set(CLANGD_FRAMEWORK_OUT_LOCATION "${CLANGD_FRAMEWORK_LOCATION}/Versions/A")
# Create the framework info PLIST.
set(CLANGD_XPC_FRAMEWORK_NAME "${name}")
configure_file(
"${CLANGD_XPC_SOURCE_DIR}/cmake/Info.plist.in"
"${CLANGD_XPC_BINARY_DIR}/${name}.Info.plist")
set(CLANGD_XPC_SERVICE_NAME "clangd")
set(CLANGD_XPC_SERVICE_OUT_LOCATION
"${CLANGD_FRAMEWORK_OUT_LOCATION}/XPCServices/${CLANGD_XPC_SERVICE_NAME}.xpc/Contents")
# Create the XPC service info PLIST.
set(CLANGD_XPC_SERVICE_BUNDLE_NAME "org.llvm.${CLANGD_XPC_SERVICE_NAME}")
set(CLANGD_PATH_IN_CLANGDXPC_SERVICE "${CLANGD_FRAMEWORK_OUT_LOCATION}/XPCServices/${CLANGD_XPC_SERVICE_NAME}.xpc/Contents/MacOS/clangd")
configure_file(
"${CLANGD_XPC_SOURCE_DIR}/cmake/XPCServiceInfo.plist.in"
"${CLANGD_XPC_BINARY_DIR}/${name}Service.Info.plist")
# Create the custom command
add_custom_command(OUTPUT ${CLANGD_FRAMEWORK_LOCATION}
# Copy the PLIST.
COMMAND ${CMAKE_COMMAND} -E copy
"${CLANGD_XPC_BINARY_DIR}/${name}.Info.plist"
"${CLANGD_FRAMEWORK_OUT_LOCATION}/Resources/Info.plist"
# Copy the framework binary.
COMMAND ${CMAKE_COMMAND} -E copy
"${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/lib${target}.dylib"
"${CLANGD_FRAMEWORK_OUT_LOCATION}/${name}"
# Copy the XPC Service PLIST.
COMMAND ${CMAKE_COMMAND} -E copy
"${CLANGD_XPC_BINARY_DIR}/${name}Service.Info.plist"
"${CLANGD_XPC_SERVICE_OUT_LOCATION}/Info.plist"
# Copy the clangd binary.
COMMAND ${CMAKE_COMMAND} -E copy
"${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/clangd"
"${CLANGD_XPC_SERVICE_OUT_LOCATION}/MacOS/clangd"
# Copy the clangd-xpc-adapter binary.
COMMAND ${CMAKE_COMMAND} -E copy
"${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/clangd-xpc-adapter"
"${CLANGD_XPC_SERVICE_OUT_LOCATION}/MacOS/clangd-xpc-adapter"
COMMAND ${CMAKE_COMMAND} -E create_symlink "A"
"${CLANGD_FRAMEWORK_LOCATION}/Versions/Current"
COMMAND ${CMAKE_COMMAND} -E create_symlink
"Versions/Current/Resources"
"${CLANGD_FRAMEWORK_LOCATION}/Resources"
COMMAND ${CMAKE_COMMAND} -E create_symlink
"Versions/Current/XPCServices"
"${CLANGD_FRAMEWORK_LOCATION}/XPCServices"
COMMAND ${CMAKE_COMMAND} -E create_symlink
"Versions/Current/${name}"
"${CLANGD_FRAMEWORK_LOCATION}/${name}"
DEPENDS
"${CLANGD_XPC_BINARY_DIR}/${name}.Info.plist"
"${CLANGD_XPC_BINARY_DIR}/${name}Service.Info.plist"
clangd
clangd-xpc-adapter
COMMENT "Creating ClangdXPC framework"
VERBATIM
)
add_custom_target(
ClangdXPC
DEPENDS
${target}
${CLANGD_FRAMEWORK_LOCATION}
)
endmacro(create_clangd_xpc_framework)

xpc/framework/CMakeLists.txt

  • This file was added.
set(SOURCES
ClangdXPC.cpp)
add_clang_library(ClangdXPCLib SHARED
${SOURCES}
DEPENDS
clangd
clangd-xpc-adapter
)
create_clangd_xpc_framework(ClangdXPCLib "ClangdXPC")
add_dependencies(ClangdXPC clangd clangd-xpc-adapter)
No newline at end of file

xpc/framework/ClangdXPC.cpp

  • This file was added.
/// Returns the bundle identifier of the Clangd XPC service.
extern "C" const char *clangd_xpc_get_bundle_identifier() {
return "org.llvm.clangd";
}

xpc/test-client/CMakeLists.txt

  • This file was added.
include_directories(
${CMAKE_CURRENT_SOURCE_DIR}/../../
)
add_clang_tool(
clangd-xpc-test-client
ClangdXPCTestClient.cpp
DEPENDS ClangdXPC
)
set(LLVM_LINK_COMPONENTS
support
)
target_link_libraries(clangd-xpc-test-client
PRIVATE
clangBasic
clangDaemon
clangFormat
clangFrontend
clangSema
clangTooling
clangToolingCore
)

xpc/test-client/ClangdXPCTestClient.cpp

  • This file was added.
#include "clang/Basic/LLVM.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/Support/LineIterator.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/Path.h"
#include "llvm/Support/raw_ostream.h"
#include <dlfcn.h>
#include <stdio.h>
#include <string>
#include <xpc/xpc.h>
typedef const char *(*clangd_xpc_get_bundle_identifier_t)(void);
using namespace llvm;
using namespace clang;
std::string getLibraryPath() {
Dl_info info;
if (dladdr((void *)(uintptr_t)getLibraryPath, &info) == 0)
llvm_unreachable("Call to dladdr() failed");
llvm::SmallString<128> LibClangPath;
LibClangPath = llvm::sys::path::parent_path(
llvm::sys::path::parent_path(info.dli_fname));
llvm::sys::path::append(LibClangPath, "lib", "ClangdXPC.framework",
"ClangdXPC");
return LibClangPath.str();
}
static void dumpXPCObject(xpc_object_t Object, llvm::raw_ostream &OS,
std::size_t &count) {
xpc_type_t Type = xpc_get_type(Object);
if (Type == XPC_TYPE_DICTIONARY) {
const char *const payload = xpc_dictionary_get_string(Object, "payload");
count += strlen(payload);
if (payload == nullptr) {
OS << "[error]: dumpXPCObject(): object missing payload";
} else {
OS << payload;
}
} else {
OS << "[error]: dumpXPCObject(): object is not a dictionary";
}
}
int main(int argc, char *argv[]) {
// Open the ClangdXPC dylib in the framework.
std::string LibPath = getLibraryPath();
void *dlHandle = dlopen(LibPath.c_str(), RTLD_LOCAL | RTLD_FIRST);
if (!dlHandle)
return 1;
// Lookup the XPC service bundle name, and launch it.
clangd_xpc_get_bundle_identifier_t clangd_xpc_get_bundle_identifier =
(clangd_xpc_get_bundle_identifier_t)dlsym(
dlHandle, "clangd_xpc_get_bundle_identifier");
xpc_connection_t conn = xpc_connection_create(
clangd_xpc_get_bundle_identifier(), dispatch_get_main_queue());
// Dump the XPC events.
xpc_connection_set_event_handler(conn, ^(xpc_object_t event) {
static std::size_t byte_count = 0;
if (event == XPC_ERROR_CONNECTION_INVALID) {
llvm::errs() << "Received XPC_ERROR_CONNECTION_INVALID.";
llvm::errs() << "total B received: " << byte_count;
exit(EXIT_SUCCESS);
}
if (event == XPC_ERROR_CONNECTION_INTERRUPTED) {
llvm::errs() << "Received XPC_ERROR_CONNECTION_INTERRUPTED.";
llvm::errs() << "total B received: " << byte_count;
exit(EXIT_SUCCESS);
}
dumpXPCObject(event, llvm::outs(), byte_count);
llvm::outs() << "\n";
});
xpc_connection_resume(conn);
// Read the input to determine the things to send to clangd.
llvm::ErrorOr<std::unique_ptr<MemoryBuffer>> Stdin =
llvm::MemoryBuffer::getSTDIN();
if (!Stdin) {
llvm::errs() << "Failed to get STDIN!\n";
return 1;
}
for (llvm::line_iterator It(**Stdin, /*SkipBlanks=*/true,
/*CommentMarker=*/'#');
!It.is_at_eof(); ++It) {
StringRef Line = *It;
std::vector<const char *> keys = {"payload", "workspace"};
std::vector<xpc_object_t> values = {xpc_string_create(Line.str().c_str()),
xpc_string_create("test")};
auto request = xpc_dictionary_create(keys.data(), values.data(), 2);
xpc_connection_send_message(conn, request);
}
dispatch_main();
// dispatch_main() doesn't return
return EXIT_FAILURE;
}

xpc/tool/CMakeLists.txt

  • This file was added.
add_clang_tool(clangd-xpc-adapter
ClangdXpcAdapter.cpp
ClangdWorkspaceInstances.cpp
ClangdSubprocess.cpp
)
No newline at end of file

xpc/tool/ClangdSubprocess.h

  • This file was added.
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_XPC_CLANGD_SUBPROCESS_H
#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_XPC_CLANGD_SUBPROCESS_H
#include "llvm/ADT/Optional.h"
#include <string>
#include <vector>
/// Holds running clangd process data.
/// Lifetime of an instance is not automagically tied to the process.
struct ClangdSubprocess {
const pid_t PID = 0;
const int childStdOut = -1;
const int childStdErr = -1;
const int childStdIn = -1;
ClangdSubprocess(pid_t PID, int childStdOut, int childStdErr, int childStdIn);
bool writeLSPMessage(const std::string &msg);
llvm::Optional<std::string> readLSPMessage();
llvm::Optional<std::string> readStdErr();
};
llvm::Optional<ClangdSubprocess>
startClangdSubprocess(const std::string &path,
const std::vector<std::string> &args);
// Use with care - unless someone calls waitpid() the process would become a
// zombie.
void sendKillSignal(pid_t pid);
void endClangdSubprocess(pid_t pid);
#endif
No newline at end of file

xpc/tool/ClangdSubprocess.cpp

  • This file was added.
#include "ClangdSubprocess.h"
#include "log.h"
#include <signal.h>
#include <spawn.h>
ClangdSubprocess::ClangdSubprocess(pid_t PID, int childStdOut, int childStdErr,
int childStdIn)
: PID(PID), childStdOut(childStdOut), childStdErr(childStdErr),
childStdIn(childStdIn) {}
bool ClangdSubprocess::writeLSPMessage(const std::string &msg) {
log_debug() << "ClangdSubprocess::writeLSPMessage() started";
std::size_t alreadyWritten = 0;
ssize_t lastWritten = 0;
while (true) {
if (alreadyWritten == msg.size()) {
break;
} else if (alreadyWritten > msg.size()) {
log() << "ClangdSubprocess::writeLSPMessage() error 'already_written > "
"msg.size()'";
return false;
}
lastWritten = ::write(childStdIn, msg.c_str() + alreadyWritten,
msg.size() - alreadyWritten);
if (lastWritten == -1) {
if (errno == EINTR)
continue;
log() << "ClangdSubprocess::writeLSPMessage() failed";
return false;
}
alreadyWritten += lastWritten;
};
log_debug() << "ClangdSubprocess::writeLSPMessage() successfully finished";
return true;
}
/// Returns true iff successfully read prefix from file discriptor fd.
static bool ignorePrefix(const int fd, const std::string &prefix) {
log_debug() << "ignorePrefix(): started";
std::vector<char> buffer(prefix.size());
std::size_t remainingPrefixLength = prefix.size();
std::string actualPrefix;
while (remainingPrefixLength > 0) {
const int bytesRead = ::read(fd, buffer.data(), remainingPrefixLength);
if (bytesRead < 0) {
if (errno == EINTR)
continue;
if (errno == EAGAIN)
log_debug() << "ignorePrefix() errno=EAGAIN";
log() << "ignorePrefix(): failed to read()";
return false;
} else if (bytesRead > 0) {
actualPrefix += std::string(buffer.begin(), buffer.begin() + bytesRead);
remainingPrefixLength -= bytesRead;
log_debug() << "ignorePrefix(): read() returned " << bytesRead
<< "B; remainingPrefixLength=" << remainingPrefixLength
<< "B";
} else {
log() << "ignorePrefix(): failed to read() more bytes";
return false;
}
}
if (actualPrefix != prefix) {
log() << "ignorePrefix(): expected '" << prefix << "'; got '"
<< actualPrefix << "'";
return false;
}
log_debug() << "ignorePrefix(): success";
return true;
}
/// Doesn't return the terminator char at the end of result.
static llvm::Optional<std::string> readUntilChar(int fd, const char terminator,
std::size_t hardLimit) {
log_debug() << "readUntilChar(): started";
std::string result;
char ch;
while (hardLimit > 0) {
const int bytesRead = ::read(fd, &ch, 1);
if (bytesRead == 1) {
log_debug() << "readUntilChar(): read 1B";
if (ch == terminator)
return result;
result += ch;
--hardLimit;
continue;
} else if (bytesRead < 0) {
if (errno == EINTR)
continue;
if (errno == EAGAIN)
log_debug() << "readUntilChar() errno=EAGAIN";
log() << "readUntilChar(): failed to read()";
return llvm::None;
} else {
log() << "readUntilChar(): failed to read() more bytes";
return llvm::None;
}
}
log() << "readUntilChar(): failed to reach terminator char before hardLimit "
"of "
<< hardLimit << "B";
return llvm::None;
}
/// returns JSON payload length
static llvm::Optional<std::size_t> parseLSPHeader(const int fd) {
log_debug() << "parseLSPHeader(): started";
// FIXME This is just simplistic - expects LSP header to be always just single
// LSP header file (Content-Length).
// TODO Proper LSP header support
std::size_t contentLength = 0;
// The first and only expected LSP header field.
{
if (!ignorePrefix(fd, "Content-Length: ")) {
log() << "parseLSPHeader(): expected LSP header field start - "
"'Content-Length: ' missing";
return llvm::None;
}
llvm::Optional<std::string> tentativeContentLength =
readUntilChar(fd, '\r', 10);
if (tentativeContentLength == llvm::None) {
log() << "parseLSPHeader(): expected LSP header field Content-Length "
"value "
"missing";
return llvm::None;
}
for (char c : tentativeContentLength.getValue()) {
if (c < '0' || c > '9') {
break;
}
contentLength *= 10;
contentLength += c - '0';
}
if (!ignorePrefix(fd, "\n")) {
log() << "parseLSPHeader(): expected LSP header field delimiter - \\r\\n "
"missing";
return llvm::None;
}
}
if (!ignorePrefix(fd, "\r\n")) {
log() << "parseLSPHeader(): expected LSP header delimiter - \\r\\n missing";
return llvm::None;
}
return contentLength;
}
// TODO OPTIMIZE
llvm::Optional<std::string> ClangdSubprocess::readLSPMessage() {
log_debug() << "ClangdSubprocess::readLSPMessage() started";
std::size_t expectedContentLength = 0;
{
llvm::Optional<std::size_t> tentativeContentLength =
parseLSPHeader(childStdOut);
if (!tentativeContentLength) {
log() << "ClangdSubprocess::readLSPMessage() failed to read LSP header";
return llvm::None;
}
expectedContentLength = tentativeContentLength.getValue();
}
log() << "ClangdSubprocess::readLSPMessage() received LSP header for "
<< expectedContentLength << "B JSON content";
std::vector<char> buffer(expectedContentLength);
std::size_t alreadyReadByteCount = 0;
log_debug()
<< "ClangdSubprocess::readLSPMessage() childStdOut file descriptor = "
<< childStdOut;
while (alreadyReadByteCount < expectedContentLength) {
const int bytesRead =
::read(childStdOut, buffer.data() + alreadyReadByteCount,
expectedContentLength - alreadyReadByteCount);
if (bytesRead > 0) {
alreadyReadByteCount += bytesRead;
log_debug() << "ClangdSubprocess::readLSPMessage() read " << bytesRead
<< "B; remaining "
<< expectedContentLength - alreadyReadByteCount << " B";
} else if (bytesRead < 0) {
if (errno == EINTR)
continue;
if (errno == EAGAIN)
log_debug() << "readLSPMessage() errno=EAGAIN";
log() << "ClangdSubprocess::readLSPMessage() failed";
return llvm::None;
} else {
log() << "ClangdSubprocess::readLSPMessage() returned 0B";
return llvm::None;
}
}
log_debug() << "ClangdSubprocess::readLSPMessage() successfully finished";
return std::string(buffer.begin(), buffer.end());
}
llvm::Optional<std::string> ClangdSubprocess::readStdErr() {
log_debug() << "ClangdSubprocess::readStdErr() started; childStdErr file "
"descriptor = "
<< childStdErr;
std::string result;
std::vector<char> buffer(4 * 1024); // 4kB
while (true) {
const int bytesRead = ::read(childStdErr, buffer.data(), buffer.size());
if (bytesRead > 0) {
result += std::string(buffer.begin(), buffer.end());
log_debug() << "ClangdSubprocess::readStdErr() read " << bytesRead << "B";
} else if (bytesRead < 0) {
if (errno == EINTR) {
log_debug() << "ClangdSubprocess::readStdErr() errno=EINTR";
continue;
}
if (errno == EAGAIN) {
log_debug() << "ClangdSubprocess::readStdErr() errno=EAGAIN";
break;
}
log() << "ClangdSubprocess::readStdErr() failed";
log() << "ClangdSubprocess::readStdErr() incomplete result='" << result
<< "'";
return llvm::None;
} else {
log() << "ClangdSubprocess::readStdErr() returned 0B";
log() << "ClangdSubprocess::readStdErr() incomplete result='" << result
<< "'";
return llvm::None;
}
}
log_debug() << "ClangdSubprocess::readStdErr() successfully finished";
return result;
}
llvm::Optional<ClangdSubprocess>
startClangdSubprocess(const std::string &path,
const std::vector<std::string> &args) {
log_debug() << "startClangdSubprocess(): started";
pid_t pid = 0;
int childStdOut = -1;
int childStdErr = -1;
int childStdIn = -1;
posix_spawn_file_actions_t action;
int childInputPipe[2] = {-1, -1}; // read end, write end
int childOutputPipe[2] = {-1, -1}; // read end, write end
int childErrorPipe[2] = {-1, -1}; // read end, write end
if (pipe(childInputPipe) || pipe(childOutputPipe) || pipe(childErrorPipe))
return llvm::None;
childStdOut = childOutputPipe[0];
childStdErr = childErrorPipe[0];
childStdIn = childInputPipe[1];
const int childWrite = childOutputPipe[1];
const int childError = childErrorPipe[1];
const int childRead = childInputPipe[0];
if (posix_spawn_file_actions_init(&action) ||
posix_spawn_file_actions_addclose(&action, childStdIn) ||
posix_spawn_file_actions_addclose(&action, childStdOut) ||
posix_spawn_file_actions_addclose(&action, childStdErr) ||
posix_spawn_file_actions_adddup2(&action, childRead, STDIN_FILENO) ||
posix_spawn_file_actions_adddup2(&action, childWrite, STDOUT_FILENO) ||
posix_spawn_file_actions_adddup2(&action, childError, STDERR_FILENO) ||
posix_spawn_file_actions_addclose(&action, childRead) ||
posix_spawn_file_actions_addclose(&action, childWrite) ||
posix_spawn_file_actions_addclose(&action, childError)) {
log() << "startClangdSubprocess(): posix_spawn_file_actions_t setup failed";
return llvm::None;
}
char **args_ptrs = new char *[args.size() + 1 + 1];
args_ptrs[0] = const_cast<char *const>(path.c_str()); // TODO FIXME const_cast
std::size_t i = 1;
for (auto &a : args) {
args_ptrs[i] = const_cast<char *const>(a.c_str()); // TODO FIXME const_cast
++i;
}
args_ptrs[args.size() + 1] = nullptr;
log_debug() << "startClangdSubprocess(): path = '" << path << "'";
if (posix_spawn(&pid, /* path */ path.c_str(), &action, /* attrp */ nullptr,
/* argv */ args_ptrs, /* envp */ nullptr)) {
log() << "startClangdSubprocess(): failed";
return llvm::None;
} else {
log() << "startClangdSubprocess(): spawned PID " << pid;
}
fcntl(childStdOut, F_SETFL, O_NONBLOCK);
fcntl(childStdErr, F_SETFL, O_NONBLOCK);
log_info() << "startClangdSubprocess(): switched file descriptor "
"of child's stdout and stderr to O_NONBLOCK";
posix_spawn_file_actions_destroy(&action);
delete[] args_ptrs;
return ClangdSubprocess(pid, childStdOut, childStdErr, childStdIn);
}
// Use with care - unless someone calls waitpid() the process would become a
// zombie.
void sendKillSignal(pid_t pid) {
log() << "sendKillSignal(): PID " << pid;
kill(pid, SIGKILL);
}
void endClangdSubprocess(pid_t pid) {
log() << "endClangdSubprocess(): PID " << pid;
kill(pid, SIGKILL);
waitpid(pid, 0, WNOHANG);
}
No newline at end of file

xpc/tool/ClangdWorkspaceInstances.h

  • This file was added.
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_XPC_CLANGD_WORKSPACE_INSTANCES_H
#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_XPC_CLANGD_WORKSPACE_INSTANCES_H
#include <functional>
#include <list>
#include <map>
#include <mutex>
#include <string>
#include <vector>
#include "llvm/ADT/Optional.h"
#include <dispatch/dispatch.h>
#include "ClangdSubprocess.h"
class ClangdWorkspaceInstances {
public:
ClangdWorkspaceInstances(const std::string &path,
const std::vector<std::string> &args);
~ClangdWorkspaceInstances();
// Must be called before any createInstance()
void setStdOutCallback(std::function<void(const std::string & /* workspace */,
const std::string & /* output */)>
callback);
// Must be called before any createInstance()
void setStdErrCallback(
std::function<void(const std::string & /* workspace */, const pid_t,
const std::string & /* output */)>
callback);
void setOnSpawnCallback(
std::function<void(const std::string & /* workspace */)> callback);
void setOnRemoveCallback(
std::function<void(const std::string & /* workspace */)> callback);
/// returns true if successfull
bool createInstance(const std::string &workspace);
bool removeInstance(const pid_t pid);
/// returns true iff successful
bool restartInstance(const pid_t pid);
bool writeLSPMessage(const std::string &workspace, const std::string &msg);
llvm::Optional<std::string> readLSPMessage(const std::string &workspace);
llvm::Optional<std::string> readStdErr(const std::string &workspace);
bool doesInstanceExist(const std::string &workspace);
std::size_t existingInstancesCount();
private:
const std::string path;
const std::vector<std::string> args;
std::recursive_mutex mut;
// using list to have stable iterators, performance is not an issue (expected
// number of workspaces is very low)
std::list<ClangdSubprocess> processes;
std::map<pid_t, std::list<ClangdSubprocess>::iterator> PIDToInstance;
std::map<std::string, pid_t> workspaceToPID;
std::map<pid_t, std::string> PIDToWorkspace;
std::map<pid_t, dispatch_source_t> PIDToStdOutHandler;
std::map<pid_t, dispatch_source_t> PIDToStdErrHandler;
std::function<void(const std::string & /* workspace */)> onSpawnCallback;
std::function<void(const std::string & /* workspace */)> onRemoveCallback;
std::function<void(const std::string & /* workspace */,
const std::string & /* output */)>
stdOutCallback;
std::function<void(const std::string & /* workspace */, const pid_t,
const std::string & /* output */)>
stdErrCallback;
};
#endif
No newline at end of file

xpc/tool/ClangdWorkspaceInstances.cpp

  • This file was added.
#include "ClangdWorkspaceInstances.h"
#include "log.h"
ClangdWorkspaceInstances::ClangdWorkspaceInstances(
const std::string &path, const std::vector<std::string> &args)
: path(path), args(args) {}
ClangdWorkspaceInstances::~ClangdWorkspaceInstances() {
log_debug()
<< "ClangdWorkspaceInstances::~ClangdWorkspaceInstances(): started";
std::lock_guard<std::recursive_mutex> lock(mut);
log_debug() << "ClangdWorkspaceInstances::~ClangdWorkspaceInstances(): mutex "
"acquired";
for (const auto it : PIDToInstance)
removeInstance(it.first);
}
void ClangdWorkspaceInstances::setStdOutCallback(
std::function<void(const std::string & /* workspace */,
const std::string & /* output */)>
callback) {
log_debug() << "ClangdWorkspaceInstances::setStdOutCallback(): started";
std::lock_guard<std::recursive_mutex> lock(mut);
log_debug()
<< "ClangdWorkspaceInstances::setStdOutCallback(): mutex acquired";
stdOutCallback = callback;
}
void ClangdWorkspaceInstances::setStdErrCallback(
std::function<void(const std::string & /* workspace */, const pid_t,
const std::string & /* output */)>
callback) {
log_debug() << "ClangdWorkspaceInstances::setStdErrCallback(): started";
std::lock_guard<std::recursive_mutex> lock(mut);
log_debug()
<< "ClangdWorkspaceInstances::setStdErrCallback(): mutex acquired";
stdErrCallback = callback;
}
void ClangdWorkspaceInstances::setOnSpawnCallback(
std::function<void(const std::string & /* workspace */)> callback) {
log_debug() << "ClangdWorkspaceInstances::setOnSpawnCallback(): started";
std::lock_guard<std::recursive_mutex> lock(mut);
log_debug()
<< "ClangdWorkspaceInstances::setOnSpawnCallback(): mutex acquired";
onSpawnCallback = callback;
}
void ClangdWorkspaceInstances::setOnRemoveCallback(
std::function<void(const std::string & /* workspace */)> callback) {
log_debug() << "ClangdWorkspaceInstances::setOnRemoveCallback(): started";
std::lock_guard<std::recursive_mutex> lock(mut);
log_debug()
<< "ClangdWorkspaceInstances::setOnRemoveCallback(): mutex acquired";
onRemoveCallback = callback;
}
bool ClangdWorkspaceInstances::createInstance(const std::string &workspace) {
log_debug() << "ClangdWorkspaceInstances::createInstance(): started "
"workspace='"
<< workspace << "'";
std::lock_guard<std::recursive_mutex> lock(mut);
log_debug() << "ClangdWorkspaceInstances::createInstance(): mutex "
"acquired";
if (doesInstanceExist(workspace)) {
log_info() << "ClangdWorkspaceInstances::createInstance(): workspace "
"already exists - returning early";
return true;
}
{
llvm::Optional<ClangdSubprocess> child = startClangdSubprocess(path, args);
if (child == llvm::None)
return false;
processes.push_back(child.getValue());
}
const pid_t PID = processes.back().PID;
log_info() << "ClangdWorkspaceInstances::createInstance(): spawned "
"subprocess; PID="
<< PID;
PIDToInstance.emplace(PID, --processes.end());
workspaceToPID.emplace(workspace, PID);
PIDToWorkspace.emplace(PID, workspace);
// asynchronous handling of child's stdout
{
dispatch_source_t eventSource = dispatch_source_create(
DISPATCH_SOURCE_TYPE_READ, PIDToInstance[PID]->childStdOut, 0,
dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0));
dispatch_source_set_event_handler(eventSource, ^{
log_debug() << "stdout handler: started";
std::lock_guard<std::recursive_mutex> lock(mut);
log_debug() << "stdout handler: mutex acquired";
const auto workspaceIt = PIDToWorkspace.find(PID);
if (workspaceIt == PIDToWorkspace.end()) {
log() << "stdout handler: nonexistent workspace for PID " << PID;
sendKillSignal(PID);
}
const auto workspace = workspaceIt->second;
const llvm::Optional<std::string> response = readLSPMessage(workspace);
if (response != llvm::None) {
log_debug() << "stdout handler: calling stdOutCallback";
stdOutCallback(workspace, response.getValue());
} else {
log() << "stdout handler: failed to read from stdout of child PID "
<< PID;
sendKillSignal(PID);
}
});
dispatch_resume(eventSource);
log_debug() << "ClangdWorkspaceInstances::createInstance(): created "
"dispatch source for stdout of PID "
<< PID;
PIDToStdOutHandler[PID] = eventSource;
}
{
// Using QOS_CLASS_BACKGROUND as we are just logging stderr output.
dispatch_source_t eventSource = dispatch_source_create(
DISPATCH_SOURCE_TYPE_READ, PIDToInstance[PID]->childStdErr, 0,
dispatch_get_global_queue(QOS_CLASS_BACKGROUND, 0));
dispatch_source_set_event_handler(eventSource, ^{
log_debug() << "stderr handler: started";
std::lock_guard<std::recursive_mutex> lock(mut);
log_debug() << "stderr handler: mutex acquired";
const auto workspaceIt = PIDToWorkspace.find(PID);
if (workspaceIt == PIDToWorkspace.end()) {
log() << "stderr handler: nonexistent workspace for PID " << PID;
sendKillSignal(PID);
}
const auto workspace = workspaceIt->second;
const llvm::Optional<std::string> response = readStdErr(workspace);
if (response != llvm::None) {
log_debug() << "stderr handler: calling stdErrCallback";
stdErrCallback(workspace, PID, response.getValue());
} else {
log() << "stdout handler: failed to read from stderr of child PID "
<< PID;
sendKillSignal(PID);
}
});
dispatch_resume(eventSource);
log_debug() << "ClangdWorkspaceInstances::createInstance(): created "
"dispatch source for stderr of PID "
<< PID;
PIDToStdErrHandler[PID] = eventSource;
}
onSpawnCallback(workspace);
return true;
}
bool ClangdWorkspaceInstances::removeInstance(const pid_t pid) {
log_debug() << "ClangdWorkspaceInstances::removeInstance(): started";
std::lock_guard<std::recursive_mutex> lock(mut);
log_debug() << "ClangdWorkspaceInstances::removeInstance(): mutex acquired";
const auto childIt = PIDToInstance.find(pid);
// Try to do the clean-up no matter how messy the current state is and
// eventually return failure only after that.
bool anyFailure = false;
if (childIt != PIDToInstance.end()) {
// Must precede closing child's I/O pipes file descriptors.
{
const auto stdoutHandlerIt = PIDToStdOutHandler.find(pid);
if (stdoutHandlerIt != PIDToStdOutHandler.end()) {
dispatch_source_cancel(stdoutHandlerIt->second);
} else {
log_info() << "removeInstance(): didn't find stdout handler for PID "
<< pid;
anyFailure = true;
}
}
{
const auto stderrHandlerIt = PIDToStdErrHandler.find(pid);
if (stderrHandlerIt != PIDToStdErrHandler.end()) {
dispatch_source_cancel(stderrHandlerIt->second);
} else {
log_info() << "removeInstance(): didn't find stderr handler for PID "
<< pid;
anyFailure = true;
}
}
endClangdSubprocess(pid);
processes.erase(childIt->second);
if (PIDToInstance.erase(pid) != 1) {
log() << "ClangdWorkspaceInstances::removeInstance(): PIDToInstance "
"doesn't "
"contain PID "
<< pid;
anyFailure = true;
}
std::string workspace;
{
const auto workspaceIt = PIDToWorkspace.find(pid);
if (workspaceIt == PIDToWorkspace.end()) {
log() << "ClangdWorkspaceInstances::removeInstance(): PIDToWorkspace "
"doesn't contain PID "
<< pid;
anyFailure = true;
}
workspace = workspaceIt->second;
onRemoveCallback(workspace);
}
if (workspaceToPID.erase(workspace) != 1) {
log() << "ClangdWorkspaceInstances::removeInstance(): workspaceToPID "
"doesn't "
"contain workspace "
<< workspace;
anyFailure = true;
}
if (PIDToWorkspace.erase(pid) != 1) {
log() << "ClangdWorkspaceInstances::removeInstance(): PIDToWorkspace "
"doesn't "
"contain PID "
<< pid;
anyFailure = true;
}
} else {
log() << "ClangdWorkspaceInstances::removeInstance(): PID " << pid
<< " doesn't exist anymore";
anyFailure = true;
}
return !anyFailure;
}
/// returns true iff successful
bool ClangdWorkspaceInstances::restartInstance(const pid_t PID) {
log_debug() << "ClangdWorkspaceInstances::restartInstance(): started";
std::lock_guard<std::recursive_mutex> lock(mut);
log_debug() << "ClangdWorkspaceInstances::restartInstance(): mutex acquired";
// Must be done before instance is removed.
llvm::Optional<std::string> workspace = [&]() {
const auto workspaceIt = PIDToWorkspace.find(PID);
return workspaceIt == PIDToWorkspace.end()
? llvm::Optional<std::string>(llvm::None)
: workspaceIt->second;
}();
if (!removeInstance(PID)) {
log() << "ClangdWorkspaceInstances::restartInstance(): failed to remove "
"child";
return false;
}
if (workspace == llvm::None) {
log() << "ClangdWorkspaceInstances::restartInstance(): no instance for PID "
<< PID;
return false;
}
if (!createInstance(workspace.getValue())) {
log()
<< "ClangdWorkspaceInstances::restartInstance(): failed to start child";
return false;
}
return true;
}
bool ClangdWorkspaceInstances::writeLSPMessage(const std::string &workspace,
const std::string &msg) {
log_debug() << "ClangdWorkspaceInstances::writeLSPMessage(): started";
std::lock_guard<std::recursive_mutex> lock(mut);
log_debug() << "ClangdWorkspaceInstances::writeLSPMessage(): mutex acquired";
auto pidIt = workspaceToPID.find(workspace);
if (pidIt == workspaceToPID.end()) {
log() << "ClangdWorkspaceInstances::writeLSPMessage(): workspaceToPID "
"doesn't "
"contain workspace "
<< workspace;
return false;
}
auto processIt = PIDToInstance.find(pidIt->second);
if (processIt == PIDToInstance.end()) {
log()
<< "ClangdWorkspaceInstances::writeLSPMessage(): PIDToInstance doesn't "
"contain PID "
<< pidIt->second;
return false;
}
return processIt->second->writeLSPMessage(msg);
}
llvm::Optional<std::string>
ClangdWorkspaceInstances::readLSPMessage(const std::string &workspace) {
log_debug() << "ClangdWorkspaceInstances::readLSPMessage(): started";
std::lock_guard<std::recursive_mutex> lock(mut);
log_debug() << "ClangdWorkspaceInstances::readLSPMessage(): mutex "
"acquired";
auto pidIt = workspaceToPID.find(workspace);
if (pidIt == workspaceToPID.end()) {
log() << "ClangdWorkspaceInstances::readLSPMessage(): no "
"child for "
"workspace '"
<< workspace << "'";
return llvm::None;
}
auto procIt = PIDToInstance.find(pidIt->second);
if (procIt == PIDToInstance.end()) {
log() << "ClangdWorkspaceInstances::readLSPMessage(): no "
"sub-process for workspace '"
<< workspace << "'";
return llvm::None;
}
log_debug() << "ClangdWorkspaceInstances::readLSPMessage(): success";
return procIt->second->readLSPMessage();
}
llvm::Optional<std::string>
ClangdWorkspaceInstances::readStdErr(const std::string &workspace) {
log_debug() << "ClangdWorkspaceInstances::readStdErr(): started";
std::lock_guard<std::recursive_mutex> lock(mut);
log_debug() << "ClangdWorkspaceInstances::readStdErr(): mutex acquired";
auto pidIt = workspaceToPID.find(workspace);
if (pidIt == workspaceToPID.end()) {
log() << "ClangdWorkspaceInstances::readStdErr(): no child for "
"workspace '"
<< workspace << "'";
return llvm::None;
}
auto procIt = PIDToInstance.find(pidIt->second);
if (procIt == PIDToInstance.end()) {
log() << "ClangdWorkspaceInstances::readStdErr(): no sub-process "
"for workspace '"
<< workspace << "'";
return llvm::None;
}
llvm::Optional<std::string> result = procIt->second->readStdErr();
if (result != llvm::None)
log_debug() << "ClangdWorkspaceInstances::readStdErr(): success";
else
log_debug() << "ClangdWorkspaceInstances::readStdErr(): failed";
return result;
}
bool ClangdWorkspaceInstances::doesInstanceExist(const std::string &workspace) {
log_debug() << "ClangdWorkspaceInstances::doesInstanceExist(): started";
std::lock_guard<std::recursive_mutex> lock(mut);
log_debug() << "ClangdWorkspaceInstances::doesInstanceExist(): mutex "
"acquired";
return workspaceToPID.find(workspace) != workspaceToPID.end();
}
std::size_t ClangdWorkspaceInstances::existingInstancesCount() {
log_debug() << "ClangdWorkspaceInstances::existingInstancesCount(): started";
std::lock_guard<std::recursive_mutex> lock(mut);
log_debug() << "ClangdWorkspaceInstances::existingInstancesCount(): mutex "
"acquired";
return processes.size();
}
No newline at end of file

xpc/tool/ClangdXpcAdapter.cpp

  • This file was added.
#include <string>
#include <vector>
#include "ClangdWorkspaceInstances.h"
#include "log.h"
namespace {
ClangdWorkspaceInstances *clangdInstancesPtr = nullptr;
}
#include <xpc/xpc.h>
namespace {
void connectionHandler(xpc_connection_t clientConnection) {
xpc_connection_set_target_queue(
clientConnection, dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0));
clangdInstancesPtr->setStdOutCallback([clientConnection](
const std::string &workspace,
const std::string &output) {
log_debug() << "clangd children stdout callback: started for workspace='"
<< workspace << "'";
// TODO OPTIMIZE - use static const char**
std::vector<const char *> keys = {"payload", "workspace"};
std::vector<xpc_object_t> values = {xpc_string_create(output.c_str()),
xpc_string_create(workspace.c_str())};
auto response = xpc_dictionary_create(keys.data(), values.data(), 2);
xpc_connection_send_message(clientConnection, response);
xpc_release(response);
});
xpc_connection_set_event_handler(clientConnection, ^(xpc_object_t message) {
if (message == XPC_ERROR_CONNECTION_INVALID) {
// connection is being terminated
log() << "XPC event handler: received XPC_ERROR_CONNECTION_INVALID";
return;
}
if (xpc_get_type(message) != XPC_TYPE_DICTIONARY) {
log() << "XPC event handler: received XPC message of unknown type";
return;
}
const char *const payload = xpc_dictionary_get_string(message, "payload");
const char *const workspace =
xpc_dictionary_get_string(message, "workspace");
if (payload && workspace) {
if (!clangdInstancesPtr->doesInstanceExist(workspace)) {
// No point in locking any mutex here - the instance can always crash.
log_info()
<< "XPC event handler: spawning new clangd instance for workspace '"
<< workspace << "'";
if (!clangdInstancesPtr->createInstance(workspace)) {
log() << "XPC event handler: failed to spawn new clangd instance for "
"workspace '"
<< "'";
xpc_connection_cancel(clientConnection);
return;
}
}
std::string delimitedPayload(payload);
delimitedPayload += "\n---\n";
if (!clangdInstancesPtr->writeLSPMessage(workspace, delimitedPayload)) {
log() << "XPC event handler: failed to write_to_child";
xpc_connection_cancel(clientConnection);
return;
}
} else {
// Just log the invalide message and go on.
__block std::string keysDump;
xpc_dictionary_apply(message,
^bool(const char *key, xpc_object_t /* ignore */) {
if (!keysDump.empty())
keysDump = keysDump + ", ";
keysDump = keysDump + "'" + key + "'";
return true;
});
log() << "XPC event handler: received invalid XPC message with keys {"
<< keysDump << "}";
}
});
xpc_connection_resume(clientConnection);
}
} // namespace
int main() {
log_debug() << "main(): started";
const char *const clangdPath = getenv("CLANGD_PATH");
if (!clangdPath) {
log() << "main(): missing CLANGD_PATH environment variable";
return EXIT_FAILURE;
}
// TODO FIXME add proper JSON RPC header and don't use delimited mode
ClangdWorkspaceInstances clangdInstances(clangdPath,
{"-input-style=delimited"});
clangdInstancesPtr = &clangdInstances;
// logging children stderr
clangdInstancesPtr->setStdErrCallback([](const std::string &workspace,
const pid_t pid,
const std::string &output) {
log_debug() << "clangd child [PID " << pid << "] stderr callback: started";
log() << "clangd child [PID " << pid << "] stderr callback: workspace='"
<< workspace << "' stderr='" << output << "'";
});
// handling XPC transactions
clangdInstancesPtr->setOnSpawnCallback([](const std::string &workspace) {
xpc_transaction_begin();
log_info() << "ClangdWorkspaceInstances:: onspawn callback: ended XPC "
"transaction for workspace "
<< workspace;
});
clangdInstancesPtr->setOnRemoveCallback([](const std::string &workspace) {
xpc_transaction_end();
log_info() << "ClangdWorkspaceInstances:: onremove callback: ended XPC "
"transaction for workspace "
<< workspace;
});
// handle children crashing
{
// We are gonna use GCD for SIGCHLD handling so we can actually do something
// without being overly restricted by signal safety requirements.
// Using DISPATCH_QUEUE_PRIORITY_HIGH as if we detect crash we want to react
// ASAP so user experience impact is as low as possible.
dispatch_source_t source = dispatch_source_create(
DISPATCH_SOURCE_TYPE_SIGNAL, SIGCHLD, 0,
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0));
dispatch_source_set_event_handler(source, ^{
log_debug() << "signal pseudo-handler: started";
pid_t pid;
int status;
while ((pid = waitpid(-1, &status, 0)) > 0) {
if (WIFEXITED(status) && WEXITSTATUS(status) == EXIT_SUCCESS) {
log() << "signal pseudo-handler: clangd PID " << pid
<< " exited with EXIT_SUCCESS";
clangdInstancesPtr->removeInstance(pid);
if (clangdInstancesPtr->existingInstancesCount() == 0) {
log() << "signal pseudo-handler: no active children - exiting";
exit(EXIT_SUCCESS);
}
} else {
// TODO FIXME some restarting strategy - maybe some increased and/or
// random delay?
log() << "signal pseudo-handler: clangd PID " << pid
<< " died - restarting";
clangdInstancesPtr->restartInstance(pid);
}
}
});
dispatch_resume(source);
}
xpc_main(connectionHandler);
return EXIT_SUCCESS;
}

xpc/tool/log.h

  • This file was added.
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_XPC_LOG_H
#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_XPC_LOG_H
#include <sstream>
#include <string>
#include <os/log.h>
class Logger {
private:
enum class log_type { log, info, debug };
log_type type;
std::string buffer_data;
std::stringstream buffer;
Logger(log_type type) : type(type), buffer_data(), buffer(buffer_data) {}
public:
template <typename T> Logger &operator<<(const T &in) {
buffer << in;
return *this;
}
friend Logger log();
friend Logger log_info();
friend Logger log_debug();
~Logger() {
switch (type) {
case log_type::log:
os_log(OS_LOG_DEFAULT, "%s", buffer.str().c_str());
break;
case log_type::info:
os_log_info(OS_LOG_DEFAULT, "%s", buffer.str().c_str());
break;
case log_type::debug:
os_log_debug(OS_LOG_DEFAULT, "%s", buffer.str().c_str());
break;
}
}
Logger(Logger &&) = default;
Logger(const Logger &) = delete;
Logger &operator=(const Logger &) = delete;
Logger &operator=(Logger &&) = delete;
};
inline Logger log() { return Logger(Logger::log_type::log); }
inline Logger log_info() { return Logger(Logger::log_type::info); }
inline Logger log_debug() { return Logger(Logger::log_type::debug); }
#endif
No newline at end of file