| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you 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 org.netbeans.modules.java.j2semodule; |
| |
| import java.beans.PropertyChangeEvent; |
| import java.beans.PropertyChangeListener; |
| import java.io.IOException; |
| import java.net.URL; |
| import java.util.Collection; |
| import java.util.Optional; |
| import java.util.concurrent.atomic.AtomicInteger; |
| import java.util.logging.Level; |
| import java.util.logging.Logger; |
| import javax.lang.model.element.TypeElement; |
| import javax.swing.SwingUtilities; |
| import org.netbeans.api.annotations.common.NonNull; |
| import org.netbeans.api.java.classpath.ClassPath; |
| import org.netbeans.api.java.classpath.JavaClassPathConstants; |
| import org.netbeans.api.java.platform.JavaPlatformManager; |
| import org.netbeans.api.java.source.*; |
| import org.netbeans.api.project.Project; |
| import org.netbeans.api.project.ProjectManager; |
| import org.netbeans.modules.java.api.common.SourceRoots; |
| import org.netbeans.modules.java.api.common.ant.UpdateHelper; |
| import org.netbeans.modules.java.api.common.project.ProjectProperties; |
| import org.netbeans.spi.java.classpath.support.ClassPathSupport; |
| import org.netbeans.spi.project.support.ant.AntProjectHelper; |
| import org.netbeans.spi.project.support.ant.EditableProperties; |
| import org.netbeans.spi.project.support.ant.PropertyEvaluator; |
| import org.openide.filesystems.FileChangeAdapter; |
| import org.openide.filesystems.FileChangeListener; |
| import org.openide.filesystems.FileObject; |
| import org.openide.filesystems.FileRenameEvent; |
| import org.openide.filesystems.FileUtil; |
| import org.openide.loaders.DataObject; |
| import org.openide.util.Exceptions; |
| import org.openide.util.Mutex; |
| import org.openide.util.MutexException; |
| import org.openide.util.RequestProcessor; |
| import org.openide.util.WeakListeners; |
| |
| /** |
| * |
| * @author Tomas Zezula |
| */ |
| final class MainClassUpdater extends FileChangeAdapter implements PropertyChangeListener { |
| |
| private static final RequestProcessor RP = new RequestProcessor ("main-class-updater",1); //NOI18N |
| private static final Logger LOG = Logger.getLogger(MainClassUpdater.class.getName()); |
| private static final int NEW = 0; |
| private static final int STARTED = 1; |
| private static final int FINISHED = 2; |
| |
| private final Project project; |
| private final PropertyEvaluator eval; |
| private final UpdateHelper helper; |
| private final SourceRoots sourceRoots; |
| private final String mainClassPropName; |
| private final AtomicInteger state; |
| //@GuardedBy("this") |
| private FileObject currentFo; |
| //@GuardedBy("this") |
| private DataObject currentDo; |
| //@GuardedBy("this") |
| private FileChangeListener foListener; |
| //@GuardedBy("this") |
| private PropertyChangeListener doListener; |
| //@GuardedBy("this") |
| private long lc = 0; |
| |
| /** Creates a new instance of MainClassUpdater */ |
| MainClassUpdater( |
| @NonNull final Project project, |
| @NonNull final PropertyEvaluator eval, |
| @NonNull final UpdateHelper helper, |
| @NonNull final SourceRoots sourceRoots, |
| @NonNull final String mainClassPropName) { |
| assert project != null; |
| assert eval != null; |
| assert helper != null; |
| assert sourceRoots != null; |
| assert mainClassPropName != null; |
| this.project = project; |
| this.eval = eval; |
| this.helper = helper; |
| this.sourceRoots = sourceRoots; |
| this.mainClassPropName = mainClassPropName; |
| this.state = new AtomicInteger(NEW); |
| } |
| |
| void start () { |
| RP.submit(() -> { |
| if (state.compareAndSet(NEW, STARTED)) { |
| eval.addPropertyChangeListener(MainClassUpdater.this); |
| addFileChangeListener (); |
| } else { |
| throw new IllegalStateException("Current State: " + state.get()); //NOI18N |
| } |
| }); |
| } |
| |
| public void stop() { |
| RP.submit(() -> { |
| if (state.compareAndSet(STARTED, FINISHED)) { |
| synchronized (MainClassUpdater.this) { |
| if (currentFo != null && foListener != null) { |
| currentFo.removeFileChangeListener(foListener); |
| } |
| if (currentDo != null && doListener != null) { |
| currentDo.removePropertyChangeListener(doListener); |
| } |
| } |
| } else { |
| throw new IllegalStateException("Current State: " + state.get()); //NOI18N |
| } |
| }); |
| } |
| |
| @Override |
| public void propertyChange(PropertyChangeEvent evt) { |
| if (DataObject.PROP_PRIMARY_FILE.equals(evt.getPropertyName())) { |
| final FileObject newFile = (FileObject) evt.getNewValue(); |
| final FileObject oldFile = (FileObject) evt.getOldValue(); |
| handleMainClassMoved(oldFile, newFile); |
| } else if (this.mainClassPropName.equals(evt.getPropertyName())) { |
| //Go out of the ProjectManager.MUTEX, see #118722 |
| RP.post(MainClassUpdater.this::addFileChangeListener); |
| } |
| } |
| |
| @Override |
| public void fileRenamed (final FileRenameEvent evt) { |
| handleMainClassMoved(evt.getFile(), evt.getFile()); |
| } |
| |
| private void handleMainClassMoved(final FileObject oldFile, final FileObject newFile) { |
| if (!project.getProjectDirectory().isValid()) { |
| return; |
| } |
| final FileObject _current; |
| synchronized (this) { |
| _current = this.currentFo; |
| } |
| if (oldFile == _current) { |
| Runnable r = () -> { |
| try { |
| final String oldMainClass = ProjectManager.mutex().readAccess((Mutex.ExceptionAction<String>) () -> eval.getProperty(mainClassPropName)); |
| Collection<ElementHandle<TypeElement>> main = SourceUtils.getMainClasses(newFile); |
| String newMainClass = null; |
| if (!main.isEmpty()) { |
| ElementHandle<TypeElement> mainHandle = main.iterator().next(); |
| newMainClass = mainHandle.getQualifiedName(); |
| } |
| if (newMainClass != null && !newMainClass.equals(oldMainClass) && helper.requestUpdate() && |
| // XXX ##84806: ideally should update nbproject/configs/*.properties in this case: |
| eval.getProperty(ProjectProperties.PROP_PROJECT_CONFIGURATION_CONFIG) == null) { |
| final String newMainClassFinal = newMainClass; |
| ProjectManager.mutex().writeAccess((Mutex.ExceptionAction<Void>) () -> { |
| EditableProperties props = helper.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH); |
| props.put (mainClassPropName, newMainClassFinal); |
| helper.putProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH, props); |
| ProjectManager.getDefault().saveProject (project); |
| return null; |
| }); |
| } |
| } catch (IOException | MutexException e) { |
| Exceptions.printStackTrace(e); |
| } |
| }; |
| if (SwingUtilities.isEventDispatchThread()) { |
| r.run(); |
| } else { |
| SwingUtilities.invokeLater(r); |
| } |
| } |
| } |
| |
| private void addFileChangeListener () { |
| final long clc; |
| synchronized (MainClassUpdater.this) { |
| if (currentFo != null && foListener != null) { |
| currentFo.removeFileChangeListener(foListener); |
| foListener = null; |
| currentFo = null; |
| } |
| if (currentDo != null && doListener != null) { |
| currentDo.removePropertyChangeListener(doListener); |
| doListener = null; |
| currentDo = null; |
| } |
| clc = ++lc; |
| } |
| final String mainClassName = eval.getProperty(mainClassPropName); |
| if (mainClassName != null) { |
| FileObject[] roots = sourceRoots.getRoots(); |
| if (roots.length>0) { |
| final ClassPath bootCp = Optional.ofNullable(ClassPath.getClassPath(roots[0], ClassPath.BOOT)) |
| .orElse(JavaPlatformManager.getDefault().getDefaultPlatform().getBootstrapLibraries()); |
| final ClassPath compileCp = Optional.ofNullable(ClassPath.getClassPath(roots[0], ClassPath.COMPILE)) |
| .orElse(ClassPath.EMPTY); |
| final ClassPath systemModules = ClassPath.getClassPath(roots[0], JavaClassPathConstants.MODULE_BOOT_PATH); |
| final ClassPath modulePath = ClassPath.getClassPath(roots[0], JavaClassPathConstants.MODULE_COMPILE_PATH); |
| final ClassPath allUnnamed = ClassPath.getClassPath(roots[0], JavaClassPathConstants.MODULE_CLASS_PATH); |
| final ClassPath moduleSourcePath = ClassPath.getClassPath(roots[0], JavaClassPathConstants.MODULE_SOURCE_PATH); |
| final ClasspathInfo cpInfo = new ClasspathInfo.Builder(bootCp) |
| .setClassPath(compileCp) |
| .setModuleBootPath(systemModules) |
| .setModuleCompilePath(modulePath) |
| .setModuleClassPath(allUnnamed) |
| .setModuleSourcePath(moduleSourcePath) |
| .build(); |
| final JavaSource js = JavaSource.create(cpInfo); |
| // execute immediately, or delay if cannot find main class |
| ScanUtils.postUserActionTask(js, (CompilationController c) -> { |
| c.toPhase(JavaSource.Phase.ELEMENTS_RESOLVED); |
| TypeElement te = ScanUtils.checkElement(c, c.getElements().getTypeElement(mainClassName)); |
| if (te != null) { |
| final ClassPath allSources = ClassPathSupport.createClassPath(roots); |
| final FileObject fo = SourceUtils.getFile( |
| te, |
| new ClasspathInfo.Builder(bootCp) |
| .setClassPath(compileCp) |
| .setSourcePath(allSources) |
| .setModuleBootPath(systemModules) |
| .setModuleCompilePath(modulePath) |
| .setModuleClassPath(allUnnamed) |
| .setModuleSourcePath(moduleSourcePath) |
| .build()); |
| final boolean owned = allSources.contains(fo); |
| synchronized (MainClassUpdater.this) { |
| if (lc == clc && fo != null && owned) { |
| currentFo = fo; |
| foListener = WeakListeners.create(FileChangeListener.class, MainClassUpdater.this, currentFo); |
| currentFo.addFileChangeListener(foListener); |
| currentDo = DataObject.find(currentFo); |
| doListener = org.openide.util.WeakListeners.propertyChange(MainClassUpdater.this, currentDo); |
| currentDo.addPropertyChangeListener(doListener); |
| } |
| } |
| } |
| }); |
| } |
| } |
| } |
| } |
