-
Notifications
You must be signed in to change notification settings - Fork 0
/
apiserver.go
101 lines (88 loc) · 2.47 KB
/
apiserver.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
package handler
import (
"net/http"
"github.com/rancher/apiserver/pkg/server"
apiserver "github.com/rancher/apiserver/pkg/server"
"github.com/rancher/apiserver/pkg/types"
"github.com/rancher/apiserver/pkg/urlbuilder"
"github.com/rancher/steve/pkg/accesscontrol"
"github.com/rancher/steve/pkg/auth"
k8sproxy "github.com/rancher/steve/pkg/proxy"
"github.com/rancher/steve/pkg/schema"
"github.com/rancher/steve/pkg/server/router"
"github.com/sirupsen/logrus"
"k8s.io/apiserver/pkg/endpoints/request"
"k8s.io/client-go/rest"
)
func New(cfg *rest.Config, sf schema.Factory, authMiddleware auth.Middleware, next http.Handler,
routerFunc router.RouterFunc) (*apiserver.Server, http.Handler, error) {
var (
proxy http.Handler
err error
)
a := &apiServer{
sf: sf,
server: server.DefaultAPIServer(),
}
a.server.AccessControl = accesscontrol.NewAccessControl()
if authMiddleware == nil {
proxy, err = k8sproxy.Handler("/", cfg)
if err != nil {
return a.server, nil, err
}
authMiddleware = auth.ToMiddleware(auth.AuthenticatorFunc(auth.AlwaysAdmin))
} else {
proxy = k8sproxy.ImpersonatingHandler("/", cfg)
}
w := authMiddleware
handlers := router.Handlers{
Next: next,
K8sResource: w(a.apiHandler(k8sAPI)),
K8sProxy: w(proxy),
APIRoot: w(a.apiHandler(apiRoot)),
}
if routerFunc == nil {
return a.server, router.Routes(handlers), nil
}
return a.server, routerFunc(handlers), nil
}
type apiServer struct {
sf schema.Factory
server *server.Server
}
func (a *apiServer) common(rw http.ResponseWriter, req *http.Request) (*types.APIRequest, bool) {
user, ok := request.UserFrom(req.Context())
if !ok {
return nil, false
}
schemas, err := a.sf.Schemas(user)
if err != nil {
logrus.Errorf("HTTP request failed: %v", err)
rw.Write([]byte(err.Error()))
rw.WriteHeader(http.StatusInternalServerError)
}
urlBuilder, err := urlbuilder.NewPrefixed(req, schemas, "v1")
if err != nil {
rw.Write([]byte(err.Error()))
rw.WriteHeader(http.StatusInternalServerError)
return nil, false
}
return &types.APIRequest{
Schemas: schemas,
Request: req,
Response: rw,
URLBuilder: urlBuilder,
}, true
}
type APIFunc func(schema.Factory, *types.APIRequest)
func (a *apiServer) apiHandler(apiFunc APIFunc) http.Handler {
return http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) {
apiOp, ok := a.common(rw, req)
if ok {
if apiFunc != nil {
apiFunc(a.sf, apiOp)
}
a.server.Handle(apiOp)
}
})
}