• Stars
    star
    9
  • Rank 1,939,727 (Top 39 %)
  • Language
    Go
  • License
    MIT License
  • Created about 8 years ago
  • Updated almost 6 years ago

Reviews

There are no reviews yet. Be the first to send feedback to the community and the maintainers!

Repository Details

Semantic addressing extention for golang's net package

netx - Semantic addressing extention for go's net package

GoDoc Build Status

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