Skip to content

Commit

Permalink
use sync.Map on pool package (#909)
Browse files Browse the repository at this point in the history
  • Loading branch information
@refs
refs authored Jun 30, 2020
1 parent 39a90d4 commit 9bbdbee
Showing 1 changed file with 97 additions and 94 deletions.
191 changes: 97 additions & 94 deletions pkg/rgrpc/todo/pool/pool.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -19,6 +19,8 @@
package pool

import (
"sync"

appprovider "github.com/cs3org/go-cs3apis/cs3/app/provider/v1beta1"
appregistry "github.com/cs3org/go-cs3apis/cs3/app/registry/v1beta1"
authprovider "github.com/cs3org/go-cs3apis/cs3/auth/provider/v1beta1"
Expand All @@ -39,25 +41,26 @@ import (
"google.golang.org/grpc"
)

// TODO(labkode): is concurrent access to the maps safe?
var storageProviders = map[string]storageprovider.ProviderAPIClient{}
var authProviders = map[string]authprovider.ProviderAPIClient{}
var authRegistries = map[string]authregistry.RegistryAPIClient{}
var userShareProviders = map[string]collaboration.CollaborationAPIClient{}
var ocmShareProviders = map[string]ocm.OcmAPIClient{}
var ocmInviteManagers = map[string]invitepb.InviteAPIClient{}
var ocmProviderAuthorizers = map[string]ocmprovider.ProviderAPIClient{}
var ocmCores = map[string]ocmcore.OcmCoreAPIClient{}
var publicShareProviders = map[string]link.LinkAPIClient{}
var preferencesProviders = map[string]preferences.PreferencesAPIClient{}
var appRegistries = map[string]appregistry.RegistryAPIClient{}
var appProviders = map[string]appprovider.ProviderAPIClient{}
var storageRegistries = map[string]storageregistry.RegistryAPIClient{}
var gatewayProviders = map[string]gateway.GatewayAPIClient{}
var userProviders = map[string]user.UserAPIClient{}

// NewConn creates a new connection to a grpc server
// with open census tracing support.
var (
publicShareProviders = sync.Map{}
preferencesProviders = sync.Map{}
userShareProviders = sync.Map{}
storageRegistries = sync.Map{}
gatewayProviders = sync.Map{}
storageProviders = sync.Map{}
authRegistries = sync.Map{}
authProviders = sync.Map{}
appRegistries = sync.Map{}
userProviders = sync.Map{}
appProviders = sync.Map{}

ocmProviderAuthorizers = sync.Map{}
ocmShareProviders = sync.Map{}
ocmInviteManagers = sync.Map{}
ocmCores = sync.Map{}
)

// NewConn creates a new connection to a grpc server with open census tracing support.
// TODO(labkode): make grpc tls configurable.
func NewConn(endpoint string) (*grpc.ClientConn, error) {
conn, err := grpc.Dial(endpoint, grpc.WithInsecure(), grpc.WithStatsHandler(&ocgrpc.ClientHandler{}))
Expand All @@ -70,240 +73,240 @@ func NewConn(endpoint string) (*grpc.ClientConn, error) {

// GetGatewayServiceClient returns a GatewayServiceClient.
func GetGatewayServiceClient(endpoint string) (gateway.GatewayAPIClient, error) {
if val, ok := gatewayProviders[endpoint]; ok {
return val, nil
if c, ok := gatewayProviders.Load(endpoint); ok {
return c.(gateway.GatewayAPIClient), nil
}

conn, err := NewConn(endpoint)
if err != nil {
return nil, err
}

gatewayProviders[endpoint] = gateway.NewGatewayAPIClient(conn)

return gatewayProviders[endpoint], nil
v := gateway.NewGatewayAPIClient(conn)
gatewayProviders.Store(endpoint, v)
return v, nil
}

// GetUserProviderServiceClient returns a UserProviderServiceClient.
func GetUserProviderServiceClient(endpoint string) (user.UserAPIClient, error) {
if val, ok := userProviders[endpoint]; ok {
return val, nil
if c, ok := userProviders.Load(endpoint); ok {
return c.(user.UserAPIClient), nil
}

conn, err := NewConn(endpoint)
if err != nil {
return nil, err
}

userProviders[endpoint] = user.NewUserAPIClient(conn)
return userProviders[endpoint], nil
v := user.NewUserAPIClient(conn)
userProviders.Store(endpoint, v)
return v, nil
}

// GetStorageProviderServiceClient returns a StorageProviderServiceClient.
func GetStorageProviderServiceClient(endpoint string) (storageprovider.ProviderAPIClient, error) {
if val, ok := storageProviders[endpoint]; ok {
return val, nil
if c, ok := storageProviders.Load(endpoint); ok {
return c.(storageprovider.ProviderAPIClient), nil
}

conn, err := NewConn(endpoint)
if err != nil {
return nil, err
}

storageProviders[endpoint] = storageprovider.NewProviderAPIClient(conn)

return storageProviders[endpoint], nil
v := storageprovider.NewProviderAPIClient(conn)
storageProviders.Store(endpoint, v)
return v, nil
}

// GetAuthRegistryServiceClient returns a new AuthRegistryServiceClient.
func GetAuthRegistryServiceClient(endpoint string) (authregistry.RegistryAPIClient, error) {
if val, ok := authRegistries[endpoint]; ok {
return val, nil
if c, ok := authRegistries.Load(endpoint); ok {
return c.(authregistry.RegistryAPIClient), nil
}

conn, err := NewConn(endpoint)
if err != nil {
return nil, err
}

authRegistries[endpoint] = authregistry.NewRegistryAPIClient(conn)

return authRegistries[endpoint], nil
v := authregistry.NewRegistryAPIClient(conn)
authRegistries.Store(endpoint, v)
return v, nil
}

// GetAuthProviderServiceClient returns a new AuthProviderServiceClient.
func GetAuthProviderServiceClient(endpoint string) (authprovider.ProviderAPIClient, error) {
if val, ok := authProviders[endpoint]; ok {
return val, nil
if c, ok := authProviders.Load(endpoint); ok {
return c.(authprovider.ProviderAPIClient), nil
}

conn, err := NewConn(endpoint)
if err != nil {
return nil, err
}

authProviders[endpoint] = authprovider.NewProviderAPIClient(conn)

return authProviders[endpoint], nil
v := authprovider.NewProviderAPIClient(conn)
authProviders.Store(endpoint, v)
return v, nil
}

// GetUserShareProviderClient returns a new UserShareProviderClient.
func GetUserShareProviderClient(endpoint string) (collaboration.CollaborationAPIClient, error) {
if val, ok := userShareProviders[endpoint]; ok {
return val, nil
if c, ok := userShareProviders.Load(endpoint); ok {
return c.(collaboration.CollaborationAPIClient), nil
}

conn, err := NewConn(endpoint)
if err != nil {
return nil, err
}

userShareProviders[endpoint] = collaboration.NewCollaborationAPIClient(conn)

return userShareProviders[endpoint], nil
v := collaboration.NewCollaborationAPIClient(conn)
userShareProviders.Store(endpoint, v)
return v, nil
}

// GetOCMShareProviderClient returns a new OCMShareProviderClient.
func GetOCMShareProviderClient(endpoint string) (ocm.OcmAPIClient, error) {
if val, ok := ocmShareProviders[endpoint]; ok {
return val, nil
if c, ok := ocmShareProviders.Load(endpoint); ok {
return c.(ocm.OcmAPIClient), nil
}

conn, err := NewConn(endpoint)
if err != nil {
return nil, err
}

ocmShareProviders[endpoint] = ocm.NewOcmAPIClient(conn)

return ocmShareProviders[endpoint], nil
v := ocm.NewOcmAPIClient(conn)
ocmShareProviders.Store(endpoint, v)
return v, nil
}

// GetOCMInviteManagerClient returns a new OCMInviteManagerClient.
func GetOCMInviteManagerClient(endpoint string) (invitepb.InviteAPIClient, error) {

if val, ok := ocmInviteManagers[endpoint]; ok {
return val, nil
if c, ok := ocmInviteManagers.Load(endpoint); ok {
return c.(invitepb.InviteAPIClient), nil
}

conn, err := NewConn(endpoint)
if err != nil {
return nil, err
}

ocmInviteManagers[endpoint] = invitepb.NewInviteAPIClient(conn)

return ocmInviteManagers[endpoint], nil
v := invitepb.NewInviteAPIClient(conn)
ocmInviteManagers.Store(endpoint, v)
return v, nil
}

// GetPublicShareProviderClient returns a new PublicShareProviderClient.
func GetPublicShareProviderClient(endpoint string) (link.LinkAPIClient, error) {
if val, ok := publicShareProviders[endpoint]; ok {
return val, nil
if c, ok := publicShareProviders.Load(endpoint); ok {
return c.(link.LinkAPIClient), nil
}

conn, err := NewConn(endpoint)
if err != nil {
return nil, err
}

publicShareProviders[endpoint] = link.NewLinkAPIClient(conn)

return publicShareProviders[endpoint], nil
v := link.NewLinkAPIClient(conn)
publicShareProviders.Store(endpoint, v)
return v, nil
}

// GetPreferencesClient returns a new PreferencesClient.
func GetPreferencesClient(endpoint string) (preferences.PreferencesAPIClient, error) {
if val, ok := preferencesProviders[endpoint]; ok {
return val, nil
if c, ok := preferencesProviders.Load(endpoint); ok {
return c.(preferences.PreferencesAPIClient), nil
}

conn, err := NewConn(endpoint)
if err != nil {
return nil, err
}

preferencesProviders[endpoint] = preferences.NewPreferencesAPIClient(conn)

return preferencesProviders[endpoint], nil
v := preferences.NewPreferencesAPIClient(conn)
preferencesProviders.Store(endpoint, v)
return v, nil
}

// GetAppRegistryClient returns a new AppRegistryClient.
func GetAppRegistryClient(endpoint string) (appregistry.RegistryAPIClient, error) {
if val, ok := appRegistries[endpoint]; ok {
return val, nil
if c, ok := appRegistries.Load(endpoint); ok {
return c.(appregistry.RegistryAPIClient), nil
}

conn, err := NewConn(endpoint)
if err != nil {
return nil, err
}

appRegistries[endpoint] = appregistry.NewRegistryAPIClient(conn)

return appRegistries[endpoint], nil
v := appregistry.NewRegistryAPIClient(conn)
appRegistries.Store(endpoint, v)
return v, nil
}

// GetAppProviderClient returns a new AppRegistryClient.
func GetAppProviderClient(endpoint string) (appprovider.ProviderAPIClient, error) {
if val, ok := appProviders[endpoint]; ok {
return val, nil
if c, ok := appProviders.Load(endpoint); ok {
return c.(appprovider.ProviderAPIClient), nil
}

conn, err := NewConn(endpoint)
if err != nil {
return nil, err
}

appProviders[endpoint] = appprovider.NewProviderAPIClient(conn)

return appProviders[endpoint], nil
v := appprovider.NewProviderAPIClient(conn)
appRegistries.Store(endpoint, v)
return v, nil
}

// GetStorageRegistryClient returns a new StorageRegistryClient.
func GetStorageRegistryClient(endpoint string) (storageregistry.RegistryAPIClient, error) {
if val, ok := storageRegistries[endpoint]; ok {
return val, nil
if c, ok := storageRegistries.Load(endpoint); ok {
return c.(storageregistry.RegistryAPIClient), nil
}

conn, err := NewConn(endpoint)
if err != nil {
return nil, err
}

storageRegistries[endpoint] = storageregistry.NewRegistryAPIClient(conn)

return storageRegistries[endpoint], nil
v := storageregistry.NewRegistryAPIClient(conn)
appRegistries.Store(endpoint, v)
return v, nil
}

// GetOCMProviderAuthorizerClient returns a new OCMProviderAuthorizerClient.
func GetOCMProviderAuthorizerClient(endpoint string) (ocmprovider.ProviderAPIClient, error) {
if val, ok := ocmProviderAuthorizers[endpoint]; ok {
return val, nil
if c, ok := ocmProviderAuthorizers.Load(endpoint); ok {
return c.(ocmprovider.ProviderAPIClient), nil
}

conn, err := NewConn(endpoint)
if err != nil {
return nil, err
}

ocmProviderAuthorizers[endpoint] = ocmprovider.NewProviderAPIClient(conn)

return ocmProviderAuthorizers[endpoint], nil
v := ocmprovider.NewProviderAPIClient(conn)
ocmProviderAuthorizers.Store(endpoint, v)
return v, nil
}

// GetOCMCoreClient returns a new OCMCoreClient.
func GetOCMCoreClient(endpoint string) (ocmcore.OcmCoreAPIClient, error) {
if val, ok := ocmCores[endpoint]; ok {
return val, nil
if c, ok := ocmCores.Load(endpoint); ok {
return c.(ocmcore.OcmCoreAPIClient), nil
}

conn, err := NewConn(endpoint)
if err != nil {
return nil, err
}

ocmCores[endpoint] = ocmcore.NewOcmCoreAPIClient(conn)

return ocmCores[endpoint], nil
v := ocmcore.NewOcmCoreAPIClient(conn)
ocmProviderAuthorizers.Store(endpoint, v)
return v, nil
}

0 comments on commit 9bbdbee

Please sign in to comment.