RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-25 04:07:44 +00:00
Code Issues Activity Actions

HackStudio: Restart LanguageServer if it crashes

Browse source 
We now restart the language server transparently if it crashes.
If the language server crashes too frequently (current threshold is
twice within 3 seconds), we give up and will not attempt to restart it
again. HackStudio will still work fine, but features that depend on the
language server will not function.

To support this change we use a new class, 'ServerConnectionWrapper',
that holds the actual ServerConnection and is responsible for restarting
the language-server if it crashes.

Closes #5574.
This commit is contained in:
Itamar 2021-03-05 21:01:42 +02:00 • committed by Andreas Kling
parent 4223f03b2b
commit cfa100cb65
3 changed files with 213 additions and 96 deletions
Download patch file Download diff file Expand all files Collapse all files

123
Userland/DevTools/HackStudio/LanguageClient.h
View file

@ -27,11 +27,13 @@
#pragma once
#include "AutoCompleteResponse.h"
#include "Language.h"
#include <AK/Forward.h>
#include <AK/LexicalPath.h>
#include <AK/Types.h>
#include <AK/WeakPtr.h>
#include <AK/Weakable.h>
#include <LibCore/ElapsedTimer.h>
#include <LibIPC/ServerConnection.h>
#include <DevTools/HackStudio/LanguageServers/LanguageClientEndpoint.h>
@ -40,10 +42,13 @@
namespace HackStudio {
class LanguageClient;
class ServerConnectionWrapper;
class ServerConnection
: public IPC::ServerConnection<LanguageClientEndpoint, LanguageServerEndpoint>
, public LanguageClientEndpoint {
friend class ServerConnectionWrapper;
public:
ServerConnection(const StringView& socket, const String& project_path)
: IPC::ServerConnection<LanguageClientEndpoint, LanguageServerEndpoint>(*this, socket)
@ -51,74 +56,90 @@ public:
m_project_path = project_path;
}
void attach(LanguageClient& client)
{
m_language_client = &client;
}
void detach()
{
m_language_client = nullptr;
}
virtual void handshake() override
{
send_sync<Messages::LanguageServer::Greet>(m_project_path);
}
WeakPtr<LanguageClient> language_client() { return m_language_client; }
WeakPtr<LanguageClient> language_client() { return m_current_language_client; }
const String& project_path() const { return m_project_path; }
template<typename LanguageServerType>
static NonnullRefPtr<ServerConnection> get_or_create(const String& project_path)
{
auto key = LanguageServerType::language_name();
if (auto instance = s_instance_for_language.get(key); instance.has_value()) {
return *instance.value();
}
auto connection = LanguageServerType::construct(project_path);
connection->handshake();
set_instance_for_project(LanguageServerType::language_name(), *connection);
return *connection;
}
static void set_instance_for_project(const String& language_name, NonnullRefPtr<ServerConnection>&&);
static void remove_instance_for_language(const String& language_name);
virtual void die() override;
protected:
virtual void handle(const Messages::LanguageClient::AutoCompleteSuggestions&) override;
virtual void handle(const Messages::LanguageClient::DeclarationLocation&) override;
virtual void handle(const Messages::LanguageClient::DeclarationsInDocument&) override;
void set_wrapper(ServerConnectionWrapper& wrapper) { m_wrapper = &wrapper; }
String m_project_path;
WeakPtr<LanguageClient> m_language_client;
WeakPtr<LanguageClient> m_current_language_client;
ServerConnectionWrapper* m_wrapper { nullptr };
};
class ServerConnectionWrapper {
AK_MAKE_NONCOPYABLE(ServerConnectionWrapper);
public:
explicit ServerConnectionWrapper(const String& language_name, Function<NonnullRefPtr<ServerConnection>()> connection_creator);
~ServerConnectionWrapper() = default;
template<typename LanguageServerType>
static ServerConnectionWrapper& get_or_create(const String& project_path);
ServerConnection* connection();
void on_crash();
void try_respawn_connection();
void attach(LanguageClient& client);
void detach();
void set_active_client(LanguageClient& client);
private:
static HashMap<String, NonnullRefPtr<ServerConnection>> s_instance_for_language;
void create_connection();
void show_crash_notification() const;
void show_frequenct_crashes_notification() const;
Language m_language;
Function<NonnullRefPtr<ServerConnection>()> m_connection_creator;
RefPtr<ServerConnection> m_connection;
Core::ElapsedTimer m_last_crash_timer;
bool m_respawn_allowed { true };
};
class ServerConnectionInstances {
public:
static void set_instance_for_language(const String& language_name, NonnullOwnPtr<ServerConnectionWrapper>&& connection_wrapper);
static void remove_instance_for_language(const String& language_name);
static ServerConnectionWrapper* get_instance_wrapper(const String& language_name);
private:
static HashMap<String, NonnullOwnPtr<ServerConnectionWrapper>> s_instance_for_language;
};
class LanguageClient : public Weakable<LanguageClient> {
public:
explicit LanguageClient(NonnullRefPtr<ServerConnection>&& connection)
: m_server_connection(move(connection))
explicit LanguageClient(ServerConnectionWrapper& connection_wrapper)
: m_connection_wrapper(connection_wrapper)
{
m_previous_client = m_server_connection->language_client();
VERIFY(m_previous_client.ptr() != this);
m_server_connection->attach(*this);
if (m_connection_wrapper.connection()) {
m_previous_client = m_connection_wrapper.connection()->language_client();
VERIFY(m_previous_client.ptr() != this);
m_connection_wrapper.attach(*this);
}
}
virtual ~LanguageClient()
{
// m_server_connection is nullified if the server crashes
if (m_server_connection)
m_server_connection->detach();
// m_connection_wrapper is nullified if the server crashes
if (m_connection_wrapper.connection())
m_connection_wrapper.detach();
VERIFY(m_previous_client.ptr() != this);
if (m_previous_client)
m_server_connection->attach(*m_previous_client);
if (m_previous_client && m_connection_wrapper.connection())
m_connection_wrapper.set_active_client(*m_previous_client);
}
void set_active_client();
@ -130,22 +151,34 @@ public:
virtual void set_autocomplete_mode(const String& mode);
virtual void search_declaration(const String& path, size_t line, size_t column);
void provide_autocomplete_suggestions(const Vector<GUI::AutocompleteProvider::Entry>&);
void declaration_found(const String& file, size_t line, size_t column);
void on_server_crash();
void provide_autocomplete_suggestions(const Vector<GUI::AutocompleteProvider::Entry>&) const;
void declaration_found(const String& file, size_t line, size_t column) const;
Function<void(Vector<GUI::AutocompleteProvider::Entry>)> on_autocomplete_suggestions;
Function<void(const String&, size_t, size_t)> on_declaration_found;
private:
WeakPtr<ServerConnection> m_server_connection;
ServerConnectionWrapper& m_connection_wrapper;
WeakPtr<LanguageClient> m_previous_client;
};
template<typename ServerConnectionT>
static inline NonnullOwnPtr<LanguageClient> get_language_client(const String& project_path)
{
return make<LanguageClient>(ServerConnection::get_or_create<ServerConnectionT>(project_path));
return make<LanguageClient>(ServerConnectionWrapper::get_or_create<ServerConnectionT>(project_path));
}
template<typename LanguageServerType>
ServerConnectionWrapper& ServerConnectionWrapper::get_or_create(const String& project_path)
{
auto* wrapper = ServerConnectionInstances::get_instance_wrapper(LanguageServerType::language_name());
if (wrapper)
return *wrapper;
auto connection_wrapper_ptr = make<ServerConnectionWrapper>(LanguageServerType::language_name(), [project_path]() { return LanguageServerType::construct(project_path); });
auto& connection_wrapper = *connection_wrapper_ptr;
ServerConnectionInstances::set_instance_for_language(LanguageServerType::language_name(), move(connection_wrapper_ptr));
return connection_wrapper;
}
}