apps/kubevpn
1
0
Fork 0
mirror of https://github.com/kubenetworks/kubevpn.git synced 2025-12-24 11:51:13 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor: divide log to session and backend (#487)

Browse Source 
* refactor: divide log to session and backend
This commit is contained in:
naison
2025-03-23 13:59:10 +08:00
committed by GitHub
parent a5622b9439
commit b46f7a9877
107 changed files with 873 additions and 871 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
pkg/webhook/main.go
View File

@@ -1,12 +1,12 @@
package webhook
import (
"context"
"crypto/tls"
"fmt"
"net/http"
"os"
log "github.com/sirupsen/logrus"
"golang.org/x/net/http2"
"golang.org/x/net/http2/h2c"
"google.golang.org/grpc"
@@ -20,6 +20,7 @@ import (
"github.com/wencaiwulue/kubevpn/v2/pkg/daemon"
"github.com/wencaiwulue/kubevpn/v2/pkg/dhcp"
"github.com/wencaiwulue/kubevpn/v2/pkg/dhcp/rpc"
plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
)
func Main(f util.Factory) error {
@@ -45,7 +46,7 @@ func Main(f util.Factory) error {
grpcServer := grpc.NewServer()
cleanup, err := admin.Register(grpcServer)
if err != nil {
log.Errorf("Failed to register admin: %v", err)
plog.G(context.Background()).Errorf("Failed to register admin: %v", err)
return err
}
grpc_health_v1.RegisterHealthServer(grpcServer, health.NewServer())
@@ -62,7 +63,7 @@ func Main(f util.Factory) error {
var h2Server http2.Server
err = http2.ConfigureServer(downgradingServer, &h2Server)
if err != nil {
log.Errorf("Failed to configure http2 server: %v", err)
plog.G(context.Background()).Errorf("Failed to configure http2 server: %v", err)
return err
}
handler := daemon.CreateDowngradingHandler(grpcServer, http.HandlerFunc(http.DefaultServeMux.ServeHTTP))

26
pkg/webhook/mutateadmissionwebhook.go
View File

@@ -1,13 +1,13 @@
package webhook
import (
"context"
"encoding/json"
"fmt"
"io"
"net/http"
"sync"
log "github.com/sirupsen/logrus"
v1 "k8s.io/api/admission/v1"
"k8s.io/api/admission/v1beta1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -15,6 +15,8 @@ import (
"k8s.io/client-go/kubernetes"
cmdutil "k8s.io/kubectl/pkg/cmd/util"
"k8s.io/utils/ptr"
plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
)
// admissionReviewHandler is a handler to handle business logic, holding an util.Factory
@@ -64,17 +66,17 @@ func serve(w http.ResponseWriter, r *http.Request, admit admitHandler) {
// verify the content type is accurate
contentType := r.Header.Get("Content-Type")
if contentType != "application/json" {
log.Errorf("ContentType=%s, expect application/json", contentType)
plog.G(context.Background()).Errorf("ContentType=%s, expect application/json", contentType)
return
}
log.Infof("Handling request: %s", body)
plog.G(context.Background()).Infof("Handling request: %s", body)
deserializer := codecs.UniversalDeserializer()
obj, gvk, err := deserializer.Decode(body, nil, nil)
if err != nil {
msg := fmt.Sprintf("Request could not be decoded: %v", err)
log.Error(msg)
plog.G(context.Background()).Error(msg)
http.Error(w, msg, http.StatusBadRequest)
return
}
@@ -84,11 +86,11 @@ func serve(w http.ResponseWriter, r *http.Request, admit admitHandler) {
case v1beta1.SchemeGroupVersion.WithKind("AdmissionReview"):
requestedAdmissionReview, ok := obj.(*v1beta1.AdmissionReview)
if !ok {
log.Errorf("Expected v1beta1.AdmissionReview but got: %T", obj)
plog.G(context.Background()).Errorf("Expected v1beta1.AdmissionReview but got: %T", obj)
return
}
if ptr.Deref(requestedAdmissionReview.Request.DryRun, false) {
log.Info("Ignore dryrun")
plog.G(context.Background()).Info("Ignore dryrun")
responseObj = &v1beta1.AdmissionReview{
TypeMeta: metav1.TypeMeta{
APIVersion: gvk.GroupVersion().String(),
@@ -109,11 +111,11 @@ func serve(w http.ResponseWriter, r *http.Request, admit admitHandler) {
case v1.SchemeGroupVersion.WithKind("AdmissionReview"):
requestedAdmissionReview, ok := obj.(*v1.AdmissionReview)
if !ok {
log.Errorf("Expected v1.AdmissionReview but got: %T", obj)
plog.G(context.Background()).Errorf("Expected v1.AdmissionReview but got: %T", obj)
return
}
if ptr.Deref(requestedAdmissionReview.Request.DryRun, false) {
log.Info("Ignore dry-run")
plog.G(context.Background()).Info("Ignore dry-run")
responseObj = &v1.AdmissionReview{
TypeMeta: metav1.TypeMeta{
APIVersion: gvk.GroupVersion().String(),
@@ -133,20 +135,20 @@ func serve(w http.ResponseWriter, r *http.Request, admit admitHandler) {
}
default:
msg := fmt.Sprintf("Unsupported group version kind: %v", gvk)
log.Error(msg)
plog.G(context.Background()).Error(msg)
http.Error(w, msg, http.StatusBadRequest)
return
}
respBytes, err := json.Marshal(responseObj)
if err != nil {
log.Errorf("Unable to encode response: %v", err)
plog.G(context.Background()).Errorf("Unable to encode response: %v", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
log.Infof("Sending response: %v", string(respBytes))
plog.G(context.Background()).Infof("Sending response: %v", string(respBytes))
w.Header().Set("Content-Type", "application/json")
if _, err = w.Write(respBytes); err != nil {
log.Errorf("Unable to write response: %v", err)
plog.G(context.Background()).Errorf("Unable to write response: %v", err)
}
}

34
pkg/webhook/pods.go
View File

@@ -7,7 +7,6 @@ import (
"net"
"github.com/mattbaird/jsonpatch"
log "github.com/sirupsen/logrus"
"k8s.io/api/admission/v1"
corev1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/api/meta"
@@ -18,17 +17,18 @@ import (
"github.com/wencaiwulue/kubevpn/v2/pkg/config"
"github.com/wencaiwulue/kubevpn/v2/pkg/dhcp"
plog "github.com/wencaiwulue/kubevpn/v2/pkg/log"
"github.com/wencaiwulue/kubevpn/v2/pkg/util"
)
// create pod will rent ip and delete pod will release ip
func (h *admissionReviewHandler) admitPods(ar v1.AdmissionReview) *v1.AdmissionResponse {
r, _ := json.Marshal(ar)
log.Infof("Admitting pods called, req: %v", string(r))
plog.G(context.Background()).Infof("Admitting pods called, req: %v", string(r))
podResource := metav1.GroupVersionResource{Group: "", Version: "v1", Resource: "pods"}
if ar.Request.Resource != podResource {
err := fmt.Errorf("expect resource to be %s but real %s", podResource, ar.Request.Resource)
log.Error(err)
plog.G(context.Background()).Error(err)
return toV1AdmissionResponse(err)
}
@@ -41,7 +41,7 @@ func (h *admissionReviewHandler) admitPods(ar v1.AdmissionReview) *v1.AdmissionR
default:
err := fmt.Errorf("expect operation is %s or %s, not %s", v1.Create, v1.Delete, ar.Request.Operation)
log.Error(err)
plog.G(context.Background()).Error(err)
return toV1AdmissionResponse(err)
}
}
@@ -52,13 +52,13 @@ func (h *admissionReviewHandler) handleCreate(ar v1.AdmissionReview) *v1.Admissi
pod := corev1.Pod{}
deserializer := codecs.UniversalDeserializer()
if _, _, err := deserializer.Decode(raw, nil, &pod); err != nil {
log.Errorf("Failed to decode into pod, err: %v, raw: %s", err, string(raw))
plog.G(context.Background()).Errorf("Failed to decode into pod, err: %v, raw: %s", err, string(raw))
return toV1AdmissionResponse(err)
}
from, err := json.Marshal(pod)
if err != nil {
log.Errorf("Failed to marshal into pod, err: %v", err)
plog.G(context.Background()).Errorf("Failed to marshal into pod, err: %v", err)
return toV1AdmissionResponse(err)
}
@@ -97,14 +97,14 @@ func (h *admissionReviewHandler) handleCreate(ar v1.AdmissionReview) *v1.Admissi
var v4, v6 *net.IPNet
v4, v6, err = manager.RentIP(context.Background())
if err != nil {
log.Errorf("Rent IP random failed, err: %v", err)
plog.G(context.Background()).Errorf("Rent IP random failed: %v", err)
return toV1AdmissionResponse(err)
}
var name string
if accessor, errT := meta.Accessor(ar.Request.Object); errT == nil {
name = accessor.GetName()
}
log.Infof("Rent IPv4: %s IPv6: %s for pod %s in namespace: %s", v4.String(), v6.String(), name, ar.Request.Namespace)
plog.G(context.Background()).Infof("Rent IPv4: %s IPv6: %s for pod %s in namespace: %s", v4.String(), v6.String(), name, ar.Request.Namespace)
//4) update spec
for j := 0; j < len(pod.Spec.Containers[index].Env); j++ {
@@ -121,19 +121,19 @@ func (h *admissionReviewHandler) handleCreate(ar v1.AdmissionReview) *v1.Admissi
var to []byte
to, err = json.Marshal(pod)
if err != nil {
log.Errorf("Failed to marshal pod, err: %v", err)
plog.G(context.Background()).Errorf("Failed to marshal pod: %v", err)
return toV1AdmissionResponse(err)
}
var patch []jsonpatch.JsonPatchOperation
patch, err = jsonpatch.CreatePatch(from, to)
if err != nil {
log.Errorf("Failed to create patch json, err: %v", err)
plog.G(context.Background()).Errorf("Failed to create patch json: %v", err)
return toV1AdmissionResponse(err)
}
var marshal []byte
marshal, err = json.Marshal(patch)
if err != nil {
log.Errorf("Failed to marshal json patch %v, err: %v", patch, err)
plog.G(context.Background()).Errorf("Failed to marshal json patch %v, err: %v", patch, err)
return toV1AdmissionResponse(err)
}
var shouldPatchPod = func(pod *corev1.Pod) bool {
@@ -149,7 +149,7 @@ func (h *admissionReviewHandler) handleDelete(ar v1.AdmissionReview) *v1.Admissi
pod := corev1.Pod{}
deserializer := codecs.UniversalDeserializer()
if _, _, err := deserializer.Decode(raw, nil, &pod); err != nil {
log.Errorf("Failed to decode into pod, err: %v, raw: %s", err, string(raw))
plog.G(context.Background()).Errorf("Failed to decode into pod, err: %v, raw: %s", err, string(raw))
return toV1AdmissionResponse(err)
}
@@ -183,20 +183,20 @@ func (h *admissionReviewHandler) handleDelete(ar v1.AdmissionReview) *v1.Admissi
cmi := h.clientset.CoreV1().ConfigMaps(ar.Request.Namespace)
err := dhcp.NewDHCPManager(cmi, ar.Request.Namespace).ReleaseIP(context.Background(), ips...)
if err != nil {
log.Errorf("Failed to release IP %v to DHCP: %v", ips, err)
plog.G(context.Background()).Errorf("Failed to release IP %v to DHCP server: %v", ips, err)
} else {
log.Debugf("Release IP %v to DHCP", ips)
plog.G(context.Background()).Debugf("Release IP %v to DHCP server", ips)
}
}
return &v1.AdmissionResponse{Allowed: true}
}
func applyPodPatch(ar v1.AdmissionReview, shouldPatchPod func(*corev1.Pod) bool, patch string) *v1.AdmissionResponse {
log.Infof("Apply pod patch: %s", patch)
plog.G(context.Background()).Infof("Apply pod patch: %s", patch)
podResource := metav1.GroupVersionResource{Group: "", Version: "v1", Resource: "pods"}
if ar.Request.Resource != podResource {
err := fmt.Errorf("expect resource to be %s but real %s", podResource, ar.Request.Resource)
log.Error(err)
plog.G(context.Background()).Error(err)
return toV1AdmissionResponse(err)
}
@@ -204,7 +204,7 @@ func applyPodPatch(ar v1.AdmissionReview, shouldPatchPod func(*corev1.Pod) bool,
pod := corev1.Pod{}
deserializer := codecs.UniversalDeserializer()
if _, _, err := deserializer.Decode(raw, nil, &pod); err != nil {
log.Errorf("Failed to decode request into pod, err: %v, req: %s", err, string(raw))
plog.G(context.Background()).Errorf("Failed to decode request into pod, err: %v, req: %s", err, string(raw))
return toV1AdmissionResponse(err)
}
reviewResponse := v1.AdmissionResponse{Allowed: true}