flare shipping

cmd/launcher/doctor.go

@@ -16,7 +16,7 @@ func runDoctor(args []string) error {
 	// Doctor assumes a launcher installation (at least partially) exists
 	// Overriding some of the default values allows options to be parsed making this assumption
 	launcher.DefaultAutoupdate = true
-	setDefaultPaths()
+	launcher.SetDefaultPaths()
 
 	opts, err := launcher.ParseOptions("doctor", os.Args[2:])
 	if err != nil {

cmd/launcher/flare.go

@@ -2,6 +2,7 @@
 
 import (
 	"context"
+	"flag"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -11,46 +12,82 @@
 	"github.com/kolide/kit/ulid"
 	"github.com/kolide/launcher/pkg/agent/flags"
 	"github.com/kolide/launcher/pkg/agent/knapsack"
+	"github.com/kolide/launcher/pkg/agent/storage/inmemory"
 	"github.com/kolide/launcher/pkg/debug/checkups"
+	"github.com/kolide/launcher/pkg/debug/shipper"
 	"github.com/kolide/launcher/pkg/launcher"
+	"github.com/peterbourgon/ff/v3"
 )
 
+// sudo /usr/local/kolide-k2/bin/launcher flareupload "note" --debug_upload_request_url="https://example.com"
 func runFlare(args []string) error {
 	// Flare assumes a launcher installation (at least partially) exists
 	// Overriding some of the default values allows options to be parsed making this assumption
 	// TODO this stuff needs some deeper thinking
 	launcher.DefaultAutoupdate = true
-	setDefaultPaths()
-	_ = launcher.DefaultBinDirectoryPath
+	launcher.SetDefaultPaths()
 
-	opts, err := launcher.ParseOptions("flare", args)
+	var (
+		flagset = flag.NewFlagSet("flare", flag.ExitOnError)
+		flSave  = flagset.String(
+			"save",
+			"local",
+			"local | upload",
+		)
+		flNote = flagset.String(
+			"note",
+			"",
+			"note used in URL upload request",
+		)
+		flUploadRequestURL = flagset.String(
+			"upload_request_url",
+			"",
+			"URL to request a signed upload URL",
+		)
+	)
+
+	if err := ff.Parse(flagset, args, ff.WithEnvVarNoPrefix()); err != nil {
+		return fmt.Errorf("parsing flags: %w", err)
+	}
+
+	if *flSave != "local" && *flSave != "upload" {
+		return fmt.Errorf("invalid save option: %s, expected local or upload", *flSave)
+	}
+
+	// were passing an empty array here just to get the default options
+	opts, err := launcher.ParseOptions("flareupload", make([]string, 0))
 	if err != nil {
 		return err
 	}
 
+	logger := log.NewLogfmtLogger(os.Stdout)
+	fcOpts := []flags.Option{flags.WithCmdLineOpts(opts)}
+	flagController := flags.NewFlagController(logger, inmemory.NewStore(logger), fcOpts...)
+
+	k := knapsack.New(nil, flagController, nil)
+	ctx := context.Background()
+
+	if *flSave == "upload" {
+		shipper, err := shipper.New(k, shipper.WithNote(*flNote))
+		if err != nil {
+			return err
+		}
+		return checkups.RunFlare(ctx, k, shipper, checkups.StandaloneEnviroment)
+	}
+
+	// saving flare locally
 	var (
 		dirPath = env.String("KOLIDE_AGENT_FLARE_ZIP_DIR_PATH", "")
 	)
 
-	id := ulid.New()
-	reportName := fmt.Sprintf("kolide_agent_flare_report_%s", id)
+	reportName := fmt.Sprintf("kolide_agent_flare_report_%s", ulid.New())
 	reportPath := fmt.Sprintf("%s.zip", filepath.Join(dirPath, reportName))
 
-	flare, err := os.Create(reportPath)
+	flareFile, err := os.Create(reportPath)
 	if err != nil {
 		return fmt.Errorf("creating flare file (%s): %w", reportPath, err)
 	}
-	defer func() {
-		_ = flare.Close()
-	}()
-
-	logger := log.NewLogfmtLogger(os.Stdout)
-	fcOpts := []flags.Option{flags.WithCmdLineOpts(opts)}
-	flagController := flags.NewFlagController(logger, nil, fcOpts...)
-	k := knapsack.New(nil, flagController, nil)
-
-	ctx := context.Background()
-	checkups.RunFlare(ctx, k, flare, checkups.StandaloneEnviroment)
+	defer flareFile.Close()
 
-	return nil
+	return checkups.RunFlare(ctx, k, flareFile, checkups.StandaloneEnviroment)
 }

cmd/launcher/launcher.go

@@ -29,6 +29,7 @@ import (
 	"github.com/kolide/launcher/cmd/launcher/internal/updater"
 	"github.com/kolide/launcher/ee/control/actionqueue"
 	"github.com/kolide/launcher/ee/control/consumers/acceleratecontrolconsumer"
+	"github.com/kolide/launcher/ee/control/consumers/flareconsumer"
 	"github.com/kolide/launcher/ee/control/consumers/keyvalueconsumer"
 	"github.com/kolide/launcher/ee/control/consumers/notificationconsumer"
 	desktopRunner "github.com/kolide/launcher/ee/desktop/runner"
@@ -324,6 +325,9 @@ func runLauncher(ctx context.Context, cancel func(), opts *launcher.Options) err
 		// register accelerate control consumer
 		actionsQueue.RegisterActor(acceleratecontrolconsumer.AccelerateControlSubsystem, acceleratecontrolconsumer.New(k))
 
+		// register flare consumer
+		actionsQueue.RegisterActor(flareconsumer.FlareSubsystem, flareconsumer.New(k))
+
 		// create notification consumer
 		notificationConsumer, err := notificationconsumer.NewNotifyConsumer(
 			runner,

ee/consoleuser/consoleuser.go

@@ -0,0 +1,25 @@
+package consoleuser
+
+import (
+	"context"
+	"os/user"
+)
+
+func CurrentUsers(ctx context.Context) ([]*user.User, error) {
+	currentUids, err := CurrentUids(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	users := make([]*user.User, len(currentUids))
+	for i, uid := range currentUids {
+		u, err := user.LookupId(uid)
+		if err != nil {
+			return nil, err
+		}
+
+		users[i] = u
+	}
+
+	return users, nil
+}

ee/control/consumers/flareconsumer/flareconsumer.go

@@ -0,0 +1,58 @@
+package flareconsumer
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+
+	"github.com/kolide/launcher/pkg/agent/types"
+	"github.com/kolide/launcher/pkg/debug/shipper"
+)
+
+const (
+	// Identifier for this consumer.
+	FlareSubsystem = "flare"
+)
+
+type FlareConsumer struct {
+	flarer   flarer
+	knapsack types.Knapsack
+	// newFlareStream is assigned to a field so it can be mocked in tests
+	newFlareStream func(uploadURL string) (io.WriteCloser, error)
+}
+
+type flarer interface {
+	RunFlare(ctx context.Context, k types.Knapsack, flareStream io.WriteCloser) error
+}
+
+func New(knapsack types.Knapsack) *FlareConsumer {
+	return &FlareConsumer{
+		flarer:   &FlareRunner{},
+		knapsack: knapsack,
+		newFlareStream: func(uploadURL string) (io.WriteCloser, error) {
+			return shipper.New(knapsack, shipper.WithUploadURL(uploadURL))
+		},
+	}
+}
+
+func (fc *FlareConsumer) Do(data io.Reader) error {
+	if fc.flarer == nil {
+		return errors.New("flarer is nil")
+	}
+
+	flareData := struct {
+		UploadURL string `json:"upload_url"`
+	}{}
+
+	if err := json.NewDecoder(data).Decode(&flareData); err != nil {
+		return fmt.Errorf("failed to decode key-value json: %w", err)
+	}
+
+	flareStream, err := fc.newFlareStream(flareData.UploadURL)
+	if err != nil {
+		return fmt.Errorf("failed to create flare stream: %w", err)
+	}
+	return fc.flarer.RunFlare(context.Background(), fc.knapsack, flareStream)
+}

ee/control/consumers/flareconsumer/flareconsumer_test.go

@@ -0,0 +1,48 @@
+package flareconsumer
+
+import (
+	"bytes"
+	"io"
+	"testing"
+
+	"github.com/kolide/launcher/ee/control/consumers/flareconsumer/mocks"
+	knapsackMock "github.com/kolide/launcher/pkg/agent/types/mocks"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
+)
+
+func TestFlareConsumer(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name         string
+		flarer       func(t *testing.T) flarer
+		errAssertion require.ErrorAssertionFunc
+	}{
+		{
+			name: "happy path",
+			flarer: func(t *testing.T) flarer {
+				flarer := mocks.NewFlarer(t)
+				flarer.On("RunFlare", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil)
+				return flarer
+			},
+			errAssertion: require.NoError,
+		},
+	}
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			mockSack := knapsackMock.NewKnapsack(t)
+			f := New(mockSack)
+			f.flarer = tt.flarer(t)
+			f.newFlareStream = func(uploadURL string) (io.WriteCloser, error) {
+				// whatever, it implements write closer
+				return &io.PipeWriter{}, nil
+			}
+
+			tt.errAssertion(t, f.Do(bytes.NewBuffer([]byte(`{"upload_url":"https://example.com"}`))))
+		})
+	}
+}

ee/control/consumers/flareconsumer/flarerunner.go

@@ -0,0 +1,15 @@
+package flareconsumer
+
+import (
+	"context"
+	"io"
+
+	"github.com/kolide/launcher/pkg/agent/types"
+	"github.com/kolide/launcher/pkg/debug/checkups"
+)
+
+type FlareRunner struct{}
+
+func (f *FlareRunner) RunFlare(ctx context.Context, k types.Knapsack, flareStream io.WriteCloser) error {
+	return checkups.RunFlare(ctx, k, flareStream, checkups.InSituEnvironment)
+}