UDP support

Co-authored-by: Julien Salleyron <julien.salleyron@gmail.com>

pkg/api/handler.go

@@ -40,6 +40,8 @@ type RunTimeRepresentation struct {
 	Services    map[string]*serviceInfoRepresentation `json:"services,omitempty"`
 	TCPRouters  map[string]*runtime.TCPRouterInfo     `json:"tcpRouters,omitempty"`
 	TCPServices map[string]*runtime.TCPServiceInfo    `json:"tcpServices,omitempty"`
+	UDPRouters  map[string]*runtime.UDPRouterInfo     `json:"udpRouters,omitempty"`
+	UDPServices map[string]*runtime.UDPServiceInfo    `json:"udpServices,omitempty"`
 }
 
 // Handler serves the configuration and status of Traefik on API endpoints.
@@ -105,6 +107,11 @@ func (h Handler) createRouter() *mux.Router {
 	router.Methods(http.MethodGet).Path("/api/tcp/services").HandlerFunc(h.getTCPServices)
 	router.Methods(http.MethodGet).Path("/api/tcp/services/{serviceID}").HandlerFunc(h.getTCPService)
 
+	router.Methods(http.MethodGet).Path("/api/udp/routers").HandlerFunc(h.getUDPRouters)
+	router.Methods(http.MethodGet).Path("/api/udp/routers/{routerID}").HandlerFunc(h.getUDPRouter)
+	router.Methods(http.MethodGet).Path("/api/udp/services").HandlerFunc(h.getUDPServices)
+	router.Methods(http.MethodGet).Path("/api/udp/services/{serviceID}").HandlerFunc(h.getUDPService)
+
 	version.Handler{}.Append(router)
 
 	if h.dashboard {
@@ -129,6 +136,8 @@ func (h Handler) getRuntimeConfiguration(rw http.ResponseWriter, request *http.R
 		Services:    siRepr,
 		TCPRouters:  h.runtimeConfiguration.TCPRouters,
 		TCPServices: h.runtimeConfiguration.TCPServices,
+		UDPRouters:  h.runtimeConfiguration.UDPRouters,
+		UDPServices: h.runtimeConfiguration.UDPServices,
 	}
 
 	rw.Header().Set("Content-Type", "application/json")

pkg/api/handler_udp.go

@@ -0,0 +1,164 @@
+package api
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"sort"
+	"strconv"
+	"strings"
+
+	"github.com/containous/traefik/v2/pkg/config/runtime"
+	"github.com/containous/traefik/v2/pkg/log"
+	"github.com/gorilla/mux"
+)
+
+type udpRouterRepresentation struct {
+	*runtime.UDPRouterInfo
+	Name     string `json:"name,omitempty"`
+	Provider string `json:"provider,omitempty"`
+}
+
+func newUDPRouterRepresentation(name string, rt *runtime.UDPRouterInfo) udpRouterRepresentation {
+	return udpRouterRepresentation{
+		UDPRouterInfo: rt,
+		Name:          name,
+		Provider:      getProviderName(name),
+	}
+}
+
+type udpServiceRepresentation struct {
+	*runtime.UDPServiceInfo
+	Name     string `json:"name,omitempty"`
+	Provider string `json:"provider,omitempty"`
+	Type     string `json:"type,omitempty"`
+}
+
+func newUDPServiceRepresentation(name string, si *runtime.UDPServiceInfo) udpServiceRepresentation {
+	return udpServiceRepresentation{
+		UDPServiceInfo: si,
+		Name:           name,
+		Provider:       getProviderName(name),
+		Type:           strings.ToLower(extractType(si.UDPService)),
+	}
+}
+
+func (h Handler) getUDPRouters(rw http.ResponseWriter, request *http.Request) {
+	results := make([]udpRouterRepresentation, 0, len(h.runtimeConfiguration.UDPRouters))
+
+	criterion := newSearchCriterion(request.URL.Query())
+
+	for name, rt := range h.runtimeConfiguration.UDPRouters {
+		if keepUDPRouter(name, rt, criterion) {
+			results = append(results, newUDPRouterRepresentation(name, rt))
+		}
+	}
+
+	sort.Slice(results, func(i, j int) bool {
+		return results[i].Name < results[j].Name
+	})
+
+	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 {
+		log.FromContext(request.Context()).Error(err)
+		writeError(rw, err.Error(), http.StatusInternalServerError)
+	}
+}
+
+func (h Handler) getUDPRouter(rw http.ResponseWriter, request *http.Request) {
+	routerID := mux.Vars(request)["routerID"]
+
+	rw.Header().Set("Content-Type", "application/json")
+
+	router, ok := h.runtimeConfiguration.UDPRouters[routerID]
+	if !ok {
+		writeError(rw, fmt.Sprintf("router not found: %s", routerID), http.StatusNotFound)
+		return
+	}
+
+	result := newUDPRouterRepresentation(routerID, router)
+
+	err := json.NewEncoder(rw).Encode(result)
+	if err != nil {
+		log.FromContext(request.Context()).Error(err)
+		writeError(rw, err.Error(), http.StatusInternalServerError)
+	}
+}
+
+func (h Handler) getUDPServices(rw http.ResponseWriter, request *http.Request) {
+	results := make([]udpServiceRepresentation, 0, len(h.runtimeConfiguration.UDPServices))
+
+	criterion := newSearchCriterion(request.URL.Query())
+
+	for name, si := range h.runtimeConfiguration.UDPServices {
+		if keepUDPService(name, si, criterion) {
+			results = append(results, newUDPServiceRepresentation(name, si))
+		}
+	}
+
+	sort.Slice(results, func(i, j int) bool {
+		return results[i].Name < results[j].Name
+	})
+
+	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 {
+		log.FromContext(request.Context()).Error(err)
+		writeError(rw, err.Error(), http.StatusInternalServerError)
+	}
+}
+
+func (h Handler) getUDPService(rw http.ResponseWriter, request *http.Request) {
+	serviceID := mux.Vars(request)["serviceID"]
+
+	rw.Header().Set("Content-Type", "application/json")
+
+	service, ok := h.runtimeConfiguration.UDPServices[serviceID]
+	if !ok {
+		writeError(rw, fmt.Sprintf("service not found: %s", serviceID), http.StatusNotFound)
+		return
+	}
+
+	result := newUDPServiceRepresentation(serviceID, service)
+
+	err := json.NewEncoder(rw).Encode(result)
+	if err != nil {
+		log.FromContext(request.Context()).Error(err)
+		writeError(rw, err.Error(), http.StatusInternalServerError)
+	}
+}
+
+func keepUDPRouter(name string, item *runtime.UDPRouterInfo, criterion *searchCriterion) bool {
+	if criterion == nil {
+		return true
+	}
+
+	return criterion.withStatus(item.Status) && criterion.searchIn(name)
+}
+
+func keepUDPService(name string, item *runtime.UDPServiceInfo, criterion *searchCriterion) bool {
+	if criterion == nil {
+		return true
+	}
+
+	return criterion.withStatus(item.Status) && criterion.searchIn(name)
+}

pkg/api/handler_udp_test.go

@@ -0,0 +1,537 @@
+package api
+
+import (
+	"context"
+	"encoding/json"
+	"io/ioutil"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/containous/traefik/v2/pkg/config/dynamic"
+	"github.com/containous/traefik/v2/pkg/config/runtime"
+	"github.com/containous/traefik/v2/pkg/config/static"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestHandler_UDP(t *testing.T) {
+	type expected struct {
+		statusCode int
+		nextPage   string
+		jsonFile   string
+	}
+
+	testCases := []struct {
+		desc     string
+		path     string
+		conf     runtime.Configuration
+		expected expected
+	}{
+		{
+			desc: "all UDP routers, but no config",
+			path: "/api/udp/routers",
+			conf: runtime.Configuration{},
+			expected: expected{
+				statusCode: http.StatusOK,
+				nextPage:   "1",
+				jsonFile:   "testdata/udprouters-empty.json",
+			},
+		},
+		{
+			desc: "all UDP routers",
+			path: "/api/udp/routers",
+			conf: runtime.Configuration{
+				UDPRouters: map[string]*runtime.UDPRouterInfo{
+					"test@myprovider": {
+						UDPRouter: &dynamic.UDPRouter{
+							EntryPoints: []string{"web"},
+							Service:     "foo-service@myprovider",
+						},
+						Status: runtime.StatusEnabled,
+					},
+					"bar@myprovider": {
+						UDPRouter: &dynamic.UDPRouter{
+							EntryPoints: []string{"web"},
+							Service:     "foo-service@myprovider",
+						},
+						Status: runtime.StatusWarning,
+					},
+					"foo@myprovider": {
+						UDPRouter: &dynamic.UDPRouter{
+							EntryPoints: []string{"web"},
+							Service:     "foo-service@myprovider",
+						},
+						Status: runtime.StatusDisabled,
+					},
+				},
+			},
+			expected: expected{
+				statusCode: http.StatusOK,
+				nextPage:   "1",
+				jsonFile:   "testdata/udprouters.json",
+			},
+		},
+		{
+			desc: "all UDP routers, pagination, 1 res per page, want page 2",
+			path: "/api/udp/routers?page=2&per_page=1",
+			conf: runtime.Configuration{
+				UDPRouters: map[string]*runtime.UDPRouterInfo{
+					"bar@myprovider": {
+						UDPRouter: &dynamic.UDPRouter{
+							EntryPoints: []string{"web"},
+							Service:     "foo-service@myprovider",
+						},
+					},
+					"baz@myprovider": {
+						UDPRouter: &dynamic.UDPRouter{
+							EntryPoints: []string{"web"},
+							Service:     "foo-service@myprovider",
+						},
+					},
+					"test@myprovider": {
+						UDPRouter: &dynamic.UDPRouter{
+							EntryPoints: []string{"web"},
+							Service:     "foo-service@myprovider",
+						},
+					},
+				},
+			},
+			expected: expected{
+				statusCode: http.StatusOK,
+				nextPage:   "3",
+				jsonFile:   "testdata/udprouters-page2.json",
+			},
+		},
+		{
+			desc: "UDP routers filtered by status",
+			path: "/api/udp/routers?status=enabled",
+			conf: runtime.Configuration{
+				UDPRouters: map[string]*runtime.UDPRouterInfo{
+					"test@myprovider": {
+						UDPRouter: &dynamic.UDPRouter{
+							EntryPoints: []string{"web"},
+							Service:     "foo-service@myprovider",
+						},
+						Status: runtime.StatusEnabled,
+					},
+					"bar@myprovider": {
+						UDPRouter: &dynamic.UDPRouter{
+							EntryPoints: []string{"web"},
+							Service:     "foo-service@myprovider",
+						},
+						Status: runtime.StatusWarning,
+					},
+					"foo@myprovider": {
+						UDPRouter: &dynamic.UDPRouter{
+							EntryPoints: []string{"web"},
+							Service:     "foo-service@myprovider",
+						},
+						Status: runtime.StatusDisabled,
+					},
+				},
+			},
+			expected: expected{
+				statusCode: http.StatusOK,
+				nextPage:   "1",
+				jsonFile:   "testdata/udprouters-filtered-status.json",
+			},
+		},
+		{
+			desc: "UDP routers filtered by search",
+			path: "/api/udp/routers?search=bar@my",
+			conf: runtime.Configuration{
+				UDPRouters: map[string]*runtime.UDPRouterInfo{
+					"test@myprovider": {
+						UDPRouter: &dynamic.UDPRouter{
+							EntryPoints: []string{"web"},
+							Service:     "foo-service@myprovider",
+						},
+						Status: runtime.StatusEnabled,
+					},
+					"bar@myprovider": {
+						UDPRouter: &dynamic.UDPRouter{
+							EntryPoints: []string{"web"},
+							Service:     "foo-service@myprovider",
+						},
+						Status: runtime.StatusWarning,
+					},
+					"foo@myprovider": {
+						UDPRouter: &dynamic.UDPRouter{
+							EntryPoints: []string{"web"},
+							Service:     "foo-service@myprovider",
+						},
+						Status: runtime.StatusDisabled,
+					},
+				},
+			},
+			expected: expected{
+				statusCode: http.StatusOK,
+				nextPage:   "1",
+				jsonFile:   "testdata/udprouters-filtered-search.json",
+			},
+		},
+		{
+			desc: "one UDP router by id",
+			path: "/api/udp/routers/bar@myprovider",
+			conf: runtime.Configuration{
+				UDPRouters: map[string]*runtime.UDPRouterInfo{
+					"bar@myprovider": {
+						UDPRouter: &dynamic.UDPRouter{
+							EntryPoints: []string{"web"},
+							Service:     "foo-service@myprovider",
+						},
+					},
+				},
+			},
+			expected: expected{
+				statusCode: http.StatusOK,
+				jsonFile:   "testdata/udprouter-bar.json",
+			},
+		},
+		{
+			desc: "one UDP router by id, that does not exist",
+			path: "/api/udp/routers/foo@myprovider",
+			conf: runtime.Configuration{
+				UDPRouters: map[string]*runtime.UDPRouterInfo{
+					"bar@myprovider": {
+						UDPRouter: &dynamic.UDPRouter{
+							EntryPoints: []string{"web"},
+							Service:     "foo-service@myprovider",
+						},
+					},
+				},
+			},
+			expected: expected{
+				statusCode: http.StatusNotFound,
+			},
+		},
+		{
+			desc: "one UDP router by id, but no config",
+			path: "/api/udp/routers/bar@myprovider",
+			conf: runtime.Configuration{},
+			expected: expected{
+				statusCode: http.StatusNotFound,
+			},
+		},
+		{
+			desc: "all udp services, but no config",
+			path: "/api/udp/services",
+			conf: runtime.Configuration{},
+			expected: expected{
+				statusCode: http.StatusOK,
+				nextPage:   "1",
+				jsonFile:   "testdata/udpservices-empty.json",
+			},
+		},
+		{
+			desc: "all udp services",
+			path: "/api/udp/services",
+			conf: runtime.Configuration{
+				UDPServices: map[string]*runtime.UDPServiceInfo{
+					"bar@myprovider": {
+						UDPService: &dynamic.UDPService{
+							LoadBalancer: &dynamic.UDPServersLoadBalancer{
+								Servers: []dynamic.UDPServer{
+									{
+										Address: "127.0.0.1:2345",
+									},
+								},
+							},
+						},
+						UsedBy: []string{"foo@myprovider", "test@myprovider"},
+						Status: runtime.StatusEnabled,
+					},
+					"baz@myprovider": {
+						UDPService: &dynamic.UDPService{
+							LoadBalancer: &dynamic.UDPServersLoadBalancer{
+								Servers: []dynamic.UDPServer{
+									{
+										Address: "127.0.0.2:2345",
+									},
+								},
+							},
+						},
+						UsedBy: []string{"foo@myprovider"},
+						Status: runtime.StatusWarning,
+					},
+					"foz@myprovider": {
+						UDPService: &dynamic.UDPService{
+							LoadBalancer: &dynamic.UDPServersLoadBalancer{
+								Servers: []dynamic.UDPServer{
+									{
+										Address: "127.0.0.2:2345",
+									},
+								},
+							},
+						},
+						UsedBy: []string{"foo@myprovider"},
+						Status: runtime.StatusDisabled,
+					},
+				},
+			},
+			expected: expected{
+				statusCode: http.StatusOK,
+				nextPage:   "1",
+				jsonFile:   "testdata/udpservices.json",
+			},
+		},
+		{
+			desc: "udp services filtered by status",
+			path: "/api/udp/services?status=enabled",
+			conf: runtime.Configuration{
+				UDPServices: map[string]*runtime.UDPServiceInfo{
+					"bar@myprovider": {
+						UDPService: &dynamic.UDPService{
+							LoadBalancer: &dynamic.UDPServersLoadBalancer{
+								Servers: []dynamic.UDPServer{
+									{
+										Address: "127.0.0.1:2345",
+									},
+								},
+							},
+						},
+						UsedBy: []string{"foo@myprovider", "test@myprovider"},
+						Status: runtime.StatusEnabled,
+					},
+					"baz@myprovider": {
+						UDPService: &dynamic.UDPService{
+							LoadBalancer: &dynamic.UDPServersLoadBalancer{
+								Servers: []dynamic.UDPServer{
+									{
+										Address: "127.0.0.2:2345",
+									},
+								},
+							},
+						},
+						UsedBy: []string{"foo@myprovider"},
+						Status: runtime.StatusWarning,
+					},
+					"foz@myprovider": {
+						UDPService: &dynamic.UDPService{
+							LoadBalancer: &dynamic.UDPServersLoadBalancer{
+								Servers: []dynamic.UDPServer{
+									{
+										Address: "127.0.0.2:2345",
+									},
+								},
+							},
+						},
+						UsedBy: []string{"foo@myprovider"},
+						Status: runtime.StatusDisabled,
+					},
+				},
+			},
+			expected: expected{
+				statusCode: http.StatusOK,
+				nextPage:   "1",
+				jsonFile:   "testdata/udpservices-filtered-status.json",
+			},
+		},
+		{
+			desc: "udp services filtered by search",
+			path: "/api/udp/services?search=baz@my",
+			conf: runtime.Configuration{
+				UDPServices: map[string]*runtime.UDPServiceInfo{
+					"bar@myprovider": {
+						UDPService: &dynamic.UDPService{
+							LoadBalancer: &dynamic.UDPServersLoadBalancer{
+								Servers: []dynamic.UDPServer{
+									{
+										Address: "127.0.0.1:2345",
+									},
+								},
+							},
+						},
+						UsedBy: []string{"foo@myprovider", "test@myprovider"},
+						Status: runtime.StatusEnabled,
+					},
+					"baz@myprovider": {
+						UDPService: &dynamic.UDPService{
+							LoadBalancer: &dynamic.UDPServersLoadBalancer{
+								Servers: []dynamic.UDPServer{
+									{
+										Address: "127.0.0.2:2345",
+									},
+								},
+							},
+						},
+						UsedBy: []string{"foo@myprovider"},
+						Status: runtime.StatusWarning,
+					},
+					"foz@myprovider": {
+						UDPService: &dynamic.UDPService{
+							LoadBalancer: &dynamic.UDPServersLoadBalancer{
+								Servers: []dynamic.UDPServer{
+									{
+										Address: "127.0.0.2:2345",
+									},
+								},
+							},
+						},
+						UsedBy: []string{"foo@myprovider"},
+						Status: runtime.StatusDisabled,
+					},
+				},
+			},
+			expected: expected{
+				statusCode: http.StatusOK,
+				nextPage:   "1",
+				jsonFile:   "testdata/udpservices-filtered-search.json",
+			},
+		},
+		{
+			desc: "all udp services, 1 res per page, want page 2",
+			path: "/api/udp/services?page=2&per_page=1",
+			conf: runtime.Configuration{
+				UDPServices: map[string]*runtime.UDPServiceInfo{
+					"bar@myprovider": {
+						UDPService: &dynamic.UDPService{
+							LoadBalancer: &dynamic.UDPServersLoadBalancer{
+								Servers: []dynamic.UDPServer{
+									{
+										Address: "127.0.0.1:2345",
+									},
+								},
+							},
+						},
+						UsedBy: []string{"foo@myprovider", "test@myprovider"},
+					},
+					"baz@myprovider": {
+						UDPService: &dynamic.UDPService{
+							LoadBalancer: &dynamic.UDPServersLoadBalancer{
+								Servers: []dynamic.UDPServer{
+									{
+										Address: "127.0.0.2:2345",
+									},
+								},
+							},
+						},
+						UsedBy: []string{"foo@myprovider"},
+					},
+					"test@myprovider": {
+						UDPService: &dynamic.UDPService{
+							LoadBalancer: &dynamic.UDPServersLoadBalancer{
+								Servers: []dynamic.UDPServer{
+									{
+										Address: "127.0.0.3:2345",
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+			expected: expected{
+				statusCode: http.StatusOK,
+				nextPage:   "3",
+				jsonFile:   "testdata/udpservices-page2.json",
+			},
+		},
+		{
+			desc: "one udp service by id",
+			path: "/api/udp/services/bar@myprovider",
+			conf: runtime.Configuration{
+				UDPServices: map[string]*runtime.UDPServiceInfo{
+					"bar@myprovider": {
+						UDPService: &dynamic.UDPService{
+							LoadBalancer: &dynamic.UDPServersLoadBalancer{
+								Servers: []dynamic.UDPServer{
+									{
+										Address: "127.0.0.1:2345",
+									},
+								},
+							},
+						},
+						UsedBy: []string{"foo@myprovider", "test@myprovider"},
+					},
+				},
+			},
+			expected: expected{
+				statusCode: http.StatusOK,
+				jsonFile:   "testdata/udpservice-bar.json",
+			},
+		},
+		{
+			desc: "one udp service by id, that does not exist",
+			path: "/api/udp/services/nono@myprovider",
+			conf: runtime.Configuration{
+				UDPServices: map[string]*runtime.UDPServiceInfo{
+					"bar@myprovider": {
+						UDPService: &dynamic.UDPService{
+							LoadBalancer: &dynamic.UDPServersLoadBalancer{
+								Servers: []dynamic.UDPServer{
+									{
+										Address: "127.0.0.1:2345",
+									},
+								},
+							},
+						},
+						UsedBy: []string{"foo@myprovider", "test@myprovider"},
+					},
+				},
+			},
+			expected: expected{
+				statusCode: http.StatusNotFound,
+			},
+		},
+		{
+			desc: "one udp service by id, but no config",
+			path: "/api/udp/services/foo@myprovider",
+			conf: runtime.Configuration{},
+			expected: expected{
+				statusCode: http.StatusNotFound,
+			},
+		},
+	}
+
+	for _, test := range testCases {
+		test := test
+		t.Run(test.desc, func(t *testing.T) {
+			t.Parallel()
+
+			rtConf := &test.conf
+			// To lazily initialize the Statuses.
+			rtConf.PopulateUsedBy()
+			rtConf.GetUDPRoutersByEntryPoints(context.Background(), []string{"web"})
+
+			handler := New(static.Configuration{API: &static.API{}, Global: &static.Global{}}, rtConf)
+			server := httptest.NewServer(handler.createRouter())
+
+			resp, err := http.DefaultClient.Get(server.URL + test.path)
+			require.NoError(t, err)
+
+			assert.Equal(t, test.expected.nextPage, resp.Header.Get(nextPageHeader))
+
+			require.Equal(t, test.expected.statusCode, resp.StatusCode)
+
+			if test.expected.jsonFile == "" {
+				return
+			}
+
+			assert.Equal(t, resp.Header.Get("Content-Type"), "application/json")
+
+			contents, err := ioutil.ReadAll(resp.Body)
+			require.NoError(t, err)
+
+			err = resp.Body.Close()
+			require.NoError(t, err)
+
+			if *updateExpected {
+				var results interface{}
+				err := json.Unmarshal(contents, &results)
+				require.NoError(t, err)
+
+				newJSON, err := json.MarshalIndent(results, "", "\t")
+				require.NoError(t, err)
+
+				err = ioutil.WriteFile(test.expected.jsonFile, newJSON, 0644)
+				require.NoError(t, err)
+			}
+
+			data, err := ioutil.ReadFile(test.expected.jsonFile)
+			require.NoError(t, err)
+			assert.JSONEq(t, string(data), string(contents))
+		})
+	}
+}

pkg/api/testdata/udprouter-bar.json

@@ -0,0 +1,12 @@
+{
+	"entryPoints": [
+		"web"
+	],
+	"name": "bar@myprovider",
+	"provider": "myprovider",
+	"service": "foo-service@myprovider",
+	"status": "enabled",
+	"using": [
+		"web"
+	]
+}

pkg/api/testdata/udprouters-empty.json

@@ -0,0 +1 @@
+[]

pkg/api/testdata/udprouters-filtered-search.json

@@ -0,0 +1,14 @@
+[
+	{
+		"entryPoints": [
+			"web"
+		],
+		"name": "bar@myprovider",
+		"provider": "myprovider",
+		"service": "foo-service@myprovider",
+		"status": "warning",
+		"using": [
+			"web"
+		]
+	}
+]

pkg/api/testdata/udprouters-filtered-status.json

@@ -0,0 +1,14 @@
+[
+	{
+		"entryPoints": [
+			"web"
+		],
+		"name": "test@myprovider",
+		"provider": "myprovider",
+		"service": "foo-service@myprovider",
+		"status": "enabled",
+		"using": [
+			"web"
+		]
+	}
+]

pkg/api/testdata/udprouters-page2.json

@@ -0,0 +1,14 @@
+[
+	{
+		"entryPoints": [
+			"web"
+		],
+		"name": "baz@myprovider",
+		"provider": "myprovider",
+		"service": "foo-service@myprovider",
+		"status": "enabled",
+		"using": [
+			"web"
+		]
+	}
+]

pkg/api/testdata/udprouters.json

@@ -0,0 +1,38 @@
+[
+	{
+		"entryPoints": [
+			"web"
+		],
+		"name": "bar@myprovider",
+		"provider": "myprovider",
+		"service": "foo-service@myprovider",
+		"status": "warning",
+		"using": [
+			"web"
+		]
+	},
+	{
+		"entryPoints": [
+			"web"
+		],
+		"name": "foo@myprovider",
+		"provider": "myprovider",
+		"service": "foo-service@myprovider",
+		"status": "disabled",
+		"using": [
+			"web"
+		]
+	},
+	{
+		"entryPoints": [
+			"web"
+		],
+		"name": "test@myprovider",
+		"provider": "myprovider",
+		"service": "foo-service@myprovider",
+		"status": "enabled",
+		"using": [
+			"web"
+		]
+	}
+]

pkg/api/testdata/udpservice-bar.json

@@ -0,0 +1,17 @@
+{
+	"loadBalancer": {
+		"servers": [
+			{
+				"address": "127.0.0.1:2345"
+			}
+		]
+	},
+	"name": "bar@myprovider",
+	"provider": "myprovider",
+	"status": "enabled",
+	"type": "loadbalancer",
+	"usedBy": [
+		"foo@myprovider",
+		"test@myprovider"
+	]
+}

pkg/api/testdata/udpservices-empty.json

@@ -0,0 +1 @@
+[]

pkg/api/testdata/udpservices-filtered-search.json

@@ -0,0 +1,18 @@
+[
+	{
+		"loadBalancer": {
+			"servers": [
+				{
+					"address": "127.0.0.2:2345"
+				}
+			]
+		},
+		"name": "baz@myprovider",
+		"provider": "myprovider",
+		"status": "warning",
+		"type": "loadbalancer",
+		"usedBy": [
+			"foo@myprovider"
+		]
+	}
+]

pkg/api/testdata/udpservices-filtered-status.json

@@ -0,0 +1,19 @@
+[
+	{
+		"loadBalancer": {
+			"servers": [
+				{
+					"address": "127.0.0.1:2345"
+				}
+			]
+		},
+		"name": "bar@myprovider",
+		"provider": "myprovider",
+		"status": "enabled",
+		"type": "loadbalancer",
+		"usedBy": [
+			"foo@myprovider",
+			"test@myprovider"
+		]
+	}
+]

pkg/api/testdata/udpservices-page2.json

@@ -0,0 +1,18 @@
+[
+	{
+		"loadBalancer": {
+			"servers": [
+				{
+					"address": "127.0.0.2:2345"
+				}
+			]
+		},
+		"name": "baz@myprovider",
+		"provider": "myprovider",
+		"status": "enabled",
+		"type": "loadbalancer",
+		"usedBy": [
+			"foo@myprovider"
+		]
+	}
+]

pkg/api/testdata/udpservices.json

@@ -0,0 +1,51 @@
+[
+	{
+		"loadBalancer": {
+			"servers": [
+				{
+					"address": "127.0.0.1:2345"
+				}
+			]
+		},
+		"name": "bar@myprovider",
+		"provider": "myprovider",
+		"status": "enabled",
+		"type": "loadbalancer",
+		"usedBy": [
+			"foo@myprovider",
+			"test@myprovider"
+		]
+	},
+	{
+		"loadBalancer": {
+			"servers": [
+				{
+					"address": "127.0.0.2:2345"
+				}
+			]
+		},
+		"name": "baz@myprovider",
+		"provider": "myprovider",
+		"status": "warning",
+		"type": "loadbalancer",
+		"usedBy": [
+			"foo@myprovider"
+		]
+	},
+	{
+		"loadBalancer": {
+			"servers": [
+				{
+					"address": "127.0.0.2:2345"
+				}
+			]
+		},
+		"name": "foz@myprovider",
+		"provider": "myprovider",
+		"status": "disabled",
+		"type": "loadbalancer",
+		"usedBy": [
+			"foo@myprovider"
+		]
+	}
+]