org.netbeans.core.filesystems.NbinstURLStreamHandlerFactory

org.netbeans.core.filesystems.NbinstURLMapper

/*

 *                 Sun Public License Notice

 *

 * The contents of this file are subject to the Sun Public License

 * Version 1.0 (the "License"). You may not use this file except in

 * compliance with the License. A copy of the License is available at

 * http://www.sun.com/

 *

 * The Original Code is NetBeans. The Initial Developer of the Original

 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2004 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans.core.filesystems;

import java.io.File;

import java.io.UnsupportedEncodingException;

import java.net.URL;

import java.net.URLDecoder;

import org.openide.ErrorManager;

import org.openide.filesystems.FileObject;

import org.openide.filesystems.FileUtil;

import org.openide.filesystems.URLMapper;

import org.openide.modules.InstalledFileLocator;

/**

 * URLMapper for the nbinst URL protocol.

 * The mapper handles only the translation from URL into FileObjects.

 * The opposite conversion is not needed, it is handled by the default URLMapper.

 * The format of the nbinst URL is nbinst://host/path.

 * The host part is optional, if presents it specifies the name of the supplying module.

 * The path is mandatory and specifies the relative path from the ${netbeans.home}, ${netbeans.user}

 * or ${netbeans.dirs}.

 * @author  Tomas Zezula

 */

public class NbinstURLMapper extends URLMapper {

    public static final String PROTOCOL = "nbinst";     //NOI18N

    /** Creates a new instance of NbInstURLMapper */

    public NbinstURLMapper() {

    }

    /**

     * Returns FileObjects for given URL

     * @param url the URL for which the FileObjects should be find.

     * @return FileObject[], never returns null, may return empty array.

     */

    public FileObject[] getFileObjects(URL url) {

        return decodeURL (url);

    }

    /**

     * Returns null, the translation into URL is doen by default URLMapper

     * @param fo

     * @param type

     * @return

     */

    public URL getURL(FileObject fo, int type) {

        return null;

    }

    /**

     * Resolves the nbinst URL into the array of the FileObjects.

     * @param url to be resolved

     * @return FileObject[], never returns null, may return empty array.

     */

    static FileObject[] decodeURL (URL url) {

        assert url != null;

        String protocol = url.getProtocol();

        if (PROTOCOL.equals(protocol)) {

            String module = url.getHost();

            if (module.length() == 0) {

                module = null;

            }

            String path = url.getPath();

            if (path.length()>0) {

                try {

                path = URLDecoder.decode(path.substring(1),"UTF-8");        //NOI18N

                File file = InstalledFileLocator.getDefault().locate(path,module,false);

                if (file != null) {

                    return FileUtil.fromFile(file);

                }

                } catch (UnsupportedEncodingException e) {

                    ErrorManager.getDefault().notify(e);

                }

            }

        }

        return new FileObject[0];

    }

}

/*

 *                 Sun Public License Notice

 *

 * The contents of this file are subject to the Sun Public License

 * Version 1.0 (the "License"). You may not use this file except in

 * compliance with the License. A copy of the License is available at

 * http://www.sun.com/

 *

 * The Original Code is NetBeans. The Initial Developer of the Original

 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2003 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans.core.filesystems;

import java.io.IOException;

import java.io.FileNotFoundException;

import java.io.InputStream;

import java.io.OutputStream;

import java.net.URL;

import java.net.URLConnection;

import java.net.URLStreamHandler;

import java.net.URLStreamHandlerFactory;

import java.net.UnknownServiceException;

import org.openide.ErrorManager;

import org.openide.filesystems.FileObject;

import org.openide.filesystems.FileLock;

/**

 * StreamHandlerFactory for nbinst protocol

 */

public class NbinstURLStreamHandlerFactory implements URLStreamHandlerFactory {

    /**

     * Creates URLStreamHandler for nbinst protocol

     * @param protocol

     * @return NbinstURLStreamHandler if the protocol is nbinst otherwise null

     */

    public URLStreamHandler createURLStreamHandler(String protocol) {

        if (NbinstURLMapper.PROTOCOL.equals(protocol)) {

            return new NbinstURLStreamHandler ();

        }

        return null;

    }

    /**

     * URLStreamHandler for nbinst protocol

     */

    private static class NbinstURLStreamHandler extends URLStreamHandler {

        /**

         * Creates URLConnection for URL with nbinst protocol.

         * @param u URL for which the URLConnection should be created

         * @return URLConnection

         * @throws IOException

         */

        protected URLConnection openConnection(URL u) throws IOException {

            return new NbinstURLConnection (u);

        }

    }

    /** URLConnection for URL with nbinst protocol.

     *

     */

    private static class NbinstURLConnection extends URLConnection {

        private FileObject fo;

        private InputStream iStream;

        private OutputStream oStream;

        /**

         * Creates new URLConnection

         * @param url the parameter for which the connection should be

         * created

         */

        public NbinstURLConnection (URL url) {

            super (url);

        }

        public void connect() throws IOException {

            if (fo != null) {

                return;

            }

            FileObject[] decoded = NbinstURLMapper.decodeURL(this.url);

            if (decoded.length>0) {

                fo = decoded[0];

            }

            else {

                throw new FileNotFoundException("Cannot find: " + url); // NOI18N

            }

        }

        public int getContentLength() {

            try {

                this.connect();

                return (int) this.fo.getSize();     //May cause overflow long->int

            } catch (IOException e) {

                return -1;

            }

        }

        public InputStream getInputStream() throws IOException {

            this.connect();

            if (fo.isFolder()) {

                throw new UnknownServiceException ();

            }

            if (iStream == null) {

                iStream = fo.getInputStream();

            }

            return iStream;

        }

        public OutputStream getOutputStream() throws IOException {

            this.connect();

            if (fo.isFolder()) {

                throw new UnknownServiceException ();

            }

            FileLock flock = fo.lock();

            if (oStream == null) {

                oStream = new LockOS (fo.getOutputStream(flock), flock);

            }

            return oStream;

        }

        public String getHeaderField (String name) {

            if ("content-type".equals(name)) {                  //NOI18N

                try {

                    this.connect();

                    return fo.getMIMEType();

                } catch (IOException ioe) {

                    ErrorManager.getDefault().notify(ioe);

                }

            }

            return super.getHeaderField(name);

        }

    }

    /** Stream that also closes the lock, if closed.

     */

    private static class LockOS extends java.io.BufferedOutputStream {

        /** lock */

        private FileLock flock;

        /**

        * @param os is an OutputStream for writing in

        * @param lock is a lock for the stream

        */

        public LockOS (OutputStream os, FileLock lock)

        throws IOException {

            super(os);

            flock = lock;

        }

        /** overriden */

        public void close()

        throws IOException {

            flock.releaseLock();

            super.close();

        }

    }

}

                <include name="org/netbeans/core/filesystems/NbinstURLMapperTest.class"/>

/*

 *                 Sun Public License Notice

 *

 * The contents of this file are subject to the Sun Public License

 * Version 1.0 (the "License"). You may not use this file except in

 * compliance with the License. A copy of the License is available at

 * http://www.sun.com/

 *

 * The Original Code is NetBeans. The Initial Developer of the Original

 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2004 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans.core.filesystems;

import java.beans.PropertyVetoException;

import java.io.*;

import java.net.MalformedURLException;

import java.net.URL;

import java.net.URLConnection;

import java.util.StringTokenizer;

import org.openide.filesystems.*;

import org.openide.util.Lookup;

import org.openide.modules.InstalledFileLocator;

import org.netbeans.junit.NbTestCase;

public class NbinstURLMapperTest extends NbTestCase {

    private static final String FILE_NAME = "test.txt";     //NOI18N

    private static final String FOLDER_NAME = "modules";    //NOI18N

    private FileSystem fs;

    private int expectedLength;

    public NbinstURLMapperTest (String testName) throws IOException {

        super (testName);

    }

    protected void setUp() throws Exception {

        super.setUp();

        File f = this.getWorkDir();

        Lookup.Result result = Lookup.getDefault().lookup (new Lookup.Template(InstalledFileLocator.class));

        for (java.util.Iterator it = result.allInstances().iterator(); it.hasNext();) {

            Object locator = it.next();

            if (locator instanceof TestInstalledFileLocator) {

                ((TestInstalledFileLocator)locator).setRoot(f);

            }

        }

        f = new File (f,FOLDER_NAME);

        f.mkdir();

        f = new File (f,FILE_NAME);

        f.createNewFile();

        PrintWriter pw = null;

        try {

            pw = new PrintWriter(new FileWriter(f));

            pw.println(FILE_NAME);

        } finally {

            if (pw!=null) {

                pw.close ();

            }

        }

        this.expectedLength = (int) f.length();

        this.fs = this.mountFs ();

        assertNotNull (this.fs);

    }

    protected void tearDown() throws Exception {

        this.umountFs (this.fs);

        File f = new File (this.getWorkDir(),FOLDER_NAME);

        cleanUp (f);

        super.tearDown();

    }

    public void testFindFileObject () throws MalformedURLException, IOException {

        URL url = new URL (null,"nbinst:///modules/test.txt");  //NOI18N

        FileObject[] fos = URLMapper.findFileObjects (url);

        assertTrue (fos!=null);

        assertTrue (fos.length == 1);

    }

    public void testURLConenction () throws MalformedURLException, IOException {

        URL url = new URL ("nbinst:///modules/test.txt");                //NOI18N

        URLConnection connection = url.openConnection();

        assertTrue (connection.getContentLength()==expectedLength);

        BufferedReader in = null;

        try {

            in = new BufferedReader  ( new InputStreamReader (connection.getInputStream()));

            String line = in.readLine();

            assertTrue(line.equals(FILE_NAME));

        } finally {

            if (in != null) {

                in.close ();

            }

        }

    }

    private FileSystem mountFs () throws IOException {

        File f = FileUtil.normalizeFile(this.getWorkDir());

        String parentName;

        while ((parentName=f.getParent())!=null) {

            f = new File (parentName);

        }

        try {

            LocalFileSystem fs = new LocalFileSystem ();

            fs.setRootDirectory (f);

            Repository.getDefault().addFileSystem(fs);

            return fs;

        } catch (PropertyVetoException pve) {

            return null;

        }

    }

    private void umountFs (FileSystem fs) {

        assertNotNull (fs);

        Repository.getDefault().removeFileSystem(fs);

    }

    private void cleanUp (File f) {

        if (f.isDirectory()) {

            File[] files = f.listFiles();

            for (int i = 0; i < files.length; i++) {

                cleanUp(files[i]);

            }

        }

        f.delete();

    }

    public static class TestInstalledFileLocator extends InstalledFileLocator {

        private File root;

        public TestInstalledFileLocator () {

        }

        public void setRoot (File root) {

            this.root = root;

        }

        public File locate(String relativePath, String codeNameBase, boolean localized) {

            assert relativePath != null;

            if (root == null) {

                return null;

            }

            StringTokenizer tk = new StringTokenizer(relativePath,"/");

            File f = this.root;

            while (tk.hasMoreTokens()) {

                String part = tk.nextToken();

                f = new File (f,part);

                if (!f.exists()) {

                    return null;

                }

            }

            return f;

        }

    }

}