Simplify file service.

Instead of having worker goroutines, we use a channel as a semaphore to
limit the number of concurrent requests for the file service, but
perform all the work synchronously.

file_server.go

@@ -4,23 +4,12 @@ import (
 	"os"
 )
 
-type fileRequest struct {
-	path  string
-	flags int
-	f     func(f *os.File) error
-	res   chan error
-}
-
 type FileService struct {
-	reqs chan fileRequest
+	reqs chan bool
 }
 
-func NewFileService(workers int) *FileService {
-	fs := &FileService{make(chan fileRequest, 1000)}
-	for i := 0; i < workers; i++ {
-		go fs.worker()
-	}
-	return fs
+func NewFileService(concurrency int) *FileService {
+	return &FileService{make(chan bool, concurrency)}
 }
 
 // Open a FileLike thing that works within this FileService.
@@ -34,27 +23,17 @@ func (fs *FileService) OpenFile(path string, mode int) (FileLike, error) {
 }
 
 func (f *FileService) Do(path string, flags int, fn func(*os.File) error) error {
-	r := fileRequest{path, flags, fn, make(chan error, 1)}
-	f.reqs <- r
-	return <-r.res
+	f.reqs <- true
+	defer func() { <-f.reqs }()
+	file, err := os.OpenFile(path, flags, 0666)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+	return fn(file)
 }
 
 func (f *FileService) Close() error {
 	close(f.reqs)
 	return nil
 }
-
-func serviceFileRequest(r fileRequest) {
-	f, err := os.OpenFile(r.path, r.flags, 0666)
-	if err == nil {
-		defer f.Close()
-		err = r.f(f)
-	}
-	r.res <- err
-}
-
-func (f *FileService) worker() {
-	for req := range f.reqs {
-		serviceFileRequest(req)
-	}
-}