planner: use 'pl' for Planner variable name

Use 'pl' for Planner variable, and avoid confusion to the naive reader
with the (now obsolete) 'sl' name.

Signed-off-by: Shachar Sharon <[email protected]>

Author: synarete

internal/planner/configuration.go

@@ -22,23 +22,23 @@ import (
 	"github.com/samba-in-kubernetes/samba-operator/internal/smbcc"
 )
 
-func (sp *Planner) instanceID() smbcc.Key {
-	return smbcc.Key(sp.InstanceName())
+func (pl *Planner) instanceID() smbcc.Key {
+	return smbcc.Key(pl.InstanceName())
 }
 
-func (sp *Planner) shareName() string {
+func (pl *Planner) shareName() string {
 	// todo: make sure this is smb-conf clean, otherwise we need to
 	// fix up the name value(s).
-	if sp.SmbShare.Spec.ShareName != "" {
-		return sp.SmbShare.Spec.ShareName
+	if pl.SmbShare.Spec.ShareName != "" {
+		return pl.SmbShare.Spec.ShareName
 	}
 	// It was not named explicitly. Name it after the CR.
 	// todo: may need massaging too.
-	return sp.SmbShare.Name
+	return pl.SmbShare.Name
 }
 
-func (sp *Planner) idmapOptions() smbcc.SmbOptions {
-	if sp.SecurityConfig == nil || len(sp.SecurityConfig.Spec.Domains) == 0 {
+func (pl *Planner) idmapOptions() smbcc.SmbOptions {
+	if pl.SecurityConfig == nil || len(pl.SecurityConfig.Spec.Domains) == 0 {
 		// default idmap config
 		return smbcc.SmbOptions{
 			"idmap config * : backend": "autorid",
@@ -51,7 +51,7 @@ func (sp *Planner) idmapOptions() smbcc.SmbOptions {
 	o := smbcc.SmbOptions{}
 	doms := []api.SmbSecurityDomainSpec{}
 	userDefault := false
-	for _, d := range sp.SecurityConfig.Spec.Domains {
+	for _, d := range pl.SecurityConfig.Spec.Domains {
 		doms = append(doms, d)
 		if d.Name == "*" {
 			userDefault = true
@@ -80,61 +80,61 @@ func (sp *Planner) idmapOptions() smbcc.SmbOptions {
 
 // Update the held configuration based on the state of the instance
 // configuration.
-func (sp *Planner) Update() (changed bool, err error) {
-	globals, found := sp.ConfigState.Globals[smbcc.Globals]
+func (pl *Planner) Update() (changed bool, err error) {
+	globals, found := pl.ConfigState.Globals[smbcc.Globals]
 	if !found {
 		globalOptions := smbcc.NewGlobalOptions()
-		globalOptions.SmbPort = sp.GlobalConfig.SmbdPort
+		globalOptions.SmbPort = pl.GlobalConfig.SmbdPort
 		globals = smbcc.NewGlobals(globalOptions)
-		sp.ConfigState.Globals[smbcc.Globals] = globals
+		pl.ConfigState.Globals[smbcc.Globals] = globals
 		changed = true
 	}
-	shareKey := smbcc.Key(sp.shareName())
-	share, found := sp.ConfigState.Shares[shareKey]
+	shareKey := smbcc.Key(pl.shareName())
+	share, found := pl.ConfigState.Shares[shareKey]
 	if !found {
-		share = smbcc.NewSimpleShare(sp.Paths().Share())
-		if !sp.SmbShare.Spec.Browseable {
+		share = smbcc.NewSimpleShare(pl.Paths().Share())
+		if !pl.SmbShare.Spec.Browseable {
 			share.Options[smbcc.BrowseableParam] = smbcc.No
 		}
-		if sp.SmbShare.Spec.ReadOnly {
+		if pl.SmbShare.Spec.ReadOnly {
 			share.Options[smbcc.ReadOnlyParam] = smbcc.Yes
 		}
-		sp.ConfigState.Shares[shareKey] = share
+		pl.ConfigState.Shares[shareKey] = share
 		changed = true
 	}
-	cfgKey := sp.instanceID()
-	cfg, found := sp.ConfigState.Configs[cfgKey]
+	cfgKey := pl.instanceID()
+	cfg, found := pl.ConfigState.Configs[cfgKey]
 	if !found || cfg.Shares[0] != shareKey {
 		cfg = smbcc.ConfigSection{
 			Shares:       []smbcc.Key{shareKey},
 			Globals:      []smbcc.Key{smbcc.Globals},
-			InstanceName: sp.InstanceName(),
+			InstanceName: pl.InstanceName(),
 		}
-		if sp.SecurityMode() == ADMode {
-			realmKey := smbcc.Key(sp.Realm())
+		if pl.SecurityMode() == ADMode {
+			realmKey := smbcc.Key(pl.Realm())
 			cfg.Globals = append(cfg.Globals, realmKey)
 		}
-		if sp.IsClustered() {
+		if pl.IsClustered() {
 			cfg.InstanceFeatures = []smbcc.FeatureFlag{smbcc.CTDB}
 		}
-		sp.ConfigState.Configs[cfgKey] = cfg
+		pl.ConfigState.Configs[cfgKey] = cfg
 		changed = true
 	}
-	if len(sp.ConfigState.Users) == 0 {
-		sp.ConfigState.Users = smbcc.NewDefaultUsers()
+	if len(pl.ConfigState.Users) == 0 {
+		pl.ConfigState.Users = smbcc.NewDefaultUsers()
 		changed = true
 	}
-	if sp.SecurityMode() == ADMode {
-		realmKey := smbcc.Key(sp.Realm())
-		_, found := sp.ConfigState.Globals[realmKey]
+	if pl.SecurityMode() == ADMode {
+		realmKey := smbcc.Key(pl.Realm())
+		_, found := pl.ConfigState.Globals[realmKey]
 		if !found {
-			opts := sp.idmapOptions()
+			opts := pl.idmapOptions()
 			// security mode
 			opts["security"] = "ads"
 			// workgroup and realm
-			opts["workgroup"] = sp.Workgroup()
-			opts["realm"] = sp.Realm()
-			sp.ConfigState.Globals[realmKey] = smbcc.GlobalConfig{
+			opts["workgroup"] = pl.Workgroup()
+			opts["realm"] = pl.Realm()
+			pl.ConfigState.Globals[realmKey] = smbcc.GlobalConfig{
 				Options: opts,
 			}
 			changed = true

internal/planner/misc.go

@@ -32,18 +32,18 @@ type UserSecuritySource struct {
 
 // UserSecuritySource returns the UserSecuritySource type for the
 // particular instance.
-func (sp *Planner) UserSecuritySource() UserSecuritySource {
+func (pl *Planner) UserSecuritySource() UserSecuritySource {
 	s := UserSecuritySource{}
-	if sp.SecurityMode() != UserMode {
+	if pl.SecurityMode() != UserMode {
 		return s
 	}
-	if sp.SecurityConfig == nil || sp.SecurityConfig.Spec.Users == nil {
+	if pl.SecurityConfig == nil || pl.SecurityConfig.Spec.Users == nil {
 		return s
 	}
 	s.Configured = true
-	s.Namespace = sp.SecurityConfig.Namespace
-	s.Secret = sp.SecurityConfig.Spec.Users.Secret
-	s.Key = sp.SecurityConfig.Spec.Users.Key
+	s.Namespace = pl.SecurityConfig.Namespace
+	s.Secret = pl.SecurityConfig.Spec.Users.Secret
+	s.Key = pl.SecurityConfig.Spec.Users.Key
 	return s
 }
 
@@ -63,10 +63,10 @@ const (
 )
 
 // DNSRegister returns a DNSRegister type for this instance.
-func (sp *Planner) DNSRegister() DNSRegister {
+func (pl *Planner) DNSRegister() DNSRegister {
 	reg := DNSRegisterNever
-	if sp.SecurityMode() == ADMode && sp.SecurityConfig.Spec.DNS != nil {
-		reg = DNSRegister(sp.SecurityConfig.Spec.DNS.Register)
+	if pl.SecurityMode() == ADMode && pl.SecurityConfig.Spec.DNS != nil {
+		reg = DNSRegister(pl.SecurityConfig.Spec.DNS.Register)
 	}
 	switch reg {
 	// allowed values
@@ -82,27 +82,27 @@ func (sp *Planner) DNSRegister() DNSRegister {
 
 // ServiceType returns the value that should be used for a Service fronting
 // the SMB port for this instance.
-func (sp *Planner) ServiceType() string {
-	if sp.CommonConfig != nil && sp.CommonConfig.Spec.Network.Publish == "external" {
+func (pl *Planner) ServiceType() string {
+	if pl.CommonConfig != nil && pl.CommonConfig.Spec.Network.Publish == "external" {
 		return "LoadBalancer"
 	}
 	return "ClusterIP"
 }
 
 // SambaContainerDebugLevel returns a string that can be passed to Samba
 // tools for debugging.
-func (sp *Planner) SambaContainerDebugLevel() string {
-	return sp.GlobalConfig.SambaDebugLevel
+func (pl *Planner) SambaContainerDebugLevel() string {
+	return pl.GlobalConfig.SambaDebugLevel
 }
 
 // MayCluster returns true if the operator is permitted to create clustered
 // instances.
-func (sp *Planner) MayCluster() bool {
-	return sp.GlobalConfig.ClusterSupport == "ctdb-is-experimental"
+func (pl *Planner) MayCluster() bool {
+	return pl.GlobalConfig.ClusterSupport == "ctdb-is-experimental"
 }
 
 // NodeSpread returns true if pods are required to be spread over multiple
 // nodes.
-func (sp *Planner) NodeSpread() bool {
-	return sp.SmbShare.Annotations[nodeSpreadKey] != nodeSpreadDisable
+func (pl *Planner) NodeSpread() bool {
+	return pl.SmbShare.Annotations[nodeSpreadKey] != nodeSpreadDisable
 }

internal/planner/properties.go

@@ -41,17 +41,17 @@ const (
 )
 
 // InstanceName returns the instance's name.
-func (sp *Planner) InstanceName() string {
+func (pl *Planner) InstanceName() string {
 	// for now, its the name of the Server Group
-	return sp.SmbShare.Status.ServerGroup
+	return pl.SmbShare.Status.ServerGroup
 }
 
 // SecurityMode returns the high level security mode to be used.
-func (sp *Planner) SecurityMode() SecurityMode {
-	if sp.SecurityConfig == nil {
+func (pl *Planner) SecurityMode() SecurityMode {
+	if pl.SecurityConfig == nil {
 		return UserMode
 	}
-	m := SecurityMode(sp.SecurityConfig.Spec.Mode)
+	m := SecurityMode(pl.SecurityConfig.Spec.Mode)
 	if m != UserMode && m != ADMode {
 		// this shouldn't normally be possible unless kube validation
 		// fails or is out of sync.
@@ -61,30 +61,30 @@ func (sp *Planner) SecurityMode() SecurityMode {
 }
 
 // Realm returns the name of the realm (domain).
-func (sp *Planner) Realm() string {
-	return strings.ToUpper(sp.SecurityConfig.Spec.Realm)
+func (pl *Planner) Realm() string {
+	return strings.ToUpper(pl.SecurityConfig.Spec.Realm)
 }
 
 // Workgroup returns the name of the workgroup. This may be automatically
 // derived from the realm.
-func (sp *Planner) Workgroup() string {
+func (pl *Planner) Workgroup() string {
 	// todo: this is a big hack. needs thought and cleanup
-	parts := strings.SplitN(sp.Realm(), ".", 2)
+	parts := strings.SplitN(pl.Realm(), ".", 2)
 	return parts[0]
 }
 
 // IsClustered returns true if the instance is configured for clustering.
-func (sp *Planner) IsClustered() bool {
-	if sp.SmbShare.Spec.Scaling == nil {
+func (pl *Planner) IsClustered() bool {
+	if pl.SmbShare.Spec.Scaling == nil {
 		return false
 	}
-	return sp.SmbShare.Spec.Scaling.AvailabilityMode == "clustered"
+	return pl.SmbShare.Spec.Scaling.AvailabilityMode == "clustered"
 }
 
 // ClusterSize returns the (minimum) size of the cluster.
-func (sp *Planner) ClusterSize() int32 {
-	if sp.SmbShare.Spec.Scaling == nil {
+func (pl *Planner) ClusterSize() int32 {
+	if pl.SmbShare.Spec.Scaling == nil {
 		return 1
 	}
-	return int32(sp.SmbShare.Spec.Scaling.MinClusterSize)
+	return int32(pl.SmbShare.Spec.Scaling.MinClusterSize)
 }