fix: list bgp config.

cmd/api/v5/bgp.go

@@ -20,7 +20,7 @@ type BGP struct {
 }
 
 func (b BGP) Url(prefix string) string {
-	return prefix + "/api/network/bgp"
+	return prefix + "/api/network/bgp/global"
 }
 
 func (b BGP) List(c *cli.Context) error {

pkg/api/bgp.go

@@ -1,142 +0,0 @@
-package api
-
-import (
-	"net/http"
-
-	"github.com/gorilla/mux"
-	"github.com/luscis/openlan/pkg/libol"
-	"github.com/luscis/openlan/pkg/schema"
-)
-
-type Bgp struct {
-	cs SwitchApi
-}
-
-func (h Bgp) Router(router *mux.Router) {
-	router.HandleFunc("/api/network/bgp", h.Get).Methods("GET")
-	router.HandleFunc("/api/network/bgp", h.Post).Methods("POST")
-	router.HandleFunc("/api/network/bgp", h.Remove).Methods("DELETE")
-	router.HandleFunc("/api/network/bgp/neighbor", h.RemoveNeighbor).Methods("DELETE")
-	router.HandleFunc("/api/network/bgp/neighbor", h.AddNeighbor).Methods("POST")
-	router.HandleFunc("/api/network/bgp/advertis", h.RemoveAdvertis).Methods("DELETE")
-	router.HandleFunc("/api/network/bgp/advertis", h.AddAdvertis).Methods("POST")
-	router.HandleFunc("/api/network/bgp/receives", h.RemoveReceivess).Methods("DELETE")
-	router.HandleFunc("/api/network/bgp/receives", h.AddReceivess).Methods("POST")
-}
-
-func (h Bgp) Get(w http.ResponseWriter, r *http.Request) {
-	libol.Debug("Bgp.Get %s")
-	if Call.bgpApi == nil {
-		http.Error(w, "network is nil", http.StatusBadRequest)
-		return
-	}
-	data := Call.bgpApi.Get()
-	ResponseJson(w, data)
-}
-
-func (h Bgp) Post(w http.ResponseWriter, r *http.Request) {
-	data := schema.Bgp{}
-	if err := GetData(r, &data); err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-	if Call.bgpApi == nil {
-		http.Error(w, "network is nil", http.StatusBadRequest)
-		return
-	}
-	Call.bgpApi.Enable(data)
-	ResponseMsg(w, 0, "")
-}
-
-func (h Bgp) Remove(w http.ResponseWriter, r *http.Request) {
-	if Call.bgpApi == nil {
-		http.Error(w, "network is nil", http.StatusBadRequest)
-		return
-	}
-	Call.bgpApi.Disable()
-	ResponseMsg(w, 0, "")
-}
-
-func (h Bgp) RemoveNeighbor(w http.ResponseWriter, r *http.Request) {
-	nei := schema.BgpNeighbor{}
-	if err := GetData(r, &nei); err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-	if Call.bgpApi == nil {
-		http.Error(w, "network is nil", http.StatusBadRequest)
-		return
-	}
-	Call.bgpApi.DelNeighbor(nei)
-	ResponseMsg(w, 0, "")
-}
-
-func (h Bgp) AddNeighbor(w http.ResponseWriter, r *http.Request) {
-	nei := schema.BgpNeighbor{}
-	if err := GetData(r, &nei); err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-	if Call.bgpApi == nil {
-		http.Error(w, "network is nil", http.StatusBadRequest)
-		return
-	}
-	Call.bgpApi.AddNeighbor(nei)
-	ResponseMsg(w, 0, "")
-}
-
-func (h Bgp) RemoveAdvertis(w http.ResponseWriter, r *http.Request) {
-	data := schema.BgpPrefix{}
-	if err := GetData(r, &data); err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-	if Call.bgpApi == nil {
-		http.Error(w, "network is nil", http.StatusBadRequest)
-		return
-	}
-	Call.bgpApi.DelAdvertis(data)
-	ResponseMsg(w, 0, "")
-}
-
-func (h Bgp) AddAdvertis(w http.ResponseWriter, r *http.Request) {
-	data := schema.BgpPrefix{}
-	if err := GetData(r, &data); err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-	if Call.bgpApi == nil {
-		http.Error(w, "network is nil", http.StatusBadRequest)
-		return
-	}
-	Call.bgpApi.AddAdvertis(data)
-	ResponseMsg(w, 0, "")
-}
-
-func (h Bgp) RemoveReceivess(w http.ResponseWriter, r *http.Request) {
-	data := schema.BgpPrefix{}
-	if err := GetData(r, &data); err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-	if Call.bgpApi == nil {
-		http.Error(w, "network is nil", http.StatusBadRequest)
-		return
-	}
-	Call.bgpApi.DelReceives(data)
-	ResponseMsg(w, 0, "")
-}
-
-func (h Bgp) AddReceivess(w http.ResponseWriter, r *http.Request) {
-	data := schema.BgpPrefix{}
-	if err := GetData(r, &data); err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-	if Call.bgpApi == nil {
-		http.Error(w, "network is nil", http.StatusBadRequest)
-		return
-	}
-	Call.bgpApi.AddReceives(data)
-	ResponseMsg(w, 0, "")
-}

pkg/api/ceci.go

@@ -1,52 +0,0 @@
-package api
-
-import (
-	"net/http"
-
-	"github.com/gorilla/mux"
-	"github.com/luscis/openlan/pkg/libol"
-	"github.com/luscis/openlan/pkg/schema"
-)
-
-type Ceci struct {
-	cs SwitchApi
-}
-
-func (h Ceci) Router(router *mux.Router) {
-	router.HandleFunc("/api/network/ceci/tcp", h.Get).Methods("GET")
-	router.HandleFunc("/api/network/ceci/tcp", h.Post).Methods("POST")
-	router.HandleFunc("/api/network/ceci/tcp", h.Remove).Methods("DELETE")
-}
-
-func (h Ceci) Get(w http.ResponseWriter, r *http.Request) {
-	libol.Debug("Ceci.Get %s")
-	ResponseJson(w, nil)
-}
-
-func (h Ceci) Post(w http.ResponseWriter, r *http.Request) {
-	data := schema.CeciTcp{}
-	if err := GetData(r, &data); err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-	if Call.ceciApi == nil {
-		http.Error(w, "network is nil", http.StatusBadRequest)
-		return
-	}
-	Call.ceciApi.AddTcp(data)
-	ResponseMsg(w, 0, "")
-}
-
-func (h Ceci) Remove(w http.ResponseWriter, r *http.Request) {
-	data := schema.CeciTcp{}
-	if err := GetData(r, &data); err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-	if Call.ceciApi == nil {
-		http.Error(w, "network is nil", http.StatusBadRequest)
-		return
-	}
-	Call.ceciApi.DelTcp(data)
-	ResponseMsg(w, 0, "")
-}

pkg/api/ipsec.go

@@ -1,75 +0,0 @@
-package api
-
-import (
-	"net/http"
-
-	"github.com/gorilla/mux"
-	"github.com/luscis/openlan/pkg/libol"
-	"github.com/luscis/openlan/pkg/schema"
-)
-
-type IPSec struct {
-	cs SwitchApi
-}
-
-func (h IPSec) Router(router *mux.Router) {
-	router.HandleFunc("/api/network/ipsec/tunnel", h.Get).Methods("GET")
-	router.HandleFunc("/api/network/ipsec/tunnel", h.Post).Methods("POST")
-	router.HandleFunc("/api/network/ipsec/tunnel", h.Delete).Methods("DELETE")
-	router.HandleFunc("/api/network/ipsec/tunnel/restart", h.Start).Methods("PUT")
-}
-
-func (h IPSec) Get(w http.ResponseWriter, r *http.Request) {
-	libol.Debug("IPSec.Get %s")
-	tunnels := make([]schema.IPSecTunnel, 0, 1024)
-	if Call.ipsecApi == nil {
-		http.Error(w, "network is nil", http.StatusBadRequest)
-		return
-	}
-	Call.ipsecApi.ListTunnels(func(obj schema.IPSecTunnel) {
-		tunnels = append(tunnels, obj)
-	})
-	ResponseJson(w, tunnels)
-}
-
-func (h IPSec) Post(w http.ResponseWriter, r *http.Request) {
-	tun := &schema.IPSecTunnel{}
-	if err := GetData(r, tun); err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-	if Call.ipsecApi == nil {
-		http.Error(w, "network is nil", http.StatusBadRequest)
-		return
-	}
-	Call.ipsecApi.AddTunnel(*tun)
-	ResponseMsg(w, 0, "")
-}
-
-func (h IPSec) Delete(w http.ResponseWriter, r *http.Request) {
-	tun := &schema.IPSecTunnel{}
-	if err := GetData(r, tun); err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-	if Call.ipsecApi == nil {
-		http.Error(w, "network is nil", http.StatusBadRequest)
-		return
-	}
-	Call.ipsecApi.DelTunnel(*tun)
-	ResponseMsg(w, 0, "")
-}
-
-func (h IPSec) Start(w http.ResponseWriter, r *http.Request) {
-	tun := &schema.IPSecTunnel{}
-	if err := GetData(r, tun); err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-	if Call.ipsecApi == nil {
-		http.Error(w, "network is nil", http.StatusBadRequest)
-		return
-	}
-	Call.ipsecApi.StartTunnel(*tun)
-	ResponseMsg(w, 0, "")
-}

pkg/api/network.go

@@ -288,3 +288,438 @@ func (h RouterTunnel) Delete(w http.ResponseWriter, r *http.Request) {
 	}
 	ResponseJson(w, "success")
 }
+
+type Bgp struct {
+	cs SwitchApi
+}
+
+func (h Bgp) Router(router *mux.Router) {
+	router.HandleFunc("/api/network/bgp/global", h.Get).Methods("GET")
+	router.HandleFunc("/api/network/bgp/global", h.Post).Methods("POST")
+	router.HandleFunc("/api/network/bgp/global", h.Remove).Methods("DELETE")
+	router.HandleFunc("/api/network/bgp/neighbor", h.RemoveNeighbor).Methods("DELETE")
+	router.HandleFunc("/api/network/bgp/neighbor", h.AddNeighbor).Methods("POST")
+	router.HandleFunc("/api/network/bgp/advertis", h.RemoveAdvertis).Methods("DELETE")
+	router.HandleFunc("/api/network/bgp/advertis", h.AddAdvertis).Methods("POST")
+	router.HandleFunc("/api/network/bgp/receives", h.RemoveReceivess).Methods("DELETE")
+	router.HandleFunc("/api/network/bgp/receives", h.AddReceivess).Methods("POST")
+}
+
+func (h Bgp) Get(w http.ResponseWriter, r *http.Request) {
+	libol.Debug("Bgp.Get %s")
+	if Call.bgpApi == nil {
+		http.Error(w, "network is nil", http.StatusBadRequest)
+		return
+	}
+	data := Call.bgpApi.Get()
+	ResponseJson(w, data)
+}
+
+func (h Bgp) Post(w http.ResponseWriter, r *http.Request) {
+	data := schema.Bgp{}
+	if err := GetData(r, &data); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	if Call.bgpApi == nil {
+		http.Error(w, "network is nil", http.StatusBadRequest)
+		return
+	}
+	Call.bgpApi.Enable(data)
+	ResponseMsg(w, 0, "")
+}
+
+func (h Bgp) Remove(w http.ResponseWriter, r *http.Request) {
+	if Call.bgpApi == nil {
+		http.Error(w, "network is nil", http.StatusBadRequest)
+		return
+	}
+	Call.bgpApi.Disable()
+	ResponseMsg(w, 0, "")
+}
+
+func (h Bgp) RemoveNeighbor(w http.ResponseWriter, r *http.Request) {
+	nei := schema.BgpNeighbor{}
+	if err := GetData(r, &nei); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	if Call.bgpApi == nil {
+		http.Error(w, "network is nil", http.StatusBadRequest)
+		return
+	}
+	Call.bgpApi.DelNeighbor(nei)
+	ResponseMsg(w, 0, "")
+}
+
+func (h Bgp) AddNeighbor(w http.ResponseWriter, r *http.Request) {
+	nei := schema.BgpNeighbor{}
+	if err := GetData(r, &nei); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	if Call.bgpApi == nil {
+		http.Error(w, "network is nil", http.StatusBadRequest)
+		return
+	}
+	Call.bgpApi.AddNeighbor(nei)
+	ResponseMsg(w, 0, "")
+}
+
+func (h Bgp) RemoveAdvertis(w http.ResponseWriter, r *http.Request) {
+	data := schema.BgpPrefix{}
+	if err := GetData(r, &data); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	if Call.bgpApi == nil {
+		http.Error(w, "network is nil", http.StatusBadRequest)
+		return
+	}
+	Call.bgpApi.DelAdvertis(data)
+	ResponseMsg(w, 0, "")
+}
+
+func (h Bgp) AddAdvertis(w http.ResponseWriter, r *http.Request) {
+	data := schema.BgpPrefix{}
+	if err := GetData(r, &data); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	if Call.bgpApi == nil {
+		http.Error(w, "network is nil", http.StatusBadRequest)
+		return
+	}
+	Call.bgpApi.AddAdvertis(data)
+	ResponseMsg(w, 0, "")
+}
+
+func (h Bgp) RemoveReceivess(w http.ResponseWriter, r *http.Request) {
+	data := schema.BgpPrefix{}
+	if err := GetData(r, &data); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	if Call.bgpApi == nil {
+		http.Error(w, "network is nil", http.StatusBadRequest)
+		return
+	}
+	Call.bgpApi.DelReceives(data)
+	ResponseMsg(w, 0, "")
+}
+
+func (h Bgp) AddReceivess(w http.ResponseWriter, r *http.Request) {
+	data := schema.BgpPrefix{}
+	if err := GetData(r, &data); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	if Call.bgpApi == nil {
+		http.Error(w, "network is nil", http.StatusBadRequest)
+		return
+	}
+	Call.bgpApi.AddReceives(data)
+	ResponseMsg(w, 0, "")
+}
+
+type Ceci struct {
+	cs SwitchApi
+}
+
+func (h Ceci) Router(router *mux.Router) {
+	router.HandleFunc("/api/network/ceci/tcp", h.Get).Methods("GET")
+	router.HandleFunc("/api/network/ceci/tcp", h.Post).Methods("POST")
+	router.HandleFunc("/api/network/ceci/tcp", h.Remove).Methods("DELETE")
+}
+
+func (h Ceci) Get(w http.ResponseWriter, r *http.Request) {
+	libol.Debug("Ceci.Get %s")
+	ResponseJson(w, nil)
+}
+
+func (h Ceci) Post(w http.ResponseWriter, r *http.Request) {
+	data := schema.CeciTcp{}
+	if err := GetData(r, &data); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	if Call.ceciApi == nil {
+		http.Error(w, "network is nil", http.StatusBadRequest)
+		return
+	}
+	Call.ceciApi.AddTcp(data)
+	ResponseMsg(w, 0, "")
+}
+
+func (h Ceci) Remove(w http.ResponseWriter, r *http.Request) {
+	data := schema.CeciTcp{}
+	if err := GetData(r, &data); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	if Call.ceciApi == nil {
+		http.Error(w, "network is nil", http.StatusBadRequest)
+		return
+	}
+	Call.ceciApi.DelTcp(data)
+	ResponseMsg(w, 0, "")
+}
+
+type IPSec struct {
+	cs SwitchApi
+}
+
+func (h IPSec) Router(router *mux.Router) {
+	router.HandleFunc("/api/network/ipsec/tunnel", h.Get).Methods("GET")
+	router.HandleFunc("/api/network/ipsec/tunnel", h.Post).Methods("POST")
+	router.HandleFunc("/api/network/ipsec/tunnel", h.Delete).Methods("DELETE")
+	router.HandleFunc("/api/network/ipsec/tunnel/restart", h.Start).Methods("PUT")
+}
+
+func (h IPSec) Get(w http.ResponseWriter, r *http.Request) {
+	libol.Debug("IPSec.Get %s")
+	tunnels := make([]schema.IPSecTunnel, 0, 1024)
+	if Call.ipsecApi == nil {
+		http.Error(w, "network is nil", http.StatusBadRequest)
+		return
+	}
+	Call.ipsecApi.ListTunnels(func(obj schema.IPSecTunnel) {
+		tunnels = append(tunnels, obj)
+	})
+	ResponseJson(w, tunnels)
+}
+
+func (h IPSec) Post(w http.ResponseWriter, r *http.Request) {
+	tun := &schema.IPSecTunnel{}
+	if err := GetData(r, tun); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	if Call.ipsecApi == nil {
+		http.Error(w, "network is nil", http.StatusBadRequest)
+		return
+	}
+	Call.ipsecApi.AddTunnel(*tun)
+	ResponseMsg(w, 0, "")
+}
+
+func (h IPSec) Delete(w http.ResponseWriter, r *http.Request) {
+	tun := &schema.IPSecTunnel{}
+	if err := GetData(r, tun); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	if Call.ipsecApi == nil {
+		http.Error(w, "network is nil", http.StatusBadRequest)
+		return
+	}
+	Call.ipsecApi.DelTunnel(*tun)
+	ResponseMsg(w, 0, "")
+}
+
+func (h IPSec) Start(w http.ResponseWriter, r *http.Request) {
+	tun := &schema.IPSecTunnel{}
+	if err := GetData(r, tun); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	if Call.ipsecApi == nil {
+		http.Error(w, "network is nil", http.StatusBadRequest)
+		return
+	}
+	Call.ipsecApi.StartTunnel(*tun)
+	ResponseMsg(w, 0, "")
+}
+
+type PrefixRoute struct {
+	cs SwitchApi
+}
+
+func (rt PrefixRoute) Router(router *mux.Router) {
+	router.HandleFunc("/api/network/{id}/route", rt.List).Methods("GET")
+	router.HandleFunc("/api/network/{id}/route", rt.Add).Methods("POST")
+	router.HandleFunc("/api/network/{id}/route", rt.Del).Methods("DELETE")
+	router.HandleFunc("/api/network/{id}/route", rt.Save).Methods("PUT")
+}
+
+func (rt PrefixRoute) List(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	id := vars["id"]
+
+	routes := make([]schema.PrefixRoute, 0, 1024)
+
+	worker := Call.GetWorker(id)
+	if worker == nil {
+		http.Error(w, "Network not found", http.StatusBadRequest)
+		return
+	}
+
+	worker.ListRoute(func(obj schema.PrefixRoute) {
+		routes = append(routes, obj)
+	})
+	ResponseJson(w, routes)
+}
+
+func (rt PrefixRoute) Add(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	id := vars["id"]
+
+	worker := Call.GetWorker(id)
+	if worker == nil {
+		http.Error(w, "Network not found", http.StatusBadRequest)
+		return
+	}
+
+	pr := &schema.PrefixRoute{}
+	if err := GetData(r, pr); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	if err := worker.AddRoute(pr, rt.cs); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	ResponseJson(w, true)
+}
+
+func (rt PrefixRoute) Del(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	id := vars["id"]
+
+	worker := Call.GetWorker(id)
+	if worker == nil {
+		http.Error(w, "Network not found", http.StatusBadRequest)
+		return
+	}
+
+	pr := &schema.PrefixRoute{}
+	if err := GetData(r, pr); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	if err := worker.DelRoute(pr, rt.cs); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	ResponseJson(w, true)
+}
+
+func (rt PrefixRoute) Save(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	id := vars["id"]
+
+	worker := Call.GetWorker(id)
+	if worker == nil {
+		http.Error(w, "Network not found", http.StatusBadRequest)
+		return
+	}
+
+	worker.SaveRoute()
+
+	ResponseJson(w, true)
+}
+
+type ClientQoS struct {
+}
+
+func (h ClientQoS) Router(router *mux.Router) {
+	router.HandleFunc("/api/network/{id}/qos", h.List).Methods("GET")
+	router.HandleFunc("/api/network/{id}/qos", h.Add).Methods("POST")
+	router.HandleFunc("/api/network/{id}/qos", h.Del).Methods("DELETE")
+	router.HandleFunc("/api/network/{id}/qos", h.Save).Methods("PUT")
+}
+
+func (h ClientQoS) List(w http.ResponseWriter, r *http.Request) {
+
+	qosList := make([]schema.Qos, 0, 1024)
+	vars := mux.Vars(r)
+	id := vars["id"]
+
+	worker := Call.GetWorker(id)
+	if worker == nil {
+		http.Error(w, "Network not found", http.StatusBadRequest)
+		return
+	}
+
+	var qos = worker.Qoser()
+	qos.ListQos(func(obj schema.Qos) {
+		qosList = append(qosList, obj)
+	})
+
+	ResponseJson(w, qosList)
+}
+
+func (h ClientQoS) Add(w http.ResponseWriter, r *http.Request) {
+
+	qos := &schema.Qos{}
+	if err := GetData(r, qos); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	vars := mux.Vars(r)
+	id := vars["id"]
+
+	worker := Call.GetWorker(id)
+	if worker == nil {
+		http.Error(w, "Network not found", http.StatusBadRequest)
+		return
+	}
+
+	if qos != nil {
+		if err := worker.Qoser().AddQos(qos.Name, qos.InSpeed); err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+		ResponseJson(w, true)
+	} else {
+		http.Error(w, vars["id"], http.StatusNotFound)
+	}
+}
+
+func (h ClientQoS) Del(w http.ResponseWriter, r *http.Request) {
+
+	qos := &schema.Qos{}
+	if err := GetData(r, qos); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	vars := mux.Vars(r)
+	id := vars["id"]
+
+	worker := Call.GetWorker(id)
+	if worker == nil {
+		http.Error(w, "Network not found", http.StatusBadRequest)
+		return
+	}
+
+	if qos != nil {
+		if err := worker.Qoser().DelQos(qos.Name); err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+		ResponseJson(w, true)
+	} else {
+		http.Error(w, vars["id"], http.StatusNotFound)
+	}
+}
+
+func (h ClientQoS) Save(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	id := vars["id"]
+
+	worker := Call.GetWorker(id)
+	if worker == nil {
+		http.Error(w, "Network not found", http.StatusBadRequest)
+		return
+	}
+	qos := worker.Qoser()
+	qos.SaveQos()
+
+	ResponseJson(w, "success")
+}

pkg/api/qos.go

@@ -1,109 +0,0 @@
-package api
-
-import (
-	"net/http"
-
-	"github.com/gorilla/mux"
-	"github.com/luscis/openlan/pkg/schema"
-)
-
-type Qos struct {
-}
-
-func (h Qos) Router(router *mux.Router) {
-	router.HandleFunc("/api/network/{id}/qos", h.List).Methods("GET")
-	router.HandleFunc("/api/network/{id}/qos", h.Add).Methods("POST")
-	router.HandleFunc("/api/network/{id}/qos", h.Del).Methods("DELETE")
-	router.HandleFunc("/api/network/{id}/qos", h.Save).Methods("PUT")
-}
-
-func (h Qos) List(w http.ResponseWriter, r *http.Request) {
-
-	qosList := make([]schema.Qos, 0, 1024)
-	vars := mux.Vars(r)
-	id := vars["id"]
-
-	worker := Call.GetWorker(id)
-	if worker == nil {
-		http.Error(w, "Network not found", http.StatusBadRequest)
-		return
-	}
-
-	var qos = worker.Qoser()
-	qos.ListQos(func(obj schema.Qos) {
-		qosList = append(qosList, obj)
-	})
-
-	ResponseJson(w, qosList)
-}
-
-func (h Qos) Add(w http.ResponseWriter, r *http.Request) {
-
-	qos := &schema.Qos{}
-	if err := GetData(r, qos); err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-
-	vars := mux.Vars(r)
-	id := vars["id"]
-
-	worker := Call.GetWorker(id)
-	if worker == nil {
-		http.Error(w, "Network not found", http.StatusBadRequest)
-		return
-	}
-
-	if qos != nil {
-		if err := worker.Qoser().AddQos(qos.Name, qos.InSpeed); err != nil {
-			http.Error(w, err.Error(), http.StatusBadRequest)
-			return
-		}
-		ResponseJson(w, true)
-	} else {
-		http.Error(w, vars["id"], http.StatusNotFound)
-	}
-}
-
-func (h Qos) Del(w http.ResponseWriter, r *http.Request) {
-
-	qos := &schema.Qos{}
-	if err := GetData(r, qos); err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-
-	vars := mux.Vars(r)
-	id := vars["id"]
-
-	worker := Call.GetWorker(id)
-	if worker == nil {
-		http.Error(w, "Network not found", http.StatusBadRequest)
-		return
-	}
-
-	if qos != nil {
-		if err := worker.Qoser().DelQos(qos.Name); err != nil {
-			http.Error(w, err.Error(), http.StatusBadRequest)
-			return
-		}
-		ResponseJson(w, true)
-	} else {
-		http.Error(w, vars["id"], http.StatusNotFound)
-	}
-}
-
-func (h Qos) Save(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	id := vars["id"]
-
-	worker := Call.GetWorker(id)
-	if worker == nil {
-		http.Error(w, "Network not found", http.StatusBadRequest)
-		return
-	}
-	qos := worker.Qoser()
-	qos.SaveQos()
-
-	ResponseJson(w, "success")
-}

pkg/api/ratelimit.go

@@ -7,16 +7,16 @@ import (
 	"github.com/luscis/openlan/pkg/schema"
 )
 
-type Rate struct {
+type RateLimit struct {
 	cs SwitchApi
 }
 
-func (h Rate) Router(router *mux.Router) {
+func (h RateLimit) Router(router *mux.Router) {
 	router.HandleFunc("/api/interface/{id}/rate", h.Post).Methods("POST")
 	router.HandleFunc("/api/interface/{id}/rate", h.Delete).Methods("DELETE")
 }
 
-func (h Rate) Post(w http.ResponseWriter, r *http.Request) {
+func (h RateLimit) Post(w http.ResponseWriter, r *http.Request) {
 	vars := mux.Vars(r)
 	device := vars["id"]
 
@@ -28,7 +28,7 @@ func (h Rate) Post(w http.ResponseWriter, r *http.Request) {
 	h.cs.AddRate(device, rate.Speed)
 }
 
-func (h Rate) Delete(w http.ResponseWriter, r *http.Request) {
+func (h RateLimit) Delete(w http.ResponseWriter, r *http.Request) {
 	vars := mux.Vars(r)
 	device := vars["id"]
 	h.cs.DelRate(device)

pkg/api/route.go

@@ -1,101 +0,0 @@
-package api
-
-import (
-	"net/http"
-
-	"github.com/gorilla/mux"
-	"github.com/luscis/openlan/pkg/schema"
-)
-
-type Route struct {
-	cs SwitchApi
-}
-
-func (rt Route) Router(router *mux.Router) {
-	router.HandleFunc("/api/network/{id}/route", rt.List).Methods("GET")
-	router.HandleFunc("/api/network/{id}/route", rt.Add).Methods("POST")
-	router.HandleFunc("/api/network/{id}/route", rt.Del).Methods("DELETE")
-	router.HandleFunc("/api/network/{id}/route", rt.Save).Methods("PUT")
-}
-
-func (rt Route) List(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	id := vars["id"]
-
-	routes := make([]schema.PrefixRoute, 0, 1024)
-
-	worker := Call.GetWorker(id)
-	if worker == nil {
-		http.Error(w, "Network not found", http.StatusBadRequest)
-		return
-	}
-
-	worker.ListRoute(func(obj schema.PrefixRoute) {
-		routes = append(routes, obj)
-	})
-	ResponseJson(w, routes)
-}
-
-func (rt Route) Add(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	id := vars["id"]
-
-	worker := Call.GetWorker(id)
-	if worker == nil {
-		http.Error(w, "Network not found", http.StatusBadRequest)
-		return
-	}
-
-	pr := &schema.PrefixRoute{}
-	if err := GetData(r, pr); err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-
-	if err := worker.AddRoute(pr, rt.cs); err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-
-	ResponseJson(w, true)
-}
-
-func (rt Route) Del(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	id := vars["id"]
-
-	worker := Call.GetWorker(id)
-	if worker == nil {
-		http.Error(w, "Network not found", http.StatusBadRequest)
-		return
-	}
-
-	pr := &schema.PrefixRoute{}
-	if err := GetData(r, pr); err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-
-	if err := worker.DelRoute(pr, rt.cs); err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-
-	ResponseJson(w, true)
-}
-
-func (rt Route) Save(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	id := vars["id"]
-
-	worker := Call.GetWorker(id)
-	if worker == nil {
-		http.Error(w, "Network not found", http.StatusBadRequest)
-		return
-	}
-
-	worker.SaveRoute()
-
-	ResponseJson(w, true)
-
-}

pkg/api/system.go

@@ -11,14 +11,14 @@ import (
 	"github.com/luscis/openlan/pkg/schema"
 )
 
-type Prefix struct {
+type KernelRoute struct {
 }
 
-func (l Prefix) Router(router *mux.Router) {
-	router.HandleFunc("/api/prefix", l.List).Methods("GET")
+func (l KernelRoute) Router(router *mux.Router) {
+	router.HandleFunc("/api/kernel/route", l.List).Methods("GET")
 }
 
-func (l Prefix) List(w http.ResponseWriter, r *http.Request) {
+func (l KernelRoute) List(w http.ResponseWriter, r *http.Request) {
 	var items []schema.PrefixRoute
 
 	routes, _ := libol.ListRoutes()

pkg/api/url.go

@@ -5,10 +5,7 @@ import "github.com/gorilla/mux"
 func Add(router *mux.Router, cs SwitchApi) {
 	Link{cs: cs}.Router(router)
 	User{}.Router(router)
-	Ceci{}.Router(router)
-	Bgp{}.Router(router)
-	IPSec{}.Router(router)
-	Prefix{}.Router(router)
+	KernelRoute{}.Router(router)
 	Neighbor{}.Router(router)
 	Access{}.Router(router)
 	OnLine{}.Router(router)
@@ -20,14 +17,18 @@ func Add(router *mux.Router, cs SwitchApi) {
 	Config{cs: cs}.Router(router)
 	Version{}.Router(router)
 	Log{}.Router(router)
+	RateLimit{cs: cs}.Router(router)
+	Ceci{}.Router(router)
+	Bgp{}.Router(router)
+	IPSec{}.Router(router)
+
 	OpenAPI{}.Router(router)
 	ZTrust{}.Router(router)
-	Qos{}.Router(router)
+	ClientQoS{}.Router(router)
 	Output{cs: cs}.Router(router)
 	ACL{}.Router(router)
-	Route{cs: cs}.Router(router)
+	PrefixRoute{cs: cs}.Router(router)
 	FindHop{}.Router(router)
-	Rate{cs: cs}.Router(router)
 	SNAT{}.Router(router)
 	DNAT{}.Router(router)
 	RouterTunnel{}.Router(router)