Go naive worker pool toy

main.go

package main

import (
	"fmt"
	"log"
	"sync"
)

type Input struct {
	Id string
}

func (i Input) ID() string {
	return i.Id
}

func main() {
	input := make(chan Identifiable, 100)
	for i := 0; i < 100; i++ {
		input <- Input{Id: fmt.Sprint(i)}
	}

	Process(input, 100, 10, func(i Identifiable) error {
		fmt.Printf("doing work for ID %s\n", i.ID())
		return nil
	})
}

type Identifiable interface {
	ID() string
}

type Failed struct {
	Error error
	ID    string
}

type Success struct {
	ID string
}

func Process(input chan Identifiable, inputSize int64, maxConcurrency int, doWork func(Identifiable) error) ([]Success, []Failed) {
	failuresCh := make(chan Failed, inputSize)
	successCh := make(chan Success, inputSize)

	var wg sync.WaitGroup
	wg.Add(maxConcurrency)
	for w := 0; w < maxConcurrency; w++ {
		go func() {
			defer func() {
				if r := recover(); r != nil {
					log.Printf("recover: %+v", r)
				}
			}()

			defer wg.Done()

			for j := range input {
				err := doWork(j)
				if err != nil {
					failuresCh <- Failed{ID: j.ID(), Error: err}
					continue
				}

				successCh <- Success{ID: j.ID()}
			}
		}()
	}

	close(input)

	wg.Wait()
	close(failuresCh)
	close(successCh)

	failures := []Failed{}
	for f := range failuresCh {
		failures = append(failures, f)
	}

	succesful := []Success{}
	for f := range successCh {
		succesful = append(succesful, f)
	}

	return succesful, failures
}