mirror of
https://github.com/golang/go
synced 2024-11-18 18:54:42 -07:00
a208025ccb
Most users will not want to manage their own gopls instance, but may still want to benefit from using a shared instance. This CL adds support for an 'auto' network type that can be encoded in the -remote flag similarly to UDS (i.e. -remote="auto;uniqueid"). In this mode, the actual remote address will be resolved automatically based on the executing environment and unique identifier, and the remote server will be started if it isn't already running. Updates golang/go#34111 Change-Id: Ib62159765a108f3645f57709b8ff079b39dd6727 Reviewed-on: https://go-review.googlesource.com/c/tools/+/220137 Run-TryBot: Robert Findley <rfindley@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Heschi Kreinick <heschi@google.com>
101 lines
3.2 KiB
Go
101 lines
3.2 KiB
Go
// Copyright 2018 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 cmd
|
|
|
|
import (
|
|
"context"
|
|
"flag"
|
|
"fmt"
|
|
"os"
|
|
"strings"
|
|
|
|
"golang.org/x/tools/internal/jsonrpc2"
|
|
"golang.org/x/tools/internal/lsp/cache"
|
|
"golang.org/x/tools/internal/lsp/lsprpc"
|
|
"golang.org/x/tools/internal/lsp/protocol"
|
|
"golang.org/x/tools/internal/tool"
|
|
)
|
|
|
|
// Serve is a struct that exposes the configurable parts of the LSP server as
|
|
// flags, in the right form for tool.Main to consume.
|
|
type Serve struct {
|
|
Logfile string `flag:"logfile" help:"filename to log to. if value is \"auto\", then logging to a default output file is enabled"`
|
|
Mode string `flag:"mode" help:"no effect"`
|
|
Port int `flag:"port" help:"port on which to run gopls for debugging purposes"`
|
|
Address string `flag:"listen" help:"address on which to listen for remote connections. If prefixed by 'unix;', the subsequent address is assumed to be a unix domain socket. Otherwise, TCP is used."`
|
|
Trace bool `flag:"rpc.trace" help:"print the full rpc trace in lsp inspector format"`
|
|
Debug string `flag:"debug" help:"serve debug information on the supplied address"`
|
|
|
|
app *Application
|
|
}
|
|
|
|
func (s *Serve) Name() string { return "serve" }
|
|
func (s *Serve) Usage() string { return "" }
|
|
func (s *Serve) ShortHelp() string {
|
|
return "run a server for Go code using the Language Server Protocol"
|
|
}
|
|
func (s *Serve) DetailedHelp(f *flag.FlagSet) {
|
|
fmt.Fprint(f.Output(), `
|
|
The server communicates using JSONRPC2 on stdin and stdout, and is intended to be run directly as
|
|
a child of an editor process.
|
|
|
|
gopls server flags are:
|
|
`)
|
|
f.PrintDefaults()
|
|
}
|
|
|
|
// Run configures a server based on the flags, and then runs it.
|
|
// It blocks until the server shuts down.
|
|
func (s *Serve) Run(ctx context.Context, args ...string) error {
|
|
if len(args) > 0 {
|
|
return tool.CommandLineErrorf("server does not take arguments, got %v", args)
|
|
}
|
|
|
|
closeLog, err := s.app.debug.SetLogFile(s.Logfile)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer closeLog()
|
|
s.app.debug.ServerAddress = s.Address
|
|
s.app.debug.DebugAddress = s.Debug
|
|
s.app.debug.Serve(ctx)
|
|
s.app.debug.MonitorMemory(ctx)
|
|
|
|
var ss jsonrpc2.StreamServer
|
|
if s.app.Remote != "" {
|
|
network, addr := parseAddr(s.app.Remote)
|
|
ss = lsprpc.NewForwarder(network, addr, true, s.app.debug)
|
|
} else {
|
|
ss = lsprpc.NewStreamServer(cache.New(s.app.options, s.app.debug.State), true, s.app.debug)
|
|
}
|
|
|
|
if s.Address != "" {
|
|
network, addr := parseAddr(s.Address)
|
|
return jsonrpc2.ListenAndServe(ctx, network, addr, ss)
|
|
}
|
|
if s.Port != 0 {
|
|
addr := fmt.Sprintf(":%v", s.Port)
|
|
return jsonrpc2.ListenAndServe(ctx, "tcp", addr, ss)
|
|
}
|
|
stream := jsonrpc2.NewHeaderStream(os.Stdin, os.Stdout)
|
|
if s.Trace {
|
|
stream = protocol.LoggingStream(stream, s.app.debug.LogWriter)
|
|
}
|
|
return ss.ServeStream(ctx, stream)
|
|
}
|
|
|
|
// parseAddr parses the -listen flag in to a network, and address.
|
|
func parseAddr(listen string) (network string, address string) {
|
|
// Allow passing just -remote=auto, as a shorthand for using automatic remote
|
|
// resolution.
|
|
if listen == lsprpc.AutoNetwork {
|
|
return lsprpc.AutoNetwork, ""
|
|
}
|
|
if parts := strings.SplitN(listen, ";", 2); len(parts) == 2 {
|
|
return parts[0], parts[1]
|
|
}
|
|
return "tcp", listen
|
|
}
|