Esempio n. 1
0
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
}
Esempio n. 2
0
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)
}
Esempio n. 3
0
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)
					}
				}
			}

		}
	}
}