切换gorilla/mux，编译结果减少10MB，更轻量

go.mod

@@ -4,43 +4,18 @@ go 1.13
 
 require (
 	git.zgwit.com/iot/beeq v0.0.7
-	github.com/ajg/form v1.5.1 // indirect
-	github.com/andybalholm/brotli v1.0.1-0.20200619015827-c3da72aa01ed // indirect
+	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/denisbrodbeck/machineid v1.0.1
-	github.com/fasthttp-contrib/websocket v0.0.0-20160511215533-1f3b11f56072 // indirect
 	github.com/go-sql-driver/mysql v1.5.0
 	github.com/golang/snappy v0.0.1 // indirect
-	github.com/google/go-querystring v1.0.0 // indirect
-	github.com/gorilla/websocket v1.4.2 // indirect
-	github.com/imkira/go-interpol v1.1.0 // indirect
-	github.com/iris-contrib/jade v1.1.4 // indirect
-	github.com/iris-contrib/schema v0.0.2 // indirect
-	github.com/json-iterator/go v1.1.10 // indirect
-	github.com/k0kubun/colorstring v0.0.0-20150214042306-9440f1994b88 // indirect
-	github.com/kataras/golog v0.0.18 // indirect
-	github.com/kataras/iris/v12 v12.1.8
-	github.com/klauspost/compress v1.10.10 // indirect
-	github.com/mattn/go-colorable v0.1.8 // indirect
-	github.com/microcosm-cc/bluemonday v1.0.3 // indirect
-	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
-	github.com/modern-go/reflect2 v1.0.1 // indirect
-	github.com/moul/http2curl v1.0.0 // indirect
-	github.com/sergi/go-diff v1.1.0 // indirect
-	github.com/shurcooL/sanitized_anchor_name v1.0.0 // indirect
-	github.com/smartystreets/goconvey v1.6.4 // indirect
+	github.com/gorilla/mux v1.8.0
+	github.com/kr/pretty v0.1.0 // indirect
 	github.com/stretchr/testify v1.6.1 // indirect
-	github.com/valyala/fasthttp v1.16.0 // indirect
-	github.com/xeipuuv/gojsonschema v1.2.0 // indirect
-	github.com/yalp/jsonpath v0.0.0-20180802001716-5cc68e5049a0 // indirect
-	github.com/yudai/gojsondiff v1.0.0 // indirect
-	github.com/yudai/golcs v0.0.0-20170316035057-ecda9a501e82 // indirect
-	github.com/yudai/pp v2.0.1+incompatible // indirect
-	golang.org/x/crypto v0.0.0-20200728195943-123391ffb6de // indirect
 	golang.org/x/net v0.0.0-20200822124328-c89045814202
 	golang.org/x/sys v0.0.0-20200908134130-d2e65c121b96 // indirect
 	golang.org/x/text v0.3.3 // indirect
 	google.golang.org/protobuf v1.25.0 // indirect
-	gopkg.in/ini.v1 v1.57.0 // indirect
+	gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 // indirect
 	gopkg.in/yaml.v2 v2.2.8
 	gopkg.in/yaml.v3 v3.0.0-20200615113413-eeeca48fe776 // indirect
 	xorm.io/xorm v1.0.5

models/project.go

@@ -11,9 +11,9 @@ type Project struct {
 
 	Version  string    `json:"version"`
 	Disabled bool      `json:"disabled"`
+
 	Created  time.Time `json:"created" xorm:"created"`
 	Updated  time.Time `json:"updated" xorm:"updated"`
-	Deployed time.Time `json:"deployed"` //如果 deployed < updated，说明有更新，提示重新部署
 }
 
 type ProjectElement struct {

web/api/curd.go

 package api
 
 import (
+	"encoding/json"
 	"git.zgwit.com/zgwit/iot-admin/db"
-	"github.com/kataras/iris/v12"
+	"github.com/gorilla/mux"
+	"io/ioutil"
+	"net/http"
 	"reflect"
+	"strconv"
 )
 
 type hook func(value interface{}) error
@@ -18,14 +22,24 @@ func createSliceFromType(mod reflect.Type) interface{} {
 	return ptr.Interface()
 }
 
-func curdApiList(mod reflect.Type) iris.Handler {
-	return func(ctx iris.Context) {
+func parseBody(request *http.Request, data interface{}) error  {
+	body, err := ioutil.ReadAll(request.Body)
+	if err != nil {
+		return err
+	}
+	return json.Unmarshal(body, data)
+}
+
+type Handler func(writer http.ResponseWriter, request *http.Request)
+
+func curdApiList(mod reflect.Type) Handler {
+	return func(writer http.ResponseWriter, request *http.Request) {
 		datas := createSliceFromType(mod)
 
 		var body paramSearch
-		err := ctx.ReadJSON(&body)
+		err := parseBody(request, &body)
 		if err != nil {
-			replyError(ctx, err)
+			replyError(writer, err)
 			return
 		}
 
@@ -56,33 +70,29 @@ func curdApiList(mod reflect.Type) iris.Handler {
 		}
 		cnt, err := op.FindAndCount(datas)
 		if err != nil {
-			replyError(ctx, err)
+			replyError(writer, err)
 			return
 		}
 
 		//replyOk(ctx, cs)
-		ctx.JSON(iris.Map{
-			"ok":    true,
-			"data":  datas,
-			"total": cnt,
-		})
+		replyList(writer, datas, cnt)
 	}
 }
 
-func curdApiListById(mod reflect.Type, field string) iris.Handler {
-	return func(ctx iris.Context) {
+func curdApiListById(mod reflect.Type, field string) Handler {
+	return func(writer http.ResponseWriter, request *http.Request) {
 		datas := createSliceFromType(mod)
 
-		id, err := ctx.URLParamInt64("id")
+		id, err := strconv.ParseInt(mux.Vars(request)["id"], 10, 64)
 		if err != nil {
-			replyError(ctx, err)
+			replyError(writer, err)
 			return
 		}
 
 		var body paramSearch
-		err = ctx.ReadJSON(&body)
+		err = parseBody(request, &body)
 		if err != nil {
-			replyError(ctx, err)
+			replyError(writer, err)
 			return
 		}
 
@@ -113,120 +123,116 @@ func curdApiListById(mod reflect.Type, field string) iris.Handler {
 		}
 		cnt, err := op.FindAndCount(datas)
 		if err != nil {
-			replyError(ctx, err)
+			replyError(writer, err)
 			return
 		}
 
 		//replyOk(ctx, cs)
-		ctx.JSON(iris.Map{
-			"ok":    true,
-			"data":  datas,
-			"total": cnt,
-		})
+		replyList(writer, datas, cnt)
 	}
 }
 
-func curdApiCreate(mod reflect.Type, after hook) iris.Handler {
-	return func(ctx iris.Context) {
+func curdApiCreate(mod reflect.Type, after hook) Handler {
+	return func(writer http.ResponseWriter, request *http.Request) {
 		data := reflect.New(mod).Interface()
-		if err := ctx.ReadJSON(data); err != nil {
-			replyError(ctx, err)
+		if err := parseBody(request, data); err != nil {
+			replyError(writer, err)
 			return
 		}
 
 		_, err := db.Engine.Insert(data)
 		if err != nil {
-			replyError(ctx, err)
+			replyError(writer, err)
 			return
 		}
 
 		if after != nil {
 			err = after(data)
 			if err != nil {
-				replyError(ctx, err)
+				replyError(writer, err)
 				return
 			}
 		}
 
-		replyOk(ctx, data)
+		replyOk(writer, data)
 	}
 }
 
-func curdApiModify(mod reflect.Type, updateFields []string, after hook) iris.Handler {
-	return func(ctx iris.Context) {
-		id, err := ctx.URLParamInt64("id")
+func curdApiModify(mod reflect.Type, updateFields []string, after hook) Handler {
+	return func(writer http.ResponseWriter, request *http.Request) {
+		id, err := strconv.ParseInt(mux.Vars(request)["id"], 10, 64)
 		if err != nil {
-			replyError(ctx, err)
+			replyError(writer, err)
 			return
 		}
 
 		data := reflect.New(mod).Interface()
-		if err := ctx.ReadJSON(data); err != nil {
-			replyError(ctx, err)
+		if err := parseBody(request, data); err != nil {
+			replyError(writer, err)
 			return
 		}
 
 		_, err = db.Engine.ID(id).Cols(updateFields...).Update(data)
 		if err != nil {
-			replyError(ctx, err)
+			replyError(writer, err)
 			return
 		}
 
 		if after != nil {
 			err = after(data)
 			if err != nil {
-				replyError(ctx, err)
+				replyError(writer, err)
 				return
 			}
 		}
 
-		replyOk(ctx, data)
+		replyOk(writer, data)
 	}
 }
 
-func curdApiDelete(mod reflect.Type, after hook) iris.Handler {
-	return func(ctx iris.Context) {
-		id, err := ctx.URLParamInt64("id")
+func curdApiDelete(mod reflect.Type, after hook) Handler {
+	return func(writer http.ResponseWriter, request *http.Request) {
+		id, err := strconv.ParseInt(mux.Vars(request)["id"], 10, 64)
 		if err != nil {
-			replyError(ctx, err)
+			replyError(writer, err)
 			return
 		}
 
 		data := reflect.New(mod).Interface()
 		_, err = db.Engine.ID(id).Delete(data)
 		if err != nil {
-			replyError(ctx, err)
+			replyError(writer, err)
 			return
 		}
 
 		if after != nil {
 			err = after(data)
 			if err != nil {
-				replyError(ctx, err)
+				replyError(writer, err)
 				return
 			}
 		}
 
-		replyOk(ctx, nil)
+		replyOk(writer, nil)
 	}
 }
 
-func curdApiGet(mod reflect.Type) iris.Handler {
-	return func(ctx iris.Context) {
-		id, err := ctx.URLParamInt64("id")
+func curdApiGet(mod reflect.Type) Handler {
+	return func(writer http.ResponseWriter, request *http.Request) {
+		id, err := strconv.ParseInt(mux.Vars(request)["id"], 10, 64)
 		if err != nil {
-			replyError(ctx, err)
+			replyError(writer, err)
 			return
 		}
 		data := reflect.New(mod).Interface()
 		has, err := db.Engine.ID(id).Get(data)
 		if !has {
-			replyFail(ctx, "记录不存在")
+			replyFail(writer, "记录不存在")
 			return
 		} else if err != nil {
-			replyError(ctx, err)
+			replyError(writer, err)
 			return
 		}
-		replyOk(ctx, data)
+		replyOk(writer, data)
 	}
 }

web/api/project.go

 package api
 
 import (
-	"git.zgwit.com/zgwit/iot-admin/db"
-	"git.zgwit.com/zgwit/iot-admin/models"
-	"github.com/kataras/iris/v12"
+	"net/http"
 )
 
-func projectImport(ctx iris.Context) {
-	var model models.Template
+func projectImport(writer http.ResponseWriter, request *http.Request) {
 
-	err := ctx.ReadJSON(&model)
-	if err != nil {
-		replyError(ctx, err)
-		return
-	}
-
-	replyOk(ctx, nil)
 }
 
-func projectExport(ctx iris.Context) {
-	id, err := ctx.URLParamInt64("id")
-	if err != nil {
-		replyError(ctx, err)
-		return
-	}
-
-	var model models.Template
-	has, err := db.Engine.ID(id).Table("model").Get(&model)
-	if !has {
-		replyFail(ctx, "记录不存在")
-		return
-	}
-	if err != nil {
-		replyError(ctx, err)
-		return
-	}
-
-	//读取任务
-	err = db.Engine.Where("model_id=?", id).Find(&model.Jobs)
-	if err != nil {
-		replyError(ctx, err)
-		return
-	}
-
-	//读取策略
-	err = db.Engine.Where("model_id=?", id).Find(&model.Strategies)
-	if err != nil {
-		replyError(ctx, err)
-		return
-	}
+func projectExport(writer http.ResponseWriter, request *http.Request) {
 
-	replyOk(ctx, model)
 }
 
-func projectDeploy(ctx iris.Context) {
+func projectDeploy(writer http.ResponseWriter, request *http.Request) {
 
 }

web/api/router.go

 package api
 
 import (
+	"encoding/json"
 	"git.zgwit.com/zgwit/iot-admin/conf"
 	"git.zgwit.com/zgwit/iot-admin/models"
-	"github.com/kataras/iris/v12"
-	"github.com/kataras/iris/v12/middleware/basicauth"
-	"github.com/kataras/iris/v12/sessions"
+	"github.com/gorilla/mux"
+	"net/http"
 	"reflect"
 )
 
@@ -31,37 +31,37 @@ type paramId2 struct {
 	Id  int64 `uri:"id"`
 	Id2 int64 `uri:"id2"`
 }
-
-var (
-	cookieNameForSessionID ="iot-admin"
-	sess = sessions.New(sessions.Config{Cookie:cookieNameForSessionID})
-)
-
-func mustLogin(ctx iris.Context) {
-	session := sess.Start(ctx)
-	if user := session.Get("user"); user != nil {
-		ctx.Next()
-	} else {
-		//TODO 检查OAuth2返回的code，进一步获取用户信息，放置到session中
-
-		ctx.StatusCode(iris.StatusUnauthorized)
-		ctx.JSON(iris.Map{"ok": false, "error": "Unauthorized"})
-		//ctx.Abort()
-	}
-}
-
-func RegisterRoutes(app iris.Party) {
+//
+//var (
+//	cookieNameForSessionID = "iot-admin"
+//	sess                   = sessions.New(sessions.Config{Cookie: cookieNameForSessionID})
+//)
+//
+//func mustLogin(ctx iris.Context) {
+//	session := sess.Start(ctx)
+//	if user := session.Get("user"); user != nil {
+//		ctx.Next()
+//	} else {
+//		//TODO 检查OAuth2返回的code，进一步获取用户信息，放置到session中
+//
+//		ctx.StatusCode(iris.StatusUnauthorized)
+//		ctx.JSON(iris.Map{"ok": false, "error": "Unauthorized"})
+//		//ctx.Abort()
+//	}
+//}
+
+func RegisterRoutes(app *mux.Router) {
 
 	if conf.Config.SysAdmin.Enable {
 		//检查 session，必须登录
-		app.Use(mustLogin)
+		//app.Use(mustLogin)
 	} else if conf.Config.BaseAuth.Enable {
 		//检查HTTP认证
 		//app.Use(gin.BasicAuth(gin.Accounts(conf.Config.BaseAuth.Users)))
-		authConfig := basicauth.Config{
-			Users: conf.Config.BaseAuth.Users,
-		}
-		app.Use(basicauth.New(authConfig))
+		//authConfig := basicauth.Config{
+		//	Users: conf.Config.BaseAuth.Users,
+		//}
+		//app.Use(basicauth.New(authConfig))
 	} else {
 		//支持匿名访问
 	}
@@ -73,154 +73,174 @@ func RegisterRoutes(app iris.Party) {
 		"register_enable", "register_regex", "register_min", "register_max",
 		"heart_beat_enable", "heart_beat_interval", "heart_beat_content", "heart_beat_is_hex",
 		"disabled"}
-	app.Post("/project/:id/tunnels", curdApiListById(mod, "project_id"))
-	app.Post("/tunnels", curdApiList(mod))
-	app.Post("/tunnel", curdApiCreate(mod, nil))            //TODO 启动
-	app.Delete("/tunnel/:id", curdApiDelete(mod, nil))      //TODO 停止
-	app.Put("/tunnel/:id", curdApiModify(mod, fields, nil)) //TODO 重新启动
-	app.Get("/tunnel/:id", curdApiGet(mod))
+	app.HandleFunc("/project/:id/tunnels", curdApiListById(mod, "project_id")).Methods("POST")
+	app.HandleFunc("/tunnels", curdApiList(mod)).Methods("POST")
+	app.HandleFunc("/tunnel", curdApiCreate(mod, nil)).Methods("POST")            //TODO 启动
+	app.HandleFunc("/tunnel/:id", curdApiDelete(mod, nil)).Methods("DELETE")      //TODO 停止
+	app.HandleFunc("/tunnel/:id", curdApiModify(mod, fields, nil)).Methods("PUT") //TODO 重新启动
+	app.HandleFunc("/tunnel/:id", curdApiGet(mod)).Methods("GET")
 
-	app.Get("/tunnel/:id/start", tunnelStart)
-	app.Get("/tunnel/:id/stop", tunnelStop)
+	app.HandleFunc("/tunnel/:id/start", tunnelStart).Methods("GET")
+	app.HandleFunc("/tunnel/:id/stop", tunnelStop).Methods("GET")
 
-	//app.Post("/channel/:id/links")
+	//app.HandleFunc("/channel/:id/links")
 
 	//连接管理
 	mod = reflect.TypeOf(models.Link{})
 	fields = []string{"name"}
-	app.Post("/tunnel/:id/links", curdApiListById(mod, "tunnel_id"))
-	app.Post("/links", curdApiList(mod))
-	app.Delete("/link/:id", curdApiDelete(mod, nil)) //TODO 停止
-	app.Put("/link/:id", curdApiModify(mod, fields, nil))
-	app.Get("/link/:id", curdApiGet(mod))
+	app.HandleFunc("/tunnel/:id/links", curdApiListById(mod, "tunnel_id")).Methods("POST")
+	app.HandleFunc("/links", curdApiList(mod)).Methods("POST")
+	app.HandleFunc("/link/:id", curdApiDelete(mod, nil)).Methods("DELETE")    //TODO 停止
+	app.HandleFunc("/link/:id", curdApiModify(mod, fields, nil)).Methods("PUT")
+	app.HandleFunc("/link/:id", curdApiGet(mod)).Methods("GET")
 
 	mod = reflect.TypeOf(models.Device{})
 	fields = []string{"name"}
-	app.Post("/project/:id/devices", curdApiListById(mod, "project_id"))
-	app.Post("/devices", curdApiList(mod))
-	app.Post("/device", curdApiCreate(mod, nil))
-	app.Delete("/device/:id", curdApiDelete(mod, nil))
-	app.Put("/device/:id", curdApiModify(mod, fields, nil))
-	app.Get("/device/:id", curdApiGet(mod))
+	app.HandleFunc("/project/:id/devices", curdApiListById(mod, "project_id")).Methods("POST")
+	app.HandleFunc("/devices", curdApiList(mod)).Methods("POST")
+	app.HandleFunc("/device", curdApiCreate(mod, nil)).Methods("POST")
+	app.HandleFunc("/device/:id", curdApiDelete(mod, nil)).Methods("DELETE")
+	app.HandleFunc("/device/:id", curdApiModify(mod, fields, nil)).Methods("PUT")
+	app.HandleFunc("/device/:id", curdApiGet(mod)).Methods("GET")
 
 	mod = reflect.TypeOf(models.Location{})
 	fields = []string{"name"}
-	app.Post("/device/:id/locations", curdApiListById(mod, "device_id"))
-	//app.Post("/locations", curdApiList(mod))
-	//app.Post("/location", curdApiCreate(mod, nil))
-	app.Delete("/location/:id", curdApiDelete(mod, nil))
-	//app.Put("/location/:id", curdApiModify(mod, fields, nil))
-	app.Get("/location/:id", curdApiGet(mod))
+	app.HandleFunc("/device/:id/locations", curdApiListById(mod, "device_id")).Methods("POST")
+	//app.HandleFunc("/locations", curdApiList(mod)).Methods("POST")
+	//app.HandleFunc("/location", curdApiCreate(mod, nil)).Methods("POST")
+	app.HandleFunc("/location/:id", curdApiDelete(mod, nil)).Methods("DELETE")
+	//app.HandleFunc("/location/:id", curdApiModify(mod, fields, nil)).Methods("PUT")
+	app.HandleFunc("/location/:id", curdApiGet(mod)).Methods("GET")
 
 	//插件管理
 	mod = reflect.TypeOf(models.Plugin{})
 	fields = []string{"name"}
-	app.Post("/plugins", curdApiList(mod))
-	app.Post("/plugin", curdApiCreate(mod, nil))
-	app.Delete("/plugin/:id", curdApiDelete(mod, nil))
-	app.Put("/plugin/:id", curdApiModify(mod, fields, nil))
-	app.Get("/plugin/:id", curdApiGet(mod))
+	app.HandleFunc("/plugins", curdApiList(mod)).Methods("POST")
+	app.HandleFunc("/plugin", curdApiCreate(mod, nil)).Methods("POST")
+	app.HandleFunc("/plugin/:id", curdApiDelete(mod, nil)).Methods("DELETE")
+	app.HandleFunc("/plugin/:id", curdApiModify(mod, fields, nil)).Methods("PUT")
+	app.HandleFunc("/plugin/:id", curdApiGet(mod)).Methods("GET")
 
 	//模型管理
 	mod = reflect.TypeOf(models.Project{})
 	fields = []string{"name"}
-	app.Post("/projects", curdApiList(mod))
-	app.Post("/project", curdApiCreate(mod, nil))
-	app.Delete("/project/:id", curdApiDelete(mod, nil))
-	app.Put("/project/:id", curdApiModify(mod, fields, nil))
-	app.Get("/project/:id", curdApiGet(mod))
-
-	//app.Get("/project/:id/tunnels", nop)
-	//app.Get("/project/:id/variables", nop)
-	//app.Get("/project/:id/batches", nop)
-	//app.Get("/project/:id/jobs", nop)
-	//app.Get("/project/:id/strategies", nop)
-
-	app.Post("/project/import", projectImport)
-	app.Get("/project/:id/export", projectExport)
-	app.Get("/project/:id/deploy", projectDeploy)
-
-	
+	app.HandleFunc("/projects", curdApiList(mod)).Methods("POST")
+	app.HandleFunc("/project", curdApiCreate(mod, nil)).Methods("POST")
+	app.HandleFunc("/project/:id", curdApiDelete(mod, nil)).Methods("DELETE")
+	app.HandleFunc("/project/:id", curdApiModify(mod, fields, nil)).Methods("PUT")
+	app.HandleFunc("/project/:id", curdApiGet(mod)).Methods("GET")
+
+	//app.HandleFunc("/project/:id/tunnels", nop)
+	//app.HandleFunc("/project/:id/variables", nop)
+	//app.HandleFunc("/project/:id/batches", nop)
+	//app.HandleFunc("/project/:id/jobs", nop)
+	//app.HandleFunc("/project/:id/strategies", nop)
+
+	//app.HandleFunc("/project/import", projectImport).Methods("POST")
+	//app.HandleFunc("/project/:id/export", projectExport).Methods("GET")
+	//app.HandleFunc("/project/:id/deploy", projectDeploy).Methods("GET")
+
 	mod = reflect.TypeOf(models.ProjectElement{})
 	fields = []string{"name"}
-	app.Post("/project/:id/elements", curdApiListById(mod, "project_id"))
-	//app.Post("/project/elements", curdApiList(mod))
-	app.Post("/project/element", curdApiCreate(mod, nil))
-	app.Delete("/project/element/:id", curdApiDelete(mod, nil))
-	app.Put("/project/element/:id", curdApiModify(mod, fields, nil))
-	app.Get("/project/element/:id", curdApiGet(mod))
+	app.HandleFunc("/project/:id/elements", curdApiListById(mod, "project_id")).Methods("POST")
+	//app.HandleFunc("/project/elements", curdApiList(mod)).Methods("POST")
+	app.HandleFunc("/project/element", curdApiCreate(mod, nil)).Methods("POST")
+	app.HandleFunc("/project/element/:id", curdApiDelete(mod, nil)).Methods("DELETE")
+	app.HandleFunc("/project/element/:id", curdApiModify(mod, fields, nil)).Methods("PUT")
+	app.HandleFunc("/project/element/:id", curdApiGet(mod)).Methods("GET")
 
 	mod = reflect.TypeOf(models.ProjectJob{})
 	fields = []string{"name"}
-	app.Post("/project/:id/jobs", curdApiListById(mod, "project_id"))
-	//app.Post("/project/jobs", curdApiList(mod))
-	app.Post("/project/job", curdApiCreate(mod, nil))
-	app.Delete("/project/job/:id", curdApiDelete(mod, nil))
-	app.Put("/project/job/:id", curdApiModify(mod, fields, nil))
-	app.Get("/project/job/:id", curdApiGet(mod))
+	app.HandleFunc("/project/:id/jobs", curdApiListById(mod, "project_id")).Methods("POST")
+	//app.HandleFunc("/project/jobs", curdApiList(mod)).Methods("POST")
+	app.HandleFunc("/project/job", curdApiCreate(mod, nil)).Methods("POST")
+	app.HandleFunc("/project/job/:id", curdApiDelete(mod, nil)).Methods("DELETE")
+	app.HandleFunc("/project/job/:id", curdApiModify(mod, fields, nil)).Methods("PUT")
+	app.HandleFunc("/project/job/:id", curdApiGet(mod)).Methods("GET")
 
 	mod = reflect.TypeOf(models.ProjectStrategy{})
 	fields = []string{"name"}
-	app.Post("/project/:id/strategies", curdApiListById(mod, "project_id"))
-	//app.Post("/project/strategies", curdApiList(mod))
-	app.Post("/project/strategy", curdApiCreate(mod, nil))
-	app.Delete("/project/strategy/:id", curdApiDelete(mod, nil))
-	app.Put("/project/strategy/:id", curdApiModify(mod, fields, nil))
-	app.Get("/project/strategy/:id", curdApiGet(mod))
+	app.HandleFunc("/project/:id/strategies", curdApiListById(mod, "project_id")).Methods("POST")
+	//app.HandleFunc("/project/strategies", curdApiList(mod)).Methods("POST")
+	app.HandleFunc("/project/strategy", curdApiCreate(mod, nil)).Methods("POST")
+	app.HandleFunc("/project/strategy/:id", curdApiDelete(mod, nil)).Methods("DELETE")
+	app.HandleFunc("/project/strategy/:id", curdApiModify(mod, fields, nil)).Methods("PUT")
+	app.HandleFunc("/project/strategy/:id", curdApiGet(mod)).Methods("GET")
 
 	//元件管理
 	mod = reflect.TypeOf(models.Element{})
 	fields = []string{"name"}
-	app.Post("/elements", curdApiList(mod))
-	app.Post("/element", curdApiCreate(mod, nil))
-	app.Delete("/element/:id", curdApiDelete(mod, nil))
-	app.Put("/element/:id", curdApiModify(mod, fields, nil))
-	app.Get("/element/:id", curdApiGet(mod))
+	app.HandleFunc("/elements", curdApiList(mod)).Methods("POST")
+	app.HandleFunc("/element", curdApiCreate(mod, nil)).Methods("POST")
+	app.HandleFunc("/element/:id", curdApiDelete(mod, nil)).Methods("DELETE")
+	app.HandleFunc("/element/:id", curdApiModify(mod, fields, nil)).Methods("PUT")
+	app.HandleFunc("/element/:id", curdApiGet(mod)).Methods("GET")
 
 	//元件变量
 	mod = reflect.TypeOf(models.ElementVariable{})
 	fields = []string{"name"}
-	app.Post("/element/:id/variables", curdApiListById(mod, "element_id"))
-	//app.Post("/element/variables", curdApiList(mod))
-	app.Post("/element/variable", curdApiCreate(mod, nil))
-	app.Delete("/element/variable/:id", curdApiDelete(mod, nil))
-	app.Put("/element/variable/:id", curdApiModify(mod, fields, nil))
-	app.Get("/element/variable/:id", curdApiGet(mod))
+	app.HandleFunc("/element/:id/variables", curdApiListById(mod, "element_id")).Methods("POST")
+	//app.HandleFunc("/element/variables", curdApiList(mod)).Methods("POST")
+	app.HandleFunc("/element/variable", curdApiCreate(mod, nil)).Methods("POST")
+	app.HandleFunc("/element/variable/:id", curdApiDelete(mod, nil)).Methods("DELETE")
+	app.HandleFunc("/element/variable/:id", curdApiModify(mod, fields, nil)).Methods("PUT")
+	app.HandleFunc("/element/variable/:id", curdApiGet(mod)).Methods("GET")
 
 	//元件批量操作
 	mod = reflect.TypeOf(models.ElementBatch{})
 	fields = []string{"name"}
-	app.Post("/element/:id/batches", curdApiListById(mod, "element_id"))
-	//app.Post("/element/batches", curdApiList(mod))
-	app.Post("/element/batch", curdApiCreate(mod, nil))
-	app.Delete("/element/batch/:id", curdApiDelete(mod, nil))
-	app.Put("/element/batch/:id", curdApiModify(mod, fields, nil))
-	app.Get("/element/batch/:id", curdApiGet(mod))
+	app.HandleFunc("/element/:id/batches", curdApiListById(mod, "element_id")).Methods("POST")
+	//app.HandleFunc("/element/batches", curdApiList(mod)).Methods("POST")
+	app.HandleFunc("/element/batch", curdApiCreate(mod, nil)).Methods("POST")
+	app.HandleFunc("/element/batch/:id", curdApiDelete(mod, nil)).Methods("DELETE")
+	app.HandleFunc("/element/batch/:id", curdApiModify(mod, fields, nil)).Methods("PUT")
+	app.HandleFunc("/element/batch/:id", curdApiGet(mod)).Methods("GET")
 
 }
 
-func replyOk(ctx iris.Context, data interface{}) {
-	ctx.JSON(iris.Map{
-		"ok":   true,
-		"data": data,
-	})
+type Reply struct {
+	Ok    bool        `json:"ok"`
+	Error string      `json:"error,omitempty"`
+	Data  interface{} `json:"data,omitempty"`
+	Total int64       `json:"total,omitempty"`
 }
 
-func replyFail(ctx iris.Context, err string) {
-	ctx.JSON(iris.Map{
-		"ok":    false,
-		"error": err,
-	})
+func replyList(writer http.ResponseWriter, data interface{}, total int64) {
+	r := Reply{
+		Ok:    true,
+		Data:  data,
+		Total: total,
+	}
+	b, _ := json.Marshal(r)
+	_, _ = writer.Write(b)
+}
+
+func replyOk(writer http.ResponseWriter, data interface{}) {
+	r := Reply{
+		Ok:   true,
+		Data: data,
+	}
+	b, _ := json.Marshal(r)
+	_, _ = writer.Write(b)
 }
 
-func replyError(ctx iris.Context, err error) {
-	ctx.JSON(iris.Map{
-		"ok":    false,
-		"error": err.Error(),
-	})
+func replyFail(writer http.ResponseWriter, err string) {
+	r := Reply{
+		Error: err,
+	}
+	b, _ := json.Marshal(r)
+	_, _ = writer.Write(b)
+}
+
+func replyError(writer http.ResponseWriter, err error) {
+	r := Reply{
+		Error: err.Error(),
+	}
+	b, _ := json.Marshal(r)
+	_, _ = writer.Write(b)
 }
 
-func nop(ctx iris.Context) {
-	ctx.StatusCode(iris.StatusForbidden)
-	ctx.WriteString("Unsupported")
+func nop(writer http.ResponseWriter, request *http.Request) {
+	writer.WriteHeader(http.StatusForbidden)
+	_, _ = writer.Write([]byte("Unsupported"))
 }

web/api/tunnel.go

@@ -2,47 +2,49 @@ package api
 
 import (
 	"git.zgwit.com/zgwit/iot-admin/core"
-	"github.com/kataras/iris/v12"
+	"github.com/gorilla/mux"
+	"net/http"
+	"strconv"
 )
 
-func tunnelStart(ctx iris.Context) {
-	id, err := ctx.URLParamInt64("id")
+func tunnelStart(writer http.ResponseWriter, request *http.Request) {
+	id, err := strconv.ParseInt(mux.Vars(request)["id"], 10, 64)
 	if err != nil {
-		replyError(ctx, err)
+		replyError(writer, err)
 		return
 	}
 	c, err := core.GetTunnel(id)
 	if err != nil {
-		replyError(ctx, err)
+		replyError(writer, err)
 		return
 	}
 
 	err = c.Open()
 	if err != nil {
-		replyError(ctx, err)
+		replyError(writer, err)
 		return
 	}
 
-	replyOk(ctx, nil)
+	replyOk(writer, nil)
 }
 
-func tunnelStop(ctx iris.Context) {
-	id, err := ctx.URLParamInt64("id")
+func tunnelStop(writer http.ResponseWriter, request *http.Request) {
+	id, err := strconv.ParseInt(mux.Vars(request)["id"], 10, 64)
 	if err != nil {
-		replyError(ctx, err)
+		replyError(writer, err)
 		return
 	}
 	c, err := core.GetTunnel(id)
 	if err != nil {
-		replyError(ctx, err)
+		replyError(writer, err)
 		return
 	}
 
 	err = c.Close()
 	if err != nil {
-		replyError(ctx, err)
+		replyError(writer, err)
 		return
 	}
 
-	replyOk(ctx, nil)
+	replyOk(writer, nil)
 }

web/app.go

@@ -5,9 +5,10 @@ import (
 	"git.zgwit.com/zgwit/iot-admin/web/api"
 	"git.zgwit.com/zgwit/iot-admin/web/open"
 	wwwFiles "git.zgwit.com/zgwit/iot-admin/web/www"
-	"github.com/kataras/iris/v12"
+	"github.com/gorilla/mux"
 	"log"
 	"net/http"
+	"time"
 )
 
 func Serve() {
@@ -16,10 +17,12 @@ func Serve() {
 
 	}
 
+	app := mux.NewRouter()
+
 
 	//GIN初始化
 	//app := gin.Default()
-	app := iris.New()
+	//app := iris.New()
 
 
 	//加入swagger会增加10MB多体积，使用github.com/zgwit/swagger-files，去除Map文件，可以节省7MB左右
@@ -27,12 +30,13 @@ func Serve() {
 	//app.Get("/docs/*any", ginSwagger.WrapHandler(swaggerFiles.Handler))
 
 	//MQTT
-	app.Get("/mqtt", mqtt)
+	app.HandleFunc("/mqtt", mqtt).Methods("GET")
 	//透传
-	app.Get("/peer", peer)
+	app.HandleFunc("/peer", peer).Methods("GET")
 
 	//开放接口
-	open.RegisterRoutes(app.Party("/open"))
+	open.RegisterRoutes(app.PathPrefix("/open").Subrouter())
+
 
 	//启用session
 	//app.Use(sessions.Sessions("core-admin", memstore.NewStore([]byte("core-admin-secret"))))
@@ -45,20 +49,20 @@ func Serve() {
 
 
 	//注册前端接口
-	api.RegisterRoutes(app.Party("/api"))
+	api.RegisterRoutes(app.PathPrefix("/open").Subrouter())
 
 	//未登录，访问前端文件，跳转到OAuth2登录
 	if conf.Config.SysAdmin.Enable {
-		app.Use(func(c iris.Context) {
-			//session := sessions.Default(c)
-			//if user := session.Get("user"); user != nil {
-			//	c.Next()
-			//} else {
-			//	//TODO 拼接 OAuth2链接，需要AppKey和Secret
-			//	url := conf.Config.SysAdmin.Addr + "?redirect_uri="
-			//	c.Redirect(http.StatusFound, url)
-			//}
-		})
+		//app.Use(func(c iris.Context) {
+		//	//session := sessions.Default(c)
+		//	//if user := session.Get("user"); user != nil {
+		//	//	c.Next()
+		//	//} else {
+		//	//	//TODO 拼接 OAuth2链接，需要AppKey和Secret
+		//	//	url := conf.Config.SysAdmin.Addr + "?redirect_uri="
+		//	//	c.Redirect(http.StatusFound, url)
+		//	//}
+		//})
 	} else if conf.Config.BaseAuth.Enable {
 		//开启基本HTTP认证
 		//app.Use(gin.BasicAuth(gin.Accounts(conf.Config.BaseAuth.Users)))
@@ -66,23 +70,32 @@ func Serve() {
 
 	//前端静态文件
 	//app.Get("/*any", func(c iris.Context) {
-	app.Use(func(c iris.Context) {
-		if c.Method() == http.MethodGet {
-			//支持前端框架的无“#”路由
-			if c.Request().RequestURI == "/" {
-				c.Request().URL.Path = "index.html"
-			} else if _, err := wwwFiles.FS.Stat(wwwFiles.CTX, c.Request().RequestURI); err != nil {
-				c.Request().URL.Path = "index.html"
+	app.Use(func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
+			if request.Method == http.MethodGet {
+				//支持前端框架的无“#”路由
+				if request.RequestURI == "/" {
+					request.URL.Path = "index.html"
+				} else if _, err := wwwFiles.FS.Stat(wwwFiles.CTX, request.RequestURI); err != nil {
+					request.URL.Path = "index.html"
+				}
+				//TODO 如果未登录，则跳转SysAdmin OAuth2自动授权页面
+
+				//文件失效期已经在Handler中处理
+				wwwFiles.Handler.ServeHTTP(writer, request)
 			}
-			//TODO 如果未登录，则跳转SysAdmin OAuth2自动授权页面
-
-			//文件失效期已经在Handler中处理
-			wwwFiles.Handler.ServeHTTP(c.ResponseWriter(), c.Request())
-		}
+		})
 	})
 
 	//监听HTTP
-	if err := app.Listen(conf.Config.Web.Addr); err != nil {
+	srv := &http.Server{
+		Addr:         conf.Config.Web.Addr,
+		WriteTimeout: time.Second * 15,
+		ReadTimeout:  time.Second * 15,
+		IdleTimeout:  time.Second * 60,
+		Handler: app,
+	}
+	if err := srv.ListenAndServe(); err != nil {
 		log.Fatal("HTTP 服务启动错误", err)
 	}
 }

web/mqtt.go

@@ -2,15 +2,15 @@ package web
 
 import (
 	"git.zgwit.com/zgwit/iot-admin/core"
-	"github.com/kataras/iris/v12"
 	"golang.org/x/net/websocket"
+	"net/http"
 )
 
-func mqtt(ctx iris.Context)  {
+func mqtt(writer http.ResponseWriter, request *http.Request)  {
 	websocket.Handler(func(ws *websocket.Conn) {
 		//设置二进制模式
 		ws.PayloadType = websocket.BinaryFrame
 		core.Hive().Receive(ws)
-	}).ServeHTTP(ctx.ResponseWriter(), ctx.Request())
+	}).ServeHTTP(writer, request)
 	//ctx.Abort()
 }

web/open/router.go

 package open
 
 import (
-	"github.com/kataras/iris/v12"
+	"github.com/gorilla/mux"
 )
 
-func RegisterRoutes(app iris.Party) {
+func RegisterRoutes(app *mux.Router) {
 
 	//跨域咨问题
 	//app.Use(cors.Default())
 
-	app.Use(func(ctx iris.Context) {
-		//TODO 检查KEY
-
-		//log.Println("open", ctx.FullPath())
-	})
+	//app.Use(func(ctx iris.Context) {
+	//	//TODO 检查KEY
+	//
+	//	//log.Println("open", ctx.FullPath())
+	//})
 
 	//app.Get("/channels")
 }

web/peer.go

 package web
 
 import (
-	"github.com/kataras/iris/v12"
 	"golang.org/x/net/websocket"
 	"log"
+	"net/http"
 )
 
-func peer(ctx iris.Context)  {
-	key := ctx.URLParam("key")
+func peer(writer http.ResponseWriter, request *http.Request)  {
+	key := request.URL.Query()["key"]
 	log.Println(key)
 
 	//TODO 获取链接
@@ -17,7 +17,7 @@ func peer(ctx iris.Context)  {
 	websocket.Handler(func(ws *websocket.Conn) {
 		//peer := core.NewPeer(ws, nil)
 		//peer.Receive()
-	}).ServeHTTP(ctx.ResponseWriter(), ctx.Request())
+	}).ServeHTTP(writer, request)
 	//ctx.Abort()
 }