Java OvsdbBridge类代码示例

import org.onosproject.ovsdb.controller.OvsdbBridge; //导入依赖的package包/类
@Override
public Collection<BridgeDescription> getBridges() {
    DriverHandler handler = handler();
    DeviceId deviceId = handler.data().deviceId();
    OvsdbClientService clientService = getOvsdbClientService(handler);
    Set<OvsdbBridge> bridges = clientService.getBridges();

    return bridges.stream()
            .map(x -> new DefaultBridgeDescription(
                            BridgeName.bridgeName(x.bridgeName().value()),
                            deviceId,
                            DeviceId.deviceId("of:" + x.datapathId().value())
                    )
            )
            .collect(Collectors.toSet());
}
 

import org.onosproject.ovsdb.controller.OvsdbBridge; //导入依赖的package包/类
@Override
public Set<OvsdbBridge> getBridges() {
    Set<OvsdbBridge> ovsdbBridges = new HashSet<OvsdbBridge>();
    OvsdbTableStore tableStore = getTableStore(OvsdbConstant.DATABASENAME);
    if (tableStore == null) {
        return null;
    }
    OvsdbRowStore rowStore = tableStore.getRows(OvsdbConstant.BRIDGE);
    if (rowStore == null) {
        return null;
    }
    ConcurrentMap<String, Row> rows = rowStore.getRowStore();
    for (String uuid : rows.keySet()) {
        Row row = getRow(OvsdbConstant.DATABASENAME, OvsdbConstant.BRIDGE,
                         uuid);
        OvsdbBridge ovsdbBridge = getOvsdbBridge(row);
        if (ovsdbBridge != null) {
            ovsdbBridges.add(ovsdbBridge);
        }
    }
    return ovsdbBridges;
}
 

import org.onosproject.ovsdb.controller.OvsdbBridge; //导入依赖的package包/类
private OvsdbBridge getOvsdbBridge(Row row) {
    DatabaseSchema dbSchema = getDatabaseSchema(OvsdbConstant.DATABASENAME);
    Bridge bridge = (Bridge) TableGenerator.getTable(dbSchema, row,
                                                     OvsdbTable.BRIDGE);
    if (bridge == null) {
        return null;
    }

    OvsdbSet datapathIdSet = (OvsdbSet) bridge.getDatapathIdColumn().data();
    @SuppressWarnings("unchecked")
    Set<String> datapathIds = datapathIdSet.set();
    if (datapathIds == null || datapathIds.size() == 0) {
        return null;
    }
    String datapathId = (String) datapathIds.toArray()[0];
    String bridgeName = bridge.getName();
    if ((datapathId == null) || (bridgeName == null)) {
        return null;
    }

    OvsdbBridge ovsdbBridge = new OvsdbBridge(new OvsdbBridgeName(bridgeName),
                                              new OvsdbDatapathId(datapathId));
    return ovsdbBridge;
}
 

import org.onosproject.ovsdb.controller.OvsdbBridge; //导入依赖的package包/类
@Override
public Collection<BridgeDescription> getBridges() {
    OvsdbClientService client = getOvsdbClientService(handler());
    if (client == null) {
        return Collections.emptyList();
    }

    Set<OvsdbBridge> bridges = client.getBridges();

    return bridges.stream()
            .map(bridge -> DefaultBridgeDescription.builder()
                    .name(bridge.name())
                    .datapathId(bridge.datapathId().get())
                    .build())
            .collect(Collectors.toSet());
}
 

import org.onosproject.ovsdb.controller.OvsdbBridge; //导入依赖的package包/类
@Override
public Set<OvsdbBridge> getBridges() {
    Set<OvsdbBridge> ovsdbBridges = new HashSet<>();
    OvsdbTableStore tableStore = getTableStore(DATABASENAME);
    if (tableStore == null) {
        return ovsdbBridges;
    }
    OvsdbRowStore rowStore = tableStore.getRows(BRIDGE);
    if (rowStore == null) {
        return ovsdbBridges;
    }
    ConcurrentMap<String, Row> rows = rowStore.getRowStore();
    for (String uuid : rows.keySet()) {
        Row bridgeRow = getRow(DATABASENAME, BRIDGE, uuid);
        OvsdbBridge ovsdbBridge = getOvsdbBridge(bridgeRow, Uuid.uuid(uuid));
        if (ovsdbBridge != null) {
            ovsdbBridges.add(ovsdbBridge);
        }
    }
    return ovsdbBridges;
}
 

import org.onosproject.ovsdb.controller.OvsdbBridge; //导入依赖的package包/类
/**
 * Create a GRE tunnel interface pointing to remote MOAS.
 *
 * @param remoteIp remote ip on GRE tunnel
 */
private void createTunnelInterface(IpAddress remoteIp) {
    ovsdbController.getNodeIds().forEach(nodeId -> artemisService.getConfig().flatMap(config ->
            config.moasInfo().getTunnelPoints()
                    .stream()
                    .filter(tunnelPoint -> tunnelPoint.getOvsdbIp().toString().equals(nodeId.getIpAddress()))
                    .findFirst()
    ).ifPresent(tunnelPoint -> {
        OvsdbClientService ovsdbClient = ovsdbController.getOvsdbClient(nodeId);
        ovsdbClient.dropInterface("gre-int");
        Map<String, String> options = Maps.newHashMap();
        options.put("remote_ip", remoteIp.toString());
        OvsdbInterface ovsdbInterface = OvsdbInterface.builder()
                .name("gre-int")
                .options(options)
                .type(OvsdbInterface.Type.GRE)
                .build();
        OvsdbBridge mainBridge = ovsdbClient.getBridges().iterator().next();
        ovsdbClient.createInterface(mainBridge.name(), ovsdbInterface);
        log.info("Tunnel setup at {} - {}", nodeId, tunnelPoint);
    }));
}
 

import org.onosproject.ovsdb.controller.OvsdbBridge; //导入依赖的package包/类
@Deprecated
@Override
public void addPort(PortDescription port) {
    DriverHandler handler = handler();
    OvsdbClientService clientService = getOvsdbClientService(handler);
    Set<OvsdbBridge> ovsdbSet = clientService.getBridges();
    if (ovsdbSet != null && ovsdbSet.size() > 0) {
        OvsdbBridge bridge = ovsdbSet.iterator().next();
        clientService.createPort(bridge.bridgeName().value(), port
                .portNumber().toString());
    }
}
 

import org.onosproject.ovsdb.controller.OvsdbBridge; //导入依赖的package包/类
@Deprecated
@Override
public void deletePort(PortDescription port) {
    DriverHandler handler = handler();
    OvsdbClientService clientService = getOvsdbClientService(handler);
    Set<OvsdbBridge> ovsdbSet = clientService.getBridges();
    if (ovsdbSet != null && ovsdbSet.size() > 0) {
        OvsdbBridge bridge = ovsdbSet.iterator().next();
        clientService.dropPort(bridge.bridgeName().value(), port
                .portNumber().toString());
    }
}
 

import org.onosproject.ovsdb.controller.OvsdbBridge; //导入依赖的package包/类
private static boolean dpidMatches(OvsdbBridge bridge, DeviceId deviceId) {
    checkArgument(bridge.datapathId().isPresent());

    String bridgeDpid = "of:" + bridge.datapathId().get();
    String ofDpid = deviceId.toString();
    return bridgeDpid.equals(ofDpid);
}
 

import org.onosproject.ovsdb.controller.OvsdbBridge; //导入依赖的package包/类
@Override
public boolean addBridge(BridgeDescription bridgeDesc) {
    OvsdbClientService client = getOvsdbClientService(handler());
    if (client == null) {
        return false;
    }
    OvsdbBridge.Builder bridgeBuilder = OvsdbBridge.builder(bridgeDesc);
    if (bridgeDesc.enableLocalController()) {
        bridgeBuilder.controller(client.localController());
    }
    return client.createBridge(bridgeBuilder.build());
}
 

import org.onosproject.ovsdb.controller.OvsdbBridge; //导入依赖的package包/类
private OvsdbBridge getOvsdbBridge(Row row, Uuid bridgeUuid) {
    DatabaseSchema dbSchema = getDatabaseSchema(DATABASENAME);
    Bridge bridge = (Bridge) TableGenerator.getTable(dbSchema, row, OvsdbTable.BRIDGE);
    if (bridge == null) {
        return null;
    }

    OvsdbSet datapathIdSet = (OvsdbSet) bridge.getDatapathIdColumn().data();
    @SuppressWarnings("unchecked")
    Set<String> datapathIds = datapathIdSet.set();
    if (datapathIds == null || datapathIds.isEmpty()) {
        return null;
    }
    String datapathId = (String) datapathIds.toArray()[0];
    String bridgeName = bridge.getName();
    if ((datapathId == null) || (bridgeName == null)) {
        return null;
    }

    List<Controller> controllers = getControllers(bridgeUuid);

    if (controllers != null) {
        List<ControllerInfo> controllerInfos = controllers.stream().map(
                controller -> new ControllerInfo(
                (String) controller.getTargetColumn()
                        .data())).collect(Collectors.toList());

        return OvsdbBridge.builder()
                .name(bridgeName)
                .datapathId(datapathId)
                .controllers(controllerInfos)
                .build();
    } else {
        return OvsdbBridge.builder()
                .name(bridgeName)
                .datapathId(datapathId)
                .build();
    }
}
 

import org.onosproject.ovsdb.controller.OvsdbBridge; //导入依赖的package包/类
private static boolean dpidMatches(OvsdbBridge bridge, DeviceId deviceId) {
    String bridgeDpid = "of:" + bridge.datapathId().value();
    String ofDpid = deviceId.toString();
    return bridgeDpid.equals(ofDpid);
}
 

import org.onosproject.ovsdb.controller.OvsdbBridge; //导入依赖的package包/类
@Override
public Set<OvsdbBridge> getBridges() {
    return null;
}
 

import org.onosproject.ovsdb.controller.OvsdbBridge; //导入依赖的package包/类
@Override
public boolean createBridge(OvsdbBridge ovsdbBridge) {
    return true;
}