TUN-8730: implement diag/configuration

Implements the endpoint that retrieves the configuration of a running instance.

The configuration consists in a map of cli flag to the provided value along with the uid that of the user that started the process

diagnostic/handlers.go

@@ -4,21 +4,28 @@ import (
 	"context"
 	"encoding/json"
 	"net/http"
+	"os"
+	"path/filepath"
+	"strconv"
 	"time"
 
 	"github.com/google/uuid"
 	"github.com/rs/zerolog"
+	"github.com/urfave/cli/v2"
 
+	"github.com/cloudflare/cloudflared/logger"
 	"github.com/cloudflare/cloudflared/tunnelstate"
 )
 
 type Handler struct {
-	log             *zerolog.Logger
-	timeout         time.Duration
-	systemCollector SystemCollector
-	tunnelID        uuid.UUID
-	connectorID     uuid.UUID
-	tracker         *tunnelstate.ConnTracker
+	log               *zerolog.Logger
+	timeout           time.Duration
+	systemCollector   SystemCollector
+	tunnelID          uuid.UUID
+	connectorID       uuid.UUID
+	tracker           *tunnelstate.ConnTracker
+	cli               *cli.Context
+	flagInclusionList []string
 }
 
 func NewDiagnosticHandler(
@@ -28,6 +35,8 @@ func NewDiagnosticHandler(
 	tunnelID uuid.UUID,
 	connectorID uuid.UUID,
 	tracker *tunnelstate.ConnTracker,
+	cli *cli.Context,
+	flagInclusionList []string,
 ) *Handler {
 	logger := log.With().Logger()
 	if timeout == 0 {
@@ -35,12 +44,14 @@ func NewDiagnosticHandler(
 	}
 
 	return &Handler{
-		log:             &logger,
-		timeout:         timeout,
-		systemCollector: systemCollector,
-		tunnelID:        tunnelID,
-		connectorID:     connectorID,
-		tracker:         tracker,
+		log:               &logger,
+		timeout:           timeout,
+		systemCollector:   systemCollector,
+		tunnelID:          tunnelID,
+		connectorID:       connectorID,
+		tracker:           tracker,
+		cli:               cli,
+		flagInclusionList: flagInclusionList,
 	}
 }
 
@@ -110,8 +121,77 @@ func (handler *Handler) TunnelStateHandler(writer http.ResponseWriter, _ *http.R
 	}
 }
 
-func writeResponse(writer http.ResponseWriter, bytes []byte, logger *zerolog.Logger) {
-	bytesWritten, err := writer.Write(bytes)
+func (handler *Handler) ConfigurationHandler(writer http.ResponseWriter, _ *http.Request) {
+	log := handler.log.With().Str(collectorField, configurationCollectorName).Logger()
+	log.Info().Msg("Collection started")
+
+	defer func() {
+		log.Info().Msg("Collection finished")
+	}()
+
+	flagsNames := handler.cli.FlagNames()
+	flags := make(map[string]string, len(flagsNames))
+
+	for _, flag := range flagsNames {
+		value := handler.cli.String(flag)
+
+		// empty values are not relevant
+		if value == "" {
+			continue
+		}
+
+		// exclude flags that are sensitive
+		isIncluded := handler.isFlagIncluded(flag)
+		if !isIncluded {
+			continue
+		}
+
+		switch flag {
+		case logger.LogDirectoryFlag:
+		case logger.LogFileFlag:
+			{
+				// the log directory may be relative to the instance thus it must be resolved
+				absolute, err := filepath.Abs(value)
+				if err != nil {
+					handler.log.Error().Err(err).Msgf("could not convert %s path to absolute", flag)
+				} else {
+					flags[flag] = absolute
+				}
+			}
+		default:
+			flags[flag] = value
+		}
+	}
+
+	// The UID is included to help the
+	// diagnostic tool to understand
+	// if this instance is managed or not.
+	flags[configurationKeyUid] = strconv.Itoa(os.Getuid())
+	encoder := json.NewEncoder(writer)
+
+	err := encoder.Encode(flags)
+	if err != nil {
+		handler.log.Error().Err(err).Msgf("error occurred whilst serializing response")
+		writer.WriteHeader(http.StatusInternalServerError)
+	}
+}
+
+func (handler *Handler) isFlagIncluded(flag string) bool {
+	isIncluded := false
+
+	for _, include := range handler.flagInclusionList {
+		if include == flag {
+			isIncluded = true
+
+			break
+		}
+	}
+
+	return isIncluded
+}
+
+func writeResponse(w http.ResponseWriter, bytes []byte, logger *zerolog.Logger) {
+	bytesWritten, err := w.Write(bytes)
 	if err != nil {
 		logger.Error().Err(err).Msg("error occurred writing response")
 	} else if bytesWritten != len(bytes) {