mirror of
https://github.com/laurent22/joplin.git
synced 2024-12-15 09:04:04 +02:00
337 lines
12 KiB
TypeScript
337 lines
12 KiB
TypeScript
import AsyncActionQueue from '../../AsyncActionQueue';
|
|
import shim from '../../shim';
|
|
import { _ } from '../../locale';
|
|
import { toSystemSlashes } from '../../path-utils';
|
|
import Logger from '@joplin/utils/Logger';
|
|
import Setting from '../../models/Setting';
|
|
import Resource from '../../models/Resource';
|
|
import { ResourceEntity } from '../database/types';
|
|
const EventEmitter = require('events');
|
|
const chokidar = require('chokidar');
|
|
|
|
interface WatchedItem {
|
|
resourceId: string;
|
|
lastFileUpdatedTime: number;
|
|
lastResourceUpdatedTime: number;
|
|
path: string;
|
|
asyncSaveQueue: AsyncActionQueue;
|
|
size: number;
|
|
}
|
|
|
|
interface WatchedItems {
|
|
[key: string]: WatchedItem;
|
|
}
|
|
|
|
type OpenItemFn = (path: string)=> void;
|
|
|
|
export default class ResourceEditWatcher {
|
|
|
|
private static instance_: ResourceEditWatcher;
|
|
|
|
private logger_: any;
|
|
// eslint-disable-next-line @typescript-eslint/ban-types -- Old code before rule was applied
|
|
private dispatch: Function;
|
|
private watcher_: any;
|
|
private chokidar_: any;
|
|
private watchedItems_: WatchedItems = {};
|
|
private eventEmitter_: any;
|
|
private tempDir_ = '';
|
|
private openItem_: OpenItemFn;
|
|
|
|
public constructor() {
|
|
this.logger_ = new Logger();
|
|
this.dispatch = () => {};
|
|
this.watcher_ = null;
|
|
this.chokidar_ = chokidar;
|
|
this.eventEmitter_ = new EventEmitter();
|
|
}
|
|
|
|
// eslint-disable-next-line @typescript-eslint/ban-types -- Old code before rule was applied
|
|
public initialize(logger: any, dispatch: Function, openItem: OpenItemFn) {
|
|
this.logger_ = logger;
|
|
this.dispatch = dispatch;
|
|
this.openItem_ = openItem;
|
|
}
|
|
|
|
public static instance() {
|
|
if (this.instance_) return this.instance_;
|
|
this.instance_ = new ResourceEditWatcher();
|
|
return this.instance_;
|
|
}
|
|
|
|
private async tempDir() {
|
|
if (!this.tempDir_) {
|
|
this.tempDir_ = `${Setting.value('tempDir')}/edited_resources`;
|
|
await shim.fsDriver().mkdir(this.tempDir_);
|
|
}
|
|
|
|
return this.tempDir_;
|
|
}
|
|
|
|
public logger() {
|
|
return this.logger_;
|
|
}
|
|
|
|
// eslint-disable-next-line @typescript-eslint/ban-types -- Old code before rule was applied
|
|
public on(eventName: string, callback: Function) {
|
|
return this.eventEmitter_.on(eventName, callback);
|
|
}
|
|
|
|
// eslint-disable-next-line @typescript-eslint/ban-types -- Old code before rule was applied
|
|
public off(eventName: string, callback: Function) {
|
|
return this.eventEmitter_.removeListener(eventName, callback);
|
|
}
|
|
|
|
public externalApi() {
|
|
return {
|
|
openAndWatch: async ({ resourceId }: any) => {
|
|
return this.openAndWatch(resourceId);
|
|
},
|
|
watch: async ({ resourceId }: any) => {
|
|
await this.watch(resourceId);
|
|
},
|
|
stopWatching: async ({ resourceId }: any) => {
|
|
return this.stopWatching(resourceId);
|
|
},
|
|
isWatched: async ({ resourceId }: any) => {
|
|
return !!this.watchedItemByResourceId(resourceId);
|
|
},
|
|
};
|
|
}
|
|
|
|
private watchFile(fileToWatch: string) {
|
|
if (!this.chokidar_) return;
|
|
|
|
const makeSaveAction = (resourceId: string, path: string) => {
|
|
return async () => {
|
|
this.logger().info(`ResourceEditWatcher: Saving resource ${resourceId}`);
|
|
const resource = await Resource.load(resourceId);
|
|
const watchedItem = this.watchedItemByResourceId(resourceId);
|
|
|
|
if (resource.updated_time !== watchedItem.lastResourceUpdatedTime) {
|
|
this.logger().info(`ResourceEditWatcher: Conflict was detected (resource was modified from somewhere else, possibly via sync). Conflict note will be created: ${resourceId}`);
|
|
// The resource has been modified from elsewhere, for example via sync
|
|
// so copy the current version to the Conflict notebook, and overwrite
|
|
// the resource content.
|
|
await Resource.createConflictResourceNote(resource);
|
|
}
|
|
|
|
const savedResource = await Resource.updateResourceBlobContent(resourceId, path);
|
|
watchedItem.lastResourceUpdatedTime = savedResource.updated_time;
|
|
this.eventEmitter_.emit('resourceChange', { id: resourceId });
|
|
};
|
|
};
|
|
|
|
const handleChangeEvent = async (path: string) => {
|
|
this.logger().debug(`ResourceEditWatcher: handleChangeEvent: ${path}`);
|
|
|
|
const watchedItem = this.watchedItemByPath(path);
|
|
|
|
if (!watchedItem) {
|
|
// The parent directory of the edited resource often gets a change event too
|
|
// and ends up here. Print a warning, but most likely it's nothing important.
|
|
this.logger().debug(`ResourceEditWatcher: could not find resource ID from path: ${path}`);
|
|
return;
|
|
}
|
|
|
|
const resourceId = watchedItem.resourceId;
|
|
const stat = await shim.fsDriver().stat(path);
|
|
const editedFileUpdatedTime = stat.mtime.getTime();
|
|
|
|
// To check if the item has really changed we look at the updated time and size, which
|
|
// in most cases is sufficient. It could be a problem if the editing tool is making a change
|
|
// that neither changes the timestamp nor the file size. The alternative would be to compare
|
|
// the files byte for byte but that could be slow and the file might have changed again by
|
|
// the time we finished comparing.
|
|
if (watchedItem.lastFileUpdatedTime === editedFileUpdatedTime && watchedItem.size === stat.size) {
|
|
// chokidar is buggy and emits "change" events even when nothing has changed
|
|
// so double-check the modified time and skip processing if there's no change.
|
|
// In particular it emits two such events just after the file has been copied
|
|
// in openAndWatch().
|
|
//
|
|
// We also need this because some events are handled twice - once in the "all" event
|
|
// handle and once in the "raw" event handler, due to a bug in chokidar. So having
|
|
// this check means we don't unecessarily save the resource twice when the file is
|
|
// modified by the user.
|
|
this.logger().debug(`ResourceEditWatcher: No timestamp and file size change - skip: ${resourceId}`);
|
|
return;
|
|
}
|
|
|
|
this.logger().debug(`ResourceEditWatcher: Queuing save action: ${resourceId}`);
|
|
watchedItem.asyncSaveQueue.push(makeSaveAction(resourceId, path));
|
|
watchedItem.lastFileUpdatedTime = editedFileUpdatedTime;
|
|
watchedItem.size = stat.size;
|
|
};
|
|
|
|
if (!this.watcher_) {
|
|
this.watcher_ = this.chokidar_.watch(fileToWatch, {
|
|
// Need to turn off fs-events because when it's on Chokidar
|
|
// keeps emitting "modified" events (on "raw" handler), several
|
|
// times per seconds, even when nothing is changed.
|
|
useFsEvents: false,
|
|
});
|
|
this.watcher_.on('all', (event: any, path: string) => {
|
|
path = path ? toSystemSlashes(path, 'linux') : '';
|
|
|
|
this.logger().info(`ResourceEditWatcher: Event: ${event}: ${path}`);
|
|
|
|
if (event === 'unlink') {
|
|
// File are unwatched in the stopWatching functions below. When we receive an unlink event
|
|
// here it might be that the file is quickly moved to a different location and replaced by
|
|
// another file with the same name, as it happens with emacs. So because of this
|
|
// we keep watching anyway.
|
|
// See: https://github.com/laurent22/joplin/issues/710#issuecomment-420997167
|
|
// this.watcher_.unwatch(path);
|
|
} else if (event === 'change') {
|
|
void handleChangeEvent(path);
|
|
} else if (event === 'error') {
|
|
this.logger().error('ResourceEditWatcher: error');
|
|
}
|
|
});
|
|
|
|
// Hack to support external watcher on some linux applications (gedit, gvim, etc)
|
|
// taken from https://github.com/paulmillr/chokidar/issues/591
|
|
//
|
|
// 2020-07-22: It also applies when editing Excel files, which copy the new file
|
|
// then rename, so handling the "change" event alone is not enough as sometimes
|
|
// that event is not event triggered.
|
|
// https://github.com/laurent22/joplin/issues/3407
|
|
//
|
|
this.watcher_.on('raw', (event: string, _path: string, options: any) => {
|
|
const watchedPath = options.watchedPath ? toSystemSlashes(options.watchedPath, 'linux') : '';
|
|
|
|
this.logger().debug(`ResourceEditWatcher: Raw event: ${event}: ${watchedPath}`);
|
|
if (event === 'rename') {
|
|
this.watcher_.unwatch(watchedPath);
|
|
this.watcher_.add(watchedPath);
|
|
void handleChangeEvent(watchedPath);
|
|
}
|
|
});
|
|
} else {
|
|
this.watcher_.add(fileToWatch);
|
|
}
|
|
|
|
return this.watcher_;
|
|
}
|
|
|
|
private async makeEditPath(resource: ResourceEntity) {
|
|
const tempDir = await this.tempDir();
|
|
return toSystemSlashes(await shim.fsDriver().findUniqueFilename(`${tempDir}/${Resource.friendlySafeFilename(resource)}`), 'linux');
|
|
}
|
|
|
|
private async copyResourceToEditablePath(resourceId: string) {
|
|
const resource = await Resource.load(resourceId);
|
|
if (!(await Resource.isReady(resource))) throw new Error(_('This attachment is not downloaded or not decrypted yet'));
|
|
const sourceFilePath = Resource.fullPath(resource);
|
|
const editFilePath = await this.makeEditPath(resource);
|
|
await shim.fsDriver().copy(sourceFilePath, editFilePath);
|
|
return { resource, editFilePath };
|
|
}
|
|
|
|
private async watch(resourceId: string): Promise<WatchedItem> {
|
|
let watchedItem = this.watchedItemByResourceId(resourceId);
|
|
|
|
if (!watchedItem) {
|
|
// Immediately create and push the item to prevent race conditions
|
|
|
|
watchedItem = {
|
|
resourceId: resourceId,
|
|
lastFileUpdatedTime: 0,
|
|
lastResourceUpdatedTime: 0,
|
|
asyncSaveQueue: new AsyncActionQueue(1000),
|
|
path: '',
|
|
size: -1,
|
|
};
|
|
|
|
this.watchedItems_[resourceId] = watchedItem;
|
|
const { resource, editFilePath } = await this.copyResourceToEditablePath(resourceId);
|
|
const stat = await shim.fsDriver().stat(editFilePath);
|
|
|
|
watchedItem.path = editFilePath;
|
|
watchedItem.lastFileUpdatedTime = stat.mtime.getTime();
|
|
watchedItem.lastResourceUpdatedTime = resource.updated_time;
|
|
watchedItem.size = stat.size;
|
|
|
|
this.watchFile(editFilePath);
|
|
|
|
this.dispatch({
|
|
type: 'RESOURCE_EDIT_WATCHER_SET',
|
|
id: resource.id,
|
|
title: resource.title,
|
|
});
|
|
}
|
|
|
|
this.logger().info(`ResourceEditWatcher: Started watching ${watchedItem.path}`);
|
|
|
|
return watchedItem;
|
|
}
|
|
|
|
public async openAndWatch(resourceId: string) {
|
|
const watchedItem = await this.watch(resourceId);
|
|
this.openItem_(watchedItem.path);
|
|
}
|
|
|
|
// This call simply copies the resource file to a separate path and opens it.
|
|
// That way, even if it is changed, the real resource file on drive won't be
|
|
// affected.
|
|
public async openAsReadOnly(resourceId: string) {
|
|
const { editFilePath } = await this.copyResourceToEditablePath(resourceId);
|
|
await shim.fsDriver().chmod(editFilePath, 0o0666);
|
|
this.openItem_(editFilePath);
|
|
}
|
|
|
|
public async stopWatching(resourceId: string) {
|
|
if (!resourceId) return;
|
|
|
|
const item = this.watchedItemByResourceId(resourceId);
|
|
if (!item) {
|
|
this.logger().error(`ResourceEditWatcher: Trying to stop watching non-watched resource ${resourceId}`);
|
|
return;
|
|
}
|
|
|
|
await item.asyncSaveQueue.waitForAllDone();
|
|
|
|
try {
|
|
if (this.watcher_) this.watcher_.unwatch(item.path);
|
|
await shim.fsDriver().remove(item.path);
|
|
} catch (error) {
|
|
this.logger().warn(`ResourceEditWatcher: There was an error unwatching resource ${resourceId}. Joplin will ignore the file regardless.`, error);
|
|
}
|
|
|
|
delete this.watchedItems_[resourceId];
|
|
|
|
this.dispatch({
|
|
type: 'RESOURCE_EDIT_WATCHER_REMOVE',
|
|
id: resourceId,
|
|
});
|
|
|
|
this.logger().info(`ResourceEditWatcher: Stopped watching ${item.path}`);
|
|
}
|
|
|
|
public async stopWatchingAll() {
|
|
const promises = [];
|
|
for (const resourceId in this.watchedItems_) {
|
|
const item = this.watchedItems_[resourceId];
|
|
promises.push(this.stopWatching(item.resourceId));
|
|
}
|
|
await Promise.all(promises);
|
|
|
|
this.dispatch({
|
|
type: 'RESOURCE_EDIT_WATCHER_CLEAR',
|
|
});
|
|
}
|
|
|
|
private watchedItemByResourceId(resourceId: string): WatchedItem {
|
|
return this.watchedItems_[resourceId];
|
|
}
|
|
|
|
private watchedItemByPath(path: string): WatchedItem {
|
|
for (const resourceId in this.watchedItems_) {
|
|
const item = this.watchedItems_[resourceId];
|
|
if (item.path === path) return item;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
}
|