Resource API changes as preparation for hierarchy support (ONOS-2446)
The changes:
- Introduce ResourcePath to point a resource
- Remove Resource interface
- Make ResourceAllocation concrete class and remove DefaultResourceAllocation
- Remove DefaultResource
- Changes in interfaces due to the above changes
Change-Id: I0f3f846be67b0f7917117943aac31e3099c851ec
diff --git a/core/net/src/main/java/org/onosproject/net/newresource/impl/ResourceManager.java b/core/net/src/main/java/org/onosproject/net/newresource/impl/ResourceManager.java
index 785613c..7ff6514 100644
--- a/core/net/src/main/java/org/onosproject/net/newresource/impl/ResourceManager.java
+++ b/core/net/src/main/java/org/onosproject/net/newresource/impl/ResourceManager.java
@@ -21,13 +21,11 @@
import org.apache.felix.scr.annotations.Reference;
import org.apache.felix.scr.annotations.ReferenceCardinality;
import org.apache.felix.scr.annotations.Service;
-import org.onosproject.net.newresource.DefaultResource;
-import org.onosproject.net.newresource.DefaultResourceAllocation;
-import org.onosproject.net.newresource.Resource;
import org.onosproject.net.newresource.ResourceAdminService;
import org.onosproject.net.newresource.ResourceAllocation;
import org.onosproject.net.newresource.ResourceConsumer;
import org.onosproject.net.newresource.ResourceService;
+import org.onosproject.net.newresource.ResourcePath;
import org.onosproject.net.newresource.ResourceStore;
import java.util.ArrayList;
@@ -55,31 +53,29 @@
@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
protected ResourceStore store;
- @SuppressWarnings("unchecked")
@Override
- public <S, T> Optional<ResourceAllocation<S, T>> allocate(ResourceConsumer consumer, Resource<S, T> resource) {
+ public Optional<ResourceAllocation> allocate(ResourceConsumer consumer, ResourcePath resource) {
checkNotNull(consumer);
checkNotNull(resource);
- List<ResourceAllocation<?, ?>> allocations = allocate(consumer, ImmutableList.of(resource));
+ List<ResourceAllocation> allocations = allocate(consumer, ImmutableList.of(resource));
if (allocations.isEmpty()) {
return Optional.empty();
}
assert allocations.size() == 1;
- ResourceAllocation<?, ?> allocation = allocations.get(0);
+ ResourceAllocation allocation = allocations.get(0);
- assert allocation.subject().getClass() == resource.subject().getClass();
- assert allocation.resource().getClass() == resource.resource().getClass();
+ assert allocation.resource().equals(resource);
// cast is ensured by the assertions above
- return Optional.of((ResourceAllocation<S, T>) allocation);
+ return Optional.of(allocation);
}
@Override
- public List<ResourceAllocation<?, ?>> allocate(ResourceConsumer consumer,
- List<? extends Resource<?, ?>> resources) {
+ public List<ResourceAllocation> allocate(ResourceConsumer consumer,
+ List<ResourcePath> resources) {
checkNotNull(consumer);
checkNotNull(resources);
@@ -96,12 +92,12 @@
}
return resources.stream()
- .map(x -> new DefaultResourceAllocation<>(x.subject(), x.resource(), consumer))
+ .map(x -> new ResourceAllocation(x, consumer))
.collect(Collectors.toList());
}
@Override
- public List<ResourceAllocation<?, ?>> allocate(ResourceConsumer consumer, Resource<?, ?>... resources) {
+ public List<ResourceAllocation> allocate(ResourceConsumer consumer, ResourcePath... resources) {
checkNotNull(consumer);
checkNotNull(resources);
@@ -109,18 +105,18 @@
}
@Override
- public <S, T> boolean release(ResourceAllocation<S, T> allocation) {
+ public boolean release(ResourceAllocation allocation) {
checkNotNull(allocation);
return release(ImmutableList.of(allocation));
}
@Override
- public boolean release(List<? extends ResourceAllocation<?, ?>> allocations) {
+ public boolean release(List<ResourceAllocation> allocations) {
checkNotNull(allocations);
- List<DefaultResource<?, ?>> resources = allocations.stream()
- .map(x -> new DefaultResource<>(x.subject(), x.resource()))
+ List<ResourcePath> resources = allocations.stream()
+ .map(ResourceAllocation::resource)
.collect(Collectors.toList());
List<ResourceConsumer> consumers = allocations.stream()
.map(ResourceAllocation::consumer)
@@ -130,7 +126,7 @@
}
@Override
- public boolean release(ResourceAllocation<?, ?>... allocations) {
+ public boolean release(ResourceAllocation... allocations) {
checkNotNull(allocations);
return release(ImmutableList.copyOf(allocations));
@@ -140,23 +136,22 @@
public boolean release(ResourceConsumer consumer) {
checkNotNull(consumer);
- Collection<ResourceAllocation<?, ?>> allocations = getResourceAllocations(consumer);
+ Collection<ResourceAllocation> allocations = getResourceAllocations(consumer);
return release(ImmutableList.copyOf(allocations));
}
@Override
- public <S, T> Collection<ResourceAllocation<S, T>> getResourceAllocations(S subject, Class<T> cls) {
- checkNotNull(subject);
+ public <T> Collection<ResourceAllocation> getResourceAllocations(ResourcePath parent, Class<T> cls) {
+ checkNotNull(parent);
checkNotNull(cls);
- Collection<Resource<S, T>> resources = store.getAllocatedResources(subject, cls);
- List<ResourceAllocation<S, T>> allocations = new ArrayList<>(resources.size());
- for (Resource<S, T> resource: resources) {
+ Collection<ResourcePath> resources = store.getAllocatedResources(parent, cls);
+ List<ResourceAllocation> allocations = new ArrayList<>(resources.size());
+ for (ResourcePath resource: resources) {
// We access store twice in this method, then the store may be updated by others
Optional<ResourceConsumer> consumer = store.getConsumer(resource);
if (consumer.isPresent()) {
- allocations.add(
- new DefaultResourceAllocation<>(resource.subject(), resource.resource(), consumer.get()));
+ allocations.add(new ResourceAllocation(resource, consumer.get()));
}
}
@@ -164,17 +159,17 @@
}
@Override
- public Collection<ResourceAllocation<?, ?>> getResourceAllocations(ResourceConsumer consumer) {
+ public Collection<ResourceAllocation> getResourceAllocations(ResourceConsumer consumer) {
checkNotNull(consumer);
- Collection<Resource<?, ?>> resources = store.getResources(consumer);
+ Collection<ResourcePath> resources = store.getResources(consumer);
return resources.stream()
- .map(x -> new DefaultResourceAllocation<>(x.subject(), x.resource(), consumer))
+ .map(x -> new ResourceAllocation(x, consumer))
.collect(Collectors.toList());
}
@Override
- public <S, T> boolean isAvailable(Resource<S, T> resource) {
+ public boolean isAvailable(ResourcePath resource) {
checkNotNull(resource);
Optional<ResourceConsumer> consumer = store.getConsumer(resource);
@@ -204,16 +199,16 @@
* E.g. VLAN ID against a link must be within 12 bit address space.
*
* @param resource resource to be checked if it is within the resource range
- * @param <S> type of the subject
- * @param <T> type of the resource
* @return true if the resource within the range, false otherwise
*/
- <S, T> boolean isValid(Resource<S, T> resource) {
- Predicate<T> predicate = lookupPredicate(resource.resource());
+ boolean isValid(ResourcePath resource) {
+ List<Object> flatten = resource.components();
+ Object bottom = flatten.get(flatten.size() - 1);
+ Predicate<Object> predicate = lookupPredicate(bottom);
if (predicate == null) {
return true;
}
- return predicate.test(resource.resource());
+ return predicate.test(bottom);
}
}