support in-process connection

Author: hslam

README.md

@@ -5,10 +5,10 @@
 [![Go Report Card](https://goreportcard.com/badge/github.com/hslam/socket)](https://goreportcard.com/report/github.com/hslam/socket)
 [![LICENSE](https://img.shields.io/github/license/hslam/socket.svg?style=flat-square)](https://github.com/hslam/socket/blob/master/LICENSE)
 
-Package socket implements a network socket that supports TCP, UNIX, HTTP and WS.
+Package socket implements a network socket that supports TCP, UNIX, HTTP, WS and INPROC.
 
 ## Feature
-* TCP/UNIX/HTTP/WS
+* TCP/UNIX/HTTP/WS/INPROC
 * [Epoll/Kqueue](https://github.com/hslam/netpoll "netpoll")
 * TLS
 

socket.go

@@ -1,7 +1,7 @@
 // Copyright (c) 2020 Meng Huang (mhboy@outlook.com)
 // This package is licensed under a MIT license that can be found in the LICENSE file.
 
-// Package socket implements a network socket that supports TCP, UNIX, HTTP and WS.
+// Package socket implements a network socket that supports TCP, UNIX, HTTP, WS and INPROC.
 package socket
 
 import (
@@ -101,6 +101,8 @@ func NewSocket(network string, config *tls.Config) (Socket, error) {
 		return NewHTTPSocket(config), nil
 	case "ws", "wss":
 		return NewWSSocket(config), nil
+	case "inproc", "inprocs":
+		return NewINPROCSocket(config), nil
 	default:
 		return nil, ErrNetwork
 	}

socket_inproc.go

@@ -0,0 +1,125 @@
+// Copyright (c) 2021 Meng Huang (mhboy@outlook.com)
+// This package is licensed under a MIT license that can be found in the LICENSE file.
+
+package socket
+
+import (
+	"crypto/tls"
+	"errors"
+	"github.com/hslam/inproc"
+	"github.com/hslam/netpoll"
+	"net"
+)
+
+// INPROC implements the Socket interface.
+type INPROC struct {
+	Config *tls.Config
+}
+
+// INPROConn implements the Conn interface.
+type INPROConn struct {
+	net.Conn
+}
+
+// Messages returns a new Messages.
+func (c *INPROConn) Messages() Messages {
+	return NewMessages(c.Conn, false, 0, 0)
+}
+
+// Connection returns the net.Conn.
+func (c *INPROConn) Connection() net.Conn {
+	return c.Conn
+}
+
+// NewINPROCSocket returns a new TCP socket.
+func NewINPROCSocket(config *tls.Config) Socket {
+	return &INPROC{Config: config}
+}
+
+// Scheme returns the socket's scheme.
+func (t *INPROC) Scheme() string {
+	if t.Config == nil {
+		return "inproc"
+	}
+	return "inprocs"
+}
+
+// Dial connects to an address.
+func (t *INPROC) Dial(address string) (Conn, error) {
+	conn, err := inproc.Dial(address)
+	if err != nil {
+		return nil, err
+	}
+	if t.Config == nil {
+		return &INPROConn{conn}, err
+	}
+	t.Config.ServerName = address
+	tlsConn := tls.Client(conn, t.Config)
+	if err = tlsConn.Handshake(); err != nil {
+		conn.Close()
+		return nil, err
+	}
+	return &INPROConn{tlsConn}, err
+}
+
+// Listen announces on the local address.
+func (t *INPROC) Listen(address string) (Listener, error) {
+	lis, err := inproc.Listen(address)
+	if err != nil {
+		return nil, err
+	}
+	return &INPROCListener{l: lis, config: t.Config}, err
+}
+
+// INPROCListener implements the Listener interface.
+type INPROCListener struct {
+	l      net.Listener
+	config *tls.Config
+}
+
+// Accept waits for and returns the next connection to the listener.
+func (l *INPROCListener) Accept() (Conn, error) {
+	conn, err := l.l.Accept()
+	if err != nil {
+		return nil, err
+	}
+	if l.config == nil {
+		return &INPROConn{conn}, err
+	}
+	tlsConn := tls.Server(conn, l.config)
+	if err = tlsConn.Handshake(); err != nil {
+		conn.Close()
+		return nil, err
+	}
+	return &INPROConn{tlsConn}, err
+}
+
+// Serve serves the netpoll.Handler by the netpoll.
+func (l *INPROCListener) Serve(handler netpoll.Handler) error {
+	return errors.New("not pollable")
+}
+
+// ServeData serves the opened func and the serve func by the netpoll.
+func (l *INPROCListener) ServeData(opened func(net.Conn) error, serve func(req []byte) (res []byte)) error {
+	return errors.New("not pollable")
+}
+
+// ServeConn serves the opened func and the serve func by the netpoll.
+func (l *INPROCListener) ServeConn(opened func(net.Conn) (Context, error), serve func(Context) error) error {
+	return errors.New("not pollable")
+}
+
+// ServeMessages serves the opened func and the serve func by the netpoll.
+func (l *INPROCListener) ServeMessages(opened func(Messages) (Context, error), serve func(Context) error) error {
+	return errors.New("not pollable")
+}
+
+// Close closes the listener.
+func (l *INPROCListener) Close() error {
+	return l.l.Close()
+}
+
+// Addr returns the listener's network address.
+func (l *INPROCListener) Addr() net.Addr {
+	return l.l.Addr()
+}

socket_inproc_test.go

@@ -0,0 +1,26 @@
+// Copyright (c) 2021 Meng Huang (mhboy@outlook.com)
+// This package is licensed under a MIT license that can be found in the LICENSE file.
+
+package socket
+
+import (
+	"testing"
+)
+
+func TestINPROC(t *testing.T) {
+	address := ":9999"
+	serverSock := NewINPROCSocket(nil)
+	l, err := serverSock.Listen(address)
+	defer l.Close()
+	if err != nil {
+		t.Error(err)
+	}
+	if _, err := serverSock.Listen(address); err == nil {
+		t.Error(err)
+	}
+	l.Serve(nil)
+	l.ServeConn(nil, nil)
+	l.ServeData(nil, nil)
+	l.ServeMessages(nil, nil)
+	l.Close()
+}

socket_test.go

@@ -19,22 +19,21 @@ func TestSocket(t *testing.T) {
 	testSocket(NewUNIXSocket(nil), NewUNIXSocket(nil), "unix", t)
 	testSocket(NewHTTPSocket(nil), NewHTTPSocket(nil), "http", t)
 	testSocket(NewWSSocket(nil), NewWSSocket(nil), "ws", t)
+	testSocket(NewINPROCSocket(nil), NewINPROCSocket(nil), "inproc", t)
 	testSocket(NewTCPSocket(DefalutTLSConfig()), NewTCPSocket(SkipVerifyTLSConfig()), "tcps", t)
 	testSocket(NewUNIXSocket(DefalutTLSConfig()), NewUNIXSocket(SkipVerifyTLSConfig()), "unixs", t)
 	testSocket(NewHTTPSocket(DefalutTLSConfig()), NewHTTPSocket(SkipVerifyTLSConfig()), "https", t)
 	testSocket(NewWSSocket(DefalutTLSConfig()), NewWSSocket(SkipVerifyTLSConfig()), "wss", t)
+	testSocket(NewINPROCSocket(DefalutTLSConfig()), NewINPROCSocket(SkipVerifyTLSConfig()), "inprocs", t)
 	testTCPSocket(NewTCPSocket(nil), NewTCPSocket(nil), "tcp", t)
-
 }
 
 func testSocket(serverSock Socket, clientSock Socket, scheme string, t *testing.T) {
 	var addr = ":9999"
 	if serverSock.Scheme() != scheme {
 		t.Error(serverSock.Scheme())
 	}
-	if _, err := clientSock.Dial("-1"); err == nil {
-		t.Error("should be missing port in address / no such file or directory")
-	}
+
 	if _, err := clientSock.Dial(addr); err == nil {
 		t.Error("should be refused")
 	}
@@ -71,7 +70,14 @@ func testSocket(serverSock Socket, clientSock Socket, scheme string, t *testing.
 	if err != nil {
 		t.Error(err)
 	}
-	conn.Connection()
+	netConn := conn.Connection()
+	netConn.SetWriteDeadline(time.Now().Add(time.Second))
+	netConn.SetReadDeadline(time.Now().Add(time.Second))
+	netConn.SetDeadline(time.Now().Add(time.Second))
+	netConn.LocalAddr()
+	raddr := netConn.RemoteAddr()
+	raddr.Network()
+	raddr.String()
 	messages := conn.Messages()
 	str := "Hello World"
 	str = strings.Repeat(str, 50)
@@ -166,6 +172,7 @@ func TestSocketTLS(t *testing.T) {
 	testSocketTLS(NewUNIXSocket(DefalutTLSConfig()), NewUNIXSocket(config), t)
 	testSocketTLS(NewHTTPSocket(DefalutTLSConfig()), NewHTTPSocket(config), t)
 	testSocketTLS(NewWSSocket(DefalutTLSConfig()), NewWSSocket(config), t)
+	testSocketTLS(NewINPROCSocket(DefalutTLSConfig()), NewINPROCSocket(config), t)
 }
 
 func testSocketTLS(serverSock Socket, clientSock Socket, t *testing.T) {