feat: downloader

internal/pkg/errcodes/errcodes.go

@@ -23,7 +23,89 @@ func (e *ErrorCode) Error() string {
 	return e.Message
 }
 
+// IsErr checks if the given error is an ErrorCode
+func IsErr(err error) bool {
+	_, ok := err.(*ErrorCode)
+	return ok
+}
+
+// AsErr converts error to ErrorCode if possible
+func AsErr(err error) (*ErrorCode, bool) {
+	if err == nil {
+		return nil, false
+	}
+	errcode, ok := err.(*ErrorCode)
+	return errcode, ok
+}
+
+// Join combines multiple errors into a single ErrorCode
+func Join(errs ...error) error {
+	if len(errs) == 0 {
+		return nil
+	}
+
+	var messages []string
+	var details []string
+
+	for _, err := range errs {
+		if err == nil {
+			continue
+		}
+
+		if errcode, ok := AsErr(err); ok {
+			messages = append(messages, errcode.Message)
+			if errcode.Details != "" {
+				details = append(details, errcode.Details)
+			}
+		} else {
+			messages = append(messages, err.Error())
+		}
+	}
+
+	if len(messages) == 0 {
+		return nil
+	}
+
+	// Use the first error's status code, or default to 500
+	statusCode := http.StatusInternalServerError
+	if len(errs) > 0 {
+		if errcode, ok := AsErr(errs[0]); ok {
+			statusCode = errcode.StatusCode
+		}
+	}
+
+	return New(statusCode, strings.Join(messages, "; "), details...)
+}
+
+// Wrap wraps an error with additional context
+func Wrap(err error, message string) error {
+	if err == nil {
+		return nil
+	}
+
+	if errcode, ok := AsErr(err); ok {
+		return New(errcode.StatusCode, message, errcode.Message, errcode.Details)
+	}
+
+	return New(http.StatusInternalServerError, message, err.Error())
+}
+
 var (
-	ErrNoDataset   = New(http.StatusNotFound, "no grib dataset found")
-	ErrOutOfBounds = New(http.StatusBadRequest, "requested time is out of bounds")
+	ErrNoDataset               = New(http.StatusNotFound, "no grib dataset found")
+	ErrOutOfBounds             = New(http.StatusBadRequest, "requested time is out of bounds")
+	ErrConfig                  = New(http.StatusInternalServerError, "configuration error")
+	ErrConfigInvalidEnv        = New(http.StatusInternalServerError, "invalid environment configuration")
+	ErrConfigMissingRequired   = New(http.StatusInternalServerError, "missing required configuration")
+	ErrRedis                   = New(http.StatusInternalServerError, "redis error")
+	ErrRedisLockAlreadyLocked  = New(http.StatusConflict, "could not perform redis lock", "already locked")
+	ErrRedisCacheMiss          = New(http.StatusNotFound, "cache miss", "key not found")
+	ErrRedisCacheCorrupted     = New(http.StatusInternalServerError, "cache data corrupted", "invalid format")
+	ErrDownload                = New(http.StatusInternalServerError, "download error")
+	ErrProcessing              = New(http.StatusInternalServerError, "data processing error")
+	ErrNoCubeFilesFound        = New(http.StatusNotFound, "no cube files found")
+	ErrNoValidCubeFilesFound   = New(http.StatusNotFound, "no valid cube files found")
+	ErrLatestCubeFileIsTooOld  = New(http.StatusNotFound, "latest cube file is too old")
+	ErrScheduler               = New(http.StatusInternalServerError, "scheduler error")
+	ErrSchedulerInvalidJob     = New(http.StatusBadRequest, "invalid job configuration")
+	ErrSchedulerTimeoutTooLong = New(http.StatusBadRequest, "job timeout too long", "timeout cannot exceed interval")
 )

internal/pkg/errcodes/errcodes_test.go

@@ -0,0 +1,81 @@
+package errcodes
+
+import (
+	"testing"
+)
+
+func TestSpecificErrorTypes(t *testing.T) {
+	// Test Redis lock error
+	err := ErrRedisLockAlreadyLocked
+	if !IsErr(err) {
+		t.Error("Expected IsErr to return true for ErrorCode")
+	}
+
+	errcode, ok := AsErr(err)
+	if !ok {
+		t.Error("Expected AsErr to return true for ErrorCode")
+	}
+	if errcode != ErrRedisLockAlreadyLocked {
+		t.Error("Expected AsErr to return the same error")
+	}
+
+	// Test Redis cache miss error
+	cacheErr := ErrRedisCacheMiss
+	if !IsErr(cacheErr) {
+		t.Error("Expected IsErr to return true for cache miss error")
+	}
+
+	// Test configuration error
+	configErr := ErrConfigInvalidEnv
+	if !IsErr(configErr) {
+		t.Error("Expected IsErr to return true for config error")
+	}
+
+	// Test scheduler error
+	schedulerErr := ErrSchedulerTimeoutTooLong
+	if !IsErr(schedulerErr) {
+		t.Error("Expected IsErr to return true for scheduler error")
+	}
+}
+
+func TestErrorChecking(t *testing.T) {
+	// Example of how to check for specific errors in practice
+	err := ErrRedisLockAlreadyLocked
+
+	// Check if it's a specific error type
+	if errcode, ok := AsErr(err); ok {
+		switch errcode {
+		case ErrRedisLockAlreadyLocked:
+			// Handle lock already locked case
+			t.Log("Handling lock already locked error")
+		case ErrRedisCacheMiss:
+			// Handle cache miss case
+			t.Log("Handling cache miss error")
+		case ErrRedisCacheCorrupted:
+			// Handle corrupted cache case
+			t.Log("Handling corrupted cache error")
+		default:
+			// Handle other error types
+			t.Log("Handling other error type")
+		}
+	}
+}
+
+func TestWrapFunction(t *testing.T) {
+	originalErr := ErrRedisCacheMiss
+	wrappedErr := Wrap(originalErr, "additional context")
+
+	if !IsErr(wrappedErr) {
+		t.Error("Expected wrapped error to be an ErrorCode")
+	}
+
+	errcode, ok := AsErr(wrappedErr)
+	if !ok {
+		t.Error("Expected AsErr to work with wrapped error")
+	}
+
+	// The wrapped error should have the same status code as the original
+	if errcode.StatusCode != ErrRedisCacheMiss.StatusCode {
+		t.Errorf("Expected status code %d, got %d", ErrRedisCacheMiss.StatusCode, errcode.StatusCode)
+	}
+}