Exporting Dialer and Socket interfaces.

joliver · joliver · commit db90d18d5f01 · 2020-10-27T12:36:52.000-06:00
diff --git a/config.go b/config.go
@@ -19,7 +19,7 @@ type option func(*configuration)
 type configuration struct {
 	DialTimeout     time.Duration
 	Filter          Filter
-	Dialer          dialer
+	Dialer          Dialer
 	LogConnections  bool
 	ProxyProtocol   bool
 	Initializer     initializer
@@ -38,7 +38,7 @@ func (singleton) Filter(value Filter) option {
 func (singleton) ClientConnector(value clientConnector) option {
 	return func(this *configuration) { this.ClientConnector = value }
 }
-func (singleton) Dialer(value dialer) option {
+func (singleton) Dialer(value Dialer) option {
 	return func(this *configuration) { this.Dialer = value }
 }
 func (singleton) LogConnections(value bool) option {
diff --git a/default_client_connector.go b/default_client_connector.go
@@ -8,7 +8,7 @@ func newClientConnector() *defaultClientConnector {
 	return &defaultClientConnector{}
 }
 
-func (this *defaultClientConnector) Connect(response http.ResponseWriter) socket {
+func (this *defaultClientConnector) Connect(response http.ResponseWriter) Socket {
 	if hijacker, ok := response.(http.Hijacker); !ok {
 		return nil
 	} else if socket, _, _ := hijacker.Hijack(); socket == nil {
diff --git a/default_dialer.go b/default_dialer.go
@@ -14,7 +14,7 @@ func newDialer(config *configuration) *defaultDialer {
 	return &defaultDialer{timeout: config.DialTimeout, logger: config.Logger}
 }
 
-func (this *defaultDialer) Dial(address string) socket {
+func (this *defaultDialer) Dial(address string) Socket {
 	if socket, err := net.DialTimeout("tcp", address, this.timeout); err == nil {
 		return socket
 	} else {
diff --git a/default_handler_test.go b/default_handler_test.go
@@ -123,23 +123,23 @@ func (this *TestFilter) IsAuthorized(response http.ResponseWriter, request *http
 //////////////////////////////////////////////////////////////
 
 type TestClientConnector struct {
-	socket   socket
+	socket   Socket
 	response http.ResponseWriter
 }
 
-func NewTestClientConnector(socket socket) *TestClientConnector {
+func NewTestClientConnector(socket Socket) *TestClientConnector {
 	return &TestClientConnector{socket: socket}
 }
 
-func (this *TestClientConnector) Connect(response http.ResponseWriter) socket {
+func (this *TestClientConnector) Connect(response http.ResponseWriter) Socket {
 	this.response = response
 	return this.socket
 }
 
 //////////////////////////////////////////////////////////////
 
 type TestServerConnector struct {
-	socket  socket
+	socket  Socket
 	address string
 	proxy   *TestProxy
 }
@@ -148,7 +148,7 @@ func NewTestServerConnector() *TestServerConnector {
 	return &TestServerConnector{proxy: &TestProxy{}}
 }
 
-func (this *TestServerConnector) Connect(socket socket, address string) proxy {
+func (this *TestServerConnector) Connect(socket Socket, address string) proxy {
 	this.socket = socket
 	this.address = address
 
diff --git a/default_initializer.go b/default_initializer.go
@@ -4,4 +4,4 @@ type defaultInitializer struct{}
 
 func newInitializer() *defaultInitializer { return &defaultInitializer{} }
 
-func (this *defaultInitializer) Initialize(_, _ socket) bool { return true }
+func (this *defaultInitializer) Initialize(_, _ Socket) bool { return true }
diff --git a/default_proxy.go b/default_proxy.go
@@ -6,12 +6,12 @@ import (
 )
 
 type defaultProxy struct {
-	client socket
-	server socket
+	client Socket
+	server Socket
 	waiter *sync.WaitGroup
 }
 
-func newProxy(client, server socket) *defaultProxy {
+func newProxy(client, server Socket) *defaultProxy {
 	waiter := &sync.WaitGroup{}
 	waiter.Add(2) // wait on both client->server and server->client streams
 
@@ -28,20 +28,20 @@ func (this *defaultProxy) Proxy() {
 	this.closeSockets()
 }
 
-func (this *defaultProxy) streamAndClose(reader, writer socket) {
+func (this *defaultProxy) streamAndClose(reader, writer Socket) {
 	_, _ = io.Copy(writer, reader)
 
 	tryCloseRead(reader)
 	tryCloseWrite(writer)
 
 	this.waiter.Done()
 }
-func tryCloseRead(socket socket) {
+func tryCloseRead(socket Socket) {
 	if tcp, ok := socket.(tcpSocket); ok {
 		_ = tcp.CloseRead()
 	}
 }
-func tryCloseWrite(socket socket) {
+func tryCloseWrite(socket Socket) {
 	if tcp, ok := socket.(tcpSocket); ok {
 		_ = tcp.CloseWrite()
 	}
diff --git a/default_server_connector.go b/default_server_connector.go
@@ -1,15 +1,15 @@
 package cproxy
 
 type defaultServerConnector struct {
-	dialer      dialer
+	dialer      Dialer
 	initializer initializer
 }
 
-func newServerConnector(dialer dialer, initializer initializer) *defaultServerConnector {
+func newServerConnector(dialer Dialer, initializer initializer) *defaultServerConnector {
 	return &defaultServerConnector{dialer: dialer, initializer: initializer}
 }
 
-func (this *defaultServerConnector) Connect(client socket, serverAddress string) proxy {
+func (this *defaultServerConnector) Connect(client Socket, serverAddress string) proxy {
 	server := this.dialer.Dial(serverAddress)
 	if server == nil {
 		return nil
diff --git a/default_server_connector_test.go b/default_server_connector_test.go
@@ -71,14 +71,14 @@ func (this *ServerConnectorFixture) connect(address string) proxy {
 
 type TestDialer struct {
 	address string
-	socket  socket
+	socket  Socket
 }
 
-func NewTestDialer(socket socket) *TestDialer {
+func NewTestDialer(socket Socket) *TestDialer {
 	return &TestDialer{socket: socket}
 }
 
-func (this *TestDialer) Dial(address string) socket {
+func (this *TestDialer) Dial(address string) Socket {
 	this.address = address
 	return this.socket
 }
@@ -87,15 +87,15 @@ func (this *TestDialer) Dial(address string) socket {
 
 type TestInitializer struct {
 	success bool
-	client  socket
-	server  socket
+	client  Socket
+	server  Socket
 }
 
 func NewTestInitializer(success bool) *TestInitializer {
 	return &TestInitializer{success: success}
 }
 
-func (this *TestInitializer) Initialize(client, server socket) bool {
+func (this *TestInitializer) Initialize(client, server Socket) bool {
 	this.client = client
 	this.server = server
 	return this.success
diff --git a/interfaces.go b/interfaces.go
@@ -12,21 +12,21 @@ type (
 	}
 
 	clientConnector interface {
-		Connect(http.ResponseWriter) socket
+		Connect(http.ResponseWriter) Socket
 	}
 )
 
 type (
-	dialer interface {
-		Dial(string) socket
+	Dialer interface {
+		Dial(string) Socket
 	}
 
 	serverConnector interface {
-		Connect(socket, string) proxy
+		Connect(Socket, string) proxy
 	}
 
 	initializer interface {
-		Initialize(socket, socket) bool
+		Initialize(Socket, Socket) bool
 	}
 
 	proxy interface {
@@ -35,13 +35,13 @@ type (
 )
 
 type (
-	socket interface {
+	Socket interface {
 		io.ReadWriteCloser
 		RemoteAddr() net.Addr
 	}
 
 	tcpSocket interface {
-		socket
+		Socket
 		CloseRead() error
 		CloseWrite() error
 	}
diff --git a/logging_initializer.go b/logging_initializer.go
@@ -13,7 +13,7 @@ func newLoggingInitializer(config *configuration) initializer {
 	return &loggingInitializer{inner: config.Initializer, logger: config.Logger}
 }
 
-func (this *loggingInitializer) Initialize(client, server socket) bool {
+func (this *loggingInitializer) Initialize(client, server Socket) bool {
 	result := this.inner.Initialize(client, server)
 
 	if result {
diff --git a/proxy_protocol_initializer.go b/proxy_protocol_initializer.go
@@ -13,7 +13,7 @@ func newProxyProtocolInitializer() *proxyProtocolInitializer {
 	return &proxyProtocolInitializer{}
 }
 
-func (this *proxyProtocolInitializer) Initialize(client, server socket) bool {
+func (this *proxyProtocolInitializer) Initialize(client, server Socket) bool {
 	header := formatHeader(client.RemoteAddr(), server.RemoteAddr())
 	_, err := io.WriteString(server, header)
 	return err == nil

Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ func newClientConnector() *defaultClientConnector {`
`8`	`8`	`return &defaultClientConnector{}`
`9`	`9`	`}`
`10`	`10`
`11`		`-func (this *defaultClientConnector) Connect(response http.ResponseWriter) socket {`
	`11`	`+func (this *defaultClientConnector) Connect(response http.ResponseWriter) Socket {`
`12`	`12`	`if hijacker, ok := response.(http.Hijacker); !ok {`
`13`	`13`	`return nil`
`14`	`14`	`} else if socket, _, _ := hijacker.Hijack(); socket == nil {`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ func newDialer(config configuration) defaultDialer {`
`14`	`14`	`return &defaultDialer{timeout: config.DialTimeout, logger: config.Logger}`
`15`	`15`	`}`
`16`	`16`
`17`		`-func (this *defaultDialer) Dial(address string) socket {`
	`17`	`+func (this *defaultDialer) Dial(address string) Socket {`
`18`	`18`	`if socket, err := net.DialTimeout("tcp", address, this.timeout); err == nil {`
`19`	`19`	`return socket`
`20`	`20`	`} else {`
Original file line number	Diff line number	Diff line change
`@@ -123,23 +123,23 @@ func (this TestFilter) IsAuthorized(response http.ResponseWriter, request http`
`123`	`123`	`//////////////////////////////////////////////////////////////`
`124`	`124`
`125`	`125`	`type TestClientConnector struct {`
`126`		`- socket socket`
	`126`	`+ socket Socket`
`127`	`127`	`response http.ResponseWriter`
`128`	`128`	`}`
`129`	`129`
`130`		`-func NewTestClientConnector(socket socket) *TestClientConnector {`
	`130`	`+func NewTestClientConnector(socket Socket) *TestClientConnector {`
`131`	`131`	`return &TestClientConnector{socket: socket}`
`132`	`132`	`}`
`133`	`133`
`134`		`-func (this *TestClientConnector) Connect(response http.ResponseWriter) socket {`
	`134`	`+func (this *TestClientConnector) Connect(response http.ResponseWriter) Socket {`
`135`	`135`	`this.response = response`
`136`	`136`	`return this.socket`
`137`	`137`	`}`
`138`	`138`
`139`	`139`	`//////////////////////////////////////////////////////////////`
`140`	`140`
`141`	`141`	`type TestServerConnector struct {`
`142`		`- socket socket`
	`142`	`+ socket Socket`
`143`	`143`	`address string`
`144`	`144`	`proxy *TestProxy`
`145`	`145`	`}`
`@@ -148,7 +148,7 @@ func NewTestServerConnector() *TestServerConnector {`
`148`	`148`	`return &TestServerConnector{proxy: &TestProxy{}}`
`149`	`149`	`}`
`150`	`150`
`151`		`-func (this *TestServerConnector) Connect(socket socket, address string) proxy {`
	`151`	`+func (this *TestServerConnector) Connect(socket Socket, address string) proxy {`
`152`	`152`	`this.socket = socket`
`153`	`153`	`this.address = address`
`154`	`154`
Original file line number	Diff line number	Diff line change
`@@ -4,4 +4,4 @@ type defaultInitializer struct{}`
`4`	`4`
`5`	`5`	`func newInitializer() *defaultInitializer { return &defaultInitializer{} }`
`6`	`6`
`7`		`-func (this *defaultInitializer) Initialize(_, _ socket) bool { return true }`
	`7`	`+func (this *defaultInitializer) Initialize(_, _ Socket) bool { return true }`
Original file line number	Diff line number	Diff line change
`@@ -6,12 +6,12 @@ import (`
`6`	`6`	`)`
`7`	`7`
`8`	`8`	`type defaultProxy struct {`
`9`		`- client socket`
`10`		`- server socket`
	`9`	`+ client Socket`
	`10`	`+ server Socket`
`11`	`11`	`waiter *sync.WaitGroup`
`12`	`12`	`}`
`13`	`13`
`14`		`-func newProxy(client, server socket) *defaultProxy {`
	`14`	`+func newProxy(client, server Socket) *defaultProxy {`
`15`	`15`	`waiter := &sync.WaitGroup{}`
`16`	`16`	`waiter.Add(2) // wait on both client->server and server->client streams`
`17`	`17`
`@@ -28,20 +28,20 @@ func (this *defaultProxy) Proxy() {`
`28`	`28`	`this.closeSockets()`
`29`	`29`	`}`
`30`	`30`
`31`		`-func (this *defaultProxy) streamAndClose(reader, writer socket) {`
	`31`	`+func (this *defaultProxy) streamAndClose(reader, writer Socket) {`
`32`	`32`	`_, _ = io.Copy(writer, reader)`
`33`	`33`
`34`	`34`	`tryCloseRead(reader)`
`35`	`35`	`tryCloseWrite(writer)`
`36`	`36`
`37`	`37`	`this.waiter.Done()`
`38`	`38`	`}`
`39`		`-func tryCloseRead(socket socket) {`
	`39`	`+func tryCloseRead(socket Socket) {`
`40`	`40`	`if tcp, ok := socket.(tcpSocket); ok {`
`41`	`41`	`_ = tcp.CloseRead()`
`42`	`42`	`}`
`43`	`43`	`}`
`44`		`-func tryCloseWrite(socket socket) {`
	`44`	`+func tryCloseWrite(socket Socket) {`
`45`	`45`	`if tcp, ok := socket.(tcpSocket); ok {`
`46`	`46`	`_ = tcp.CloseWrite()`
`47`	`47`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,21 +12,21 @@ type (`
`12`	`12`	`}`
`13`	`13`
`14`	`14`	`clientConnector interface {`
`15`		`- Connect(http.ResponseWriter) socket`
	`15`	`+ Connect(http.ResponseWriter) Socket`
`16`	`16`	`}`
`17`	`17`	`)`
`18`	`18`
`19`	`19`	`type (`
`20`		`- dialer interface {`
`21`		`- Dial(string) socket`
	`20`	`+ Dialer interface {`
	`21`	`+ Dial(string) Socket`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`serverConnector interface {`
`25`		`- Connect(socket, string) proxy`
	`25`	`+ Connect(Socket, string) proxy`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`initializer interface {`
`29`		`- Initialize(socket, socket) bool`
	`29`	`+ Initialize(Socket, Socket) bool`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`proxy interface {`
`@@ -35,13 +35,13 @@ type (`
`35`	`35`	`)`
`36`	`36`
`37`	`37`	`type (`
`38`		`- socket interface {`
	`38`	`+ Socket interface {`
`39`	`39`	`io.ReadWriteCloser`
`40`	`40`	`RemoteAddr() net.Addr`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`tcpSocket interface {`
`44`		`- socket`
	`44`	`+ Socket`
`45`	`45`	`CloseRead() error`
`46`	`46`	`CloseWrite() error`
`47`	`47`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ func newLoggingInitializer(config *configuration) initializer {`
`13`	`13`	`return &loggingInitializer{inner: config.Initializer, logger: config.Logger}`
`14`	`14`	`}`
`15`	`15`
`16`		`-func (this *loggingInitializer) Initialize(client, server socket) bool {`
	`16`	`+func (this *loggingInitializer) Initialize(client, server Socket) bool {`
`17`	`17`	`result := this.inner.Initialize(client, server)`
`18`	`18`
`19`	`19`	`if result {`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ func newProxyProtocolInitializer() *proxyProtocolInitializer {`
`13`	`13`	`return &proxyProtocolInitializer{}`
`14`	`14`	`}`
`15`	`15`
`16`		`-func (this *proxyProtocolInitializer) Initialize(client, server socket) bool {`
	`16`	`+func (this *proxyProtocolInitializer) Initialize(client, server Socket) bool {`
`17`	`17`	`header := formatHeader(client.RemoteAddr(), server.RemoteAddr())`
`18`	`18`	`_, err := io.WriteString(server, header)`
`19`	`19`	`return err == nil`