package org.opendaylight.ovsdb.lib;
import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
import com.google.common.base.Function;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Lists;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
import org.opendaylight.ovsdb.lib.schema.TableSchema;
-import org.opendaylight.ovsdb.lib.table.Table;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.HashMap;
+import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Queue;
private ExecutorService executorService;
private OvsdbRPC rpc;
private Map<String, DatabaseSchema> schema = Maps.newHashMap();
- private HashMap<String, MonitorCallBack> monitorCallbacks = Maps.newHashMap();
+ private HashMap<String, CallbackContext> monitorCallbacks = Maps.newHashMap();
private Queue<Throwable> exceptions;
private OvsdbRPC.Callback rpcCallback;
OvsDBClientImpl() {
}
- void setupUpdateListner() {
+ void setupUpdateListener() {
if (rpcCallback == null) {
OvsdbRPC.Callback temp = new OvsdbRPC.Callback() {
@Override
public void update(Object node, UpdateNotification upadateNotification) {
Object key = upadateNotification.getContext();
- MonitorCallBack monitorCallBack = monitorCallbacks.get(key);
+ CallbackContext callbackContext = monitorCallbacks.get(key);
+ MonitorCallBack monitorCallBack = callbackContext.monitorCallBack;
if (monitorCallBack == null) {
//ignore ?
logger.info("callback received with context {}, but no known handler. Ignoring!", key);
return;
}
- _transformingCallback(upadateNotification.getUpdate(), monitorCallBack);
+ _transformingCallback(upadateNotification.getUpdates(), monitorCallBack, callbackContext.schema);
}
@Override
}
}
- protected void _transformingCallback( org.opendaylight.ovsdb.lib.message.temp.TableUpdates oldUpdate, MonitorCallBack monitorCallBack) {
- //todo(ashwin) : temp kludge to get stuff working while deprecating old stuff
- Map<String, TableUpdate> updateMap = Maps.newHashMap();
- for (Map.Entry<Table.Name, TableUpdate> temp : oldUpdate.map.entrySet()) {
- updateMap.put(temp.getKey().getName(), temp.getValue());
- }
- monitorCallBack.update(new TableUpdates(updateMap));
+ protected void _transformingCallback(JsonNode tableUpdatesJson, MonitorCallBack monitorCallBack, DatabaseSchema dbSchema) {
+ //todo(ashwin): we should move all the JSON parsing logic to a utility class
+ if (tableUpdatesJson instanceof ObjectNode) {
+ Map<String, TableUpdate> tableUpdateMap = Maps.newHashMap();
+ ObjectNode updatesJson = (ObjectNode) tableUpdatesJson;
+ for (Iterator<Map.Entry<String,JsonNode>> itr = updatesJson.fields(); itr.hasNext();){
+ Map.Entry<String, JsonNode> entry = itr.next();
+
+ DatabaseSchema databaseSchema = this.schema.get(dbSchema.getName());
+ TableSchema table = databaseSchema.table(entry.getKey(), TableSchema.class);
+ tableUpdateMap.put(entry.getKey(), table.updatesFromJson(entry.getValue()));
+
+ }
+ TableUpdates updates = new TableUpdates(tableUpdateMap);
+ monitorCallBack.update(updates);
+ }
}
@Override
});
final MonitorHandle monitorHandle = new MonitorHandle(UUID.randomUUID().toString());
- registerCallback(monitorHandle, callback);
+ registerCallback(monitorHandle, callback, dbSchema);
- ListenableFuture<org.opendaylight.ovsdb.lib.message.temp.TableUpdates> monitor = rpc.monitor(new Params() {
+ ListenableFuture<JsonNode> monitor = rpc.monitor(new Params() {
@Override
public List<Object> params() {
return Lists.<Object>newArrayList(dbSchema.getName(), monitorHandle.getId(), reqMap);
}
});
- Futures.addCallback(monitor, new FutureCallback<org.opendaylight.ovsdb.lib.message.temp.TableUpdates>() {
+ Futures.addCallback(monitor, new FutureCallback<JsonNode>() {
@Override
- public void onSuccess(org.opendaylight.ovsdb.lib.message.temp.TableUpdates result) {
- _transformingCallback(result, callback);
+ public void onSuccess(JsonNode result) {
+ _transformingCallback(result, callback, dbSchema);
}
@Override
return monitorHandle;
}
- private void registerCallback(MonitorHandle monitorHandle, MonitorCallBack callback) {
- this.monitorCallbacks.put(monitorHandle.getId(), callback);
- setupUpdateListner();
+ private void registerCallback(MonitorHandle monitorHandle, MonitorCallBack callback, DatabaseSchema schema) {
+ this.monitorCallbacks.put(monitorHandle.getId(), new CallbackContext(callback, schema));
+ setupUpdateListener();
}
@Override
return exceptions;
}
+ static class CallbackContext {
+ MonitorCallBack monitorCallBack;
+ DatabaseSchema schema;
+
+ CallbackContext(MonitorCallBack monitorCallBack, DatabaseSchema schema) {
+ this.monitorCallBack = monitorCallBack;
+ this.schema = schema;
+ }
+ }
}
import java.util.List;
-import org.opendaylight.ovsdb.lib.message.temp.TableUpdates;
import org.opendaylight.ovsdb.lib.operations.OperationResult;
import com.fasterxml.jackson.databind.JsonNode;
public ListenableFuture<List<String>> echo();
- public ListenableFuture<TableUpdates> monitor(Params equest);
+ public ListenableFuture<JsonNode> monitor(Params equest);
public ListenableFuture<List<String>> list_dbs();
/*
- * Copyright (C) 2013 EBay Software Foundation
*
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
+ * * Copyright (C) 2014 EBay Software Foundation
+ * *
+ * * This program and the accompanying materials are made available under the
+ * * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * * and is available at http://www.eclipse.org/legal/epl-v10.html
+ * *
+ * * Authors : Ashwin Raveendran
*
- * Authors : Ashwin Raveendran, Madhu Venugopal
*/
-package org.opendaylight.ovsdb.lib.message;
-
-import com.fasterxml.jackson.annotation.JsonAnyGetter;
-import com.fasterxml.jackson.annotation.JsonAnySetter;
-import com.fasterxml.jackson.annotation.JsonIgnore;
-import com.fasterxml.jackson.annotation.JsonProperty;
-import com.google.common.collect.Maps;
-
-import java.util.Collection;
-import java.util.Map;
-
-import org.opendaylight.ovsdb.lib.table.Table;
+package org.opendaylight.ovsdb.lib.message;
-public class TableUpdate<T extends Table> {
- /*This could have been done as a map, but doing so would expose the inner wrapper class in type signature*/
+import org.opendaylight.ovsdb.lib.notation.Row;
+import org.opendaylight.ovsdb.lib.schema.TableSchema;
- Map<String, Row<T>> map = Maps.newHashMap();
+public class TableUpdate<E extends TableSchema<E>> {
- @JsonAnyGetter
- public Row<T> get(String rowId) {
- return map.get(rowId);
- }
+ private Row<E> old;
+ private Row<E> new_;
- @JsonAnySetter
- public void set(String rowId, Row<T> value) {
- map.put(rowId, value);
- value.setId(rowId);
+ public Row<E> getOld() {
+ return old;
}
- public Collection<Row<T>> getRows() {
- return map.values();
+ public void setOld(Row<E> old) {
+ this.old = old;
}
- @Override
- public String toString() {
- return "TableUpdate [map=" + map + "]";
+ public Row<E> getNew() {
+ return new_;
}
- public static class Row<T> {
-
- @JsonIgnore
- String id;
-
- @JsonProperty("new")
- T _new;
- T old;
-
- public String getId() {
- return id;
- }
-
- public T getNew() {
- return _new;
- }
-
- public void setNew(T neww) {
- this._new = neww;
- }
-
- public T getOld() {
- return old;
- }
-
- public void setOld(T old) {
- this.old = old;
- }
-
- void setId(String id) {
- this.id = id;
- }
-
- @Override
- public String toString() {
- return "Row{" +
- "id='" + id + '\'' +
- ", _new=" + _new.toString() +
- '}';
- }
-
+ public void setNew(Row<E> new_) {
+ this.new_ = new_;
}
}
package org.opendaylight.ovsdb.lib.message;
import com.google.common.collect.Maps;
-import org.opendaylight.ovsdb.lib.schema.GenericTableSchema;
+import org.opendaylight.ovsdb.lib.schema.TableSchema;
import java.util.Map;
this.map = map;
}
- public TableUpdate getUpdate(GenericTableSchema table) {
- //todo Horrible just for time being, before this whole thing is refactored.
- for (Map.Entry<String, TableUpdate> s : this.map.entrySet()) {
- if (table.getName().equals(s.getKey())) {
- return s.getValue();
- }
- }
- return null;
+ public <E extends TableSchema<E>> TableUpdate<E> getUpdate(TableSchema<E> table) {
+ return this.map.get(table.getName());
}
}
*/
package org.opendaylight.ovsdb.lib.message;
+import com.fasterxml.jackson.annotation.JsonAnySetter;
+import com.fasterxml.jackson.databind.JsonNode;
import org.opendaylight.ovsdb.lib.message.temp.TableUpdates;
import org.opendaylight.ovsdb.lib.notation.json.Converter.UpdateNotificationConverter;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
public class UpdateNotification {
Object context;
TableUpdates update;
+ private JsonNode updatesJson;
+
public Object getContext() {
return context;
}
public void setUpdate(TableUpdates update) {
this.update = update;
}
+
+ @JsonAnySetter
+ public void setValue(String key, JsonNode val) {
+ System.out.println("key = " + key);
+ System.out.println("val = " + val);
+ System.out.println();
+ }
+
+ public void setUpdates(JsonNode jsonNode) {
+ this.updatesJson = jsonNode;
+ }
+
+ public JsonNode getUpdates() {
+ return updatesJson;
+ }
}
--- /dev/null
+/*
+ * Copyright (C) 2013 EBay Software Foundation
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Authors : Ashwin Raveendran, Madhu Venugopal
+ */
+package org.opendaylight.ovsdb.lib.message.temp;
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter;
+import com.fasterxml.jackson.annotation.JsonAnySetter;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.google.common.collect.Maps;
+
+import java.util.Collection;
+import java.util.Map;
+
+import org.opendaylight.ovsdb.lib.table.Table;
+
+
+public class TableUpdate<T extends Table> {
+ /*This could have been done as a map, but doing so would expose the inner wrapper class in type signature*/
+
+ Map<String, Row<T>> map = Maps.newHashMap();
+
+ @JsonAnyGetter
+ public Row<T> get(String rowId) {
+ return map.get(rowId);
+ }
+
+ @JsonAnySetter
+ public void set(String rowId, Row<T> value) {
+ map.put(rowId, value);
+ value.setId(rowId);
+ }
+
+ public Collection<Row<T>> getRows() {
+ return map.values();
+ }
+
+ @Override
+ public String toString() {
+ return "TableUpdate [map=" + map + "]";
+ }
+
+ public static class Row<T> {
+
+ @JsonIgnore
+ String id;
+
+ @JsonProperty("new")
+ T _new;
+ T old;
+
+ public String getId() {
+ return id;
+ }
+
+ public T getNew() {
+ return _new;
+ }
+
+ public void setNew(T neww) {
+ this._new = neww;
+ }
+
+ public T getOld() {
+ return old;
+ }
+
+ public void setOld(T old) {
+ this.old = old;
+ }
+
+ void setId(String id) {
+ this.id = id;
+ }
+
+ @Override
+ public String toString() {
+ return "Row{" +
+ "id='" + id + '\'' +
+ ", _new=" + _new.toString() +
+ '}';
+ }
+
+ }
+}
import com.google.common.collect.Maps;
import org.opendaylight.ovsdb.lib.message.Response;
-import org.opendaylight.ovsdb.lib.message.TableUpdate;
import org.opendaylight.ovsdb.lib.schema.GenericTableSchema;
import org.opendaylight.ovsdb.lib.table.Bridge;
import org.opendaylight.ovsdb.lib.table.Capability;
--- /dev/null
+/*
+ *
+ * * Copyright (C) 2014 EBay Software Foundation
+ * *
+ * * This program and the accompanying materials are made available under the
+ * * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * * and is available at http://www.eclipse.org/legal/epl-v10.html
+ * *
+ * * Authors : Ashwin Raveendran
+ *
+ */
+
+package org.opendaylight.ovsdb.lib.notation;
+
+
+import org.opendaylight.ovsdb.lib.schema.ColumnSchema;
+import org.opendaylight.ovsdb.lib.schema.TableSchema;
+
+
+public class Column<E extends TableSchema<E>, D> {
+
+ private ColumnSchema<E, D> schema;
+ private D data;
+
+ public Column(ColumnSchema<E, D> schema, D d) {
+ this.schema = schema;
+ this.data = d;
+ }
+
+ public <E extends TableSchema<E>, T> T getData(ColumnSchema<E, T> schema) {
+ return schema.validate(data);
+ }
+
+ public Object getData() {
+ return data;
+ }
+
+ public void setData(D data) {
+ this.data = data;
+ }
+
+ public ColumnSchema<E, D> getSchema() {
+ return schema;
+ }
+
+ public void setSchema(ColumnSchema<E, D> schema) {
+ this.schema = schema;
+ }
+}
--- /dev/null
+/*
+ *
+ * * Copyright (C) 2014 EBay Software Foundation
+ * *
+ * * This program and the accompanying materials are made available under the
+ * * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * * and is available at http://www.eclipse.org/legal/epl-v10.html
+ * *
+ * * Authors : Ashwin Raveendran
+ *
+ */
+
+package org.opendaylight.ovsdb.lib.notation;
+
+import java.util.List;
+
+/**
+ * A collection of Rows as returned by select and other operations on OVSDB
+ */
+public class ResultSet {
+
+ private List<Row> rows;
+
+ public List<Row> getRows() {
+ return rows;
+ }
+
+ public void setRows(List<Row> rows) {
+ this.rows = rows;
+ }
+}
package org.opendaylight.ovsdb.lib.notation;
-import org.opendaylight.ovsdb.lib.database.ColumnSchema;
+import org.opendaylight.ovsdb.lib.schema.ColumnSchema;
+import org.opendaylight.ovsdb.lib.schema.TableSchema;
-import java.util.Map;
+import java.util.List;
-public class Row {
- private Map<String, ColumnSchema> columnSchema;
- private Map<String, Object> columns;
+public class Row<E extends TableSchema<E>> {
+ List<Column<E, ?>> columns;
+ public Row(List<Column<E, ?>> columns) {
+ this.columns = columns;
+ }
+ public <D> Column<E, D> getColumn(ColumnSchema<E, D> schema) {
+ for (Column<E, ?> column : columns) {
+ if (column.getSchema().equals(schema)) {
+ return (Column<E, D>) column;
+ }
+ }
+ return null;
+ }
+
+ public List<Column<E, ?>> getColumns() {
+ return columns;
+ }
}
if (node.isArray()) {
if (node.size() == 2) {
un.setContext(node.get(0).asText());
+ un.setUpdates(node.get(1));
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
TableUpdates updates = objectMapper.convertValue(node.get(1), TableUpdates.class);
return this;
}
- public Operation operation() {
+ public Operation build() {
return (Operation) this.operation;
}
import com.fasterxml.jackson.databind.JsonNode;
import com.google.common.collect.Sets;
+import org.opendaylight.ovsdb.lib.notation.UUID;
import java.util.Set;
return baseType;
}
+ public abstract Object toValue(JsonNode value);
+
+ public abstract void validate(Object value);
+
public static class IntegerBaseType extends BaseType<IntegerBaseType> {
long min = Long.MIN_VALUE;
long max = Long.MAX_VALUE;
populateEnum(type);
}
+ @Override
+ public Object toValue(JsonNode value) {
+ return value.asLong();
+ }
+
+ @Override
+ public void validate(Object value) {
+
+ }
+
private void populateEnum(JsonNode node) {
if (node.has("enum")) {
Set<Long> s = Sets.newHashSet();
populateEnum(type);
}
+ @Override
+ public Object toValue(JsonNode value) {
+ return value.asDouble();
+ }
+
+ @Override
+ public void validate(Object value) {
+
+ }
+
private void populateEnum(JsonNode node) {
if (node.has("enum")) {
Set<Double> s = Sets.newHashSet();
//no op
}
+ @Override
+ public Object toValue(JsonNode value) {
+ return value.asBoolean();
+ }
+
+ @Override
+ public void validate(Object value) {
+
+ }
+
@Override
public String toString() {
return "BooleanBaseType";
populateEnum(baseType, type);
}
+ @Override
+ public Object toValue(JsonNode value) {
+ return value.asText();
+ }
+
+ @Override
+ public void validate(Object value) {
+
+ }
+
private void populateEnum(StringBaseType baseType, JsonNode node) {
if (node.has("enum")) {
Set<String> s = Sets.newHashSet();
}
+ @Override
+ public Object toValue(JsonNode value) {
+ return new UUID(value.asText());
+ }
+
+ @Override
+ public void validate(Object value) {
+
+ }
+
public String getRefTable() {
return refTable;
}
// --- Operations on the column ----------//:w
+
@Override
public String toString() {
- return "ColumnType [type=" + type + ", ephemeral=" + ephemeral
- + ", mutable=" + mutable + "]";
+ return "ColumnSchema{" +
+ "name='" + name + '\'' +
+ ", type=" + type +
+ '}';
}
/**
* @param value
* @throws java.lang.RuntimeException (validation exception)
*/
- public void validate(Object value)throws RuntimeException {
+ public D validate(Object value)throws RuntimeException {
//todo(type check and validate based on constraints set)
+ this.type.validate(value);
+ return (D) value;
}
/**
public void validateType(Class<?> type) {
}
+
+ public D valueFromJson(JsonNode value) {
+ return (D) this.getType().valueFromJson(value);
+ }
+
}
package org.opendaylight.ovsdb.lib.schema;
import com.fasterxml.jackson.databind.JsonNode;
+import com.google.common.collect.Sets;
import org.opendaylight.ovsdb.lib.jsonrpc.JsonUtils;
+import java.util.Set;
+
public abstract class ColumnType {
BaseType baseType;
- long min = 0;
- long max = 0;
+ long min = 1;
+ long max = 1;
public long getMin() {
return min;
return this.min != this.max && this.min != 1;
}
+ public abstract Object valueFromJson(JsonNode value);
+
+ public abstract void validate(Object value);
+
+ @Override
+ public String toString() {
+ return "ColumnType{" +
+ "baseType=" + baseType +
+ ", min=" + min +
+ ", max=" + max +
+ '}';
+ }
+
public static class AtomicColumnType extends ColumnType {
public AtomicColumnType() {
if ((node = json.get("min")) != null) {
atomicColumnType.setMin(node.asLong());
}
+
if ((node = json.get("max")) != null) {
- atomicColumnType.setMax(node.asLong());
+ if (node.isLong()){
+ atomicColumnType.setMax(node.asLong());
+ } else if (node.isTextual() && "unlimited".equals(node.asText())) {
+ max = Long.MAX_VALUE;
+ }
}
-
return atomicColumnType;
}
return null;
}
+ @Override
+ public Object valueFromJson(JsonNode value) {
+ if (isMultiValued()) {
+ Set<Object> result = Sets.newHashSet();
+ if(value.isContainerNode()) {
+ for(JsonNode node: value) {
+ result.add(getBaseType().toValue(node));
+ }
+ } else {
+ result.add(getBaseType().toValue(value));
+ }
+ return result;
+ } else {
+ return getBaseType().toValue(value);
+ }
+ }
+
+ @Override
+ public void validate(Object value) {
+ this.baseType.validate(value);
+ }
+
}
public static class KeyValuedColumnType extends ColumnType {
return new KeyValuedColumnType(keyType, valueType);
}
+
+ @Override
+ public Object valueFromJson(JsonNode value) {
+ throw new UnsupportedOperationException("needs to be implemented");
+ }
+
+ @Override
+ public void validate(Object value) {
+ throw new UnsupportedOperationException("not implemented yet");
+ }
}
}
this.setColumns(columns);
return this;
}
+
+// public TableUpdate<GenericTableSchema> updatesFromJson(JsonNode value) {
+// ObjectNode new_ = (ObjectNode) value.get("new");
+// ObjectNode old = (ObjectNode) value.get("new");
+//
+// Row<GenericTableSchema> newRow = createRow(new_);
+// Row<GenericTableSchema> oldRow = createRow(old);
+//
+// TableUpdate<GenericTableSchema> tableUpdate = new TableUpdate<GenericTableSchema>();
+// tableUpdate.setNew(newRow);
+// tableUpdate.setNew(oldRow);
+//
+//
+// return null;
+// }
+//
+// protected Row<GenericTableSchema> createRow(ObjectNode rowNode) {
+// List<Column<GenericTableSchema, ?>> columns = Lists.newArrayList();
+// for (Iterator<Map.Entry<String, JsonNode>> iter = rowNode.fields(); iter.hasNext();) {
+// Map.Entry<String, JsonNode> next = iter.next();
+// ColumnSchema schema = column(next.getKey());
+// Object o = schema.valueFromJson(next.getValue());
+// columns.add(new Column(schema, o));
+// }
+// return new Row<>(columns);
+// }
}
*/
package org.opendaylight.ovsdb.lib.schema;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.google.common.collect.Lists;
+import org.opendaylight.ovsdb.lib.message.TableUpdate;
+import org.opendaylight.ovsdb.lib.notation.Column;
+import org.opendaylight.ovsdb.lib.notation.Row;
import org.opendaylight.ovsdb.lib.operations.Insert;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.lang.reflect.Constructor;
+import java.util.Iterator;
+import java.util.List;
import java.util.Map;
import java.util.Set;
return this.columns.get(column);
}
+
public String getName() {
return name;
}
protected void setColumns(Map<String, ColumnSchema> columns) {
this.columns = columns;
}
+
+ public TableUpdate<E> updatesFromJson(JsonNode value) {
+
+ Map.Entry<String, JsonNode> idOldNew = value.fields().next();
+
+ ObjectNode new_ = (ObjectNode) idOldNew.getValue().get("new");
+ ObjectNode old = (ObjectNode) idOldNew.getValue().get("old");
+
+ Row<E> newRow = new_ != null ? createRow(new_) : null;
+ Row<E> oldRow = old != null ? createRow(old) : null;
+
+ TableUpdate<E> tableUpdate = new TableUpdate<>();
+ tableUpdate.setNew(newRow);
+ tableUpdate.setOld(oldRow);
+
+
+ return tableUpdate;
+ }
+
+ protected Row<E> createRow(ObjectNode rowNode) {
+ List<Column<E, ?>> columns = Lists.newArrayList();
+ for (Iterator<Map.Entry<String, JsonNode>> iter = rowNode.fields(); iter.hasNext();) {
+ Map.Entry<String, JsonNode> next = iter.next();
+ ColumnSchema<E, Object> schema = column(next.getKey(), Object.class);
+ Object o = schema.valueFromJson(next.getValue());
+ columns.add(new Column<>(schema, o));
+ }
+ return new Row<>(columns);
+ }
}
*/
package org.opendaylight.ovsdb.lib;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
+import com.google.common.util.concurrent.ListenableFuture;
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
import java.io.IOException;
import java.util.List;
import java.util.Map;
-import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import org.opendaylight.ovsdb.lib.message.MonitorRequestBuilder;
import org.opendaylight.ovsdb.lib.message.MonitorSelect;
import org.opendaylight.ovsdb.lib.message.OvsdbRPC;
-import org.opendaylight.ovsdb.lib.message.TableUpdate;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.message.UpdateNotification;
-import org.opendaylight.ovsdb.lib.notation.Mutator;
+import org.opendaylight.ovsdb.lib.notation.Column;
+import org.opendaylight.ovsdb.lib.notation.Row;
import org.opendaylight.ovsdb.lib.operations.OperationResult;
import org.opendaylight.ovsdb.lib.schema.ColumnSchema;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Sets;
-import com.google.common.util.concurrent.ListenableFuture;
+import java.util.Set;
public class OvsDBClientTestIT extends OvsdbTestBase {
.add(op.update(bridge)
.set(fail_mode, "secure")
.where(name.opEqual("br-int"))
- .operation())
- .add(op.comment("Updating fail_mode to secure on Bridge br-int"))
+ .build())
.add(op.select(bridge)
.column(name)
.where(name.opEqual("br-int"))
- .operation())
- .add(op.mutate(bridge)
- .addMutation(flood_vlans, Mutator.INSERT, Sets.newHashSet(100, 101, 4001))
- .where(name.opEqual("br-int"))
- .operation())
+ .build())
.add(op.commit(true))
- .add(op.comment("Commiting the operation"))
.execute();
List<OperationResult> operationResults = results.get();
results = ovs.transactBuilder()
.add(op.delete(bridge)
.where(name.opEqual("br-int"))
- .operation())
- .add(op.comment("Deleting Bridge br-int"))
+ .build())
.add(op.commit(true))
- .add(op.comment("Commiting the operation"))
.execute();
operationResults = results.get();
results = ovs.transactBuilder()
.add(op.delete(bridge)
.where(name.opEqual("br-int"))
- .operation())
+ .build())
.add(op.abort())
.execute();
results = ovs.transactBuilder()
.add(op.delete(bridge)
.where(name.opEqual("br-int"))
- .operation())
+ .build())
.add(op.assertion("Assert12345")) // Failing intentionally
.execute();
GenericTableSchema bridge = dbSchema.table("Bridge", GenericTableSchema.class);
List<MonitorRequest<GenericTableSchema>> monitorRequests = Lists.newArrayList();
+ ColumnSchema<GenericTableSchema, Set<Integer>> flood_vlans = bridge.multiValuedColumn("flood_vlans", Integer.class);
+
monitorRequests.add(
MonitorRequestBuilder.builder(bridge)
.addColumn(bridge.column("name"))
.addColumn(bridge.column("fail_mode", String.class))
- .addColumn(bridge.multiValuedColumn("flood_vlans", Integer.class))
+ .addColumn(flood_vlans)
.with(new MonitorSelect(true, true, true, true))
.build());
Assert.assertTrue(!results.isEmpty());
Object result = results.get(0);
Assert.assertTrue(result instanceof TableUpdates);
- TableUpdate bridgeUpdate = ((TableUpdates) result).getUpdate(bridge);
- Assert.assertNotNull(bridgeUpdate);
+ TableUpdates updates = (TableUpdates) result;
+ org.opendaylight.ovsdb.lib.message.TableUpdate<GenericTableSchema> update = updates.getUpdate(bridge);
+ Row<GenericTableSchema> aNew = update.getNew();
+ for (Column<GenericTableSchema, ?> column: aNew.getColumns()) {
+ if (column.getSchema().equals(flood_vlans)) {
+ Set<Integer> data = column.getData(flood_vlans);
+ Assert.assertTrue(!data.isEmpty());
+ }
+ }
}
public void testGetDBs() throws ExecutionException, InterruptedException {
import org.opendaylight.ovsdb.lib.message.UpdateNotification;
import org.opendaylight.ovsdb.lib.operations.OperationResult;
import org.opendaylight.ovsdb.lib.schema.ColumnSchema;
+import org.opendaylight.ovsdb.lib.schema.GenericTableSchema;
import org.opendaylight.ovsdb.lib.schema.TableSchema;
import org.opendaylight.ovsdb.lib.schema.temp.Reference;
import org.slf4j.Logger;
public ColumnSchema<Bridge, Reference> netflow() {
return column("netflow", Reference.class);
}
+
}
public void test() throws IOException, InterruptedException, ExecutionException {
OvsDBClientImpl ovs = getVswitch();
- Bridge bridge = ovs.getSchema(OPEN_VSWITCH_SCHEMA, true).get().table("Bridge", Bridge.class);
+ Bridge bridge = ovs.getSchema("Open_vSwitch", true).get().table("Bridge", Bridge.class);
+ GenericTableSchema anytable = null;
+
+
ListenableFuture<List<OperationResult>> results = ovs.transactBuilder()
.add(op.insert(bridge).value(bridge.name(), "br-int"))
.set(bridge.status(), "br-blah")
.set(bridge.floodVlans(), 34)
.where(bridge.name().opEqual("br-int"))
- .and(bridge.name().opEqual("br-int")).operation())
+ .and(bridge.name().opEqual("br-int")).build())
.execute();
List<OperationResult> operationResults = results.get();
import junit.framework.TestCase;
+import org.opendaylight.ovsdb.lib.message.temp.TableUpdate;
import org.opendaylight.ovsdb.lib.message.temp.TableUpdates;
import org.opendaylight.ovsdb.lib.notation.OvsDBMap;
import org.opendaylight.ovsdb.lib.notation.OvsDBSet;
assertEquals(2, rows.size());
List<TableUpdate.Row<Port>> sorted = Ordering.natural().onResultOf(new Function<TableUpdate.Row<Port>, String>() {
@Override
- public String apply(
org.opendaylight.ovsdb.lib.message.TableUpdate.Row<Port> input) {
+ public String apply(TableUpdate.Row<Port> input) {
return input.getId();
}
}).sortedCopy(rows);
import org.opendaylight.controller.sal.utils.HexEncode;
import org.opendaylight.controller.sal.utils.ServiceHelper;
import org.opendaylight.ovsdb.lib.database.DatabaseSchema;
-import org.opendaylight.ovsdb.lib.message.TableUpdate;
-import org.opendaylight.ovsdb.lib.message.TableUpdate.Row;
+import org.opendaylight.ovsdb.lib.message.temp.TableUpdate;
+import org.opendaylight.ovsdb.lib.message.temp.TableUpdate.Row;
import org.opendaylight.ovsdb.lib.message.temp.TableUpdates;
import org.opendaylight.ovsdb.lib.notation.OvsDBSet;
import org.opendaylight.ovsdb.lib.table.Bridge;
Code Review / ovsdb.git / commitdiff