+++ /dev/null
-// Copyright 2019 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.
-
-// Replay logs. See README.md
-package main
-
-import (
- "bufio"
- "context"
- "flag"
- "fmt"
- "log"
- "os"
- "os/exec"
- "sort"
- "strconv"
- "strings"
-
- "golang.org/x/tools/gopls/integration/parse"
- "golang.org/x/tools/internal/fakenet"
- "golang.org/x/tools/internal/jsonrpc2"
- p "golang.org/x/tools/internal/lsp/protocol"
-)
-
-var (
- command = flag.String("cmd", "", "location of server to send to, looks for gopls")
- cmp = flag.Bool("cmp", false, "only compare log and /tmp/seen")
- logrdr *bufio.Scanner
- msgs []*parse.Logmsg
- // requests and responses/errors, by id
- clreq = make(map[string]*parse.Logmsg)
- clresp = make(map[string]*parse.Logmsg)
- svreq = make(map[string]*parse.Logmsg)
- svresp = make(map[string]*parse.Logmsg)
-)
-
-func main() {
- log.SetFlags(log.Lshortfile)
- flag.Usage = func() {
- fmt.Fprintln(flag.CommandLine.Output(), "replay [options] <logfile>")
- flag.PrintDefaults()
- }
- flag.Parse()
- if flag.NArg() != 1 {
- flag.Usage()
- os.Exit(2)
- }
- logf := flag.Arg(0)
-
- orig, err := parse.ToRlog(logf)
- if err != nil {
- log.Fatalf("error parsing logfile %q: %v", logf, err)
- }
- ctx := context.Background()
- msgs = orig.Logs
- log.Printf("old %d, hist:%s", len(msgs), orig.Histogram)
-
- if !*cmp {
- log.Print("calling mimic")
- mimic(ctx)
- }
- seen, err := parse.ToRlog("/tmp/seen")
- if err != nil {
- log.Fatal(err)
- }
- newMsgs := seen.Logs
- log.Printf("new %d, hist:%s", len(newMsgs), seen.Histogram)
-
- ok := make(map[string]int)
- f := func(x []*parse.Logmsg, label string, diags map[p.DocumentURI][]p.Diagnostic) {
- counts := make(map[parse.MsgType]int)
- for _, l := range x {
- if l.Method == "window/logMessage" {
- // don't care
- //continue
- }
- if l.Method == "textDocument/publishDiagnostics" {
- v, ok := l.Body.(*p.PublishDiagnosticsParams)
- if !ok {
- log.Fatalf("got %T expected PublishDiagnosticsParams", l.Body)
- }
- diags[v.URI] = v.Diagnostics
- }
- counts[l.Type]++
- // notifications only
- if l.Type != parse.ToServer && l.Type != parse.ToClient {
- continue
- }
- s := fmt.Sprintf("%s %s %s", strings.Replace(l.Hdr, "\r", "", -1), label, l.Type)
- if i := strings.Index(s, "notification"); i != -1 {
- s = s[i+12:]
- }
- if len(s) > 120 {
- s = s[:120]
- }
- ok[s]++
- }
- msg := ""
- for i := parse.ClRequest; i <= parse.ReportErr; i++ {
- msg += fmt.Sprintf("%s:%d ", i, counts[i])
- }
- log.Printf("%s: %s", label, msg)
- }
- mdiags := make(map[p.DocumentURI][]p.Diagnostic)
- f(msgs, "old", mdiags)
- vdiags := make(map[p.DocumentURI][]p.Diagnostic)
- f(newMsgs, "new", vdiags)
- buf := []string{}
- for k := range ok {
- buf = append(buf, fmt.Sprintf("%s %d", k, ok[k]))
- }
- if len(buf) > 0 {
- log.Printf("counts of notifications")
- sort.Strings(buf)
- for _, k := range buf {
- log.Print(k)
- }
- }
- buf = buf[0:0]
- for k, v := range mdiags {
- va := vdiags[k]
- if len(v) != len(va) {
- buf = append(buf, fmt.Sprintf("new has %d, old has %d for %s",
- len(va), len(v), k))
- }
- }
- for ka := range vdiags {
- if _, ok := mdiags[ka]; !ok {
- buf = append(buf, fmt.Sprintf("new diagnostics, but no old ones, for %s",
- ka))
- }
- }
- if len(buf) > 0 {
- log.Print("diagnostics differ:")
- for _, s := range buf {
- log.Print(s)
- }
- }
-}
-
-func send(ctx context.Context, l *parse.Logmsg, stream jsonrpc2.Stream, id *jsonrpc2.ID) {
- if id == nil {
- // need to use the number version of ID
- n, err := strconv.Atoi(l.ID)
- if err != nil {
- n = 0
- }
- nid := jsonrpc2.NewIntID(int64(n))
- id = &nid
- }
- var msg jsonrpc2.Message
- var err error
- switch l.Type {
- case parse.ClRequest:
- msg, err = jsonrpc2.NewCall(*id, l.Method, l.Body)
- case parse.SvResponse:
- msg, err = jsonrpc2.NewResponse(*id, l.Body, nil)
- case parse.ToServer:
- msg, err = jsonrpc2.NewNotification(l.Method, l.Body)
- default:
- log.Fatalf("sending %s", l.Type)
- }
- if err != nil {
- log.Fatal(err)
- }
- stream.Write(ctx, msg)
-}
-
-func respond(ctx context.Context, c *jsonrpc2.Call, stream jsonrpc2.Stream) {
- // c is a server request
- // pick out the id, and look for the response in msgs
- id := c.ID()
- idstr := fmt.Sprint(id)
- for _, l := range msgs {
- if l.ID == idstr && l.Type == parse.SvResponse {
- // check that the methods match?
- // need to send back the same ID we got.
- send(ctx, l, stream, &id)
- return
- }
- }
- log.Fatalf("no response found %q %+v %+v", c.Method(), c.ID(), c)
-}
-
-func findgopls() string {
- totry := [][]string{{"GOBIN", "/gopls"}, {"GOPATH", "/bin/gopls"}, {"HOME", "/go/bin/gopls"}}
- // looks in the places go install would install:
- // GOBIN, else GOPATH/bin, else HOME/go/bin
- ok := func(s string) bool {
- fd, err := os.Open(s)
- if err != nil {
- return false
- }
- fi, err := fd.Stat()
- if err != nil {
- return false
- }
- return fi.Mode()&0111 != 0
- }
- for _, t := range totry {
- g := os.Getenv(t[0])
- if g != "" && ok(g+t[1]) {
- gopls := g + t[1]
- log.Printf("using gopls at %s", gopls)
- return gopls
- }
- }
- log.Fatal("could not find gopls")
- return ""
-}
-
-func mimic(ctx context.Context) {
- log.Printf("mimic %d", len(msgs))
- if *command == "" {
- *command = findgopls()
- }
- cmd := exec.Command(*command, "-logfile", "/tmp/seen", "-rpc.trace")
- toServer, err := cmd.StdinPipe()
- if err != nil {
- log.Fatal(err)
- }
- fromServer, err := cmd.StdoutPipe()
- if err != nil {
- log.Fatal(err)
- }
- err = cmd.Start()
- if err != nil {
- log.Fatal(err)
- }
- conn := fakenet.NewConn("stdio", fromServer, toServer)
- stream := jsonrpc2.NewHeaderStream(conn)
- rchan := make(chan jsonrpc2.Message, 10) // do we need buffering?
- rdr := func() {
- for {
- msg, _, err := stream.Read(ctx)
- if err != nil {
- rchan <- nil // close it instead?
- return
- }
- rchan <- msg
- }
- }
- go rdr()
- // send as many as possible: all clrequests and toservers up to a clresponse
- // and loop
- seenids := make(map[string]bool) // id's that have been responded to:
-big:
- for _, l := range msgs {
- switch l.Type {
- case parse.ToServer: // just send these as we get to them
- send(ctx, l, stream, nil)
- case parse.ClRequest:
- send(ctx, l, stream, nil) // for now, wait for a response, to make sure code is ok
- fallthrough
- case parse.ClResponse, parse.ReportErr: // don't go past these until they're received
- if seenids[l.ID] {
- break // onward, as it has been received already
- }
- done:
- for {
- msg := <-rchan
- if msg == nil {
- break big
- }
- // if it's svrequest, do something
- // if it's clresponse or reporterr, add to seenids, and if it
- // is l.id, break out of the loop, and continue the outer loop
-
- switch msg := msg.(type) {
- case *jsonrpc2.Call:
- if parse.FromServer(msg.Method()) {
- respond(ctx, msg, stream)
- continue done // still waiting
- }
- case *jsonrpc2.Response:
- id := fmt.Sprint(msg.ID())
- seenids[id] = true
- if id == l.ID {
- break done
- }
- }
- }
- case parse.SvRequest: // not ours to send
- continue
- case parse.SvResponse: // sent by us, if the request arrives
- continue
- case parse.ToClient: // we don't send these
- continue
- }
- }
-}
projects / dotfiles / .git / blobdiff