2 * Copyright (C) 2014 EBay Software Foundation
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
8 * Authors : Ashwin Raveendran
10 package org.opendaylight.ovsdb;
12 import com.fasterxml.jackson.annotation.JsonIgnore;
13 import com.fasterxml.jackson.databind.JsonNode;
14 import com.google.common.collect.Lists;
15 import com.google.common.collect.Maps;
16 import com.google.common.util.concurrent.ListenableFuture;
17 import org.opendaylight.ovsdb.lib.message.OvsdbRPC;
18 import org.opendaylight.ovsdb.lib.message.TransactBuilder;
19 import org.opendaylight.ovsdb.lib.message.operations.ConditionalOperation;
20 import org.opendaylight.ovsdb.lib.message.operations.Operation;
21 import org.opendaylight.ovsdb.lib.message.operations.OperationResult;
22 import org.opendaylight.ovsdb.lib.meta.ColumnSchema;
23 import org.opendaylight.ovsdb.lib.meta.DatabaseSchema;
24 import org.opendaylight.ovsdb.lib.meta.TableSchema;
25 import org.opendaylight.ovsdb.lib.notation.Condition;
26 import org.opendaylight.ovsdb.lib.notation.Function;
28 import java.util.ArrayList;
29 import java.util.List;
31 import java.util.Queue;
32 import java.util.concurrent.ExecutorService;
35 public class OpenVswitch {
37 ExecutorService executorService;
40 volatile DatabaseSchema schema;
41 Queue<Throwable> exceptions;
43 public OpenVswitch(OvsdbRPC rpc, ExecutorService executorService) {
45 this.executorService = executorService;
48 public OpenVswitch() {
52 public void populateSchemaFromDevice() {
53 final ListenableFuture<JsonNode> fOfSchema = rpc.get_schema(Lists.newArrayList(DatabaseSchema.OPEN_VSWITCH_SCHEMA_NAME));
54 fOfSchema.addListener(new Runnable() {
58 JsonNode jsonNode = fOfSchema.get();
59 schema = DatabaseSchema.fromJson(jsonNode);
61 } catch (Exception e) {
68 public Transaction transact(){
69 return new Transaction(this);
72 public ListenableFuture<List<OperationResult>> transact(List<Operation> operations) {
74 //todo, we may not need transactionbuilder if we can have JSON objects
75 TransactBuilder builder = new TransactBuilder();
76 for (Operation o : operations) {
77 builder.addOperation(o);
80 ListenableFuture<List<OperationResult>> transact = rpc.transact(builder);
84 public boolean isReady(long timeout) {
85 //todo implement timeout
86 return null != schema;
89 public DatabaseSchema schema() {
94 public static class Transaction {
96 private DatabaseSchema eDatabaseSchema;
98 ArrayList<Operation> operations = Lists.newArrayList();
100 public Transaction(OpenVswitch ovs) {
104 public Transaction(DatabaseSchema eDatabaseSchema) {
105 this.eDatabaseSchema = eDatabaseSchema;
108 public Transaction add(Operation operation) {
109 operations.add(operation);
113 public List<Operation> build() {
117 public ListenableFuture<List<OperationResult>> execute() {
118 return ovs.transact(operations);
122 public static class Update<E extends TableSchema<E>> extends Operation<E> implements ConditionalOperation {
124 Map<String, Object> row = Maps.newHashMap();
127 List<Condition> where = Lists.newArrayList();
129 private String uuidName;
131 public Update(TableSchema<E> schema) {
132 super(schema, "update");
135 public Update<E> on(TableSchema schema){
139 public <T extends TableSchema<T>, D> Update<E> set(ColumnSchema<T, D> columnSchema, D value) {
140 columnSchema.validate(value);
141 this.row.put(columnSchema.getName(), value);
145 public Where where(Condition condition) {
146 return new Where(this);
149 public String getUuid() {
153 public void setUuid(String uuid) {
157 public String getUuidName() {
161 public void setUuidName(String uuidName) {
162 this.uuidName = uuidName;
165 public Map<String, Object> getRow() {
169 public void setRow(Map<String, Object> row) {
174 public void addCondition(Condition condition) {
175 this.where.add(condition);
178 public List<Condition> getWhere() {
182 public void setWhere(List<Condition> where) {
188 public static class Where {
191 ConditionalOperation operation;
193 public Where() { } public Where(ConditionalOperation operation) {
194 this.operation = operation;
197 public Where condition(Condition condition) {
198 operation.addCondition(condition);
202 public Where condition(ColumnSchema column, Function function, Object value) {
203 this.condition(new Condition(column.getName(), function, value));
207 public Where and(ColumnSchema column, Function function, Object value) {
208 condition(column, function, value);
212 public Where and(Condition condition) {
213 condition(condition);
217 public Operation operation() {
218 return (Operation) this.operation;
224 public static class Operations {
225 public static Operations op = new Operations();
227 public <E extends TableSchema<E>> Insert<E> insert(TableSchema<E> schema) {
228 return new Insert<>(schema);
231 public <E extends TableSchema<E>> Update<E> update(TableSchema<E> schema) {
232 return new Update<>(schema);
236 public ExecutorService getExecutorService() {
237 return executorService;
240 public void setExecutorService(ExecutorService executorService) {
241 this.executorService = executorService;
244 public String getSchemaName() {
248 public void setSchemaName(String schemaName) {
249 this.schemaName = schemaName;
252 public OvsdbRPC getRpc() {
256 public void setRpc(OvsdbRPC rpc) {
260 public DatabaseSchema getSchema() {
264 public void setSchema(DatabaseSchema schema) {
265 this.schema = schema;
268 public Queue<Throwable> getExceptions() {
272 public void setExceptions(Queue<Throwable> exceptions) {
273 this.exceptions = exceptions;