add registry base interface, mdns, noop implementations, add resolver, client

client/client.go

@@ -0,0 +1,53 @@
+package client
+
+import (
+	"crypto/tls"
+	"fmt"
+	"strings"
+
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials"
+	"google.golang.org/grpc/resolver"
+
+	"gitlab.bertha.cloud/partitio/lab/grpc/registry/noop"
+)
+
+type Client interface {
+	Dial(name string, version string, opts ...grpc.DialOption) (*grpc.ClientConn, error)
+}
+
+func New(opts ...Option) (Client, error) {
+	c := &client{opts: &options{}}
+	for _, o := range opts {
+		o(c.opts)
+	}
+	if c.opts.registry == nil {
+		c.opts.registry = noop.New()
+	}
+	resolver.Register(c.opts.registry.ResolverBuilder())
+	c.pool = newPool(DefaultPoolSize, DefaultPoolTTL, DefaultPoolMaxIdle, DefaultPoolMaxStreams)
+	return c, nil
+}
+
+type client struct {
+	pool *pool
+	opts *options
+}
+
+func (c client) Dial(name, version string, opts ...grpc.DialOption) (*grpc.ClientConn, error) {
+	if c.opts.tlsConfig == nil && c.opts.Secure() {
+		c.opts.tlsConfig = &tls.Config{InsecureSkipVerify: true}
+	}
+	if c.opts.tlsConfig != nil {
+		opts = append(opts, grpc.WithTransportCredentials(credentials.NewTLS(c.opts.tlsConfig)))
+	}
+	addr := fmt.Sprintf("%s:///%s", c.opts.registry.String(), name)
+	if version != "" {
+		addr = addr + ":" + strings.TrimSpace(version)
+	}
+	pc, err := c.pool.getConn(addr, opts...)
+	if err != nil {
+	  return nil, err
+	}
+	return pc.ClientConn, nil
+}

client/options.go

@@ -0,0 +1,63 @@
+package client
+
+import (
+	"crypto/tls"
+
+	"gitlab.bertha.cloud/partitio/lab/grpc/registry"
+)
+
+type Options interface {
+	Version() string
+	Registry() registry.Registry
+	TLSConfig() *tls.Config
+}
+
+type Option func(*options)
+
+func WithRegistry(registry registry.Registry) Option {
+	return func(o *options) {
+		o.registry = registry
+	}
+}
+
+func WithVersion(version string) Option {
+	return func(o *options) {
+		o.version = version
+	}
+}
+
+func WithTLSConfig(conf *tls.Config) Option {
+	return func(o *options) {
+		o.tlsConfig = conf
+	}
+}
+
+func WithSecure(s bool) Option {
+	return func(o *options) {
+		o.secure = s
+	}
+}
+
+type options struct {
+	registry  registry.Registry
+	version   string
+	tlsConfig *tls.Config
+	secure    bool
+}
+
+func (o *options) Version() string {
+	return o.version
+}
+
+func (o *options) Registry() registry.Registry {
+	return o.registry
+}
+
+func (o *options) TLSConfig() *tls.Config {
+	return o.tlsConfig
+}
+
+func (o *options) Secure() bool {
+	return o.secure
+}
+

client/pool.go

@@ -0,0 +1,244 @@
+/*
+Taken from the https://github.com/micro/go-micro/client/grpc
+ */
+
+package client
+
+import (
+	"sync"
+	"time"
+
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/connectivity"
+)
+
+var (
+	// DefaultPoolSize sets the connection pool size
+	DefaultPoolSize = 100
+	// DefaultPoolTTL sets the connection pool ttl
+	DefaultPoolTTL = time.Minute
+	// DefaultPoolMaxStreams maximum streams on a connectioin
+	// (20)
+	DefaultPoolMaxStreams = 20
+
+	// DefaultPoolMaxIdle maximum idle conns of a pool
+	// (50)
+	DefaultPoolMaxIdle = 50
+
+	// DefaultMaxRecvMsgSize maximum message that client can receive
+	// (4 MB).
+	DefaultMaxRecvMsgSize = 1024 * 1024 * 4
+
+	// DefaultMaxSendMsgSize maximum message that client can send
+	// (4 MB).
+	DefaultMaxSendMsgSize = 1024 * 1024 * 4
+)
+
+type pool struct {
+	size int
+	ttl  int64
+
+	//  max streams on a *poolConn
+	maxStreams int
+	//  max idle conns
+	maxIdle int
+
+	sync.Mutex
+	conns map[string]*streamsPool
+}
+
+type streamsPool struct {
+	//  head of list
+	head *poolConn
+	//  busy conns list
+	busy *poolConn
+	//  the siza of list
+	count int
+	//  idle conn
+	idle int
+}
+
+type poolConn struct {
+	//  grpc conn
+	*grpc.ClientConn
+	err  error
+	addr string
+
+	//  pool and streams pool
+	pool    *pool
+	sp      *streamsPool
+	streams int
+	created int64
+
+	//  list
+	pre  *poolConn
+	next *poolConn
+	in   bool
+}
+
+func newPool(size int, ttl time.Duration, idle int, ms int) *pool {
+	if ms <= 0 {
+		ms = 1
+	}
+	if idle < 0 {
+		idle = 0
+	}
+	return &pool{
+		size:       size,
+		ttl:        int64(ttl.Seconds()),
+		maxStreams: ms,
+		maxIdle:    idle,
+		conns:      make(map[string]*streamsPool),
+	}
+}
+
+func (p *pool) getConn(addr string, opts ...grpc.DialOption) (*poolConn, error) {
+	now := time.Now().Unix()
+	p.Lock()
+	sp, ok := p.conns[addr]
+	if !ok {
+		sp = &streamsPool{head: &poolConn{}, busy: &poolConn{}, count: 0, idle: 0}
+		p.conns[addr] = sp
+	}
+	//  while we have conns check streams and then return one
+	//  otherwise we'll create a new conn
+	conn := sp.head.next
+	for conn != nil {
+		//  check conn state
+		// https://github.com/grpc/grpc/blob/master/doc/connectivity-semantics-and-api.md
+		switch conn.GetState() {
+		case connectivity.Connecting:
+			conn = conn.next
+			continue
+		case connectivity.Shutdown:
+			next := conn.next
+			if conn.streams == 0 {
+				removeConn(conn)
+				sp.idle--
+			}
+			conn = next
+			continue
+		case connectivity.TransientFailure:
+			next := conn.next
+			if conn.streams == 0 {
+				removeConn(conn)
+				conn.ClientConn.Close()
+				sp.idle--
+			}
+			conn = next
+			continue
+		case connectivity.Ready:
+		case connectivity.Idle:
+		}
+		//  a old conn
+		if now-conn.created > p.ttl {
+			next := conn.next
+			if conn.streams == 0 {
+				removeConn(conn)
+				conn.ClientConn.Close()
+				sp.idle--
+			}
+			conn = next
+			continue
+		}
+		//  a busy conn
+		if conn.streams >= p.maxStreams {
+			next := conn.next
+			removeConn(conn)
+			addConnAfter(conn, sp.busy)
+			conn = next
+			continue
+		}
+		//  a idle conn
+		if conn.streams == 0 {
+			sp.idle--
+		}
+		//  a good conn
+		conn.streams++
+		p.Unlock()
+		return conn, nil
+	}
+	p.Unlock()
+
+	//  create new conn
+	cc, err := grpc.Dial(addr, opts...)
+	if err != nil {
+		return nil, err
+	}
+	conn = &poolConn{cc, nil, addr, p, sp, 1, time.Now().Unix(), nil, nil, false}
+
+	//  add conn to streams pool
+	p.Lock()
+	if sp.count < p.size {
+		addConnAfter(conn, sp.head)
+	}
+	p.Unlock()
+
+	return conn, nil
+}
+
+func (p *pool) release(addr string, conn *poolConn, err error) {
+	p.Lock()
+	p, sp, created := conn.pool, conn.sp, conn.created
+	//  try to add conn
+	if !conn.in && sp.count < p.size {
+		addConnAfter(conn, sp.head)
+	}
+	if !conn.in {
+		p.Unlock()
+		conn.ClientConn.Close()
+		return
+	}
+	//  a busy conn
+	if conn.streams >= p.maxStreams {
+		removeConn(conn)
+		addConnAfter(conn, sp.head)
+	}
+	conn.streams--
+	//  if streams == 0, we can do something
+	if conn.streams == 0 {
+		//  1. it has errored
+		//  2. too many idle conn or
+		//  3. conn is too old
+		now := time.Now().Unix()
+		if err != nil || sp.idle >= p.maxIdle || now-created > p.ttl {
+			removeConn(conn)
+			p.Unlock()
+			conn.ClientConn.Close()
+			return
+		}
+		sp.idle++
+	}
+	p.Unlock()
+	return
+}
+
+func (conn *poolConn) Close() {
+	conn.pool.release(conn.addr, conn, conn.err)
+}
+
+func removeConn(conn *poolConn) {
+	if conn.pre != nil {
+		conn.pre.next = conn.next
+	}
+	if conn.next != nil {
+		conn.next.pre = conn.pre
+	}
+	conn.pre = nil
+	conn.next = nil
+	conn.in = false
+	conn.sp.count--
+	return
+}
+
+func addConnAfter(conn *poolConn, after *poolConn) {
+	conn.next = after.next
+	conn.pre = after
+	if after.next != nil {
+		after.next.pre = conn
+	}
+	after.next = conn
+	conn.in = true
+	conn.sp.count++
+	return
+}