choose best grpc and rpc provider on first load and do the liveness test for configured provider

Author: faza

cmd/git-gitopia/lfs/init.go

@@ -13,6 +13,7 @@ import (
 	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
 	"github.com/gitopia/git-remote-gitopia/config"
 	"github.com/gitopia/git-remote-gitopia/core"
+	"github.com/gitopia/git-remote-gitopia/core/api"
 	gitopiatypes "github.com/gitopia/gitopia/v4/x/gitopia/types"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
@@ -51,7 +52,15 @@ func InitCommand() *cobra.Command {
 
 			interfaceRegistry := codectypes.NewInterfaceRegistry()
 
-			grpcConn, err := grpc.Dial(config.GRPCHost,
+			grpcHost, _ := config.GitConfigGet(config.GitopiaConfigGRPCHostOption)
+			if grpcHost == "" || !api.CheckGRPCHostLiveness(grpcHost) {
+				provider := api.GetBestApiProvider()
+				if err := api.SetConfiguredGRPCHost(provider.GRPCHost); err != nil {
+					return err
+				}
+			}
+
+			grpcConn, err := grpc.Dial(grpcHost,
 				grpc.WithTransportCredentials(insecure.NewCredentials()),
 				grpc.WithDefaultCallOptions(grpc.ForceCodec(codec.NewProtoCodec(interfaceRegistry).GRPCCodec())),
 			)

cmd/git-remote-gitopia/gitopia.go

@@ -55,10 +55,15 @@ type GitopiaHandler struct {
 func (h *GitopiaHandler) Initialize(remote *core.Remote) error {
 	var err error
 
-	grpcHost := api.GetConfiguredGRPCHost()
-	if grpcHost == "" || !api.CheckLiveness(grpcHost) {
-		grpcHost = api.GetBestGRPCHost()
-		if err := api.SetConfiguredGRPCHost(grpcHost); err != nil {
+	grpcHost, _ := config.GitConfigGet(config.GitopiaConfigGRPCHostOption)
+	tmAddr, _ := config.GitConfigGet(config.GitopiaConfigTmAddrOption)
+	if grpcHost == "" || tmAddr == "" || !api.CheckGRPCHostLiveness(grpcHost) || !api.CheckRPCHostLiveness(tmAddr) {
+		provider := api.GetBestApiProvider()
+		grpcHost = provider.GRPCHost
+		if err := api.SetConfiguredGRPCHost(provider.GRPCHost); err != nil {
+			return err
+		}
+		if err := api.SetConfiguredTmAddr(provider.TMAddr); err != nil {
 			return err
 		}
 	}

config/config.go

@@ -7,11 +7,20 @@ import (
 )
 
 const (
-	AppName              = "git-remote-gitopia"
-	gitopiaConfigSection = "gitopia"
+	AppName                          = "git-remote-gitopia"
+	GitopiaConfigSection             = "gitopia"
+	GitopiaConfigChainIdOption       = "chainId"
+	GitopiaConfigGRPCHostOption      = "grpcHost"
+	GitopiaConfigTmAddrOption        = "tmAddr"
+	GitopiaConfigGitServerHostOption = "gitServerHost"
+	GitopiaConfigKeyOption           = "key"
+	GitopiaConfigBackendOption       = "backend"
+	GitopiaConfigGasPricesOption     = "gasPrices"
+	GitopiaConfigFeeGranterOption    = "feeGranter"
+	GitopiaConfigDenomOption         = "denom"
 )
 
-func gitConfigGet(key string) (string, error) {
+func GitConfigGet(key string) (string, error) {
 	cmd := exec.Command("git", "config", "--get", fmt.Sprintf("gitopia.%s", key))
 	stdout, err := cmd.Output()
 
@@ -24,25 +33,19 @@ func gitConfigGet(key string) (string, error) {
 }
 
 func LoadGitConfig() error {
-	if res, err := gitConfigGet("chainId"); err == nil {
+	if res, err := GitConfigGet(GitopiaConfigChainIdOption); err == nil {
 		ChainId = res
 	}
-	if res, err := gitConfigGet("grpcHost"); err == nil {
-		GRPCHost = res
-	}
-	if res, err := gitConfigGet("gitServerHost"); err == nil {
+	if res, err := GitConfigGet(GitopiaConfigGitServerHostOption); err == nil {
 		GitServerHost = res
 	}
-	if res, err := gitConfigGet("tmAddr"); err == nil {
-		TmAddr = res
-	}
-	if res, err := gitConfigGet("gasPrices"); err == nil {
+	if res, err := GitConfigGet(GitopiaConfigGasPricesOption); err == nil {
 		GasPrices = res
 	}
-	if res, err := gitConfigGet("feeGranter"); err == nil {
+	if res, err := GitConfigGet(GitopiaConfigFeeGranterOption); err == nil {
 		FeeGranterAddr = res
 	}
-	if res, err := gitConfigGet("denom"); err == nil {
+	if res, err := GitConfigGet(GitopiaConfigDenomOption); err == nil {
 		Denom = res
 	}
 	return nil

config/config_dev.go

@@ -4,9 +4,7 @@ package config
 
 var (
 	ChainId        = "gitopia"
-	GRPCHost       = "grpc.devnet.gitopia.com:9090"
 	GitServerHost  = "https://server.devnet.gitopia.com"
-	TmAddr         = "https://rpc.devnet.gitopia.com:443"
 	GasPrices      = "0.001ulore"
 	FeeGranterAddr = ""
 	Denom          = "ulore"

config/config_prod.go

@@ -4,9 +4,7 @@ package config
 
 var (
 	ChainId        = "gitopia"
-	GRPCHost       = "grpc.gitopia.com:9090"
 	GitServerHost  = "https://server.gitopia.com"
-	TmAddr         = "https://rpc.gitopia.com:443"
 	GasPrices      = "0.001ulore"
 	FeeGranterAddr = "gitopia13ashgc6j5xle4m47kqyn5psavq0u3klmscfxql"
 	Denom          = "ulore"

config/config_testing.go

@@ -4,9 +4,7 @@ package config
 
 var (
 	ChainId        = "localgitopia"
-	GRPCHost       = "localhost:9090"
 	GitServerHost  = "http://localhost:5001"
-	TmAddr         = "http://localhost:26657"
 	GasPrices      = "0.001ulore"
 	FeeGranterAddr = "gitopia12sjhqc3rqgvu3zpg8ekmwl005rp4ys58ekqg89"
 	Denom          = "ulore"

core/api/grpc.go

@@ -2,8 +2,6 @@ package api
 
 import (
 	"context"
-	"os/exec"
-	"strings"
 	"time"
 
 	"github.com/cosmos/cosmos-sdk/client/grpc/tmservice"
@@ -12,13 +10,7 @@ import (
 	"google.golang.org/grpc/credentials/insecure"
 )
 
-func getGRPCHosts() []string {
-	return []string{
-		"gitopia-grpc.polkachu.com:11390",
-	}
-}
-
-func CheckLiveness(host string) bool {
+func CheckGRPCHostLiveness(host string) bool {
 	conn, err := grpc.Dial(host, grpc.WithTransportCredentials(insecure.NewCredentials()))
 	if err != nil {
 		return false
@@ -30,7 +22,7 @@ func CheckLiveness(host string) bool {
 	return err == nil
 }
 
-func checkLatency(host string) time.Duration {
+func checkGRPCHostLatency(host string) time.Duration {
 	start := time.Now()
 	conn, err := grpc.Dial(host, grpc.WithTransportCredentials(insecure.NewCredentials()))
 	if err != nil {
@@ -46,30 +38,6 @@ func checkLatency(host string) time.Duration {
 	return time.Since(start)
 }
 
-func GetBestGRPCHost() string {
-	hosts := getGRPCHosts()
-	bestHost := hosts[0]
-	bestLatency := time.Hour
-
-	for _, host := range hosts {
-		latency := checkLatency(host)
-		if latency < bestLatency {
-			bestHost = host
-			bestLatency = latency
-		}
-	}
-	return bestHost
-}
-
-func GetConfiguredGRPCHost() string {
-	cmd := exec.Command("git", "config", "--get", "gitopia.grpcHost")
-	out, err := cmd.Output()
-	if err != nil {
-		return ""
-	}
-	return strings.TrimSpace(string(out))
-}
-
 func SetConfiguredGRPCHost(host string) error {
 	cmd := core.GitCommand("git", "config", "--global", "gitopia.grpcHost", host)
 	return cmd.Run()

core/api/providers.go

@@ -0,0 +1,44 @@
+package api
+
+import (
+	"time"
+)
+
+type ProviderConfig struct {
+	GRPCHost string
+	TMAddr   string
+}
+
+var providers = []ProviderConfig{
+	{
+		GRPCHost: "gitopia.declab.pro:9017",
+		TMAddr:   "https://gitopia.declab.pro:26625",
+	},
+	{
+		GRPCHost: "gitopia-grpc.polkachu.com:11390",
+		TMAddr:   "https://gitopia-rpc.polkachu.com:443",
+	},
+	{
+		GRPCHost: "gitopia.grpc.m.stavr.tech:5123",
+		TMAddr:   "http://gitopia.rpc.m.stavr.tech:51057",
+	},
+	{
+		GRPCHost: "gitopia-rpc.stakeangle.com:41390",
+		TMAddr:   "https://gitopia-rpc.stakeangle.com",
+	},
+}
+
+func GetBestApiProvider() ProviderConfig {
+	bestHost := providers[0]
+	bestLatency := time.Hour
+
+	for _, p := range providers {
+		latency := checkGRPCHostLatency(p.GRPCHost)
+		if latency < bestLatency && CheckRPCHostLiveness(p.TMAddr) {
+			bestHost = p
+			bestLatency = latency
+		}
+	}
+
+	return bestHost
+}

core/api/rpc.go

@@ -0,0 +1,37 @@
+package api
+
+import (
+	"context"
+	"time"
+
+	clienthttp "github.com/cometbft/cometbft/rpc/client/http"
+	jsonrpcclient "github.com/cometbft/cometbft/rpc/jsonrpc/client"
+	"github.com/gitopia/git-remote-gitopia/core"
+)
+
+func CheckRPCHostLiveness(host string) bool {
+	httpClient, err := jsonrpcclient.DefaultHTTPClient(host)
+	if err != nil {
+		return false
+	}
+	httpClient.Timeout = time.Duration(5) * time.Second
+	c, err := clienthttp.NewWithClient(host, "/websocket", httpClient)
+	if err != nil {
+		return false
+	}
+
+	res, err := c.Status(context.Background())
+	if err != nil {
+		return false
+	}
+	if res.SyncInfo.CatchingUp {
+		return false
+	}
+
+	return true
+}
+
+func SetConfiguredTmAddr(addr string) error {
+	cmd := core.GitCommand("git", "config", "--global", "gitopia.tmAddr", addr)
+	return cmd.Run()
+}

core/wallet/os_keyring.go

@@ -28,11 +28,8 @@ import (
 )
 
 const (
-	AppName                    = "git-remote-gitopia"
-	AccountAddressPrefix       = "gitopia"
-	gitopiaConfigSection       = "gitopia"
-	gitopiaConfigKeyOption     = "key"
-	gitopiaConfigBackendOption = "backend"
+	AppName              = "git-remote-gitopia"
+	AccountAddressPrefix = "gitopia"
 )
 
 var (
@@ -68,28 +65,37 @@ func InitOSKeyringWallet(bankClient banktypes.QueryClient, feegrantClient feegra
 	if err != nil {
 		return nil, errors.Wrap(err, "error loading git config")
 	}
-	if conf.Raw.HasSection(gitopiaConfigSection) &&
-		conf.Raw.Section(gitopiaConfigSection).HasOption(gitopiaConfigKeyOption) {
-		key = conf.Raw.Section(gitopiaConfigSection).Option(gitopiaConfigKeyOption)
+	if conf.Raw.HasSection(config.GitopiaConfigSection) &&
+		conf.Raw.Section(config.GitopiaConfigSection).HasOption(config.GitopiaConfigKeyOption) {
+		key = conf.Raw.Section(config.GitopiaConfigSection).Option(config.GitopiaConfigKeyOption)
 	} else {
 		return nil, ErrGitopiaKeyNotConfigured
 	}
 
-	if conf.Raw.HasSection(gitopiaConfigSection) &&
-		conf.Raw.Section(gitopiaConfigSection).HasOption(gitopiaConfigBackendOption) {
-		backend = conf.Raw.Section(gitopiaConfigSection).Option(gitopiaConfigBackendOption)
+	if conf.Raw.HasSection(config.GitopiaConfigSection) &&
+		conf.Raw.Section(config.GitopiaConfigSection).HasOption(config.GitopiaConfigBackendOption) {
+		backend = conf.Raw.Section(config.GitopiaConfigSection).Option(config.GitopiaConfigBackendOption)
 	} else {
 		backend = keyring.BackendOS // default to OS. same as cosmos keys subcommand
 	}
 
+	grpcHost, err := config.GitConfigGet(config.GitopiaConfigGRPCHostOption)
+	if err != nil {
+		return nil, err
+	}
+	tmAddr, err := config.GitConfigGet(config.GitopiaConfigTmAddrOption)
+	if err != nil {
+		return nil, err
+	}
+
 	l := logrus.New()
 	l.SetOutput(os.Stderr)
 	ctx := logger.ContextWithValue(context.Background(), l)
 	glib.WithAppName(AppName)
 	glib.WithGasPrices(config.GasPrices)
-	glib.WithGitopiaAddr(config.GRPCHost)
+	glib.WithGitopiaAddr(grpcHost)
 	glib.WithChainId(config.ChainId)
-	glib.WithTmAddr(config.TmAddr)
+	glib.WithTmAddr(tmAddr)
 
 	cc, err := glib.GetClientContextWithOptions(AppName, backend, key)
 	if err != nil {