Create & Init Project...

app/admin/main/cache/http/BUILD

@@ -0,0 +1,41 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "cache.go",
+        "http.go",
+        "overlord.go",
+    ],
+    importpath = "go-common/app/admin/main/cache/http",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/cache/conf:go_default_library",
+        "//app/admin/main/cache/model:go_default_library",
+        "//app/admin/main/cache/service:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//vendor/gopkg.in/yaml.v2:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/admin/main/cache/http/cache.go

@@ -0,0 +1,214 @@
+package http
+
+import (
+	"encoding/json"
+	"net"
+	"strconv"
+	"strings"
+
+	"go-common/app/admin/main/cache/model"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+
+	yaml "gopkg.in/yaml.v2"
+)
+
+// @params ClustersReq
+// @router get /x/admin/cache/clusters
+// @response ClustersResp
+func clusters(ctx *bm.Context) {
+	req := new(model.ClusterReq)
+	if err := ctx.Bind(req); err != nil {
+		return
+	}
+	req.Cookie = ctx.Request.Header.Get("Cookie")
+	ctx.JSON(srv.Clusters(ctx, req))
+}
+
+// @params AddClusterReq
+// @router post /x/admin/cache/cluster/add
+// @response EmpResp
+func addCluster(ctx *bm.Context) {
+	req := new(model.AddClusterReq)
+	if err := ctx.Bind(req); err != nil {
+		return
+	}
+	ctx.JSON(srv.AddCluster(ctx, req))
+}
+
+// @params delClusterReq
+// @router post /x/admin/cache/cluster/del
+// @response EmpResp
+func delCluster(ctx *bm.Context) {
+	req := new(model.DelClusterReq)
+	if err := ctx.Bind(req); err != nil {
+		return
+	}
+	ctx.JSON(srv.DelCluster(ctx, req))
+}
+
+// @params ClusterReq
+// @router get /x/admin/cache/cluster
+// @response []Cluster
+func cluster(ctx *bm.Context) {
+	req := new(model.ClusterReq)
+	if err := ctx.Bind(req); err != nil {
+		return
+	}
+
+	if req.AppID != "" {
+		resp, err := srv.Cluster(ctx, req)
+		if err != nil {
+			ctx.JSON(nil, err)
+			return
+		}
+		ctx.JSON(&model.ClusterResp{Clusters: resp}, nil)
+	} else {
+		req.Cookie = ctx.Request.Header.Get("Cookie")
+		ctx.JSON(srv.Clusters(ctx, req))
+	}
+}
+
+// @params ClusterDtlReq
+// @router get /x/admin/cache/cluster/detail
+// @response ClusterDtlResp
+func clusterDtl(ctx *bm.Context) {
+	req := new(model.ClusterDtlReq)
+	if err := ctx.Bind(req); err != nil {
+		return
+	}
+	ctx.JSON(srv.ClusterDtl(ctx, req))
+}
+
+// @params ModifyClusterReq
+// @router post /x/admin/cache/cluster/modify
+// @response EmpResp
+func modifyCluster(ctx *bm.Context) {
+	req := new(model.ModifyClusterReq)
+	if err := ctx.Bind(req); err != nil {
+		return
+	}
+	ctx.JSON(srv.ModifyCluster(ctx, req))
+}
+
+func toml(ctx *bm.Context) {
+	req := new(model.ClusterReq)
+	if err := ctx.Bind(req); err != nil {
+		return
+	}
+	resp, err := srv.Toml(ctx, req)
+	if err != nil {
+		ctx.Status(500)
+		return
+	}
+	ctx.Writer.Write(resp)
+}
+
+// @params addFromYml
+// @router post /x/admin/cache/cluster/from/yml
+// @response EmpResp
+func addFromYml(ctx *bm.Context) {
+	req := new(model.ClusterFromYml)
+	if err := ctx.Bind(req); err != nil {
+		ctx.JSONMap(map[string]interface{}{
+			"message": "参数有问题：app_id,zone,tw_yml",
+		}, ecode.RequestErr)
+		return
+	}
+	type server struct {
+		AutoEjectHosts     bool     `yaml:"auto_eject_hosts"`
+		Backlog            int      `yaml:"backlog"`
+		Distribution       string   `yaml:"distribution"`
+		Hash               string   `yaml:"hash"`
+		Listen             string   `yaml:"listen"`
+		Preconnect         bool     `yaml:"preconnect"`
+		Timeout            int      `yaml:"timeout"`
+		Redis              bool     `yaml:"redis"`
+		ServerConnections  int      `yaml:"server_connections"`
+		ServerFailureLimit int      `yaml:"server_failure_limit"`
+		ServerRetryTimeout int      `yaml:"server_retry_timeout"`
+		Servers            []string `yaml:"servers"`
+	}
+	type node struct {
+		Addr   string `json:"addr"`
+		Weigth int64  `json:"weight"`
+		Alias  string `json:"alias"`
+	}
+	confs := make(map[string]server)
+	err := yaml.Unmarshal([]byte(req.TwYml), &confs)
+	if err != nil {
+		ctx.JSONMap(map[string]interface{}{
+			"message": "解析twemproxy.yml文件失败",
+		}, ecode.RequestErr)
+		return
+	}
+	mcPort := 11211
+	rdPort := 26379
+	for name, conf := range confs {
+		ctp := "memcache"
+		if conf.Redis {
+			ctp = "redis"
+		}
+		if conf.Hash != "fnv1a_64" {
+			ctx.JSONMap(map[string]interface{}{
+				"message": "不支持除了fnv1a_64之外的hash方法",
+			}, ecode.RequestErr)
+			return
+		}
+		addr := "0.0.0.0:"
+		_, port, err := net.SplitHostPort(conf.Listen)
+		if err == nil {
+			addr = addr + port
+		} else {
+			if conf.Redis {
+				addr = addr + strconv.Itoa(rdPort)
+				rdPort++
+			} else {
+				addr = addr + strconv.Itoa(mcPort)
+				mcPort++
+			}
+		}
+		clst := &model.AddClusterReq{
+			Type:             ctp,
+			AppID:            req.AppID,
+			Zone:             req.Zone,
+			HashMethod:       "fnv1a_64",
+			HashDistribution: "ketama",
+			HashTag:          "",
+			Name:             name,
+			DailTimeout:      1000,
+			ReadTimeout:      1000,
+			WriteTimeout:     1000,
+			NodeConn:         2,
+			PingFailLimit:    3,
+			PingAutoEject:    true,
+			ListenProto:      "tcp",
+			ListenAddr:       addr,
+		}
+		if _, err := srv.AddCluster(ctx, clst); err != nil {
+			ctx.JSONMap(map[string]interface{}{
+				"message": "添加cluster失败:" + name + " " + err.Error(),
+			}, ecode.RequestErr)
+			return
+		}
+		var nodes []*node
+		for _, n := range conf.Servers {
+			ss := strings.Split(n, " ")
+			idx := strings.LastIndex(ss[0], ":")
+			weight, _ := strconv.ParseInt(ss[0][idx+1:], 10, 64)
+			nodes = append(nodes, &node{Addr: ss[0][:idx], Weigth: weight, Alias: ss[1]})
+		}
+		ns, _ := json.Marshal(nodes)
+		cn := &model.ModifyClusterReq{
+			Name:   name,
+			Action: 1,
+			Nodes:  string(ns),
+		}
+		if _, err := srv.ModifyCluster(ctx, cn); err != nil {
+			ctx.JSONMap(map[string]interface{}{
+				"message": "添加cluster node失败:" + name + " " + err.Error(),
+			}, ecode.RequestErr)
+			return
+		}
+	}
+}

app/admin/main/cache/http/http.go

@@ -0,0 +1,69 @@
+package http
+
+import (
+	"net/http"
+
+	"go-common/app/admin/main/cache/conf"
+	"go-common/app/admin/main/cache/service"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+var (
+	srv *service.Service
+)
+
+// Init init
+func Init(c *conf.Config) {
+	srv = service.New(c)
+	engine := bm.DefaultServer(c.BM)
+	router(engine)
+	if err := engine.Start(); err != nil {
+		log.Error("engine.Start error(%v)", err)
+		panic(err)
+	}
+}
+
+func router(e *bm.Engine) {
+	e.Ping(ping)
+	e.Register(register)
+	g := e.Group("/x/admin/cache")
+	{
+		g.GET("/clusters", clusters)
+		g.GET("/cluster", cluster)
+		g.GET("/cluster/detail", clusterDtl)
+		g.POST("/cluster/add", addCluster)
+		g.POST("/cluster/del", delCluster)
+		g.POST("/cluster/node/modify", modifyCluster)
+		g.GET("/cluster/toml", toml)
+		g.POST("/cluster/from/yml", addFromYml)
+	}
+	ol := e.Group("/x/admin/cache/overlord")
+	{
+		ol.GET("/clusters", overlordClusters)
+		ol.POST("/del/cluster", overlordDelCluster)
+		ol.POST("/del/node", overlordDelNode)
+		ol.GET("/ops/names", overlordOpsClusterNames)
+		ol.GET("/ops/nodes", overlordOpsNodes)
+		ol.POST("/import/ops/cluster", overlordImportCluster)
+		ol.POST("/new/ops/node", overlordClusterNewNode)
+		ol.POST("/replace/ops/node", overlordClusterReplaceNode)
+		ol.GET("/app/clusters", overlordAppClusters)
+		ol.GET("/app/can/bind/clusters", overlordAppNeedClusters)
+		ol.POST("/app/cluster/bind", overlordAppClusterBind)
+		ol.POST("/app/cluster/del", overlordAppClusterDel)
+		ol.GET("/app/appids", overlordAppAppIDs)
+		ol.GET("/app/toml", overlordToml)
+	}
+}
+
+func ping(c *bm.Context) {
+	if err := srv.Ping(c); err != nil {
+		log.Error("cache-admin ping error(%v)", err)
+		c.AbortWithStatus(http.StatusServiceUnavailable)
+	}
+}
+
+func register(c *bm.Context) {
+	c.JSON(map[string]interface{}{}, nil)
+}

app/admin/main/cache/http/overlord.go

@@ -0,0 +1,166 @@
+package http
+
+import (
+	"go-common/app/admin/main/cache/model"
+	bm "go-common/library/net/http/blademaster"
+)
+
+// @params OverlordReq
+// @router get /x/admin/cache/overlord/clusters
+// @response OverlordResp
+func overlordClusters(ctx *bm.Context) {
+	req := new(model.OverlordReq)
+	if err := ctx.Bind(req); err != nil {
+		return
+	}
+	ctx.JSON(srv.OverlordClusters(ctx, req))
+}
+
+// @params OverlordReq
+// @router get /x/admin/cache/overlord/ops/names
+// @response EmpResp
+func overlordOpsClusterNames(ctx *bm.Context) {
+	req := new(model.OverlordReq)
+	if err := ctx.Bind(req); err != nil {
+		return
+	}
+	ctx.JSON(srv.OpsClusterNames(ctx, req))
+}
+
+// @params OverlordReq
+// @router get /x/admin/cache/overlord/ops/nodes
+// @response EmpResp
+func overlordOpsNodes(ctx *bm.Context) {
+	req := new(model.OverlordReq)
+	if err := ctx.Bind(req); err != nil {
+		return
+	}
+	ctx.JSON(srv.OpsClusterNodes(ctx, req))
+}
+
+// @params OverlordReq
+// @router get /x/admin/cache/overlord/import/ops/cluster
+// @response EmpResp
+func overlordImportCluster(ctx *bm.Context) {
+	req := new(model.OverlordReq)
+	if err := ctx.Bind(req); err != nil {
+		return
+	}
+	ctx.JSON(srv.ImportOpsCluster(ctx, req))
+}
+
+// @params OverlordReq
+// @router get /x/admin/cache/overlord/new/ops/node
+// @response EmpResp
+func overlordClusterNewNode(ctx *bm.Context) {
+	req := new(model.OverlordReq)
+	if err := ctx.Bind(req); err != nil {
+		return
+	}
+	ctx.JSON(srv.ImportOpsNode(ctx, req))
+}
+
+// @params OverlordReq
+// @router get /x/admin/cache/overlord/replace/ops/node
+// @response EmpResp
+func overlordClusterReplaceNode(ctx *bm.Context) {
+	req := new(model.OverlordReq)
+	if err := ctx.Bind(req); err != nil {
+		return
+	}
+	ctx.JSON(srv.ReplaceOpsNode(ctx, req))
+}
+
+// @params OverlordReq
+// @router get /x/admin/cache/overlord/cluster/del
+// @response EmpResp
+func overlordDelCluster(ctx *bm.Context) {
+	req := new(model.OverlordReq)
+	if err := ctx.Bind(req); err != nil {
+		return
+	}
+	ctx.JSON(srv.DelOverlordCluster(ctx, req))
+}
+
+// @params OverlordReq
+// @router get /x/admin/cache/overlord/node/del
+// @response EmpResp
+func overlordDelNode(ctx *bm.Context) {
+	req := new(model.OverlordReq)
+	if err := ctx.Bind(req); err != nil {
+		return
+	}
+	ctx.JSON(srv.DelOverlordNode(ctx, req))
+}
+
+// @params OverlordReq
+// @router get /x/admin/cache/overlord/app/clusters
+// @response OverlordResp
+func overlordAppClusters(ctx *bm.Context) {
+	req := new(model.OverlordReq)
+	if err := ctx.Bind(req); err != nil {
+		return
+	}
+	req.Cookie = ctx.Request.Header.Get("Cookie")
+	ctx.JSON(srv.OverlordAppClusters(ctx, req))
+}
+
+// @params OverlordReq
+// @router get /x/admin/cache/overlord/app/can/bind/clusters
+// @response OverlordResp
+func overlordAppNeedClusters(ctx *bm.Context) {
+	req := new(model.OverlordReq)
+	if err := ctx.Bind(req); err != nil {
+		return
+	}
+	ctx.JSON(srv.OverlordAppCanBindClusters(ctx, req))
+}
+
+// @params OverlordReq
+// @router get /x/admin/cache/overlord/app/cluster/bind
+// @response OverlordResp
+func overlordAppClusterBind(ctx *bm.Context) {
+	req := new(model.OverlordReq)
+	if err := ctx.Bind(req); err != nil {
+		return
+	}
+	req.Cookie = ctx.Request.Header.Get("Cookie")
+	ctx.JSON(srv.OverlordAppClusterBind(ctx, req))
+}
+
+// @params OverlordReq
+// @router get /x/admin/cache/overlord/app/cluster/del
+// @response OverlordResp
+func overlordAppClusterDel(ctx *bm.Context) {
+	req := new(model.OverlordReq)
+	if err := ctx.Bind(req); err != nil {
+		return
+	}
+	req.Cookie = ctx.Request.Header.Get("Cookie")
+	ctx.JSON(srv.OverlordAppClusterDel(ctx, req))
+}
+
+// @params OverlordReq
+// @router get /x/admin/cache/overlord/app/appids
+// @response OverlordResp
+func overlordAppAppIDs(ctx *bm.Context) {
+	req := new(model.OverlordReq)
+	if err := ctx.Bind(req); err != nil {
+		return
+	}
+	req.Cookie = ctx.Request.Header.Get("Cookie")
+	ctx.JSON(srv.OverlordAppAppIDs(ctx, req))
+}
+
+func overlordToml(ctx *bm.Context) {
+	req := new(model.OverlordReq)
+	if err := ctx.Bind(req); err != nil {
+		return
+	}
+	resp, err := srv.OverlordToml(ctx, req)
+	if err != nil {
+		ctx.Status(500)
+		return
+	}
+	ctx.Writer.Write(resp)
+}