platform/platform-impl/src/com/intellij/openapi/components/impl/stores/FileBasedStorage.java - platform/tools/idea - Git at Google

 /*
  * Copyright 2000-2013 JetBrains s.r.o.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.intellij.openapi.components.impl.stores;

 import com.intellij.notification.Notification;
 import com.intellij.notification.NotificationType;
 import com.intellij.notification.Notifications;
 import com.intellij.openapi.Disposable;
 import com.intellij.openapi.application.Application;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.application.PathManager;
 import com.intellij.openapi.components.StateStorageException;
 import com.intellij.openapi.components.TrackingPathMacroSubstitutor;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.util.JDOMUtil;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.openapi.vfs.*;
 import com.intellij.openapi.vfs.tracker.VirtualFileTracker;
 import com.intellij.util.io.fs.FileSystem;
 import com.intellij.util.io.fs.IFile;
 import com.intellij.util.messages.MessageBus;
 import org.jdom.Document;
 import org.jdom.Element;
 import org.jdom.JDOMException;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.picocontainer.PicoContainer;

 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;

 public class FileBasedStorage extends XmlElementStorage {
   private static final Logger LOG = Logger.getInstance("#com.intellij.openapi.components.impl.stores.FileBasedStorage");

   private final String myFilePath;
   private final IFile myFile;
   protected final String myRootElementName;

   private static boolean myConfigDirectoryRefreshed = false;
   private volatile VirtualFile myCachedVirtualFile;

   public FileBasedStorage(@Nullable TrackingPathMacroSubstitutor pathMacroManager,
                           StreamProvider streamProvider,
                           final String filePath,
                           final String fileSpec,
                           String rootElementName,
                           @NotNull Disposable parentDisposable,
                           PicoContainer picoContainer,
                           ComponentRoamingManager componentRoamingManager, ComponentVersionProvider localComponentVersionProvider) {
     super(pathMacroManager, parentDisposable, rootElementName, streamProvider,  fileSpec, componentRoamingManager, localComponentVersionProvider);
     Application app = ApplicationManager.getApplication();

     if (!myConfigDirectoryRefreshed && (app.isUnitTestMode() || app.isDispatchThread())) {
       try {
         syncRefreshPathRecursively(PathManager.getConfigPath(), "componentVersions");
       }
       finally {
         //noinspection AssignmentToStaticFieldFromInstanceMethod
         myConfigDirectoryRefreshed = true;
       }
     }

     myRootElementName = rootElementName;
     myFilePath = filePath;
     myFile = FileSystem.FILE_SYSTEM.createFile(myFilePath);

     VirtualFileTracker virtualFileTracker = (VirtualFileTracker)picoContainer.getComponentInstanceOfType(VirtualFileTracker.class);
     MessageBus messageBus = (MessageBus)picoContainer.getComponentInstanceOfType(MessageBus.class);
     if (virtualFileTracker != null && messageBus != null) {
       final String path = myFile.getAbsolutePath();
       final String fileUrl = LocalFileSystem.PROTOCOL_PREFIX + path.replace(File.separatorChar, '/');

       final Listener listener = messageBus.syncPublisher(STORAGE_TOPIC);
       virtualFileTracker.addTracker(fileUrl, new VirtualFileAdapter() {
         @Override
         public void fileMoved(VirtualFileMoveEvent event) {
           myCachedVirtualFile = null;
         }

         @Override
         public void fileDeleted(VirtualFileEvent event) {
           myCachedVirtualFile = null;
         }

         @Override
         public void contentsChanged(final VirtualFileEvent event) {
           if (!isDisposed()) {
             listener.storageFileChanged(event, FileBasedStorage.this);
           }
         }
       }, false, this);
     }
   }

   private static void syncRefreshPathRecursively(@NotNull String configDirectoryPath, @Nullable final String excludeDir) {
     VirtualFile configDir = LocalFileSystem.getInstance().refreshAndFindFileByPath(configDirectoryPath);
     if (configDir != null) {
       requestAllChildren(configDir, excludeDir);
       VfsUtil.markDirtyAndRefresh(false, true, false, configDir);
     }
   }

   private static void requestAllChildren(final VirtualFile configDir, @Nullable final String excludeDir) {
     VfsUtilCore.visitChildrenRecursively(configDir, new VirtualFileVisitor() {
       @Override
       public boolean visitFile(@NotNull VirtualFile file) {
         return excludeDir == null || !excludeDir.equals(file.getName());
       }
     });
   }

   @Override
   protected MySaveSession createSaveSession(final MyExternalizationSession externalizationSession) {
     return new FileSaveSession(externalizationSession);
   }

   public void resetProviderCache() {
     myProviderUpToDateHash = -1;
     if (myRemoteVersionProvider != null) {
       myRemoteVersionProvider.myProviderVersions = null;
     }
   }

   private class FileSaveSession extends MySaveSession {
     protected FileSaveSession(MyExternalizationSession externalizationSession) {
       super(externalizationSession);
     }

     @Override
     protected boolean physicalContentNeedsSave() {
       VirtualFile file = getVirtualFile();
       if (file == null || !file.exists())
         return !myStorageData.isEmpty();
       return !StorageUtil.contentEquals(getDocumentToSave(), file);
     }

     @Override
     protected int calcHash() {
       int hash = myStorageData.getHash();
       if (myPathMacroSubstitutor != null) {
         hash = 31 * hash + myPathMacroSubstitutor.hashCode();
       }
       return hash;
     }

     @Override
     protected void doSave() throws StateStorageException {
       if (myBlockSavingTheContent) {
         return;
       }
       if (ApplicationManager.getApplication().isUnitTestMode() && myFile != null && StringUtil.startsWithChar(myFile.getPath(), '$')) {
         throw new StateStorageException("It seems like some macros were not expanded for path: " + myFile.getPath());
       }

       LOG.assertTrue(myFile != null);
       myCachedVirtualFile = StorageUtil.save(myFile, getDocumentToSave(), this);
     }

     @NotNull
     @Override
     public Collection<IFile> getStorageFilesToSave() throws StateStorageException {
       boolean needsSave = needsSave();
       if (needsSave) {
         if (LOG.isDebugEnabled()) {
           LOG.info("File " + myFileSpec + " needs save; hash=" + myUpToDateHash + "; currentHash=" + calcHash() + "; " +
                    "content needs save=" + physicalContentNeedsSave());
         }
         return getAllStorageFiles();
       }
       else {
         return Collections.emptyList();
       }
     }

     @NotNull
     @Override
     public List<IFile> getAllStorageFiles() {
       return Collections.singletonList(myFile);
     }
   }

   @Override
   protected void loadState(final StorageData result, final Element element) throws StateStorageException {
     ((FileStorageData)result).myFilePath = myFile.getAbsolutePath();
     super.loadState(result, element);
   }

   @Override
   @NotNull
   protected StorageData createStorageData() {
     return new FileStorageData(myRootElementName);
   }

   public static class FileStorageData extends StorageData {
     String myFilePath;

     public FileStorageData(final String rootElementName) {
       super(rootElementName);
     }

     protected FileStorageData(FileStorageData storageData) {
       super(storageData);
       myFilePath = storageData.myFilePath;
     }

     @Override
     public StorageData clone() {
       return new FileStorageData(this);
     }

     @NonNls
     public String toString() {
       return "FileStorageData[" + myFilePath + "]";
     }
   }

   @Nullable
   public VirtualFile getVirtualFile() {
     VirtualFile virtualFile = myCachedVirtualFile;
     if (virtualFile == null) {
       myCachedVirtualFile = virtualFile = StorageUtil.getVirtualFile(myFile);
     }
     return virtualFile;
   }

   public File getFile() {
     return new File(myFile.getPath());
   }

   @Override
   @Nullable
   protected Document loadDocument() throws StateStorageException {
     myBlockSavingTheContent = false;
     try {
       VirtualFile file = getVirtualFile();
       if (file == null || file.isDirectory() || !file.isValid()) {
         LOG.info("Document was not loaded for " + myFileSpec + " file is " + (file == null ? "null" : "directory"));
         return null;
       }
       if (file.getLength() == 0) {
         return processReadException(null);
       }
       return loadDocumentImpl(file);
     }
     catch (final JDOMException e) {
       return processReadException(e);
     }
     catch (final IOException e) {
       return processReadException(e);
     }
   }

   @Nullable
   private Document processReadException(@Nullable final Exception e) {
     boolean contentTruncated = e == null;
     myBlockSavingTheContent = isProjectOrModuleFile() && !contentTruncated;
     if (!ApplicationManager.getApplication().isUnitTestMode() && !ApplicationManager.getApplication().isHeadlessEnvironment()) {
       if (e != null) {
         LOG.info(e);
       }
       final String message = "Cannot load settings from file '" + myFile.getPath() + "': " + (e == null ? "content truncated" : e.getLocalizedMessage()) + "\n" +
                              getInvalidContentMessage(contentTruncated);
       Notifications.Bus.notify(
         new Notification(Notifications.SYSTEM_MESSAGES_GROUP_ID, "Load Settings", message, NotificationType.WARNING));
     }

     return null;
   }

   private boolean isProjectOrModuleFile() {
     return StorageUtil.isProjectOrModuleFile(myFileSpec);
   }

   private String getInvalidContentMessage(boolean contentTruncated) {
     return isProjectOrModuleFile() && !contentTruncated ? "Please correct the file content" : "File content will be recreated";
   }

   private static Document loadDocumentImpl(final VirtualFile file) throws IOException, JDOMException {
     InputStream stream = file.getInputStream();
     try {
       return JDOMUtil.loadDocument(stream);
     }
     finally {
       stream.close();
     }
   }

   public String getFileName() {
     return myFile.getName();
   }

   public String getFilePath() {
     return myFilePath;
   }

   @Override
   public void setDefaultState(final Element element) {
     element.setName(myRootElementName);
     super.setDefaultState(element);
   }

   protected boolean physicalContentNeedsSave(final Document doc) {
     VirtualFile file = getVirtualFile();
     return file == null || !file.exists() || !StorageUtil.contentEquals(doc, file);
   }

   @Nullable
   public File updateFileExternallyFromStreamProviders() throws IOException {
     StorageData loadedData = loadData(true);
     Document document = getDocument(loadedData);
     if (physicalContentNeedsSave(document)) {
       File file = new File(myFile.getAbsolutePath());
       JDOMUtil.writeDocument(document, file, "\n");
       return file;
     }

     return null;
   }
 }
	/*
	* Copyright 2000-2013 JetBrains s.r.o.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package com.intellij.openapi.components.impl.stores;

	import com.intellij.notification.Notification;
	import com.intellij.notification.NotificationType;
	import com.intellij.notification.Notifications;
	import com.intellij.openapi.Disposable;
	import com.intellij.openapi.application.Application;
	import com.intellij.openapi.application.ApplicationManager;
	import com.intellij.openapi.application.PathManager;
	import com.intellij.openapi.components.StateStorageException;
	import com.intellij.openapi.components.TrackingPathMacroSubstitutor;
	import com.intellij.openapi.diagnostic.Logger;
	import com.intellij.openapi.util.JDOMUtil;
	import com.intellij.openapi.util.text.StringUtil;
	import com.intellij.openapi.vfs.*;
	import com.intellij.openapi.vfs.tracker.VirtualFileTracker;
	import com.intellij.util.io.fs.FileSystem;
	import com.intellij.util.io.fs.IFile;
	import com.intellij.util.messages.MessageBus;
	import org.jdom.Document;
	import org.jdom.Element;
	import org.jdom.JDOMException;
	import org.jetbrains.annotations.NonNls;
	import org.jetbrains.annotations.NotNull;
	import org.jetbrains.annotations.Nullable;
	import org.picocontainer.PicoContainer;

	import java.io.File;
	import java.io.IOException;
	import java.io.InputStream;
	import java.util.Collection;
	import java.util.Collections;
	import java.util.List;

	public class FileBasedStorage extends XmlElementStorage {
	private static final Logger LOG = Logger.getInstance("#com.intellij.openapi.components.impl.stores.FileBasedStorage");

	private final String myFilePath;
	private final IFile myFile;
	protected final String myRootElementName;

	private static boolean myConfigDirectoryRefreshed = false;
	private volatile VirtualFile myCachedVirtualFile;

	public FileBasedStorage(@Nullable TrackingPathMacroSubstitutor pathMacroManager,
	StreamProvider streamProvider,
	final String filePath,
	final String fileSpec,
	String rootElementName,
	@NotNull Disposable parentDisposable,
	PicoContainer picoContainer,
	ComponentRoamingManager componentRoamingManager, ComponentVersionProvider localComponentVersionProvider) {
	super(pathMacroManager, parentDisposable, rootElementName, streamProvider, fileSpec, componentRoamingManager, localComponentVersionProvider);
	Application app = ApplicationManager.getApplication();

	if (!myConfigDirectoryRefreshed && (app.isUnitTestMode() \|\| app.isDispatchThread())) {
	try {
	syncRefreshPathRecursively(PathManager.getConfigPath(), "componentVersions");
	}
	finally {
	//noinspection AssignmentToStaticFieldFromInstanceMethod
	myConfigDirectoryRefreshed = true;
	}
	}

	myRootElementName = rootElementName;
	myFilePath = filePath;
	myFile = FileSystem.FILE_SYSTEM.createFile(myFilePath);

	VirtualFileTracker virtualFileTracker = (VirtualFileTracker)picoContainer.getComponentInstanceOfType(VirtualFileTracker.class);
	MessageBus messageBus = (MessageBus)picoContainer.getComponentInstanceOfType(MessageBus.class);
	if (virtualFileTracker != null && messageBus != null) {
	final String path = myFile.getAbsolutePath();
	final String fileUrl = LocalFileSystem.PROTOCOL_PREFIX + path.replace(File.separatorChar, '/');

	final Listener listener = messageBus.syncPublisher(STORAGE_TOPIC);
	virtualFileTracker.addTracker(fileUrl, new VirtualFileAdapter() {
	@Override
	public void fileMoved(VirtualFileMoveEvent event) {
	myCachedVirtualFile = null;
	}

	@Override
	public void fileDeleted(VirtualFileEvent event) {
	myCachedVirtualFile = null;
	}

	@Override
	public void contentsChanged(final VirtualFileEvent event) {
	if (!isDisposed()) {
	listener.storageFileChanged(event, FileBasedStorage.this);
	}
	}
	}, false, this);
	}
	}

	private static void syncRefreshPathRecursively(@NotNull String configDirectoryPath, @Nullable final String excludeDir) {
	VirtualFile configDir = LocalFileSystem.getInstance().refreshAndFindFileByPath(configDirectoryPath);
	if (configDir != null) {
	requestAllChildren(configDir, excludeDir);
	VfsUtil.markDirtyAndRefresh(false, true, false, configDir);
	}
	}

	private static void requestAllChildren(final VirtualFile configDir, @Nullable final String excludeDir) {
	VfsUtilCore.visitChildrenRecursively(configDir, new VirtualFileVisitor() {
	@Override
	public boolean visitFile(@NotNull VirtualFile file) {
	return excludeDir == null \|\| !excludeDir.equals(file.getName());
	}
	});
	}

	@Override
	protected MySaveSession createSaveSession(final MyExternalizationSession externalizationSession) {
	return new FileSaveSession(externalizationSession);
	}

	public void resetProviderCache() {
	myProviderUpToDateHash = -1;
	if (myRemoteVersionProvider != null) {
	myRemoteVersionProvider.myProviderVersions = null;
	}
	}

	private class FileSaveSession extends MySaveSession {
	protected FileSaveSession(MyExternalizationSession externalizationSession) {
	super(externalizationSession);
	}

	@Override
	protected boolean physicalContentNeedsSave() {
	VirtualFile file = getVirtualFile();
	if (file == null \|\| !file.exists())
	return !myStorageData.isEmpty();
	return !StorageUtil.contentEquals(getDocumentToSave(), file);
	}

	@Override
	protected int calcHash() {
	int hash = myStorageData.getHash();
	if (myPathMacroSubstitutor != null) {
	hash = 31 * hash + myPathMacroSubstitutor.hashCode();
	}
	return hash;
	}

	@Override
	protected void doSave() throws StateStorageException {
	if (myBlockSavingTheContent) {
	return;
	}
	if (ApplicationManager.getApplication().isUnitTestMode() && myFile != null && StringUtil.startsWithChar(myFile.getPath(), '$')) {
	throw new StateStorageException("It seems like some macros were not expanded for path: " + myFile.getPath());
	}

	LOG.assertTrue(myFile != null);
	myCachedVirtualFile = StorageUtil.save(myFile, getDocumentToSave(), this);
	}

	@NotNull
	@Override
	public Collection<IFile> getStorageFilesToSave() throws StateStorageException {
	boolean needsSave = needsSave();
	if (needsSave) {
	if (LOG.isDebugEnabled()) {
	LOG.info("File " + myFileSpec + " needs save; hash=" + myUpToDateHash + "; currentHash=" + calcHash() + "; " +
	"content needs save=" + physicalContentNeedsSave());
	}
	return getAllStorageFiles();
	}
	else {
	return Collections.emptyList();
	}
	}

	@NotNull
	@Override
	public List<IFile> getAllStorageFiles() {
	return Collections.singletonList(myFile);
	}
	}

	@Override
	protected void loadState(final StorageData result, final Element element) throws StateStorageException {
	((FileStorageData)result).myFilePath = myFile.getAbsolutePath();
	super.loadState(result, element);
	}

	@Override
	@NotNull
	protected StorageData createStorageData() {
	return new FileStorageData(myRootElementName);
	}

	public static class FileStorageData extends StorageData {
	String myFilePath;

	public FileStorageData(final String rootElementName) {
	super(rootElementName);
	}

	protected FileStorageData(FileStorageData storageData) {
	super(storageData);
	myFilePath = storageData.myFilePath;
	}

	@Override
	public StorageData clone() {
	return new FileStorageData(this);
	}

	@NonNls
	public String toString() {
	return "FileStorageData[" + myFilePath + "]";
	}
	}

	@Nullable
	public VirtualFile getVirtualFile() {
	VirtualFile virtualFile = myCachedVirtualFile;
	if (virtualFile == null) {
	myCachedVirtualFile = virtualFile = StorageUtil.getVirtualFile(myFile);
	}
	return virtualFile;
	}

	public File getFile() {
	return new File(myFile.getPath());
	}

	@Override
	@Nullable
	protected Document loadDocument() throws StateStorageException {
	myBlockSavingTheContent = false;
	try {
	VirtualFile file = getVirtualFile();
	if (file == null \|\| file.isDirectory() \|\| !file.isValid()) {
	LOG.info("Document was not loaded for " + myFileSpec + " file is " + (file == null ? "null" : "directory"));
	return null;
	}
	if (file.getLength() == 0) {
	return processReadException(null);
	}
	return loadDocumentImpl(file);
	}
	catch (final JDOMException e) {
	return processReadException(e);
	}
	catch (final IOException e) {
	return processReadException(e);
	}
	}

	@Nullable
	private Document processReadException(@Nullable final Exception e) {
	boolean contentTruncated = e == null;
	myBlockSavingTheContent = isProjectOrModuleFile() && !contentTruncated;
	if (!ApplicationManager.getApplication().isUnitTestMode() && !ApplicationManager.getApplication().isHeadlessEnvironment()) {
	if (e != null) {
	LOG.info(e);
	}
	final String message = "Cannot load settings from file '" + myFile.getPath() + "': " + (e == null ? "content truncated" : e.getLocalizedMessage()) + "\n" +
	getInvalidContentMessage(contentTruncated);
	Notifications.Bus.notify(
	new Notification(Notifications.SYSTEM_MESSAGES_GROUP_ID, "Load Settings", message, NotificationType.WARNING));
	}

	return null;
	}

	private boolean isProjectOrModuleFile() {
	return StorageUtil.isProjectOrModuleFile(myFileSpec);
	}

	private String getInvalidContentMessage(boolean contentTruncated) {
	return isProjectOrModuleFile() && !contentTruncated ? "Please correct the file content" : "File content will be recreated";
	}

	private static Document loadDocumentImpl(final VirtualFile file) throws IOException, JDOMException {
	InputStream stream = file.getInputStream();
	try {
	return JDOMUtil.loadDocument(stream);
	}
	finally {
	stream.close();
	}
	}

	public String getFileName() {
	return myFile.getName();
	}

	public String getFilePath() {
	return myFilePath;
	}

	@Override
	public void setDefaultState(final Element element) {
	element.setName(myRootElementName);
	super.setDefaultState(element);
	}

	protected boolean physicalContentNeedsSave(final Document doc) {
	VirtualFile file = getVirtualFile();
	return file == null \|\| !file.exists() \|\| !StorageUtil.contentEquals(doc, file);
	}

	@Nullable
	public File updateFileExternallyFromStreamProviders() throws IOException {
	StorageData loadedData = loadData(true);
	Document document = getDocument(loadedData);
	if (physicalContentNeedsSave(document)) {
	File file = new File(myFile.getAbsolutePath());
	JDOMUtil.writeDocument(document, file, "\n");
	return file;
	}

	return null;
	}
	}