mirror of
https://github.com/golang/go
synced 2024-10-01 07:18:32 -06:00
c29062fe1d
Previously, the process of instantiating and running the LSP server was
sharded across the lsp, protocol, and cmd packages, and this resulted in
some APIs that are hard to work with. For example, it's hard to guess
the difference between lsp.NewClientServer, lsp.NewServer,
protocol.NewServer (which returns a client), and protocol.NewClient
(which returns a server).
This change reorganizes Server instantiation as follows:
+ The lsp.Server is now purely an implementation of the protocol.Server
interface. It is no longer responsible for installing itself into the
jsonrpc2 Stream, nor for running itself.
+ A new package 'lsprpc' is added, to implement the logic of binding an
incoming connection to an LSP server session. This is put in a
separate package for lack of a clear home: it didn't really
philosophically belong in any of the lsp, cmd, or protocol packages.
We can perhaps move it to cmd in the future, but I'd like to keep it
as a separate package while I develop request forwarding.
simplified import graph:
jsonrpc2 ⭠ lsprpc ⭠ cmd
⭩ ⭦
lsp (t.b.d. client tests)
⭩ ⭨
protocol source
+ The jsonrpc2 package is extended to have a minimal API for running a
'StreamServer': something analogous to an HTTP server that listens
for new connections and delegates to a handler (but we couldn't use
the word 'Handler' for this delegate as it was already taken).
After these changes, I hope that the concerns of "serving the LSP",
"serving jsonrpc2", and "installing the LSP on jsonrpc2" are more
logically organized, though one legitimate criticism is that the word
'Server' is still heavily overloaded.
This change prepares a subsequent change which hijacks the jsonrpc2
connection when forwarding messages to a shared gopls instance.
To test this change, the following improvements are made:
+ A servertest package is added to make it easier to run a test against
an in-process jsonrpc2 server. For now, this uses TCP but it could
easily be modified to use io.Pipe.
+ cmd tests are updated to use the servertest package. Unfortunately it
wasn't yet possible to eliminate the concept of `remote=internal` in
favor of just using multiple sessions, because view initialization
involves calling both `go env` and `packages.Load`, which slow down
session startup significantly. See also golang.org/issue/35968.
Instead, the syntax for `-remote=internal` is modified to be
`-remote=internal@127.0.0.1:12345`.
+ An additional test for request cancellation is added for the
sessionserver package. This test uncovered a bug: when calling
Canceller.Cancel, we were using id rather than &id, which resulted in
incorrect json serialization (as only the pointer receiver implements
the json.Marshaller interface).
Updates golang/go#34111
Change-Id: I75c219df634348cdf53a9e57839b98588311a9ef
Reviewed-on: https://go-review.googlesource.com/c/tools/+/215742
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Rebecca Stambler <rstambler@golang.org>
Reviewed-by: Heschi Kreinick <heschi@google.com>
54 lines
1.7 KiB
Go
54 lines
1.7 KiB
Go
// Copyright 2020 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// Package lsprpc implements a jsonrpc2.StreamServer that may be used to
|
|
// serve the LSP on a jsonrpc2 channel.
|
|
package lsprpc
|
|
|
|
import (
|
|
"context"
|
|
|
|
"golang.org/x/tools/internal/jsonrpc2"
|
|
"golang.org/x/tools/internal/lsp"
|
|
"golang.org/x/tools/internal/lsp/protocol"
|
|
"golang.org/x/tools/internal/lsp/source"
|
|
)
|
|
|
|
// The StreamServer type is a jsonrpc2.StreamServer that handles incoming
|
|
// streams as a new LSP session, using a shared cache.
|
|
type StreamServer struct {
|
|
withTelemetry bool
|
|
|
|
// accept is mutable for testing.
|
|
accept func(protocol.Client) protocol.Server
|
|
}
|
|
|
|
// NewStreamServer creates a StreamServer using the shared cache. If
|
|
// withTelemetry is true, each session is instrumented with telemetry that
|
|
// records RPC statistics.
|
|
func NewStreamServer(cache source.Cache, withTelemetry bool) *StreamServer {
|
|
s := &StreamServer{
|
|
withTelemetry: withTelemetry,
|
|
}
|
|
s.accept = func(c protocol.Client) protocol.Server {
|
|
session := cache.NewSession()
|
|
return lsp.NewServer(session, c)
|
|
}
|
|
return s
|
|
}
|
|
|
|
// ServeStream implements the jsonrpc2.StreamServer interface, by handling
|
|
// incoming streams using a new lsp server.
|
|
func (s *StreamServer) ServeStream(ctx context.Context, stream jsonrpc2.Stream) error {
|
|
conn := jsonrpc2.NewConn(stream)
|
|
client := protocol.ClientDispatcher(conn)
|
|
server := s.accept(client)
|
|
conn.AddHandler(protocol.ServerHandler(server))
|
|
conn.AddHandler(protocol.Canceller{})
|
|
if s.withTelemetry {
|
|
conn.AddHandler(telemetryHandler{})
|
|
}
|
|
return conn.Run(protocol.WithClient(ctx, client))
|
|
}
|