Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/simia-tech/netx
Semantic addressing extention for golang's net package
https://github.com/simia-tech/netx
consul dnssrv golang grpc http microservice nats networking-stack
Last synced: about 1 month ago
JSON representation
Semantic addressing extention for golang's net package
- Host: GitHub
- URL: https://github.com/simia-tech/netx
- Owner: simia-tech
- License: mit
- Created: 2016-10-20T12:03:08.000Z (about 8 years ago)
- Default Branch: master
- Last Pushed: 2018-12-05T15:29:23.000Z (almost 6 years ago)
- Last Synced: 2024-09-29T10:47:34.037Z (about 2 months ago)
- Topics: consul, dnssrv, golang, grpc, http, microservice, nats, networking-stack
- Language: Go
- Homepage:
- Size: 147 KB
- Stars: 9
- Watchers: 5
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# netx - Semantic addressing extention for go's net package
[](https://godoc.org/github.com/simia-tech/netx) [](https://travis-ci.org/simia-tech/netx)
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](http://nats.io), [consul](https://consul.io) or DNSSRV can be used. An
implementation of quic is in development.
The following examples require a local [NATS](http://nats.io) node on port 4222.
## TCP connection example
```go
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
```go
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
```go
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](https://github.com/simia-tech/netx/tree/master/example) directory.
## Tests
In order to run the tests, type
go test -v ./...