Merge pull request #61 from codecrafters-io/progress-bar

Progress bar

Author: rohitpaulk

internal/actions/action.go

@@ -1,6 +1,7 @@
 package actions
 
 import (
+	"context"
 	"fmt"
 
 	"github.com/codecrafters-io/cli/internal/client"
@@ -10,6 +11,11 @@ type Action interface {
 	Execute() error
 }
 
+type InterruptibleAction interface {
+	Action
+	ExecuteWithContext(ctx context.Context) error
+}
+
 func ActionFromDefinition(actionDefinition client.ActionDefinition) (Action, error) {
 	switch actionDefinition.Type {
 	case "await_terminal_build_status":
@@ -24,6 +30,8 @@ func ActionFromDefinition(actionDefinition client.ActionDefinition) (Action, err
 		return NewPrintFileDiffAction(actionDefinition.Args)
 	case "print_message":
 		return NewPrintMessageAction(actionDefinition.Args)
+	case "print_progress_bar":
+		return NewPrintProgressBarAction(actionDefinition.Args)
 	case "print_terminal_commands_box":
 		return NewPrintTerminalCommandsBoxAction(actionDefinition.Args)
 	case "sleep":

internal/actions/await_terminal_autofix_request_status.go

@@ -1,6 +1,7 @@
 package actions
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"time"
@@ -10,15 +11,17 @@ import (
 )
 
 type AwaitTerminalAutofixRequestStatusAction struct {
-	OnFailureActions []Action
-	OnSuccessActions []Action
-	SubmissionID     string
+	InProgressActions []Action
+	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"`
+	InProgressActions []client.ActionDefinition `json:"in_progress_actions"`
+	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) {
@@ -47,17 +50,41 @@ func NewAwaitTerminalAutofixRequestStatusAction(argsJson json.RawMessage) (*Awai
 		onFailureActions = append(onFailureActions, action)
 	}
 
+	inProgressActions := []Action{}
+	for _, actionDefinition := range awaitTerminalAutofixRequestStatusActionArgs.InProgressActions {
+		action, err := ActionFromDefinition(actionDefinition)
+		if err != nil {
+			return nil, err
+		}
+
+		inProgressActions = append(inProgressActions, action)
+	}
+
 	return &AwaitTerminalAutofixRequestStatusAction{
-		OnFailureActions: onFailureActions,
-		OnSuccessActions: onSuccessActions,
-		SubmissionID:     awaitTerminalAutofixRequestStatusActionArgs.SubmissionID,
+		InProgressActions: inProgressActions,
+		OnFailureActions:  onFailureActions,
+		OnSuccessActions:  onSuccessActions,
+		SubmissionID:      awaitTerminalAutofixRequestStatusActionArgs.SubmissionID,
 	}, nil
 }
 
 func (a *AwaitTerminalAutofixRequestStatusAction) Execute() error {
 	attempts := 0
 	autofixRequestStatus := "in_progress"
 
+	inProgressActionsDoneCh := make(chan bool)
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	go func() {
+		if err := a.executeInProgressActions(ctx); err != nil {
+			sentry.CaptureException(err)
+		}
+
+		inProgressActionsDoneCh <- true
+	}()
+
 	// We wait for upto 60 seconds (+ the time it takes to fetch status each time)
 	for autofixRequestStatus == "in_progress" && attempts < 60 {
 		var err error
@@ -75,6 +102,10 @@ func (a *AwaitTerminalAutofixRequestStatusAction) Execute() error {
 		time.Sleep(time.Second)
 	}
 
+	// Ensure interruptible actions (like printing progress bars) finish early
+	cancel()
+	<-inProgressActionsDoneCh
+
 	switch autofixRequestStatus {
 	case "success":
 		for _, action := range a.OnSuccessActions {
@@ -101,3 +132,19 @@ func (a *AwaitTerminalAutofixRequestStatusAction) Execute() error {
 
 	return nil
 }
+
+func (a *AwaitTerminalAutofixRequestStatusAction) executeInProgressActions(ctx context.Context) error {
+	for _, action := range a.InProgressActions {
+		if interruptibleAction, ok := action.(InterruptibleAction); ok {
+			if err := interruptibleAction.ExecuteWithContext(ctx); err != nil {
+				return err
+			}
+		} else {
+			if err := action.Execute(); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}

internal/actions/print_progress_bar.go

@@ -0,0 +1,109 @@
+package actions
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"math/rand"
+	"strings"
+	"time"
+)
+
+// The maximum delay between prints in seconds
+const maxDelayBetweenPrintsInSeconds = 2
+
+// The minimum number of times we will print the progress bar
+const minPrintCount = 5
+
+// The length of the progress bar
+const progressBarLength = 20
+
+type PrintProgressBarAction struct {
+	ExpectedDelayInSeconds int `json:"expected_delay_in_seconds"`
+}
+
+func NewPrintProgressBarAction(argsJson json.RawMessage) (PrintProgressBarAction, error) {
+	var printProgressBarAction PrintProgressBarAction
+	if err := json.Unmarshal(argsJson, &printProgressBarAction); err != nil {
+		return PrintProgressBarAction{}, err
+	}
+
+	return printProgressBarAction, nil
+}
+
+func (a PrintProgressBarAction) numberOfPrints() int {
+	return max(a.ExpectedDelayInSeconds/maxDelayBetweenPrintsInSeconds, minPrintCount)
+}
+
+func (a PrintProgressBarAction) delayBetweenPrintsInMilliseconds(printsLeft int) int {
+	if printsLeft <= 1 {
+		return 60 * 1000 // 60 seconds (The action should timeout by then)
+	}
+
+	return min(maxDelayBetweenPrintsInSeconds*1000, 1000*a.ExpectedDelayInSeconds/a.numberOfPrints())
+}
+
+func (a PrintProgressBarAction) Execute() error {
+	return a.ExecuteWithContext(context.Background())
+}
+
+func (a PrintProgressBarAction) ExecuteWithContext(ctx context.Context) error {
+	contextIsCancelled := false
+	lastPrintedPercentage := 0
+
+	for i := 0; i < a.numberOfPrints(); i++ {
+		percentage := (i + 1) * 100 / a.numberOfPrints()
+		numberOfBars := percentage * progressBarLength / 100
+		numberOfSpaces := progressBarLength - numberOfBars
+
+		bars := strings.Repeat("=", numberOfBars)
+		if numberOfSpaces > 0 {
+			bars = bars[:len(bars)-1] + ">"
+		}
+
+		// Print with a random jitter of up to 5%
+		percentageToPrint := percentage
+
+		// If this is in-progress, add a random jitter of up to 5%
+		if percentage < 100 {
+			percentageToPrint = percentage - 5 + rand.Intn(10)
+		}
+
+		// Ensure the printed percentage is not greater than 100
+		if percentageToPrint > 100 {
+			percentageToPrint = 100
+		}
+
+		// Ensure the printed percentage always increases
+		if percentageToPrint < lastPrintedPercentage {
+			percentageToPrint = lastPrintedPercentage
+		}
+
+		// Use ANSI color codes for green (same pattern as print_message.go)
+		greenStart := "\033[32m"
+		greenEnd := "\033[0m"
+		fmt.Printf("[%s%s%s%s] %s%s%s\n", greenStart, bars, greenEnd, strings.Repeat(" ", numberOfSpaces), greenStart, fmt.Sprintf("%d%%", percentageToPrint), greenEnd)
+		lastPrintedPercentage = percentageToPrint
+
+		// If the context is cancelled, keep looping until we print all bars and exit (with no delay)
+		if contextIsCancelled {
+			continue
+		}
+
+		sleepDurationInMilliseconds := a.delayBetweenPrintsInMilliseconds(a.numberOfPrints() - (i + 1))
+
+		// Add a random jitter of up to 500ms
+		sleepDurationInMilliseconds = sleepDurationInMilliseconds - 500 + rand.Intn(1000)
+
+		// If the context is still active, sleep for the max delay between prints
+		select {
+		case <-ctx.Done():
+			contextIsCancelled = true
+			continue
+		case <-time.After(time.Duration(sleepDurationInMilliseconds) * time.Millisecond):
+			continue
+		}
+	}
+
+	return nil
+}