Categorygithub.com/hslam/socket
modulepackage
0.0.3
Repository: https://github.com/hslam/socket.git
Documentation: pkg.go.dev

# README

socket

PkgGoDev Build Status codecov Go Report Card LICENSE

Package socket implements a network socket that supports TCP, UNIX, HTTP and WS.

Feature

Benchmark

Socket QPS
socket

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.