Replying with a JSON on an open TCP socket

I have a server that successfully opens a connection with a second server. The second server performs an action and I am trying to get it to reply to the first server with a JSON on the same connection.

package main
import (
"fmt"
"net"
"encoding/json"
)
type NewContainerJSON struct {
Action string			`json:"Action"`
ContainerName string	`json:"ContainerName"`
BaseServer string		`json:"BaseServer"`
CMS string				`json:"CMS"`
WebsiteName string		`json:"WebsiteName"`
DBrootPWD string		`json:"DBrootPWD"`
DBadminUname string		`json:"DBadminUname"`
DBadminPWD string		`json:"DBadminPWD"`
}
func main() {
service := "127.0.0.1:8081"
tcpAddr, err := net.ResolveTCPAddr("tcp", service)
checkError(err)
listener, err := net.ListenTCP("tcp", tcpAddr)
checkError(err)
conn, err := listener.Accept()
checkError(err)
decoder := json.NewDecoder(conn)
encoder := json.NewEncoder(conn)
var b NewContainerJSON
err = decoder.Decode(&b)
checkError(err)
fmt.Println(b.Action)
if b.Action == "createNew" {
fmt.Println("This works")
resp := []byte("And here's our repomse")
conn.Write(resp)
c := NewContainerJSON {
Action: "createdNewContainer",
ContainerName: "Test",
BaseServer: "Test",
CMS: "Test",
WebsiteName: "Test",
DBrootPWD: "Test",
DBadminUname: "Test",
DBadminPWD: "Test",
}
encoder := json.NewEncoder(conn)
if err := encoder.Encode(c); err != nil {
fmt.Println("encode.Encode error: ", err)
}
conn.Write(c)
}
}
func checkError(err error) {
if err != nil {
fmt.Println("An error occurred: ", err.Error())
}
}

I get following error on the line conn.Write(c)

> cannot use c (type NewContainerJSON) as type []byte in argument to conn.Write

Two questions:

1: What exactly is this error saying? It seems to be complaining that 'c' cannot be used as a Byte when using the conn.Write function but shouldn't the json.Encoder convert the JSON to a format the conn.Write can use?

2: How exactly can I return a JSON back to the first server using the open connection?

The encoder writes the JSON encoding of c to conn on this line:

if err := encoder.Encode(c); err != nil {

That's all you need to do. Delete the call to conn.Write(c).

The error message is telling you that the value of c cannot be used as the argument to Write because of a type mismatch. A NewContainerJSON is not a []byte.

You first write a string to the connection by

resp := []byte("And here's our repomse")
conn.Write(resp)

This will make it error-prone on the client side. You'll need to read exactly the same amount of data before employ the json decoder on this connection.

If a connection is used for json communication, all the messages on this stream should be json.
So if you want send a message to notify, encode that message too:

encoder.Encode(string(resp))