Merge pull request #44 from Dot-Liu/master

3.1.3版本发布

README.md

@@ -91,4 +91,4 @@ You may obtain a copy of the License at http://www.gnu.org/licenses/gpl-3.0.html
 
 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and limitations under the License.
-```
+```
\ No newline at end of file

admin/cmd/cmd.go

+package cmd
+
+import (
+	"encoding/json"
+	"errors"
+
+	"github.com/eolinker/goku-api-gateway/config"
+)
+
+var (
+	ErrorInvalidNodeInstance = errors.New("invalid instance value")
+	ErrorInvalidNodeConfig   = errors.New("invalid instance config")
+)
+
+type Code string
+
+const (
+	None               Code = "none"
+	NodeRegister       Code = "register"
+	NodeRegisterResult Code = "register-result"
+	NodeLevel          Code = "level"
+	Config             Code = "config"
+	Restart            Code = "restart"
+	Stop               Code = "stop"
+	Monitor            Code = "monitor"
+	EventClientLeave   Code = "leave"
+	Error              Code = "error"
+)
+
+func EncodeConfig(c *config.GokuConfig) ([]byte, error) {
+	if c == nil {
+		return nil, ErrorInvalidNodeConfig
+	}
+
+	return json.Marshal(c)
+}
+func DecodeConfig(data []byte) (*config.GokuConfig, error) {
+	if len(data) == 0 {
+		return nil, ErrorInvalidNodeConfig
+	}
+	c := new(config.GokuConfig)
+	err := json.Unmarshal(data, c)
+	if err != nil {
+		return nil, err
+	}
+	return c, nil
+}

admin/cmd/conn.go

+package cmd
+
+import (
+	"context"
+	"errors"
+	"net"
+	"sync"
+)
+
+var (
+	ErrorSendToClosedConnect = errors.New("send to closed connect")
+)
+
+type Connect struct {
+	conn net.Conn
+
+	//inputC chan _Frame
+	outputC chan []byte
+
+	doneC chan struct{}
+
+	ctx        context.Context
+	cancelFunc context.CancelFunc
+
+	once sync.Once
+}
+
+func NewConnect(conn net.Conn) *Connect {
+	ctx, cancel := context.WithCancel(context.Background())
+	c := &Connect{
+		conn: conn,
+
+		//inputC:     make(chan _Frame,10),
+		outputC: make(chan []byte, 10),
+
+		ctx:        ctx,
+		cancelFunc: cancel,
+	}
+
+	go c.r()
+
+	return c
+}
+func (c *Connect) r() {
+
+	for {
+		frame, err := ReadFrame(c.conn)
+		if err != nil {
+			break
+		}
+		c.outputC <- frame
+	}
+	close(c.outputC)
+}
+
+func (c *Connect) Close() error {
+
+	c.once.Do(func() {
+		c.cancelFunc()
+		c.conn.Close()
+
+	})
+
+	return nil
+}
+
+func (c *Connect) LocalAddr() net.Addr {
+	return c.conn.LocalAddr()
+}
+
+func (c *Connect) RemoteAddr() net.Addr {
+	return c.conn.RemoteAddr()
+}
+
+func (c *Connect) Send(code Code, data []byte) error {
+	return SendFrame(c.conn, code, data)
+}
+
+func (c *Connect) ReadC() <-chan []byte {
+	return c.outputC
+}
+func (c *Connect) Done() <-chan struct{} {
+	return c.ctx.Done()
+}

admin/cmd/error.go

+package cmd
+
+type ErrorInfo struct {
+	Error string `json:"error"`
+}
+
+func DecodeError(data []byte) (string, error) {
+
+	return string(data), nil
+}
+func EncodeError(err string) ([]byte, error) {
+
+	return []byte(err), nil
+}

admin/cmd/register.go

+package cmd
+
+import (
+	"encoding/json"
+	"github.com/eolinker/goku-api-gateway/config"
+)
+
+type RegisterResult struct {
+	Code   int
+	Error  string
+	Config *config.GokuConfig
+}
+
+func DecodeRegisterResult(data []byte) (*RegisterResult, error) {
+	r := new(RegisterResult)
+	err := json.Unmarshal(data, r)
+	if err != nil {
+		return nil, err
+	}
+	return r, nil
+}
+func EncodeRegisterResultConfig(c *config.GokuConfig) ([]byte, error) {
+	r := RegisterResult{
+		Code:   0,
+		Error:  "",
+		Config: c,
+	}
+	return json.Marshal(r)
+}
+func EncodeRegisterResultError(err string) ([]byte, error) {
+	r := RegisterResult{
+		Code:   -1,
+		Error:  err,
+		Config: nil,
+	}
+	return json.Marshal(r)
+}
+
+func DecodeRegister(data []byte) (string, error) {
+	if len(data) == 32 {
+		return string(data), nil
+	}
+	return "", ErrorInvalidNodeInstance
+}
+
+func EncodeRegister(nodeKey string) ([]byte, error) {
+	data := []byte(nodeKey)
+	if len(data) == 32 {
+		return data, nil
+	}
+	return nil, ErrorInvalidNodeInstance
+}

admin/cmd/server.go

+package cmd
+
+import (
+	"bytes"
+	"encoding/binary"
+	"errors"
+	"io"
+
+	"github.com/eolinker/goku-api-gateway/common/ioutils"
+)
+
+var (
+	ErrorEmptyFrame  = errors.New("empty frame")
+	ErrorInvalidCode = errors.New("invalid code")
+)
+
+func ReadFrame(reader io.Reader) ([]byte, error) {
+
+	sizeBuf := make([]byte, 4, 4)
+	// 获取报文头部信息
+	_, err := io.ReadFull(reader, sizeBuf)
+	if err != nil {
+		return nil, err
+	}
+	// 获取报文数据大小
+	size := binary.BigEndian.Uint32(sizeBuf)
+
+	data := make([]byte, size, size)
+
+	_, e := io.ReadFull(reader, data)
+	if e != nil {
+		return nil, err
+	}
+	return data, nil
+}
+func GetCmd(frame []byte) (Code, []byte, error) {
+	frameLen := len(frame)
+	if frameLen < 5 {
+		// 长度小于5时，报文没有数据
+		return "", nil, ErrorEmptyFrame
+	}
+	buf := bytes.NewBuffer(frame)
+	codeData, n, err := ioutils.ReadLField(buf, nil)
+	if err != nil {
+		return "", nil, err
+	}
+
+	return Code(codeData), frame[n:], nil
+}
+
+func SendError(w io.Writer, err error) {
+	if err == nil {
+		return
+	}
+	data := []byte(err.Error())
+	SendFrame(w, Error, data)
+}
+func SendFrame(w io.Writer, code Code, data []byte) error {
+	codeData := []byte(code)
+
+	size := uint32(len(data) + len(codeData) + 1)
+	sizeAll := size + 4
+	buf := bytes.NewBuffer(make([]byte, sizeAll, sizeAll))
+	buf.Reset()
+
+	err := binary.Write(buf, binary.BigEndian, size)
+	if err != nil {
+		return err
+	}
+
+	_, err = ioutils.WriteLField(buf, codeData)
+	if err != nil {
+		return err
+	}
+
+	if len(data) > 0 {
+		_, err := buf.Write(data)
+		if err != nil {
+			return err
+		}
+	}
+	//b:= buf.Bytes()
+	//_,err =w.Write(b)
+	_, err = buf.WriteTo(w)
+	return err
+}

admin/console/callback.go

+package console
+
+import (
+	"github.com/eolinker/goku-api-gateway/admin/cmd"
+	goku_log "github.com/eolinker/goku-api-gateway/goku-log"
+)
+
+type Callback func(code cmd.Code, data []byte,client *Client) error
+
+func (c Callback) ServerCode(code cmd.Code, data []byte, client *Client) error{
+	return c(code,data,client)
+}
+
+type CodeHandler interface {
+	ServerCode(code cmd.Code, data []byte,client *Client)error
+}
+
+//Register cmd 回调注册器
+type Register struct {
+	callbacks map[cmd.Code][]CodeHandler
+}
+//NewRegister create register
+func NewRegister() *Register {
+	return &Register{
+		callbacks: make(map[cmd.Code][]CodeHandler),
+	}
+}
+
+//Register 注册回调
+func (s *Register) Register(code cmd.Code,handler CodeHandler){
+	s.callbacks[code] = append(s.callbacks[code],handler)
+}
+//Register 注册回调
+func (s *Register) RegisterFunc(code cmd.Code,callback func(code cmd.Code, data []byte,client *Client) error){
+	s.callbacks[code] = append(s.callbacks[code],Callback(callback))
+}
+
+//Callback 调用回调
+func (s *Register)Callback(code cmd.Code,data []byte,client *Client)error  {
+	m:=s.callbacks
+	callbacks,has:=  m[code]
+	if !has{
+		goku_log.Info("not exists call for ",code)
+		return nil
+	}
+	for _,handler:=range callbacks{
+		if e:=handler.ServerCode(code,data,client);e!=nil{
+			return e
+		}
+	}
+	return nil
+}
\ No newline at end of file

admin/console/client-manager.go

+package console
+
+import (
+	"fmt"
+	"sync"
+
+	"github.com/eolinker/goku-api-gateway/common/listener"
+)
+
+type ClientManager struct {
+	clients   map[string]*Client
+	locker    sync.RWMutex
+	intercept *listener.Intercept
+}
+
+var (
+	clientManager = &ClientManager{
+		clients:   make(map[string]*Client),
+		locker:    sync.RWMutex{},
+		intercept: listener.NewIntercept(),
+	}
+)
+
+func (m *ClientManager) Add(client *Client) (err error) {
+
+	if _, has := m.Get(client.instance); has {
+		return ErrorDuplicateInstance
+	}
+
+	e := m.intercept.Call(client)
+	if e != nil {
+		return e
+	}
+	m.locker.Lock()
+
+	_, has := m.clients[client.instance]
+	if has {
+		fmt.Println(client.instance)
+		err = ErrorDuplicateInstance
+	} else {
+		m.clients[client.instance] = client
+		err = nil
+	}
+	m.locker.Unlock()
+	return
+}
+func (m *ClientManager) Get(instance string) (*Client, bool) {
+	m.locker.RLock()
+	c, has := m.clients[instance]
+	m.locker.RUnlock()
+	return c, has
+}
+func (m *ClientManager) Remove(instance string) {
+	m.locker.Lock()
+	delete(m.clients, instance)
+	m.locker.Unlock()
+}
+func InterceptNodeRegister(f func(client *Client) error) {
+	clientManager.intercept.Add(func(v interface{}) error {
+		c := v.(*Client)
+		return f(c)
+	})
+}
+func IsLive(key string) bool {
+	_, b := clientManager.Get(key)
+	return b
+}

admin/console/client.go

+package console
+
+import (
+	"net"
+
+	"github.com/eolinker/goku-api-gateway/admin/cmd"
+	"github.com/eolinker/goku-api-gateway/config"
+	entity "github.com/eolinker/goku-api-gateway/server/entity/console-entity"
+)
+
+type Client struct {
+	*cmd.Connect
+	instance string
+}
+
+func NewClient(conn net.Conn, instance string) *Client {
+
+	return &Client{
+		Connect:  cmd.NewConnect(conn),
+		instance: instance,
+	}
+}
+
+func (c *Client) Instance() string {
+	return c.instance
+}
+
+func (c *Client) SendConfig(conf *config.GokuConfig, nodeInfo *entity.Node) error {
+
+	nodeConfig := toNodeConfig(conf, nodeInfo)
+
+	data, err := cmd.EncodeConfig(nodeConfig)
+	if err != nil {
+		return err
+	}
+
+	return c.Send(cmd.Config, data)
+}
+
+func (c *Client) SendRunCMD(operate string) error {
+
+	if operate == "stop" {
+		return c.Send(cmd.Stop, []byte(""))
+	} else if operate == "restart" {
+
+		return c.Send(cmd.Restart, []byte(""))
+	}
+	return nil
+
+}

admin/console/config.go

+package console
+
+import (
+	"github.com/eolinker/goku-api-gateway/config"
+	entity "github.com/eolinker/goku-api-gateway/server/entity/console-entity"
+)
+
+func toNodeConfig(c *config.GokuConfig, nodeInfo *entity.Node) *config.GokuConfig {
+
+	conf := *c
+	conf.Cluster = nodeInfo.Cluster
+	conf.BindAddress = nodeInfo.ListenAddress
+	conf.AdminAddress = nodeInfo.AdminAddress
+	conf.Instance = nodeInfo.NodeKey
+
+	return &conf
+}

admin/console/console.go

+package console
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"sync"
+
+	"github.com/eolinker/goku-api-gateway/admin/cmd"
+	"github.com/eolinker/goku-api-gateway/console/module/node"
+	"github.com/eolinker/goku-api-gateway/console/module/versionConfig"
+)
+
+var (
+	register   *Register
+	ctx        context.Context
+	cancelFunc context.CancelFunc
+
+	once sync.Once
+)
+
+func Stop() {
+	cancelFunc()
+}
+
+func Start(addr string) error {
+	once.Do(func() {
+		versionConfig.InitVersionConfig()
+		register = doRegister()
+	})
+
+	var lc net.ListenConfig
+	ctx, cancelFunc = context.WithCancel(context.Background())
+
+	listener, err := lc.Listen(ctx, "tcp", addr)
+	if err != nil {
+		return err
+	}
+
+	go doAccept(listener)
+	return nil
+
+}
+
+func doAccept(listener net.Listener) {
+	for {
+		conn, e := listener.Accept()
+		if e != nil {
+			listener.Close()
+			return
+		}
+
+		go startClient(conn)
+
+	}
+}
+
+func readClient(conn net.Conn) (string, error) {
+	frame, e := cmd.ReadFrame(conn)
+	if e != nil {
+		return "", e
+	}
+
+	code, data, e := cmd.GetCmd(frame)
+	if e != nil {
+		return "", e
+	}
+	if code != cmd.NodeRegister {
+		return "", ErrorNeedRegister
+	}
+
+	instance, err := cmd.DecodeRegister(data)
+	if err != nil {
+		return "", err
+	}
+
+	return instance, nil
+
+}
+func startClient(conn net.Conn) {
+
+	instance, err := readClient(conn)
+	if err != nil {
+		return
+	}
+	fmt.Println(instance)
+	if !node.Lock(instance) {
+		data, err := cmd.EncodeRegisterResultError(ErrorDuplicateInstance.Error())
+		if err == nil {
+			cmd.SendFrame(conn, cmd.NodeRegisterResult, data)
+		}
+		//conn.Close()
+		return
+	}
+
+	client := NewClient(conn, instance)
+	defer func() {
+		node.UnLock(instance)
+		NodeLeave(client)
+		_ = client.Close()
+	}()
+
+	e := NodeRegister(client)
+	if e != nil {
+		data, err := cmd.EncodeRegisterResultError(e.Error())
+		if err == nil {
+			cmd.SendFrame(conn, cmd.NodeRegisterResult, data)
+		}
+		return
+	}
+
+	for {
+		select {
+		case frame, ok := <-client.ReadC():
+			{
+				if !ok {
+					return
+				}
+				code, data, e := cmd.GetCmd(frame)
+				if e != nil {
+					return
+				}
+				err := register.Callback(code, data, client)
+				if err != nil {
+					return
+				}
+			}
+		case <-client.Done():
+			return
+		}
+	}
+}

admin/console/node-register.go

+package console
+
+import (
+	"errors"
+
+	"github.com/eolinker/goku-api-gateway/admin/cmd"
+	"github.com/eolinker/goku-api-gateway/config"
+	"github.com/eolinker/goku-api-gateway/console/module/node"
+	"github.com/eolinker/goku-api-gateway/console/module/versionConfig"
+	log "github.com/eolinker/goku-api-gateway/goku-log"
+	entity "github.com/eolinker/goku-api-gateway/server/entity/console-entity"
+)
+
+var (
+	ErrorDuplicateInstance = errors.New("duplicate instance")
+	ErrorNeedRegister      = errors.New("need register")
+)
+
+func NodeRegister(client *Client) error {
+
+	err := clientManager.Add(client)
+	if err != nil {
+		return err
+	}
+
+	nodeInfo, err := node.GetNodeInfoByKey(client.instance)
+
+	if err != nil {
+		return ErrorDuplicateInstance
+	}
+	result, err := versionConfig.GetConfig(nodeInfo.Cluster)
+	if err != nil {
+		return err
+	}
+	nodeConf := toNodeConfig(result, nodeInfo)
+	data, _ := cmd.EncodeRegisterResultConfig(nodeConf)
+
+	return client.Send(cmd.NodeRegisterResult, data)
+}
+
+func NodeLeave(client *Client) {
+	clientManager.Remove(client.instance)
+
+}
+
+func getNodeMapByCluster() (map[string][]*entity.Node, error) {
+	nodes, e := node.GetAllNode()
+	if e != nil {
+		return nil, e
+	}
+
+	nodeMap := make(map[string][]*entity.Node)
+	for _, node := range nodes {
+
+		nodeMap[node.Cluster] = append(nodeMap[node.Cluster], node)
+	}
+	return nodeMap, nil
+}
+func OnConfigChange(conf map[string]*config.GokuConfig) {
+
+	nodeMap, err := getNodeMapByCluster()
+	if err != nil {
+		log.Warn(err)
+	}
+	for cluster, c := range conf {
+		for _, nodeInfo := range nodeMap[cluster] {
+
+			client, has := clientManager.Get(nodeInfo.NodeKey)
+			if has {
+
+				_ = client.SendConfig(c, nodeInfo)
+
+			}
+
+		}
+	}
+}
+
+func StopNode(nodeKey string) {
+
+	client, has := clientManager.Get(nodeKey)
+	if has {
+		_ = client.SendRunCMD("stop")
+		NodeLeave(client)
+
+	}
+}
+
+func RestartNode(nodeKey string) {
+
+	client, has := clientManager.Get(nodeKey)
+	if has {
+		NodeLeave(client)
+		node.UnLock(nodeKey)
+		_ = client.SendRunCMD("restart")
+	}
+}

admin/console/register.go

+package console
+
+import (
+	"github.com/eolinker/goku-api-gateway/admin/cmd"
+	"github.com/eolinker/goku-api-gateway/console/module/versionConfig"
+	log "github.com/eolinker/goku-api-gateway/goku-log"
+)
+
+
+var(
+	callbacksInit = NewRegister()
+)
+
+func doRegister()*Register{
+
+	r:=callbacksInit
+	callbacksInit = nil
+	versionConfig.AddCallback(OnConfigChange)
+	return r
+}
+func AddRegisterHandler(code cmd.Code,handler CodeHandler)  {
+	if callbacksInit == nil{
+		log.Panic("not allow register now")
+	}
+	callbacksInit.Register(code,handler)
+}
+
+func AddRegisterFunc(code cmd.Code,handleFunc func(code cmd.Code, data []byte,client *Client) error)  {
+	if callbacksInit == nil{
+		log.Panic("not allow register now")
+	}
+	callbacksInit.RegisterFunc(code,handleFunc)
+}
\ No newline at end of file

admin/node/callback.go

+package node
+
+import (
+	"github.com/eolinker/goku-api-gateway/admin/cmd"
+)
+
+type Callback func(code cmd.Code, data []byte) error
+
+func (c Callback) ServerCode(code cmd.Code, data []byte) error {
+	return c(code, data)
+}
+
+type CodeHandler interface {
+	ServerCode(code cmd.Code, data []byte) error
+}
+
+//Register cmd 回调注册器
+type Register struct {
+	callbacks map[cmd.Code][]CodeHandler
+}
+
+//NewRegister create register
+func NewRegister() *Register {
+	return &Register{
+		callbacks: make(map[cmd.Code][]CodeHandler),
+	}
+}
+
+//Register 注册回调
+func (s *Register) Register(code cmd.Code, handler CodeHandler) {
+	s.callbacks[code] = append(s.callbacks[code], handler)
+}
+
+//Register 注册回调
+func (s *Register) RegisterFunc(code cmd.Code, callback func(code cmd.Code, data []byte) error) {
+	s.callbacks[code] = append(s.callbacks[code], Callback(callback))
+}
+
+//Callback 调用回调
+func (s *Register) Callback(code cmd.Code, data []byte) error {
+	m := s.callbacks
+
+	for _, handler := range m[code] {
+		if e := handler.ServerCode(code, data); e != nil {
+			return e
+		}
+	}
+	return nil
+}

admin/node/config.go

+package node
+
+import (
+	"github.com/eolinker/goku-api-gateway/admin/cmd"
+)
+
+
+func (c *TcpConsole)OnConfigChange(code cmd.Code,data []byte) error {
+
+	conf,err:= cmd.DecodeConfig(data)
+	if err!=nil{
+		return err
+	}
+	c.lastConfig.Set(conf)
+	c.listener.Call(conf)
+	return nil
+}
\ No newline at end of file

admin/node/console.go

+package node
+
+import (
+	"context"
+	"errors"
+	"net"
+	"sync"
+	"time"
+
+	"github.com/eolinker/goku-api-gateway/admin/cmd"
+	"github.com/eolinker/goku-api-gateway/common/listener"
+	"github.com/eolinker/goku-api-gateway/common/manager"
+	"github.com/eolinker/goku-api-gateway/config"
+	"github.com/eolinker/goku-api-gateway/node/console"
+)
+
+type TcpConsole struct {
+	conn       *cmd.Connect
+	addr       string
+	lock       sync.Mutex
+	instance   string
+	register   *Register
+	listener   *listener.Listener
+	lastConfig *manager.Value
+
+	ctx    context.Context
+	cancel context.CancelFunc
+
+	listenOnce sync.Once
+}
+
+func (c *TcpConsole) SendMonitor(data []byte) error {
+
+	return c.conn.Send(cmd.Monitor, data)
+
+}
+
+func (c *TcpConsole) GetConfig() (*config.GokuConfig, error) {
+	conf, b := c.lastConfig.Get()
+	if b {
+
+		return conf.(*config.GokuConfig), nil
+	}
+	return nil, errors.New("not register to console")
+}
+
+func (c *TcpConsole) Close() {
+	c.cancel()
+}
+
+func (c *TcpConsole) AddListen(callback console.ConfigCallbackFunc) {
+	c.listener.Listen(func(event interface{}) {
+		conf := event.(*config.GokuConfig)
+		callback(conf)
+	})
+}
+
+func NewConsole(addr string, instance string) *TcpConsole {
+	c := &TcpConsole{
+		addr:     addr,
+		instance: instance,
+		conn:     nil,
+		register: NewRegister(),
+		listener: listener.New(),
+
+		lastConfig: manager.NewValue(),
+	}
+	c.register.RegisterFunc(cmd.Config, c.OnConfigChange)
+	c.register.RegisterFunc(cmd.Restart, Restart)
+	c.register.RegisterFunc(cmd.Stop, Stop)
+
+	return c
+}
+
+func connect(addr string) net.Conn {
+	sleeps := []time.Duration{time.Second * 0, time.Second * 1, time.Second * 5, time.Second * 10}
+	maxSleep := sleeps[len(sleeps)-1]
+	retry := 0
+
+	for {
+		if retry > 0 {
+			if retry > len(sleeps)-1 {
+				time.Sleep(maxSleep)
+			} else {
+				time.Sleep(sleeps[retry])
+			}
+		}
+		conn, err := net.Dial("tcp", addr)
+		if err != nil {
+			continue
+		}
+		return conn
+	}
+}
+
+func (c *TcpConsole) RegisterToConsole() (*config.GokuConfig, error) {
+	data, err := cmd.EncodeRegister(c.instance)
+	if err != nil {
+		return nil, err
+	}
+	for {
+
+		conn := connect(c.addr)
+		e := cmd.SendFrame(conn, cmd.NodeRegister, data)
+		if e != nil {
+			conn.Close()
+			continue
+		}
+
+		frame, err := cmd.ReadFrame(conn)
+
+		if err != nil {
+			conn.Close()
+			continue
+		}
+
+		code, data, err := cmd.GetCmd(frame)
+		if err != nil {
+			conn.Close()
+			return nil, err
+		}
+		if code != cmd.NodeRegisterResult {
+			conn.Close()
+			return nil, ErrorNeedReadRegisterResult
+		}
+
+		result, err := cmd.DecodeRegisterResult(data)
+
+		if err != nil {
+			conn.Close()
+			return nil, err
+		}
+		if result.Code != 0 {
+			conn.Close()
+			return nil, errors.New(result.Error)
+		}
+
+		c.conn = cmd.NewConnect(conn)
+
+		return result.Config, nil
+	}
+}
+func (c *TcpConsole) Listen() {
+
+	c.listenOnce.Do(
+		func() {
+			go func() {
+				for {
+					c.listenRead()
+					c.RegisterToConsole()
+				}
+			}()
+		})
+
+}
+
+func (c *TcpConsole) listenRead() {
+	defer c.conn.Close()
+	for {
+		select {
+		case <-c.conn.Done():
+			return
+		case frame, ok := <-c.conn.ReadC():
+			{
+				if !ok {
+					return
+				}
+
+				code, data, e := cmd.GetCmd(frame)
+				if e != nil {
+					return
+				}
+
+				err := c.register.Callback(code, data)
+				if err != nil {
+					return
+				}
+			}
+		}
+	}
+}

admin/node/error.go

+package node
+
+import "errors"
+
+var (
+	ErrorReadRegisterResultTimeOut = errors.New("read register result timeout")
+	ErrorNeedReadRegisterResult    = errors.New("need register-result but not")
+	ErrorConsoleRefuse             = errors.New("console refuse")
+)

admin/node/register.go

+package node

admin/node/restart.go

+package node
+
+import (
+	goku_log "github.com/eolinker/goku-api-gateway/goku-log"
+
+	"github.com/eolinker/goku-api-gateway/admin/cmd"
+)
+
+func Restart(code cmd.Code, data []byte) error {
+	goku_log.Info("restart")
+	//endless.RestartServer()
+
+	return nil
+}
+
+func Stop(code cmd.Code, data []byte) error {
+	goku_log.Info("stop")
+	//endless.StopServer()
+
+	return nil
+}

app/console/cluster.go

+package main
+
+import (
+	"github.com/eolinker/goku-api-gateway/common/database"
+	"strconv"
+
+	"github.com/pkg/errors"
+
+	"github.com/eolinker/goku-api-gateway/common/conf"
+	"github.com/eolinker/goku-api-gateway/server/entity"
+)
+
+func getDefaultDatabase() (*entity.ClusterDB, error) {
+	dbType := conf.MastValue("db_type", "sqlite3")
+	switch dbType {
+	case database.MysqlDriver:
+		{
+			dbPort, err := strconv.Atoi(conf.MastValue("db_port", "3306"))
+			if err != nil {
+				return nil, err
+			}
+			return &entity.ClusterDB{
+				Driver:   dbType,
+				Host:     conf.Value("db_host"),
+				Port:     dbPort,
+				UserName: conf.Value("db_user"),
+				Password: conf.Value("db_password"),
+				Database: conf.Value("db_name"),
+			}, nil
+		}
+	case database.Sqlite3Driver:
+		{
+			return &entity.ClusterDB{
+				Driver: dbType,
+				Path:   conf.MastValue("db_path", "./work/goku.db"),
+			}, nil
+		}
+	default:
+		{
+			return nil, errors.New("unsupported database type")
+		}
+	}
+
+}

app/console/databse.go

+package main
+
+import (
+	"fmt"
+	"github.com/eolinker/goku-api-gateway/common/database"
+	"github.com/eolinker/goku-api-gateway/common/pdao"
+	console_sqlite3 "github.com/eolinker/goku-api-gateway/server/dao/console-sqlite3"
+	"github.com/eolinker/goku-api-gateway/server/entity"
+)
+
+
+
+//ClusterDatabaseConfig 集群数据库配置
+type ClusterDatabaseConfig entity.ClusterDB
+
+//GetDriver 获取驱动类型
+func (c *ClusterDatabaseConfig) GetDriver() string {
+	return c.Driver
+}
+
+//GetSource 获取连接字符串
+func (c *ClusterDatabaseConfig) GetSource() string {
+
+	switch c.Driver {
+	case database.MysqlDriver:
+		{
+			return fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8", c.UserName, c.Password, c.Host, c.Port, c.Database)
+		}
+	case database.Sqlite3Driver:
+		{
+			return c.Path
+		}
+	default:
+		{
+			return ""
+		}
+	}
+
+}
+
+//InitDatabase 初始化数据库
+func InitDatabase() {
+	console_sqlite3.DoRegister()
+
+	def, err := getDefaultDatabase()
+	if err != nil {
+		panic(err)
+	}
+	c := ClusterDatabaseConfig(*def)
+	db,e := database.InitConnection(&c)
+	if e != nil {
+		panic(e)
+	}
+	err =pdao.Build(c.GetDriver(),db)
+	if err!=nil{
+		panic(err)
+	}
+
+	err =pdao.Check()
+	if err!=nil{
+		panic(err)
+	}
+}
+

app/console/log.go

+package main
+
+import (
+	module "github.com/eolinker/goku-api-gateway/console/module/config-log"
+	log "github.com/eolinker/goku-api-gateway/goku-log"
+)
+
+//InitLog 初始化日志
+func InitLog() {
+	c, _ := module.Get(module.ConsoleLog)
+
+	period, _ := log.ParsePeriod(c.Period)
+	log.SetOutPut(c.Enable, c.Dir, c.File, period, c.Expire)
+	l, _ := log.ParseLevel(c.Level)
+	log.SetLevel(l)
+}

app/console/main.go

@@ -2,13 +2,11 @@ package main
 
 import (
 	"flag"
-
-	"github.com/eolinker/goku-api-gateway/console/module/account"
 	log "github.com/eolinker/goku-api-gateway/goku-log"
 
 	"github.com/eolinker/goku-api-gateway/common/conf"
 	"github.com/eolinker/goku-api-gateway/common/general"
-	"github.com/eolinker/goku-api-gateway/console"
+	"github.com/eolinker/goku-api-gateway/console/module/account"
 	"github.com/eolinker/goku-api-gateway/utils"
 )
 
@@ -33,21 +31,20 @@ func main() {
 		log.Panic(err)
 		return
 	}
+
+
 	// 初始化db
-	console.InitDatabase()
-	console.InitLog()
+	InitDatabase()
+	InitLog()
 
-	//console.InitClusters()
 	// 其他需要初始化的模块
 	_ = general.General()
 	// 检测是否安装
 	s, err := account.CheckSuperAdminCount()
 	if err != nil {
-		err = console.InitTable()
-		if err != nil {
 			log.Panic(err)
 			return
-		}
+
 	}
 	if s == 0 {
 		if userName == "" {
@@ -62,13 +59,13 @@ func main() {
 
 		// 用户注册
 		password := utils.Md5(utils.Md5(userPassword))
-		f := console.Register(userName, password)
+		f := account.Register(userName, password)
 		if !f {
 			log.Fatal("[ERROR] Fail to create administrator. Please try again or contact technical support of eoLinker GOKU API Gateway.")
 			return
 		}
 	}
-
-	console.Router()
-	console.Server()
+	Server()
+	//console.Router()
+	//console.Server()
 }

app/console/module.go

+package main
+
+import (
+	graphite "github.com/eolinker/goku-api-gateway/module/graphite/config"
+	prometheus "github.com/eolinker/goku-api-gateway/module/prometheus/config"
+)
+
+func moduleRegister() {
+	prometheus.Register()
+	graphite.Register()
+
+}

app/console/redis_config.go

+package main

app/console/router.go

+package main
+
+import (
+	"net/http"
+
+	account_default "github.com/eolinker/goku-api-gateway/console/account"
+	"github.com/eolinker/goku-api-gateway/console/controller/account"
+	"github.com/eolinker/goku-api-gateway/console/controller/api"
+	"github.com/eolinker/goku-api-gateway/console/controller/auth"
+	"github.com/eolinker/goku-api-gateway/console/controller/balance"
+	"github.com/eolinker/goku-api-gateway/console/controller/cluster"
+	config_log "github.com/eolinker/goku-api-gateway/console/controller/config-log"
+	"github.com/eolinker/goku-api-gateway/console/controller/discovery"
+	"github.com/eolinker/goku-api-gateway/console/controller/gateway"
+	"github.com/eolinker/goku-api-gateway/console/controller/monitor"
+	"github.com/eolinker/goku-api-gateway/console/controller/node"
+	"github.com/eolinker/goku-api-gateway/console/controller/plugin"
+	"github.com/eolinker/goku-api-gateway/console/controller/project"
+	"github.com/eolinker/goku-api-gateway/console/controller/strategy"
+	goku_handler "github.com/eolinker/goku-api-gateway/goku-handler"
+)
+
+var (
+	accountFactory = goku_handler.NewAccountHandlerFactory(account_default.NewDefaultAccount())
+)
+
+func router() http.Handler {
+	s := goku_handler.NewGokuServer(accountFactory)
+
+	// 账号管理模块
+	s.Add("/guest", account.NewAccountController())
+	s.Add("/user", account.NewUserController())
+
+	// 接口管理模块
+	s.Add("/apis", api.NewAPIHandlers())
+	s.Add("/apis/group", api.NewGroupHandlers())
+	s.Add("/import/ams", api.NewImportHandlers())
+	s.Add("/plugin/api", api.NewPluginHandlers())
+
+	// 鉴权模块
+	s.Add("/auth", auth.NewHandlers())
+
+	// 负载模块
+	s.Add("/balance", balance.NewHandlers())
+
+	// 集群模块
+	s.Add("/cluster", cluster.NewHandlers())
+	s.Add("/version/config", cluster.NewVersionHandlers())
+
+	// 日志配置模块
+	s.Add("/config/log", config_log.NewHandlers())
+
+	// 服务发现模块
+	s.Add("/balance/service", discovery.NewHandlers())
+
+	// 网关模块
+	s.Add("/monitor/gateway", gateway.NewHandlers())
+
+	// 监控模块
+	s.Add("/monitor/module/config", monitor.NewHandlers())
+
+	// 节点模块
+	s.Add("/node", node.NewNodeHandlers())
+	s.Add("/node/group", node.NewGroupHandlers())
+
+	// 插件模块
+	s.Add("/plugin", plugin.NewHandlers())
+
+	// 项目模块
+	s.Add("/project", project.NewHandlers())
+
+	// 策略模块
+	s.Add("/strategy", strategy.NewStrategyHandlers())
+	s.Add("/strategy/group", strategy.NewGroupHandlers())
+	s.Add("/strategy/api", strategy.NewAPIStrategyHandlers())
+	s.Add("/plugin/strategy", strategy.NewPluginHandlers())
+
+	// 前端接入
+	s.Add("/", new(staticHandlers))
+	return s
+}
+
+type staticHandlers struct {
+}
+
+func (s *staticHandlers) Handlers(factory *goku_handler.AccountHandlerFactory) map[string]http.Handler {
+	return map[string]http.Handler{
+		"/": http.StripPrefix("/", http.FileServer(http.Dir("./static"))),
+	}
+}

app/console/server.go

+package main
+
+import (
+	"log"
+	"net/http"
+
+	"github.com/eolinker/goku-api-gateway/admin/console"
+	"github.com/eolinker/goku-api-gateway/common/conf"
+)
+
+//Server 控制台服务
+func Server() {
+	moduleRegister()
+	bind, has := conf.Get("admin_bind")
+	if !has {
+		log.Panic("[ERROR] Illegal admin_bind!")
+		return
+	}
+	err := console.Start(bind)
+	if err != nil {
+		log.Fatal(err)
+		return
+	}
+
+	ec := make(chan error, 1)
+
+	port, has := conf.Get("listen_port")
+	if has {
+		go func() {
+			log.Print("Listen: ", port)
+			log.Print("Start Successfully!")
+			err := http.ListenAndServe(":7000", router())
+
+			ec <- err
+		}()
+	} else {
+		log.Panic("[ERROR] Illegal listen port!")
+	}
+
+	for {
+		select {
+		case e, ok := <-ec:
+			if !ok {
+				break
+			}
+			log.Fatal(e)
+		}
+
+	}
+}

app/node/driver.go

 package main
 
 import (
-
-  "github.com/eolinker/goku-api-gateway/goku-service/driver/consul"
-  "github.com/eolinker/goku-api-gateway/goku-service/driver/eureka"
-  "github.com/eolinker/goku-api-gateway/goku-service/driver/static"
-
+	"github.com/eolinker/goku-api-gateway/goku-service/driver/consul"
+	"github.com/eolinker/goku-api-gateway/goku-service/driver/eureka"
+	"github.com/eolinker/goku-api-gateway/goku-service/driver/static"
 )
 
 func init() {
 	consul.Register()
 	eureka.Register()
 	static.Register()
-}
\ No newline at end of file
+}

app/node/init.go

@@ -9,4 +9,4 @@ func init() {
 
 	prometheus.Register()
 	graphite.Register()
-}
\ No newline at end of file
+}

app/node/main.go

@@ -2,9 +2,9 @@ package main
 
 import (
 	"flag"
+	"github.com/eolinker/goku-api-gateway/admin/node"
 	"github.com/eolinker/goku-api-gateway/config"
 	log "github.com/eolinker/goku-api-gateway/goku-log"
-	console2 "github.com/eolinker/goku-api-gateway/node/console"
 	"github.com/eolinker/goku-api-gateway/node/server"
 	"runtime"
 )
@@ -20,7 +20,8 @@ func main() {
 
 	if admin != "" && instance != ""{
 
-		console := console2.NewConsole(instance, admin)
+		console := node.NewConsole(admin,instance)
+
 		ser := server.NewServer()
 		log.Fatal(ser.ServerWidthConsole(console))
 		return

build/cmd/build-console.sh

@@ -12,7 +12,7 @@ OUTPATH="${BasePath}/out/console-${VERSION}"
 buildApp console $VERSION
 
 mkdir  ${OUTPATH}/static
-cp -a ${BasePath}/app/console/static/*  ${OUTPATH}/static/
+
 cp -a ${BasePath}/build/console/resources/*  ${OUTPATH}/
 
 chmod +x ${OUTPATH}/install.sh ${OUTPATH}/run.sh

build/console/.gitignore

+/static/

build/node/resources/run.sh

@@ -26,34 +26,32 @@ start() {
 
     ADMIN=$1
     INSTANCE=$2
-
-    if [[ "INSTANCE" = "" ]] ;then
-        PORT=${ENV_INSTANCE}
+    CONFIG_PATH=$WORK_PATH/goku-node.json
+    RUN_MODEL="console"
+    if [ -f "$CONFIG_PATH" ]; then
+	RUN_MODEL="config"  
     fi
 
     if [[ "$ADMIN" = "" ]] ; then
         ADMIN=${ENV_ADMIN}
     fi
+    
+    if [[ "$INSTANCE" = "" ]]; then
+	INSTANCE = ${ENV_INSTANCE}
+    fi
 
-    if [[ "$ADMIN" = "" ]] ; then
+    if [[ "$ADMIN" == "" && "$RUN_MODEL" == "console" ]] ; then
         echo "start fail :need admin url"
         exit 1
     fi
 
     mkdir -p $WORK_PATH/logs
     echo -e "ENV_PORT=$PORT\nENV_ADMIN=$ADMIN" > $WORK_PATH/$PROG.env
-
-    if [[ -e "$WORK_PATH/$PROG.pid" ]]; then
-        ## Program is running, exit with error.
-        echo "Error! $PROG is currently running!" 1>&2
-        exit 1
-    else
-        time=$(date "+%Y%m%d-%H%M%S")
-        ## Change from /dev/null to something like /var/log/$PROG if you want to save output.
-        nohup $PROG_PATH/$PROG --instance=$INSTANCE --admin=$ADMIN 2>&1 >"$WORK_PATH/logs/stdout-$PROG-$time.log" &  pid=$!
-
-        echo "$PROG started"
-        echo $pid > "$WORK_PATH/$PROG.pid"
+    
+    if [[ "$ADMIN" != "NULL" ]]; then
+    	$PROG_PATH/$PROG --admin=$ADMIN --instance=$INSTANCE
+    else 
+	$PROG_PATH/$PROG --config=$CONFIG_PATH
     fi
 }
  
@@ -104,3 +102,4 @@ case "$1" in
         exit 1
     ;;
 esac
+

common/database/conn.go

@@ -2,8 +2,6 @@ package database
 
 import (
 	"database/sql"
-	"io/ioutil"
-	"strings"
 
 	log "github.com/eolinker/goku-api-gateway/goku-log"
 
@@ -13,15 +11,9 @@ import (
 	_ "github.com/mattn/go-sqlite3"
 )
 
-var (
-	defaultDB *sql.DB
-)
-
 //InitConnection 初始化数据库连接
-func InitConnection(config Config) error {
-	db, e := getConnection(config)
-	defaultDB = db
-	return e
+func InitConnection(config Config) (*sql.DB, error) {
+	return getConnection(config)
 }
 func getConnection(config Config) (*sql.DB, error) {
 
@@ -34,7 +26,6 @@ func getConnection(config Config) (*sql.DB, error) {
 		}
 		db.SetMaxOpenConns(1000)
 		db.SetMaxIdleConns(100)
-		defaultDB = db
 		return db, nil
 	}
 	log.Info(e)
@@ -42,25 +33,17 @@ func getConnection(config Config) (*sql.DB, error) {
 
 }
 
-//GetConnection 获取数据库连接
-func GetConnection() *sql.DB {
-	return defaultDB
-}
-
-//InitTable 初始化表
-func InitTable() error {
+//CheckConnection 检查数据库连接
+func CheckConnection(driver string, source string) error {
 
-	content, err := ioutil.ReadFile("sql/goku_ce.sql")
-	sqls := strings.Split(string(content), ";")
-	Tx, _ := GetConnection().Begin()
-	for _, sql := range sqls {
-		_, err = Tx.Exec(sql)
-		if err != nil {
-			Tx.Rollback()
-			log.Error("InitTable error:",err,"\t sql:",sql)
+	db, e := sql.Open(driver, source)
+	defer db.Close()
+	if e == nil {
+		if err := db.Ping(); err != nil {
 			return err
 		}
+		return nil
 	}
-	Tx.Commit()
-	return nil
+	return e
+
 }

common/database/database.go

 package database
 
+const (
+	//MysqlDriver mysql驱动器
+	MysqlDriver = "mysql"
+	//Sqlite3Driver Sqlite3Driver驱动
+	Sqlite3Driver = "sqlite3"
+)
+
 //Config 数据库配置结构体
 type Config interface {
 	GetDriver() string

common/endless/endless.go

@@ -4,7 +4,6 @@ import (
 	"crypto/tls"
 	"errors"
 	"fmt"
-	log "github.com/eolinker/goku-api-gateway/goku-log"
 	"net"
 	"net/http"
 	"os"
@@ -15,6 +14,8 @@ import (
 	"sync"
 	"syscall"
 	"time"
+
+	log "github.com/eolinker/goku-api-gateway/goku-log"
 )
 
 const (
@@ -39,9 +40,10 @@ var (
 	DefaultMaxHeaderBytes int
 	DefaultHammerTime     time.Duration
 
-	isChild     bool
-	socketOrder string
-
+	isChild         bool
+	socketOrder     string
+	adminServer     *endlessServer
+	nodeServer      *endlessServer
 	hookableSignals []os.Signal
 )
 
@@ -71,15 +73,24 @@ func init() {
 
 type endlessServer struct {
 	http.Server
-	EndlessListener  net.Listener
-	SignalHooks      map[int]map[os.Signal][]func()
-	tlsInnerListener *endlessListener
-	wg               sync.WaitGroup
-	sigChan          chan os.Signal
-	isChild          bool
-	state            uint8
-	lock             *sync.RWMutex
-	BeforeBegin      func(add string)
+	EndlessListener      net.Listener
+	SignalHooks          map[int]map[os.Signal][]func()
+	tlsInnerListener     *endlessListener
+	wg                   sync.WaitGroup
+	sigChan              chan os.Signal
+	isChild              bool
+	state                uint8
+	lock                 *sync.RWMutex
+	BeforeBegin          func(add string)
+	runningServersForked bool
+}
+
+func SetAdminServer(server *endlessServer) {
+	adminServer = server
+}
+
+func SetNodeServer(server *endlessServer) {
+	nodeServer = server
 }
 
 /*
@@ -140,17 +151,25 @@ func NewServer(addr string, handler http.Handler) (srv *endlessServer) {
 
 	runningServersOrder = append(runningServersOrder, addr)
 	runningServers[addr] = srv
-
 	return
 }
 
-/*
+func RestartServer() {
+	nodeServer.sigChan <- syscall.SIGHUP
+}
+
+func StopServer() {
+	nodeServer.sigChan <- syscall.SIGTERM
+}
+
+/*F
 ListenAndServe listens on the TCP network address addr and then calls Serve
 with handler to handle requests on incoming connections. Handler is typically
 nil, in which case the DefaultServeMux is used.
 */
 func ListenAndServe(addr string, handler http.Handler) error {
 	server := NewServer(addr, handler)
+	nodeServer = server
 	return server.ListenAndServe()
 }
 
@@ -338,7 +357,7 @@ func (srv *endlessServer) handleSignals() {
 			log.Info(pid, "Received SIGINT.")
 			srv.shutdown()
 		case syscall.SIGTERM:
-			log.Info(pid, "Received SIGTERM.")
+			log.Info(``, "Received SIGTERM.")
 			srv.shutdown()
 		case syscall.SIGTSTP:
 			log.Info(pid, "Received SIGTSTP.")
@@ -418,15 +437,15 @@ func (srv *endlessServer) hammerTime(d time.Duration) {
 
 func (srv *endlessServer) fork() (err error) {
 
-
 	runningServerReg.Lock()
 	defer runningServerReg.Unlock()
+	log.Info(1234)
 	// only one server instance should fork!
-	if runningServersForked {
+	if srv.runningServersForked {
 		return errors.New("Another process already forked. Ignoring this one.")
 	}
-
-	runningServersForked = true
+	log.Info(5456)
+	srv.runningServersForked = true
 
 	var files = make([]*os.File, len(runningServers))
 	var orderArgs = make([]string, len(runningServers))
@@ -443,7 +462,7 @@ func (srv *endlessServer) fork() (err error) {
 		}
 		orderArgs[socketPtrOffsetMap[srvPtr.Server.Addr]] = srvPtr.Server.Addr
 	}
-
+	log.Info(123)
 	env := append(
 		os.Environ(),
 		"ENDLESS_CONTINUE=1",
@@ -458,7 +477,7 @@ func (srv *endlessServer) fork() (err error) {
 	if len(os.Args) > 1 {
 		args = os.Args[1:]
 	}
-
+	log.Info(path, args)
 	cmd := exec.Command(path, args...)
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
@@ -476,6 +495,7 @@ func (srv *endlessServer) fork() (err error) {
 		log.Fatalf("Restart: Failed to launch, error: %v", err)
 	}
 
+	srv.runningServersForked = false
 	return
 }
 

common/ioutils/utils.go

+package ioutils
+
+import (
+	"encoding/binary"
+	"io"
+)
+
+//WriteLField 写域内容
+func WriteLField(writer io.Writer, s []byte) (int, error) {
+
+	l := uint8(len(s))
+
+	e := binary.Write(writer, binary.BigEndian, l)
+	if e != nil {
+		return 0, e
+	}
+	n, err := writer.Write(s)
+	if err != nil {
+		return n + 1, err
+	}
+	return n + 1, nil
+}
+
+//ReadLField 读取域内容
+func ReadLField(reader io.Reader, buf []byte) ([]byte, int, error) {
+	l := uint8(0)
+
+	e := binary.Read(reader, binary.BigEndian, &l)
+	if e != nil {
+		return nil, 0, e
+	}
+	tmpbuf := buf
+	if int(l) > len(buf) {
+		tmpbuf = make([]byte, l, l)
+	} else {
+		tmpbuf = buf[:l]
+	}
+
+	_, err := reader.Read(tmpbuf)
+	if err != nil {
+		return nil, 0, err
+	}
+	return tmpbuf, int(l) + 1, nil
+}

common/listener/intercept.go

+package listener
+
+import "sync"
+
+//InterceptFunc 拦截函数
+type InterceptFunc func(event interface{}) error
+
+//Intercept 拦截器
+type Intercept struct {
+	callbacks []InterceptFunc
+	locker    sync.RWMutex
+}
+
+//NewIntercept 创建拦截器
+func NewIntercept() *Intercept {
+	return &Intercept{
+		callbacks: nil,
+		locker:    sync.RWMutex{},
+	}
+}
+
+//Add add
+func (i *Intercept) Add(f func(v interface{}) error) {
+	i.locker.Lock()
+	i.callbacks = append(i.callbacks, InterceptFunc(f))
+	i.locker.Unlock()
+}
+
+//Call call
+func (i *Intercept) Call(v interface{}) error {
+	i.locker.RLock()
+	fs := i.callbacks
+	i.locker.RUnlock()
+
+	for _, f := range fs {
+		err := f(v)
+		if err != nil {
+
+			return err
+		}
+	}
+	return nil
+}

common/listener/listener.go

@@ -5,7 +5,7 @@ import "sync"
 //CallbackFunc 回调函数
 type CallbackFunc func(event interface{})
 
-//Listener
+//Listener 监听者
 type Listener struct {
 	callbacks     []CallbackFunc
 	callbacksOnce []CallbackFunc

common/manager/manager.go

+package manager
+
+import "sync"
+
+//Manager manager
+type Manager struct {
+	locker sync.RWMutex
+	objs   map[string]interface{}
+}
+
+//NewManager new manager
+func NewManager() *Manager {
+	return &Manager{
+		locker: sync.RWMutex{},
+		objs:   make(map[string]interface{}),
+	}
+}
+
+//Get get
+func (m *Manager) Get(key string) (interface{}, bool) {
+
+	m.locker.RLock()
+	v, has := m.objs[key]
+	m.locker.RUnlock()
+	return v, has
+}
+
+//Set set
+func (m *Manager) Set(key string, value interface{}) {
+	m.locker.Lock()
+	m.objs[key] = value
+	m.locker.Unlock()
+}
+
+//Value value
+type Value struct {
+	locker sync.RWMutex
+	isHas  bool
+	value  interface{}
+}
+
+//NewValue new value
+func NewValue() *Value {
+	return &Value{
+		locker: sync.RWMutex{},
+		isHas:  false,
+		value:  nil,
+	}
+}
+
+//Set set
+func (v *Value) Set(value interface{}) {
+	v.locker.Lock()
+
+	v.value = value
+	v.isHas = true
+	v.locker.Unlock()
+}
+
+//Get get
+func (v *Value) Get() (interface{}, bool) {
+	v.locker.RLock()
+	value, has := v.value, v.isHas
+
+	v.locker.RUnlock()
+	return value, has
+}

common/pdao/demo/demo.go

+package main
+
+import (
+	"fmt"
+	"github.com/eolinker/goku-api-gateway/common/pdao"
+)
+
+type DemoGetDao interface {
+	GetNameById(id int) string
+	GetIdByName(name string) int
+}
+type DemoSetDao interface {
+	Set(id int,name string) 
+	 
+}
+
+type Demo struct {
+	names map[string]int
+	ids map[int]string
+}
+
+func NewDemo() *Demo {
+	return &Demo{
+		names: make(map[string]int),
+		ids:   make(map[int]string),
+	}}
+
+func (d *Demo) Set(id int, name string) {
+	 d.names[name]=id
+	 d.ids[id]=name
+}
+
+func (d *Demo) GetNameById(id int) string {
+	return d.ids[id]
+}
+
+func (d *Demo) GetIdByName(name string) int {
+	  return d.names[name]
+}
+var (
+	getDao DemoGetDao
+	setDao DemoSetDao
+)
+
+func init() {
+	pdao.Need(&getDao)
+	pdao.Need(&setDao)
+}
+func main() {
+
+	demo:=NewDemo()
+	var seter DemoSetDao = demo
+	pdao.Set(&seter)
+	var getter DemoGetDao = demo
+	pdao.Set(&getter)
+
+	pdao.Check()
+
+	setDao.Set(1,"test")
+	fmt.Println(getDao.GetNameById(1))
+	fmt.Println(getDao.GetIdByName("test"))
+}
\ No newline at end of file

common/pdao/factory.go

+package pdao
+
+import "database/sql"
+
+//FactoryFunc factoryFunc
+type FactoryFunc func(db *sql.DB) (interface{}, error)
+
+//Create create
+func (f FactoryFunc) Create(db *sql.DB) (interface{}, error) {
+	return f(db)
+}
+
+//Factory factory
+type Factory interface {
+	Create(db *sql.DB) (interface{}, error)
+}
+
+//DBBuilder dbBuilder
+type DBBuilder interface {
+	Build(db *sql.DB) error
+}

common/pdao/needs.go

+package pdao
+
+import (
+	"fmt"
+	"reflect"
+	"sync"
+)
+
+//NeedsManager needsManager
+type NeedsManager struct {
+	daoInterfaces map[string][]*reflect.Value
+	lock          sync.Mutex
+}
+
+//NewNeedsManager 创建新的needsManager
+func NewNeedsManager() *NeedsManager {
+	return &NeedsManager{
+		daoInterfaces: make(map[string][]*reflect.Value),
+		lock:          sync.Mutex{},
+	}
+}
+
+func (m *NeedsManager) add(key string, v *reflect.Value) {
+	m.lock.Lock()
+	m.daoInterfaces[key] = append(m.daoInterfaces[key], v)
+	m.lock.Unlock()
+}
+
+func (m *NeedsManager) set(key string, v reflect.Value) {
+	m.lock.Lock()
+	for _, e := range m.daoInterfaces[key] {
+		e.Set(v)
+	}
+	delete(m.daoInterfaces, key)
+	m.lock.Unlock()
+}
+func (m *NeedsManager) check() []string {
+	m.lock.Lock()
+	r := make([]string, 0, len(m.daoInterfaces))
+	for pkg := range m.daoInterfaces {
+
+		r = append(r, pkg)
+	}
+	m.lock.Unlock()
+	return r
+}
+
+//Need 声明
+func (m *NeedsManager) Need(p interface{}) {
+
+	v := reflect.ValueOf(p)
+
+	if v.Kind() != reflect.Ptr {
+		panic("must ptr")
+	}
+	e := v.Elem()
+	pkg := key(e.Type())
+	if pkg == "" {
+		panic("invalid interface")
+	}
+
+	if !e.CanSet() {
+		panic("invalid interface")
+	}
+	m.add(pkg, &e)
+}
+
+//Set 注入
+func (m *NeedsManager) Set(i interface{}) {
+	v := reflect.ValueOf(i)
+	if v.Kind() != reflect.Ptr {
+		panic("must ptr")
+	}
+	e := v.Elem()
+	pkg := key(e.Type())
+
+	if pkg == "" {
+		panic("invalid interface")
+	}
+	m.set(pkg, e)
+}
+func key(t reflect.Type) string {
+	return fmt.Sprintf("%s.%s", t.PkgPath(), t.String())
+}
+
+//Check 检查是否实现相关dao类
+func (m *NeedsManager) Check() error {
+	rs := m.check()
+	if len(rs) > 0 {
+		return fmt.Errorf("need:%v", rs)
+	}
+	return nil
+}

common/pdao/needs_test.go

+package pdao
+
+import (
+	"fmt"
+	"testing"
+
+	test1 "github.com/eolinker/goku-api-gateway/common/pdao/test/test/test/test"
+)
+
+type T1 struct {
+}
+
+func (t *T1) Test4() {
+	fmt.Println("implement me")
+}
+
+type T2 struct {
+}
+
+func (t *T2) Test3() {
+	fmt.Println("implement me")
+}
+
+type T3 struct {
+}
+
+func (t *T3) Test2() {
+
+	fmt.Println("implement me")
+}
+
+type T4 struct {
+}
+
+func (t *T4) Test1() {
+	fmt.Println("implement me")
+}
+
+func Test(t *testing.T) {
+
+	t.Run("all", func(t *testing.T) {
+		var t1 test1.Test
+		//var t2 test2.Test = nil
+		//var t3 test3.Test  = nil
+		//var t4 test4.Test = nil
+		Need(&t1)
+		//Need(&t2)
+		//Need(&t3)
+		//Need(&t4)
+
+		var t1v test1.Test = new(T4)
+		Set(&t1v)
+		//Set(test2.Test(new(T3)))
+		//
+		//Set(test3.Test(new(T2)))
+		//Set(test4.Test(new(T1)))
+
+		t1.Test1()
+		//t2.Test2()
+		//t3.Test3()
+		//t4.Test4()
+		Check()
+
+	})
+
+}

common/pdao/pdao.go

+package pdao
+
+import (
+	"database/sql"
+	"sync"
+)
+
+var (
+	needsManager  = NewNeedsManager()
+	factoryManage = NewFactoryManager()
+)
+
+//Need need
+func Need(is ...interface{}) {
+	for _, i := range is {
+		needsManager.Need(i)
+	}
+}
+
+//Check check
+func Check() error {
+	return needsManager.Check()
+}
+
+//RegisterDao 注册dao类
+func RegisterDao(driver string, factories ...Factory) {
+	for _, factory := range factories {
+		factoryManage.RegisterDao(driver, factory)
+	}
+
+}
+
+//RegisterDBBuilder 注册dbBuilder
+func RegisterDBBuilder(driver string, builders ...DBBuilder) {
+	for _, builder := range builders {
+		factoryManage.RegisterDBBuilder(driver, builder)
+
+	}
+}
+
+//Build build
+func Build(driver string, db *sql.DB) error {
+	return factoryManage.Build(driver, db, needsManager)
+}
+
+//FactoryManager 工厂管理者
+type FactoryManager struct {
+	factories map[string][]Factory
+	builders  map[string][]DBBuilder
+	locker    sync.Mutex
+}
+
+//NewFactoryManager new工厂管理者
+func NewFactoryManager() *FactoryManager {
+	return &FactoryManager{
+		factories: make(map[string][]Factory),
+		builders:  make(map[string][]DBBuilder),
+		locker:    sync.Mutex{},
+	}
+}
+
+//RegisterDBBuilder dbBuilder注册器
+func (f *FactoryManager) RegisterDBBuilder(driver string, builder DBBuilder) {
+	f.locker.Lock()
+	f.builders[driver] = append(f.builders[driver], builder)
+	f.locker.Unlock()
+}
+
+//RegisterDao dao类注册器
+func (f *FactoryManager) RegisterDao(driver string, factory Factory) {
+	f.locker.Lock()
+	f.factories[driver] = append(f.factories[driver], factory)
+	f.locker.Unlock()
+}
+
+func (f *FactoryManager) get(driver string) []Factory {
+	f.locker.Lock()
+	fs := f.factories[driver]
+	delete(f.factories, driver)
+	f.locker.Unlock()
+	return fs
+}
+
+func (f *FactoryManager) callBuild(driver string, db *sql.DB) error {
+	f.locker.Lock()
+
+	bs := f.builders[driver]
+	for _, b := range bs {
+		err := b.Build(db)
+		if err != nil {
+			f.locker.Unlock()
+			return err
+		}
+	}
+	f.locker.Unlock()
+	return nil
+}
+
+//Build build
+func (f *FactoryManager) Build(driver string, db *sql.DB, m *NeedsManager) error {
+	err := f.callBuild(driver, db)
+	if err != nil {
+		return err
+	}
+	fs := f.get(driver)
+	for _, factory := range fs {
+
+		i, err := factory.Create(db)
+		if err != nil {
+			return err
+		}
+		m.Set(i)
+	}
+	return nil
+
+}

common/pdao/test/t.go

+package test
+
+
+type Test interface {
+	Test4()
+}
\ No newline at end of file

common/pdao/test/test/t.go

+package test
+
+
+type Test interface {
+	Test3()
+}
\ No newline at end of file

common/pdao/test/test/test/t.go

+package test
+
+
+type Test interface {
+	Test2()
+}
\ No newline at end of file

common/pdao/test/test/test/test/t.go

+package test
+
+
+type Test interface {
+	Test1()
+}
\ No newline at end of file

common/redis-manager/manager.go

@@ -54,3 +54,18 @@ func Get(name string) (Redis, bool) {
 
 	return nil, false
 }
+
+func del(name string) {
+	locker.RLock()
+	defer locker.RUnlock()
+
+	delete(redisOfCluster, name)
+
+	return
+}
+
+//Delete delete
+func Delete(name string) {
+	del(name)
+	return
+}

common/redis-manager/redis.go

@@ -5,6 +5,9 @@ import "github.com/go-redis/redis"
 const (
 	//RedisModeCluster cluster模式
 	RedisModeCluster = "cluster"
+
+	//RedisModeSentinel sentinel模式
+	RedisModeSentinel = "sentinel"
 	//RedisModeStand stand模式
 	RedisModeStand = "stand"
 )

common/redis-manager/redis_conn.go

 package redis_manager
 
 import (
+	"fmt"
+	"sort"
+	"strings"
 	"sync"
+
+	"github.com/go-redis/redis"
 )
 
 var (
@@ -17,17 +22,77 @@ func SetDefault(r Redis) {
 
 //GetConnection 获取redis连接
 func GetConnection() Redis {
-	if def != nil {
-		return def
-	}
+	//if def != nil {
+	return def
+	//}
+	//defLocker.Lock()
+	//defer defLocker.Unlock()
+	//
+	//def = Create(defaultConfig)
+	//return def
+}
 
-	defLocker.Lock()
-	defer defLocker.Unlock()
+//CheckConnection 获取redis连接
+func CheckConnection(mode, addrs, password, masters string, dbIndex int) bool {
+	switch mode {
+	case RedisModeCluster:
+		{
+			a := strings.Split(addrs, ",")
+			option := &redis.ClusterOptions{
+				Addrs:          a,
+				Password:       password,
+				PoolSize:       2000,
+				ReadOnly:       true,
+				RouteByLatency: true,
+			}
+			r := redis.NewClusterClient(option)
+			defer r.Close()
+			if _, err := r.Ping().Result(); err != nil {
+				return false
+			}
+			return true
+		}
+	case RedisModeSentinel:
+		{
+			a := strings.Split(addrs, ",")
+			option := redis.FailoverOptions{
+				SentinelAddrs: a,
+				MasterName:    masters,
+				Password:      password,
+				DB:            dbIndex,
+				PoolSize:      _PoolSize,
+			}
+			r := redis.NewFailoverClient(&option)
+			defer r.Close()
+			if _, err := r.Ping().Result(); err != nil {
+				return false
+			}
+			return true
+		}
+	case RedisModeStand:
+		{
 
-	if def != nil {
-		return def
+			a := strings.Split(addrs, ",")
+
+			option := redis.RingOptions{
+				Addrs:    make(map[string]string),
+				Password: password,
+				DB:       dbIndex,
+
+				PoolSize: _PoolSize,
+			}
+			sort.Strings(a)
+			for i, ad := range a {
+				option.Addrs[fmt.Sprintf("shad:%d", i)] = ad
+			}
+			r := redis.NewRing(&option)
+			defer r.Close()
+			if _, err := r.Ping().Result(); err != nil {
+				return false
+			}
+			return true
+		}
 	}
+	return false
 
-	def = Create(defaultConfig)
-	return def
 }

common/telegraph/telegraph.go

@@ -5,9 +5,12 @@ import (
 	"errors"
 	"sync"
 )
+
 var (
+	//ErrorContextDone context done error
 	ErrorContextDone = errors.New("context done")
 )
+
 //Telegraph telegraph
 type Telegraph struct {
 	value   interface{}
@@ -50,7 +53,7 @@ func (t *Telegraph) get() (string, <-chan struct{}, interface{}) {
 }
 
 //Get get
-func (t *Telegraph) Get(version string) (interface{},error) {
+func (t *Telegraph) Get(version string) (interface{}, error) {
 	return t.GetWidthContext(context.Background(), version)
 }
 
@@ -63,21 +66,21 @@ func (t *Telegraph) Close() {
 }
 
 //GetWidthContext 获取上下文
-func (t *Telegraph) GetWidthContext(ctx context.Context, version string) (interface{} ,error){
+func (t *Telegraph) GetWidthContext(ctx context.Context, version string) (interface{}, error) {
 	v, c, value := t.get()
 	if v == "" {
 		// closed
-		return nil,nil
+		return nil, nil
 	}
 	if version != v {
-		return value,nil
+		return value, nil
 	}
 
 	select {
 	case <-c:
 		return t.GetWidthContext(ctx, version)
 	case <-ctx.Done():
-		return nil,ErrorContextDone
+		return nil, ErrorContextDone
 	}
 
 }

common/version/version.go

 package version
 
 //Version 版本号
-const Version = "3.1.1"
+const Version = "3.1.3"

config/config.go

 package config
 
-
 //GokuConfig goku根配置
 type GokuConfig struct {
-	Version string `json:"version"`
-	Cluster string `json:"cluster"`
-	Instance string `json:"instance"`
-	BindAddress string `json:"bind"`
+	Version      string `json:"version"`
+	Cluster      string `json:"cluster"`
+	Instance     string `json:"instance"`
+	BindAddress  string `json:"bind"`
 	AdminAddress string `json:"admin"`
 
 	//Port                int                        `json:"port"`
 	DiscoverConfig      map[string]*DiscoverConfig `json:"discover,omitempty"`
 	Balance             map[string]*BalanceConfig  `json:"balance,omitempty"`
-	Plugins             *GatewayPluginConfig       `json:"plugins,omitempty"`
+	Plugins             GatewayPluginConfig        `json:"plugins,omitempty"`
 	APIS                []*APIContent              `json:"apis,omitempty"`
 	Strategy            []*StrategyConfig          `json:"strategy,omitempty"`
 	AnonymousStrategyID string                     `json:"anonymousStrategyID,omitempty"`
 	AuthPlugin          map[string]string          `json:"authPlugin,omitempty"`
+	GatewayBasicInfo    *Gateway                   `json:"gatewayBasicInfo"`
+	//RouterRule          map[string]*RouterRule     `json:"routerRule"`
+	Log            *LogConfig             `json:"log,omitempty"`
+	AccessLog      *AccessLogConfig       `json:"access_log,omitempty"`
+	Routers        []*Router              `json:"routers"`
+	MonitorModules map[string]string      `json:"monitor_modules"`
+	RedisConfig    map[string]interface{} `json:"redisConfig"`
+	ExtendsConfig  map[string]interface{} `json:"extends_config"`
+}
 
-	Log       *LogConfig       `json:"log,omitempty"`
-	AccessLog *AccessLogConfig `json:"access_log,omitempty"`
+//Router 路由
+type Router struct {
+	Rules    string `json:"routerRules"`
+	Target   string `json:"target"`
+	Priority int    `json:"priority"`
+}
 
-	MonitorModules map[string]string `json:"monitor_modules"`
+//RouterRule 路由规则
+type RouterRule struct {
+	Host       string `json:"host"`
+	StrategyID string `json:"strategyID"`
 }
 
 //AccessLogConfig access日志配置
@@ -82,12 +97,15 @@ type PluginConfig struct {
 	IsStop    bool   `json:"stop"`
 	Config    string `json:"config"`
 	UpdateTag string `json:"updateTag"`
+	IsAuth    bool   `json:"isAuth"`
 }
 
 //APIContent api详情
 type APIContent struct {
-	ID             int              `json:"id"`
-	Name           string           `json:"name"`
+	ID    int    `json:"id"`
+	Name  string `json:"name"`
+	Alias string `json:"alias"`
+
 	OutPutEncoder  string           `json:"output"`
 	RequestURL     string           `json:"requestUrl"`
 	Methods        []string         `json:"methods"`
@@ -177,6 +195,11 @@ type StrategyConfig struct {
 	Plugins []*PluginConfig   `json:"plugins"`
 }
 
+//Gateway 网关配置
+type Gateway struct {
+	SkipCertificate int `json:"skipCertificate"`
+}
+
 //APIOfStrategy 策略接口配置
 type APIOfStrategy struct {
 	ID      int             `json:"id"`
@@ -193,6 +216,7 @@ type VersionConfig struct {
 	CreateTime    string `json:"createTime"`
 	PublishStatus int    `json:"publishStatus"`
 	PublishTime   string `json:"publishTime"`
+	Publisher     string `json:"publisher"`
 }
 
 //Project 项目

console/account/account-default.go

+package account
+
+import (
+	"errors"
+	"net/http"
+	"strconv"
+
+	"github.com/eolinker/goku-api-gateway/console/module/account"
+)
+
+//DefaultAccount default
+type DefaultAccount struct {
+}
+
+//NewDefaultAccount new defaultAccount
+func NewDefaultAccount() *DefaultAccount {
+	return &DefaultAccount{}
+}
+
+//CheckLogin 判断是否登录
+func (d *DefaultAccount) CheckLogin(r *http.Request) (int, error) {
+
+	userIDCookie, idErr := r.Cookie("userID")
+	userCookie, userErr := r.Cookie("userToken")
+	if idErr != nil || userErr != nil {
+		e := errors.New("user not logged in")
+		return 0, e
+	}
+	userID, err := strconv.Atoi(userIDCookie.Value)
+	if err != nil {
+		return 0, err
+	}
+	flag := account.CheckLogin(userCookie.Value, userID)
+	if !flag {
+		e := errors.New("illegal users")
+		return userID, e
+	}
+
+	return userID, nil
+}
+
+//CheckPermission 检查操作权限
+func (d *DefaultAccount) CheckPermission(pre string, isEdit bool, userID int) (bool, error) {
+	if isEdit {
+		return true, nil
+	}
+	return true, nil
+}

console/controller/account/guest.go

@@ -2,6 +2,9 @@ package account
 
 import (
 	"errors"
+
+	goku_handler "github.com/eolinker/goku-api-gateway/goku-handler"
+
 	"net/http"
 	"strconv"
 
@@ -10,6 +13,22 @@ import (
 	"github.com/eolinker/goku-api-gateway/utils"
 )
 
+//Account 账号类
+type Account struct {
+}
+
+//Handlers 处理器
+func (c *Account) Handlers(factory *goku_handler.AccountHandlerFactory) map[string]http.Handler {
+	return map[string]http.Handler{
+		"/login": http.HandlerFunc(Login),
+	}
+}
+
+//NewAccountController 新建账号控制类
+func NewAccountController() *Account {
+	return &Account{}
+}
+
 //Login 用户登录
 func Login(httpResponse http.ResponseWriter, httpRequest *http.Request) {
 
@@ -24,7 +43,7 @@ func Login(httpResponse http.ResponseWriter, httpRequest *http.Request) {
 			"100000",
 			"guest",
 			"[ERROR]Wrong username or password!",
-			errors.New("Wrong username or password"))
+			errors.New("wrong username or password"))
 		return
 	}
 

console/controller/account/user.go

@@ -6,11 +6,38 @@ import (
 	"regexp"
 	"strconv"
 
+	goku_handler "github.com/eolinker/goku-api-gateway/goku-handler"
+
 	"github.com/eolinker/goku-api-gateway/console/controller"
 	"github.com/eolinker/goku-api-gateway/console/module/account"
 	"github.com/eolinker/goku-api-gateway/utils"
 )
 
+//OperationUser 用户权限
+const OperationUser = "user"
+
+//UserController 用户控制器
+type UserController struct {
+}
+
+//NewUserController 新建用户控制器
+func NewUserController() *UserController {
+	return &UserController{}
+}
+
+//Handlers 处理类
+func (u *UserController) Handlers(factory *goku_handler.AccountHandlerFactory) map[string]http.Handler {
+
+	return map[string]http.Handler{
+		"/logout":            factory.NewAccountHandleFunction(OperationUser, false, Logout),
+		"/password/edit":     factory.NewAccountHandleFunction(OperationUser, false, EditPassword),
+		"/getInfo":           factory.NewAccountHandleFunction(OperationUser, false, GetUserInfo),
+		"/getUserType":       factory.NewAccountHandleFunction(OperationUser, false, GetUserType),
+		"/checkIsAdmin":      factory.NewAccountHandleFunction(OperationUser, false, CheckUserIsAdmin),
+		"/checkIsSuperAdmin": factory.NewAccountHandleFunction(OperationUser, false, CheckUserIsSuperAdmin),
+	}
+}
+
 //Logout 用户注销
 func Logout(httpResponse http.ResponseWriter, httpRequest *http.Request) {
 
@@ -25,10 +52,6 @@ func Logout(httpResponse http.ResponseWriter, httpRequest *http.Request) {
 
 //EditPassword 修改账户信息
 func EditPassword(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	userID, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationNone, controller.OperationEDIT)
-	if e != nil {
-		return
-	}
 
 	oldPassword := httpRequest.PostFormValue("oldPassword")
 	newPassword := httpRequest.PostFormValue("newPassword")
@@ -50,6 +73,7 @@ func EditPassword(httpResponse http.ResponseWriter, httpRequest *http.Request) {
 			errors.New("[ERROR]Illegal newPassword"))
 		return
 	}
+	userID := goku_handler.UserIDFromRequest(httpRequest)
 	flag, result, err := account.EditPassword(oldPassword, newPassword, userID)
 	if !flag {
 		controller.WriteError(httpResponse,
@@ -72,10 +96,7 @@ func EditPassword(httpResponse http.ResponseWriter, httpRequest *http.Request) {
 
 //GetUserInfo 获取用户信息
 func GetUserInfo(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	userID, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationNone, controller.OperationEDIT)
-	if e != nil {
-		return
-	}
+	userID := goku_handler.UserIDFromRequest(httpRequest)
 
 	flag, result, err := account.GetUserInfo(userID)
 	if !flag {
@@ -91,11 +112,8 @@ func GetUserInfo(httpResponse http.ResponseWriter, httpRequest *http.Request) {
 
 //GetUserType 获取用户类型
 func GetUserType(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	userID, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationNone, controller.OperationEDIT)
-	if e != nil {
-		return
-	}
 
+	userID := goku_handler.UserIDFromRequest(httpRequest)
 	flag, result, err := account.GetUserType(userID)
 	if !flag {
 
@@ -109,10 +127,7 @@ func GetUserType(httpResponse http.ResponseWriter, httpRequest *http.Request) {
 
 //CheckUserIsAdmin 判断是否是管理员
 func CheckUserIsAdmin(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	userID, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationNone, controller.OperationEDIT)
-	if e != nil {
-		return
-	}
+	userID := goku_handler.UserIDFromRequest(httpRequest)
 
 	flag, _, err := account.CheckUserIsAdmin(userID)
 	if !flag {
@@ -132,10 +147,7 @@ func CheckUserIsAdmin(httpResponse http.ResponseWriter, httpRequest *http.Reques
 
 //CheckUserIsSuperAdmin 判断是否是超级管理员
 func CheckUserIsSuperAdmin(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	userID, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationNone, controller.OperationEDIT)
-	if e != nil {
-		return
-	}
+	userID := goku_handler.UserIDFromRequest(httpRequest)
 
 	flag, _, err := account.CheckUserIsSuperAdmin(userID)
 
@@ -153,29 +165,3 @@ func CheckUserIsSuperAdmin(httpResponse http.ResponseWriter, httpRequest *http.R
 	controller.WriteResultInfo(httpResponse, "user", "", nil)
 	return
 }
-
-//CheckUserPermission 检查用户权限
-func CheckUserPermission(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	userID, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationNone, controller.OperationEDIT)
-	if e != nil {
-		return
-	}
-
-	operationType := httpRequest.PostFormValue("operationType")
-	operation := httpRequest.PostFormValue("operation")
-	flag, result, err := account.CheckUserPermission(operationType, operation, userID)
-
-	if !flag {
-
-		controller.WriteError(httpResponse,
-			"110000",
-			"user",
-			result,
-			err)
-		return
-
-	}
-
-	controller.WriteResultInfo(httpResponse, "user", "", nil)
-	return
-}

console/controller/api/api-balance-batch.go

 package api
 
 import (
-	"net/http"
-	"strings"
-
 	"github.com/eolinker/goku-api-gateway/console/controller"
 	"github.com/eolinker/goku-api-gateway/console/module/api"
+	"net/http"
+	"strings"
 )
 
 //BatchSetBalanceAPI 批量设置接口负载
 func BatchSetBalanceAPI(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	_, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationAPI, controller.OperationEDIT)
-	if e != nil {
-		return
-	}
+
 
 	apiIDList := httpRequest.PostFormValue("apiIDList")
 	balanceName := httpRequest.PostFormValue("balance")

console/controller/api/api.go

@@ -6,19 +6,47 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/eolinker/goku-api-gateway/utils"
+
+	"github.com/pkg/errors"
+
+	goku_handler "github.com/eolinker/goku-api-gateway/goku-handler"
+
 	"github.com/eolinker/goku-api-gateway/console/controller"
-	"github.com/eolinker/goku-api-gateway/console/module/account"
 	"github.com/eolinker/goku-api-gateway/console/module/api"
 )
 
+const operationAPI = "apiManagement"
+
+//Handlers handlers
+type Handlers struct {
+}
+
+//Handlers handlers
+func (h *Handlers) Handlers(factory *goku_handler.AccountHandlerFactory) map[string]http.Handler {
+	return map[string]http.Handler{
+		"/add":              factory.NewAccountHandleFunction(operationAPI, true, AddAPI),
+		"/edit":             factory.NewAccountHandleFunction(operationAPI, true, EditAPI),
+		"/copy":             factory.NewAccountHandleFunction(operationAPI, true, CopyAPI),
+		"/getInfo":          factory.NewAccountHandleFunction(operationAPI, false, GetAPIInfo),
+		"/getList":          factory.NewAccountHandleFunction(operationAPI, false, GetAPIList),
+		"/id/getList":       factory.NewAccountHandleFunction(operationAPI, false, GetAPIIDList),
+		"/batchEditGroup":   factory.NewAccountHandleFunction(operationAPI, true, BatchEditAPIGroup),
+		"/batchDelete":      factory.NewAccountHandleFunction(operationAPI, true, BatchDeleteAPI),
+		"/batchEditBalance": factory.NewAccountHandleFunction(operationAPI, true, BatchSetBalanceAPI),
+	}
+}
+
+//NewAPIHandlers API处理器
+func NewAPIHandlers() *Handlers {
+	return &Handlers{}
+}
+
 //AddAPI 新增接口
 func AddAPI(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	userID, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationAPI, controller.OperationEDIT)
-	if e != nil {
-		return
-	}
 
 	apiName := httpRequest.PostFormValue("apiName")
+	alias := httpRequest.PostFormValue("alias")
 	requestURL := httpRequest.PostFormValue("requestURL")
 	requestMethod := httpRequest.PostFormValue("requestMethod")
 	protocol := httpRequest.PostFormValue("protocol")
@@ -36,7 +64,7 @@ func AddAPI(httpResponse http.ResponseWriter, httpRequest *http.Request) {
 	linkApis := httpRequest.PostFormValue("linkApis")
 	staticResponse := httpRequest.PostFormValue("staticResponse")
 	responseDataType := httpRequest.PostFormValue("responseDataType")
-
+	userID := goku_handler.UserIDFromRequest(httpRequest)
 	if apiName == "" {
 		controller.WriteError(httpResponse, "190002", "api", "[ERROR]Illegal apiName!", nil)
 		return
@@ -55,6 +83,15 @@ func AddAPI(httpResponse http.ResponseWriter, httpRequest *http.Request) {
 		controller.WriteError(httpResponse, "190012", "api", "[ERROR]Illegal apiType!", err)
 		return
 	}
+
+	if !utils.ValidateURL(requestURL) {
+		controller.WriteError(httpResponse, "190021", "api", "[ERROR]Illegal requestURL!", nil)
+		return
+	}
+	if aType == 1 && !utils.ValidateURL(targetURL) {
+		controller.WriteError(httpResponse, "190022", "api", "[ERROR]Illegal requestURL!", nil)
+		return
+	}
 	if responseDataType != "origin" && responseDataType != "json" && responseDataType != "xml" {
 		controller.WriteError(httpResponse, "190013", "api", "[ERROR]Illegal responseDataType!", err)
 		return
@@ -102,8 +139,13 @@ func AddAPI(httpResponse http.ResponseWriter, httpRequest *http.Request) {
 	if managerID == "" {
 		mgID = userID
 	}
+	if api.CheckAliasIsExist(0, alias) {
+		errInfo := "[ERROR]duplicate alias!"
+		controller.WriteError(httpResponse, "190020", "api", errInfo, errors.New(errInfo))
+		return
+	}
 
-	flag, id, err := api.AddAPI(apiName, requestURL, targetURL, requestMethod, targetMethod, isFollow, linkApis, staticResponse, responseDataType, balanceName, protocol, pjID, gID, t, count, apiValve, mgID, userID, aType)
+	flag, id, err := api.AddAPI(apiName, alias, requestURL, targetURL, requestMethod, targetMethod, isFollow, linkApis, staticResponse, responseDataType, balanceName, protocol, pjID, gID, t, count, apiValve, mgID, userID, aType)
 	if !flag {
 
 		controller.WriteError(httpResponse,
@@ -117,13 +159,10 @@ func AddAPI(httpResponse http.ResponseWriter, httpRequest *http.Request) {
 
 //EditAPI 编辑接口
 func EditAPI(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	userID, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationAPI, controller.OperationEDIT)
-	if e != nil {
-		return
-	}
 
 	apiID := httpRequest.PostFormValue("apiID")
 	apiName := httpRequest.PostFormValue("apiName")
+	alias := httpRequest.PostFormValue("alias")
 	requestURL := httpRequest.PostFormValue("requestURL")
 	targetURL := httpRequest.PostFormValue("targetURL")
 	requestMethod := httpRequest.PostFormValue("requestMethod")
@@ -140,6 +179,8 @@ func EditAPI(httpResponse http.ResponseWriter, httpRequest *http.Request) {
 	linkApis := httpRequest.PostFormValue("linkApis")
 	staticResponse := httpRequest.PostFormValue("staticResponse")
 	responseDataType := httpRequest.PostFormValue("responseDataType")
+	userID := goku_handler.UserIDFromRequest(httpRequest)
+
 	if apiName == "" {
 		controller.WriteError(httpResponse, "190002", "api", "[ERROR]Illegal apiName!", nil)
 		return
@@ -207,8 +248,13 @@ func EditAPI(httpResponse http.ResponseWriter, httpRequest *http.Request) {
 	if managerID == "" {
 		mgID = userID
 	}
+	if api.CheckAliasIsExist(aID, alias) {
+		errInfo := "[ERROR]duplicate alias!"
+		controller.WriteError(httpResponse, "190020", "api", errInfo, errors.New(errInfo))
+		return
+	}
 
-	flag, err := api.EditAPI(apiName, requestURL, targetURL, requestMethod, targetMethod, isFollow, linkApis, staticResponse, responseDataType, balanceName, protocol, pjID, gID, t, count, apiValve, aID, mgID, userID)
+	flag, err := api.EditAPI(apiName, alias, requestURL, targetURL, requestMethod, targetMethod, isFollow, linkApis, staticResponse, responseDataType, balanceName, protocol, pjID, gID, t, count, apiValve, aID, mgID, userID)
 	if !flag {
 
 		controller.WriteError(httpResponse, "190000", "api", "[ERROR]apiID does not exist!", err)
@@ -223,10 +269,6 @@ func EditAPI(httpResponse http.ResponseWriter, httpRequest *http.Request) {
 
 //GetAPIInfo 获取接口信息
 func GetAPIInfo(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	_, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationAPI, controller.OperationREAD)
-	if e != nil {
-		return
-	}
 
 	apiID := httpRequest.PostFormValue("apiID")
 
@@ -249,10 +291,6 @@ func GetAPIInfo(httpResponse http.ResponseWriter, httpRequest *http.Request) {
 
 // GetAPIIDList 获取接口ID列表
 func GetAPIIDList(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	_, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationAPI, controller.OperationREAD)
-	if e != nil {
-		return
-	}
 
 	httpRequest.ParseForm()
 	projectID := httpRequest.Form.Get("projectID")
@@ -284,8 +322,11 @@ func GetAPIIDList(httpResponse http.ResponseWriter, httpRequest *http.Request) {
 	ids := make([]int, 0)
 	json.Unmarshal([]byte(idsStr), &ids)
 
-	_, result, _ := api.GetAPIIDList(pjID, gID, keyword, op, ids)
-
+	_, result, err := api.GetAPIIDList(pjID, gID, keyword, op, ids)
+	if err != nil {
+		controller.WriteError(httpResponse, "190020", "api", "[ERROR]db error!", err)
+		return
+	}
 	// controller.WriteResultInfo(httpResponse, "api", "apiList", result)
 	controller.WriteResultInfoWithPage(httpResponse, "api", "apiIDList", result, &controller.PageInfo{
 		ItemNum:  len(result),
@@ -296,10 +337,6 @@ func GetAPIIDList(httpResponse http.ResponseWriter, httpRequest *http.Request) {
 
 //GetAPIList 获取接口列表
 func GetAPIList(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	_, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationAPI, controller.OperationREAD)
-	if e != nil {
-		return
-	}
 
 	httpRequest.ParseForm()
 	projectID := httpRequest.Form.Get("projectID")
@@ -343,8 +380,11 @@ func GetAPIList(httpResponse http.ResponseWriter, httpRequest *http.Request) {
 	ids := make([]int, 0)
 	json.Unmarshal([]byte(idsStr), &ids)
 
-	_, result, count, _ := api.GetAPIList(pjID, gID, keyword, op, p, pSize, ids)
-
+	_, result, count, err := api.GetAPIList(pjID, gID, keyword, op, p, pSize, ids)
+	if err != nil {
+		controller.WriteError(httpResponse, "190019", "api", "[Error]db error", err)
+		return
+	}
 	// controller.WriteResultInfo(httpResponse, "api", "apiList", result)
 	controller.WriteResultInfoWithPage(httpResponse, "api", "apiList", result, &controller.PageInfo{
 		ItemNum:  len(result),
@@ -357,10 +397,6 @@ func GetAPIList(httpResponse http.ResponseWriter, httpRequest *http.Request) {
 
 // BatchEditAPIGroup 批量修改接口分组
 func BatchEditAPIGroup(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	_, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationAPI, controller.OperationEDIT)
-	if e != nil {
-		return
-	}
 
 	apiIDList := httpRequest.PostFormValue("apiIDList")
 	groupID := httpRequest.PostFormValue("groupID")
@@ -381,10 +417,6 @@ func BatchEditAPIGroup(httpResponse http.ResponseWriter, httpRequest *http.Reque
 
 //BatchDeleteAPI 批量删除接口
 func BatchDeleteAPI(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	_, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationAPI, controller.OperationEDIT)
-	if e != nil {
-		return
-	}
 
 	apiIDList := httpRequest.PostFormValue("apiIDList")
 
@@ -400,30 +432,11 @@ func BatchDeleteAPI(httpResponse http.ResponseWriter, httpRequest *http.Request)
 	return
 }
 
-//GetAPIManagerList 获取接口负责人列表
-func GetAPIManagerList(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	_, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationAPI, controller.OperationREAD)
-	if e != nil {
-		return
-	}
-
-	flag, result, err := account.GetUserListWithPermission("apiManagement", "edit")
-	if !flag {
-		controller.WriteError(httpResponse, "190000", "api", err.Error(), err)
-		return
-	}
-	controller.WriteResultInfo(httpResponse, "api", "userList", result)
-	return
-}
-
 //CopyAPI 复制接口
 func CopyAPI(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	userID, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationAPI, controller.OperationEDIT)
-	if e != nil {
-		return
-	}
 
 	apiID := httpRequest.PostFormValue("apiID")
+	alisa := httpRequest.PostFormValue("alisa")
 	apiName := httpRequest.PostFormValue("apiName")
 	requestURL := httpRequest.PostFormValue("requestURL")
 	targetURL := httpRequest.PostFormValue("targetURL")
@@ -434,6 +447,7 @@ func CopyAPI(httpResponse http.ResponseWriter, httpRequest *http.Request) {
 	isFollow := httpRequest.PostFormValue("isFollow")
 	groupID := httpRequest.PostFormValue("groupID")
 	projectID := httpRequest.PostFormValue("projectID")
+	userID := goku_handler.UserIDFromRequest(httpRequest)
 	if apiName == "" {
 		controller.WriteError(httpResponse, "190002", "api", "[ERROR]Illegal apiName!", nil)
 		return
@@ -465,13 +479,21 @@ func CopyAPI(httpResponse http.ResponseWriter, httpRequest *http.Request) {
 		return
 
 	}
+	if !utils.ValidateURL(requestURL) {
+		controller.WriteError(httpResponse, "190021", "api", "[ERROR]Illegal requestURL!", nil)
+		return
+	}
 	flag, apiInfo, err := api.GetAPIInfo(aID)
 	if !flag {
 		controller.WriteError(httpResponse, "190000", "api", "[ERROR]apiID does not exist!", nil)
 		return
 	}
+	if apiInfo.APIType == 1 && !utils.ValidateURL(targetURL) {
+		controller.WriteError(httpResponse, "190022", "api", "[ERROR]Illegal targetURL!", nil)
+		return
+	}
 	linkApis, _ := json.Marshal(apiInfo.LinkAPIs)
-	flag, id, err := api.AddAPI(apiName, requestURL, targetURL, requestMethod, targetMethod, isFollow, string(linkApis), apiInfo.StaticResponse, apiInfo.ResponseDataType, balanceName, protocol, pjID, gID, apiInfo.Timeout, apiInfo.RetryConut, apiInfo.Valve, apiInfo.ManagerID, userID, apiInfo.APIType)
+	flag, id, err := api.AddAPI(apiName, alisa, requestURL, targetURL, requestMethod, targetMethod, isFollow, string(linkApis), apiInfo.StaticResponse, apiInfo.ResponseDataType, balanceName, protocol, pjID, gID, apiInfo.Timeout, apiInfo.RetryConut, apiInfo.Valve, apiInfo.ManagerID, userID, apiInfo.APIType)
 	if !flag {
 		controller.WriteError(httpResponse, "190000", "api", "[ERROR]Fail to add api!", err)
 		return

console/controller/api/apiGroup.go

@@ -7,14 +7,32 @@ import (
 	"github.com/eolinker/goku-api-gateway/console/controller"
 	"github.com/eolinker/goku-api-gateway/console/module/api"
 	"github.com/eolinker/goku-api-gateway/console/module/project"
+	goku_handler "github.com/eolinker/goku-api-gateway/goku-handler"
 )
 
+const operationAPIGroup = "apiManagement"
+
+//GroupHandlers 接口分组处理器
+type GroupHandlers struct {
+}
+
+//Handlers 处理器
+func (g *GroupHandlers) Handlers(factory *goku_handler.AccountHandlerFactory) map[string]http.Handler {
+	return map[string]http.Handler{
+		"/add":     factory.NewAccountHandleFunction(operationAPIGroup, true, AddAPIGroup),
+		"/edit":    factory.NewAccountHandleFunction(operationAPIGroup, true, EditAPIGroup),
+		"/delete":  factory.NewAccountHandleFunction(operationAPIGroup, true, DeleteAPIGroup),
+		"/getList": factory.NewAccountHandleFunction(operationAPIGroup, false, GetAPIGroupList),
+	}
+}
+
+//NewGroupHandlers new 接口分组处理器
+func NewGroupHandlers() *GroupHandlers {
+	return &GroupHandlers{}
+}
+
 //AddAPIGroup 新建接口分组
 func AddAPIGroup(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	_, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationAPI, controller.OperationEDIT)
-	if e != nil {
-		return
-	}
 
 	groupName := httpRequest.PostFormValue("groupName")
 	projectID := httpRequest.PostFormValue("projectID")
@@ -68,10 +86,6 @@ func AddAPIGroup(httpResponse http.ResponseWriter, httpRequest *http.Request) {
 
 //EditAPIGroup 修改接口分组
 func EditAPIGroup(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	_, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationAPI, controller.OperationEDIT)
-	if e != nil {
-		return
-	}
 
 	groupName := httpRequest.PostFormValue("groupName")
 	groupID := httpRequest.PostFormValue("groupID")
@@ -120,10 +134,6 @@ func EditAPIGroup(httpResponse http.ResponseWriter, httpRequest *http.Request) {
 
 //DeleteAPIGroup 删除接口分组
 func DeleteAPIGroup(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	_, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationAPI, controller.OperationEDIT)
-	if e != nil {
-		return
-	}
 
 	groupID := httpRequest.PostFormValue("groupID")
 	projectID := httpRequest.PostFormValue("projectID")
@@ -158,10 +168,6 @@ func DeleteAPIGroup(httpResponse http.ResponseWriter, httpRequest *http.Request)
 
 //GetAPIGroupList 获取接口分组列表
 func GetAPIGroupList(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	_, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationAPI, controller.OperationREAD)
-	if e != nil {
-		return
-	}
 
 	projectID := httpRequest.PostFormValue("projectID")
 	pjID, err := strconv.Atoi(projectID)

console/controller/api/apiPlugin.go

@@ -10,20 +10,44 @@ import (
 	"github.com/eolinker/goku-api-gateway/console/module/plugin"
 	plugin_config "github.com/eolinker/goku-api-gateway/console/module/plugin/plugin-config"
 	"github.com/eolinker/goku-api-gateway/console/module/strategy"
+	goku_handler "github.com/eolinker/goku-api-gateway/goku-handler"
 )
 
+const operationAPIPlugin = "strategyManagement"
+
+//PluginHandlers 插件处理器
+type PluginHandlers struct {
+}
+
+//Handlers handlers
+func (p *PluginHandlers) Handlers(factory *goku_handler.AccountHandlerFactory) map[string]http.Handler {
+	return map[string]http.Handler{
+		"/addPluginToApi":    factory.NewAccountHandleFunction(operationAPIPlugin, true, AddPluginToAPI),
+		"/edit":              factory.NewAccountHandleFunction(operationAPIPlugin, true, EditAPIPluginConfig),
+		"/getInfo":           factory.NewAccountHandleFunction(operationAPIPlugin, false, GetAPIPluginConfig),
+		"/getList":           factory.NewAccountHandleFunction(operationAPIPlugin, false, GetAPIPluginList),
+		"/getListByStrategy": factory.NewAccountHandleFunction(operationAPIPlugin, false, GetAllAPIPluginInStrategy),
+		"/batchStart":        factory.NewAccountHandleFunction(operationAPIPlugin, true, BatchStartAPIPlugin),
+		"/batchStop":         factory.NewAccountHandleFunction(operationAPIPlugin, true, BatchStopAPIPlugin),
+		"/batchDelete":       factory.NewAccountHandleFunction(operationAPIPlugin, true, BatchDeleteAPIPlugin),
+		"/notAssign/getList": factory.NewAccountHandleFunction(operationAPIPlugin, false, GetAPIPluginListWithNotAssignAPIList),
+	}
+}
+
+//NewPluginHandlers new插件处理器
+func NewPluginHandlers() *PluginHandlers {
+	return &PluginHandlers{}
+
+}
+
 //AddPluginToAPI 新增插件到接口
 func AddPluginToAPI(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	userID, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationAPI, controller.OperationEDIT)
-	if e != nil {
-		return
-	}
 
 	pluginName := httpRequest.PostFormValue("pluginName")
 	pluginConfig := httpRequest.PostFormValue("pluginConfig")
 	strategyID := httpRequest.PostFormValue("strategyID")
 	apiID := httpRequest.PostFormValue("apiID")
-
+	userID := goku_handler.UserIDFromRequest(httpRequest)
 	aID, err := strconv.Atoi(apiID)
 	if err != nil {
 		controller.WriteError(httpResponse, "240002", "apiPlugin", "[ERROR]Illegal apiID!", err)
@@ -81,15 +105,13 @@ func AddPluginToAPI(httpResponse http.ResponseWriter, httpRequest *http.Request)
 
 //EditAPIPluginConfig 修改接口插件
 func EditAPIPluginConfig(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	userID, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationAPI, controller.OperationEDIT)
-	if e != nil {
-		return
-	}
 
 	pluginName := httpRequest.PostFormValue("pluginName")
 	pluginConfig := httpRequest.PostFormValue("pluginConfig")
 	strategyID := httpRequest.PostFormValue("strategyID")
 	apiID := httpRequest.PostFormValue("apiID")
+	userID := goku_handler.UserIDFromRequest(httpRequest)
+
 	flag, err := plugin_config.CheckConfig(pluginName, []byte(pluginConfig))
 	if !flag {
 		controller.WriteError(httpResponse, "500000", "apiPlugin", "[ERROR]插件配置无效:"+err.Error(), err)
@@ -153,10 +175,6 @@ func EditAPIPluginConfig(httpResponse http.ResponseWriter, httpRequest *http.Req
 
 //GetAPIPluginConfig 获取接口插件配置
 func GetAPIPluginConfig(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	_, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationAPI, controller.OperationREAD)
-	if e != nil {
-		return
-	}
 
 	pluginName := httpRequest.PostFormValue("pluginName")
 	strategyID := httpRequest.PostFormValue("strategyID")
@@ -198,10 +216,6 @@ func GetAPIPluginConfig(httpResponse http.ResponseWriter, httpRequest *http.Requ
 
 //GetAPIPluginList 获取接口插件配置
 func GetAPIPluginList(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	_, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationAPI, controller.OperationREAD)
-	if e != nil {
-		return
-	}
 
 	strategyID := httpRequest.PostFormValue("strategyID")
 	apiID := httpRequest.PostFormValue("apiID")
@@ -230,60 +244,8 @@ func GetAPIPluginList(httpResponse http.ResponseWriter, httpRequest *http.Reques
 	return
 }
 
-// GetAPIPluginInStrategyByAPIID 获取策略组中所有接口插件列表
-func GetAPIPluginInStrategyByAPIID(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	_, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationAPI, controller.OperationREAD)
-	if e != nil {
-		return
-	}
-	httpRequest.ParseForm()
-	strategyID := httpRequest.Form.Get("strategyID")
-	apiID := httpRequest.Form.Get("apiID")
-	keyword := httpRequest.Form.Get("keyword")
-	condition := httpRequest.Form.Get("condition")
-
-	aID, err := strconv.Atoi(apiID)
-	if err != nil {
-		controller.WriteError(httpResponse, "240002", "apiPlugin", "[ERROR]Illegal condition!", err)
-		return
-	}
-	op, err := strconv.Atoi(condition)
-	if err != nil && condition != "" {
-		controller.WriteError(httpResponse, "270006", "apiPlugin", "[ERROR]Illegal condition!", err)
-		return
-	}
-
-	flag, pluginList, apiInfo, err := api.GetAPIPluginInStrategyByAPIID(strategyID, aID, keyword, op)
-	if !flag {
-		controller.WriteError(httpResponse,
-			"240000",
-			"apiPlugin",
-			"[ERROR]Empty api plugin list!",
-			err)
-		return
-
-	}
-	result := map[string]interface{}{
-		"statusCode":    "000000",
-		"type":          "apiPlugin",
-		"resultDesc":    "",
-		"apiPluginList": pluginList,
-		"apiInfo":       apiInfo,
-		"page": controller.PageInfo{
-			ItemNum: len(pluginList),
-		},
-	}
-	resultStr, _ := json.Marshal(result)
-	httpResponse.Write(resultStr)
-	// controller.WriteResultInfo(httpResponse, "apiPlugin", "apiPluginList", result)
-}
-
 //GetAllAPIPluginInStrategy 获取策略组中所有接口插件列表
 func GetAllAPIPluginInStrategy(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	_, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationAPI, controller.OperationREAD)
-	if e != nil {
-		return
-	}
 
 	strategyID := httpRequest.PostFormValue("strategyID")
 
@@ -305,13 +267,11 @@ func GetAllAPIPluginInStrategy(httpResponse http.ResponseWriter, httpRequest *ht
 
 //BatchStartAPIPlugin 批量修改策略组插件状态
 func BatchStartAPIPlugin(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	userID, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationAPI, controller.OperationEDIT)
-	if e != nil {
-		return
-	}
 
 	strategyID := httpRequest.PostFormValue("strategyID")
 	connIDList := httpRequest.PostFormValue("connIDList")
+	userID := goku_handler.UserIDFromRequest(httpRequest)
+
 	if connIDList == "" {
 		controller.WriteError(httpResponse,
 			"240001",
@@ -338,13 +298,11 @@ func BatchStartAPIPlugin(httpResponse http.ResponseWriter, httpRequest *http.Req
 
 //BatchStopAPIPlugin 批量修改策略组插件状态
 func BatchStopAPIPlugin(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	userID, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationAPI, controller.OperationEDIT)
-	if e != nil {
-		return
-	}
 
 	strategyID := httpRequest.PostFormValue("strategyID")
 	connIDList := httpRequest.PostFormValue("connIDList")
+	userID := goku_handler.UserIDFromRequest(httpRequest)
+
 	if connIDList == "" {
 		controller.WriteError(httpResponse,
 			"240001",
@@ -371,13 +329,10 @@ func BatchStopAPIPlugin(httpResponse http.ResponseWriter, httpRequest *http.Requ
 
 //BatchDeleteAPIPlugin 批量删除策略组插件
 func BatchDeleteAPIPlugin(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	_, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationAPI, controller.OperationEDIT)
-	if e != nil {
-		return
-	}
 
 	strategyID := httpRequest.PostFormValue("strategyID")
 	connIDList := httpRequest.PostFormValue("connIDList")
+
 	if connIDList == "" {
 		controller.WriteError(httpResponse,
 			"240001",
@@ -401,10 +356,6 @@ func BatchDeleteAPIPlugin(httpResponse http.ResponseWriter, httpRequest *http.Re
 
 //GetAPIPluginListWithNotAssignAPIList 获取没有分配接口插件的接口列表
 func GetAPIPluginListWithNotAssignAPIList(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	_, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationAPI, controller.OperationREAD)
-	if e != nil {
-		return
-	}
 
 	strategyID := httpRequest.PostFormValue("strategyID")
 	if strategyID == "" {

console/controller/api/import.go

@@ -2,6 +2,7 @@ package api
 
 import (
 	"encoding/json"
+	"fmt"
 	"io/ioutil"
 	"net/http"
 	"strconv"
@@ -9,18 +10,36 @@ import (
 
 	"github.com/eolinker/goku-api-gateway/console/controller"
 	"github.com/eolinker/goku-api-gateway/console/module/api"
+	goku_handler "github.com/eolinker/goku-api-gateway/goku-handler"
 	entity "github.com/eolinker/goku-api-gateway/server/entity/console-entity"
 )
 
+const operationImportAMS = "apiManagement"
+
+//ImportHandlers 导入handlers
+type ImportHandlers struct {
+}
+
+//Handlers handler
+func (i *ImportHandlers) Handlers(factory *goku_handler.AccountHandlerFactory) map[string]http.Handler {
+
+	return map[string]http.Handler{
+		"/api":     factory.NewAccountHandleFunction(operationImportAMS, true, ImportAPIFromAms),
+		"/group":   factory.NewAccountHandleFunction(operationImportAMS, true, ImportAPIGroupFromAms),
+		"/project": factory.NewAccountHandleFunction(operationImportAMS, true, ImportProjectFromAms),
+	}
+}
+
+//NewImportHandlers new导入处理器
+func NewImportHandlers() *ImportHandlers {
+	return &ImportHandlers{}
+}
+
 //ImportAPIGroupFromAms 导入分组
 func ImportAPIGroupFromAms(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	userID, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationAPI, controller.OperationEDIT)
-	if e != nil {
-		return
-	}
 
 	contentType := httpRequest.Header.Get("Content-Type")
-
+	userID := goku_handler.UserIDFromRequest(httpRequest)
 	if !strings.Contains(contentType, "multipart/form-data") {
 		controller.WriteError(httpResponse,
 			"310001",
@@ -98,13 +117,9 @@ func ImportAPIGroupFromAms(httpResponse http.ResponseWriter, httpRequest *http.R
 
 //ImportProjectFromAms 导入项目
 func ImportProjectFromAms(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	userID, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationAPI, controller.OperationEDIT)
-	if e != nil {
-		return
-	}
 
 	contentType := httpRequest.Header.Get("Content-Type")
-
+	userID := goku_handler.UserIDFromRequest(httpRequest)
 	if !strings.Contains(contentType, "multipart/form-data") {
 		controller.WriteError(httpResponse,
 			"310001",
@@ -170,12 +185,9 @@ func ImportProjectFromAms(httpResponse http.ResponseWriter, httpRequest *http.Re
 
 //ImportAPIFromAms 导入接口
 func ImportAPIFromAms(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	userID, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationAPI, controller.OperationEDIT)
-	if e != nil {
-		return
-	}
 
 	contentType := httpRequest.Header.Get("Content-Type")
+	userID := goku_handler.UserIDFromRequest(httpRequest)
 	if !strings.Contains(contentType, "multipart/form-data") {
 		controller.WriteError(httpResponse,
 			"310001",
@@ -229,6 +241,7 @@ func ImportAPIFromAms(httpResponse http.ResponseWriter, httpRequest *http.Reques
 
 	}
 	apiList := make([]entity.AmsAPIInfo, 0)
+	fmt.Println(string(body))
 	err = json.Unmarshal(body, &apiList)
 	if err != nil {
 		controller.WriteError(httpResponse,

console/controller/auth/auth.go

@@ -5,23 +5,40 @@ import (
 	"net/http"
 	"strings"
 
+	goku_handler "github.com/eolinker/goku-api-gateway/goku-handler"
+
 	"github.com/eolinker/goku-api-gateway/console/controller"
 	"github.com/eolinker/goku-api-gateway/console/module/auth"
 	log "github.com/eolinker/goku-api-gateway/goku-log"
 )
 
+const operationAuth = "strategyManagement"
+
+//Handlers handlers
+type Handlers struct {
+}
+
+//Handlers handlers
+func (h *Handlers) Handlers(factory *goku_handler.AccountHandlerFactory) map[string]http.Handler {
+	return map[string]http.Handler{
+		"/getStatus": factory.NewAccountHandleFunction(operationAuth, true, GetAuthStatus),
+		"/getInfo":   factory.NewAccountHandleFunction(operationAuth, true, GetAuthInfo),
+		"/editInfo":  factory.NewAccountHandleFunction(operationAuth, true, EditAuthInfo),
+	}
+}
+
+//NewHandlers new handlers
+func NewHandlers() *Handlers {
+	return &Handlers{}
+}
+
 //GetAuthStatus 获取认证状态
 func GetAuthStatus(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	_, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationNone, controller.OperationREAD)
-	if e != nil {
-		return
-	}
 
 	strategyID := httpRequest.PostFormValue("strategyID")
 
 	flag, result, err := auth.GetAuthStatus(strategyID)
 	if !flag {
-
 		controller.WriteError(httpResponse, "250000", "auth", "[ERROR]The auth info of the strategy does not exist!", err)
 		return
 	}
@@ -37,10 +54,6 @@ func GetAuthStatus(httpResponse http.ResponseWriter, httpRequest *http.Request)
 
 //GetAuthInfo 获取认证信息
 func GetAuthInfo(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	_, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationNone, controller.OperationREAD)
-	if e != nil {
-		return
-	}
 
 	strategyID := httpRequest.PostFormValue("strategyID")
 
@@ -64,10 +77,6 @@ func GetAuthInfo(httpResponse http.ResponseWriter, httpRequest *http.Request) {
 
 //EditAuthInfo 编辑认证信息
 func EditAuthInfo(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	_, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationNone, controller.OperationEDIT)
-	if e != nil {
-		return
-	}
 
 	strategyID := httpRequest.PostFormValue("strategyID")
 	strategyName := httpRequest.PostFormValue("strategyName")

console/controller/balance/add.go

@@ -2,10 +2,11 @@ package balance
 
 import (
 	"fmt"
+	"github.com/eolinker/goku-api-gateway/console/controller"
+
 	"net/http"
 
 	"github.com/eolinker/goku-api-gateway/common/auto-form"
-	"github.com/eolinker/goku-api-gateway/console/controller"
 	"github.com/eolinker/goku-api-gateway/console/module/balance"
 	"github.com/go-sql-driver/mysql"
 )
@@ -13,10 +14,7 @@ import (
 //AddBalance 新增负载配置
 func AddBalance(w http.ResponseWriter, r *http.Request) {
 
-	_, e := controller.CheckLogin(w, r, controller.OperationLoadBalance, controller.OperationEDIT)
-	if e != nil {
-		return
-	}
+
 
 	if err := r.ParseForm(); err != nil {
 		controller.WriteError(w, "260000",

console/controller/balance/delete.go

 package balance
 
 import (
+	"github.com/eolinker/goku-api-gateway/console/controller"
 	"net/http"
 	"strings"
 
-	"github.com/eolinker/goku-api-gateway/console/controller"
 	"github.com/eolinker/goku-api-gateway/console/module/balance"
 )
 
 //DeleteBalance 删除负载配置
 func DeleteBalance(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	_, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationLoadBalance, controller.OperationEDIT)
-	if e != nil {
-		return
-	}
+
 
 	if err := httpRequest.ParseForm(); err != nil {
 		controller.WriteError(httpResponse, "260000", "data", "[param_check] Parse form body error | 解析form表单参数错误", err)
@@ -37,10 +34,7 @@ func DeleteBalance(httpResponse http.ResponseWriter, httpRequest *http.Request)
 //BatchDeleteBalance 批量删除负载
 func BatchDeleteBalance(httpResponse http.ResponseWriter, httpRequest *http.Request) {
 
-	_, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationLoadBalance, controller.OperationEDIT)
-	if e != nil {
-		return
-	}
+
 	balanceNames := httpRequest.PostFormValue("balanceNames")
 	result, err := balance.BatchDeleteBalance(strings.Split(balanceNames, ","))
 	if err != nil {

console/controller/balance/get.go

 package balance
 
 import (
-	"net/http"
-
 	"github.com/eolinker/goku-api-gateway/console/controller"
 	"github.com/eolinker/goku-api-gateway/console/module/balance"
+	"net/http"
 )
 
 //GetBalanceInfo 获取负载信息
 func GetBalanceInfo(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	_, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationLoadBalance, controller.OperationREAD)
-	if e != nil {
-		return
-	}
+
 	if err := httpRequest.ParseForm(); err != nil {
 		controller.WriteError(httpResponse, "501", "balance", "[ERROR]参数解析错误t!", err)
 		return

console/controller/balance/handle.go

+package balance
+
+import (
+	"net/http"
+
+	goku_handler "github.com/eolinker/goku-api-gateway/goku-handler"
+)
+
+const operationBalance = "balanceManagement"
+
+//Handlers handlers
+type Handlers struct {
+}
+
+//Handlers handlers
+func (h *Handlers) Handlers(factory *goku_handler.AccountHandlerFactory) map[string]http.Handler {
+	return map[string]http.Handler{
+		"/add":         factory.NewAccountHandleFunction(operationBalance, true, AddBalance),
+		"/edit":        factory.NewAccountHandleFunction(operationBalance, true, SaveBalance),
+		"/delete":      factory.NewAccountHandleFunction(operationBalance, true, DeleteBalance),
+		"/getInfo":     factory.NewAccountHandleFunction(operationBalance, false, GetBalanceInfo),
+		"/getList":     factory.NewAccountHandleFunction(operationBalance, false, GetBalanceList),
+		"/batchDelete": factory.NewAccountHandleFunction(operationBalance, true, BatchDeleteBalance),
+		"/simple":      factory.NewAccountHandleFunction(operationBalance, true, GetSimpleList),
+	}
+}
+
+//NewHandlers new handlers
+func NewHandlers() *Handlers {
+	return &Handlers{}
+}

console/controller/balance/list.go

@@ -2,18 +2,14 @@ package balance
 
 import (
 	"fmt"
-	"net/http"
-
 	"github.com/eolinker/goku-api-gateway/console/controller"
 	"github.com/eolinker/goku-api-gateway/console/module/balance"
+	"net/http"
 )
 
 //GetBalanceList 获取负载列表
 func GetBalanceList(w http.ResponseWriter, r *http.Request) {
-	_, e := controller.CheckLogin(w, r, controller.OperationLoadBalance, controller.OperationREAD)
-	if e != nil {
-		return
-	}
+
 	_ = r.ParseForm()
 
 	keyword := r.FormValue("keyword")

console/controller/balance/save.go

@@ -2,21 +2,17 @@ package balance
 
 import (
 	"fmt"
-	"net/http"
-
 	"github.com/eolinker/goku-api-gateway/common/auto-form"
 	"github.com/eolinker/goku-api-gateway/console/controller"
 	"github.com/eolinker/goku-api-gateway/console/module/balance"
 	"github.com/go-sql-driver/mysql"
+	"net/http"
 )
 
 //SaveBalance 新增负载配置
 func SaveBalance(w http.ResponseWriter, r *http.Request) {
 
-	_, e := controller.CheckLogin(w, r, controller.OperationLoadBalance, controller.OperationEDIT)
-	if e != nil {
-		return
-	}
+
 
 	if err := r.ParseForm(); err != nil {
 		controller.WriteError(w, "260000", "data", "[param_check] Parse form body error | 解析form表单参数错误", err)

console/controller/balance/simple.go

 package balance
 
 import (
-	"net/http"
-
 	"github.com/eolinker/goku-api-gateway/console/controller"
 	"github.com/eolinker/goku-api-gateway/console/module/balance"
+	"net/http"
 )
 
 //GetSimpleList 获取简易列表
 func GetSimpleList(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	_, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationLoadBalance, controller.OperationREAD)
-	if e != nil {
-		return
-	}
+
 
 	flag, result, err := balance.GetBalancNames()
 

console/controller/cluster/cluster.go

@@ -4,18 +4,39 @@ import (
 	"net/http"
 	"regexp"
 
+	goku_handler "github.com/eolinker/goku-api-gateway/goku-handler"
+
 	"github.com/pkg/errors"
 
 	"github.com/eolinker/goku-api-gateway/console/controller"
 	"github.com/eolinker/goku-api-gateway/console/module/cluster"
 )
 
+const operationCluster = "nodeManagement"
+
+//Handlers handlers
+type Handlers struct {
+}
+
+//Handlers handlers
+func (h *Handlers) Handlers(factory *goku_handler.AccountHandlerFactory) map[string]http.Handler {
+	return map[string]http.Handler{
+		"/add":        factory.NewAccountHandleFunction(operationCluster, true, AddCluster),
+		"/edit":       factory.NewAccountHandleFunction(operationCluster, true, EditCluster),
+		"/delete":     factory.NewAccountHandleFunction(operationCluster, true, DeleteCluster),
+		"/list":       factory.NewAccountHandleFunction(operationCluster, false, GetClusterInfoList),
+		"/simpleList": factory.NewAccountHandleFunction(operationCluster, false, GetClusterList),
+	}
+}
+
+//NewHandlers new handlers
+func NewHandlers() *Handlers {
+	return &Handlers{}
+}
+
 //GetClusterList 获取集群列表
 func GetClusterList(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	_, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationNone, controller.OperationREAD)
-	if e != nil {
-		return
-	}
+
 	list, _ := cluster.GetClusters()
 
 	controller.WriteResultInfo(httpResponse,
@@ -26,10 +47,7 @@ func GetClusterList(httpResponse http.ResponseWriter, httpRequest *http.Request)
 
 //GetCluster 获取集群信息
 func GetCluster(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	_, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationNone, controller.OperationREAD)
-	if e != nil {
-		return
-	}
+
 	httpRequest.ParseForm()
 	name := httpRequest.Form.Get("name")
 
@@ -47,10 +65,7 @@ func GetCluster(httpResponse http.ResponseWriter, httpRequest *http.Request) {
 
 //AddCluster 新增集群
 func AddCluster(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	_, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationNone, controller.OperationREAD)
-	if e != nil {
-		return
-	}
+
 	httpRequest.ParseForm()
 	name := httpRequest.Form.Get("name")
 	title := httpRequest.Form.Get("title")
@@ -78,10 +93,7 @@ func AddCluster(httpResponse http.ResponseWriter, httpRequest *http.Request) {
 
 //EditCluster 新增集群
 func EditCluster(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	_, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationNone, controller.OperationREAD)
-	if e != nil {
-		return
-	}
+
 	httpRequest.ParseForm()
 	name := httpRequest.Form.Get("name")
 	title := httpRequest.Form.Get("title")
@@ -105,10 +117,7 @@ func EditCluster(httpResponse http.ResponseWriter, httpRequest *http.Request) {
 
 //DeleteCluster 新增集群
 func DeleteCluster(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	_, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationNone, controller.OperationREAD)
-	if e != nil {
-		return
-	}
+
 	httpRequest.ParseForm()
 	name := httpRequest.Form.Get("name")
 	match, err := regexp.MatchString(`^[a-zA-Z][a-zA-z0-9_]*$`, name)
@@ -135,10 +144,7 @@ func DeleteCluster(httpResponse http.ResponseWriter, httpRequest *http.Request)
 
 //GetClusterInfoList 获取集群信息列表
 func GetClusterInfoList(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	_, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationNone, controller.OperationREAD)
-	if e != nil {
-		return
-	}
+
 	result, _ := cluster.GetClusters()
 
 	controller.WriteResultInfo(httpResponse,

console/controller/cluster/version.go

@@ -6,17 +6,38 @@ import (
 	"strconv"
 	"time"
 
+	goku_handler "github.com/eolinker/goku-api-gateway/goku-handler"
+
 	"github.com/eolinker/goku-api-gateway/console/module/versionConfig"
 
 	"github.com/eolinker/goku-api-gateway/console/controller"
 )
 
+const operationVersion = "versionManagement"
+
+//VersionHandlers 版本处理器
+type VersionHandlers struct {
+}
+
+//Handlers handlers
+func (h *VersionHandlers) Handlers(factory *goku_handler.AccountHandlerFactory) map[string]http.Handler {
+	return map[string]http.Handler{
+		"/add":        factory.NewAccountHandleFunction(operationVersion, true, AddVersionConfig),
+		"/basic/edit": factory.NewAccountHandleFunction(operationVersion, true, EditVersionBasicConfig),
+		"/delete":     factory.NewAccountHandleFunction(operationVersion, true, BatchDeleteVersionConfig),
+		"/getList":    factory.NewAccountHandleFunction(operationVersion, false, GetVersionList),
+		"/publish":    factory.NewAccountHandleFunction(operationVersion, true, PublishVersion),
+	}
+}
+
+//NewVersionHandlers new versionHandlers
+func NewVersionHandlers() *VersionHandlers {
+	return &VersionHandlers{}
+}
+
 //GetVersionList 获取版本列表
 func GetVersionList(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	_, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationNone, controller.OperationREAD)
-	if e != nil {
-		return
-	}
+
 	httpRequest.ParseForm()
 	keyword := httpRequest.Form.Get("keyword")
 	result, _ := versionConfig.GetVersionList(keyword)
@@ -28,10 +49,7 @@ func GetVersionList(httpResponse http.ResponseWriter, httpRequest *http.Request)
 
 //AddVersionConfig 新增版本配置
 func AddVersionConfig(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	_, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationNone, controller.OperationREAD)
-	if e != nil {
-		return
-	}
+
 	httpRequest.ParseForm()
 	name := httpRequest.Form.Get("name")
 	version := httpRequest.Form.Get("version")
@@ -44,14 +62,15 @@ func AddVersionConfig(httpResponse http.ResponseWriter, httpRequest *http.Reques
 	}
 	//count := cluster.GetVersionConfigCount()
 	now := time.Now().Format("2006-01-02 15:04:05")
-	id, err := versionConfig.AddVersionConfig(name, version, remark, now)
+	userID := goku_handler.UserIDFromRequest(httpRequest)
+	id, err := versionConfig.AddVersionConfig(name, version, remark, now, userID)
 	if err != nil {
 		controller.WriteError(httpResponse, "380000", "versionConfig", err.Error(), err)
 		return
 	}
 
 	if p == 1 {
-		versionConfig.PublishVersion(id, now)
+		versionConfig.PublishVersion(id, userID, now)
 	}
 	controller.WriteResultInfo(httpResponse,
 		"versionConfig",
@@ -60,12 +79,37 @@ func AddVersionConfig(httpResponse http.ResponseWriter, httpRequest *http.Reques
 	return
 }
 
-//BatchDeleteVersionConfig 批量删除版本配置
-func BatchDeleteVersionConfig(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	_, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationNone, controller.OperationREAD)
-	if e != nil {
+//EditVersionBasicConfig 新增版本配置
+func EditVersionBasicConfig(httpResponse http.ResponseWriter, httpRequest *http.Request) {
+
+	httpRequest.ParseForm()
+	name := httpRequest.Form.Get("name")
+	version := httpRequest.Form.Get("version")
+	remark := httpRequest.Form.Get("remark")
+	versionID := httpRequest.Form.Get("versionID")
+	id, err := strconv.Atoi(versionID)
+	if err != nil {
+		controller.WriteError(httpResponse, "380000", "versionConfig", err.Error(), err)
 		return
 	}
+
+	userID := goku_handler.UserIDFromRequest(httpRequest)
+	err = versionConfig.EditVersionBasicConfig(name, version, remark, userID, id)
+	if err != nil {
+		controller.WriteError(httpResponse, "380000", "versionConfig", err.Error(), err)
+		return
+	}
+
+	controller.WriteResultInfo(httpResponse,
+		"versionConfig",
+		"",
+		nil)
+	return
+}
+
+//BatchDeleteVersionConfig 批量删除版本配置
+func BatchDeleteVersionConfig(httpResponse http.ResponseWriter, httpRequest *http.Request) {
+
 	httpRequest.ParseForm()
 	ids := httpRequest.Form.Get("ids")
 	idList := make([]int, 0, 10)
@@ -93,13 +137,14 @@ func BatchDeleteVersionConfig(httpResponse http.ResponseWriter, httpRequest *htt
 func PublishVersion(httpResponse http.ResponseWriter, httpRequest *http.Request) {
 	httpRequest.ParseForm()
 	versionID := httpRequest.Form.Get("versionID")
+	userID := goku_handler.UserIDFromRequest(httpRequest)
 	id, err := strconv.Atoi(versionID)
 	if err != nil {
 		controller.WriteError(httpResponse, "380002", "versionConfig", "[ERROR]Illegal versionID", err)
 		return
 	}
 	now := time.Now().Format("2006-01-02 15:04:05")
-	err = versionConfig.PublishVersion(id, now)
+	err = versionConfig.PublishVersion(id, userID, now)
 	if err != nil {
 		controller.WriteError(httpResponse, "380000", "versionConfig", err.Error(), err)
 		return

console/controller/config-log/access.go

@@ -4,39 +4,38 @@ import (
 	"fmt"
 	"net/http"
 
+	goku_handler "github.com/eolinker/goku-api-gateway/goku-handler"
+
 	"github.com/eolinker/goku-api-gateway/common/auto-form"
 	"github.com/eolinker/goku-api-gateway/console/controller"
 	module "github.com/eolinker/goku-api-gateway/console/module/config-log"
 )
 
-//AccessLogHandler access日志处理器
-type AccessLogHandler struct {
+//LogHandler access日志处理器
+type LogHandler struct {
+	getHandler http.Handler
+	setHandler http.Handler
 }
 
-func (h *AccessLogHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	_, err := controller.CheckLogin(w, r, controller.OperationGatewayConfig, controller.OperationEDIT)
-	if err != nil {
-		return
-	}
+func (h *LogHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 
 	switch r.Method {
 	case http.MethodGet:
 		{
-			h.get(w, r)
-
+			h.getHandler.ServeHTTP(w, r)
 		}
 
 	case http.MethodPut:
 		{
-			h.set(w, r)
-
+			h.setHandler.ServeHTTP(w, r)
 		}
 	default:
 		w.WriteHeader(404)
 	}
 }
 
-func (h *AccessLogHandler) get(w http.ResponseWriter, r *http.Request) {
+//AccessLogGet 获取access日志配置
+func AccessLogGet(w http.ResponseWriter, r *http.Request) {
 	config, e := module.GetAccess()
 	if e = r.ParseForm(); e != nil {
 		controller.WriteError(w, "270000", "data", "[Get]未知错误："+e.Error(), e)
@@ -49,7 +48,9 @@ func (h *AccessLogHandler) get(w http.ResponseWriter, r *http.Request) {
 		config)
 
 }
-func (h *AccessLogHandler) set(w http.ResponseWriter, r *http.Request) {
+
+//AccessLogSet 设置access日志内容
+func AccessLogSet(w http.ResponseWriter, r *http.Request) {
 	err := r.ParseForm()
 	if err = r.ParseForm(); err != nil {
 		controller.WriteError(w, "260000", "data", "[param_check] Parse form body error | 解析form表单参数错误", err)
@@ -82,7 +83,7 @@ func (h *AccessLogHandler) set(w http.ResponseWriter, r *http.Request) {
 
 	err = module.Set(module.AccessLog, paramBase)
 	if err != nil {
-		controller.WriteError(w, "260000", "data", fmt.Sprintf("[mysql_error] %s", err.Error()), err)
+		controller.WriteError(w, "260000", "data", fmt.Sprintf("[db_error] %s", err.Error()), err)
 		return
 	}
 	controller.WriteResultInfo(w,
@@ -90,3 +91,11 @@ func (h *AccessLogHandler) set(w http.ResponseWriter, r *http.Request) {
 		"",
 		nil)
 }
+
+//NewAccessHandler accessHandler
+func NewAccessHandler(factory *goku_handler.AccountHandlerFactory) http.Handler {
+	return &LogHandler{
+		getHandler: factory.NewAccountHandleFunction(operationLog, false, AccessLogGet),
+		setHandler: factory.NewAccountHandleFunction(operationLog, true, AccessLogSet),
+	}
+}

console/controller/config-log/handle.go

 package config_log
 
 import (
-	"fmt"
 	"net/http"
-	"strings"
 
-	module "github.com/eolinker/goku-api-gateway/console/module/config-log"
+	goku_handler "github.com/eolinker/goku-api-gateway/goku-handler"
 )
 
-//Handle handle
-func Handle(prefix string) http.Handler {
+const operationLog = "logManagement"
 
-	pre := strings.TrimSuffix(prefix, "/")
-	serveMux := http.NewServeMux()
-	consoleLogHandler := &LogHandler{
-		name: module.ConsoleLog,
-	}
+//Handlers handlers
+type Handlers struct {
+}
 
-	serveMux.Handle(fmt.Sprintf("%s/%s", pre, "console"), consoleLogHandler)
-	nodeLogHandler := &LogHandler{
-		name: module.NodeLog,
+//Handlers handlers
+func (h *Handlers) Handlers(factory *goku_handler.AccountHandlerFactory) map[string]http.Handler {
+	return map[string]http.Handler{
+		"/console": NewLogHandler("console", factory),
+		"/node":    NewLogHandler("node", factory),
+		"/access":  NewAccessHandler(factory),
 	}
-	serveMux.Handle(fmt.Sprintf("%s/%s", pre, "node"), nodeLogHandler)
-
-	accessLogHandler := &AccessLogHandler{}
-
-	serveMux.Handle(fmt.Sprintf("%s/%s", pre, "access"), accessLogHandler)
-
-	return serveMux
+}
 
+//NewHandlers new handlers
+func NewHandlers() *Handlers {
+	return &Handlers{}
 }

console/controller/config-log/log.go

@@ -4,39 +4,20 @@ import (
 	"fmt"
 	"net/http"
 
+	goku_handler "github.com/eolinker/goku-api-gateway/goku-handler"
+
 	"github.com/eolinker/goku-api-gateway/common/auto-form"
 	"github.com/eolinker/goku-api-gateway/console/controller"
 	module "github.com/eolinker/goku-api-gateway/console/module/config-log"
 )
 
-//LogHandler 日志处理器
-type LogHandler struct {
+//LogHandlerGet 日志配置获取处理器
+type LogHandlerGet struct {
 	name string
 }
 
-func (h *LogHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	_, err := controller.CheckLogin(w, r, controller.OperationGatewayConfig, controller.OperationEDIT)
-	if err != nil {
-		return
-	}
-
-	switch r.Method {
-	case http.MethodGet:
-		{
-			h.get(w, r)
-
-		}
+func (h *LogHandlerGet) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 
-	case http.MethodPut:
-		{
-			h.set(w, r)
-
-		}
-	default:
-		w.WriteHeader(404)
-	}
-}
-func (h *LogHandler) get(w http.ResponseWriter, r *http.Request) {
 	config, e := module.Get(h.name)
 	if e = r.ParseForm(); e != nil {
 		controller.WriteError(w, "270000", "data", "[Get]未知错误："+e.Error(), e)
@@ -50,7 +31,12 @@ func (h *LogHandler) get(w http.ResponseWriter, r *http.Request) {
 
 }
 
-func (h *LogHandler) set(w http.ResponseWriter, r *http.Request) {
+//LogHandlerSet 设置日志处理器
+type LogHandlerSet struct {
+	name string
+}
+
+func (h *LogHandlerSet) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 
 	err := r.ParseForm()
 	if err = r.ParseForm(); err != nil {
@@ -83,7 +69,7 @@ func (h *LogHandler) set(w http.ResponseWriter, r *http.Request) {
 	}
 	err = module.Set(h.name, paramBase)
 	if err != nil {
-		controller.WriteError(w, "260000", "data", fmt.Sprintf("[mysql_error] %s", err.Error()), err)
+		controller.WriteError(w, "260000", "data", fmt.Sprintf("[db_error] %s", err.Error()), err)
 		return
 	}
 	controller.WriteResultInfo(w,
@@ -91,3 +77,11 @@ func (h *LogHandler) set(w http.ResponseWriter, r *http.Request) {
 		"",
 		nil)
 }
+
+//NewLogHandler 日志handler
+func NewLogHandler(name string, factory *goku_handler.AccountHandlerFactory) http.Handler {
+	return &LogHandler{
+		getHandler: factory.NewAccountHandler(operationLog, false, &LogHandlerGet{name: name}),
+		setHandler: factory.NewAccountHandler(operationLog, true, &LogHandlerSet{name: name}),
+	}
+}

console/controller/discovery/add.go

@@ -2,27 +2,24 @@ package discovery
 
 import (
 	"fmt"
+	"github.com/eolinker/goku-api-gateway/console/controller"
 	"net/http"
 
 	"github.com/eolinker/goku-api-gateway/common/auto-form"
-	"github.com/eolinker/goku-api-gateway/console/controller"
 	"github.com/eolinker/goku-api-gateway/console/module/service"
 	driver2 "github.com/eolinker/goku-api-gateway/server/driver"
 )
 
 func add(w http.ResponseWriter, r *http.Request) {
-	_, err := controller.CheckLogin(w, r, controller.OperationLoadBalance, controller.OperationEDIT)
-	if err != nil {
-		return
-	}
 
-	if err = r.ParseForm(); err != nil {
+
+	if err := r.ParseForm(); err != nil {
 		controller.WriteError(w, "260000", "data", "[param_check] Parse form body error | 解析form表单参数错误", err)
 		return
 	}
 
 	param := new(service.AddParam)
-	err = auto.SetValues(r.PostForm, param)
+	err := auto.SetValues(r.PostForm, param)
 	if err != nil {
 		controller.WriteError(w, "260000", "data", fmt.Sprintf("[param_check] %s", err.Error()), err)
 		return

console/controller/discovery/default.go

@@ -2,19 +2,16 @@ package discovery
 
 import (
 	"fmt"
+	"github.com/eolinker/goku-api-gateway/console/controller"
 	"net/http"
 
-	"github.com/eolinker/goku-api-gateway/console/controller"
 	"github.com/eolinker/goku-api-gateway/console/module/service"
 )
 
 func setDefault(w http.ResponseWriter, r *http.Request) {
 
-	_, err := controller.CheckLogin(w, r, controller.OperationLoadBalance, controller.OperationEDIT)
-	if err != nil {
-		return
-	}
-	if err != r.ParseForm() {
+
+	if err := r.ParseForm() ; err!= nil{
 		controller.WriteError(w, "260000", "data", "[param_check] Parse form body error | 解析form表单参数错误", err)
 		return
 	}
@@ -24,7 +21,7 @@ func setDefault(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	err = service.SetDefaut(name)
+	err := service.SetDefaut(name)
 	if err != nil {
 		controller.WriteError(w, "260000", "data", fmt.Sprintf("[error] %s", err.Error()), err)
 		return

console/controller/discovery/delete.go

@@ -2,21 +2,16 @@ package discovery
 
 import (
 	"fmt"
-	"net/http"
-	"strings"
-
-	dao_service2 "github.com/eolinker/goku-api-gateway/server/dao/console-sqlite3/dao-service"
-
 	"github.com/eolinker/goku-api-gateway/console/controller"
 	"github.com/eolinker/goku-api-gateway/console/module/service"
+	dao_service2 "github.com/eolinker/goku-api-gateway/server/dao/console-sqlite3/dao-service"
+	"net/http"
+	"strings"
 )
 
 func delete(w http.ResponseWriter, r *http.Request) {
-	_, err := controller.CheckLogin(w, r, controller.OperationLoadBalance, controller.OperationEDIT)
-	if err != nil {
-		return
-	}
-	if err != r.ParseForm() {
+
+	if err := r.ParseForm() ; err!= nil{
 		controller.WriteError(w, "260000", "serviceDiscovery", "[param_check] Parse form body error | 解析form表单参数错误", err)
 		return
 	}
@@ -24,7 +19,7 @@ func delete(w http.ResponseWriter, r *http.Request) {
 
 	names := strings.Split(nameStr, ",")
 
-	err = service.Delete(names)
+	err := service.Delete(names)
 
 	if err != nil {
 		if en, ok := err.(dao_service2.DeleteError); ok {

console/controller/discovery/driver.go

 package discovery
 
 import (
-	"net/http"
-
 	"github.com/eolinker/goku-api-gateway/console/controller"
 	driver2 "github.com/eolinker/goku-api-gateway/server/driver"
+	"net/http"
 )
 
 func getDrivices(w http.ResponseWriter, r *http.Request) {
 
 	ds := driver2.GetByType(driver2.Discovery)
-	_, err := controller.CheckLogin(w, r, controller.OperationLoadBalance, controller.OperationREAD)
-	if err != nil {
-		return
-	}
-
 	controller.WriteResultInfo(w, "serviceDiscovery", "data", ds)
 
 }

console/controller/discovery/edit.go

@@ -2,26 +2,22 @@ package discovery
 
 import (
 	"fmt"
-	"net/http"
-
 	"github.com/eolinker/goku-api-gateway/common/auto-form"
 	"github.com/eolinker/goku-api-gateway/console/controller"
 	"github.com/eolinker/goku-api-gateway/console/module/service"
 	driver2 "github.com/eolinker/goku-api-gateway/server/driver"
+	"net/http"
 )
 
 func edit(w http.ResponseWriter, r *http.Request) {
-	_, err := controller.CheckLogin(w, r, controller.OperationLoadBalance, controller.OperationEDIT)
-	if err != nil {
-		return
-	}
-	if err != r.ParseForm() {
+
+	if err := r.ParseForm() ; err!= nil{
 		controller.WriteError(w, "260000", "serviceDiscovery", "[param_check] Parse form body error | 解析form表单参数错误", err)
 		return
 	}
 
 	param := new(service.AddParam)
-	err = auto.SetValues(r.PostForm, param)
+	err := auto.SetValues(r.PostForm, param)
 	if err != nil {
 		controller.WriteError(w, "260000", "data", fmt.Sprintf("[param_check] %s", err.Error()), err)
 		return

console/controller/discovery/get.go

@@ -2,17 +2,13 @@ package discovery
 
 import (
 	"fmt"
-	"net/http"
-
 	"github.com/eolinker/goku-api-gateway/console/controller"
 	"github.com/eolinker/goku-api-gateway/console/module/service"
+	"net/http"
 )
 
 func getInfo(w http.ResponseWriter, r *http.Request) {
-	_, err := controller.CheckLogin(w, r, controller.OperationLoadBalance, controller.OperationREAD)
-	if err != nil {
-		return
-	}
+
 
 	name := r.URL.Query().Get("name")
 	if !service.ValidateName(name) {

console/controller/discovery/handle.go

@@ -2,24 +2,31 @@ package discovery
 
 import (
 	"net/http"
-)
-
-//Handle 服务发现处理器
-func Handle(prefix string) http.Handler {
-
-	serveMux := http.NewServeMux()
-	serveMux.HandleFunc("/drivers", getDrivices)
-
-	serveMux.HandleFunc("/add", add)
-	serveMux.HandleFunc("/delete", delete)
-	serveMux.HandleFunc("/save", edit)
-	serveMux.HandleFunc("/info", getInfo)
 
-	serveMux.HandleFunc("/simple", simple)
-	serveMux.HandleFunc("/list", list)
+	goku_handler "github.com/eolinker/goku-api-gateway/goku-handler"
+)
 
-	serveMux.HandleFunc("/default", setDefault)
+//Handlers handlers
+type Handlers struct {
+}
 
-	return http.StripPrefix(prefix, serveMux)
+//Handlers handlers
+func (h *Handlers) Handlers(factory *goku_handler.AccountHandlerFactory) map[string]http.Handler {
+	return map[string]http.Handler{
+		"/add":     factory.NewAccountHandleFunction(operationDiscovery, true, add),
+		"/save":    factory.NewAccountHandleFunction(operationDiscovery, true, edit),
+		"/delete":  factory.NewAccountHandleFunction(operationDiscovery, true, delete),
+		"/info":    factory.NewAccountHandleFunction(operationDiscovery, false, getInfo),
+		"/list":    factory.NewAccountHandleFunction(operationDiscovery, false, list),
+		"/default": factory.NewAccountHandleFunction(operationDiscovery, true, setDefault),
+		"/drivers": factory.NewAccountHandleFunction(operationDiscovery, false, getDrivices),
+		"/simple":  factory.NewAccountHandleFunction(operationDiscovery, false, simple),
+	}
+}
 
+//NewHandlers new handlers
+func NewHandlers() *Handlers {
+	return &Handlers{}
 }
+
+const operationDiscovery = "balanceManagement"

console/controller/discovery/list.go

 package discovery
 
 import (
-	"net/http"
-
 	"github.com/eolinker/goku-api-gateway/console/controller"
 	"github.com/eolinker/goku-api-gateway/console/module/service"
+	"net/http"
 )
 
 func list(w http.ResponseWriter, r *http.Request) {
-	_, err := controller.CheckLogin(w, r, controller.OperationLoadBalance, controller.OperationREAD)
-	if err != nil {
-		return
-	}
 
 	_ = r.ParseForm()
 

console/controller/discovery/simple.go

 package discovery
 
 import (
+	"github.com/eolinker/goku-api-gateway/console/controller"
 	"net/http"
 
-	"github.com/eolinker/goku-api-gateway/console/controller"
 	"github.com/eolinker/goku-api-gateway/console/module/service"
 )
 
 func simple(w http.ResponseWriter, r *http.Request) {
-	_, err := controller.CheckLogin(w, r, controller.OperationLoadBalance, controller.OperationREAD)
-	if err != nil {
-		return
-	}
+
 
 	vs, def, err := service.SimpleList()
 	if err != nil {

console/controller/gateway/gateway.go

@@ -4,16 +4,32 @@ import (
 	"encoding/json"
 	"net/http"
 
+	goku_handler "github.com/eolinker/goku-api-gateway/goku-handler"
+
 	"github.com/eolinker/goku-api-gateway/console/controller"
 	"github.com/eolinker/goku-api-gateway/console/module/gateway"
 )
 
+const operationGateway = "gateway"
+
+//Handlers hendlers
+type Handlers struct {
+}
+
+//Handlers handlers
+func (h *Handlers) Handlers(factory *goku_handler.AccountHandlerFactory) map[string]http.Handler {
+	return map[string]http.Handler{
+		"/getSummaryInfo": factory.NewAccountHandleFunction(operationGateway, false, GetGatewayBasicInfo),
+	}
+}
+
+//NewHandlers new handlers
+func NewHandlers() *Handlers {
+	return &Handlers{}
+}
+
 //GetGatewayBasicInfo 获取网关基本信息
 func GetGatewayBasicInfo(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	_, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationNone, controller.OperationREAD)
-	if e != nil {
-		return
-	}
 
 	flag, result, err := gateway.GetGatewayMonitorSummaryByPeriod()
 	if !flag {

console/controller/monitor/module.go

@@ -4,19 +4,36 @@ import (
 	"net/http"
 	"strconv"
 
+	goku_handler "github.com/eolinker/goku-api-gateway/goku-handler"
+	"github.com/eolinker/goku-api-gateway/ksitigarbha"
+
 	"github.com/pkg/errors"
 
 	"github.com/eolinker/goku-api-gateway/console/controller"
 	"github.com/eolinker/goku-api-gateway/console/module/monitor"
 )
 
-//GetMonitorModules 获取监控模块列表
-func GetMonitorModules(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	_, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationNone, controller.OperationREAD)
-	if e != nil {
-		return
+const operationMonitorModule = "monitorModuleManagement"
+
+//Handlers handlers
+type Handlers struct {
+}
+
+//Handlers handlers
+func (h *Handlers) Handlers(factory *goku_handler.AccountHandlerFactory) map[string]http.Handler {
+	return map[string]http.Handler{
+		"/get": factory.NewAccountHandleFunction(operationMonitorModule, false, GetMonitorModules),
+		"/set": factory.NewAccountHandleFunction(operationMonitorModule, true, SetMonitorModule),
 	}
+}
 
+//NewHandlers new handlers
+func NewHandlers() *Handlers {
+	return &Handlers{}
+}
+
+//GetMonitorModules 获取监控模块列表
+func GetMonitorModules(httpResponse http.ResponseWriter, httpRequest *http.Request) {
 	result, err := monitor.GetMonitorModules()
 	if err != nil {
 		controller.WriteError(httpResponse,
@@ -25,18 +42,14 @@ func GetMonitorModules(httpResponse http.ResponseWriter, httpRequest *http.Reque
 			err.Error(),
 			err)
 		return
-
 	}
 
 	controller.WriteResultInfo(httpResponse, "monitorModule", "moduleList", result)
 	return
 }
 
+//SetMonitorModule 设置监控模块
 func SetMonitorModule(httpResponse http.ResponseWriter, httpRequest *http.Request) {
-	_, e := controller.CheckLogin(httpResponse, httpRequest, controller.OperationNone, controller.OperationREAD)
-	if e != nil {
-		return
-	}
 	httpRequest.ParseForm()
 	moduleName := httpRequest.Form.Get("moduleName")
 	moduleStatus := httpRequest.Form.Get("moduleStatus")
@@ -62,7 +75,11 @@ func SetMonitorModule(httpResponse http.ResponseWriter, httpRequest *http.Reques
 			err)
 		return
 	}
-
+	if status == 1 {
+		ksitigarbha.Open(moduleName, config)
+	} else {
+		ksitigarbha.Close(moduleName)
+	}
 	controller.WriteResultInfo(httpResponse, "monitorModule", "", nil)
 	return
 }

console/controller/reg.go

+// 控制台模块注册文件
+package controller
+
+