WIP

go.mod

@@ -8,6 +8,7 @@ require (
  github.com/fsnotify/fsnotify v1.4.9
  github.com/gammazero/workerpool v1.0.0
  github.com/google/go-cmp v0.5.1
+ github.com/google/uuid v1.1.2
  github.com/hashicorp/go-multierror v1.1.0
  github.com/hashicorp/go-version v1.2.1
  github.com/hashicorp/hcl-lang v0.0.0-20201116081236-948e43712a65

go.sum

@@ -133,6 +133,8 @@ github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXi
 github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
 github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
 github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
+github.com/google/uuid v1.1.2 h1:EVhdT+1Kseyi1/pUmXKaFxYsDNy9RQYkMWRH68J/W7Y=
+github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
 github.com/googleapis/gax-go/v2 v2.0.5 h1:sjZBwGj9Jlw33ImPtvFviGYvseOtDM7hkSKB7+Tv3SM=
 github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=

internal/context/context.go

@@ -36,6 +36,7 @@ var (
  ctxCommandPrefix = &contextKey{"command prefix"}
  ctxDiags = &contextKey{"diagnostics"}
  ctxLsVersion = &contextKey{"language server version"}
+ ctxProgressToken = &contextKey{"progress token"}
 )
 
 func missingContextErr(ctxKey *contextKey) *MissingContextErr {
@@ -249,3 +250,15 @@ func LanguageServerVersion(ctx context.Context) (string, bool) {
  }
  return version, true
 }
+
+func WithProgressToken(ctx context.Context, pt lsp.ProgressToken) context.Context {
+ return context.WithValue(ctx, ctxProgressToken, pt)
+}
+
+func ProgressToken(ctx context.Context) (lsp.ProgressToken, bool) {
+ pt, ok := ctx.Value(ctxProgressToken).(lsp.ProgressToken)
+ if !ok {
+ return "", false
+ }
+ return pt, true
+}

internal/langserver/cmd/cmd.go

@@ -2,6 +2,7 @@ package cmd
 
 import (
  "context"
+ "sort"
  "strings"
 )
 
@@ -21,6 +22,11 @@ func (h Handlers) Names(commandPrefix string) (names []string) {
  for name := range h {
  names = append(names, commandPrefix+name)
  }
+
+ sort.SliceStable(names, func(i, j int) bool {
+ return names[i] < names[j]
+ })
+
  return names
 }
 

internal/langserver/handlers/command/init.go

@@ -0,0 +1,56 @@
+package command
+
+import (
+ "context"
+ "fmt"
+
+ "github.com/creachadair/jrpc2/code"
+ lsctx "github.com/hashicorp/terraform-ls/internal/context"
+ "github.com/hashicorp/terraform-ls/internal/langserver/cmd"
+ ilsp "github.com/hashicorp/terraform-ls/internal/lsp"
+ lsp "github.com/hashicorp/terraform-ls/internal/protocol"
+)
+
+func TerraformInitHandler(ctx context.Context, args cmd.CommandArgs) (interface{}, error) {
+ fileUri, ok := args.GetString("uri")
+ if !ok || fileUri == "" {
+ return nil, fmt.Errorf("%w: expected uri argument to be set", code.InvalidParams.Err())
+ }
+
+ fh := ilsp.FileHandlerFromDocumentURI(lsp.DocumentURI(fileUri))
+
+ cf, err := lsctx.RootModuleFinder(ctx)
+ if err != nil {
+ return nil, err
+ }
+
+ rm, err := cf.RootModuleByPath(fh.Dir())
+ if err != nil {
+ return nil, err
+ }
+
+ progressBegin(ctx, "Initializing")
+ defer func() {
+ progressEnd(ctx, "Finished")
+ }()
+
+ progressReport(ctx, "Running terraform init ...")
+ err = rm.ExecuteTerraformInit(ctx)
+ if err != nil {
+ return nil, err
+ }
+
+ progressReport(ctx, "Detecting paths to watch ...")
+ paths := rm.PathsToWatch()
+
+ w, err := lsctx.Watcher(ctx)
+ if err != nil {
+ return nil, err
+ }
+ err = w.AddPaths(paths)
+ if err != nil {
+ return nil, fmt.Errorf("failed to add watch for dir (%s): %+v", fh.Dir(), err)
+ }
+
+ return nil, nil
+}

internal/langserver/handlers/command/progress.go

@@ -0,0 +1,54 @@
+package command
+
+import (
+ "context"
+
+ "github.com/creachadair/jrpc2"
+ lsctx "github.com/hashicorp/terraform-ls/internal/context"
+ lsp "github.com/hashicorp/terraform-ls/internal/protocol"
+)
+
+func progressBegin(ctx context.Context, title string) error {
+ token, ok := lsctx.ProgressToken(ctx)
+ if !ok {
+ return nil
+ }
+
+ return jrpc2.PushNotify(ctx, "$/progress", lsp.ProgressParams{
+ Token: token,
+ Value: lsp.WorkDoneProgressBegin{
+ Kind: "begin",
+ Title: title,
+ },
+ })
+}
+
+func progressReport(ctx context.Context, message string) error {
+ token, ok := lsctx.ProgressToken(ctx)
+ if !ok {
+ return nil
+ }
+
+ return jrpc2.PushNotify(ctx, "$/progress", lsp.ProgressParams{
+ Token: token,
+ Value: lsp.WorkDoneProgressReport{
+ Kind: "report",
+ Message: message,
+ },
+ })
+}
+
+func progressEnd(ctx context.Context, message string) error {
+ token, ok := lsctx.ProgressToken(ctx)
+ if !ok {
+ return nil
+ }
+
+ return jrpc2.PushNotify(ctx, "$/progress", lsp.ProgressParams{
+ Token: token,
+ Value: lsp.WorkDoneProgressEnd{
+ Kind: "end",
+ Message: message,
+ },
+ })
+}

internal/langserver/handlers/did_open.go

@@ -7,11 +7,13 @@ import (
  "strings"
 
  "github.com/creachadair/jrpc2"
+ "github.com/google/uuid"
  lsctx "github.com/hashicorp/terraform-ls/internal/context"
+ "github.com/hashicorp/terraform-ls/internal/langserver/cmd"
+ "github.com/hashicorp/terraform-ls/internal/langserver/handlers/command"
  ilsp "github.com/hashicorp/terraform-ls/internal/lsp"
  lsp "github.com/hashicorp/terraform-ls/internal/protocol"
  "github.com/hashicorp/terraform-ls/internal/terraform/rootmodule"
- "github.com/hashicorp/terraform-ls/internal/watcher"
 )
 
 func (lh *logHandler) TextDocumentDidOpen(ctx context.Context, params lsp.DidOpenTextDocumentParams) error {
@@ -37,11 +39,6 @@ func (lh *logHandler) TextDocumentDidOpen(ctx context.Context, params lsp.DidOpe
  return err
  }
 
- w, err := lsctx.Watcher(ctx)
- if err != nil {
- return err
- }
-
  rootDir, _ := lsctx.RootDirectory(ctx)
  readableDir := humanReadablePath(rootDir, f.Dir())
 
@@ -83,7 +80,7 @@ func (lh *logHandler) TextDocumentDidOpen(ctx context.Context, params lsp.DidOpe
  } else if len(candidates) == 0 {
  // TODO: Only notify once per f.Dir() per session
  go func() {
- err := askInitForEmptyRootModule(ctx, w, rootDir, f.Dir())
+ err := askInitForEmptyRootModule(ctx, rootDir, f)
  if err != nil {
  jrpc2.PushNotify(ctx, "window/showMessage", lsp.ShowMessageParams{
  Type: lsp.Error,
@@ -138,12 +135,12 @@ func humanReadablePath(rootDir, path string) string {
  return relDir
 }
 
-func askInitForEmptyRootModule(ctx context.Context, w watcher.Watcher, rootDir, dir string) error {
+func askInitForEmptyRootModule(ctx context.Context, rootDir string, dh ilsp.DirHandler) error {
  msg := fmt.Sprintf("No root module found for %q."+
  " Functionality may be limited."+
  // Unfortunately we can't be any more specific wrt where
  // because we don't gather "init-able folders" in any way
- " You may need to run terraform init.", humanReadablePath(rootDir, dir))
+ " You may need to run terraform init.", humanReadablePath(rootDir, dh.Dir()))
  title := "terraform init"
  resp, err := jrpc2.PushCall(ctx, "window/showMessageRequest", lsp.ShowMessageRequestParams{
  Type: lsp.Info,
@@ -162,21 +159,44 @@ func askInitForEmptyRootModule(ctx context.Context, w watcher.Watcher, rootDir,
  return fmt.Errorf("unmarshal MessageActionItem: %+v", err)
  }
  if action.Title == title {
- rmm, err := lsctx.RootModuleManager(ctx)
+ ctx, err := initiateProgress(ctx)
  if err != nil {
  return err
  }
-
- rm, err := rmm.InitAndUpdateRootModule(ctx, dir)
- if err != nil {
- return fmt.Errorf("failed to init root module %+v", err)
- }
-
- paths := rm.PathsToWatch()
- err = w.AddPaths(paths)
+ _, err = command.TerraformInitHandler(ctx, cmd.CommandArgs{
+ "uri": dh.URI(),
+ })
  if err != nil {
- return fmt.Errorf("failed to add watch for dir (%s): %+v", dir, err)
+ return fmt.Errorf("Initialization failed: %w", err)
  }
+ return nil
  }
  return nil
 }
+
+func initiateProgress(ctx context.Context) (context.Context, error) {
+ cc, err := lsctx.ClientCapabilities(ctx)
+ if err != nil {
+ return ctx, err
+ }
+
+ if !cc.Window.WorkDoneProgress {
+ // server-side reporting not supported
+ return ctx, nil
+ }
+
+ id, err := uuid.NewUUID()
+ if err != nil {
+ return nil, err
+ }
+ token := lsp.ProgressToken(id.String())
+
+ _, err = jrpc2.PushCall(ctx, "window/workDoneProgress/create", lsp.WorkDoneProgressCreateParams{
+ Token: token,
+ })
+ if err == nil {
+ return lsctx.WithProgressToken(ctx, token), nil
+ }
+
+ return ctx, err
+}

internal/langserver/handlers/execute_command.go

@@ -12,7 +12,8 @@ import (
 )
 
 var handlers = cmd.Handlers{
- cmd.Name("rootmodules"): command.RootModulesHandler,
+ cmd.Name("rootmodules"): command.RootModulesHandler,
+ cmd.Name("terraform.init"): command.TerraformInitHandler,
 }
 
 func (lh *logHandler) WorkspaceExecuteCommand(ctx context.Context, params lsp.ExecuteCommandParams) (interface{}, error) {
@@ -28,5 +29,11 @@ func (lh *logHandler) WorkspaceExecuteCommand(ctx context.Context, params lsp.Ex
  if !ok {
  return nil, fmt.Errorf("%w: command handler not found for %q", code.MethodNotFound.Err(), params.Command)
  }
+
+ pt, ok := params.WorkDoneToken.(lsp.ProgressToken)
+ if ok {
+ ctx = lsctx.WithProgressToken(ctx, pt)
+ }
+
  return handler(ctx, cmd.ParseCommandArgs(params.Arguments))
 }

internal/langserver/handlers/handlers_test.go

@@ -44,7 +44,8 @@ func initializeResponse(t *testing.T, commandPrefix string) string {
  "firstTriggerCharacter": ""
  },
  "executeCommandProvider": {
- "commands": %s
+ "commands": %s,
+ "workDoneProgress":true
  },
  "workspace": {
  "workspaceFolders": {}

internal/langserver/handlers/initialize.go

@@ -85,6 +85,9 @@ func (lh *logHandler) Initialize(ctx context.Context, params lsp.InitializeParam
  // apply prefix to executeCommand handler names
  serverCaps.Capabilities.ExecuteCommandProvider = lsp.ExecuteCommandOptions{
  Commands: handlers.Names(out.Options.CommandPrefix),
+ WorkDoneProgressOptions: lsp.WorkDoneProgressOptions{
+ WorkDoneProgress: true,
+ },
  }
 
  if len(out.UnusedKeys) > 0 {

internal/langserver/handlers/service.go

@@ -196,10 +196,12 @@ func (svc *service) Assigner() (jrpc2.Assigner, error) {
  if err != nil {
  return nil, err
  }
+ ctx = lsctx.WithClientCapabilities(ctx, cc)
  ctx = lsctx.WithDiagnostics(ctx, diags)
  ctx = lsctx.WithDocumentStorage(ctx, svc.fs)
  ctx = lsctx.WithRootDirectory(ctx, &rootDir)
  ctx = lsctx.WithRootModuleManager(ctx, svc.modMgr)
+ ctx = lsctx.WithRootModuleFinder(ctx, svc.modMgr)
  ctx = lsctx.WithRootModuleWalker(ctx, svc.walker)
  ctx = lsctx.WithWatcher(ctx, ww)
  return handle(ctx, req, lh.TextDocumentDidOpen)

internal/lsp/dir_handler.go

@@ -0,0 +1,6 @@
+package lsp
+
+type DirHandler interface {
+ Dir() string
+ URI() string
+}

internal/terraform/exec/exec.go

@@ -87,15 +87,15 @@ func (e *Executor) setLogPath(method string) error {
  return e.tf.SetLogPath(logPath)
 }
 
-func (e *Executor) Init(ctx context.Context) error {
+func (e *Executor) Init(ctx context.Context, opts ...tfexec.InitOption) error {
  ctx, cancel := e.withTimeout(ctx)
  defer cancel()
  err := e.setLogPath("Init")
  if err != nil {
  return err
  }
 
- return e.contextfulError(ctx, "Init", e.tf.Init(ctx))
+ return e.contextfulError(ctx, "Init", e.tf.Init(ctx, opts...))
 }
 
 func (e *Executor) Format(ctx context.Context, input []byte) ([]byte, error) {