I don't understand the error, this is my main.go that I execute in the machine "A":
package main
import (
"fmt"
"net"
"os"
"github.com/mistifyio/go-zfs"
)
func main() {
// Listen for incoming connections.
l, err := net.Listen("tcp", "192.168.99.5:9977")
if err != nil ...
// Close the listener when the application closes.
defer l.Close()
fmt.Println("Listening on " + CONN_HOST + ":" + CONN_PORT)
for {
// Listen for an incoming connection.
conn, err := l.Accept()
if err != nil ...
//Handle connections in a new goroutine.
go handleRequest(conn)
}
}
// Handles incoming requests.
func handleRequest(conn net.Conn) {
// Make a buffer to hold incoming data.
buff := make([]byte, 1024)
// Read the incoming connection into the buffer.
_, err := conn.Read(buff)
if err != nil {
fmt.Printf("Error reading: %s.\n", err.Error())
}
// ReceiveSnapshot
ds, err := zfs.ReceiveSnapshot(buff, "tank/replication")
if err != nil {
fmt.Printf("Error receiving: %s.\n", err.Error())
}
fmt.Printf("%s... done!\n", ds)
// Send a response back to person contacting us.
conn.Write([]byte("Received!"))
// Close the connection when you're done with it.
conn.Close()
}
Now, I show you the function ReceiveSnapshot from github.com/mistifyio/go-zfs/zfs.go:
type command struct {
Command string
Stdin io.Reader
Stdout io.Writer
}
func ReceiveSnapshot(input io.Reader, name string) (*Dataset, error) {
c := command{Command: "zfs", Stdin: input}
_, err := c.Run("receive", name)
if err != nil {
return nil, err
}
return GetDataset(name)
}
I have seen in golang pkg the doc of io.Reader:
type Reader interface {
Read(p []byte) (n int, err error)
}
Why do I receive the error...
...when I make go install
?
I think you are missing a step in your logic when you think that []byte
would be equivalent to Reader
just because the Reader's Read
method receives a []byte
as a parameter.
Let me try to clarify:
Your ReceiveSnapshot
function expects a Reader
as a parameter:
ReceiveSnapshot( input io.Reader ...
In order for a type to fulfil the Reader
interface, that type should itself implement this function:
Read(p []byte) (n int, err error)
Note that the type should implement that function in order to be a Reader
.
[]byte
does not implement a Read
function. It is just a coincidence that the argument to Read
happens to be a []byte
.
In order for this to work, you need to send ReceiveSnapshot
a proper Reader
.
Luckily for you, having a []byte
and wanting to Read for it is a common situation so the API provides an easy way to do this:
https://golang.org/pkg/bytes/#NewReader
You just need to send bytes.NewReader(buff)
to your ReceiveSnapshot
function instead of just buff
.