| /* |
| * Copyright 2016 The Bazel Authors. All rights reserved. |
| * |
| * 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.google.idea.blaze.base.sync; |
| |
| import com.google.common.annotations.VisibleForTesting; |
| import com.google.common.collect.ImmutableMap; |
| import com.google.common.collect.ImmutableMultimap; |
| import com.google.common.collect.Iterables; |
| import com.google.common.collect.Lists; |
| import com.google.common.util.concurrent.ListenableFuture; |
| import com.google.common.util.concurrent.ListeningExecutorService; |
| import com.google.idea.blaze.base.async.AsyncUtil; |
| import com.google.idea.blaze.base.async.FutureUtil; |
| import com.google.idea.blaze.base.async.executor.BlazeExecutor; |
| import com.google.idea.blaze.base.experiments.ExperimentScope; |
| import com.google.idea.blaze.base.ideinfo.RuleIdeInfo; |
| import com.google.idea.blaze.base.metrics.Action; |
| import com.google.idea.blaze.base.model.BlazeProjectData; |
| import com.google.idea.blaze.base.model.SyncState; |
| import com.google.idea.blaze.base.model.primitives.Label; |
| import com.google.idea.blaze.base.model.primitives.TargetExpression; |
| import com.google.idea.blaze.base.model.primitives.WorkspacePath; |
| import com.google.idea.blaze.base.model.primitives.WorkspaceRoot; |
| import com.google.idea.blaze.base.projectview.ProjectViewManager; |
| import com.google.idea.blaze.base.projectview.ProjectViewSet; |
| import com.google.idea.blaze.base.projectview.ProjectViewVerifier; |
| import com.google.idea.blaze.base.projectview.section.sections.TargetSection; |
| import com.google.idea.blaze.base.rulemaps.ReverseDependencyMap; |
| import com.google.idea.blaze.base.scope.BlazeContext; |
| import com.google.idea.blaze.base.scope.Scope; |
| import com.google.idea.blaze.base.scope.output.IssueOutput; |
| import com.google.idea.blaze.base.scope.output.PrintOutput; |
| import com.google.idea.blaze.base.scope.output.StatusOutput; |
| import com.google.idea.blaze.base.scope.scopes.*; |
| import com.google.idea.blaze.base.settings.Blaze; |
| import com.google.idea.blaze.base.settings.BlazeImportSettings; |
| import com.google.idea.blaze.base.settings.BlazeUserSettings; |
| import com.google.idea.blaze.base.sync.BlazeSyncParams.SyncMode; |
| import com.google.idea.blaze.base.sync.BlazeSyncPlugin.ModuleEditor; |
| import com.google.idea.blaze.base.sync.aspects.BlazeIdeInterface; |
| import com.google.idea.blaze.base.sync.data.BlazeProjectDataManagerImpl; |
| import com.google.idea.blaze.base.sync.projectstructure.ContentEntryEditor; |
| import com.google.idea.blaze.base.sync.projectstructure.ModuleDataStorage; |
| import com.google.idea.blaze.base.sync.projectstructure.ModuleEditorImpl; |
| import com.google.idea.blaze.base.sync.projectstructure.ModuleEditorProvider; |
| import com.google.idea.blaze.base.sync.projectview.LanguageSupport; |
| import com.google.idea.blaze.base.sync.projectview.WorkspaceLanguageSettings; |
| import com.google.idea.blaze.base.sync.workspace.*; |
| import com.google.idea.blaze.base.util.SaveUtil; |
| import com.google.idea.blaze.base.vcs.BlazeVcsHandler; |
| import com.intellij.openapi.diagnostic.Logger; |
| import com.intellij.openapi.module.Module; |
| import com.intellij.openapi.module.ModuleType; |
| import com.intellij.openapi.progress.ProgressIndicator; |
| import com.intellij.openapi.progress.Progressive; |
| import com.intellij.openapi.project.Project; |
| import com.intellij.openapi.roots.ContentEntry; |
| import com.intellij.openapi.roots.ModifiableRootModel; |
| import com.intellij.openapi.roots.ex.ProjectRootManagerEx; |
| import com.intellij.openapi.util.io.FileUtil; |
| import com.intellij.openapi.vfs.LocalFileSystem; |
| import com.intellij.openapi.vfs.StandardFileSystems; |
| import com.intellij.openapi.vfs.VirtualFileManager; |
| |
| import javax.annotation.Nullable; |
| import java.io.File; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.List; |
| import java.util.stream.Collectors; |
| |
| |
| /** |
| * Syncs the project with blaze. |
| */ |
| final class BlazeSyncTask implements Progressive { |
| |
| private final static Logger LOG = Logger.getInstance(BlazeSyncTask.class); |
| |
| private final Project project; |
| private final BlazeImportSettings importSettings; |
| private final WorkspaceRoot workspaceRoot; |
| private final BlazeSyncParams syncParams; |
| private final boolean expandSyncToWorkingSet; |
| private final boolean showPerformanceWarnings; |
| private long syncStartTime; |
| |
| BlazeSyncTask( |
| Project project, |
| BlazeImportSettings importSettings, |
| final BlazeSyncParams syncParams) { |
| this.project = project; |
| this.importSettings = importSettings; |
| this.workspaceRoot = WorkspaceRoot.fromImportSettings(importSettings); |
| this.syncParams = syncParams; |
| this.expandSyncToWorkingSet = BlazeUserSettings.getInstance().getExpandSyncToWorkingSet() |
| && ExpandWorkingSetTargetsExperiment.ENABLE_EXPAND_WORKING_SET_TARGETS.getValue(); |
| this.showPerformanceWarnings = BlazeUserSettings.getInstance().getShowPerformanceWarnings(); |
| } |
| |
| |
| @Override |
| public void run(final ProgressIndicator indicator) { |
| Scope.root((BlazeContext context) -> { |
| context.push(new ExperimentScope()); |
| if (showPerformanceWarnings) { |
| context.push(new PerformanceWarningScope()); |
| } |
| context |
| .push(new ProgressIndicatorScope(indicator)) |
| .push(new TimingScope("Sync")) |
| .push(new LoggedTimingScope(project, Action.SYNC_TOTAL_TIME)) |
| ; |
| |
| if (!syncParams.backgroundSync) { |
| context |
| .push(new BlazeConsoleScope.Builder(project, indicator).build()) |
| .push(new IssuesScope(project)) |
| .push(new NotificationScope( |
| project, |
| "Sync", |
| "Sync project", |
| "Sync successful", |
| "Sync failed" |
| )) |
| ; |
| } |
| |
| context.output(new StatusOutput("Syncing project...")); |
| syncProject(context); |
| }); |
| } |
| |
| /** |
| * Returns true if sync successfully completed |
| */ |
| @VisibleForTesting |
| boolean syncProject(BlazeContext context) { |
| boolean success = false; |
| try { |
| SaveUtil.saveAllFiles(); |
| onSyncStart(project); |
| success = doSyncProject(context); |
| } catch (AssertionError|Exception e) { |
| LOG.error(e); |
| IssueOutput.error("Internal error: " + e.getMessage()).submit(context); |
| } finally { |
| afterSync(project, success); |
| } |
| return success; |
| } |
| |
| /** |
| * @return true if sync successfully completed |
| */ |
| private boolean doSyncProject(final BlazeContext context) { |
| this.syncStartTime = System.currentTimeMillis(); |
| |
| if (importSettings.getProjectViewFile() == null) { |
| IssueOutput.error( |
| "This project looks like it's been opened from an old version of ASwB. " |
| + "That is unfortunately not supported. Please reimport your project." |
| ).submit(context); |
| return false; |
| } |
| |
| @Nullable BlazeProjectData oldBlazeProjectData = null; |
| if (syncParams.syncMode != SyncMode.FULL) { |
| oldBlazeProjectData = BlazeProjectDataManagerImpl.getImpl(project).loadProjectRoot(context, importSettings); |
| } |
| |
| BlazeVcsHandler vcsHandler = null; |
| for (BlazeVcsHandler candidate : BlazeVcsHandler.EP_NAME.getExtensions()) { |
| if (candidate.handlesProject(project, workspaceRoot)) { |
| vcsHandler = candidate; |
| break; |
| } |
| } |
| if (vcsHandler == null) { |
| IssueOutput.error("Could not find a VCS handler").submit(context); |
| return false; |
| } |
| |
| ListeningExecutorService executor = BlazeExecutor.getInstance().getExecutor(); |
| ListenableFuture<BlazeRoots> blazeRootsFuture = BlazeRoots.compute(project, workspaceRoot, context); |
| ListenableFuture<WorkingSet> workingSetFuture = vcsHandler.getWorkingSet(project, workspaceRoot, executor); |
| |
| BlazeRoots blazeRoots = FutureUtil.waitForFuture(context, blazeRootsFuture) |
| .timed(Blaze.buildSystemName(project) + "Roots") |
| .withProgressMessage(String.format("Running %s info...", Blaze.buildSystemName(project))) |
| .onError(String.format("Could not get %s roots", Blaze.buildSystemName(project))) |
| .run() |
| .result(); |
| if (blazeRoots == null) { |
| return false; |
| } |
| |
| WorkspacePathResolverAndProjectView workspacePathResolverAndProjectView = computeWorkspacePathResolverAndProjectView( |
| context, |
| blazeRoots, |
| vcsHandler, |
| executor |
| ); |
| if (workspacePathResolverAndProjectView == null) { |
| return false; |
| } |
| WorkspacePathResolver workspacePathResolver = workspacePathResolverAndProjectView.workspacePathResolver; |
| ProjectViewSet projectViewSet = workspacePathResolverAndProjectView.projectViewSet; |
| |
| WorkspaceLanguageSettings workspaceLanguageSettings = LanguageSupport.createWorkspaceLanguageSettings(context, projectViewSet); |
| if (workspaceLanguageSettings == null) { |
| return false; |
| } |
| |
| if (!ProjectViewVerifier.verifyProjectView(context, workspaceRoot, projectViewSet, workspaceLanguageSettings)) { |
| return false; |
| } |
| |
| final BlazeProjectData newBlazeProjectData; |
| |
| WorkingSet workingSet = FutureUtil.waitForFuture(context, workingSetFuture) |
| .timed("WorkingSet") |
| .withProgressMessage("Computing VCS working set...") |
| .onError("Could not compute working set") |
| .run() |
| .result(); |
| if (!context.shouldContinue()) { |
| return false; |
| } |
| |
| if (workingSet != null) { |
| printWorkingSet(context, workingSet); |
| } |
| |
| boolean ideResolveErrors = false; |
| if (syncParams.syncMode != SyncMode.RESTORE_EPHEMERAL_STATE || oldBlazeProjectData == null) { |
| SyncState.Builder syncStateBuilder = new SyncState.Builder(); |
| SyncState previousSyncState = oldBlazeProjectData != null ? oldBlazeProjectData.syncState : null; |
| List<TargetExpression> allTargets = projectViewSet.listItems(TargetSection.KEY); |
| if (expandSyncToWorkingSet && workingSet != null) { |
| allTargets.addAll(getWorkingSetTargets(workingSet)); |
| } |
| |
| boolean syncPluginRequiresBuild = false; |
| boolean requiresAndroidSdk = false; |
| for (BlazeSyncPlugin syncPlugin : BlazeSyncPlugin.EP_NAME.getExtensions()) { |
| syncPluginRequiresBuild |= syncPlugin.requiresResolveIdeArtifacts(); |
| requiresAndroidSdk |= syncPlugin.requiresAndroidSdk(workspaceLanguageSettings); |
| } |
| |
| final BlazeIdeInterface.IdeResult ideQueryResult = getIdeQueryResult( |
| project, |
| context, |
| projectViewSet, |
| allTargets, |
| workspaceLanguageSettings, |
| new ArtifactLocationDecoder(blazeRoots, workspacePathResolver), |
| syncStateBuilder, |
| previousSyncState, |
| requiresAndroidSdk |
| ); |
| if (ideQueryResult == null) { |
| if (workingSet != null && !workingSet.isEmpty() && expandSyncToWorkingSet && !context.isCancelled()) { |
| String msg = String.format("If you have broken targets in your VCS working set, uncheck '%s > Expand Sync to Working Set'" + |
| " and try again.", Blaze.buildSystemName(project)); |
| context.output(new PrintOutput(msg, PrintOutput.OutputType.ERROR)); |
| } |
| return false; |
| } |
| ImmutableMap<Label, RuleIdeInfo> ruleMap = ideQueryResult.ruleMap; |
| |
| ListenableFuture<ImmutableMultimap<Label, Label>> reverseDependenciesFuture = |
| BlazeExecutor.getInstance().submit(() -> ReverseDependencyMap.createRdepsMap(ruleMap)); |
| |
| boolean doBuild = syncPluginRequiresBuild || (syncParams.doBuild || oldBlazeProjectData == null); |
| if (doBuild) { |
| List<TargetExpression> targetExpressions = Lists.newArrayList(syncParams.targetExpressions); |
| if (targetExpressions.isEmpty()) { |
| targetExpressions.addAll(allTargets); |
| } |
| ideResolveErrors = !resolveIdeArtifacts(project, context, workspaceRoot, projectViewSet, targetExpressions); |
| LocalFileSystem.getInstance().refresh(true); |
| if (context.isCancelled()) { |
| return false; |
| } |
| } |
| |
| Scope.push(context, (childContext) -> { |
| childContext.push(new TimingScope("UpdateSyncState")); |
| for (BlazeSyncPlugin syncPlugin : BlazeSyncPlugin.EP_NAME.getExtensions()) { |
| syncPlugin.updateSyncState( |
| project, |
| childContext, |
| workspaceRoot, |
| projectViewSet, |
| workspaceLanguageSettings, |
| blazeRoots, |
| workingSet, |
| workspacePathResolver, |
| ruleMap, |
| ideQueryResult.androidPlatformDirectory, |
| syncStateBuilder, |
| previousSyncState); |
| } |
| }); |
| |
| ImmutableMultimap<Label, Label> reverseDependencies = FutureUtil.waitForFuture(context, reverseDependenciesFuture) |
| .timed("ReverseDependencies") |
| .onError("Failed to compute reverse dependency map") |
| .run() |
| .result(); |
| if (reverseDependencies == null) { |
| return false; |
| } |
| |
| newBlazeProjectData = new BlazeProjectData( |
| syncStartTime, |
| ruleMap, |
| blazeRoots, |
| workingSet, |
| workspacePathResolver, |
| workspaceLanguageSettings, |
| syncStateBuilder.build(), |
| reverseDependencies |
| ); |
| } else { |
| // Restore project based on old blaze project data |
| newBlazeProjectData = oldBlazeProjectData; |
| } |
| |
| boolean success = updateProject(project, context, projectViewSet, oldBlazeProjectData, newBlazeProjectData); |
| if (!success) { |
| return false; |
| } |
| |
| if (ideResolveErrors) { |
| context.output(new PrintOutput( |
| "Sync was successful, but there were compilation errors. The project may not fully resolve until fixed.", |
| PrintOutput.OutputType.ERROR |
| )); |
| } |
| |
| onSyncComplete(project, context, projectViewSet, newBlazeProjectData); |
| return true; |
| } |
| |
| static class WorkspacePathResolverAndProjectView { |
| final WorkspacePathResolver workspacePathResolver; |
| final ProjectViewSet projectViewSet; |
| public WorkspacePathResolverAndProjectView(WorkspacePathResolver workspacePathResolver, |
| ProjectViewSet projectViewSet) { |
| this.workspacePathResolver = workspacePathResolver; |
| this.projectViewSet = projectViewSet; |
| } |
| } |
| private WorkspacePathResolverAndProjectView computeWorkspacePathResolverAndProjectView(BlazeContext context, |
| BlazeRoots blazeRoots, |
| BlazeVcsHandler vcsHandler, |
| ListeningExecutorService executor) { |
| for (int i = 0; i < 3; ++i) { |
| WorkspacePathResolver vcsWorkspacePathResolver = null; |
| BlazeVcsHandler.BlazeVcsSyncHandler vcsSyncHandler = vcsHandler.createSyncHandler(project, workspaceRoot); |
| if (vcsSyncHandler != null) { |
| boolean ok = Scope.push(context, (childContext) -> { |
| childContext.push(new TimingScope("UpdateVcs")); |
| return vcsSyncHandler.update(context, blazeRoots, executor); |
| }); |
| if (!ok) { |
| return null; |
| } |
| vcsWorkspacePathResolver = vcsSyncHandler.getWorkspacePathResolver(); |
| } |
| |
| WorkspacePathResolver workspacePathResolver = vcsWorkspacePathResolver != null |
| ? vcsWorkspacePathResolver |
| : new WorkspacePathResolverImpl(workspaceRoot, blazeRoots); |
| |
| ProjectViewSet projectViewSet = ProjectViewManager.getInstance(project).reloadProjectView(context, workspacePathResolver); |
| if (projectViewSet == null) { |
| return null; |
| } |
| |
| if (vcsSyncHandler != null) { |
| BlazeVcsHandler.BlazeVcsSyncHandler.ValidationResult validationResult = |
| vcsSyncHandler.validateProjectView(context, projectViewSet); |
| switch (validationResult) { |
| case OK: |
| // Fall-through and return |
| break; |
| case Error: |
| return null; |
| case RestartSync: |
| continue; |
| default: |
| // Cannot happen |
| return null; |
| } |
| } |
| |
| return new WorkspacePathResolverAndProjectView(workspacePathResolver, projectViewSet); |
| } |
| return null; |
| } |
| |
| private void printWorkingSet(BlazeContext context, WorkingSet workingSet) { |
| List<String> messages = Lists.newArrayList(); |
| messages.addAll(workingSet.addedFiles.stream().map(file -> file.relativePath() + " (added)").collect(Collectors.toList())); |
| messages.addAll(workingSet.modifiedFiles.stream().map(file -> file.relativePath() + " (modified)").collect(Collectors.toList())); |
| Collections.sort(messages); |
| |
| if (messages.isEmpty()) { |
| context.output(new PrintOutput("Your working set is empty")); |
| return; |
| } |
| int maxFiles = 20; |
| for (String message : Iterables.limit(messages, maxFiles)) { |
| context.output(new PrintOutput(" " + message)); |
| } |
| if (messages.size() > maxFiles) { |
| context.output(new PrintOutput(String.format(" (and %d more)", messages.size() - maxFiles))); |
| } |
| } |
| |
| private Collection<? extends TargetExpression> getWorkingSetTargets(WorkingSet workingSet) { |
| List<TargetExpression> result = Lists.newArrayList(); |
| for (WorkspacePath workspacePath : Iterables.concat(workingSet.addedFiles, workingSet.modifiedFiles)) { |
| File buildFile = workspaceRoot.fileForPath(workspacePath); |
| if (buildFile.getName().equals("BUILD")) { |
| result.add(TargetExpression.allFromPackageNonRecursive(workspaceRoot.workspacePathFor(buildFile.getParentFile()))); |
| } |
| } |
| return result; |
| } |
| |
| |
| private boolean updateProject(Project project, |
| BlazeContext parentContext, |
| ProjectViewSet projectViewSet, |
| @Nullable BlazeProjectData oldBlazeProjectData, |
| BlazeProjectData newBlazeProjectData) { |
| return Scope.push(parentContext, context -> { |
| context |
| .push(new LoggedTimingScope(project, Action.SYNC_IMPORT_DATA_TIME)) |
| .push(new TimingScope("UpdateProjectStructure")); |
| context.output(new StatusOutput("Committing project structure...")); |
| |
| return updateProject( |
| context, |
| importSettings, |
| projectViewSet, |
| oldBlazeProjectData, |
| newBlazeProjectData |
| ); |
| }); |
| } |
| |
| @Nullable |
| private BlazeIdeInterface.IdeResult getIdeQueryResult( |
| Project project, |
| BlazeContext parentContext, |
| ProjectViewSet projectViewSet, |
| List<TargetExpression> targets, |
| WorkspaceLanguageSettings workspaceLanguageSettings, |
| ArtifactLocationDecoder artifactLocationDecoder, |
| SyncState.Builder syncStateBuilder, |
| @Nullable SyncState previousSyncState, |
| boolean requiresAndroidSdk) { |
| |
| return Scope.push(parentContext, context -> { |
| context.push(new TimingScope("IdeQuery")); |
| |
| BlazeIdeInterface blazeIdeInterface = BlazeIdeInterface.getInstance(); |
| return blazeIdeInterface.updateBlazeIdeState( |
| project, |
| context, |
| workspaceRoot, |
| projectViewSet, |
| targets, |
| workspaceLanguageSettings, |
| artifactLocationDecoder, |
| syncStateBuilder, |
| previousSyncState, |
| requiresAndroidSdk |
| ); |
| }); |
| } |
| |
| private static boolean resolveIdeArtifacts( |
| Project project, |
| BlazeContext parentContext, |
| WorkspaceRoot workspaceRoot, |
| ProjectViewSet projectViewSet, |
| List<TargetExpression> targetExpressions) { |
| return Scope.push(parentContext, context -> { |
| context |
| .push(new LoggedTimingScope(project, Action.BLAZE_BUILD_DURING_SYNC)) |
| .push(new TimingScope("BlazeBuild")) |
| ; |
| context.output(new StatusOutput("Building project dependencies...")); |
| |
| // We don't want errors propagated for the build step - compilation errors shouldn't be interpreted |
| // as "Sync failed" |
| context.setPropagatesErrors(false); |
| |
| if (!targetExpressions.isEmpty()) { |
| BlazeIdeInterface blazeIdeInterface = BlazeIdeInterface.getInstance(); |
| blazeIdeInterface.resolveIdeArtifacts(project, context, workspaceRoot, projectViewSet, targetExpressions); |
| } |
| |
| return !context.hasErrors(); |
| }); |
| } |
| |
| private boolean updateProject( |
| BlazeContext context, |
| BlazeImportSettings importSettings, |
| ProjectViewSet projectViewSet, |
| @Nullable BlazeProjectData oldBlazeProjectData, |
| BlazeProjectData newBlazeProjectData) { |
| |
| try { |
| AsyncUtil.executeProjectChangeAction(() -> ProjectRootManagerEx.getInstanceEx(project).mergeRootsChangesDuring(() -> { |
| updateSdk( |
| context, |
| projectViewSet, |
| newBlazeProjectData |
| ); |
| updateProjectStructure( |
| context, |
| importSettings, |
| projectViewSet, |
| oldBlazeProjectData, |
| newBlazeProjectData |
| ); |
| })); |
| } catch (Throwable t) { |
| IssueOutput.error("Internal error. Please issue a bug at go/aswbbug. Error: " + t) |
| .submit(context); |
| LOG.error(t); |
| return false; |
| } |
| |
| BlazeProjectDataManagerImpl.getImpl(project).saveProject(importSettings, newBlazeProjectData); |
| return true; |
| } |
| |
| private void updateSdk(BlazeContext context, |
| ProjectViewSet projectViewSet, |
| BlazeProjectData newBlazeProjectData) { |
| for (BlazeSyncPlugin syncPlugin : BlazeSyncPlugin.EP_NAME.getExtensions()) { |
| syncPlugin.updateSdk(project, context, projectViewSet, newBlazeProjectData); |
| } |
| } |
| |
| private void updateProjectStructure( |
| BlazeContext context, |
| BlazeImportSettings importSettings, |
| ProjectViewSet projectViewSet, |
| @Nullable BlazeProjectData oldBlazeProjectData, |
| BlazeProjectData newBlazeProjectData) { |
| |
| ModuleEditorImpl moduleEditor = ModuleEditorProvider.getInstance().getModuleEditor(project, importSettings); |
| |
| ModuleType workspaceModuleType = null; |
| for (BlazeSyncPlugin syncPlugin : BlazeSyncPlugin.EP_NAME.getExtensions()) { |
| workspaceModuleType = syncPlugin.getWorkspaceModuleType(newBlazeProjectData.workspaceLanguageSettings.getWorkspaceType()); |
| if (workspaceModuleType != null) { |
| break; |
| } |
| } |
| if (workspaceModuleType == null) { |
| workspaceModuleType = ModuleType.EMPTY; |
| IssueOutput.warn("Could not set module type for workspace module.").submit(context); |
| } |
| |
| Module workspaceModule = moduleEditor.createModule(ModuleDataStorage.WORKSPACE_MODULE_NAME, workspaceModuleType); |
| ModifiableRootModel workspaceModifiableModel = moduleEditor.editModule(workspaceModule); |
| |
| ContentEntryEditor.createContentEntries( |
| project, |
| context, |
| workspaceRoot, |
| projectViewSet, |
| newBlazeProjectData, |
| workspaceModifiableModel |
| ); |
| |
| for (BlazeSyncPlugin blazeSyncPlugin : BlazeSyncPlugin.EP_NAME.getExtensions()) { |
| blazeSyncPlugin.updateProjectStructure( |
| project, |
| context, |
| workspaceRoot, |
| projectViewSet, |
| newBlazeProjectData, |
| oldBlazeProjectData, |
| moduleEditor, |
| workspaceModule, |
| workspaceModifiableModel); |
| } |
| |
| createProjectDataDirectoryModule(moduleEditor, new File(importSettings.getProjectDataDirectory()), workspaceModuleType); |
| |
| moduleEditor.commitWithGc(context); |
| } |
| |
| /** |
| * Creates a module that includes the user's data directory. |
| * |
| * This is useful to be able to edit the project view without IntelliJ complaining it's outside the project. |
| */ |
| private void createProjectDataDirectoryModule(ModuleEditor moduleEditor, |
| File projectDataDirectory, |
| ModuleType moduleType) { |
| Module module = moduleEditor.createModule(ModuleDataStorage.PROJECT_DATA_DIR_MODULE_NAME, moduleType); |
| ModifiableRootModel modifiableModel = moduleEditor.editModule(module); |
| ContentEntry rootContentEntry = modifiableModel.addContentEntry(pathToUrl(projectDataDirectory)); |
| rootContentEntry.addExcludeFolder(pathToUrl(new File(projectDataDirectory, ".idea"))); |
| rootContentEntry.addExcludeFolder(pathToUrl(new File(projectDataDirectory, ModuleDataStorage.DATA_SUBDIRECTORY))); |
| } |
| |
| private static String pathToUrl(File path) { |
| String filePath = FileUtil.toSystemIndependentName(path.getPath()); |
| return VirtualFileManager.constructUrl(StandardFileSystems.FILE_PROTOCOL, filePath); |
| } |
| |
| private static void onSyncStart(Project project) { |
| final SyncListener[] syncListeners = SyncListener.EP_NAME.getExtensions(); |
| for (SyncListener syncListener : syncListeners) { |
| syncListener.onSyncStart(project); |
| } |
| } |
| |
| private static void afterSync(Project project, |
| boolean successful) { |
| final SyncListener[] syncListeners = SyncListener.EP_NAME.getExtensions(); |
| for (SyncListener syncListener : syncListeners) { |
| syncListener.afterSync(project, successful); |
| } |
| } |
| |
| private void onSyncComplete(Project project, |
| BlazeContext context, |
| ProjectViewSet projectViewSet, |
| BlazeProjectData blazeProjectData) { |
| validate(project, context, blazeProjectData); |
| |
| final SyncListener[] syncListeners = SyncListener.EP_NAME.getExtensions(); |
| for (SyncListener syncListener : syncListeners) { |
| syncListener.onSyncComplete( |
| project, |
| importSettings, |
| projectViewSet, |
| blazeProjectData |
| ); |
| } |
| } |
| |
| private static void validate( |
| Project project, |
| BlazeContext context, |
| BlazeProjectData blazeProjectData) { |
| for (BlazeSyncPlugin syncPlugin : BlazeSyncPlugin.EP_NAME.getExtensions()) { |
| syncPlugin.validate(project, context, blazeProjectData); |
| } |
| } |
| } |
