switch to go vendoring

vendor/github.com/tus/tusd/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2013-2017 Transloadit Ltd and Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vendor/github.com/tus/tusd/pkg/handler/body_reader.go

@@ -0,0 +1,53 @@
+package handler
+
+import (
+	"io"
+	"sync/atomic"
+)
+
+// bodyReader is an io.Reader, which is intended to wrap the request
+// body reader. If an error occurr during reading the request body, it
+// will not return this error to the reading entity, but instead store
+// the error and close the io.Reader, so that the error can be checked
+// afterwards. This is helpful, so that the stores do not have to handle
+// the error but this can instead be done in the handler.
+// In addition, the bodyReader keeps track of how many bytes were read.
+type bodyReader struct {
+	reader       io.Reader
+	err          error
+	bytesCounter int64
+}
+
+func newBodyReader(r io.Reader) *bodyReader {
+	return &bodyReader{
+		reader: r,
+	}
+}
+
+func (r *bodyReader) Read(b []byte) (int, error) {
+	if r.err != nil {
+		return 0, io.EOF
+	}
+
+	n, err := r.reader.Read(b)
+	atomic.AddInt64(&r.bytesCounter, int64(n))
+	r.err = err
+
+	if err == io.EOF {
+		return n, io.EOF
+	} else {
+		return n, nil
+	}
+}
+
+func (r bodyReader) hasError() error {
+	if r.err == io.EOF {
+		return nil
+	}
+
+	return r.err
+}
+
+func (r *bodyReader) bytesRead() int64 {
+	return atomic.LoadInt64(&r.bytesCounter)
+}

vendor/github.com/tus/tusd/pkg/handler/composer.go

@@ -0,0 +1,87 @@
+package handler
+
+// StoreComposer represents a composable data store. It consists of the core
+// data store and optional extensions. Please consult the package's overview
+// for a more detailed introduction in how to use this structure.
+type StoreComposer struct {
+	Core DataStore
+
+	UsesTerminater     bool
+	Terminater         TerminaterDataStore
+	UsesLocker         bool
+	Locker             Locker
+	UsesConcater       bool
+	Concater           ConcaterDataStore
+	UsesLengthDeferrer bool
+	LengthDeferrer     LengthDeferrerDataStore
+}
+
+// NewStoreComposer creates a new and empty store composer.
+func NewStoreComposer() *StoreComposer {
+	return &StoreComposer{}
+}
+
+// Capabilities returns a string representing the provided extensions in a
+// human-readable format meant for debugging.
+func (store *StoreComposer) Capabilities() string {
+	str := "Core: "
+
+	if store.Core != nil {
+		str += "✓"
+	} else {
+		str += "✗"
+	}
+
+	str += ` Terminater: `
+	if store.UsesTerminater {
+		str += "✓"
+	} else {
+		str += "✗"
+	}
+	str += ` Locker: `
+	if store.UsesLocker {
+		str += "✓"
+	} else {
+		str += "✗"
+	}
+	str += ` Concater: `
+	if store.UsesConcater {
+		str += "✓"
+	} else {
+		str += "✗"
+	}
+	str += ` LengthDeferrer: `
+	if store.UsesLengthDeferrer {
+		str += "✓"
+	} else {
+		str += "✗"
+	}
+
+	return str
+}
+
+// UseCore will set the used core data store. If the argument is nil, the
+// property will be unset.
+func (store *StoreComposer) UseCore(core DataStore) {
+	store.Core = core
+}
+
+func (store *StoreComposer) UseTerminater(ext TerminaterDataStore) {
+	store.UsesTerminater = ext != nil
+	store.Terminater = ext
+}
+
+func (store *StoreComposer) UseLocker(ext Locker) {
+	store.UsesLocker = ext != nil
+	store.Locker = ext
+}
+
+func (store *StoreComposer) UseConcater(ext ConcaterDataStore) {
+	store.UsesConcater = ext != nil
+	store.Concater = ext
+}
+
+func (store *StoreComposer) UseLengthDeferrer(ext LengthDeferrerDataStore) {
+	store.UsesLengthDeferrer = ext != nil
+	store.LengthDeferrer = ext
+}

vendor/github.com/tus/tusd/pkg/handler/composer.mgo

@@ -0,0 +1,74 @@
+package handler
+
+#define USE_FUNC(TYPE) \
+func (store *StoreComposer) Use ## TYPE(ext TYPE ## DataStore) { \
+  store.Uses ## TYPE = ext != nil; \
+  store.TYPE = ext; \
+}
+
+#define USE_FIELD(TYPE) Uses ## TYPE bool; \
+  TYPE TYPE ## DataStore
+
+#define USE_FROM(TYPE) if mod, ok := store.(TYPE ## DataStore); ok { \
+  composer.Use ## TYPE (mod) \
+}
+
+#define USE_CAP(TYPE) str += ` TYPE: `; \
+if store.Uses ## TYPE { \
+  str += "✓" \
+} else { \
+  str += "✗" \
+}
+
+// StoreComposer represents a composable data store. It consists of the core
+// data store and optional extensions. Please consult the package's overview
+// for a more detailed introduction in how to use this structure.
+type StoreComposer struct {
+  Core DataStore
+
+  USE_FIELD(Terminater)
+  USE_FIELD(Finisher)
+  USE_FIELD(Locker)
+  USE_FIELD(GetReader)
+  USE_FIELD(Concater)
+  USE_FIELD(LengthDeferrer)
+}
+
+// NewStoreComposer creates a new and empty store composer.
+func NewStoreComposer() *StoreComposer {
+  return &StoreComposer{}
+}
+
+// Capabilities returns a string representing the provided extensions in a
+// human-readable format meant for debugging.
+func (store *StoreComposer) Capabilities() string {
+  str := "Core: "
+
+  if store.Core != nil {
+    str += "✓"
+  } else {
+    str += "✗"
+  }
+
+  USE_CAP(Terminater)
+  USE_CAP(Finisher)
+  USE_CAP(Locker)
+  USE_CAP(GetReader)
+  USE_CAP(Concater)
+  USE_CAP(LengthDeferrer)
+
+  return str
+}
+
+// UseCore will set the used core data store. If the argument is nil, the
+// property will be unset.
+func (store *StoreComposer) UseCore(core DataStore) {
+  store.Core = core
+}
+
+USE_FUNC(Terminater)
+USE_FUNC(Finisher)
+USE_FUNC(Locker)
+USE_FUNC(GetReader)
+USE_FUNC(Concater)
+USE_FUNC(LengthDeferrer)

vendor/github.com/tus/tusd/pkg/handler/config.go

@@ -0,0 +1,92 @@
+package handler
+
+import (
+	"errors"
+	"log"
+	"net/url"
+	"os"
+)
+
+// Config provides a way to configure the Handler depending on your needs.
+type Config struct {
+	// StoreComposer points to the store composer from which the core data store
+	// and optional dependencies should be taken. May only be nil if DataStore is
+	// set.
+	// TODO: Remove pointer?
+	StoreComposer *StoreComposer
+	// MaxSize defines how many bytes may be stored in one single upload. If its
+	// value is is 0 or smaller no limit will be enforced.
+	MaxSize int64
+	// BasePath defines the URL path used for handling uploads, e.g. "/files/".
+	// If no trailing slash is presented it will be added. You may specify an
+	// absolute URL containing a scheme, e.g. "http://tus.io"
+	BasePath string
+	isAbs    bool
+	// DisableDownload indicates whether the server will refuse downloads of the
+	// uploaded file, by not mounting the GET handler.
+	DisableDownload bool
+	// DisableTermination indicates whether the server will refuse termination
+	// requests of the uploaded file, by not mounting the DELETE handler.
+	DisableTermination bool
+	// NotifyCompleteUploads indicates whether sending notifications about
+	// completed uploads using the CompleteUploads channel should be enabled.
+	NotifyCompleteUploads bool
+	// NotifyTerminatedUploads indicates whether sending notifications about
+	// terminated uploads using the TerminatedUploads channel should be enabled.
+	NotifyTerminatedUploads bool
+	// NotifyUploadProgress indicates whether sending notifications about
+	// the upload progress using the UploadProgress channel should be enabled.
+	NotifyUploadProgress bool
+	// NotifyCreatedUploads indicates whether sending notifications about
+	// the upload having been created using the CreatedUploads channel should be enabled.
+	NotifyCreatedUploads bool
+	// Logger is the logger to use internally, mostly for printing requests.
+	Logger *log.Logger
+	// Respect the X-Forwarded-Host, X-Forwarded-Proto and Forwarded headers
+	// potentially set by proxies when generating an absolute URL in the
+	// response to POST requests.
+	RespectForwardedHeaders bool
+	// PreUploadCreateCallback will be invoked before a new upload is created, if the
+	// property is supplied. If the callback returns nil, the upload will be created.
+	// Otherwise the HTTP request will be aborted. This can be used to implement
+	// validation of upload metadata etc.
+	PreUploadCreateCallback func(hook HookEvent) error
+	// PreFinishResponseCallback will be invoked after an upload is completed but before
+	// a response is returned to the client. Error responses from the callback will be passed
+	// back to the client. This can be used to implement post-processing validation.
+	PreFinishResponseCallback func(hook HookEvent) error
+}
+
+func (config *Config) validate() error {
+	if config.Logger == nil {
+		config.Logger = log.New(os.Stdout, "[tusd] ", log.Ldate|log.Lmicroseconds)
+	}
+
+	base := config.BasePath
+	uri, err := url.Parse(base)
+	if err != nil {
+		return err
+	}
+
+	// Ensure base path ends with slash to remove logic from absFileURL
+	if base != "" && string(base[len(base)-1]) != "/" {
+		base += "/"
+	}
+
+	// Ensure base path begins with slash if not absolute (starts with scheme)
+	if !uri.IsAbs() && len(base) > 0 && string(base[0]) != "/" {
+		base = "/" + base
+	}
+	config.BasePath = base
+	config.isAbs = uri.IsAbs()
+
+	if config.StoreComposer == nil {
+		return errors.New("tusd: StoreComposer must no be nil")
+	}
+
+	if config.StoreComposer.Core == nil {
+		return errors.New("tusd: StoreComposer in Config needs to contain a non-nil core")
+	}
+
+	return nil
+}

vendor/github.com/tus/tusd/pkg/handler/datastore.go

@@ -0,0 +1,156 @@
+package handler
+
+import (
+	"context"
+	"io"
+)
+
+type MetaData map[string]string
+
+type FileInfo struct {
+	ID string
+	// Total file size in bytes specified in the NewUpload call
+	Size int64
+	// Indicates whether the total file size is deferred until later
+	SizeIsDeferred bool
+	// Offset in bytes (zero-based)
+	Offset   int64
+	MetaData MetaData
+	// Indicates that this is a partial upload which will later be used to form
+	// a final upload by concatenation. Partial uploads should not be processed
+	// when they are finished since they are only incomplete chunks of files.
+	IsPartial bool
+	// Indicates that this is a final upload
+	IsFinal bool
+	// If the upload is a final one (see IsFinal) this will be a non-empty
+	// ordered slice containing the ids of the uploads of which the final upload
+	// will consist after concatenation.
+	PartialUploads []string
+	// Storage contains information about where the data storage saves the upload,
+	// for example a file path. The available values vary depending on what data
+	// store is used. This map may also be nil.
+	Storage map[string]string
+
+	// stopUpload is the cancel function for the upload's context.Context. When
+	// invoked it will interrupt the writes to DataStore#WriteChunk.
+	stopUpload context.CancelFunc
+}
+
+// StopUpload interrupts an running upload from the server-side. This means that
+// the current request body is closed, so that the data store does not get any
+// more data. Furthermore, a response is sent to notify the client of the
+// interrupting and the upload is terminated (if supported by the data store),
+// so the upload cannot be resumed anymore.
+func (f FileInfo) StopUpload() {
+	if f.stopUpload != nil {
+		f.stopUpload()
+	}
+}
+
+type Upload interface {
+	// Write the chunk read from src into the file specified by the id at the
+	// given offset. The handler will take care of validating the offset and
+	// limiting the size of the src to not overflow the file's size. It may
+	// return an os.ErrNotExist which will be interpreted as a 404 Not Found.
+	// It will also lock resources while they are written to ensure only one
+	// write happens per time.
+	// The function call must return the number of bytes written.
+	WriteChunk(ctx context.Context, offset int64, src io.Reader) (int64, error)
+	// Read the fileinformation used to validate the offset and respond to HEAD
+	// requests. It may return an os.ErrNotExist which will be interpreted as a
+	// 404 Not Found.
+	GetInfo(ctx context.Context) (FileInfo, error)
+	// GetReader returns a reader which allows iterating of the content of an
+	// upload specified by its ID. It should attempt to provide a reader even if
+	// the upload has not been finished yet but it's not required.
+	// If the returned reader also implements the io.Closer interface, the
+	// Close() method will be invoked once everything has been read.
+	// If the given upload could not be found, the error tusd.ErrNotFound should
+	// be returned.
+	GetReader(ctx context.Context) (io.Reader, error)
+	// FinisherDataStore is the interface which can be implemented by DataStores
+	// which need to do additional operations once an entire upload has been
+	// completed. These tasks may include but are not limited to freeing unused
+	// resources or notifying other services. For example, S3Store uses this
+	// interface for removing a temporary object.
+	// FinishUpload executes additional operations for the finished upload which
+	// is specified by its ID.
+	FinishUpload(ctx context.Context) error
+}
+
+type DataStore interface {
+	// Create a new upload using the size as the file's length. The method must
+	// return an unique id which is used to identify the upload. If no backend
+	// (e.g. Riak) specifes the id you may want to use the uid package to
+	// generate one. The properties Size and MetaData will be filled.
+	NewUpload(ctx context.Context, info FileInfo) (upload Upload, err error)
+
+	GetUpload(ctx context.Context, id string) (upload Upload, err error)
+}
+
+type TerminatableUpload interface {
+	// Terminate an upload so any further requests to the resource, both reading
+	// and writing, must return os.ErrNotExist or similar.
+	Terminate(ctx context.Context) error
+}
+
+// TerminaterDataStore is the interface which must be implemented by DataStores
+// if they want to receive DELETE requests using the Handler. If this interface
+// is not implemented, no request handler for this method is attached.
+type TerminaterDataStore interface {
+	AsTerminatableUpload(upload Upload) TerminatableUpload
+}
+
+// ConcaterDataStore is the interface required to be implemented if the
+// Concatenation extension should be enabled. Only in this case, the handler
+// will parse and respect the Upload-Concat header.
+type ConcaterDataStore interface {
+	AsConcatableUpload(upload Upload) ConcatableUpload
+}
+
+type ConcatableUpload interface {
+	// ConcatUploads concatenates the content from the provided partial uploads
+	// and writes the result in the destination upload.
+	// The caller (usually the handler) must and will ensure that this
+	// destination upload has been created before with enough space to hold all
+	// partial uploads. The order, in which the partial uploads are supplied,
+	// must be respected during concatenation.
+	ConcatUploads(ctx context.Context, partialUploads []Upload) error
+}
+
+// LengthDeferrerDataStore is the interface that must be implemented if the
+// creation-defer-length extension should be enabled. The extension enables a
+// client to upload files when their total size is not yet known. Instead, the
+// client must send the total size as soon as it becomes known.
+type LengthDeferrerDataStore interface {
+	AsLengthDeclarableUpload(upload Upload) LengthDeclarableUpload
+}
+
+type LengthDeclarableUpload interface {
+	DeclareLength(ctx context.Context, length int64) error
+}
+
+// Locker is the interface required for custom lock persisting mechanisms.
+// Common ways to store this information is in memory, on disk or using an
+// external service, such as Redis.
+// When multiple processes are attempting to access an upload, whether it be
+// by reading or writing, a synchronization mechanism is required to prevent
+// data corruption, especially to ensure correct offset values and the proper
+// order of chunks inside a single upload.
+type Locker interface {
+	// NewLock creates a new unlocked lock object for the given upload ID.
+	NewLock(id string) (Lock, error)
+}
+
+// Lock is the interface for a lock as returned from a Locker.
+type Lock interface {
+	// Lock attempts to obtain an exclusive lock for the upload specified
+	// by its id.
+	// If this operation fails because the resource is already locked, the
+	// tusd.ErrFileLocked must be returned. If no error is returned, the attempt
+	// is consider to be successful and the upload to be locked until UnlockUpload
+	// is invoked for the same upload.
+	Lock() error
+	// Unlock releases an existing lock for the given upload.
+	Unlock() error
+}

vendor/github.com/tus/tusd/pkg/handler/doc.go

@@ -0,0 +1,69 @@
+/*
+Package handler provides ways to accept tus 1.0 calls using HTTP.
+
+tus is a protocol based on HTTP for resumable file uploads. Resumable means that
+an upload can be interrupted at any moment and can be resumed without
+re-uploading the previous data again. An interruption may happen willingly, if
+the user wants to pause, or by accident in case of an network issue or server
+outage (http://tus.io).
+
+The basics of tusd
+
+tusd was designed in way which allows an flexible and customizable usage. We
+wanted to avoid binding this package to a specific storage system – particularly
+a proprietary third-party software. Therefore tusd is an abstract layer whose
+only job is to accept incoming HTTP requests, validate them according to the
+specification and finally passes them to the data store.
+
+The data store is another important component in tusd's architecture whose
+purpose is to do the actual file handling. It has to write the incoming upload
+to a persistent storage system and retrieve information about an upload's
+current state. Therefore it is the only part of the system which communicates
+directly with the underlying storage system, whether it be the local disk, a
+remote FTP server or cloud providers such as AWS S3.
+
+Using a store composer
+
+The only hard requirements for a data store can be found in the DataStore
+interface. It contains methods for creating uploads (NewUpload), writing to
+them (WriteChunk) and retrieving their status (GetInfo). However, there
+are many more features which are not mandatory but may still be used.
+These are contained in their own interfaces which all share the *DataStore
+suffix. For example, GetReaderDataStore which enables downloading uploads or
+TerminaterDataStore which allows uploads to be terminated.
+
+The store composer offers a way to combine the basic data store - the core -
+implementation and these additional extensions:
+
+  composer := tusd.NewStoreComposer()
+  composer.UseCore(dataStore) // Implements DataStore
+  composer.UseTerminater(terminater) // Implements TerminaterDataStore
+  composer.UseLocker(locker) // Implements LockerDataStore
+
+The corresponding methods for adding an extension to the composer are prefixed
+with Use* followed by the name of the corresponding interface. However, most
+data store provide multiple extensions and adding all of them manually can be
+tedious and error-prone. Therefore, all data store distributed with tusd provide
+an UseIn() method which does this job automatically. For example, this is the
+S3 store in action (see S3Store.UseIn):
+
+  store := s3store.New(…)
+  locker := memorylocker.New()
+  composer := tusd.NewStoreComposer()
+  store.UseIn(composer)
+  locker.UseIn(composer)
+
+Finally, once you are done with composing your data store, you can pass it
+inside the Config struct in order to create create a new tusd HTTP handler:
+
+  config := tusd.Config{
+    StoreComposer: composer,
+    BasePath: "/files/",
+  }
+  handler, err := tusd.NewHandler(config)
+
+This handler can then be mounted to a specific path, e.g. /files:
+
+  http.Handle("/files/", http.StripPrefix("/files/", handler))
+*/
+package handler

vendor/github.com/tus/tusd/pkg/handler/handler.go

@@ -0,0 +1,53 @@
+package handler
+
+import (
+	"net/http"
+
+	"github.com/bmizerany/pat"
+)
+
+// Handler is a ready to use handler with routing (using pat)
+type Handler struct {
+	*UnroutedHandler
+	http.Handler
+}
+
+// NewHandler creates a routed tus protocol handler. This is the simplest
+// way to use tusd but may not be as configurable as you require. If you are
+// integrating this into an existing app you may like to use tusd.NewUnroutedHandler
+// instead. Using tusd.NewUnroutedHandler allows the tus handlers to be combined into
+// your existing router (aka mux) directly. It also allows the GET and DELETE
+// endpoints to be customized. These are not part of the protocol so can be
+// changed depending on your needs.
+func NewHandler(config Config) (*Handler, error) {
+	if err := config.validate(); err != nil {
+		return nil, err
+	}
+
+	handler, err := NewUnroutedHandler(config)
+	if err != nil {
+		return nil, err
+	}
+
+	routedHandler := &Handler{
+		UnroutedHandler: handler,
+	}
+
+	mux := pat.New()
+
+	routedHandler.Handler = handler.Middleware(mux)
+
+	mux.Post("", http.HandlerFunc(handler.PostFile))
+	mux.Head(":id", http.HandlerFunc(handler.HeadFile))
+	mux.Add("PATCH", ":id", http.HandlerFunc(handler.PatchFile))
+	if !config.DisableDownload {
+		mux.Get(":id", http.HandlerFunc(handler.GetFile))
+	}
+
+	// Only attach the DELETE handler if the Terminate() method is provided
+	if config.StoreComposer.UsesTerminater && !config.DisableTermination {
+		mux.Del(":id", http.HandlerFunc(handler.DelFile))
+	}
+
+	return routedHandler, nil
+}

vendor/github.com/tus/tusd/pkg/handler/log.go

@@ -0,0 +1,27 @@
+package handler
+
+import (
+	"log"
+)
+
+func (h *UnroutedHandler) log(eventName string, details ...string) {
+	LogEvent(h.logger, eventName, details...)
+}
+
+func LogEvent(logger *log.Logger, eventName string, details ...string) {
+	result := make([]byte, 0, 100)
+
+	result = append(result, `event="`...)
+	result = append(result, eventName...)
+	result = append(result, `" `...)
+
+	for i := 0; i < len(details); i += 2 {
+		result = append(result, details[i]...)
+		result = append(result, `="`...)
+		result = append(result, details[i+1]...)
+		result = append(result, `" `...)
+	}
+
+	result = append(result, "\n"...)
+	logger.Output(2, string(result))
+}

vendor/github.com/tus/tusd/pkg/handler/metrics.go

@@ -0,0 +1,137 @@
+package handler
+
+import (
+	"errors"
+	"sync"
+	"sync/atomic"
+)
+
+// Metrics provides numbers about the usage of the tusd handler. Since these may
+// be accessed from multiple goroutines, it is necessary to read and modify them
+// atomically using the functions exposed in the sync/atomic package, such as
+// atomic.LoadUint64. In addition the maps must not be modified to prevent data
+// races.
+type Metrics struct {
+	// RequestTotal counts the number of incoming requests per method
+	RequestsTotal map[string]*uint64
+	// ErrorsTotal counts the number of returned errors by their message
+	ErrorsTotal       *ErrorsTotalMap
+	BytesReceived     *uint64
+	UploadsFinished   *uint64
+	UploadsCreated    *uint64
+	UploadsTerminated *uint64
+}
+
+// incRequestsTotal increases the counter for this request method atomically by
+// one. The method must be one of GET, HEAD, POST, PATCH, DELETE.
+func (m Metrics) incRequestsTotal(method string) {
+	if ptr, ok := m.RequestsTotal[method]; ok {
+		atomic.AddUint64(ptr, 1)
+	}
+}
+
+// incErrorsTotal increases the counter for this error atomically by one.
+func (m Metrics) incErrorsTotal(err HTTPError) {
+	ptr := m.ErrorsTotal.retrievePointerFor(err)
+	atomic.AddUint64(ptr, 1)
+}
+
+// incBytesReceived increases the number of received bytes atomically be the
+// specified number.
+func (m Metrics) incBytesReceived(delta uint64) {
+	atomic.AddUint64(m.BytesReceived, delta)
+}
+
+// incUploadsFinished increases the counter for finished uploads atomically by one.
+func (m Metrics) incUploadsFinished() {
+	atomic.AddUint64(m.UploadsFinished, 1)
+}
+
+// incUploadsCreated increases the counter for completed uploads atomically by one.
+func (m Metrics) incUploadsCreated() {
+	atomic.AddUint64(m.UploadsCreated, 1)
+}
+
+// incUploadsTerminated increases the counter for completed uploads atomically by one.
+func (m Metrics) incUploadsTerminated() {
+	atomic.AddUint64(m.UploadsTerminated, 1)
+}
+
+func newMetrics() Metrics {
+	return Metrics{
+		RequestsTotal: map[string]*uint64{
+			"GET":     new(uint64),
+			"HEAD":    new(uint64),
+			"POST":    new(uint64),
+			"PATCH":   new(uint64),
+			"DELETE":  new(uint64),
+			"OPTIONS": new(uint64),
+		},
+		ErrorsTotal:       newErrorsTotalMap(),
+		BytesReceived:     new(uint64),
+		UploadsFinished:   new(uint64),
+		UploadsCreated:    new(uint64),
+		UploadsTerminated: new(uint64),
+	}
+}
+
+// ErrorsTotalMap stores the counters for the different HTTP errors.
+type ErrorsTotalMap struct {
+	lock    sync.RWMutex
+	counter map[simpleHTTPError]*uint64
+}
+
+type simpleHTTPError struct {
+	Message    string
+	StatusCode int
+}
+
+func simplifyHTTPError(err HTTPError) simpleHTTPError {
+	return simpleHTTPError{
+		Message:    err.Error(),
+		StatusCode: err.StatusCode(),
+	}
+}
+
+func newErrorsTotalMap() *ErrorsTotalMap {
+	m := make(map[simpleHTTPError]*uint64, 20)
+	return &ErrorsTotalMap{
+		counter: m,
+	}
+}
+
+// retrievePointerFor returns (after creating it if necessary) the pointer to
+// the counter for the error.
+func (e *ErrorsTotalMap) retrievePointerFor(err HTTPError) *uint64 {
+	serr := simplifyHTTPError(err)
+	e.lock.RLock()
+	ptr, ok := e.counter[serr]
+	e.lock.RUnlock()
+	if ok {
+		return ptr
+	}
+
+	// For pointer creation, a write-lock is required
+	e.lock.Lock()
+	// We ensure that the pointer wasn't created in the meantime
+	if ptr, ok = e.counter[serr]; !ok {
+		ptr = new(uint64)
+		e.counter[serr] = ptr
+	}
+	e.lock.Unlock()
+
+	return ptr
+}
+
+// Load retrieves the map of the counter pointers atomically
+func (e *ErrorsTotalMap) Load() map[HTTPError]*uint64 {
+	m := make(map[HTTPError]*uint64, len(e.counter))
+	e.lock.RLock()
+	for err, ptr := range e.counter {
+		httpErr := NewHTTPError(errors.New(err.Message), err.StatusCode)
+		m[httpErr] = ptr
+	}
+	e.lock.RUnlock()
+
+	return m
+}