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.
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
}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
}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 example can be found in the example directory.
In order to run the tests, type
go test -v ./...