初始化

application/auth/factory.go

@@ -43,7 +43,7 @@ type driverRegister struct {
 	render      map[string]interface{}
 }
 
-func (dm *driverRegister) Check(cfg interface{}) (id, profession, name, driver, desc string, err error) {
+func (dm *driverRegister) Check(cfg interface{}) (profession, name, driver, desc string, err error) {
 	return
 }
 

drivers/plugin-manager/manager.go

@@ -29,7 +29,7 @@ type PluginManager struct {
 	workers         eosc.IWorkers
 }
 
-func (p *PluginManager) Check(cfg interface{}) (id, profession, name, driver, desc string, err error) {
+func (p *PluginManager) Check(cfg interface{}) (profession, name, driver, desc string, err error) {
 	err = eosc.ErrorUnsupportedKind
 	return
 }

drivers/strategy/limiting-stragety/actuator.go

@@ -0,0 +1,43 @@
+package limiting_stragety
+
+import (
+	"github.com/eolinker/apinto/strategy"
+	"github.com/eolinker/eosc/eocontext"
+)
+
+var (
+	actuatorSet     ActuatorSet
+	actuatorHandler strategy.IStrategyHandler
+)
+
+func init() {
+	actuator := newActuator()
+	actuatorSet = actuator
+
+	strategy.AddStrategyHandler(actuatorHandler)
+}
+
+type ActuatorSet interface {
+	Set(id string, limiting *Limiting)
+	Del(id string)
+}
+
+type tActuator struct {
+}
+
+func (a *tActuator) Set(id string, limiting *Limiting) {
+
+}
+
+func (a *tActuator) Del(id string) {
+
+}
+
+func newActuator() *tActuator {
+	return &tActuator{}
+}
+
+func (a *tActuator) Strategy(ctx eocontext.EoContext, next eocontext.IChain) error {
+	//TODO implement me
+	panic("implement me")
+}

drivers/strategy/limiting-stragety/config.go

@@ -3,16 +3,22 @@ package limiting_stragety
 import "github.com/eolinker/apinto/strategy"
 
 type Threshold struct {
-	Second int64 `json:"second" label`
-	Minute int64 `json:"minute"`
-	Hour   int64 `json:"hour"`
+	Second int64 `json:"second" label:"每秒限制"`
+	Minute int64 `json:"minute" label:"每分钟限制"`
+	Hour   int64 `json:"hour" label:"每小时限制"`
 }
 type Rule struct {
-	Metrics []string  `json:"metrics" `
-	Query   Threshold `json:"query" `
-	Traffic Threshold `json:"traffic"`
+	Metrics []string  `json:"metrics" label:"限流计数器名"`
+	Query   Threshold `json:"query" label:"请求限制" description:"按请求次数"`
+	Traffic Threshold `json:"traffic" label:"流量限制" description:"按请求内容大小"`
 }
 type Config struct {
-	Filters strategy.FilterConfig `json:"filters"`
-	Rule    Rule                  `json:"limiting"`
+	Profession  string                `json:"profession" skip:"skip"`
+	Name        string                `json:"name" skip:"skip"`
+	Driver      string                `json:"driver" skip:"skip"`
+	Description string                `json:"description" skip:"skip"`
+	Priority    int                   `json:"priority" label:"优先级" description:"1-999"`
+	Filters     strategy.FilterConfig `json:"filters" label:"过滤规则"`
+
+	Rule Rule `json:"limiting" label:"限流规则" description:"限流规则"`
 }

drivers/strategy/limiting-stragety/controller.go

@@ -0,0 +1,83 @@
+package limiting_stragety
+
+import (
+	"github.com/eolinker/eosc"
+	"reflect"
+)
+
+var (
+	controller               = NewController()
+	_          eosc.ISetting = controller
+	_          IController   = controller
+)
+
+type IController interface {
+	Store(id string)
+	Del(id string)
+}
+type Controller struct {
+	all map[string]struct{}
+}
+
+func (c *Controller) Store(id string) {
+	c.all[id] = struct{}{}
+}
+
+func (c *Controller) Del(id string) {
+	delete(c.all, id)
+}
+
+func (c *Controller) ConfigType() reflect.Type {
+	return configType
+}
+
+func (c *Controller) Set(conf interface{}) (err error) {
+	return eosc.ErrorUnsupportedKind
+}
+
+func (c *Controller) Get() interface{} {
+	return nil
+}
+
+func (c *Controller) Mode() eosc.SettingMode {
+	return eosc.SettingModeBatch
+}
+
+func (c *Controller) Check(cfg interface{}) (profession, name, driver, desc string, err error) {
+	conf, ok := cfg.(*Config)
+	if !ok {
+		err = eosc.ErrorConfigIsNil
+		return
+	}
+	if empty(conf.Name, conf.Driver, conf.Profession) {
+		err = eosc.ErrorConfigFieldUnknown
+		return
+	}
+	err = checkConfig(conf)
+	if err != nil {
+		return
+	}
+	return conf.Profession, conf.Name, conf.Driver, conf.Description, nil
+
+}
+func empty(vs ...string) bool {
+	for _, v := range vs {
+		if len(v) == 0 {
+			return false
+		}
+	}
+	return true
+}
+func (c *Controller) AllWorkers() []string {
+	ws := make([]string, 0, len(c.all))
+	for id := range c.all {
+		ws = append(ws, id)
+	}
+	return ws
+}
+
+func NewController() *Controller {
+	return &Controller{
+		all: map[string]struct{}{},
+	}
+}

drivers/strategy/limiting-stragety/driver.go

@@ -1,13 +1,13 @@
 package limiting_stragety
 
 import (
+	"fmt"
 	"github.com/eolinker/apinto/strategy"
 	"github.com/eolinker/eosc"
 	"reflect"
 )
 
 type driver struct {
-	configType reflect.Type
 }
 
 func (d *driver) Check(v interface{}, workers map[eosc.RequireId]eosc.IWorker) error {
@@ -15,7 +15,15 @@ func (d *driver) Check(v interface{}, workers map[eosc.RequireId]eosc.IWorker) e
 	if !ok {
 		return eosc.ErrorConfigIsNil
 	}
-	_, err := strategy.ParseFilter(cfg.Filters)
+
+	return checkConfig(cfg)
+}
+
+func checkConfig(conf *Config) error {
+	if conf.Priority > 999 || conf.Priority < 1 {
+		return fmt.Errorf("priority value %d not allow ", conf.Priority)
+	}
+	_, err := strategy.ParseFilter(conf.Filters)
 	if err != nil {
 		return err
 	}
@@ -24,11 +32,18 @@ func (d *driver) Check(v interface{}, workers map[eosc.RequireId]eosc.IWorker) e
 }
 
 func (d *driver) ConfigType() reflect.Type {
-	return d.configType
+	return configType
 }
 
 func (d *driver) Create(id, name string, v interface{}, workers map[eosc.RequireId]eosc.IWorker) (eosc.IWorker, error) {
-	return &Limiting{
-		id: id,
-	}, nil
+	if err := d.Check(v, workers); err != nil {
+		return nil, err
+	}
+
+	lg := &Limiting{
+		id:   id,
+		name: Name,
+	}
+	controller.Store(id)
+	return lg, nil
 }

drivers/strategy/limiting-stragety/factory.go

@@ -2,23 +2,36 @@ package limiting_stragety
 
 import (
 	"github.com/eolinker/eosc"
+	"github.com/eolinker/eosc/setting"
+	"github.com/eolinker/eosc/utils/schema"
 	"reflect"
 )
 
 const Name = "strategy-limiting"
 
+var (
+	configType = reflect.TypeOf((*Config)(nil))
+)
+
 //Register 注册http路由驱动工厂
 func Register(register eosc.IExtenderDriverRegister) {
+
 	register.RegisterExtenderDriver(Name, newFactory())
+	setting.RegisterSetting("strategies-limiting", NewController())
 }
 
 type factory struct {
-	configType reflect.Type
-	render     interface{}
+	render interface{}
 }
 
 func newFactory() *factory {
-	return &factory{}
+	render, err := schema.Generate(configType, nil)
+	if err != nil {
+		panic(err)
+	}
+	return &factory{
+		render: render,
+	}
 }
 
 func (f *factory) Render() interface{} {
@@ -26,5 +39,5 @@ func (f *factory) Render() interface{} {
 }
 
 func (f *factory) Create(profession string, name string, label string, desc string, params map[string]interface{}) (eosc.IExtenderDriver, error) {
-	return &driver{configType: f.configType}, nil
+	return &driver{}, nil
 }

drivers/strategy/limiting-stragety/limiting.go

@@ -5,17 +5,28 @@ import (
 	"github.com/eolinker/eosc"
 )
 
+var (
+	_ eosc.IWorker        = (*Limiting)(nil)
+	_ eosc.IWorkerDestroy = (*Limiting)(nil)
+)
+
 type Limiting struct {
 	id     string
 	name   string
 	filter strategy.IFilter
 }
 
+func (l *Limiting) Destroy() error {
+	controller.Del(l.id)
+	return nil
+}
+
 func (l *Limiting) Id() string {
 	return l.id
 }
 
 func (l *Limiting) Start() error {
+	actuatorSet.Set(l.id, l)
 	return nil
 }
 
@@ -24,6 +35,7 @@ func (l *Limiting) Reset(conf interface{}, workers map[eosc.RequireId]eosc.IWork
 }
 
 func (l *Limiting) Stop() error {
+	actuatorSet.Del(l.id)
 	return nil
 }
 

strategy/manager.go

@@ -1,5 +1,16 @@
 package strategy
 
+import eoscContext "github.com/eolinker/eosc/eocontext"
+
 type IStrategyManager interface {
-	Set(name string, filter IFilter)
+	AddStrategyHandler(handler IStrategyHandler)
+}
+
+func AddStrategyHandler(handler IStrategyHandler) {
+
+}
+
+func Strategy(ctx eoscContext.EoContext, next eoscContext.IChain) error {
+
+	return nil
 }

strategy/strategy.go

@@ -6,10 +6,6 @@ type IStrategyHandler interface {
 	Strategy(ctx eoscContext.EoContext, next eoscContext.IChain) error
 }
 
-func Strategy(ctx eoscContext.EoContext, next eoscContext.IChain) error {
-	return nil
-}
-
 type IFilter interface {
 	Check(ctx eoscContext.EoContext) bool
 }