frostfs-node/pkg/network/cache/client.go

package cache

import (
	"crypto/tls"
	"fmt"
	"sync"

	"github.com/nspcc-dev/neofs-api-go/pkg/client"
	"github.com/nspcc-dev/neofs-node/pkg/network"
)

type (
	// ClientCache is a structure around neofs-api-go/pkg/client to reuse
	// already created clients.
	ClientCache struct {
		mu      *sync.RWMutex
		clients map[string]client.Client
		opts    []client.Option
	}
)

// NewSDKClientCache creates instance of client cache.
// `opts` are used for new client creation.
func NewSDKClientCache(opts ...client.Option) *ClientCache {
	return &ClientCache{
		mu:      new(sync.RWMutex),
		clients: make(map[string]client.Client),
		opts:    opts,
	}
}

// Get function returns existing client or creates a new one.
func (c *ClientCache) Get(netAddr *network.Address) (client.Client, error) {
	// multiaddr is used as a key in client cache since
	// same host may have different connections(with tls or not),
	// therefore, host+port pair is not unique
	mAddr := netAddr.String()

	c.mu.RLock()
	if cli, ok := c.clients[mAddr]; ok {
		// todo: check underlying connection neofs-api-go#196
		c.mu.RUnlock()

		return cli, nil
	}

	c.mu.RUnlock()
	// if client is not found in cache, then create a new one
	c.mu.Lock()
	defer c.mu.Unlock()

	// check once again if client is missing in cache, concurrent routine could
	// create client while this routine was locked on `c.mu.Lock()`.
	if cli, ok := c.clients[mAddr]; ok {
		return cli, nil
	}

	hostAddr, err := netAddr.HostAddrString()
	if err != nil {
		return nil, fmt.Errorf("could not parse address as a string: %w", err)
	}

	opts := append(c.opts, client.WithAddress(hostAddr))

	if netAddr.TLSEnabled() {
		opts = append(opts, client.WithTLSConfig(&tls.Config{}))
	}

	cli, err := client.New(opts...)
	if err != nil {
		return nil, err
	}

	c.clients[mAddr] = cli

	return cli, nil
}

// CloseAll closes underlying connections of all cached clients.
//
// Ignores closing errors.
func (c *ClientCache) CloseAll() {
	c.mu.RLock()

	{
		for _, cl := range c.clients {
			con := cl.Conn()
			if con != nil {
				_ = con.Close()
			}
		}
	}

	c.mu.RUnlock()
}