Merge pull request #429 from spiral/2.0

Release 2.0-dev

24 files changed, 4574 insertions, 0 deletions

diff --git a/tests/plugins/http/attributes_test.go b/tests/plugins/http/attributes_test.go
new file mode 100644
index 00000000..69200a30
--- /dev/null
+++ b/tests/plugins/http/attributes_test.go
@@ -0,0 +1,78 @@
+package http
+
+import (
+	"net/http"
+	"testing"
+
+	"github.com/spiral/roadrunner/v2/plugins/http/attributes"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestAllAttributes(t *testing.T) {
+	r := &http.Request{}
+	r = attributes.Init(r)
+
+	err := attributes.Set(r, "key", "value")
+	if err != nil {
+		t.Errorf("error during the Set: error %v", err)
+	}
+
+	assert.Equal(t, attributes.All(r), map[string]interface{}{
+		"key": "value",
+	})
+}
+
+func TestAllAttributesNone(t *testing.T) {
+	r := &http.Request{}
+	r = attributes.Init(r)
+
+	assert.Equal(t, attributes.All(r), map[string]interface{}{})
+}
+
+func TestAllAttributesNone2(t *testing.T) {
+	r := &http.Request{}
+
+	assert.Equal(t, attributes.All(r), map[string]interface{}{})
+}
+
+func TestGetAttribute(t *testing.T) {
+	r := &http.Request{}
+	r = attributes.Init(r)
+
+	err := attributes.Set(r, "key", "value")
+	if err != nil {
+		t.Errorf("error during the Set: error %v", err)
+	}
+	assert.Equal(t, attributes.Get(r, "key"), "value")
+}
+
+func TestGetAttributeNone(t *testing.T) {
+	r := &http.Request{}
+	r = attributes.Init(r)
+
+	assert.Equal(t, attributes.Get(r, "key"), nil)
+}
+
+func TestGetAttributeNone2(t *testing.T) {
+	r := &http.Request{}
+
+	assert.Equal(t, attributes.Get(r, "key"), nil)
+}
+
+func TestSetAttribute(t *testing.T) {
+	r := &http.Request{}
+	r = attributes.Init(r)
+
+	err := attributes.Set(r, "key", "value")
+	if err != nil {
+		t.Errorf("error during the Set: error %v", err)
+	}
+	assert.Equal(t, attributes.Get(r, "key"), "value")
+}
+
+func TestSetAttributeNone(t *testing.T) {
+	r := &http.Request{}
+	err := attributes.Set(r, "key", "value")
+	assert.Error(t, err)
+	assert.Equal(t, attributes.Get(r, "key"), nil)
+}
diff --git a/tests/plugins/http/configs/.rr-broken-pipes.yaml b/tests/plugins/http/configs/.rr-broken-pipes.yaml
new file mode 100644
index 00000000..9b7d2d0b
--- /dev/null
+++ b/tests/plugins/http/configs/.rr-broken-pipes.yaml
@@ -0,0 +1,30 @@
+rpc:
+  listen: tcp://127.0.0.1:6001
+
+server:
+  command: "php ../../http/client.php broken pipes"
+  user: ""
+  group: ""
+  env:
+    "RR_HTTP": "true"
+  relay: "pipes"
+  relay_timeout: "20s"
+
+http:
+  debug: true
+  address: 127.0.0.1:12384
+  max_request_size: 1024
+  middleware: [ "" ]
+  uploads:
+    forbid: [ ".php", ".exe", ".bat" ]
+  trusted_subnets: [ "10.0.0.0/8", "127.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16", "::1/128", "fc00::/7", "fe80::/10" ]
+  pool:
+    num_workers: 2
+    max_jobs: 0
+    allocate_timeout: 60s
+    destroy_timeout: 60s
+logs:
+  mode: development
+  level: error
+
+
diff --git a/tests/plugins/http/configs/.rr-env.yaml b/tests/plugins/http/configs/.rr-env.yaml
new file mode 100644
index 00000000..e6b00b69
--- /dev/null
+++ b/tests/plugins/http/configs/.rr-env.yaml
@@ -0,0 +1,32 @@
+rpc:
+  listen: tcp://127.0.0.1:6001
+
+server:
+  command: "php ../../http/client.php env pipes"
+  user: ""
+  group: ""
+  env:
+    "env_key": "ENV_VALUE"
+  relay: "pipes"
+  relay_timeout: "20s"
+
+http:
+  debug: true
+  address: 127.0.0.1:12084
+  max_request_size: 1024
+  middleware: [ "" ]
+  env:
+    "RR_HTTP": "true"
+    "env_key": "ENV_VALUE"
+  uploads:
+    forbid: [ ".php", ".exe", ".bat" ]
+  trusted_subnets: [ "10.0.0.0/8", "127.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16", "::1/128", "fc00::/7", "fe80::/10" ]
+  pool:
+    num_workers: 2
+    max_jobs: 0
+    allocate_timeout: 60s
+    destroy_timeout: 60s
+logs:
+  mode: development
+  level: error
+
diff --git a/tests/plugins/http/configs/.rr-fcgi-reqUri.yaml b/tests/plugins/http/configs/.rr-fcgi-reqUri.yaml
new file mode 100644
index 00000000..ab42f4fc
--- /dev/null
+++ b/tests/plugins/http/configs/.rr-fcgi-reqUri.yaml
@@ -0,0 +1,37 @@
+server:
+  command: "php ../../http/client.php request-uri pipes"
+  user: ""
+  group: ""
+  env:
+    "RR_HTTP": "true"
+  relay: "pipes"
+  relay_timeout: "20s"
+
+http:
+  debug: true
+  address: :8082
+  max_request_size: 1024
+  middleware: [ "" ]
+  uploads:
+    forbid: [ ".php", ".exe", ".bat" ]
+  trusted_subnets: [ "10.0.0.0/8", "127.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16", "::1/128", "fc00::/7", "fe80::/10" ]
+  pool:
+    num_workers: 1
+    max_jobs: 0
+    allocate_timeout: 60s
+    destroy_timeout: 60s
+
+  ssl:
+    address: :8890
+    redirect: false
+    cert: fixtures/server.crt
+    key: fixtures/server.key
+  #    root_ca: root.crt
+  fcgi:
+    address: tcp://127.0.0.1:6921
+  http2:
+    h2c: false
+    maxConcurrentStreams: 128
+logs:
+  mode: development
+  level: error
\ No newline at end of file
diff --git a/tests/plugins/http/configs/.rr-fcgi.yaml b/tests/plugins/http/configs/.rr-fcgi.yaml
new file mode 100644
index 00000000..bd5d01bd
--- /dev/null
+++ b/tests/plugins/http/configs/.rr-fcgi.yaml
@@ -0,0 +1,37 @@
+server:
+  command: "php ../../http/client.php echo pipes"
+  user: ""
+  group: ""
+  env:
+    "RR_HTTP": "true"
+  relay: "pipes"
+  relay_timeout: "20s"
+
+http:
+  debug: true
+  address: :8081
+  max_request_size: 1024
+  middleware: [ "" ]
+  uploads:
+    forbid: [ ".php", ".exe", ".bat" ]
+  trusted_subnets: [ "10.0.0.0/8", "127.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16", "::1/128", "fc00::/7", "fe80::/10" ]
+  pool:
+    num_workers: 1
+    max_jobs: 0
+    allocate_timeout: 60s
+    destroy_timeout: 60s
+
+  ssl:
+    address: :8889
+    redirect: false
+    cert: fixtures/server.crt
+    key: fixtures/server.key
+  #    root_ca: root.crt
+  fcgi:
+    address: tcp://0.0.0.0:6920
+  http2:
+    h2c: false
+    maxConcurrentStreams: 128
+logs:
+  mode: development
+  level: error
\ No newline at end of file
diff --git a/tests/plugins/http/configs/.rr-h2c.yaml b/tests/plugins/http/configs/.rr-h2c.yaml
new file mode 100644
index 00000000..2061a76b
--- /dev/null
+++ b/tests/plugins/http/configs/.rr-h2c.yaml
@@ -0,0 +1,28 @@
+server:
+  command: "php ../../http/client.php echo pipes"
+  user: ""
+  group: ""
+  env:
+    "RR_HTTP": "true"
+  relay: "pipes"
+  relay_timeout: "20s"
+
+http:
+  debug: true
+  address: :8083
+  max_request_size: 1024
+  middleware: [ "" ]
+  uploads:
+    forbid: [ ".php", ".exe", ".bat" ]
+  trusted_subnets: [ "10.0.0.0/8", "127.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16", "::1/128", "fc00::/7", "fe80::/10" ]
+  pool:
+    num_workers: 1
+    max_jobs: 0
+    allocate_timeout: 60s
+    destroy_timeout: 60s
+  http2:
+    h2c: true
+    maxConcurrentStreams: 128
+logs:
+  mode: development
+  level: error
\ No newline at end of file
diff --git a/tests/plugins/http/configs/.rr-http-supervised-pool.yaml b/tests/plugins/http/configs/.rr-http-supervised-pool.yaml
new file mode 100644
index 00000000..3e392577
--- /dev/null
+++ b/tests/plugins/http/configs/.rr-http-supervised-pool.yaml
@@ -0,0 +1,33 @@
+rpc:
+  listen: tcp://127.0.0.1:15432
+server:
+  command: "php ../../http/client.php echo pipes"
+  user: ""
+  group: ""
+  env:
+    "RR_HTTP": "true"
+  relay: "pipes"
+  relay_timeout: "20s"
+
+http:
+  debug: true
+  address: 127.0.0.1:18888
+  max_request_size: 1024
+  middleware: [ "" ]
+  uploads:
+    forbid: [ ".php", ".exe", ".bat" ]
+  trusted_subnets: [ "10.0.0.0/8", "127.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16", "::1/128", "fc00::/7", "fe80::/10" ]
+  pool:
+    num_workers: 1
+    max_jobs: 0
+    allocate_timeout: 60s
+    destroy_timeout: 60s
+    supervisor:
+      watch_tick: 1s
+      ttl: 0
+      idle_ttl: 5s
+      exec_ttl: 10s
+      max_worker_memory: 100
+logs:
+  mode: development
+  level: error
\ No newline at end of file
diff --git a/tests/plugins/http/configs/.rr-http.yaml b/tests/plugins/http/configs/.rr-http.yaml
new file mode 100644
index 00000000..184a353c
--- /dev/null
+++ b/tests/plugins/http/configs/.rr-http.yaml
@@ -0,0 +1,30 @@
+rpc:
+  listen: tcp://127.0.0.1:6001
+
+server:
+  command: "php ../../http/client.php echo pipes"
+  user: ""
+  group: ""
+  env:
+    "RR_HTTP": "true"
+  relay: "pipes"
+  relay_timeout: "20s"
+
+http:
+  debug: true
+  address: 127.0.0.1:18903
+  max_request_size: 1024
+  middleware: [ "pluginMiddleware", "pluginMiddleware2" ]
+  uploads:
+    forbid: [ ".php", ".exe", ".bat" ]
+  trusted_subnets: [ "10.0.0.0/8", "127.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16", "::1/128", "fc00::/7", "fe80::/10" ]
+  pool:
+    num_workers: 2
+    max_jobs: 0
+    allocate_timeout: 60s
+    destroy_timeout: 60s
+logs:
+  mode: development
+  level: error
+
+
diff --git a/tests/plugins/http/configs/.rr-init.yaml b/tests/plugins/http/configs/.rr-init.yaml
new file mode 100644
index 00000000..77132b43
--- /dev/null
+++ b/tests/plugins/http/configs/.rr-init.yaml
@@ -0,0 +1,41 @@
+rpc:
+  listen: tcp://127.0.0.1:6001
+
+server:
+  command: "php ../../http/client.php echo pipes"
+  user: ""
+  group: ""
+  env:
+    "RR_HTTP": "true"
+  relay: "pipes"
+  relay_timeout: "20s"
+
+http:
+  debug: true
+  address: 127.0.0.1:15395
+  max_request_size: 1024
+  middleware: [ "" ]
+  uploads:
+    forbid: [ ".php", ".exe", ".bat" ]
+  trusted_subnets: [ "10.0.0.0/8", "127.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16", "::1/128", "fc00::/7", "fe80::/10" ]
+  pool:
+    num_workers: 2
+    max_jobs: 0
+    allocate_timeout: 60s
+    destroy_timeout: 60s
+
+  ssl:
+    address: :8892
+    redirect: false
+    cert: fixtures/server.crt
+    key: fixtures/server.key
+  #    root_ca: root.crt
+  fcgi:
+    address: tcp://0.0.0.0:7921
+  http2:
+    h2c: false
+    maxConcurrentStreams: 128
+logs:
+  mode: development
+  level: error
+
diff --git a/tests/plugins/http/configs/.rr-no-http.yaml b/tests/plugins/http/configs/.rr-no-http.yaml
new file mode 100644
index 00000000..a6747b5d
--- /dev/null
+++ b/tests/plugins/http/configs/.rr-no-http.yaml
@@ -0,0 +1,16 @@
+rpc:
+  listen: tcp://127.0.0.1:6001
+
+server:
+  command: "php ../../http/client.php echo pipes"
+  user: ""
+  group: ""
+  env:
+    "RR_HTTP": "true"
+  relay: "pipes"
+  relay_timeout: "20s"
+
+logs:
+  mode: development
+  level: error
+
diff --git a/tests/plugins/http/configs/.rr-resetter.yaml b/tests/plugins/http/configs/.rr-resetter.yaml
new file mode 100644
index 00000000..a1ef27d1
--- /dev/null
+++ b/tests/plugins/http/configs/.rr-resetter.yaml
@@ -0,0 +1,29 @@
+rpc:
+  listen: tcp://127.0.0.1:6001
+
+server:
+  command: "php ../../http/client.php echo pipes"
+  user: ""
+  group: ""
+  env:
+    "RR_HTTP": "true"
+  relay: "pipes"
+  relay_timeout: "20s"
+
+http:
+  debug: true
+  address: 127.0.0.1:10084
+  max_request_size: 1024
+  middleware: [ "" ]
+  uploads:
+    forbid: [ ".php", ".exe", ".bat" ]
+  trusted_subnets: [ "10.0.0.0/8", "127.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16", "::1/128", "fc00::/7", "fe80::/10" ]
+  pool:
+    num_workers: 2
+    max_jobs: 0
+    allocate_timeout: 60s
+    destroy_timeout: 60s
+logs:
+  mode: development
+  level: error
+
diff --git a/tests/plugins/http/configs/.rr-ssl-push.yaml b/tests/plugins/http/configs/.rr-ssl-push.yaml
new file mode 100644
index 00000000..11a8ddd3
--- /dev/null
+++ b/tests/plugins/http/configs/.rr-ssl-push.yaml
@@ -0,0 +1,31 @@
+server:
+  command: "php ../../http/client.php push pipes"
+  user: ""
+  group: ""
+  env:
+    "RR_HTTP": "true"
+  relay: "pipes"
+  relay_timeout: "20s"
+
+http:
+  debug: true
+  address: :8086
+  max_request_size: 1024
+  middleware: [ "" ]
+  uploads:
+    forbid: [ ".php", ".exe", ".bat" ]
+  trusted_subnets: [ "10.0.0.0/8", "127.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16", "::1/128", "fc00::/7", "fe80::/10" ]
+  pool:
+    num_workers: 1
+    max_jobs: 0
+    allocate_timeout: 60s
+    destroy_timeout: 60s
+
+  ssl:
+    address: :8894
+    redirect: true
+    cert: fixtures/server.crt
+    key: fixtures/server.key
+logs:
+  mode: development
+  level: error
\ No newline at end of file
diff --git a/tests/plugins/http/configs/.rr-ssl-redirect.yaml b/tests/plugins/http/configs/.rr-ssl-redirect.yaml
new file mode 100644
index 00000000..e49a73ed
--- /dev/null
+++ b/tests/plugins/http/configs/.rr-ssl-redirect.yaml
@@ -0,0 +1,31 @@
+server:
+  command: "php ../../http/client.php echo pipes"
+  user: ""
+  group: ""
+  env:
+    "RR_HTTP": "true"
+  relay: "pipes"
+  relay_timeout: "20s"
+
+http:
+  debug: true
+  address: :8087
+  max_request_size: 1024
+  middleware: [ "" ]
+  uploads:
+    forbid: [ ".php", ".exe", ".bat" ]
+  trusted_subnets: [ "10.0.0.0/8", "127.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16", "::1/128", "fc00::/7", "fe80::/10" ]
+  pool:
+    num_workers: 1
+    max_jobs: 0
+    allocate_timeout: 60s
+    destroy_timeout: 60s
+
+  ssl:
+    address: :8895
+    redirect: true
+    cert: fixtures/server.crt
+    key: fixtures/server.key
+logs:
+  mode: development
+  level: error
\ No newline at end of file
diff --git a/tests/plugins/http/configs/.rr-ssl.yaml b/tests/plugins/http/configs/.rr-ssl.yaml
new file mode 100644
index 00000000..8a0f16b8
--- /dev/null
+++ b/tests/plugins/http/configs/.rr-ssl.yaml
@@ -0,0 +1,32 @@
+server:
+  command: "php ../../http/client.php echo pipes"
+  user: ""
+  group: ""
+  env:
+    "RR_HTTP": "true"
+  relay: "pipes"
+  relay_timeout: "20s"
+
+http:
+  address: :8085
+  max_request_size: 1024
+  middleware: [ "" ]
+  uploads:
+    forbid: [ ".php", ".exe", ".bat" ]
+  trusted_subnets: [ "10.0.0.0/8", "127.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16", "::1/128", "fc00::/7", "fe80::/10" ]
+  pool:
+    num_workers: 1
+    max_jobs: 0
+    allocate_timeout: 60s
+    destroy_timeout: 60s
+
+  ssl:
+    address: :8893
+    redirect: false
+    cert: fixtures/server.crt
+    key: fixtures/server.key
+  fcgi:
+    address: tcp://0.0.0.0:16920
+logs:
+  mode: development
+  level: error
\ No newline at end of file
diff --git a/tests/plugins/http/fixtures/server.crt b/tests/plugins/http/fixtures/server.crt
new file mode 100644
index 00000000..24d67fd7
--- /dev/null
+++ b/tests/plugins/http/fixtures/server.crt
@@ -0,0 +1,15 @@
+-----BEGIN CERTIFICATE-----
+MIICTTCCAdOgAwIBAgIJAOKyUd+llTRKMAoGCCqGSM49BAMCMGMxCzAJBgNVBAYT
+AlVTMRMwEQYDVQQIDApDYWxpZm9ybmlhMRYwFAYDVQQHDA1TYW4gRnJhbmNpc2Nv
+MRMwEQYDVQQKDApSb2FkUnVubmVyMRIwEAYDVQQDDAlsb2NhbGhvc3QwHhcNMTgw
+OTMwMTMzNDUzWhcNMjgwOTI3MTMzNDUzWjBjMQswCQYDVQQGEwJVUzETMBEGA1UE
+CAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwNU2FuIEZyYW5jaXNjbzETMBEGA1UECgwK
+Um9hZFJ1bm5lcjESMBAGA1UEAwwJbG9jYWxob3N0MHYwEAYHKoZIzj0CAQYFK4EE
+ACIDYgAEVnbShsM+l5RR3wfWWmGhzuFGwNzKCk7i9xyobDIyBUxG/UUSfj7KKlUX
+puDnDEtF5xXcepl744CyIAYFLOXHb5WqI4jCOzG0o9f/00QQ4bQudJOdbqV910QF
+C2vb7Fxro1MwUTAdBgNVHQ4EFgQU9xUexnbB6ORKayA7Pfjzs33otsAwHwYDVR0j
+BBgwFoAU9xUexnbB6ORKayA7Pfjzs33otsAwDwYDVR0TAQH/BAUwAwEB/zAKBggq
+hkjOPQQDAgNoADBlAjEAue3HhR/MUhxoa9tSDBtOJT3FYbDQswrsdqBTz97CGKst
+e7XeZ3HMEvEXy0hGGEMhAjAqcD/4k9vViVppgWFtkk6+NFbm+Kw/QeeAiH5FgFSj
+8xQcb+b7nPwNLp3JOkXkVd4=
+-----END CERTIFICATE-----
diff --git a/tests/plugins/http/fixtures/server.key b/tests/plugins/http/fixtures/server.key
new file mode 100644
index 00000000..7501dd46
--- /dev/null
+++ b/tests/plugins/http/fixtures/server.key
@@ -0,0 +1,9 @@
+-----BEGIN EC PARAMETERS-----
+BgUrgQQAIg==
+-----END EC PARAMETERS-----
+-----BEGIN EC PRIVATE KEY-----
+MIGkAgEBBDCQP8utxNbHR6xZOLAJgUhn88r6IrPqmN0MsgGJM/jePB+T9UhkmIU8
+PMm2HeScbcugBwYFK4EEACKhZANiAARWdtKGwz6XlFHfB9ZaYaHO4UbA3MoKTuL3
+HKhsMjIFTEb9RRJ+PsoqVRem4OcMS0XnFdx6mXvjgLIgBgUs5cdvlaojiMI7MbSj
+1//TRBDhtC50k51upX3XRAULa9vsXGs=
+-----END EC PRIVATE KEY-----
diff --git a/tests/plugins/http/handler_test.go b/tests/plugins/http/handler_test.go
new file mode 100644
index 00000000..e47dbd44
--- /dev/null
+++ b/tests/plugins/http/handler_test.go
@@ -0,0 +1,1861 @@
+package http
+
+import (
+	"bytes"
+	"context"
+	"io/ioutil"
+	"mime/multipart"
+	"net/url"
+	"os/exec"
+	"runtime"
+	"strings"
+
+	"github.com/spiral/roadrunner/v2/pkg/pool"
+	"github.com/spiral/roadrunner/v2/pkg/transport/pipe"
+	httpPlugin "github.com/spiral/roadrunner/v2/plugins/http"
+	"github.com/spiral/roadrunner/v2/plugins/http/config"
+	"github.com/stretchr/testify/assert"
+
+	"net/http"
+	"os"
+	"testing"
+	"time"
+)
+
+func TestHandler_Echo(t *testing.T) {
+	p, err := pool.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "echo", "pipes") },
+		pipe.NewPipeFactory(),
+		pool.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	h, err := httpPlugin.NewHandler(1024, config.Uploads{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, p)
+	assert.NoError(t, err)
+
+	hs := &http.Server{Addr: ":8177", Handler: h}
+	defer func() {
+		err := hs.Shutdown(context.Background())
+		if err != nil {
+			t.Errorf("error during the shutdown: error %v", err)
+		}
+	}()
+	go func(server *http.Server) {
+		err := server.ListenAndServe()
+		if err != nil && err != http.ErrServerClosed {
+			t.Errorf("error listening the interface: error %v", err)
+		}
+	}(hs)
+	time.Sleep(time.Millisecond * 10)
+
+	body, r, err := get("http://localhost:8177/?hello=world")
+	assert.NoError(t, err)
+	defer func() {
+		_ = r.Body.Close()
+	}()
+	assert.Equal(t, 201, r.StatusCode)
+	assert.Equal(t, "WORLD", body)
+}
+
+func Test_HandlerErrors(t *testing.T) {
+	_, err := httpPlugin.NewHandler(1024, config.Uploads{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, nil)
+	assert.Error(t, err)
+}
+
+func TestHandler_Headers(t *testing.T) {
+	p, err := pool.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "header", "pipes") },
+		pipe.NewPipeFactory(),
+		pool.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		p.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, config.Uploads{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, p)
+	assert.NoError(t, err)
+
+	hs := &http.Server{Addr: ":8078", Handler: h}
+	defer func() {
+		err := hs.Shutdown(context.Background())
+		if err != nil {
+			t.Errorf("error during the shutdown: error %v", err)
+		}
+	}()
+
+	go func() {
+		err := hs.ListenAndServe()
+		if err != nil && err != http.ErrServerClosed {
+			t.Errorf("error listening the interface: error %v", err)
+		}
+	}()
+	time.Sleep(time.Millisecond * 100)
+
+	req, err := http.NewRequest("GET", "http://localhost:8078?hello=world", nil)
+	assert.NoError(t, err)
+
+	req.Header.Add("input", "sample")
+
+	r, err := http.DefaultClient.Do(req)
+	assert.NoError(t, err)
+	defer func() {
+		err := r.Body.Close()
+		if err != nil {
+			t.Errorf("error during the closing Body: error %v", err)
+		}
+	}()
+
+	b, err := ioutil.ReadAll(r.Body)
+	assert.NoError(t, err)
+
+	assert.NoError(t, err)
+	assert.Equal(t, 200, r.StatusCode)
+	assert.Equal(t, "world", r.Header.Get("Header"))
+	assert.Equal(t, "SAMPLE", string(b))
+}
+
+func TestHandler_Empty_User_Agent(t *testing.T) {
+	p, err := pool.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "user-agent", "pipes") },
+		pipe.NewPipeFactory(),
+		pool.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		p.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, config.Uploads{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, p)
+	assert.NoError(t, err)
+
+	hs := &http.Server{Addr: ":8088", Handler: h}
+	defer func() {
+		err := hs.Shutdown(context.Background())
+		if err != nil {
+			t.Errorf("error during the shutdown: error %v", err)
+		}
+	}()
+
+	go func() {
+		err := hs.ListenAndServe()
+		if err != nil && err != http.ErrServerClosed {
+			t.Errorf("error listening the interface: error %v", err)
+		}
+	}()
+	time.Sleep(time.Millisecond * 10)
+
+	req, err := http.NewRequest("GET", "http://localhost:8088?hello=world", nil)
+	assert.NoError(t, err)
+
+	req.Header.Add("user-agent", "")
+
+	r, err := http.DefaultClient.Do(req)
+	assert.NoError(t, err)
+	defer func() {
+		err := r.Body.Close()
+		if err != nil {
+			t.Errorf("error during the closing Body: error %v", err)
+		}
+	}()
+
+	b, err := ioutil.ReadAll(r.Body)
+	assert.NoError(t, err)
+
+	assert.NoError(t, err)
+	assert.Equal(t, 200, r.StatusCode)
+	assert.Equal(t, "", string(b))
+}
+
+func TestHandler_User_Agent(t *testing.T) {
+	p, err := pool.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "user-agent", "pipes") },
+		pipe.NewPipeFactory(),
+		pool.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		p.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, config.Uploads{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, p)
+	assert.NoError(t, err)
+
+	hs := &http.Server{Addr: ":8088", Handler: h}
+	defer func() {
+		err := hs.Shutdown(context.Background())
+		if err != nil {
+			t.Errorf("error during the shutdown: error %v", err)
+		}
+	}()
+
+	go func() {
+		err := hs.ListenAndServe()
+		if err != nil && err != http.ErrServerClosed {
+			t.Errorf("error listening the interface: error %v", err)
+		}
+	}()
+	time.Sleep(time.Millisecond * 10)
+
+	req, err := http.NewRequest("GET", "http://localhost:8088?hello=world", nil)
+	assert.NoError(t, err)
+
+	req.Header.Add("User-Agent", "go-agent")
+
+	r, err := http.DefaultClient.Do(req)
+	assert.NoError(t, err)
+	defer func() {
+		err := r.Body.Close()
+		if err != nil {
+			t.Errorf("error during the closing Body: error %v", err)
+		}
+	}()
+
+	b, err := ioutil.ReadAll(r.Body)
+	assert.NoError(t, err)
+
+	assert.NoError(t, err)
+	assert.Equal(t, 200, r.StatusCode)
+	assert.Equal(t, "go-agent", string(b))
+}
+
+func TestHandler_Cookies(t *testing.T) {
+	p, err := pool.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "cookie", "pipes") },
+		pipe.NewPipeFactory(),
+		pool.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		p.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, config.Uploads{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, p)
+	assert.NoError(t, err)
+
+	hs := &http.Server{Addr: ":8079", Handler: h}
+	defer func() {
+		err := hs.Shutdown(context.Background())
+		if err != nil {
+			t.Errorf("error during the shutdown: error %v", err)
+		}
+	}()
+
+	go func() {
+		err := hs.ListenAndServe()
+		if err != nil && err != http.ErrServerClosed {
+			t.Errorf("error listening the interface: error %v", err)
+		}
+	}()
+	time.Sleep(time.Millisecond * 10)
+
+	req, err := http.NewRequest("GET", "http://localhost:8079", nil)
+	assert.NoError(t, err)
+
+	req.AddCookie(&http.Cookie{Name: "input", Value: "input-value"})
+
+	r, err := http.DefaultClient.Do(req)
+	assert.NoError(t, err)
+	defer func() {
+		err := r.Body.Close()
+		if err != nil {
+			t.Errorf("error during the closing Body: error %v", err)
+		}
+	}()
+
+	b, err := ioutil.ReadAll(r.Body)
+	assert.NoError(t, err)
+
+	assert.NoError(t, err)
+	assert.Equal(t, 200, r.StatusCode)
+	assert.Equal(t, "INPUT-VALUE", string(b))
+
+	for _, c := range r.Cookies() {
+		assert.Equal(t, "output", c.Name)
+		assert.Equal(t, "cookie-output", c.Value)
+	}
+}
+
+func TestHandler_JsonPayload_POST(t *testing.T) {
+	p, err := pool.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "payload", "pipes") },
+		pipe.NewPipeFactory(),
+		pool.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		p.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, config.Uploads{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, p)
+	assert.NoError(t, err)
+
+	hs := &http.Server{Addr: ":8090", Handler: h}
+	defer func() {
+		err := hs.Shutdown(context.Background())
+		if err != nil {
+			t.Errorf("error during the shutdown: error %v", err)
+		}
+	}()
+
+	go func() {
+		err := hs.ListenAndServe()
+		if err != nil && err != http.ErrServerClosed {
+			t.Errorf("error listening the interface: error %v", err)
+		}
+	}()
+	time.Sleep(time.Millisecond * 10)
+
+	req, err := http.NewRequest(
+		"POST",
+		"http://localhost"+hs.Addr,
+		bytes.NewBufferString(`{"key":"value"}`),
+	)
+	assert.NoError(t, err)
+
+	req.Header.Add("Content-Type", "application/json")
+
+	r, err := http.DefaultClient.Do(req)
+	assert.NoError(t, err)
+	defer func() {
+		err := r.Body.Close()
+		if err != nil {
+			t.Errorf("error during the closing Body: error %v", err)
+		}
+	}()
+
+	b, err := ioutil.ReadAll(r.Body)
+	assert.NoError(t, err)
+
+	assert.NoError(t, err)
+	assert.Equal(t, 200, r.StatusCode)
+	assert.Equal(t, `{"value":"key"}`, string(b))
+}
+
+func TestHandler_JsonPayload_PUT(t *testing.T) {
+	p, err := pool.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "payload", "pipes") },
+		pipe.NewPipeFactory(),
+		pool.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		p.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, config.Uploads{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, p)
+	assert.NoError(t, err)
+
+	hs := &http.Server{Addr: ":8081", Handler: h}
+	defer func() {
+		err := hs.Shutdown(context.Background())
+		if err != nil {
+			t.Errorf("error during the shutdown: error %v", err)
+		}
+	}()
+
+	go func() {
+		err := hs.ListenAndServe()
+		if err != nil && err != http.ErrServerClosed {
+			t.Errorf("error listening the interface: error %v", err)
+		}
+	}()
+	time.Sleep(time.Millisecond * 10)
+
+	req, err := http.NewRequest("PUT", "http://localhost"+hs.Addr, bytes.NewBufferString(`{"key":"value"}`))
+	assert.NoError(t, err)
+
+	req.Header.Add("Content-Type", "application/json")
+
+	r, err := http.DefaultClient.Do(req)
+	assert.NoError(t, err)
+	defer func() {
+		err := r.Body.Close()
+		if err != nil {
+			t.Errorf("error during the closing Body: error %v", err)
+		}
+	}()
+
+	b, err := ioutil.ReadAll(r.Body)
+	assert.NoError(t, err)
+
+	assert.NoError(t, err)
+	assert.Equal(t, 200, r.StatusCode)
+	assert.Equal(t, `{"value":"key"}`, string(b))
+}
+
+func TestHandler_JsonPayload_PATCH(t *testing.T) {
+	p, err := pool.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "payload", "pipes") },
+		pipe.NewPipeFactory(),
+		pool.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		p.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, config.Uploads{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, p)
+	assert.NoError(t, err)
+
+	hs := &http.Server{Addr: ":8082", Handler: h}
+	defer func() {
+		err := hs.Shutdown(context.Background())
+		if err != nil {
+			t.Errorf("error during the shutdown: error %v", err)
+		}
+	}()
+
+	go func() {
+		err := hs.ListenAndServe()
+		if err != nil && err != http.ErrServerClosed {
+			t.Errorf("error listening the interface: error %v", err)
+		}
+	}()
+	time.Sleep(time.Millisecond * 10)
+
+	req, err := http.NewRequest("PATCH", "http://localhost"+hs.Addr, bytes.NewBufferString(`{"key":"value"}`))
+	assert.NoError(t, err)
+
+	req.Header.Add("Content-Type", "application/json")
+
+	r, err := http.DefaultClient.Do(req)
+	assert.NoError(t, err)
+	defer func() {
+		err := r.Body.Close()
+		if err != nil {
+			t.Errorf("error during the closing Body: error %v", err)
+		}
+	}()
+
+	b, err := ioutil.ReadAll(r.Body)
+	assert.NoError(t, err)
+
+	assert.NoError(t, err)
+	assert.Equal(t, 200, r.StatusCode)
+	assert.Equal(t, `{"value":"key"}`, string(b))
+}
+
+func TestHandler_FormData_POST(t *testing.T) {
+	p, err := pool.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "data", "pipes") },
+		pipe.NewPipeFactory(),
+		pool.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		p.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, config.Uploads{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, p)
+	assert.NoError(t, err)
+
+	hs := &http.Server{Addr: ":8083", Handler: h}
+	defer func() {
+		err := hs.Shutdown(context.Background())
+		if err != nil {
+			t.Errorf("error during the shutdown: error %v", err)
+		}
+	}()
+
+	go func() {
+		err := hs.ListenAndServe()
+		if err != nil && err != http.ErrServerClosed {
+			t.Errorf("error listening the interface: error %v", err)
+		}
+	}()
+	time.Sleep(time.Millisecond * 500)
+
+	form := url.Values{}
+
+	form.Add("key", "value")
+	form.Add("name[]", "name1")
+	form.Add("name[]", "name2")
+	form.Add("name[]", "name3")
+	form.Add("arr[x][y][z]", "y")
+	form.Add("arr[x][y][e]", "f")
+	form.Add("arr[c]p", "l")
+	form.Add("arr[c]z", "")
+
+	req, err := http.NewRequest("POST", "http://localhost"+hs.Addr, strings.NewReader(form.Encode()))
+	assert.NoError(t, err)
+
+	req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
+
+	r, err := http.DefaultClient.Do(req)
+	assert.NoError(t, err)
+	defer func() {
+		err := r.Body.Close()
+		if err != nil {
+			t.Errorf("error during the closing Body: error %v", err)
+		}
+	}()
+
+	b, err := ioutil.ReadAll(r.Body)
+	assert.NoError(t, err)
+
+	assert.NoError(t, err)
+	assert.Equal(t, 200, r.StatusCode)
+
+	// Sorted
+	assert.Equal(t, "{\"arr\":{\"c\":{\"p\":\"l\",\"z\":\"\"},\"x\":{\"y\":{\"e\":\"f\",\"z\":\"y\"}}},\"key\":\"value\",\"name\":[\"name1\",\"name2\",\"name3\"]}", string(b))
+}
+
+func TestHandler_FormData_POST_Overwrite(t *testing.T) {
+	p, err := pool.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "data", "pipes") },
+		pipe.NewPipeFactory(),
+		pool.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		p.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, config.Uploads{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, p)
+	assert.NoError(t, err)
+
+	hs := &http.Server{Addr: ":8083", Handler: h}
+	defer func() {
+		err := hs.Shutdown(context.Background())
+		if err != nil {
+			t.Errorf("error during the shutdown: error %v", err)
+		}
+	}()
+
+	go func() {
+		err := hs.ListenAndServe()
+		if err != nil && err != http.ErrServerClosed {
+			t.Errorf("error listening the interface: error %v", err)
+		}
+	}()
+	time.Sleep(time.Millisecond * 10)
+
+	form := url.Values{}
+
+	form.Add("key", "value")
+	form.Add("key", "value2")
+	form.Add("name[]", "name1")
+	form.Add("name[]", "name2")
+	form.Add("name[]", "name3")
+	form.Add("arr[x][y][z]", "y")
+	form.Add("arr[x][y][e]", "f")
+	form.Add("arr[c]p", "l")
+	form.Add("arr[c]z", "")
+
+	req, err := http.NewRequest("POST", "http://localhost"+hs.Addr, strings.NewReader(form.Encode()))
+	assert.NoError(t, err)
+
+	req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
+
+	r, err := http.DefaultClient.Do(req)
+	assert.NoError(t, err)
+	defer func() {
+		err := r.Body.Close()
+		if err != nil {
+			t.Errorf("error during the closing Body: error %v", err)
+		}
+	}()
+
+	b, err := ioutil.ReadAll(r.Body)
+	assert.NoError(t, err)
+
+	assert.NoError(t, err)
+	assert.Equal(t, 200, r.StatusCode)
+
+	assert.Equal(t, `{"arr":{"c":{"p":"l","z":""},"x":{"y":{"e":"f","z":"y"}}},"key":"value2","name":["name1","name2","name3"]}`, string(b))
+}
+
+func TestHandler_FormData_POST_Form_UrlEncoded_Charset(t *testing.T) {
+	p, err := pool.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "data", "pipes") },
+		pipe.NewPipeFactory(),
+		pool.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		p.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, config.Uploads{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, p)
+	assert.NoError(t, err)
+
+	hs := &http.Server{Addr: ":8083", Handler: h}
+	defer func() {
+		err := hs.Shutdown(context.Background())
+		if err != nil {
+			t.Errorf("error during the shutdown: error %v", err)
+		}
+	}()
+
+	go func() {
+		err := hs.ListenAndServe()
+		if err != nil && err != http.ErrServerClosed {
+			t.Errorf("error listening the interface: error %v", err)
+		}
+	}()
+	time.Sleep(time.Millisecond * 10)
+
+	form := url.Values{}
+
+	form.Add("key", "value")
+	form.Add("name[]", "name1")
+	form.Add("name[]", "name2")
+	form.Add("name[]", "name3")
+	form.Add("arr[x][y][z]", "y")
+	form.Add("arr[x][y][e]", "f")
+	form.Add("arr[c]p", "l")
+	form.Add("arr[c]z", "")
+
+	req, err := http.NewRequest("POST", "http://localhost"+hs.Addr, strings.NewReader(form.Encode()))
+	assert.NoError(t, err)
+
+	req.Header.Add("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8")
+
+	r, err := http.DefaultClient.Do(req)
+	assert.NoError(t, err)
+	defer func() {
+		err := r.Body.Close()
+		if err != nil {
+			t.Errorf("error during the closing Body: error %v", err)
+		}
+	}()
+
+	b, err := ioutil.ReadAll(r.Body)
+	assert.NoError(t, err)
+
+	assert.NoError(t, err)
+	assert.Equal(t, 200, r.StatusCode)
+
+	assert.Equal(t, `{"arr":{"c":{"p":"l","z":""},"x":{"y":{"e":"f","z":"y"}}},"key":"value","name":["name1","name2","name3"]}`, string(b))
+}
+
+func TestHandler_FormData_PUT(t *testing.T) {
+	p, err := pool.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "data", "pipes") },
+		pipe.NewPipeFactory(),
+		pool.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		p.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, config.Uploads{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, p)
+	assert.NoError(t, err)
+
+	hs := &http.Server{Addr: ":17834", Handler: h}
+	defer func() {
+		err := hs.Shutdown(context.Background())
+		if err != nil {
+			t.Errorf("error during the shutdown: error %v", err)
+		}
+	}()
+
+	go func() {
+		err := hs.ListenAndServe()
+		if err != nil && err != http.ErrServerClosed {
+			t.Errorf("error listening the interface: error %v", err)
+		}
+	}()
+	time.Sleep(time.Millisecond * 500)
+
+	form := url.Values{}
+
+	form.Add("key", "value")
+	form.Add("name[]", "name1")
+	form.Add("name[]", "name2")
+	form.Add("name[]", "name3")
+	form.Add("arr[x][y][z]", "y")
+	form.Add("arr[x][y][e]", "f")
+	form.Add("arr[c]p", "l")
+	form.Add("arr[c]z", "")
+
+	req, err := http.NewRequest("PUT", "http://localhost"+hs.Addr, strings.NewReader(form.Encode()))
+	assert.NoError(t, err)
+
+	req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
+
+	r, err := http.DefaultClient.Do(req)
+	assert.NoError(t, err)
+	defer func() {
+		err := r.Body.Close()
+		if err != nil {
+			t.Errorf("error during the closing Body: error %v", err)
+		}
+	}()
+
+	b, err := ioutil.ReadAll(r.Body)
+	assert.NoError(t, err)
+
+	assert.NoError(t, err)
+	assert.Equal(t, 200, r.StatusCode)
+
+	assert.Equal(t, `{"arr":{"c":{"p":"l","z":""},"x":{"y":{"e":"f","z":"y"}}},"key":"value","name":["name1","name2","name3"]}`, string(b))
+}
+
+func TestHandler_FormData_PATCH(t *testing.T) {
+	p, err := pool.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "data", "pipes") },
+		pipe.NewPipeFactory(),
+		pool.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		p.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, config.Uploads{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, p)
+	assert.NoError(t, err)
+
+	hs := &http.Server{Addr: ":8085", Handler: h}
+	defer func() {
+		err := hs.Shutdown(context.Background())
+		if err != nil {
+			t.Errorf("error during the shutdown: error %v", err)
+		}
+	}()
+
+	go func() {
+		err := hs.ListenAndServe()
+		if err != nil && err != http.ErrServerClosed {
+			t.Errorf("error listening the interface: error %v", err)
+		}
+	}()
+	time.Sleep(time.Millisecond * 10)
+
+	form := url.Values{}
+
+	form.Add("key", "value")
+	form.Add("name[]", "name1")
+	form.Add("name[]", "name2")
+	form.Add("name[]", "name3")
+	form.Add("arr[x][y][z]", "y")
+	form.Add("arr[x][y][e]", "f")
+	form.Add("arr[c]p", "l")
+	form.Add("arr[c]z", "")
+
+	req, err := http.NewRequest("PATCH", "http://localhost"+hs.Addr, strings.NewReader(form.Encode()))
+	assert.NoError(t, err)
+
+	req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
+
+	r, err := http.DefaultClient.Do(req)
+	assert.NoError(t, err)
+	defer func() {
+		err := r.Body.Close()
+		if err != nil {
+			t.Errorf("error during the closing Body: error %v", err)
+		}
+	}()
+
+	b, err := ioutil.ReadAll(r.Body)
+	assert.NoError(t, err)
+
+	assert.NoError(t, err)
+	assert.Equal(t, 200, r.StatusCode)
+
+	assert.Equal(t, "{\"arr\":{\"c\":{\"p\":\"l\",\"z\":\"\"},\"x\":{\"y\":{\"e\":\"f\",\"z\":\"y\"}}},\"key\":\"value\",\"name\":[\"name1\",\"name2\",\"name3\"]}", string(b))
+}
+
+func TestHandler_Multipart_POST(t *testing.T) {
+	p, err := pool.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "data", "pipes") },
+		pipe.NewPipeFactory(),
+		pool.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		p.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, config.Uploads{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, p)
+	assert.NoError(t, err)
+
+	hs := &http.Server{Addr: ":8019", Handler: h}
+	defer func() {
+		err := hs.Shutdown(context.Background())
+		if err != nil {
+			t.Errorf("error during the shutdown: error %v", err)
+		}
+	}()
+
+	go func() {
+		err := hs.ListenAndServe()
+		if err != nil && err != http.ErrServerClosed {
+			t.Errorf("error listening the interface: error %v", err)
+		}
+	}()
+	time.Sleep(time.Millisecond * 10)
+
+	var mb bytes.Buffer
+	w := multipart.NewWriter(&mb)
+	err = w.WriteField("key", "value")
+	if err != nil {
+		t.Errorf("error writing the field: error %v", err)
+	}
+
+	err = w.WriteField("key", "value")
+	if err != nil {
+		t.Errorf("error writing the field: error %v", err)
+	}
+
+	err = w.WriteField("name[]", "name1")
+	if err != nil {
+		t.Errorf("error writing the field: error %v", err)
+	}
+
+	err = w.WriteField("name[]", "name2")
+	if err != nil {
+		t.Errorf("error writing the field: error %v", err)
+	}
+
+	err = w.WriteField("name[]", "name3")
+	if err != nil {
+		t.Errorf("error writing the field: error %v", err)
+	}
+
+	err = w.WriteField("arr[x][y][z]", "y")
+	if err != nil {
+		t.Errorf("error writing the field: error %v", err)
+	}
+
+	err = w.WriteField("arr[x][y][e]", "f")
+
+	if err != nil {
+		t.Errorf("error writing the field: error %v", err)
+	}
+
+	err = w.WriteField("arr[c]p", "l")
+	if err != nil {
+		t.Errorf("error writing the field: error %v", err)
+	}
+
+	err = w.WriteField("arr[c]z", "")
+	if err != nil {
+		t.Errorf("error writing the field: error %v", err)
+	}
+
+	err = w.Close()
+	if err != nil {
+		t.Errorf("error closing the writer: error %v", err)
+	}
+
+	req, err := http.NewRequest("POST", "http://localhost"+hs.Addr, &mb)
+	assert.NoError(t, err)
+
+	req.Header.Set("Content-Type", w.FormDataContentType())
+
+	r, err := http.DefaultClient.Do(req)
+	assert.NoError(t, err)
+	defer func() {
+		err := r.Body.Close()
+		if err != nil {
+			t.Errorf("error during the closing Body: error %v", err)
+		}
+	}()
+
+	b, err := ioutil.ReadAll(r.Body)
+	assert.NoError(t, err)
+
+	assert.NoError(t, err)
+	assert.Equal(t, 200, r.StatusCode)
+
+	assert.Equal(t, "{\"arr\":{\"c\":{\"p\":\"l\",\"z\":\"\"},\"x\":{\"y\":{\"e\":\"f\",\"z\":\"y\"}}},\"key\":\"value\",\"name\":[\"name1\",\"name2\",\"name3\"]}", string(b))
+}
+
+func TestHandler_Multipart_PUT(t *testing.T) {
+	p, err := pool.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "data", "pipes") },
+		pipe.NewPipeFactory(),
+		pool.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		p.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, config.Uploads{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, p)
+	assert.NoError(t, err)
+
+	hs := &http.Server{Addr: ":8020", Handler: h}
+	defer func() {
+		err := hs.Shutdown(context.Background())
+		if err != nil {
+			t.Errorf("error during the shutdown: error %v", err)
+		}
+	}()
+
+	go func() {
+		err := hs.ListenAndServe()
+		if err != nil && err != http.ErrServerClosed {
+			t.Errorf("error listening the interface: error %v", err)
+		}
+	}()
+	time.Sleep(time.Millisecond * 500)
+
+	var mb bytes.Buffer
+	w := multipart.NewWriter(&mb)
+	err = w.WriteField("key", "value")
+	if err != nil {
+		t.Errorf("error writing the field: error %v", err)
+	}
+
+	err = w.WriteField("key", "value")
+	if err != nil {
+		t.Errorf("error writing the field: error %v", err)
+	}
+
+	err = w.WriteField("name[]", "name1")
+
+	if err != nil {
+		t.Errorf("error writing the field: error %v", err)
+	}
+
+	err = w.WriteField("name[]", "name2")
+	if err != nil {
+		t.Errorf("error writing the field: error %v", err)
+	}
+
+	err = w.WriteField("name[]", "name3")
+	if err != nil {
+		t.Errorf("error writing the field: error %v", err)
+	}
+
+	err = w.WriteField("arr[x][y][z]", "y")
+	if err != nil {
+		t.Errorf("error writing the field: error %v", err)
+	}
+
+	err = w.WriteField("arr[x][y][e]", "f")
+	if err != nil {
+		t.Errorf("error writing the field: error %v", err)
+	}
+
+	err = w.WriteField("arr[c]p", "l")
+	if err != nil {
+		t.Errorf("error writing the field: error %v", err)
+	}
+
+	err = w.WriteField("arr[c]z", "")
+	if err != nil {
+		t.Errorf("error writing the field: error %v", err)
+	}
+
+	err = w.Close()
+	if err != nil {
+		t.Errorf("error closing the writer: error %v", err)
+	}
+
+	req, err := http.NewRequest("PUT", "http://localhost"+hs.Addr, &mb)
+	assert.NoError(t, err)
+
+	req.Header.Set("Content-Type", w.FormDataContentType())
+
+	r, err := http.DefaultClient.Do(req)
+	assert.NoError(t, err)
+	defer func() {
+		err := r.Body.Close()
+		if err != nil {
+			t.Errorf("error during the closing Body: error %v", err)
+		}
+	}()
+
+	b, err := ioutil.ReadAll(r.Body)
+	assert.NoError(t, err)
+
+	assert.NoError(t, err)
+	assert.Equal(t, 200, r.StatusCode)
+
+	assert.Equal(t, `{"arr":{"c":{"p":"l","z":""},"x":{"y":{"e":"f","z":"y"}}},"key":"value","name":["name1","name2","name3"]}`, string(b))
+}
+
+func TestHandler_Multipart_PATCH(t *testing.T) {
+	p, err := pool.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "data", "pipes") },
+		pipe.NewPipeFactory(),
+		pool.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		p.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, config.Uploads{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, p)
+	assert.NoError(t, err)
+
+	hs := &http.Server{Addr: ":8021", Handler: h}
+	defer func() {
+		err := hs.Shutdown(context.Background())
+		if err != nil {
+			t.Errorf("error during the shutdown: error %v", err)
+		}
+	}()
+
+	go func() {
+		err := hs.ListenAndServe()
+
+		if err != nil && err != http.ErrServerClosed {
+			t.Errorf("error listening the interface: error %v", err)
+		}
+	}()
+	time.Sleep(time.Millisecond * 500)
+
+	var mb bytes.Buffer
+	w := multipart.NewWriter(&mb)
+	err = w.WriteField("key", "value")
+	if err != nil {
+		t.Errorf("error writing the field: error %v", err)
+	}
+
+	err = w.WriteField("key", "value")
+	if err != nil {
+		t.Errorf("error writing the field: error %v", err)
+	}
+
+	err = w.WriteField("name[]", "name1")
+	if err != nil {
+		t.Errorf("error writing the field: error %v", err)
+	}
+
+	err = w.WriteField("name[]", "name2")
+
+	if err != nil {
+		t.Errorf("error writing the field: error %v", err)
+	}
+
+	err = w.WriteField("name[]", "name3")
+
+	if err != nil {
+		t.Errorf("error writing the field: error %v", err)
+	}
+
+	err = w.WriteField("arr[x][y][z]", "y")
+	if err != nil {
+		t.Errorf("error writing the field: error %v", err)
+	}
+
+	err = w.WriteField("arr[x][y][e]", "f")
+	if err != nil {
+		t.Errorf("error writing the field: error %v", err)
+	}
+
+	err = w.WriteField("arr[c]p", "l")
+	if err != nil {
+		t.Errorf("error writing the field: error %v", err)
+	}
+
+	err = w.WriteField("arr[c]z", "")
+	if err != nil {
+		t.Errorf("error writing the field: error %v", err)
+	}
+
+	err = w.Close()
+	if err != nil {
+		t.Errorf("error closing the writer: error %v", err)
+	}
+
+	req, err := http.NewRequest("PATCH", "http://localhost"+hs.Addr, &mb)
+	assert.NoError(t, err)
+
+	req.Header.Set("Content-Type", w.FormDataContentType())
+
+	r, err := http.DefaultClient.Do(req)
+	assert.NoError(t, err)
+	defer func() {
+		err := r.Body.Close()
+		if err != nil {
+			t.Errorf("error during the closing Body: error %v", err)
+		}
+	}()
+
+	b, err := ioutil.ReadAll(r.Body)
+	assert.NoError(t, err)
+
+	assert.NoError(t, err)
+	assert.Equal(t, 200, r.StatusCode)
+
+	assert.Equal(t, `{"arr":{"c":{"p":"l","z":""},"x":{"y":{"e":"f","z":"y"}}},"key":"value","name":["name1","name2","name3"]}`, string(b))
+}
+
+func TestHandler_Error(t *testing.T) {
+	p, err := pool.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "error", "pipes") },
+		pipe.NewPipeFactory(),
+		pool.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		p.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, config.Uploads{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, p)
+	assert.NoError(t, err)
+
+	hs := &http.Server{Addr: ":8177", Handler: h}
+	defer func() {
+		err := hs.Shutdown(context.Background())
+		if err != nil {
+			t.Errorf("error during the shutdown: error %v", err)
+		}
+	}()
+
+	go func() {
+		err := hs.ListenAndServe()
+		if err != nil && err != http.ErrServerClosed {
+			t.Errorf("error listening the interface: error %v", err)
+		}
+	}()
+	time.Sleep(time.Millisecond * 10)
+
+	_, r, err := get("http://localhost:8177/?hello=world")
+	assert.NoError(t, err)
+	defer func() {
+		_ = r.Body.Close()
+	}()
+	assert.Equal(t, 500, r.StatusCode)
+}
+
+func TestHandler_Error2(t *testing.T) {
+	p, err := pool.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "error2", "pipes") },
+		pipe.NewPipeFactory(),
+		pool.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		p.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, config.Uploads{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, p)
+	assert.NoError(t, err)
+
+	hs := &http.Server{Addr: ":8177", Handler: h}
+	defer func() {
+		err := hs.Shutdown(context.Background())
+		if err != nil {
+			t.Errorf("error during the shutdown: error %v", err)
+		}
+	}()
+
+	go func() {
+		err := hs.ListenAndServe()
+		if err != nil && err != http.ErrServerClosed {
+			t.Errorf("error listening the interface: error %v", err)
+		}
+	}()
+	time.Sleep(time.Millisecond * 10)
+
+	_, r, err := get("http://localhost:8177/?hello=world")
+	assert.NoError(t, err)
+	defer func() {
+		_ = r.Body.Close()
+	}()
+	assert.Equal(t, 500, r.StatusCode)
+}
+
+func TestHandler_Error3(t *testing.T) {
+	p, err := pool.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "pid", "pipes") },
+		pipe.NewPipeFactory(),
+		pool.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		p.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1, config.Uploads{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, p)
+	assert.NoError(t, err)
+
+	hs := &http.Server{Addr: ":8177", Handler: h}
+	defer func() {
+		err := hs.Shutdown(context.Background())
+		if err != nil {
+			t.Errorf("error during the shutdown: error %v", err)
+		}
+	}()
+
+	go func() {
+		err = hs.ListenAndServe()
+		if err != nil && err != http.ErrServerClosed {
+			t.Errorf("error listening the interface: error %v", err)
+		}
+	}()
+	time.Sleep(time.Millisecond * 10)
+
+	b2 := &bytes.Buffer{}
+	for i := 0; i < 1024*1024; i++ {
+		b2.Write([]byte("  "))
+	}
+
+	req, err := http.NewRequest("POST", "http://localhost"+hs.Addr, b2)
+	assert.NoError(t, err)
+
+	r, err := http.DefaultClient.Do(req)
+	assert.NoError(t, err)
+	defer func() {
+		err = r.Body.Close()
+		if err != nil {
+			t.Errorf("error during the closing Body: error %v", err)
+		}
+	}()
+
+	assert.NoError(t, err)
+	assert.Equal(t, 500, r.StatusCode)
+}
+
+func TestHandler_ResponseDuration(t *testing.T) {
+	p, err := pool.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "echo", "pipes") },
+		pipe.NewPipeFactory(),
+		pool.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		p.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, config.Uploads{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, p)
+	assert.NoError(t, err)
+
+	hs := &http.Server{Addr: ":8177", Handler: h}
+	defer func() {
+		err := hs.Shutdown(context.Background())
+		if err != nil {
+			t.Errorf("error during the shutdown: error %v", err)
+		}
+	}()
+
+	go func() {
+		err := hs.ListenAndServe()
+		if err != nil && err != http.ErrServerClosed {
+			t.Errorf("error listening the interface: error %v", err)
+		}
+	}()
+	time.Sleep(time.Millisecond * 10)
+
+	gotresp := make(chan interface{})
+	h.AddListener(func(event interface{}) {
+		switch t := event.(type) {
+		case httpPlugin.ResponseEvent:
+			if t.Elapsed() > 0 {
+				close(gotresp)
+			}
+		default:
+		}
+	})
+
+	body, r, err := get("http://localhost:8177/?hello=world")
+	assert.NoError(t, err)
+	defer func() {
+		_ = r.Body.Close()
+	}()
+
+	<-gotresp
+
+	assert.Equal(t, 201, r.StatusCode)
+	assert.Equal(t, "WORLD", body)
+}
+
+func TestHandler_ResponseDurationDelayed(t *testing.T) {
+	p, err := pool.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "echoDelay", "pipes") },
+		pipe.NewPipeFactory(),
+		pool.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		p.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, config.Uploads{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, p)
+	assert.NoError(t, err)
+
+	hs := &http.Server{Addr: ":8177", Handler: h}
+	defer func() {
+		err := hs.Shutdown(context.Background())
+		if err != nil {
+			t.Errorf("error during the shutdown: error %v", err)
+		}
+	}()
+
+	go func() {
+		err := hs.ListenAndServe()
+		if err != nil && err != http.ErrServerClosed {
+			t.Errorf("error listening the interface: error %v", err)
+		}
+	}()
+	time.Sleep(time.Millisecond * 10)
+
+	gotresp := make(chan interface{})
+	h.AddListener(func(event interface{}) {
+		switch tp := event.(type) {
+		case httpPlugin.ResponseEvent:
+			if tp.Elapsed() > time.Second {
+				close(gotresp)
+			}
+		default:
+		}
+	})
+
+	body, r, err := get("http://localhost:8177/?hello=world")
+	assert.NoError(t, err)
+	defer func() {
+		_ = r.Body.Close()
+	}()
+	<-gotresp
+
+	assert.Equal(t, 201, r.StatusCode)
+	assert.Equal(t, "WORLD", body)
+}
+
+func TestHandler_ErrorDuration(t *testing.T) {
+	p, err := pool.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "error", "pipes") },
+		pipe.NewPipeFactory(),
+		pool.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		p.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, config.Uploads{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, p)
+	assert.NoError(t, err)
+
+	hs := &http.Server{Addr: ":8177", Handler: h}
+	defer func() {
+		err := hs.Shutdown(context.Background())
+		if err != nil {
+			t.Errorf("error during the shutdown: error %v", err)
+		}
+	}()
+
+	go func() {
+		err = hs.ListenAndServe()
+		if err != nil && err != http.ErrServerClosed {
+			t.Errorf("error listening the interface: error %v", err)
+		}
+	}()
+	time.Sleep(time.Millisecond * 10)
+
+	goterr := make(chan interface{})
+	h.AddListener(func(event interface{}) {
+		switch tp := event.(type) {
+		case httpPlugin.ErrorEvent:
+			if tp.Elapsed() > 0 {
+				close(goterr)
+			}
+		default:
+		}
+	})
+
+	_, r, err := get("http://localhost:8177/?hello=world")
+	assert.NoError(t, err)
+	defer func() {
+		_ = r.Body.Close()
+	}()
+
+	<-goterr
+
+	assert.Equal(t, 500, r.StatusCode)
+}
+
+func TestHandler_IP(t *testing.T) {
+	trusted := []string{
+		"10.0.0.0/8",
+		"127.0.0.0/8",
+		"172.16.0.0/12",
+		"192.168.0.0/16",
+		"::1/128",
+		"fc00::/7",
+		"fe80::/10",
+	}
+
+	cidrs, err := config.ParseCIDRs(trusted)
+	assert.NoError(t, err)
+	assert.NotNil(t, cidrs)
+
+	p, err := pool.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "ip", "pipes") },
+		pipe.NewPipeFactory(),
+		pool.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		p.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, config.Uploads{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, cidrs, p)
+	assert.NoError(t, err)
+
+	hs := &http.Server{Addr: "127.0.0.1:8177", Handler: h}
+	defer func() {
+		err := hs.Shutdown(context.Background())
+		if err != nil {
+			t.Errorf("error during the shutdown: error %v", err)
+		}
+	}()
+
+	go func() {
+		err := hs.ListenAndServe()
+		if err != nil && err != http.ErrServerClosed {
+			t.Errorf("error listening the interface: error %v", err)
+		}
+	}()
+	time.Sleep(time.Millisecond * 10)
+
+	body, r, err := get("http://127.0.0.1:8177/")
+	assert.NoError(t, err)
+	defer func() {
+		_ = r.Body.Close()
+	}()
+	assert.Equal(t, 200, r.StatusCode)
+	assert.Equal(t, "127.0.0.1", body)
+}
+
+func TestHandler_XRealIP(t *testing.T) {
+	trusted := []string{
+		"10.0.0.0/8",
+		"127.0.0.0/8",
+		"172.16.0.0/12",
+		"192.168.0.0/16",
+		"::1/128",
+		"fc00::/7",
+		"fe80::/10",
+	}
+
+	cidrs, err := config.ParseCIDRs(trusted)
+	assert.NoError(t, err)
+	assert.NotNil(t, cidrs)
+
+	p, err := pool.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "ip", "pipes") },
+		pipe.NewPipeFactory(),
+		pool.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		p.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, config.Uploads{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, cidrs, p)
+	assert.NoError(t, err)
+
+	hs := &http.Server{Addr: "127.0.0.1:8179", Handler: h}
+	defer func() {
+		err := hs.Shutdown(context.Background())
+		if err != nil {
+			t.Errorf("error during the shutdown: error %v", err)
+		}
+	}()
+
+	go func() {
+		err := hs.ListenAndServe()
+		if err != nil && err != http.ErrServerClosed {
+			t.Errorf("error listening the interface: error %v", err)
+		}
+	}()
+	time.Sleep(time.Millisecond * 10)
+
+	body, r, err := getHeader("http://127.0.0.1:8179/", map[string]string{
+		"X-Real-Ip": "200.0.0.1",
+	})
+
+	assert.NoError(t, err)
+	defer func() {
+		_ = r.Body.Close()
+	}()
+	assert.Equal(t, 200, r.StatusCode)
+	assert.Equal(t, "200.0.0.1", body)
+}
+
+func TestHandler_XForwardedFor(t *testing.T) {
+	trusted := []string{
+		"10.0.0.0/8",
+		"127.0.0.0/8",
+		"172.16.0.0/12",
+		"192.168.0.0/16",
+		"100.0.0.0/16",
+		"200.0.0.0/16",
+		"::1/128",
+		"fc00::/7",
+		"fe80::/10",
+	}
+
+	cidrs, err := config.ParseCIDRs(trusted)
+	assert.NoError(t, err)
+	assert.NotNil(t, cidrs)
+
+	p, err := pool.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "ip", "pipes") },
+		pipe.NewPipeFactory(),
+		pool.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		p.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, config.Uploads{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, cidrs, p)
+	assert.NoError(t, err)
+
+	hs := &http.Server{Addr: "127.0.0.1:8177", Handler: h}
+	defer func() {
+		err := hs.Shutdown(context.Background())
+		if err != nil {
+			t.Errorf("error during the shutdown: error %v", err)
+		}
+	}()
+
+	go func() {
+		err := hs.ListenAndServe()
+		if err != nil && err != http.ErrServerClosed {
+			t.Errorf("error listening the interface: error %v", err)
+		}
+	}()
+	time.Sleep(time.Millisecond * 10)
+
+	body, r, err := getHeader("http://127.0.0.1:8177/", map[string]string{
+		"X-Forwarded-For": "100.0.0.1, 200.0.0.1, invalid, 101.0.0.1",
+	})
+
+	assert.NoError(t, err)
+	assert.Equal(t, 200, r.StatusCode)
+	assert.Equal(t, "101.0.0.1", body)
+	_ = r.Body.Close()
+
+	body, r, err = getHeader("http://127.0.0.1:8177/", map[string]string{
+		"X-Forwarded-For": "100.0.0.1, 200.0.0.1, 101.0.0.1, invalid",
+	})
+
+	assert.NoError(t, err)
+	_ = r.Body.Close()
+	assert.Equal(t, 200, r.StatusCode)
+	assert.Equal(t, "101.0.0.1", body)
+}
+
+func TestHandler_XForwardedFor_NotTrustedRemoteIp(t *testing.T) {
+	trusted := []string{
+		"10.0.0.0/8",
+	}
+
+	cidrs, err := config.ParseCIDRs(trusted)
+	assert.NoError(t, err)
+	assert.NotNil(t, cidrs)
+
+	p, err := pool.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "ip", "pipes") },
+		pipe.NewPipeFactory(),
+		pool.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		p.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, config.Uploads{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, cidrs, p)
+	assert.NoError(t, err)
+
+	hs := &http.Server{Addr: "127.0.0.1:8177", Handler: h}
+	defer func() {
+		err := hs.Shutdown(context.Background())
+		if err != nil {
+			t.Errorf("error during the shutdown: error %v", err)
+		}
+	}()
+
+	go func() {
+		err := hs.ListenAndServe()
+		if err != nil && err != http.ErrServerClosed {
+			t.Errorf("error listening the interface: error %v", err)
+		}
+	}()
+	time.Sleep(time.Millisecond * 10)
+
+	body, r, err := getHeader("http://127.0.0.1:8177/", map[string]string{
+		"X-Forwarded-For": "100.0.0.1, 200.0.0.1, invalid, 101.0.0.1",
+	})
+
+	assert.NoError(t, err)
+	_ = r.Body.Close()
+	assert.Equal(t, 200, r.StatusCode)
+	assert.Equal(t, "127.0.0.1", body)
+}
+
+func BenchmarkHandler_Listen_Echo(b *testing.B) {
+	p, err := pool.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "echo", "pipes") },
+		pipe.NewPipeFactory(),
+		pool.Config{
+			NumWorkers:      uint64(runtime.NumCPU()),
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		b.Fatal(err)
+	}
+	defer func() {
+		p.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, config.Uploads{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, p)
+	assert.NoError(b, err)
+
+	hs := &http.Server{Addr: ":8177", Handler: h}
+	defer func() {
+		err := hs.Shutdown(context.Background())
+		if err != nil {
+			b.Errorf("error during the shutdown: error %v", err)
+		}
+	}()
+
+	go func() {
+		err = hs.ListenAndServe()
+		if err != nil && err != http.ErrServerClosed {
+			b.Errorf("error listening the interface: error %v", err)
+		}
+	}()
+	time.Sleep(time.Millisecond * 10)
+
+	b.ResetTimer()
+	b.ReportAllocs()
+	bb := "WORLD"
+	for n := 0; n < b.N; n++ {
+		r, err := http.Get("http://localhost:8177/?hello=world")
+		if err != nil {
+			b.Fail()
+		}
+		// Response might be nil here
+		if r != nil {
+			br, err := ioutil.ReadAll(r.Body)
+			if err != nil {
+				b.Errorf("error reading Body: error %v", err)
+			}
+			if string(br) != bb {
+				b.Fail()
+			}
+			err = r.Body.Close()
+			if err != nil {
+				b.Errorf("error closing the Body: error %v", err)
+			}
+		} else {
+			b.Errorf("got nil response")
+		}
+	}
+}
diff --git a/tests/plugins/http/http_plugin_test.go b/tests/plugins/http/http_plugin_test.go
new file mode 100644
index 00000000..4f99dbbb
--- /dev/null
+++ b/tests/plugins/http/http_plugin_test.go
@@ -0,0 +1,1430 @@
+package http
+
+import (
+	"bytes"
+	"crypto/tls"
+	"fmt"
+	"io/ioutil"
+	"net"
+	"net/http"
+	"net/http/httptest"
+	"net/rpc"
+	"os"
+	"os/signal"
+	"sync"
+	"syscall"
+	"testing"
+	"time"
+
+	"github.com/golang/mock/gomock"
+	endure "github.com/spiral/endure/pkg/container"
+	goridgeRpc "github.com/spiral/goridge/v3/pkg/rpc"
+	"github.com/spiral/roadrunner/v2/pkg/events"
+	"github.com/spiral/roadrunner/v2/plugins/config"
+	"github.com/spiral/roadrunner/v2/plugins/informer"
+	"github.com/spiral/roadrunner/v2/plugins/logger"
+	"github.com/spiral/roadrunner/v2/plugins/resetter"
+	"github.com/spiral/roadrunner/v2/plugins/server"
+	"github.com/spiral/roadrunner/v2/tests/mocks"
+	"github.com/spiral/roadrunner/v2/tools"
+	"github.com/yookoala/gofast"
+
+	httpPlugin "github.com/spiral/roadrunner/v2/plugins/http"
+	rpcPlugin "github.com/spiral/roadrunner/v2/plugins/rpc"
+	"github.com/stretchr/testify/assert"
+)
+
+var sslClient = &http.Client{
+	Transport: &http.Transport{
+		TLSClientConfig: &tls.Config{
+			InsecureSkipVerify: true, //nolint:gosec
+		},
+	},
+}
+
+func TestHTTPInit(t *testing.T) {
+	cont, err := endure.NewContainer(nil, endure.SetLogLevel(endure.ErrorLevel))
+	assert.NoError(t, err)
+
+	rIn := makeConfig("6001", "15395", "7921", ":8892", "false", "false", "php ../../http/client.php echo pipes")
+	cfg := &config.Viper{
+		ReadInCfg: rIn,
+		Type:      "yaml",
+	}
+
+	err = cont.RegisterAll(
+		cfg,
+		&logger.ZapLogger{},
+		&server.Plugin{},
+		&httpPlugin.Plugin{},
+	)
+	assert.NoError(t, err)
+
+	err = cont.Init()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ch, err := cont.Serve()
+	assert.NoError(t, err)
+
+	sig := make(chan os.Signal, 1)
+	signal.Notify(sig, os.Interrupt, syscall.SIGINT, syscall.SIGTERM)
+
+	wg := &sync.WaitGroup{}
+	wg.Add(1)
+
+	stopCh := make(chan struct{}, 1)
+
+	go func() {
+		defer wg.Done()
+		for {
+			select {
+			case e := <-ch:
+				assert.Fail(t, "error", e.Error.Error())
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+			case <-sig:
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+				return
+			case <-stopCh:
+				// timeout
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+				return
+			}
+		}
+	}()
+
+	stopCh <- struct{}{}
+	wg.Wait()
+}
+
+func TestHTTPNoConfigSection(t *testing.T) {
+	cont, err := endure.NewContainer(nil, endure.SetLogLevel(endure.ErrorLevel))
+	assert.NoError(t, err)
+
+	cfg := &config.Viper{
+		Path:   "configs/.rr-no-http.yaml",
+		Prefix: "rr",
+	}
+
+	err = cont.RegisterAll(
+		cfg,
+		&logger.ZapLogger{},
+		&server.Plugin{},
+		&httpPlugin.Plugin{},
+	)
+	assert.NoError(t, err)
+
+	err = cont.Init()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ch, err := cont.Serve()
+	assert.NoError(t, err)
+
+	sig := make(chan os.Signal, 1)
+	signal.Notify(sig, os.Interrupt, syscall.SIGINT, syscall.SIGTERM)
+
+	wg := &sync.WaitGroup{}
+	wg.Add(1)
+
+	stopCh := make(chan struct{}, 1)
+	go func() {
+		defer wg.Done()
+		for {
+			select {
+			case e := <-ch:
+				assert.Fail(t, "error", e.Error.Error())
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+			case <-sig:
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+				return
+			case <-stopCh:
+				// timeout
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+				return
+			}
+		}
+	}()
+
+	time.Sleep(time.Second * 2)
+	stopCh <- struct{}{}
+	wg.Wait()
+}
+
+func TestHTTPInformerReset(t *testing.T) {
+	cont, err := endure.NewContainer(nil, endure.SetLogLevel(endure.ErrorLevel))
+	assert.NoError(t, err)
+
+	cfg := &config.Viper{
+		Path:   "configs/.rr-resetter.yaml",
+		Prefix: "rr",
+	}
+
+	err = cont.RegisterAll(
+		cfg,
+		&rpcPlugin.Plugin{},
+		&logger.ZapLogger{},
+		&server.Plugin{},
+		&httpPlugin.Plugin{},
+		&informer.Plugin{},
+		&resetter.Plugin{},
+	)
+	assert.NoError(t, err)
+
+	err = cont.Init()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ch, err := cont.Serve()
+	assert.NoError(t, err)
+
+	sig := make(chan os.Signal, 1)
+	signal.Notify(sig, os.Interrupt, syscall.SIGINT, syscall.SIGTERM)
+
+	wg := &sync.WaitGroup{}
+	wg.Add(1)
+
+	stopCh := make(chan struct{}, 1)
+
+	go func() {
+		defer wg.Done()
+		for {
+			select {
+			case e := <-ch:
+				assert.Fail(t, "error", e.Error.Error())
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+			case <-sig:
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+				return
+			case <-stopCh:
+				// timeout
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+				return
+			}
+		}
+	}()
+
+	time.Sleep(time.Second * 1)
+	t.Run("HTTPInformerTest", informerTest)
+	t.Run("HTTPEchoTestBefore", echoHTTP)
+	t.Run("HTTPResetTest", resetTest)
+	t.Run("HTTPEchoTestAfter", echoHTTP)
+
+	stopCh <- struct{}{}
+
+	wg.Wait()
+}
+
+func echoHTTP(t *testing.T) {
+	req, err := http.NewRequest("GET", "http://localhost:10084?hello=world", nil)
+	assert.NoError(t, err)
+
+	r, err := http.DefaultClient.Do(req)
+	assert.NoError(t, err)
+	b, err := ioutil.ReadAll(r.Body)
+	assert.NoError(t, err)
+	assert.Equal(t, 201, r.StatusCode)
+	assert.Equal(t, "WORLD", string(b))
+
+	err = r.Body.Close()
+	assert.NoError(t, err)
+}
+
+func resetTest(t *testing.T) {
+	conn, err := net.Dial("tcp", "127.0.0.1:6001")
+	assert.NoError(t, err)
+	client := rpc.NewClientWithCodec(goridgeRpc.NewClientCodec(conn))
+	// WorkerList contains list of workers.
+
+	var ret bool
+	err = client.Call("resetter.Reset", "http", &ret)
+	assert.NoError(t, err)
+	assert.True(t, ret)
+	ret = false
+
+	var services []string
+	err = client.Call("resetter.List", nil, &services)
+	assert.NoError(t, err)
+	if services[0] != "http" {
+		t.Fatal("no enough services")
+	}
+}
+
+func informerTest(t *testing.T) {
+	conn, err := net.Dial("tcp", "127.0.0.1:6001")
+	assert.NoError(t, err)
+	client := rpc.NewClientWithCodec(goridgeRpc.NewClientCodec(conn))
+	// WorkerList contains list of workers.
+	list := struct {
+		// Workers is list of workers.
+		Workers []tools.ProcessState `json:"workers"`
+	}{}
+
+	err = client.Call("informer.Workers", "http", &list)
+	assert.NoError(t, err)
+	assert.Len(t, list.Workers, 2)
+}
+
+func TestSSL(t *testing.T) {
+	cont, err := endure.NewContainer(nil, endure.SetLogLevel(endure.ErrorLevel))
+	assert.NoError(t, err)
+
+	cfg := &config.Viper{
+		Path:   "configs/.rr-ssl.yaml",
+		Prefix: "rr",
+	}
+
+	err = cont.RegisterAll(
+		cfg,
+		&rpcPlugin.Plugin{},
+		&logger.ZapLogger{},
+		&server.Plugin{},
+		&httpPlugin.Plugin{},
+	)
+	assert.NoError(t, err)
+
+	err = cont.Init()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ch, err := cont.Serve()
+	assert.NoError(t, err)
+
+	sig := make(chan os.Signal, 1)
+	signal.Notify(sig, os.Interrupt, syscall.SIGINT, syscall.SIGTERM)
+
+	wg := &sync.WaitGroup{}
+	wg.Add(1)
+
+	stopCh := make(chan struct{}, 1)
+
+	go func() {
+		defer wg.Done()
+		for {
+			select {
+			case e := <-ch:
+				assert.Fail(t, "error", e.Error.Error())
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+			case <-sig:
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+				return
+			case <-stopCh:
+				// timeout
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+				return
+			}
+		}
+	}()
+
+	time.Sleep(time.Second * 1)
+	t.Run("SSLEcho", sslEcho)
+	t.Run("SSLNoRedirect", sslNoRedirect)
+	t.Run("fCGIecho", fcgiEcho)
+
+	stopCh <- struct{}{}
+	wg.Wait()
+}
+
+func sslNoRedirect(t *testing.T) {
+	req, err := http.NewRequest("GET", "http://localhost:8085?hello=world", nil)
+	assert.NoError(t, err)
+
+	r, err := sslClient.Do(req)
+	assert.NoError(t, err)
+
+	assert.Nil(t, r.TLS)
+
+	b, err := ioutil.ReadAll(r.Body)
+	assert.NoError(t, err)
+
+	assert.NoError(t, err)
+	assert.Equal(t, 201, r.StatusCode)
+	assert.Equal(t, "WORLD", string(b))
+
+	err2 := r.Body.Close()
+	if err2 != nil {
+		t.Errorf("fail to close the Body: error %v", err2)
+	}
+}
+
+func sslEcho(t *testing.T) {
+	req, err := http.NewRequest("GET", "https://localhost:8893?hello=world", nil)
+	assert.NoError(t, err)
+
+	r, err := sslClient.Do(req)
+	assert.NoError(t, err)
+
+	b, err := ioutil.ReadAll(r.Body)
+	assert.NoError(t, err)
+
+	assert.NoError(t, err)
+	assert.Equal(t, 201, r.StatusCode)
+	assert.Equal(t, "WORLD", string(b))
+
+	err2 := r.Body.Close()
+	if err2 != nil {
+		t.Errorf("fail to close the Body: error %v", err2)
+	}
+}
+
+func fcgiEcho(t *testing.T) {
+	fcgiConnFactory := gofast.SimpleConnFactory("tcp", "0.0.0.0:16920")
+
+	fcgiHandler := gofast.NewHandler(
+		gofast.BasicParamsMap(gofast.BasicSession),
+		gofast.SimpleClientFactory(fcgiConnFactory, 0),
+	)
+
+	w := httptest.NewRecorder()
+	req := httptest.NewRequest("GET", "http://site.local/?hello=world", nil)
+	fcgiHandler.ServeHTTP(w, req)
+
+	body, err := ioutil.ReadAll(w.Result().Body) //nolint:bodyclose
+
+	defer func() {
+		_ = w.Result().Body.Close()
+		w.Body.Reset()
+	}()
+
+	assert.NoError(t, err)
+	assert.Equal(t, 201, w.Result().StatusCode) //nolint:bodyclose
+	assert.Equal(t, "WORLD", string(body))
+}
+
+func TestSSLRedirect(t *testing.T) {
+	cont, err := endure.NewContainer(nil, endure.SetLogLevel(endure.ErrorLevel))
+	assert.NoError(t, err)
+
+	cfg := &config.Viper{
+		Path:   "configs/.rr-ssl-redirect.yaml",
+		Prefix: "rr",
+	}
+
+	err = cont.RegisterAll(
+		cfg,
+		&rpcPlugin.Plugin{},
+		&logger.ZapLogger{},
+		&server.Plugin{},
+		&httpPlugin.Plugin{},
+	)
+	assert.NoError(t, err)
+
+	err = cont.Init()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ch, err := cont.Serve()
+	assert.NoError(t, err)
+
+	sig := make(chan os.Signal, 1)
+	signal.Notify(sig, os.Interrupt, syscall.SIGINT, syscall.SIGTERM)
+
+	wg := &sync.WaitGroup{}
+	wg.Add(1)
+
+	stopCh := make(chan struct{}, 1)
+
+	go func() {
+		defer wg.Done()
+		for {
+			select {
+			case e := <-ch:
+				assert.Fail(t, "error", e.Error.Error())
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+			case <-sig:
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+				return
+			case <-stopCh:
+				// timeout
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+				return
+			}
+		}
+	}()
+
+	time.Sleep(time.Second * 1)
+	t.Run("SSLRedirect", sslRedirect)
+
+	stopCh <- struct{}{}
+	wg.Wait()
+}
+
+func sslRedirect(t *testing.T) {
+	req, err := http.NewRequest("GET", "http://localhost:8087?hello=world", nil)
+	assert.NoError(t, err)
+
+	r, err := sslClient.Do(req)
+	assert.NoError(t, err)
+	assert.NotNil(t, r.TLS)
+
+	b, err := ioutil.ReadAll(r.Body)
+	assert.NoError(t, err)
+
+	assert.NoError(t, err)
+	assert.Equal(t, 201, r.StatusCode)
+	assert.Equal(t, "WORLD", string(b))
+
+	err2 := r.Body.Close()
+	if err2 != nil {
+		t.Errorf("fail to close the Body: error %v", err2)
+	}
+}
+
+func TestSSLPushPipes(t *testing.T) {
+	cont, err := endure.NewContainer(nil, endure.SetLogLevel(endure.ErrorLevel))
+	assert.NoError(t, err)
+
+	cfg := &config.Viper{
+		Path:   "configs/.rr-ssl-push.yaml",
+		Prefix: "rr",
+	}
+
+	err = cont.RegisterAll(
+		cfg,
+		&rpcPlugin.Plugin{},
+		&logger.ZapLogger{},
+		&server.Plugin{},
+		&httpPlugin.Plugin{},
+	)
+	assert.NoError(t, err)
+
+	err = cont.Init()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ch, err := cont.Serve()
+	assert.NoError(t, err)
+
+	sig := make(chan os.Signal, 1)
+	signal.Notify(sig, os.Interrupt, syscall.SIGINT, syscall.SIGTERM)
+
+	wg := &sync.WaitGroup{}
+	wg.Add(1)
+	stopCh := make(chan struct{}, 1)
+
+	go func() {
+		defer wg.Done()
+		for {
+			select {
+			case e := <-ch:
+				assert.Fail(t, "error", e.Error.Error())
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+			case <-sig:
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+				return
+			case <-stopCh:
+				// timeout
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+				return
+			}
+		}
+	}()
+
+	time.Sleep(time.Second * 1)
+	t.Run("SSLPush", sslPush)
+
+	stopCh <- struct{}{}
+	wg.Wait()
+}
+
+func sslPush(t *testing.T) {
+	req, err := http.NewRequest("GET", "https://localhost:8894?hello=world", nil)
+	assert.NoError(t, err)
+
+	r, err := sslClient.Do(req)
+	assert.NoError(t, err)
+
+	assert.NotNil(t, r.TLS)
+
+	b, err := ioutil.ReadAll(r.Body)
+	assert.NoError(t, err)
+
+	assert.Equal(t, "", r.Header.Get("Http2-Push"))
+
+	assert.NoError(t, err)
+	assert.Equal(t, 201, r.StatusCode)
+	assert.Equal(t, "WORLD", string(b))
+
+	err2 := r.Body.Close()
+	if err2 != nil {
+		t.Errorf("fail to close the Body: error %v", err2)
+	}
+}
+
+func TestFastCGI_RequestUri(t *testing.T) {
+	cont, err := endure.NewContainer(nil, endure.SetLogLevel(endure.ErrorLevel))
+	assert.NoError(t, err)
+
+	cfg := &config.Viper{
+		Path:   "configs/.rr-fcgi-reqUri.yaml",
+		Prefix: "rr",
+	}
+
+	err = cont.RegisterAll(
+		cfg,
+		&logger.ZapLogger{},
+		&server.Plugin{},
+		&httpPlugin.Plugin{},
+	)
+	assert.NoError(t, err)
+
+	err = cont.Init()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ch, err := cont.Serve()
+	assert.NoError(t, err)
+
+	sig := make(chan os.Signal, 1)
+	signal.Notify(sig, os.Interrupt, syscall.SIGINT, syscall.SIGTERM)
+
+	wg := &sync.WaitGroup{}
+	wg.Add(1)
+
+	stopCh := make(chan struct{}, 1)
+
+	go func() {
+		defer wg.Done()
+		for {
+			select {
+			case e := <-ch:
+				assert.Fail(t, "error", e.Error.Error())
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+			case <-sig:
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+				return
+			case <-stopCh:
+				// timeout
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+				return
+			}
+		}
+	}()
+
+	time.Sleep(time.Second * 1)
+	t.Run("FastCGIServiceRequestUri", fcgiReqURI)
+
+	stopCh <- struct{}{}
+	wg.Wait()
+}
+
+func fcgiReqURI(t *testing.T) {
+	time.Sleep(time.Second * 2)
+	fcgiConnFactory := gofast.SimpleConnFactory("tcp", "127.0.0.1:6921")
+
+	fcgiHandler := gofast.NewHandler(
+		gofast.BasicParamsMap(gofast.BasicSession),
+		gofast.SimpleClientFactory(fcgiConnFactory, 0),
+	)
+
+	w := httptest.NewRecorder()
+	req := httptest.NewRequest("GET", "http://site.local/hello-world", nil)
+	fcgiHandler.ServeHTTP(w, req)
+
+	body, err := ioutil.ReadAll(w.Result().Body) //nolint:bodyclose
+	assert.NoError(t, err)
+	assert.Equal(t, 200, w.Result().StatusCode) //nolint:bodyclose
+	assert.Equal(t, "http://site.local/hello-world", string(body))
+}
+
+func TestH2CUpgrade(t *testing.T) {
+	cont, err := endure.NewContainer(nil, endure.SetLogLevel(endure.ErrorLevel))
+	assert.NoError(t, err)
+
+	cfg := &config.Viper{
+		Path:   "configs/.rr-h2c.yaml",
+		Prefix: "rr",
+	}
+
+	err = cont.RegisterAll(
+		cfg,
+		&rpcPlugin.Plugin{},
+		&logger.ZapLogger{},
+		&server.Plugin{},
+		&httpPlugin.Plugin{},
+	)
+	assert.NoError(t, err)
+
+	err = cont.Init()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ch, err := cont.Serve()
+	assert.NoError(t, err)
+
+	sig := make(chan os.Signal, 1)
+	signal.Notify(sig, os.Interrupt, syscall.SIGINT, syscall.SIGTERM)
+
+	wg := &sync.WaitGroup{}
+	wg.Add(1)
+
+	stopCh := make(chan struct{}, 1)
+
+	go func() {
+		defer wg.Done()
+		for {
+			select {
+			case e := <-ch:
+				assert.Fail(t, "error", e.Error.Error())
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+			case <-sig:
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+				return
+			case <-stopCh:
+				// timeout
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+				return
+			}
+		}
+	}()
+
+	time.Sleep(time.Second * 1)
+	t.Run("H2cUpgrade", h2cUpgrade)
+
+	stopCh <- struct{}{}
+	wg.Wait()
+}
+
+func h2cUpgrade(t *testing.T) {
+	req, err := http.NewRequest("PRI", "http://localhost:8083?hello=world", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	req.Header.Add("Upgrade", "h2c")
+	req.Header.Add("Connection", "HTTP2-Settings")
+	req.Header.Add("HTTP2-Settings", "")
+
+	r, err2 := http.DefaultClient.Do(req)
+	if err2 != nil {
+		t.Fatal(err)
+	}
+
+	assert.Equal(t, "101 Switching Protocols", r.Status)
+
+	err3 := r.Body.Close()
+	if err3 != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestH2C(t *testing.T) {
+	cont, err := endure.NewContainer(nil, endure.SetLogLevel(endure.ErrorLevel))
+	assert.NoError(t, err)
+
+	cfg := &config.Viper{
+		Path:   "configs/.rr-h2c.yaml",
+		Prefix: "rr",
+	}
+
+	err = cont.RegisterAll(
+		cfg,
+		&rpcPlugin.Plugin{},
+		&logger.ZapLogger{},
+		&server.Plugin{},
+		&httpPlugin.Plugin{},
+	)
+	assert.NoError(t, err)
+
+	err = cont.Init()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ch, err := cont.Serve()
+	assert.NoError(t, err)
+
+	sig := make(chan os.Signal, 1)
+	signal.Notify(sig, os.Interrupt, syscall.SIGINT, syscall.SIGTERM)
+
+	wg := &sync.WaitGroup{}
+	wg.Add(1)
+
+	stopCh := make(chan struct{}, 1)
+
+	go func() {
+		defer wg.Done()
+		for {
+			select {
+			case e := <-ch:
+				assert.Fail(t, "error", e.Error.Error())
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+			case <-sig:
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+				return
+			case <-stopCh:
+				// timeout
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+				return
+			}
+		}
+	}()
+
+	time.Sleep(time.Second * 1)
+	t.Run("H2c", h2c)
+
+	stopCh <- struct{}{}
+	wg.Wait()
+}
+
+func h2c(t *testing.T) {
+	req, err := http.NewRequest("PRI", "http://localhost:8083?hello=world", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	req.Header.Add("Connection", "HTTP2-Settings")
+	req.Header.Add("HTTP2-Settings", "")
+
+	r, err2 := http.DefaultClient.Do(req)
+	if err2 != nil {
+		t.Fatal(err)
+	}
+
+	assert.Equal(t, "201 Created", r.Status)
+
+	err3 := r.Body.Close()
+	if err3 != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestHttpMiddleware(t *testing.T) {
+	cont, err := endure.NewContainer(nil, endure.SetLogLevel(endure.ErrorLevel))
+	assert.NoError(t, err)
+
+	cfg := &config.Viper{
+		Path:   "configs/.rr-http.yaml",
+		Prefix: "rr",
+	}
+
+	err = cont.RegisterAll(
+		cfg,
+		&rpcPlugin.Plugin{},
+		&logger.ZapLogger{},
+		&server.Plugin{},
+		&httpPlugin.Plugin{},
+		&PluginMiddleware{},
+		&PluginMiddleware2{},
+	)
+	assert.NoError(t, err)
+
+	err = cont.Init()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ch, err := cont.Serve()
+	assert.NoError(t, err)
+
+	sig := make(chan os.Signal, 1)
+	signal.Notify(sig, os.Interrupt, syscall.SIGINT, syscall.SIGTERM)
+
+	wg := &sync.WaitGroup{}
+	wg.Add(1)
+
+	stopCh := make(chan struct{}, 1)
+
+	go func() {
+		defer wg.Done()
+		for {
+			select {
+			case e := <-ch:
+				assert.Fail(t, "error", e.Error.Error())
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+			case <-sig:
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+				return
+			case <-stopCh:
+				// timeout
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+				return
+			}
+		}
+	}()
+
+	time.Sleep(time.Second * 1)
+	t.Run("MiddlewareTest", middleware)
+
+	stopCh <- struct{}{}
+	wg.Wait()
+}
+
+func middleware(t *testing.T) {
+	req, err := http.NewRequest("GET", "http://localhost:18903?hello=world", nil)
+	assert.NoError(t, err)
+
+	r, err := http.DefaultClient.Do(req)
+	assert.NoError(t, err)
+
+	b, err := ioutil.ReadAll(r.Body)
+	assert.NoError(t, err)
+
+	assert.Equal(t, 201, r.StatusCode)
+	assert.Equal(t, "WORLD", string(b))
+
+	err = r.Body.Close()
+	assert.NoError(t, err)
+
+	req, err = http.NewRequest("GET", "http://localhost:18903/halt", nil)
+	assert.NoError(t, err)
+
+	r, err = http.DefaultClient.Do(req)
+	assert.NoError(t, err)
+	b, err = ioutil.ReadAll(r.Body)
+	assert.NoError(t, err)
+
+	assert.Equal(t, 500, r.StatusCode)
+	assert.Equal(t, "halted", string(b))
+
+	err = r.Body.Close()
+	assert.NoError(t, err)
+}
+
+func TestHttpEchoErr(t *testing.T) {
+	cont, err := endure.NewContainer(nil, endure.SetLogLevel(endure.ErrorLevel))
+	assert.NoError(t, err)
+
+	rIn := `
+rpc:
+  listen: tcp://127.0.0.1:6001
+  disabled: false
+
+server:
+  command: "php ../../http/client.php echoerr pipes"
+  user: ""
+  group: ""
+  env:
+    "RR_HTTP": "true"
+  relay: "pipes"
+  relayTimeout: "20s"
+
+http:
+  debug: true
+  address: 127.0.0.1:34999
+  maxRequestSize: 1024
+  middleware: [ "pluginMiddleware", "pluginMiddleware2" ]
+  uploads:
+    forbid: [ "" ]
+  trustedSubnets: [ "10.0.0.0/8", "127.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16", "::1/128", "fc00::/7", "fe80::/10" ]
+  pool:
+    numWorkers: 2
+    maxJobs: 0
+    allocateTimeout: 60s
+    destroyTimeout: 60s
+logs:
+  mode: development
+  level: error
+`
+
+	cfg := &config.Viper{
+		Path:      "",
+		Prefix:    "",
+		Type:      "yaml",
+		ReadInCfg: []byte(rIn),
+	}
+
+	controller := gomock.NewController(t)
+	mockLogger := mocks.NewMockLogger(controller)
+
+	mockLogger.EXPECT().Debug("worker destructed", "pid", gomock.Any()).MinTimes(1)
+	mockLogger.EXPECT().Debug("worker constructed", "pid", gomock.Any()).MinTimes(1)
+	mockLogger.EXPECT().Debug("", "remote", gomock.Any(), "ts", gomock.Any(), "resp.status", gomock.Any(), "method", gomock.Any(), "uri", gomock.Any()).MinTimes(1)
+	mockLogger.EXPECT().Debug("WORLD", "pid", gomock.Any()).MinTimes(1)
+	mockLogger.EXPECT().Debug("worker event received", "event", events.EventWorkerLog, "worker state", gomock.Any()).MinTimes(1)
+	mockLogger.EXPECT().Error(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() // placeholder for the workerlogerror
+
+	err = cont.RegisterAll(
+		cfg,
+		mockLogger,
+		&server.Plugin{},
+		&httpPlugin.Plugin{},
+		&PluginMiddleware{},
+		&PluginMiddleware2{},
+	)
+	assert.NoError(t, err)
+
+	err = cont.Init()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ch, err := cont.Serve()
+	assert.NoError(t, err)
+
+	sig := make(chan os.Signal, 1)
+	signal.Notify(sig, os.Interrupt, syscall.SIGINT, syscall.SIGTERM)
+
+	wg := &sync.WaitGroup{}
+	wg.Add(1)
+
+	stopCh := make(chan struct{}, 1)
+
+	go func() {
+		defer wg.Done()
+		for {
+			select {
+			case e := <-ch:
+				assert.Fail(t, "error", e.Error.Error())
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+			case <-sig:
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+				return
+			case <-stopCh:
+				// timeout
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+				return
+			}
+		}
+	}()
+
+	time.Sleep(time.Second * 1)
+	t.Run("HttpEchoError", echoError)
+
+	stopCh <- struct{}{}
+	wg.Wait()
+}
+
+func echoError(t *testing.T) {
+	req, err := http.NewRequest("GET", "http://localhost:34999?hello=world", nil)
+	assert.NoError(t, err)
+
+	r, err := http.DefaultClient.Do(req)
+	assert.NoError(t, err)
+
+	b, err := ioutil.ReadAll(r.Body)
+	assert.NoError(t, err)
+
+	assert.Equal(t, 201, r.StatusCode)
+	assert.Equal(t, "WORLD", string(b))
+	err = r.Body.Close()
+	assert.NoError(t, err)
+}
+
+func TestHttpEnvVariables(t *testing.T) {
+	cont, err := endure.NewContainer(nil, endure.SetLogLevel(endure.ErrorLevel))
+	assert.NoError(t, err)
+
+	cfg := &config.Viper{
+		Path:   "configs/.rr-env.yaml",
+		Prefix: "rr",
+	}
+
+	err = cont.RegisterAll(
+		cfg,
+		&logger.ZapLogger{},
+		&server.Plugin{},
+		&httpPlugin.Plugin{},
+		&PluginMiddleware{},
+		&PluginMiddleware2{},
+	)
+	assert.NoError(t, err)
+
+	err = cont.Init()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ch, err := cont.Serve()
+	assert.NoError(t, err)
+
+	sig := make(chan os.Signal, 1)
+	signal.Notify(sig, os.Interrupt, syscall.SIGINT, syscall.SIGTERM)
+
+	wg := &sync.WaitGroup{}
+	wg.Add(1)
+
+	stopCh := make(chan struct{}, 1)
+
+	go func() {
+		defer wg.Done()
+		for {
+			select {
+			case e := <-ch:
+				assert.Fail(t, "error", e.Error.Error())
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+			case <-sig:
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+				return
+			case <-stopCh:
+				// timeout
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+				return
+			}
+		}
+	}()
+
+	time.Sleep(time.Second * 1)
+	t.Run("EnvVariablesTest", envVarsTest)
+
+	stopCh <- struct{}{}
+	wg.Wait()
+}
+
+func envVarsTest(t *testing.T) {
+	req, err := http.NewRequest("GET", "http://localhost:12084", nil)
+	assert.NoError(t, err)
+
+	r, err := http.DefaultClient.Do(req)
+	assert.NoError(t, err)
+
+	b, err := ioutil.ReadAll(r.Body)
+	assert.NoError(t, err)
+
+	assert.Equal(t, 200, r.StatusCode)
+	assert.Equal(t, "ENV_VALUE", string(b))
+
+	err = r.Body.Close()
+	assert.NoError(t, err)
+}
+
+func TestHttpBrokenPipes(t *testing.T) {
+	cont, err := endure.NewContainer(nil, endure.SetLogLevel(endure.ErrorLevel))
+	assert.NoError(t, err)
+
+	cfg := &config.Viper{
+		Path:   "configs/.rr-broken-pipes.yaml",
+		Prefix: "rr",
+		Type:   "yaml",
+	}
+
+	err = cont.RegisterAll(
+		cfg,
+		&logger.ZapLogger{},
+		&server.Plugin{},
+		&httpPlugin.Plugin{},
+		&PluginMiddleware{},
+		&PluginMiddleware2{},
+	)
+	assert.NoError(t, err)
+
+	err = cont.Init()
+	assert.Error(t, err)
+
+	_, err = cont.Serve()
+	assert.Error(t, err)
+}
+
+func TestHTTPSupervisedPool(t *testing.T) {
+	cont, err := endure.NewContainer(nil, endure.SetLogLevel(endure.ErrorLevel))
+	assert.NoError(t, err)
+
+	cfg := &config.Viper{
+		Path:   "configs/.rr-http-supervised-pool.yaml",
+		Prefix: "rr",
+	}
+
+	err = cont.RegisterAll(
+		cfg,
+		&rpcPlugin.Plugin{},
+		&logger.ZapLogger{},
+		&server.Plugin{},
+		&httpPlugin.Plugin{},
+		&informer.Plugin{},
+	)
+	assert.NoError(t, err)
+
+	err = cont.Init()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ch, err := cont.Serve()
+	assert.NoError(t, err)
+
+	sig := make(chan os.Signal, 1)
+	signal.Notify(sig, os.Interrupt, syscall.SIGINT, syscall.SIGTERM)
+
+	wg := &sync.WaitGroup{}
+	wg.Add(1)
+
+	stopCh := make(chan struct{}, 1)
+
+	go func() {
+		defer wg.Done()
+		for {
+			select {
+			case e := <-ch:
+				assert.Fail(t, "error", e.Error.Error())
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+			case <-sig:
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+				return
+			case <-stopCh:
+				// timeout
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+				return
+			}
+		}
+	}()
+
+	time.Sleep(time.Second * 1)
+	t.Run("HTTPEchoTest", echoHTTP2)
+	// worker should be destructed (idle_ttl)
+	t.Run("HTTPInformerCompareWorkersTest", informerTest2)
+
+	stopCh <- struct{}{}
+	wg.Wait()
+}
+
+func echoHTTP2(t *testing.T) {
+	req, err := http.NewRequest("GET", "http://localhost:18888?hello=world", nil)
+	assert.NoError(t, err)
+
+	r, err := http.DefaultClient.Do(req)
+	assert.NoError(t, err)
+	b, err := ioutil.ReadAll(r.Body)
+	assert.NoError(t, err)
+	assert.Equal(t, 201, r.StatusCode)
+	assert.Equal(t, "WORLD", string(b))
+
+	err = r.Body.Close()
+	assert.NoError(t, err)
+}
+
+// get worker
+// sleep
+// supervisor destroy worker
+// compare pid's
+func informerTest2(t *testing.T) {
+	conn, err := net.Dial("tcp", "127.0.0.1:15432")
+	assert.NoError(t, err)
+	client := rpc.NewClientWithCodec(goridgeRpc.NewClientCodec(conn))
+	pid := 0
+	// WorkerList contains list of workers.
+	list := struct {
+		// Workers is list of workers.
+		Workers []tools.ProcessState `json:"workers"`
+	}{}
+
+	err = client.Call("informer.Workers", "http", &list)
+	assert.NoError(t, err)
+	assert.Len(t, list.Workers, 1)
+	// save the pid
+	pid = list.Workers[0].Pid
+	time.Sleep(time.Second * 10)
+
+	list = struct {
+		// Workers is list of workers.
+		Workers []tools.ProcessState `json:"workers"`
+	}{}
+
+	err = client.Call("informer.Workers", "http", &list)
+	assert.NoError(t, err)
+	assert.Len(t, list.Workers, 1)
+	assert.NotEqual(t, list.Workers[0].Pid, pid)
+}
+
+func get(url string) (string, *http.Response, error) {
+	r, err := http.Get(url) //nolint:gosec
+	if err != nil {
+		return "", nil, err
+	}
+	b, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		return "", nil, err
+	}
+	defer func() {
+		_ = r.Body.Close()
+	}()
+	return string(b), r, err
+}
+
+// get request and return body
+func getHeader(url string, h map[string]string) (string, *http.Response, error) {
+	req, err := http.NewRequest("GET", url, bytes.NewBuffer(nil))
+	if err != nil {
+		return "", nil, err
+	}
+
+	for k, v := range h {
+		req.Header.Set(k, v)
+	}
+
+	r, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return "", nil, err
+	}
+
+	b, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		return "", nil, err
+	}
+
+	err = r.Body.Close()
+	if err != nil {
+		return "", nil, err
+	}
+	return string(b), r, err
+}
+
+func makeConfig(rpcPort, httpPort, fcgiPort, sslAddress, redirect, http2Enabled, command string) []byte {
+	return []byte(fmt.Sprintf(`
+rpc:
+  listen: tcp://127.0.0.1:%s
+  disabled: false
+
+server:
+  command: "%s"
+  user: ""
+  group: ""
+  env:
+    "RR_HTTP": "true"
+  relay: "pipes"
+  relayTimeout: "20s"
+
+http:
+  address: 127.0.0.1:%s
+  maxRequestSize: 1024
+  middleware: [ "" ]
+  uploads:
+    forbid: [ ".php", ".exe", ".bat" ]
+  trustedSubnets: [ "10.0.0.0/8", "127.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16", "::1/128", "fc00::/7", "fe80::/10" ]
+  pool:
+    numWorkers: 2
+    maxJobs: 0
+    allocateTimeout: 60s
+    destroyTimeout: 60s
+
+  ssl:
+    address: %s
+    redirect: %s
+    cert: fixtures/server.crt
+    key: fixtures/server.key
+  #    rootCa: root.crt
+  fcgi:
+    address: tcp://0.0.0.0:%s
+  http2:
+    enabled: %s
+    h2c: false
+    maxConcurrentStreams: 128
+logs:
+  mode: development
+  level: error
+`, rpcPort, command, httpPort, sslAddress, redirect, fcgiPort, http2Enabled))
+}
diff --git a/tests/plugins/http/parse_test.go b/tests/plugins/http/parse_test.go
new file mode 100644
index 00000000..5cc1ce32
--- /dev/null
+++ b/tests/plugins/http/parse_test.go
@@ -0,0 +1,54 @@
+package http
+
+import (
+	"testing"
+
+	"github.com/spiral/roadrunner/v2/plugins/http"
+)
+
+var samples = []struct {
+	in  string
+	out []string
+}{
+	{"key", []string{"key"}},
+	{"key[subkey]", []string{"key", "subkey"}},
+	{"key[subkey]value", []string{"key", "subkey", "value"}},
+	{"key[subkey][value]", []string{"key", "subkey", "value"}},
+	{"key[subkey][value][]", []string{"key", "subkey", "value", ""}},
+	{"key[subkey] [value][]", []string{"key", "subkey", "value", ""}},
+	{"key [ subkey ] [ value ] [ ]", []string{"key", "subkey", "value", ""}},
+}
+
+func Test_FetchIndexes(t *testing.T) {
+	for i := 0; i < len(samples); i++ {
+		r := http.FetchIndexes(samples[i].in)
+		if !same(r, samples[i].out) {
+			t.Errorf("got %q, want %q", r, samples[i].out)
+		}
+	}
+}
+
+func BenchmarkConfig_FetchIndexes(b *testing.B) {
+	for _, tt := range samples {
+		for n := 0; n < b.N; n++ {
+			r := http.FetchIndexes(tt.in)
+			if !same(r, tt.out) {
+				b.Fail()
+			}
+		}
+	}
+}
+
+func same(in, out []string) bool {
+	if len(in) != len(out) {
+		return false
+	}
+
+	for i, v := range in {
+		if v != out[i] {
+			return false
+		}
+	}
+
+	return true
+}
diff --git a/tests/plugins/http/plugin1.go b/tests/plugins/http/plugin1.go
new file mode 100644
index 00000000..0ec31211
--- /dev/null
+++ b/tests/plugins/http/plugin1.go
@@ -0,0 +1,27 @@
+package http
+
+import (
+	"github.com/spiral/roadrunner/v2/plugins/config"
+)
+
+type Plugin1 struct {
+	config config.Configurer
+}
+
+func (p1 *Plugin1) Init(cfg config.Configurer) error {
+	p1.config = cfg
+	return nil
+}
+
+func (p1 *Plugin1) Serve() chan error {
+	errCh := make(chan error, 1)
+	return errCh
+}
+
+func (p1 *Plugin1) Stop() error {
+	return nil
+}
+
+func (p1 *Plugin1) Name() string {
+	return "http_test.plugin1"
+}
diff --git a/tests/plugins/http/plugin_middleware.go b/tests/plugins/http/plugin_middleware.go
new file mode 100644
index 00000000..00640b69
--- /dev/null
+++ b/tests/plugins/http/plugin_middleware.go
@@ -0,0 +1,69 @@
+package http
+
+import (
+	"net/http"
+
+	"github.com/spiral/roadrunner/v2/plugins/config"
+)
+
+// PluginMiddleware test
+type PluginMiddleware struct {
+	config config.Configurer
+}
+
+// Init test
+func (p *PluginMiddleware) Init(cfg config.Configurer) error {
+	p.config = cfg
+	return nil
+}
+
+// Middleware test
+func (p *PluginMiddleware) Middleware(next http.Handler) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path == "/halt" {
+			w.WriteHeader(500)
+			_, err := w.Write([]byte("halted"))
+			if err != nil {
+				panic("error writing the data to the http reply")
+			}
+		} else {
+			next.ServeHTTP(w, r)
+		}
+	}
+}
+
+// Name test
+func (p *PluginMiddleware) Name() string {
+	return "pluginMiddleware"
+}
+
+// PluginMiddleware2 test
+type PluginMiddleware2 struct {
+	config config.Configurer
+}
+
+// Init test
+func (p *PluginMiddleware2) Init(cfg config.Configurer) error {
+	p.config = cfg
+	return nil
+}
+
+// Middleware test
+func (p *PluginMiddleware2) Middleware(next http.Handler) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path == "/boom" {
+			w.WriteHeader(555)
+			_, err := w.Write([]byte("boom"))
+			if err != nil {
+				panic("error writing the data to the http reply")
+			}
+		} else {
+			next.ServeHTTP(w, r)
+		}
+	}
+}
+
+// Name test
+func (p *PluginMiddleware2) Name() string {
+	return "pluginMiddleware2"
+}
diff --git a/tests/plugins/http/response_test.go b/tests/plugins/http/response_test.go
new file mode 100644
index 00000000..dc9856ac
--- /dev/null
+++ b/tests/plugins/http/response_test.go
@@ -0,0 +1,165 @@
+package http
+
+import (
+	"bytes"
+	"errors"
+	"net/http"
+	"testing"
+
+	"github.com/spiral/roadrunner/v2/pkg/payload"
+	httpPlugin "github.com/spiral/roadrunner/v2/plugins/http"
+	"github.com/stretchr/testify/assert"
+)
+
+type testWriter struct {
+	h           http.Header
+	buf         bytes.Buffer
+	wroteHeader bool
+	code        int
+	err         error
+	pushErr     error
+	pushes      []string
+}
+
+func (tw *testWriter) Header() http.Header { return tw.h }
+
+func (tw *testWriter) Write(p []byte) (int, error) {
+	if !tw.wroteHeader {
+		tw.WriteHeader(http.StatusOK)
+	}
+
+	n, e := tw.buf.Write(p)
+	if e == nil {
+		e = tw.err
+	}
+
+	return n, e
+}
+
+func (tw *testWriter) WriteHeader(code int) { tw.wroteHeader = true; tw.code = code }
+
+func (tw *testWriter) Push(target string, opts *http.PushOptions) error {
+	tw.pushes = append(tw.pushes, target)
+
+	return tw.pushErr
+}
+
+func TestNewResponse_Error(t *testing.T) {
+	r, err := httpPlugin.NewResponse(payload.Payload{Context: []byte(`invalid payload`)})
+	assert.Error(t, err)
+	assert.Nil(t, r)
+}
+
+func TestNewResponse_Write(t *testing.T) {
+	r, err := httpPlugin.NewResponse(payload.Payload{
+		Context: []byte(`{"headers":{"key":["value"]},"status": 301}`),
+		Body:    []byte(`sample body`),
+	})
+
+	assert.NoError(t, err)
+	assert.NotNil(t, r)
+
+	w := &testWriter{h: http.Header(make(map[string][]string))}
+	assert.NoError(t, r.Write(w))
+
+	assert.Equal(t, 301, w.code)
+	assert.Equal(t, "value", w.h.Get("key"))
+	assert.Equal(t, "sample body", w.buf.String())
+}
+
+func TestNewResponse_Stream(t *testing.T) {
+	r, err := httpPlugin.NewResponse(payload.Payload{
+		Context: []byte(`{"headers":{"key":["value"]},"status": 301}`),
+	})
+
+	// r is pointer, so, it might be nil
+	if r == nil {
+		t.Fatal("response is nil")
+		return
+	}
+
+	r.Body = new(bytes.Buffer)
+	r.Body.(*bytes.Buffer).WriteString("hello world")
+
+	assert.NoError(t, err)
+	assert.NotNil(t, r)
+
+	w := &testWriter{h: http.Header(make(map[string][]string))}
+	assert.NoError(t, r.Write(w))
+
+	assert.Equal(t, 301, w.code)
+	assert.Equal(t, "value", w.h.Get("key"))
+	assert.Equal(t, "hello world", w.buf.String())
+}
+
+func TestNewResponse_StreamError(t *testing.T) {
+	r, err := httpPlugin.NewResponse(payload.Payload{
+		Context: []byte(`{"headers":{"key":["value"]},"status": 301}`),
+	})
+
+	// r is pointer, so, it might be nil
+	if r == nil {
+		t.Fatal("response is nil")
+		return
+	}
+
+	r.Body = &bytes.Buffer{}
+	r.Body.(*bytes.Buffer).WriteString("hello world")
+
+	assert.NoError(t, err)
+	assert.NotNil(t, r)
+
+	w := &testWriter{h: http.Header(make(map[string][]string)), err: errors.New("error")}
+	assert.Error(t, r.Write(w))
+}
+
+func TestWrite_HandlesPush(t *testing.T) {
+	r, err := httpPlugin.NewResponse(payload.Payload{
+		Context: []byte(`{"headers":{"Http2-Push":["/test.js"],"content-type":["text/html"]},"status": 200}`),
+	})
+
+	assert.NoError(t, err)
+	assert.NotNil(t, r)
+
+	w := &testWriter{h: http.Header(make(map[string][]string))}
+	assert.NoError(t, r.Write(w))
+
+	assert.Nil(t, w.h["Http2-Push"])
+	assert.Equal(t, []string{"/test.js"}, w.pushes)
+}
+
+func TestWrite_HandlesTrailers(t *testing.T) {
+	r, err := httpPlugin.NewResponse(payload.Payload{
+		Context: []byte(`{"headers":{"Trailer":["foo, bar", "baz"],"foo":["test"],"bar":["demo"]},"status": 200}`),
+	})
+
+	assert.NoError(t, err)
+	assert.NotNil(t, r)
+
+	w := &testWriter{h: http.Header(make(map[string][]string))}
+	assert.NoError(t, r.Write(w))
+
+	assert.Nil(t, w.h[httpPlugin.TrailerHeaderKey])
+	assert.Nil(t, w.h["foo"]) //nolint:staticcheck
+	assert.Nil(t, w.h["baz"]) //nolint:staticcheck
+
+	assert.Equal(t, "test", w.h.Get("Trailer:foo"))
+	assert.Equal(t, "demo", w.h.Get("Trailer:bar"))
+}
+
+func TestWrite_HandlesHandlesWhitespacesInTrailer(t *testing.T) {
+	r, err := httpPlugin.NewResponse(payload.Payload{
+		Context: []byte(
+			`{"headers":{"Trailer":["foo\t,bar  ,    baz"],"foo":["a"],"bar":["b"],"baz":["c"]},"status": 200}`),
+	})
+
+	assert.NoError(t, err)
+	assert.NotNil(t, r)
+
+	w := &testWriter{h: http.Header(make(map[string][]string))}
+	assert.NoError(t, r.Write(w))
+
+	assert.Equal(t, "a", w.h.Get("Trailer:foo"))
+	assert.Equal(t, "b", w.h.Get("Trailer:bar"))
+	assert.Equal(t, "c", w.h.Get("Trailer:baz"))
+}
diff --git a/tests/plugins/http/uploads_config_test.go b/tests/plugins/http/uploads_config_test.go
new file mode 100644
index 00000000..4f99b621
--- /dev/null
+++ b/tests/plugins/http/uploads_config_test.go
@@ -0,0 +1,26 @@
+package http
+
+import (
+	"os"
+	"testing"
+
+	"github.com/spiral/roadrunner/v2/plugins/http/config"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFsConfig_Forbids(t *testing.T) {
+	cfg := config.Uploads{Forbid: []string{".php"}}
+
+	assert.True(t, cfg.Forbids("index.php"))
+	assert.True(t, cfg.Forbids("index.PHP"))
+	assert.True(t, cfg.Forbids("phpadmin/index.bak.php"))
+	assert.False(t, cfg.Forbids("index.html"))
+}
+
+func TestFsConfig_TmpFallback(t *testing.T) {
+	cfg := config.Uploads{Dir: "test"}
+	assert.Equal(t, "test", cfg.TmpDir())
+
+	cfg = config.Uploads{Dir: ""}
+	assert.Equal(t, os.TempDir(), cfg.TmpDir())
+}
diff --git a/tests/plugins/http/uploads_test.go b/tests/plugins/http/uploads_test.go
new file mode 100644
index 00000000..dd986902
--- /dev/null
+++ b/tests/plugins/http/uploads_test.go
@@ -0,0 +1,433 @@
+package http
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha512"
+	"encoding/hex"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"mime/multipart"
+	"net/http"
+	"os"
+	"os/exec"
+	"testing"
+	"time"
+
+	j "github.com/json-iterator/go"
+	poolImpl "github.com/spiral/roadrunner/v2/pkg/pool"
+	"github.com/spiral/roadrunner/v2/pkg/transport/pipe"
+	httpPlugin "github.com/spiral/roadrunner/v2/plugins/http"
+	"github.com/spiral/roadrunner/v2/plugins/http/config"
+	"github.com/stretchr/testify/assert"
+)
+
+var json = j.ConfigCompatibleWithStandardLibrary
+
+const testFile = "uploads_test.go"
+
+func TestHandler_Upload_File(t *testing.T) {
+	pool, err := poolImpl.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "upload", "pipes") },
+		pipe.NewPipeFactory(),
+		poolImpl.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	h, err := httpPlugin.NewHandler(1024, config.Uploads{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, pool)
+	assert.NoError(t, err)
+
+	hs := &http.Server{Addr: ":8021", Handler: h}
+	defer func() {
+		err := hs.Shutdown(context.Background())
+		if err != nil {
+			t.Errorf("error during the shutdown: error %v", err)
+		}
+	}()
+
+	go func() {
+		err := hs.ListenAndServe()
+		if err != nil && err != http.ErrServerClosed {
+			t.Errorf("error listening the interface: error %v", err)
+		}
+	}()
+	time.Sleep(time.Millisecond * 10)
+
+	var mb bytes.Buffer
+	w := multipart.NewWriter(&mb)
+
+	f := mustOpen(testFile)
+	defer func() {
+		err := f.Close()
+		if err != nil {
+			t.Errorf("failed to close a file: error %v", err)
+		}
+	}()
+	fw, err := w.CreateFormFile("upload", f.Name())
+	assert.NotNil(t, fw)
+	assert.NoError(t, err)
+	_, err = io.Copy(fw, f)
+	if err != nil {
+		t.Errorf("error copying the file: error %v", err)
+	}
+
+	err = w.Close()
+	if err != nil {
+		t.Errorf("error closing the file: error %v", err)
+	}
+
+	req, err := http.NewRequest("POST", "http://localhost"+hs.Addr, &mb)
+	assert.NoError(t, err)
+
+	req.Header.Set("Content-Type", w.FormDataContentType())
+
+	r, err := http.DefaultClient.Do(req)
+	assert.NoError(t, err)
+	defer func() {
+		err := r.Body.Close()
+		if err != nil {
+			t.Errorf("error closing the Body: error %v", err)
+		}
+	}()
+
+	b, err := ioutil.ReadAll(r.Body)
+	assert.NoError(t, err)
+
+	assert.NoError(t, err)
+	assert.Equal(t, 200, r.StatusCode)
+
+	fs := fileString(testFile, 0, "application/octet-stream")
+
+	assert.Equal(t, `{"upload":`+fs+`}`, string(b))
+}
+
+func TestHandler_Upload_NestedFile(t *testing.T) {
+	pool, err := poolImpl.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "upload", "pipes") },
+		pipe.NewPipeFactory(),
+		poolImpl.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	h, err := httpPlugin.NewHandler(1024, config.Uploads{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, pool)
+	assert.NoError(t, err)
+
+	hs := &http.Server{Addr: ":8021", Handler: h}
+	defer func() {
+		err := hs.Shutdown(context.Background())
+		if err != nil {
+			t.Errorf("error during the shutdown: error %v", err)
+		}
+	}()
+
+	go func() {
+		err := hs.ListenAndServe()
+		if err != nil && err != http.ErrServerClosed {
+			t.Errorf("error listening the interface: error %v", err)
+		}
+	}()
+	time.Sleep(time.Millisecond * 10)
+
+	var mb bytes.Buffer
+	w := multipart.NewWriter(&mb)
+
+	f := mustOpen(testFile)
+	defer func() {
+		err := f.Close()
+		if err != nil {
+			t.Errorf("failed to close a file: error %v", err)
+		}
+	}()
+	fw, err := w.CreateFormFile("upload[x][y][z][]", f.Name())
+	assert.NotNil(t, fw)
+	assert.NoError(t, err)
+	_, err = io.Copy(fw, f)
+	if err != nil {
+		t.Errorf("error copying the file: error %v", err)
+	}
+
+	err = w.Close()
+	if err != nil {
+		t.Errorf("error closing the file: error %v", err)
+	}
+
+	req, err := http.NewRequest("POST", "http://localhost"+hs.Addr, &mb)
+	assert.NoError(t, err)
+
+	req.Header.Set("Content-Type", w.FormDataContentType())
+
+	r, err := http.DefaultClient.Do(req)
+	assert.NoError(t, err)
+	defer func() {
+		err := r.Body.Close()
+		if err != nil {
+			t.Errorf("error closing the Body: error %v", err)
+		}
+	}()
+
+	b, err := ioutil.ReadAll(r.Body)
+	assert.NoError(t, err)
+
+	assert.NoError(t, err)
+	assert.Equal(t, 200, r.StatusCode)
+
+	fs := fileString(testFile, 0, "application/octet-stream")
+
+	assert.Equal(t, `{"upload":{"x":{"y":{"z":[`+fs+`]}}}}`, string(b))
+}
+
+func TestHandler_Upload_File_NoTmpDir(t *testing.T) {
+	pool, err := poolImpl.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "upload", "pipes") },
+		pipe.NewPipeFactory(),
+		poolImpl.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	h, err := httpPlugin.NewHandler(1024, config.Uploads{
+		Dir:    "-------",
+		Forbid: []string{},
+	}, nil, pool)
+	assert.NoError(t, err)
+
+	hs := &http.Server{Addr: ":8021", Handler: h}
+	defer func() {
+		err := hs.Shutdown(context.Background())
+		if err != nil {
+			t.Errorf("error during the shutdown: error %v", err)
+		}
+	}()
+
+	go func() {
+		err := hs.ListenAndServe()
+		if err != nil && err != http.ErrServerClosed {
+			t.Errorf("error listening the interface: error %v", err)
+		}
+	}()
+	time.Sleep(time.Millisecond * 10)
+
+	var mb bytes.Buffer
+	w := multipart.NewWriter(&mb)
+
+	f := mustOpen(testFile)
+	defer func() {
+		err := f.Close()
+		if err != nil {
+			t.Errorf("failed to close a file: error %v", err)
+		}
+	}()
+	fw, err := w.CreateFormFile("upload", f.Name())
+	assert.NotNil(t, fw)
+	assert.NoError(t, err)
+	_, err = io.Copy(fw, f)
+	if err != nil {
+		t.Errorf("error copying the file: error %v", err)
+	}
+
+	err = w.Close()
+	if err != nil {
+		t.Errorf("error closing the file: error %v", err)
+	}
+
+	req, err := http.NewRequest("POST", "http://localhost"+hs.Addr, &mb)
+	assert.NoError(t, err)
+
+	req.Header.Set("Content-Type", w.FormDataContentType())
+
+	r, err := http.DefaultClient.Do(req)
+	assert.NoError(t, err)
+	defer func() {
+		err := r.Body.Close()
+		if err != nil {
+			t.Errorf("error closing the Body: error %v", err)
+		}
+	}()
+
+	b, err := ioutil.ReadAll(r.Body)
+	assert.NoError(t, err)
+
+	assert.NoError(t, err)
+	assert.Equal(t, 200, r.StatusCode)
+
+	fs := fileString(testFile, 6, "application/octet-stream")
+
+	assert.Equal(t, `{"upload":`+fs+`}`, string(b))
+}
+
+func TestHandler_Upload_File_Forbids(t *testing.T) {
+	pool, err := poolImpl.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "upload", "pipes") },
+		pipe.NewPipeFactory(),
+		poolImpl.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	h, err := httpPlugin.NewHandler(1024, config.Uploads{
+		Dir:    os.TempDir(),
+		Forbid: []string{".go"},
+	}, nil, pool)
+	assert.NoError(t, err)
+
+	hs := &http.Server{Addr: ":8021", Handler: h}
+	defer func() {
+		err := hs.Shutdown(context.Background())
+		if err != nil {
+			t.Errorf("error during the shutdown: error %v", err)
+		}
+	}()
+
+	go func() {
+		err := hs.ListenAndServe()
+		if err != nil && err != http.ErrServerClosed {
+			t.Errorf("error listening the interface: error %v", err)
+		}
+	}()
+	time.Sleep(time.Millisecond * 10)
+
+	var mb bytes.Buffer
+	w := multipart.NewWriter(&mb)
+
+	f := mustOpen(testFile)
+	defer func() {
+		err := f.Close()
+		if err != nil {
+			t.Errorf("failed to close a file: error %v", err)
+		}
+	}()
+	fw, err := w.CreateFormFile("upload", f.Name())
+	assert.NotNil(t, fw)
+	assert.NoError(t, err)
+	_, err = io.Copy(fw, f)
+	if err != nil {
+		t.Errorf("error copying the file: error %v", err)
+	}
+
+	err = w.Close()
+	if err != nil {
+		t.Errorf("error closing the file: error %v", err)
+	}
+
+	req, err := http.NewRequest("POST", "http://localhost"+hs.Addr, &mb)
+	assert.NoError(t, err)
+
+	req.Header.Set("Content-Type", w.FormDataContentType())
+
+	r, err := http.DefaultClient.Do(req)
+	assert.NoError(t, err)
+	defer func() {
+		err := r.Body.Close()
+		if err != nil {
+			t.Errorf("error closing the Body: error %v", err)
+		}
+	}()
+
+	b, err := ioutil.ReadAll(r.Body)
+	assert.NoError(t, err)
+
+	assert.NoError(t, err)
+	assert.Equal(t, 200, r.StatusCode)
+
+	fs := fileString(testFile, 8, "application/octet-stream")
+
+	assert.Equal(t, `{"upload":`+fs+`}`, string(b))
+}
+
+func Test_FileExists(t *testing.T) {
+	assert.True(t, exists(testFile))
+	assert.False(t, exists("uploads_test."))
+}
+
+func mustOpen(f string) *os.File {
+	r, err := os.Open(f)
+	if err != nil {
+		panic(err)
+	}
+	return r
+}
+
+type fInfo struct {
+	Name   string `json:"name"`
+	Size   int64  `json:"size"`
+	Mime   string `json:"mime"`
+	Error  int    `json:"error"`
+	Sha512 string `json:"sha512,omitempty"`
+}
+
+func fileString(f string, errNo int, mime string) string {
+	s, err := os.Stat(f)
+	if err != nil {
+		fmt.Println(fmt.Errorf("error stat the file, error: %v", err))
+	}
+
+	ff, err := os.Open(f)
+	if err != nil {
+		fmt.Println(fmt.Errorf("error opening the file, error: %v", err))
+	}
+
+	defer func() {
+		er := ff.Close()
+		if er != nil {
+			fmt.Println(fmt.Errorf("error closing the file, error: %v", er))
+		}
+	}()
+
+	h := sha512.New()
+	_, err = io.Copy(h, ff)
+	if err != nil {
+		fmt.Println(fmt.Errorf("error copying the file, error: %v", err))
+	}
+
+	v := &fInfo{
+		Name:   s.Name(),
+		Size:   s.Size(),
+		Error:  errNo,
+		Mime:   mime,
+		Sha512: hex.EncodeToString(h.Sum(nil)),
+	}
+
+	if errNo != 0 {
+		v.Sha512 = ""
+		v.Size = 0
+	}
+
+	r, err := json.Marshal(v)
+	if err != nil {
+		fmt.Println(fmt.Errorf("error marshalling fInfo, error: %v", err))
+	}
+	return string(r)
+}
+
+// exists if file exists.
+func exists(path string) bool {
+	if _, err := os.Stat(path); os.IsNotExist(err) {
+		return false
+	}
+	return true
+}