| /* |
| * 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.dependencymanager.samples.customdep; |
| |
| import java.nio.file.Path; |
| import java.nio.file.Paths; |
| import java.nio.file.StandardWatchEventKinds; |
| import java.nio.file.WatchEvent; |
| import java.nio.file.WatchEvent.Kind; |
| import java.nio.file.WatchKey; |
| import java.nio.file.WatchService; |
| import java.util.List; |
| |
| import org.apache.felix.dm.context.AbstractDependency; |
| import org.apache.felix.dm.context.DependencyContext; |
| import org.apache.felix.dm.context.Event; |
| import org.apache.felix.dm.context.EventType; |
| |
| /** |
| * This is our own "path" Dependency Manager Dependency, which can track the presence of files in a given path dir. |
| * Every DM custom dependency must implement the DependencyContext interface, but we extends the AbstractDependency |
| * which already implements most of the DependencyContext methods. |
| * |
| * @author <a href="mailto:dev@felix.apache.org">Felix Project Team</a> |
| */ |
| public class PathDependencyImpl extends AbstractDependency<PathDependencyImpl> implements PathDependency, Runnable { |
| private final String m_path; |
| private volatile Thread m_thread; |
| |
| /** |
| * Creates a new custom DM "path" dependency. |
| * @param path the directory to watch for |
| */ |
| public PathDependencyImpl(String path) { |
| super.setRequired(true); |
| m_path = path; |
| } |
| |
| /** |
| * Create a new PathDependency from an existing prototype. |
| * @param prototype the existing PathDependency. |
| */ |
| public PathDependencyImpl(PathDependencyImpl prototype) { |
| super(prototype); |
| m_path = prototype.m_path; |
| } |
| |
| // ---------- DependencyContext interface ---------- |
| |
| @Override |
| public DependencyContext createCopy() { |
| return new PathDependencyImpl(this); |
| } |
| |
| @Override |
| public Class<?> getAutoConfigType() { |
| return null; // we don't support auto config mode |
| } |
| |
| @Override |
| public void start() { |
| m_thread = new Thread(this); |
| m_thread.start(); |
| super.start(); |
| } |
| |
| @Override |
| public void stop() { |
| m_thread.interrupt(); |
| super.stop(); |
| } |
| |
| @Override |
| public void invokeCallback(EventType type, Event ...events) { |
| switch (type) { |
| case ADDED: |
| if (m_add != null) { |
| invoke(m_add, events[0], getInstances()); |
| } |
| break; |
| case REMOVED: |
| if (m_remove != null) { |
| invoke(m_remove, events[0], getInstances()); |
| } |
| break; |
| default: |
| // We don't support other kind of callbacks. |
| break; |
| } |
| } |
| |
| // ---------- ComponentDependencyDeclaration interface ----------- |
| |
| /** |
| * Returns the name of this dependency (a generic name with optional info separated by spaces). |
| * The DM Shell will use this method when displaying the dependency |
| **/ |
| @Override |
| public String getSimpleName() { |
| return m_path; |
| } |
| |
| /** |
| * Returns the name of the type of this dependency. Used by the DM shell when displaying the dependency. |
| **/ |
| @Override |
| public String getType() { |
| return "path"; |
| } |
| |
| // ---------- other methods ----------- |
| |
| /** |
| * Our start method fires a thread and this is our run method, which is watching for a given directory path |
| */ |
| public void run() { |
| Path myDir = Paths.get(m_path); |
| |
| try { |
| WatchService watcher = myDir.getFileSystem().newWatchService(); |
| myDir.register(watcher, StandardWatchEventKinds.ENTRY_CREATE, StandardWatchEventKinds.ENTRY_MODIFY, |
| StandardWatchEventKinds.ENTRY_DELETE); |
| while (! Thread.currentThread().isInterrupted()) { |
| WatchKey watckKey = watcher.take(); |
| |
| List<WatchEvent<?>> events = watckKey.pollEvents(); |
| |
| for (@SuppressWarnings("rawtypes") WatchEvent event : events) { |
| final Kind<?> kind = event.kind(); |
| if (StandardWatchEventKinds.OVERFLOW == kind) { |
| continue; |
| } |
| if (StandardWatchEventKinds.ENTRY_CREATE == kind) { |
| // Notify the component implementation context that a file has been created. |
| // Later, the component will call our invokeAdd method in order to inject the file |
| // in the component instance |
| m_component.handleEvent(this, EventType.ADDED, new Event(event.context().toString())); |
| } else if (StandardWatchEventKinds.ENTRY_DELETE == kind) { |
| // Notify the component implementation context that a file has been removed. |
| // Later, the component will call our invokeRemove method in order to call our component "remove" callback |
| m_component.handleEvent(this, EventType.REMOVED, new Event(event.context().toString())); |
| } |
| } |
| |
| watckKey.reset(); |
| } |
| } catch (Throwable e) { |
| m_component.getLogger().err("path dependency exception", e); |
| } |
| } |
| |
| /** |
| * Invoke either the "add" or "remove" callback of the component instance(s). |
| */ |
| private void invoke(String method, Event e, Object[] instances) { |
| // specific for this type of dependency |
| m_component.invokeCallbackMethod(instances, method, |
| new Class[][] { {String.class}, |
| {}}, |
| new Object[][] { { e.getEvent() }, |
| {}}); |
| } |
| } |