diff options
author | gjoranv <gv@verizonmedia.com> | 2021-04-02 16:59:04 +0200 |
---|---|---|
committer | gjoranv <gv@verizonmedia.com> | 2021-04-02 19:03:05 +0200 |
commit | 3b286c4c41ef4946afcc958f1724e7e467e5dc3a (patch) | |
tree | 907263ee2de0671957e583bcc44f0639ce8c6401 /container-core/src/main/java/com/yahoo/container/di/componentgraph/core | |
parent | 794378c79b06e6860f862f4c966740a6c8582325 (diff) |
Add java source from container-di.
Diffstat (limited to 'container-core/src/main/java/com/yahoo/container/di/componentgraph/core')
9 files changed, 1274 insertions, 0 deletions
diff --git a/container-core/src/main/java/com/yahoo/container/di/componentgraph/core/ComponentGraph.java b/container-core/src/main/java/com/yahoo/container/di/componentgraph/core/ComponentGraph.java new file mode 100644 index 00000000000..fef2809f236 --- /dev/null +++ b/container-core/src/main/java/com/yahoo/container/di/componentgraph/core/ComponentGraph.java @@ -0,0 +1,431 @@ +// Copyright 2018 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. +package com.yahoo.container.di.componentgraph.core; + +import com.google.common.collect.Iterables; +import com.google.common.collect.Sets; +import com.google.inject.BindingAnnotation; +import com.google.inject.ConfigurationException; +import com.google.inject.Guice; +import com.google.inject.Injector; +import com.google.inject.Key; +import com.yahoo.collections.Pair; +import com.yahoo.component.ComponentId; +import com.yahoo.component.provider.ComponentRegistry; +import com.yahoo.config.ConfigInstance; +import com.yahoo.container.di.componentgraph.Provider; +import com.yahoo.container.di.componentgraph.cycle.CycleFinder; +import com.yahoo.container.di.componentgraph.cycle.Graph; + +import java.util.Collections; +import java.util.logging.Level; +import com.yahoo.vespa.config.ConfigKey; + +import java.lang.annotation.Annotation; +import java.lang.reflect.ParameterizedType; +import java.lang.reflect.Type; +import java.lang.reflect.TypeVariable; +import java.lang.reflect.WildcardType; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.HashMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Set; +import java.util.logging.Logger; +import java.util.stream.Collectors; + +import static com.yahoo.container.di.componentgraph.core.Exceptions.removeStackTrace; + +/** + * @author Tony Vaagenes + * @author gjoranv + * @author ollivir + * + * Not thread safe. + */ +public class ComponentGraph { + + private static final Logger log = Logger.getLogger(ComponentGraph.class.getName()); + + private final long generation; + private final Map<ComponentId, Node> nodesById = new HashMap<>(); + + public ComponentGraph(long generation) { + this.generation = generation; + } + + public ComponentGraph() { + this(0L); + } + + public long generation() { + return generation; + } + + public int size() { + return nodesById.size(); + } + + public Collection<Node> nodes() { + return nodesById.values(); + } + + public void add(Node component) { + if (nodesById.containsKey(component.componentId())) { + throw new IllegalStateException("Multiple components with the same id " + component.componentId()); + } + nodesById.put(component.componentId(), component); + } + + private Optional<Node> lookupGlobalComponent(Key<?> key) { + if (!(key.getTypeLiteral().getType() instanceof Class)) { + throw new RuntimeException("Type not supported " + key.getTypeLiteral()); + } + Class<?> clazz = key.getTypeLiteral().getRawType(); + + Collection<ComponentNode> components = matchingComponentNodes(nodes(), key); + if (components.isEmpty()) { + return Optional.empty(); + } else if (components.size() == 1) { + return Optional.ofNullable(Iterables.get(components, 0)); + } else { + + List<Node> nonProviderComponents = components.stream().filter(c -> !Provider.class.isAssignableFrom(c.instanceType())) + .collect(Collectors.toList()); + if (nonProviderComponents.isEmpty()) { + throw new IllegalStateException("Multiple global component providers for class '" + clazz.getName() + "' found"); + } else if (nonProviderComponents.size() == 1) { + return Optional.of(nonProviderComponents.get(0)); + } else { + throw new IllegalStateException("Multiple global components with class '" + clazz.getName() + "' found"); + } + } + } + + public <T> T getInstance(Class<T> clazz) { + return getInstance(Key.get(clazz)); + } + + @SuppressWarnings("unchecked") + public <T> T getInstance(Key<T> key) { + // TODO: Combine exception handling with lookupGlobalComponent. + Object ob = lookupGlobalComponent(key).map(Node::component) + .orElseThrow(() -> new IllegalStateException(String.format("No global component with key '%s' ", key))); + return (T) ob; + } + + private Collection<ComponentNode> componentNodes() { + return nodesOfType(nodes(), ComponentNode.class); + } + + private Collection<ComponentRegistryNode> componentRegistryNodes() { + return nodesOfType(nodes(), ComponentRegistryNode.class); + } + + private Collection<ComponentNode> osgiComponentsOfClass(Class<?> clazz) { + return componentNodes().stream().filter(node -> clazz.isAssignableFrom(node.componentType())).collect(Collectors.toList()); + } + + public List<Node> complete(Injector fallbackInjector) { + componentNodes().forEach(node -> completeNode(node, fallbackInjector)); + componentRegistryNodes().forEach(this::completeComponentRegistryNode); + return topologicalSort(nodes()); + } + + public List<Node> complete() { + return complete(Guice.createInjector()); + } + + public Set<ConfigKey<? extends ConfigInstance>> configKeys() { + return nodes().stream().flatMap(node -> node.configKeys().stream()).collect(Collectors.toSet()); + } + + public void setAvailableConfigs(Map<ConfigKey<? extends ConfigInstance>, ConfigInstance> configs) { + componentNodes().forEach(node -> node.setAvailableConfigs(Keys.invariantCopy(configs))); + } + + public void reuseNodes(ComponentGraph old) { + // copy instances if node equal + Set<ComponentId> commonComponentIds = Sets.intersection(nodesById.keySet(), old.nodesById.keySet()); + for (ComponentId id : commonComponentIds) { + if (nodesById.get(id).equals(old.nodesById.get(id))) { + nodesById.get(id).instance = old.nodesById.get(id).instance; + } + } + + // reset instances with modified dependencies + for (Node node : topologicalSort(nodes())) { + for (Node usedComponent : node.usedComponents()) { + if (usedComponent.instance.isEmpty()) { + node.instance = Optional.empty(); + } + } + } + } + + /** All constructed components and providers of this, in reverse creation order, i.e., suited for ordered deconstruction. */ + public List<Object> allConstructedComponentsAndProviders() { + List<Node> orderedNodes = topologicalSort(nodes()); + Collections.reverse(orderedNodes); + return orderedNodes.stream().map(node -> node.constructedInstance().get()).collect(Collectors.toList()); + } + + private void completeComponentRegistryNode(ComponentRegistryNode registry) { + registry.injectAll(osgiComponentsOfClass(registry.componentClass())); + } + + private void completeNode(ComponentNode node, Injector fallbackInjector) { + try { + Object[] arguments = node.getAnnotatedConstructorParams().stream().map(param -> handleParameter(node, fallbackInjector, param)) + .toArray(); + + node.setArguments(arguments); + } catch (Exception e) { + throw removeStackTrace(new RuntimeException("When resolving dependencies of " + node.idAndType(), e)); + } + } + + private Object handleParameter(Node node, Injector fallbackInjector, Pair<Type, List<Annotation>> annotatedParameterType) { + Type parameterType = annotatedParameterType.getFirst(); + List<Annotation> annotations = annotatedParameterType.getSecond(); + + if (parameterType instanceof Class && parameterType.equals(ComponentId.class)) { + return node.componentId(); + } else if (parameterType instanceof Class && ConfigInstance.class.isAssignableFrom((Class<?>) parameterType)) { + return handleConfigParameter((ComponentNode) node, (Class<?>) parameterType); + } else if (parameterType instanceof ParameterizedType + && ((ParameterizedType) parameterType).getRawType().equals(ComponentRegistry.class)) { + ParameterizedType registry = (ParameterizedType) parameterType; + return getComponentRegistry(registry.getActualTypeArguments()[0]); + } else if (parameterType instanceof Class) { + return handleComponentParameter(node, fallbackInjector, (Class<?>) parameterType, annotations); + } else if (parameterType instanceof ParameterizedType) { + throw new RuntimeException("Injection of parameterized type " + parameterType + " is not supported."); + } else { + throw new RuntimeException("Injection of type " + parameterType + " is not supported"); + } + } + + private ComponentRegistryNode newComponentRegistryNode(Class<?> componentClass) { + ComponentRegistryNode registry = new ComponentRegistryNode(componentClass); + add(registry); //TODO: don't mutate nodes here. + return registry; + } + + private ComponentRegistryNode getComponentRegistry(Type componentType) { + Class<?> componentClass; + if (componentType instanceof WildcardType) { + WildcardType wildcardType = (WildcardType) componentType; + if (wildcardType.getLowerBounds().length > 0 || wildcardType.getUpperBounds().length > 1) { + throw new RuntimeException("Can't create ComponentRegistry of unknown wildcard type" + wildcardType); + } + componentClass = (Class<?>) wildcardType.getUpperBounds()[0]; + } else if (componentType instanceof Class) { + componentClass = (Class<?>) componentType; + } else if (componentType instanceof TypeVariable) { + throw new RuntimeException("Can't create ComponentRegistry of unknown type variable " + componentType); + } else { + throw new RuntimeException("Can't create ComponentRegistry of unknown type " + componentType); + } + + for (ComponentRegistryNode node : componentRegistryNodes()) { + if (node.componentClass().equals(componentType)) { + return node; + } + } + return newComponentRegistryNode(componentClass); + } + + @SuppressWarnings("unchecked") + private ConfigKey<ConfigInstance> handleConfigParameter(ComponentNode node, Class<?> clazz) { + Class<ConfigInstance> castClass = (Class<ConfigInstance>) clazz; + return new ConfigKey<>(castClass, node.configId()); + } + + private <T> Key<T> getKey(Class<T> clazz, Optional<Annotation> bindingAnnotation) { + return bindingAnnotation.map(annotation -> Key.get(clazz, annotation)).orElseGet(() -> Key.get(clazz)); + } + + private Optional<GuiceNode> matchingGuiceNode(Key<?> key, Object instance) { + return matchingNodes(nodes(), GuiceNode.class, key).stream().filter(node -> node.component() == instance). // TODO: assert that there is only one (after filter) + findFirst(); + } + + private Node lookupOrCreateGlobalComponent(Node node, Injector fallbackInjector, Class<?> clazz, Key<?> key) { + Optional<Node> component = lookupGlobalComponent(key); + if (component.isEmpty()) { + Object instance; + try { + log.log(Level.FINE, "Trying the fallback injector to create" + messageForNoGlobalComponent(clazz, node)); + instance = fallbackInjector.getInstance(key); + } catch (ConfigurationException e) { + throw removeStackTrace(new IllegalStateException( + (messageForMultipleClassLoaders(clazz).isEmpty()) ? "No global" + messageForNoGlobalComponent(clazz, node) + : messageForMultipleClassLoaders(clazz))); + } + component = Optional.of(matchingGuiceNode(key, instance).orElseGet(() -> { + GuiceNode guiceNode = new GuiceNode(instance, key.getAnnotation()); + add(guiceNode); + return guiceNode; + })); + } + return component.get(); + } + + private Node handleComponentParameter(Node node, Injector fallbackInjector, Class<?> clazz, Collection<Annotation> annotations) { + + List<Annotation> bindingAnnotations = annotations.stream().filter(ComponentGraph::isBindingAnnotation).collect(Collectors.toList()); + Key<?> key = getKey(clazz, bindingAnnotations.stream().findFirst()); + + if (bindingAnnotations.size() > 1) { + throw new RuntimeException(String.format("More than one binding annotation used in class '%s'", node.instanceType())); + } + + Collection<ComponentNode> injectedNodesOfCorrectType = matchingComponentNodes(node.componentsToInject, key); + if (injectedNodesOfCorrectType.size() == 0) { + return lookupOrCreateGlobalComponent(node, fallbackInjector, clazz, key); + } else if (injectedNodesOfCorrectType.size() == 1) { + return Iterables.get(injectedNodesOfCorrectType, 0); + } else { + //TODO: !className for last parameter + throw new RuntimeException( + String.format("Multiple components of type '%s' injected into component '%s'", clazz.getName(), node.instanceType())); + } + } + + private static String messageForNoGlobalComponent(Class<?> clazz, Node node) { + return String.format(" component of class %s to inject into component %s.", clazz.getName(), node.idAndType()); + } + + private String messageForMultipleClassLoaders(Class<?> clazz) { + String errMsg = "Class " + clazz.getName() + " is provided by the framework, and cannot be embedded in a user bundle. " + + "To resolve this problem, please refer to osgi-classloading.html#multiple-implementations in the documentation"; + + try { + Class<?> resolvedClass = Class.forName(clazz.getName(), false, this.getClass().getClassLoader()); + if (!resolvedClass.equals(clazz)) { + return errMsg; + } + } catch (ClassNotFoundException ignored) { + + } + return ""; + } + + public static Node getNode(ComponentGraph graph, String componentId) { + return graph.nodesById.get(new ComponentId(componentId)); + } + + private static <T> Collection<T> nodesOfType(Collection<Node> nodes, Class<T> clazz) { + List<T> ret = new ArrayList<>(); + for (Node node : nodes) { + if (clazz.isInstance(node)) { + ret.add(clazz.cast(node)); + } + } + return ret; + } + + private static Collection<ComponentNode> matchingComponentNodes(Collection<Node> nodes, Key<?> key) { + return matchingNodes(nodes, ComponentNode.class, key); + } + + // Finds all nodes with a given nodeType and instance with given key + private static <T extends Node> Collection<T> matchingNodes(Collection<Node> nodes, Class<T> nodeType, Key<?> key) { + Class<?> clazz = key.getTypeLiteral().getRawType(); + Annotation annotation = key.getAnnotation(); + + List<T> filteredByClass = nodesOfType(nodes, nodeType).stream().filter(node -> clazz.isAssignableFrom(node.componentType())) + .collect(Collectors.toList()); + + if (filteredByClass.size() == 1) { + return filteredByClass; + } else { + List<T> filteredByClassAndAnnotation = filteredByClass.stream() + .filter(node -> (annotation == null && node.instanceKey().getAnnotation() == null) + || annotation.equals(node.instanceKey().getAnnotation())) + .collect(Collectors.toList()); + if (filteredByClassAndAnnotation.size() > 0) { + return filteredByClassAndAnnotation; + } else { + return filteredByClass; + } + } + } + + // Returns true if annotation is a BindingAnnotation, e.g. com.google.inject.name.Named + public static boolean isBindingAnnotation(Annotation annotation) { + LinkedList<Class<?>> queue = new LinkedList<>(); + queue.add(annotation.getClass()); + queue.addAll(Arrays.asList(annotation.getClass().getInterfaces())); + + while (!queue.isEmpty()) { + Class<?> clazz = queue.removeFirst(); + if (clazz.getAnnotation(BindingAnnotation.class) != null) { + return true; + } else { + if (clazz.getSuperclass() != null) { + queue.addFirst(clazz.getSuperclass()); + } + } + } + return false; + } + + /** + * The returned list is the nodes from the graph bottom-up. + * + * For each iteration, the algorithm finds the components that are not "wanted by" any other component, + * and prepends those components into the resulting 'sorted' list. Hence, the first element in the returned + * list is the component that is directly or indirectly wanted by "most" other components. + * + * @return A list where a earlier than b in the list implies that there is no path from a to b + */ + private static List<Node> topologicalSort(Collection<Node> nodes) { + Map<ComponentId, Integer> numIncoming = new HashMap<>(); + + nodes.forEach( + node -> node.usedComponents().forEach( + injectedNode -> numIncoming.merge(injectedNode.componentId(), 1, (a, b) -> a + b))); + + LinkedList<Node> sorted = new LinkedList<>(); + List<Node> unsorted = new ArrayList<>(nodes); + + while (!unsorted.isEmpty()) { + List<Node> ready = new ArrayList<>(); + List<Node> notReady = new ArrayList<>(); + unsorted.forEach(node -> { + if (numIncoming.getOrDefault(node.componentId(), 0) == 0) { + ready.add(node); + } else { + notReady.add(node); + } + }); + + if (ready.isEmpty()) { + throw new IllegalStateException("There is a cycle in the component injection graph: " + findCycle(notReady)); + } + + ready.forEach(node -> node.usedComponents() + .forEach(injectedNode -> numIncoming.merge(injectedNode.componentId(), -1, (a, b) -> a + b))); + sorted.addAll(0, ready); + unsorted = notReady; + } + return sorted; + } + + private static List<String> findCycle(List<Node> nodes) { + var cyclicGraph = new Graph<String>(); + for (var node : nodes) { + for (var adjacent : node.usedComponents()) { + cyclicGraph.edge(node.componentId().stringValue(), + adjacent.componentId().stringValue()); + } + } + return new CycleFinder<>(cyclicGraph).findCycle(); + } + +} diff --git a/container-core/src/main/java/com/yahoo/container/di/componentgraph/core/ComponentNode.java b/container-core/src/main/java/com/yahoo/container/di/componentgraph/core/ComponentNode.java new file mode 100644 index 00000000000..b6fa4241e26 --- /dev/null +++ b/container-core/src/main/java/com/yahoo/container/di/componentgraph/core/ComponentNode.java @@ -0,0 +1,313 @@ +// Copyright Verizon Media. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. +package com.yahoo.container.di.componentgraph.core; + +import com.google.inject.Inject; +import com.google.inject.Key; +import com.yahoo.collections.Pair; +import com.yahoo.component.AbstractComponent; +import com.yahoo.component.ComponentId; +import com.yahoo.config.ConfigInstance; +import com.yahoo.container.di.componentgraph.Provider; +import com.yahoo.vespa.config.ConfigKey; + +import java.lang.annotation.Annotation; +import java.lang.reflect.Constructor; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Modifier; +import java.lang.reflect.ParameterizedType; +import java.lang.reflect.Type; +import java.time.Duration; +import java.time.Instant; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Comparator; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.logging.Logger; +import java.util.stream.Collectors; + +import static com.yahoo.container.di.componentgraph.core.Exceptions.cutStackTraceAtConstructor; +import static com.yahoo.container.di.componentgraph.core.Exceptions.removeStackTrace; +import static com.yahoo.container.di.componentgraph.core.Keys.createKey; +import static java.util.logging.Level.FINE; +import static java.util.logging.Level.INFO; + +/** + * @author Tony Vaagenes + * @author gjoranv + * @author ollivir + */ +public class ComponentNode extends Node { + + private static final Logger log = Logger.getLogger(ComponentNode.class.getName()); + + private final Class<?> clazz; + private final Annotation key; + private Object[] arguments = null; + private final String configId; + + private final Constructor<?> constructor; + + private Map<ConfigKey<ConfigInstance>, ConfigInstance> availableConfigs = null; + + + public ComponentNode(ComponentId componentId, + String configId, + Class<?> clazz, Annotation XXX_key) // TODO expose key, not javaAnnotation + { + super(componentId); + if (isAbstract(clazz)) { + throw new IllegalArgumentException("Can't instantiate abstract class " + clazz.getName()); + } + this.configId = configId; + this.clazz = clazz; + this.key = XXX_key; + this.constructor = bestConstructor(clazz); + } + + public ComponentNode(ComponentId componentId, String configId, Class<?> clazz) { + this(componentId, configId, clazz, null); + } + + public String configId() { + return configId; + } + + @Override + public Key<?> instanceKey() { + return createKey(clazz, key); + } + + @Override + public Class<?> instanceType() { + return clazz; + } + + @Override + public List<Node> usedComponents() { + if (arguments == null) { + throw new IllegalStateException("Arguments must be set first."); + } + List<Node> ret = new ArrayList<>(); + for (Object arg : arguments) { + if (arg instanceof Node) { + ret.add((Node) arg); + } + } + return ret; + } + + private static List<Class<?>> allSuperClasses(Class<?> clazz) { + List<Class<?>> ret = new ArrayList<>(); + while (clazz != null) { + ret.add(clazz); + clazz = clazz.getSuperclass(); + } + return ret; + } + + @Override + public Class<?> componentType() { + if (Provider.class.isAssignableFrom(clazz)) { + //TODO: Test what happens if you ask for something that isn't a class, e.g. a parameterized type. + + List<Type> allGenericInterfaces = allSuperClasses(clazz).stream().flatMap(c -> Arrays.stream(c.getGenericInterfaces())).collect(Collectors.toList()); + for (Type t : allGenericInterfaces) { + if (t instanceof ParameterizedType && ((ParameterizedType) t).getRawType().equals(Provider.class)) { + Type[] typeArgs = ((ParameterizedType) t).getActualTypeArguments(); + if (typeArgs != null && typeArgs.length > 0) { + return (Class<?>) typeArgs[0]; + } + } + } + throw new IllegalStateException("Component type cannot be resolved"); + } else { + return clazz; + } + } + + public void setArguments(Object[] arguments) { + this.arguments = arguments; + } + + @Override + protected Object newInstance() { + if (arguments == null) { + throw new IllegalStateException("graph.complete must be called before retrieving instances."); + } + + List<Object> actualArguments = new ArrayList<>(); + for (Object ob : arguments) { + if (ob instanceof Node) { + actualArguments.add(((Node) ob).component()); + } else if (ob instanceof ConfigKey) { + actualArguments.add(availableConfigs.get(ob)); + } else { + actualArguments.add(ob); + } + } + + Object instance; + try { + log.log(FINE, () -> "Constructing " + idAndType()); + Instant start = Instant.now(); + instance = constructor.newInstance(actualArguments.toArray()); + Duration duration = Duration.between(start, Instant.now()); + log.log(duration.compareTo(Duration.ofMinutes(1)) > 0 ? INFO : FINE, + () -> "Finished constructing " + idAndType() + " in " + duration); + } catch (InvocationTargetException | InstantiationException | IllegalAccessException e) { + StackTraceElement dependencyInjectorMarker = new StackTraceElement("============= Dependency Injection =============", "newInstance", null, -1); + throw removeStackTrace(new ComponentConstructorException("Error constructing " + idAndType() + ": " + e.getMessage(), cutStackTraceAtConstructor(e.getCause(), dependencyInjectorMarker))); + } + + return initId(instance); + } + + private Object initId(Object component) { + if (component instanceof AbstractComponent) { + AbstractComponent abstractComponent = (AbstractComponent) component; + if (abstractComponent.hasInitializedId() && !abstractComponent.getId().equals(componentId())) { + throw new IllegalStateException( + "Component with id '" + componentId() + "' is trying to set its component id explicitly: '" + abstractComponent.getId() + "'. " + + "This is not allowed, so please remove any call to super() in your component's constructor."); + } + abstractComponent.initId(componentId()); + } + return component; + } + + + @Override + public int hashCode() { + final int prime = 31; + int result = super.hashCode(); + result = prime * result + Arrays.hashCode(arguments); + result = prime * result + ((availableConfigs == null) ? 0 : availableConfigs.hashCode()); + result = prime * result + ((configId == null) ? 0 : configId.hashCode()); + return result; + } + + @Override + public boolean equals(Object other) { + if (other instanceof ComponentNode) { + ComponentNode that = (ComponentNode) other; + return super.equals(that) && equalEdges(Arrays.asList(this.arguments), Arrays.asList(that.arguments)) && this.usedConfigs().equals(that.usedConfigs()); + } else { + return false; + } + } + + private List<ConfigInstance> usedConfigs() { + if (availableConfigs == null) { + throw new IllegalStateException("setAvailableConfigs must be called!"); + } + List<ConfigInstance> ret = new ArrayList<>(); + for (Object arg : arguments) { + if (arg instanceof ConfigKey) { + ret.add(availableConfigs.get(arg)); + } + } + return ret; + } + + protected List<Pair<Type, List<Annotation>>> getAnnotatedConstructorParams() { + Type[] types = constructor.getGenericParameterTypes(); + Annotation[][] annotations = constructor.getParameterAnnotations(); + + List<Pair<Type, List<Annotation>>> ret = new ArrayList<>(); + + for (int i = 0; i < types.length; i++) { + ret.add(new Pair<>(types[i], Arrays.asList(annotations[i]))); + } + return ret; + } + + public void setAvailableConfigs(Map<ConfigKey<ConfigInstance>, ConfigInstance> configs) { + if (arguments == null) { + throw new IllegalStateException("graph.complete must be called before graph.setAvailableConfigs."); + } + this.availableConfigs = configs; + } + + @Override + public Set<ConfigKey<ConfigInstance>> configKeys() { + return configParameterClasses().stream().map(par -> new ConfigKey<>(par, configId)).collect(Collectors.toSet()); + } + + @SuppressWarnings("unchecked") + private List<Class<ConfigInstance>> configParameterClasses() { + List<Class<ConfigInstance>> ret = new ArrayList<>(); + for (Type type : constructor.getGenericParameterTypes()) { + if (type instanceof Class && ConfigInstance.class.isAssignableFrom((Class<?>) type)) { + ret.add((Class<ConfigInstance>) type); + } + } + return ret; + } + + @Override + public String label() { + LinkedList<String> configNames = configKeys().stream().map(k -> k.getName() + ".def").collect(Collectors.toCollection(LinkedList::new)); + + configNames.addFirst(instanceType().getSimpleName()); + configNames.addFirst(Node.packageName(instanceType())); + + return "{" + String.join("|", configNames) + "}"; + } + + private static Constructor<?> bestConstructor(Class<?> clazz) { + Constructor<?>[] publicConstructors = clazz.getConstructors(); + + Constructor<?> annotated = null; + for (Constructor<?> ctor : publicConstructors) { + Annotation annotation = ctor.getAnnotation(Inject.class); + if (annotation != null) { + if (annotated == null) { + annotated = ctor; + } else { + throw componentConstructorException("Multiple constructor annotated with @Inject in class " + clazz.getName()); + } + } + } + if (annotated != null) { + return annotated; + } + + if (publicConstructors.length == 0) { + throw componentConstructorException("No public constructors in class " + clazz.getName()); + } else if (publicConstructors.length == 1) { + return publicConstructors[0]; + } else { + log.warning(String.format("Multiple public constructors found in class %s, there should only be one. " + + "If more than one public constructor is needed, the primary one must be annotated with @Inject.", clazz.getName())); + List<Pair<Constructor<?>, Integer>> withParameterCount = new ArrayList<>(); + for (Constructor<?> ctor : publicConstructors) { + long count = Arrays.stream(ctor.getParameterTypes()).filter(ConfigInstance.class::isAssignableFrom).count(); + withParameterCount.add(new Pair<>(ctor, (int) count)); + } + withParameterCount.sort(Comparator.comparingInt(Pair::getSecond)); + return withParameterCount.get(withParameterCount.size() - 1).getFirst(); + } + } + + private static ComponentConstructorException componentConstructorException(String message) { + return removeStackTrace(new ComponentConstructorException(message)); + } + + public static class ComponentConstructorException extends RuntimeException { + ComponentConstructorException(String message) { + super(message); + } + + ComponentConstructorException(String message, Throwable cause) { + super(message, cause); + } + } + + + private static boolean isAbstract(Class<?> clazz) { + return Modifier.isAbstract(clazz.getModifiers()); + } +}
\ No newline at end of file diff --git a/container-core/src/main/java/com/yahoo/container/di/componentgraph/core/ComponentRegistryNode.java b/container-core/src/main/java/com/yahoo/container/di/componentgraph/core/ComponentRegistryNode.java new file mode 100644 index 00000000000..429052c0039 --- /dev/null +++ b/container-core/src/main/java/com/yahoo/container/di/componentgraph/core/ComponentRegistryNode.java @@ -0,0 +1,107 @@ +// Copyright 2018 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. +package com.yahoo.container.di.componentgraph.core; + +import com.google.inject.Key; +import com.google.inject.util.Types; +import com.yahoo.component.ComponentId; +import com.yahoo.component.provider.ComponentRegistry; +import com.yahoo.config.ConfigInstance; +import com.yahoo.vespa.config.ConfigKey; + +import java.util.Collections; +import java.util.List; +import java.util.Set; +import java.util.stream.Collectors; + +/** + * @author Tony Vaagenes + * @author gjoranv + * @author ollivir + */ +public class ComponentRegistryNode extends Node { + + private static ComponentId componentRegistryNamespace = ComponentId.fromString("ComponentRegistry"); + + private final Class<?> componentClass; + + public ComponentRegistryNode(Class<?> componentClass) { + super(componentId(componentClass)); + this.componentClass = componentClass; + } + + @Override + public List<Node> usedComponents() { + return componentsToInject; + } + + @Override + protected Object newInstance() { + ComponentRegistry<Object> registry = new ComponentRegistry<>(); + componentsToInject.forEach(component -> registry.register(component.componentId(), component.component())); + + return registry; + } + + @Override + public Key<?> instanceKey() { + return Key.get(Types.newParameterizedType(ComponentRegistry.class, componentClass)); + } + + @Override + public Class<?> instanceType() { + return instanceKey().getTypeLiteral().getRawType(); + } + + @Override + public Class<?> componentType() { + return instanceType(); + } + + public Class<?> componentClass() { + return componentClass; + } + + @Override + public Set<ConfigKey<ConfigInstance>> configKeys() { + return Collections.emptySet(); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = super.hashCode(); + result = prime * result + ((componentClass == null) ? 0 : componentClass.hashCode()); + return result; + } + + @Override + public boolean equals(Object other) { + if (other instanceof ComponentRegistryNode) { + ComponentRegistryNode that = (ComponentRegistryNode) other; + return this.componentId().equals(that.componentId()) && this.instanceType().equals(that.instanceType()) + && equalNodeEdges(this.usedComponents(), that.usedComponents()); + } else { + return false; + } + } + + @Override + public String label() { + return String.format("{ComponentRegistry\\<%s\\>|%s}", componentClass.getSimpleName(), Node.packageName(componentClass)); + } + + private static ComponentId componentId(Class<?> componentClass) { + return syntheticComponentId(componentClass.getName(), componentClass, componentRegistryNamespace); + } + + public static boolean equalNodeEdges(List<Node> edges, List<Node> otherEdges) { + if (edges.size() == otherEdges.size()) { + List<ComponentId> left = edges.stream().map(Node::componentId).sorted().collect(Collectors.toList()); + List<ComponentId> right = otherEdges.stream().map(Node::componentId).sorted().collect(Collectors.toList()); + return left.equals(right); + } else { + return false; + } + } + +} diff --git a/container-core/src/main/java/com/yahoo/container/di/componentgraph/core/Exceptions.java b/container-core/src/main/java/com/yahoo/container/di/componentgraph/core/Exceptions.java new file mode 100644 index 00000000000..b0d9d1f3921 --- /dev/null +++ b/container-core/src/main/java/com/yahoo/container/di/componentgraph/core/Exceptions.java @@ -0,0 +1,47 @@ +// Copyright 2018 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. +package com.yahoo.container.di.componentgraph.core; + +import java.util.Arrays; + +class Exceptions { + + static <E extends Throwable> E removeStackTrace(E exception) { + if (preserveStackTrace()) { + return exception; + } else { + exception.setStackTrace(new StackTraceElement[0]); + return exception; + } + } + + static boolean preserveStackTrace() { + String preserve = System.getProperty("jdisc.container.preserveStackTrace"); + return (preserve != null && !preserve.isEmpty()); + } + + static Throwable cutStackTraceAtConstructor(Throwable throwable, StackTraceElement marker) { + if (throwable != null && !preserveStackTrace()) { + StackTraceElement[] stackTrace = throwable.getStackTrace(); + int upTo = stackTrace.length - 1; + + // take until ComponentNode is reached + while (upTo >= 0 && !stackTrace[upTo].getClassName().equals(ComponentNode.class.getName())) { + upTo--; + } + + // then drop until <init> is reached + while (upTo >= 0 && !stackTrace[upTo].getMethodName().equals("<init>")) { + upTo--; + } + if (upTo < 0) { + throwable.setStackTrace(new StackTraceElement[0]); + } else { + throwable.setStackTrace(Arrays.copyOfRange(stackTrace, 0, upTo)); + } + + cutStackTraceAtConstructor(throwable.getCause(), marker); + } + return throwable; + } + +} diff --git a/container-core/src/main/java/com/yahoo/container/di/componentgraph/core/GuiceNode.java b/container-core/src/main/java/com/yahoo/container/di/componentgraph/core/GuiceNode.java new file mode 100644 index 00000000000..61d0d9bba8d --- /dev/null +++ b/container-core/src/main/java/com/yahoo/container/di/componentgraph/core/GuiceNode.java @@ -0,0 +1,78 @@ +// Copyright 2018 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. +package com.yahoo.container.di.componentgraph.core; + +import com.google.inject.Key; +import com.yahoo.component.ComponentId; +import com.yahoo.config.ConfigInstance; +import com.yahoo.vespa.config.ConfigKey; + +import java.lang.annotation.Annotation; +import java.util.Collections; +import java.util.List; +import java.util.Set; + +import static com.yahoo.container.di.componentgraph.core.Keys.createKey; + +/** + * @author Tony Vaagenes + * @author gjoranv + * @author ollivir + */ +public final class GuiceNode extends Node { + private static final ComponentId guiceNamespace = ComponentId.fromString("Guice"); + + private final Object myInstance; + private final Annotation annotation; + + public GuiceNode(Object myInstance, + Annotation annotation) { + super(componentId(myInstance)); + this.myInstance = myInstance; + this.annotation = annotation; + } + + @Override + public Set<ConfigKey<ConfigInstance>> configKeys() { + return Collections.emptySet(); + } + + @Override + public Key<?> instanceKey() { + return createKey(myInstance.getClass(), annotation); + } + + @Override + public Class<?> instanceType() { + return myInstance.getClass(); + } + + @Override + public Class<?> componentType() { + return instanceType(); + } + + + @Override + public List<Node> usedComponents() { + return Collections.emptyList(); + } + + @Override + protected Object newInstance() { + return myInstance; + } + + @Override + public void inject(Node component) { + throw new UnsupportedOperationException("Illegal to inject components to a GuiceNode!"); + } + + @Override + public String label() { + return String.format("{{%s|Guice}|%s}", instanceType().getSimpleName(), Node.packageName(instanceType())); + } + + private static ComponentId componentId(Object instance) { + return Node.syntheticComponentId(instance.getClass().getName(), instance, guiceNamespace); + } +} diff --git a/container-core/src/main/java/com/yahoo/container/di/componentgraph/core/JerseyNode.java b/container-core/src/main/java/com/yahoo/container/di/componentgraph/core/JerseyNode.java new file mode 100644 index 00000000000..0f8aa678934 --- /dev/null +++ b/container-core/src/main/java/com/yahoo/container/di/componentgraph/core/JerseyNode.java @@ -0,0 +1,92 @@ +// Copyright 2018 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. +package com.yahoo.container.di.componentgraph.core; + +import com.yahoo.component.ComponentId; +import com.yahoo.component.ComponentSpecification; +import com.yahoo.container.di.Osgi; +import com.yahoo.container.di.config.JerseyBundlesConfig; +import com.yahoo.container.di.config.RestApiContext; +import com.yahoo.container.di.config.RestApiContext.BundleInfo; +import com.yahoo.container.di.osgi.BundleClasses; +import org.osgi.framework.Bundle; +import org.osgi.framework.wiring.BundleWiring; + +import java.net.URL; +import java.util.Collection; +import java.util.HashSet; +import java.util.List; + +/** + * Represents an instance of RestApiContext + * + * @author gjoranv + * @author Tony Vaagenes + * @author ollivir + */ +public class JerseyNode extends ComponentNode { + private static final String WEB_INF_URL = "WebInfUrl"; + + private final Osgi osgi; + + public JerseyNode(ComponentId componentId, String configId, Class<?> clazz, Osgi osgi) { + super(componentId, configId, clazz, null); + this.osgi = osgi; + } + + @Override + protected RestApiContext newInstance() { + Object instance = super.newInstance(); + RestApiContext restApiContext = (RestApiContext) instance; + + List<JerseyBundlesConfig.Bundles> bundles = restApiContext.bundlesConfig.bundles(); + for (JerseyBundlesConfig.Bundles bundleConfig : bundles) { + BundleClasses bundleClasses = osgi.getBundleClasses(ComponentSpecification.fromString(bundleConfig.spec()), + new HashSet<>(bundleConfig.packages())); + + restApiContext.addBundle(createBundleInfo(bundleClasses.bundle(), bundleClasses.classEntries())); + } + + componentsToInject.forEach(component -> restApiContext.addInjectableComponent(component.instanceKey(), component.componentId(), + component.component())); + + return restApiContext; + } + + @Override + public int hashCode() { + return super.hashCode(); + } + + @Override + public boolean equals(Object other) { + return super.equals(other) + && (other instanceof JerseyNode && this.componentsToInject.equals(((JerseyNode) other).componentsToInject)); + } + + public static BundleInfo createBundleInfo(Bundle bundle, Collection<String> classEntries) { + BundleInfo bundleInfo = new BundleInfo(bundle.getSymbolicName(), bundle.getVersion(), bundle.getLocation(), webInfUrl(bundle), + bundle.adapt(BundleWiring.class).getClassLoader()); + + bundleInfo.setClassEntries(classEntries); + return bundleInfo; + } + + public static Bundle getBundle(Osgi osgi, String bundleSpec) { + Bundle bundle = osgi.getBundle(ComponentSpecification.fromString(bundleSpec)); + if (bundle == null) { + throw new IllegalArgumentException("Bundle not found: " + bundleSpec); + } + return bundle; + } + + private static URL webInfUrl(Bundle bundle) { + String webInfUrlHeader = bundle.getHeaders().get(WEB_INF_URL); + + if (webInfUrlHeader == null) { + return null; + } else { + return bundle.getEntry(webInfUrlHeader); + } + } + +} diff --git a/container-core/src/main/java/com/yahoo/container/di/componentgraph/core/Keys.java b/container-core/src/main/java/com/yahoo/container/di/componentgraph/core/Keys.java new file mode 100644 index 00000000000..be80fc1616d --- /dev/null +++ b/container-core/src/main/java/com/yahoo/container/di/componentgraph/core/Keys.java @@ -0,0 +1,39 @@ +// Copyright 2018 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. +package com.yahoo.container.di.componentgraph.core; + +import com.google.inject.Key; +import com.yahoo.config.ConfigInstance; +import com.yahoo.vespa.config.ConfigKey; + +import java.lang.annotation.Annotation; +import java.lang.reflect.Type; +import java.util.HashMap; +import java.util.Map; + +/** + * @author ollivir + */ +public class Keys { + + static Key<?> createKey(Type instanceType, Annotation annotation) { + if (annotation == null) { + return Key.get(instanceType); + } else { + return Key.get(instanceType, annotation); + } + } + + @SuppressWarnings("unchecked") + public static Map<ConfigKey<ConfigInstance>, ConfigInstance> invariantCopy(Map<ConfigKey<? extends ConfigInstance>, ConfigInstance> configs) { + Map<ConfigKey<ConfigInstance>, ConfigInstance> ret = new HashMap<>(); + configs.forEach((k, v) -> ret.put((ConfigKey<ConfigInstance>) k, v)); + return ret; + } + + public static Map<ConfigKey<? extends ConfigInstance>, ConfigInstance> covariantCopy(Map<ConfigKey<ConfigInstance>, ConfigInstance> configs) { + Map<ConfigKey<? extends ConfigInstance>, ConfigInstance> ret = new HashMap<>(); + configs.forEach((k, v) -> ret.put(k, v)); + return ret; + } + +} diff --git a/container-core/src/main/java/com/yahoo/container/di/componentgraph/core/Node.java b/container-core/src/main/java/com/yahoo/container/di/componentgraph/core/Node.java new file mode 100644 index 00000000000..3afc8bb817c --- /dev/null +++ b/container-core/src/main/java/com/yahoo/container/di/componentgraph/core/Node.java @@ -0,0 +1,162 @@ +// Copyright 2018 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. +package com.yahoo.container.di.componentgraph.core; + +import com.google.inject.Key; +import com.yahoo.component.ComponentId; +import com.yahoo.config.ConfigInstance; +import com.yahoo.container.di.componentgraph.Provider; +import com.yahoo.vespa.config.ConfigKey; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Iterator; +import java.util.List; +import java.util.Optional; +import java.util.Set; +import java.util.logging.Logger; + +import static java.util.logging.Level.FINE; + +/** + * @author Tony Vaagenes + * @author gjoranv + * @author ollivir + */ +public abstract class Node { + + private final static Logger log = Logger.getLogger(Node.class.getName()); + + private final ComponentId componentId; + protected Optional<Object> instance = Optional.empty(); + List<Node> componentsToInject = new ArrayList<>(); + + public Node(ComponentId componentId) { + this.componentId = componentId; + } + + public abstract Key<?> instanceKey(); + + /** + * The components actually used by this node. Consist of a subset of the injected nodes + subset of the global nodes. + */ + public abstract List<Node> usedComponents(); + + protected abstract Object newInstance(); + + /** Constructs the instance represented by this node, if not already done. */ + public void constructInstance() { + if ( ! instance.isPresent()) + instance = Optional.of(newInstance()); + } + + /** + * Returns the component represented by this - which is either the instance, or if the instance is a provider, + * the component returned by it. + */ + public Object component() { + constructInstance(); + if (instance.get() instanceof Provider) { + Provider<?> provider = (Provider<?>) instance.get(); + return provider.get(); + } else { + return instance.get(); + } + } + + public abstract Set<ConfigKey<ConfigInstance>> configKeys(); + + public void inject(Node component) { + componentsToInject.add(component); + } + + public void injectAll(Collection<ComponentNode> componentNodes) { + componentNodes.forEach(this::inject); + } + + public abstract Class<?> instanceType(); + + public abstract Class<?> componentType(); + + public abstract String label(); + + public String idAndType() { + String className = instanceType().getName(); + + if (className.equals(componentId.getName())) { + return "'" + componentId + "'"; + } else { + return "'" + componentId + "' of type '" + className + "'"; + } + } + + private static boolean equalNodes(Object a, Object b) { + if (a instanceof Node && b instanceof Node) { + Node l = (Node) a; + Node r = (Node) b; + return l.componentId.equals(r.componentId); + } else { + return a.equals(b); + } + } + + public static boolean equalEdges(List<?> edges1, List<?> edges2) { + Iterator<?> right = edges2.iterator(); + for (Object l : edges1) { + if (!right.hasNext()) { + return false; + } + Object r = right.next(); + if (!equalNodes(l, r)) { + return false; + } + } + return !right.hasNext(); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + ((componentId == null) ? 0 : componentId.hashCode()); + result = prime * result + ((componentsToInject == null) ? 0 : componentsToInject.hashCode()); + return result; + } + + @Override + public boolean equals(Object other) { + if (other instanceof Node) { + Node that = (Node) other; + return getClass().equals(that.getClass()) && this.componentId.equals(that.componentId) + && this.instanceType().equals(that.instanceType()) && equalEdges(this.usedComponents(), that.usedComponents()); + } else { + return false; + } + } + + public ComponentId componentId() { + return componentId; + } + + /** Returns the already constructed instance in this, if any */ + public Optional<?> constructedInstance() { + return instance; + } + + /** + * @param identityObject he identifying object that makes the Node unique + */ + protected static ComponentId syntheticComponentId(String className, Object identityObject, ComponentId namespace) { + String name = className + "_" + System.identityHashCode(identityObject); + return ComponentId.fromString(name).nestInNamespace(namespace); + } + + public static String packageName(Class<?> componentClass) { + String fullClassName = componentClass.getName(); + int index = fullClassName.lastIndexOf('.'); + if (index < 0) { + return ""; + } else { + return fullClassName.substring(0, index); + } + } +} diff --git a/container-core/src/main/java/com/yahoo/container/di/componentgraph/core/package-info.java b/container-core/src/main/java/com/yahoo/container/di/componentgraph/core/package-info.java new file mode 100644 index 00000000000..e9b5b14d5d8 --- /dev/null +++ b/container-core/src/main/java/com/yahoo/container/di/componentgraph/core/package-info.java @@ -0,0 +1,5 @@ +// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. +@ExportPackage +package com.yahoo.container.di.componentgraph.core; + +import com.yahoo.osgi.annotation.ExportPackage; |