BndJarResourceStore.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.felix.ipojo.bnd;

import static java.lang.String.format;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.jar.Attributes;
import java.util.jar.Manifest;

import org.apache.felix.ipojo.manipulator.ResourceStore;
import org.apache.felix.ipojo.manipulator.ResourceVisitor;
import org.apache.felix.ipojo.manipulator.render.MetadataRenderer;
import org.apache.felix.ipojo.manipulator.util.Constants;
import org.apache.felix.ipojo.manipulator.util.Metadatas;
import org.apache.felix.ipojo.manipulator.util.Streams;
import org.apache.felix.ipojo.metadata.Element;

import aQute.bnd.header.Attrs;
import aQute.bnd.osgi.Analyzer;
import aQute.bnd.osgi.Clazz;
import aQute.bnd.osgi.Jar;
import aQute.bnd.osgi.Resource;
import aQute.service.reporter.Reporter;

public class BndJarResourceStore implements ResourceStore {

    private Analyzer m_analyzer;
    private Reporter m_reporter;

    private MetadataRenderer m_renderer = new MetadataRenderer();

    private List<Element> m_metadata;
    private boolean m_includeEmbedComponents;

    public BndJarResourceStore(Analyzer analyzer, Reporter reporter) {
        m_metadata = new ArrayList<Element>();
        m_analyzer = analyzer;
        m_reporter = reporter;
    }

    public byte[] read(String path) throws IOException {

        // Find the resource either in the global jar or in one of the embed dependencies
        Resource resource = m_analyzer.getJar().getResource(path);
        if (resource == null) {
            Jar embed = findJar(path);
            if (embed == null) {
                throw new IOException(format("Cannot find resource %s in jar and classpath", path));
            }
            resource = embed.getResource(path);
        }
        InputStream is = null;
        try {
            is = resource.openInputStream();
        } catch (Exception e) {
            throw new IOException("Cannot read " + path);
        }
        return Streams.readBytes(is);
    }

    public void accept(ResourceVisitor visitor) {

        try {
            // Collect all annotated classes
            Collection<Clazz> classes = m_analyzer.getClasses("",
                    Clazz.QUERY.CLASSANNOTATIONS.name());

            classes = filter(classes);

            // Iterates over discovered resources
            for (Clazz clazz : classes) {
                visitor.visit(clazz.getAbsolutePath());
            }
        } catch (Exception e) {
            m_reporter.error("Cannot find iPOJO annotated types: " + e.getMessage());
        }
    }

    private Collection<Clazz> filter(Collection<Clazz> classes) throws Exception {
        Set<Clazz> manipulable = new HashSet<Clazz>();
        for (Clazz clazz : classes) {

            // If it is in the main jar, simply use it
            if (m_analyzer.getJar().getResource(clazz.getAbsolutePath()) != null) {
                manipulable.add(clazz);
                continue;
            }

            if (m_includeEmbedComponents) {
                // Otherwise ...
                // Try to see if it is in an embed dependencies
                Jar jar = findJar(clazz.getAbsolutePath());
                if (jar == null) {
                    m_reporter.error("Resource for class %s not found in classpath", clazz.getFQN());
                    continue;
                }

                // Is it a Bundle ?
                if (jar.getBsn() != null) {
                    // OSGi Bundle case

                    // Check if the bundle was manipulated before
                    Attributes attr = jar.getManifest().getMainAttributes();
                    if (Manifests.getComponents(attr) != null) {
                        // Bundle has been previously manipulated
                        // TODO We should ignore the resource since it was already manipulated
                        // TODO But we should also merge its IPOJO-Components header
                    } else {
                        // Bundle was not manipulated
                        manipulable.add(clazz);
                    }

                } else  {
                    // Simple Jar file with iPOJO annotations
                    m_reporter.warning("Class %s found in a non-Bundle archive %s", clazz.getFQN(), jar.getName());
                    continue;
                }
            } else {
                m_reporter.warning("Embed components are excluded, Component %s will not be manipulated", clazz.getFQN());
            }
        }
        return manipulable;
    }

    private Jar findJar(String path) {
        for (Jar jar : m_analyzer.getClasspath()) {
            if (jar.getResource(path) != null) {
                return jar;
            }
        }
        return null;
    }

    public void open() throws IOException {
        // nothing to do
    }

    public void writeMetadata(Element metadata) {
        m_metadata.add(metadata);

        // Find referred packages and add them into Bnd
        for (String referred : Metadatas.findReferredPackages(metadata)) {
            if (!m_analyzer.getReferred().containsFQN(referred)) {
                // The given package is not referred ATM
                m_analyzer.getReferred().put(m_analyzer.getPackageRef(referred),
                                             new Attrs());
            }
        }

        // IPOJO-Components will be written during the close method.
    }

    public void write(String resourcePath, byte[] resource) throws IOException {
        Jar jar = m_analyzer.getJar();
        jar.putResource(resourcePath, new ByteArrayResource(resource));
    }

    public void close() throws IOException {

        // Write the iPOJO header (including manipulation metadata)
        StringBuilder builder = new StringBuilder();

        if (m_includeEmbedComponents) {
            // Incorporate metadata of embed dependencies (if any)
            for (Jar jar : m_analyzer.getClasspath()) {
                try {
                    Manifest manifest = jar.getManifest();
                    Attributes main = manifest.getMainAttributes();
                    String components = Manifests.getComponents(main);
                    if (components != null) {
                        m_reporter.trace("Merging components from %s", jar.getName());
                        builder.append(components);
                    }
                } catch (Exception e) {
                    m_reporter.warning("Cannot open MANIFEST of %s", jar.getName());
                }
            }
        }

        for (Element metadata : m_metadata) {
            builder.append(m_renderer.render(metadata));
        }

        if (builder.length() != 0) {
            m_analyzer.setProperty("IPOJO-Components", builder.toString());
        }

        // Add some mandatory imported packages
        Attrs version = new Attrs();
        version.put("version:Version", Constants.getPackageImportClause());

        if (!m_analyzer.getReferred().containsFQN("org.apache.felix.ipojo")) {
            m_analyzer.getReferred().put(m_analyzer.getPackageRef("org.apache.felix.ipojo"),
                                         version);
        }
        if (!m_analyzer.getReferred().containsFQN("org.apache.felix.ipojo.architecture")) {
            m_analyzer.getReferred().put(m_analyzer.getPackageRef("org.apache.felix.ipojo.architecture"),
                                         version);
        }
        if (!m_analyzer.getReferred().containsFQN("org.osgi.service.cm")) {
            Attrs cm = new Attrs();
            cm.put("version:Version", "1.2");
            m_analyzer.getReferred().put(m_analyzer.getPackageRef("org.osgi.service.cm"),
                                         cm);
        }
        if (!m_analyzer.getReferred().containsFQN("org.osgi.service.log")) {
            Attrs log = new Attrs();
            log.put("version:Version", "1.3");
            m_analyzer.getReferred().put(m_analyzer.getPackageRef("org.osgi.service.log"),
                                         log);
        }


    }

    public void setIncludeEmbedComponents(boolean excludeEmbedComponents) {
        m_includeEmbedComponents = excludeEmbedComponents;
    }
}