001/*
002 * Licensed to the Apache Software Foundation (ASF) under one
003 * or more contributor license agreements.  See the NOTICE file
004 * distributed with this work for additional information
005 * regarding copyright ownership.  The ASF licenses this file
006 * to you under the Apache License, Version 2.0 (the
007 * "License"); you may not use this file except in compliance
008 * with the License.  You may obtain a copy of the License at
009 *
010 *  http://www.apache.org/licenses/LICENSE-2.0
011 *
012 * Unless required by applicable law or agreed to in writing,
013 * software distributed under the License is distributed on an
014 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
015 * KIND, either express or implied.  See the License for the
016 * specific language governing permissions and limitations
017 * under the License.
018 */
019
020package org.apache.xbean.osgi.bundle.util;
021
022import java.io.FilterInputStream;
023import java.io.IOException;
024import java.io.InputStream;
025import java.net.URL;
026import java.util.Enumeration;
027import java.util.LinkedHashSet;
028import java.util.List;
029import java.util.Set;
030import java.util.zip.ZipEntry;
031import java.util.zip.ZipInputStream;
032
033import org.apache.xbean.osgi.bundle.util.BundleDescription.HeaderEntry;
034import org.osgi.framework.Bundle;
035import org.osgi.service.packageadmin.PackageAdmin;
036
037/**
038 * Finds all available resources to a bundle by scanning Bundle-ClassPath header
039 * of the given bundle and its fragments.
040 * DynamicImport-Package header is not considered during scanning.
041 *
042 * @version $Rev: 942661 $ $Date: 2010-05-10 07:17:20 +0200 (lun. 10 mai 2010) $
043 */
044public class BundleResourceFinder {
045
046    public static final ResourceDiscoveryFilter FULL_DISCOVERY_FILTER = new DummyDiscoveryFilter();
047    private final Bundle bundle;
048    private final PackageAdmin packageAdmin;
049    private final String prefix;
050    private final String suffix;
051    private ResourceDiscoveryFilter discoveryFilter;
052
053    public BundleResourceFinder(PackageAdmin packageAdmin, Bundle bundle, String prefix, String suffix) {
054        this(packageAdmin, bundle, prefix, suffix, FULL_DISCOVERY_FILTER);
055    }
056
057    public BundleResourceFinder(PackageAdmin packageAdmin, Bundle bundle, String prefix, String suffix, ResourceDiscoveryFilter discoveryFilter) {
058        this.packageAdmin = packageAdmin;
059        this.bundle = bundle;
060        this.prefix = prefix.trim();
061        this.suffix = suffix.trim();
062        this.discoveryFilter = discoveryFilter;
063    }
064
065    public void find(ResourceFinderCallback callback) throws Exception {
066        if (discoveryFilter.rangeDiscoveryRequired(DiscoveryRange.BUNDLE_CLASSPATH)) {
067            scanBundleClassPath(callback, bundle);
068        }
069        if (packageAdmin != null && discoveryFilter.rangeDiscoveryRequired(DiscoveryRange.FRAGMENT_BUNDLES)) {
070            Bundle[] fragments = packageAdmin.getFragments(bundle);
071            if (fragments != null) {
072                for (Bundle fragment : fragments) {
073                    scanBundleClassPath(callback, fragment);
074                }
075            }
076        }
077    }
078
079    public Set<URL> find() {
080        Set<URL> resources = new LinkedHashSet<URL>();
081        try {
082            find(new DefaultResourceFinderCallback(resources));
083        } catch (Exception e) {
084            // this should not happen
085            throw new RuntimeException("Resource discovery failed", e);
086        }
087        return resources;
088    }
089
090    private void scanBundleClassPath(ResourceFinderCallback callback, Bundle bundle) throws Exception {
091        BundleDescription desc = new BundleDescription(bundle.getHeaders());
092        List<HeaderEntry> paths = desc.getBundleClassPath();
093        if (paths.isEmpty()) {
094            scanDirectory(callback, bundle, prefix);
095        } else {
096            for (HeaderEntry path : paths) {
097                String name = path.getName();
098                if (name.equals(".") || name.equals("/")) {
099                    // scan root
100                    scanDirectory(callback, bundle, prefix);
101                } else if (name.endsWith(".jar") || name.endsWith(".zip")) {
102                    // scan embedded jar/zip
103                    scanZip(callback, bundle, name);
104                } else {
105                    // assume it's a directory
106                    scanDirectory(callback, bundle, addSlash(prefix) + name);
107                }
108            }
109        }
110    }
111
112    private void scanDirectory(ResourceFinderCallback callback, Bundle bundle, String basePath) throws Exception {
113        if (!discoveryFilter.directoryDiscoveryRequired(basePath)) {
114            return;
115        }
116        Enumeration e = bundle.findEntries(basePath, "*" + suffix, true);
117        if (e != null) {
118            while (e.hasMoreElements()) {
119                callback.foundInDirectory(bundle, basePath, (URL) e.nextElement());
120            }
121        }
122    }
123
124    private void scanZip(ResourceFinderCallback callback, Bundle bundle, String zipName) throws Exception {
125        if (!discoveryFilter.zipFileDiscoveryRequired(zipName)) {
126            return;
127        }
128        URL zipEntry = bundle.getEntry(zipName);
129        if (zipEntry == null) {
130            return;
131        }
132        try {
133            ZipInputStream in = new ZipInputStream(zipEntry.openStream());
134            ZipEntry entry;
135            while ((entry = in.getNextEntry()) != null) {
136                String name = entry.getName();
137                if (prefixMatches(name) && suffixMatches(name)) {
138                    callback.foundInJar(bundle, zipName, entry, new ZipEntryInputStream(in));
139                }
140            }
141        } catch (IOException e) {
142            e.printStackTrace();
143        }
144    }
145
146    private static class ZipEntryInputStream extends FilterInputStream {
147        public ZipEntryInputStream(ZipInputStream in) {
148            super(in);
149        }
150        public void close() throws IOException {
151            // not really necessary
152            // ((ZipInputStream) in).closeEntry();
153        }
154    }
155
156    private boolean prefixMatches(String name) {
157        if (prefix.length() == 0 || prefix.equals(".") || prefix.equals("/")) {
158            return true;
159        } else if (prefix.startsWith("/")) {
160            return name.startsWith(prefix, 1);
161        } else {
162            return name.startsWith(prefix);
163        }
164    }
165
166    private boolean suffixMatches(String name) {
167        return (suffix.length() == 0) ? true : name.endsWith(suffix);
168    }
169
170    private static String addSlash(String name) {
171        if (!name.endsWith("/")) {
172            name = name + "/";
173        }
174        return name;
175    }
176
177    public interface ResourceFinderCallback {
178        void foundInDirectory(Bundle bundle, String baseDir, URL url) throws Exception;
179
180        void foundInJar(Bundle bundle, String jarName, ZipEntry entry, InputStream in) throws Exception;
181    }
182
183    public static class DefaultResourceFinderCallback implements ResourceFinderCallback {
184
185        private Set<URL> resources;
186
187        public DefaultResourceFinderCallback() {
188            this(new LinkedHashSet<URL>());
189        }
190
191        public DefaultResourceFinderCallback(Set<URL> resources) {
192            this.resources = resources;
193        }
194
195        public Set<URL> getResources() {
196            return resources;
197        }
198
199        public void foundInDirectory(Bundle bundle, String baseDir, URL url) throws Exception {
200            resources.add(url);
201        }
202
203        public void foundInJar(Bundle bundle, String jarName, ZipEntry entry, InputStream in) throws Exception {
204            URL jarURL = bundle.getEntry(jarName);
205            URL url = new URL("jar:" + jarURL.toString() + "!/" + entry.getName());
206            resources.add(url);
207        }
208
209    }
210
211    public static class DummyDiscoveryFilter implements ResourceDiscoveryFilter {
212
213
214        public boolean directoryDiscoveryRequired(String url) {
215            return true;
216        }
217
218
219        public boolean rangeDiscoveryRequired(DiscoveryRange discoveryRange) {
220            return true;
221        }
222
223
224        public boolean zipFileDiscoveryRequired(String url) {
225            return true;
226        }
227
228    }
229}