add new APIs

api/api.go

@@ -17,6 +17,7 @@ var (
 type Response struct {
 	Code int         `json:"code,omitempty"`
 	Msg  string      `json:"msg,omitempty"`
+	Data interface{} `json:"data,omitempty"`
 }
 
 type Options struct {
@@ -58,66 +59,98 @@ func Register(r *gin.Engine, opts *Options) {
 
 	config.POST("/reload", reloadConfig)
 
+	config.GET("/services", getServiceList)
+	config.GET("/services/:service", getService)
 	config.POST("/services", createService)
 	config.PUT("/services/:service", updateService)
 	config.DELETE("/services/:service", deleteService)
 
+	config.GET("/chains", getChainList)
+	config.GET("/chains/:chain", getChain)
 	config.POST("/chains", createChain)
 	config.PUT("/chains/:chain", updateChain)
 	config.DELETE("/chains/:chain", deleteChain)
 
+	config.GET("/hops", getHopList)
+	config.GET("/hops/:hop", getHop)
 	config.POST("/hops", createHop)
 	config.PUT("/hops/:hop", updateHop)
 	config.DELETE("/hops/:hop", deleteHop)
 
+	config.GET("/authers", getAutherList)
+	config.GET("/authers/:auther", getAuther)
 	config.POST("/authers", createAuther)
 	config.PUT("/authers/:auther", updateAuther)
 	config.DELETE("/authers/:auther", deleteAuther)
 
+	config.GET("/admissions", getAdmissionList)
+	config.GET("/admissions/:admission", getAdmission)
 	config.POST("/admissions", createAdmission)
 	config.PUT("/admissions/:admission", updateAdmission)
 	config.DELETE("/admissions/:admission", deleteAdmission)
 
+	config.GET("/bypasses", getBypassList)
+	config.GET("/bypasses/:bypass", getBypass)
 	config.POST("/bypasses", createBypass)
 	config.PUT("/bypasses/:bypass", updateBypass)
 	config.DELETE("/bypasses/:bypass", deleteBypass)
 
+	config.GET("/resolvers", getResolverList)
+	config.GET("/resolvers/:resolver", getResolver)
 	config.POST("/resolvers", createResolver)
 	config.PUT("/resolvers/:resolver", updateResolver)
 	config.DELETE("/resolvers/:resolver", deleteResolver)
 
+	config.GET("/hosts", getHostsList)
+	config.GET("/hosts/:hosts", getHosts)
 	config.POST("/hosts", createHosts)
 	config.PUT("/hosts/:hosts", updateHosts)
 	config.DELETE("/hosts/:hosts", deleteHosts)
 
+	config.GET("/ingresses", getIngressList)
+	config.GET("/ingresses/:ingress", getIngress)
 	config.POST("/ingresses", createIngress)
 	config.PUT("/ingresses/:ingress", updateIngress)
 	config.DELETE("/ingresses/:ingress", deleteIngress)
 
+	config.GET("/routers", getRouterList)
+	config.GET("/routers/:router", getRouter)
 	config.POST("/routers", createRouter)
 	config.PUT("/routers/:router", updateRouter)
 	config.DELETE("/routers/:router", deleteRouter)
 
+	config.GET("/observers", getObserverList)
+	config.GET("/observers/:observer", getObserver)
 	config.POST("/observers", createObserver)
 	config.PUT("/observers/:observer", updateObserver)
 	config.DELETE("/observers/:observer", deleteObserver)
 
+	config.GET("/recorders", getRecorderList)
+	config.GET("/recorders/:recorder", getRecorder)
 	config.POST("/recorders", createRecorder)
 	config.PUT("/recorders/:recorder", updateRecorder)
 	config.DELETE("/recorders/:recorder", deleteRecorder)
 
+	config.GET("/sds", getSDList)
+	config.GET("/sds/:sd", getSD)
 	config.POST("/sds", createSD)
 	config.PUT("/sds/:sd", updateSD)
 	config.DELETE("/sds/:sd", deleteSD)
 
+	config.GET("/limiters", getLimiterList)
+	config.GET("/limiters/:limiter", getLimiter)
 	config.POST("/limiters", createLimiter)
 	config.PUT("/limiters/:limiter", updateLimiter)
 	config.DELETE("/limiters/:limiter", deleteLimiter)
 
+	config.GET("/climiters", getConnLimiterList)
+	config.GET("/climiters/:limiter", getConnLimiter)
 	config.POST("/climiters", createConnLimiter)
 	config.PUT("/climiters/:limiter", updateConnLimiter)
 	config.DELETE("/climiters/:limiter", deleteConnLimiter)
 
+	config.GET("/rlimiters", getRateLimiterList)
+	config.GET("/rlimiters/:limiter", getRateLimiter)
 	config.POST("/rlimiters", createRateLimiter)
 	config.PUT("/rlimiters/:limiter", updateRateLimiter)
 	config.DELETE("/rlimiters/:limiter", deleteRateLimiter)

api/config_admission.go

@@ -11,6 +11,93 @@ import (
 	"github.com/go-gost/x/registry"
 )
 
+// swagger:parameters getAdmissionListRequest
+type getAdmissionListRequest struct {
+}
+
+// successful operation.
+// swagger:response getAdmissionListResponse
+type getAdmissionListResponse struct {
+	// in: body
+	Data admissionList
+}
+
+type admissionList struct {
+	Count int                       `json:"count"`
+	List  []*config.AdmissionConfig `json:"list"`
+}
+
+func getAdmissionList(ctx *gin.Context) {
+	// swagger:route GET /config/admissions Admission getAdmissionListRequest
+	//
+	// Get admission list.
+	//
+	//     Security:
+	//       basicAuth: []
+	//
+	//     Responses:
+	//       200: getAdmissionListResponse
+
+	var req getAdmissionListRequest
+	ctx.ShouldBindQuery(&req)
+
+	list := config.Global().Admissions
+
+	var resp getAdmissionListResponse
+	resp.Data = admissionList{
+		Count: len(list),
+		List:  list,
+	}
+
+	ctx.JSON(http.StatusOK, Response{
+		Data: resp.Data,
+	})
+}
+
+// swagger:parameters getAdmissionRequest
+type getAdmissionRequest struct {
+	// in: path
+	// required: true
+	Admission string `uri:"admission" json:"admission"`
+}
+
+// successful operation.
+// swagger:response getAdmissionResponse
+type getAdmissionResponse struct {
+	// in: body
+	Data *config.AdmissionConfig
+}
+
+func getAdmission(ctx *gin.Context) {
+	// swagger:route GET /config/admissions/{admission} Admission getAdmissionRequest
+	//
+	// Get admission.
+	//
+	//     Security:
+	//       basicAuth: []
+	//
+	//     Responses:
+	//       200: getAdmissionResponse
+
+	var req getAdmissionRequest
+	ctx.ShouldBindUri(&req)
+
+	var resp getAdmissionResponse
+
+	for _, admission := range config.Global().Admissions {
+		if admission == nil {
+			continue
+		}
+		if admission.Name == req.Admission {
+			resp.Data = admission
+		}
+	}
+
+	ctx.JSON(http.StatusOK, Response{
+		Data: resp.Data,
+	})
+}
+
 // swagger:parameters createAdmissionRequest
 type createAdmissionRequest struct {
 	// in: body

api/config_auther.go

@@ -11,6 +11,93 @@ import (
 	"github.com/go-gost/x/registry"
 )
 
+// swagger:parameters getAutherListRequest
+type getAutherListRequest struct {
+}
+
+// successful operation.
+// swagger:response getAutherListResponse
+type getAutherListResponse struct {
+	// in: body
+	Data autherList
+}
+
+type autherList struct {
+	Count int                    `json:"count"`
+	List  []*config.AutherConfig `json:"list"`
+}
+
+func getAutherList(ctx *gin.Context) {
+	// swagger:route GET /config/authers Auther getAutherListRequest
+	//
+	// Get auther list.
+	//
+	//     Security:
+	//       basicAuth: []
+	//
+	//     Responses:
+	//       200: getAutherListResponse
+
+	var req getAutherListRequest
+	ctx.ShouldBindQuery(&req)
+
+	list := config.Global().Authers
+
+	var resp getAutherListResponse
+	resp.Data = autherList{
+		Count: len(list),
+		List:  list,
+	}
+
+	ctx.JSON(http.StatusOK, Response{
+		Data: resp.Data,
+	})
+}
+
+// swagger:parameters getAutherRequest
+type getAutherRequest struct {
+	// in: path
+	// required: true
+	Auther string `uri:"auther" json:"auther"`
+}
+
+// successful operation.
+// swagger:response getAutherResponse
+type getAutherResponse struct {
+	// in: body
+	Data *config.AutherConfig
+}
+
+func getAuther(ctx *gin.Context) {
+	// swagger:route GET /config/authers/{auther} Auther getAutherRequest
+	//
+	// Get auther.
+	//
+	//     Security:
+	//       basicAuth: []
+	//
+	//     Responses:
+	//       200: getAutherResponse
+
+	var req getAutherRequest
+	ctx.ShouldBindUri(&req)
+
+	var resp getAutherResponse
+
+	for _, auther := range config.Global().Authers {
+		if auther == nil {
+			continue
+		}
+		if auther.Name == req.Auther {
+			resp.Data = auther
+		}
+	}
+
+	ctx.JSON(http.StatusOK, Response{
+		Data: resp.Data,
+	})
+}
+
 // swagger:parameters createAutherRequest
 type createAutherRequest struct {
 	// in: body

api/config_bypass.go

@@ -11,6 +11,93 @@ import (
 	"github.com/go-gost/x/registry"
 )
 
+// swagger:parameters getBypassListRequest
+type getBypassListRequest struct {
+}
+
+// successful operation.
+// swagger:response getBypassListResponse
+type getBypassListResponse struct {
+	// in: body
+	Data bypassList
+}
+
+type bypassList struct {
+	Count int                       `json:"count"`
+	List  []*config.BypassConfig `json:"list"`
+}
+
+func getBypassList(ctx *gin.Context) {
+	// swagger:route GET /config/bypasses Bypass getBypassListRequest
+	//
+	// Get bypass list.
+	//
+	//     Security:
+	//       basicAuth: []
+	//
+	//     Responses:
+	//       200: getBypassListResponse
+
+	var req getBypassListRequest
+	ctx.ShouldBindQuery(&req)
+
+	list := config.Global().Bypasses
+
+	var resp getBypassListResponse
+	resp.Data = bypassList{
+		Count: len(list),
+		List:  list,
+	}
+
+	ctx.JSON(http.StatusOK, Response{
+		Data: resp.Data,
+	})
+}
+
+// swagger:parameters getBypassRequest
+type getBypassRequest struct {
+	// in: path
+	// required: true
+	Bypass string `uri:"bypass" json:"bypass"`
+}
+
+// successful operation.
+// swagger:response getBypassResponse
+type getBypassResponse struct {
+	// in: body
+	Data *config.BypassConfig
+}
+
+func getBypass(ctx *gin.Context) {
+	// swagger:route GET /config/bypasses/{bypass} Bypass getBypassRequest
+	//
+	// Get bypass.
+	//
+	//     Security:
+	//       basicAuth: []
+	//
+	//     Responses:
+	//       200: getBypassResponse
+
+	var req getBypassRequest
+	ctx.ShouldBindUri(&req)
+
+	var resp getBypassResponse
+
+	for _, bypass := range config.Global().Bypasses {
+		if bypass == nil {
+			continue
+		}
+		if bypass.Name == req.Bypass {
+			resp.Data = bypass
+		}
+	}
+
+	ctx.JSON(http.StatusOK, Response{
+		Data: resp.Data,
+	})
+}
+
 // swagger:parameters createBypassRequest
 type createBypassRequest struct {
 	// in: body

api/config_chain.go

@@ -12,6 +12,93 @@ import (
 	"github.com/go-gost/x/registry"
 )
 
+// swagger:parameters getChainListRequest
+type getChainListRequest struct {
+}
+
+// successful operation.
+// swagger:response getChainListResponse
+type getChainListResponse struct {
+	// in: body
+	Data chainList
+}
+
+type chainList struct {
+	Count int                       `json:"count"`
+	List  []*config.ChainConfig `json:"list"`
+}
+
+func getChainList(ctx *gin.Context) {
+	// swagger:route GET /config/chains Chain getChainListRequest
+	//
+	// Get chain list.
+	//
+	//     Security:
+	//       basicAuth: []
+	//
+	//     Responses:
+	//       200: getChainListResponse
+
+	var req getChainListRequest
+	ctx.ShouldBindQuery(&req)
+
+	list := config.Global().Chains
+
+	var resp getChainListResponse
+	resp.Data = chainList{
+		Count: len(list),
+		List:  list,
+	}
+
+	ctx.JSON(http.StatusOK, Response{
+		Data: resp.Data,
+	})
+}
+
+// swagger:parameters getChainRequest
+type getChainRequest struct {
+	// in: path
+	// required: true
+	Chain string `uri:"chain" json:"chain"`
+}
+
+// successful operation.
+// swagger:response getChainResponse
+type getChainResponse struct {
+	// in: body
+	Data *config.ChainConfig
+}
+
+func getChain(ctx *gin.Context) {
+	// swagger:route GET /config/chains/{chain} Chain getChainRequest
+	//
+	// Get chain.
+	//
+	//     Security:
+	//       basicAuth: []
+	//
+	//     Responses:
+	//       200: getChainResponse
+
+	var req getChainRequest
+	ctx.ShouldBindUri(&req)
+
+	var resp getChainResponse
+
+	for _, chain := range config.Global().Chains {
+		if chain == nil {
+			continue
+		}
+		if chain.Name == req.Chain {
+			resp.Data = chain
+		}
+	}
+
+	ctx.JSON(http.StatusOK, Response{
+		Data: resp.Data,
+	})
+}
+
 // swagger:parameters createChainRequest
 type createChainRequest struct {
 	// in: body

api/config_conn_limiter.go

@@ -11,6 +11,93 @@ import (
 	"github.com/go-gost/x/registry"
 )
 
+// swagger:parameters getConnLimiterListRequest
+type getConnLimiterListRequest struct {
+}
+
+// successful operation.
+// swagger:response getConnLimiterListResponse
+type getConnLimiterListResponse struct {
+	// in: body
+	Data connLimiterList
+}
+
+type connLimiterList struct {
+	Count int                       `json:"count"`
+	List  []*config.LimiterConfig `json:"list"`
+}
+
+func getConnLimiterList(ctx *gin.Context) {
+	// swagger:route GET /config/climiters Limiter getConnLimiterListRequest
+	//
+	// Get conn limiter list.
+	//
+	//     Security:
+	//       basicAuth: []
+	//
+	//     Responses:
+	//       200: getConnLimiterListResponse
+
+	var req getConnLimiterListRequest
+	ctx.ShouldBindQuery(&req)
+
+	list := config.Global().CLimiters
+
+	var resp getConnLimiterListResponse
+	resp.Data = connLimiterList{
+		Count: len(list),
+		List:  list,
+	}
+
+	ctx.JSON(http.StatusOK, Response{
+		Data: resp.Data,
+	})
+}
+
+// swagger:parameters getConnLimiterRequest
+type getConnLimiterRequest struct {
+	// in: path
+	// required: true
+	Limiter string `uri:"limiter" json:"limiter"`
+}
+
+// successful operation.
+// swagger:response getConnLimiterResponse
+type getConnLimiterResponse struct {
+	// in: body
+	Data *config.LimiterConfig
+}
+
+func getConnLimiter(ctx *gin.Context) {
+	// swagger:route GET /config/climiters/{limiter} Limiter getConnLimiterRequest
+	//
+	// Get conn limiter.
+	//
+	//     Security:
+	//       basicAuth: []
+	//
+	//     Responses:
+	//       200: getConnLimiterResponse
+
+	var req getConnLimiterRequest
+	ctx.ShouldBindUri(&req)
+
+	var resp getConnLimiterResponse
+
+	for _, limiter := range config.Global().CLimiters{
+		if limiter == nil {
+			continue
+		}
+		if limiter.Name == req.Limiter {
+			resp.Data = limiter
+		}
+	}
+
+	ctx.JSON(http.StatusOK, Response{
+		Data: resp.Data,
+	})
+}
+
 // swagger:parameters createConnLimiterRequest
 type createConnLimiterRequest struct {
 	// in: body

api/config_hop.go

@@ -12,6 +12,93 @@ import (
 	"github.com/go-gost/x/registry"
 )
 
+// swagger:parameters getHopListRequest
+type getHopListRequest struct {
+}
+
+// successful operation.
+// swagger:response getHopListResponse
+type getHopListResponse struct {
+	// in: body
+	Data hopList
+}
+
+type hopList struct {
+	Count int                       `json:"count"`
+	List  []*config.HopConfig `json:"list"`
+}
+
+func getHopList(ctx *gin.Context) {
+	// swagger:route GET /config/hops Hop getHopListRequest
+	//
+	// Get hop list.
+	//
+	//     Security:
+	//       basicAuth: []
+	//
+	//     Responses:
+	//       200: getHopListResponse
+
+	var req getHopListRequest
+	ctx.ShouldBindQuery(&req)
+
+	list := config.Global().Hops
+
+	var resp getHopListResponse
+	resp.Data = hopList{
+		Count: len(list),
+		List:  list,
+	}
+
+	ctx.JSON(http.StatusOK, Response{
+		Data: resp.Data,
+	})
+}
+
+// swagger:parameters getHopRequest
+type getHopRequest struct {
+	// in: path
+	// required: true
+	Hop string `uri:"hop" json:"hop"`
+}
+
+// successful operation.
+// swagger:response getHopResponse
+type getHopResponse struct {
+	// in: body
+	Data *config.HopConfig
+}
+
+func getHop(ctx *gin.Context) {
+	// swagger:route GET /config/hops/{hop} Hop getHopRequest
+	//
+	// Get hop.
+	//
+	//     Security:
+	//       basicAuth: []
+	//
+	//     Responses:
+	//       200: getHopResponse
+
+	var req getHopRequest
+	ctx.ShouldBindUri(&req)
+
+	var resp getHopResponse
+
+	for _, hop := range config.Global().Hops {
+		if hop == nil {
+			continue
+		}
+		if hop.Name == req.Hop {
+			resp.Data = hop
+		}
+	}
+
+	ctx.JSON(http.StatusOK, Response{
+		Data: resp.Data,
+	})
+}
+
 // swagger:parameters createHopRequest
 type createHopRequest struct {
 	// in: body

api/config_hosts.go

@@ -11,6 +11,93 @@ import (
 	"github.com/go-gost/x/registry"
 )
 
+// swagger:parameters getHostsListRequest
+type getHostsListRequest struct {
+}
+
+// successful operation.
+// swagger:response getHostsListResponse
+type getHostsListResponse struct {
+	// in: body
+	Data hostsList
+}
+
+type hostsList struct {
+	Count int                   `json:"count"`
+	List  []*config.HostsConfig `json:"list"`
+}
+
+func getHostsList(ctx *gin.Context) {
+	// swagger:route GET /config/hosts Hosts getHostsListRequest
+	//
+	// Get hosts list.
+	//
+	//     Security:
+	//       basicAuth: []
+	//
+	//     Responses:
+	//       200: getHostsListResponse
+
+	var req getHostsListRequest
+	ctx.ShouldBindQuery(&req)
+
+	list := config.Global().Hosts
+
+	var resp getHostsListResponse
+	resp.Data = hostsList{
+		Count: len(list),
+		List:  list,
+	}
+
+	ctx.JSON(http.StatusOK, Response{
+		Data: resp.Data,
+	})
+}
+
+// swagger:parameters getHostsRequest
+type getHostsRequest struct {
+	// in: path
+	// required: true
+	Hosts string `uri:"hosts" json:"hosts"`
+}
+
+// successful operation.
+// swagger:response getHostsResponse
+type getHostsResponse struct {
+	// in: body
+	Data *config.HostsConfig
+}
+
+func getHosts(ctx *gin.Context) {
+	// swagger:route GET /config/hosts/{hosts} Hosts getHostsRequest
+	//
+	// Get hosts.
+	//
+	//     Security:
+	//       basicAuth: []
+	//
+	//     Responses:
+	//       200: getHostsResponse
+
+	var req getHostsRequest
+	ctx.ShouldBindUri(&req)
+
+	var resp getHostsResponse
+
+	for _, hosts := range config.Global().Hosts {
+		if hosts == nil {
+			continue
+		}
+		if hosts.Name == req.Hosts {
+			resp.Data = hosts
+		}
+	}
+
+	ctx.JSON(http.StatusOK, Response{
+		Data: resp.Data,
+	})
+}
+
 // swagger:parameters createHostsRequest
 type createHostsRequest struct {
 	// in: body

api/config_ingress.go

@@ -11,6 +11,93 @@ import (
 	"github.com/go-gost/x/registry"
 )
 
+// swagger:parameters getIngressListRequest
+type getIngressListRequest struct {
+}
+
+// successful operation.
+// swagger:response getIngressListResponse
+type getIngressListResponse struct {
+	// in: body
+	Data ingressList
+}
+
+type ingressList struct {
+	Count int                       `json:"count"`
+	List  []*config.IngressConfig `json:"list"`
+}
+
+func getIngressList(ctx *gin.Context) {
+	// swagger:route GET /config/ingresses Ingress getIngressListRequest
+	//
+	// Get ingress list.
+	//
+	//     Security:
+	//       basicAuth: []
+	//
+	//     Responses:
+	//       200: getIngressListResponse
+
+	var req getIngressListRequest
+	ctx.ShouldBindQuery(&req)
+
+	list := config.Global().Ingresses
+
+	var resp getIngressListResponse
+	resp.Data = ingressList{
+		Count: len(list),
+		List:  list,
+	}
+
+	ctx.JSON(http.StatusOK, Response{
+		Data: resp.Data,
+	})
+}
+
+// swagger:parameters getIngressRequest
+type getIngressRequest struct {
+	// in: path
+	// required: true
+	Ingress string `uri:"ingress" json:"ingress"`
+}
+
+// successful operation.
+// swagger:response getIngressResponse
+type getIngressResponse struct {
+	// in: body
+	Data *config.IngressConfig
+}
+
+func getIngress(ctx *gin.Context) {
+	// swagger:route GET /config/ingresses/{ingress} Ingress getIngressRequest
+	//
+	// Get ingress.
+	//
+	//     Security:
+	//       basicAuth: []
+	//
+	//     Responses:
+	//       200: getIngressResponse
+
+	var req getIngressRequest
+	ctx.ShouldBindUri(&req)
+
+	var resp getIngressResponse
+
+	for _, ingress := range config.Global().Ingresses {
+		if ingress == nil {
+			continue
+		}
+		if ingress.Name == req.Ingress {
+			resp.Data = ingress
+		}
+	}
+
+	ctx.JSON(http.StatusOK, Response{
+		Data: resp.Data,
+	})
+}
+
 // swagger:parameters createIngressRequest
 type createIngressRequest struct {
 	// in: body

api/config_limiter.go

@@ -11,6 +11,93 @@ import (
 	"github.com/go-gost/x/registry"
 )
 
+// swagger:parameters getLimiterListRequest
+type getLimiterListRequest struct {
+}
+
+// successful operation.
+// swagger:response getLimiterListResponse
+type getLimiterListResponse struct {
+	// in: body
+	Data limiterList
+}
+
+type limiterList struct {
+	Count int                       `json:"count"`
+	List  []*config.LimiterConfig `json:"list"`
+}
+
+func getLimiterList(ctx *gin.Context) {
+	// swagger:route GET /config/limiters Limiter getLimiterListRequest
+	//
+	// Get limiter list.
+	//
+	//     Security:
+	//       basicAuth: []
+	//
+	//     Responses:
+	//       200: getLimiterListResponse
+
+	var req getLimiterListRequest
+	ctx.ShouldBindQuery(&req)
+
+	list := config.Global().Limiters
+
+	var resp getLimiterListResponse
+	resp.Data = limiterList{
+		Count: len(list),
+		List:  list,
+	}
+
+	ctx.JSON(http.StatusOK, Response{
+		Data: resp.Data,
+	})
+}
+
+// swagger:parameters getLimiterRequest
+type getLimiterRequest struct {
+	// in: path
+	// required: true
+	Limiter string `uri:"limiter" json:"limiter"`
+}
+
+// successful operation.
+// swagger:response getLimiterResponse
+type getLimiterResponse struct {
+	// in: body
+	Data *config.LimiterConfig
+}
+
+func getLimiter(ctx *gin.Context) {
+	// swagger:route GET /config/limiters/{limiter} Limiter getLimiterRequest
+	//
+	// Get limiter.
+	//
+	//     Security:
+	//       basicAuth: []
+	//
+	//     Responses:
+	//       200: getLimiterResponse
+
+	var req getLimiterRequest
+	ctx.ShouldBindUri(&req)
+
+	var resp getLimiterResponse
+
+	for _, limiter := range config.Global().Limiters {
+		if limiter == nil {
+			continue
+		}
+		if limiter.Name == req.Limiter {
+			resp.Data = limiter
+		}
+	}
+
+	ctx.JSON(http.StatusOK, Response{
+		Data: resp.Data,
+	})
+}
+
 // swagger:parameters createLimiterRequest
 type createLimiterRequest struct {
 	// in: body

api/config_observer.go

@@ -11,6 +11,93 @@ import (
 	"github.com/go-gost/x/registry"
 )
 
+// swagger:parameters getObserverListRequest
+type getObserverListRequest struct {
+}
+
+// successful operation.
+// swagger:response getObserverListResponse
+type getObserverListResponse struct {
+	// in: body
+	Data observerList
+}
+
+type observerList struct {
+	Count int                       `json:"count"`
+	List  []*config.ObserverConfig `json:"list"`
+}
+
+func getObserverList(ctx *gin.Context) {
+	// swagger:route GET /config/observers Observer getObserverListRequest
+	//
+	// Get observer list.
+	//
+	//     Security:
+	//       basicAuth: []
+	//
+	//     Responses:
+	//       200: getObserverListResponse
+
+	var req getObserverListRequest
+	ctx.ShouldBindQuery(&req)
+
+	list := config.Global().Observers
+
+	var resp getObserverListResponse
+	resp.Data = observerList{
+		Count: len(list),
+		List:  list,
+	}
+
+	ctx.JSON(http.StatusOK, Response{
+		Data: resp.Data,
+	})
+}
+
+// swagger:parameters getObserverRequest
+type getObserverRequest struct {
+	// in: path
+	// required: true
+	Observer string `uri:"observer" json:"observer"`
+}
+
+// successful operation.
+// swagger:response getObserverResponse
+type getObserverResponse struct {
+	// in: body
+	Data *config.ObserverConfig
+}
+
+func getObserver(ctx *gin.Context) {
+	// swagger:route GET /config/observers/{observer} Observer getObserverRequest
+	//
+	// Get observer.
+	//
+	//     Security:
+	//       basicAuth: []
+	//
+	//     Responses:
+	//       200: getObserverResponse
+
+	var req getObserverRequest
+	ctx.ShouldBindUri(&req)
+
+	var resp getObserverResponse
+
+	for _, observer := range config.Global().Observers {
+		if observer == nil {
+			continue
+		}
+		if observer.Name == req.Observer {
+			resp.Data = observer
+		}
+	}
+
+	ctx.JSON(http.StatusOK, Response{
+		Data: resp.Data,
+	})
+}
+
 // swagger:parameters createObserverRequest
 type createObserverRequest struct {
 	// in: body

api/config_rate_limiter.go

@@ -11,6 +11,93 @@ import (
 	"github.com/go-gost/x/registry"
 )
 
+// swagger:parameters getRateLimiterListRequest
+type getRateLimiterListRequest struct {
+}
+
+// successful operation.
+// swagger:response getRateLimiterListResponse
+type getRateLimiterListResponse struct {
+	// in: body
+	Data rateLimiterList
+}
+
+type rateLimiterList struct {
+	Count int                       `json:"count"`
+	List  []*config.LimiterConfig `json:"list"`
+}
+
+func getRateLimiterList(ctx *gin.Context) {
+	// swagger:route GET /config/rlimiters Limiter getRateLimiterListRequest
+	//
+	// Get rate limiter list.
+	//
+	//     Security:
+	//       basicAuth: []
+	//
+	//     Responses:
+	//       200: getRateLimiterListResponse
+
+	var req getRateLimiterListRequest
+	ctx.ShouldBindQuery(&req)
+
+	list := config.Global().CLimiters
+
+	var resp getRateLimiterListResponse
+	resp.Data = rateLimiterList{
+		Count: len(list),
+		List:  list,
+	}
+
+	ctx.JSON(http.StatusOK, Response{
+		Data: resp.Data,
+	})
+}
+
+// swagger:parameters getRateLimiterRequest
+type getRateLimiterRequest struct {
+	// in: path
+	// required: true
+	Limiter string `uri:"limiter" json:"limiter"`
+}
+
+// successful operation.
+// swagger:response getRateLimiterResponse
+type getRateLimiterResponse struct {
+	// in: body
+	Data *config.LimiterConfig
+}
+
+func getRateLimiter(ctx *gin.Context) {
+	// swagger:route GET /config/rlimiters/{limiter} Limiter getRateLimiterRequest
+	//
+	// Get conn limiter.
+	//
+	//     Security:
+	//       basicAuth: []
+	//
+	//     Responses:
+	//       200: getRateLimiterResponse
+
+	var req getRateLimiterRequest
+	ctx.ShouldBindUri(&req)
+
+	var resp getRateLimiterResponse
+
+	for _, limiter := range config.Global().CLimiters{
+		if limiter == nil {
+			continue
+		}
+		if limiter.Name == req.Limiter {
+			resp.Data = limiter
+		}
+	}
+
+	ctx.JSON(http.StatusOK, Response{
+		Data: resp.Data,
+	})
+}
+
 // swagger:parameters createRateLimiterRequest
 type createRateLimiterRequest struct {
 	// in: body

api/config_recorder.go

@@ -11,6 +11,93 @@ import (
 	"github.com/go-gost/x/registry"
 )
 
+// swagger:parameters getRecorderListRequest
+type getRecorderListRequest struct {
+}
+
+// successful operation.
+// swagger:response getRecorderListResponse
+type getRecorderListResponse struct {
+	// in: body
+	Data recorderList
+}
+
+type recorderList struct {
+	Count int                       `json:"count"`
+	List  []*config.RecorderConfig `json:"list"`
+}
+
+func getRecorderList(ctx *gin.Context) {
+	// swagger:route GET /config/recorders Recorder getRecorderListRequest
+	//
+	// Get recorder list.
+	//
+	//     Security:
+	//       basicAuth: []
+	//
+	//     Responses:
+	//       200: getRecorderListResponse
+
+	var req getRecorderListRequest
+	ctx.ShouldBindQuery(&req)
+
+	list := config.Global().Recorders
+
+	var resp getRecorderListResponse
+	resp.Data = recorderList{
+		Count: len(list),
+		List:  list,
+	}
+
+	ctx.JSON(http.StatusOK, Response{
+		Data: resp.Data,
+	})
+}
+
+// swagger:parameters getRecorderRequest
+type getRecorderRequest struct {
+	// in: path
+	// required: true
+	Recorder string `uri:"recorder" json:"recorder"`
+}
+
+// successful operation.
+// swagger:response getRecorderResponse
+type getRecorderResponse struct {
+	// in: body
+	Data *config.RecorderConfig
+}
+
+func getRecorder(ctx *gin.Context) {
+	// swagger:route GET /config/recorders/{recorder} Recorder getRecorderRequest
+	//
+	// Get recorder.
+	//
+	//     Security:
+	//       basicAuth: []
+	//
+	//     Responses:
+	//       200: getRecorderResponse
+
+	var req getRecorderRequest
+	ctx.ShouldBindUri(&req)
+
+	var resp getRecorderResponse
+
+	for _, recorder := range config.Global().Recorders {
+		if recorder == nil {
+			continue
+		}
+		if recorder.Name == req.Recorder {
+			resp.Data = recorder
+		}
+	}
+
+	ctx.JSON(http.StatusOK, Response{
+		Data: resp.Data,
+	})
+}
+
 // swagger:parameters createRecorderRequest
 type createRecorderRequest struct {
 	// in: body

api/config_resolver.go

@@ -11,6 +11,93 @@ import (
 	"github.com/go-gost/x/registry"
 )
 
+// swagger:parameters getResolverListRequest
+type getResolverListRequest struct {
+}
+
+// successful operation.
+// swagger:response getResolverListResponse
+type getResolverListResponse struct {
+	// in: body
+	Data resolverList
+}
+
+type resolverList struct {
+	Count int                       `json:"count"`
+	List  []*config.ResolverConfig `json:"list"`
+}
+
+func getResolverList(ctx *gin.Context) {
+	// swagger:route GET /config/resolvers Resolver getResolverListRequest
+	//
+	// Get resolver list.
+	//
+	//     Security:
+	//       basicAuth: []
+	//
+	//     Responses:
+	//       200: getResolverListResponse
+
+	var req getResolverListRequest
+	ctx.ShouldBindQuery(&req)
+
+	list := config.Global().Resolvers
+
+	var resp getResolverListResponse
+	resp.Data = resolverList{
+		Count: len(list),
+		List:  list,
+	}
+
+	ctx.JSON(http.StatusOK, Response{
+		Data: resp.Data,
+	})
+}
+
+// swagger:parameters getResolverRequest
+type getResolverRequest struct {
+	// in: path
+	// required: true
+	Resolver string `uri:"resolver" json:"resolver"`
+}
+
+// successful operation.
+// swagger:response getResolverResponse
+type getResolverResponse struct {
+	// in: body
+	Data *config.ResolverConfig
+}
+
+func getResolver(ctx *gin.Context) {
+	// swagger:route GET /config/resolvers/{resolver} Resolver getResolverRequest
+	//
+	// Get resolver.
+	//
+	//     Security:
+	//       basicAuth: []
+	//
+	//     Responses:
+	//       200: getResolverResponse
+
+	var req getResolverRequest
+	ctx.ShouldBindUri(&req)
+
+	var resp getResolverResponse
+
+	for _, resolver := range config.Global().Resolvers {
+		if resolver == nil {
+			continue
+		}
+		if resolver.Name == req.Resolver {
+			resp.Data = resolver
+		}
+	}
+
+	ctx.JSON(http.StatusOK, Response{
+		Data: resp.Data,
+	})
+}
+
 // swagger:parameters createResolverRequest
 type createResolverRequest struct {
 	// in: body

api/config_router.go

@@ -11,6 +11,93 @@ import (
 	"github.com/go-gost/x/registry"
 )
 
+// swagger:parameters getRouterListRequest
+type getRouterListRequest struct {
+}
+
+// successful operation.
+// swagger:response getRouterListResponse
+type getRouterListResponse struct {
+	// in: body
+	Data routerList
+}
+
+type routerList struct {
+	Count int                       `json:"count"`
+	List  []*config.RouterConfig `json:"list"`
+}
+
+func getRouterList(ctx *gin.Context) {
+	// swagger:route GET /config/routers Router getRouterListRequest
+	//
+	// Get router list.
+	//
+	//     Security:
+	//       basicAuth: []
+	//
+	//     Responses:
+	//       200: getRouterListResponse
+
+	var req getRouterListRequest
+	ctx.ShouldBindQuery(&req)
+
+	list := config.Global().Routers
+
+	var resp getRouterListResponse
+	resp.Data = routerList{
+		Count: len(list),
+		List:  list,
+	}
+
+	ctx.JSON(http.StatusOK, Response{
+		Data: resp.Data,
+	})
+}
+
+// swagger:parameters getRouterRequest
+type getRouterRequest struct {
+	// in: path
+	// required: true
+	Router string `uri:"router" json:"router"`
+}
+
+// successful operation.
+// swagger:response getRouterResponse
+type getRouterResponse struct {
+	// in: body
+	Data *config.RouterConfig
+}
+
+func getRouter(ctx *gin.Context) {
+	// swagger:route GET /config/routers/{router} Router getRouterRequest
+	//
+	// Get router.
+	//
+	//     Security:
+	//       basicAuth: []
+	//
+	//     Responses:
+	//       200: getRouterResponse
+
+	var req getRouterRequest
+	ctx.ShouldBindUri(&req)
+
+	var resp getRouterResponse
+
+	for _, router := range config.Global().Routers {
+		if router == nil {
+			continue
+		}
+		if router.Name == req.Router {
+			resp.Data = router
+		}
+	}
+
+	ctx.JSON(http.StatusOK, Response{
+		Data: resp.Data,
+	})
+}
+
 // swagger:parameters createRouterRequest
 type createRouterRequest struct {
 	// in: body

api/config_sd.go

@@ -11,6 +11,93 @@ import (
 	"github.com/go-gost/x/registry"
 )
 
+// swagger:parameters getSDListRequest
+type getSDListRequest struct {
+}
+
+// successful operation.
+// swagger:response getSDListResponse
+type getSDListResponse struct {
+	// in: body
+	Data sdList
+}
+
+type sdList struct {
+	Count int                       `json:"count"`
+	List  []*config.SDConfig `json:"list"`
+}
+
+func getSDList(ctx *gin.Context) {
+	// swagger:route GET /config/sds SD getSDListRequest
+	//
+	// Get sd list.
+	//
+	//     Security:
+	//       basicAuth: []
+	//
+	//     Responses:
+	//       200: getSDListResponse
+
+	var req getSDListRequest
+	ctx.ShouldBindQuery(&req)
+
+	list := config.Global().SDs
+
+	var resp getSDListResponse
+	resp.Data = sdList{
+		Count: len(list),
+		List:  list,
+	}
+
+	ctx.JSON(http.StatusOK, Response{
+		Data: resp.Data,
+	})
+}
+
+// swagger:parameters getSDRequest
+type getSDRequest struct {
+	// in: path
+	// required: true
+	SD string `uri:"sd" json:"sd"`
+}
+
+// successful operation.
+// swagger:response getSDResponse
+type getSDResponse struct {
+	// in: body
+	Data *config.SDConfig
+}
+
+func getSD(ctx *gin.Context) {
+	// swagger:route GET /config/sds/{sd} SD getSDRequest
+	//
+	// Get sd.
+	//
+	//     Security:
+	//       basicAuth: []
+	//
+	//     Responses:
+	//       200: getSDResponse
+
+	var req getSDRequest
+	ctx.ShouldBindUri(&req)
+
+	var resp getSDResponse
+
+	for _, sd := range config.Global().SDs {
+		if sd == nil {
+			continue
+		}
+		if sd.Name == req.SD {
+			resp.Data = sd
+		}
+	}
+
+	ctx.JSON(http.StatusOK, Response{
+		Data: resp.Data,
+	})
+}
+
 // swagger:parameters createSDRequest
 type createSDRequest struct {
 	// in: body

api/config_service.go

@@ -11,6 +11,93 @@ import (
 	"github.com/go-gost/x/registry"
 )
 
+// swagger:parameters getServiceListRequest
+type getServiceListRequest struct {
+}
+
+// successful operation.
+// swagger:response getServiceListResponse
+type getServiceListResponse struct {
+	// in: body
+	Data serviceList
+}
+
+type serviceList struct {
+	Count int                       `json:"count"`
+	List  []*config.ServiceConfig `json:"list"`
+}
+
+func getServiceList(ctx *gin.Context) {
+	// swagger:route GET /config/services Service getServiceListRequest
+	//
+	// Get service list.
+	//
+	//     Security:
+	//       basicAuth: []
+	//
+	//     Responses:
+	//       200: getServiceListResponse
+
+	var req getServiceListRequest
+	ctx.ShouldBindQuery(&req)
+
+	list := config.Global().Services
+
+	var resp getServiceListResponse
+	resp.Data = serviceList{
+		Count: len(list),
+		List:  list,
+	}
+
+	ctx.JSON(http.StatusOK, Response{
+		Data: resp.Data,
+	})
+}
+
+// swagger:parameters getServiceRequest
+type getServiceRequest struct {
+	// in: path
+	// required: true
+	Service string `uri:"service" json:"service"`
+}
+
+// successful operation.
+// swagger:response getServiceResponse
+type getServiceResponse struct {
+	// in: body
+	Data *config.ServiceConfig
+}
+
+func getService(ctx *gin.Context) {
+	// swagger:route GET /config/services/{service} Service getServiceRequest
+	//
+	// Get service.
+	//
+	//     Security:
+	//       basicAuth: []
+	//
+	//     Responses:
+	//       200: getServiceResponse
+
+	var req getServiceRequest
+	ctx.ShouldBindUri(&req)
+
+	var resp getServiceResponse
+
+	for _, service := range config.Global().Services {
+		if service == nil {
+			continue
+		}
+		if service.Name == req.Service {
+			resp.Data = service
+		}
+	}
+
+	ctx.JSON(http.StatusOK, Response{
+		Data: resp.Data,
+	})
+}
+
 // swagger:parameters createServiceRequest
 type createServiceRequest struct {
 	// in: body