Failed Unmarshal for xxx invalid character '{' after top-level value

Failed Unmarshal for LP name invalid character '{' after top-level value

package main
import (...)
type hostInfo struct {
Name string
}
var b bytes.Buffer
var c bytes.Buffer
var tmphostInfo hostInfo
var result map[string]interface{}
func main() {
keypath := os.Args[1]
hostiplist := []string {"192.168.1.150","192.168.1.151","192.168.1.152","192.168.1.153"}
port := "22"
key,err := ioutil.ReadFile(keypath)
if err != nil {
log.Fatalf("Unable to read private key: %v", err)
}
signer,err:=ssh.ParsePrivateKey(key)
if err != nil {
log.Fatalf("Unable to parse private key: %v",err)
}
var conn *ssh.Client
config := &ssh.ClientConfig{
User:            "support",
Auth:            []ssh.AuthMethod{ssh.PublicKeys(signer)},
HostKeyCallback: ssh.InsecureIgnoreHostKey(),
Timeout: 5*time.Second,
}
for _,hostip := range hostiplist {
conn,err = ssh.Dial("tcp",net.JoinHostPort(hostip,port),config)
if err != nil {
log.Fatalf("unable to connect: %v",err)
}
defer conn.Close()
session1,err:=conn.NewSession()
if err != nil {
log.Fatalf("unable to connect: %v",err)
}
defer session1.Close()
session1.Stdout = &b
if err := session1.Run("some mongo query"); err != nil {
log.Fatal("Failed to run:sess1 " + err.Error())
}
tmphostInfo=hostInfo{}
fmt.Printf("tmphostInfo: %v , ip : %s",tmphostInfo.Name,hostip)
err1 := json.Unmarshal([]byte(""),&tmphostInfo)
if err1 != nil {
log.Fatalf("Failed Unmarshal for LP name %v for IP %s",err1,hostip)
}
session2,err:=conn.NewSession()
session2.Stdout = &c
if err := session2.Run("another mongo query"); err != nil {
log.Fatal("Failed to run:sess2 " + err.Error())
}
err2 := json.Unmarshal([]byte(c.String()),&result)
if err2 != nil {
log.Fatalf("Failed Unmarshal for Customer name %v",err2)
}
//fmt.Println(c.String())
custmap := result["customer"].(map[string]interface{})
//fmt.Println(birds)
var LPname string
for key, value := range custmap {
// Each value is an interface{} type, that is type asserted as a string
//fmt.Println(key, value.(string))
if key == "name" {
LPname=value.(string)
}
}
fmt.Println(hostip,tmphostInfo.Name,LPname)
f, err := os.OpenFile("/tmp/supportip.csv", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
if err != nil {
log.Fatal(err)
}
if _, err := f.Write([]byte(hostip+","+tmphostInfo.Name+","+LPname+"\n")); err != nil {
log.Fatal(err)
}
if err := f.Close(); err != nil {
log.Fatal(err)
}
}
}

go run scan.go /path/to/key results in

tmphostInfo: {} , ip : 192.168.1.150 10.45.9.141 servername1 DFIDorg
tmphostInfo: {} , ip : 192.168.1.151 2021/12/10 15:07:36 Failed Unmarshal for LP name invalid character '{' after top-level value for 192.168.1.151
exit status 1

The unmarshal for both queries result for first array element "192.168.1.150" is successful but fails on second and rest of items

The json string for first query looks like below

{ "name" : "john doe" } 

result of second query looks like

{
"customer" : {
"address1" : "ktm",
"secret_key" : "12237918f0d441d25fb",
"address2" : "",
"name" : "KUKL Limited",
"phone" : "12345"
}
}

I had to reset the bytes.Buffer variable right after the for loop start, the issue was that the result pulled from ssh execution had been appended to buffer which could not be deserialized

 for _,hostip := range hostiplist {
b.Reset()
c.Reset()