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: refactor log make it more formal (#314)

Browse Source
This commit is contained in:
naison
2024-08-03 15:01:16 +08:00
committed by GitHub
parent 9f62e02f96
commit 0826f2e20c
105 changed files with 1485 additions and 1561 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
pkg/webhook/main.go
View File

@@ -45,7 +45,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)
log.Errorf("Failed to register admin: %v", err)
return err
}
grpc_health_v1.RegisterHealthServer(grpcServer, health.NewServer())
@@ -62,7 +62,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)
log.Errorf("Failed to configure http2 server: %v", err)
return err
}
handler := daemon.CreateDowngradingHandler(grpcServer, http.HandlerFunc(http.DefaultServeMux.ServeHTTP))

8
pkg/webhook/mutateadmissionwebhook.go
View File

@@ -64,11 +64,11 @@ 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)
log.Errorf("ContentType=%s, expect application/json", contentType)
return
}
log.Infof("handling request: %s", body)
log.Infof("Handling request: %s", body)
deserializer := codecs.UniversalDeserializer()
obj, gvk, err := deserializer.Decode(body, nil, nil)
@@ -113,7 +113,7 @@ func serve(w http.ResponseWriter, r *http.Request, admit admitHandler) {
return
}
if ptr.Deref(requestedAdmissionReview.Request.DryRun, false) {
log.Info("Ignore dryrun")
log.Info("Ignore dry-run")
responseObj = &v1.AdmissionReview{
TypeMeta: metav1.TypeMeta{
APIVersion: gvk.GroupVersion().String(),
@@ -144,7 +144,7 @@ func serve(w http.ResponseWriter, r *http.Request, admit admitHandler) {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
log.Infof("sending response: %v", string(respBytes))
log.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)

26
pkg/webhook/pods.go
View File

@@ -24,7 +24,7 @@ import (
// 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))
log.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)
@@ -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("can not decode into pod, err: %v, raw: %s", err, string(raw))
log.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("can not marshal into pod, err: %v", err)
log.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)
log.Errorf("Rent IP random failed, err: %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)
log.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("can not marshal pod, err: %v", err)
log.Errorf("Failed to marshal pod, err: %v", err)
return toV1AdmissionResponse(err)
}
var patch []jsonpatch.JsonPatchOperation
patch, err = jsonpatch.CreatePatch(from, to)
if err != nil {
log.Errorf("can not create patch json, err: %v", err)
log.Errorf("Failed to create patch json, err: %v", err)
return toV1AdmissionResponse(err)
}
var marshal []byte
marshal, err = json.Marshal(patch)
if err != nil {
log.Errorf("can not marshal json patch %v, err: %v", patch, err)
log.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("can not decode into pod, err: %v, raw: %s", err, string(raw))
log.Errorf("Failed to decode into pod, err: %v, raw: %s", err, string(raw))
return toV1AdmissionResponse(err)
}
@@ -183,16 +183,16 @@ 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("release ip to dhcp err: %v, ips: %v", err, ips)
log.Errorf("Failed to release IP %v to DHCP: %v", ips, err)
} else {
log.Debugf("release ip to dhcp ok, ip: %v", ips)
log.Debugf("Release IP %v to DHCP", 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)
log.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)
@@ -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("can not decode request into pod, err: %v, req: %s", err, string(raw))
log.Errorf("Failed to decode request into pod, err: %v, req: %s", err, string(raw))
return toV1AdmissionResponse(err)
}
reviewResponse := v1.AdmissionResponse{Allowed: true}