aaa-filterchain/src/main/java/org/opendaylight/aaa/filterchain/configuration/impl/CustomFilterAdapterConfigurationImpl.java

   1 /*
   2  * Copyright (c) 2016, 2017 Brocade Communications Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.aaa.filterchain.configuration.impl;
   9
  10 import static java.util.Objects.requireNonNull;
  11
  12 import com.google.common.base.Strings;
  13 import com.google.common.collect.ImmutableList;
  14 import java.util.Arrays;
  15 import java.util.Collection;
  16 import java.util.Collections;
  17 import java.util.Enumeration;
  18 import java.util.HashMap;
  19 import java.util.Iterator;
  20 import java.util.List;
  21 import java.util.Map;
  22 import java.util.Map.Entry;
  23 import java.util.Optional;
  24 import java.util.concurrent.ConcurrentHashMap;
  25 import java.util.stream.Collectors;
  26 import java.util.stream.Stream;
  27 import javax.servlet.Filter;
  28 import javax.servlet.FilterConfig;
  29 import javax.servlet.ServletContext;
  30 import javax.servlet.ServletException;
  31 import org.eclipse.jdt.annotation.Nullable;
  32 import org.opendaylight.aaa.filterchain.configuration.CustomFilterAdapterConfiguration;
  33 import org.opendaylight.aaa.filterchain.configuration.CustomFilterAdapterListener;
  34 import org.osgi.service.component.annotations.Activate;
  35 import org.osgi.service.component.annotations.Component;
  36 import org.osgi.service.component.annotations.Modified;
  37 import org.osgi.service.component.annotations.Reference;
  38 import org.osgi.service.component.annotations.ReferenceCardinality;
  39 import org.osgi.service.component.annotations.ReferencePolicy;
  40 import org.osgi.service.component.annotations.ReferencePolicyOption;
  41 import org.slf4j.Logger;
  42 import org.slf4j.LoggerFactory;
  43
  44 /**
  45  * Implementation of CustomFilterAdapterConfiguration.
  46  */
  47 @Component(immediate = true, configurationPid = "org.opendaylight.aaa.filterchain")
  48 public final class CustomFilterAdapterConfigurationImpl implements CustomFilterAdapterConfiguration {
  49     private static final Logger LOG = LoggerFactory.getLogger(CustomFilterAdapterConfigurationImpl.class);
  50
  51     /**
  52      * Separates different filter definitions. For example:
  53      * <code>customFilterList = c.b.a.TestFilter1,f.d.e.TestFilter2,j.h.i.FilterN</code>
  54      */
  55     private static final String FILTER_DTO_SEPARATOR = ",";
  56
  57     /**
  58      * <code>customFilterList</code> is the property advertised in the Karaf
  59      * configuration admin.
  60      */
  61     static final String CUSTOM_FILTER_LIST_KEY = "customFilterList";
  62
  63     /**
  64      * List of listeners to notify upon config admin events.
  65      */
  66     private final Collection<CustomFilterAdapterListener> listeners = ConcurrentHashMap.newKeySet();
  67
  68     /**
  69      * Saves a local copy of the most recent configuration so when a listener is
  70      * added, it can receive and initial update.
  71      */
  72     private volatile List<FilterDTO> namedFilterDTOs = Collections.emptyList();
  73
  74     private volatile List<FilterDTO> instanceFilterDTOs = Collections.emptyList();
  75
  76     @Activate
  77     void activate(final Map<String, String> properties) {
  78         update(properties);
  79     }
  80
  81     @Modified
  82     // Invoked in response to configuration admin changes
  83     public void update(final Map<String, String> properties) {
  84         if (properties != null) {
  85             LOG.info("Custom filter properties updated: {}", properties);
  86
  87             this.namedFilterDTOs = getCustomFilterList(properties);
  88             updateListeners();
  89         }
  90     }
  91
  92     // Invoked when a Filter OSGi service is added
  93     @Reference(cardinality = ReferenceCardinality.MULTIPLE,
  94             policy = ReferencePolicy.DYNAMIC, policyOption = ReferencePolicyOption.GREEDY,
  95             // Needed to exclude any filters that is published for HTTP Whiteboard
  96             // FIXME: it would be much better if we had a whitelist property to prevent confusion
  97             target = "(!(|"
  98                 + "(osgi.http.whiteboard.filter.pattern=*)"
  99                 + "(osgi.http.whiteboard.filter.regex=*)"
 100                 + "(osgi.http.whiteboard.filter.servlet=*)"
 101                 + "))")
 102     public void addFilter(final Filter filter) {
 103         if (filter == null) {
 104             return;
 105         }
 106
 107         LOG.info("Custom Filter {} added", filter);
 108         this.instanceFilterDTOs = ImmutableList.<FilterDTO>builder().addAll(instanceFilterDTOs)
 109                 .add(FilterDTO.createFilterDTO(filter)).build();
 110         updateListeners();
 111     }
 112
 113     // Invoked when a Filter OSGi service is removed
 114     public void removeFilter(final Filter filter) {
 115         if (filter == null) {
 116             return;
 117         }
 118
 119         LOG.info("Custom Filter {} removed", filter);
 120         FilterDTO toRemove = FilterDTO.createFilterDTO(filter);
 121         this.instanceFilterDTOs = ImmutableList.copyOf(instanceFilterDTOs.stream().filter(dto -> !dto.equals(toRemove))
 122                 .collect(Collectors.toList()));
 123         updateListeners();
 124     }
 125
 126     /**
 127      * Notify all listeners of a change event.
 128      */
 129     private void updateListeners() {
 130         for (CustomFilterAdapterListener listener : listeners) {
 131             updateListener(listener);
 132         }
 133     }
 134
 135     /**
 136      * Update a particular listener with the new injected <code>FilterDTO</code>
 137      * list.
 138      *
 139      * @param listener
 140      *            The <code>CustomFilterAdapter</code> instance
 141      * @param customFilterList
 142      *            The newly injected <code>FilterDTO</code> list
 143      */
 144     private void updateListener(final CustomFilterAdapterListener listener) {
 145         final Optional<ServletContext> listenerServletContext = extractServletContext(listener);
 146         final List<Filter> filterList = convertCustomFilterList(listenerServletContext);
 147
 148         LOG.debug("Notifying listener {} of filters {}", listener, filterList);
 149
 150         listener.updateInjectedFilters(filterList);
 151     }
 152
 153     /**
 154      * Utility method to extract a <code>ServletContext</code> from a listener's
 155      * <code>FilterConfig</code>.
 156      *
 157      * @param listener
 158      *            An object which listens for filter chain configuration
 159      *            changes.
 160      * @return An extracted <code>ServletContext</code>, or null if either the
 161      *         <code>FilterConfig</code> of <code>ServletContext</code> is null
 162      */
 163     private static Optional<ServletContext> extractServletContext(final CustomFilterAdapterListener listener) {
 164         final FilterConfig listenerFilterConfig = listener.getFilterConfig();
 165         return listenerFilterConfig != null ? Optional.ofNullable(listenerFilterConfig.getServletContext())
 166                 : Optional.empty();
 167     }
 168
 169     /**
 170      * Converts a List of class names (possibly Filters) and attempts to spawn
 171      * corresponding <code>javax.servlet.Filter</code> instances.
 172      *
 173      * @param customFilterList
 174      *            a list of class names, ideally Filters
 175      * @return a list of derived Filter(s)
 176      */
 177     private List<Filter> convertCustomFilterList(final Optional<ServletContext> listenerServletContext) {
 178         final List<Filter> filterList = ImmutableList.<FilterDTO>builder().addAll(namedFilterDTOs)
 179             .addAll(instanceFilterDTOs).build().stream().flatMap(
 180                 filter -> getFilterInstance(filter, listenerServletContext)).collect(Collectors.toList());
 181         return Collections.unmodifiableList(filterList);
 182     }
 183
 184     /**
 185      * Utility method used to create and initialize a Filter from a FilterDTO.
 186      *
 187      * @param customFilter
 188      *            DTO containing Filter and properties path, if one exists.
 189      * @param servletContext
 190      *            Scoped to the listener
 191      * @return A Stream containing the Filter, or empty if one cannot be instantiated.
 192      */
 193     private static Stream<Filter> getFilterInstance(final FilterDTO customFilter,
 194             final Optional<ServletContext> servletContext) {
 195         final Filter filter = customFilter.getInstance(servletContext);
 196         if (filter != null) {
 197             LOG.info("Successfully loaded custom Filter {} for context {}", filter, servletContext);
 198             return Stream.of(filter);
 199         }
 200
 201         return Stream.empty();
 202     }
 203
 204     /**
 205      * Allows creation of <code>FilterConfig</code> from a key/value properties file.
 206      */
 207     private static final class InjectedFilterConfig implements FilterConfig {
 208
 209         private final String filterName;
 210         private final ServletContext servletContext;
 211         private final Map<String, String> filterConfig;
 212
 213         // private for Factory Method pattern
 214         private InjectedFilterConfig(final Filter filter, final Optional<ServletContext> servletContext,
 215                 final Map<String, String> filterConfig) {
 216
 217             this.filterName = filter.getClass().getSimpleName();
 218             this.servletContext = servletContext.orElse(null);
 219             this.filterConfig = filterConfig;
 220         }
 221
 222         static InjectedFilterConfig createInjectedFilterConfig(final Filter filter,
 223                 final Optional<ServletContext> servletContext, final Map<String, String> filterConfig) {
 224             return new InjectedFilterConfig(filter, servletContext, filterConfig);
 225         }
 226
 227         @Override
 228         public String getFilterName() {
 229             return filterName;
 230         }
 231
 232         @Override
 233         public String getInitParameter(final String paramName) {
 234             return filterConfig != null ? filterConfig.get(paramName) : null;
 235         }
 236
 237         @Override
 238         public Enumeration<String> getInitParameterNames() {
 239             return filterConfig != null ? new Enumeration<>() {
 240                 final Iterator<String> keySet = filterConfig.keySet().iterator();
 241
 242                 @Override
 243                 public boolean hasMoreElements() {
 244                     return keySet.hasNext();
 245                 }
 246
 247                 @Override
 248                 public String nextElement() {
 249                     return keySet.next();
 250                 }
 251             } : Collections.emptyEnumeration();
 252         }
 253
 254         @Override
 255         public ServletContext getServletContext() {
 256             return servletContext;
 257         }
 258     }
 259
 260     /**
 261      * Extracts the custom filter list as provided by Karaf Configuration Admin.
 262      *
 263      * @return A <code>non-null</code> <code>List</code> of the custom filter
 264      *         fully qualified class names.
 265      */
 266     private static List<FilterDTO> getCustomFilterList(final Map<String, String> configuration) {
 267         final String customFilterListValue = configuration.get(CUSTOM_FILTER_LIST_KEY);
 268         final ImmutableList.Builder<FilterDTO> customFilterListBuilder = ImmutableList.builder();
 269         if (customFilterListValue != null) {
 270             // Creates the list from comma separate values; whitespace is
 271             // removed first
 272             final List<String> filterClazzNames = Arrays
 273                     .asList(customFilterListValue.replaceAll("\\s", "").split(FILTER_DTO_SEPARATOR));
 274             for (String filterClazzName : filterClazzNames) {
 275                 if (!Strings.isNullOrEmpty(filterClazzName)) {
 276                     final Map<String, String> applicableConfigs = extractPropertiesForFilter(filterClazzName,
 277                             configuration);
 278                     final FilterDTO filterDTO = FilterDTO.createFilterDTO(filterClazzName, applicableConfigs);
 279                     customFilterListBuilder.add(filterDTO);
 280                 }
 281             }
 282         }
 283         return customFilterListBuilder.build();
 284     }
 285
 286     /**
 287      * Extract a subset of properties that apply to a particular Filter.
 288      *
 289      * @param clazzName
 290      *            prefix used to specify key value pair (i.e.,
 291      *            a.b.c.Filter.property)
 292      * @param fullConfiguration
 293      *            The entire configuration dictionary, which is traversed for
 294      *            applicable properties.
 295      * @return A Map of applicable properties for a filter.
 296      */
 297     private static Map<String, String> extractPropertiesForFilter(final String clazzName,
 298             final Map<String, String> fullConfiguration) {
 299
 300         final Map<String, String> extractedConfig = new HashMap<>();
 301         for (Entry<String, String> entry : fullConfiguration.entrySet()) {
 302             String key = entry.getKey();
 303             final int lastDotSeparator = key.lastIndexOf(".");
 304             if (lastDotSeparator >= 0) {
 305                 final String comparisonClazzNameSubstring = key.substring(0, lastDotSeparator);
 306                 if (comparisonClazzNameSubstring.equals(clazzName)) {
 307                     final String filterInitParamKey = key.substring(lastDotSeparator + 1);
 308                     extractedConfig.put(filterInitParamKey, entry.getValue());
 309                 }
 310             } else {
 311                 if (!key.equals(CUSTOM_FILTER_LIST_KEY)) {
 312                     LOG.error("couldn't parse property \"{}\"; skipping", key);
 313                 }
 314             }
 315         }
 316         return extractedConfig;
 317     }
 318
 319     /**
 320      * Register for config changes.
 321      *
 322      * @param listener
 323      *            A listener implementing
 324      *            <code>CustomFilterAdapterListener</code>
 325      */
 326     @Override
 327     public void registerCustomFilterAdapterConfigurationListener(final CustomFilterAdapterListener listener) {
 328         LOG.debug("registerCustomFilterAdapterConfigurationListener: {}", listener);
 329         if (this.listeners.add(listener)) {
 330             LOG.debug("Updated listener set: {}", listeners);
 331             this.updateListener(listener);
 332         }
 333     }
 334
 335     private abstract static class FilterDTO {
 336
 337         private final Map<String, String> initParams;
 338
 339         protected FilterDTO(final Map<String, String> initParams) {
 340             this.initParams = requireNonNull(initParams);
 341         }
 342
 343         abstract @Nullable Filter getInstance(Optional<ServletContext> servletContext);
 344
 345         static FilterDTO createFilterDTO(final String clazzName, final Map<String, String> initParams) {
 346             return new NamedFilterDTO(clazzName, initParams);
 347         }
 348
 349         static FilterDTO createFilterDTO(final Filter instance) {
 350             return new InstanceFilterDTO(instance);
 351         }
 352
 353         /**
 354          * Attempts to extract a map of key/value pairs from a given file.
 355          *
 356          * @return map with the initialization parameters.
 357          */
 358         Map<String, String> getInitParams() {
 359             return initParams;
 360         }
 361     }
 362
 363     /**
 364      * Essentially a tuple of (filterClassName, propertiesFileName). Allows
 365      * quicker passing and return of Filter information.
 366      */
 367     private static class NamedFilterDTO extends FilterDTO {
 368         private final String clazzName;
 369
 370         NamedFilterDTO(final String clazzName, final Map<String, String> initParams) {
 371             super(initParams);
 372             this.clazzName = requireNonNull(clazzName);
 373         }
 374
 375         @SuppressWarnings("unchecked")
 376         @Override
 377         Filter getInstance(final Optional<ServletContext> servletContext) {
 378             try {
 379                 final Class<Filter> filterClazz = (Class<Filter>) Class.forName(clazzName);
 380                 return init(filterClazz.getDeclaredConstructor().newInstance(), servletContext);
 381             } catch (ReflectiveOperationException | ClassCastException e) {
 382                 LOG.error("Error loading  {}", this, e);
 383             }
 384
 385             return null;
 386         }
 387
 388         private Filter init(final Filter filter, final Optional<ServletContext> servletContext) {
 389             try {
 390                 FilterConfig filterConfig = InjectedFilterConfig.createInjectedFilterConfig(filter, servletContext,
 391                         getInitParams());
 392                 filter.init(filterConfig);
 393             } catch (ServletException e) {
 394                 LOG.error("Error injecting custom filter {} - continuing anyway", filter, e);
 395             }
 396
 397             return filter;
 398         }
 399
 400         @Override
 401         public int hashCode() {
 402             return clazzName.hashCode();
 403         }
 404
 405         @Override
 406         public boolean equals(final Object obj) {
 407             if (this == obj) {
 408                 return true;
 409             }
 410
 411             if (obj == null) {
 412                 return false;
 413             }
 414
 415             if (getClass() != obj.getClass()) {
 416                 return false;
 417             }
 418
 419             NamedFilterDTO other = (NamedFilterDTO) obj;
 420             return clazzName.equals(other.clazzName);
 421         }
 422
 423         @Override
 424         public String toString() {
 425             return "NamedFilterDTO [clazzName=" + clazzName + ", initParams=" + getInitParams() + "]";
 426         }
 427     }
 428
 429     private static class InstanceFilterDTO extends FilterDTO {
 430         private final Filter instance;
 431
 432         InstanceFilterDTO(final Filter instance) {
 433             super(Collections.emptyMap());
 434             this.instance = requireNonNull(instance);
 435         }
 436
 437         @Override
 438         Filter getInstance(final Optional<ServletContext> servletContext) {
 439             return instance;
 440         }
 441
 442         @Override
 443         public int hashCode() {
 444             return instance.hashCode();
 445         }
 446
 447         @Override
 448         public boolean equals(final Object obj) {
 449             if (this == obj) {
 450                 return true;
 451             }
 452
 453             if (obj == null) {
 454                 return false;
 455             }
 456
 457             if (getClass() != obj.getClass()) {
 458                 return false;
 459             }
 460
 461             InstanceFilterDTO other = (InstanceFilterDTO) obj;
 462             return instance.equals(other.instance);
 463         }
 464
 465         @Override
 466         public String toString() {
 467             return "InstanceFilterDTO [instance=" + instance + "]";
 468         }
 469     }
 470 }