Merge pull request #60 from codecrafters-io/use-actions

Use actions

Author: rohitpaulk

cmd/codecrafters/main.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-	"context"
 	"flag"
 	"fmt"
 	"os"
@@ -13,6 +12,8 @@ import (
 
 // Usage: codecrafters test
 func main() {
+	utils.InitLogger()
+
 	utils.InitSentry()
 	defer utils.TeardownSentry()
 
@@ -69,32 +70,27 @@ VERSION
 }
 
 func run() error {
-	ctx := context.Background()
-	logger := utils.NewLogger()
 	cmd := flag.Arg(0)
-
-	logger.Debug().Msgf("Running command: %s", cmd)
-
-	ctx = logger.WithContext(ctx)
+	utils.Logger.Debug().Msgf("Running command: %s", cmd)
 
 	switch cmd {
 	case "test":
 		testCmd := flag.NewFlagSet("test", flag.ExitOnError)
 		shouldTestPrevious := testCmd.Bool("previous", false, "run tests for the current stage and all previous stages in ascending order")
 		testCmd.Parse(flag.Args()[1:]) // parse the args after the test command
 
-		return commands.TestCommand(ctx, *shouldTestPrevious)
+		return commands.TestCommand(*shouldTestPrevious)
 	case "submit":
-		return commands.SubmitCommand(ctx)
+		return commands.SubmitCommand()
 	case "task":
 		taskCmd := flag.NewFlagSet("task", flag.ExitOnError)
 		stageSlug := taskCmd.String("stage", "", "view instructions for a specific stage (slug, +N, or -N)")
 		raw := taskCmd.Bool("raw", false, "print instructions without pretty-printing")
 		taskCmd.Parse(flag.Args()[1:])
 
-		return commands.TaskCommand(ctx, *stageSlug, *raw)
+		return commands.TaskCommand(*stageSlug, *raw)
 	case "update-buildpack":
-		return commands.UpdateBuildpackCommand(ctx)
+		return commands.UpdateBuildpackCommand()
 	case "help",
 		"": // no argument
 		flag.Usage()

internal/actions/action.go

@@ -0,0 +1,38 @@
+package actions
+
+import (
+	"fmt"
+
+	"github.com/codecrafters-io/cli/internal/client"
+)
+
+type Action interface {
+	Execute() error
+}
+
+func ActionFromDefinition(actionDefinition client.ActionDefinition) (Action, error) {
+	switch actionDefinition.Type {
+	case "await_terminal_build_status":
+		return NewAwaitTerminalBuildStatusAction(actionDefinition.Args)
+	case "await_terminal_submission_status":
+		return NewAwaitTerminalSubmissionStatusAction(actionDefinition.Args)
+	case "await_terminal_autofix_request_status":
+		return NewAwaitTerminalAutofixRequestStatusAction(actionDefinition.Args)
+	case "execute_dynamic_actions":
+		return NewExecuteDynamicActionsAction(actionDefinition.Args)
+	case "print_file_diff":
+		return NewPrintFileDiffAction(actionDefinition.Args)
+	case "print_message":
+		return NewPrintMessageAction(actionDefinition.Args)
+	case "print_terminal_commands_box":
+		return NewPrintTerminalCommandsBoxAction(actionDefinition.Args)
+	case "sleep":
+		return NewSleepAction(actionDefinition.Args)
+	case "stream_logs":
+		return NewStreamLogsAction(actionDefinition.Args)
+	case "terminate":
+		return NewTerminateAction(actionDefinition.Args)
+	default:
+		return nil, fmt.Errorf("unexpected action type: %s", actionDefinition.Type)
+	}
+}

internal/actions/await_terminal_autofix_request_status.go

@@ -0,0 +1,103 @@
+package actions
+
+import (
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"github.com/codecrafters-io/cli/internal/client"
+	"github.com/getsentry/sentry-go"
+)
+
+type AwaitTerminalAutofixRequestStatusAction struct {
+	OnFailureActions []Action
+	OnSuccessActions []Action
+	SubmissionID     string
+}
+
+type AwaitTerminalAutofixRequestStatusActionArgs struct {
+	OnFailureActions []client.ActionDefinition `json:"on_failure_actions"`
+	OnSuccessActions []client.ActionDefinition `json:"on_success_actions"`
+	SubmissionID     string                    `json:"submission_id"`
+}
+
+func NewAwaitTerminalAutofixRequestStatusAction(argsJson json.RawMessage) (*AwaitTerminalAutofixRequestStatusAction, error) {
+	var awaitTerminalAutofixRequestStatusActionArgs AwaitTerminalAutofixRequestStatusActionArgs
+	if err := json.Unmarshal(argsJson, &awaitTerminalAutofixRequestStatusActionArgs); err != nil {
+		return nil, err
+	}
+
+	onSuccessActions := []Action{}
+	for _, actionDefinition := range awaitTerminalAutofixRequestStatusActionArgs.OnSuccessActions {
+		action, err := ActionFromDefinition(actionDefinition)
+		if err != nil {
+			return nil, err
+		}
+
+		onSuccessActions = append(onSuccessActions, action)
+	}
+
+	onFailureActions := []Action{}
+	for _, actionDefinition := range awaitTerminalAutofixRequestStatusActionArgs.OnFailureActions {
+		action, err := ActionFromDefinition(actionDefinition)
+		if err != nil {
+			return nil, err
+		}
+
+		onFailureActions = append(onFailureActions, action)
+	}
+
+	return &AwaitTerminalAutofixRequestStatusAction{
+		OnFailureActions: onFailureActions,
+		OnSuccessActions: onSuccessActions,
+		SubmissionID:     awaitTerminalAutofixRequestStatusActionArgs.SubmissionID,
+	}, nil
+}
+
+func (a *AwaitTerminalAutofixRequestStatusAction) Execute() error {
+	attempts := 0
+	autofixRequestStatus := "in_progress"
+
+	// We wait for upto 60 seconds (+ the time it takes to fetch status each time)
+	for autofixRequestStatus == "in_progress" && attempts < 60 {
+		var err error
+
+		codecraftersClient := client.NewCodecraftersClient()
+		autofixRequestStatusResponse, err := codecraftersClient.FetchAutofixRequest(a.SubmissionID)
+		if err != nil {
+			// We can still proceed here anyway
+			sentry.CaptureException(err)
+		} else {
+			autofixRequestStatus = autofixRequestStatusResponse.Status
+		}
+
+		attempts += 1
+		time.Sleep(time.Second)
+	}
+
+	switch autofixRequestStatus {
+	case "success":
+		for _, action := range a.OnSuccessActions {
+			if err := action.Execute(); err != nil {
+				return err
+			}
+		}
+	case "failure":
+		for _, action := range a.OnFailureActions {
+			if err := action.Execute(); err != nil {
+				return err
+			}
+		}
+	default:
+		err := fmt.Errorf("unexpected autofix request status: %s", autofixRequestStatus)
+		sentry.CaptureException(err)
+
+		PrintMessageAction{Color: "red", Text: "We failed to analyze your test failure in time. Please try again?"}.Execute()
+		PrintMessageAction{Color: "red", Text: "Let us know at [email protected] if this error persists."}.Execute()
+
+		// This is an internal error, let's terminate
+		TerminateAction{ExitCode: 1}.Execute()
+	}
+
+	return nil
+}

internal/actions/await_terminal_build_status.go

@@ -0,0 +1,109 @@
+package actions
+
+import (
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"github.com/codecrafters-io/cli/internal/client"
+	"github.com/getsentry/sentry-go"
+)
+
+type AwaitTerminalBuildStatusAction struct {
+	BuildID          string
+	OnSuccessActions []Action
+	OnFailureActions []Action
+}
+
+type AwaitTerminalBuildStatusActionArgs struct {
+	BuildID          string                    `json:"build_id"`
+	OnSuccessActions []client.ActionDefinition `json:"on_success_actions"`
+	OnFailureActions []client.ActionDefinition `json:"on_failure_actions"`
+}
+
+func NewAwaitTerminalBuildStatusAction(argsJson json.RawMessage) (*AwaitTerminalBuildStatusAction, error) {
+	var awaitTerminalBuildStatusActionArgs AwaitTerminalBuildStatusActionArgs
+	if err := json.Unmarshal(argsJson, &awaitTerminalBuildStatusActionArgs); err != nil {
+		return nil, err
+	}
+
+	onSuccessActions := []Action{}
+	for _, actionDefinition := range awaitTerminalBuildStatusActionArgs.OnSuccessActions {
+		action, err := ActionFromDefinition(actionDefinition)
+		if err != nil {
+			return nil, err
+		}
+
+		onSuccessActions = append(onSuccessActions, action)
+	}
+
+	onFailureActions := []Action{}
+	for _, actionDefinition := range awaitTerminalBuildStatusActionArgs.OnFailureActions {
+		action, err := ActionFromDefinition(actionDefinition)
+		if err != nil {
+			return nil, err
+		}
+
+		onFailureActions = append(onFailureActions, action)
+	}
+
+	return &AwaitTerminalBuildStatusAction{
+		BuildID:          awaitTerminalBuildStatusActionArgs.BuildID,
+		OnSuccessActions: onSuccessActions,
+		OnFailureActions: onFailureActions,
+	}, nil
+}
+
+func (a *AwaitTerminalBuildStatusAction) Execute() error {
+	attempts := 0
+	buildStatus := "not_started"
+
+	// We start waiting for 100 ms, gradually increasing to 2 seconds. Total wait time can be upto 21 seconds ((20 + 21 / 2) * 100ms)
+	for buildStatus != "success" && buildStatus != "failure" && buildStatus != "error" && attempts < 20 {
+		var err error
+
+		codecraftersClient := client.NewCodecraftersClient()
+		resp, err := codecraftersClient.FetchBuild(a.BuildID)
+		if err != nil {
+			// We can still proceed here anyway
+			sentry.CaptureException(err)
+		} else {
+			buildStatus = resp.Status
+		}
+
+		attempts += 1
+		time.Sleep(time.Duration(100*attempts) * time.Millisecond)
+	}
+
+	switch buildStatus {
+	case "success":
+		for _, action := range a.OnSuccessActions {
+			if err := action.Execute(); err != nil {
+				return err
+			}
+		}
+	case "failure":
+		for _, action := range a.OnFailureActions {
+			if err := action.Execute(); err != nil {
+				return err
+			}
+		}
+	default:
+		err := fmt.Errorf("unexpected build status: %s", buildStatus)
+		sentry.CaptureException(err)
+
+		printErr := PrintMessageAction{Color: "red", Text: "We couldn't fetch the results of your build. Please try again?"}.Execute()
+		if printErr != nil {
+			return printErr
+		}
+		printErr = PrintMessageAction{Color: "red", Text: "Let us know at [email protected] if this error persists."}.Execute()
+		if printErr != nil {
+			return printErr
+		}
+
+		// If the build failed, we don't need to stream test logs
+		return TerminateAction{ExitCode: 1}.Execute()
+	}
+
+	return nil
+}