Java DatabaseSchema类代码示例

import org.onosproject.ovsdb.rfc.schema.DatabaseSchema; //导入依赖的package包/类
@Override
public void createPort(String bridgeName, String portName) {
    String bridgeUuid = getBridgeUuid(bridgeName);
    if (bridgeUuid == null) {
        log.error("Can't find bridge {} in {}", bridgeName,
                  nodeId.getIpAddress());
        return;
    }

    DatabaseSchema dbSchema = schema.get(OvsdbConstant.DATABASENAME);
    String portUuid = getPortUuid(portName, bridgeUuid);

    Port port = (Port) TableGenerator
            .createTable(dbSchema, OvsdbTable.PORT);

    port.setName(portName);
    if (portUuid == null) {
        insertConfig(OvsdbConstant.PORT, "_uuid", OvsdbConstant.BRIDGE,
                     "ports", bridgeUuid, port.getRow());
    } else {
        updateConfig(OvsdbConstant.PORT, "_uuid", portUuid, port.getRow());
    }

    return;
}
 

import org.onosproject.ovsdb.rfc.schema.DatabaseSchema; //导入依赖的package包/类
/**
 * Update transact config.
 *
 * @param tableName  table name
 * @param columnName column name
 * @param uuid       uuid
 * @param row        the config data
 */
private void updateConfig(String tableName, String columnName, String uuid,
                          Row row) {
    DatabaseSchema dbSchema = schema.get(OvsdbConstant.DATABASENAME);
    TableSchema tableSchema = dbSchema.getTableSchema(tableName);

    List<Condition> conditions = Lists.newArrayList();
    Condition condition = ConditionUtil.isEqual(columnName, Uuid.uuid(uuid));
    conditions.add(condition);

    Update update = new Update(tableSchema, row, conditions);

    ArrayList<Operation> operations = Lists.newArrayList();
    operations.add(update);

    transactConfig(OvsdbConstant.DATABASENAME, operations);
}
 

import org.onosproject.ovsdb.rfc.schema.DatabaseSchema; //导入依赖的package包/类
/**
 * Handles port insert.
 *
 * @param tableName ovsdb table interface
 * @param portRow   row of port
 * @return insert, empty if null
 */
private Insert handlePortInsertTable(String tableName, Row portRow) {
    DatabaseSchema dbSchema = schema.get(OvsdbConstant.DATABASENAME);

    TableSchema portTableSchema = dbSchema
            .getTableSchema(OvsdbConstant.PORT);
    ColumnSchema portColumnSchema = portTableSchema.getColumnSchema("name");

    String portName = (String) portRow.getColumn(portColumnSchema.name()).data();

    Interface inf = (Interface) TableGenerator
            .createTable(dbSchema, OvsdbTable.INTERFACE);

    inf.setName(portName);

    TableSchema intfTableSchema = dbSchema
            .getTableSchema(OvsdbConstant.INTERFACE);
    Insert insert = new Insert(intfTableSchema, OvsdbConstant.INTERFACE,
                               inf.getRow());
    return insert;
}
 

import org.onosproject.ovsdb.rfc.schema.DatabaseSchema; //导入依赖的package包/类
@Override
public ListenableFuture<TableUpdates> monitorTables(String dbName, String id) {
    if (dbName == null) {
        return null;
    }
    DatabaseSchema dbSchema = schema.get(dbName);
    if (dbSchema != null) {
        Function<JsonNode, TableUpdates> rowFunction = new Function<JsonNode, TableUpdates>() {
            @Override
            public TableUpdates apply(JsonNode input) {
                log.info("Get table updates");
                TableUpdates updates = FromJsonUtil
                        .jsonNodeToTableUpdates(input, dbSchema);
                if (updates == null) {
                    log.debug("Get table updates error");
                    return null;
                }
                return updates;
            }
        };
        return Futures.transform(monitor(dbSchema, id), rowFunction);
    }
    return null;
}
 

import org.onosproject.ovsdb.rfc.schema.DatabaseSchema; //导入依赖的package包/类
@Override
public ListenableFuture<List<OperationResult>> transactConfig(String dbName,
                                                              List<Operation> operations) {
    if (dbName == null) {
        return null;
    }
    DatabaseSchema dbSchema = schema.get(dbName);
    if (dbSchema != null) {
        Function<List<JsonNode>, List<OperationResult>> rowFunction = (input -> {
            log.info("Get ovsdb operation result");
            List<OperationResult> result = FromJsonUtil
                    .jsonNodeToOperationResult(input, operations);

            if (result == null) {
                log.debug("The operation result is null");
                return null;
            }
            return result;
        });
        return Futures.transform(transact(dbSchema, operations),
                                 rowFunction);
    }
    return null;
}
 

import org.onosproject.ovsdb.rfc.schema.DatabaseSchema; //导入依赖的package包/类
private OvsdbPort getOvsdbPort(Row row) {
    DatabaseSchema dbSchema = getDatabaseSchema(OvsdbConstant.DATABASENAME);
    Interface intf = (Interface) TableGenerator
            .getTable(dbSchema, row, OvsdbTable.INTERFACE);
    if (intf == null) {
        return null;
    }
    long ofPort = getOfPort(intf);
    String portName = intf.getName();
    if ((ofPort < 0) || (portName == null)) {
        return null;
    }

    OvsdbPort ovsdbPort = new OvsdbPort(new OvsdbPortNumber(ofPort),
                                        new OvsdbPortName(portName));
    return ovsdbPort;
}
 

import org.onosproject.ovsdb.rfc.schema.DatabaseSchema; //导入依赖的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.rfc.schema.DatabaseSchema; //导入依赖的package包/类
/**
 * Gets datapathid from table bridge.
 *
 * @param clientService OvsdbClientService instance
 * @param dbSchema      ovsdb database schema
 * @return datapathid the bridge datapathid
 */
private long getDataPathid(OvsdbClientService clientService,
                           DatabaseSchema dbSchema) {
    String bridgeUuid = clientService
            .getBridgeUuid(OvsdbConstant.INTEGRATION_BRIDGE);
    if (bridgeUuid == null) {
        log.debug("Unable to spot bridge uuid for {} in {}",
                  OvsdbConstant.INTEGRATION_BRIDGE, clientService);
        return 0;
    }

    Row bridgeRow = clientService.getRow(OvsdbConstant.DATABASENAME,
                                         "Bridge", bridgeUuid);
    Bridge bridge = (Bridge) TableGenerator.getTable(dbSchema, bridgeRow,
                                                     OvsdbTable.BRIDGE);
    OvsdbSet dpidSet = (OvsdbSet) bridge.getDatapathIdColumn().data();
    @SuppressWarnings("unchecked")
    Set<String> dpids = dpidSet.set();
    if (dpids == null || dpids.size() == 0) {
        return 0;
    }
    return stringToLong((String) dpids.toArray()[0]);
}
 

import org.onosproject.ovsdb.rfc.schema.DatabaseSchema; //导入依赖的package包/类
@Override
public void update(UpdateNotification updateNotification) {
    Object key = updateNotification.jsonValue();
    OvsdbClientService ovsdbClient = requestNotification.get(key);

    String dbName = requestDbName.get(key);
    JsonNode updatesJson = updateNotification.tbUpdatesJsonNode();
    DatabaseSchema dbSchema = ovsdbClient.getDatabaseSchema(dbName);
    TableUpdates updates = FromJsonUtil
            .jsonNodeToTableUpdates(updatesJson, dbSchema);
    try {
        processTableUpdates(ovsdbClient, updates, dbName);
    } catch (InterruptedException e) {
        log.warn("Interrupted while processing table updates");
        Thread.currentThread().interrupt();
    }
}
 

import org.onosproject.ovsdb.rfc.schema.DatabaseSchema; //导入依赖的package包/类
@Override
public String getBridgeUuid(String bridgeName) {
    DatabaseSchema dbSchema = schema.get(DATABASENAME);
    OvsdbRowStore rowStore = getRowStore(DATABASENAME, BRIDGE);
    if (rowStore == null) {
        log.debug("The bridge uuid is null");
        return null;
    }

    ConcurrentMap<String, Row> bridgeTableRows = rowStore.getRowStore();
    if (bridgeTableRows == null) {
        log.debug("The bridge uuid is null");
        return null;
    }

    for (String uuid : bridgeTableRows.keySet()) {
        Bridge bridge = (Bridge) TableGenerator
                .getTable(dbSchema, bridgeTableRows.get(uuid), OvsdbTable.BRIDGE);
        if (bridge.getName().equals(bridgeName)) {
            return uuid;
        }
    }
    return null;
}
 

import org.onosproject.ovsdb.rfc.schema.DatabaseSchema; //导入依赖的package包/类
@Override
public void createPort(String bridgeName, String portName) {
    String bridgeUuid = getBridgeUuid(bridgeName);
    if (bridgeUuid == null) {
        log.error("Can't find bridge {} in {}", bridgeName, nodeId.getIpAddress());
        return;
    }

    DatabaseSchema dbSchema = schema.get(DATABASENAME);
    String portUuid = getPortUuid(portName, bridgeUuid);
    Port port = (Port) TableGenerator.createTable(dbSchema, OvsdbTable.PORT);
    port.setName(portName);
    if (portUuid == null) {
        insertConfig(PORT, UUID, BRIDGE, PORTS, bridgeUuid, port.getRow());
    }
}
 

import org.onosproject.ovsdb.rfc.schema.DatabaseSchema; //导入依赖的package包/类
@Override
public boolean createQueue(OvsdbQueue ovsdbQueue) {
    DatabaseSchema dbSchema = schema.get(DATABASENAME);
    Queue queue = (Queue) TableGenerator.createTable(dbSchema, OvsdbTable.QUEUE);
    ArrayList<Operation> operations = Lists.newArrayList();
    OvsdbRowStore rowStore = getRowStore(DATABASENAME, QUEUE);
    if (rowStore == null) {
        log.debug("The queue uuid is null");
        return false;
    }

    if (ovsdbQueue.dscp().isPresent()) {
        queue.setDscp(ImmutableSet.of(ovsdbQueue.dscp().get()));
    }
    queue.setOtherConfig(ovsdbQueue.otherConfigs());
    queue.setExternalIds(ovsdbQueue.externalIds());
    Insert queueInsert = new Insert(dbSchema.getTableSchema(QUEUE), QUEUE, queue.getRow());
    operations.add(queueInsert);

    try {
        transactConfig(DATABASENAME, operations).get();
    } catch (InterruptedException | ExecutionException e) {
        log.error("createQueue transactConfig get exception !");
    }
    return true;
}
 

import org.onosproject.ovsdb.rfc.schema.DatabaseSchema; //导入依赖的package包/类
/**
 * Update transact config.
 *
 * @param tableName  table name
 * @param columnName column name
 * @param uuid       uuid
 * @param row        the config data
 */
private void updateConfig(String tableName, String columnName, String uuid,
                          Row row) {
    DatabaseSchema dbSchema = schema.get(DATABASENAME);
    TableSchema tableSchema = dbSchema.getTableSchema(tableName);

    List<Condition> conditions = Lists.newArrayList();
    Condition condition = ConditionUtil.isEqual(columnName, Uuid.uuid(uuid));
    conditions.add(condition);

    Update update = new Update(tableSchema, row, conditions);

    ArrayList<Operation> operations = Lists.newArrayList();
    operations.add(update);

    transactConfig(DATABASENAME, operations);
}
 

import org.onosproject.ovsdb.rfc.schema.DatabaseSchema; //导入依赖的package包/类
@Override
public ListenableFuture<TableUpdates> monitorTables(String dbName, String id) {
    if (dbName == null) {
        return null;
    }
    DatabaseSchema dbSchema = schema.get(dbName);
    if (dbSchema != null) {
        Function<JsonNode, TableUpdates> rowFunction = input -> {
            log.debug("Get table updates");
            TableUpdates updates = FromJsonUtil.jsonNodeToTableUpdates(input, dbSchema);
            if (updates == null) {
                log.debug("Get table updates error");
                return null;
            }
            return updates;
        };
        return Futures.transform(monitor(dbSchema, id), rowFunction);
    }
    return null;
}
 

import org.onosproject.ovsdb.rfc.schema.DatabaseSchema; //导入依赖的package包/类
private ListenableFuture<List<OperationResult>> transactConfig(String dbName,
                                                               List<Operation> operations) {
    if (dbName == null) {
        return null;
    }
    DatabaseSchema dbSchema = schema.get(dbName);
    if (dbSchema != null) {
        Function<List<JsonNode>, List<OperationResult>> rowFunction = (input -> {
            try {
                log.debug("Get ovsdb operation result");
                List<OperationResult> result = FromJsonUtil.jsonNodeToOperationResult(input, operations);
                if (result == null) {
                    log.debug("The operation result is null");
                    return null;
                }
                return result;
            } catch (Exception e) {
                log.error("Exception while parsing result", e);
            }
            return null;
        });
        return Futures.transform(transact(dbSchema, operations), rowFunction);
    }
    return null;
}