mirrors/node-feature-discovery
mirrors/node-feature-discovery
1
0
Fork 0
mirror of https://github.com/kubernetes-sigs/node-feature-discovery.git synced 2025-03-28 02:37:11 +00:00
Code Activity

nfd-master: migrate to structured logging

Browse source
This commit is contained in:
Markus Lehtonen 2023-04-28 09:23:38 +03:00
parent 326521fe28
commit 8113d651c2
3 changed files with 51 additions and 57 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
cmd/nfd-master/main.go
View file

@ -54,7 +54,7 @@ func main() {
flags.Visit(func(f *flag.Flag) {
switch f.Name {
case "featurerules-controller":
klog.Warningf("-featurerules-controller is deprecated, use '-crd-controller' flag instead")
klog.InfoS("-featurerules-controller is deprecated, use '-crd-controller' flag instead")
case "extra-label-ns":
args.Overrides.ExtraLabelNs = overrides.ExtraLabelNs
case "deny-label-ns":
@ -62,7 +62,7 @@ func main() {
case "label-whitelist":
args.Overrides.LabelWhiteList = overrides.LabelWhiteList
case "resource-labels":
klog.Warningf("-resource-labels is deprecated, extended resources should be managed with NodeFeatureRule objects")
klog.InfoS("-resource-labels is deprecated, extended resources should be managed with NodeFeatureRule objects")
args.Overrides.ResourceLabels = overrides.ResourceLabels
case "enable-taints":
args.Overrides.EnableTaints = overrides.EnableTaints
@ -80,7 +80,7 @@ func main() {
// Assert that the version is known
if version.Undefined() {
klog.Warningf("version not set! Set -ldflags \"-X sigs.k8s.io/node-feature-discovery/pkg/version.version=`git describe --tags --dirty --always`\" during build or run.")
klog.InfoS("version not set! Set -ldflags \"-X sigs.k8s.io/node-feature-discovery/pkg/version.version=`git describe --tags --dirty --always`\" during build or run.")
}
// Plug klog into grpc logging infrastructure
@ -89,11 +89,13 @@ func main() {
// Get new NfdMaster instance
instance, err := master.NewNfdMaster(args)
if err != nil {
klog.Exitf("failed to initialize NfdMaster instance: %v", err)
klog.ErrorS(err, "failed to initialize NfdMaster instance")
os.Exit(1)
}
if err = instance.Run(); err != nil {
klog.Exit(err)
klog.ErrorS(err, "error while running")
os.Exit(1)
}
}

17
pkg/nfd-master/nfd-api-controller.go
View file

@ -67,17 +67,17 @@ func newNfdController(config *restclient.Config, nfdApiControllerOptions nfdApiC
if _, err := featureInformer.Informer().AddEventHandler(cache.ResourceEventHandlerFuncs{
AddFunc: func(obj interface{}) {
nfr := obj.(*nfdv1alpha1.NodeFeature)
klog.V(2).Infof("NodeFeature %s/%s added", nfr.Namespace, nfr.Name)
klog.V(2).InfoS("NodeFeature added", "nodefeature", klog.KObj(nfr))
c.updateOneNode("NodeFeature", nfr)
},
UpdateFunc: func(oldObj, newObj interface{}) {
nfr := newObj.(*nfdv1alpha1.NodeFeature)
klog.V(2).Infof("NodeFeature %s/%s updated", nfr.Namespace, nfr.Name)
klog.V(2).InfoS("NodeFeature updated", "nodefeature", klog.KObj(nfr))
c.updateOneNode("NodeFeature", nfr)
},
DeleteFunc: func(obj interface{}) {
nfr := obj.(*nfdv1alpha1.NodeFeature)
klog.V(2).Infof("NodeFeature %s/%s deleted", nfr.Namespace, nfr.Name)
klog.V(2).InfoS("NodeFeature deleted", "nodefeature", klog.KObj(nfr))
c.updateOneNode("NodeFeature", nfr)
},
}); err != nil {
@ -90,24 +90,21 @@ func newNfdController(config *restclient.Config, nfdApiControllerOptions nfdApiC
ruleInformer := informerFactory.Nfd().V1alpha1().NodeFeatureRules()
if _, err := ruleInformer.Informer().AddEventHandler(cache.ResourceEventHandlerFuncs{
AddFunc: func(object interface{}) {
key, _ := cache.MetaNamespaceKeyFunc(object)
klog.V(2).Infof("NodeFeatureRule %v added", key)
klog.V(2).InfoS("NodeFeatureRule added", "nodefeaturerule", klog.KObj(object.(metav1.Object)))
if !nfdApiControllerOptions.DisableNodeFeature {
c.updateAllNodes()
}
// else: rules will be processed only when gRPC requests are received
},
UpdateFunc: func(oldObject, newObject interface{}) {
key, _ := cache.MetaNamespaceKeyFunc(newObject)
klog.V(2).Infof("NodeFeatureRule %v updated", key)
klog.V(2).InfoS("NodeFeatureRule updated", "nodefeaturerule", klog.KObj(newObject.(metav1.Object)))
if !nfdApiControllerOptions.DisableNodeFeature {
c.updateAllNodes()
}
// else: rules will be processed only when gRPC requests are received
},
DeleteFunc: func(object interface{}) {
key, _ := cache.MetaNamespaceKeyFunc(object)
klog.V(2).Infof("NodeFeatureRule %v deleted", key)
klog.V(2).InfoS("NodeFeatureRule deleted", "nodefeaturerule", klog.KObj(object.(metav1.Object)))
if !nfdApiControllerOptions.DisableNodeFeature {
c.updateAllNodes()
}
@ -135,7 +132,7 @@ func (c *nfdController) stop() {
func (c *nfdController) updateOneNode(typ string, obj metav1.Object) {
nodeName, err := getNodeNameForObj(obj)
if err != nil {
klog.Errorf("failed to determine node name for %s %s/%s: %v", typ, obj.GetNamespace(), obj.GetName(), err)
klog.ErrorS(err, "failed to determine node name for object", "type", typ, "object", klog.KObj(obj))
return
}
c.updateOneNodeChan <- nodeName

79
pkg/nfd-master/nfd-master.go
View file

@ -199,12 +199,10 @@ func newDefaultConfig() *NFDConfig {
// Run NfdMaster server. The method returns in case of fatal errors or if Stop()
// is called.
func (m *nfdMaster) Run() error {
klog.Infof("Node Feature Discovery Master %s", version.Get())
klog.InfoS("Node Feature Discovery Master", "version", version.Get(), "nodeName", m.nodeName, "namespace", m.namespace)
if m.args.Instance != "" {
klog.Infof("Master instance: %q", m.args.Instance)
klog.InfoS("Master instance", "instance", m.args.Instance)
}
klog.Infof("NodeName: %q", m.nodeName)
klog.Infof("Kubernetes namespace: %q", m.namespace)
// Read initial configuration
if err := m.configure(m.configFilePath, m.args.Options); err != nil {
@ -258,14 +256,14 @@ func (m *nfdMaster) Run() error {
return fmt.Errorf("error in serving gRPC: %w", err)
case <-configWatch.Events:
klog.Infof("reloading configuration")
klog.InfoS("reloading configuration")
if err := m.configure(m.configFilePath, m.args.Options); err != nil {
return err
}
// restart NFD API controller
if m.nfdController != nil {
klog.Info("stopping the nfd api controller")
klog.InfoS("stopping the nfd api controller")
m.nfdController.stop()
}
if m.args.CrdController {
@ -279,7 +277,7 @@ func (m *nfdMaster) Run() error {
m.nfdController.updateAllNodesChan <- struct{}{}
}
case <-m.stop:
klog.Infof("shutting down nfd-master")
klog.InfoS("shutting down nfd-master")
return nil
}
}
@ -321,7 +319,7 @@ func (m *nfdMaster) runGrpcServer(errChan chan<- error) {
}
grpc_health_v1.RegisterHealthServer(m.server, health.NewServer())
klog.Infof("gRPC server serving on port: %d", m.args.Port)
klog.InfoS("gRPC server serving", "port", m.args.Port)
// Run gRPC server
grpcErr := make(chan error, 1)
@ -333,7 +331,7 @@ func (m *nfdMaster) runGrpcServer(errChan chan<- error) {
for {
select {
case <-certWatch.Events:
klog.Infof("reloading TLS certificates")
klog.InfoS("reloading TLS certificates")
if err := tlsConfig.UpdateConfig(m.args.CertFile, m.args.KeyFile, m.args.CaFile); err != nil {
errChan <- err
}
@ -342,7 +340,7 @@ func (m *nfdMaster) runGrpcServer(errChan chan<- error) {
if err != nil {
errChan <- fmt.Errorf("gRPC server exited with an error: %v", err)
}
klog.Infof("gRPC server stopped")
klog.InfoS("gRPC server stopped")
}
}
}
@ -367,13 +365,13 @@ func (m *nfdMaster) nfdAPIUpdateHandler() {
errNodes := make(map[string]struct{})
if updateAll {
if err := m.nfdAPIUpdateAllNodes(); err != nil {
klog.Error(err)
klog.ErrorS(err, "failed to update nodes")
errUpdateAll = true
}
} else {
for nodeName := range updateNodes {
if err := m.nfdAPIUpdateOneNode(nodeName); err != nil {
klog.Error(err)
klog.ErrorS(err, "failed to update node", "nodeName", nodeName)
errNodes[nodeName] = struct{}{}
}
}
@ -416,7 +414,7 @@ func (m *nfdMaster) WaitForReady(timeout time.Duration) bool {
// Prune erases all NFD related properties from the node objects of the cluster.
func (m *nfdMaster) prune() error {
if m.config.NoPublish {
klog.Info("skipping pruning of nodes as noPublish config option is set")
klog.InfoS("skipping pruning of nodes as noPublish config option is set")
return nil
}
@ -431,7 +429,7 @@ func (m *nfdMaster) prune() error {
}
for _, node := range nodes.Items {
klog.Infof("pruning node %q...", node.Name)
klog.InfoS("pruning node...", "nodeName", node.Name)
// Prune labels and extended resources
err := m.updateNodeObject(cli, node.Name, Labels{}, Annotations{}, ExtendedResources{}, []corev1.Taint{})
@ -492,7 +490,7 @@ func (m *nfdMaster) filterFeatureLabels(labels Labels) (Labels, ExtendedResource
name := addNs(name, nfdv1alpha1.FeatureLabelNs)
if err := m.filterFeatureLabel(name, value); err != nil {
klog.Errorf("ignoring label %s=%v: %v", name, value, err)
klog.ErrorS(err, "ignoring label", "labelKey", name, "labelValue", value)
} else {
outLabels[name] = value
}
@ -505,7 +503,7 @@ func (m *nfdMaster) filterFeatureLabels(labels Labels) (Labels, ExtendedResource
extendedResourceName = addNs(extendedResourceName, nfdv1alpha1.FeatureLabelNs)
if value, ok := outLabels[extendedResourceName]; ok {
if _, err := strconv.Atoi(value); err != nil {
klog.Errorf("bad label value (%s: %s) encountered for extended resource: %s", extendedResourceName, value, err.Error())
klog.ErrorS(err, "bad label value encountered for extended resource", "labelKey", extendedResourceName, "labelValue", value)
continue // non-numeric label can't be used
}
@ -553,7 +551,7 @@ func filterTaints(taints []corev1.Taint) []corev1.Taint {
for _, taint := range taints {
if err := filterTaint(&taint); err != nil {
klog.Errorf("ignoring taint %q: %w", taint.ToString(), err)
klog.ErrorS(err, "ignoring taint", "taint", taint)
} else {
outTaints = append(outTaints, taint)
}
@ -604,16 +602,17 @@ func isNamespaceDenied(labelNs string, wildcardDeniedNs map[string]struct{}, nor
func (m *nfdMaster) SetLabels(c context.Context, r *pb.SetLabelsRequest) (*pb.SetLabelsReply, error) {
err := authorizeClient(c, m.args.VerifyNodeName, r.NodeName)
if err != nil {
klog.ErrorS(err, "gRPC client authorization failed", "nodeName", r.NodeName)
return &pb.SetLabelsReply{}, err
}
switch {
case klog.V(4).Enabled():
utils.KlogDump(3, "REQUEST", " ", r)
utils.KlogDump(3, "gRPC SetLabels request received", " ", r)
case klog.V(1).Enabled():
klog.Infof("REQUEST Node: %q NFD-version: %q Labels: %s", r.NodeName, r.NfdVersion, r.Labels)
klog.InfoS("gRPC SetLabels request received", "nodeName", r.NodeName, "nfdVersion", r.NfdVersion, "labels", r.Labels)
default:
klog.Infof("received labeling request for node %q", r.NodeName)
klog.InfoS("gRPC SetLabels request received", "nodeName", r.NodeName)
}
if !m.config.NoPublish {
cli, err := m.apihelper.GetClient()
@ -633,7 +632,7 @@ func (m *nfdMaster) SetLabels(c context.Context, r *pb.SetLabelsRequest) (*pb.Se
}
func (m *nfdMaster) nfdAPIUpdateAllNodes() error {
klog.Info("will process all nodes in the cluster")
klog.InfoS("will process all nodes in the cluster")
cli, err := m.apihelper.GetClient()
if err != nil {
@ -682,7 +681,7 @@ func (m *nfdMaster) nfdAPIUpdateOneNode(nodeName string) error {
return nil
}
klog.V(1).Infof("processing node %q, initiated by NodeFeature API", nodeName)
klog.V(1).InfoS("processing of node initiated by NodeFeature API", "nodeName", nodeName)
features := nfdv1alpha1.NewNodeFeatureSpec()
@ -732,7 +731,7 @@ func filterExtendedResources(features *nfdv1alpha1.Features, extendedResources E
capacity, err := filterExtendedResource(name, value, features)
if err != nil {
klog.Errorf("failed to create extended resources %s=%s: %v", name, value, err)
klog.ErrorS(err, "failed to create extended resources", "extendedResourceName", name, "extendedResourceValue", value)
} else {
outExtendedResources[name] = capacity
}
@ -810,7 +809,7 @@ func (m *nfdMaster) refreshNodeFeatures(cli *kubernetes.Clientset, nodeName stri
err := m.updateNodeObject(cli, nodeName, labels, annotations, extendedResources, taints)
if err != nil {
klog.Errorf("failed to update node %q: %v", nodeName, err)
klog.ErrorS(err, "failed to update node", "nodeName", nodeName)
return err
}
@ -847,7 +846,7 @@ func (m *nfdMaster) setTaints(cli *kubernetes.Clientset, taints []corev1.Taint,
newTaints, removed := taintutils.DeleteTaint(newNode.Spec.Taints, &taintToRemove)
if !removed {
klog.V(1).Infof("taint %q already deleted from node", taintToRemove.ToString())
klog.V(1).InfoS("taint already deleted from node", "taint", taintToRemove)
}
taintsUpdated = taintsUpdated || removed
newNode.Spec.Taints = newTaints
@ -868,7 +867,7 @@ func (m *nfdMaster) setTaints(cli *kubernetes.Clientset, taints []corev1.Taint,
if err != nil {
return fmt.Errorf("failed to patch the node %v", node.Name)
}
klog.Infof("updated node %q taints", nodeName)
klog.InfoS("updated node taints", "nodeName", nodeName)
}
// Update node annotation that holds the taints managed by us
@ -889,7 +888,7 @@ func (m *nfdMaster) setTaints(cli *kubernetes.Clientset, taints []corev1.Taint,
if err != nil {
return fmt.Errorf("error while patching node object: %v", err)
}
klog.V(1).Infof("patched node %q annotations for taints", nodeName)
klog.V(1).InfoS("patched node annotations for taints", "nodeName", nodeName)
}
return nil
}
@ -900,22 +899,18 @@ func authorizeClient(c context.Context, checkNodeName bool, nodeName string) err
// Check that the node name matches the CN from the TLS cert
client, ok := peer.FromContext(c)
if !ok {
klog.Errorf("gRPC request error: failed to get peer (client)")
return fmt.Errorf("failed to get peer (client)")
}
tlsAuth, ok := client.AuthInfo.(credentials.TLSInfo)
if !ok {
klog.Errorf("gRPC request error: incorrect client credentials from '%v'", client.Addr)
return fmt.Errorf("incorrect client credentials")
}
if len(tlsAuth.State.VerifiedChains) == 0 || len(tlsAuth.State.VerifiedChains[0]) == 0 {
klog.Errorf("gRPC request error: client certificate verification for '%v' failed", client.Addr)
return fmt.Errorf("client certificate verification failed")
}
err := verifyNodeName(tlsAuth.State.VerifiedChains[0][0], nodeName)
if err != nil {
klog.Errorf("gRPC request error: authorization for %v failed: %v", client.Addr, err)
return err
}
}
@ -936,7 +931,7 @@ func (m *nfdMaster) processNodeFeatureRule(nodeName string, features *nfdv1alpha
})
if err != nil {
klog.Errorf("failed to list NodeFeatureRule resources: %v", err)
klog.ErrorS(err, "failed to list NodeFeatureRule resources")
return nil, nil, nil
}
@ -947,12 +942,12 @@ func (m *nfdMaster) processNodeFeatureRule(nodeName string, features *nfdv1alpha
h := fmt.Sprintf("executing NodeFeatureRule %q on node %q:", spec.Name, nodeName)
utils.KlogDump(3, h, " ", spec.Spec)
case klog.V(1).Enabled():
klog.Infof("executing NodeFeatureRule %q on node %q", spec.Name, nodeName)
klog.InfoS("executing NodeFeatureRule", "nodefeaturerule", klog.KObj(spec), "nodeName", nodeName)
}
for _, rule := range spec.Spec.Rules {
ruleOut, err := rule.Execute(features)
if err != nil {
klog.Errorf("failed to process Rule %q on node %q: %v", rule.Name, nodeName, err)
klog.ErrorS(err, "failed to process rule", "ruleName", rule.Name, "nodefeaturerule", klog.KObj(spec), "nodeName", nodeName)
continue
}
taints = append(taints, ruleOut.Taints...)
@ -1032,9 +1027,9 @@ func (m *nfdMaster) updateNodeObject(cli *kubernetes.Clientset, nodeName string,
}
if len(patches) > 0 || len(statusPatches) > 0 {
klog.Infof("node %q updated", nodeName)
klog.InfoS("node updated", "nodeName", nodeName)
} else {
klog.V(1).Infof("no updates to node %q", nodeName)
klog.V(1).InfoS("no updates to node", "nodeName", nodeName)
}
// Set taints
@ -1128,17 +1123,17 @@ func (m *nfdMaster) configure(filepath string, overrides string) error {
data, err := os.ReadFile(filepath)
if err != nil {
if os.IsNotExist(err) {
klog.Infof("config file %q not found, using defaults", filepath)
klog.InfoS("config file not found, using defaults", "path", filepath)
} else {
return fmt.Errorf("error reading config file: %s", err)
return fmt.Errorf("error reading config file: %w", err)
}
} else {
err = yaml.Unmarshal(data, c)
if err != nil {
return fmt.Errorf("failed to parse config file: %s", err)
return fmt.Errorf("failed to parse config file: %w", err)
}
klog.Infof("configuration file %q parsed", filepath)
klog.InfoS("configuration file parsed", "path", filepath)
}
}
@ -1187,7 +1182,7 @@ func (m *nfdMaster) configure(filepath string, overrides string) error {
m.deniedNs.wildcard[".kubernetes.io"] = struct{}{}
utils.KlogDump(1, "effective configuration:", " ", m.config)
klog.Infof("master (re-)configuration successfully completed")
klog.InfoS("configuration successfully updated")
return nil
}
@ -1251,7 +1246,7 @@ func (m *nfdMaster) startNfdApiController() error {
if err != nil {
return err
}
klog.Info("starting nfd api controller")
klog.InfoS("starting the nfd api controller")
m.nfdController, err = newNfdController(kubeconfig, nfdApiControllerOptions{
DisableNodeFeature: !m.args.EnableNodeFeatureApi,
ResyncPeriod: m.config.ResyncPeriod.Duration,