001    /*
002     * Licensed to the Apache Software Foundation (ASF) under one or more
003     * contributor license agreements.  See the NOTICE file distributed with
004     * this work for additional information regarding copyright ownership.
005     * The ASF licenses this file to You under the Apache License, Version 2.0
006     * (the "License"); you may not use this file except in compliance with
007     * the License.  You may obtain a copy of the License at
008     *
009     *     http://www.apache.org/licenses/LICENSE-2.0
010     *
011     * Unless required by applicable law or agreed to in writing, software
012     * distributed under the License is distributed on an "AS IS" BASIS,
013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014     * See the License for the specific language governing permissions and
015     * limitations under the License.
016     */
017    package org.apache.commons.configuration;
018    
019    import java.io.File;
020    import java.io.InputStream;
021    import java.io.OutputStream;
022    import java.net.MalformedURLException;
023    import java.net.URL;
024    
025    import org.apache.commons.logging.Log;
026    import org.apache.commons.logging.LogFactory;
027    import org.apache.commons.logging.impl.NoOpLog;
028    
029    /**
030     * Abstract layer to allow various types of file systems.
031     * @since 1.7
032     * @author <a
033     * href="http://commons.apache.org/configuration/team-list.html">Commons Configuration team</a>
034     * @version $Id: FileSystem.java 1209996 2011-12-03 20:24:21Z oheger $
035     */
036    public abstract class FileSystem
037    {
038        /** The name of the system property that can be used to set the file system class name */
039        private static final String FILE_SYSTEM = "org.apache.commons.configuration.filesystem";
040    
041        /** The default file system */
042        private static FileSystem fileSystem;
043    
044        /** The Logger */
045        private Log log;
046    
047        /** FileSystem options provider */
048        private FileOptionsProvider optionsProvider;
049    
050        public FileSystem()
051        {
052            setLogger(null);
053        }
054    
055        /**
056         * Returns the logger used by this FileSystem.
057         *
058         * @return the logger
059         */
060        public Log getLogger()
061        {
062            return log;
063        }
064    
065        /**
066         * Allows to set the logger to be used by this FileSystem. This
067         * method makes it possible for clients to exactly control logging behavior.
068         * Per default a logger is set that will ignore all log messages. Derived
069         * classes that want to enable logging should call this method during their
070         * initialization with the logger to be used.
071         *
072         * @param log the new logger
073         */
074        public void setLogger(Log log)
075        {
076            this.log = (log != null) ? log : new NoOpLog();
077        }
078    
079        static
080        {
081            String fsClassName = System.getProperty(FILE_SYSTEM);
082            if (fsClassName != null)
083            {
084                Log log = LogFactory.getLog(FileSystem.class);
085    
086                try
087                {
088                    Class<?> clazz = Class.forName(fsClassName);
089                    if (FileSystem.class.isAssignableFrom(clazz))
090                    {
091                        fileSystem = (FileSystem) clazz.newInstance();
092                        if (log.isDebugEnabled())
093                        {
094                            log.debug("Using " + fsClassName);
095                        }
096                    }
097                }
098                catch (InstantiationException ex)
099                {
100                    log.error("Unable to create " + fsClassName, ex);
101                }
102                catch (IllegalAccessException ex)
103                {
104                    log.error("Unable to create " + fsClassName, ex);
105                }
106                catch (ClassNotFoundException ex)
107                {
108                    log.error("Unable to create " + fsClassName, ex);
109                }
110            }
111    
112            if (fileSystem == null)
113            {
114                fileSystem = new DefaultFileSystem();
115            }
116        }
117    
118        /**
119         * Set the FileSystem to use.
120         * @param fs The FileSystem
121         * @throws NullPointerException if the FileSystem parameter is null.
122         */
123        public static void setDefaultFileSystem(FileSystem fs) throws NullPointerException
124        {
125            if (fs == null)
126            {
127                throw new NullPointerException("A FileSystem implementation is required");
128            }
129            fileSystem = fs;
130        }
131    
132        /**
133         * Reset the FileSystem to the default.
134         */
135        public static void resetDefaultFileSystem()
136        {
137            fileSystem = new DefaultFileSystem();
138        }
139    
140        /**
141         * Retrieve the FileSystem being used.
142         * @return The FileSystem.
143         */
144        public static FileSystem getDefaultFileSystem()
145        {
146            return fileSystem;
147        }
148    
149        /**
150         * Set the FileOptionsProvider
151         * @param provider The FileOptionsProvider
152         */
153        public void setFileOptionsProvider(FileOptionsProvider provider)
154        {
155            this.optionsProvider = provider;
156        }
157    
158        public FileOptionsProvider getFileOptionsProvider()
159        {
160            return this.optionsProvider;
161        }
162    
163        public abstract InputStream getInputStream(String basePath, String fileName)
164                throws ConfigurationException;
165    
166        public abstract InputStream getInputStream(URL url) throws ConfigurationException;
167    
168        public abstract OutputStream getOutputStream(URL url) throws ConfigurationException;
169    
170        public abstract OutputStream getOutputStream(File file) throws ConfigurationException;
171    
172        public abstract String getPath(File file, URL url, String basePath, String fileName);
173    
174        public abstract String getBasePath(String path);
175    
176        public abstract String getFileName(String path);
177    
178        public abstract URL locateFromURL(String basePath, String fileName);
179    
180        public abstract URL getURL(String basePath, String fileName) throws MalformedURLException;
181    }