func runFileChmod(base_path, path string) bool {
listener := utils.GetListenerFromDir(base_path)
rel_path := utils.GetRelativePath(listener, path)
dbItem, err := datastore.GetOne(base_path, rel_path)
if err != nil {
log.Errorf("Error occurred trying to get %s from DB\nError: %s", rel_path, err.Error())
return false
}
fsItem, err := utils.GetFileInfo(path)
if err != nil {
log.Errorf("Could not find item on filesystem: %s\nError:%s", path, err.Error())
}
if dbItem.Perms != fsItem.Perms {
iPerm, _ := strconv.Atoi(dbItem.Perms)
mode := int(iPerm)
if _, err := os.Stat(path); os.IsNotExist(err) {
log.Infof("File no longer exists returning")
return true
} else {
err := os.Chmod(path, os.FileMode(mode))
if err != nil {
log.Errorf("Error occurred changing file modes: %s", err.Error())
return false
}
return true
}
} else {
log.Info("File modes are correct changing nothing")
return false
}
return true
}
func runFileCreateUpdate(base_path, path, operation string) bool {
listener := utils.GetListenerFromDir(base_path)
rel_path := utils.GetRelativePath(listener, path)
fsItem, err := utils.GetFileInfo(path)
if err != nil {
log.Infof("Error getting file details for %s: %+v", path, err)
}
log.Infof("Putting in storage:-> %s", rel_path)
storage.PutFile(path, listener)
log.Infof("Creating/Updating:-> %s", rel_path)
return datastore.Insert(listener, fsItem)
}
func handleDataChanges(items []utils.DataTable, listener utils.Listener, listenerName string) {
// Walking the directory to get files.
fsItems := utils.ListFilesInDir(listener.Directory)
itemsToDelete := findOnlyInFS(fsItems, items, listenerName)
if len(itemsToDelete) > 0 {
for _, delItem := range itemsToDelete {
if !utils.MatchesIgnore(listener.Directory, delItem) {
itemExists := datastore.PathExists(listenerName, delItem)
if !itemExists {
log.Infof("Removing untracked item: %s", delItem)
err := os.Remove(delItem)
if err != nil {
log.Infof("Error deleting untracked file %s\n%s", delItem, err.Error())
}
}
}
}
}
for _, item := range items {
absPath := utils.GetAbsPath(listenerName, item.Path)
itemMatch := getFileInDatabase(absPath, fsItems)
perms := fmt.Sprintf("File Permissions: %#o", item.Perms)
if itemMatch {
// Check to make sure it's not a directory as directories don't need to be uploaded
if !item.IsDirectory {
fileMD5 := utils.GetMd5Checksum(absPath)
if fileMD5 != item.Checksum {
log.Info("Processing modified file: " + absPath)
hostname, _ := os.Hostname()
if item.HostUpdated != hostname {
// File wasn't updated locally so get it from remote
bNodeCopy := storage.GetNodeCopy(item, listenerName, listener.Uid, listener.Gid, perms)
if bNodeCopy {
// Item downloaded successfully so update db with new md5
newFileInfo, err := utils.GetFileInfo(absPath)
if err != nil {
log.Infof("Error occurred trying to get info on file: %s", absPath)
} else {
datastore.Insert(listenerName, newFileInfo)
}
} else {
// Item didn't download from nodes (maybe ports are closed so lets get from backups)
storage.GetFile(absPath, listenerName, listener.Uid, listener.Gid, perms)
newFileInfo, err := utils.GetFileInfo(absPath)
if err != nil {
log.Infof("Error occurred trying to get info on file: %s", absPath)
} else {
datastore.Insert(listenerName, newFileInfo)
}
}
} else {
// Item was modified locally and does not match so lets fix it with what is in db
storage.GetFile(absPath, listenerName, listener.Uid, listener.Gid, perms)
newFileInfo, err := utils.GetFileInfo(absPath)
if err != nil {
log.Infof("Error occurred trying to get info on file: %s", absPath)
} else {
datastore.Insert(listenerName, newFileInfo)
}
}
}
}
// Now we check to make sure the files match correct users etc
} else {
if !utils.MatchesIgnore(listener.Directory, absPath) {
// Item doesn't exist locally but exists in DB so restore it
log.Infof("Item Deleted Locally: %s restoring from DB marker", absPath)
if item.IsDirectory {
dirExists, _ := utils.ItemExists(absPath)
if !dirExists {
os.MkdirAll(absPath, 0775)
}
} else {
if !storage.GetNodeCopy(item, listenerName, listener.Uid, listener.Gid, perms) {
log.Infof("Server is down for %s going to backup storage", listenerName)
// The server must be down so lets get it from S3
storage.GetFile(absPath, listenerName, listener.Uid, listener.Gid, perms)
}
}
}
}
}
}