SlingIOProvider.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.sling.scripting.java.impl;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

import org.apache.sling.api.SlingException;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.api.resource.ResourceMetadata;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.commons.compiler.JavaCompiler;
import org.apache.sling.commons.compiler.Options;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * The <code>SlingIOProvider</code>
 */
public class SlingIOProvider  {

    /** Default logger */
    private final Logger logger = LoggerFactory.getLogger(SlingIOProvider.class);

    private ThreadLocal<ResourceResolver> requestResourceResolver;

    private final JavaCompiler compiler;

    /** Options for compilation. */
    private final CompilerOptions options;

    /** Options for compilation including the force compile option. */
    private final CompilerOptions forceCompileOptions;

    /**
     * Servlet cache.
     */
    private final ServletCache servletCache = new ServletCache();

    /**
     * Constructor.
     */
    SlingIOProvider(final JavaCompiler compiler,
                    final CompilerOptions options) {
        this.requestResourceResolver = new ThreadLocal<ResourceResolver>();
        this.compiler = compiler;
        this.options = options;
        this.forceCompileOptions = CompilerOptions.copyOptions(options);
        this.forceCompileOptions.put(Options.KEY_FORCE_COMPILATION, true);
    }

    void destroy() {
        this.servletCache.destroy();
    }

    void setRequestResourceResolver(ResourceResolver resolver) {
        requestResourceResolver.set(resolver);
    }

    void resetRequestResourceResolver() {
        requestResourceResolver.remove();
    }

    // ---------- IOProvider interface -----------------------------------------

    public JavaCompiler getCompiler() {
        return this.compiler;
    }

    public CompilerOptions getOptions() {
        return this.options;
    }

    public CompilerOptions getForceCompileOptions() {
        return this.forceCompileOptions;
    }

    public ServletCache getServletCache() {
        return this.servletCache;
    }

    /**
     * Returns an InputStream for the file name which is looked up with the
     * ResourceProvider and retrieved from the Resource if the StreamProvider
     * interface is implemented.
     */
    public InputStream getInputStream(String fileName)
    throws FileNotFoundException, IOException {
        try {
            final Resource resource = getResourceInternal(fileName);
            if (resource == null) {
                throw new FileNotFoundException("Cannot find " + fileName);
            }

            final InputStream stream = resource.adaptTo(InputStream.class);
            if (stream == null) {
                throw new FileNotFoundException("Cannot find " + fileName);
            }

            return stream;

        } catch (SlingException se) {
            throw (IOException) new IOException(
                "Failed to get InputStream for " + fileName).initCause(se);
        }
    }

    /**
     * Returns the value of the last modified meta data field of the resource
     * found at file name or zero if the meta data field is not set. If the
     * resource does not exist or an error occurrs finding the resource, -1 is
     * returned.
     */
    public long lastModified(String fileName) {
        try {
            final Resource resource = getResourceInternal(fileName);
            if (resource != null) {
                final ResourceMetadata meta = resource.getResourceMetadata();
                final long modTime = meta.getModificationTime();
                return (modTime > 0) ? modTime : 0;
            }

        } catch (SlingException se) {
            logger.error("Cannot get last modification time for " + fileName, se);
        }

        // fallback to "non-existant" in case of problems
        return -1;
    }

    public URL getURL(String path) throws MalformedURLException {
        try {
            final Resource resource = getResourceInternal(path);
            return resource != null ? resource.adaptTo(URL.class) : null;
        } catch (SlingException se) {
            throw (MalformedURLException) new MalformedURLException(
                "Cannot get URL for " + path).initCause(se);
        }
    }

    public Set<String> getResourcePaths(final String path) {
        final Set<String> paths = new HashSet<String>();
        try {
            final Resource resource = getResourceInternal(path);
            if (resource != null) {
                final Iterator<Resource> entries = resource.getResourceResolver().listChildren(resource);
                while (entries.hasNext()) {
                    paths.add(entries.next().getPath());
                }
            }
        } catch (SlingException se) {
            logger.warn("Unable to get resource at path " + path, se);
        }

        return paths.isEmpty() ? null : paths;
    }

    private Resource getResourceInternal(String path) throws SlingException {
        ResourceResolver resolver = requestResourceResolver.get();
        if (resolver != null) {
            return resolver.getResource(path);
        }

        return null;
    }

}