Attachment #101467 for bug #186024

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 186024
Collapse All | Expand All




 * Portions Copyrighted 2008 Sun Microsystems, Inc.
 */

package org.netbeans.modules.maven;

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.io.File;
import java.net.URI;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.event.ChangeListener;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.repository.ArtifactRepository;
import org.netbeans.api.project.FileOwnerQuery;
import org.netbeans.api.project.ProjectManager;
import org.netbeans.spi.project.FileOwnerQueryImplementation;
import org.netbeans.spi.project.SubprojectProvider;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;
import org.openide.util.ChangeSupport;
import org.openide.util.Lookup;
import org.openide.util.Mutex.Action;
import org.openide.util.lookup.ServiceProvider;


/**
 * Links the Maven project with its artifact in the local repository.
 * and it's artifact in the maven repository. any other files shall be handled by the
 * default netbeans implementation.
 *
 * @author  Milos Kleint
 */
public class MavenFileOwner {
public class MavenFileOwnerQueryImpl implements FileOwnerQueryImplementation {
    
    private final PropertyChangeListener projectListener;
    private final Object setLock = new Object();

    private Set<NbMavenProjectImpl> cachedProjects;
    private Set<NbMavenProjectImpl> projectsToAddToCache;
    private final Object cacheLock = new Object();

    private PropertyChangeListener projectListener;
    private final ChangeSupport cs = new ChangeSupport(this);

    private static final Logger LOG = Logger.getLogger(MavenFileOwner.class.getName());
    
    private MavenFileOwner() {
        set = new HashSet<NbMavenProjectImpl>();
        cachedProjects = null;
        projectsToAddToCache = null;
        projectListener = new PropertyChangeListener() {
            public @Override void propertyChange(PropertyChangeEvent evt) {
                if (NbMavenProjectImpl.PROP_PROJECT.equals(evt.getPropertyName())) {
                    fireChange();
                    if (evtSource instanceof NbMavenProjectImpl) {
                        // try adding the changed project and its subprojects again to cache
                        // new subprojects might have been added/activated for the changed project
                        synchronized (cacheLock) {
                            if (null == projectsToAddToCache) {
                                projectsToAddToCache = new HashSet<NbMavenProjectImpl>(1);
                            }
                            projectsToAddToCache.add((NbMavenProjectImpl) evtSource);
                        }
                    }
                }
            }
        };
    }

    private static final MavenFileOwner IMPL = new MavenFileOwner();
    public static MavenFileOwner getInstance() {
        return IMPL;
        Iterator<? extends FileOwnerQueryImplementation> it = implementations.allInstances().iterator();
        while (it.hasNext()) {
            FileOwnerQueryImplementation obj = it.next();
            if (obj instanceof MavenFileOwnerQueryImpl) {
                return (MavenFileOwnerQueryImpl)obj;
            }
        }
        return null;
    }
    
    public void addMavenProject(NbMavenProjectImpl project) {
        Artifact art = project.getOriginalMavenProject().getArtifact();
        if (art != null) {
            File f = art.getFile();
            if (f == null) { // XXX seems to be the normal case - why?
                ArtifactRepository repo = project.getEmbedder().getLocalRepository();
                f = new File(repo.getBasedir(), repo.pathOf(art));
            }
            File allArtifacts = FileUtil.normalizeFile(f.getParentFile());
            LOG.log(Level.FINE, "registering {0} for {1}", new Object[] {allArtifacts, art});
            FileOwnerQuery.markExternalOwner(allArtifacts.toURI(), project, FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
            // Also claim other versions, though another project with that exact version might override you:
            FileOwnerQuery.markExternalOwner(allArtifacts.getParentFile().toURI(), project, FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
        } else {
            LOG.log(Level.WARNING, "no artifact for {0}", project);
        }
        project.getProjectWatcher().removePropertyChangeListener(projectListener);
        project.getProjectWatcher().addPropertyChangeListener(projectListener);
            // added to cache already from "set" where we added it just above
            if (null != cachedProjects && !cachedProjects.contains(project)) {
                if (null == projectsToAddToCache) {
                    projectsToAddToCache = new HashSet<NbMavenProjectImpl>(1);
                }
                projectsToAddToCache.add(project);
            }
        }
        
        fireChange();
    }
    public void removeMavenProject(NbMavenProjectImpl project) {
        synchronized (setLock) {
            if (set.contains(project)) {
                LOG.log(Level.FINE, "Removing Maven project:{0}", project.getArtifactRelativeRepositoryPath());
                set.remove(project);
                NbMavenProject.removePropertyChangeListener(project, projectListener);
            }
        }
        synchronized (cacheLock) {
            cachedProjects = null;
        }
        fireChange();
    }
    

        cs.fireChange();
    }
    
    /**
     * get the list of currently opened maven projects.. kind of hack, but well..
     */
    public Set<Project> getOpenedProjects() {
        synchronized (setLock) {
            return new HashSet<Project>(set);
        }
    }
    
    public @Override Project getOwner(URI uri) {
        LOG.log(Level.FINEST, "getOwner of uri={0}", uri);
        if (uri.getScheme() != null && "file".equals(uri.getScheme())) { //NOI18N
            File file = new File(uri);
            return getOwner(file);
        }
        return null;
    }
    
    public @Override Project getOwner(FileObject fileObject) {
        LOG.log(Level.FINEST, "getOwner of fileobject={0}", fileObject);
        File file = FileUtil.toFile(fileObject);
        if (file != null) {
            //logger.fatal("getOwner of fileobject=" + fileObject.getNameExt());
            return getOwner(file);
        }
        return null;
    }
    
    private Project getOwner(File file) {
        //TODO check if the file is from local repo ??
        LOG.log(Level.FINE, "Looking for owner of {0}", file);
        boolean passBasicCheck = false;
        String nm = file.getName();
        File parentVer = file.getParentFile();
        if (parentVer != null) {
            File parentArt = parentVer.getParentFile();
            if (parentArt != null) {
                if (nm.startsWith(parentArt.getName() + "-" + parentVer.getName())) {
                    passBasicCheck = true;
                }
            }
        }
        if (!passBasicCheck) {
            LOG.fine(" exiting early, not from local repository.");
            return null;
        }
        Set<NbMavenProjectImpl> currentProjects = getAllKnownProjects();
        
        Iterator<NbMavenProjectImpl> it = currentProjects.iterator();
        String filepath = file.getAbsolutePath().replace('\\', '/');
        while (it.hasNext()) {
            NbMavenProjectImpl project = it.next();
            String path = project.getArtifactRelativeRepositoryPath();
            LOG.log(Level.FINEST, "matching againts known project {0}", path);
            if (filepath.endsWith(path)) {
                return project;
            }
            path = project.getTestArtifactRelativeRepositoryPath();
            LOG.log(Level.FINEST, "matching againts known project''s test {0}", path);
            if (filepath.endsWith(path)) {
                return project;
            }
        }
        return null;
        
    }
    
     
    private Set<NbMavenProjectImpl> getAllKnownProjects() {
        return ProjectManager.mutex().readAccess(new Action<Set<NbMavenProjectImpl>>() {
            public @Override Set<NbMavenProjectImpl> run() {
                synchronized (cacheLock) {
                    // is cachedProjects up-to-date?
                    if (cachedProjects != null && null == projectsToAddToCache) {
                        return new HashSet<NbMavenProjectImpl>(cachedProjects);
                    }
                    // cachedProjects empty?
                    if (null == cachedProjects) {
                        // full build of the cache
                        Set<NbMavenProjectImpl> currentProjects;
                        List<NbMavenProjectImpl> iterating;
                        synchronized (setLock) {
                            currentProjects = new HashSet<NbMavenProjectImpl>(set);
                            iterating = new ArrayList<NbMavenProjectImpl>(set);
                        }
                        int index = 0;
                        // iterate all opened projects and figure their subprojects..
                        // consider these as well. do so recursively.
                        while (index < iterating.size()) {
                            NbMavenProjectImpl prj = iterating.get(index);
                            addSubProjects(currentProjects, iterating, prj);
                            index = index + 1;
                        }
                        cachedProjects = currentProjects;
                        projectsToAddToCache = null;
                    }
                    // non-empty projectsToAddToCache?
                    if (null != projectsToAddToCache) {
                        // incrementally adding to the cache
                        Set<NbMavenProjectImpl> currentProjects;
                        List<NbMavenProjectImpl> iterating;
                        currentProjects = new HashSet<NbMavenProjectImpl>(cachedProjects);
                        currentProjects.addAll(projectsToAddToCache);
                        iterating = new ArrayList<NbMavenProjectImpl>(projectsToAddToCache);
                        int index = 0;
                        // iterate all new or changed (after propChange) projects
                        // and figure their subprojects..
                        // consider these as well. do so recursively.
                        while (index < iterating.size()) {
                            NbMavenProjectImpl prj = iterating.get(index);
                            addSubProjects(currentProjects, iterating, prj);
                            index = index + 1;
                        }
                        cachedProjects = currentProjects;
                        projectsToAddToCache = null;
                    }
                    return new HashSet<NbMavenProjectImpl>(cachedProjects);
                }
            }
        });
    }

    private void addSubProjects(Set<NbMavenProjectImpl> finalset, List<NbMavenProjectImpl> iteratinglist, NbMavenProjectImpl prj) {
        SubprojectProvider sub = prj.getLookup().lookup(SubprojectProvider.class);
        if (sub != null) {
            Set<? extends Project> subs = sub.getSubprojects();
            for (Project p : subs) {
                if (p instanceof NbMavenProjectImpl) {
                    finalset.add((NbMavenProjectImpl) p);
                    if (!iteratinglist.contains((NbMavenProjectImpl)p)) {
                        iteratinglist.add((NbMavenProjectImpl) p);
                    }
                }
            }
        }
    }
}




import java.util.logging.Logger;
import java.util.prefs.Preferences;
import org.netbeans.modules.maven.classpath.ClassPathProviderImpl;
import org.netbeans.modules.maven.queries.MavenFileOwnerQueryImpl;
import org.netbeans.api.java.classpath.ClassPath;
import org.netbeans.api.java.classpath.GlobalPathRegistry;
import org.netbeans.api.project.FileOwnerQuery;

import org.netbeans.modules.maven.api.NbMavenProject;
import org.netbeans.modules.maven.options.MavenSettings;
import org.netbeans.spi.project.ui.ProjectOpenedHook;
import org.openide.ErrorManager;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;
import org.openide.util.Exceptions;

        checkSourceDownloads();
        checkJavadocDownloads();
        attachUpdater();
        MavenFileOwner.getInstance().addMavenProject(project);
        if (q != null) {
            q.addMavenProject(project);
        } else {
            ErrorManager.getDefault().log("MavenFileOwnerQueryImpl not found..");  //NOI18N
        }
        Set<URI> uris = new HashSet<URI>();
        uris.addAll(Arrays.asList(project.getSourceRoots(false)));
        uris.addAll(Arrays.asList(project.getSourceRoots(true)));

    
    protected void projectClosed() {
        uriReferences.clear();
        MavenFileOwnerQueryImpl q = MavenFileOwnerQueryImpl.getInstance();
        if (q != null) {
            q.removeMavenProject(project);
        } else {
            ErrorManager.getDefault().log("MavenFileOwnerQueryImpl not found.."); //NOI18N
        }
        detachUpdater();
        // unregister project's classpaths to GlobalPathRegistry
        ClassPathProviderImpl cpProvider = project.getLookup().lookup(org.netbeans.modules.maven.classpath.ClassPathProviderImpl.class);




import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import org.apache.maven.artifact.Artifact;
import org.netbeans.api.project.FileOwnerQuery;
import org.netbeans.modules.maven.api.NbMavenProject;
import org.netbeans.modules.maven.queries.MavenFileOwnerQueryImpl;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectManager;
import org.netbeans.spi.project.SubprojectProvider;

                fireChange();
            }
        };
        MavenFileOwner.getInstance().addChangeListener(WeakListeners.change(listener2, MavenFileOwner.getInstance()));
                WeakListeners.change(listener2,
                MavenFileOwnerQueryImpl.getInstance()));
    }



            // can be interrupted in the open project dialog..
            return Collections.emptySet();
        }
        addKnownOwners(projects);
        projects.remove(project);
        return projects;
    }

    private void addKnownOwners(Set<Project> resultset) {
        Set<Project> opened = MavenFileOwnerQueryImpl.getInstance().getOpenedProjects();
        @SuppressWarnings("unchecked")
        List<Artifact> compileArtifacts = project.getOriginalMavenProject().getCompileArtifacts();
        List<String> artPaths = new ArrayList<String>();
        for (Artifact ar : compileArtifacts) {
            File f = ar.getFile();
            if (f != null) {
                Project p = FileOwnerQuery.getOwner(f.toURI());
                if (p != null) {
                    resultset.add(p);
                }
            }
        }
    }




import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.Icon;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.ArtifactUtils;
import org.apache.maven.artifact.resolver.ArtifactNotFoundException;

import org.netbeans.modules.maven.api.CommonArtifactActions;
import org.netbeans.modules.maven.api.NbMavenProject;
import org.netbeans.modules.maven.embedder.NbArtifact;
import org.netbeans.modules.maven.queries.MavenFileOwnerQueryImpl;
import hidden.org.codehaus.plexus.util.FileUtils;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import org.apache.maven.model.Dependency;
import org.apache.maven.model.DependencyManagement;
import org.netbeans.api.java.queries.JavadocForBinaryQuery;
import org.netbeans.api.java.queries.SourceForBinaryQuery;
import org.netbeans.api.progress.aggregate.ProgressContributor;
import org.netbeans.api.project.FileOwnerQuery;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.SourceGroup;
import org.netbeans.api.project.ui.OpenProjects;
import org.netbeans.modules.maven.MavenFileOwner;
import org.netbeans.modules.maven.dependencies.DependencyExcludeNodeVisitor;
import org.netbeans.modules.maven.embedder.DependencyTreeFactory;
import org.netbeans.modules.maven.dependencies.ExcludeDependencyPanel;

                }
            };
            //TODO check if this one is a performance bottleneck.
            MavenFileOwner.getInstance().addChangeListener(WeakListeners.change(listener2, MavenFileOwner.getInstance()));
                    WeakListeners.change(listener2,
                    MavenFileOwnerQueryImpl.getInstance()));
        }
        setDisplayName(createName());
        setIconBase(false);

    }

    private void setIconBase(boolean longLiving) {
        if (longLiving && isDependencyProjectAvailable()) {
            if (isTransitive()) {
                setIconBaseWithExtension("org/netbeans/modules/maven/TransitiveMaven2Icon.gif"); //NOI18N
            } else {

     * this call is slow
     * @return
     */
    private boolean isDependencyProjectAvailable() {
        if ( Artifact.SCOPE_SYSTEM.equals(art.getScope())) {
            return false;
        }
        URI uri = art.getFile().toURI();
        Project depPrj = FileOwnerQuery.getOwner(uri);
//        URI uri = rootUri.create(rootUri.toString() + "/" + project.getArtifactRelativeRepositoryPath(art));
        Project depPrj = MavenFileOwnerQueryImpl.getInstance().getOwner(uri);
        return depPrj != null;
    }


    @SuppressWarnings("unchecked")
    public Action[] getActions(boolean context) {
        Collection<Action> acts = new ArrayList<Action>();
        if (longLiving && isDependencyProjectAvailable()) {
            acts.add(OpenProjectAction.SINGLETON);
        }
        if (isAddedToCP()) {
            InstallLocalArtifactAction act = new InstallLocalArtifactAction();
            acts.add(act);

            }
        }
    }

    private static class OpenProjectAction extends AbstractAction implements ContextAwareAction {

        static final OpenProjectAction SINGLETON = new OpenProjectAction();

        private OpenProjectAction() {}

        public @Override void actionPerformed(ActionEvent e) {
            assert false;
        }

        public @Override Action createContextAwareInstance(final Lookup context) {
            return new AbstractAction(NbBundle.getMessage(ModulesNode.class, "BTN_Open_Project")) {
                public @Override void actionPerformed(ActionEvent e) {
                    Set<Project> projects = new HashSet<Project>();
                    for (Artifact art : context.lookupAll(Artifact.class)) {
                        projects.add(FileOwnerQuery.getOwner(art.getFile().toURI()));
                    }
                    projects.remove(null);
                    OpenProjects.getDefault().open(projects.toArray(new NbMavenProjectImpl[projects.size()]), false, true);
                }
            };
        }
    }

}

Return to bug 186024

Lines 54-61 Link Here

(-)a/maven/src/org/netbeans/modules/maven/SubprojectProviderImpl.java (-14 / +10 lines)
54	import javax.swing.event.ChangeEvent;	54	import javax.swing.event.ChangeEvent;
55	import javax.swing.event.ChangeListener;	55	import javax.swing.event.ChangeListener;
56	import org.apache.maven.artifact.Artifact;	56	import org.apache.maven.artifact.Artifact;
		57	import org.netbeans.api.project.FileOwnerQuery;
57	import org.netbeans.modules.maven.api.NbMavenProject;	58	import org.netbeans.modules.maven.api.NbMavenProject;
58	import org.netbeans.modules.maven.queries.MavenFileOwnerQueryImpl;
59	import org.netbeans.api.project.Project;	59	import org.netbeans.api.project.Project;
60	import org.netbeans.api.project.ProjectManager;	60	import org.netbeans.api.project.ProjectManager;
61	import org.netbeans.spi.project.SubprojectProvider;	61	import org.netbeans.spi.project.SubprojectProvider;
Lines 94-102 Link Here
94	fireChange();	94	fireChange();
95	}	95	}
96	};	96	};
97	MavenFileOwnerQueryImpl.getInstance().addChangeListener(	97	MavenFileOwner.getInstance().addChangeListener(WeakListeners.change(listener2, MavenFileOwner.getInstance()));
98	WeakListeners.change(listener2,
99	MavenFileOwnerQueryImpl.getInstance()));
100	}	98	}
101		99
102		100
Lines 109-131 Link Here
109	// can be interrupted in the open project dialog..	107	// can be interrupted in the open project dialog..
110	return Collections.emptySet();	108	return Collections.emptySet();
111	}	109	}
112	addOpenedCandidates(projects);	110	addKnownOwners(projects);
113	projects.remove(project);	111	projects.remove(project);
114	return projects;	112	return projects;
115	}	113	}
116		114
117	private void addOpenedCandidates(Set<Project> resultset) {	115	private void addKnownOwners(Set<Project> resultset) {
118	Set<Project> opened = MavenFileOwnerQueryImpl.getInstance().getOpenedProjects();
119	@SuppressWarnings("unchecked")	116	@SuppressWarnings("unchecked")
120	List<Artifact> compileArtifacts = project.getOriginalMavenProject().getCompileArtifacts();	117	List<Artifact> compileArtifacts = project.getOriginalMavenProject().getCompileArtifacts();
121	List<String> artPaths = new ArrayList<String>();
122	for (Artifact ar : compileArtifacts) {	118	for (Artifact ar : compileArtifacts) {
123	artPaths.add(project.getArtifactRelativeRepositoryPath(ar));	119	File f = ar.getFile();
124	}	120	if (f != null) {
125	for (Project prj : opened) {	121	Project p = FileOwnerQuery.getOwner(f.toURI());
126	String prjpath = ((NbMavenProjectImpl)prj).getArtifactRelativeRepositoryPath();	122	if (p != null) {
127	if (artPaths.contains(prjpath)) {	123	resultset.add(p);
128	resultset.add(prj);	124	}
129	}	125	}
130	}	126	}
131	}	127	}

Lines 59-66 Link Here

(-)a/maven/src/org/netbeans/modules/maven/nodes/DependencyNode.java (-11 / +37 lines)
59	import javax.swing.AbstractAction;	59	import javax.swing.AbstractAction;
60	import javax.swing.Action;	60	import javax.swing.Action;
61	import javax.swing.Icon;	61	import javax.swing.Icon;
62	import javax.swing.event.ChangeEvent;
63	import javax.swing.event.ChangeListener;
64	import org.apache.maven.artifact.Artifact;	62	import org.apache.maven.artifact.Artifact;
65	import org.apache.maven.artifact.ArtifactUtils;	63	import org.apache.maven.artifact.ArtifactUtils;
66	import org.apache.maven.artifact.resolver.ArtifactNotFoundException;	64	import org.apache.maven.artifact.resolver.ArtifactNotFoundException;
Lines 71-88 Link Here
71	import org.netbeans.modules.maven.api.CommonArtifactActions;	69	import org.netbeans.modules.maven.api.CommonArtifactActions;
72	import org.netbeans.modules.maven.api.NbMavenProject;	70	import org.netbeans.modules.maven.api.NbMavenProject;
73	import org.netbeans.modules.maven.embedder.NbArtifact;	71	import org.netbeans.modules.maven.embedder.NbArtifact;
74	import org.netbeans.modules.maven.queries.MavenFileOwnerQueryImpl;
75	import hidden.org.codehaus.plexus.util.FileUtils;	72	import hidden.org.codehaus.plexus.util.FileUtils;
76	import java.util.Collections;	73	import java.util.Collections;
77	import java.util.HashSet;	74	import java.util.HashSet;
78	import java.util.Set;	75	import java.util.Set;
		76	import javax.swing.event.ChangeEvent;
		77	import javax.swing.event.ChangeListener;
79	import org.apache.maven.model.Dependency;	78	import org.apache.maven.model.Dependency;
80	import org.apache.maven.model.DependencyManagement;	79	import org.apache.maven.model.DependencyManagement;
81	import org.netbeans.api.java.queries.JavadocForBinaryQuery;	80	import org.netbeans.api.java.queries.JavadocForBinaryQuery;
82	import org.netbeans.api.java.queries.SourceForBinaryQuery;	81	import org.netbeans.api.java.queries.SourceForBinaryQuery;
83	import org.netbeans.api.progress.aggregate.ProgressContributor;	82	import org.netbeans.api.progress.aggregate.ProgressContributor;
		83	import org.netbeans.api.project.FileOwnerQuery;
84	import org.netbeans.api.project.Project;	84	import org.netbeans.api.project.Project;
85	import org.netbeans.api.project.SourceGroup;	85	import org.netbeans.api.project.SourceGroup;
		86	import org.netbeans.api.project.ui.OpenProjects;
		87	import org.netbeans.modules.maven.MavenFileOwner;
86	import org.netbeans.modules.maven.dependencies.DependencyExcludeNodeVisitor;	88	import org.netbeans.modules.maven.dependencies.DependencyExcludeNodeVisitor;
87	import org.netbeans.modules.maven.embedder.DependencyTreeFactory;	89	import org.netbeans.modules.maven.embedder.DependencyTreeFactory;
88	import org.netbeans.modules.maven.dependencies.ExcludeDependencyPanel;	90	import org.netbeans.modules.maven.dependencies.ExcludeDependencyPanel;
Lines 191-199 Link Here
191	}	193	}
192	};	194	};
193	//TODO check if this one is a performance bottleneck.	195	//TODO check if this one is a performance bottleneck.
194	MavenFileOwnerQueryImpl.getInstance().addChangeListener(	196	MavenFileOwner.getInstance().addChangeListener(WeakListeners.change(listener2, MavenFileOwner.getInstance()));
195	WeakListeners.change(listener2,
196	MavenFileOwnerQueryImpl.getInstance()));
197	}	197	}
198	setDisplayName(createName());	198	setDisplayName(createName());
199	setIconBase(false);	199	setIconBase(false);
Lines 230-236 Link Here
230	}	230	}
231		231
232	private void setIconBase(boolean longLiving) {	232	private void setIconBase(boolean longLiving) {
233	if (longLiving && isDependencyProjectOpen()) {	233	if (longLiving && isDependencyProjectAvailable()) {
234	if (isTransitive()) {	234	if (isTransitive()) {
235	setIconBaseWithExtension("org/netbeans/modules/maven/TransitiveMaven2Icon.gif"); //NOI18N	235	setIconBaseWithExtension("org/netbeans/modules/maven/TransitiveMaven2Icon.gif"); //NOI18N
236	} else {	236	} else {
Lines 272-285 Link Here
272	* this call is slow	272	* this call is slow
273	* @return	273	* @return
274	*/	274	*/
275	boolean isDependencyProjectOpen() {	275	private boolean isDependencyProjectAvailable() {
276	if ( Artifact.SCOPE_SYSTEM.equals(art.getScope())) {	276	if ( Artifact.SCOPE_SYSTEM.equals(art.getScope())) {
277	return false;	277	return false;
278	}	278	}
279	URI uri = art.getFile().toURI();	279	URI uri = art.getFile().toURI();
280	// URI rootUri = project.getRepositoryRoot().getURL().toURI();	280	Project depPrj = FileOwnerQuery.getOwner(uri);
281	// URI uri = rootUri.create(rootUri.toString() + "/" + project.getArtifactRelativeRepositoryPath(art));
282	Project depPrj = MavenFileOwnerQueryImpl.getInstance().getOwner(uri);
283	return depPrj != null;	281	return depPrj != null;
284	}	282	}
285		283
Lines 329-334 Link Here
329	@SuppressWarnings("unchecked")	327	@SuppressWarnings("unchecked")
330	public Action[] getActions(boolean context) {	328	public Action[] getActions(boolean context) {
331	Collection<Action> acts = new ArrayList<Action>();	329	Collection<Action> acts = new ArrayList<Action>();
		330	if (longLiving && isDependencyProjectAvailable()) {
		331	acts.add(OpenProjectAction.SINGLETON);
		332	}
332	if (isAddedToCP()) {	333	if (isAddedToCP()) {
333	InstallLocalArtifactAction act = new InstallLocalArtifactAction();	334	InstallLocalArtifactAction act = new InstallLocalArtifactAction();
334	acts.add(act);	335	acts.add(act);
Lines 1101-1104 Link Here
1101	}	1102	}
1102	}	1103	}
1103	}	1104	}
		1105
		1106	private static class OpenProjectAction extends AbstractAction implements ContextAwareAction {
		1107
		1108	static final OpenProjectAction SINGLETON = new OpenProjectAction();
		1109
		1110	private OpenProjectAction() {}
		1111
		1112	public @Override void actionPerformed(ActionEvent e) {
		1113	assert false;
		1114	}
		1115
		1116	public @Override Action createContextAwareInstance(final Lookup context) {
		1117	return new AbstractAction(NbBundle.getMessage(ModulesNode.class, "BTN_Open_Project")) {
		1118	public @Override void actionPerformed(ActionEvent e) {
		1119	Set<Project> projects = new HashSet<Project>();
		1120	for (Artifact art : context.lookupAll(Artifact.class)) {
		1121	projects.add(FileOwnerQuery.getOwner(art.getFile().toURI()));
		1122	}
		1123	projects.remove(null);
		1124	OpenProjects.getDefault().open(projects.toArray(new NbMavenProjectImpl[projects.size()]), false, true);
		1125	}
		1126	};
		1127	}
		1128	}
		1129
1104	}	1130	}

Lines 40-163 Link Here

(-)a/maven/src/org/netbeans/modules/maven/queries/MavenFileOwnerQueryImpl.java (-226 / +29 lines)
40	* Portions Copyrighted 2008 Sun Microsystems, Inc.	40	* Portions Copyrighted 2008 Sun Microsystems, Inc.
41	*/	41	*/
42		42
43	package org.netbeans.modules.maven.queries;	43	package org.netbeans.modules.maven;
44		44
45	import java.beans.PropertyChangeEvent;	45	import java.beans.PropertyChangeEvent;
46	import java.beans.PropertyChangeListener;	46	import java.beans.PropertyChangeListener;
47	import java.io.File;	47	import java.io.File;
48	import java.net.URI;
49	import java.util.ArrayList;
50	import java.util.HashSet;
51	import java.util.Iterator;
52	import java.util.List;
53	import java.util.Set;
54	import java.util.logging.Level;	48	import java.util.logging.Level;
55	import java.util.logging.Logger;	49	import java.util.logging.Logger;
56	import javax.swing.event.ChangeListener;	50	import javax.swing.event.ChangeListener;
57	import org.netbeans.modules.maven.NbMavenProjectImpl;	51	import org.apache.maven.artifact.Artifact;
58	import org.netbeans.modules.maven.api.NbMavenProject;	52	import org.apache.maven.artifact.repository.ArtifactRepository;
59	import org.netbeans.api.project.Project;	53	import org.netbeans.api.project.FileOwnerQuery;
60	import org.netbeans.api.project.ProjectManager;
61	import org.netbeans.spi.project.FileOwnerQueryImplementation;
62	import org.netbeans.spi.project.SubprojectProvider;
63	import org.openide.filesystems.FileObject;
64	import org.openide.filesystems.FileUtil;	54	import org.openide.filesystems.FileUtil;
65	import org.openide.util.ChangeSupport;	55	import org.openide.util.ChangeSupport;
66	import org.openide.util.Lookup;
67	import org.openide.util.Mutex.Action;
68	import org.openide.util.lookup.ServiceProvider;
69
70		56
71	/**	57	/**
72	* A global implementation of FileOwnerQueryImplementation, is required to link together the maven project	58	* Links the Maven project with its artifact in the local repository.
73	* and it's artifact in the maven repository. any other files shall be handled by the
74	* default netbeans implementation.
75	*
76	* @author Milos Kleint
77	*/	59	*/
78	@ServiceProvider(service=FileOwnerQueryImplementation.class, position=97)	60	public class MavenFileOwner {
79	public class MavenFileOwnerQueryImpl implements FileOwnerQueryImplementation {
80		61
81	private Set<NbMavenProjectImpl> set;	62	private final PropertyChangeListener projectListener;
82	private final Object setLock = new Object();
83
84	private Set<NbMavenProjectImpl> cachedProjects;
85	private Set<NbMavenProjectImpl> projectsToAddToCache;
86	private final Object cacheLock = new Object();
87
88	private PropertyChangeListener projectListener;
89	private final ChangeSupport cs = new ChangeSupport(this);	63	private final ChangeSupport cs = new ChangeSupport(this);
90		64
91	private static final Logger LOG = Logger.getLogger(MavenFileOwnerQueryImpl.class.getName());	65	private static final Logger LOG = Logger.getLogger(MavenFileOwner.class.getName());
92		66
93	public MavenFileOwnerQueryImpl() {	67	private MavenFileOwner() {
94	set = new HashSet<NbMavenProjectImpl>();
95	cachedProjects = null;
96	projectsToAddToCache = null;
97	projectListener = new PropertyChangeListener() {	68	projectListener = new PropertyChangeListener() {
98	public @Override void propertyChange(PropertyChangeEvent evt) {	69	public @Override void propertyChange(PropertyChangeEvent evt) {
99	if (NbMavenProjectImpl.PROP_PROJECT.equals(evt.getPropertyName())) {	70	if (NbMavenProjectImpl.PROP_PROJECT.equals(evt.getPropertyName())) {
100	Object evtSource = evt.getSource();	71	fireChange();
101	if (evtSource instanceof NbMavenProjectImpl) {
102	// try adding the changed project and its subprojects again to cache
103	// new subprojects might have been added/activated for the changed project
104	synchronized (cacheLock) {
105	if (null == projectsToAddToCache) {
106	projectsToAddToCache = new HashSet<NbMavenProjectImpl>(1);
107	}
108	projectsToAddToCache.add((NbMavenProjectImpl) evtSource);
109	}
110	}
111	}	72	}
112	}	73	}
113	};	74	};
114	}	75	}
115		76
116	public static MavenFileOwnerQueryImpl getInstance() {	77	private static final MavenFileOwner IMPL = new MavenFileOwner();
117	Lookup.Result<FileOwnerQueryImplementation> implementations =	78	public static MavenFileOwner getInstance() {
118	Lookup.getDefault().lookup(new Lookup.Template<FileOwnerQueryImplementation>(FileOwnerQueryImplementation.class));	79	return IMPL;
119	Iterator<? extends FileOwnerQueryImplementation> it = implementations.allInstances().iterator();
120	while (it.hasNext()) {
121	FileOwnerQueryImplementation obj = it.next();
122	if (obj instanceof MavenFileOwnerQueryImpl) {
123	return (MavenFileOwnerQueryImpl)obj;
124	}
125	}
126	return null;
127	}	80	}
128		81
129	public void addMavenProject(NbMavenProjectImpl project) {	82	public void addMavenProject(NbMavenProjectImpl project) {
130	synchronized (setLock) {	83	Artifact art = project.getOriginalMavenProject().getArtifact();
131	if (!set.contains(project)) {	84	if (art != null) {
132	LOG.log(Level.FINE, "Adding Maven project:{0}", project.getArtifactRelativeRepositoryPath());	85	File f = art.getFile();
133	set.add(project);	86	if (f == null) { // XXX seems to be the normal case - why?
134	NbMavenProject.addPropertyChangeListener(project, projectListener);	87	ArtifactRepository repo = project.getEmbedder().getLocalRepository();
		88	f = new File(repo.getBasedir(), repo.pathOf(art));
135	}	89	}
		90	File allArtifacts = FileUtil.normalizeFile(f.getParentFile());
		91	LOG.log(Level.FINE, "registering {0} for {1}", new Object[] {allArtifacts, art});
		92	FileOwnerQuery.markExternalOwner(allArtifacts.toURI(), project, FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
		93	// Also claim other versions, though another project with that exact version might override you:
		94	FileOwnerQuery.markExternalOwner(allArtifacts.getParentFile().toURI(), project, FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
		95	} else {
		96	LOG.log(Level.WARNING, "no artifact for {0}", project);
136	}	97	}
137	synchronized (cacheLock) {	98	project.getProjectWatcher().removePropertyChangeListener(projectListener);
138	// add the new project to cache incrementally if it has not been	99	project.getProjectWatcher().addPropertyChangeListener(projectListener);
139	// added to cache already from "set" where we added it just above
140	if (null != cachedProjects && !cachedProjects.contains(project)) {
141	if (null == projectsToAddToCache) {
142	projectsToAddToCache = new HashSet<NbMavenProjectImpl>(1);
143	}
144	projectsToAddToCache.add(project);
145	}
146	}
147
148	fireChange();
149	}
150	public void removeMavenProject(NbMavenProjectImpl project) {
151	synchronized (setLock) {
152	if (set.contains(project)) {
153	LOG.log(Level.FINE, "Removing Maven project:{0}", project.getArtifactRelativeRepositoryPath());
154	set.remove(project);
155	NbMavenProject.removePropertyChangeListener(project, projectListener);
156	}
157	}
158	synchronized (cacheLock) {
159	cachedProjects = null;
160	}
161	fireChange();	100	fireChange();
162	}	101	}
163		102
Lines 173-312 Link Here
173	cs.fireChange();	112	cs.fireChange();
174	}	113	}
175		114
176	/**
177	* get the list of currently opened maven projects.. kind of hack, but well..
178	*/
179	public Set<Project> getOpenedProjects() {
180	synchronized (setLock) {
181	return new HashSet<Project>(set);
182	}
183	}
184
185	public @Override Project getOwner(URI uri) {
186	LOG.log(Level.FINEST, "getOwner of uri={0}", uri);
187	if (uri.getScheme() != null && "file".equals(uri.getScheme())) { //NOI18N
188	File file = new File(uri);
189	return getOwner(file);
190	}
191	return null;
192	}
193
194	public @Override Project getOwner(FileObject fileObject) {
195	LOG.log(Level.FINEST, "getOwner of fileobject={0}", fileObject);
196	File file = FileUtil.toFile(fileObject);
197	if (file != null) {
198	//logger.fatal("getOwner of fileobject=" + fileObject.getNameExt());
199	return getOwner(file);
200	}
201	return null;
202	}
203
204	private Project getOwner(File file) {
205	//TODO check if the file is from local repo ??
206	LOG.log(Level.FINE, "Looking for owner of {0}", file);
207	boolean passBasicCheck = false;
208	String nm = file.getName();
209	File parentVer = file.getParentFile();
210	if (parentVer != null) {
211	File parentArt = parentVer.getParentFile();
212	if (parentArt != null) {
213	if (nm.startsWith(parentArt.getName() + "-" + parentVer.getName())) {
214	passBasicCheck = true;
215	}
216	}
217	}
218	if (!passBasicCheck) {
219	LOG.fine(" exiting early, not from local repository.");
220	return null;
221	}
222	Set<NbMavenProjectImpl> currentProjects = getAllKnownProjects();
223
224	Iterator<NbMavenProjectImpl> it = currentProjects.iterator();
225	String filepath = file.getAbsolutePath().replace('\\', '/');
226	while (it.hasNext()) {
227	NbMavenProjectImpl project = it.next();
228	String path = project.getArtifactRelativeRepositoryPath();
229	LOG.log(Level.FINEST, "matching againts known project {0}", path);
230	if (filepath.endsWith(path)) {
231	return project;
232	}
233	path = project.getTestArtifactRelativeRepositoryPath();
234	LOG.log(Level.FINEST, "matching againts known project''s test {0}", path);
235	if (filepath.endsWith(path)) {
236	return project;
237	}
238	}
239	return null;
240
241	}
242
243
244	private Set<NbMavenProjectImpl> getAllKnownProjects() {
245	return ProjectManager.mutex().readAccess(new Action<Set<NbMavenProjectImpl>>() {
246	public @Override Set<NbMavenProjectImpl> run() {
247	synchronized (cacheLock) {
248	// is cachedProjects up-to-date?
249	if (cachedProjects != null && null == projectsToAddToCache) {
250	return new HashSet<NbMavenProjectImpl>(cachedProjects);
251	}
252	// cachedProjects empty?
253	if (null == cachedProjects) {
254	// full build of the cache
255	Set<NbMavenProjectImpl> currentProjects;
256	List<NbMavenProjectImpl> iterating;
257	synchronized (setLock) {
258	currentProjects = new HashSet<NbMavenProjectImpl>(set);
259	iterating = new ArrayList<NbMavenProjectImpl>(set);
260	}
261	int index = 0;
262	// iterate all opened projects and figure their subprojects..
263	// consider these as well. do so recursively.
264	while (index < iterating.size()) {
265	NbMavenProjectImpl prj = iterating.get(index);
266	addSubProjects(currentProjects, iterating, prj);
267	index = index + 1;
268	}
269	cachedProjects = currentProjects;
270	projectsToAddToCache = null;
271	}
272	// non-empty projectsToAddToCache?
273	if (null != projectsToAddToCache) {
274	// incrementally adding to the cache
275	Set<NbMavenProjectImpl> currentProjects;
276	List<NbMavenProjectImpl> iterating;
277	currentProjects = new HashSet<NbMavenProjectImpl>(cachedProjects);
278	currentProjects.addAll(projectsToAddToCache);
279	iterating = new ArrayList<NbMavenProjectImpl>(projectsToAddToCache);
280	int index = 0;
281	// iterate all new or changed (after propChange) projects
282	// and figure their subprojects..
283	// consider these as well. do so recursively.
284	while (index < iterating.size()) {
285	NbMavenProjectImpl prj = iterating.get(index);
286	addSubProjects(currentProjects, iterating, prj);
287	index = index + 1;
288	}
289	cachedProjects = currentProjects;
290	projectsToAddToCache = null;
291	}
292	return new HashSet<NbMavenProjectImpl>(cachedProjects);
293	}
294	}
295	});
296	}
297
298	private void addSubProjects(Set<NbMavenProjectImpl> finalset, List<NbMavenProjectImpl> iteratinglist, NbMavenProjectImpl prj) {
299	SubprojectProvider sub = prj.getLookup().lookup(SubprojectProvider.class);
300	if (sub != null) {
301	Set<? extends Project> subs = sub.getSubprojects();
302	for (Project p : subs) {
303	if (p instanceof NbMavenProjectImpl) {
304	finalset.add((NbMavenProjectImpl) p);
305	if (!iteratinglist.contains((NbMavenProjectImpl)p)) {
306	iteratinglist.add((NbMavenProjectImpl) p);
307	}
308	}
309	}
310	}
311	}
312	}	115	}