| package net.onrc.onos.api.newintent; |
| |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.concurrent.ExecutorService; |
| import java.util.concurrent.Executors; |
| |
| /** |
| * Fake implementation of the intent service to assist in developing tests |
| * of the interface contract. |
| */ |
| public class FakeIntentManager implements TestableIntentService { |
| |
| private final Map<IntentId, Intent> intents = new HashMap<>(); |
| private final Map<IntentId, IntentState> intentStates = new HashMap<>(); |
| private final Map<IntentId, List<InstallableIntent>> installables = new HashMap<>(); |
| private final Set<IntentEventListener> listeners = new HashSet<>(); |
| |
| private final Map<Class<? extends Intent>, IntentCompiler<? extends Intent>> compilers = new HashMap<>(); |
| private final Map<Class<? extends InstallableIntent>, |
| IntentInstaller<? extends InstallableIntent>> installers = new HashMap<>(); |
| |
| private final ExecutorService executor = Executors.newSingleThreadExecutor(); |
| private final List<IntentException> exceptions = new ArrayList<>(); |
| |
| @Override |
| public List<IntentException> getExceptions() { |
| return exceptions; |
| } |
| |
| // Provides an out-of-thread simulation of intent submit life-cycle |
| private void executeSubmit(final Intent intent) { |
| registerSubclassCompilerIfNeeded(intent); |
| registerSubclassInstallerIfNeeded((InstallableIntent) intent); |
| executor.execute(new Runnable() { |
| @Override |
| public void run() { |
| try { |
| List<InstallableIntent> installable = compileIntent(intent); |
| installIntents(intent, installable); |
| } catch (IntentException e) { |
| exceptions.add(e); |
| } |
| } |
| }); |
| } |
| |
| // Provides an out-of-thread simulation of intent withdraw life-cycle |
| private void executeWithdraw(final Intent intent) { |
| executor.execute(new Runnable() { |
| @Override |
| public void run() { |
| try { |
| List<InstallableIntent> installable = getInstallable(intent.getId()); |
| uninstallIntents(intent, installable); |
| } catch (IntentException e) { |
| exceptions.add(e); |
| } |
| |
| } |
| }); |
| } |
| |
| private <T extends Intent> IntentCompiler<T> getCompiler(T intent) { |
| @SuppressWarnings("unchecked") |
| IntentCompiler<T> compiler = (IntentCompiler<T>) compilers.get(intent.getClass()); |
| if (compiler == null) { |
| throw new IntentException("no compiler for class " + intent.getClass()); |
| } |
| return compiler; |
| } |
| |
| private <T extends InstallableIntent> IntentInstaller<T> getInstaller(T intent) { |
| @SuppressWarnings("unchecked") |
| IntentInstaller<T> installer = (IntentInstaller<T>) installers.get(intent.getClass()); |
| if (installer == null) { |
| throw new IntentException("no installer for class " + intent.getClass()); |
| } |
| return installer; |
| } |
| |
| private <T extends Intent> List<InstallableIntent> compileIntent(T intent) { |
| try { |
| // For the fake, we compile using a single level pass |
| List<InstallableIntent> installable = new ArrayList<>(); |
| for (Intent compiled : getCompiler(intent).compile(intent)) { |
| installable.add((InstallableIntent) compiled); |
| } |
| setState(intent, IntentState.COMPILED); |
| return installable; |
| } catch (IntentException e) { |
| setState(intent, IntentState.FAILED); |
| throw e; |
| } |
| } |
| |
| private void installIntents(Intent intent, List<InstallableIntent> installable) { |
| try { |
| for (InstallableIntent ii : installable) { |
| getInstaller(ii).install(ii); |
| } |
| setState(intent, IntentState.INSTALLED); |
| putInstallable(intent.getId(), installable); |
| } catch (IntentException e) { |
| setState(intent, IntentState.FAILED); |
| throw e; |
| } |
| } |
| |
| private void uninstallIntents(Intent intent, List<InstallableIntent> installable) { |
| try { |
| for (InstallableIntent ii : installable) { |
| getInstaller(ii).remove(ii); |
| } |
| setState(intent, IntentState.WITHDRAWN); |
| removeInstallable(intent.getId()); |
| } catch (IntentException e) { |
| setState(intent, IntentState.FAILED); |
| throw e; |
| } |
| } |
| |
| |
| // Sets the internal state for the given intent and dispatches an event |
| private void setState(Intent intent, IntentState state) { |
| IntentState previous = intentStates.get(intent.getId()); |
| intentStates.put(intent.getId(), state); |
| dispatch(new IntentEvent(intent, state, previous, System.currentTimeMillis())); |
| } |
| |
| private void putInstallable(IntentId id, List<InstallableIntent> installable) { |
| installables.put(id, installable); |
| } |
| |
| private void removeInstallable(IntentId id) { |
| installables.remove(id); |
| } |
| |
| private List<InstallableIntent> getInstallable(IntentId id) { |
| List<InstallableIntent> installable = installables.get(id); |
| if (installable != null) { |
| return installable; |
| } else { |
| return Collections.emptyList(); |
| } |
| } |
| |
| @Override |
| public void submit(Intent intent) { |
| intents.put(intent.getId(), intent); |
| setState(intent, IntentState.SUBMITTED); |
| executeSubmit(intent); |
| } |
| |
| @Override |
| public void withdraw(Intent intent) { |
| intents.remove(intent.getId()); |
| setState(intent, IntentState.WITHDRAWING); |
| executeWithdraw(intent); |
| } |
| |
| @Override |
| public void execute(IntentOperations operations) { |
| // TODO: implement later |
| } |
| |
| @Override |
| @SuppressWarnings("unchecked") |
| public Set<Intent> getIntents() { |
| return Collections.unmodifiableSet(new HashSet<>(intents.values())); |
| } |
| |
| @Override |
| public Intent getIntent(IntentId id) { |
| return intents.get(id); |
| } |
| |
| @Override |
| public IntentState getIntentState(IntentId id) { |
| return intentStates.get(id); |
| } |
| |
| @Override |
| public void addListener(IntentEventListener listener) { |
| listeners.add(listener); |
| } |
| |
| @Override |
| public void removeListener(IntentEventListener listener) { |
| listeners.remove(listener); |
| } |
| |
| private void dispatch(IntentEvent event) { |
| for (IntentEventListener listener : listeners) { |
| listener.event(event); |
| } |
| } |
| |
| @Override |
| public <T extends Intent> void registerCompiler(Class<T> cls, IntentCompiler<T> compiler) { |
| compilers.put(cls, compiler); |
| } |
| |
| @Override |
| public <T extends Intent> void unregisterCompiler(Class<T> cls) { |
| compilers.remove(cls); |
| } |
| |
| @Override |
| public Map<Class<? extends Intent>, IntentCompiler<? extends Intent>> getCompilers() { |
| return Collections.unmodifiableMap(compilers); |
| } |
| |
| @Override |
| public <T extends InstallableIntent> void registerInstaller(Class<T> cls, IntentInstaller<T> installer) { |
| installers.put(cls, installer); |
| } |
| |
| @Override |
| public <T extends InstallableIntent> void unregisterInstaller(Class<T> cls) { |
| installers.remove(cls); |
| } |
| |
| @Override |
| public Map<Class<? extends InstallableIntent>, |
| IntentInstaller<? extends InstallableIntent>> getInstallers() { |
| return Collections.unmodifiableMap(installers); |
| } |
| |
| @SuppressWarnings("unchecked") |
| private void registerSubclassCompilerIfNeeded(Intent intent) { |
| if (!compilers.containsKey(intent.getClass())) { |
| Class<?> cls = intent.getClass(); |
| while (cls != Object.class) { |
| // As long as we're within the Intent class descendants |
| if (Intent.class.isAssignableFrom(cls)) { |
| IntentCompiler<?> compiler = compilers.get(cls); |
| if (compiler != null) { |
| compilers.put(intent.getClass(), compiler); |
| return; |
| } |
| } |
| cls = cls.getSuperclass(); |
| } |
| } |
| } |
| |
| @SuppressWarnings("unchecked") |
| private void registerSubclassInstallerIfNeeded(InstallableIntent intent) { |
| if (!installers.containsKey(intent.getClass())) { |
| Class<?> cls = intent.getClass(); |
| while (cls != Object.class) { |
| // As long as we're within the InstallableIntent class descendants |
| if (InstallableIntent.class.isAssignableFrom(cls)) { |
| IntentInstaller<?> installer = installers.get(cls); |
| if (installer != null) { |
| installers.put(intent.getClass(), installer); |
| return; |
| } |
| } |
| cls = cls.getSuperclass(); |
| } |
| } |
| } |
| |
| } |