Java BasicDeviceConfig类代码示例

import org.onosproject.net.config.basics.BasicDeviceConfig; //导入依赖的package包/类
@Override
public void process(long sid, ObjectNode payload) {
    DeviceId deviceId = deviceId(string(payload, ID, ZERO_URI));
    String name = emptyToNull(string(payload, NAME, null));
    log.debug("Name change request: {} -- '{}'", deviceId, name);

    NetworkConfigService service = get(NetworkConfigService.class);
    BasicDeviceConfig cfg =
            service.addConfig(deviceId, BasicDeviceConfig.class);

    // Name attribute missing from the payload (or empty string)
    // means that the friendly name should be unset.
    cfg.name(name);
    cfg.apply();
    sendMessage(DEV_NAME_CHANGE_RESP, 0, payload);
}
 

import org.onosproject.net.config.basics.BasicDeviceConfig; //导入依赖的package包/类
@Override
public void process(ObjectNode payload) {
    DeviceId deviceId = deviceId(string(payload, ID, ZERO_URI));
    String name = emptyToNull(string(payload, NAME, null));
    log.debug("Name change request: {} -- '{}'", deviceId, name);

    NetworkConfigService service = get(NetworkConfigService.class);
    BasicDeviceConfig cfg =
            service.addConfig(deviceId, BasicDeviceConfig.class);

    // Name attribute missing from the payload (or empty string)
    // means that the friendly name should be unset.
    cfg.name(name);
    cfg.apply();
    sendMessage(DEV_NAME_CHANGE_RESP, payload);
}
 

import org.onosproject.net.config.basics.BasicDeviceConfig; //导入依赖的package包/类
@Override
public <S, C extends Config<S>> C getConfig(S subject, Class<C> configClass) {
    if (available) {
        if (configClass.equals(NetconfProviderConfig.class)) {
            return (C) netconfProviderConfig;
        }
        DeviceId did = (DeviceId) subject;
        if (configClass.equals(NetconfDeviceConfig.class)
                && did.equals(DeviceId.deviceId(NETCONF_DEVICE_ID_STRING))) {
            return (C) netconfDeviceConfig;
        } else if (configClass.equals(NetconfDeviceConfig.class)
                && did.equals(DeviceId.deviceId(NETCONF_DEVICE_ID_STRING_OLD))) {
            if (firstRequest) {
                firstRequest = false;
                return null;
            }
            return (C) cfg;
        } else {
            return (C) new BasicDeviceConfig();
        }
    }
    return null;
}
 

import org.onosproject.net.config.basics.BasicDeviceConfig; //导入依赖的package包/类
/**
 * Generates an annotation from an existing annotation and DeviceConfig.
 *
 * @param cfg the device config entity from network config
 * @param an  the annotation
 * @return annotation combining both sources
 */
public static SparseAnnotations combine(BasicDeviceConfig cfg, SparseAnnotations an) {
    DefaultAnnotations.Builder builder = DefaultAnnotations.builder();
    builder.putAll(an);
    if (!Objects.equals(cfg.driver(), an.value(AnnotationKeys.DRIVER))) {
        builder.set(AnnotationKeys.DRIVER, cfg.driver());
    }

    combineElementAnnotations(cfg, builder);

    if (cfg.managementAddress() != null) {
        builder.set(AnnotationKeys.MANAGEMENT_ADDRESS, cfg.managementAddress());
    }

    return builder.build();
}
 

import org.onosproject.net.config.basics.BasicDeviceConfig; //导入依赖的package包/类
@Override
public <S, C extends Config<S>> C getConfig(S subject, Class<C> configClass) {
    if (configClass.equals(SnmpProviderConfig.class)) {
        return (C) snmpProviderConfig;
    } else {
        return (C) new BasicDeviceConfig();
    }
}
 

import org.onosproject.net.config.basics.BasicDeviceConfig; //导入依赖的package包/类
@Override
public void onControllerDetected(Device controllerDevice) {
    if (controllerDevice == null) {
        log.error("The controller device is null");
        return;
    }
    String localIpAddress = controllerDevice.annotations()
            .value(CONTROLLER_IP_KEY);
    IpAddress localIp = IpAddress.valueOf(localIpAddress);
    DeviceId controllerDeviceId = controllerDevice.id();
    DriverHandler handler = driverService.createHandler(controllerDeviceId);
    if (mastershipService.isLocalMaster(controllerDeviceId)) {
        // Get DataPathIdGenerator
        String ipaddress = controllerDevice.annotations().value("ipaddress");
        DataPathIdGenerator dpidGenerator = DataPathIdGenerator.builder()
                                        .addIpAddress(ipaddress).build();
        DeviceId deviceId = dpidGenerator.getDeviceId();
        String dpid = dpidGenerator.getDpId();
        // Inject pipeline driver name
        BasicDeviceConfig config = configService.addConfig(deviceId,
                                                           BasicDeviceConfig.class);
        config.driver(DRIVER_NAME);
        configService.applyConfig(deviceId, BasicDeviceConfig.class, config.node());
        // Add Bridge
        Versioned<String> exPortVersioned = exPortMap.get(EX_PORT_KEY);
        if (exPortVersioned != null) {
            VtnConfig.applyBridgeConfig(handler, dpid, exPortVersioned.value());
            log.info("A new ovs is created in node {}", localIp.toString());
        }
        switchesOfController.put(localIp, true);
    }
    // Create tunnel in br-int on all controllers
    programTunnelConfig(controllerDeviceId, localIp, handler);
}
 

import org.onosproject.net.config.basics.BasicDeviceConfig; //导入依赖的package包/类
@Override
public void deviceConnected(DeviceId deviceId,
                            DeviceDescription deviceDescription) {
    checkNotNull(deviceId, DEVICE_ID_NULL);
    checkNotNull(deviceDescription, DEVICE_DESCRIPTION_NULL);
    checkValidity();

    BasicDeviceConfig cfg = networkConfigService.getConfig(deviceId, BasicDeviceConfig.class);
    if (!isAllowed(cfg)) {
        log.warn("Device {} is not allowed", deviceId);
        return;
    }
    // Generate updated description and establish my Role
    deviceDescription = BasicDeviceOperator.combine(cfg, deviceDescription);
    Futures.getUnchecked(mastershipService.requestRoleFor(deviceId)
            .thenAccept(role -> {
                log.info("Local role is {} for {}", role, deviceId);
                applyRole(deviceId, role);
            }));

    DeviceEvent event = store.createOrUpdateDevice(provider().id(), deviceId,
                                                   deviceDescription);
    log.info("Device {} connected", deviceId);
    if (event != null) {
        log.trace("event: {} {}", event.type(), event);
        post(event);
    }

}
 

import org.onosproject.net.config.basics.BasicDeviceConfig; //导入依赖的package包/类
@Override
public boolean isRelevant(NetworkConfigEvent event) {
    return (event.type() == NetworkConfigEvent.Type.CONFIG_ADDED
            || event.type() == NetworkConfigEvent.Type.CONFIG_UPDATED)
            && (event.configClass().equals(BasicDeviceConfig.class)
                || event.configClass().equals(OpticalPortConfig.class));
}
 

import org.onosproject.net.config.basics.BasicDeviceConfig; //导入依赖的package包/类
/**
 * Generates a DeviceDescription containing fields from a DeviceDescription and
 * a DeviceConfig.
 *
 * @param bdc   the device config entity from network config
 * @param descr a DeviceDescription
 * @return DeviceDescription based on both sources
 */
public static DeviceDescription combine(BasicDeviceConfig bdc, DeviceDescription descr) {
    if (bdc == null || descr == null) {
        return descr;
    }

    Device.Type type = descr.type();
    if (bdc.type() != null && bdc.type() != type) {
        type = bdc.type();
    }
    String manufacturer = descr.manufacturer();
    if (bdc.manufacturer() != null && !bdc.manufacturer().equals(manufacturer)) {
        manufacturer = bdc.manufacturer();
    }
    String hwVersion = descr.hwVersion();
    if (bdc.hwVersion() != null && !bdc.hwVersion().equals(hwVersion)) {
        hwVersion = bdc.hwVersion();
    }
    String swVersion = descr.swVersion();
    if (bdc.swVersion() != null && !bdc.swVersion().equals(swVersion)) {
        swVersion = bdc.swVersion();
    }
    String serial = descr.serialNumber();
    if (bdc.serial() != null && !bdc.serial().equals(serial)) {
        serial = bdc.serial();
    }

    SparseAnnotations sa = combine(bdc, descr.annotations());
    return new DefaultDeviceDescription(descr.deviceUri(), type, manufacturer,
                                        hwVersion, swVersion,
                                        serial, descr.chassisId(), sa);
}
 

import org.onosproject.net.config.basics.BasicDeviceConfig; //导入依赖的package包/类
@Override
public DeviceDescription discoverDeviceDetails() {
    NetworkConfigService netcfg = handler().get(NetworkConfigService.class);
    DeviceId did = data().deviceId();

    String unk = "UNKNOWN";

    Optional<DeviceInjectionConfig> inject =
            Optional.ofNullable(netcfg.getConfig(did, DeviceInjectionConfig.class));

    Optional<BasicDeviceConfig> basic =
            Optional.ofNullable(netcfg.getConfig(did, BasicDeviceConfig.class));

    Device.Type type = basic.map(BasicDeviceConfig::type).orElse(Device.Type.SWITCH);
    String manufacturer = basic.map(BasicDeviceConfig::manufacturer).orElse(unk);
    String hwVersion = basic.map(BasicDeviceConfig::hwVersion).orElse(unk);
    String swVersion = basic.map(BasicDeviceConfig::swVersion).orElse(unk);
    String serialNumber = basic.map(BasicDeviceConfig::serial).orElse(unk);
    ChassisId chassis = new ChassisId();
    // if inject is not specified, return default unavailable device
    boolean defaultAvailable = inject.isPresent();
    return new DefaultDeviceDescription(did.uri(),
                                        type,
                                        manufacturer,
                                        hwVersion,
                                        swVersion,
                                        serialNumber,
                                        chassis,
                                        defaultAvailable);
}
 

import org.onosproject.net.config.basics.BasicDeviceConfig; //导入依赖的package包/类
private Driver getDriver(DeviceId deviceId) {
    Driver driver = null;
    try {
        driver = driverService.getDriver(deviceId);
    } catch (ItemNotFoundException e) {
        log.debug("Falling back to configuration to fetch driver " +
                "for device {}", deviceId);
        BasicDeviceConfig cfg = cfgService.getConfig(deviceId, BasicDeviceConfig.class);
        if (cfg != null) {
            driver = driverService.getDriver(cfg.driver());
        }
    }
    return driver;
}
 

import org.onosproject.net.config.basics.BasicDeviceConfig; //导入依赖的package包/类
@Override
public boolean isRelevant(NetworkConfigEvent event) {
    return (event.configClass().equals(GeneralProviderDeviceConfig.class) ||
            event.configClass().equals(BasicDeviceConfig.class) ||
            event.configClass().equals(PiPipeconfConfig.class)) &&
            (event.type() == NetworkConfigEvent.Type.CONFIG_ADDED ||
                    event.type() == NetworkConfigEvent.Type.CONFIG_UPDATED);
}
 

import org.onosproject.net.config.basics.BasicDeviceConfig; //导入依赖的package包/类
@Override
protected void execute() {
    NullProviders service = get(NullProviders.class);
    NetworkConfigService cfgService = get(NetworkConfigService.class);

    TopologySimulator simulator = service.currentSimulator();
    if (!(simulator instanceof CustomTopologySimulator)) {
        error("Custom topology simulator is not active.");
        return;
    }

    if (!(GEO.equals(locType) || GRID.equals(locType))) {
        error("locType must be 'geo' or 'grid'.");
        return;
    }

    CustomTopologySimulator sim = (CustomTopologySimulator) simulator;
    DeviceId deviceId = sim.nextDeviceId();
    BasicDeviceConfig cfg = cfgService.addConfig(deviceId, BasicDeviceConfig.class);
    cfg.name(name)
            .locType(locType);

    if (GEO.equals(locType)) {
        cfg.latitude(latOrY).longitude(longOrX);
    } else {
        cfg.gridX(longOrX).gridY(latOrY);
    }
    cfg.apply();

    sim.createDevice(deviceId, name, Device.Type.valueOf(type.toUpperCase()), portCount);
}
 

import org.onosproject.net.config.basics.BasicDeviceConfig; //导入依赖的package包/类
@Override
public <S, C extends Config<S>> C getConfig(S subject, Class<C> configClass) {
    if (configClass.equals(SnmpProviderConfig.class)) {
        return (C) snmpProviderConfig;
    } else if (configClass.equals(SnmpDeviceConfig.class)) {
        return (C) config;
    } else {
        return (C) new BasicDeviceConfig();
    }
}
 

import org.onosproject.net.config.basics.BasicDeviceConfig; //导入依赖的package包/类
@Override
public boolean isRelevant(NetworkConfigEvent event) {
    return (event.type() == NetworkConfigEvent.Type.CONFIG_ADDED
            || event.type() == NetworkConfigEvent.Type.CONFIG_UPDATED)
            && (event.configClass().equals(BasicDeviceConfig.class)
            || portOpsIndex.containsKey(event.configClass())
            || event.configClass().equals(PortDescriptionsConfig.class)
            || event.configClass().equals(DeviceAnnotationConfig.class));
}