Check if bundle is valid before restarting

[vinistock]

Motivation

The more we restart the server, the higher the risk that something related to Bundler may fail and prevent users from having a smooth experience.

I think we can be a bit smarter about when we restart the server by checking if composing the bundle is successful before we try. If we know that composing fails, it's better to continue running the current version of the server than crashing.

Implementation

The proposal is to add a custom request that allows the client to ask the server if composing the bundle succeeds. That way, if there's a lockfile update, we can first check if the update produces a valid bundle.

If we couldn't compose the bundle, then we avoid restarting. Otherwise, we trigger the restart, but skip composing the bundle since we just did that ahead of time - saving time for the user and allow them to skip directly to indexing.

Note

This solution doesn't fully solve #1458, but it does move the needle a little bit at least for VS Code. The big challenge in moving lockfile watching to the server is how to transfer the state of the server currently running to the new instance we launch.

For example, when we receive a notification that the lockfile was changed, we would need to:

1. Compose the new bundle
2. Replace the current process with a new one, using the new bundle (via exec)
3. Transfer the state of the previous process to the new one. We need all configurations that were applied during initialize (think the global state), the state of all current documents (the store object) and other pieces of state that exist in the version of the server running before the relaunch

I have not yet figured out how to achieve 3.

Automated Tests

Added tests.

[vinistock]

• Check if lockfile is valid before composing bundle #3077
• Check if bundle is valid before restarting #3066 👈 (View in Graphite)
• Use local executables when working on the Ruby LSP #3065
• main

This stack of pull requests is managed by Graphite. Learn more about stacking.