# README
socket
Package socket implements a network socket that supports TCP, UNIX, HTTP and WS.
Feature
- TCP / UNIX / HTTP / WS
- Epoll / Kqueue
- TLS
Benchmark
Socket QPS

Get started
Install
go get github.com/hslam/socket
Import
import "github.com/hslam/socket"
Usage
Example
server.go
package main
import (
"flag"
"github.com/hslam/socket"
)
var network string
var addr string
func init() {
flag.StringVar(&network, "network", "tcp", "-network=tcp, unix, http or ws")
flag.StringVar(&addr, "addr", ":8080", "-addr=:8080")
flag.Parse()
}
func main() {
sock, err := socket.NewSocket(network, nil)
if err != nil {
panic(err)
}
l, err := sock.Listen(addr)
if err != nil {
panic(err)
}
for {
conn, err := l.Accept()
if err != nil {
panic(err)
}
go func(conn socket.Conn) {
messages := conn.Messages()
buf := make([]byte, 65536)
for {
msg, err := messages.ReadMessage(buf)
if err != nil {
break
}
messages.WriteMessage(msg)
}
messages.Close()
}(conn)
}
}
server_poll.go
package main
import (
"flag"
"github.com/hslam/socket"
"sync"
)
var network string
var addr string
func init() {
flag.StringVar(&network, "network", "tcp", "-network=tcp, unix, http or ws")
flag.StringVar(&addr, "addr", ":8080", "-addr=:8080")
flag.Parse()
}
func main() {
sock, err := socket.NewSocket(network, nil)
if err != nil {
panic(err)
}
l, err := sock.Listen(addr)
if err != nil {
panic(err)
}
bufferPool := &sync.Pool{New: func() interface{} { return make([]byte, 65536) }}
l.ServeMessages(func(messages socket.Messages) (socket.Context, error) {
return messages, nil
}, func(context socket.Context) error {
messages := context.(socket.Messages)
buf := bufferPool.Get().([]byte)
defer bufferPool.Put(buf)
msg, err := messages.ReadMessage(buf)
if err != nil {
return err
}
return messages.WriteMessage(msg)
})
}
client.go
package main
import (
"flag"
"fmt"
"github.com/hslam/socket"
)
var network string
var addr string
func init() {
flag.StringVar(&network, "network", "tcp", "-network=tcp, unix, http or ws")
flag.StringVar(&addr, "addr", ":8080", "-addr=:8080")
flag.Parse()
}
func main() {
sock, err := socket.NewSocket(network, nil)
if err != nil {
panic(err)
}
conn, err := sock.Dial(addr)
if err != nil {
panic(err)
}
messages := conn.Messages()
buf := make([]byte, 65536)
for i := 0; i < 1; i++ {
err := messages.WriteMessage([]byte("Hello World"))
if err != nil {
panic(err)
}
msg, err := messages.ReadMessage(buf)
if err != nil {
panic(err)
}
fmt.Println(string(msg))
}
}
Output
Hello World
License
This package is licensed under a MIT license (Copyright (c) 2020 Meng Huang)
Author
socket was written by Meng Huang.
# Functions
Address returns the socket's address by a url.
DefalutTLSConfig returns a default TLS config.
LoadTLSConfig returns a TLS config by loading the certificate file and the key file.
NewHTTPSocket returns a new HTTP socket.
NewMessages returns a new messages.
NewSocket returns a new socket by a network and a TLS config.
NewTCPSocket returns a new TCP socket.
NewUNIXSocket returns a new UNIX socket.
NewWSSocket returns a new WS socket.
SkipVerifyTLSConfig returns a insecure skip verify TLS config.
TLSConfig returns a TLS config by the certificate data and the key data.
URL returns the socket's url by a address.
# Constants
HTTPConnected defines the http connected.
HTTPPath defines the http path.
WSPath defines the ws path.
# Variables
DefaultCertPEM represents the default certificate data.
DefaultKeyPEM represents the default private key data.
ErrConn is the error when the conn is nil.
ErrHandler is the error when the handler is nil.
ErrNetwork is the error when the network is not supported.
ErrOpened is the error when the opened is nil.
ErrServe is the error when the serve is nil.
# Structs
HTTP implements the Socket interface.
HTTPConn implements the Conn interface.
HTTPListener implements the Listener interface.
TCP implements the Socket interface.
TCPConn implements the Conn interface.
TCPListener implements the Listener interface.
UNIX implements the Socket interface.
UNIXConn implements the Conn interface.
UNIXListener implements the Listener interface.
WS implements the Socket interface.
WSConn implements the Conn interface.
WSListener implements the Listener interface.
# Interfaces
Batch interface is used to write batch messages.
Conn is a generic stream-oriented network connection.
Context represents a context.
Dialer is a generic network dialer for stream-oriented protocols.
Listener is a generic network listener for stream-oriented protocols.
Messages interface is used to read and write message.
Socket contains the Dialer and the Listener.