feat: add timeout option for chapter conversion to prevent hanging on problematic files

fixes #102

pkg/converter/webp/webp_converter.go

@@ -2,6 +2,7 @@ package webp
 
 import (
 	"bytes"
+	"context"
 	"errors"
 	"fmt"
 	"image"
@@ -53,7 +54,7 @@ func (converter *Converter) PrepareConverter() error {
 	return nil
 }
 
-func (converter *Converter) ConvertChapter(chapter *manga.Chapter, quality uint8, split bool, progress func(message string, current uint32, total uint32)) (*manga.Chapter, error) {
+func (converter *Converter) ConvertChapter(ctx context.Context, chapter *manga.Chapter, quality uint8, split bool, progress func(message string, current uint32, total uint32)) (*manga.Chapter, error) {
 	log.Debug().
 		Str("chapter", chapter.FilePath).
 		Int("pages", len(chapter.Pages)).
@@ -89,26 +90,55 @@ func (converter *Converter) ConvertChapter(chapter *manga.Chapter, quality uint8
 		Int("worker_count", maxGoroutines).
 		Msg("Initialized conversion worker pool")
 
+	// Check if context is already cancelled
+	select {
+	case <-ctx.Done():
+		log.Warn().Str("chapter", chapter.FilePath).Msg("Chapter conversion cancelled due to timeout")
+		return nil, ctx.Err()
+	default:
+	}
+
 	// Start the worker pool
 	go func() {
+		defer close(doneChan)
 		for page := range pagesChan {
-			guard <- struct{}{} // would block if guard channel is already filled
+			select {
+			case <-ctx.Done():
+				return
+			case guard <- struct{}{}: // would block if guard channel is already filled
+			}
+
 			go func(pageToConvert *manga.PageContainer) {
 				defer func() {
 					wgConvertedPages.Done()
 					<-guard
 				}()
 
+				// Check context cancellation before processing
+				select {
+				case <-ctx.Done():
+					return
+				default:
+				}
+
 				convertedPage, err := converter.convertPage(pageToConvert, quality)
 				if err != nil {
 					if convertedPage == nil {
-						errChan <- err
+						select {
+						case errChan <- err:
+						case <-ctx.Done():
+							return
+						}
 						return
 					}
 					buffer := new(bytes.Buffer)
 					err := png.Encode(buffer, convertedPage.Image)
 					if err != nil {
-						errChan <- err
+						select {
+						case errChan <- err:
+						case <-ctx.Done():
+							return
+						}
 						return
 					}
 					convertedPage.Page.Contents = buffer
@@ -121,45 +151,77 @@ func (converter *Converter) ConvertChapter(chapter *manga.Chapter, quality uint8
 				pagesMutex.Unlock()
 			}(page)
 		}
-		close(doneChan)
 	}()
 
 	// Process pages
 	for _, page := range chapter.Pages {
+		select {
+		case <-ctx.Done():
+			log.Warn().Str("chapter", chapter.FilePath).Msg("Chapter conversion cancelled due to timeout")
+			return nil, ctx.Err()
+		default:
+		}
+
 		go func(page *manga.Page) {
 			defer wgPages.Done()
 
 			splitNeeded, img, format, err := converter.checkPageNeedsSplit(page, split)
 			if err != nil {
-				errChan <- err
+				select {
+				case errChan <- err:
+				case <-ctx.Done():
+					return
+				}
 				if img != nil {
 					wgConvertedPages.Add(1)
-					pagesChan <- manga.NewContainer(page, img, format, false)
+					select {
+					case pagesChan <- manga.NewContainer(page, img, format, false):
+					case <-ctx.Done():
+						return
+					}
 				}
 				return
 			}
 
 			if !splitNeeded {
 				wgConvertedPages.Add(1)
-				pagesChan <- manga.NewContainer(page, img, format, true)
+				select {
+				case pagesChan <- manga.NewContainer(page, img, format, true):
+				case <-ctx.Done():
+					return
+				}
 				return
 			}
 
 			images, err := converter.cropImage(img)
 			if err != nil {
-				errChan <- err
+				select {
+				case errChan <- err:
+				case <-ctx.Done():
+					return
+				}
 				return
 			}
 
 			atomic.AddUint32(&totalPages, uint32(len(images)-1))
 			for i, img := range images {
+				select {
+				case <-ctx.Done():
+					return
+				default:
+				}
+
 				newPage := &manga.Page{
 					Index:          page.Index,
 					IsSplitted:     true,
 					SplitPartIndex: uint16(i),
 				}
 				wgConvertedPages.Add(1)
-				pagesChan <- manga.NewContainer(newPage, img, "N/A", true)
+				select {
+				case pagesChan <- manga.NewContainer(newPage, img, "N/A", true):
+				case <-ctx.Done():
+					return
+				}
 			}
 		}(page)
 	}
@@ -167,9 +229,21 @@ func (converter *Converter) ConvertChapter(chapter *manga.Chapter, quality uint8
 	wgPages.Wait()
 	close(pagesChan)
 
-	// Wait for all conversions to complete
-	<-doneChan
-	wgConvertedPages.Wait()
+	// Wait for all conversions to complete or context cancellation
+	done := make(chan struct{})
+	go func() {
+		defer close(done)
+		wgConvertedPages.Wait()
+	}()
+
+	select {
+	case <-done:
+		// Conversion completed successfully
+	case <-ctx.Done():
+		log.Warn().Str("chapter", chapter.FilePath).Msg("Chapter conversion cancelled due to timeout")
+		return nil, ctx.Err()
+	}
+
 	close(errChan)
 	close(guard)
 

pkg/converter/webp/webp_converter_test.go

@@ -2,12 +2,14 @@ package webp
 
 import (
 	"bytes"
+	"context"
 	"image"
 	"image/color"
+	"image/jpeg"
 	"image/png"
 	"sync"
 	"testing"
-	"image/jpeg"
+
 	_ "golang.org/x/image/webp"
 
 	"github.com/belphemur/CBZOptimizer/v2/internal/manga"
@@ -170,7 +172,7 @@ func TestConverter_ConvertChapter(t *testing.T) {
 				assert.LessOrEqual(t, current, total, "Current progress should not exceed total")
 			}
 
-			convertedChapter, err := converter.ConvertChapter(chapter, 80, tt.split, progress)
+			convertedChapter, err := converter.ConvertChapter(context.Background(), chapter, 80, tt.split, progress)
 
 			if tt.expectError {
 				assert.Error(t, err)
@@ -322,3 +324,42 @@ func TestConverter_Format(t *testing.T) {
 	converter := New()
 	assert.Equal(t, constant.WebP, converter.Format())
 }
+
+func TestConverter_ConvertChapter_Timeout(t *testing.T) {
+	converter := New()
+	err := converter.PrepareConverter()
+	require.NoError(t, err)
+
+	// Create a test chapter with a few pages
+	pages := []*manga.Page{
+		createTestPage(t, 1, 800, 1200, "jpeg"),
+		createTestPage(t, 2, 800, 1200, "jpeg"),
+		createTestPage(t, 3, 800, 1200, "jpeg"),
+	}
+
+	chapter := &manga.Chapter{
+		FilePath: "/test/chapter.cbz",
+		Pages:    pages,
+	}
+
+	var progressMutex sync.Mutex
+	var lastProgress uint32
+	progress := func(message string, current uint32, total uint32) {
+		progressMutex.Lock()
+		defer progressMutex.Unlock()
+		assert.GreaterOrEqual(t, current, lastProgress, "Progress should never decrease")
+		lastProgress = current
+		assert.LessOrEqual(t, current, total, "Current progress should not exceed total")
+	}
+
+	// Test with very short timeout (1 nanosecond)
+	ctx, cancel := context.WithTimeout(context.Background(), 1)
+	defer cancel()
+
+	convertedChapter, err := converter.ConvertChapter(ctx, chapter, 80, false, progress)
+
+	// Should return context error due to timeout
+	assert.Error(t, err)
+	assert.Nil(t, convertedChapter)
+	assert.Equal(t, context.DeadlineExceeded, err)
+}