Nail/fission-src
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add webhook server to tests (#2873)

Browse Source 
* Add webhook server to tests
* fix config for webhoook service
* Fix logger in webhook manager
* Use interface for webhook manager
* single reference for router url
* Cleanup token code

---------

Signed-off-by: Sanket Sudake <sanketsudake@gmail.com>
This commit is contained in:
Sanket Sudake
2023-11-16 14:16:28 +05:30
committed by GitHub
parent 57b537f09e
commit e7d6381876
15 changed files with 346 additions and 92 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pkg/crd/client.go
+7 -3
View File
@@ -37,6 +37,7 @@ import (
type (
ClientGeneratorInterface interface {
GetRestConfig() (*rest.Config, error)
GetFissionClient() (versioned.Interface, error)
GetKubernetesClient() (kubernetes.Interface, error)
GetApiExtensionsClient() (apiextensionsclient.Interface, error)
@@ -62,6 +63,10 @@ func (cg *ClientGenerator) getRestConfig() (*rest.Config, error) {
return cg.restConfig, nil
}
func (cg *ClientGenerator) GetRestConfig() (*rest.Config, error) {
return cg.getRestConfig()
}
func (cg *ClientGenerator) GetFissionClient() (versioned.Interface, error) {
config, err := cg.getRestConfig()
if err != nil {
@@ -121,11 +126,10 @@ func WaitForFunctionCRDs(ctx context.Context, logger *zap.Logger, fissionClient
for {
fi := fissionClient.CoreV1().Functions(defaultNs)
_, err := fi.List(ctx, metav1.ListOptions{})
if err != nil {
time.Sleep(100 * time.Millisecond)
} else {
if err == nil {
return nil
}
time.Sleep(100 * time.Millisecond)
if time.Since(start) > 30*time.Second {
return fmt.Errorf("timeout waiting for function CRD access")
pkg/fission-cli/cmd/function/test.go
+10 -20
View File
@@ -66,31 +66,21 @@ func (opts *TestSubCommand) do(input cli.Input) error {
Namespace: namespace,
}
routerURL := os.Getenv("FISSION_ROUTER_URL")
if len(routerURL) == 0 {
// Portforward to the fission router
localRouterPort, err := util.SetupPortForward(input.Context(), opts.Client(), util.GetFissionNamespace(), "application=fission-router")
if err != nil {
return err
}
routerURL = "http://127.0.0.1:" + localRouterPort
routerURL, err := util.GetRouterURL(input.Context(), opts.Client())
if err != nil {
return errors.Wrap(err, "error getting router URL")
}
fnURL := routerURL + util.UrlForFunction(m.Name, m.Namespace)
fnURI := util.UrlForFunction(m.Name, m.Namespace)
if input.IsSet(flagkey.FnSubPath) {
subPath := input.String(flagkey.FnSubPath)
if !strings.HasPrefix(subPath, "/") {
fnURL = fnURL + "/" + subPath
fnURI = fnURI + "/" + subPath
} else {
fnURL = fnURL + subPath
fnURI = fnURI + subPath
}
}
functionUrl, err := url.Parse(fnURL)
if err != nil {
return err
}
console.Verbose(2, "Function test url: %v", functionUrl.String())
fnURL := routerURL.JoinPath(fnURI)
console.Verbose(2, "Function test url: %v", fnURL.String())
queryParams := input.StringSlice(flagkey.FnTestQuery)
if len(queryParams) > 0 {
@@ -109,7 +99,7 @@ func (opts *TestSubCommand) do(input cli.Input) error {
}
query.Set(key, value)
}
functionUrl.RawQuery = query.Encode()
fnURL.RawQuery = query.Encode()
}
var (
@@ -145,7 +135,7 @@ func (opts *TestSubCommand) do(input cli.Input) error {
if err != nil {
return err
}
resp, err := doHTTPRequest(ctx, functionUrl.String(),
resp, err := doHTTPRequest(ctx, fnURL.String(),
input.StringSlice(flagkey.FnTestHeader),
method,
input.String(flagkey.FnTestBody))
pkg/fission-cli/cmd/token/create.go
+7 -14
View File
@@ -22,7 +22,6 @@ import (
"fmt"
"io"
"net/http"
"net/url"
"os"
"github.com/pkg/errors"
@@ -30,6 +29,7 @@ import (
fv1 "github.com/fission/fission/pkg/apis/core/v1"
"github.com/fission/fission/pkg/fission-cli/cliwrapper/cli"
"github.com/fission/fission/pkg/fission-cli/cmd"
"github.com/fission/fission/pkg/fission-cli/console"
flagkey "github.com/fission/fission/pkg/fission-cli/flag/key"
"github.com/fission/fission/pkg/fission-cli/util"
)
@@ -64,26 +64,19 @@ func (opts *CreateSubCommand) run(input cli.Input) error {
jsonValue, _ := json.Marshal(values)
// Portforward to the fission router
localRouterPort, err := util.SetupPortForward(input.Context(), opts.Client(), util.GetFissionNamespace(), "application=fission-router")
if err != nil {
return err
}
authURI, _ := os.LookupEnv("FISSION_AUTH_URI")
if input.IsSet(flagkey.TokAuthURI) {
authURI = input.String(flagkey.TokAuthURI)
}
if len(authURI) == 0 {
authURI = util.FISSION_AUTH_URI
}
relativeURL, _ := url.Parse(authURI)
serverURL, _ := url.Parse("http://127.0.0.1:" + localRouterPort)
authAuthenticatorUrl := serverURL.ResolveReference(relativeURL)
routerURL, err := util.GetRouterURL(input.Context(), opts.Client())
if err != nil {
return errors.Wrap(err, "error getting router URL")
}
authAuthenticatorUrl := routerURL.JoinPath(authURI)
console.Verbose(2, "Auth URI: %s", authAuthenticatorUrl.String())
resp, err := http.Post(authAuthenticatorUrl.String(), "application/json", bytes.NewBuffer(jsonValue))
if err != nil {
return err
pkg/fission-cli/flag/flag.go
-1
View File
@@ -68,7 +68,6 @@ const (
var (
GlobalVerbosity = Flag{Type: Int, Name: flagkey.Verbosity, Short: "v", Usage: "CLI verbosity (0 is quiet, 1 is the default, 2 is verbose)", DefaultValue: 1}
GlobalServer = Flag{Type: String, Name: flagkey.Server, Usage: "Server URL"}
ClientOnly = Flag{Type: Bool, Name: flagkey.ClientOnly, Usage: "If set, the CLI won't connect to remote server"}
pkg/fission-cli/util/util.go
+7 -22
View File
@@ -170,7 +170,7 @@ func GetVersion(ctx context.Context, input cli.Input, cmdClient cmd.Client) info
func GetServerInfo(input cli.Input, cmdClient cmd.Client) *info.ServerInfo {
var serverInfo info.ServerInfo
serverURL, err := getRouterURL(input.Context(), cmdClient)
serverURL, err := GetRouterURL(input.Context(), cmdClient)
if err != nil {
console.Warn("could not connect to server")
return &serverInfo
@@ -212,7 +212,12 @@ func GetServerInfo(input cli.Input, cmdClient cmd.Client) *info.ServerInfo {
return &serverInfo
}
func getRouterURL(ctx context.Context, cmdClient cmd.Client) (serverURL *url.URL, err error) {
func GetRouterURL(ctx context.Context, cmdClient cmd.Client) (serverURL *url.URL, err error) {
routerURL := os.Getenv("FISSION_ROUTER_URL")
if len(routerURL) > 0 {
return url.Parse(routerURL)
}
// Portforward to the fission router
localRouterPort, err := SetupPortForward(ctx, cmdClient, GetFissionNamespace(), "application=fission-router")
if err != nil {
@@ -226,26 +231,6 @@ func getRouterURL(ctx context.Context, cmdClient cmd.Client) (serverURL *url.URL
return serverURL, err
}
func GetServerURL(input cli.Input, client cmd.Client) (serverUrl string, err error) {
serverUrl = input.GlobalString(flagkey.Server)
if len(serverUrl) == 0 {
// starts local portforwarder etc.
serverUrl, err = GetApplicationUrl(input.Context(), client, "application=fission-api")
if err != nil {
return "", err
}
}
isHTTPS := strings.Index(serverUrl, "https://") == 0
isHTTP := strings.Index(serverUrl, "http://") == 0
if !(isHTTP || isHTTPS) {
serverUrl = "http://" + serverUrl
}
return serverUrl, nil
}
func GetResourceReqs(input cli.Input, resReqs *v1.ResourceRequirements) (*v1.ResourceRequirements, error) {
r := &v1.ResourceRequirements{}
pkg/webhook/admission-webhook.go
+19 -8
View File
@@ -18,19 +18,23 @@ package webhook
import (
"context"
"fmt"
"os"
// Import all Kubernetes client auth plugins (e.g. Azure, GCP, OIDC, etc.)
// to ensure that exec-entrypoint and run can make use of them.
"github.com/go-logr/zapr"
"go.uber.org/zap"
_ "k8s.io/client-go/plugin/pkg/client/auth"
"sigs.k8s.io/controller-runtime/pkg/client/config"
"sigs.k8s.io/controller-runtime/pkg/log"
"sigs.k8s.io/controller-runtime/pkg/manager"
metricsserver "sigs.k8s.io/controller-runtime/pkg/metrics/server"
"sigs.k8s.io/controller-runtime/pkg/webhook"
v1 "github.com/fission/fission/pkg/apis/core/v1"
"github.com/fission/fission/pkg/crd"
"github.com/fission/fission/pkg/generated/clientset/versioned/scheme"
//+kubebuilder:scaffold:imports
)
@@ -39,26 +43,33 @@ type WebhookInjector interface {
SetupWebhookWithManager(mgr manager.Manager) error
}
func Start(ctx context.Context, logger *zap.Logger, port int) (err error) {
func Start(ctx context.Context, clientGen crd.ClientGeneratorInterface, logger *zap.Logger, options webhook.Options) (err error) {
wLogger := logger.Named("webhook")
zaprLogger := zapr.NewLogger(logger)
log.SetLogger(zaprLogger)
metricsAddr := os.Getenv("METRICS_ADDR")
if metricsAddr == "" {
metricsAddr = ":8080"
}
if metricsAddr[0] != ':' {
metricsAddr = fmt.Sprintf(":%s", metricsAddr)
}
mgrOpt := manager.Options{
Scheme: scheme.Scheme,
Metrics: metricsserver.Options{
BindAddress: metricsAddr,
},
WebhookServer: webhook.NewServer(webhook.Options{
Port: port,
}),
WebhookServer: webhook.NewServer(options),
Logger: zaprLogger,
}
restConfig, err := clientGen.GetRestConfig()
if err != nil {
wLogger.Error("unable to get rest config", zap.Error(err))
return err
}
// Setup a Manager
mgr, err := manager.New(config.GetConfigOrDie(), mgrOpt)
mgr, err := manager.New(restConfig, mgrOpt)
if err != nil {
wLogger.Error("unable to set up overall controller manager", zap.Error(err))
return err