Popularity
1.4
Growing
Activity
0.0
Stable
8
4
0

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

netx alternatives and similar packages

Based on the "Networking" category.
Alternatively, view netx alternatives based on common mentions on social networks and blogs.

Do you think we are missing an alternative of netx or a related project?

Add another 'Networking' Package

README

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