Added command line options to allow daemon connection

Author: cmaglie

Diff for: ls/builder.go

@@ -159,10 +159,8 @@ func (ls *INOLanguageServer) generateBuildEnvironment(ctx context.Context, logge
 	// Extract all build information from language server status
 	ls.readLock(logger, false)
 	sketchRoot := ls.sketchRoot
-	fqbn := ls.config.Fqbn
 	buildPath := ls.buildPath
-	cliPath := ls.config.CliPath
-	cliConfigPath := ls.config.CliConfigPath
+	config := ls.config
 	type overridesFile struct {
 		Overrides map[string]string `json:"overrides"`
 	}
@@ -178,19 +176,19 @@ func (ls *INOLanguageServer) generateBuildEnvironment(ctx context.Context, logge
 	ls.readUnlock(logger)
 
 	var success bool
-	if cliPath == nil {
+	if config.CliPath == nil {
 		// Establish a connection with the gRPC server, started with the command:
 		// arduino-cli daemon
-		conn, err := grpc.Dial("localhost:50051", grpc.WithInsecure(), grpc.WithBlock())
+		conn, err := grpc.Dial(config.CliDaemonAddress, grpc.WithInsecure(), grpc.WithBlock())
 		if err != nil {
 			return false, fmt.Errorf("error connecting to arduino-cli rpc server: %w", err)
 		}
 		defer conn.Close()
 
 		client := rpc.NewArduinoCoreServiceClient(conn)
 		compileReq := &rpc.CompileRequest{
-			Instance:                      &rpc.Instance{Id: 1}, // XXX
-			Fqbn:                          fqbn,
+			Instance:                      &rpc.Instance{Id: int32(config.CliInstanceNumber)},
+			Fqbn:                          config.Fqbn,
 			SketchPath:                    sketchRoot.String(),
 			SourceOverride:                data.Overrides,
 			BuildPath:                     buildPath.String(),
@@ -248,15 +246,15 @@ func (ls *INOLanguageServer) generateBuildEnvironment(ctx context.Context, logge
 		}
 
 		// Run arduino-cli to perform the build
-		args := []string{cliPath.String(),
-			"--config-file", cliConfigPath.String(),
+		args := []string{config.CliPath.String(),
+			"--config-file", config.CliConfigPath.String(),
 			"compile",
-			"--fqbn", fqbn,
+			"--fqbn", config.Fqbn,
 			"--only-compilation-database",
-			//"--clean",
 			"--source-override", overridesJSON.String(),
 			"--build-path", buildPath.String(),
 			"--format", "json",
+			//"--clean",
 			sketchRoot.String(),
 		}
 		cmd, err := executils.NewProcess(args...)

Diff for: ls/ls.go

@@ -49,12 +49,14 @@ type INOLanguageServer struct {
 
 // Config describes the language server configuration.
 type Config struct {
-	Fqbn          string
-	CliPath       *paths.Path
-	CliConfigPath *paths.Path
-	ClangdPath    *paths.Path
-	FormatterConf *paths.Path
-	EnableLogging bool
+	Fqbn              string
+	CliPath           *paths.Path
+	CliConfigPath     *paths.Path
+	ClangdPath        *paths.Path
+	CliDaemonAddress  string
+	CliInstanceNumber int
+	FormatterConf     *paths.Path
+	EnableLogging     bool
 }
 
 var yellow = color.New(color.FgHiYellow)

Diff for: main.go

@@ -14,69 +14,84 @@ import (
 	"github.com/arduino/go-paths-helper"
 )
 
-var clangdPath string
-var compileCommandsDir string
-var cliPath string
-var cliConfigPath string
-var initialFqbn string
-var initialBoardName string
-var enableLogging bool
-var loggingBasePath string
-var formatFilePath string
-
 func main() {
-	flag.StringVar(&clangdPath, "clangd", "clangd", "Path to clangd executable")
-	flag.StringVar(&compileCommandsDir, "compile-commands-dir", "", "Specify a path to look for compile_commands.json. If path is invalid, clangd will look in the current directory and parent paths of each source file. If not specified, the clangd process is started without the compilation database.")
-	flag.StringVar(&cliPath, "cli", "arduino-cli", "Path to arduino-cli executable")
-	flag.StringVar(&cliConfigPath, "cli-config", "", "Path to arduino-cli config file")
-	flag.StringVar(&initialFqbn, "fqbn", "arduino:avr:uno", "Fully qualified board name to use initially (can be changed via JSON-RPC)")
-	flag.StringVar(&initialBoardName, "board-name", "", "User-friendly board name to use initially (can be changed via JSON-RPC)")
-	flag.BoolVar(&enableLogging, "log", false, "Enable logging to files")
-	flag.StringVar(&loggingBasePath, "logpath", ".", "Location where to write logging files to when logging is enabled")
-	flag.StringVar(&formatFilePath, "format-conf-path", "", "Path to global clang-format configuration file")
+	clangdPath := flag.String(
+		"clangd", "",
+		"Path to clangd executable")
+	cliPath := flag.String(
+		"cli", "",
+		"Path to arduino-cli executable")
+	cliConfigPath := flag.String(
+		"cli-config", "",
+		"Path to arduino-cli config file")
+	fqbn := flag.String(
+		"fqbn", "",
+		"Fully qualified board name to use initially (can be changed via JSON-RPC)")
+	/* unused */ _ = flag.String(
+		"board-name", "",
+		"User-friendly board name to use initially (can be changed via JSON-RPC)")
+	enableLogging := flag.Bool(
+		"log", false,
+		"Enable logging to files")
+	loggingBasePath := flag.String(
+		"logpath", ".",
+		"Location where to write logging files to when logging is enabled")
+	formatFilePath := flag.String(
+		"format-conf-path", "",
+		"Path to global clang-format configuration file")
+	cliDaemonAddress := flag.String(
+		"cli-daemon-addr", "",
+		"TCP address and port of the Arduino CLI daemon (for example: localhost:50051)")
+	cliDaemonInstanceNumber := flag.Int(
+		"cli-daemon-instance", -1,
+		"Instance number of the Arduino CLI daemon")
 	flag.Parse()
 
-	if loggingBasePath != "" {
-		streams.GlobalLogDirectory = paths.New(loggingBasePath)
-	} else if enableLogging {
+	if *loggingBasePath != "" {
+		streams.GlobalLogDirectory = paths.New(*loggingBasePath)
+	} else if *enableLogging {
 		log.Fatalf("Please specify logpath")
 	}
 
-	if enableLogging {
+	if *enableLogging {
 		logfile := streams.OpenLogFileAs("inols-err.log")
 		log.SetOutput(io.MultiWriter(logfile, os.Stderr))
 		defer streams.CatchAndLogPanic()
 		go func() {
 			log.Println(http.ListenAndServe("localhost:6060", nil))
 		}()
+		log.Println("Language server launched with arguments:")
+		for i, arg := range os.Args {
+			log.Printf("  arg[%d] = %s", i, arg)
+		}
 	} else {
 		log.SetOutput(os.Stderr)
 	}
 
-	if cliConfigPath == "" {
-		log.Fatal("Path to ArduinoCLI config file must be set.")
+	if *cliPath != "" {
+		if *cliConfigPath == "" {
+			log.Fatal("Path to ArduinoCLI config file must be set.")
+		}
+	} else if *cliDaemonAddress == "" || *cliDaemonInstanceNumber == -1 {
+		log.Fatal("ArduinoCLI daemon address and instance number must be set.")
 	}
-	if clangdPath == "" {
+	if *clangdPath == "" {
 		log.Fatal("Path to Clangd must be set.")
 	}
 
 	config := &ls.Config{
-		Fqbn:          initialFqbn,
-		ClangdPath:    paths.New(clangdPath),
-		EnableLogging: enableLogging,
-	}
-	if cliPath != "" {
-		config.CliPath = paths.New(cliPath)
-	}
-	if cliConfigPath != "" {
-		config.CliConfigPath = paths.New(cliConfigPath)
-	}
-	if formatFilePath != "" {
-		config.FormatterConf = paths.New(formatFilePath)
+		Fqbn:              *fqbn,
+		ClangdPath:        paths.New(*clangdPath),
+		EnableLogging:     *enableLogging,
+		CliPath:           paths.New(*cliPath),
+		CliConfigPath:     paths.New(*cliConfigPath),
+		FormatterConf:     paths.New(*formatFilePath),
+		CliDaemonAddress:  *cliDaemonAddress,
+		CliInstanceNumber: *cliDaemonInstanceNumber,
 	}
 
 	stdio := streams.NewReadWriteCloser(os.Stdin, os.Stdout)
-	if enableLogging {
+	if *enableLogging {
 		stdio = streams.LogReadWriteCloserAs(stdio, "inols.log")
 	}