To interact with the filesystem, we'll want an interface that displays all of the current files with the version, last modified time, and alerts to changes, and allows drag-and-drop creation/replacement of files.
Getting a list of files will be simple, as we'll grab them directly from our file_manager Couchbase bucket. Changes will be sent through our file manager process via TCP, which will trigger an API call, illuminating changes to the file for our web user.
A few of the methods we've used here are duplicates of the ones we used in the backup process and could certainly benefit from some consolidation; still, the following is the code for the web server, which allows uploads and shows notifications for changes:
package main
import
(
"net"
"net/http"
"html/template"
"log"
"io"
"os"
"io/ioutil"
"github.com/couchbaselabs/go-couchbase"
"time"
"fmt"
"crypto/md5"
"encoding/hex"
"encoding/json"
)
type File struct {
Hash string "json:hash"
Name string "json:file_name"
Created int64 "json:created"
CreatedUser int "json:created_user"
LastModified int64 "json:last_modified"
LastModifiedUser int "json:last_modified_user"
Revisions int "json:revisions"
Version int "json:version"
}This, for example, is the same File struct we use in both the file listener and the backup process:
type Page struct {
Title string
Files map[string] File
}Our Page struct represents generic web data that gets converted into corresponding variables for our web page's template:
type ItemWrapper struct {
Items []File
CurrentTime int64
PreviousTime int64
}
type Message struct {
Hash string "json:hash"
Action string "json:action"
Location string "json:location"
Name string "json:name"
Version int "json:version"
}The ItemWrapper struct is simply a JSON wrapper that will keep an array that's converted from our Files struct. This is essential to loop through the API's JSON on the client side. Our Message struct is a duplicate of the same type we saw in our file listener and backup processes. In the following code snippet, we'll dictate some general configuration variables and our hash generation function:
var listenFolder = "/wamp/www/shared/"
var Files map[string] File
var webTemplate = template.Must(template.ParseFiles("ch8_html.html"))
var fileChange chan File
var lastChecked int64
func generateHash(name string) string {
hash := md5.New()
io.WriteString(hash,name)
hashString := hex.EncodeToString(hash.Sum(nil))
return hashString
}Our md5 hashing method is the same for this application as well. It's worth noting that we derive a lastChecked variable that is the Unix-style timestamp from each time we get a signal from our file listener. We use this to compare with file changes on the client side to know whether to alert the user on the Web. Let's now look at the updateFile function for the web interface:
func updateFile(name string, bucket *couchbase.Bucket) {
thisFile := File{}
hashString := generateHash(name)
thisFile.Hash = hashString
thisFile.Name = name
thisFile.Created = time.Now().Unix()
thisFile.CreatedUser = 0
thisFile.LastModified = time.Now().Unix()
thisFile.LastModifiedUser = 0
thisFile.Revisions = 0
thisFile.Version = 1
Files[hashString] = thisFile
checkFile := File{}
err := bucket.Get(hashString,&checkFile)
if err != nil {
fmt.Println("New File Added",name)
bucket.Set(hashString,0,thisFile)
}else {
Files[hashString] = checkFile
}
}This is the same function as our backup process, except that instead of creating a duplicate file, we simply overwrite our internal File struct to allow it represent its updated LastModified value when the /api is next called. And as with our last example, let's check out the
listen() function:
func listen(conn net.Conn) {
for {
messBuff := make([]byte,1024)
n, err := conn.Read(messBuff)
if err != nil {
}
message := string(messBuff[:n])
message = message[0:]
resultMessage := Message{}
json.Unmarshal(messBuff[:n],&resultMessage)
updateHash := resultMessage.Hash
tmp := Files[updateHash]
tmp.LastModified = time.Now().Unix()
Files[updateHash] = tmp
}
}Here is where our message is read, unmarshalled, and set to its hashed map's key. This will create a file if it doesn't exist or update our current one if it does. Next, we'll look at the
main() function, which sets up our application and the web server:
func main() {
lastChecked := time.Now().Unix()
Files = make(map[string]File)
fileChange = make(chan File)
couchbaseClient, err := couchbase.Connect("http://localhost:8091/")
if err != nil {
fmt.Println("Error connecting to Couchbase", err)
}
pool, err := couchbaseClient.GetPool("default")
if err != nil {
fmt.Println("Error getting pool",err)
}
bucket, err := pool.GetBucket("file_manager")
if err != nil {
fmt.Println("Error getting bucket",err)
}
files, _ := ioutil.ReadDir(listenFolder)
for _, file := range files {
updateFile(file.Name(),bucket)
}
conn, err := net.Dial("tcp","127.0.0.1:9000")
if err != nil {
fmt.Println("Could not connect to File Listener!")
}
go listen(conn)
http.HandleFunc("/api", func(w http.ResponseWriter, r
*http.Request) {
apiOutput := ItemWrapper{}
apiOutput.PreviousTime = lastChecked
lastChecked = time.Now().Unix()
apiOutput.CurrentTime = lastChecked
for i:= range Files {
apiOutput.Items = append(apiOutput.Items,Files[i])
}
output,_ := json.Marshal(apiOutput)
fmt.Fprintln(w,string(output))
})
http.HandleFunc("/", func(w http.ResponseWriter, r
*http.Request) {
output := Page{Files:Files,Title:"File Manager"}
tmp, _ := template.ParseFiles("ch8_html.html")
tmp.Execute(w, output)
})
http.HandleFunc("/upload", func(w http.ResponseWriter, r
*http.Request) {
err := r.ParseMultipartForm(10000000)
if err != nil {
return
}
form := r.MultipartForm
files := form.File["file"]
for i, _ := range files {
newFileName := listenFolder + files[i].Filename
org,_:= files[i].Open()
defer org.Close()
cpy,_ := os.Create(newFileName)
defer cpy.Close()
io.Copy(cpy,org)
}
})
log.Fatal(http.ListenAndServe(":8080",nil))
}In our web server component, main() takes control of setting up the connection to the file listener and Couchbase and creating a web server (with related routing).
If you upload a file by dragging it to the Drop files here to upload box, within a few seconds you'll see that the file is noted as changed in the web interface, as shown in the following screenshot:
We haven't included the code for the client side of the web interface; the key points, though, are retrieval via an API. We used a JavaScript library called Dropzone.js that allows a drag-and-drop upload, and jQuery for API access.