fix variable names collding with imported package names

Author: knopers8

configuration/template/fields.go

@@ -343,7 +343,7 @@ func (fields Fields) Execute(confSvc ConfigurationService, parentPath string, va
 
 func copyMap(src map[string]interface{}, dest map[string]interface{}) {
 	for k, v := range src {
-		vm, ok := v.(map[string]interface{})
+		vmap, ok := v.(map[string]interface{})
 		if ok {
 			var destk map[string]interface{}
 			if _, exists := dest[k]; exists {
@@ -354,7 +354,7 @@ func copyMap(src map[string]interface{}, dest map[string]interface{}) {
 			} else {
 				destk = make(map[string]interface{})
 			}
-			copyMap(vm, destk)
+			copyMap(vmap, destk)
 			dest[k] = destk
 		} else {
 			dest[k] = v

core/server.go

@@ -860,24 +860,24 @@ func (m *RpcServer) GetTask(cxt context.Context, req *pb.GetTaskRequest) (*pb.Ge
 	m.logMethod()
 	defer m.logMethodHandled()
 
-	task := m.state.taskman.GetTask(req.TaskId)
-	if task == nil {
+	requestedTask := m.state.taskman.GetTask(req.TaskId)
+	if requestedTask == nil {
 		return &pb.GetTaskReply{Timestamp: currentUnixMilli()}, status.New(codes.NotFound, "task not found").Err()
 	}
-	taskClass := task.GetTaskClass()
-	commandInfo := task.GetTaskCommandInfo()
+	taskClass := requestedTask.GetTaskClass()
+	commandInfo := requestedTask.GetTaskCommandInfo()
 	var outbound []channel.Outbound
 	var inbound []channel.Inbound
 	taskPath := ""
 	// TODO: probably not the nicest way to do this... the outbound assignments should be cached
 	// in the Task
-	if task.IsLocked() {
+	if requestedTask.IsLocked() {
 		type parentRole interface {
 			CollectOutboundChannels() []channel.Outbound
 			GetPath() string
 			CollectInboundChannels() []channel.Inbound
 		}
-		parent, ok := task.GetParentRole().(parentRole)
+		parent, ok := requestedTask.GetParentRole().(parentRole)
 		if ok {
 			outbound = channel.MergeOutbound(parent.CollectOutboundChannels(), taskClass.Connect)
 			taskPath = parent.GetPath()
@@ -891,13 +891,13 @@ func (m *RpcServer) GetTask(cxt context.Context, req *pb.GetTaskRequest) (*pb.Ge
 
 	rep := &pb.GetTaskReply{
 		Task: &pb.TaskInfo{
-			ShortInfo:        taskToShortTaskInfo(task, m.state.taskman),
+			ShortInfo:        taskToShortTaskInfo(requestedTask, m.state.taskman),
 			InboundChannels:  inboundChannelsToPbChannels(inbound),
 			OutboundChannels: outboundChannelsToPbChannels(outbound),
 			CommandInfo:      commandInfoToPbCommandInfo(commandInfo),
 			TaskPath:         taskPath,
-			EnvId:            task.GetEnvironmentId().String(),
-			Properties:       task.GetProperties(),
+			EnvId:            requestedTask.GetEnvironmentId().String(),
+			Properties:       requestedTask.GetProperties(),
 		},
 		Timestamp: currentUnixMilli(),
 	}

core/task/manager.go

@@ -744,7 +744,7 @@ func (m *Manager) configureTasks(envId uid.ID, tasks Tasks) error {
 		Debug("generated inbound bindMap for environment configuration")
 
 	src := sm.STANDBY.String()
-	event := "CONFIGURE"
+	evt := "CONFIGURE"
 	dest := sm.CONFIGURED.String()
 	args := make(controlcommands.PropertyMapsMap)
 	args, err = tasks.BuildPropertyMaps(bindMap)
@@ -755,7 +755,7 @@ func (m *Manager) configureTasks(envId uid.ID, tasks Tasks) error {
 		WithField("partition", envId.String()).
 		Debug("pushing configuration to tasks")
 
-	cmd := controlcommands.NewMesosCommand_Transition(envId, receivers, src, event, dest, args)
+	cmd := controlcommands.NewMesosCommand_Transition(envId, receivers, src, evt, dest, args)
 	cmd.ResponseTimeout = 120 * time.Second // The default timeout is 90 seconds, but we need more time for the tasks to configure
 	_ = m.cq.Enqueue(cmd, notify)
 

core/task/scheduler.go

@@ -1516,12 +1516,12 @@ func makeTaskForMesosResources(
 		WithField("inboundChannels", func() string {
 			accu := make([]string, len(wants.InboundChannels))
 			for i := 0; i < len(wants.InboundChannels); i++ {
-				channel := wants.InboundChannels[i]
-				accu[i] = channel.Name
-				if len(channel.Global) > 0 {
-					accu[i] += fmt.Sprintf(" (global: %s)", channel.Global)
+				inboundChannel := wants.InboundChannels[i]
+				accu[i] = inboundChannel.Name
+				if len(inboundChannel.Global) > 0 {
+					accu[i] += fmt.Sprintf(" (global: %s)", inboundChannel.Global)
 				}
-				if endpoint, ok := bindMap[channel.Name]; ok {
+				if endpoint, ok := bindMap[inboundChannel.Name]; ok {
 					accu[i] += fmt.Sprintf(" -> %s", endpoint.GetAddress())
 				}
 			}

core/workflow/callable/call.go

@@ -72,14 +72,14 @@ func NewCall(funcCall string, returnVar string, parent ParentRole) (call *Call)
 }
 
 func (s Calls) CallAll() map[*Call]error {
-	errors := make(map[*Call]error)
+	errs := make(map[*Call]error)
 	for _, v := range s {
 		err := v.Call()
 		if err != nil {
-			errors[v] = err
+			errs[v] = err
 		}
 	}
-	return errors
+	return errs
 }
 
 func (s Calls) StartAll() {
@@ -90,20 +90,20 @@ func (s Calls) StartAll() {
 
 func (s Calls) AwaitAll() map[*Call]error {
 	// Since each Await call blocks, we call it in parallel and then collect
-	errors := make(map[*Call]error)
+	errs := make(map[*Call]error)
 	wg := &sync.WaitGroup{}
 	wg.Add(len(s))
 	for _, v := range s {
 		go func(v *Call) {
 			defer wg.Done()
 			err := v.Await()
 			if err != nil {
-				errors[v] = err
+				errs[v] = err
 			}
 		}(v)
 	}
 	wg.Wait()
-	return errors
+	return errs
 }
 
 func (c *Call) Call() error {

executor/executable/task.go

@@ -208,20 +208,20 @@ func prepareTaskCmd(commandInfo *common.TaskCommandInfo) (*exec.Cmd, error) {
 			return nil, err
 		}
 
-		uid, err := strconv.ParseUint(targetUser.Uid, 10, 32)
+		userid, err := strconv.ParseUint(targetUser.Uid, 10, 32)
 		if err != nil {
 			return nil, err
 		}
-		gid, err := strconv.ParseUint(targetUser.Gid, 10, 32)
+		groupid, err := strconv.ParseUint(targetUser.Gid, 10, 32)
 		if err != nil {
 			return nil, err
 		}
 
 		gids, gidStrings := executorutil.GetGroupIDs(targetUser)
 
 		credential := &syscall.Credential{
-			Uid:         uint32(uid),
-			Gid:         uint32(gid),
+			Uid:         uint32(userid),
+			Gid:         uint32(groupid),
 			Groups:      gids,
 			NoSetGroups: false,
 		}

executor/executor.go

@@ -111,7 +111,7 @@ func Run(cfg config.Config) {
 			Host:   cfg.AgentEndpoint,
 			Path:   apiPath,
 		}
-		http = httpcli.New(
+		client = httpcli.New(
 			httpcli.Endpoint(apiURL.String()),
 			httpcli.Codec(codecs.ByMediaType[codecs.MediaTypeProtobuf]),
 			httpcli.Do(httpcli.With(
@@ -132,7 +132,7 @@ func Run(cfg config.Config) {
 		state = &internalState{
 			// With this we inject the callOptions into all outgoing calls
 			cli: calls.SenderWith(
-				httpexec.NewSender(http.Send),
+				httpexec.NewSender(client.Send),
 				callOptions...,
 			),
 			// The executor keeps lists of unacknowledged tasks and unacknowledged updates. In case of unexpected
@@ -151,7 +151,7 @@ func Run(cfg config.Config) {
 		}
 		subscriber = calls.SenderWith(
 			// Here too, callOptions for all outgoing subscriber calls
-			httpexec.NewSender(http.Send, httpcli.Close(true)),
+			httpexec.NewSender(client.Send, httpcli.Close(true)),
 			callOptions...,
 		)
 

executor/executorcmd/client.go

@@ -43,7 +43,7 @@ import (
 	"github.com/AliceO2Group/Control/executor/executorcmd/transitioner"
 	pb "github.com/AliceO2Group/Control/executor/protos"
 	"github.com/sirupsen/logrus"
-	"google.golang.org/grpc/status"
+	grpcstatus "google.golang.org/grpc/status"
 )
 
 type ControlTransport uint32
@@ -164,7 +164,7 @@ func (r *RpcClient) doTransition(ei transitioner.EventInfo) (newState string, er
 	}, grpc.EmptyCallOption{})
 
 	if err != nil {
-		status, ok := status.FromError(err)
+		status, ok := grpcstatus.FromError(err)
 		if ok {
 			r.Log.WithFields(logrus.Fields{
 				"code":    status.Code().String(),