Initial commit of experiment

62 files changed, 7753 insertions, 22 deletions

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 22a2440e..b624451e 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -80,6 +80,9 @@ jobs:
           go test -v -race -cover -tags=debug -coverprofile=./coverage-ci/pool.txt -covermode=atomic ./pkg/pool
           go test -v -race -cover -tags=debug -coverprofile=./coverage-ci/socket.txt -covermode=atomic ./pkg/socket
           go test -v -race -cover -tags=debug -coverprofile=./coverage-ci/worker.txt -covermode=atomic ./pkg/worker
+          go test -v -race -cover -tags=debug -coverprofile=./coverage-ci/http.txt -covermode=atomic ./tests/plugins/http
+          go test -v -race -cover -tags=debug -coverprofile=./coverage-ci/informer.txt -covermode=atomic ./tests/plugins/informer
+          go test -v -race -cover -tags=debug -coverprofile=./coverage-ci/server.txt -covermode=atomic ./tests/plugins/server
           cat ./coverage-ci/*.txt > ./coverage-ci/summary.txt
 
       - uses: codecov/codecov-action@v1 # Docs: <https://github.com/codecov/codecov-action>
diff --git a/Makefile b/Makefile
index 54744223..9f8323a5 100755
--- a/Makefile
+++ b/Makefile
@@ -24,12 +24,15 @@ uninstall: ## Uninstall locally installed RR
 	rm -f /usr/local/bin/rr
 
 test: ## Run application tests
-	go clean -testcache
+	#go clean -testcache
 	go test -v -race -cover -tags=debug -covermode=atomic ./util
 	go test -v -race -cover -tags=debug -covermode=atomic ./pkg/pipe
 	go test -v -race -cover -tags=debug -covermode=atomic ./pkg/pool
 	go test -v -race -cover -tags=debug -covermode=atomic ./pkg/socket
 	go test -v -race -cover -tags=debug -covermode=atomic ./pkg/worker
+	go test -v -race -cover -tags=debug -covermode=atomic ./tests/plugins/http
+	go test -v -race -cover -tags=debug -covermode=atomic ./tests/plugins/informer
+	go test -v -race -cover -tags=debug -covermode=atomic ./tests/plugins/server
 
 lint: ## Run application linters
 	go fmt ./...
diff --git a/cmd/cli/workers.go b/cmd/cli/workers.go
index d34de40a..03639aa4 100644
--- a/cmd/cli/workers.go
+++ b/cmd/cli/workers.go
@@ -13,7 +13,7 @@ import (
 	"github.com/fatih/color"
 	"github.com/spf13/cobra"
 	"github.com/spiral/errors"
-	"github.com/spiral/roadrunner-plugins/informer"
+	"github.com/spiral/roadrunner/v2/plugins/informer"
 	"github.com/spiral/roadrunner/v2/tools"
 )
 
@@ -22,6 +22,7 @@ var (
 )
 
 const InformerList string = "informer.List"
+const InformerWorkers string = "informer.Workers"
 
 func init() {
 	workersCommand := &cobra.Command{
@@ -42,7 +43,7 @@ func init() {
 }
 
 func workersHandler(cmd *cobra.Command, args []string) error {
-	const op = errors.Op("workers handler")
+	const op = errors.Op("workers cobra handler")
 	// get RPC client
 	client, err := RPCClient()
 	if err != nil {
@@ -94,25 +95,16 @@ func workersHandler(cmd *cobra.Command, args []string) error {
 }
 
 func showWorkers(plugins []string, client *rpc.Client) error {
+	const op = errors.Op("show workers")
 	for _, plugin := range plugins {
 		list := &informer.WorkerList{}
-		err := client.Call("informer.Workers", plugin, &list)
+		err := client.Call(InformerWorkers, plugin, &list)
 		if err != nil {
-			return err
-		}
-
-		// it's a golang :)
-		ps := make([]tools.ProcessState, len(list.Workers))
-		for i := 0; i < len(list.Workers); i++ {
-			ps[i].Created = list.Workers[i].Created
-			ps[i].NumJobs = list.Workers[i].NumJobs
-			ps[i].MemoryUsage = list.Workers[i].MemoryUsage
-			ps[i].Pid = list.Workers[i].Pid
-			ps[i].Status = list.Workers[i].Status
+			return errors.E(op, err)
 		}
 
 		fmt.Printf("Workers of [%s]:\n", color.HiYellowString(plugin))
-		tools.WorkerTable(os.Stdout, ps).Render()
+		tools.WorkerTable(os.Stdout, list.Workers).Render()
 	}
 	return nil
 }
diff --git a/cmd/main.go b/cmd/main.go
index 8151d4fe..5893fbcb 100644
--- a/cmd/main.go
+++ b/cmd/main.go
@@ -4,15 +4,16 @@ import (
 	"log"
 
 	"github.com/spiral/endure"
-	"github.com/spiral/roadrunner-plugins/http"
-	"github.com/spiral/roadrunner-plugins/informer"
+	"github.com/spiral/roadrunner/v2/plugins/http"
+	"github.com/spiral/roadrunner/v2/plugins/informer"
+	"github.com/spiral/roadrunner/v2/plugins/server"
+
 	"github.com/spiral/roadrunner-plugins/logger"
 	"github.com/spiral/roadrunner-plugins/metrics"
 	"github.com/spiral/roadrunner-plugins/redis"
 	"github.com/spiral/roadrunner-plugins/reload"
 	"github.com/spiral/roadrunner-plugins/resetter"
 	"github.com/spiral/roadrunner-plugins/rpc"
-	"github.com/spiral/roadrunner-plugins/server"
 	"github.com/spiral/roadrunner/v2/cmd/cli"
 )
 
diff --git a/go.mod b/go.mod
index a70c9379..e2c12c7f 100755
--- a/go.mod
+++ b/go.mod
@@ -6,6 +6,8 @@ require (
 	github.com/buger/goterm v0.0.0-20200322175922-2f3e71b85129
 	github.com/dustin/go-humanize v0.0.0-20171111073723-bb3d318650d4
 	github.com/fatih/color v1.10.0
+	github.com/golang/mock v1.4.4
+	github.com/hashicorp/go-multierror v1.1.0
 	github.com/json-iterator/go v1.1.10
 	github.com/mattn/go-runewidth v0.0.9
 	github.com/olekukonko/tablewriter v0.0.4
@@ -14,19 +16,20 @@ require (
 	github.com/spiral/endure v1.0.0-beta20
 	github.com/spiral/errors v1.0.6
 	github.com/spiral/goridge/v3 v3.0.0-beta8
+	github.com/spiral/roadrunner-plugins/checker v1.0.1
 	github.com/spiral/roadrunner-plugins/config v1.0.1
-	github.com/spiral/roadrunner-plugins/http v1.0.5
-	github.com/spiral/roadrunner-plugins/informer v1.0.5
 	github.com/spiral/roadrunner-plugins/logger v1.0.2
 	github.com/spiral/roadrunner-plugins/metrics v1.0.1
 	github.com/spiral/roadrunner-plugins/redis v1.0.1
 	github.com/spiral/roadrunner-plugins/reload v1.0.1
 	github.com/spiral/roadrunner-plugins/resetter v1.0.1
 	github.com/spiral/roadrunner-plugins/rpc v1.0.2
-	github.com/spiral/roadrunner-plugins/server v1.0.6
 	github.com/stretchr/testify v1.6.1
 	github.com/valyala/tcplisten v0.0.0-20161114210144-ceec8f93295a
 	github.com/vbauerster/mpb/v5 v5.4.0
+	github.com/yookoala/gofast v0.4.0
 	go.uber.org/multierr v1.6.0
+	golang.org/x/net v0.0.0-20201216054612-986b41b23924
 	golang.org/x/sync v0.0.0-20201207232520-09787c993a3a
+	golang.org/x/sys v0.0.0-20201221093633-bc327ba9c2f0
 )
diff --git a/go.sum b/go.sum
index 2dba039a..783b9195 100755
--- a/go.sum
+++ b/go.sum
@@ -415,6 +415,9 @@ github.com/spiral/errors v1.0.6 h1:berk5ShEILSw6DplUVv9Ea1wGdk2WlVKQpuvDngll0U=
 github.com/spiral/errors v1.0.6/go.mod h1:SwMSZVdZkkJVgXNNafccqOaxWg0XPzVU/dEdUEInE0o=
 github.com/spiral/goridge/v3 v3.0.0-beta8 h1:x8uXCdhY49U1LEvmehnTaD2El6J9ZHAefRdh/QIZ6A4=
 github.com/spiral/goridge/v3 v3.0.0-beta8/go.mod h1:XFQGc42KNzo/hPIXPki7mEkFTf9v/T7qFk/TYJjMtzE=
+github.com/spiral/roadrunner-plugins v0.0.0-20201224162001-79cb05174578 h1:zFQuyy/RMMVsQtD6y2RAPO4eBsWwGvsB04BuEmXOVD4=
+github.com/spiral/roadrunner-plugins/a_plugin_tests v0.0.0-20201224162001-79cb05174578 h1:E4cenNwBMi0F9327C7WMKx484MwFs5etbRcYKs1+EgY=
+github.com/spiral/roadrunner-plugins/a_plugin_tests v0.0.0-20201224162001-79cb05174578/go.mod h1:0aZijFwgc35Px78nXqOZNjJjd1jaHGxejGJrd8dJnuc=
 github.com/spiral/roadrunner-plugins/checker v1.0.1 h1:UVMX9zUF0R3ScRFUQg89e5+CLn3I2e5uAKsD4A52iDU=
 github.com/spiral/roadrunner-plugins/checker v1.0.1/go.mod h1:/gnVybeKye5uq/8hgjI7YDoK/ntPd0ej6tWkxlYdiz8=
 github.com/spiral/roadrunner-plugins/checker v1.0.3 h1:fnWX2PBXlNhYp8UERgFx/eMM1Qf4pDJCeUY4NoiWwbo=
@@ -423,6 +426,8 @@ github.com/spiral/roadrunner-plugins/config v1.0.0 h1:RPYB8Ha/UeuBGRwtcqNb0uU8R5
 github.com/spiral/roadrunner-plugins/config v1.0.0/go.mod h1:XcVJLFDUlYPvZ3kVzssmP4fJbEzUvVJf534+eZaotAo=
 github.com/spiral/roadrunner-plugins/config v1.0.1 h1:6n9mFqvy+Fk3LaOWfNSA7lb5o2vJOnGJivNFP7Fg8QA=
 github.com/spiral/roadrunner-plugins/config v1.0.1/go.mod h1:MQGXiAP8Sr6/LjFVcr+AeUElNMKJXnwVEKXn1I5ztXk=
+github.com/spiral/roadrunner-plugins/gzip v1.0.0/go.mod h1:gQSyvp7u8udOwZac5o2vcfrGANIaozyrIU1Q+xXq328=
+github.com/spiral/roadrunner-plugins/headers v1.0.0/go.mod h1:bZAGI0wo465MlYNx0Urpss0GyQDJQY5tcY9YrgiUElE=
 github.com/spiral/roadrunner-plugins/http v1.0.0 h1:8WGAuZOrkYZQWo6n13ip+ZtzhKugZZ+b5W+ivVr7FjI=
 github.com/spiral/roadrunner-plugins/http v1.0.0/go.mod h1:37ReUuAKJDtXH3GjMjRH5q3plBXq5r5lUfltRTVZzDE=
 github.com/spiral/roadrunner-plugins/http v1.0.2 h1:BRmdbx0DYlgYTkvmd1IDZJewC1y30GqBCKRjbTn3OLc=
@@ -469,6 +474,7 @@ github.com/spiral/roadrunner-plugins/server v1.0.4 h1:i6QWbVM/gLnM3Tb/DDFSFpRnxc
 github.com/spiral/roadrunner-plugins/server v1.0.4/go.mod h1:XHfOZwvITuKyUwU79KaeMm8gU5AqzKQg0MCHJ7eBU5c=
 github.com/spiral/roadrunner-plugins/server v1.0.6 h1:JOrA/O/DJjuqKE1YTxLSyYh+/FLsJHY9biZkLwZk+LE=
 github.com/spiral/roadrunner-plugins/server v1.0.6/go.mod h1:FyUujaAfNNdXCJHDkWD5pcRolNQ4cOMb6N+KapIMVpk=
+github.com/spiral/roadrunner-plugins/static v1.0.0/go.mod h1:lipuYhoSoZR95DR6hO7MOdaJKQq4JibCPC2V2BDzNXg=
 github.com/spiral/roadrunner/v2 v2.0.0-alpha26/go.mod h1:r7ojuHm9qCVbg4fKcqr4Aqk7VXqZ9YPefr1LOv7HNys=
 github.com/spiral/roadrunner/v2 v2.0.0-alpha28/go.mod h1:Uqtk/47S+qweVjSl4R9XVImEVZc3nMWku4yg3A+f18Q=
 github.com/spiral/roadrunner/v2 v2.0.0-alpha30/go.mod h1:fKmPelVQxWql3cpjt/hYsf/Y2zDKb+DbZXgxdwj2nTc=
@@ -499,6 +505,7 @@ github.com/vbauerster/mpb/v5 v5.4.0/go.mod h1:fi4wVo7BVQ22QcvFObm+VwliQXlV1eBT8J
 github.com/vmihailenco/msgpack v4.0.4+incompatible h1:dSLoQfGFAo3F6OoNhwUmLwVgaUXK79GlxNBwueZn0xI=
 github.com/vmihailenco/msgpack v4.0.4+incompatible/go.mod h1:fy3FlTQTDXWkZ7Bh6AcGMlsjHatGryHQYUTf1ShIgkk=
 github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=
+github.com/yookoala/gofast v0.4.0 h1:dLBjghcsbbZNOEHN8N1X/gh9S6srmJed4WQfG7DlKwo=
 github.com/yookoala/gofast v0.4.0/go.mod h1:rfbkoKaQG1bnuTUZcmV3vAlnfpF4FTq8WbQJf2vcpg8=
 github.com/yuin/gopher-lua v0.0.0-20191220021717-ab39c6098bdb/go.mod h1:gqRgreBUhTSL0GeU64rtZ3Uq3wtjOa/TB2YfrtkCbVQ=
 go.etcd.io/bbolt v1.3.2/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU=
diff --git a/mocks/mock_log.go b/mocks/mock_log.go
new file mode 100644
index 00000000..8e3e2836
--- /dev/null
+++ b/mocks/mock_log.go
@@ -0,0 +1,150 @@
+package mocks
+
+import (
+	"reflect"
+
+	"github.com/golang/mock/gomock"
+	"github.com/spiral/roadrunner-plugins/logger"
+)
+
+// MockLogger is a mock of Logger interface.
+type MockLogger struct {
+	ctrl     *gomock.Controller
+	recorder *MockLoggerMockRecorder
+}
+
+// MockLoggerMockRecorder is the mock recorder for MockLogger.
+type MockLoggerMockRecorder struct {
+	mock *MockLogger
+}
+
+// NewMockLogger creates a new mock instance.
+func NewMockLogger(ctrl *gomock.Controller) *MockLogger {
+	mock := &MockLogger{ctrl: ctrl}
+	mock.recorder = &MockLoggerMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockLogger) EXPECT() *MockLoggerMockRecorder {
+	return m.recorder
+}
+
+func (m *MockLogger) Init() error {
+	mock := &MockLogger{ctrl: m.ctrl}
+	mock.recorder = &MockLoggerMockRecorder{mock}
+	return nil
+}
+
+// Debug mocks base method.
+func (m *MockLogger) Debug(msg string, keyvals ...interface{}) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{msg}
+	for _, a := range keyvals {
+		varargs = append(varargs, a)
+	}
+	m.ctrl.Call(m, "Debug", varargs...)
+}
+
+// Warn mocks base method.
+func (m *MockLogger) Warn(msg string, keyvals ...interface{}) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{msg}
+	for _, a := range keyvals {
+		varargs = append(varargs, a)
+	}
+	m.ctrl.Call(m, "Warn", varargs...)
+}
+
+// Info mocks base method.
+func (m *MockLogger) Info(msg string, keyvals ...interface{}) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{msg}
+	for _, a := range keyvals {
+		varargs = append(varargs, a)
+	}
+	m.ctrl.Call(m, "Info", varargs...)
+}
+
+// Error mocks base method.
+func (m *MockLogger) Error(msg string, keyvals ...interface{}) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{msg}
+	for _, a := range keyvals {
+		varargs = append(varargs, a)
+	}
+	m.ctrl.Call(m, "Error", varargs...)
+}
+
+// Warn indicates an expected call of Warn.
+func (mr *MockLoggerMockRecorder) Warn(msg interface{}, keyvals ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{msg}, keyvals...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Warn", reflect.TypeOf((*MockLogger)(nil).Warn), varargs...)
+}
+
+// Debug indicates an expected call of Debug.
+func (mr *MockLoggerMockRecorder) Debug(msg interface{}, keyvals ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{msg}, keyvals...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Debug", reflect.TypeOf((*MockLogger)(nil).Debug), varargs...)
+}
+
+// Error indicates an expected call of Error.
+func (mr *MockLoggerMockRecorder) Error(msg interface{}, keyvals ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{msg}, keyvals...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Error", reflect.TypeOf((*MockLogger)(nil).Error), varargs...)
+}
+
+func (mr *MockLoggerMockRecorder) Init() error {
+	return nil
+}
+
+// Info indicates an expected call of Info.
+func (mr *MockLoggerMockRecorder) Info(msg interface{}, keyvals ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{msg}, keyvals...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockLogger)(nil).Info), varargs...)
+}
+
+// MockWithLogger is a mock of WithLogger interface.
+type MockWithLogger struct {
+	ctrl     *gomock.Controller
+	recorder *MockWithLoggerMockRecorder
+}
+
+// MockWithLoggerMockRecorder is the mock recorder for MockWithLogger.
+type MockWithLoggerMockRecorder struct {
+	mock *MockWithLogger
+}
+
+// NewMockWithLogger creates a new mock instance.
+func NewMockWithLogger(ctrl *gomock.Controller) *MockWithLogger {
+	mock := &MockWithLogger{ctrl: ctrl}
+	mock.recorder = &MockWithLoggerMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockWithLogger) EXPECT() *MockWithLoggerMockRecorder {
+	return m.recorder
+}
+
+// With mocks base method.
+func (m *MockWithLogger) With(keyvals ...interface{}) logger.Logger {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{}
+	for _, a := range keyvals {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "With", varargs...)
+	ret0, _ := ret[0].(logger.Logger)
+	return ret0
+}
+
+// With indicates an expected call of With.
+func (mr *MockWithLoggerMockRecorder) With(keyvals ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "With", reflect.TypeOf((*MockWithLogger)(nil).With), keyvals...)
+}
diff --git a/plugins/http/attributes/attributes.go b/plugins/http/attributes/attributes.go
new file mode 100644
index 00000000..4c453766
--- /dev/null
+++ b/plugins/http/attributes/attributes.go
@@ -0,0 +1,85 @@
+package attributes
+
+import (
+	"context"
+	"errors"
+	"net/http"
+)
+
+// contextKey is a value for use with context.WithValue. It's used as
+// a pointer so it fits in an interface{} without allocation.
+type contextKey struct {
+	name string
+}
+
+func (k *contextKey) String() string { return k.name }
+
+var (
+	// PsrContextKey is a context key. It can be used in the http attributes
+	PsrContextKey = &contextKey{"psr_attributes"}
+)
+
+type attrs map[string]interface{}
+
+func (v attrs) get(key string) interface{} {
+	if v == nil {
+		return ""
+	}
+
+	return v[key]
+}
+
+func (v attrs) set(key string, value interface{}) {
+	v[key] = value
+}
+
+func (v attrs) del(key string) {
+	delete(v, key)
+}
+
+// Init returns request with new context and attribute bag.
+func Init(r *http.Request) *http.Request {
+	return r.WithContext(context.WithValue(r.Context(), PsrContextKey, attrs{}))
+}
+
+// All returns all context attributes.
+func All(r *http.Request) map[string]interface{} {
+	v := r.Context().Value(PsrContextKey)
+	if v == nil {
+		return attrs{}
+	}
+
+	return v.(attrs)
+}
+
+// Get gets the value from request context. It replaces any existing
+// values.
+func Get(r *http.Request, key string) interface{} {
+	v := r.Context().Value(PsrContextKey)
+	if v == nil {
+		return nil
+	}
+
+	return v.(attrs).get(key)
+}
+
+// Set sets the key to value. It replaces any existing
+// values. Context specific.
+func Set(r *http.Request, key string, value interface{}) error {
+	v := r.Context().Value(PsrContextKey)
+	if v == nil {
+		return errors.New("unable to find `psr:attributes` context key")
+	}
+
+	v.(attrs).set(key, value)
+	return nil
+}
+
+// Delete deletes values associated with attribute key.
+func (v attrs) Delete(key string) {
+	if v == nil {
+		return
+	}
+
+	v.del(key)
+}
diff --git a/plugins/http/config.go b/plugins/http/config.go
new file mode 100644
index 00000000..00d2940b
--- /dev/null
+++ b/plugins/http/config.go
@@ -0,0 +1,291 @@
+package http
+
+import (
+	"net"
+	"os"
+	"runtime"
+	"strings"
+	"time"
+
+	"github.com/spiral/errors"
+	poolImpl "github.com/spiral/roadrunner/v2/pkg/pool"
+)
+
+type Cidrs []*net.IPNet
+
+func (c *Cidrs) IsTrusted(ip string) bool {
+	if len(*c) == 0 {
+		return false
+	}
+
+	i := net.ParseIP(ip)
+	if i == nil {
+		return false
+	}
+
+	for _, cird := range *c {
+		if cird.Contains(i) {
+			return true
+		}
+	}
+
+	return false
+}
+
+// Config configures RoadRunner HTTP server.
+type Config struct {
+	// Port and port to handle as http server.
+	Address string
+
+	// SSL defines https server options.
+	SSL *SSLConfig
+
+	// FCGI configuration. You can use FastCGI without HTTP server.
+	FCGI *FCGIConfig
+
+	// HTTP2 configuration
+	HTTP2 *HTTP2Config
+
+	// MaxRequestSize specified max size for payload body in megabytes, set 0 to unlimited.
+	MaxRequestSize uint64
+
+	// TrustedSubnets declare IP subnets which are allowed to set ip using X-Real-Ip and X-Forwarded-For
+	TrustedSubnets []string
+
+	// Uploads configures uploads configuration.
+	Uploads *UploadsConfig
+
+	// Pool configures worker pool.
+	Pool *poolImpl.Config
+
+	// Env is environment variables passed to the  http pool
+	Env map[string]string
+
+	// List of the middleware names (order will be preserved)
+	Middleware []string
+
+	// slice of net.IPNet
+	cidrs Cidrs
+}
+
+// FCGIConfig for FastCGI server.
+type FCGIConfig struct {
+	// Address and port to handle as http server.
+	Address string
+}
+
+// HTTP2Config HTTP/2 server customizations.
+type HTTP2Config struct {
+	// Enable or disable HTTP/2 extension, default enable.
+	Enabled bool
+
+	// H2C enables HTTP/2 over TCP
+	H2C bool
+
+	// MaxConcurrentStreams defaults to 128.
+	MaxConcurrentStreams uint32
+}
+
+// InitDefaults sets default values for HTTP/2 configuration.
+func (cfg *HTTP2Config) InitDefaults() error {
+	cfg.Enabled = true
+	cfg.MaxConcurrentStreams = 128
+
+	return nil
+}
+
+// SSLConfig defines https server configuration.
+type SSLConfig struct {
+	// Port to listen as HTTPS server, defaults to 443.
+	Port int
+
+	// Redirect when enabled forces all http connections to switch to https.
+	Redirect bool
+
+	// Key defined private server key.
+	Key string
+
+	// Cert is https certificate.
+	Cert string
+
+	// Root CA file
+	RootCA string
+}
+
+// EnableHTTP is true when http server must run.
+func (c *Config) EnableHTTP() bool {
+	return c.Address != ""
+}
+
+// EnableTLS returns true if pool must listen TLS connections.
+func (c *Config) EnableTLS() bool {
+	return c.SSL.Key != "" || c.SSL.Cert != "" || c.SSL.RootCA != ""
+}
+
+// EnableHTTP2 when HTTP/2 extension must be enabled (only with TSL).
+func (c *Config) EnableHTTP2() bool {
+	return c.HTTP2.Enabled
+}
+
+// EnableH2C when HTTP/2 extension must be enabled on TCP.
+func (c *Config) EnableH2C() bool {
+	return c.HTTP2.H2C
+}
+
+// EnableFCGI is true when FastCGI server must be enabled.
+func (c *Config) EnableFCGI() bool {
+	return c.FCGI.Address != ""
+}
+
+// Hydrate must populate Config values using given Config source. Must return error if Config is not valid.
+func (c *Config) InitDefaults() error {
+	if c.Pool == nil {
+		// default pool
+		c.Pool = &poolImpl.Config{
+			Debug:           false,
+			NumWorkers:      int64(runtime.NumCPU()),
+			MaxJobs:         1000,
+			AllocateTimeout: time.Second * 60,
+			DestroyTimeout:  time.Second * 60,
+			Supervisor:      nil,
+		}
+	}
+
+	if c.HTTP2 == nil {
+		c.HTTP2 = &HTTP2Config{}
+	}
+
+	if c.FCGI == nil {
+		c.FCGI = &FCGIConfig{}
+	}
+
+	if c.Uploads == nil {
+		c.Uploads = &UploadsConfig{}
+	}
+
+	if c.SSL == nil {
+		c.SSL = &SSLConfig{}
+	}
+
+	if c.SSL.Port == 0 {
+		c.SSL.Port = 443
+	}
+
+	err := c.HTTP2.InitDefaults()
+	if err != nil {
+		return err
+	}
+	err = c.Uploads.InitDefaults()
+	if err != nil {
+		return err
+	}
+
+	if c.TrustedSubnets == nil {
+		// @see https://en.wikipedia.org/wiki/Reserved_IP_addresses
+		c.TrustedSubnets = []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 := ParseCIDRs(c.TrustedSubnets)
+	if err != nil {
+		return err
+	}
+	c.cidrs = cidrs
+
+	return c.Valid()
+}
+
+func ParseCIDRs(subnets []string) (Cidrs, error) {
+	c := make(Cidrs, 0, len(subnets))
+	for _, cidr := range subnets {
+		_, cr, err := net.ParseCIDR(cidr)
+		if err != nil {
+			return nil, err
+		}
+
+		c = append(c, cr)
+	}
+
+	return c, nil
+}
+
+// IsTrusted if api can be trusted to use X-Real-Ip, X-Forwarded-For
+func (c *Config) IsTrusted(ip string) bool {
+	if c.cidrs == nil {
+		return false
+	}
+
+	i := net.ParseIP(ip)
+	if i == nil {
+		return false
+	}
+
+	for _, cird := range c.cidrs {
+		if cird.Contains(i) {
+			return true
+		}
+	}
+
+	return false
+}
+
+// Valid validates the configuration.
+func (c *Config) Valid() error {
+	const op = errors.Op("validation")
+	if c.Uploads == nil {
+		return errors.E(op, errors.Str("malformed uploads config"))
+	}
+
+	if c.HTTP2 == nil {
+		return errors.E(op, errors.Str("malformed http2 config"))
+	}
+
+	if c.Pool == nil {
+		return errors.E(op, "malformed pool config")
+	}
+
+	if !c.EnableHTTP() && !c.EnableTLS() && !c.EnableFCGI() {
+		return errors.E(op, errors.Str("unable to run http service, no method has been specified (http, https, http/2 or FastCGI)"))
+	}
+
+	if c.Address != "" && !strings.Contains(c.Address, ":") {
+		return errors.E(op, errors.Str("malformed http server address"))
+	}
+
+	if c.EnableTLS() {
+		if _, err := os.Stat(c.SSL.Key); err != nil {
+			if os.IsNotExist(err) {
+				return errors.E(op, errors.Errorf("key file '%s' does not exists", c.SSL.Key))
+			}
+
+			return err
+		}
+
+		if _, err := os.Stat(c.SSL.Cert); err != nil {
+			if os.IsNotExist(err) {
+				return errors.E(op, errors.Errorf("cert file '%s' does not exists", c.SSL.Cert))
+			}
+
+			return err
+		}
+
+		// RootCA is optional, but if provided - check it
+		if c.SSL.RootCA != "" {
+			if _, err := os.Stat(c.SSL.RootCA); err != nil {
+				if os.IsNotExist(err) {
+					return errors.E(op, errors.Errorf("root ca path provided, but path '%s' does not exists", c.SSL.RootCA))
+				}
+				return err
+			}
+		}
+	}
+
+	return nil
+}
diff --git a/plugins/http/constants.go b/plugins/http/constants.go
new file mode 100644
index 00000000..773d1f46
--- /dev/null
+++ b/plugins/http/constants.go
@@ -0,0 +1,6 @@
+package http
+
+import "net/http"
+
+var http2pushHeaderKey = http.CanonicalHeaderKey("http2-push")
+var TrailerHeaderKey = http.CanonicalHeaderKey("trailer")
diff --git a/plugins/http/errors.go b/plugins/http/errors.go
new file mode 100644
index 00000000..fb8762ef
--- /dev/null
+++ b/plugins/http/errors.go
@@ -0,0 +1,25 @@
+// +build !windows
+
+package http
+
+import (
+	"errors"
+	"net"
+	"os"
+	"syscall"
+)
+
+// Broken pipe
+var errEPIPE = errors.New("EPIPE(32) -> connection reset by peer")
+
+// handleWriteError just check if error was caused by aborted connection on linux
+func handleWriteError(err error) error {
+	if netErr, ok2 := err.(*net.OpError); ok2 {
+		if syscallErr, ok3 := netErr.Err.(*os.SyscallError); ok3 {
+			if syscallErr.Err == syscall.EPIPE {
+				return errEPIPE
+			}
+		}
+	}
+	return err
+}
diff --git a/plugins/http/errors_windows.go b/plugins/http/errors_windows.go
new file mode 100644
index 00000000..3d0ba04c
--- /dev/null
+++ b/plugins/http/errors_windows.go
@@ -0,0 +1,27 @@
+// +build windows
+
+package http
+
+import (
+	"errors"
+	"net"
+	"os"
+	"syscall"
+)
+
+//Software caused connection abort.
+//An established connection was aborted by the software in your host computer,
+//possibly due to a data transmission time-out or protocol error.
+var errEPIPE = errors.New("WSAECONNABORTED (10053) ->  an established connection was aborted by peer")
+
+// handleWriteError just check if error was caused by aborted connection on windows
+func handleWriteError(err error) error {
+	if netErr, ok2 := err.(*net.OpError); ok2 {
+		if syscallErr, ok3 := netErr.Err.(*os.SyscallError); ok3 {
+			if syscallErr.Err == syscall.WSAECONNABORTED {
+				return errEPIPE
+			}
+		}
+	}
+	return err
+}
diff --git a/plugins/http/handler.go b/plugins/http/handler.go
new file mode 100644
index 00000000..08cee661
--- /dev/null
+++ b/plugins/http/handler.go
@@ -0,0 +1,240 @@
+package http
+
+import (
+	"net"
+	"net/http"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/hashicorp/go-multierror"
+	"github.com/spiral/errors"
+	"github.com/spiral/roadrunner-plugins/logger"
+	"github.com/spiral/roadrunner/v2/interfaces/events"
+	"github.com/spiral/roadrunner/v2/interfaces/pool"
+)
+
+const (
+	// EventResponse thrown after the request been processed. See ErrorEvent as payload.
+	EventResponse = iota + 500
+
+	// EventError thrown on any non job error provided by road runner server.
+	EventError
+)
+
+const MB = 1024 * 1024
+
+type Handle interface {
+	AddListener(l events.EventListener)
+	ServeHTTP(w http.ResponseWriter, r *http.Request)
+}
+
+// ErrorEvent represents singular http error event.
+type ErrorEvent struct {
+	// Request contains client request, must not be stored.
+	Request *http.Request
+
+	// Error - associated error, if any.
+	Error error
+
+	// event timings
+	start   time.Time
+	elapsed time.Duration
+}
+
+// Elapsed returns duration of the invocation.
+func (e *ErrorEvent) Elapsed() time.Duration {
+	return e.elapsed
+}
+
+// ResponseEvent represents singular http response event.
+type ResponseEvent struct {
+	// Request contains client request, must not be stored.
+	Request *Request
+
+	// Response contains service response.
+	Response *Response
+
+	// event timings
+	start   time.Time
+	elapsed time.Duration
+}
+
+// Elapsed returns duration of the invocation.
+func (e *ResponseEvent) Elapsed() time.Duration {
+	return e.elapsed
+}
+
+// Handler serves http connections to underlying PHP application using PSR-7 protocol. Context will include request headers,
+// parsed files and query, payload will include parsed form dataTree (if any).
+type handler struct {
+	maxRequestSize uint64
+	uploads        UploadsConfig
+	trusted        Cidrs
+	log            logger.Logger
+	pool           pool.Pool
+	mul            sync.Mutex
+	lsn            events.EventListener
+}
+
+func NewHandler(maxReqSize uint64, uploads UploadsConfig, trusted Cidrs, pool pool.Pool) (Handle, error) {
+	if pool == nil {
+		return nil, errors.E(errors.Str("pool should be initialized"))
+	}
+	return &handler{
+		maxRequestSize: maxReqSize * MB,
+		uploads:        uploads,
+		pool:           pool,
+		trusted:        trusted,
+	}, nil
+}
+
+// Listen attaches handler event controller.
+func (h *handler) AddListener(l events.EventListener) {
+	h.mul.Lock()
+	defer h.mul.Unlock()
+
+	h.lsn = l
+}
+
+// mdwr serve using PSR-7 requests passed to underlying application. Attempts to serve static files first if enabled.
+func (h *handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	const op = errors.Op("ServeHTTP")
+	start := time.Now()
+
+	// validating request size
+	if h.maxRequestSize != 0 {
+		err := h.maxSize(w, r, start, op)
+		if err != nil {
+			return
+		}
+	}
+
+	req, err := NewRequest(r, h.uploads)
+	if err != nil {
+		h.handleError(w, r, err, start)
+		return
+	}
+
+	// proxy IP resolution
+	h.resolveIP(req)
+
+	req.Open(h.log)
+	defer req.Close(h.log)
+
+	p, err := req.Payload()
+	if err != nil {
+		h.handleError(w, r, err, start)
+		return
+	}
+
+	rsp, err := h.pool.Exec(p)
+	if err != nil {
+		h.handleError(w, r, err, start)
+		return
+	}
+
+	resp, err := NewResponse(rsp)
+	if err != nil {
+		h.handleError(w, r, err, start)
+		return
+	}
+
+	h.handleResponse(req, resp, start)
+	err = resp.Write(w)
+	if err != nil {
+		h.handleError(w, r, err, start)
+	}
+}
+
+func (h *handler) maxSize(w http.ResponseWriter, r *http.Request, start time.Time, op errors.Op) error {
+	if length := r.Header.Get("content-length"); length != "" {
+		if size, err := strconv.ParseInt(length, 10, 64); err != nil {
+			h.handleError(w, r, err, start)
+			return err
+		} else if size > int64(h.maxRequestSize) {
+			h.handleError(w, r, errors.E(op, errors.Str("request body max size is exceeded")), start)
+			return err
+		}
+	}
+	return nil
+}
+
+// handleError sends error.
+func (h *handler) handleError(w http.ResponseWriter, r *http.Request, err error, start time.Time) {
+	h.mul.Lock()
+	defer h.mul.Unlock()
+	// if pipe is broken, there is no sense to write the header
+	// in this case we just report about error
+	if err == errEPIPE {
+		h.throw(ErrorEvent{Request: r, Error: err, start: start, elapsed: time.Since(start)})
+		return
+	}
+	err = multierror.Append(err)
+	// ResponseWriter is ok, write the error code
+	w.WriteHeader(500)
+	_, err2 := w.Write([]byte(err.Error()))
+	// error during the writing to the ResponseWriter
+	if err2 != nil {
+		err = multierror.Append(err2, err)
+		// concat original error with ResponseWriter error
+		h.throw(ErrorEvent{Request: r, Error: errors.E(err), start: start, elapsed: time.Since(start)})
+		return
+	}
+	h.throw(ErrorEvent{Request: r, Error: err, start: start, elapsed: time.Since(start)})
+}
+
+// handleResponse triggers response event.
+func (h *handler) handleResponse(req *Request, resp *Response, start time.Time) {
+	h.throw(ResponseEvent{Request: req, Response: resp, start: start, elapsed: time.Since(start)})
+}
+
+// throw invokes event handler if any.
+func (h *handler) throw(event interface{}) {
+	if h.lsn != nil {
+		h.lsn(event)
+	}
+}
+
+// get real ip passing multiple proxy
+func (h *handler) resolveIP(r *Request) {
+	if h.trusted.IsTrusted(r.RemoteAddr) == false {
+		return
+	}
+
+	if r.Header.Get("X-Forwarded-For") != "" {
+		ips := strings.Split(r.Header.Get("X-Forwarded-For"), ",")
+		ipCount := len(ips)
+
+		for i := ipCount - 1; i >= 0; i-- {
+			addr := strings.TrimSpace(ips[i])
+			if net.ParseIP(addr) != nil {
+				r.RemoteAddr = addr
+				return
+			}
+		}
+
+		return
+	}
+
+	// The logic here is the following:
+	// In general case, we only expect X-Real-Ip header. If it exist, we get the IP address from header and set request Remote address
+	// But, if there is no X-Real-Ip header, we also trying to check CloudFlare headers
+	// True-Client-IP is a general CF header in which copied information from X-Real-Ip in CF.
+	// CF-Connecting-IP is an Enterprise feature and we check it last in order.
+	// This operations are near O(1) because Headers struct are the map type -> type MIMEHeader map[string][]string
+	if r.Header.Get("X-Real-Ip") != "" {
+		r.RemoteAddr = fetchIP(r.Header.Get("X-Real-Ip"))
+		return
+	}
+
+	if r.Header.Get("True-Client-IP") != "" {
+		r.RemoteAddr = fetchIP(r.Header.Get("True-Client-IP"))
+		return
+	}
+
+	if r.Header.Get("CF-Connecting-IP") != "" {
+		r.RemoteAddr = fetchIP(r.Header.Get("CF-Connecting-IP"))
+	}
+}
diff --git a/plugins/http/parse.go b/plugins/http/parse.go
new file mode 100644
index 00000000..d4a1604b
--- /dev/null
+++ b/plugins/http/parse.go
@@ -0,0 +1,147 @@
+package http
+
+import (
+	"net/http"
+)
+
+// MaxLevel defines maximum tree depth for incoming request data and files.
+const MaxLevel = 127
+
+type dataTree map[string]interface{}
+type fileTree map[string]interface{}
+
+// parseData parses incoming request body into data tree.
+func parseData(r *http.Request) dataTree {
+	data := make(dataTree)
+	if r.PostForm != nil {
+		for k, v := range r.PostForm {
+			data.push(k, v)
+		}
+	}
+
+	if r.MultipartForm != nil {
+		for k, v := range r.MultipartForm.Value {
+			data.push(k, v)
+		}
+	}
+
+	return data
+}
+
+// pushes value into data tree.
+func (d dataTree) push(k string, v []string) {
+	keys := FetchIndexes(k)
+	if len(keys) <= MaxLevel {
+		d.mount(keys, v)
+	}
+}
+
+// mount mounts data tree recursively.
+func (d dataTree) mount(i []string, v []string) {
+	if len(i) == 1 {
+		// single value context (last element)
+		d[i[0]] = v[len(v)-1]
+		return
+	}
+
+	if len(i) == 2 && i[1] == "" {
+		// non associated array of elements
+		d[i[0]] = v
+		return
+	}
+
+	if p, ok := d[i[0]]; ok {
+		p.(dataTree).mount(i[1:], v)
+		return
+	}
+
+	d[i[0]] = make(dataTree)
+	d[i[0]].(dataTree).mount(i[1:], v)
+}
+
+// parse incoming dataTree request into JSON (including contentMultipart form dataTree)
+func parseUploads(r *http.Request, cfg UploadsConfig) *Uploads {
+	u := &Uploads{
+		cfg:  cfg,
+		tree: make(fileTree),
+		list: make([]*FileUpload, 0),
+	}
+
+	for k, v := range r.MultipartForm.File {
+		files := make([]*FileUpload, 0, len(v))
+		for _, f := range v {
+			files = append(files, NewUpload(f))
+		}
+
+		u.list = append(u.list, files...)
+		u.tree.push(k, files)
+	}
+
+	return u
+}
+
+// pushes new file upload into it's proper place.
+func (d fileTree) push(k string, v []*FileUpload) {
+	keys := FetchIndexes(k)
+	if len(keys) <= MaxLevel {
+		d.mount(keys, v)
+	}
+}
+
+// mount mounts data tree recursively.
+func (d fileTree) mount(i []string, v []*FileUpload) {
+	if len(i) == 1 {
+		// single value context
+		d[i[0]] = v[0]
+		return
+	}
+
+	if len(i) == 2 && i[1] == "" {
+		// non associated array of elements
+		d[i[0]] = v
+		return
+	}
+
+	if p, ok := d[i[0]]; ok {
+		p.(fileTree).mount(i[1:], v)
+		return
+	}
+
+	d[i[0]] = make(fileTree)
+	d[i[0]].(fileTree).mount(i[1:], v)
+}
+
+// FetchIndexes parses input name and splits it into separate indexes list.
+func FetchIndexes(s string) []string {
+	var (
+		pos  int
+		ch   string
+		keys = make([]string, 1)
+	)
+
+	for _, c := range s {
+		ch = string(c)
+		switch ch {
+		case " ":
+			// ignore all spaces
+			continue
+		case "[":
+			pos = 1
+			continue
+		case "]":
+			if pos == 1 {
+				keys = append(keys, "")
+			}
+			pos = 2
+		default:
+			if pos == 1 || pos == 2 {
+				keys = append(keys, "")
+			}
+
+			keys[len(keys)-1] += ch
+			pos = 0
+		}
+	}
+
+	return keys
+}
diff --git a/plugins/http/plugin.go b/plugins/http/plugin.go
new file mode 100644
index 00000000..301468d1
--- /dev/null
+++ b/plugins/http/plugin.go
@@ -0,0 +1,528 @@
+package http
+
+import (
+	"context"
+	"crypto/tls"
+	"crypto/x509"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"net/http/fcgi"
+	"net/url"
+	"strings"
+	"sync"
+
+	"github.com/hashicorp/go-multierror"
+	"github.com/spiral/endure"
+	"github.com/spiral/errors"
+	"github.com/spiral/roadrunner-plugins/checker"
+	"github.com/spiral/roadrunner-plugins/config"
+	"github.com/spiral/roadrunner-plugins/logger"
+	"github.com/spiral/roadrunner/v2/interfaces/pool"
+	"github.com/spiral/roadrunner/v2/interfaces/worker"
+	poolImpl "github.com/spiral/roadrunner/v2/pkg/pool"
+	"github.com/spiral/roadrunner/v2/plugins/http/attributes"
+	"github.com/spiral/roadrunner/v2/plugins/server"
+	"github.com/spiral/roadrunner/v2/util"
+	"golang.org/x/net/http2"
+	"golang.org/x/net/http2/h2c"
+	"golang.org/x/sys/cpu"
+)
+
+const (
+	// PluginName declares plugin name.
+	PluginName = "http"
+
+	// EventInitSSL thrown at moment of https initialization. SSL server passed as context.
+	EventInitSSL = 750
+)
+
+// Middleware interface
+type Middleware interface {
+	Middleware(f http.Handler) http.HandlerFunc
+}
+
+type middleware map[string]Middleware
+
+// Service manages pool, http servers.
+type Plugin struct {
+	sync.RWMutex
+
+	configurer config.Configurer
+	server     server.Server
+	log        logger.Logger
+
+	cfg *Config
+	// middlewares to chain
+	mdwr middleware
+
+	// Pool which attached to all servers
+	pool pool.Pool
+
+	// servers RR handler
+	handler Handle
+
+	// servers
+	http  *http.Server
+	https *http.Server
+	fcgi  *http.Server
+}
+
+// Init must return configure svc and return true if svc hasStatus enabled. Must return error in case of
+// misconfiguration. Services must not be used without proper configuration pushed first.
+func (s *Plugin) Init(cfg config.Configurer, log logger.Logger, server server.Server) error {
+	const op = errors.Op("http Init")
+	err := cfg.UnmarshalKey(PluginName, &s.cfg)
+	if err != nil {
+		return errors.E(op, err)
+	}
+
+	err = s.cfg.InitDefaults()
+	if err != nil {
+		return errors.E(op, err)
+	}
+
+	s.configurer = cfg
+	s.log = log
+	s.mdwr = make(map[string]Middleware)
+
+	if !s.cfg.EnableHTTP() && !s.cfg.EnableTLS() && !s.cfg.EnableFCGI() {
+		return errors.E(op, errors.Disabled)
+	}
+
+	s.pool, err = server.NewWorkerPool(context.Background(), poolImpl.Config{
+		Debug:           s.cfg.Pool.Debug,
+		NumWorkers:      s.cfg.Pool.NumWorkers,
+		MaxJobs:         s.cfg.Pool.MaxJobs,
+		AllocateTimeout: s.cfg.Pool.AllocateTimeout,
+		DestroyTimeout:  s.cfg.Pool.DestroyTimeout,
+		Supervisor:      s.cfg.Pool.Supervisor,
+	}, s.cfg.Env, s.logCallback)
+	if err != nil {
+		return errors.E(op, err)
+	}
+
+	s.server = server
+
+	return nil
+}
+
+func (s *Plugin) logCallback(event interface{}) {
+	if ev, ok := event.(ResponseEvent); ok {
+		s.log.Debug("http handler response received", "elapsed", ev.Elapsed().String(), "remote address", ev.Request.RemoteAddr)
+	}
+}
+
+// Serve serves the svc.
+func (s *Plugin) Serve() chan error {
+	s.Lock()
+	defer s.Unlock()
+
+	const op = errors.Op("serve http")
+	errCh := make(chan error, 2)
+
+	var err error
+	s.handler, err = NewHandler(
+		s.cfg.MaxRequestSize,
+		*s.cfg.Uploads,
+		s.cfg.cidrs,
+		s.pool,
+	)
+	if err != nil {
+		errCh <- errors.E(op, err)
+		return errCh
+	}
+
+	s.handler.AddListener(s.logCallback)
+
+	if s.cfg.EnableHTTP() {
+		if s.cfg.EnableH2C() {
+			s.http = &http.Server{Addr: s.cfg.Address, Handler: h2c.NewHandler(s, &http2.Server{})}
+		} else {
+			s.http = &http.Server{Addr: s.cfg.Address, Handler: s}
+		}
+	}
+
+	if s.cfg.EnableTLS() {
+		s.https = s.initSSL()
+		if s.cfg.SSL.RootCA != "" {
+			err = s.appendRootCa()
+			if err != nil {
+				errCh <- errors.E(op, err)
+				return errCh
+			}
+		}
+
+		if s.cfg.EnableHTTP2() {
+			if err := s.initHTTP2(); err != nil {
+				errCh <- errors.E(op, err)
+				return errCh
+			}
+		}
+	}
+
+	if s.cfg.EnableFCGI() {
+		s.fcgi = &http.Server{Handler: s}
+	}
+
+	// apply middlewares before starting the server
+	if len(s.mdwr) > 0 {
+		s.addMiddlewares()
+	}
+
+	if s.http != nil {
+		go func() {
+			httpErr := s.http.ListenAndServe()
+			if httpErr != nil && httpErr != http.ErrServerClosed {
+				errCh <- errors.E(op, httpErr)
+				return
+			}
+		}()
+	}
+
+	if s.https != nil {
+		go func() {
+			httpErr := s.https.ListenAndServeTLS(
+				s.cfg.SSL.Cert,
+				s.cfg.SSL.Key,
+			)
+
+			if httpErr != nil && httpErr != http.ErrServerClosed {
+				errCh <- errors.E(op, httpErr)
+				return
+			}
+		}()
+	}
+
+	if s.fcgi != nil {
+		go func() {
+			httpErr := s.serveFCGI()
+			if httpErr != nil && httpErr != http.ErrServerClosed {
+				errCh <- errors.E(op, httpErr)
+				return
+			}
+		}()
+	}
+
+	return errCh
+}
+
+// Stop stops the http.
+func (s *Plugin) Stop() error {
+	s.Lock()
+	defer s.Unlock()
+
+	var err error
+	if s.fcgi != nil {
+		err = s.fcgi.Shutdown(context.Background())
+		if err != nil && err != http.ErrServerClosed {
+			s.log.Error("error shutting down the fcgi server", "error", err)
+			// write error and try to stop other transport
+			err = multierror.Append(err)
+		}
+	}
+
+	if s.https != nil {
+		err = s.https.Shutdown(context.Background())
+		if err != nil && err != http.ErrServerClosed {
+			s.log.Error("error shutting down the https server", "error", err)
+			// write error and try to stop other transport
+			err = multierror.Append(err)
+		}
+	}
+
+	if s.http != nil {
+		err = s.http.Shutdown(context.Background())
+		if err != nil && err != http.ErrServerClosed {
+			s.log.Error("error shutting down the http server", "error", err)
+			// write error and try to stop other transport
+			err = multierror.Append(err)
+		}
+	}
+
+	s.pool.Destroy(context.Background())
+
+	return err
+}
+
+// ServeHTTP handles connection using set of middleware and pool PSR-7 server.
+func (s *Plugin) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	if headerContainsUpgrade(r, s) {
+		http.Error(w, "server does not support upgrade header", http.StatusInternalServerError)
+		return
+	}
+
+	if s.redirect(w, r) {
+		return
+	}
+
+	if s.https != nil && r.TLS != nil {
+		w.Header().Add("Strict-Transport-Security", "max-age=31536000; includeSubDomains; preload")
+	}
+
+	r = attributes.Init(r)
+	// protect the case, when user send Reset and we are replacing handler with pool
+	s.RLock()
+	s.handler.ServeHTTP(w, r)
+	s.RUnlock()
+}
+
+// Server returns associated pool workers
+func (s *Plugin) Workers() []worker.BaseProcess {
+	return s.pool.Workers()
+}
+
+func (s *Plugin) Name() string {
+	return PluginName
+}
+
+func (s *Plugin) Reset() error {
+	s.Lock()
+	defer s.Unlock()
+	const op = errors.Op("http reset")
+	s.log.Info("HTTP plugin got restart request. Restarting...")
+	s.pool.Destroy(context.Background())
+	s.pool = nil
+
+	// re-read the config
+	err := s.configurer.UnmarshalKey(PluginName, &s.cfg)
+	if err != nil {
+		return errors.E(op, err)
+	}
+
+	s.pool, err = s.server.NewWorkerPool(context.Background(), poolImpl.Config{
+		Debug:           s.cfg.Pool.Debug,
+		NumWorkers:      s.cfg.Pool.NumWorkers,
+		MaxJobs:         s.cfg.Pool.MaxJobs,
+		AllocateTimeout: s.cfg.Pool.AllocateTimeout,
+		DestroyTimeout:  s.cfg.Pool.DestroyTimeout,
+		Supervisor:      s.cfg.Pool.Supervisor,
+	}, s.cfg.Env, s.logCallback)
+	if err != nil {
+		return errors.E(op, err)
+	}
+
+	s.log.Info("HTTP listeners successfully re-added")
+
+	s.log.Info("HTTP workers Pool successfully restarted")
+	s.handler, err = NewHandler(
+		s.cfg.MaxRequestSize,
+		*s.cfg.Uploads,
+		s.cfg.cidrs,
+		s.pool,
+	)
+	if err != nil {
+		return errors.E(op, err)
+	}
+
+	s.log.Info("HTTP plugin successfully restarted")
+	return nil
+}
+
+func (s *Plugin) Collects() []interface{} {
+	return []interface{}{
+		s.AddMiddleware,
+	}
+}
+
+func (s *Plugin) AddMiddleware(name endure.Named, m Middleware) {
+	s.mdwr[name.Name()] = m
+}
+
+// Status return status of the particular plugin
+func (s *Plugin) Status() checker.Status {
+	workers := s.Workers()
+	for i := 0; i < len(workers); i++ {
+		if workers[i].State().IsActive() {
+			return checker.Status{
+				Code: http.StatusOK,
+			}
+		}
+	}
+	// if there are no workers, threat this as error
+	return checker.Status{
+		Code: http.StatusInternalServerError,
+	}
+}
+
+func (s *Plugin) redirect(w http.ResponseWriter, r *http.Request) bool {
+	if s.https != nil && r.TLS == nil && s.cfg.SSL.Redirect {
+		target := &url.URL{
+			Scheme:   "https",
+			Host:     s.tlsAddr(r.Host, false),
+			Path:     r.URL.Path,
+			RawQuery: r.URL.RawQuery,
+		}
+
+		http.Redirect(w, r, target.String(), http.StatusTemporaryRedirect)
+		return true
+	}
+	return false
+}
+
+func headerContainsUpgrade(r *http.Request, s *Plugin) bool {
+	if _, ok := r.Header["Upgrade"]; ok {
+		// https://golang.org/pkg/net/http/#Hijacker
+		s.log.Error("server does not support Upgrade header")
+		return true
+	}
+	return false
+}
+
+// append RootCA to the https server TLS config
+func (s *Plugin) appendRootCa() error {
+	const op = errors.Op("append root CA")
+	rootCAs, err := x509.SystemCertPool()
+	if err != nil {
+		return nil
+	}
+	if rootCAs == nil {
+		rootCAs = x509.NewCertPool()
+	}
+
+	CA, err := ioutil.ReadFile(s.cfg.SSL.RootCA)
+	if err != nil {
+		return err
+	}
+
+	// should append our CA cert
+	ok := rootCAs.AppendCertsFromPEM(CA)
+	if !ok {
+		return errors.E(op, errors.Str("could not append Certs from PEM"))
+	}
+	// disable "G402 (CWE-295): TLS MinVersion too low. (Confidence: HIGH, Severity: HIGH)"
+	// #nosec G402
+	cfg := &tls.Config{
+		InsecureSkipVerify: false,
+		RootCAs:            rootCAs,
+	}
+	s.http.TLSConfig = cfg
+
+	return nil
+}
+
+// Init https server
+func (s *Plugin) initSSL() *http.Server {
+	var topCipherSuites []uint16
+	var defaultCipherSuitesTLS13 []uint16
+
+	hasGCMAsmAMD64 := cpu.X86.HasAES && cpu.X86.HasPCLMULQDQ
+	hasGCMAsmARM64 := cpu.ARM64.HasAES && cpu.ARM64.HasPMULL
+	// Keep in sync with crypto/aes/cipher_s390x.go.
+	hasGCMAsmS390X := cpu.S390X.HasAES && cpu.S390X.HasAESCBC && cpu.S390X.HasAESCTR && (cpu.S390X.HasGHASH || cpu.S390X.HasAESGCM)
+
+	hasGCMAsm := hasGCMAsmAMD64 || hasGCMAsmARM64 || hasGCMAsmS390X
+
+	if hasGCMAsm {
+		// If AES-GCM hardware is provided then prioritise AES-GCM
+		// cipher suites.
+		topCipherSuites = []uint16{
+			tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
+			tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
+			tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
+			tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
+			tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305,
+			tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305,
+		}
+		defaultCipherSuitesTLS13 = []uint16{
+			tls.TLS_AES_128_GCM_SHA256,
+			tls.TLS_CHACHA20_POLY1305_SHA256,
+			tls.TLS_AES_256_GCM_SHA384,
+		}
+	} else {
+		// Without AES-GCM hardware, we put the ChaCha20-Poly1305
+		// cipher suites first.
+		topCipherSuites = []uint16{
+			tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305,
+			tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305,
+			tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
+			tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
+			tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
+			tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
+		}
+		defaultCipherSuitesTLS13 = []uint16{
+			tls.TLS_CHACHA20_POLY1305_SHA256,
+			tls.TLS_AES_128_GCM_SHA256,
+			tls.TLS_AES_256_GCM_SHA384,
+		}
+	}
+
+	DefaultCipherSuites := make([]uint16, 0, 22)
+	DefaultCipherSuites = append(DefaultCipherSuites, topCipherSuites...)
+	DefaultCipherSuites = append(DefaultCipherSuites, defaultCipherSuitesTLS13...)
+
+	server := &http.Server{
+		Addr:    s.tlsAddr(s.cfg.Address, true),
+		Handler: s,
+		TLSConfig: &tls.Config{
+			CurvePreferences: []tls.CurveID{
+				tls.CurveP256,
+				tls.CurveP384,
+				tls.CurveP521,
+				tls.X25519,
+			},
+			CipherSuites:             DefaultCipherSuites,
+			MinVersion:               tls.VersionTLS12,
+			PreferServerCipherSuites: true,
+		},
+	}
+
+	return server
+}
+
+// init http/2 server
+func (s *Plugin) initHTTP2() error {
+	return http2.ConfigureServer(s.https, &http2.Server{
+		MaxConcurrentStreams: s.cfg.HTTP2.MaxConcurrentStreams,
+	})
+}
+
+// serveFCGI starts FastCGI server.
+func (s *Plugin) serveFCGI() error {
+	l, err := util.CreateListener(s.cfg.FCGI.Address)
+	if err != nil {
+		return err
+	}
+
+	err = fcgi.Serve(l, s.fcgi.Handler)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// tlsAddr replaces listen or host port with port configured by SSL config.
+func (s *Plugin) tlsAddr(host string, forcePort bool) string {
+	// remove current forcePort first
+	host = strings.Split(host, ":")[0]
+
+	if forcePort || s.cfg.SSL.Port != 443 {
+		host = fmt.Sprintf("%s:%v", host, s.cfg.SSL.Port)
+	}
+
+	return host
+}
+
+func (s *Plugin) addMiddlewares() {
+	if s.http != nil {
+		applyMiddlewares(s.http, s.mdwr, s.cfg.Middleware, s.log)
+	}
+	if s.https != nil {
+		applyMiddlewares(s.https, s.mdwr, s.cfg.Middleware, s.log)
+	}
+
+	if s.fcgi != nil {
+		applyMiddlewares(s.fcgi, s.mdwr, s.cfg.Middleware, s.log)
+	}
+}
+
+func applyMiddlewares(server *http.Server, middlewares map[string]Middleware, order []string, log logger.Logger) {
+	for i := 0; i < len(order); i++ {
+		if mdwr, ok := middlewares[order[i]]; ok {
+			server.Handler = mdwr.Middleware(server.Handler)
+		} else {
+			log.Warn("requested middleware does not exist", "requested", order[i])
+		}
+	}
+}
diff --git a/plugins/http/request.go b/plugins/http/request.go
new file mode 100644
index 00000000..16243bcc
--- /dev/null
+++ b/plugins/http/request.go
@@ -0,0 +1,186 @@
+package http
+
+import (
+	"fmt"
+	"io/ioutil"
+	"net"
+	"net/http"
+	"net/url"
+	"strings"
+
+	j "github.com/json-iterator/go"
+	"github.com/spiral/roadrunner-plugins/logger"
+	"github.com/spiral/roadrunner/v2/pkg/payload"
+	"github.com/spiral/roadrunner/v2/plugins/http/attributes"
+)
+
+var json = j.ConfigCompatibleWithStandardLibrary
+
+const (
+	defaultMaxMemory = 32 << 20 // 32 MB
+	contentNone      = iota + 900
+	contentStream
+	contentMultipart
+	contentFormData
+)
+
+// Request maps net/http requests to PSR7 compatible structure and managed state of temporary uploaded files.
+type Request struct {
+	// RemoteAddr contains ip address of client, make sure to check X-Real-Ip and X-Forwarded-For for real client address.
+	RemoteAddr string `json:"remoteAddr"`
+
+	// Protocol includes HTTP protocol version.
+	Protocol string `json:"protocol"`
+
+	// Method contains name of HTTP method used for the request.
+	Method string `json:"method"`
+
+	// URI contains full request URI with scheme and query.
+	URI string `json:"uri"`
+
+	// Header contains list of request headers.
+	Header http.Header `json:"headers"`
+
+	// Cookies contains list of request cookies.
+	Cookies map[string]string `json:"cookies"`
+
+	// RawQuery contains non parsed query string (to be parsed on php end).
+	RawQuery string `json:"rawQuery"`
+
+	// Parsed indicates that request body has been parsed on RR end.
+	Parsed bool `json:"parsed"`
+
+	// Uploads contains list of uploaded files, their names, sized and associations with temporary files.
+	Uploads *Uploads `json:"uploads"`
+
+	// Attributes can be set by chained mdwr to safely pass value from Golang to PHP. See: GetAttribute, SetAttribute functions.
+	Attributes map[string]interface{} `json:"attributes"`
+
+	// request body can be parsedData or []byte
+	body interface{}
+}
+
+func fetchIP(pair string) string {
+	if !strings.ContainsRune(pair, ':') {
+		return pair
+	}
+
+	addr, _, _ := net.SplitHostPort(pair)
+	return addr
+}
+
+// NewRequest creates new PSR7 compatible request using net/http request.
+func NewRequest(r *http.Request, cfg UploadsConfig) (*Request, error) {
+	req := &Request{
+		RemoteAddr: fetchIP(r.RemoteAddr),
+		Protocol:   r.Proto,
+		Method:     r.Method,
+		URI:        uri(r),
+		Header:     r.Header,
+		Cookies:    make(map[string]string),
+		RawQuery:   r.URL.RawQuery,
+		Attributes: attributes.All(r),
+	}
+
+	for _, c := range r.Cookies() {
+		if v, err := url.QueryUnescape(c.Value); err == nil {
+			req.Cookies[c.Name] = v
+		}
+	}
+
+	switch req.contentType() {
+	case contentNone:
+		return req, nil
+
+	case contentStream:
+		var err error
+		req.body, err = ioutil.ReadAll(r.Body)
+		return req, err
+
+	case contentMultipart:
+		if err := r.ParseMultipartForm(defaultMaxMemory); err != nil {
+			return nil, err
+		}
+
+		req.Uploads = parseUploads(r, cfg)
+		fallthrough
+	case contentFormData:
+		if err := r.ParseForm(); err != nil {
+			return nil, err
+		}
+
+		req.body = parseData(r)
+	}
+
+	req.Parsed = true
+	return req, nil
+}
+
+// Open moves all uploaded files to temporary directory so it can be given to php later.
+func (r *Request) Open(log logger.Logger) {
+	if r.Uploads == nil {
+		return
+	}
+
+	r.Uploads.Open(log)
+}
+
+// Close clears all temp file uploads
+func (r *Request) Close(log logger.Logger) {
+	if r.Uploads == nil {
+		return
+	}
+
+	r.Uploads.Clear(log)
+}
+
+// Payload request marshaled RoadRunner payload based on PSR7 data. values encode method is JSON. Make sure to open
+// files prior to calling this method.
+func (r *Request) Payload() (payload.Payload, error) {
+	p := payload.Payload{}
+
+	var err error
+	if p.Context, err = json.Marshal(r); err != nil {
+		return payload.Payload{}, err
+	}
+
+	if r.Parsed {
+		if p.Body, err = json.Marshal(r.body); err != nil {
+			return payload.Payload{}, err
+		}
+	} else if r.body != nil {
+		p.Body = r.body.([]byte)
+	}
+
+	return p, nil
+}
+
+// contentType returns the payload content type.
+func (r *Request) contentType() int {
+	if r.Method == "HEAD" || r.Method == "OPTIONS" {
+		return contentNone
+	}
+
+	ct := r.Header.Get("content-type")
+	if strings.Contains(ct, "application/x-www-form-urlencoded") {
+		return contentFormData
+	}
+
+	if strings.Contains(ct, "multipart/form-data") {
+		return contentMultipart
+	}
+
+	return contentStream
+}
+
+// uri fetches full uri from request in a form of string (including https scheme if TLS connection is enabled).
+func uri(r *http.Request) string {
+	if r.URL.Host != "" {
+		return r.URL.String()
+	}
+	if r.TLS != nil {
+		return fmt.Sprintf("https://%s%s", r.Host, r.URL.String())
+	}
+
+	return fmt.Sprintf("http://%s%s", r.Host, r.URL.String())
+}
diff --git a/plugins/http/response.go b/plugins/http/response.go
new file mode 100644
index 00000000..17049ce1
--- /dev/null
+++ b/plugins/http/response.go
@@ -0,0 +1,105 @@
+package http
+
+import (
+	"io"
+	"net/http"
+	"strings"
+	"sync"
+
+	"github.com/spiral/roadrunner/v2/pkg/payload"
+)
+
+// Response handles PSR7 response logic.
+type Response struct {
+	// Status contains response status.
+	Status int `json:"status"`
+
+	// Header contains list of response headers.
+	Headers map[string][]string `json:"headers"`
+
+	// associated Body payload.
+	Body interface{}
+	sync.Mutex
+}
+
+// NewResponse creates new response based on given pool payload.
+func NewResponse(p payload.Payload) (*Response, error) {
+	r := &Response{Body: p.Body}
+	if err := json.Unmarshal(p.Context, r); err != nil {
+		return nil, err
+	}
+
+	return r, nil
+}
+
+// Write writes response headers, status and body into ResponseWriter.
+func (r *Response) Write(w http.ResponseWriter) error {
+	// INFO map is the reference type in golang
+	p := handlePushHeaders(r.Headers)
+	if pusher, ok := w.(http.Pusher); ok {
+		for _, v := range p {
+			err := pusher.Push(v, nil)
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	handleTrailers(r.Headers)
+	for n, h := range r.Headers {
+		for _, v := range h {
+			w.Header().Add(n, v)
+		}
+	}
+
+	w.WriteHeader(r.Status)
+
+	if data, ok := r.Body.([]byte); ok {
+		_, err := w.Write(data)
+		if err != nil {
+			return handleWriteError(err)
+		}
+	}
+
+	if rc, ok := r.Body.(io.Reader); ok {
+		if _, err := io.Copy(w, rc); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func handlePushHeaders(h map[string][]string) []string {
+	var p []string
+	pushHeader, ok := h[http2pushHeaderKey]
+	if !ok {
+		return p
+	}
+
+	p = append(p, pushHeader...)
+
+	delete(h, http2pushHeaderKey)
+
+	return p
+}
+
+func handleTrailers(h map[string][]string) {
+	trailers, ok := h[TrailerHeaderKey]
+	if !ok {
+		return
+	}
+
+	for _, tr := range trailers {
+		for _, n := range strings.Split(tr, ",") {
+			n = strings.Trim(n, "\t ")
+			if v, ok := h[n]; ok {
+				h["Trailer:"+n] = v
+
+				delete(h, n)
+			}
+		}
+	}
+
+	delete(h, TrailerHeaderKey)
+}
diff --git a/plugins/http/uploads.go b/plugins/http/uploads.go
new file mode 100644
index 00000000..1f14cc0d
--- /dev/null
+++ b/plugins/http/uploads.go
@@ -0,0 +1,158 @@
+package http
+
+import (
+	"github.com/spiral/roadrunner-plugins/logger"
+
+	"io"
+	"io/ioutil"
+	"mime/multipart"
+	"os"
+	"sync"
+)
+
+const (
+	// UploadErrorOK - no error, the file uploaded with success.
+	UploadErrorOK = 0
+
+	// UploadErrorNoFile - no file was uploaded.
+	UploadErrorNoFile = 4
+
+	// UploadErrorNoTmpDir - missing a temporary folder.
+	UploadErrorNoTmpDir = 6
+
+	// UploadErrorCantWrite - failed to write file to disk.
+	UploadErrorCantWrite = 7
+
+	// UploadErrorExtension - forbidden file extension.
+	UploadErrorExtension = 8
+)
+
+// Uploads tree manages uploaded files tree and temporary files.
+type Uploads struct {
+	// associated temp directory and forbidden extensions.
+	cfg UploadsConfig
+
+	// pre processed data tree for Uploads.
+	tree fileTree
+
+	// flat list of all file Uploads.
+	list []*FileUpload
+}
+
+// MarshalJSON marshal tree tree into JSON.
+func (u *Uploads) MarshalJSON() ([]byte, error) {
+	return json.Marshal(u.tree)
+}
+
+// Open moves all uploaded files to temp directory, return error in case of issue with temp directory. File errors
+// will be handled individually.
+func (u *Uploads) Open(log logger.Logger) {
+	var wg sync.WaitGroup
+	for _, f := range u.list {
+		wg.Add(1)
+		go func(f *FileUpload) {
+			defer wg.Done()
+			err := f.Open(u.cfg)
+			if err != nil && log != nil {
+				log.Error("error opening the file", "err", err)
+			}
+		}(f)
+	}
+
+	wg.Wait()
+}
+
+// Clear deletes all temporary files.
+func (u *Uploads) Clear(log logger.Logger) {
+	for _, f := range u.list {
+		if f.TempFilename != "" && exists(f.TempFilename) {
+			err := os.Remove(f.TempFilename)
+			if err != nil && log != nil {
+				log.Error("error removing the file", "err", err)
+			}
+		}
+	}
+}
+
+// FileUpload represents singular file NewUpload.
+type FileUpload struct {
+	// ID contains filename specified by the client.
+	Name string `json:"name"`
+
+	// Mime contains mime-type provided by the client.
+	Mime string `json:"mime"`
+
+	// Size of the uploaded file.
+	Size int64 `json:"size"`
+
+	// Error indicates file upload error (if any). See http://php.net/manual/en/features.file-upload.errors.php
+	Error int `json:"error"`
+
+	// TempFilename points to temporary file location.
+	TempFilename string `json:"tmpName"`
+
+	// associated file header
+	header *multipart.FileHeader
+}
+
+// NewUpload wraps net/http upload into PRS-7 compatible structure.
+func NewUpload(f *multipart.FileHeader) *FileUpload {
+	return &FileUpload{
+		Name:   f.Filename,
+		Mime:   f.Header.Get("Content-Type"),
+		Error:  UploadErrorOK,
+		header: f,
+	}
+}
+
+// Open moves file content into temporary file available for PHP.
+// NOTE:
+// There is 2 deferred functions, and in case of getting 2 errors from both functions
+// error from close of temp file would be overwritten by error from the main file
+// STACK
+// DEFER FILE CLOSE (2)
+// DEFER TMP CLOSE  (1)
+func (f *FileUpload) Open(cfg UploadsConfig) (err error) {
+	if cfg.Forbids(f.Name) {
+		f.Error = UploadErrorExtension
+		return nil
+	}
+
+	file, err := f.header.Open()
+	if err != nil {
+		f.Error = UploadErrorNoFile
+		return err
+	}
+
+	defer func() {
+		// close the main file
+		err = file.Close()
+	}()
+
+	tmp, err := ioutil.TempFile(cfg.TmpDir(), "upload")
+	if err != nil {
+		// most likely cause of this issue is missing tmp dir
+		f.Error = UploadErrorNoTmpDir
+		return err
+	}
+
+	f.TempFilename = tmp.Name()
+	defer func() {
+		// close the temp file
+		err = tmp.Close()
+	}()
+
+	if f.Size, err = io.Copy(tmp, file); err != nil {
+		f.Error = UploadErrorCantWrite
+	}
+
+	return err
+}
+
+// exists if file exists.
+func exists(path string) bool {
+	if _, err := os.Stat(path); os.IsNotExist(err) {
+		return false
+	}
+	return true
+}
diff --git a/plugins/http/uploads_config.go b/plugins/http/uploads_config.go
new file mode 100644
index 00000000..4c20c8e8
--- /dev/null
+++ b/plugins/http/uploads_config.go
@@ -0,0 +1,46 @@
+package http
+
+import (
+	"os"
+	"path"
+	"strings"
+)
+
+// UploadsConfig describes file location and controls access to them.
+type UploadsConfig struct {
+	// Dir contains name of directory to control access to.
+	Dir string
+
+	// Forbid specifies list of file extensions which are forbidden for access.
+	// Example: .php, .exe, .bat, .htaccess and etc.
+	Forbid []string
+}
+
+// InitDefaults sets missing values to their default values.
+func (cfg *UploadsConfig) InitDefaults() error {
+	cfg.Forbid = []string{".php", ".exe", ".bat"}
+	cfg.Dir = os.TempDir()
+	return nil
+}
+
+// TmpDir returns temporary directory.
+func (cfg *UploadsConfig) TmpDir() string {
+	if cfg.Dir != "" {
+		return cfg.Dir
+	}
+
+	return os.TempDir()
+}
+
+// Forbids must return true if file extension is not allowed for the upload.
+func (cfg *UploadsConfig) Forbids(filename string) bool {
+	ext := strings.ToLower(path.Ext(filename))
+
+	for _, v := range cfg.Forbid {
+		if ext == v {
+			return true
+		}
+	}
+
+	return false
+}
diff --git a/plugins/informer/interface.go b/plugins/informer/interface.go
new file mode 100644
index 00000000..27139ae1
--- /dev/null
+++ b/plugins/informer/interface.go
@@ -0,0 +1,8 @@
+package informer
+
+import "github.com/spiral/roadrunner/v2/interfaces/worker"
+
+// Informer used to get workers from particular plugin or set of plugins
+type Informer interface {
+	Workers() []worker.BaseProcess
+}
diff --git a/plugins/informer/plugin.go b/plugins/informer/plugin.go
new file mode 100644
index 00000000..e2da7d86
--- /dev/null
+++ b/plugins/informer/plugin.go
@@ -0,0 +1,55 @@
+package informer
+
+import (
+	"github.com/spiral/endure"
+	"github.com/spiral/errors"
+	"github.com/spiral/roadrunner-plugins/logger"
+	"github.com/spiral/roadrunner/v2/interfaces/worker"
+)
+
+const PluginName = "informer"
+
+type Plugin struct {
+	registry map[string]Informer
+	log      logger.Logger
+}
+
+func (p *Plugin) Init(log logger.Logger) error {
+	p.registry = make(map[string]Informer)
+	p.log = log
+	return nil
+}
+
+// Workers provides BaseProcess slice with workers for the requested plugin
+func (p *Plugin) Workers(name string) ([]worker.BaseProcess, error) {
+	const op = errors.Op("get workers")
+	svc, ok := p.registry[name]
+	if !ok {
+		return nil, errors.E(op, errors.Errorf("no such service: %s", name))
+	}
+
+	return svc.Workers(), nil
+}
+
+// CollectTarget resettable service.
+func (p *Plugin) CollectTarget(name endure.Named, r Informer) error {
+	p.registry[name.Name()] = r
+	return nil
+}
+
+// Collects declares services to be collected.
+func (p *Plugin) Collects() []interface{} {
+	return []interface{}{
+		p.CollectTarget,
+	}
+}
+
+// Name of the service.
+func (p *Plugin) Name() string {
+	return PluginName
+}
+
+// RPCService returns associated rpc service.
+func (p *Plugin) RPC() interface{} {
+	return &rpc{srv: p, log: p.log}
+}
diff --git a/plugins/informer/rpc.go b/plugins/informer/rpc.go
new file mode 100644
index 00000000..d32d4e3a
--- /dev/null
+++ b/plugins/informer/rpc.go
@@ -0,0 +1,54 @@
+package informer
+
+import (
+	"github.com/spiral/roadrunner-plugins/logger"
+	"github.com/spiral/roadrunner/v2/interfaces/worker"
+	"github.com/spiral/roadrunner/v2/tools"
+)
+
+type rpc struct {
+	srv *Plugin
+	log logger.Logger
+}
+
+// WorkerList contains list of workers.
+type WorkerList struct {
+	// Workers is list of workers.
+	Workers []tools.ProcessState `json:"workers"`
+}
+
+// List all resettable services.
+func (rpc *rpc) List(_ bool, list *[]string) error {
+	rpc.log.Debug("Started List method")
+	*list = make([]string, 0, len(rpc.srv.registry))
+
+	for name := range rpc.srv.registry {
+		*list = append(*list, name)
+	}
+	rpc.log.Debug("list of services", "list", *list)
+
+	rpc.log.Debug("successfully finished List method")
+	return nil
+}
+
+// Workers state of a given service.
+func (rpc *rpc) Workers(service string, list *WorkerList) error {
+	rpc.log.Debug("started Workers method", "service", service)
+	workers, err := rpc.srv.Workers(service)
+	if err != nil {
+		return err
+	}
+
+	list.Workers = make([]tools.ProcessState, 0)
+	for _, w := range workers {
+		ps, err := tools.WorkerProcessState(w.(worker.BaseProcess))
+		if err != nil {
+			continue
+		}
+
+		list.Workers = append(list.Workers, ps)
+	}
+	rpc.log.Debug("list of workers", "workers", list.Workers)
+	rpc.log.Debug("successfully finished Workers method")
+	return nil
+}
diff --git a/plugins/server/config.go b/plugins/server/config.go
new file mode 100644
index 00000000..4bef3c5f
--- /dev/null
+++ b/plugins/server/config.go
@@ -0,0 +1,39 @@
+package server
+
+import (
+	"time"
+)
+
+// Config config combines factory, pool and cmd configurations.
+type Config struct {
+	// Command to run as application.
+	Command string
+
+	// User to run application under.
+	User string
+
+	// Group to run application under.
+	Group string
+
+	// Env represents application environment.
+	Env Env
+
+	// Listen defines connection method and factory to be used to connect to workers:
+	// "pipes", "tcp://:6001", "unix://rr.sock"
+	// This config section must not change on re-configuration.
+	Relay string
+
+	// RelayTimeout defines for how long socket factory will be waiting for worker connection. This config section
+	// must not change on re-configuration. Defaults to 60s.
+	RelayTimeout time.Duration
+}
+
+func (cfg *Config) InitDefaults() {
+	if cfg.Relay == "" {
+		cfg.Relay = "pipes"
+	}
+
+	if cfg.RelayTimeout == 0 {
+		cfg.RelayTimeout = time.Second * 60
+	}
+}
diff --git a/plugins/server/interface.go b/plugins/server/interface.go
new file mode 100644
index 00000000..9c1079ea
--- /dev/null
+++ b/plugins/server/interface.go
@@ -0,0 +1,20 @@
+package server
+
+import (
+	"context"
+	"os/exec"
+
+	"github.com/spiral/roadrunner/v2/interfaces/events"
+	"github.com/spiral/roadrunner/v2/interfaces/pool"
+	"github.com/spiral/roadrunner/v2/interfaces/worker"
+	poolImpl "github.com/spiral/roadrunner/v2/pkg/pool"
+)
+
+type Env map[string]string
+
+// Server creates workers for the application.
+type Server interface {
+	CmdFactory(env Env) (func() *exec.Cmd, error)
+	NewWorker(ctx context.Context, env Env, listeners ...events.EventListener) (worker.BaseProcess, error)
+	NewWorkerPool(ctx context.Context, opt poolImpl.Config, env Env, listeners ...events.EventListener) (pool.Pool, error)
+}
diff --git a/plugins/server/plugin.go b/plugins/server/plugin.go
new file mode 100644
index 00000000..5266b2b6
--- /dev/null
+++ b/plugins/server/plugin.go
@@ -0,0 +1,228 @@
+package server
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+
+	"github.com/spiral/errors"
+	"github.com/spiral/roadrunner-plugins/config"
+	"github.com/spiral/roadrunner-plugins/logger"
+	// core imports
+	"github.com/spiral/roadrunner/v2/interfaces/events"
+	"github.com/spiral/roadrunner/v2/interfaces/pool"
+	"github.com/spiral/roadrunner/v2/interfaces/worker"
+	"github.com/spiral/roadrunner/v2/pkg/pipe"
+	poolImpl "github.com/spiral/roadrunner/v2/pkg/pool"
+	"github.com/spiral/roadrunner/v2/pkg/socket"
+	"github.com/spiral/roadrunner/v2/util"
+)
+
+const PluginName = "server"
+
+// Plugin manages worker
+type Plugin struct {
+	cfg     Config
+	log     logger.Logger
+	factory worker.Factory
+}
+
+// Init application provider.
+func (server *Plugin) Init(cfg config.Configurer, log logger.Logger) error {
+	const op = errors.Op("Init")
+	err := cfg.UnmarshalKey(PluginName, &server.cfg)
+	if err != nil {
+		return errors.E(op, errors.Init, err)
+	}
+	server.cfg.InitDefaults()
+	server.log = log
+
+	server.factory, err = server.initFactory()
+	if err != nil {
+		return errors.E(errors.Op("Init factory"), err)
+	}
+
+	return nil
+}
+
+// Name contains service name.
+func (server *Plugin) Name() string {
+	return PluginName
+}
+
+func (server *Plugin) Serve() chan error {
+	errCh := make(chan error, 1)
+	return errCh
+}
+
+func (server *Plugin) Stop() error {
+	if server.factory == nil {
+		return nil
+	}
+
+	return server.factory.Close()
+}
+
+// CmdFactory provides worker command factory associated with given context.
+func (server *Plugin) CmdFactory(env Env) (func() *exec.Cmd, error) {
+	const op = errors.Op("cmd factory")
+	var cmdArgs []string
+
+	// create command according to the config
+	cmdArgs = append(cmdArgs, strings.Split(server.cfg.Command, " ")...)
+	if len(cmdArgs) < 2 {
+		return nil, errors.E(op, errors.Str("should be in form of `php <script>"))
+	}
+	if cmdArgs[0] != "php" {
+		return nil, errors.E(op, errors.Str("first arg in command should be `php`"))
+	}
+
+	_, err := os.Stat(cmdArgs[1])
+	if err != nil {
+		return nil, errors.E(op, err)
+	}
+	return func() *exec.Cmd {
+		cmd := exec.Command(cmdArgs[0], cmdArgs[1:]...) //nolint:gosec
+		util.IsolateProcess(cmd)
+
+		// if user is not empty, and OS is linux or macos
+		// execute php worker from that particular user
+		if server.cfg.User != "" {
+			err := util.ExecuteFromUser(cmd, server.cfg.User)
+			if err != nil {
+				return nil
+			}
+		}
+
+		cmd.Env = server.setEnv(env)
+
+		return cmd
+	}, nil
+}
+
+// NewWorker issues new standalone worker.
+func (server *Plugin) NewWorker(ctx context.Context, env Env, listeners ...events.EventListener) (worker.BaseProcess, error) {
+	const op = errors.Op("new worker")
+
+	list := make([]events.EventListener, 0, len(listeners))
+	list = append(list, server.collectWorkerLogs)
+
+	spawnCmd, err := server.CmdFactory(env)
+	if err != nil {
+		return nil, errors.E(op, err)
+	}
+
+	w, err := server.factory.SpawnWorkerWithTimeout(ctx, spawnCmd(), list...)
+	if err != nil {
+		return nil, errors.E(op, err)
+	}
+
+	return w, nil
+}
+
+// NewWorkerPool issues new worker pool.
+func (server *Plugin) NewWorkerPool(ctx context.Context, opt poolImpl.Config, env Env, listeners ...events.EventListener) (pool.Pool, error) {
+	const op = errors.Op("server plugins new worker pool")
+	spawnCmd, err := server.CmdFactory(env)
+	if err != nil {
+		return nil, errors.E(op, err)
+	}
+
+	list := make([]events.EventListener, 0, len(listeners))
+	list = append(list, server.collectPoolLogs)
+
+	p, err := poolImpl.Initialize(ctx, spawnCmd, server.factory, opt, poolImpl.AddListeners(list...))
+	if err != nil {
+		return nil, errors.E(op, err)
+	}
+
+	return p, nil
+}
+
+// creates relay and worker factory.
+func (server *Plugin) initFactory() (worker.Factory, error) {
+	const op = errors.Op("network factory init")
+	if server.cfg.Relay == "" || server.cfg.Relay == "pipes" {
+		return pipe.NewPipeFactory(), nil
+	}
+
+	dsn := strings.Split(server.cfg.Relay, "://")
+	if len(dsn) != 2 {
+		return nil, errors.E(op, errors.Network, errors.Str("invalid DSN (tcp://:6001, unix://file.sock)"))
+	}
+
+	lsn, err := util.CreateListener(server.cfg.Relay)
+	if err != nil {
+		return nil, errors.E(op, errors.Network, err)
+	}
+
+	switch dsn[0] {
+	// sockets group
+	case "unix":
+		return socket.NewSocketServer(lsn, server.cfg.RelayTimeout), nil
+	case "tcp":
+		return socket.NewSocketServer(lsn, server.cfg.RelayTimeout), nil
+	default:
+		return nil, errors.E(op, errors.Network, errors.Str("invalid DSN (tcp://:6001, unix://file.sock)"))
+	}
+}
+
+func (server *Plugin) setEnv(e Env) []string {
+	env := append(os.Environ(), fmt.Sprintf("RR_RELAY=%s", server.cfg.Relay))
+	for k, v := range e {
+		env = append(env, fmt.Sprintf("%s=%s", strings.ToUpper(k), v))
+	}
+
+	return env
+}
+
+func (server *Plugin) collectPoolLogs(event interface{}) {
+	if we, ok := event.(events.PoolEvent); ok {
+		switch we.Event {
+		case events.EventMaxMemory:
+			server.log.Info("worker max memory reached", "pid", we.Payload.(worker.BaseProcess).Pid())
+		case events.EventNoFreeWorkers:
+			server.log.Info("no free workers in pool", "error", we.Payload.(error).Error())
+		case events.EventPoolError:
+			server.log.Info("pool error", "error", we.Payload.(error).Error())
+		case events.EventSupervisorError:
+			server.log.Info("pool supervizor error", "error", we.Payload.(error).Error())
+		case events.EventTTL:
+			server.log.Info("worker TTL reached", "pid", we.Payload.(worker.BaseProcess).Pid())
+		case events.EventWorkerConstruct:
+			if _, ok := we.Payload.(error); ok {
+				server.log.Error("worker construction error", "error", we.Payload.(error).Error())
+				return
+			}
+			server.log.Info("worker constructed", "pid", we.Payload.(worker.BaseProcess).Pid())
+		case events.EventWorkerDestruct:
+			server.log.Info("worker destructed", "pid", we.Payload.(worker.BaseProcess).Pid())
+		case events.EventExecTTL:
+			server.log.Info("EVENT EXEC TTL PLACEHOLDER")
+		case events.EventIdleTTL:
+			server.log.Info("worker IDLE timeout reached", "pid", we.Payload.(worker.BaseProcess).Pid())
+		}
+	}
+
+	if we, ok := event.(events.WorkerEvent); ok {
+		switch we.Event {
+		case events.EventWorkerError:
+			server.log.Info(we.Payload.(error).Error(), "pid", we.Worker.(worker.BaseProcess).Pid())
+		case events.EventWorkerLog:
+			server.log.Info(strings.TrimRight(string(we.Payload.([]byte)), " \n\t"), "pid", we.Worker.(worker.BaseProcess).Pid())
+		}
+	}
+}
+
+func (server *Plugin) collectWorkerLogs(event interface{}) {
+	if we, ok := event.(events.WorkerEvent); ok {
+		switch we.Event {
+		case events.EventWorkerError:
+			server.log.Error(we.Payload.(error).Error(), "pid", we.Worker.(worker.BaseProcess).Pid())
+		case events.EventWorkerLog:
+			server.log.Info(strings.TrimRight(string(we.Payload.([]byte)), " \n\t"), "pid", we.Worker.(worker.BaseProcess).Pid())
+		}
+	}
+}
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..8006cb5f
--- /dev/null
+++ b/tests/plugins/http/configs/.rr-broken-pipes.yaml
@@ -0,0 +1,31 @@
+rpc:
+  listen: tcp://127.0.0.1:6001
+  disabled: false
+
+server:
+  command: "php ../../http/client.php broken pipes"
+  user: ""
+  group: ""
+  env:
+    "RR_HTTP": "true"
+  relay: "pipes"
+  relayTimeout: "20s"
+
+http:
+  debug: true
+  address: 127.0.0.1:12384
+  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
+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..1cce5dab
--- /dev/null
+++ b/tests/plugins/http/configs/.rr-env.yaml
@@ -0,0 +1,33 @@
+rpc:
+  listen: tcp://127.0.0.1:6001
+  disabled: false
+
+server:
+  command: "php ../../http/client.php env pipes"
+  user: ""
+  group: ""
+  env:
+    "env_key": "ENV_VALUE"
+  relay: "pipes"
+  relayTimeout: "20s"
+
+http:
+  debug: true
+  address: 127.0.0.1:12084
+  maxRequestSize: 1024
+  middleware: [ "" ]
+  env:
+    "RR_HTTP": "true"
+    "env_key": "ENV_VALUE"
+  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
+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..725ae724
--- /dev/null
+++ b/tests/plugins/http/configs/.rr-fcgi-reqUri.yaml
@@ -0,0 +1,38 @@
+server:
+  command: "php ../../http/client.php request-uri pipes"
+  user: ""
+  group: ""
+  env:
+    "RR_HTTP": "true"
+  relay: "pipes"
+  relayTimeout: "20s"
+
+http:
+  debug: true
+  address: :8082
+  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: 1
+    maxJobs: 0
+    allocateTimeout: 60s
+    destroyTimeout: 60s
+
+  ssl:
+    port: 8890
+    redirect: false
+    cert: fixtures/server.crt
+    key: fixtures/server.key
+  #    rootCa: root.crt
+  fcgi:
+    address: tcp://127.0.0.1:6921
+  http2:
+    enabled: false
+    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..ba119a88
--- /dev/null
+++ b/tests/plugins/http/configs/.rr-fcgi.yaml
@@ -0,0 +1,38 @@
+server:
+  command: "php ../../http/client.php echo pipes"
+  user: ""
+  group: ""
+  env:
+    "RR_HTTP": "true"
+  relay: "pipes"
+  relayTimeout: "20s"
+
+http:
+  debug: true
+  address: :8081
+  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: 1
+    maxJobs: 0
+    allocateTimeout: 60s
+    destroyTimeout: 60s
+
+  ssl:
+    port: 8889
+    redirect: false
+    cert: fixtures/server.crt
+    key: fixtures/server.key
+  #    rootCa: root.crt
+  fcgi:
+    address: tcp://0.0.0.0:6920
+  http2:
+    enabled: false
+    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..287b7929
--- /dev/null
+++ b/tests/plugins/http/configs/.rr-h2c.yaml
@@ -0,0 +1,29 @@
+server:
+  command: "php ../../http/client.php echo pipes"
+  user: ""
+  group: ""
+  env:
+    "RR_HTTP": "true"
+  relay: "pipes"
+  relayTimeout: "20s"
+
+http:
+  debug: true
+  address: :8083
+  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: 1
+    maxJobs: 0
+    allocateTimeout: 60s
+    destroyTimeout: 60s
+  http2:
+    enabled: true
+    h2c: true
+    maxConcurrentStreams: 128
+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..93f131f8
--- /dev/null
+++ b/tests/plugins/http/configs/.rr-http.yaml
@@ -0,0 +1,31 @@
+rpc:
+  listen: tcp://127.0.0.1:6001
+  disabled: false
+
+server:
+  command: "php ../../http/client.php echo pipes"
+  user: ""
+  group: ""
+  env:
+    "RR_HTTP": "true"
+  relay: "pipes"
+  relayTimeout: "20s"
+
+http:
+  debug: true
+  address: 127.0.0.1:18903
+  maxRequestSize: 1024
+  middleware: [ "pluginMiddleware", "pluginMiddleware2" ]
+  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
+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..79303eab
--- /dev/null
+++ b/tests/plugins/http/configs/.rr-init.yaml
@@ -0,0 +1,43 @@
+rpc:
+  listen: tcp://127.0.0.1:6001
+  disabled: false
+
+server:
+  command: "php ../../http/client.php echo pipes"
+  user: ""
+  group: ""
+  env:
+    "RR_HTTP": "true"
+  relay: "pipes"
+  relayTimeout: "20s"
+
+http:
+  debug: true
+  address: 127.0.0.1:15395
+  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:
+    port: 8892
+    redirect: false
+    cert: fixtures/server.crt
+    key: fixtures/server.key
+  #    rootCa: root.crt
+  fcgi:
+    address: tcp://0.0.0.0:7921
+  http2:
+    enabled: false
+    h2c: false
+    maxConcurrentStreams: 128
+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..e2edafc6
--- /dev/null
+++ b/tests/plugins/http/configs/.rr-resetter.yaml
@@ -0,0 +1,30 @@
+rpc:
+  listen: tcp://127.0.0.1:6001
+  disabled: false
+
+server:
+  command: "php ../../http/client.php echo pipes"
+  user: ""
+  group: ""
+  env:
+    "RR_HTTP": "true"
+  relay: "pipes"
+  relayTimeout: "20s"
+
+http:
+  debug: true
+  address: 127.0.0.1:10084
+  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
+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..81699a21
--- /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"
+  relayTimeout: "20s"
+
+http:
+  debug: true
+  address: :8086
+  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: 1
+    maxJobs: 0
+    allocateTimeout: 60s
+    destroyTimeout: 60s
+
+  ssl:
+    port: 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..fe6c5a86
--- /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"
+  relayTimeout: "20s"
+
+http:
+  debug: true
+  address: :8087
+  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: 1
+    maxJobs: 0
+    allocateTimeout: 60s
+    destroyTimeout: 60s
+
+  ssl:
+    port: 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..3255383a
--- /dev/null
+++ b/tests/plugins/http/configs/.rr-ssl.yaml
@@ -0,0 +1,38 @@
+server:
+  command: "php ../../http/client.php echo pipes"
+  user: ""
+  group: ""
+  env:
+    "RR_HTTP": "true"
+  relay: "pipes"
+  relayTimeout: "20s"
+
+http:
+  debug: true
+  address: :8085
+  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: 1
+    maxJobs: 0
+    allocateTimeout: 60s
+    destroyTimeout: 60s
+
+  ssl:
+    port: 8893
+    redirect: false
+    cert: fixtures/server.crt
+    key: fixtures/server.key
+  #    rootCa: root.crt
+  fcgi:
+    address: tcp://0.0.0.0:16920
+  http2:
+    enabled: false
+    h2c: false
+    maxConcurrentStreams: 128
+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..18558296
--- /dev/null
+++ b/tests/plugins/http/handler_test.go
@@ -0,0 +1,1860 @@
+package http
+
+import (
+	"bytes"
+	"context"
+	"io/ioutil"
+	"mime/multipart"
+	"net/url"
+	"os/exec"
+	"runtime"
+	"strings"
+
+	"github.com/spiral/roadrunner/v2/pkg/pipe"
+	poolImpl "github.com/spiral/roadrunner/v2/pkg/pool"
+	httpPlugin "github.com/spiral/roadrunner/v2/plugins/http"
+	"github.com/stretchr/testify/assert"
+
+	"net/http"
+	"os"
+	"testing"
+	"time"
+)
+
+func TestHandler_Echo(t *testing.T) {
+	pool, err := poolImpl.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "echo", "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, httpPlugin.UploadsConfig{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, pool)
+	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, httpPlugin.UploadsConfig{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, nil)
+	assert.Error(t, err)
+}
+
+func TestHandler_Headers(t *testing.T) {
+	pool, err := poolImpl.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "header", "pipes") },
+		pipe.NewPipeFactory(),
+		poolImpl.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		pool.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, httpPlugin.UploadsConfig{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, pool)
+	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) {
+	pool, err := poolImpl.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "user-agent", "pipes") },
+		pipe.NewPipeFactory(),
+		poolImpl.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		pool.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, httpPlugin.UploadsConfig{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, pool)
+	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) {
+	pool, err := poolImpl.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "user-agent", "pipes") },
+		pipe.NewPipeFactory(),
+		poolImpl.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		pool.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, httpPlugin.UploadsConfig{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, pool)
+	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) {
+	pool, err := poolImpl.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "cookie", "pipes") },
+		pipe.NewPipeFactory(),
+		poolImpl.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		pool.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, httpPlugin.UploadsConfig{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, pool)
+	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) {
+	pool, err := poolImpl.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "payload", "pipes") },
+		pipe.NewPipeFactory(),
+		poolImpl.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		pool.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, httpPlugin.UploadsConfig{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, pool)
+	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) {
+	pool, err := poolImpl.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "payload", "pipes") },
+		pipe.NewPipeFactory(),
+		poolImpl.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		pool.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, httpPlugin.UploadsConfig{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, pool)
+	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) {
+	pool, err := poolImpl.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "payload", "pipes") },
+		pipe.NewPipeFactory(),
+		poolImpl.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		pool.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, httpPlugin.UploadsConfig{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, pool)
+	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) {
+	pool, err := poolImpl.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "data", "pipes") },
+		pipe.NewPipeFactory(),
+		poolImpl.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		pool.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, httpPlugin.UploadsConfig{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, pool)
+	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) {
+	pool, err := poolImpl.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "data", "pipes") },
+		pipe.NewPipeFactory(),
+		poolImpl.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		pool.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, httpPlugin.UploadsConfig{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, pool)
+	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) {
+	pool, err := poolImpl.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "data", "pipes") },
+		pipe.NewPipeFactory(),
+		poolImpl.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		pool.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, httpPlugin.UploadsConfig{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, pool)
+	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) {
+	pool, err := poolImpl.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "data", "pipes") },
+		pipe.NewPipeFactory(),
+		poolImpl.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		pool.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, httpPlugin.UploadsConfig{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, pool)
+	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) {
+	pool, err := poolImpl.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "data", "pipes") },
+		pipe.NewPipeFactory(),
+		poolImpl.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		pool.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, httpPlugin.UploadsConfig{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, pool)
+	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) {
+	pool, err := poolImpl.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "data", "pipes") },
+		pipe.NewPipeFactory(),
+		poolImpl.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		pool.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, httpPlugin.UploadsConfig{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, pool)
+	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) {
+	pool, err := poolImpl.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "data", "pipes") },
+		pipe.NewPipeFactory(),
+		poolImpl.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		pool.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, httpPlugin.UploadsConfig{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, pool)
+	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) {
+	pool, err := poolImpl.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "data", "pipes") },
+		pipe.NewPipeFactory(),
+		poolImpl.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		pool.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, httpPlugin.UploadsConfig{
+		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 * 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) {
+	pool, err := poolImpl.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "error", "pipes") },
+		pipe.NewPipeFactory(),
+		poolImpl.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		pool.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, httpPlugin.UploadsConfig{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, pool)
+	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) {
+	pool, err := poolImpl.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "error2", "pipes") },
+		pipe.NewPipeFactory(),
+		poolImpl.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		pool.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, httpPlugin.UploadsConfig{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, pool)
+	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) {
+	pool, err := poolImpl.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "pid", "pipes") },
+		pipe.NewPipeFactory(),
+		poolImpl.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		pool.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1, httpPlugin.UploadsConfig{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, pool)
+	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) {
+	pool, err := poolImpl.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "echo", "pipes") },
+		pipe.NewPipeFactory(),
+		poolImpl.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		pool.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, httpPlugin.UploadsConfig{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, pool)
+	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) {
+	pool, err := poolImpl.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "echoDelay", "pipes") },
+		pipe.NewPipeFactory(),
+		poolImpl.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		pool.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, httpPlugin.UploadsConfig{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, pool)
+	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) {
+	pool, err := poolImpl.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "error", "pipes") },
+		pipe.NewPipeFactory(),
+		poolImpl.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		pool.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, httpPlugin.UploadsConfig{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, pool)
+	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 := httpPlugin.ParseCIDRs(trusted)
+	assert.NoError(t, err)
+	assert.NotNil(t, cidrs)
+
+	pool, err := poolImpl.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "ip", "pipes") },
+		pipe.NewPipeFactory(),
+		poolImpl.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		pool.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, httpPlugin.UploadsConfig{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, cidrs, pool)
+	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 := httpPlugin.ParseCIDRs(trusted)
+	assert.NoError(t, err)
+	assert.NotNil(t, cidrs)
+
+	pool, err := poolImpl.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "ip", "pipes") },
+		pipe.NewPipeFactory(),
+		poolImpl.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		pool.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, httpPlugin.UploadsConfig{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, cidrs, pool)
+	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 := httpPlugin.ParseCIDRs(trusted)
+	assert.NoError(t, err)
+	assert.NotNil(t, cidrs)
+
+	pool, err := poolImpl.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "ip", "pipes") },
+		pipe.NewPipeFactory(),
+		poolImpl.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		pool.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, httpPlugin.UploadsConfig{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, cidrs, pool)
+	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 := httpPlugin.ParseCIDRs(trusted)
+	assert.NoError(t, err)
+	assert.NotNil(t, cidrs)
+
+	pool, err := poolImpl.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "ip", "pipes") },
+		pipe.NewPipeFactory(),
+		poolImpl.Config{
+			NumWorkers:      1,
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		pool.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, httpPlugin.UploadsConfig{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, cidrs, pool)
+	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) {
+	pool, err := poolImpl.Initialize(context.Background(),
+		func() *exec.Cmd { return exec.Command("php", "../../http/client.php", "echo", "pipes") },
+		pipe.NewPipeFactory(),
+		poolImpl.Config{
+			NumWorkers:      int64(runtime.NumCPU()),
+			AllocateTimeout: time.Second * 1000,
+			DestroyTimeout:  time.Second * 1000,
+		})
+	if err != nil {
+		b.Fatal(err)
+	}
+	defer func() {
+		pool.Destroy(context.Background())
+	}()
+
+	h, err := httpPlugin.NewHandler(1024, httpPlugin.UploadsConfig{
+		Dir:    os.TempDir(),
+		Forbid: []string{},
+	}, nil, pool)
+	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_test.go b/tests/plugins/http/http_test.go
new file mode 100644
index 00000000..9c081bc5
--- /dev/null
+++ b/tests/plugins/http/http_test.go
@@ -0,0 +1,1222 @@
+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"
+	"github.com/spiral/endure"
+	goridgeRpc "github.com/spiral/goridge/v3/pkg/rpc"
+	"github.com/spiral/roadrunner-plugins/config"
+	"github.com/spiral/roadrunner-plugins/logger"
+	"github.com/spiral/roadrunner-plugins/resetter"
+	"github.com/spiral/roadrunner/v2/interfaces/events"
+	"github.com/spiral/roadrunner/v2/mocks"
+	"github.com/spiral/roadrunner/v2/plugins/informer"
+	"github.com/spiral/roadrunner/v2/plugins/server"
+	"github.com/spiral/roadrunner/v2/tools"
+	"github.com/yookoala/gofast"
+
+	rpcPlugin "github.com/spiral/roadrunner-plugins/rpc"
+	httpPlugin "github.com/spiral/roadrunner/v2/plugins/http"
+	"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)
+
+	tt := time.NewTimer(time.Second * 5)
+
+	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 <-tt.C:
+				// timeout
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+				return
+			}
+		}
+	}()
+
+	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)
+
+	go func() {
+		tt := time.NewTimer(time.Second * 10)
+		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 <-tt.C:
+				// 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)
+
+	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)
+	tt := time.NewTimer(time.Second * 10)
+
+	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 <-tt.C:
+				// 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)
+	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)
+
+	tt := time.NewTimer(time.Second * 10)
+	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 <-tt.C:
+				// timeout
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+				return
+			}
+		}
+	}()
+
+	time.Sleep(time.Second * 1)
+	t.Run("SSLRedirect", sslRedirect)
+	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)
+	tt := time.NewTimer(time.Second * 10)
+	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 <-tt.C:
+				// timeout
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+				return
+			}
+		}
+	}()
+
+	time.Sleep(time.Second * 1)
+	t.Run("SSLPush", sslPush)
+	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)
+
+	tt := time.NewTimer(time.Second * 10)
+
+	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 <-tt.C:
+				// timeout
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+				return
+			}
+		}
+	}()
+
+	time.Sleep(time.Second * 1)
+	t.Run("FastCGIServiceRequestUri", fcgiReqURI)
+	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)
+
+	tt := time.NewTimer(time.Second * 10)
+
+	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 <-tt.C:
+				// timeout
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+				return
+			}
+		}
+	}()
+
+	time.Sleep(time.Second * 1)
+	t.Run("H2cUpgrade", h2cUpgrade)
+	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)
+
+	tt := time.NewTimer(time.Second * 10)
+
+	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 <-tt.C:
+				// timeout
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+				return
+			}
+		}
+	}()
+
+	time.Sleep(time.Second * 1)
+	t.Run("H2c", h2c)
+	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)
+
+	tt := time.NewTimer(time.Second * 20)
+
+	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 <-tt.C:
+				// timeout
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+				return
+			}
+		}
+	}()
+
+	time.Sleep(time.Second * 1)
+	t.Run("MiddlewareTest", middleware)
+	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.DebugLevel))
+	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().Info("worker destructed", "pid", gomock.Any()).MinTimes(1)
+	mockLogger.EXPECT().Info("worker constructed", "pid", gomock.Any()).MinTimes(1)
+	mockLogger.EXPECT().Debug("http handler response received", "elapsed", gomock.Any(), "remote address", "127.0.0.1").MinTimes(1)
+	mockLogger.EXPECT().Info("WORLD", "pid", gomock.Any()).MinTimes(1)
+	mockLogger.EXPECT().Debug("worker event received", "event", events.EventWorkerLog, "worker state", gomock.Any()).MinTimes(1)
+	mockLogger.EXPECT().Info(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)
+
+	tt := time.NewTimer(time.Second * 10)
+
+	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 <-tt.C:
+				// timeout
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+				return
+			}
+		}
+	}()
+
+	time.Sleep(time.Second * 1)
+	t.Run("HttpEchoError", echoError)
+	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)
+
+	tt := time.NewTimer(time.Second * 10)
+
+	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 <-tt.C:
+				// timeout
+				err = cont.Stop()
+				if err != nil {
+					assert.FailNow(t, "error", err.Error())
+				}
+				return
+			}
+		}
+	}()
+
+	time.Sleep(time.Second * 1)
+	t.Run("EnvVariablesTest", envVarsTest)
+	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 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, sslPort, 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:
+    port: %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, sslPort, 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..da887da8
--- /dev/null
+++ b/tests/plugins/http/plugin1.go
@@ -0,0 +1,27 @@
+package http
+
+import (
+	"github.com/spiral/roadrunner-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..6d67725d
--- /dev/null
+++ b/tests/plugins/http/plugin_middleware.go
@@ -0,0 +1,61 @@
+package http
+
+import (
+	"net/http"
+
+	"github.com/spiral/roadrunner-plugins/config"
+)
+
+type PluginMiddleware struct {
+	config config.Configurer
+}
+
+func (p *PluginMiddleware) Init(cfg config.Configurer) error {
+	p.config = cfg
+	return nil
+}
+
+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)
+		}
+	}
+}
+
+func (p *PluginMiddleware) Name() string {
+	return "pluginMiddleware"
+}
+
+type PluginMiddleware2 struct {
+	config config.Configurer
+}
+
+func (p *PluginMiddleware2) Init(cfg config.Configurer) error {
+	p.config = cfg
+	return nil
+}
+
+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)
+		}
+	}
+}
+
+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..a9cbf91a
--- /dev/null
+++ b/tests/plugins/http/response_test.go
@@ -0,0 +1,163 @@
+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")
+	}
+
+	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))}
+	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")
+	}
+
+	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:golint,staticcheck
+	assert.Nil(t, w.h["baz"]) //nolint:golint,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..e76078ee
--- /dev/null
+++ b/tests/plugins/http/uploads_config_test.go
@@ -0,0 +1,26 @@
+package http
+
+import (
+	"os"
+	"testing"
+
+	httpPlugin "github.com/spiral/roadrunner/v2/plugins/http"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFsConfig_Forbids(t *testing.T) {
+	cfg := httpPlugin.UploadsConfig{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 := httpPlugin.UploadsConfig{Dir: "test"}
+	assert.Equal(t, "test", cfg.TmpDir())
+
+	cfg = httpPlugin.UploadsConfig{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..7bb25cbf
--- /dev/null
+++ b/tests/plugins/http/uploads_test.go
@@ -0,0 +1,432 @@
+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"
+	"github.com/spiral/roadrunner/v2/pkg/pipe"
+	poolImpl "github.com/spiral/roadrunner/v2/pkg/pool"
+	httpPlugin "github.com/spiral/roadrunner/v2/plugins/http"
+	"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, httpPlugin.UploadsConfig{
+		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, httpPlugin.UploadsConfig{
+		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, httpPlugin.UploadsConfig{
+		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, httpPlugin.UploadsConfig{
+		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
+}
diff --git a/tests/plugins/informer/.rr-informer.yaml b/tests/plugins/informer/.rr-informer.yaml
new file mode 100644
index 00000000..d817684f
--- /dev/null
+++ b/tests/plugins/informer/.rr-informer.yaml
@@ -0,0 +1,16 @@
+server:
+  command: "php ../../client.php echo pipes"
+  user: ""
+  group: ""
+  env:
+    "RR_CONFIG": "/some/place/on/the/C134"
+    "RR_CONFIG2": "C138"
+  relay: "pipes"
+  relayTimeout: "20s"
+
+rpc:
+  listen: tcp://127.0.0.1:6001
+  disabled: false
+logs:
+  mode: development
+  level: error
\ No newline at end of file
diff --git a/tests/plugins/informer/informer_test.go b/tests/plugins/informer/informer_test.go
new file mode 100644
index 00000000..97f27671
--- /dev/null
+++ b/tests/plugins/informer/informer_test.go
@@ -0,0 +1,97 @@
+package informer
+
+import (
+	"net"
+	"net/rpc"
+	"os"
+	"os/signal"
+	"syscall"
+	"testing"
+	"time"
+
+	"github.com/spiral/endure"
+	goridgeRpc "github.com/spiral/goridge/v3/pkg/rpc"
+	"github.com/spiral/roadrunner-plugins/config"
+	"github.com/spiral/roadrunner-plugins/logger"
+	rpcPlugin "github.com/spiral/roadrunner-plugins/rpc"
+	"github.com/spiral/roadrunner/v2/plugins/informer"
+	"github.com/spiral/roadrunner/v2/plugins/server"
+	"github.com/spiral/roadrunner/v2/tools"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestInformerInit(t *testing.T) {
+	cont, err := endure.NewContainer(nil, endure.SetLogLevel(endure.ErrorLevel))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	cfg := &config.Viper{
+		Path:   ".rr-informer.yaml",
+		Prefix: "rr",
+	}
+
+	err = cont.RegisterAll(
+		cfg,
+		&server.Plugin{},
+		&logger.ZapLogger{},
+		&informer.Plugin{},
+		&rpcPlugin.Plugin{},
+		&Plugin1{},
+	)
+	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)
+
+	tt := time.NewTimer(time.Second * 15)
+
+	t.Run("InformerRpcTest", informerRPCTest)
+
+	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 <-tt.C:
+			// timeout
+			err = cont.Stop()
+			if err != nil {
+				assert.FailNow(t, "error", err.Error())
+			}
+			return
+		}
+	}
+}
+
+func informerRPCTest(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", "informer.plugin1", &list)
+	assert.NoError(t, err)
+	assert.Len(t, list.Workers, 10)
+}
diff --git a/tests/plugins/informer/test_plugin.go b/tests/plugins/informer/test_plugin.go
new file mode 100644
index 00000000..ab3b2286
--- /dev/null
+++ b/tests/plugins/informer/test_plugin.go
@@ -0,0 +1,59 @@
+package informer
+
+import (
+	"context"
+	"time"
+
+	"github.com/spiral/roadrunner-plugins/config"
+	"github.com/spiral/roadrunner/v2/interfaces/worker"
+	poolImpl "github.com/spiral/roadrunner/v2/pkg/pool"
+	"github.com/spiral/roadrunner/v2/plugins/server"
+)
+
+var testPoolConfig = poolImpl.Config{
+	NumWorkers:      10,
+	MaxJobs:         100,
+	AllocateTimeout: time.Second * 10,
+	DestroyTimeout:  time.Second * 10,
+	Supervisor: &poolImpl.SupervisorConfig{
+		WatchTick:       60,
+		TTL:             1000,
+		IdleTTL:         10,
+		ExecTTL:         10,
+		MaxWorkerMemory: 1000,
+	},
+}
+
+// Gauge //////////////
+type Plugin1 struct {
+	config config.Configurer
+	server server.Server
+}
+
+func (p1 *Plugin1) Init(cfg config.Configurer, server server.Server) error {
+	p1.config = cfg
+	p1.server = server
+	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 "informer.plugin1"
+}
+
+func (p1 *Plugin1) Workers() []worker.BaseProcess {
+	pool, err := p1.server.NewWorkerPool(context.Background(), testPoolConfig, nil)
+	if err != nil {
+		panic(err)
+	}
+
+	return pool.Workers()
+}
diff --git a/tests/plugins/server/configs/.rr-no-app-section.yaml b/tests/plugins/server/configs/.rr-no-app-section.yaml
new file mode 100644
index 00000000..4888d249
--- /dev/null
+++ b/tests/plugins/server/configs/.rr-no-app-section.yaml
@@ -0,0 +1,12 @@
+server:
+  command: "php ../../client.php echo pipes"
+  user: ""
+  group: ""
+  env:
+    "RR_CONFIG": "/some/place/on/the/C134"
+    "RR_CONFIG2": "C138"
+  relay: "pipes"
+  relayTimeout: "20s"
+logs:
+  mode: development
+  level: error
\ No newline at end of file
diff --git a/tests/plugins/server/configs/.rr-sockets.yaml b/tests/plugins/server/configs/.rr-sockets.yaml
new file mode 100644
index 00000000..6b5b6bf5
--- /dev/null
+++ b/tests/plugins/server/configs/.rr-sockets.yaml
@@ -0,0 +1,12 @@
+server:
+  command: "php socket.php"
+  user: ""
+  group: ""
+  env:
+    "RR_CONFIG": "/some/place/on/the/C134"
+    "RR_CONFIG2": "C138"
+  relay: "unix://unix.sock"
+  relayTimeout: "20s"
+logs:
+  mode: development
+  level: error
\ No newline at end of file
diff --git a/tests/plugins/server/configs/.rr-tcp.yaml b/tests/plugins/server/configs/.rr-tcp.yaml
new file mode 100644
index 00000000..ee1d450a
--- /dev/null
+++ b/tests/plugins/server/configs/.rr-tcp.yaml
@@ -0,0 +1,12 @@
+server:
+  command: "php tcp.php"
+  user: ""
+  group: ""
+  env:
+    "RR_CONFIG": "/some/place/on/the/C134"
+    "RR_CONFIG2": "C138"
+  relay: "tcp://localhost:9999"
+  relayTimeout: "20s"
+logs:
+  mode: development
+  level: error
\ No newline at end of file
diff --git a/tests/plugins/server/configs/.rr-wrong-command.yaml b/tests/plugins/server/configs/.rr-wrong-command.yaml
new file mode 100644
index 00000000..e66349dd
--- /dev/null
+++ b/tests/plugins/server/configs/.rr-wrong-command.yaml
@@ -0,0 +1,12 @@
+server:
+  command: "php some_absent_file.php"
+  user: ""
+  group: ""
+  env:
+    "RR_CONFIG": "/some/place/on/the/C134"
+    "RR_CONFIG2": "C138"
+  relay: "pipes"
+  relayTimeout: "20s"
+logs:
+  mode: development
+  level: error
\ No newline at end of file
diff --git a/tests/plugins/server/configs/.rr-wrong-relay.yaml b/tests/plugins/server/configs/.rr-wrong-relay.yaml
new file mode 100644
index 00000000..6f532c3f
--- /dev/null
+++ b/tests/plugins/server/configs/.rr-wrong-relay.yaml
@@ -0,0 +1,12 @@
+server:
+  command: "php ../../client.php echo pipes"
+  user: ""
+  group: ""
+  env:
+    "RR_CONFIG": "/some/place/on/the/C134"
+    "RR_CONFIG2": "C138"
+  relay: "pupes"
+  relayTimeout: "20s"
+logs:
+  mode: development
+  level: error
\ No newline at end of file
diff --git a/tests/plugins/server/configs/.rr.yaml b/tests/plugins/server/configs/.rr.yaml
new file mode 100644
index 00000000..4888d249
--- /dev/null
+++ b/tests/plugins/server/configs/.rr.yaml
@@ -0,0 +1,12 @@
+server:
+  command: "php ../../client.php echo pipes"
+  user: ""
+  group: ""
+  env:
+    "RR_CONFIG": "/some/place/on/the/C134"
+    "RR_CONFIG2": "C138"
+  relay: "pipes"
+  relayTimeout: "20s"
+logs:
+  mode: development
+  level: error
\ No newline at end of file
diff --git a/tests/plugins/server/plugin_pipes.go b/tests/plugins/server/plugin_pipes.go
new file mode 100644
index 00000000..afed695f
--- /dev/null
+++ b/tests/plugins/server/plugin_pipes.go
@@ -0,0 +1,133 @@
+package server
+
+import (
+	"context"
+	"time"
+
+	"github.com/spiral/errors"
+	"github.com/spiral/roadrunner-plugins/config"
+	"github.com/spiral/roadrunner/v2/interfaces/pool"
+	"github.com/spiral/roadrunner/v2/pkg/payload"
+	poolImpl "github.com/spiral/roadrunner/v2/pkg/pool"
+	"github.com/spiral/roadrunner/v2/pkg/worker"
+	"github.com/spiral/roadrunner/v2/plugins/server"
+)
+
+const ConfigSection = "server"
+const Response = "test"
+
+var testPoolConfig = poolImpl.Config{
+	NumWorkers:      10,
+	MaxJobs:         100,
+	AllocateTimeout: time.Second * 10,
+	DestroyTimeout:  time.Second * 10,
+	Supervisor: &poolImpl.SupervisorConfig{
+		WatchTick:       60,
+		TTL:             1000,
+		IdleTTL:         10,
+		ExecTTL:         10,
+		MaxWorkerMemory: 1000,
+	},
+}
+
+type Foo struct {
+	configProvider config.Configurer
+	wf             server.Server
+	pool           pool.Pool
+}
+
+func (f *Foo) Init(p config.Configurer, workerFactory server.Server) error {
+	f.configProvider = p
+	f.wf = workerFactory
+	return nil
+}
+
+func (f *Foo) Serve() chan error {
+	const op = errors.Op("serve")
+
+	// test payload for echo
+	r := payload.Payload{
+		Context: nil,
+		Body:    []byte(Response),
+	}
+
+	errCh := make(chan error, 1)
+
+	conf := &server.Config{}
+	var err error
+	err = f.configProvider.UnmarshalKey(ConfigSection, conf)
+	if err != nil {
+		errCh <- err
+		return errCh
+	}
+
+	// test CMDFactory
+	cmd, err := f.wf.CmdFactory(nil)
+	if err != nil {
+		errCh <- err
+		return errCh
+	}
+	if cmd == nil {
+		errCh <- errors.E(op, "command is nil")
+		return errCh
+	}
+
+	// test worker creation
+	w, err := f.wf.NewWorker(context.Background(), nil)
+	if err != nil {
+		errCh <- err
+		return errCh
+	}
+
+	// test that our worker is functional
+	sw, err := worker.From(w)
+	if err != nil {
+		errCh <- err
+		return errCh
+	}
+
+	rsp, err := sw.Exec(r)
+	if err != nil {
+		errCh <- err
+		return errCh
+	}
+
+	if string(rsp.Body) != Response {
+		errCh <- errors.E("response from worker is wrong", errors.Errorf("response: %s", rsp.Body))
+		return errCh
+	}
+
+	// should not be errors
+	err = sw.Stop()
+	if err != nil {
+		errCh <- err
+		return errCh
+	}
+
+	// test pool
+	f.pool, err = f.wf.NewWorkerPool(context.Background(), testPoolConfig, nil)
+	if err != nil {
+		errCh <- err
+		return errCh
+	}
+
+	// test pool execution
+	rsp, err = f.pool.Exec(r)
+	if err != nil {
+		errCh <- err
+		return errCh
+	}
+
+	// echo of the "test" should be -> test
+	if string(rsp.Body) != Response {
+		errCh <- errors.E("response from worker is wrong", errors.Errorf("response: %s", rsp.Body))
+		return errCh
+	}
+
+	return errCh
+}
+
+func (f *Foo) Stop() error {
+	f.pool.Destroy(context.Background())
+	return nil
+}
diff --git a/tests/plugins/server/plugin_sockets.go b/tests/plugins/server/plugin_sockets.go
new file mode 100644
index 00000000..f5f8f7ad
--- /dev/null
+++ b/tests/plugins/server/plugin_sockets.go
@@ -0,0 +1,113 @@
+package server
+
+import (
+	"context"
+
+	"github.com/spiral/errors"
+	"github.com/spiral/roadrunner-plugins/config"
+	"github.com/spiral/roadrunner/v2/interfaces/pool"
+	"github.com/spiral/roadrunner/v2/pkg/payload"
+	"github.com/spiral/roadrunner/v2/pkg/worker"
+	"github.com/spiral/roadrunner/v2/plugins/server"
+)
+
+type Foo2 struct {
+	configProvider config.Configurer
+	wf             server.Server
+	pool           pool.Pool
+}
+
+func (f *Foo2) Init(p config.Configurer, workerFactory server.Server) error {
+	f.configProvider = p
+	f.wf = workerFactory
+	return nil
+}
+
+func (f *Foo2) Serve() chan error {
+	const op = errors.Op("serve")
+	var err error
+	errCh := make(chan error, 1)
+	conf := &server.Config{}
+
+	// test payload for echo
+	r := payload.Payload{
+		Context: nil,
+		Body:    []byte(Response),
+	}
+
+	err = f.configProvider.UnmarshalKey(ConfigSection, conf)
+	if err != nil {
+		errCh <- err
+		return errCh
+	}
+
+	// test CMDFactory
+	cmd, err := f.wf.CmdFactory(nil)
+	if err != nil {
+		errCh <- err
+		return errCh
+	}
+	if cmd == nil {
+		errCh <- errors.E(op, "command is nil")
+		return errCh
+	}
+
+	// test worker creation
+	w, err := f.wf.NewWorker(context.Background(), nil)
+	if err != nil {
+		errCh <- err
+		return errCh
+	}
+
+	// test that our worker is functional
+	sw, err := worker.From(w)
+	if err != nil {
+		errCh <- err
+		return errCh
+	}
+
+	rsp, err := sw.Exec(r)
+	if err != nil {
+		errCh <- err
+		return errCh
+	}
+
+	if string(rsp.Body) != Response {
+		errCh <- errors.E("response from worker is wrong", errors.Errorf("response: %s", rsp.Body))
+		return errCh
+	}
+
+	// should not be errors
+	err = sw.Stop()
+	if err != nil {
+		errCh <- err
+		return errCh
+	}
+
+	// test pool
+	f.pool, err = f.wf.NewWorkerPool(context.Background(), testPoolConfig, nil)
+	if err != nil {
+		errCh <- err
+		return errCh
+	}
+
+	// test pool execution
+	rsp, err = f.pool.Exec(r)
+	if err != nil {
+		errCh <- err
+		return errCh
+	}
+
+	// echo of the "test" should be -> test
+	if string(rsp.Body) != Response {
+		errCh <- errors.E("response from worker is wrong", errors.Errorf("response: %s", rsp.Body))
+		return errCh
+	}
+
+	return errCh
+}
+
+func (f *Foo2) Stop() error {
+	f.pool.Destroy(context.Background())
+	return nil
+}
diff --git a/tests/plugins/server/plugin_tcp.go b/tests/plugins/server/plugin_tcp.go
new file mode 100644
index 00000000..2f33659c
--- /dev/null
+++ b/tests/plugins/server/plugin_tcp.go
@@ -0,0 +1,113 @@
+package server
+
+import (
+	"context"
+
+	"github.com/spiral/errors"
+	"github.com/spiral/roadrunner-plugins/config"
+	"github.com/spiral/roadrunner/v2/interfaces/pool"
+	"github.com/spiral/roadrunner/v2/pkg/payload"
+	"github.com/spiral/roadrunner/v2/pkg/worker"
+	"github.com/spiral/roadrunner/v2/plugins/server"
+)
+
+type Foo3 struct {
+	configProvider config.Configurer
+	wf             server.Server
+	pool           pool.Pool
+}
+
+func (f *Foo3) Init(p config.Configurer, workerFactory server.Server) error {
+	f.configProvider = p
+	f.wf = workerFactory
+	return nil
+}
+
+func (f *Foo3) Serve() chan error {
+	const op = errors.Op("serve")
+	var err error
+	errCh := make(chan error, 1)
+	conf := &server.Config{}
+
+	// test payload for echo
+	r := payload.Payload{
+		Context: nil,
+		Body:    []byte(Response),
+	}
+
+	err = f.configProvider.UnmarshalKey(ConfigSection, conf)
+	if err != nil {
+		errCh <- err
+		return errCh
+	}
+
+	// test CMDFactory
+	cmd, err := f.wf.CmdFactory(nil)
+	if err != nil {
+		errCh <- err
+		return errCh
+	}
+	if cmd == nil {
+		errCh <- errors.E(op, "command is nil")
+		return errCh
+	}
+
+	// test worker creation
+	w, err := f.wf.NewWorker(context.Background(), nil)
+	if err != nil {
+		errCh <- err
+		return errCh
+	}
+
+	// test that our worker is functional
+	sw, err := worker.From(w)
+	if err != nil {
+		errCh <- err
+		return errCh
+	}
+
+	rsp, err := sw.Exec(r)
+	if err != nil {
+		errCh <- err
+		return errCh
+	}
+
+	if string(rsp.Body) != Response {
+		errCh <- errors.E("response from worker is wrong", errors.Errorf("response: %s", rsp.Body))
+		return errCh
+	}
+
+	// should not be errors
+	err = sw.Stop()
+	if err != nil {
+		errCh <- err
+		return errCh
+	}
+
+	// test pool
+	f.pool, err = f.wf.NewWorkerPool(context.Background(), testPoolConfig, nil)
+	if err != nil {
+		errCh <- err
+		return errCh
+	}
+
+	// test pool execution
+	rsp, err = f.pool.Exec(r)
+	if err != nil {
+		errCh <- err
+		return errCh
+	}
+
+	// echo of the "test" should be -> test
+	if string(rsp.Body) != Response {
+		errCh <- errors.E("response from worker is wrong", errors.Errorf("response: %s", rsp.Body))
+		return errCh
+	}
+
+	return errCh
+}
+
+func (f *Foo3) Stop() error {
+	f.pool.Destroy(context.Background())
+	return nil
+}
diff --git a/tests/plugins/server/server_test.go b/tests/plugins/server/server_test.go
new file mode 100644
index 00000000..5be25a20
--- /dev/null
+++ b/tests/plugins/server/server_test.go
@@ -0,0 +1,356 @@
+package server
+
+import (
+	"os"
+	"os/signal"
+	"testing"
+	"time"
+
+	"github.com/spiral/endure"
+	"github.com/spiral/roadrunner-plugins/config"
+	"github.com/spiral/roadrunner-plugins/logger"
+	"github.com/spiral/roadrunner/v2/plugins/server"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestAppPipes(t *testing.T) {
+	container, err := endure.NewContainer(nil, endure.RetryOnFail(true), endure.SetLogLevel(endure.ErrorLevel))
+	if err != nil {
+		t.Fatal(err)
+	}
+	// config plugin
+	vp := &config.Viper{}
+	vp.Path = "configs/.rr.yaml"
+	vp.Prefix = "rr"
+	err = container.Register(vp)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = container.Register(&server.Plugin{})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = container.Register(&Foo{})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = container.Register(&logger.ZapLogger{})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = container.Init()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	errCh, err := container.Serve()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// stop by CTRL+C
+	c := make(chan os.Signal, 1)
+	signal.Notify(c, os.Interrupt)
+
+	// stop after 10 seconds
+	tt := time.NewTicker(time.Second * 10)
+
+	for {
+		select {
+		case e := <-errCh:
+			assert.NoError(t, e.Error)
+			assert.NoError(t, container.Stop())
+			return
+		case <-c:
+			er := container.Stop()
+			if er != nil {
+				panic(er)
+			}
+			return
+		case <-tt.C:
+			tt.Stop()
+			assert.NoError(t, container.Stop())
+			return
+		}
+	}
+}
+
+func TestAppSockets(t *testing.T) {
+	container, err := endure.NewContainer(nil, endure.RetryOnFail(true), endure.SetLogLevel(endure.ErrorLevel))
+	if err != nil {
+		t.Fatal(err)
+	}
+	// config plugin
+	vp := &config.Viper{}
+	vp.Path = "configs/.rr-sockets.yaml"
+	vp.Prefix = "rr"
+	err = container.Register(vp)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = container.Register(&server.Plugin{})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = container.Register(&Foo2{})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = container.Register(&logger.ZapLogger{})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = container.Init()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	errCh, err := container.Serve()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// stop by CTRL+C
+	c := make(chan os.Signal, 1)
+	signal.Notify(c, os.Interrupt)
+
+	// stop after 10 seconds
+	tt := time.NewTicker(time.Second * 10)
+
+	for {
+		select {
+		case e := <-errCh:
+			assert.NoError(t, e.Error)
+			assert.NoError(t, container.Stop())
+			return
+		case <-c:
+			er := container.Stop()
+			if er != nil {
+				panic(er)
+			}
+			return
+		case <-tt.C:
+			tt.Stop()
+			assert.NoError(t, container.Stop())
+			return
+		}
+	}
+}
+
+func TestAppTCP(t *testing.T) {
+	container, err := endure.NewContainer(nil, endure.RetryOnFail(true), endure.SetLogLevel(endure.ErrorLevel))
+	if err != nil {
+		t.Fatal(err)
+	}
+	// config plugin
+	vp := &config.Viper{}
+	vp.Path = "configs/.rr-tcp.yaml"
+	vp.Prefix = "rr"
+	err = container.Register(vp)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = container.Register(&server.Plugin{})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = container.Register(&Foo3{})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = container.Register(&logger.ZapLogger{})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = container.Init()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	errCh, err := container.Serve()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// stop by CTRL+C
+	c := make(chan os.Signal, 1)
+	signal.Notify(c, os.Interrupt)
+
+	// stop after 10 seconds
+	tt := time.NewTicker(time.Second * 10)
+
+	for {
+		select {
+		case e := <-errCh:
+			assert.NoError(t, e.Error)
+			assert.NoError(t, container.Stop())
+			return
+		case <-c:
+			er := container.Stop()
+			if er != nil {
+				panic(er)
+			}
+			return
+		case <-tt.C:
+			tt.Stop()
+			assert.NoError(t, container.Stop())
+			return
+		}
+	}
+}
+
+func TestAppWrongConfig(t *testing.T) {
+	container, err := endure.NewContainer(nil, endure.RetryOnFail(true), endure.SetLogLevel(endure.ErrorLevel))
+	if err != nil {
+		t.Fatal(err)
+	}
+	// config plugin
+	vp := &config.Viper{}
+	vp.Path = "configs/.rrrrrrrrrr.yaml"
+	vp.Prefix = "rr"
+	err = container.Register(vp)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = container.Register(&server.Plugin{})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = container.Register(&Foo3{})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = container.Register(&logger.ZapLogger{})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	assert.Error(t, container.Init())
+}
+
+func TestAppWrongRelay(t *testing.T) {
+	container, err := endure.NewContainer(nil, endure.RetryOnFail(true), endure.SetLogLevel(endure.ErrorLevel))
+	if err != nil {
+		t.Fatal(err)
+	}
+	// config plugin
+	vp := &config.Viper{}
+	vp.Path = "configs/.rr-wrong-relay.yaml"
+	vp.Prefix = "rr"
+	err = container.Register(vp)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = container.Register(&server.Plugin{})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = container.Register(&Foo3{})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = container.Register(&logger.ZapLogger{})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = container.Init()
+	assert.Error(t, err)
+
+	_, err = container.Serve()
+	assert.Error(t, err)
+}
+
+func TestAppWrongCommand(t *testing.T) {
+	container, err := endure.NewContainer(nil, endure.RetryOnFail(true), endure.SetLogLevel(endure.ErrorLevel))
+	if err != nil {
+		t.Fatal(err)
+	}
+	// config plugin
+	vp := &config.Viper{}
+	vp.Path = "configs/.rr-wrong-command.yaml"
+	vp.Prefix = "rr"
+	err = container.Register(vp)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = container.Register(&server.Plugin{})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = container.Register(&Foo3{})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = container.Register(&logger.ZapLogger{})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = container.Init()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, err = container.Serve()
+	assert.Error(t, err)
+}
+
+func TestAppNoAppSectionInConfig(t *testing.T) {
+	container, err := endure.NewContainer(nil, endure.RetryOnFail(true), endure.SetLogLevel(endure.ErrorLevel))
+	if err != nil {
+		t.Fatal(err)
+	}
+	// config plugin
+	vp := &config.Viper{}
+	vp.Path = "configs/.rr-wrong-command.yaml"
+	vp.Prefix = "rr"
+	err = container.Register(vp)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = container.Register(&server.Plugin{})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = container.Register(&Foo3{})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = container.Register(&logger.ZapLogger{})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = container.Init()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, err = container.Serve()
+	assert.Error(t, err)
+}
diff --git a/tests/plugins/server/socket.php b/tests/plugins/server/socket.php
new file mode 100644
index 00000000..3159c445
--- /dev/null
+++ b/tests/plugins/server/socket.php
@@ -0,0 +1,25 @@
+<?php
+/**
+ * @var Goridge\RelayInterface $relay
+ */
+
+use Spiral\Goridge;
+use Spiral\RoadRunner;
+
+require dirname(__DIR__) . "/../vendor/autoload.php";
+
+$relay = new Goridge\SocketRelay(
+            "unix.sock",
+            null,
+            Goridge\SocketRelay::SOCK_UNIX
+        );
+
+$rr = new RoadRunner\Worker($relay);
+
+while ($in = $rr->waitPayload()) {
+    try {
+        $rr->send((string)$in->body);
+    } catch (\Throwable $e) {
+        $rr->error((string)$e);
+    }
+}
diff --git a/tests/plugins/server/tcp.php b/tests/plugins/server/tcp.php
new file mode 100644
index 00000000..88c49848
--- /dev/null
+++ b/tests/plugins/server/tcp.php
@@ -0,0 +1,20 @@
+<?php
+/**
+ * @var Goridge\RelayInterface $relay
+ */
+
+use Spiral\Goridge;
+use Spiral\RoadRunner;
+
+require dirname(__DIR__) . "/../vendor/autoload.php";
+
+$relay = new Goridge\SocketRelay("localhost", 9999);
+$rr = new RoadRunner\Worker($relay);
+
+while ($in = $rr->waitPayload()) {
+    try {
+        $rr->send((string)$in->body);
+    } catch (\Throwable $e) {
+        $rr->error((string)$e);
+    }
+}