'get nacos client'

configs/api_config.yaml

@@ -34,7 +34,7 @@ resources:
             - name: requestBody._all
               mapTo: 0
               mapType: "object"
-          applicationName: "UserProvider"
+          applicationName: "service-gateway-provider"
           interface: "com.dubbogo.pixiu.UserService"
           method: "CreateUser"
           group: "test"

configs/conf.yaml

@@ -93,6 +93,12 @@ static_resources:
             strip-prefix: true            # 代理请求时移除前缀 rm /scp
             otherConfig: "pixiu"
         registries:
+          "Nacos":
+            protocol: "Nacos"
+            timeout: "3s"
+            address: "127.0.0.1:8848"
+            username: ""
+            password: ""
           "eureka":
             protocol: "eureka"
             enable: true
@@ -109,4 +115,3 @@ static_resources:
             address: "127.0.0.1:2181"
             username: ""
             password: ""
-

pkg/adapter/springcloud/cloud.go

@@ -18,10 +18,17 @@
 package springcloud
 
 import (
+	"fmt"
 	"github.com/apache/dubbo-go-pixiu/pkg/common/constant"
 	"github.com/apache/dubbo-go-pixiu/pkg/common/extension/adapter"
+	"github.com/apache/dubbo-go-pixiu/pkg/logger"
 	"github.com/apache/dubbo-go-pixiu/pkg/model"
+	"github.com/apache/dubbo-go-pixiu/pkg/registry"
+	"github.com/apache/dubbo-go-pixiu/pkg/registry/nacos"
 	"github.com/apache/dubbo-go-pixiu/pkg/server"
+	"net"
+	"strconv"
+	"strings"
 )
 
 const (
@@ -40,13 +47,13 @@ type (
 
 	// CloudAdapter the adapter for spring cloud
 	CloudAdapter struct {
-		boot *model.Bootstrap
-		cfg *Config
+		cfg        *Config
+		LoaderUsed registry.Loader
 	}
 
 	// Config the config for CloudAdapter
 	Config struct {
-		Registry *Registry `yaml:"registry" json:"registry" default:"registry"`
+		Registry *Registry `yaml:"registrys" json:"registrys" default:"registrys"`
 	}
 
 	// Registry remote registry where spring cloud apis are registered.
@@ -65,17 +72,35 @@ func (p *CloudPlugin) Kind() string {
 }
 
 // CreateAdapter create adapter
-func (p *CloudPlugin) CreateAdapter(config interface{}, bs *model.Bootstrap) (adapter.Adapter, error) {
-	return &CloudAdapter{
-		cfg: &Config{},
-		boot: bs,
-	}, nil
+func (p *CloudPlugin) CreateAdapter(config interface{}, ad *model.Adapter) (adapter.Adapter, error) {
+	//registryUsed := ad.Config["registry"].(map[string]interface{})
+	registryUsed := config.(map[string]interface{})
+	fmt.Println(registryUsed)
+	var loader registry.Loader
+	reg := registryUsed["registries"].(map[string]interface{})
+	for key, _ := range reg {
+		switch key {
+		case "Nacos":
+			loader = new(nacos.NacosRegistry)
+		case "consul":
+			loader = new(registry.ConsulRegistryLoad)
+		case "zookeeper":
+			loader = new(registry.ZookeeperRegistryLoad)
+		}
+	}
+	return &CloudAdapter{cfg: &Config{}, LoaderUsed: loader}, nil
 }
 
 // Start start the adapter
-func (a *CloudAdapter) Start() {
+func (a *CloudAdapter) Start(adapter *model.Adapter) {
+	reg := a.LoaderUsed
+	RegistryLoader, err := reg.NewRegistryLoader(adapter)
+	if err != nil {
+		logger.Info("fail to get registyloader")
+	}
 	// do not block the main goroutine
 	go func() {
+		//init registry client
 
 		// init SpringCloud Manager for control initialize
 		cloudManager := NewSpringCloudManager(&SpringCloudConfig{boot: a.boot})
@@ -85,33 +110,83 @@ func (a *CloudAdapter) Start() {
 		// fetch service instance from consul
 
 		// transform into endpoint and cluster
-		endpoint := &model.Endpoint{}
-		endpoint.ID = "user-mock-service"
-		endpoint.Address = model.SocketAddress{
-			Address: "127.0.0.1",
-			Port:    8080,
+		//endpoint := &model.Endpoint{}
+		//endpoint.ID = "user-mock-service"
+		//endpoint.Address = model.SocketAddress{
+		//	Address: "127.0.0.1",
+		//	Port:    8080,
+		//}
+		//cluster := &model.Cluster{}
+		//cluster.Name = "userservice"
+		//cluster.Lb = model.Rand
+		//cluster.Endpoints = []*model.Endpoint{
+		//	endpoint,
+		//}
+		//// add cluster into manager
+		//cm := server.GetClusterManager()
+		//cm.AddCluster(cluster)
+		//
+		//// transform into route
+		//routeMatch := model.RouterMatch{
+		//	Prefix: "/user",
+		//}
+		//routeAction := model.RouteAction{
+		//	Cluster: "userservice",
+		//}
+		//route := &model.Router{Match: routeMatch, Route: routeAction}
+		//
+		//server.GetRouterManager().AddRouter(route)
+
+		urls, err := RegistryLoader.LoadAllServices()
+		if err != nil {
+			logger.Error("can't get service for %s re")
 		}
-		cluster := &model.Cluster{}
-		cluster.Name = "userservice"
-		cluster.Lb = model.Rand
-		cluster.Endpoints = []*model.Endpoint{
-			endpoint,
-		}
-		// add cluster into manager
-		cm := server.GetClusterManager()
-		cm.AddCluster(cluster)
-
-		// transform into route
-		routeMatch := model.RouterMatch{
-			Prefix: "/user",
+		var endpoints []*model.Endpoint
+		for _, url := range urls {
+			endpoint := url.GetParam("endpoint", "")
+			tmp := strings.Split(endpoint, ",")
+			for _, path := range tmp {
+				ep := &model.Endpoint{}
+				ip, port, err := net.SplitHostPort(path)
+				porti, err := strconv.Atoi(port)
+				if err != nil {
+					logger.Info("split ip & port failed")
+				}
+				ep.ID = url.GetParam("Name", "")
+				ep.Address = model.SocketAddress{
+					Address: ip,
+					Port:    porti,
+				}
+				endpoints = append(endpoints, ep)
+			}
+			// get cluster
+			cluster := &model.Cluster{}
+			cluster.Name = url.GetParam(constant.NameKey, "")
+			lb := url.GetParam("loadbalance", "")
+			switch lb {
+			case "RoundRobin":
+				cluster.Lb = model.RoundRobin
+			case "IPHash":
+				cluster.Lb = model.IPHash
+			case "WightRobin":
+				cluster.Lb = model.WightRobin
+			case "Rand":
+				cluster.Lb = model.Rand
+			}
+			cluster.Endpoints = endpoints
+			cm := server.GetClusterManager()
+			cm.AddCluster(cluster)
+			// transform into route
+			routeMatch := model.RouterMatch{
+				Prefix: "/user",
+			}
+			routeAction := model.RouteAction{
+				Cluster: "userservice",
+			}
+			route := &model.Router{Match: routeMatch, Route: routeAction}
+
+			server.GetRouterManager().AddRouter(route)
 		}
-		routeAction := model.RouteAction{
-			Cluster: "userservice",
-		}
-		route := &model.Router{Match: routeMatch, Route: routeAction}
-
-		server.GetRouterManager().AddRouter(route)
-
 	}()
 }
 
@@ -122,6 +197,7 @@ func (a *CloudAdapter) Stop() {
 
 // Apply init
 func (a *CloudAdapter) Apply() error {
+
 	return nil
 }
 

pkg/common/extension/adapter/adapter.go

@@ -36,13 +36,13 @@ type (
 		Kind() string
 
 		// CreateAdapter return the Adapter callback
-		CreateAdapter(config interface{}, bs *model.Bootstrap) (Adapter, error)
+		CreateAdapter(config interface{}, ad *model.Adapter) (Adapter, error)
 	}
 
 	// Adapter adapter interface
 	Adapter interface {
 		// Start start adapter lifetime
-		Start()
+		Start(adapter *model.Adapter)
 		// Stop stop adapter lifetime
 		Stop()
 		// Apply init

pkg/common/yaml/yaml.go

@@ -18,6 +18,7 @@
 package yaml
 
 import (
+	"fmt"
 	"io/ioutil"
 	"path"
 )
@@ -69,6 +70,7 @@ func ParseConfig(factoryConfStruct interface{}, conf map[string]interface{}) err
 	// Unmarshal yamlStr to factoryConf
 	err = yaml.Unmarshal(yamlBytes, factoryConfStruct)
 	if err != nil {
+		fmt.Println(err)
 		return err
 	}
 	return nil

pkg/registry/consul.go

@@ -18,6 +18,7 @@
 package registry
 
 import (
+	"github.com/apache/dubbo-go-pixiu/pkg/model"
 	"net/url"
 	"strconv"
 	"strings"
@@ -52,6 +53,10 @@ type ConsulRegistryLoad struct {
 	cluster string
 }
 
+func (crl *ConsulRegistryLoad) NewRegistryLoader(ad *model.Adapter) (Loader, error) {
+	return nil, nil
+}
+
 func newConsulRegistryLoad(address, cluster string) (Loader, error) {
 	config := &consul.Config{Address: address}
 	client, err := consul.NewClient(config)
@@ -121,3 +126,7 @@ func (crl *ConsulRegistryLoad) LoadAllServices() ([]*common.URL, error) {
 	}
 	return urls, nil
 }
+
+func (crl *ConsulRegistryLoad) NewRegistry(sr *model.StaticResources) Loader {
+	return nil
+}

pkg/registry/load.go

@@ -18,11 +18,14 @@
 package registry
 
 import (
+	"github.com/apache/dubbo-go-pixiu/pkg/model"
 	"github.com/apache/dubbo-go/common"
 )
 
 // Loader this interface defined for load services from different kinds registry, such as nacos,consul,zookeeper.
 type Loader interface {
+	//
+	NewRegistryLoader(*model.Adapter) (Loader, error)
 	// LoadAllServices load all services registered in registry
 	LoadAllServices() ([]*common.URL, error)
 	// GetCluster get the registry name