lsprpc

package
v0.0.0-...-3f344d0 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Dec 19, 2021 License: GPL-2.0 Imports: 30 Imported by: 0

Documentation

Overview

Package lsprpc implements a jsonrpc2.StreamServer that may be used to serve the LSP on a jsonrpc2 channel.

Index

Constants

View Source
const AutoNetwork = "auto"

AutoNetwork is the pseudo network type used to signal that gopls should use automatic discovery to resolve a remote address.

Variables

This section is empty.

Functions

func ConnectToRemote

func ConnectToRemote(ctx context.Context, addr string) (net.Conn, error)

func ExecuteCommand

func ExecuteCommand(ctx context.Context, addr string, id string, request, result interface{}) error

func ParseAddr

func ParseAddr(listen string) (network string, address string)

ParseAddr parses the address of a gopls remote. TODO(rFindley): further document this syntax, and allow URI-style remote addresses such as "auto://...".

Types

type AutoDialer

type AutoDialer struct {
	// contains filtered or unexported fields
}

An AutoDialer is a jsonrpc2 dialer that understands the 'auto' network.

func NewAutoDialer

func NewAutoDialer(rawAddr string, argFunc func(network, addr string) []string) (*AutoDialer, error)

func (*AutoDialer) Dial

Dial implements the jsonrpc2.Dialer interface.

type BinderFunc

The BinderFunc type adapts a bind function to implement the jsonrpc2.Binder interface.

func (BinderFunc) Bind

type ClientBinder

type ClientBinder struct {
	// contains filtered or unexported fields
}

ClientBinder binds an LSP client to an incoming connection.

func NewClientBinder

func NewClientBinder(newClient ClientFunc) *ClientBinder

func (*ClientBinder) Bind

type ClientFunc

type ClientFunc func(context.Context, protocol.Server) protocol.Client

A ClientFunc is used to construct an LSP client for a given server.

type ClientSession

type ClientSession struct {
	SessionID string `json:"sessionID"`
	Logfile   string `json:"logfile"`
	DebugAddr string `json:"debugAddr"`
}

ClientSession identifies a current client LSP session on the server. Note that it looks similar to handshakeResposne, but in fact 'Logfile' and 'DebugAddr' now refer to the client.

type ForwardBinder

type ForwardBinder struct {
	// contains filtered or unexported fields
}

func NewForwardBinder

func NewForwardBinder(dialer jsonrpc2_v2.Dialer) *ForwardBinder

func (*ForwardBinder) Bind

type Forwarder

type Forwarder struct {
	// contains filtered or unexported fields
}

A Forwarder is a jsonrpc2.StreamServer that handles an LSP stream by forwarding it to a remote. This is used when the gopls process started by the editor is in the `-remote` mode, which means it finds and connects to a separate gopls daemon. In these cases, we still want the forwarder gopls to be instrumented with telemetry, and want to be able to in some cases hijack the jsonrpc2 connection with the daemon.

func NewForwarder

func NewForwarder(rawAddr string, argFunc func(network, address string) []string) (*Forwarder, error)

NewForwarder creates a new Forwarder, ready to forward connections to the remote server specified by rawAddr. If provided and rawAddr indicates an 'automatic' address (starting with 'auto;'), argFunc may be used to start a remote server for the auto-discovered address.

func (*Forwarder) ServeStream

func (f *Forwarder) ServeStream(ctx context.Context, clientConn jsonrpc2.Conn) error

ServeStream dials the forwarder remote and binds the remote to serve the LSP on the incoming stream.

type HandlerMiddleware

type HandlerMiddleware func(jsonrpc2_v2.Handler) jsonrpc2_v2.Handler

HandlerMiddleware is a middleware that only modifies the jsonrpc2 handler.

type Handshaker

type Handshaker struct {
	// Metadata will be shared with peers via handshaking.
	Metadata Metadata
	// contains filtered or unexported fields
}

Handshaker handles both server and client handshaking over jsonrpc2. To instrument server-side handshaking, use Handshaker.Middleware. To instrument client-side handshaking, call Handshaker.ClientHandshake for any new client-side connections.

func (*Handshaker) ClientHandshake

func (h *Handshaker) ClientHandshake(ctx context.Context, conn *jsonrpc2_v2.Connection)

ClientHandshake performs a client-side handshake with the server at the other end of conn, recording the server's peer info and watching for conn's disconnection.

func (*Handshaker) Middleware

func (h *Handshaker) Middleware(inner jsonrpc2_v2.Binder) jsonrpc2_v2.Binder

Middleware is a jsonrpc2 middleware function to augment connection binding to handle the handshake method, and record disconnections.

func (*Handshaker) Peers

func (h *Handshaker) Peers() []PeerInfo

Peers returns the peer info this handshaker knows about by way of either the server-side handshake middleware, or client-side handshakes.

type Metadata

type Metadata map[string]interface{}

Metadata holds arbitrary data transferred between jsonrpc2 peers.

type Middleware

type Middleware func(jsonrpc2_v2.Binder) jsonrpc2_v2.Binder

Middleware defines a transformation of jsonrpc2 Binders, that may be composed to build jsonrpc2 servers.

func BindHandler

func BindHandler(hmw HandlerMiddleware) Middleware

BindHandler transforms a HandlerMiddleware into a Middleware.

func CommandInterceptor

func CommandInterceptor(command string, run func(*protocol.ExecuteCommandParams) (interface{}, error)) Middleware

func GoEnvMiddleware

func GoEnvMiddleware() (Middleware, error)

type PeerInfo

type PeerInfo struct {
	// RemoteID is the identity of the current server on its peer.
	RemoteID int64

	// LocalID is the identity of the peer on the server.
	LocalID int64

	// IsClient reports whether the peer is a client. If false, the peer is a
	// server.
	IsClient bool

	// Metadata holds arbitrary information provided by the peer.
	Metadata Metadata
}

PeerInfo holds information about a peering between jsonrpc2 servers.

type ServerBinder

type ServerBinder struct {
	// contains filtered or unexported fields
}

ServerBinder binds incoming connections to a new server.

func NewServerBinder

func NewServerBinder(newServer ServerFunc) *ServerBinder

func (*ServerBinder) Bind

type ServerFunc

A ServerFunc is used to construct an LSP server for a given client.

type ServerState

type ServerState struct {
	Logfile         string          `json:"logfile"`
	DebugAddr       string          `json:"debugAddr"`
	GoplsPath       string          `json:"goplsPath"`
	CurrentClientID string          `json:"currentClientID"`
	Clients         []ClientSession `json:"clients"`
}

ServerState holds information about the gopls daemon process, including its debug information and debug information of all of its current connected clients.

func QueryServerState

func QueryServerState(ctx context.Context, addr string) (*ServerState, error)

QueryServerState queries the server state of the current server.

type StreamServer

type StreamServer struct {
	// contains filtered or unexported fields
}

The StreamServer type is a jsonrpc2.StreamServer that handles incoming streams as a new LSP session, using a shared cache.

func NewStreamServer

func NewStreamServer(cache *cache.Cache, daemon bool) *StreamServer

NewStreamServer creates a StreamServer using the shared cache. If withTelemetry is true, each session is instrumented with telemetry that records RPC statistics.

func (*StreamServer) Binder

func (s *StreamServer) Binder() *ServerBinder

func (*StreamServer) ServeStream

func (s *StreamServer) ServeStream(ctx context.Context, conn jsonrpc2.Conn) error

ServeStream implements the jsonrpc2.StreamServer interface, by handling incoming streams using a new lsp server.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL