Attachment #32400 for bug #81510

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 81510
Collapse All | Expand All




        <apidef name="masterfs">MasterFileSystem API</apidef>
    </apidefs>
    <changes>
        <change id="added-support-for-subversion-delete">
            <api name="masterfs"/>
            <summary><code>ProvidedExtensions.getDeleteHandler</code> was added.</summary>
            <version major="1" minor="8" subminor="23"/>
            <date day="01" month="08" year="2006"/>
            <author login="rmatous"/>
            <compatibility addition="yes" binary="compatible" source="compatible" semantic="compatible" deprecation="no" deletion="no" modification="no"/>
            <description>
                <p>
                    <code>ProvidedExtensions.getDeleteHandler</code> was added, which
                    is the way how to impose handlers for 
                    deleting into mastersfs implementation 
                    which was required by module org.netbeans.modules.subversion.
                </p>
            </description>
            <class package="org.netbeans.modules.masterfs.providers" name="ProvidedExtensions"/>
            <issue number="81510"/>
        </change>                
        <change id="added-support-for-subversion">
            <api name="masterfs"/>
            <summary><code>ProvidedExtensions</code> was added.</summary>

Lines 1-5 Link Here

(-)manifest.mf (-1 / +1 lines)
1	Manifest-Version: 1.0	1	Manifest-Version: 1.0
2	OpenIDE-Module: org.netbeans.modules.masterfs/1	2	OpenIDE-Module: org.netbeans.modules.masterfs/1
3	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/masterfs/resources/Bundle.properties	3	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/masterfs/resources/Bundle.properties
4	OpenIDE-Module-Specification-Version: 1.8.22	4	OpenIDE-Module-Specification-Version: 1.8.23
5		5




import java.io.File;
import org.netbeans.modules.masterfs.filebasedfs.FileBasedFileSystem;
import org.netbeans.modules.masterfs.filebasedfs.fileobjects.BaseFileObj;
import org.netbeans.modules.masterfs.filebasedfs.naming.FileNaming;

import org.openide.ErrorManager;
import org.openide.filesystems.*;

    public boolean isValid() {
        FileObject deleg = getValidOrInvalid(getDelegate().getPrefered());
        File f = (deleg.isVirtual()) ? null: getResource().getFile();                
        return (f != null) ?  (deleg.isValid() && (f.exists())) : deleg.isValid();
    }

    /**

                }
                if (canRefresh) {
                    if (f != null && f.exists()) {
                        if (getDeleteHandler(f) == null) {
                            this.refresh();
                            if (deleg instanceof BaseFileObj) {//#54856
                                FileObject child = deleg.getFileObject(name, ext);
                                retVal = (child != null) ? transformChild(child) : null;                
                            } else {
                                retVal = getCache().getOrCreate(childResourcePath);            
                            }                        
                        }
                    }
                }
            }

            finishCriticalSection();
        }
    }
    
    private ProvidedExtensions.IOHandler getRenameHandler(final String name, final String ext) {
        ProvidedExtensions pe;
        pe = ((MasterFileSystem.StatusImpl)MasterFileSystem.getDefault().getStatus()).getExtensions();

            FileEvent fe2Fire = new FileEvent(MasterFileObject.this, eventFile, fe.isExpected());
            FileObject eventFileDelegate = eventFile.getDelegate().get();
            FileObject meDelegate = MasterFileObject.this.getDelegate().get();
            if (fe.getFile() instanceof BaseFileObj && eventFileDelegate instanceof BaseFileObj 
                    && fe.getSource() instanceof BaseFileObj && meDelegate instanceof BaseFileObj) {
                FileNaming fName = ((BaseFileObj)fe.getFile()).getFileName();
                FileNaming sName = ((BaseFileObj)fe.getSource()).getFileName();                
                FileNaming f1Name = ((BaseFileObj)eventFileDelegate).getFileName();
                FileNaming s1Name = ((BaseFileObj)meDelegate).getFileName();
                if (fName.equals(f1Name) && sName.equals(s1Name)) {
                    fireFileDeletedEvent(getEnumOfListeners(), fe2Fire);
                }                
            } else {
                if (eventFileDelegate == fe.getFile() && meDelegate == fe.getSource()) {
                    fireFileDeletedEvent(getEnumOfListeners(), fe2Fire);
                }
            }
        }


        }
    }

    private static ProvidedExtensions.DeleteHandler getDeleteHandler(File f) {
        ProvidedExtensions pe;
        pe = ((MasterFileSystem.StatusImpl)MasterFileSystem.getDefault().getStatus()).getExtensions();
        
        return pe.getDeleteHandler(f);
    }
    
    private static final class AtomicAction implements FileSystem.AtomicAction {
        private int operation;
        private final MasterFileObject hfoI;

        private void delete() throws IOException {
            FileObject deleg = getValidOrInvalid(hfoI.getDelegate().get(), hfoI);
            FileLock lck = Delegate.getLockForDelegate(fLockI, deleg);
            if (deleg instanceof BaseFileObj) {
                ((BaseFileObj)deleg).delete(lck, 
                        MasterFileObject.getDeleteHandler(((BaseFileObj)deleg).getFileName().getFile()));
            } else {
                deleg.delete(lck);
            }
        }

        private void move() throws IOException {

                retVal = hfoI.superMove(fLockI, targetI, nameI, extI);
            }
        }
        
        private ProvidedExtensions.IOHandler getMoveHandler() {
            ProvidedExtensions pe;
            pe = ((MasterFileSystem.StatusImpl)MasterFileSystem.getDefault().getStatus()).getExtensions();




        this.annotationProviders = annotationProviders;
    }
    
    public ProvidedExtensions.DeleteHandler getDeleteHandler(final File f) {
        ProvidedExtensions.DeleteHandler retValue = null;
        for (Iterator it = annotationProviders.iterator(); it.hasNext() && retValue == null;) {
            AnnotationProvider provider = (AnnotationProvider) it.next();
            final InterceptionListener iListener = (provider != null) ?  provider.getInterceptionListener() : null;
            if (iListener instanceof ProvidedExtensions) {
                retValue = ((ProvidedExtensions)iListener).getDeleteHandler(f);
            } 
        }
        return retValue;                        
    }
    
    public ProvidedExtensions.IOHandler getRenameHandler(final File from, final String newName) {
        final File to = new File(from.getParentFile(), newName);
        IOHandler retValue = null;

                iListener.beforeDelete(fo);
            }
        }
    }            
}

Lines 32-37 Link Here

(-)src/org/netbeans/modules/masterfs/filebasedfs/children/ChildrenCache.java (+8 lines)
32	Set getChildren(boolean rescan);	32	Set getChildren(boolean rescan);
33		33
34	FileNaming getChild(String childName, boolean rescan);	34	FileNaming getChild(String childName, boolean rescan);
		35
		36	/**
		37	* Added because of subversion support, please do don't use
		38	* this method and use rather FileNaming getChild(String childName, boolean rescan)
		39	* This method is just good for keeping cache in state that doesn't correspond
		40	* with disk status.
		41	*/
		42	void removeChild(String childName);
35		43
36	boolean existsInCache(String childName);	44	boolean existsInCache(String childName);
37		45

Lines 94-99 Link Here

(-)src/org/netbeans/modules/masterfs/filebasedfs/children/ChildrenSupport.java (+7 lines)
94	return lookupChildInCache(folder, childName) != null;	94	return lookupChildInCache(folder, childName) != null;
95	}	95	}
96		96
		97	public void removeChild(final FileNaming folderName, final String childName) {
		98	FileName fName = lookupChildInCache(folderName, childName);
		99	if (fName != null) {
		100	getChildrenCache().remove(fName);
		101	}
		102	}
		103
97	private FileName lookupChildInCache(final FileNaming folder, final String childName) {	104	private FileName lookupChildInCache(final FileNaming folder, final String childName) {
98	final File f = new File(folder.getFile(), childName);	105	final File f = new File(folder.getFile(), childName);
99	final Integer id = NamingFactory.createID(f);	106	final Integer id = NamingFactory.createID(f);

Lines 19-24 Link Here

(-)src/org/netbeans/modules/masterfs/filebasedfs/fileobjects/BaseFileObj.java (-6 / +38 lines)
19		19
20	package org.netbeans.modules.masterfs.filebasedfs.fileobjects;	20	package org.netbeans.modules.masterfs.filebasedfs.fileobjects;
21		21
		22	import java.util.Iterator;
22	import org.netbeans.modules.masterfs.filebasedfs.FileBasedFileSystem;	23	import org.netbeans.modules.masterfs.filebasedfs.FileBasedFileSystem;
23	import org.netbeans.modules.masterfs.filebasedfs.Statistics;	24	import org.netbeans.modules.masterfs.filebasedfs.Statistics;
24	import org.netbeans.modules.masterfs.filebasedfs.children.ChildrenCache;	25	import org.netbeans.modules.masterfs.filebasedfs.children.ChildrenCache;
Lines 33-40 Link Here
33		34
34	import javax.swing.event.EventListenerList;	35	import javax.swing.event.EventListenerList;
35	import java.io.*;	36	import java.io.*;
		37	import java.util.ArrayList;
		38	import java.util.Arrays;
36	import java.util.Date;	39	import java.util.Date;
37	import java.util.Enumeration;	40	import java.util.Enumeration;
		41	import java.util.List;
38	import org.netbeans.modules.masterfs.providers.ProvidedExtensions;	42	import org.netbeans.modules.masterfs.providers.ProvidedExtensions;
39		43
40	/**	44	/**
Lines 188-202 Link Here
188	final String originalExt = getExt();	192	final String originalExt = getExt();
189		193
190	//TODO: no lock used	194	//TODO: no lock used
191	if (!NamingFactory.rename(getFileName(),file2Rename.getName(),handler)) {	195	FileNaming[] allRenamed = NamingFactory.rename(getFileName(),file2Rename.getName(),handler);
		196	if (allRenamed == null) {
192	FileObject parentFo = getExistingParent();	197	FileObject parentFo = getExistingParent();
193	String parentPath = (parentFo != null) ? parentFo.getPath() : file.getParentFile().getAbsolutePath();	198	String parentPath = (parentFo != null) ? parentFo.getPath() : file.getParentFile().getAbsolutePath();
194	FSException.io("EXC_CannotRename", file.getName(), parentPath, file2Rename.getName());// NOI18N	199	FSException.io("EXC_CannotRename", file.getName(), parentPath, file2Rename.getName());// NOI18N
195	}	200	}
196
197	FileBasedFileSystem fs = getLocalFileSystem();	201	FileBasedFileSystem fs = getLocalFileSystem();
198	fs.getFactory().rename();	202	fs.getFactory().rename();
199	BaseFileObj.attribs.renameAttributes(file.getAbsolutePath().replace('\\', '/'), file2Rename.getAbsolutePath().replace('\\', '/'));//NOI18N	203	BaseFileObj.attribs.renameAttributes(file.getAbsolutePath().replace('\\', '/'), file2Rename.getAbsolutePath().replace('\\', '/'));//NOI18N
		204	for (int i = 0; i < allRenamed.length; i++) {
		205	FolderObj par = (allRenamed[i].getParent() != null) ?
		206	(FolderObj)fs.getFactory().get(allRenamed[i].getParent().getFile()) : null;
		207	if (par != null) {
		208	ChildrenCache childrenCache = par.getChildrenCache();
		209	final Mutex.Privileged mutexPrivileged = (childrenCache != null) ? childrenCache.getMutexPrivileged() : null;
		210	if (mutexPrivileged != null) mutexPrivileged.enterWriteAccess();
		211	try {
		212	childrenCache.removeChild(allRenamed[i].getName());
		213	childrenCache.getChild(allRenamed[i].getName(), true);
		214	} finally {
		215	if (mutexPrivileged != null) mutexPrivileged.exitWriteAccess();
		216	}
		217	}
		218	}
		219
200	fireFileRenamedEvent(originalName, originalExt);	220	fireFileRenamedEvent(originalName, originalExt);
201	}	221	}
202		222
Lines 384-391 Link Here
384	public final FileNaming getFileName() {	404	public final FileNaming getFileName() {
385	return fileName;	405	return fileName;
386	}	406	}
		407
		408	public final void delete(final FileLock lock) throws IOException {
		409	delete(lock, null);
		410	}
387		411
388	public void delete(final FileLock lock) throws IOException {	412	public void delete(final FileLock lock, ProvidedExtensions.DeleteHandler deleteHandler) throws IOException {
389	final File f = getFileName().getFile();	413	final File f = getFileName().getFile();
390		414
391	final FolderObj existingParent = getExistingParent();	415	final FolderObj existingParent = getExistingParent();
Lines 398-410 Link Here
398	FSException.io("EXC_InvalidLock", lock, getPath()); // NOI18N	422	FSException.io("EXC_InvalidLock", lock, getPath()); // NOI18N
399	}	423	}
400		424
401	if (!f.delete()) {	425	boolean deleteStatus = (deleteHandler != null) ? deleteHandler.delete(f) : f.delete();
		426	if (!deleteStatus) {
402	FileObject parent = getExistingParent();	427	FileObject parent = getExistingParent();
403	String parentPath = (parent != null) ? parent.getPath() : f.getParentFile().getAbsolutePath();	428	String parentPath = (parent != null) ? parent.getPath() : f.getParentFile().getAbsolutePath();
404	FSException.io("EXC_CannotDelete", f.getName(), parentPath);// NOI18N	429	FSException.io("EXC_CannotDelete", f.getName(), parentPath);// NOI18N
405	}	430	}
406	BaseFileObj.attribs.deleteAttributes(f.getAbsolutePath().replace('\\', '/'));//NOI18N	431	BaseFileObj.attribs.deleteAttributes(f.getAbsolutePath().replace('\\', '/'));//NOI18N
407	if (childrenCache != null) childrenCache.getChild(BaseFileObj.getNameExt(f), true);	432	if (childrenCache != null) {
		433	if (deleteHandler != null) {
		434	childrenCache.removeChild(BaseFileObj.getNameExt(f));
		435	} else {
		436	childrenCache.getChild(BaseFileObj.getNameExt(f), true);
		437	}
		438	}
408	} finally {	439	} finally {
409	if (mutexPrivileged != null) mutexPrivileged.exitWriteAccess();	440	if (mutexPrivileged != null) mutexPrivileged.exitWriteAccess();
410	setValid(false);	441	setValid(false);
Lines 413-419 Link Here
413	fireFileDeletedEvent(false);	444	fireFileDeletedEvent(false);
414		445
415	}	446	}
416		447
417	abstract boolean checkLock(FileLock lock) throws IOException;	448	abstract boolean checkLock(FileLock lock) throws IOException;
418		449
419	public Object writeReplace() {	450	public Object writeReplace() {
Lines 423-428 Link Here
423	abstract protected void setValid(boolean valid);	454	abstract protected void setValid(boolean valid);
424		455
425	abstract public void refresh(final boolean expected, boolean fire);	456	abstract public void refresh(final boolean expected, boolean fire);
		457
426		458
427	//TODO: attributes written by VCS must be readable by FileBaseFS and vice versa	459	//TODO: attributes written by VCS must be readable by FileBaseFS and vice versa
428	/**	460	/**




import java.util.Date;
import java.util.Enumeration;
import org.netbeans.modules.masterfs.filebasedfs.Statistics;
import org.netbeans.modules.masterfs.filebasedfs.children.ChildrenCache;
import org.netbeans.modules.masterfs.filebasedfs.naming.FileNaming;
import org.netbeans.modules.masterfs.filebasedfs.utils.FSException;
import org.netbeans.modules.masterfs.filebasedfs.utils.FileInfo;
import org.netbeans.modules.masterfs.providers.ProvidedExtensions;
import org.openide.filesystems.FileLock;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;
import org.openide.util.Enumerations;
import org.openide.util.Mutex;

/**
 * @author rm111737

            boolean validityFlag = getFileName().getFile().exists();                    
            if (!validityFlag) {
                //fileobject is invalidated
                FolderObj parent = getExistingParent();
                if (parent != null) {
                    ChildrenCache childrenCache = parent.getChildrenCache();
                    final Mutex.Privileged mutexPrivileged = (childrenCache != null) ? childrenCache.getMutexPrivileged() : null;
                    if (mutexPrivileged != null) mutexPrivileged.enterWriteAccess();
                    try {
                        childrenCache.getChild(getFileName().getFile().getName(),true);
                    } finally {
                        if (mutexPrivileged != null) mutexPrivileged.exitWriteAccess();
                    }
                    
                }
                setValid(false);
                if (fire) {
                    fireFileDeletedEvent(expected);
                }
            }
        }                 
        stopWatch.stop();
    }




import java.io.*;
import java.util.*;
import org.netbeans.modules.masterfs.filebasedfs.naming.NamingFactory;
import org.netbeans.modules.masterfs.providers.ProvidedExtensions;

/**
 * @author rm111737

        }        
    }

    public void delete(final FileLock lock, ProvidedExtensions.DeleteHandler deleteHandler) throws IOException {
        final LinkedList all = new LinkedList();

        final File file = getFileName().getFile();
        if (!deleteFile(file, all, getLocalFileSystem().getFactory(), deleteHandler)) {
            FileObject parent = getExistingParent();
            String parentPath = (parent != null) ? parent.getPath() : file.getParentFile().getAbsolutePath();
            FSException.io("EXC_CannotDelete", file.getName(), parentPath);// NOI18N            
        }

        BaseFileObj.attribs.deleteAttributes(file.getAbsolutePath().replace('\\', '/'));//NOI18N
        setValid(false);
        for (int i = 0; i < all.size(); i++) {
            final BaseFileObj toDel = (BaseFileObj) all.get(i);            
            final FolderObj existingParent = toDel.getExistingParent();            

            if (childrenCache != null) {
                final Mutex.Privileged mutexPrivileged = (childrenCache != null) ? childrenCache.getMutexPrivileged() : null;
                if (mutexPrivileged != null) mutexPrivileged.enterWriteAccess();
                try {      
                    if (deleteHandler != null) {
                        childrenCache.removeChild(BaseFileObj.getNameExt(file));
                    } else {
                        childrenCache.getChild(BaseFileObj.getNameExt(file), true);
                    }
                    
                    
                } finally {
                    if (mutexPrivileged != null) mutexPrivileged.exitWriteAccess();                    
                }

    }
    
    //TODO: rewrite partly and check FileLocks for existing FileObjects
    private boolean deleteFile(final File file, final LinkedList all, final FileObjectFactory factory, ProvidedExtensions.DeleteHandler deleteHandler) throws IOException {
        final boolean ret = (deleteHandler != null) ? deleteHandler.delete(file) : file.delete();

        if (ret) {
            final FileObject aliveFo = factory.get(file);

            final File[] arr = file.listFiles();
            for (int i = 0; i < arr.length; i++) {
                final File f2Delete = arr[i];
                if (!deleteFile(f2Delete, all, factory, deleteHandler)) {
                    return false;
                }
            }

        //super.delete(lock());
        

        final boolean retVal = (deleteHandler != null) ? deleteHandler.delete(file) : file.delete();
        if (retVal) {
            final FileObject aliveFo = factory.get(file);
            if (aliveFo != null) {


        public boolean existsInCache(String childName) {
            return ch.existsldInCache(getFileName(), childName);
        }

        public void removeChild(String childName) {
            ch.removeChild(getFileName(), childName);
        }
    }





package org.netbeans.modules.masterfs.filebasedfs.fileobjects;

import org.netbeans.modules.masterfs.filebasedfs.FileBasedFileSystem;
import org.netbeans.modules.masterfs.providers.ProvidedExtensions;
import org.openide.filesystems.*;

import java.io.*;

            super(file);
        }

        public void delete(FileLock lock, ProvidedExtensions.IOHandler io) throws IOException {
            throw new IOException(getPath()); 
        }
        
        boolean checkLock(FileLock lock) throws IOException {
            return false;
        }




        }                        
    }

    private static synchronized FileNaming[] rename (FileNaming fNaming, String newName) {        
        return rename(fNaming, newName, null);
    }
    
    public static synchronized FileNaming[] rename (FileNaming fNaming, String newName, ProvidedExtensions.IOHandler handler) {
        final ArrayList all = new ArrayList();
        boolean retVal = false;
        remove(fNaming, null);
        retVal = fNaming.rename(newName, handler);
        all.add(fNaming);
        NamingFactory.registerInstanceOfFileNaming(fNaming.getParent(), fNaming.getFile(), fNaming);
        renameChildren(all);
        return (retVal) ? ((FileNaming[])all.toArray(new FileNaming[all.size()])) : null;
    }

    private static void renameChildren(final ArrayList all) {
        HashMap toRename = new HashMap ();
        for (Iterator iterator = nameMap.entrySet().iterator(); iterator.hasNext();) {
            Map.Entry entry = (Map.Entry) iterator.next();

            Map.Entry entry = (Map.Entry) iterator.next();
            Integer id = (Integer)entry.getKey();
            FileNaming fN = (FileNaming)entry.getValue(); 
            all.add(fN);    
            remove(fN, id);
            fN.getId(true);
            NamingFactory.registerInstanceOfFileNaming(fN.getParent(), fN.getFile(), fN);            

Lines 72-77 Link Here

(-)src/org/netbeans/modules/masterfs/providers/ProvidedExtensions.java (+28 lines)
72	File from, String newName) {	72	File from, String newName) {
73	return null;	73	return null;
74	}	74	}
		75
		76	/*
		77	* Return instance of {@link ProvidedExtensions.DeleteHandler}
		78	* that is responsible for deleting the file or null.
		79	*
		80	* Just the first non null instance of <code>DeleteHandler</code> is used by
		81	* <code>MasterFileSystem</code>
		82	*
		83	* @param f file or folder to be deleted
		84	* @return instance of {@link ProvidedExtensions.DeleteHandler}
		85	* that is responsible for deleting the file or null
		86	*/
		87	public ProvidedExtensions.DeleteHandler getDeleteHandler(File f) {
		88	return null;
		89	}
75		90
76		91
77	public interface IOHandler {	92	public interface IOHandler {
Lines 80-85 Link Here
80	*/	95	*/
81	void handle() throws IOException;	96	void handle() throws IOException;
82	}	97	}
		98
		99	public interface DeleteHandler {
		100	/**
		101	* Deletes the file or directory denoted by this abstract pathname. If
		102	* this pathname denotes a directory, then the directory must be empty in
		103	* order to be deleted.
		104	*
		105	* @return <code>true</code> if and only if the file or directory is
		106	* successfully deleted; <code>false</code> otherwise
		107	*/
		108	boolean delete(File file);
		109	}
		110
83		111
84	public void createSuccess(FileObject fo) {}	112	public void createSuccess(FileObject fo) {}
85	public void createFailure(FileObject parent, String name, boolean isFolder) {}	113	public void createFailure(FileObject parent, String name, boolean isFolder) {}




import java.io.File;
import java.lang.ref.Reference;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.List;
import org.netbeans.junit.NbTestCase;
import org.netbeans.modules.masterfs.providers.ProvidedExtensionsTest;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;


        testFo.getFileSystem().findResource(testFo.getPath());        
                
        FileObject testFo2 = Cache.getDefault().getValidOrInvalid(((MasterFileObject)testFo).getResource());
        if (!ProvidedExtensionsTest.ProvidedExtensionsImpl.isImplsDeleteRetVal()) {
            assertFalse(testFo2.isValid());
        }
        assertEquals(testFo, testFo2);        
    }
    

Lines 36-41 Link Here

(-)test/unit/src/org/netbeans/modules/masterfs/MasterFileObjectTestHid.java (-7 / +14 lines)
36		36
37	import javax.swing.filechooser.FileSystemView;	37	import javax.swing.filechooser.FileSystemView;
38	import org.netbeans.modules.masterfs.filebasedfs.fileobjects.WriteLockUtils;	38	import org.netbeans.modules.masterfs.filebasedfs.fileobjects.WriteLockUtils;
		39	import org.netbeans.modules.masterfs.providers.ProvidedExtensionsTest;
39		40
40	public class MasterFileObjectTestHid extends TestBaseHid{	41	public class MasterFileObjectTestHid extends TestBaseHid{
41	private FileObject root;	42	private FileObject root;
Lines 431-438 Link Here
431	}	432	}
432	});	433	});
433		434
434	assertNotNull(fo.getFileObject("newchild.txt"));	435	if (!ProvidedExtensionsTest.ProvidedExtensionsImpl.isImplsDeleteRetVal()) {
435	assertTrue(list.size() == 1);	436	assertNotNull(fo.getFileObject("newchild.txt"));
		437	assertTrue(list.size() == 1);
		438	}
436	fo.removeFileChangeListener(fcl);	439	fo.removeFileChangeListener(fcl);
437	}	440	}
438		441
Lines 535-544 Link Here
535		538
536	MountTable mt = MountTable.getDefault();	539	MountTable mt = MountTable.getDefault();
537	mt.mount(mountFile.getAbsolutePath(), ifs);	540	mt.mount(mountFile.getAbsolutePath(), ifs);
538		541
539	mountDir.delete();	542	if (!ProvidedExtensionsTest.ProvidedExtensionsImpl.isImplsDeleteRetVal()) {
540	assertTrue(!mountDir.isValid());	543	mountDir.delete();
541	assertNull(root.getFileObject("testdir/mountdir"));	544	assertTrue(!mountDir.isValid());
		545	assertNull(root.getFileObject("testdir/mountdir"));
		546	}
542	}	547	}
543		548
544	public void testDeleteCaptureExteralChanges () throws Exception {	549	public void testDeleteCaptureExteralChanges () throws Exception {
Lines 553-559 Link Here
553	assertTrue(f.exists());	558	assertTrue(f.exists());
554	assertTrue (f.delete());	559	assertTrue (f.delete());
555		560
556	assertFalse(fileObject.isValid());	561	if (!ProvidedExtensionsTest.ProvidedExtensionsImpl.isImplsDeleteRetVal()) {
		562	assertFalse(fileObject.isValid());
		563	}
557	}	564	}
558		565
559	public void testFindResourceCaptureExteralChanges () throws Exception {	566	public void testFindResourceCaptureExteralChanges () throws Exception {

Lines 58-64 Link Here

(-)test/unit/src/org/netbeans/modules/masterfs/MasterFileSystemTest.java (-1 / +1 lines)
58	super(test);	58	super(test);
59	ProvidedExtensionsTest.ProvidedExtensionsImpl.setImplsMoveRetVal(false);	59	ProvidedExtensionsTest.ProvidedExtensionsImpl.setImplsMoveRetVal(false);
60	ProvidedExtensionsTest.ProvidedExtensionsImpl.setImplsRenameRetVal(false);	60	ProvidedExtensionsTest.ProvidedExtensionsImpl.setImplsRenameRetVal(false);
61		61	ProvidedExtensionsTest.ProvidedExtensionsImpl.setImplsDeleteRetVal(false);
62	}	62	}
63		63
64		64

Lines 31-36 Link Here

(-)test/unit/src/org/netbeans/modules/masterfs/MasterFileSystemWithExtensionsTest.java (+1 lines)
31	super(test);	31	super(test);
32	ProvidedExtensionsTest.ProvidedExtensionsImpl.setImplsMoveRetVal(true);	32	ProvidedExtensionsTest.ProvidedExtensionsImpl.setImplsMoveRetVal(true);
33	ProvidedExtensionsTest.ProvidedExtensionsImpl.setImplsRenameRetVal(true);	33	ProvidedExtensionsTest.ProvidedExtensionsImpl.setImplsRenameRetVal(true);
		34	ProvidedExtensionsTest.ProvidedExtensionsImpl.setImplsDeleteRetVal(true);
34	}	35	}
35		36
36	public static Test suite() {	37	public static Test suite() {




import java.util.ArrayList;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import org.netbeans.junit.NbTestCase;
import org.netbeans.modules.masterfs.filebasedfs.FileBasedFileSystem;

            
            f = f.getParentFile();
        }        
    }
    
    public void testGetChildrenStackOwerflow() throws Exception {
        File f = testFile;
        assertTrue(f.exists());
        assertTrue(f.isDirectory());        
        FileSystem fs = FileBasedFileSystem.getInstance(f);
        assertNotNull(fs);
        final FileObject fo = fs.findResource(f.getAbsolutePath()); 
        assertNotNull(f.getAbsolutePath(),fo);        
        assertTrue(fo.isFolder());
        assertEquals(0,fo.getChildren().length);
        assertTrue(new File(f,"child1").createNewFile());
        assertTrue(new File(f,"child2").createNewFile());
        final File child3 = new File(f,"child3");
        assertTrue(child3.createNewFile());
        final List keepThem = new ArrayList();
        fo.addFileChangeListener(new FileChangeAdapter(){
            public void fileDeleted(FileEvent fe) {
                for (Iterator it = keepThem.iterator(); it.hasNext();) {
                    FileObject fodel = (FileObject) it.next();
                    FileObject[] all =  fo.getChildren();
                    for (int i = 0; i < all.length; i++) {
                        all[i].refresh();
                    }
                    
                }
            }
            
            public void fileDataCreated(FileEvent fe) {
                FileObject ffoo = fe.getFile(); 
                keepThem.add(ffoo);
                ((BaseFileObj)ffoo).getFileName().getFile().delete();
                ffoo.refresh();
            }            
        } );

        fo.refresh();
        assertEquals(0,fo.getChildren().length);
    }
    
    /**




package org.netbeans.modules.masterfs.providers;

import java.io.File;
import java.io.FileFilter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import junit.framework.AssertionFailedError;
import org.netbeans.junit.NbTestCase;
import org.netbeans.modules.masterfs.filebasedfs.FileBasedFileSystem;

        
        private static  boolean implsMoveRetVal = true;
        private static boolean implsRenameRetVal = true;
        private static boolean implsDeleteRetVal = true;
        
        public static FileLock lock;
        

            implsRenameCalls = 0;
            renameImplCalls = 0;
        }

        public ProvidedExtensions.DeleteHandler getDeleteHandler(File f) {
            return (!isImplsDeleteRetVal()) ? null : new ProvidedExtensions.DeleteHandler(){
                final Set s = new HashSet();
                public boolean delete(File file) {
                    if (file.isDirectory()) {
                        File[] childs = file.listFiles(new FileFilter() {
                            public boolean accept(File pathname) {
                                boolean accepted = pathname.isFile();
                                if (!accepted && pathname.isDirectory()) {
                                    accepted = !s.contains(pathname);
                                    if (!s.contains(pathname)) {
                                        s.add(pathname);
                                    }
                                } 
                                return accepted;
                            }
                        });
                        return childs.length == 0;
                    }
                    return file.delete();
                }                
            };
        }
                
        public ProvidedExtensions.IOHandler getRenameHandler(final File from, final String newName) {
            implsRenameCalls++;
            final File f = new File(from.getParentFile(),newName);

        public static void setImplsRenameRetVal(boolean implsRenameRetVal) {
            ProvidedExtensionsImpl.implsRenameRetVal = implsRenameRetVal;
        }
               
        public static boolean isImplsDeleteRetVal() {
            return implsDeleteRetVal;
        }
        
        public static void setImplsDeleteRetVal(boolean implsDeleteRetVal) {
            ProvidedExtensionsImpl.implsDeleteRetVal = implsDeleteRetVal;
        }                
    }
}

Return to bug 81510

Lines 23-28 Link Here

(-)src/org/netbeans/modules/masterfs/MasterFileObject.java (-14 / +39 lines)
23	import java.io.File;	23	import java.io.File;
24	import org.netbeans.modules.masterfs.filebasedfs.FileBasedFileSystem;	24	import org.netbeans.modules.masterfs.filebasedfs.FileBasedFileSystem;
25	import org.netbeans.modules.masterfs.filebasedfs.fileobjects.BaseFileObj;	25	import org.netbeans.modules.masterfs.filebasedfs.fileobjects.BaseFileObj;
		26	import org.netbeans.modules.masterfs.filebasedfs.naming.FileNaming;
26		27
27	import org.openide.ErrorManager;	28	import org.openide.ErrorManager;
28	import org.openide.filesystems.*;	29	import org.openide.filesystems.*;
Lines 83-89 Link Here
83	public boolean isValid() {	84	public boolean isValid() {
84	FileObject deleg = getValidOrInvalid(getDelegate().getPrefered());	85	FileObject deleg = getValidOrInvalid(getDelegate().getPrefered());
85	File f = (deleg.isVirtual()) ? null: getResource().getFile();	86	File f = (deleg.isVirtual()) ? null: getResource().getFile();
86	return (f != null) ? (deleg.isValid() && f.exists()) : deleg.isValid();	87	return (f != null) ? (deleg.isValid() && (f.exists())) : deleg.isValid();
87	}	88	}
88		89
89	/**	90	/**
Lines 291-303 Link Here
291	}	292	}
292	if (canRefresh) {	293	if (canRefresh) {
293	if (f != null && f.exists()) {	294	if (f != null && f.exists()) {
294	this.refresh();	295	if (getDeleteHandler(f) == null) {
295	if (deleg instanceof BaseFileObj) {//#54856	296	this.refresh();
296	FileObject child = deleg.getFileObject(name, ext);	297	if (deleg instanceof BaseFileObj) {//#54856
297	retVal = (child != null) ? transformChild(child) : null;	298	FileObject child = deleg.getFileObject(name, ext);
298	} else {	299	retVal = (child != null) ? transformChild(child) : null;
299	retVal = getCache().getOrCreate(childResourcePath);	300	} else {
300	}	301	retVal = getCache().getOrCreate(childResourcePath);
		302	}
		303	}
301	}	304	}
302	}	305	}
303	}	306	}
Lines 589-595 Link Here
589	finishCriticalSection();	592	finishCriticalSection();
590	}	593	}
591	}	594	}
592		595
593	private ProvidedExtensions.IOHandler getRenameHandler(final String name, final String ext) {	596	private ProvidedExtensions.IOHandler getRenameHandler(final String name, final String ext) {
594	ProvidedExtensions pe;	597	ProvidedExtensions pe;
595	pe = ((MasterFileSystem.StatusImpl)MasterFileSystem.getDefault().getStatus()).getExtensions();	598	pe = ((MasterFileSystem.StatusImpl)MasterFileSystem.getDefault().getStatus()).getExtensions();
Lines 907-915 Link Here
907	FileEvent fe2Fire = new FileEvent(MasterFileObject.this, eventFile, fe.isExpected());	910	FileEvent fe2Fire = new FileEvent(MasterFileObject.this, eventFile, fe.isExpected());
908	FileObject eventFileDelegate = eventFile.getDelegate().get();	911	FileObject eventFileDelegate = eventFile.getDelegate().get();
909	FileObject meDelegate = MasterFileObject.this.getDelegate().get();	912	FileObject meDelegate = MasterFileObject.this.getDelegate().get();
910		913	if (fe.getFile() instanceof BaseFileObj && eventFileDelegate instanceof BaseFileObj
911	if (eventFileDelegate == fe.getFile() && meDelegate == fe.getSource()) {	914	&& fe.getSource() instanceof BaseFileObj && meDelegate instanceof BaseFileObj) {
912	fireFileDeletedEvent(getEnumOfListeners(), fe2Fire);	915	FileNaming fName = ((BaseFileObj)fe.getFile()).getFileName();
		916	FileNaming sName = ((BaseFileObj)fe.getSource()).getFileName();
		917	FileNaming f1Name = ((BaseFileObj)eventFileDelegate).getFileName();
		918	FileNaming s1Name = ((BaseFileObj)meDelegate).getFileName();
		919	if (fName.equals(f1Name) && sName.equals(s1Name)) {
		920	fireFileDeletedEvent(getEnumOfListeners(), fe2Fire);
		921	}
		922	} else {
		923	if (eventFileDelegate == fe.getFile() && meDelegate == fe.getSource()) {
		924	fireFileDeletedEvent(getEnumOfListeners(), fe2Fire);
		925	}
913	}	926	}
914	}	927	}
915		928
Lines 960-965 Link Here
960	}	973	}
961	}	974	}
962		975
		976	private static ProvidedExtensions.DeleteHandler getDeleteHandler(File f) {
		977	ProvidedExtensions pe;
		978	pe = ((MasterFileSystem.StatusImpl)MasterFileSystem.getDefault().getStatus()).getExtensions();
		979
		980	return pe.getDeleteHandler(f);
		981	}
		982
963	private static final class AtomicAction implements FileSystem.AtomicAction {	983	private static final class AtomicAction implements FileSystem.AtomicAction {
964	private int operation;	984	private int operation;
965	private final MasterFileObject hfoI;	985	private final MasterFileObject hfoI;
Lines 1123-1129 Link Here
1123	private void delete() throws IOException {	1143	private void delete() throws IOException {
1124	FileObject deleg = getValidOrInvalid(hfoI.getDelegate().get(), hfoI);	1144	FileObject deleg = getValidOrInvalid(hfoI.getDelegate().get(), hfoI);
1125	FileLock lck = Delegate.getLockForDelegate(fLockI, deleg);	1145	FileLock lck = Delegate.getLockForDelegate(fLockI, deleg);
1126	deleg.delete(lck);	1146	if (deleg instanceof BaseFileObj) {
		1147	((BaseFileObj)deleg).delete(lck,
		1148	MasterFileObject.getDeleteHandler(((BaseFileObj)deleg).getFileName().getFile()));
		1149	} else {
		1150	deleg.delete(lck);
		1151	}
1127	}	1152	}
1128		1153
1129	private void move() throws IOException {	1154	private void move() throws IOException {
Lines 1154-1160 Link Here
1154	retVal = hfoI.superMove(fLockI, targetI, nameI, extI);	1179	retVal = hfoI.superMove(fLockI, targetI, nameI, extI);
1155	}	1180	}
1156	}	1181	}
1157		1182
1158	private ProvidedExtensions.IOHandler getMoveHandler() {	1183	private ProvidedExtensions.IOHandler getMoveHandler() {
1159	ProvidedExtensions pe;	1184	ProvidedExtensions pe;
1160	pe = ((MasterFileSystem.StatusImpl)MasterFileSystem.getDefault().getStatus()).getExtensions();	1185	pe = ((MasterFileSystem.StatusImpl)MasterFileSystem.getDefault().getStatus()).getExtensions();

Lines 23-28 Link Here

(-)apichanges.xml (+18 lines)
23	<apidef name="masterfs">MasterFileSystem API</apidef>	23	<apidef name="masterfs">MasterFileSystem API</apidef>
24	</apidefs>	24	</apidefs>
25	<changes>	25	<changes>
		26	<change id="added-support-for-subversion-delete">
		27	<api name="masterfs"/>
		28	<summary><code>ProvidedExtensions.getDeleteHandler</code> was added.</summary>
		29	<version major="1" minor="8" subminor="23"/>
		30	<date day="01" month="08" year="2006"/>
		31	<author login="rmatous"/>
		32	<compatibility addition="yes" binary="compatible" source="compatible" semantic="compatible" deprecation="no" deletion="no" modification="no"/>
		33	<description>
		34	<p>
		35	<code>ProvidedExtensions.getDeleteHandler</code> was added, which
		36	is the way how to impose handlers for
		37	deleting into mastersfs implementation
		38	which was required by module org.netbeans.modules.subversion.
		39	</p>
		40	</description>
		41	<class package="org.netbeans.modules.masterfs.providers" name="ProvidedExtensions"/>
		42	<issue number="81510"/>
		43	</change>
26	<change id="added-support-for-subversion">	44	<change id="added-support-for-subversion">
27	<api name="masterfs"/>	45	<api name="masterfs"/>
28	<summary><code>ProvidedExtensions</code> was added.</summary>	46	<summary><code>ProvidedExtensions</code> was added.</summary>

Lines 41-46 Link Here

(-)src/org/netbeans/modules/masterfs/ProvidedExtensionsProxy.java (-1 / +13 lines)
41	this.annotationProviders = annotationProviders;	41	this.annotationProviders = annotationProviders;
42	}	42	}
43		43
		44	public ProvidedExtensions.DeleteHandler getDeleteHandler(final File f) {
		45	ProvidedExtensions.DeleteHandler retValue = null;
		46	for (Iterator it = annotationProviders.iterator(); it.hasNext() && retValue == null;) {
		47	AnnotationProvider provider = (AnnotationProvider) it.next();
		48	final InterceptionListener iListener = (provider != null) ? provider.getInterceptionListener() : null;
		49	if (iListener instanceof ProvidedExtensions) {
		50	retValue = ((ProvidedExtensions)iListener).getDeleteHandler(f);
		51	}
		52	}
		53	return retValue;
		54	}
		55
44	public ProvidedExtensions.IOHandler getRenameHandler(final File from, final String newName) {	56	public ProvidedExtensions.IOHandler getRenameHandler(final File from, final String newName) {
45	final File to = new File(from.getParentFile(), newName);	57	final File to = new File(from.getParentFile(), newName);
46	IOHandler retValue = null;	58	IOHandler retValue = null;
Lines 124-128 Link Here
124	iListener.beforeDelete(fo);	136	iListener.beforeDelete(fo);
125	}	137	}
126	}	138	}
127	}	139	}
128	}	140	}

Lines 66-85 Link Here

(-)src/org/netbeans/modules/masterfs/filebasedfs/naming/NamingFactory.java (-6 / +8 lines)
66	}	66	}
67	}	67	}
68		68
69	public static synchronized boolean rename (FileNaming fNaming, String newName) {	69	private static synchronized FileNaming[] rename (FileNaming fNaming, String newName) {
70	return rename(fNaming, newName, null);	70	return rename(fNaming, newName, null);
71	}	71	}
72		72
73	public static synchronized boolean rename (FileNaming fNaming, String newName, ProvidedExtensions.IOHandler handler) {	73	public static synchronized FileNaming[] rename (FileNaming fNaming, String newName, ProvidedExtensions.IOHandler handler) {
		74	final ArrayList all = new ArrayList();
74	boolean retVal = false;	75	boolean retVal = false;
75	remove(fNaming, null);	76	remove(fNaming, null);
76	retVal = fNaming.rename(newName, handler);	77	retVal = fNaming.rename(newName, handler);
		78	all.add(fNaming);
77	NamingFactory.registerInstanceOfFileNaming(fNaming.getParent(), fNaming.getFile(), fNaming);	79	NamingFactory.registerInstanceOfFileNaming(fNaming.getParent(), fNaming.getFile(), fNaming);
78	renameChildren();	80	renameChildren(all);
79	return retVal;	81	return (retVal) ? ((FileNaming[])all.toArray(new FileNaming[all.size()])) : null;
80	}	82	}
81		83
82	private static void renameChildren() {	84	private static void renameChildren(final ArrayList all) {
83	HashMap toRename = new HashMap ();	85	HashMap toRename = new HashMap ();
84	for (Iterator iterator = nameMap.entrySet().iterator(); iterator.hasNext();) {	86	for (Iterator iterator = nameMap.entrySet().iterator(); iterator.hasNext();) {
85	Map.Entry entry = (Map.Entry) iterator.next();	87	Map.Entry entry = (Map.Entry) iterator.next();
Lines 101-107 Link Here
101	Map.Entry entry = (Map.Entry) iterator.next();	103	Map.Entry entry = (Map.Entry) iterator.next();
102	Integer id = (Integer)entry.getKey();	104	Integer id = (Integer)entry.getKey();
103	FileNaming fN = (FileNaming)entry.getValue();	105	FileNaming fN = (FileNaming)entry.getValue();
104		106	all.add(fN);
105	remove(fN, id);	107	remove(fN, id);
106	fN.getId(true);	108	fN.getId(true);
107	NamingFactory.registerInstanceOfFileNaming(fN.getParent(), fN.getFile(), fN);	109	NamingFactory.registerInstanceOfFileNaming(fN.getParent(), fN.getFile(), fN);

Lines 20-25 Link Here

(-)test/unit/src/org/netbeans/modules/masterfs/providers/ProvidedExtensionsTest.java (-1 / +37 lines)
20	package org.netbeans.modules.masterfs.providers;	20	package org.netbeans.modules.masterfs.providers;
21		21
22	import java.io.File;	22	import java.io.File;
		23	import java.io.FileFilter;
23	import java.io.FileInputStream;	24	import java.io.FileInputStream;
24	import java.io.FileOutputStream;	25	import java.io.FileOutputStream;
25	import java.io.IOException;	26	import java.io.IOException;
Lines 27-34 Link Here
27	import java.io.OutputStream;	28	import java.io.OutputStream;
28	import java.util.ArrayList;	29	import java.util.ArrayList;
29	import java.util.Collection;	30	import java.util.Collection;
		31	import java.util.HashSet;
30	import java.util.Iterator;	32	import java.util.Iterator;
31	import java.util.List;	33	import java.util.List;
		34	import java.util.Set;
32	import junit.framework.AssertionFailedError;	35	import junit.framework.AssertionFailedError;
33	import org.netbeans.junit.NbTestCase;	36	import org.netbeans.junit.NbTestCase;
34	import org.netbeans.modules.masterfs.filebasedfs.FileBasedFileSystem;	37	import org.netbeans.modules.masterfs.filebasedfs.FileBasedFileSystem;
Lines 368-373 Link Here
368		371
369	private static boolean implsMoveRetVal = true;	372	private static boolean implsMoveRetVal = true;
370	private static boolean implsRenameRetVal = true;	373	private static boolean implsRenameRetVal = true;
		374	private static boolean implsDeleteRetVal = true;
371		375
372	public static FileLock lock;	376	public static FileLock lock;
373		377
Lines 377-383 Link Here
377	implsRenameCalls = 0;	381	implsRenameCalls = 0;
378	renameImplCalls = 0;	382	renameImplCalls = 0;
379	}	383	}
380		384
		385	public ProvidedExtensions.DeleteHandler getDeleteHandler(File f) {
		386	return (!isImplsDeleteRetVal()) ? null : new ProvidedExtensions.DeleteHandler(){
		387	final Set s = new HashSet();
		388	public boolean delete(File file) {
		389	if (file.isDirectory()) {
		390	File[] childs = file.listFiles(new FileFilter() {
		391	public boolean accept(File pathname) {
		392	boolean accepted = pathname.isFile();
		393	if (!accepted && pathname.isDirectory()) {
		394	accepted = !s.contains(pathname);
		395	if (!s.contains(pathname)) {
		396	s.add(pathname);
		397	}
		398	}
		399	return accepted;
		400	}
		401	});
		402	return childs.length == 0;
		403	}
		404	return file.delete();
		405	}
		406	};
		407	}
		408
381	public ProvidedExtensions.IOHandler getRenameHandler(final File from, final String newName) {	409	public ProvidedExtensions.IOHandler getRenameHandler(final File from, final String newName) {
382	implsRenameCalls++;	410	implsRenameCalls++;
383	final File f = new File(from.getParentFile(),newName);	411	final File f = new File(from.getParentFile(),newName);
Lines 441-445 Link Here
441	public static void setImplsRenameRetVal(boolean implsRenameRetVal) {	469	public static void setImplsRenameRetVal(boolean implsRenameRetVal) {
442	ProvidedExtensionsImpl.implsRenameRetVal = implsRenameRetVal;	470	ProvidedExtensionsImpl.implsRenameRetVal = implsRenameRetVal;
443	}	471	}
		472
		473	public static boolean isImplsDeleteRetVal() {
		474	return implsDeleteRetVal;
		475	}
		476
		477	public static void setImplsDeleteRetVal(boolean implsDeleteRetVal) {
		478	ProvidedExtensionsImpl.implsDeleteRetVal = implsDeleteRetVal;
		479	}
444	}	480	}
445	}	481	}