Add: config hub route

constant/rule.go

@@ -11,8 +11,26 @@ const (
 
 type RuleType int
 
+func (rt RuleType) String() string {
+	switch rt {
+	case DomainSuffix:
+		return "DomainSuffix"
+	case DomainKeyword:
+		return "DomainKeyword"
+	case GEOIP:
+		return "GEOIP"
+	case IPCIDR:
+		return "IPCIDR"
+	case FINAL:
+		return "FINAL"
+	default:
+		return "Unknow"
+	}
+}
+
 type Rule interface {
 	RuleType() RuleType
 	IsMatch(addr *Addr) bool
 	Adapter() string
+	Payload() string
 }

hub/configs.go

@@ -0,0 +1,67 @@
+package hub
+
+import (
+	"net/http"
+
+	"github.com/go-chi/chi"
+	"github.com/go-chi/render"
+)
+
+type Configs struct {
+	Proxys []Proxy `json:"proxys"`
+	Rules  []Rule  `json:"rules"`
+}
+
+type Proxy struct {
+	Name string `json:"name"`
+}
+
+type Rule struct {
+	Name    string `json:"name"`
+	Payload string `json:"type"`
+}
+
+func configRouter() http.Handler {
+	r := chi.NewRouter()
+	r.Get("/", getConfig)
+	r.Put("/", updateConfig)
+	return r
+}
+
+func getConfig(w http.ResponseWriter, r *http.Request) {
+	rulesCfg, proxysCfg := tun.Config()
+
+	var (
+		rules  []Rule
+		proxys []Proxy
+	)
+
+	for _, rule := range rulesCfg {
+		rules = append(rules, Rule{
+			Name:    rule.RuleType().String(),
+			Payload: rule.Payload(),
+		})
+	}
+
+	for _, proxy := range proxysCfg {
+		proxys = append(proxys, Proxy{Name: proxy.Name()})
+	}
+
+	w.WriteHeader(http.StatusOK)
+	render.JSON(w, r, Configs{
+		Rules:  rules,
+		Proxys: proxys,
+	})
+}
+
+func updateConfig(w http.ResponseWriter, r *http.Request) {
+	err := tun.UpdateConfig()
+	if err != nil {
+		w.WriteHeader(http.StatusInternalServerError)
+		render.JSON(w, r, Error{
+			Error: err.Error(),
+		})
+		return
+	}
+	w.WriteHeader(http.StatusNoContent)
+}

hub/server.go

@@ -35,6 +35,7 @@ func NewHub(addr string) {
 
 	r.Get("/traffic", traffic)
 	r.Get("/logs", getLogs)
+	r.Mount("/configs", configRouter())
 
 	err := http.ListenAndServe(addr, r)
 	if err != nil {
@@ -43,7 +44,7 @@ func NewHub(addr string) {
 }
 
 func traffic(w http.ResponseWriter, r *http.Request) {
-	render.Status(r, http.StatusOK)
+	w.WriteHeader(http.StatusOK)
 
 	tick := time.NewTicker(time.Second)
 	t := tun.Traffic()
@@ -64,10 +65,11 @@ func getLogs(w http.ResponseWriter, r *http.Request) {
 	sub, err := src.Subscribe()
 	defer src.UnSubscribe(sub)
 	if err != nil {
-		render.Status(r, http.StatusInternalServerError)
+		w.WriteHeader(http.StatusInternalServerError)
 		render.JSON(w, r, Error{
 			Error: err.Error(),
 		})
+		return
 	}
 	render.Status(r, http.StatusOK)
 	for elm := range sub {

rules/domain_keyword.go

@@ -27,6 +27,10 @@ func (dk *DomainKeyword) Adapter() string {
 	return dk.adapter
 }
 
+func (dk *DomainKeyword) Payload() string {
+	return dk.keyword
+}
+
 func NewDomainKeyword(keyword string, adapter string) *DomainKeyword {
 	return &DomainKeyword{
 		keyword: keyword,

rules/domain_suffix.go

@@ -27,6 +27,10 @@ func (ds *DomainSuffix) Adapter() string {
 	return ds.adapter
 }
 
+func (ds *DomainSuffix) Payload() string {
+	return ds.suffix
+}
+
 func NewDomainSuffix(suffix string, adapter string) *DomainSuffix {
 	return &DomainSuffix{
 		suffix:  suffix,

rules/final.go

@@ -20,6 +20,10 @@ func (f *Final) Adapter() string {
 	return f.adapter
 }
 
+func (f *Final) Payload() string {
+	return ""
+}
+
 func NewFinal(adapter string) *Final {
 	return &Final{
 		adapter: adapter,

rules/geoip.go

@@ -38,6 +38,10 @@ func (g *GEOIP) Adapter() string {
 	return g.adapter
 }
 
+func (g *GEOIP) Payload() string {
+	return g.country
+}
+
 func NewGEOIP(country string, adapter string) *GEOIP {
 	return &GEOIP{
 		country: country,

rules/ipcidr.go

@@ -23,8 +23,12 @@ func (i *IPCIDR) IsMatch(addr *C.Addr) bool {
 	return i.ipnet.Contains(*addr.IP)
 }
 
-func (g *IPCIDR) Adapter() string {
+func (i *IPCIDR) Adapter() string {
-	return g.adapter
+	return i.adapter
+}
+
+func (i *IPCIDR) Payload() string {
+	return i.ipnet.String()
 }
 
 func NewIPCIDR(s string, adapter string) *IPCIDR {

tunnel/tunnel.go

@@ -38,6 +38,10 @@ func (t *Tunnel) Traffic() *C.Traffic {
 	return t.traffic
 }
 
+func (t *Tunnel) Config() ([]C.Rule, map[string]C.Proxy) {
+	return t.rules, t.proxys
+}
+
 func (t *Tunnel) Log() *observable.Observable {
 	return t.observable
 }