The final component we'd like to add to this application suite is a command-line file revision process. We can keep this one fairly simple, as we know where a file is located, where its backups are located, and how to replace the former with the latter. As with before, we have some global configuration variables and a replication of our
generateHash() function:
var liveFolder = "/mnt/sharedir "
var backupFolder = "/mnt/backup
func generateHash(name string) string {
hash := md5.New()
io.WriteString(hash,name)
hashString := hex.EncodeToString(hash.Sum(nil))
return hashString
}
func main() {
revision := flag.Int("r",0,"Number of versions back")
fileName := flag.String("f","","File Name")
flag.Parse()
if *fileName == "" {
fmt.Println("Provide a file name to use!")
os.Exit(0)
}
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)
}
hashString := generateHash(*fileName)
checkFile := File{}
bucketerr := bucket.Get(hashString,&checkFile)
if bucketerr != nil {
}else {
backupLocation := backupFolder + checkFile.Name + "." + strconv.FormatInt(int64(checkFile.Version-*revision),10)
newLocation := liveFolder + checkFile.Name
fmt.Println(backupLocation)
org,_ := os.Open(backupLocation)
defer org.Close()
cpy,_ := os.Create(newLocation)
defer cpy.Close()
io.Copy(cpy,org)
fmt.Println("Revision complete")
}
}This application accepts up to two parameters:
-f: This denotes the filename-r: This denotes the number of versions to revert
Note that this itself creates a new version and thus a backup, so -2 would need to become -3, and then -6, and so on in order to continuously back up recursively.
As an example, if you wished to revert example.txt back three versions, you could use the following command:
fileversion -f example.txt -r -3
A minor note on running something like this part of the application—you'll ideally wish to keep these applications as active, restartable services instead of standalone, manually executed background processes. Doing so will allow you to keep the application active and manage its life from external or server processes.
This sort of application suite would be best suited on a Linux box (or boxes) and managed with a daemon manager such as daemontools or Ubuntu's built-in Upstart service. The reason for this is that any long-term downtime can result in lost data and inconsistency. Even storing file data details in the memory (Couchbase and memcached) provides a vulnerability for lost data.