Move files under newresource package to resource package
Change-Id: Ifedb99be4671ada97fafe3ecfd196939207baa86
diff --git a/core/net/src/main/java/org/onosproject/net/resource/impl/ResourceDeviceListener.java b/core/net/src/main/java/org/onosproject/net/resource/impl/ResourceDeviceListener.java
new file mode 100644
index 0000000..1cd47aa
--- /dev/null
+++ b/core/net/src/main/java/org/onosproject/net/resource/impl/ResourceDeviceListener.java
@@ -0,0 +1,322 @@
+/*
+ * Copyright 2015-2016 Open Networking Laboratory
+ *
+ * Licensed 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.onosproject.net.resource.impl;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Lists;
+import org.onlab.packet.MplsLabel;
+import org.onlab.packet.VlanId;
+import org.onlab.util.Bandwidth;
+import org.onlab.util.ItemNotFoundException;
+import org.onosproject.mastership.MastershipService;
+import org.onosproject.net.ConnectPoint;
+import org.onosproject.net.Device;
+import org.onosproject.net.DeviceId;
+import org.onosproject.net.OchSignal;
+import org.onosproject.net.Port;
+import org.onosproject.net.PortNumber;
+import org.onosproject.net.TributarySlot;
+import org.onosproject.net.behaviour.LambdaQuery;
+import org.onosproject.net.behaviour.MplsQuery;
+import org.onosproject.net.behaviour.TributarySlotQuery;
+import org.onosproject.net.behaviour.VlanQuery;
+import org.onosproject.net.config.NetworkConfigService;
+import org.onosproject.net.device.DeviceEvent;
+import org.onosproject.net.device.DeviceListener;
+import org.onosproject.net.device.DeviceService;
+import org.onosproject.net.driver.DriverHandler;
+import org.onosproject.net.driver.DriverService;
+import org.onosproject.net.resource.DiscreteResource;
+import org.onosproject.net.resource.ResourceAdminService;
+import org.onosproject.net.resource.BandwidthCapacity;
+import org.onosproject.net.resource.Resource;
+import org.onosproject.net.resource.Resources;
+import org.onosproject.net.resource.ResourceService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.ExecutorService;
+import java.util.stream.Collectors;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+/**
+ * An implementation of DeviceListener registering devices as resources.
+ */
+final class ResourceDeviceListener implements DeviceListener {
+
+ private static final Logger log = LoggerFactory.getLogger(ResourceDeviceListener.class);
+
+ private final ResourceAdminService adminService;
+ private final ResourceService resourceService;
+ private final DeviceService deviceService;
+ private final MastershipService mastershipService;
+ private final DriverService driverService;
+ private final NetworkConfigService netcfgService;
+ private final ExecutorService executor;
+
+
+ /**
+ * Creates an instance with the specified ResourceAdminService and ExecutorService.
+ *
+ * @param adminService instance invoked to register resources
+ * @param resourceService {@link ResourceService} to be used
+ * @param deviceService {@link DeviceService} to be used
+ * @param mastershipService {@link MastershipService} to be used
+ * @param driverService {@link DriverService} to be used
+ * @param netcfgService {@link NetworkConfigService} to be used.
+ * @param executor executor used for processing resource registration
+ */
+ ResourceDeviceListener(ResourceAdminService adminService, ResourceService resourceService,
+ DeviceService deviceService, MastershipService mastershipService,
+ DriverService driverService, NetworkConfigService netcfgService,
+ ExecutorService executor) {
+ this.adminService = checkNotNull(adminService);
+ this.resourceService = checkNotNull(resourceService);
+ this.deviceService = checkNotNull(deviceService);
+ this.mastershipService = checkNotNull(mastershipService);
+ this.driverService = checkNotNull(driverService);
+ this.netcfgService = checkNotNull(netcfgService);
+ this.executor = checkNotNull(executor);
+ }
+
+ @Override
+ public void event(DeviceEvent event) {
+ Device device = event.subject();
+ // registration happens only when the caller is the master of the device
+ if (!mastershipService.isLocalMaster(device.id())) {
+ return;
+ }
+
+ switch (event.type()) {
+ case DEVICE_ADDED:
+ registerDeviceResource(device);
+ break;
+ case DEVICE_REMOVED:
+ unregisterDeviceResource(device);
+ break;
+ case DEVICE_AVAILABILITY_CHANGED:
+ if (deviceService.isAvailable(device.id())) {
+ registerDeviceResource(device);
+ // TODO: do we need to walk the ports?
+ } else {
+ unregisterDeviceResource(device);
+ }
+ break;
+ case PORT_ADDED:
+ case PORT_UPDATED:
+ if (event.port().isEnabled()) {
+ registerPortResource(device, event.port());
+ } else {
+ unregisterPortResource(device, event.port());
+ }
+ break;
+ case PORT_REMOVED:
+ unregisterPortResource(device, event.port());
+ break;
+ default:
+ break;
+ }
+ }
+
+ private void registerDeviceResource(Device device) {
+ executor.execute(() -> adminService.register(Resources.discrete(device.id()).resource()));
+ }
+
+ private void unregisterDeviceResource(Device device) {
+ executor.execute(() -> {
+ DiscreteResource devResource = Resources.discrete(device.id()).resource();
+ List<Resource> allResources = getDescendantResources(devResource);
+ adminService.unregister(Lists.transform(allResources, Resource::id));
+ });
+ }
+
+ private void registerPortResource(Device device, Port port) {
+ Resource portPath = Resources.discrete(device.id(), port.number()).resource();
+ executor.execute(() -> {
+ adminService.register(portPath);
+
+ queryBandwidth(device.id(), port.number())
+ .map(bw -> portPath.child(Bandwidth.class, bw.bps()))
+ .map(adminService::register)
+ .ifPresent(success -> {
+ if (!success) {
+ log.error("Failed to register Bandwidth for {}", portPath.id());
+ }
+ });
+
+ // for VLAN IDs
+ Set<VlanId> vlans = queryVlanIds(device.id(), port.number());
+ if (!vlans.isEmpty()) {
+ adminService.register(vlans.stream()
+ .map(portPath::child)
+ .collect(Collectors.toList()));
+ }
+
+ // for MPLS labels
+ Set<MplsLabel> mplsLabels = queryMplsLabels(device.id(), port.number());
+ if (!mplsLabels.isEmpty()) {
+ adminService.register(mplsLabels.stream()
+ .map(portPath::child)
+ .collect(Collectors.toList()));
+ }
+
+ // for Lambdas
+ Set<OchSignal> lambdas = queryLambdas(device.id(), port.number());
+ if (!lambdas.isEmpty()) {
+ adminService.register(lambdas.stream()
+ .map(portPath::child)
+ .collect(Collectors.toList()));
+ }
+
+ // for Tributary slots
+ Set<TributarySlot> tSlots = queryTributarySlots(device.id(), port.number());
+ if (!tSlots.isEmpty()) {
+ adminService.register(tSlots.stream()
+ .map(portPath::child)
+ .collect(Collectors.toList()));
+ }
+ });
+ }
+
+ private void unregisterPortResource(Device device, Port port) {
+ executor.execute(() -> {
+ DiscreteResource portResource = Resources.discrete(device.id(), port.number()).resource();
+ List<Resource> allResources = getDescendantResources(portResource);
+ adminService.unregister(Lists.transform(allResources, Resource::id));
+ });
+ }
+
+ // Returns list of all descendant resources of given resource, including itself.
+ private List<Resource> getDescendantResources(DiscreteResource parent) {
+ LinkedList<Resource> allResources = new LinkedList<>();
+ allResources.add(parent);
+
+ Set<Resource> nextResources = resourceService.getRegisteredResources(parent.id());
+ while (!nextResources.isEmpty()) {
+ Set<Resource> currentResources = nextResources;
+ // resource list should be ordered from leaf to root
+ allResources.addAll(0, currentResources);
+
+ nextResources = currentResources.stream()
+ .filter(r -> r instanceof DiscreteResource)
+ .map(r -> (DiscreteResource) r)
+ .flatMap(r -> resourceService.getRegisteredResources(r.id()).stream())
+ .collect(Collectors.toSet());
+ }
+
+ return allResources;
+ }
+
+ /**
+ * Query bandwidth capacity on a port.
+ *
+ * @param did {@link DeviceId}
+ * @param number {@link PortNumber}
+ * @return bandwidth capacity
+ */
+ private Optional<Bandwidth> queryBandwidth(DeviceId did, PortNumber number) {
+ // Check and use netcfg first.
+ ConnectPoint cp = new ConnectPoint(did, number);
+ BandwidthCapacity config = netcfgService.getConfig(cp, BandwidthCapacity.class);
+ if (config != null) {
+ log.trace("Registering configured bandwidth {} for {}/{}", config.capacity(), did, number);
+ return Optional.of(config.capacity());
+ }
+
+ // populate bandwidth value, assuming portSpeed == bandwidth
+ Port port = deviceService.getPort(did, number);
+ if (port != null) {
+ return Optional.of(Bandwidth.mbps(port.portSpeed()));
+ }
+ return Optional.empty();
+ }
+
+ private Set<OchSignal> queryLambdas(DeviceId did, PortNumber port) {
+ try {
+ DriverHandler handler = driverService.createHandler(did);
+ if (handler == null || !handler.hasBehaviour(LambdaQuery.class)) {
+ return Collections.emptySet();
+ }
+ LambdaQuery query = handler.behaviour(LambdaQuery.class);
+ if (query != null) {
+ return query.queryLambdas(port).stream()
+ .flatMap(x -> OchSignal.toFlexGrid(x).stream())
+ .collect(Collectors.toSet());
+ } else {
+ return Collections.emptySet();
+ }
+ } catch (ItemNotFoundException e) {
+ return Collections.emptySet();
+ }
+ }
+
+ private Set<VlanId> queryVlanIds(DeviceId device, PortNumber port) {
+ try {
+ DriverHandler handler = driverService.createHandler(device);
+ if (handler == null || !handler.hasBehaviour(VlanQuery.class)) {
+ return ImmutableSet.of();
+ }
+
+ VlanQuery query = handler.behaviour(VlanQuery.class);
+ if (query == null) {
+ return ImmutableSet.of();
+ }
+ return query.queryVlanIds(port);
+ } catch (ItemNotFoundException e) {
+ return ImmutableSet.of();
+ }
+ }
+
+ private Set<MplsLabel> queryMplsLabels(DeviceId device, PortNumber port) {
+ try {
+ DriverHandler handler = driverService.createHandler(device);
+ if (handler == null || !handler.hasBehaviour(MplsQuery.class)) {
+ return ImmutableSet.of();
+ }
+
+ MplsQuery query = handler.behaviour(MplsQuery.class);
+ if (query == null) {
+ return ImmutableSet.of();
+ }
+ return query.queryMplsLabels(port);
+ } catch (ItemNotFoundException e) {
+ return ImmutableSet.of();
+ }
+ }
+
+ private Set<TributarySlot> queryTributarySlots(DeviceId device, PortNumber port) {
+ try {
+ DriverHandler handler = driverService.createHandler(device);
+ if (handler == null || !handler.hasBehaviour(TributarySlotQuery.class)) {
+ return Collections.emptySet();
+ }
+ TributarySlotQuery query = handler.behaviour(TributarySlotQuery.class);
+ if (query != null) {
+ return query.queryTributarySlots(port);
+ } else {
+ return Collections.emptySet();
+ }
+ } catch (ItemNotFoundException e) {
+ return Collections.emptySet();
+ }
+ }
+}
diff --git a/core/net/src/main/java/org/onosproject/net/resource/impl/ResourceManager.java b/core/net/src/main/java/org/onosproject/net/resource/impl/ResourceManager.java
new file mode 100644
index 0000000..04499bb
--- /dev/null
+++ b/core/net/src/main/java/org/onosproject/net/resource/impl/ResourceManager.java
@@ -0,0 +1,222 @@
+/*
+ * Copyright 2015-2016 Open Networking Laboratory
+ *
+ * Licensed 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.onosproject.net.resource.impl;
+
+import com.google.common.annotations.Beta;
+import com.google.common.collect.ImmutableList;
+import org.apache.felix.scr.annotations.Activate;
+import org.apache.felix.scr.annotations.Component;
+import org.apache.felix.scr.annotations.Deactivate;
+import org.apache.felix.scr.annotations.Reference;
+import org.apache.felix.scr.annotations.ReferenceCardinality;
+import org.apache.felix.scr.annotations.Service;
+import org.onlab.util.GuavaCollectors;
+import org.onlab.util.Tools;
+import org.onosproject.event.AbstractListenerManager;
+import org.onosproject.net.resource.DiscreteResourceId;
+import org.onosproject.net.resource.ResourceAdminService;
+import org.onosproject.net.resource.ResourceAllocation;
+import org.onosproject.net.resource.ResourceConsumer;
+import org.onosproject.net.resource.ResourceEvent;
+import org.onosproject.net.resource.ResourceId;
+import org.onosproject.net.resource.ResourceListener;
+import org.onosproject.net.resource.ResourceService;
+import org.onosproject.net.resource.Resource;
+import org.onosproject.net.resource.ResourceStore;
+import org.onosproject.net.resource.ResourceStoreDelegate;
+import org.slf4j.Logger;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static org.onosproject.security.AppGuard.checkPermission;
+import static org.onosproject.security.AppPermission.Type.RESOURCE_WRITE;
+import static org.onosproject.security.AppPermission.Type.RESOURCE_READ;
+import static org.slf4j.LoggerFactory.getLogger;
+
+/**
+ * An implementation of ResourceService.
+ */
+@Component(immediate = true)
+@Service
+@Beta
+public final class ResourceManager extends AbstractListenerManager<ResourceEvent, ResourceListener>
+ implements ResourceService, ResourceAdminService {
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected ResourceStore store;
+
+ private final Logger log = getLogger(getClass());
+
+ private final ResourceStoreDelegate delegate = new InternalStoreDelegate();
+
+ @Activate
+ public void activate() {
+ store.setDelegate(delegate);
+ eventDispatcher.addSink(ResourceEvent.class, listenerRegistry);
+
+ log.info("Started");
+ }
+
+ @Deactivate
+ public void deactivate() {
+ store.unsetDelegate(delegate);
+ eventDispatcher.removeSink(ResourceEvent.class);
+
+ log.info("Stopped");
+ }
+
+ @Override
+ public List<ResourceAllocation> allocate(ResourceConsumer consumer,
+ List<Resource> resources) {
+ checkPermission(RESOURCE_WRITE);
+ checkNotNull(consumer);
+ checkNotNull(resources);
+
+ boolean success = store.allocate(resources, consumer);
+ if (!success) {
+ return ImmutableList.of();
+ }
+
+ return resources.stream()
+ .map(x -> new ResourceAllocation(x, consumer))
+ .collect(Collectors.toList());
+ }
+
+ @Override
+ public boolean release(List<ResourceAllocation> allocations) {
+ checkPermission(RESOURCE_WRITE);
+ checkNotNull(allocations);
+
+ return store.release(allocations);
+ }
+
+ @Override
+ public boolean release(ResourceConsumer consumer) {
+ checkNotNull(consumer);
+
+ Collection<ResourceAllocation> allocations = getResourceAllocations(consumer);
+ return release(ImmutableList.copyOf(allocations));
+ }
+
+ @Override
+ public List<ResourceAllocation> getResourceAllocations(ResourceId id) {
+ checkPermission(RESOURCE_READ);
+ checkNotNull(id);
+
+ return store.getResourceAllocations(id);
+ }
+
+ @Override
+ public <T> Collection<ResourceAllocation> getResourceAllocations(DiscreteResourceId parent, Class<T> cls) {
+ checkPermission(RESOURCE_READ);
+ checkNotNull(parent);
+ checkNotNull(cls);
+
+ // We access store twice in this method, then the store may be updated by others
+ Collection<Resource> resources = store.getAllocatedResources(parent, cls);
+ return resources.stream()
+ .flatMap(resource -> store.getResourceAllocations(resource.id()).stream())
+ .collect(GuavaCollectors.toImmutableList());
+ }
+
+ @Override
+ public Collection<ResourceAllocation> getResourceAllocations(ResourceConsumer consumer) {
+ checkPermission(RESOURCE_READ);
+ checkNotNull(consumer);
+
+ Collection<Resource> resources = store.getResources(consumer);
+ return resources.stream()
+ .map(x -> new ResourceAllocation(x, consumer))
+ .collect(Collectors.toList());
+ }
+
+ @Override
+ public Set<Resource> getAvailableResources(DiscreteResourceId parent) {
+ checkPermission(RESOURCE_READ);
+ checkNotNull(parent);
+
+ Set<Resource> children = store.getChildResources(parent);
+ return children.stream()
+ // We access store twice in this method, then the store may be updated by others
+ .filter(store::isAvailable)
+ .collect(Collectors.toSet());
+ }
+
+ @Override
+ public <T> Set<Resource> getAvailableResources(DiscreteResourceId parent, Class<T> cls) {
+ checkPermission(RESOURCE_READ);
+ checkNotNull(parent);
+ checkNotNull(cls);
+
+ // naive implementation
+ return getAvailableResources(parent).stream()
+ .filter(resource -> resource.isTypeOf(cls))
+ .collect(Collectors.toSet());
+ }
+
+ @Override
+ public <T> Set<T> getAvailableResourceValues(DiscreteResourceId parent, Class<T> cls) {
+ checkPermission(RESOURCE_READ);
+ checkNotNull(parent);
+ checkNotNull(cls);
+
+ // naive implementation
+ return getAvailableResources(parent).stream()
+ .flatMap(resource -> Tools.stream(resource.valueAs(cls)))
+ .collect(Collectors.toSet());
+ }
+
+ @Override
+ public Set<Resource> getRegisteredResources(DiscreteResourceId parent) {
+ checkPermission(RESOURCE_READ);
+ checkNotNull(parent);
+
+ return store.getChildResources(parent);
+ }
+
+ @Override
+ public boolean isAvailable(Resource resource) {
+ checkPermission(RESOURCE_READ);
+ checkNotNull(resource);
+
+ return store.isAvailable(resource);
+ }
+
+ @Override
+ public boolean register(List<Resource> resources) {
+ checkNotNull(resources);
+
+ return store.register(resources);
+ }
+
+ @Override
+ public boolean unregister(List<ResourceId> ids) {
+ checkNotNull(ids);
+
+ return store.unregister(ids);
+ }
+
+ private class InternalStoreDelegate implements ResourceStoreDelegate {
+ @Override
+ public void notify(ResourceEvent event) {
+ post(event);
+ }
+ }
+}
diff --git a/core/net/src/main/java/org/onosproject/net/resource/impl/ResourceNetworkConfigListener.java b/core/net/src/main/java/org/onosproject/net/resource/impl/ResourceNetworkConfigListener.java
new file mode 100644
index 0000000..12acc19
--- /dev/null
+++ b/core/net/src/main/java/org/onosproject/net/resource/impl/ResourceNetworkConfigListener.java
@@ -0,0 +1,177 @@
+/*
+ * Copyright 2016 Open Networking Laboratory
+ *
+ * Licensed 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.onosproject.net.resource.impl;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static org.slf4j.LoggerFactory.getLogger;
+
+import java.util.Set;
+import java.util.concurrent.ExecutorService;
+
+import org.onlab.util.Bandwidth;
+import org.onosproject.mastership.MastershipService;
+import org.onosproject.net.ConnectPoint;
+import org.onosproject.net.config.NetworkConfigEvent;
+import org.onosproject.net.config.NetworkConfigListener;
+import org.onosproject.net.config.NetworkConfigService;
+import org.onosproject.net.resource.BandwidthCapacity;
+import org.onosproject.net.resource.ResourceAdminService;
+import org.onosproject.net.resource.Resources;
+import org.slf4j.Logger;
+
+import com.google.common.annotations.Beta;
+import com.google.common.collect.ImmutableSet;
+
+// TODO Consider merging this with ResourceDeviceListener.
+/**
+ * Handler for NetworkConfiguration changes.
+ */
+@Beta
+final class ResourceNetworkConfigListener implements NetworkConfigListener {
+
+ /**
+ * Config classes relevant to this listener.
+ */
+ private static final Set<Class<?>> CONFIG_CLASSES = ImmutableSet.of(BandwidthCapacity.class);
+
+ private final Logger log = getLogger(getClass());
+
+ private final ResourceAdminService adminService;
+ private final NetworkConfigService cfgService;
+ private final MastershipService mastershipService;
+ private final ExecutorService executor;
+
+ /**
+ * Creates an instance of listener.
+ *
+ * @param adminService {@link ResourceAdminService}
+ * @param cfgService {@link NetworkConfigService}
+ * @param mastershipService {@link MastershipService}
+ * @param executor Executor to use.
+ */
+ ResourceNetworkConfigListener(ResourceAdminService adminService, NetworkConfigService cfgService,
+ MastershipService mastershipService, ExecutorService executor) {
+ this.adminService = checkNotNull(adminService);
+ this.cfgService = checkNotNull(cfgService);
+ this.mastershipService = checkNotNull(mastershipService);
+ this.executor = checkNotNull(executor);
+ }
+
+ @Override
+ public boolean isRelevant(NetworkConfigEvent event) {
+ switch (event.type()) {
+ case CONFIG_ADDED:
+ case CONFIG_REMOVED:
+ case CONFIG_UPDATED:
+ return CONFIG_CLASSES.contains(event.configClass());
+
+ case CONFIG_REGISTERED:
+ case CONFIG_UNREGISTERED:
+ default:
+ return false;
+ }
+ }
+
+ @Override
+ public void event(NetworkConfigEvent event) {
+ if (event.configClass() == BandwidthCapacity.class) {
+ executor.execute(() -> {
+ try {
+ handleBandwidthCapacity(event);
+ } catch (Exception e) {
+ log.error("Exception handling BandwidthCapacity", e);
+ }
+ });
+ }
+ }
+
+ private void handleBandwidthCapacity(NetworkConfigEvent event) {
+ checkArgument(event.configClass() == BandwidthCapacity.class);
+
+ ConnectPoint cp = (ConnectPoint) event.subject();
+ if (!mastershipService.isLocalMaster(cp.deviceId())) {
+ return;
+ }
+
+ BandwidthCapacity bwCapacity = cfgService.getConfig(cp, BandwidthCapacity.class);
+
+ switch (event.type()) {
+ case CONFIG_ADDED:
+ if (!adminService.register(Resources.continuous(cp.deviceId(),
+ cp.port(), Bandwidth.class)
+ .resource(bwCapacity.capacity().bps()))) {
+ log.info("Failed to register Bandwidth for {}, attempting update", cp);
+
+ // Bandwidth based on port speed, was probably already registered.
+ // need to update to the valued based on configuration
+
+ if (!updateRegistration(cp, bwCapacity)) {
+ log.warn("Failed to update Bandwidth for {}", cp);
+ }
+ }
+ break;
+
+ case CONFIG_UPDATED:
+ if (!updateRegistration(cp, bwCapacity)) {
+ log.warn("Failed to update Bandwidth for {}", cp);
+ }
+ break;
+
+ case CONFIG_REMOVED:
+ // FIXME Following should be an update to the value based on port speed
+ if (!adminService.unregister(Resources.continuous(cp.deviceId(),
+ cp.port(),
+ Bandwidth.class).id())) {
+ log.warn("Failed to unregister Bandwidth for {}", cp);
+ }
+ break;
+
+ case CONFIG_REGISTERED:
+ case CONFIG_UNREGISTERED:
+ // no-op
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ private boolean updateRegistration(ConnectPoint cp, BandwidthCapacity bwCapacity) {
+ // FIXME workaround until replace/update semantics become available
+ // this potentially blows up existing registration
+ // or end up as no-op
+ //
+ // Current code end up in situation like below:
+ // PortNumber: 2
+ // MplsLabel: [[16‥240)]
+ // VlanId: [[0‥4095)]
+ // Bandwidth: 2000000.000000
+ // Bandwidth: 20000000.000000
+ //
+ // but both unregisterResources(..) and registerResources(..)
+ // returns true (success)
+
+ if (!adminService.unregister(
+ Resources.continuous(cp.deviceId(), cp.port(), Bandwidth.class).id())) {
+ log.warn("unregisterResources for {} failed", cp);
+ }
+ return adminService.register(Resources.continuous(cp.deviceId(),
+ cp.port(),
+ Bandwidth.class).resource(bwCapacity.capacity().bps()));
+ }
+
+}
diff --git a/core/net/src/main/java/org/onosproject/net/resource/impl/ResourceRegistrar.java b/core/net/src/main/java/org/onosproject/net/resource/impl/ResourceRegistrar.java
new file mode 100644
index 0000000..a13c5e7
--- /dev/null
+++ b/core/net/src/main/java/org/onosproject/net/resource/impl/ResourceRegistrar.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright 2015-2016 Open Networking Laboratory
+ *
+ * Licensed 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.onosproject.net.resource.impl;
+
+import com.google.common.annotations.Beta;
+import com.google.common.collect.ImmutableList;
+
+import org.apache.felix.scr.annotations.Activate;
+import org.apache.felix.scr.annotations.Component;
+import org.apache.felix.scr.annotations.Deactivate;
+import org.apache.felix.scr.annotations.Reference;
+import org.apache.felix.scr.annotations.ReferenceCardinality;
+import org.onosproject.mastership.MastershipService;
+import org.onosproject.net.ConnectPoint;
+import org.onosproject.net.config.ConfigFactory;
+import org.onosproject.net.config.NetworkConfigListener;
+import org.onosproject.net.config.NetworkConfigRegistry;
+import org.onosproject.net.device.DeviceListener;
+import org.onosproject.net.device.DeviceService;
+import org.onosproject.net.driver.DriverService;
+import org.onosproject.net.resource.BandwidthCapacity;
+import org.onosproject.net.resource.ResourceAdminService;
+import org.onosproject.net.resource.ResourceService;
+import org.slf4j.Logger;
+
+import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+import static org.onlab.util.Tools.groupedThreads;
+import static org.onosproject.net.config.basics.SubjectFactories.CONNECT_POINT_SUBJECT_FACTORY;
+import static org.slf4j.LoggerFactory.getLogger;
+
+/**
+ * A class registering resources when they are detected.
+ */
+@Component(immediate = true)
+@Beta
+public final class ResourceRegistrar {
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected ResourceAdminService adminService;
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected ResourceService resourceService;
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected DriverService driverService;
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected DeviceService deviceService;
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected MastershipService mastershipService;
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected NetworkConfigRegistry cfgRegistry;
+
+ private final Logger log = getLogger(getClass());
+
+ private final List<ConfigFactory<?, ?>> factories = ImmutableList.of(
+ new ConfigFactory<ConnectPoint, BandwidthCapacity>(CONNECT_POINT_SUBJECT_FACTORY,
+ BandwidthCapacity.class, BandwidthCapacity.CONFIG_KEY) {
+ @Override
+ public BandwidthCapacity createConfig() {
+ return new BandwidthCapacity();
+ }
+ });
+
+
+ private DeviceListener deviceListener;
+
+ private final ExecutorService executor =
+ Executors.newSingleThreadExecutor(groupedThreads("onos/resource", "registrar", log));
+
+ private NetworkConfigListener cfgListener;
+
+ @Activate
+ public void activate() {
+ factories.forEach(cfgRegistry::registerConfigFactory);
+
+ cfgListener = new ResourceNetworkConfigListener(adminService, cfgRegistry, mastershipService, executor);
+ cfgRegistry.addListener(cfgListener);
+
+ deviceListener = new ResourceDeviceListener(adminService, resourceService,
+ deviceService, mastershipService, driverService, cfgRegistry, executor);
+ deviceService.addListener(deviceListener);
+
+ // TODO Attempt initial registration of existing resources?
+
+ log.info("Started");
+ }
+
+ @Deactivate
+ public void deactivate() {
+ deviceService.removeListener(deviceListener);
+ cfgRegistry.removeListener(cfgListener);
+
+ executor.shutdownNow();
+
+ factories.forEach(cfgRegistry::unregisterConfigFactory);
+
+ log.info("Stopped");
+ }
+}
diff --git a/core/net/src/main/java/org/onosproject/net/resource/impl/package-info.java b/core/net/src/main/java/org/onosproject/net/resource/impl/package-info.java
index fd0bbde..1537829 100644
--- a/core/net/src/main/java/org/onosproject/net/resource/impl/package-info.java
+++ b/core/net/src/main/java/org/onosproject/net/resource/impl/package-info.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2014 Open Networking Laboratory
+ * Copyright 2015-2016 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -15,6 +15,6 @@
*/
/**
- * Services for reserving network resources, e.g. bandwidth, lambdas.
+ * Implementation of the generic network resource subsystem.
*/
package org.onosproject.net.resource.impl;