Description
This package provides an extention of go stdlib's net package. It provides extended Listen and Dial methods
in order to enabled clients and servers for semantic addressing. The returned structs implement net.Listener and
net.Conn and should seamlessly integrate with your existing application.
For transport/service organisation, NATS, consul or DNSSRV can be used. An
implementation of quic is in development.
The following examples require a local NATS node on port 4222.
netx alternatives and similar packages
Based on the "Networking" category.
Alternatively, view netx alternatives based on common mentions on social networks and blogs.
-
gnet
⚡️A high-performance, lightweight, nonblocking, event-loop networking library written in pure Go.🔥 -
mqttPaho
The Paho Go Client provides an MQTT client library for connection to MQTT brokers via TCP, TLS or WebSockets. -
fortio
Load testing library and command line tool and web UI. Allows to specify a set query-per-second load and record latency histograms and other useful stats and graph them. -
sftp
Package sftp implements the SSH File Transfer Protocol as described in https://filezilla-project.org/specs/draft-ietf-secsh-filexfer-02.txt. -
raw
Package raw enables reading and writing data at the device driver level for a network interface. -
gmqtt
Gmqtt is a flexible, high-performance MQTT broker library that fully implements the MQTT protocol V3.1.1. -
ethernet
Package ethernet implements marshaling and unmarshaling of IEEE 802.3 Ethernet II frames and IEEE 802.1Q VLAN tags. -
xtcp
A TCP Server Framework with simultaneous full duplex communication,graceful shutdown,custom protocol.
Get performance insights in less than 4 minutes
Do you think we are missing an alternative of netx or a related project?
Popular Comparisons
README
netx - Semantic addressing extention for go's net package
This package provides an extention of go stdlib's net package. It provides extended Listen
and Dial
methods
in order to enabled clients and servers for semantic addressing. The returned structs implement net.Listener
and
net.Conn
and should seamlessly integrate with your existing application.
For transport/service organisation, NATS, consul or DNSSRV can be used. An implementation of quic is in development.
The following examples require a local NATS node on port 4222.
TCP connection example
import (
"fmt"
"github.com/simia-tech/netx"
_ "github.com/simia-tech/netx/network/nats"
)
func main() {
listener, _ := netx.Listen("nats", "echo", netx.Nodes("nats://localhost:4222"))
go func() {
conn, _ := listener.Accept()
defer conn.Close()
buffer := make([]byte, 5)
conn.Read(buffer)
conn.Write(buffer)
}()
client, _ := netx.Dial("nats", "echo", netx.Nodes("nats://localhost:4222"))
defer client.Close()
fmt.Fprintf(client, "hello")
buffer := make([]byte, 5)
client.Read(buffer)
fmt.Println(string(buffer))
// Output: hello
}
HTTP connection example
import (
"net/http"
"fmt"
"io/ioutil"
"github.com/simia-tech/netx"
_ "github.com/simia-tech/netx/network/nats"
)
func main() {
listener, _ := netx.Listen("nats", "greeter", netx.Nodes("nats://localhost:4222"))
mux := &http.ServeMux{}
mux.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Hello")
})
server := &http.Server{Handler: mux}
go func() {
server.Serve(listener)
}()
client := &http.Client{
Transport: netx.NewHTTPTransport("nats", netx.Nodes("nats://localhost:4222")),
}
response, _ := client.Get("http://greeter/hello")
defer response.Body.Close()
body, _ := ioutil.ReadAll(response.Body)
fmt.Println(string(body))
// Output: Hello
}
GRPC connection example
import (
"fmt"
"log"
"time"
"golang.org/x/net/context"
"google.golang.org/grpc"
"github.com/simia-tech/netx"
_ "github.com/simia-tech/netx/network/nats"
)
type echoServer struct{}
func (e *echoServer) Echo(ctx context.Context, request *EchoRequest) (*EchoResponse, error) {
return &EchoResponse{Text: request.Text}, nil
}
func main() {
listener, _ := netx.Listen("nats", "echo", netx.Nodes("nats://localhost:4222"))
server := grpc.NewServer()
RegisterEchoServiceServer(server, &echoServer{})
go func() {
server.Serve(listener)
}()
conn, _ := grpc.Dial("echo",
grpc.WithDialer(netx.NewGRPCDialer("nats", netx.Nodes("nats://localhost:4222"))),
grpc.WithInsecure())
client := NewEchoServiceClient(conn)
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
response, _ := client.Echo(ctx, &EchoRequest{Text: "Hello"})
cancel()
fmt.Println(response.Text)
// Output: Hello
}
More examples
More example can be found in the example directory.
Tests
In order to run the tests, type
go test -v ./...