traefik/pkg/api/handler_tcp.go

240 lines
6.7 KiB
Go
Raw Normal View History

2019-07-12 09:10:03 +00:00
package api
import (
"encoding/json"
2019-09-02 09:38:04 +00:00
"fmt"
2019-07-12 09:10:03 +00:00
"net/http"
"strconv"
2019-09-02 09:38:04 +00:00
"strings"
2019-07-12 09:10:03 +00:00
2019-08-03 01:58:23 +00:00
"github.com/gorilla/mux"
2022-11-21 17:36:05 +00:00
"github.com/rs/zerolog/log"
2023-02-03 14:24:05 +00:00
"github.com/traefik/traefik/v3/pkg/config/runtime"
2019-07-12 09:10:03 +00:00
)
type tcpRouterRepresentation struct {
*runtime.TCPRouterInfo
2019-07-12 09:10:03 +00:00
Name string `json:"name,omitempty"`
Provider string `json:"provider,omitempty"`
}
2019-09-02 09:38:04 +00:00
func newTCPRouterRepresentation(name string, rt *runtime.TCPRouterInfo) tcpRouterRepresentation {
return tcpRouterRepresentation{
TCPRouterInfo: rt,
Name: name,
Provider: getProviderName(name),
}
}
2019-07-12 09:10:03 +00:00
type tcpServiceRepresentation struct {
*runtime.TCPServiceInfo
2019-07-12 09:10:03 +00:00
Name string `json:"name,omitempty"`
Provider string `json:"provider,omitempty"`
2019-09-02 09:38:04 +00:00
Type string `json:"type,omitempty"`
}
func newTCPServiceRepresentation(name string, si *runtime.TCPServiceInfo) tcpServiceRepresentation {
return tcpServiceRepresentation{
TCPServiceInfo: si,
Name: name,
Provider: getProviderName(name),
Type: strings.ToLower(extractType(si.TCPService)),
}
2019-07-12 09:10:03 +00:00
}
2021-06-11 13:30:05 +00:00
type tcpMiddlewareRepresentation struct {
*runtime.TCPMiddlewareInfo
Name string `json:"name,omitempty"`
Provider string `json:"provider,omitempty"`
Type string `json:"type,omitempty"`
}
func newTCPMiddlewareRepresentation(name string, mi *runtime.TCPMiddlewareInfo) tcpMiddlewareRepresentation {
return tcpMiddlewareRepresentation{
TCPMiddlewareInfo: mi,
Name: name,
Provider: getProviderName(name),
Type: strings.ToLower(extractType(mi.TCPMiddleware)),
}
}
2019-07-12 09:10:03 +00:00
func (h Handler) getTCPRouters(rw http.ResponseWriter, request *http.Request) {
results := make([]tcpRouterRepresentation, 0, len(h.runtimeConfiguration.TCPRouters))
query := request.URL.Query()
criterion := newSearchCriterion(query)
2019-09-02 09:38:04 +00:00
2019-07-12 09:10:03 +00:00
for name, rt := range h.runtimeConfiguration.TCPRouters {
2019-09-02 09:38:04 +00:00
if keepTCPRouter(name, rt, criterion) {
results = append(results, newTCPRouterRepresentation(name, rt))
}
2019-07-12 09:10:03 +00:00
}
sortRouters(query, results)
2019-07-12 09:10:03 +00:00
2019-09-02 09:38:04 +00:00
rw.Header().Set("Content-Type", "application/json")
2019-07-12 09:10:03 +00:00
pageInfo, err := pagination(request, len(results))
if err != nil {
2019-09-02 09:38:04 +00:00
writeError(rw, err.Error(), http.StatusBadRequest)
2019-07-12 09:10:03 +00:00
return
}
rw.Header().Set(nextPageHeader, strconv.Itoa(pageInfo.nextPage))
err = json.NewEncoder(rw).Encode(results[pageInfo.startIndex:pageInfo.endIndex])
if err != nil {
2022-11-21 17:36:05 +00:00
log.Ctx(request.Context()).Error().Err(err).Send()
2019-09-02 09:38:04 +00:00
writeError(rw, err.Error(), http.StatusInternalServerError)
2019-07-12 09:10:03 +00:00
}
}
func (h Handler) getTCPRouter(rw http.ResponseWriter, request *http.Request) {
routerID := mux.Vars(request)["routerID"]
2019-09-02 09:38:04 +00:00
rw.Header().Set("Content-Type", "application/json")
2019-07-12 09:10:03 +00:00
router, ok := h.runtimeConfiguration.TCPRouters[routerID]
if !ok {
2019-09-02 09:38:04 +00:00
writeError(rw, fmt.Sprintf("router not found: %s", routerID), http.StatusNotFound)
2019-07-12 09:10:03 +00:00
return
}
2019-09-02 09:38:04 +00:00
result := newTCPRouterRepresentation(routerID, router)
2019-07-12 09:10:03 +00:00
err := json.NewEncoder(rw).Encode(result)
if err != nil {
2022-11-21 17:36:05 +00:00
log.Ctx(request.Context()).Error().Err(err).Send()
2019-09-02 09:38:04 +00:00
writeError(rw, err.Error(), http.StatusInternalServerError)
2019-07-12 09:10:03 +00:00
}
}
func (h Handler) getTCPServices(rw http.ResponseWriter, request *http.Request) {
results := make([]tcpServiceRepresentation, 0, len(h.runtimeConfiguration.TCPServices))
query := request.URL.Query()
criterion := newSearchCriterion(query)
2019-09-02 09:38:04 +00:00
2019-07-12 09:10:03 +00:00
for name, si := range h.runtimeConfiguration.TCPServices {
2019-09-02 09:38:04 +00:00
if keepTCPService(name, si, criterion) {
results = append(results, newTCPServiceRepresentation(name, si))
}
2019-07-12 09:10:03 +00:00
}
sortServices(query, results)
2019-07-12 09:10:03 +00:00
2019-09-02 09:38:04 +00:00
rw.Header().Set("Content-Type", "application/json")
2019-07-12 09:10:03 +00:00
pageInfo, err := pagination(request, len(results))
if err != nil {
2019-09-02 09:38:04 +00:00
writeError(rw, err.Error(), http.StatusBadRequest)
2019-07-12 09:10:03 +00:00
return
}
rw.Header().Set(nextPageHeader, strconv.Itoa(pageInfo.nextPage))
err = json.NewEncoder(rw).Encode(results[pageInfo.startIndex:pageInfo.endIndex])
if err != nil {
2022-11-21 17:36:05 +00:00
log.Ctx(request.Context()).Error().Err(err).Send()
2019-09-02 09:38:04 +00:00
writeError(rw, err.Error(), http.StatusInternalServerError)
2019-07-12 09:10:03 +00:00
}
}
func (h Handler) getTCPService(rw http.ResponseWriter, request *http.Request) {
serviceID := mux.Vars(request)["serviceID"]
2019-09-02 09:38:04 +00:00
rw.Header().Set("Content-Type", "application/json")
2019-07-12 09:10:03 +00:00
service, ok := h.runtimeConfiguration.TCPServices[serviceID]
if !ok {
2019-09-02 09:38:04 +00:00
writeError(rw, fmt.Sprintf("service not found: %s", serviceID), http.StatusNotFound)
2019-07-12 09:10:03 +00:00
return
}
2019-09-02 09:38:04 +00:00
result := newTCPServiceRepresentation(serviceID, service)
2019-07-12 09:10:03 +00:00
err := json.NewEncoder(rw).Encode(result)
if err != nil {
2022-11-21 17:36:05 +00:00
log.Ctx(request.Context()).Error().Err(err).Send()
2019-09-02 09:38:04 +00:00
writeError(rw, err.Error(), http.StatusInternalServerError)
2019-07-12 09:10:03 +00:00
}
}
2019-09-02 09:38:04 +00:00
2021-06-11 13:30:05 +00:00
func (h Handler) getTCPMiddlewares(rw http.ResponseWriter, request *http.Request) {
results := make([]tcpMiddlewareRepresentation, 0, len(h.runtimeConfiguration.Middlewares))
query := request.URL.Query()
criterion := newSearchCriterion(query)
2021-06-11 13:30:05 +00:00
for name, mi := range h.runtimeConfiguration.TCPMiddlewares {
if keepTCPMiddleware(name, mi, criterion) {
results = append(results, newTCPMiddlewareRepresentation(name, mi))
}
}
sortMiddlewares(query, results)
2021-06-11 13:30:05 +00:00
rw.Header().Set("Content-Type", "application/json")
pageInfo, err := pagination(request, len(results))
if err != nil {
writeError(rw, err.Error(), http.StatusBadRequest)
return
}
rw.Header().Set(nextPageHeader, strconv.Itoa(pageInfo.nextPage))
err = json.NewEncoder(rw).Encode(results[pageInfo.startIndex:pageInfo.endIndex])
if err != nil {
2022-11-21 17:36:05 +00:00
log.Ctx(request.Context()).Error().Err(err).Send()
2021-06-11 13:30:05 +00:00
writeError(rw, err.Error(), http.StatusInternalServerError)
}
}
func (h Handler) getTCPMiddleware(rw http.ResponseWriter, request *http.Request) {
middlewareID := mux.Vars(request)["middlewareID"]
rw.Header().Set("Content-Type", "application/json")
middleware, ok := h.runtimeConfiguration.TCPMiddlewares[middlewareID]
if !ok {
writeError(rw, fmt.Sprintf("middleware not found: %s", middlewareID), http.StatusNotFound)
return
}
result := newTCPMiddlewareRepresentation(middlewareID, middleware)
err := json.NewEncoder(rw).Encode(result)
if err != nil {
2022-11-21 17:36:05 +00:00
log.Ctx(request.Context()).Error().Err(err).Send()
2021-06-11 13:30:05 +00:00
writeError(rw, err.Error(), http.StatusInternalServerError)
}
}
2019-09-02 09:38:04 +00:00
func keepTCPRouter(name string, item *runtime.TCPRouterInfo, criterion *searchCriterion) bool {
if criterion == nil {
return true
}
return criterion.withStatus(item.Status) &&
criterion.searchIn(item.Rule, name) &&
criterion.filterService(item.Service) &&
criterion.filterMiddleware(item.Middlewares)
2019-09-02 09:38:04 +00:00
}
func keepTCPService(name string, item *runtime.TCPServiceInfo, criterion *searchCriterion) bool {
if criterion == nil {
return true
}
return criterion.withStatus(item.Status) && criterion.searchIn(name)
}
2021-06-11 13:30:05 +00:00
func keepTCPMiddleware(name string, item *runtime.TCPMiddlewareInfo, criterion *searchCriterion) bool {
if criterion == nil {
return true
}
return criterion.withStatus(item.Status) && criterion.searchIn(name)
}