config-loader/config-loader-impl/src/main/java/org/opendaylight/protocol/bgp/config/loader/impl/ConfigLoaderImpl.java

   1 /*
   2  * Copyright (c) 2016 Cisco 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
   9 package org.opendaylight.protocol.bgp.config.loader.impl;
  10
  11 import static java.util.Objects.requireNonNull;
  12
  13 import java.io.File;
  14 import java.io.FileInputStream;
  15 import java.io.IOException;
  16 import java.io.InputStream;
  17 import java.net.URISyntaxException;
  18 import java.nio.file.WatchEvent;
  19 import java.nio.file.WatchKey;
  20 import java.nio.file.WatchService;
  21 import java.util.HashMap;
  22 import java.util.Map;
  23 import java.util.regex.Pattern;
  24 import javax.annotation.concurrent.GuardedBy;
  25 import javax.xml.parsers.ParserConfigurationException;
  26 import javax.xml.stream.XMLInputFactory;
  27 import javax.xml.stream.XMLStreamException;
  28 import javax.xml.stream.XMLStreamReader;
  29 import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
  30 import org.opendaylight.protocol.bgp.config.loader.spi.ConfigFileProcessor;
  31 import org.opendaylight.protocol.bgp.config.loader.spi.ConfigLoader;
  32 import org.opendaylight.yangtools.concepts.AbstractRegistration;
  33 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  34 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
  35 import org.opendaylight.yangtools.yang.data.codec.xml.XmlParserStream;
  36 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
  37 import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
  38 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  39 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
  40 import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
  41 import org.slf4j.Logger;
  42 import org.slf4j.LoggerFactory;
  43 import org.xml.sax.SAXException;
  44
  45 public final class ConfigLoaderImpl implements ConfigLoader, AutoCloseable {
  46     private static final Logger LOG = LoggerFactory.getLogger(ConfigLoaderImpl.class);
  47     private static final String INTERRUPTED = "InterruptedException";
  48     private static final String EXTENSION = "-.*\\.xml";
  49     private static final String INITIAL = "^";
  50     @GuardedBy("this")
  51     private final Map<String, ConfigFileProcessor> configServices = new HashMap<>();
  52     private final SchemaContext schemaContext;
  53     private final BindingNormalizedNodeSerializer bindingSerializer;
  54     private final String path;
  55     private final Thread watcherThread;
  56     @GuardedBy("this")
  57     private boolean closed = false;
  58
  59     public ConfigLoaderImpl(final SchemaContext schemaContext, final BindingNormalizedNodeSerializer bindingSerializer,
  60             final String path, final WatchService watchService) {
  61         this.schemaContext = requireNonNull(schemaContext);
  62         this.bindingSerializer = requireNonNull(bindingSerializer);
  63         this.path = requireNonNull(path);
  64         requireNonNull(watchService);
  65         this.watcherThread = new Thread(new ConfigLoaderImplRunnable(watchService));
  66         this.watcherThread.start();
  67         LOG.info("Config Loader service initiated");
  68     }
  69
  70     private void handleConfigFile(final ConfigFileProcessor config, final String filename) {
  71         final NormalizedNode<?, ?> dto;
  72         try {
  73             dto = parseDefaultConfigFile(config, filename);
  74         } catch (final IOException | XMLStreamException | ParserConfigurationException | SAXException
  75                 | URISyntaxException e) {
  76             LOG.warn("Failed to parse config file {}", filename, e);
  77             return;
  78         }
  79         LOG.info("Loading initial config {}", filename);
  80         config.loadConfiguration(dto);
  81     }
  82
  83     private NormalizedNode<?, ?> parseDefaultConfigFile(final ConfigFileProcessor config, final String filename)
  84             throws IOException, XMLStreamException, ParserConfigurationException, SAXException, URISyntaxException {
  85         final NormalizedNodeResult result = new NormalizedNodeResult();
  86         final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
  87
  88         final InputStream resourceAsStream = new FileInputStream(new File(this.path, filename));
  89         final XMLInputFactory factory = XMLInputFactory.newInstance();
  90         final XMLStreamReader reader = factory.createXMLStreamReader(resourceAsStream);
  91
  92         final SchemaNode schemaNode = SchemaContextUtil.findDataSchemaNode(this.schemaContext, config.getSchemaPath());
  93         final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, this.schemaContext, schemaNode);
  94         xmlParser.parse(reader);
  95
  96         return result.getResult();
  97     }
  98
  99     @Override
 100     public synchronized AbstractRegistration registerConfigFile(final ConfigFileProcessor config) {
 101         final String pattern = INITIAL + config.getSchemaPath().getLastComponent().getLocalName() + EXTENSION;
 102         this.configServices.put(pattern, config);
 103
 104         final File[] fList = new File(this.path).listFiles();
 105         if (fList != null) {
 106             for (final File file : fList) {
 107                 if (file.isFile()) {
 108                     final String filename = file.getName();
 109                     if (Pattern.matches(pattern, filename)) {
 110                         handleConfigFile(config, filename);
 111                     }
 112                 }
 113             }
 114         }
 115
 116         return new AbstractRegistration() {
 117             @Override
 118             protected void removeRegistration() {
 119                 synchronized (ConfigLoaderImpl.this) {
 120                     ConfigLoaderImpl.this.configServices.remove(pattern);
 121                 }
 122             }
 123         };
 124     }
 125
 126     @Override
 127     public BindingNormalizedNodeSerializer getBindingNormalizedNodeSerializer() {
 128         return this.bindingSerializer;
 129     }
 130
 131
 132     @Override
 133     public synchronized void close() throws Exception {
 134         LOG.info("Config Loader service closed");
 135         this.closed = true;
 136         this.watcherThread.interrupt();
 137     }
 138
 139     private class ConfigLoaderImplRunnable implements Runnable {
 140         private final WatchService watchService;
 141
 142         ConfigLoaderImplRunnable(final WatchService watchService) {
 143             this.watchService = watchService;
 144         }
 145
 146         @Override
 147         public void run() {
 148             while (!Thread.currentThread().isInterrupted()) {
 149                 handleChanges(this.watchService);
 150             }
 151         }
 152
 153         private synchronized void handleChanges(final WatchService watchService) {
 154             final WatchKey key;
 155             try {
 156                 key = watchService.take();
 157             } catch (final InterruptedException e) {
 158                 if (!ConfigLoaderImpl.this.closed) {
 159                     LOG.warn(INTERRUPTED, e);
 160                     Thread.currentThread().interrupt();
 161                 }
 162                 return;
 163             }
 164
 165             if (key != null) {
 166                 for (final WatchEvent<?> event : key.pollEvents()) {
 167                     handleEvent(event.context().toString());
 168                 }
 169                 final boolean reset = key.reset();
 170                 if (!reset) {
 171                     LOG.warn("Could not reset the watch key.");
 172                 }
 173             }
 174         }
 175
 176         private synchronized void handleEvent(final String filename) {
 177             ConfigLoaderImpl.this.configServices.entrySet().stream()
 178                     .filter(entry -> Pattern.matches(entry.getKey(), filename))
 179                     .forEach(entry -> handleConfigFile(entry.getValue(), filename));
 180         }
 181     }
 182 }