11341895365

Committed 15 Oct 2024 08:08AM UTC coverage: 44.967% (-0.05%) from 45.017%

Build # 11341895365

Build Type

Pull #792

github

Committed by

web-flow

Commit Message

Merge 9c8ed6e3c into 8fe7a5e00

Pull Request Pull Request #792: Clean Systemd files on exit

Run Details

10 of 52 new or added lines in 2 files covered. (19.23%)

1 existing line in 1 file now uncovered.

6669 of 14831 relevant lines covered (44.97%)

0.5 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

5.39

/cmd/sriov-network-config-daemon/start.go

/*
Copyright 2023.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

        http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package main

import (
        "context"
        "fmt"
        "net"
        "net/url"
        "os"
        "os/signal"
        "strings"
        "syscall"
        "time"

        "github.com/spf13/cobra"
        v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        "k8s.io/apimachinery/pkg/types"
        "k8s.io/client-go/kubernetes"
        "k8s.io/client-go/kubernetes/scheme"
        "k8s.io/client-go/rest"
        "k8s.io/client-go/tools/clientcmd"
        "k8s.io/client-go/util/connrotation"
        "sigs.k8s.io/controller-runtime/pkg/client"
        "sigs.k8s.io/controller-runtime/pkg/log"

        configv1 "github.com/openshift/api/config/v1"
        mcfgv1 "github.com/openshift/machine-config-operator/pkg/apis/machineconfiguration.openshift.io/v1"

        sriovnetworkv1 "github.com/k8snetworkplumbingwg/sriov-network-operator/api/v1"
        snclientset "github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/client/clientset/versioned"
        "github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/consts"
        "github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/daemon"
        "github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/featuregate"
        "github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/helper"
        snolog "github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/log"
        "github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/platforms"
        "github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/vars"
)

// stringList is a list of strings, implements pflag.Value interface
type stringList []string

func (sl *stringList) String() string {
        return strings.Join(*sl, ",")
}

func (sl *stringList) Set(arg string) error {
        elems := strings.Split(arg, ",")

        for _, elem := range elems {
                if len(elem) == 0 {
                        return fmt.Errorf("empty plugin name")
                }
                *sl = append(*sl, elem)
        }
        return nil
}

func (sl *stringList) Type() string {
        return "CommaSeparatedString"
}

var (
        startCmd = &cobra.Command{
                Use:   "start",
                Short: "Starts SR-IOV Network Config Daemon",
                Long:  "",
                RunE:  runStartCmd,
        }

        startOpts struct {
                kubeconfig            string
                nodeName              string
                systemd               bool
                disabledPlugins       stringList
                parallelNicConfig     bool
                manageSoftwareBridges bool
                ovsSocketPath         string
        }
)

func init() {
        rootCmd.AddCommand(startCmd)
        startCmd.PersistentFlags().StringVar(&startOpts.kubeconfig, "kubeconfig", "", "Kubeconfig file to access a remote cluster (testing only)")
        startCmd.PersistentFlags().StringVar(&startOpts.nodeName, "node-name", "", "kubernetes node name daemon is managing")
        startCmd.PersistentFlags().BoolVar(&startOpts.systemd, "use-systemd-service", false, "use config daemon in systemd mode")
        startCmd.PersistentFlags().VarP(&startOpts.disabledPlugins, "disable-plugins", "", "comma-separated list of plugins to disable")
        startCmd.PersistentFlags().BoolVar(&startOpts.parallelNicConfig, "parallel-nic-config", false, "perform NIC configuration in parallel")
        startCmd.PersistentFlags().BoolVar(&startOpts.manageSoftwareBridges, "manage-software-bridges", false, "enable management of software bridges")
        startCmd.PersistentFlags().StringVar(&startOpts.ovsSocketPath, "ovs-socket-path", vars.OVSDBSocketPath, "path for OVSDB socket")
}

func runStartCmd(cmd *cobra.Command, args []string) error {
        // init logger
        snolog.InitLog()
        setupLog := log.Log.WithName("sriov-network-config-daemon")

        // Mark that we are running inside a container
        vars.UsingSystemdMode = false
        if startOpts.systemd {
                vars.UsingSystemdMode = true
        }

        vars.ParallelNicConfig = startOpts.parallelNicConfig
        vars.ManageSoftwareBridges = startOpts.manageSoftwareBridges
        vars.OVSDBSocketPath = startOpts.ovsSocketPath

        if startOpts.nodeName == "" {
                name, ok := os.LookupEnv("NODE_NAME")
                if !ok || name == "" {
                        return fmt.Errorf("node-name is required")
                }
                startOpts.nodeName = name
        }
        vars.NodeName = startOpts.nodeName

        for _, p := range startOpts.disabledPlugins {
                if _, ok := vars.DisableablePlugins[p]; !ok {
                        return fmt.Errorf("%s plugin cannot be disabled", p)
                }
        }

        // This channel is used to ensure all spawned goroutines exit when we exit.
        stopCh := make(chan struct{})

        // This channel is used to signal Run() something failed and to jump ship.
        // It's purely a chan<- in the Daemon struct for goroutines to write to, and
        // a <-chan in Run() for the main thread to listen on.
        exitCh := make(chan error)
        defer close(exitCh)

        // This channel is to make sure main thread will wait until the writer finish
        // to report lastSyncError in SriovNetworkNodeState object.
        syncCh := make(chan struct{})
        defer close(syncCh)

        refreshCh := make(chan daemon.Message)
        defer close(refreshCh)

        var config *rest.Config
        var err error

        // On openshift we use the kubeconfig from kubelet on the node where the daemon is running
        // this allow us to improve security as every daemon has access only to its own node
        if vars.ClusterType == consts.ClusterTypeOpenshift {
                kubeconfig, err := clientcmd.LoadFromFile("/host/etc/kubernetes/kubeconfig")
                if err != nil {
                        setupLog.Error(err, "failed to load kubelet kubeconfig")
                }
                clusterName := kubeconfig.Contexts[kubeconfig.CurrentContext].Cluster
                apiURL := kubeconfig.Clusters[clusterName].Server

                urlPath, err := url.Parse(apiURL)
                if err != nil {
                        setupLog.Error(err, "failed to parse api url from kubelet kubeconfig")
                }

                // The kubernetes in-cluster functions don't let you override the apiserver
                // directly; gotta "pass" it via environment vars.
                setupLog.V(0).Info("overriding kubernetes api", "new-url", apiURL)
                err = os.Setenv("KUBERNETES_SERVICE_HOST", urlPath.Hostname())
                if err != nil {
                        setupLog.Error(err, "failed to set KUBERNETES_SERVICE_HOST environment variable")
                }
                err = os.Setenv("KUBERNETES_SERVICE_PORT", urlPath.Port())
                if err != nil {
                        setupLog.Error(err, "failed to set KUBERNETES_SERVICE_PORT environment variable")
                }
        }

        kubeconfig := os.Getenv("KUBECONFIG")
        if kubeconfig != "" {
                config, err = clientcmd.BuildConfigFromFlags("", kubeconfig)
        } else {
                // creates the in-cluster config
                config, err = rest.InClusterConfig()
        }

        if err != nil {
                return err
        }

        vars.Config = config
        vars.Scheme = scheme.Scheme

        closeAllConns, err := updateDialer(config)
        if err != nil {
                return err
        }

        err = sriovnetworkv1.AddToScheme(scheme.Scheme)
        if err != nil {
                setupLog.Error(err, "failed to load sriov network CRDs to scheme")
                return err
        }

        err = mcfgv1.AddToScheme(scheme.Scheme)
        if err != nil {
                setupLog.Error(err, "failed to load machine config CRDs to scheme")
                return err
        }

        err = configv1.Install(scheme.Scheme)
        if err != nil {
                setupLog.Error(err, "failed to load openshift config CRDs to scheme")
                return err
        }

        kClient, err := client.New(config, client.Options{Scheme: scheme.Scheme})
        if err != nil {
                setupLog.Error(err, "couldn't create client")
                os.Exit(1)
        }

        snclient := snclientset.NewForConfigOrDie(config)
        kubeclient := kubernetes.NewForConfigOrDie(config)

        hostHelpers, err := helper.NewDefaultHostHelpers()
        if err != nil {
                setupLog.Error(err, "failed to create hostHelpers")
                return err
        }

        platformHelper, err := platforms.NewDefaultPlatformHelper()
        if err != nil {
                setupLog.Error(err, "failed to create platformHelper")
                return err
        }

        config.Timeout = 5 * time.Second
        writerclient := snclientset.NewForConfigOrDie(config)

        eventRecorder := daemon.NewEventRecorder(writerclient, kubeclient)
        defer eventRecorder.Shutdown()

        setupLog.V(0).Info("starting node writer")
        nodeWriter := daemon.NewNodeStateStatusWriter(writerclient,
                closeAllConns,
                eventRecorder,
                hostHelpers,
                platformHelper)

        nodeInfo, err := kubeclient.CoreV1().Nodes().Get(context.Background(), startOpts.nodeName, v1.GetOptions{})
        if err == nil {
                for key, pType := range vars.PlatformsMap {
                        if strings.Contains(strings.ToLower(nodeInfo.Spec.ProviderID), strings.ToLower(key)) {
                                vars.PlatformType = pType
                        }
                }
        } else {
                setupLog.Error(err, "failed to fetch node state, exiting", "node-name", startOpts.nodeName)
                return err
        }
        setupLog.Info("Running on", "platform", vars.PlatformType.String())

        if err := sriovnetworkv1.InitNicIDMapFromConfigMap(kubeclient, vars.Namespace); err != nil {
                setupLog.Error(err, "failed to run init NicIdMap")
                return err
        }

        eventRecorder.SendEvent("ConfigDaemonStart", "Config Daemon starting")

        // block the deamon process until nodeWriter finish first its run
        err = nodeWriter.RunOnce()
        if err != nil {
                setupLog.Error(err, "failed to run writer")
                return err
        }
        go nodeWriter.Run(stopCh, refreshCh, syncCh)

        // Init feature gates once to prevent race conditions.
        defaultConfig := &sriovnetworkv1.SriovOperatorConfig{}
        err = kClient.Get(context.Background(), types.NamespacedName{Namespace: vars.Namespace, Name: consts.DefaultConfigName}, defaultConfig)
        if err != nil {
                log.Log.Error(err, "Failed to get default SriovOperatorConfig object")
                close(stopCh)
                return err
        }
        featureGates := featuregate.New()
        featureGates.Init(defaultConfig.Spec.FeatureGates)
        vars.MlxPluginFwReset = featureGates.IsEnabled(consts.MellanoxFirmwareResetFeatureGate)
        log.Log.Info("Enabled featureGates", "featureGates", featureGates.String())

        setupLog.V(0).Info("Starting SriovNetworkConfigDaemon")

        // create a signal channel to catch interrupts and gracefully shutdown the daemon
        sigc := make(chan os.Signal, 1)
        signal.Notify(sigc, os.Interrupt)
        signal.Notify(sigc, syscall.SIGTERM)

        errChan := make(chan error)
        defer close(errChan)
        go func() {
                errChan <- daemon.New(
                        kClient,
                        snclient,
                        kubeclient,
                        hostHelpers,
                        platformHelper,
                        exitCh,
                        stopCh,
                        syncCh,
                        refreshCh,
                        eventRecorder,
                        featureGates,
                        startOpts.disabledPlugins,
                ).Run(stopCh, exitCh)
        }()

        select {
        case err := <-errChan:
                // daemon has exited, close the stop channel and return the error
                close(stopCh)
                return err
        case <-sigc:
                // signal received, close the stop channel and wait for the daemon to exit
                close(stopCh)
                if err := <-errChan; err != nil {
                        return err
                }
        }
        setupLog.V(0).Info("Shutting down SriovNetworkConfigDaemon")
        return nil
}

// updateDialer instruments a restconfig with a dial. the returned function allows forcefully closing all active connections.
func updateDialer(clientConfig *rest.Config) (func(), error) {
        if clientConfig.Transport != nil || clientConfig.Dial != nil {
                return nil, fmt.Errorf("there is already a transport or dialer configured")
        }
        f := &net.Dialer{Timeout: 30 * time.Second, KeepAlive: 30 * time.Second}
        d := connrotation.NewDialer(f.DialContext)
        clientConfig.Dial = d.DialContext
        return d.CloseAll, nil
}

1	/*
2	Copyright 2023.
3
4	Licensed under the Apache License, Version 2.0 (the "License");
5	you may not use this file except in compliance with the License.
6	You may obtain a copy of the License at
7
8	http://www.apache.org/licenses/LICENSE-2.0
9
10	Unless required by applicable law or agreed to in writing, software
11	distributed under the License is distributed on an "AS IS" BASIS,
12	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	See the License for the specific language governing permissions and
14	limitations under the License.
15	*/
16	package main
17
18	import (
19	"context"
20	"fmt"
21	"net"
22	"net/url"
23	"os"
24	"os/signal"
25	"strings"
26	"syscall"
27	"time"
28
29	"github.com/spf13/cobra"
30	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
31	"k8s.io/apimachinery/pkg/types"
32	"k8s.io/client-go/kubernetes"
33	"k8s.io/client-go/kubernetes/scheme"
34	"k8s.io/client-go/rest"
35	"k8s.io/client-go/tools/clientcmd"
36	"k8s.io/client-go/util/connrotation"
37	"sigs.k8s.io/controller-runtime/pkg/client"
38	"sigs.k8s.io/controller-runtime/pkg/log"
39
40	configv1 "github.com/openshift/api/config/v1"
41	mcfgv1 "github.com/openshift/machine-config-operator/pkg/apis/machineconfiguration.openshift.io/v1"
42
43	sriovnetworkv1 "github.com/k8snetworkplumbingwg/sriov-network-operator/api/v1"
44	snclientset "github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/client/clientset/versioned"
45	"github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/consts"
46	"github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/daemon"
47	"github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/featuregate"
48	"github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/helper"
49	snolog "github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/log"
50	"github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/platforms"
51	"github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/vars"
52	)
53
54	// stringList is a list of strings, implements pflag.Value interface
55	type stringList []string
56
57	func (sl *stringList) String() string {	1✔
58	return strings.Join(*sl, ",")	1✔
59	}	1✔
60
61	func (sl *stringList) Set(arg string) error {	×
62	elems := strings.Split(arg, ",")	×
63		×
64	for _, elem := range elems {	×
65	if len(elem) == 0 {	×
66	return fmt.Errorf("empty plugin name")	×
67	}	×
68	sl = append(sl, elem)	×
69	}
70	return nil	×
71	}
72
73	func (sl *stringList) Type() string {	×
74	return "CommaSeparatedString"	×
75	}	×
76
77	var (
78	startCmd = &cobra.Command{
79	Use: "start",
80	Short: "Starts SR-IOV Network Config Daemon",
81	Long: "",
82	RunE: runStartCmd,
83	}
84
85	startOpts struct {
86	kubeconfig string
87	nodeName string
88	systemd bool
89	disabledPlugins stringList
90	parallelNicConfig bool
91	manageSoftwareBridges bool
92	ovsSocketPath string
93	}
94	)
95
96	func init() {	1✔
97	rootCmd.AddCommand(startCmd)	1✔
98	startCmd.PersistentFlags().StringVar(&startOpts.kubeconfig, "kubeconfig", "", "Kubeconfig file to access a remote cluster (testing only)")	1✔
99	startCmd.PersistentFlags().StringVar(&startOpts.nodeName, "node-name", "", "kubernetes node name daemon is managing")	1✔
100	startCmd.PersistentFlags().BoolVar(&startOpts.systemd, "use-systemd-service", false, "use config daemon in systemd mode")	1✔
101	startCmd.PersistentFlags().VarP(&startOpts.disabledPlugins, "disable-plugins", "", "comma-separated list of plugins to disable")	1✔
102	startCmd.PersistentFlags().BoolVar(&startOpts.parallelNicConfig, "parallel-nic-config", false, "perform NIC configuration in parallel")	1✔
103	startCmd.PersistentFlags().BoolVar(&startOpts.manageSoftwareBridges, "manage-software-bridges", false, "enable management of software bridges")	1✔
104	startCmd.PersistentFlags().StringVar(&startOpts.ovsSocketPath, "ovs-socket-path", vars.OVSDBSocketPath, "path for OVSDB socket")	1✔
105	}	1✔
106
107	func runStartCmd(cmd *cobra.Command, args []string) error {	×
108	// init logger	×
109	snolog.InitLog()	×
110	setupLog := log.Log.WithName("sriov-network-config-daemon")	×
111		×
112	// Mark that we are running inside a container	×
113	vars.UsingSystemdMode = false	×
114	if startOpts.systemd {	×
115	vars.UsingSystemdMode = true	×
116	}	×
117
118	vars.ParallelNicConfig = startOpts.parallelNicConfig	×
119	vars.ManageSoftwareBridges = startOpts.manageSoftwareBridges	×
120	vars.OVSDBSocketPath = startOpts.ovsSocketPath	×
121		×
122	if startOpts.nodeName == "" {	×
123	name, ok := os.LookupEnv("NODE_NAME")	×
124	if !ok \|\| name == "" {	×
125	return fmt.Errorf("node-name is required")	×
126	}	×
127	startOpts.nodeName = name	×
128	}
129	vars.NodeName = startOpts.nodeName	×
130		×
131	for _, p := range startOpts.disabledPlugins {	×
132	if _, ok := vars.DisableablePlugins[p]; !ok {	×
133	return fmt.Errorf("%s plugin cannot be disabled", p)	×
134	}	×
135	}
136
137	// This channel is used to ensure all spawned goroutines exit when we exit.
138	stopCh := make(chan struct{})	×
139		×
140	// This channel is used to signal Run() something failed and to jump ship.	×
141	// It's purely a chan<- in the Daemon struct for goroutines to write to, and	×
142	// a <-chan in Run() for the main thread to listen on.	×
143	exitCh := make(chan error)	×
144	defer close(exitCh)	×
145		×
146	// This channel is to make sure main thread will wait until the writer finish	×
147	// to report lastSyncError in SriovNetworkNodeState object.	×
148	syncCh := make(chan struct{})	×
149	defer close(syncCh)	×
150		×
151	refreshCh := make(chan daemon.Message)	×
152	defer close(refreshCh)	×
153		×
154	var config *rest.Config	×
155	var err error	×
156		×
157	// On openshift we use the kubeconfig from kubelet on the node where the daemon is running	×
158	// this allow us to improve security as every daemon has access only to its own node	×
159	if vars.ClusterType == consts.ClusterTypeOpenshift {	×
160	kubeconfig, err := clientcmd.LoadFromFile("/host/etc/kubernetes/kubeconfig")	×
161	if err != nil {	×
162	setupLog.Error(err, "failed to load kubelet kubeconfig")	×
163	}	×
164	clusterName := kubeconfig.Contexts[kubeconfig.CurrentContext].Cluster	×
165	apiURL := kubeconfig.Clusters[clusterName].Server	×
166		×
167	urlPath, err := url.Parse(apiURL)	×
168	if err != nil {	×
169	setupLog.Error(err, "failed to parse api url from kubelet kubeconfig")	×
170	}	×
171
172	// The kubernetes in-cluster functions don't let you override the apiserver
173	// directly; gotta "pass" it via environment vars.
174	setupLog.V(0).Info("overriding kubernetes api", "new-url", apiURL)	×
175	err = os.Setenv("KUBERNETES_SERVICE_HOST", urlPath.Hostname())	×
176	if err != nil {	×
177	setupLog.Error(err, "failed to set KUBERNETES_SERVICE_HOST environment variable")	×
178	}	×
179	err = os.Setenv("KUBERNETES_SERVICE_PORT", urlPath.Port())	×
180	if err != nil {	×
181	setupLog.Error(err, "failed to set KUBERNETES_SERVICE_PORT environment variable")	×
182	}	×
183	}
184
185	kubeconfig := os.Getenv("KUBECONFIG")	×
186	if kubeconfig != "" {	×
187	config, err = clientcmd.BuildConfigFromFlags("", kubeconfig)	×
188	} else {	×
189	// creates the in-cluster config	×
190	config, err = rest.InClusterConfig()	×
191	}	×
192
193	if err != nil {	×
194	return err	×
195	}	×
196
197	vars.Config = config	×
198	vars.Scheme = scheme.Scheme	×
199		×
200	closeAllConns, err := updateDialer(config)	×
201	if err != nil {	×
202	return err	×
203	}	×
204
205	err = sriovnetworkv1.AddToScheme(scheme.Scheme)	×
206	if err != nil {	×
207	setupLog.Error(err, "failed to load sriov network CRDs to scheme")	×
208	return err	×
209	}	×
210
211	err = mcfgv1.AddToScheme(scheme.Scheme)	×
212	if err != nil {	×
213	setupLog.Error(err, "failed to load machine config CRDs to scheme")	×
214	return err	×
215	}	×
216
217	err = configv1.Install(scheme.Scheme)	×
218	if err != nil {	×
219	setupLog.Error(err, "failed to load openshift config CRDs to scheme")	×
220	return err	×
221	}	×
222
223	kClient, err := client.New(config, client.Options{Scheme: scheme.Scheme})	×
224	if err != nil {	×
225	setupLog.Error(err, "couldn't create client")	×
226	os.Exit(1)	×
227	}	×
228
229	snclient := snclientset.NewForConfigOrDie(config)	×
230	kubeclient := kubernetes.NewForConfigOrDie(config)	×
231		×
232	hostHelpers, err := helper.NewDefaultHostHelpers()	×
233	if err != nil {	×
234	setupLog.Error(err, "failed to create hostHelpers")	×
235	return err	×
236	}	×
237
238	platformHelper, err := platforms.NewDefaultPlatformHelper()	×
239	if err != nil {	×
240	setupLog.Error(err, "failed to create platformHelper")	×
241	return err	×
242	}	×
243
244	config.Timeout = 5 * time.Second	×
245	writerclient := snclientset.NewForConfigOrDie(config)	×
246		×
247	eventRecorder := daemon.NewEventRecorder(writerclient, kubeclient)	×
248	defer eventRecorder.Shutdown()	×
249		×
250	setupLog.V(0).Info("starting node writer")	×
251	nodeWriter := daemon.NewNodeStateStatusWriter(writerclient,	×
252	closeAllConns,	×
253	eventRecorder,	×
254	hostHelpers,	×
255	platformHelper)	×
256		×
257	nodeInfo, err := kubeclient.CoreV1().Nodes().Get(context.Background(), startOpts.nodeName, v1.GetOptions{})	×
258	if err == nil {	×
259	for key, pType := range vars.PlatformsMap {	×
260	if strings.Contains(strings.ToLower(nodeInfo.Spec.ProviderID), strings.ToLower(key)) {	×
261	vars.PlatformType = pType	×
262	}	×
263	}
264	} else {	×
265	setupLog.Error(err, "failed to fetch node state, exiting", "node-name", startOpts.nodeName)	×
266	return err	×
267	}	×
268	setupLog.Info("Running on", "platform", vars.PlatformType.String())	×
269		×
270	if err := sriovnetworkv1.InitNicIDMapFromConfigMap(kubeclient, vars.Namespace); err != nil {	×
271	setupLog.Error(err, "failed to run init NicIdMap")	×
272	return err	×
273	}	×
274
275	eventRecorder.SendEvent("ConfigDaemonStart", "Config Daemon starting")	×
276		×
277	// block the deamon process until nodeWriter finish first its run	×
278	err = nodeWriter.RunOnce()	×
279	if err != nil {	×
280	setupLog.Error(err, "failed to run writer")	×
281	return err	×
282	}	×
283	go nodeWriter.Run(stopCh, refreshCh, syncCh)	×
284		×
285	// Init feature gates once to prevent race conditions.	×
286	defaultConfig := &sriovnetworkv1.SriovOperatorConfig{}	×
287	err = kClient.Get(context.Background(), types.NamespacedName{Namespace: vars.Namespace, Name: consts.DefaultConfigName}, defaultConfig)	×
288	if err != nil {	×
289	log.Log.Error(err, "Failed to get default SriovOperatorConfig object")	×
NEW 290	close(stopCh)	×
291	return err	×
292	}	×
293	featureGates := featuregate.New()	×
294	featureGates.Init(defaultConfig.Spec.FeatureGates)	×
295	vars.MlxPluginFwReset = featureGates.IsEnabled(consts.MellanoxFirmwareResetFeatureGate)	×
296	log.Log.Info("Enabled featureGates", "featureGates", featureGates.String())	×
297		×
298	setupLog.V(0).Info("Starting SriovNetworkConfigDaemon")	×
NEW 299		×
NEW 300	// create a signal channel to catch interrupts and gracefully shutdown the daemon	×
NEW 301	sigc := make(chan os.Signal, 1)	×
NEW 302	signal.Notify(sigc, os.Interrupt)	×
NEW 303	signal.Notify(sigc, syscall.SIGTERM)	×
NEW 304		×
NEW 305	errChan := make(chan error)	×
NEW 306	defer close(errChan)	×
NEW 307	go func() {	×
NEW 308	errChan <- daemon.New(	×
NEW 309	kClient,	×
NEW 310	snclient,	×
NEW 311	kubeclient,	×
NEW 312	hostHelpers,	×
NEW 313	platformHelper,	×
NEW 314	exitCh,	×
NEW 315	stopCh,	×
NEW 316	syncCh,	×
NEW 317	refreshCh,	×
NEW 318	eventRecorder,	×
NEW 319	featureGates,	×
NEW 320	startOpts.disabledPlugins,	×
NEW 321	).Run(stopCh, exitCh)	×
NEW 322	}()	×
323
NEW 324	select {	×
NEW 325	case err := <-errChan:	×
NEW 326	// daemon has exited, close the stop channel and return the error	×
NEW 327	close(stopCh)	×
NEW 328	return err	×
NEW 329	case <-sigc:	×
NEW 330	// signal received, close the stop channel and wait for the daemon to exit	×
NEW 331	close(stopCh)	×
NEW 332	if err := <-errChan; err != nil {	×
NEW 333	return err	×
NEW 334	}	×
335	}
336	setupLog.V(0).Info("Shutting down SriovNetworkConfigDaemon")	×
NEW 337	return nil	×
338	}
339
340	// updateDialer instruments a restconfig with a dial. the returned function allows forcefully closing all active connections.
341	func updateDialer(clientConfig *rest.Config) (func(), error) {	×
342	if clientConfig.Transport != nil \|\| clientConfig.Dial != nil {	×
343	return nil, fmt.Errorf("there is already a transport or dialer configured")	×
344	}	×
345	f := &net.Dialer{Timeout: 30 * time.Second, KeepAlive: 30 * time.Second}	×
346	d := connrotation.NewDialer(f.DialContext)	×
347	clientConfig.Dial = d.DialContext	×
348	return d.CloseAll, nil	×
349	}

k8snetworkplumbingwg / sriov-network-operator / 11341895365

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous