netx

Semantic addressing extention for golang's net package

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.

Programming language: Go

License: MIT License

Tags: Distributed Systems     Networking     Go     Golang    

Latest version: v0.0.1

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 ./...