refactor func names

Author: kaberovnikita

fakedevices/genericFakeDevice.go

@@ -61,16 +61,16 @@ func readFile(filename string) (string, error) {
 
 // InitScenario builds a FakeDevice for a named scenario, loading the base platform
 // and returning the pre-loaded sequence steps alongside the device.
-func InitScenario(scenarioName string, tm transcript.Map, baseDir string) (*FakeDevice, []transcript.SequenceStep, error) {
-	s, ok := tm.Scenarios[scenarioName]
+func InitScenario(name string, tm transcript.Map, baseDir string) (*FakeDevice, []transcript.SequenceStep, error) {
+	s, ok := tm.Scenarios[name]
 	if !ok {
-		return nil, nil, fmt.Errorf("scenario %q not found in transcript map", scenarioName)
+		return nil, nil, fmt.Errorf("scenario %q not found in transcript map", name)
 	}
 	fd, err := InitGeneric(s.Platform, tm, baseDir)
 	if err != nil {
 		return nil, nil, err
 	}
-	fd.ScenarioName = scenarioName
+	fd.ScenarioName = name
 	steps := make([]transcript.SequenceStep, len(s.Sequence))
 	for i, step := range s.Sequence {
 		path := step.Transcript
@@ -89,8 +89,8 @@ func InitScenario(scenarioName string, tm transcript.Map, baseDir string) (*Fake
 // InitGeneric builds a FakeDevice struct for use with cisshgo.
 // baseDir is the directory from which transcript paths are resolved (typically
 // the directory containing the transcript map file).
-func InitGeneric(platform string, myTranscriptMap transcript.Map, baseDir string) (*FakeDevice, error) {
-	p, ok := myTranscriptMap.Platforms[platform]
+func InitGeneric(platform string, tm transcript.Map, baseDir string) (*FakeDevice, error) {
+	p, ok := tm.Platforms[platform]
 	if !ok {
 		return nil, fmt.Errorf("platform %q not found in transcript map", platform)
 	}

fakedevices/transcriptReader.go

@@ -8,7 +8,7 @@ import (
 )
 
 // TranscriptReader parses a transcript file and populates any variables that may exist in it
-func TranscriptReader(transcript string, fakeDevice *FakeDevice) (string, error) {
+func TranscriptReader(transcript string, fd *FakeDevice) (string, error) {
 
 	// Setup a template with our transcript
 	tmpl, err := template.New("fakeDeviceTemplate").Parse(transcript)
@@ -20,7 +20,7 @@ func TranscriptReader(transcript string, fakeDevice *FakeDevice) (string, error)
 	var renderedTemplate bytes.Buffer
 
 	// Render (Execute) the template with our input
-	if err := tmpl.Execute(&renderedTemplate, fakeDevice); err != nil {
+	if err := tmpl.Execute(&renderedTemplate, fd); err != nil {
 		return "", err
 	}
 

ssh_server/handlers/ciscohandlers.go

@@ -16,25 +16,25 @@ import (
 )
 
 // GenericCiscoHandler function handles generic Cisco style sessions
-func GenericCiscoHandler(myFakeDevice *fakedevices.FakeDevice) ssh.Handler {
-	return genericCiscoSession(myFakeDevice, nil)
+func GenericCiscoHandler(fd *fakedevices.FakeDevice) ssh.Handler {
+	return genericCiscoSession(fd, nil)
 }
 
 // GenericCiscoScenarioHandler returns an ssh.Handler that plays back a scenario sequence.
-func GenericCiscoScenarioHandler(myFakeDevice *fakedevices.FakeDevice, sequence []transcript.SequenceStep) ssh.Handler {
-	return genericCiscoSession(myFakeDevice, sequence)
+func GenericCiscoScenarioHandler(fd *fakedevices.FakeDevice, sequence []transcript.SequenceStep) ssh.Handler {
+	return genericCiscoSession(fd, sequence)
 }
 
-func genericCiscoSession(myFakeDevice *fakedevices.FakeDevice, sequence []transcript.SequenceStep) ssh.Handler {
+func genericCiscoSession(fd *fakedevices.FakeDevice, sequence []transcript.SequenceStep) ssh.Handler {
 	return func(s ssh.Session) {
 
 		// Exec mode: client sent a command directly (e.g., ssh host "show version")
 		if cmd := s.RawCommand(); cmd != "" {
 			log.Printf("exec: %s", cmd)
-			match, matchedCommand, multipleMatches := cmdmatch.Match(cmd, myFakeDevice.SupportedCommands)
+			match, matchedCommand, multipleMatches := cmdmatch.Match(cmd, fd.SupportedCommands)
 			if match && !multipleMatches {
 				output, err := fakedevices.TranscriptReader(
-					myFakeDevice.SupportedCommands[matchedCommand], myFakeDevice,
+					fd.SupportedCommands[matchedCommand], fd,
 				)
 				if err == nil {
 					io.WriteString(s, output)
@@ -46,8 +46,8 @@ func genericCiscoSession(myFakeDevice *fakedevices.FakeDevice, sequence []transc
 
 		// Interactive shell mode — sequence pointer resets per session
 		seqIdx := 0
-		contextState := myFakeDevice.ContextSearch["base"]
-		t := term.NewTerminal(s, devicePrompt(myFakeDevice, contextState))
+		contextState := fd.ContextSearch["base"]
+		t := term.NewTerminal(s, devicePrompt(fd, contextState))
 
 		for {
 			userInput, err := t.ReadLine()
@@ -56,7 +56,7 @@ func genericCiscoSession(myFakeDevice *fakedevices.FakeDevice, sequence []transc
 			}
 			log.Println(userInput)
 
-			done := handleShellInput(t, userInput, myFakeDevice, &contextState, sequence, &seqIdx)
+			done := handleShellInput(t, userInput, fd, &contextState, sequence, &seqIdx)
 			if done {
 				break
 			}

ssh_server/sshlisteners/sshlisteners.go

@@ -18,38 +18,38 @@ import (
 // GenericListener starts an SSH server on the given port and blocks until ctx is cancelled.
 func GenericListener(
 	ctx context.Context,
-	myFakeDevice *fakedevices.FakeDevice,
-	portNumber int,
+	fd *fakedevices.FakeDevice,
+	port int,
 	myHandler handlers.PlatformHandler,
 ) error {
-	return listen(ctx, myFakeDevice, portNumber, myHandler(myFakeDevice.Copy()))
+	return listen(ctx, fd, port, myHandler(fd.Copy()))
 }
 
 // ScenarioListener starts an SSH server that plays back a scenario sequence.
 func ScenarioListener(
 	ctx context.Context,
-	myFakeDevice *fakedevices.FakeDevice,
+	fd *fakedevices.FakeDevice,
 	sequence []transcript.SequenceStep,
-	portNumber int,
+	port int,
 ) error {
-	return listen(ctx, myFakeDevice, portNumber, handlers.GenericCiscoScenarioHandler(myFakeDevice.Copy(), sequence))
+	return listen(ctx, fd, port, handlers.GenericCiscoScenarioHandler(fd.Copy(), sequence))
 }
 
-func listen(ctx context.Context, myFakeDevice *fakedevices.FakeDevice, portNumber int, handler ssh.Handler) error {
-	portString := ":" + strconv.Itoa(portNumber)
-	if myFakeDevice.ScenarioName != "" {
+func listen(ctx context.Context, fd *fakedevices.FakeDevice, port int, handler ssh.Handler) error {
+	portString := ":" + strconv.Itoa(port)
+	if fd.ScenarioName != "" {
 		log.Printf("Starting listener on %s [scenario=%s hostname=%s user=%s]",
-			portString, myFakeDevice.ScenarioName, myFakeDevice.Hostname, myFakeDevice.Username)
+			portString, fd.ScenarioName, fd.Hostname, fd.Username)
 	} else {
 		log.Printf("Starting listener on %s [platform=%s hostname=%s user=%s]",
-			portString, myFakeDevice.Platform, myFakeDevice.Hostname, myFakeDevice.Username)
+			portString, fd.Platform, fd.Hostname, fd.Username)
 	}
 
 	srv := &ssh.Server{
 		Addr:    portString,
 		Handler: handler,
 		PasswordHandler: func(sshCtx ssh.Context, pass string) bool {
-			return sshCtx.User() == myFakeDevice.Username && pass == myFakeDevice.Password
+			return sshCtx.User() == fd.Username && pass == fd.Password
 		},
 	}