content: /**
   *  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.aries.blueprint.spring.extender;
  
  import java.net.URL;
  import java.util.ArrayList;
  import java.util.Enumeration;
  import java.util.List;
  
  import org.apache.aries.blueprint.services.BlueprintExtenderService;
  import org.apache.aries.blueprint.utils.HeaderParser;
  import org.apache.aries.blueprint.utils.HeaderParser.PathElement;
  import org.apache.felix.utils.extender.AbstractExtender;
  import org.apache.felix.utils.extender.Extension;
  import org.osgi.framework.Bundle;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * Spring namespace extender.
   * This OSGi extender is responsible for registering spring namespaces for blueprint.
   *
   * @see SpringOsgiExtension
   */
  public class SpringOsgiExtender extends AbstractExtender {
  
      public static final String SPRING_CONTEXT_HEADER = "Spring-Context";
  
      private static final Logger LOGGER = LoggerFactory.getLogger(SpringOsgiExtender.class);
  
      private final BlueprintExtenderService blueprintExtenderService;
  
      public SpringOsgiExtender(BlueprintExtenderService blueprintExtenderService) {
          this.blueprintExtenderService = blueprintExtenderService;
      }
  
      @Override
      protected Extension doCreateExtension(Bundle bundle) throws Exception {
          List<URL> paths = getSpringPaths(bundle);
          if (paths != null && !paths.isEmpty()) {
              return new SpringOsgiExtension(blueprintExtenderService, bundle, paths);
          }
          return null;
      }
  
      private List<URL> getSpringPaths(Bundle bundle) throws Exception {
          LOGGER.debug("Scanning bundle {}/{} for spring application", bundle.getSymbolicName(), bundle.getVersion());
          List<URL> pathList = new ArrayList<URL>();
          String springHeader = bundle.getHeaders().get(SPRING_CONTEXT_HEADER);
          if (springHeader == null) {
              springHeader = "*";
          }
          List<PathElement> paths = HeaderParser.parseHeader(springHeader);
          for (PathElement path : paths) {
              String name = path.getName();
              if ("*".equals(name)) {
                  name = "META-INF/spring/*.xml";
              }
              String baseName;
              String filePattern;
              int pos = name.lastIndexOf('/');
              if (pos < 0) {
                  baseName = "/";
                  filePattern = name;
              } else {
                  baseName = name.substring(0, pos + 1);
                  filePattern = name.substring(pos + 1);
              }
              if (filePattern.contains("*")) {
                  Enumeration<URL> e = bundle.findEntries(baseName, filePattern, false);
                  while (e != null && e.hasMoreElements()) {
                      pathList.add(e.nextElement());
                  }
              } else {
                  pathList.add(bundle.getEntry(name));
              }
          }
          if (!pathList.isEmpty()) {
              LOGGER.debug("Found spring application in bundle {}/{} with paths: {}", bundle.getSymbolicName(), bundle.getVersion(), pathList);
              // Check compatibility
              // TODO: For lazy bundles, the class is either loaded from an imported package or not found, so it should
              // not trigger the activation.  If it does, we need to use something else like package admin or
              // ServiceReference, or just not do this check, which could be quite harmful.
              if (isCompatible(bundle)) {
                  return pathList;
              } else {
                  LOGGER.info("Bundle {}/{} is not compatible with this blueprint extender", bundle.getSymbolicName(), bundle.getVersion());
              }
          } else {
              LOGGER.debug("No blueprint application found in bundle {}/{}", bundle.getSymbolicName(), bundle.getVersion());
          }
          return null;
      }
  
      private boolean isCompatible(Bundle bundle) {
          // TODO
          return true;
      }
  
      @Override
      protected void debug(Bundle bundle, String msg) {
          LOGGER.debug(msg + ": " + bundle.getSymbolicName() + "/" + bundle.getVersion());
      }
  
      @Override
      protected void warn(Bundle bundle, String msg, Throwable t) {
          LOGGER.warn(msg + ": " + bundle.getSymbolicName() + "/" + bundle.getVersion(), t);
      }
  
      @Override
      protected void error(String msg, Throwable t) {
          LOGGER.error(msg, t);
      }
  
  }
  