Java tutorial
/** * Copyright (c) 2000-present Liferay, Inc. All rights reserved. * * This library is free software; you can redistribute it and/or modify it under * the terms of the GNU Lesser General Public License as published by the Free * Software Foundation; either version 2.1 of the License, or (at your option) * any later version. * * This library is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more * details. */ package com.liferay.sync.engine.document.library.handler; import com.liferay.sync.engine.document.library.event.Event; import com.liferay.sync.engine.document.library.event.GetSyncContextEvent; import com.liferay.sync.engine.document.library.model.SyncDLObjectUpdate; import com.liferay.sync.engine.document.library.util.BatchEventManager; import com.liferay.sync.engine.document.library.util.FileEventUtil; import com.liferay.sync.engine.document.library.util.comparator.SyncFileSizeComparator; import com.liferay.sync.engine.file.system.Watcher; import com.liferay.sync.engine.file.system.util.WatcherManager; import com.liferay.sync.engine.model.SyncAccount; import com.liferay.sync.engine.model.SyncFile; import com.liferay.sync.engine.model.SyncSite; import com.liferay.sync.engine.service.SyncAccountService; import com.liferay.sync.engine.service.SyncFileService; import com.liferay.sync.engine.service.SyncSiteService; import com.liferay.sync.engine.session.Session; import com.liferay.sync.engine.session.SessionManager; import com.liferay.sync.engine.util.FileKeyUtil; import com.liferay.sync.engine.util.FileUtil; import com.liferay.sync.engine.util.GetterUtil; import com.liferay.sync.engine.util.IODeltaUtil; import com.liferay.sync.engine.util.JSONUtil; import com.liferay.sync.engine.util.SyncEngineUtil; import com.liferay.sync.engine.util.Validator; import java.io.IOException; import java.nio.file.AccessDeniedException; import java.nio.file.FileSystemException; import java.nio.file.FileVisitResult; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; import java.nio.file.SimpleFileVisitor; import java.nio.file.StandardCopyOption; import java.nio.file.attribute.BasicFileAttributes; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.ScheduledFuture; import java.util.concurrent.TimeUnit; import org.apache.commons.io.FileUtils; import org.apache.commons.lang.StringEscapeUtils; import org.apache.http.HttpResponse; import org.apache.http.HttpStatus; import org.apache.http.StatusLine; import org.apache.http.client.methods.HttpPost; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * @author Shinn Lok */ public class GetSyncDLObjectUpdateHandler extends BaseJSONHandler { public GetSyncDLObjectUpdateHandler(final Event event) { super(event); GetSyncContextEvent getSyncContextEvent = new GetSyncContextEvent(getSyncAccountId(), Collections.<String, Object>emptyMap()) { @Override public void executePost(String urlPath, Map<String, Object> parameters) throws Exception { SyncAccount syncAccount = SyncAccountService.fetchSyncAccount(getSyncAccountId()); Session session = SessionManager.getSession(getSyncAccountId(), true); HttpResponse httpResponse = session .execute(new HttpPost(syncAccount.getUrl() + "/api/jsonws" + urlPath)); StatusLine statusLine = httpResponse.getStatusLine(); if (statusLine.getStatusCode() != HttpStatus.SC_OK) { doCancel(); return; } Handler<Void> handler = event.getHandler(); String response = getResponseString(httpResponse); if (handler.handlePortalException(getException(response))) { doCancel(); return; } if (!_firedProcessingState) { SyncEngineUtil.fireSyncEngineStateChanged(getSyncAccountId(), SyncEngineUtil.SYNC_ENGINE_STATE_PROCESSING); _firedProcessingState = true; } } protected void doCancel() { if (_firedProcessingState) { SyncEngineUtil.fireSyncEngineStateChanged(getSyncAccountId(), SyncEngineUtil.SYNC_ENGINE_STATE_PROCESSED); _firedProcessingState = false; } event.cancel(); _scheduledFuture.cancel(true); } @Override protected void doRun() { SyncAccount syncAccount = SyncAccountService.fetchSyncAccount(getSyncAccountId()); SyncSite syncSite = SyncSiteService.fetchSyncSite((Long) event.getParameterValue("repositoryId"), getSyncAccountId()); if ((syncAccount == null) || (syncAccount.getState() != SyncAccount.STATE_CONNECTED) || (syncSite == null) || !syncSite.isActive()) { doCancel(); return; } super.doRun(); } private boolean _firedProcessingState; }; _scheduledFuture = _scheduledExecutorService.scheduleWithFixedDelay(getSyncContextEvent, 10, 5, TimeUnit.SECONDS); } @Override public void processFinally() { _scheduledFuture.cancel(false); SyncEngineUtil.fireSyncEngineStateChanged(getSyncAccountId(), SyncEngineUtil.SYNC_ENGINE_STATE_PROCESSED); SyncSite syncSite = (SyncSite) getParameterValue("syncSite"); if (syncSite != null) { syncSite = SyncSiteService.fetchSyncSite(syncSite.getGroupId(), syncSite.getSyncAccountId()); syncSite.setState(SyncSite.STATE_SYNCED); SyncSiteService.update(syncSite); } else { SyncFile syncFile = SyncFileService.fetchSyncFile((Long) getParameterValue("repositoryId"), getSyncAccountId(), (Long) getParameterValue("parentFolderId")); if (syncFile != null) { syncFile.setState(SyncFile.STATE_SYNCED); syncFile.setUiEvent(SyncFile.UI_EVENT_NONE); SyncFileService.update(syncFile); } } } @Override public void processResponse(String response) throws Exception { if (_syncDLObjectUpdate == null) { if (response.startsWith("\"")) { response = StringEscapeUtils.unescapeJava(response); response = response.replaceAll("\n", "\\n"); response = response.substring(1, response.length() - 1); } _syncDLObjectUpdate = JSONUtil.readValue(response, SyncDLObjectUpdate.class); } updateSettings(_syncDLObjectUpdate.getSettingsModifiedTimes()); List<SyncFile> syncFiles = _syncDLObjectUpdate.getSyncFiles(); if (!syncFiles.isEmpty()) { Collections.sort(syncFiles, _syncFileComparator); for (SyncFile syncFile : syncFiles) { processSyncFile(syncFile); } } if (getParameterValue("parentFolderId") == null) { SyncSite syncSite = SyncSiteService.fetchSyncSite((Long) getParameterValue("repositoryId"), getSyncAccountId()); if ((syncSite == null) || ((Long) getParameterValue("lastAccessTime") != syncSite.getRemoteSyncTime())) { return; } long lastAccessTime = _syncDLObjectUpdate.getLastAccessTime(); if (lastAccessTime == -1) { lastAccessTime = 0; } syncSite.setRemoteSyncTime(lastAccessTime); if (_syncDLObjectUpdate.getResultsTotal() <= syncFiles.size()) { syncSite.setState(SyncSite.STATE_SYNCED); } SyncSiteService.update(syncSite); if (_syncDLObjectUpdate.getResultsTotal() > syncFiles.size()) { FileEventUtil.getUpdates(syncSite.getGroupId(), getSyncAccountId(), syncSite, GetterUtil.getBoolean(getParameterValue("retrieveFromCache"))); } } BatchEventManager.fireBatchDownloadEvents(); } protected void addFile(SyncFile syncFile, String filePathName) throws Exception { Path filePath = Paths.get(filePathName); if (isParentUnsynced(syncFile)) { if (syncFile.isFolder()) { syncFile.setFilePathName(filePath.toString()); syncFile.setModifiedTime(0); syncFile.setState(SyncFile.STATE_UNSYNCED); syncFile.setSyncAccountId(getSyncAccountId()); syncFile.setUiEvent(SyncFile.UI_EVENT_NONE); SyncFileService.update(syncFile); } return; } if (FileUtil.exists(filePath) && (syncFile.isFolder() || !FileUtil.isModified(syncFile, filePath))) { return; } syncFile.setFilePathName(filePathName); syncFile.setSyncAccountId(getSyncAccountId()); if (syncFile.isFolder()) { Files.createDirectories(filePath); syncFile.setState(SyncFile.STATE_SYNCED); syncFile.setUiEvent(SyncFile.UI_EVENT_ADDED_REMOTE); SyncFileService.update(syncFile); FileKeyUtil.writeFileKey(filePath, String.valueOf(syncFile.getSyncFileId()), false); } else { syncFile.setUiEvent(SyncFile.UI_EVENT_DOWNLOADING); SyncFileService.update(syncFile); downloadFile(syncFile, null, 0, false); } } protected boolean checkUnsynced(SyncFile sourceSyncFile, SyncFile targetSyncFile, String targetFilePathName) throws Exception { Path targetFilePath = Paths.get(targetFilePathName); if (isParentUnsynced(targetSyncFile)) { if (sourceSyncFile.isFolder()) { List<SyncFile> syncFiles = new ArrayList<>(); syncFiles.add(sourceSyncFile); List<SyncFile> childSyncFiles = SyncFileService.findSyncFiles(sourceSyncFile.getFilePathName()); syncFiles.addAll(childSyncFiles); SyncFileService.unsyncFolders(getSyncAccountId(), syncFiles); sourceSyncFile = SyncFileService.fetchSyncFile(sourceSyncFile.getSyncFileId()); SyncFileService.updateSyncFile(targetFilePath, targetSyncFile.getParentFolderId(), sourceSyncFile); } else { deleteFile(sourceSyncFile, targetSyncFile); } return true; } if (sourceSyncFile.isUnsynced()) { if (!isParentUnsynced(sourceSyncFile)) { return true; } List<SyncFile> syncFiles = new ArrayList<>(); syncFiles.add(sourceSyncFile); List<SyncFile> childSyncFiles = SyncFileService.findSyncFiles(sourceSyncFile.getFilePathName()); syncFiles.addAll(childSyncFiles); SyncFileService.resyncFolders(getSyncAccountId(), syncFiles); return true; } return false; } protected void copyFile(SyncFile sourceSyncFile, SyncFile targetSyncFile) throws Exception { if (_logger.isDebugEnabled()) { _logger.debug("Copying file {} to {}", sourceSyncFile.getFilePathName(), targetSyncFile.getFilePathName()); } Path tempFilePath = FileUtil.getTempFilePath(targetSyncFile); Files.copy(Paths.get(sourceSyncFile.getFilePathName()), tempFilePath, StandardCopyOption.REPLACE_EXISTING); FileKeyUtil.writeFileKey(tempFilePath, String.valueOf(targetSyncFile.getSyncFileId()), false); FileUtil.setModifiedTime(tempFilePath, targetSyncFile.getModifiedTime()); Watcher watcher = WatcherManager.getWatcher(getSyncAccountId()); watcher.addDownloadedFilePathName(targetSyncFile.getFilePathName()); boolean exists = FileUtil.exists(Paths.get(targetSyncFile.getFilePathName())); try { Files.move(tempFilePath, Paths.get(targetSyncFile.getFilePathName()), StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING); } catch (AccessDeniedException ade) { _logger.error(ade.getMessage(), ade); targetSyncFile.setState(SyncFile.STATE_ERROR); targetSyncFile.setUiEvent(SyncFile.UI_EVENT_ACCESS_DENIED_LOCAL); SyncFileService.update(targetSyncFile); return; } targetSyncFile.setState(SyncFile.STATE_SYNCED); if (GetterUtil.getBoolean(targetSyncFile.getLocalExtraSettingValue("restoreEvent"))) { targetSyncFile.unsetLocalExtraSetting("restoreEvent"); targetSyncFile.setUiEvent(SyncFile.UI_EVENT_RESTORED_REMOTE); } else if (exists) { targetSyncFile.setUiEvent(SyncFile.UI_EVENT_DOWNLOADED_UPDATE); } else { targetSyncFile.setUiEvent(SyncFile.UI_EVENT_DOWNLOADED_NEW); } SyncFileService.update(targetSyncFile); IODeltaUtil.copyChecksums(sourceSyncFile, targetSyncFile); } protected void deleteFile(SyncFile sourceSyncFile, SyncFile targetSyncFile) throws Exception { if (sourceSyncFile.getUiEvent() == SyncFile.UI_EVENT_DELETED_LOCAL) { return; } sourceSyncFile.setModifiedTime(targetSyncFile.getModifiedTime()); String event = targetSyncFile.getEvent(); if (event.equals(SyncFile.EVENT_TRASH)) { sourceSyncFile.setUiEvent(SyncFile.UI_EVENT_TRASHED_REMOTE); } else { sourceSyncFile.setUiEvent(SyncFile.UI_EVENT_DELETED_REMOTE); } sourceSyncFile.setUserId(targetSyncFile.getUserId()); sourceSyncFile.setUserName(targetSyncFile.getUserName()); if (!sourceSyncFile.isUnsynced()) { SyncFileService.deleteSyncFile(sourceSyncFile); } Path sourceFilePath = Paths.get(sourceSyncFile.getFilePathName()); if (FileUtil.notExists(sourceFilePath)) { return; } final Watcher watcher = WatcherManager.getWatcher(getSyncAccountId()); if (sourceSyncFile.isFile()) { watcher.addDeletedFilePathName(sourceSyncFile.getFilePathName()); FileUtil.deleteFile(sourceFilePath); return; } Files.walkFileTree(sourceFilePath, new SimpleFileVisitor<Path>() { @Override public FileVisitResult postVisitDirectory(Path filePath, IOException ioe) throws IOException { if (ioe != null) { return super.postVisitDirectory(filePath, ioe); } watcher.addDeletedFilePathName(filePath.toString()); FileUtil.deleteFile(filePath); return FileVisitResult.CONTINUE; } @Override public FileVisitResult preVisitDirectory(Path filePath, BasicFileAttributes basicFileAttributes) throws IOException { watcher.unregisterFilePath(filePath); return super.preVisitDirectory(filePath, basicFileAttributes); } @Override public FileVisitResult visitFile(Path filePath, BasicFileAttributes basicFileAttributes) throws IOException { watcher.addDeletedFilePathName(filePath.toString()); FileUtil.deleteFile(filePath); return FileVisitResult.CONTINUE; } }); } protected void downloadFile(SyncFile syncFile, String sourceVersion, long sourceVersionId, boolean patch) throws Exception { String checksum = syncFile.getChecksum(); if (!checksum.isEmpty() && (syncFile.getSize() > 0)) { SyncFile sourceSyncFile = SyncFileService.fetchSyncFile(checksum, SyncFile.STATE_SYNCED); if ((sourceSyncFile != null) && FileUtil.exists(Paths.get(sourceSyncFile.getFilePathName()))) { copyFile(sourceSyncFile, syncFile); return; } } String targetVersion = syncFile.getVersion(); if (patch && !sourceVersion.equals("PWC") && !targetVersion.equals("PWC") && (Double.valueOf(sourceVersion) < Double.valueOf(targetVersion))) { FileEventUtil.downloadPatch(sourceVersionId, getSyncAccountId(), syncFile, syncFile.getVersionId()); } else { FileEventUtil.downloadFile(getSyncAccountId(), syncFile); } } protected boolean isIgnoredFilePath(SyncFile syncFile, String filePathName) { if (syncFile != null) { filePathName = syncFile.getFilePathName(); } return FileUtil.isIgnoredFilePath(FileUtil.getFilePath(filePathName)); } protected boolean isParentUnsynced(SyncFile syncFile) { Path filePath = Paths.get(syncFile.getFilePathName()); if (FileUtil.isUnsynced(filePath.getParent())) { return true; } return false; } @Override protected void logResponse(String response) { try { if (response.startsWith("\"")) { response = StringEscapeUtils.unescapeJava(response); response = response.replaceAll("\n", "\\n"); response = response.substring(1, response.length() - 1); } _syncDLObjectUpdate = JSONUtil.readValue(response, SyncDLObjectUpdate.class); List<SyncFile> syncFiles = _syncDLObjectUpdate.getSyncFiles(); if (!syncFiles.isEmpty()) { super.logResponse(response); } else { super.logResponse(""); } } catch (Exception e) { _logger.error(e.getMessage(), e); } } protected void processDependentSyncFiles(SyncFile syncFile) { List<SyncFile> dependentSyncFiles = _dependentSyncFilesMap .remove(getSyncAccountId() + "#" + syncFile.getTypePK()); if (syncFile.isUnsynced() || (dependentSyncFiles == null)) { return; } for (SyncFile dependentSyncFile : dependentSyncFiles) { processSyncFile(dependentSyncFile); } } protected boolean processFilePathChange(SyncFile sourceSyncFile, SyncFile targetSyncFile) throws Exception { String sourceSyncFileName = FileUtil.getSanitizedFileName(sourceSyncFile.getName(), sourceSyncFile.getExtension()); String targetSyncFileName = FileUtil.getSanitizedFileName(targetSyncFile.getName(), targetSyncFile.getExtension()); if ((sourceSyncFile.getParentFolderId() != targetSyncFile.getParentFolderId()) || !sourceSyncFileName.equals(targetSyncFileName)) { SyncFile targetParentSyncFile = SyncFileService.fetchSyncFile(targetSyncFile.getRepositoryId(), getSyncAccountId(), targetSyncFile.getParentFolderId()); Path targetParentFilePath = Paths.get(targetParentSyncFile.getFilePathName()); Path targetFilePath = targetParentFilePath.resolve(targetSyncFileName); Path sourceFilePath = Paths.get(sourceSyncFile.getFilePathName()); sourceSyncFile.setUiEvent(SyncFile.UI_EVENT_NONE); SyncFileService.updateSyncFile(targetFilePath, targetSyncFile.getParentFolderId(), sourceSyncFile); if (FileUtil.exists(sourceFilePath)) { Watcher watcher = WatcherManager.getWatcher(getSyncAccountId()); watcher.addMovedFilePathName(targetSyncFile.getFilePathName()); FileUtil.moveFile(sourceFilePath, targetFilePath); } return true; } return false; } protected void processSyncFile(SyncFile targetSyncFile) { SyncFile sourceSyncFile = SyncFileService.fetchSyncFile(targetSyncFile.getRepositoryId(), getSyncAccountId(), targetSyncFile.getTypePK()); if ((sourceSyncFile != null) && (sourceSyncFile.getState() == SyncFile.STATE_ERROR)) { if (_logger.isDebugEnabled()) { _logger.debug("Skipping file {}. File is in an error state.", sourceSyncFile.getFilePathName()); } return; } String event = targetSyncFile.getEvent(); if (event.equals(SyncFile.EVENT_DELETE) || event.equals(SyncFile.EVENT_TRASH)) { if (sourceSyncFile != null) { try { deleteFile(sourceSyncFile, targetSyncFile); } catch (Exception e) { _logger.error(e.getMessage(), e); } } return; } SyncFile parentSyncFile = SyncFileService.fetchSyncFile(targetSyncFile.getRepositoryId(), getSyncAccountId(), targetSyncFile.getParentFolderId()); if (parentSyncFile == null) { queueSyncFile(targetSyncFile.getParentFolderId(), targetSyncFile); return; } try { String filePathName = FileUtil.getFilePathName(parentSyncFile.getFilePathName(), FileUtil.getSanitizedFileName(targetSyncFile.getName(), targetSyncFile.getExtension())); if (sourceSyncFile == null) { sourceSyncFile = SyncFileService.fetchSyncFile(filePathName); } if (isIgnoredFilePath(sourceSyncFile, filePathName)) { return; } if ((sourceSyncFile != null) && (sourceSyncFile.getModifiedTime() == targetSyncFile.getModifiedTime())) { if (!Validator.isBlank(targetSyncFile.getChecksum())) { sourceSyncFile.setChecksum(targetSyncFile.getChecksum()); SyncFileService.update(sourceSyncFile); } return; } if ((sourceSyncFile != null) && !sourceSyncFile.isUnsynced()) { sourceSyncFile.setState(SyncFile.STATE_IN_PROGRESS); } targetSyncFile.setFilePathName(filePathName); targetSyncFile.setState(SyncFile.STATE_IN_PROGRESS); if (event.equals(SyncFile.EVENT_ADD) || event.equals(SyncFile.EVENT_GET) || event.equals(SyncFile.EVENT_MOVE) || event.equals(SyncFile.EVENT_UPDATE)) { if (sourceSyncFile == null) { addFile(targetSyncFile, filePathName); } else { updateFile(sourceSyncFile, targetSyncFile, filePathName); } } else if (event.equals(SyncFile.EVENT_RESTORE)) { if (Validator.isBlank(targetSyncFile.getName())) { // Workaround for SYNC-1690 return; } else if (sourceSyncFile != null) { updateFile(sourceSyncFile, targetSyncFile, filePathName); } else if (isParentUnsynced(targetSyncFile)) { if (targetSyncFile.isFolder()) { targetSyncFile.setModifiedTime(0); targetSyncFile.setState(SyncFile.STATE_UNSYNCED); targetSyncFile.setSyncAccountId(getSyncAccountId()); targetSyncFile.setUiEvent(SyncFile.UI_EVENT_NONE); SyncFileService.update(targetSyncFile); } return; } else { targetSyncFile.setLocalExtraSetting("restoreEvent", true); SyncFileService.update(targetSyncFile); addFile(targetSyncFile, filePathName); } } processDependentSyncFiles(targetSyncFile); if (getParameterValue("parentFolderId") != null) { SyncFile syncFile = SyncFileService.fetchSyncFile((Long) getParameterValue("repositoryId"), getSyncAccountId(), (Long) getParameterValue("parentFolderId")); if (syncFile != null) { syncFile.setState(SyncFile.STATE_IN_PROGRESS); syncFile.setUiEvent(SyncFile.UI_EVENT_RESYNCING); SyncFileService.update(syncFile); } } } catch (FileSystemException fse) { String message = fse.getMessage(); if (message.contains("File name too long")) { targetSyncFile.setState(SyncFile.STATE_ERROR); targetSyncFile.setUiEvent(SyncFile.UI_EVENT_FILE_NAME_TOO_LONG); SyncFileService.update(targetSyncFile); } } catch (Exception e) { _logger.error(e.getMessage(), e); } } protected void queueSyncFile(long parentFolderId, SyncFile syncFile) { List<SyncFile> syncFiles = _dependentSyncFilesMap.get(getSyncAccountId() + "#" + parentFolderId); if (syncFiles == null) { syncFiles = new ArrayList<>(); _dependentSyncFilesMap.put(getSyncAccountId() + "#" + parentFolderId, syncFiles); } syncFiles.add(syncFile); } protected void updateFile(SyncFile sourceSyncFile, SyncFile targetSyncFile, String filePathName) throws Exception { if (checkUnsynced(sourceSyncFile, targetSyncFile, filePathName)) { return; } if (sourceSyncFile.getTypePK() != targetSyncFile.getTypePK()) { _logger.error("Source type pk {} does not match target {} for {}", sourceSyncFile.getTypePK(), targetSyncFile.getTypePK(), sourceSyncFile.getFilePathName()); } String previousChecksum = sourceSyncFile.getChecksum(); String previousFilePathName = sourceSyncFile.getFilePathName(); long previousParentFolderId = sourceSyncFile.getParentFolderId(); String previousType = sourceSyncFile.getType(); String previousVersion = sourceSyncFile.getVersion(); long previousVersionId = sourceSyncFile.getVersionId(); boolean filePathChanged = processFilePathChange(sourceSyncFile, targetSyncFile); sourceSyncFile.setChangeLog(targetSyncFile.getChangeLog()); sourceSyncFile.setChecksum(targetSyncFile.getChecksum()); sourceSyncFile.setDescription(targetSyncFile.getDescription()); sourceSyncFile.setExtension(targetSyncFile.getExtension()); sourceSyncFile.setExtraSettings(targetSyncFile.getExtraSettings()); sourceSyncFile.setLanTokenKey(targetSyncFile.getLanTokenKey()); sourceSyncFile.setLockExpirationDate(targetSyncFile.getLockExpirationDate()); sourceSyncFile.setLockUserId(targetSyncFile.getLockUserId()); sourceSyncFile.setLockUserName(targetSyncFile.getLockUserName()); sourceSyncFile.setModifiedTime(targetSyncFile.getModifiedTime()); sourceSyncFile.setSize(targetSyncFile.getSize()); sourceSyncFile.setType(targetSyncFile.getType()); sourceSyncFile.setTypePK(targetSyncFile.getTypePK()); sourceSyncFile.setUserId(targetSyncFile.getUserId()); sourceSyncFile.setUserName(targetSyncFile.getUserName()); sourceSyncFile.setVersion(targetSyncFile.getVersion()); sourceSyncFile.setVersionId(targetSyncFile.getVersionId()); SyncFileService.update(sourceSyncFile); if (filePathChanged && !Validator.isBlank(previousChecksum) && previousChecksum.equals(targetSyncFile.getChecksum())) { sourceSyncFile.setState(SyncFile.STATE_SYNCED); if (previousParentFolderId == sourceSyncFile.getParentFolderId()) { sourceSyncFile.setUiEvent(SyncFile.UI_EVENT_RENAMED_REMOTE); } else { sourceSyncFile.setUiEvent(SyncFile.UI_EVENT_MOVED_REMOTE); } SyncFileService.update(sourceSyncFile); return; } Path filePath = Paths.get(targetSyncFile.getFilePathName()); if (!previousType.equals(sourceSyncFile.getType())) { if (previousType.equals(SyncFile.TYPE_FOLDER)) { FileUtils.deleteDirectory(filePath.toFile()); } else { Files.deleteIfExists(filePath); } } if (!FileUtil.exists(filePath)) { if (targetSyncFile.isFolder()) { Path targetFilePath = Paths.get(filePathName); Files.createDirectories(targetFilePath); sourceSyncFile.setState(SyncFile.STATE_SYNCED); sourceSyncFile.setUiEvent(SyncFile.UI_EVENT_UPDATED_REMOTE); SyncFileService.update(sourceSyncFile); FileKeyUtil.writeFileKey(targetFilePath, String.valueOf(sourceSyncFile.getSyncFileId()), false); } else { downloadFile(sourceSyncFile, null, 0, false); } } else if (targetSyncFile.isFile() && FileUtil.isModified(targetSyncFile, filePath)) { downloadFile(sourceSyncFile, previousVersion, previousVersionId, !IODeltaUtil.isIgnoredFilePatchingExtension(targetSyncFile)); } else { sourceSyncFile.setState(SyncFile.STATE_SYNCED); if (previousFilePathName.equals(sourceSyncFile.getFilePathName())) { sourceSyncFile.setUiEvent(SyncFile.UI_EVENT_NONE); } else { sourceSyncFile.setUiEvent(SyncFile.UI_EVENT_RENAMED_REMOTE); } SyncFileService.update(sourceSyncFile); } } protected void updateSettings(Map<String, Long> settingsModifiedTimes) { if (settingsModifiedTimes == null) { return; } for (Map.Entry<String, Long> entry : settingsModifiedTimes.entrySet()) { String setting = entry.getKey(); long modifiedTime = entry.getValue(); if (setting.equals(SyncDLObjectUpdate.PREFERENCE_KEY_SYNC_CONTEXT_MODIFIED_TIME)) { SyncAccount syncAccount = SyncAccountService.fetchSyncAccount(getSyncAccountId()); syncAccount.setSyncContextModifiedTime(modifiedTime); SyncAccountService.update(syncAccount); } } } private static final Logger _logger = LoggerFactory.getLogger(GetSyncDLObjectUpdateHandler.class); private static final Map<String, List<SyncFile>> _dependentSyncFilesMap = new HashMap<>(); private static final ScheduledExecutorService _scheduledExecutorService = Executors.newScheduledThreadPool(5); private static final Comparator<SyncFile> _syncFileComparator = new SyncFileSizeComparator(); private final ScheduledFuture<?> _scheduledFuture; private SyncDLObjectUpdate _syncDLObjectUpdate; }