Since we're sending our commands on the wire, so to speak, our backup process needs to listen on that wire and respond with any changes. Given that modifications will be sent via localhost, we should have minimal latency on both the network and the file side.
We'll also return some information as to what happened with the file, although at this point we're not doing much with that information. The code for this is as follows:
package main import ( "fmt" "net" "io" "os" "strconv" "encoding/json" ) var backupFolder = "mnt/backup/"
Note that we have a separate folder for backups, in this case, on a Windows machine. If we happen to accidentally use the same directory, we run the risk of infinitely duplicating and backing up files. In the following code snippet, we'll look at the Message struct itself and the
backup function, the core of this part of the application:
type Message struct {
Hash string "json:hash"
Action string "json:action"
Location string "json:location"
Name string "json:name"
Version int "json:version"
}
func backup (location string, name string, version int) {
newFileName := backupFolder + name + "." +
strconv.FormatInt(int64(version),10)
fmt.Println(newFileName)
org,_ := os.Open(location)
defer org.Close()
cpy,_ := os.Create(newFileName)
defer cpy.Close()
io.Copy(cpy,org)
}Here is our basic file operation. Go doesn't have a one-step copy function; instead you need to create a file and then copy the contents of another file into it with io.Copy:
func listen(conn net.Conn) {
for {
messBuff := make([]byte,1024)
n, err := conn.Read(messBuff)
if err != nil {
}
resultMessage := Message{}
json.Unmarshal(messBuff[:n],&resultMessage)
if resultMessage.Action == "MODIFY" {
fmt.Println("Back up file",resultMessage.Location)
newVersion := resultMessage.Version + 1
backup(resultMessage.Location,resultMessage.Name,newVersion)
}
}
}This code is nearly verbatim for our chat client's listen() function, except that we take the contents of the streamed JSON data, unmarshal it, and convert it to a Message{} struct and then a File{} struct. Finally, let's look at the main function and TCP initialization:
func main() {
endBackup := make(chan bool)
conn, err := net.Dial("tcp","127.0.0.1:9000")
if err != nil {
fmt.Println("Could not connect to File Listener!")
}
go listen(conn)
<- endBackup
}