Added wsl linter, and fixed related issues (#275)

* added wsl linter

* fixed issues

.golangci.yml

@@ -10,3 +10,4 @@ linters:
 
   # extra
   - misspell
+  - wsl

cli/cmds/cluster/create.go

@@ -97,6 +97,7 @@ func createAction(config *CreateConfig) cli.ActionFunc {
 
 		if config.token != "" {
 			logrus.Infof("Creating cluster token secret")
+
 			obj := k3kcluster.TokenSecretObj(config.token, name, cmds.Namespace())
 			if err := ctrlClient.Create(ctx, &obj); err != nil {
 				return err
@@ -116,10 +117,12 @@ func createAction(config *CreateConfig) cli.ActionFunc {
 		if err != nil {
 			return err
 		}
+
 		host := strings.Split(url.Host, ":")
 		if config.kubeconfigServerHost != "" {
 			host = []string{config.kubeconfigServerHost}
 		}
+
 		cluster.Spec.TLSSANs = []string{host[0]}
 
 		if err := ctrlClient.Create(ctx, cluster); err != nil {
@@ -144,6 +147,7 @@ func createAction(config *CreateConfig) cli.ActionFunc {
 		cfg := kubeconfig.New()
 
 		var kubeconfig *clientcmdapi.Config
+
 		if err := retry.OnError(availableBackoff, apierrors.IsNotFound, func() error {
 			kubeconfig, err = cfg.Extract(ctx, ctrlClient, cluster, host[0])
 			return err
@@ -199,6 +203,7 @@ func newCluster(name, namespace string, config *CreateConfig) *v1alpha1.Cluster
 	if config.storageClassName == "" {
 		cluster.Spec.Persistence.StorageClassName = nil
 	}
+
 	if config.token != "" {
 		cluster.Spec.TokenSecretRef = &v1.SecretReference{
 			Name:      k3kcluster.TokenSecretName(name),

cli/cmds/cluster/delete.go

@@ -57,5 +57,6 @@ func delete(clx *cli.Context) error {
 			Namespace: cmds.Namespace(),
 		},
 	}
+
 	return ctrlClient.Delete(ctx, &cluster)
 }

cli/cmds/kubeconfig/kubeconfig.go

@@ -102,6 +102,7 @@ func NewCommand() *cli.Command {
 
 func generate(clx *cli.Context) error {
 	var cluster v1alpha1.Cluster
+
 	ctx := context.Background()
 
 	restConfig, err := clientcmd.BuildConfigFromFlags("", cmds.Kubeconfig)
@@ -115,6 +116,7 @@ func generate(clx *cli.Context) error {
 	if err != nil {
 		return err
 	}
+
 	clusterKey := types.NamespacedName{
 		Name:      name,
 		Namespace: cmds.Namespace(),
@@ -128,11 +130,12 @@ func generate(clx *cli.Context) error {
 	if err != nil {
 		return err
 	}
+
 	host := strings.Split(url.Host, ":")
 	if kubeconfigServerHost != "" {
 		host = []string{kubeconfigServerHost}
-		err := altNames.Set(kubeconfigServerHost)
-		if err != nil {
+
+		if err := altNames.Set(kubeconfigServerHost); err != nil {
 			return err
 		}
 	}
@@ -154,6 +157,7 @@ func generate(clx *cli.Context) error {
 	logrus.Infof("waiting for cluster to be available..")
 
 	var kubeconfig *clientcmdapi.Config
+
 	if err := retry.OnError(controller.Backoff, apierrors.IsNotFound, func() error {
 		kubeconfig, err = cfg.Extract(ctx, ctrlClient, &cluster, host[0])
 		return err

cli/cmds/root.go

@@ -48,6 +48,7 @@ func NewApp() *cli.App {
 		if debug {
 			logrus.SetLevel(logrus.DebugLevel)
 		}
+
 		return nil
 	}
 
@@ -58,5 +59,6 @@ func Namespace() string {
 	if namespace == "" {
 		return defaultNamespace
 	}
+
 	return namespace
 }

k3k-kubelet/config.go

@@ -31,46 +31,59 @@ func (c *config) unmarshalYAML(data []byte) error {
 	if c.ClusterName == "" {
 		c.ClusterName = conf.ClusterName
 	}
+
 	if c.ClusterNamespace == "" {
 		c.ClusterNamespace = conf.ClusterNamespace
 	}
+
 	if c.HostConfigPath == "" {
 		c.HostConfigPath = conf.HostConfigPath
 	}
+
 	if c.VirtualConfigPath == "" {
 		c.VirtualConfigPath = conf.VirtualConfigPath
 	}
+
 	if c.KubeletPort == "" {
 		c.KubeletPort = conf.KubeletPort
 	}
+
 	if c.AgentHostname == "" {
 		c.AgentHostname = conf.AgentHostname
 	}
+
 	if c.ServiceName == "" {
 		c.ServiceName = conf.ServiceName
 	}
+
 	if c.Token == "" {
 		c.Token = conf.Token
 	}
+
 	if c.ServerIP == "" {
 		c.ServerIP = conf.ServerIP
 	}
+
 	if c.Version == "" {
 		c.Version = conf.Version
 	}
+
 	return nil
 }
 
 func (c *config) validate() error {
 	if c.ClusterName == "" {
 		return errors.New("cluster name is not provided")
 	}
+
 	if c.ClusterNamespace == "" {
 		return errors.New("cluster namespace is not provided")
 	}
+
 	if c.AgentHostname == "" {
 		return errors.New("agent Hostname is not provided")
 	}
+
 	return nil
 }
 
@@ -83,5 +96,6 @@ func (c *config) parse(path string) error {
 	if err != nil {
 		return err
 	}
+
 	return c.unmarshalYAML(b)
 }

k3k-kubelet/controller/configmap.go

@@ -38,23 +38,27 @@ func (c *ConfigMapSyncer) Reconcile(ctx context.Context, req reconcile.Request)
 		// return immediately without re-enqueueing. We aren't watching this resource
 		return reconcile.Result{}, nil
 	}
+
 	var virtual corev1.ConfigMap
 
 	if err := c.VirtualClient.Get(ctx, req.NamespacedName, &virtual); err != nil {
 		return reconcile.Result{
 			Requeue: true,
 		}, fmt.Errorf("unable to get configmap %s/%s from virtual cluster: %w", req.Namespace, req.Name, err)
 	}
+
 	translated, err := c.TranslateFunc(&virtual)
 	if err != nil {
 		return reconcile.Result{
 			Requeue: true,
 		}, fmt.Errorf("unable to translate configmap %s/%s from virtual cluster: %w", req.Namespace, req.Name, err)
 	}
+
 	translatedKey := types.NamespacedName{
 		Namespace: translated.Namespace,
 		Name:      translated.Name,
 	}
+
 	var host corev1.ConfigMap
 	if err = c.HostClient.Get(ctx, translatedKey, &host); err != nil {
 		if apierrors.IsNotFound(err) {
@@ -66,6 +70,7 @@ func (c *ConfigMapSyncer) Reconcile(ctx context.Context, req reconcile.Request)
 				}, fmt.Errorf("unable to create host configmap %s/%s for virtual configmap %s/%s: %w",
 					translated.Namespace, translated.Name, req.Namespace, req.Name, err)
 		}
+
 		return reconcile.Result{Requeue: true}, fmt.Errorf("unable to get host configmap %s/%s: %w", translated.Namespace, translated.Name, err)
 	}
 	// we are going to use the host in order to avoid conflicts on update
@@ -79,13 +84,14 @@ func (c *ConfigMapSyncer) Reconcile(ctx context.Context, req reconcile.Request)
 	for key, value := range translated.Labels {
 		host.Labels[key] = value
 	}
+
 	if err = c.HostClient.Update(ctx, &host); err != nil {
 		return reconcile.Result{
 				Requeue: true,
 			}, fmt.Errorf("unable to update host configmap %s/%s for virtual configmap %s/%s: %w",
 				translated.Namespace, translated.Name, req.Namespace, req.Name, err)
-
 	}
+
 	return reconcile.Result{}, nil
 }
 
@@ -94,6 +100,7 @@ func (c *ConfigMapSyncer) Reconcile(ctx context.Context, req reconcile.Request)
 func (c *ConfigMapSyncer) isWatching(key types.NamespacedName) bool {
 	c.mutex.RLock()
 	defer c.mutex.RUnlock()
+
 	return c.objs.Has(key)
 }
 
@@ -104,23 +111,29 @@ func (c *ConfigMapSyncer) AddResource(ctx context.Context, namespace, name strin
 		Namespace: namespace,
 		Name:      name,
 	}
+
 	// if we already sync this object, no need to writelock/add it
 	if c.isWatching(objKey) {
 		return nil
 	}
+
 	// lock in write mode since we are now adding the key
 	c.mutex.Lock()
 	if c.objs == nil {
 		c.objs = sets.Set[types.NamespacedName]{}
 	}
+
 	c.objs = c.objs.Insert(objKey)
 	c.mutex.Unlock()
+
 	_, err := c.Reconcile(ctx, reconcile.Request{
 		NamespacedName: objKey,
 	})
+
 	if err != nil {
 		return fmt.Errorf("unable to reconcile new object %s/%s: %w", objKey.Namespace, objKey.Name, err)
 	}
+
 	return nil
 }
 
@@ -143,24 +156,34 @@ func (c *ConfigMapSyncer) RemoveResource(ctx context.Context, namespace, name st
 	}); err != nil {
 		return fmt.Errorf("unable to remove configmap: %w", err)
 	}
+
 	c.mutex.Lock()
 	if c.objs == nil {
 		c.objs = sets.Set[types.NamespacedName]{}
 	}
+
 	c.objs = c.objs.Delete(objKey)
 	c.mutex.Unlock()
+
 	return nil
 }
 
 func (c *ConfigMapSyncer) removeHostConfigMap(ctx context.Context, virtualNamespace, virtualName string) error {
 	var vConfigMap corev1.ConfigMap
-	err := c.VirtualClient.Get(ctx, types.NamespacedName{Namespace: virtualNamespace, Name: virtualName}, &vConfigMap)
-	if err != nil {
+
+	key := types.NamespacedName{
+		Namespace: virtualNamespace,
+		Name:      virtualName,
+	}
+
+	if err := c.VirtualClient.Get(ctx, key, &vConfigMap); err != nil {
 		return fmt.Errorf("unable to get virtual configmap %s/%s: %w", virtualNamespace, virtualName, err)
 	}
+
 	translated, err := c.TranslateFunc(&vConfigMap)
 	if err != nil {
 		return fmt.Errorf("unable to translate virtual secret: %s/%s: %w", virtualNamespace, virtualName, err)
 	}
+
 	return c.HostClient.Delete(ctx, translated)
 }

k3k-kubelet/controller/handler.go

@@ -45,17 +45,22 @@ type updateableReconciler interface {
 
 func (c *ControllerHandler) AddResource(ctx context.Context, obj client.Object) error {
 	c.RLock()
+
 	controllers := c.controllers
 	if controllers != nil {
 		if r, ok := c.controllers[obj.GetObjectKind().GroupVersionKind()]; ok {
 			err := r.AddResource(ctx, obj.GetNamespace(), obj.GetName())
 			c.RUnlock()
+
 			return err
 		}
 	}
+
 	// we need to manually lock/unlock since we intned on write locking to add a new controller
 	c.RUnlock()
+
 	var r updateableReconciler
+
 	switch obj.(type) {
 	case *v1.Secret:
 		r = &SecretSyncer{
@@ -89,19 +94,23 @@ func (c *ControllerHandler) AddResource(ctx context.Context, obj client.Object)
 		// TODO: Technically, the configmap/secret syncers are relatively generic, and this
 		// logic could be used for other types.
 		return fmt.Errorf("unrecognized type: %T", obj)
-
 	}
+
 	err := ctrl.NewControllerManagedBy(c.Mgr).
 		For(&v1.ConfigMap{}).
 		Complete(r)
+
 	if err != nil {
 		return fmt.Errorf("unable to start configmap controller: %w", err)
 	}
+
 	c.Lock()
 	if c.controllers == nil {
 		c.controllers = map[schema.GroupVersionKind]updateableReconciler{}
 	}
+
 	c.controllers[obj.GetObjectKind().GroupVersionKind()] = r
+
 	c.Unlock()
 
 	return r.AddResource(ctx, obj.GetNamespace(), obj.GetName())
@@ -112,8 +121,10 @@ func (c *ControllerHandler) RemoveResource(ctx context.Context, obj client.Objec
 	c.RLock()
 	ctrl, ok := c.controllers[obj.GetObjectKind().GroupVersionKind()]
 	c.RUnlock()
+
 	if !ok {
 		return fmt.Errorf("no controller found for gvk %s", obj.GetObjectKind().GroupVersionKind())
 	}
+
 	return ctrl.RemoveResource(ctx, obj.GetNamespace(), obj.GetName())
 }