Java LabelResourcePool类代码示例

import org.onosproject.incubator.net.resource.label.LabelResourcePool; //导入依赖的package包/类
private boolean create(LabelResourcePool pool) {
    Device device = deviceService.getDevice(pool.deviceId());
    if (device == null) {
        return false;
    }

    NodeId master = mastershipService.getMasterFor(pool.deviceId());

    if (master == null) {
        log.warn("Failed to create label resource pool: No master for {}", pool);
        return false;
    }

    if (master.equals(clusterService.getLocalNode().id())) {
        return internalCreate(pool);
    }

    log.trace("Forwarding getFlowEntries to {}, which is the primary (master) for device {}",
              master, pool.deviceId());

    return complete(clusterCommunicator
            .sendAndReceive(pool,
                            LabelResourceMessageSubjects.LABEL_POOL_CREATED,
                            SERIALIZER::encode, SERIALIZER::decode,
                            master));
}
 

import org.onosproject.incubator.net.resource.label.LabelResourcePool; //导入依赖的package包/类
@Override
public boolean createDevicePool(DeviceId deviceId, LabelResourceId beginLabel, LabelResourceId endLabel) {
    LabelResourcePool labelResource = new LabelResourcePool(deviceId.toString(),
            beginLabel.labelId(),
            endLabel.labelId());
    if (resourcePool.containsValue(labelResource)) {
        return false;
    }

    resourcePool.put(deviceId, labelResource);
    return true;
}
 

import org.onosproject.incubator.net.resource.label.LabelResourcePool; //导入依赖的package包/类
@Override
public boolean destroyDevicePool(DeviceId deviceId) {
    LabelResourcePool devicePool = resourcePool.get(deviceId);

    if (devicePool == null) {
        return false;
    }

    resourcePool.remove(deviceId);
    return true;
}
 

import org.onosproject.incubator.net.resource.label.LabelResourcePool; //导入依赖的package包/类
@Override
public boolean createDevicePool(DeviceId deviceId,
                                LabelResourceId beginLabel,
                                LabelResourceId endLabel) {
    LabelResourcePool pool = new LabelResourcePool(deviceId.toString(),
                                                   beginLabel.labelId(),
                                                   endLabel.labelId());
    return this.create(pool);
}
 

import org.onosproject.incubator.net.resource.label.LabelResourcePool; //导入依赖的package包/类
@Override
public boolean createGlobalPool(LabelResourceId beginLabel,
                                LabelResourceId endLabel) {
    LabelResourcePool pool = new LabelResourcePool(GLOBAL_RESOURCE_POOL_DEVICE_ID,
                                                   beginLabel.labelId(),
                                                   endLabel.labelId());
    return this.internalCreate(pool);
}
 

import org.onosproject.incubator.net.resource.label.LabelResourcePool; //导入依赖的package包/类
private boolean internalCreate(LabelResourcePool pool) {
    Versioned<LabelResourcePool> poolOld = resourcePool
            .get(pool.deviceId());
    if (poolOld == null) {
        resourcePool.put(pool.deviceId(), pool);
        LabelResourceEvent event = new LabelResourceEvent(Type.POOL_CREATED,
                                                          pool);
        notifyDelegate(event);
        return true;
    }
    return false;
}
 

import org.onosproject.incubator.net.resource.label.LabelResourcePool; //导入依赖的package包/类
private boolean internalDestroy(DeviceId deviceId) {
    Versioned<LabelResourcePool> poolOld = resourcePool.get(deviceId);
    if (poolOld != null) {
        resourcePool.remove(deviceId);
        LabelResourceEvent event = new LabelResourceEvent(Type.POOL_DESTROYED,
                                                          poolOld.value());
        notifyDelegate(event);
    }
    log.info("success to destroy the label resource pool of device id {}",
             deviceId);
    return true;
}
 

import org.onosproject.incubator.net.resource.label.LabelResourcePool; //导入依赖的package包/类
@Override
public boolean isDevicePoolFull(DeviceId deviceId) {
    Versioned<LabelResourcePool> pool = resourcePool.get(deviceId);
    if (pool == null) {
        return true;
    }
    return pool.value().currentUsedMaxLabelId() == pool.value().endLabel()
            && pool.value().releaseLabelId().size() == 0 ? true : false;
}
 

import org.onosproject.incubator.net.resource.label.LabelResourcePool; //导入依赖的package包/类
@Override
public long getFreeNumOfDevicePool(DeviceId deviceId) {
    Versioned<LabelResourcePool> pool = resourcePool.get(deviceId);
    if (pool == null) {
        return 0;
    }
    return pool.value().endLabel().labelId()
            - pool.value().currentUsedMaxLabelId().labelId()
            + pool.value().releaseLabelId().size();
}
 

import org.onosproject.incubator.net.resource.label.LabelResourcePool; //导入依赖的package包/类
@Override
protected void execute() {
    LabelResourceService lrs = get(LabelResourceService.class);
    LabelResourcePool pool = lrs.getDeviceLabelResourcePool(DeviceId
            .deviceId(deviceId));
    if (pool != null) {
        print(FMT, pool.deviceId().toString(), pool.beginLabel(),
              pool.endLabel(), pool.totalNum(), pool.usedNum(),
              pool.currentUsedMaxLabelId(), pool.releaseLabelId()
                      .toString());
    } else {
        print(FMT, deviceId, null, null, null, null, null, null);
    }
}
 

import org.onosproject.incubator.net.resource.label.LabelResourcePool; //导入依赖的package包/类
@Override
protected void execute() {
    LabelResourceService lrs = get(LabelResourceService.class);
    LabelResourcePool pool = lrs.getGlobalLabelResourcePool();
    if (pool != null) {
        print(FMT, pool.deviceId().toString(), pool.beginLabel(),
              pool.endLabel(), pool.totalNum(), pool.usedNum(),
              pool.currentUsedMaxLabelId(), pool.releaseLabelId()
                      .toString());
    }
}
 

import org.onosproject.incubator.net.resource.label.LabelResourcePool; //导入依赖的package包/类
@Override
public LabelResourcePool getDeviceLabelResourcePool(DeviceId deviceId) {
    checkNotNull(deviceId, "deviceId is not null");
    return store.getDeviceLabelResourcePool(deviceId);
}
 

import org.onosproject.incubator.net.resource.label.LabelResourcePool; //导入依赖的package包/类
@Override
public LabelResourcePool getGlobalLabelResourcePool() {
    return store.getGlobalLabelResourcePool();
}
 

import org.onosproject.incubator.net.resource.label.LabelResourcePool; //导入依赖的package包/类
@Activate
public void activate() {

    resourcePool = storageService
            .<DeviceId, LabelResourcePool>consistentMapBuilder()
            .withName(POOL_MAP_NAME).withSerializer(SERIALIZER)
            .withPartitionsDisabled().build();
    messageHandlingExecutor = Executors
            .newFixedThreadPool(MESSAGE_HANDLER_THREAD_POOL_SIZE,
                                groupedThreads("onos/store/flow",
                                               "message-handlers"));
    clusterCommunicator
            .addSubscriber(LabelResourceMessageSubjects.LABEL_POOL_CREATED,
                    SERIALIZER::<LabelResourcePool>decode,
                    operation -> {
                        log.trace("received get flow entry request for {}", operation);
                        return internalCreate(operation);
                    },
                    SERIALIZER::<Boolean>encode,
                    messageHandlingExecutor);
    clusterCommunicator
            .addSubscriber(LabelResourceMessageSubjects.LABEL_POOL_DESTROYED,
                    SERIALIZER::<DeviceId>decode,
                    deviceId -> {
                        log.trace("received get flow entry request for {}", deviceId);
                        return internalDestroy(deviceId);
                    },
                    SERIALIZER::<Boolean>encode,
                    messageHandlingExecutor);
    clusterCommunicator
            .addSubscriber(LabelResourceMessageSubjects.LABEL_POOL_APPLY,
                    SERIALIZER::<LabelResourceRequest>decode,
                    request -> {
                        log.trace("received get flow entry request for {}", request);
                        return internalApply(request);

                    },
                    SERIALIZER::<Collection<LabelResource>>encode,
                    messageHandlingExecutor);
    clusterCommunicator
            .addSubscriber(LabelResourceMessageSubjects.LABEL_POOL_RELEASE,
                    SERIALIZER::<LabelResourceRequest>decode,
                    request -> {
                        log.trace("received get flow entry request for {}",
                                request);
                        return internalRelease(request);
                    },
                    SERIALIZER::<Boolean>encode,
                    messageHandlingExecutor);
    log.info("Started");
}
 

import org.onosproject.incubator.net.resource.label.LabelResourcePool; //导入依赖的package包/类
private boolean internalRelease(LabelResourceRequest request) {
    DeviceId deviceId = request.deviceId();
    Collection<LabelResource> release = request.releaseCollection();
    Versioned<LabelResourcePool> poolOld = resourcePool.get(deviceId);
    if (poolOld == null) {
        log.info("the label resource pool of device id {} not allocated");
        return false;
    }
    LabelResourcePool pool = poolOld.value();
    if (pool == null) {
        log.info("the label resource pool of device id {} does not exist");
        return false;
    }
    Set<LabelResource> storeSet = new HashSet<>(pool.releaseLabelId());
    LabelResource labelResource = null;
    long realReleasedNum = 0;
    for (Iterator<LabelResource> it = release.iterator(); it.hasNext();) {
        labelResource = it.next();
        if (labelResource.labelResourceId().labelId() < pool.beginLabel()
                .labelId()
                || labelResource.labelResourceId().labelId() > pool
                        .endLabel().labelId()) {
            continue;
        }
        if (pool.currentUsedMaxLabelId().labelId() > labelResource
                .labelResourceId().labelId()
                || !storeSet.contains(labelResource)) {
            storeSet.add(labelResource);
            realReleasedNum++;
        }
    }
    long beginNum = pool.beginLabel().labelId();
    long endNum = pool.endLabel().labelId();
    long totalNum = pool.totalNum();
    long usedNum = pool.usedNum() - realReleasedNum;
    long current = pool.currentUsedMaxLabelId().labelId();
    ImmutableSet<LabelResource> s = ImmutableSet.copyOf(storeSet);
    LabelResourcePool newPool = new LabelResourcePool(deviceId.toString(),
                                                      beginNum, endNum,
                                                      totalNum, usedNum,
                                                      current, s);
    resourcePool.put(deviceId, newPool);
    log.info("success to release label resource");
    return true;
}