func (s *Server) HandleUpload(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
    defer r.Body.Close()
    
    buf, err := s.rm.Acquire()
    defer s.rm.Release(buf)
    
    for {
        n, err := r.Body.Read(buf.(memu.ByteSlice))
        if err != nil && err != io.EOF {
            log.Print(err.Error())
        }
        doSomeActionWithBuffer(buf)
        if err != io.EOF {
            break
        }
    }
}

package main

import (
	"io"
	"io/ioutil"
	"log"
	"net/http"
	"time"
)

type handler struct {
	gate chan struct{}
}

func NewHandler() *handler {
	return &handler{gate: make(chan struct{}, 5)}
}

func (h *handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	defer r.Body.Close()

	h.gate <- struct{}{}
	defer func() { <-h.gate }()

	buf := make([]byte, 2*1024*1024)
	for {
		log.Printf("Start reading")
		n, err := r.Body.Read(buf)
		if err == io.EOF {
			break
		}

		if err != nil {
			log.Printf("Error %v", err)
			return
		}

		log.Printf("%d bytes is readed (error %v)", n, err)
		time.Sleep(1 * time.Second)
	}

	_, err := ioutil.ReadAll(r.Body)
	log.Printf("End read body (err: %v)", err)
}

func main() {
	srv := &http.Server{Addr: ":16999", Handler: NewHandler()}
	log.Fatal(srv.ListenAndServeTLS("server.crt", "server.key"))
}

package main

import (
	"context"
	"crypto/tls"
	"crypto/x509"
	"flag"
	"io/ioutil"
	"log"
	"net/http"
	"os"
	"os/signal"
	"path/filepath"

	"golang.org/x/net/http2"
	"golang.org/x/sync/errgroup"
)

const url = "https://localhost:16999"

var (
	dir      = flag.String("dir", "", "directory")
	parallel = flag.Int("parallel", 100, "parallel")
)

func initClient() *http.Client {
	client := &http.Client{}

	caCert, err := ioutil.ReadFile("server.crt")
	if err != nil {
		log.Fatalf("Reading server certificate: %s", err)
	}
	caCertPool := x509.NewCertPool()
	caCertPool.AppendCertsFromPEM(caCert)

	tlsConfig := &tls.Config{
		RootCAs: caCertPool,
	}

	client.Transport = &http2.Transport{
		TLSClientConfig: tlsConfig,
	}

	return client
}

func fileUpload(ctx context.Context, filepath string, client *http.Client) error {
	file, err := os.Open(filepath)
	if err != nil {
		return err
	}
	defer file.Close()

	req, err := http.NewRequest("POST", url, file)
	if err != nil {
		return err
	}
	req = req.WithContext(ctx)
	req.Header.Set("Content-Type", "binary/octet-stream")

	log.Printf("Start uploading file %s", filepath)
	res, err := client.Do(req)
	if err != nil {
		return err
	}
	defer res.Body.Close()

	log.Printf("File %s is uploaded", filepath)
	return nil
}

func startWorkers(ctx context.Context, jobs <-chan string, client *http.Client) *errgroup.Group {
	g, _ := errgroup.WithContext(ctx)
	for i := 0; i < *parallel; i++ {
		g.Go(func() error {
			for filepath := range jobs {
				if err := fileUpload(ctx, filepath, client); err != nil {
					return err
				}
			}

			return nil
		})
	}

	return g
}

func CtrlCContext(ctx context.Context) context.Context {
	c, cancel := context.WithCancel(ctx)
	signalCh := make(chan os.Signal, 1)
	signal.Notify(signalCh, os.Interrupt)
	go func() {
		select {
		case <-signalCh:
			cancel()
			return
		}
	}()
	return c
}

func main() {
	flag.Parse()

	client := initClient()
	jobs := make(chan string, *parallel*2)
	ctx := CtrlCContext(context.Background())
	g := startWorkers(ctx, jobs, client)

	err := filepath.Walk(*dir, func(path string, info os.FileInfo, err error) error {
		if info == nil {
			return nil
		}

		if info.IsDir() {
			return nil
		}

		select {
		case <-ctx.Done():
			return ctx.Err()
		case jobs <- path:
		}
		return nil
	})
	close(jobs)
	if err != nil {
		log.Fatal(err)
	}

	log.Fatal(g.Wait())
}