홍길동 / onos

Go to a project
Toggle navigation Toggle navigation pinning
lishuai
Committed by Gerrit Code Review
fa7013da 1 parent a6d787bf

[ONOS-2563]Optimize RFC 7047's code. 

Change-Id: I000f2b802420e4f47ce320f6ed021049bd2fd83e
Inline Side-by-side
Showing 23 changed files with 1765 additions and 2052 deletions
......@@ -16,25 +16,25 @@
package org.onosproject.ovsdb.rfc.error;
/**
* AbnormalSchema exception is thrown when the received schema is invalid.
* AbnormalJsonNodeException exception is thrown when the received JsonNode is invalid.
*/
public class AbnormalSchemaException extends RuntimeException {
public class AbnormalJsonNodeException extends RuntimeException {
private static final long serialVersionUID = 8328377718334680368L;
/**
* Constructs a AbnormalSchemaException object.
* Constructs a AbnormalJsonNodeException object.
* @param message error message
*/
public AbnormalSchemaException(String message) {
public AbnormalJsonNodeException(String message) {
super(message);
}
/**
* Constructs a AbnormalSchemaException object.
* Constructs a AbnormalJsonNodeException object.
* @param message error message
* @param cause Throwable
*/
public AbnormalSchemaException(String message, Throwable cause) {
public AbnormalJsonNodeException(String message, Throwable cause) {
super(message, cause);
}
......
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.ovsdb.rfc.error;
/**
* This exception is thrown when the argument is not supported.
*/
public class ArgumentException extends RuntimeException {
private static final long serialVersionUID = 4950089877540156797L;
/**
* Constructs a ArgumentException object.
* @param message error message
*/
public ArgumentException(String message) {
super(message);
}
/**
* Constructs a ArgumentException object.
* @param message error message
* @param cause Throwable
*/
public ArgumentException(String message, Throwable cause) {
super(message, cause);
}
}
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.ovsdb.rfc.error;
/**
* The JsonParsingException is thrown when JSON could not be successfully
* parsed.
*/
public class JsonParsingException extends RuntimeException {
private static final long serialVersionUID = 1424752181911923235L;
/**
* Constructs a JsonParsingException object.
* @param message error message
*/
public JsonParsingException(String message) {
super(message);
}
/**
* Constructs a JsonParsingException object.
* @param message error message
* @param cause Throwable
*/
public JsonParsingException(String message, Throwable cause) {
super(message, cause);
}
/**
* Constructs a JsonParsingException object.
* @param cause Throwable
*/
public JsonParsingException(Throwable cause) {
super(cause);
}
/**
* Constructs a JsonParsingException object.
* @param message error message
* @param cause Throwable
* @param enableSuppression enable Suppression
* @param writableStackTrace writable StackTrace
*/
public JsonParsingException(String message, Throwable cause,
boolean enableSuppression,
boolean writableStackTrace) {
super(message, cause, enableSuppression, writableStackTrace);
}
}
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.ovsdb.rfc.error;
/**
* This is a generic exception thrown by the Typed Schema utilities.
*/
public class TypedSchemaException extends RuntimeException {
private static final long serialVersionUID = -1452257990783176715L;
/**
* Constructs a TypedSchemaException object.
* @param message error message
*/
public TypedSchemaException(String message) {
super(message);
}
/**
* Constructs a TypedSchemaException object.
* @param message error message
* @param cause Throwable
*/
public TypedSchemaException(String message, Throwable cause) {
super(message, cause);
}
}
package org.onosproject.ovsdb.rfc.error;
/**
* This exception is thrown when the encoding does not meet UTF-8 in RFC7047.
*/
public class UnsupportedEncodingException extends RuntimeException {
private static final long serialVersionUID = -4865311369828520666L;
/**
* Constructs a UnsupportedEncodingException object.
* @param message error message
*/
public UnsupportedEncodingException(String message) {
super(message);
}
}
......@@ -16,26 +16,26 @@
package org.onosproject.ovsdb.rfc.error;
/**
* This exception is thrown when a result does not meet any of the known formats
* in RFC7047.
* This exception is thrown when the caller invoke the unsupported method or
* use the encoding is not supported.
*/
public class UnknownResultException extends RuntimeException {
public class UnsupportedException extends RuntimeException {
private static final long serialVersionUID = 1377011546616825375L;
/**
* Constructs a UnknownResultException object.
* Constructs a UnsupportedException object.
* @param message error message
*/
public UnknownResultException(String message) {
public UnsupportedException(String message) {
super(message);
}
/**
* Constructs a UnknownResultException object.
* Constructs a UnsupportedException object.
* @param message error message
* @param cause Throwable
*/
public UnknownResultException(String message, Throwable cause) {
public UnsupportedException(String message, Throwable cause) {
super(message, cause);
}
}
......
......@@ -15,7 +15,6 @@
*/
package org.onosproject.ovsdb.rfc.error;
import static com.google.common.base.MoreObjects.toStringHelper;
/**
* This exception is used when the a table or row is accessed though a typed
......@@ -47,15 +46,9 @@ public class VersionMismatchException extends RuntimeException {
* @param fromVersion the initial version
* @return message
*/
public static String createFromMessage(String actualVersion,
String fromVersion) {
String message = toStringHelper("VersionMismatchException")
.addValue("The fromVersion should less than the actualVersion.\n"
+ "fromVersion: "
+ fromVersion
+ ".\n"
+ "actualVersion: " + actualVersion)
.toString();
public static String createFromMessage(String actualVersion, String fromVersion) {
String message = "The fromVersion should less than the actualVersion.\n fromVersion: "
+ fromVersion + ".\n" + "actualVersion: " + actualVersion;
return message;
}
......@@ -66,13 +59,8 @@ public class VersionMismatchException extends RuntimeException {
* @return message
*/
public static String createToMessage(String actualVersion, String toVersion) {
String message = toStringHelper("VersionMismatchException")
.addValue("The toVersion should greater than the required version.\n"
+ "toVersion: "
+ toVersion
+ ".\n"
+ "Actual Version: " + actualVersion)
.toString();
String message = "The toVersion should greater than the actualVersion.\n"
+ "toVersion: " + toVersion + ".\n" + " actualVersion: " + actualVersion;
return message;
}
}
......
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.ovsdb.rfc.message;
import static com.google.common.base.MoreObjects.toStringHelper;
import static com.google.common.base.Preconditions.checkNotNull;
import java.util.Objects;
import org.onosproject.ovsdb.rfc.notation.json.UpdateNotificationConverter;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
/**
* The "update" notification is sent by the server to the client to report
* changes in tables that are being monitored following a "monitor" request. The
* "params" of the result JsonNode.
*/
@JsonDeserialize(converter = UpdateNotificationConverter.class)
public final class UpdateNotification {
private final Object context;
private final JsonNode tbUpdatesJsonNode;
/**
* Constructs a UpdateNotification object.
* @param context the "json-value" in "params" of the result JsonNode
* @param tbUpdatesJsonNode the "table-updates" in "params" of the result JsonNode
*/
public UpdateNotification(Object context, JsonNode tbUpdatesJsonNode) {
checkNotNull(context, "context cannot be null");
checkNotNull(tbUpdatesJsonNode, "tablebUpdates JsonNode cannot be null");
this.context = context;
this.tbUpdatesJsonNode = tbUpdatesJsonNode;
}
/**
* Return context.
* @return context
*/
public Object context() {
return context;
}
/**
* Return tbUpdatesJsonNode.
* @return tbUpdatesJsonNode
*/
public JsonNode tbUpdatesJsonNode() {
return tbUpdatesJsonNode;
}
@Override
public int hashCode() {
return Objects.hash(context, tbUpdatesJsonNode);
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj instanceof UpdateNotification) {
final UpdateNotification other = (UpdateNotification) obj;
return Objects.equals(this.context, other.context)
&& Objects.equals(this.tbUpdatesJsonNode,
other.tbUpdatesJsonNode);
}
return false;
}
@Override
public String toString() {
return toStringHelper(this).add("context", context)
.add("tbUpdatesJsonNode", tbUpdatesJsonNode).toString();
}
}
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.ovsdb.rfc.message;
import static com.google.common.base.MoreObjects.toStringHelper;
import static com.google.common.base.Preconditions.checkNotNull;
import java.util.Objects;
import org.onosproject.ovsdb.rfc.notation.json.UpdateNotificationConverter;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
/**
* The "update" notification is sent by the server to the client to report
* changes in tables that are being monitored following a "monitor" request. The
* "params" of the result JsonNode.
*/
@JsonDeserialize(converter = UpdateNotificationConverter.class)
public final class UpdateNotification {
private final Object jsonValue;
private final JsonNode tbUpdatesJsonNode;
/**
* Constructs a UpdateNotification object.
* @param jsonValue the "json-value" in "params" of the result JsonNode
* @param tbUpdatesJsonNode the "table-updates" in "params" of the result JsonNode
*/
public UpdateNotification(Object jsonValue, JsonNode tbUpdatesJsonNode) {
checkNotNull(jsonValue, "jsonValue cannot be null");
checkNotNull(tbUpdatesJsonNode, "tablebUpdates JsonNode cannot be null");
this.jsonValue = jsonValue;
this.tbUpdatesJsonNode = tbUpdatesJsonNode;
}
/**
* Return context.
* @return context
*/
public Object jsonValue() {
return jsonValue;
}
/**
* Return tbUpdatesJsonNode.
* @return tbUpdatesJsonNode
*/
public JsonNode tbUpdatesJsonNode() {
return tbUpdatesJsonNode;
}
@Override
public int hashCode() {
return Objects.hash(jsonValue, tbUpdatesJsonNode);
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj instanceof UpdateNotification) {
final UpdateNotification other = (UpdateNotification) obj;
return Objects.equals(this.jsonValue, other.jsonValue)
&& Objects.equals(this.tbUpdatesJsonNode,
other.tbUpdatesJsonNode);
}
return false;
}
@Override
public String toString() {
return toStringHelper(this).add("jsonValue", jsonValue)
.add("tbUpdatesJsonNode", tbUpdatesJsonNode).toString();
}
}
......
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.ovsdb.rfc.notation;
import static com.google.common.base.MoreObjects.toStringHelper;
import static com.google.common.base.Preconditions.checkNotNull;
import java.util.Objects;
import org.onosproject.ovsdb.rfc.schema.ColumnSchema;
import com.fasterxml.jackson.annotation.JsonIgnore;
/**
* Column is the basic element of the OpenVswitch database.
*/
public final class Column {
@JsonIgnore
private final ColumnSchema schema;
private final Object data;
/**
* Column constructor.
* @param schema the column schema
* @param obj the data of the column
*/
public Column(ColumnSchema schema, Object obj) {
checkNotNull(schema, "schema cannot be null");
checkNotNull(obj, "data cannot be null");
this.schema = schema;
this.data = obj;
}
/**
* Returns column data.
* @return column data
*/
public Object data() {
return data;
}
/**
* Returns ColumnSchema.
* @return ColumnSchema
*/
public ColumnSchema schema() {
return schema;
}
@Override
public int hashCode() {
return Objects.hash(schema, data);
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj instanceof Column) {
final Column other = (Column) obj;
return Objects.equals(this.schema, other.schema)
&& Objects.equals(this.data, other.data);
}
return false;
}
@Override
public String toString() {
return toStringHelper(this).add("schema", schema).add("data", data)
.toString();
}
}
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.ovsdb.rfc.notation;
import static com.google.common.base.MoreObjects.toStringHelper;
import static com.google.common.base.Preconditions.checkNotNull;
import java.util.Objects;
/**
* Column is the basic element of the OpenVswitch database.
*/
public final class Column {
private final String columnName;
private final Object data;
/**
* Column constructor.
* @param columnName the column name
* @param obj the data of the column
*/
public Column(String columnName, Object obj) {
checkNotNull(columnName, "columnName cannot be null");
checkNotNull(obj, "data cannot be null");
this.columnName = columnName;
this.data = obj;
}
/**
* Returns column data.
* @return column data
*/
public Object data() {
return data;
}
/**
* Returns columnName.
* @return columnName
*/
public String columnName() {
return columnName;
}
@Override
public int hashCode() {
return Objects.hash(columnName, data);
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj instanceof Column) {
final Column other = (Column) obj;
return Objects.equals(this.columnName, other.columnName)
&& Objects.equals(this.data, other.data);
}
return false;
}
@Override
public String toString() {
return toStringHelper(this).add("columnName", columnName)
.add("data", data).toString();
}
}
......
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.ovsdb.rfc.notation;
import static com.google.common.base.MoreObjects.toStringHelper;
import static com.google.common.base.Preconditions.checkNotNull;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import org.onosproject.ovsdb.rfc.schema.ColumnSchema;
import org.onosproject.ovsdb.rfc.schema.TableSchema;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.google.common.collect.Maps;
/**
* Row is the basic element of the OpenVswitch's table.
*/
public final class Row {
@JsonIgnore
private TableSchema tableSchema;
private Map<String, Column> columns;
/**
* Row constructor.
*/
public Row() {
this.columns = Maps.newHashMap();
}
/**
* Row constructor.
* @param tableSchema TableSchema entity
*/
public Row(TableSchema tableSchema) {
checkNotNull(tableSchema, "tableSchema cannot be null");
this.tableSchema = tableSchema;
this.columns = Maps.newHashMap();
}
/**
* Row constructor.
* @param tableSchema TableSchema entity
* @param columns List of Column entity
*/
public Row(TableSchema tableSchema, List<Column> columns) {
checkNotNull(tableSchema, "tableSchema cannot be null");
checkNotNull(columns, "columns cannot be null");
this.tableSchema = tableSchema;
this.columns = Maps.newHashMap();
for (Column column : columns) {
this.columns.put(column.schema().name(), column);
}
}
/**
* Returns tableSchema.
* @return tableSchema
*/
public TableSchema getTableSchema() {
return tableSchema;
}
/**
* Set tableSchema value.
* @param tableSchema TableSchema entity
*/
public void setTableSchema(TableSchema tableSchema) {
this.tableSchema = tableSchema;
}
/**
* Returns Column by ColumnSchema.
* @param schema ColumnSchema entity
* @return Column
*/
public Column getColumn(ColumnSchema schema) {
return (Column) columns.get(schema.name());
}
/**
* Returns Collection of Column.
* @return Collection of Column
*/
public Collection<Column> getColumns() {
return columns.values();
}
/**
* add Column.
* @param columnName column name
* @param data Column entity
*/
public void addColumn(String columnName, Column data) {
this.columns.put(columnName, data);
}
@Override
public int hashCode() {
return Objects.hash(tableSchema, columns);
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj instanceof Row) {
final Row other = (Row) obj;
return Objects.equals(this.tableSchema, other.tableSchema)
&& Objects.equals(this.columns, other.columns);
}
return false;
}
@Override
public String toString() {
return toStringHelper(this).add("tableSchema", tableSchema).add("columns", columns).toString();
}
}
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.ovsdb.rfc.notation;
import static com.google.common.base.MoreObjects.toStringHelper;
import static com.google.common.base.Preconditions.checkNotNull;
import java.util.Collection;
import java.util.Map;
import java.util.Objects;
import com.google.common.collect.Maps;
/**
* Row is the basic element of the OpenVswitch's table.
*/
public final class Row {
private String tableName;
private Map<String, Column> columns;
/**
* Row constructor.
*/
public Row() {
this.columns = Maps.newHashMap();
}
/**
* Row constructor.
* @param tableName table name
*/
public Row(String tableName) {
checkNotNull(tableName, "tableName cannot be null");
this.tableName = tableName;
this.columns = Maps.newHashMap();
}
/**
* Row constructor.
* @param tableName table name
* @param columns Map of Column entity
*/
public Row(String tableName, Map<String, Column> columns) {
checkNotNull(tableName, "table name cannot be null");
checkNotNull(columns, "columns cannot be null");
this.tableName = tableName;
this.columns = columns;
}
/**
* Returns tableName.
* @return tableName
*/
public String tableName() {
return tableName;
}
/**
* Set tableName value.
* @param tableName table name
*/
public void setTableName(String tableName) {
this.tableName = tableName;
}
/**
* Returns Column by ColumnSchema.
* @param columnName column name
* @return Column
*/
public Column getColumn(String columnName) {
return columns.get(columnName);
}
/**
* Returns Collection of Column.
* @return Collection of Column
*/
public Collection<Column> getColumns() {
return columns.values();
}
/**
* add Column.
* @param columnName column name
* @param data Column entity
*/
public void addColumn(String columnName, Column data) {
this.columns.put(columnName, data);
}
@Override
public int hashCode() {
return Objects.hash(tableName, columns);
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj instanceof Row) {
final Row other = (Row) obj;
return Objects.equals(this.tableName, other.tableName)
&& Objects.equals(this.columns, other.columns);
}
return false;
}
@Override
public String toString() {
return toStringHelper(this).add("tableName", tableName)
.add("columns", columns).toString();
}
}
......
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.ovsdb.rfc.operations;
import static com.google.common.base.Preconditions.checkNotNull;
import java.util.List;
import org.onosproject.ovsdb.rfc.notation.Condition;
import org.onosproject.ovsdb.rfc.schema.TableSchema;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
/**
* delete operation.Refer to RFC 7047 Section 5.2.
*/
public final class Delete implements Operation {
@JsonIgnore
private final TableSchema tableSchema;
private final String op;
private final List<Condition> where;
/**
* Constructs a Delete object.
* @param schema TableSchema entity
* @param where the List of Condition entity
*/
public Delete(TableSchema schema, List<Condition> where) {
checkNotNull(schema, "TableSchema cannot be null");
checkNotNull(where, "where is not null");
this.tableSchema = schema;
this.op = Operations.DELETE.op();
this.where = where;
}
/**
* Returns the where member of delete operation.
* @return the where member of delete operation
*/
public List<Condition> getWhere() {
return where;
}
@Override
public String getOp() {
return op;
}
@Override
public TableSchema getTableSchema() {
return tableSchema;
}
/**
* For the use of serialization.
* @return the table member of update operation
*/
@JsonProperty
public String getTable() {
return (tableSchema == null) ? null : tableSchema.name();
}
}
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.ovsdb.rfc.operations;
import static com.google.common.base.Preconditions.checkNotNull;
import java.util.List;
import org.onosproject.ovsdb.rfc.notation.Condition;
import org.onosproject.ovsdb.rfc.schema.TableSchema;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
/**
* delete operation.Refer to RFC 7047 Section 5.2.
*/
public final class Delete implements Operation {
@JsonIgnore
private final TableSchema tableSchema;
private final String op;
private final List<Condition> where;
/**
* Constructs a Delete object.
* @param schema TableSchema entity
* @param where the List of Condition entity
*/
public Delete(TableSchema schema, List<Condition> where) {
checkNotNull(schema, "TableSchema cannot be null");
checkNotNull(where, "where is not null");
this.tableSchema = schema;
this.op = Operations.DELETE.op();
this.where = where;
}
/**
* Returns the where member of delete operation.
* @return the where member of delete operation
*/
public List<Condition> getWhere() {
return where;
}
@Override
public String getOp() {
return op;
}
@Override
public TableSchema getTableSchema() {
return tableSchema;
}
/**
* For the use of serialization.
* @return the table member of update operation
*/
@JsonProperty
public String getTable() {
return tableSchema.name();
}
}
......
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.ovsdb.rfc.operations;
import static com.google.common.base.Preconditions.checkNotNull;
import java.util.Collection;
import java.util.Map;
import org.onosproject.ovsdb.rfc.notation.Column;
import org.onosproject.ovsdb.rfc.notation.Row;
import org.onosproject.ovsdb.rfc.schema.ColumnSchema;
import org.onosproject.ovsdb.rfc.schema.TableSchema;
import org.onosproject.ovsdb.rfc.utils.TransValueUtil;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.google.common.collect.Maps;
/**
* insert operation.Refer to RFC 7047 Section 5.2.
*/
public final class Insert implements Operation {
@JsonIgnore
private final TableSchema tableSchema;
private final String op;
@JsonProperty("uuid-name")
private final String uuidName;
private final Map<String, Object> row;
/**
* Constructs a Insert object.
* @param schema TableSchema entity
* @param uuidName uuid-name
* @param row Row entity
*/
public Insert(TableSchema schema, String uuidName, Row row) {
checkNotNull(schema, "TableSchema cannot be null");
checkNotNull(uuidName, "uuid name cannot be null");
checkNotNull(row, "row cannot be null");
this.tableSchema = schema;
this.op = Operations.INSERT.op();
this.uuidName = uuidName;
this.row = Maps.newHashMap();
generateOperationRow(row);
}
/**
* Row entity convert into the row format of insert operation. Refer to RFC
* 7047 Section 5.2.
* @param row Row entity
*/
private void generateOperationRow(Row row) {
Collection<Column> columns = row.getColumns();
for (Column column : columns) {
ColumnSchema columnSchema = column.schema();
Object value = column.data();
Object untypedValue = TransValueUtil.getFormatData(value);
this.row.put(columnSchema.name(), untypedValue);
}
}
/**
* Returns the uuid-name member of insert operation.
* @return the uuid-name member of insert operation
*/
public String getUuidName() {
return uuidName;
}
/**
* Returns the row member of insert operation.
* @return the row member of insert operation
*/
public Map<String, Object> getRow() {
return row;
}
@Override
public String getOp() {
return op;
}
@Override
public TableSchema getTableSchema() {
return tableSchema;
}
/**
* For the use of serialization.
* @return the table member of update operation
*/
@JsonProperty
public String getTable() {
return (tableSchema == null) ? null : tableSchema.name();
}
}
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.ovsdb.rfc.operations;
import static com.google.common.base.Preconditions.checkNotNull;
import java.util.Collection;
import java.util.Map;
import org.onosproject.ovsdb.rfc.notation.Column;
import org.onosproject.ovsdb.rfc.notation.Row;
import org.onosproject.ovsdb.rfc.schema.TableSchema;
import org.onosproject.ovsdb.rfc.utils.TransValueUtil;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.google.common.collect.Maps;
/**
* insert operation.Refer to RFC 7047 Section 5.2.
*/
public final class Insert implements Operation {
@JsonIgnore
private final TableSchema tableSchema;
private final String op;
@JsonProperty("uuid-name")
private final String uuidName;
private final Map<String, Object> row;
/**
* Constructs a Insert object.
* @param schema TableSchema entity
* @param uuidName uuid-name
* @param row Row entity
*/
public Insert(TableSchema schema, String uuidName, Row row) {
checkNotNull(schema, "TableSchema cannot be null");
checkNotNull(uuidName, "uuid name cannot be null");
checkNotNull(row, "row cannot be null");
this.tableSchema = schema;
this.op = Operations.INSERT.op();
this.uuidName = uuidName;
this.row = Maps.newHashMap();
generateOperationRow(row);
}
/**
* Row entity convert into the row format of insert operation. Refer to RFC
* 7047 Section 5.2.
* @param row Row entity
*/
private void generateOperationRow(Row row) {
Collection<Column> columns = row.getColumns();
for (Column column : columns) {
String columnName = column.columnName();
Object value = column.data();
Object formatValue = TransValueUtil.getFormatData(value);
this.row.put(columnName, formatValue);
}
}
/**
* Returns the uuid-name member of insert operation.
* @return the uuid-name member of insert operation
*/
public String getUuidName() {
return uuidName;
}
/**
* Returns the row member of insert operation.
* @return the row member of insert operation
*/
public Map<String, Object> getRow() {
return row;
}
@Override
public String getOp() {
return op;
}
@Override
public TableSchema getTableSchema() {
return tableSchema;
}
/**
* For the use of serialization.
* @return the table member of update operation
*/
@JsonProperty
public String getTable() {
return tableSchema.name();
}
}
......
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.ovsdb.rfc.operations;
import static com.google.common.base.Preconditions.checkNotNull;
import java.util.List;
import org.onosproject.ovsdb.rfc.notation.Condition;
import org.onosproject.ovsdb.rfc.notation.Mutation;
import org.onosproject.ovsdb.rfc.schema.TableSchema;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
/**
* mutate operation.Refer to RFC 7047 Section 5.2.
*/
public final class Mutate implements Operation {
@JsonIgnore
private final TableSchema tableSchema;
private final String op;
private final List<Condition> where;
private final List<Mutation> mutations;
/**
* Constructs a Mutate object.
* @param schema TableSchema entity
* @param where the List of Condition entity
* @param mutations the List of Mutation entity
*/
public Mutate(TableSchema schema, List<Condition> where,
List<Mutation> mutations) {
checkNotNull(schema, "TableSchema cannot be null");
checkNotNull(mutations, "mutations cannot be null");
checkNotNull(where, "where cannot be null");
this.tableSchema = schema;
this.op = Operations.MUTATE.op();
this.where = where;
this.mutations = mutations;
}
/**
* Returns the mutations member of mutate operation.
* @return the mutations member of mutate operation
*/
public List<Mutation> getMutations() {
return mutations;
}
/**
* Returns the where member of mutate operation.
* @return the where member of mutate operation
*/
public List<Condition> getWhere() {
return where;
}
@Override
public String getOp() {
return op;
}
@Override
public TableSchema getTableSchema() {
return tableSchema;
}
/**
* For the use of serialization.
* @return the table member of update operation
*/
@JsonProperty
public String getTable() {
return (tableSchema == null) ? null : tableSchema.name();
}
}
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.ovsdb.rfc.operations;
import static com.google.common.base.Preconditions.checkNotNull;
import java.util.List;
import org.onosproject.ovsdb.rfc.notation.Condition;
import org.onosproject.ovsdb.rfc.notation.Mutation;
import org.onosproject.ovsdb.rfc.schema.TableSchema;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
/**
* mutate operation.Refer to RFC 7047 Section 5.2.
*/
public final class Mutate implements Operation {
@JsonIgnore
private final TableSchema tableSchema;
private final String op;
private final List<Condition> where;
private final List<Mutation> mutations;
/**
* Constructs a Mutate object.
* @param schema TableSchema entity
* @param where the List of Condition entity
* @param mutations the List of Mutation entity
*/
public Mutate(TableSchema schema, List<Condition> where,
List<Mutation> mutations) {
checkNotNull(schema, "TableSchema cannot be null");
checkNotNull(mutations, "mutations cannot be null");
checkNotNull(where, "where cannot be null");
this.tableSchema = schema;
this.op = Operations.MUTATE.op();
this.where = where;
this.mutations = mutations;
}
/**
* Returns the mutations member of mutate operation.
* @return the mutations member of mutate operation
*/
public List<Mutation> getMutations() {
return mutations;
}
/**
* Returns the where member of mutate operation.
* @return the where member of mutate operation
*/
public List<Condition> getWhere() {
return where;
}
@Override
public String getOp() {
return op;
}
@Override
public TableSchema getTableSchema() {
return tableSchema;
}
/**
* For the use of serialization.
* @return the table member of update operation
*/
@JsonProperty
public String getTable() {
return tableSchema.name();
}
}
......
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.ovsdb.rfc.operations;
import static com.google.common.base.Preconditions.checkNotNull;
import java.util.List;
import org.onosproject.ovsdb.rfc.notation.Condition;
import org.onosproject.ovsdb.rfc.schema.TableSchema;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
/**
* select operation.Refer to RFC 7047 Section 5.2.
*/
public final class Select implements Operation {
@JsonIgnore
private final TableSchema tableSchema;
private final String op;
private final List<Condition> where;
private final List<String> columns;
/**
* Constructs a Select object.
* @param schema TableSchema entity
* @param where the List of Condition entity
* @param columns the List of column name
*/
public Select(TableSchema schema, List<Condition> where, List<String> columns) {
checkNotNull(schema, "TableSchema cannot be null");
checkNotNull(where, "where cannot be null");
checkNotNull(columns, "columns cannot be null");
this.tableSchema = schema;
this.op = Operations.SELECT.op();
this.where = where;
this.columns = columns;
}
/**
* Returns the columns member of select operation.
* @return the columns member of select operation
*/
public List<String> getColumns() {
return columns;
}
/**
* Returns the where member of select operation.
* @return the where member of select operation
*/
public List<Condition> getWhere() {
return where;
}
@Override
public String getOp() {
return op;
}
@Override
public TableSchema getTableSchema() {
return tableSchema;
}
/**
* For the use of serialization.
* @return the table member of update operation
*/
@JsonProperty
public String getTable() {
return (tableSchema == null) ? null : tableSchema.name();
}
}
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.ovsdb.rfc.operations;
import static com.google.common.base.Preconditions.checkNotNull;
import java.util.List;
import org.onosproject.ovsdb.rfc.notation.Condition;
import org.onosproject.ovsdb.rfc.schema.TableSchema;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
/**
* select operation.Refer to RFC 7047 Section 5.2.
*/
public final class Select implements Operation {
@JsonIgnore
private final TableSchema tableSchema;
private final String op;
private final List<Condition> where;
private final List<String> columns;
/**
* Constructs a Select object.
* @param schema TableSchema entity
* @param where the List of Condition entity
* @param columns the List of column name
*/
public Select(TableSchema schema, List<Condition> where, List<String> columns) {
checkNotNull(schema, "TableSchema cannot be null");
checkNotNull(where, "where cannot be null");
checkNotNull(columns, "columns cannot be null");
this.tableSchema = schema;
this.op = Operations.SELECT.op();
this.where = where;
this.columns = columns;
}
/**
* Returns the columns member of select operation.
* @return the columns member of select operation
*/
public List<String> getColumns() {
return columns;
}
/**
* Returns the where member of select operation.
* @return the where member of select operation
*/
public List<Condition> getWhere() {
return where;
}
@Override
public String getOp() {
return op;
}
@Override
public TableSchema getTableSchema() {
return tableSchema;
}
/**
* For the use of serialization.
* @return the table member of update operation
*/
@JsonProperty
public String getTable() {
return tableSchema.name();
}
}
......
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.ovsdb.rfc.operations;
import static com.google.common.base.Preconditions.checkNotNull;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import org.onosproject.ovsdb.rfc.notation.Column;
import org.onosproject.ovsdb.rfc.notation.Condition;
import org.onosproject.ovsdb.rfc.notation.Row;
import org.onosproject.ovsdb.rfc.schema.ColumnSchema;
import org.onosproject.ovsdb.rfc.schema.TableSchema;
import org.onosproject.ovsdb.rfc.utils.TransValueUtil;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.google.common.collect.Maps;
/**
* update operation.Refer to RFC 7047 Section 5.2.
*/
public final class Update implements Operation {
@JsonIgnore
private final TableSchema tableSchema;
private final String op;
private final Map<String, Object> row;
private final List<Condition> where;
/**
* Constructs a Update object.
* @param schema TableSchema entity
* @param row Row entity
* @param where the List of Condition entity
*/
public Update(TableSchema schema, Row row, List<Condition> where) {
checkNotNull(schema, "TableSchema cannot be null");
checkNotNull(row, "row cannot be null");
checkNotNull(where, "where cannot be null");
this.tableSchema = schema;
this.op = Operations.UPDATE.op();
this.row = Maps.newHashMap();
this.where = where;
generateOperationRow(row);
}
/**
* Row entity convert into the row format of update operation. Refer to RFC
* 7047 Section 5.2.
* @param row Row entity
*/
private void generateOperationRow(Row row) {
Collection<Column> columns = row.getColumns();
for (Column column : columns) {
ColumnSchema columnSchema = column.schema();
Object value = column.data();
Object untypedValue = TransValueUtil.getFormatData(value);
this.row.put(columnSchema.name(), untypedValue);
}
}
/**
* Returns the row member of update operation.
* @return the row member of update operation
*/
public Map<String, Object> getRow() {
return row;
}
/**
* Returns the where member of update operation.
* @return the where member of update operation
*/
public List<Condition> getWhere() {
return where;
}
@Override
public String getOp() {
return op;
}
@Override
public TableSchema getTableSchema() {
return tableSchema;
}
/**
* For the use of serialization.
* @return the table member of update operation
*/
@JsonProperty
public String getTable() {
return (tableSchema == null) ? null : tableSchema.name();
}
}
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.ovsdb.rfc.operations;
import static com.google.common.base.Preconditions.checkNotNull;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import org.onosproject.ovsdb.rfc.notation.Column;
import org.onosproject.ovsdb.rfc.notation.Condition;
import org.onosproject.ovsdb.rfc.notation.Row;
import org.onosproject.ovsdb.rfc.schema.TableSchema;
import org.onosproject.ovsdb.rfc.utils.TransValueUtil;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.google.common.collect.Maps;
/**
* update operation.Refer to RFC 7047 Section 5.2.
*/
public final class Update implements Operation {
@JsonIgnore
private final TableSchema tableSchema;
private final String op;
private final Map<String, Object> row;
private final List<Condition> where;
/**
* Constructs a Update object.
* @param schema TableSchema entity
* @param row Row entity
* @param where the List of Condition entity
*/
public Update(TableSchema schema, Row row, List<Condition> where) {
checkNotNull(schema, "TableSchema cannot be null");
checkNotNull(row, "row cannot be null");
checkNotNull(where, "where cannot be null");
this.tableSchema = schema;
this.op = Operations.UPDATE.op();
this.row = Maps.newHashMap();
this.where = where;
generateOperationRow(row);
}
/**
* Row entity convert into the row format of update operation. Refer to RFC
* 7047 Section 5.2.
* @param row Row entity
*/
private void generateOperationRow(Row row) {
Collection<Column> columns = row.getColumns();
for (Column column : columns) {
String columnName = column.columnName();
Object value = column.data();
Object formatValue = TransValueUtil.getFormatData(value);
this.row.put(columnName, formatValue);
}
}
/**
* Returns the row member of update operation.
* @return the row member of update operation
*/
public Map<String, Object> getRow() {
return row;
}
/**
* Returns the where member of update operation.
* @return the where member of update operation
*/
public List<Condition> getWhere() {
return where;
}
@Override
public String getOp() {
return op;
}
@Override
public TableSchema getTableSchema() {
return tableSchema;
}
/**
* For the use of serialization.
* @return the table member of update operation
*/
@JsonProperty
public String getTable() {
return tableSchema.name();
}
}
......
......@@ -17,8 +17,9 @@ package org.onosproject.ovsdb.rfc.schema.type;
import java.util.Set;
import org.onosproject.ovsdb.rfc.error.TypedSchemaException;
import org.onosproject.ovsdb.rfc.error.AbnormalJsonNodeException;
import org.onosproject.ovsdb.rfc.schema.type.UuidBaseType.RefType;
import org.onosproject.ovsdb.rfc.utils.ObjectMapperUtil;
import com.fasterxml.jackson.databind.JsonNode;
import com.google.common.collect.Sets;
......@@ -29,27 +30,29 @@ import com.google.common.collect.Sets;
public final class BaseTypeFactory {
/**
* Constructs a BaseTypeFactory object.
* This class should not be instantiated.
* Constructs a BaseTypeFactory object. This class should not be
* instantiated.
*/
private BaseTypeFactory() {
}
/**
* Create a BaseType from the JsonNode.
* @param json the BaseType JsonNode
* @param baseTypeJson the BaseType JsonNode
* @param keyorval the key node or value node
* @return BaseType
*/
public static BaseType getBaseTypeFromJson(JsonNode json, String keyorval) {
if (json.isValueNode()) {
String type = json.asText().trim();
public static BaseType getBaseTypeFromJson(JsonNode baseTypeJson, String keyorval) {
if (baseTypeJson.isValueNode()) {
String type = baseTypeJson.asText().trim();
return fromTypeStr(type);
} else {
if (!json.has(keyorval)) {
throw new TypedSchemaException("not a type");
if (!baseTypeJson.has(keyorval)) {
String message = "Abnormal BaseType JsonNode, it should contain 'key' or 'value' node but was not found"
+ ObjectMapperUtil.convertToString(baseTypeJson);
throw new AbnormalJsonNodeException(message);
}
return fromJsonNode(json.get(keyorval));
return fromJsonNode(baseTypeJson.get(keyorval));
}
}
......
......@@ -15,7 +15,7 @@
*/
package org.onosproject.ovsdb.rfc.schema.type;
import org.onosproject.ovsdb.rfc.error.TypedSchemaException;
import org.onosproject.ovsdb.rfc.error.AbnormalJsonNodeException;
import org.onosproject.ovsdb.rfc.utils.ObjectMapperUtil;
import com.fasterxml.jackson.databind.JsonNode;
......@@ -26,8 +26,8 @@ import com.fasterxml.jackson.databind.JsonNode;
public final class ColumnTypeFactory {
/**
* Constructs a ColumnTypeFactory object.
* This class should not be instantiated.
* Constructs a ColumnTypeFactory object. This class should not be
* instantiated.
*/
private ColumnTypeFactory() {
}
......@@ -54,20 +54,22 @@ public final class ColumnTypeFactory {
}
/**
* JsonNode like "flow_tables":{"type":{"key":{"maxInteger":254,"minInteger":0,"type":
* JsonNode like
* "flow_tables":{"type":{"key":{"maxInteger":254,"minInteger":0,"type":
* "integer"},"min":0,"value":{"type":"uuid","refTable":"Flow_Table"},"max":
* "unlimited"}}.
* @param json the ColumnType JsonNode
* @param columnTypeJson the ColumnType JsonNode
* @return ColumnType
*/
public static ColumnType getColumnTypeFromJson(JsonNode json) {
if (!json.isObject() || !json.has(Type.VALUE.type())) {
return createAtomicColumnType(json);
} else if (!json.isValueNode() && json.has(Type.VALUE.type())) {
return createKeyValuedColumnType(json);
public static ColumnType getColumnTypeFromJson(JsonNode columnTypeJson) {
if (!columnTypeJson.isObject() || !columnTypeJson.has(Type.VALUE.type())) {
return createAtomicColumnType(columnTypeJson);
} else if (!columnTypeJson.isValueNode() && columnTypeJson.has(Type.VALUE.type())) {
return createKeyValuedColumnType(columnTypeJson);
}
throw new TypedSchemaException("could not find the right column type :"
+ ObjectMapperUtil.convertToString(json));
String message = "Abnormal ColumnType JsonNode, it should be AtomicColumnType or KeyValuedColumnType"
+ ObjectMapperUtil.convertToString(columnTypeJson);
throw new AbnormalJsonNodeException(message);
}
/**
......@@ -76,12 +78,11 @@ public final class ColumnTypeFactory {
* @return AtomicColumnType entity
*/
private static AtomicColumnType createAtomicColumnType(JsonNode json) {
BaseType baseType = BaseTypeFactory
.getBaseTypeFromJson(json, Type.KEY.type());
BaseType baseType = BaseTypeFactory.getBaseTypeFromJson(json, Type.KEY.type());
int min = 1;
int max = 1;
JsonNode node = json.get("min");
if (node != null) {
if (node != null && node.isNumber()) {
min = node.asInt();
}
node = json.get("max");
......@@ -101,14 +102,12 @@ public final class ColumnTypeFactory {
* @return KeyValuedColumnType entity
*/
private static KeyValuedColumnType createKeyValuedColumnType(JsonNode json) {
BaseType keyType = BaseTypeFactory.getBaseTypeFromJson(json,
Type.KEY.type());
BaseType valueType = BaseTypeFactory
.getBaseTypeFromJson(json, Type.VALUE.type());
BaseType keyType = BaseTypeFactory.getBaseTypeFromJson(json, Type.KEY.type());
BaseType valueType = BaseTypeFactory.getBaseTypeFromJson(json, Type.VALUE.type());
int min = 1;
int max = 1;
JsonNode node = json.get("min");
if (node != null) {
if (node != null && node.isNumber()) {
min = node.asInt();
}
node = json.get("max");
......
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.ovsdb.rfc.tableservice;
import static com.google.common.base.MoreObjects.toStringHelper;
import static com.google.common.base.Preconditions.checkNotNull;
import java.util.Objects;
import org.onosproject.ovsdb.rfc.error.ColumnSchemaNotFoundException;
import org.onosproject.ovsdb.rfc.error.TableSchemaNotFoundException;
import org.onosproject.ovsdb.rfc.error.TypedSchemaException;
import org.onosproject.ovsdb.rfc.error.VersionMismatchException;
import org.onosproject.ovsdb.rfc.notation.Column;
import org.onosproject.ovsdb.rfc.notation.Row;
import org.onosproject.ovsdb.rfc.notation.UUID;
import org.onosproject.ovsdb.rfc.schema.ColumnSchema;
import org.onosproject.ovsdb.rfc.schema.DatabaseSchema;
import org.onosproject.ovsdb.rfc.schema.TableSchema;
import org.onosproject.ovsdb.rfc.table.OvsdbTable;
import org.onosproject.ovsdb.rfc.table.VersionNum;
import org.onosproject.ovsdb.rfc.utils.VersionUtil;
/**
* Representation of conversion between Ovsdb table and Row.
*/
public abstract class AbstractOvsdbTableService implements OvsdbTableService {
private final DatabaseSchema dbSchema;
private final Row row;
private final TableDescription tableDesc;
/**
* Constructs a AbstractOvsdbTableService object.
* @param dbSchema DatabaseSchema entity
* @param row Row entity
* @param table table name
* @param formVersion the initial version
*/
public AbstractOvsdbTableService(DatabaseSchema dbSchema, Row row,
OvsdbTable table, VersionNum formVersion) {
checkNotNull(dbSchema, "database schema cannot be null");
checkNotNull(row, "row cannot be null");
checkNotNull(table, "table cannot be null");
checkNotNull(formVersion, "the initial version cannot be null");
this.dbSchema = dbSchema;
this.row = row;
TableDescription tableDesc = new TableDescription(table, formVersion);
this.tableDesc = tableDesc;
row.setTableSchema(dbSchema.getTableSchema(table.tableName()));
}
/**
* Check whether the parameter of dbSchema is valid and check whether the
* table is existent in Database Schema.
*/
private boolean isValid() {
if (dbSchema == null) {
return false;
}
if (!dbSchema.name().equalsIgnoreCase(tableDesc.database())) {
return false;
}
checkTableSchemaVersion();
return true;
}
/**
* Check the table version.
*/
private void checkTableSchemaVersion() {
String fromVersion = tableDesc.fromVersion();
String untilVersion = tableDesc.untilVersion();
String schemaVersion = dbSchema.version();
checkVersion(schemaVersion, fromVersion, untilVersion);
}
/**
* Check the column version.
* @param columnDesc ColumnDescription entity
*/
private void checkColumnSchemaVersion(ColumnDescription columnDesc) {
String fromVersion = columnDesc.fromVersion();
String untilVersion = columnDesc.untilVersion();
String schemaVersion = dbSchema.version();
checkVersion(schemaVersion, fromVersion, untilVersion);
}
/**
* Check whether the DatabaseSchema version between the initial version and
* the end of the version.
* @param schemaVersion DatabaseSchema version
* @param fromVersion The initial version
* @param untilVersion The end of the version
* @throws VersionMismatchException this is a version mismatch exception
*/
private void checkVersion(String schemaVersion, String fromVersion,
String untilVersion) {
VersionUtil.versionMatch(fromVersion);
VersionUtil.versionMatch(untilVersion);
if (!fromVersion.equals(VersionUtil.DEFAULT_VERSION_STRING)) {
if (VersionUtil.versionCompare(schemaVersion, fromVersion) < 0) {
String message = VersionMismatchException
.createFromMessage(schemaVersion, fromVersion);
throw new VersionMismatchException(message);
}
}
if (!untilVersion.equals(VersionUtil.DEFAULT_VERSION_STRING)) {
if (VersionUtil.versionCompare(untilVersion, schemaVersion) < 0) {
String message = VersionMismatchException
.createToMessage(schemaVersion, untilVersion);
throw new VersionMismatchException(message);
}
}
}
/**
* Returns TableSchema from dbSchema by table name.
* @return TableSchema
*/
private TableSchema getTableSchema() {
String tableName = tableDesc.name();
return dbSchema.getTableSchema(tableName);
}
/**
* Returns ColumnSchema from TableSchema by column name.
* @param tableSchema TableSchema entity
* @param columnName column name
* @return ColumnSchema
*/
private ColumnSchema getColumnSchema(TableSchema tableSchema,
String columnName) {
return tableSchema.getColumnSchema(columnName);
}
@Override
public Column getColumnHandler(ColumnDescription columnDesc) {
if (!isValid()) {
return null;
}
String columnName = columnDesc.name();
checkColumnSchemaVersion(columnDesc);
if (columnName == null) {
throw new TypedSchemaException("Error processing GetColumn : "
+ tableDesc.name() + "." + columnDesc.method());
}
TableSchema tableSchema = getTableSchema();
if (tableSchema == null) {
String message = TableSchemaNotFoundException
.createMessage(tableDesc.name(), dbSchema.name());
throw new TableSchemaNotFoundException(message);
}
ColumnSchema columnSchema = getColumnSchema(tableSchema, columnName);
if (columnSchema == null) {
String message = ColumnSchemaNotFoundException
.createMessage(columnName, tableSchema.name());
throw new ColumnSchemaNotFoundException(message);
}
if (row == null) {
return new Column(columnSchema, null);
}
return row.getColumn(columnSchema);
}
@Override
public Object getDataHandler(ColumnDescription columnDesc) {
if (!isValid()) {
return null;
}
String columnName = columnDesc.name();
checkColumnSchemaVersion(columnDesc);
if (columnName == null) {
throw new TypedSchemaException("Error processing GetColumn : "
+ tableDesc.name() + "." + columnDesc.method());
}
TableSchema tableSchema = getTableSchema();
if (tableSchema == null) {
String message = TableSchemaNotFoundException
.createMessage(tableDesc.name(), dbSchema.name());
throw new TableSchemaNotFoundException(message);
}
ColumnSchema columnSchema = getColumnSchema(tableSchema, columnName);
if (columnSchema == null) {
String message = ColumnSchemaNotFoundException
.createMessage(columnName, tableSchema.name());
throw new ColumnSchemaNotFoundException(message);
}
if (row == null || row.getColumn(columnSchema) == null) {
return null;
}
return row.getColumn(columnSchema).data();
}
@Override
public void setDataHandler(ColumnDescription columnDesc, Object obj) {
if (!isValid()) {
return;
}
String columnName = columnDesc.name();
checkColumnSchemaVersion(columnDesc);
if (columnName == null) {
throw new TypedSchemaException("Unable to locate Column Name for "
+ tableDesc.name() + "." + columnDesc.method());
}
TableSchema tableSchema = getTableSchema();
ColumnSchema columnSchema = getColumnSchema(tableSchema, columnName);
Column column = new Column(columnSchema, obj);
row.addColumn(columnName, column);
}
@Override
public Object getTbSchema() {
if (!isValid()) {
return null;
}
if (dbSchema == null) {
return null;
}
return getTableSchema();
}
@Override
public UUID getUuid() {
if (!isValid()) {
return null;
}
ColumnDescription columnDesc = new ColumnDescription("_uuid",
"getTbUuid");
return (UUID) getDataHandler(columnDesc);
}
@Override
public Column getUuidColumn() {
if (!isValid()) {
return null;
}
ColumnDescription columnDesc = new ColumnDescription("_uuid",
"getTbUuidColumn");
return (Column) getColumnHandler(columnDesc);
}
@Override
public UUID getVersion() {
if (!isValid()) {
return null;
}
ColumnDescription columnDesc = new ColumnDescription("_version",
"getTbVersion");
return (UUID) getDataHandler(columnDesc);
}
@Override
public Column getVersionColumn() {
if (!isValid()) {
return null;
}
ColumnDescription columnDesc = new ColumnDescription("_version",
"getTbVersionColumn");
return (Column) getColumnHandler(columnDesc);
}
/**
* Get DatabaseSchema entity.
* @return DatabaseSchema entity
*/
public DatabaseSchema dbSchema() {
return dbSchema;
}
/**
* Get Row entity.
* @return Row entity
*/
public Row getRow() {
if (!isValid()) {
return null;
}
return this.row;
}
/**
* Get TableDescription entity.
* @return TableDescription entity
*/
public TableDescription tableDesc() {
return tableDesc;
}
@Override
public int hashCode() {
return Objects.hash(row);
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj instanceof AbstractOvsdbTableService) {
final AbstractOvsdbTableService other = (AbstractOvsdbTableService) obj;
return Objects.equals(this.row, other.row);
}
return false;
}
@Override
public String toString() {
TableSchema schema = (TableSchema) getTbSchema();
String tableName = schema.name();
return toStringHelper(this).add("tableName", tableName).add("row", row)
.toString();
}
}
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.ovsdb.rfc.tableservice;
import static com.google.common.base.MoreObjects.toStringHelper;
import static com.google.common.base.Preconditions.checkNotNull;
import java.util.Objects;
import org.onosproject.ovsdb.rfc.error.ColumnSchemaNotFoundException;
import org.onosproject.ovsdb.rfc.error.TableSchemaNotFoundException;
import org.onosproject.ovsdb.rfc.error.VersionMismatchException;
import org.onosproject.ovsdb.rfc.notation.Column;
import org.onosproject.ovsdb.rfc.notation.Row;
import org.onosproject.ovsdb.rfc.notation.UUID;
import org.onosproject.ovsdb.rfc.schema.ColumnSchema;
import org.onosproject.ovsdb.rfc.schema.DatabaseSchema;
import org.onosproject.ovsdb.rfc.schema.TableSchema;
import org.onosproject.ovsdb.rfc.table.OvsdbTable;
import org.onosproject.ovsdb.rfc.table.VersionNum;
import org.onosproject.ovsdb.rfc.utils.VersionUtil;
/**
* Representation of conversion between Ovsdb table and Row.
*/
public abstract class AbstractOvsdbTableService implements OvsdbTableService {
private final DatabaseSchema dbSchema;
private final Row row;
private final TableDescription tableDesc;
/**
* Constructs a AbstractOvsdbTableService object.
* @param dbSchema DatabaseSchema entity
* @param row Row entity
* @param table table name
* @param formVersion the initial version
*/
public AbstractOvsdbTableService(DatabaseSchema dbSchema, Row row, OvsdbTable table,
VersionNum formVersion) {
checkNotNull(dbSchema, "database schema cannot be null");
checkNotNull(row, "row cannot be null");
checkNotNull(table, "table cannot be null");
checkNotNull(formVersion, "the initial version cannot be null");
this.dbSchema = dbSchema;
row.setTableName(table.tableName());
this.row = row;
TableDescription tableDesc = new TableDescription(table, formVersion);
this.tableDesc = tableDesc;
}
/**
* Check whether the parameter of dbSchema is valid and check whether the
* table is existent in Database Schema.
*/
private boolean isValid() {
if (dbSchema == null) {
return false;
}
if (!dbSchema.name().equalsIgnoreCase(tableDesc.database())) {
return false;
}
checkTableSchemaVersion();
return true;
}
/**
* Check the table version.
*/
private void checkTableSchemaVersion() {
String fromVersion = tableDesc.fromVersion();
String untilVersion = tableDesc.untilVersion();
String schemaVersion = dbSchema.version();
checkVersion(schemaVersion, fromVersion, untilVersion);
}
/**
* Check the column version.
* @param columnDesc ColumnDescription entity
*/
private void checkColumnSchemaVersion(ColumnDescription columnDesc) {
String fromVersion = columnDesc.fromVersion();
String untilVersion = columnDesc.untilVersion();
String schemaVersion = dbSchema.version();
checkVersion(schemaVersion, fromVersion, untilVersion);
}
/**
* Check whether the DatabaseSchema version between the initial version and
* the end of the version.
* @param schemaVersion DatabaseSchema version
* @param fromVersion The initial version
* @param untilVersion The end of the version
* @throws VersionMismatchException this is a version mismatch exception
*/
private void checkVersion(String schemaVersion, String fromVersion, String untilVersion) {
VersionUtil.versionMatch(fromVersion);
VersionUtil.versionMatch(untilVersion);
if (!fromVersion.equals(VersionUtil.DEFAULT_VERSION_STRING)) {
if (VersionUtil.versionCompare(schemaVersion, fromVersion) < 0) {
String message = VersionMismatchException.createFromMessage(schemaVersion,
fromVersion);
throw new VersionMismatchException(message);
}
}
if (!untilVersion.equals(VersionUtil.DEFAULT_VERSION_STRING)) {
if (VersionUtil.versionCompare(untilVersion, schemaVersion) < 0) {
String message = VersionMismatchException.createToMessage(schemaVersion,
untilVersion);
throw new VersionMismatchException(message);
}
}
}
/**
* Returns TableSchema from dbSchema by table name.
* @return TableSchema
*/
private TableSchema getTableSchema() {
String tableName = tableDesc.name();
return dbSchema.getTableSchema(tableName);
}
/**
* Returns ColumnSchema from TableSchema by column name.
* @param columnName column name
* @return ColumnSchema
*/
private ColumnSchema getColumnSchema(String columnName) {
TableSchema tableSchema = getTableSchema();
if (tableSchema == null) {
String message = TableSchemaNotFoundException.createMessage(tableDesc.name(),
dbSchema.name());
throw new TableSchemaNotFoundException(message);
}
ColumnSchema columnSchema = tableSchema.getColumnSchema(columnName);
if (columnSchema == null) {
String message = ColumnSchemaNotFoundException.createMessage(columnName,
tableSchema.name());
throw new ColumnSchemaNotFoundException(message);
}
return columnSchema;
}
@Override
public Column getColumnHandler(ColumnDescription columnDesc) {
if (!isValid()) {
return null;
}
String columnName = columnDesc.name();
checkColumnSchemaVersion(columnDesc);
ColumnSchema columnSchema = getColumnSchema(columnName);
if (row == null) {
return null;
}
return row.getColumn(columnSchema.name());
}
@Override
public Object getDataHandler(ColumnDescription columnDesc) {
if (!isValid()) {
return null;
}
String columnName = columnDesc.name();
checkColumnSchemaVersion(columnDesc);
ColumnSchema columnSchema = getColumnSchema(columnName);
if (row == null || row.getColumn(columnSchema.name()) == null) {
return null;
}
return row.getColumn(columnSchema.name()).data();
}
@Override
public void setDataHandler(ColumnDescription columnDesc, Object obj) {
if (!isValid()) {
return;
}
String columnName = columnDesc.name();
checkColumnSchemaVersion(columnDesc);
ColumnSchema columnSchema = getColumnSchema(columnName);
Column column = new Column(columnSchema.name(), obj);
row.addColumn(columnName, column);
}
@Override
public UUID getTableUuid() {
if (!isValid()) {
return null;
}
ColumnDescription columnDesc = new ColumnDescription("_uuid", "getTableUuid");
return (UUID) getDataHandler(columnDesc);
}
@Override
public Column getTableUuidColumn() {
if (!isValid()) {
return null;
}
ColumnDescription columnDesc = new ColumnDescription("_uuid", "getTableUuidColumn");
return (Column) getColumnHandler(columnDesc);
}
@Override
public UUID getTableVersion() {
if (!isValid()) {
return null;
}
ColumnDescription columnDesc = new ColumnDescription("_version", "getTableVersion");
return (UUID) getDataHandler(columnDesc);
}
@Override
public Column getTableVersionColumn() {
if (!isValid()) {
return null;
}
ColumnDescription columnDesc = new ColumnDescription("_version", "getTableVersionColumn");
return (Column) getColumnHandler(columnDesc);
}
/**
* Get DatabaseSchema entity.
* @return DatabaseSchema entity
*/
public DatabaseSchema dbSchema() {
return dbSchema;
}
/**
* Get Row entity.
* @return Row entity
*/
public Row getRow() {
if (!isValid()) {
return null;
}
return this.row;
}
/**
* Get TableDescription entity.
* @return TableDescription entity
*/
public TableDescription tableDesc() {
return tableDesc;
}
@Override
public int hashCode() {
return Objects.hash(row);
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj instanceof AbstractOvsdbTableService) {
final AbstractOvsdbTableService other = (AbstractOvsdbTableService) obj;
return Objects.equals(this.row, other.row);
}
return false;
}
@Override
public String toString() {
TableSchema schema = (TableSchema) getTableSchema();
String tableName = schema.name();
return toStringHelper(this).add("tableName", tableName).add("row", row).toString();
}
}
......
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.ovsdb.rfc.tableservice;
import org.onosproject.ovsdb.rfc.notation.Column;
import org.onosproject.ovsdb.rfc.notation.UUID;
/**
* Representation of conversion between Ovsdb table and Row.
*/
public interface OvsdbTableService {
/**
* Get Column from row.
* @param columndesc Column description
* @return Column
*/
public Column getColumnHandler(ColumnDescription columndesc);
/**
* Get Data from row.
* @param columndesc Column description
* @return Object column data
*/
public Object getDataHandler(ColumnDescription columndesc);
/**
* Set column data of row.
* @param columndesc Column description
* @param obj column data
*/
public void setDataHandler(ColumnDescription columndesc, Object obj);
/**
* Returns the TableSchema from row.
* @return Object TableSchema
*/
public Object getTbSchema();
/**
* Returns UUID which column name is _uuid.
* @return UUID
*/
public UUID getUuid();
/**
* Returns UUID Column which column name is _uuid.
* @return UUID Column
*/
public Column getUuidColumn();
/**
* Returns UUID which column name is _version.
* @return UUID
*/
public UUID getVersion();
/**
* Returns UUID Column which column name is _version.
* @return UUID Column
*/
public Column getVersionColumn();
}
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.ovsdb.rfc.tableservice;
import org.onosproject.ovsdb.rfc.notation.Column;
import org.onosproject.ovsdb.rfc.notation.UUID;
/**
* Representation of conversion between Ovsdb table and Row.
*/
public interface OvsdbTableService {
/**
* Get Column from row.
* @param columndesc Column description
* @return Column
*/
public Column getColumnHandler(ColumnDescription columndesc);
/**
* Get Data from row.
* @param columndesc Column description
* @return Object column data
*/
public Object getDataHandler(ColumnDescription columndesc);
/**
* Set column data of row.
* @param columndesc Column description
* @param obj column data
*/
public void setDataHandler(ColumnDescription columndesc, Object obj);
/**
* Returns UUID which column name is _uuid.
* @return UUID
*/
public UUID getTableUuid();
/**
* Returns UUID Column which column name is _uuid.
* @return UUID Column
*/
public Column getTableUuidColumn();
/**
* Returns UUID which column name is _version.
* @return UUID
*/
public UUID getTableVersion();
/**
* Returns UUID Column which column name is _version.
* @return UUID Column
*/
public Column getTableVersionColumn();
}
......
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.ovsdb.rfc.utils;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.onosproject.ovsdb.rfc.error.AbnormalSchemaException;
import org.onosproject.ovsdb.rfc.error.JsonParsingException;
import org.onosproject.ovsdb.rfc.error.UnknownResultException;
import org.onosproject.ovsdb.rfc.jsonrpc.Callback;
import org.onosproject.ovsdb.rfc.jsonrpc.JsonRpcResponse;
import org.onosproject.ovsdb.rfc.message.OperationResult;
import org.onosproject.ovsdb.rfc.message.RowUpdate;
import org.onosproject.ovsdb.rfc.message.TableUpdate;
import org.onosproject.ovsdb.rfc.message.TableUpdates;
import org.onosproject.ovsdb.rfc.message.UpdateNotification;
import org.onosproject.ovsdb.rfc.notation.Column;
import org.onosproject.ovsdb.rfc.notation.Row;
import org.onosproject.ovsdb.rfc.notation.UUID;
import org.onosproject.ovsdb.rfc.operations.Operation;
import org.onosproject.ovsdb.rfc.schema.ColumnSchema;
import org.onosproject.ovsdb.rfc.schema.DatabaseSchema;
import org.onosproject.ovsdb.rfc.schema.TableSchema;
import org.onosproject.ovsdb.rfc.schema.type.ColumnTypeFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
/**
* JsonNode utility class. convert JsonNode into Object.
*/
public final class FromJsonUtil {
private static final Logger log = LoggerFactory
.getLogger(FromJsonUtil.class);
/**
* Constructs a FromJsonUtil object. Utility classes should not have a
* public or default constructor, otherwise IDE will compile unsuccessfully. This
* class should not be instantiated.
*/
private FromJsonUtil() {
}
/**
* convert JsonNode into DatabaseSchema.
* @param dbName database name
* @param json the JsonNode of get_schema result
* @return DatabaseSchema
* @throws JsonParsingException this is a JsonNode parse exception
*/
public static DatabaseSchema jsonNodeToDbSchema(String dbName, JsonNode json) {
if (!json.isObject() || !json.has("tables")) {
throw new JsonParsingException(
"bad DatabaseSchema root, expected \"tables\" as child but was not found");
}
if (!json.isObject() || !json.has("version")) {
throw new JsonParsingException(
"bad DatabaseSchema root, expected \"version\" as child but was not found");
}
String dbVersion = json.get("version").asText();
Map<String, TableSchema> tables = new HashMap<>();
for (Iterator<Map.Entry<String, JsonNode>> iter = json.get("tables")
.fields(); iter.hasNext();) {
Map.Entry<String, JsonNode> table = iter.next();
tables.put(table.getKey(),
jsonNodeToTableSchema(table.getKey(), table.getValue()));
}
return new DatabaseSchema(dbName, dbVersion, tables);
}
/**
* convert JsonNode into TableSchema.
* @param tableName table name
* @param json table JsonNode
* @return TableSchema
* @throws AbnormalSchemaException this is an abnormal schema exception
*/
private static TableSchema jsonNodeToTableSchema(String tableName,
JsonNode json) {
if (!json.isObject() || !json.has("columns")) {
throw new AbnormalSchemaException(
"bad tableschema root, expected \"columns\" as child");
}
Map<String, ColumnSchema> columns = new HashMap<>();
for (Iterator<Map.Entry<String, JsonNode>> iter = json.get("columns")
.fields(); iter.hasNext();) {
Map.Entry<String, JsonNode> column = iter.next();
columns.put(column.getKey(),
jsonNodeToColumnSchema(column.getKey(),
column.getValue()));
}
return new TableSchema(tableName, columns);
}
/**
* convert JsonNode into ColumnSchema.
* @param name column name
* @param json JsonNode
* @return ColumnSchema
* @throws AbnormalSchemaException this is an abnormal schema exception
*/
private static ColumnSchema jsonNodeToColumnSchema(String name,
JsonNode json) {
if (!json.isObject() || !json.has("type")) {
throw new AbnormalSchemaException(
"bad column schema root, expected \"type\" as child");
}
return new ColumnSchema(name,
ColumnTypeFactory.getColumnTypeFromJson(json
.get("type")));
}
/**
* convert JsonNode into the returnType of methods in OvsdbRPC class.
* @param resultJsonNode the result JsonNode
* @param methodName the method name of methods in OvsdbRPC class
* @param objectMapper ObjectMapper entity
* @return Object
* @throws UnknownResultException this is an unknown result exception
*/
private static Object convertResultType(JsonNode resultJsonNode,
String methodName,
ObjectMapper objectMapper) {
switch (methodName) {
case "getSchema":
case "monitor":
return resultJsonNode;
case "echo":
case "listDbs":
return objectMapper
.convertValue(resultJsonNode, objectMapper.getTypeFactory()
.constructParametricType(List.class, String.class));
case "transact":
return objectMapper
.convertValue(resultJsonNode,
objectMapper
.getTypeFactory()
.constructParametricType(List.class,
JsonNode.class));
default:
throw new UnknownResultException("Don't know how to handle this");
}
}
/**
* convert JsonNode into the returnType of methods in OvsdbRPC class.
* @param jsonNode the result JsonNode
* @param methodName the method name of methods in OvsdbRPC class
* @return Object
*/
public static Object jsonResultParser(JsonNode jsonNode, String methodName) {
ObjectMapper objectMapper = ObjectMapperUtil.getObjectMapper();
JsonNode error = jsonNode.get("error");
if (error != null && !error.isNull()) {
log.error("Error : {}", error.toString());
}
JsonNode resultJsonNode = jsonNode.get("result");
Object result = convertResultType(resultJsonNode, methodName,
objectMapper);
return result;
}
/**
* When monitor the ovsdb tables, if a table update, ovs send update
* notification, then call callback function.
* @param jsonNode the result JsonNode
* @param callback the callback function
* @throws UnknownResultException this is an unknown result exception
*/
public static void jsonCallbackRequestParser(JsonNode jsonNode,
Callback callback) {
ObjectMapper objectMapper = ObjectMapperUtil.getObjectMapper();
JsonNode params = jsonNode.get("params");
Object param = null;
String methodName = jsonNode.get("method").asText();
switch (methodName) {
case "update":
param = objectMapper.convertValue(params, UpdateNotification.class);
callback.update((UpdateNotification) param);
break;
default:
throw new UnknownResultException("Cannot handle this method: "
+ methodName);
}
}
/**
* Ovs send echo request to keep the heart, need we return echo result.
* @param jsonNode the result JsonNode
* @return JsonRpcResponse String
*/
public static String getEchoRequestStr(JsonNode jsonNode) {
ObjectMapper objectMapper = ObjectMapperUtil.getObjectMapper();
String str = null;
if (jsonNode.get("method").asText().equals("echo")) {
JsonRpcResponse response = new JsonRpcResponse(jsonNode.get("id")
.asText());
try {
str = objectMapper.writeValueAsString(response);
} catch (JsonProcessingException e) {
log.error("JsonProcessingException while converting JsonNode into string ", e);
}
}
return str;
}
/**
* Convert the List of Operation result into List of OperationResult .
* @param input the List of JsonNode
* @param operations the List of Operation
* @return the List of OperationResult
*/
public static List<OperationResult> jsonNodeToOperationResult(List<JsonNode> input,
List<Operation> operations) {
ObjectMapper objectMapper = ObjectMapperUtil.getObjectMapper(false);
List<OperationResult> operationResults = new ArrayList<OperationResult>();
for (int i = 0; i < input.size(); i++) {
JsonNode jsonNode = input.get(i);
Operation operation = operations.get(i);
if (jsonNode != null && jsonNode.size() > 0) {
if (i >= operations.size() || operation.getOp() != "select") {
OperationResult or = objectMapper.convertValue(jsonNode,
OperationResult.class);
operationResults.add(or);
} else {
List<Row> rows = createRows(operation.getTableSchema(), jsonNode);
OperationResult or = new OperationResult(rows);
operationResults.add(or);
}
}
}
return operationResults;
}
/**
* Convert Operation JsonNode into Rows.
* @param tableSchema TableSchema entity
* @param rowsNode JsonNode
* @return ArrayList<Row> the List of Row
*/
private static ArrayList<Row> createRows(TableSchema tableSchema,
JsonNode rowsNode) {
ArrayList<Row> rows = Lists.newArrayList();
for (JsonNode rowNode : rowsNode.get("rows")) {
rows.add(createRow(tableSchema, rowNode));
}
return rows;
}
/**
* convert the params of Update Notification into TableUpdates.
* @param updatesJson the params of Update Notification
* @param dbSchema DatabaseSchema entity
* @return TableUpdates
*/
public static TableUpdates jsonNodeToTableUpdates(JsonNode updatesJson,
DatabaseSchema dbSchema) {
Map<String, TableUpdate> tableUpdateMap = Maps.newHashMap();
for (Iterator<Map.Entry<String, JsonNode>> itr = updatesJson.fields(); itr
.hasNext();) {
Map.Entry<String, JsonNode> entry = itr.next();
TableSchema tableSchema = dbSchema.getTableSchema(entry.getKey());
TableUpdate tableUpdate = jsonNodeToTableUpdate(tableSchema,
entry.getValue());
tableUpdateMap.put(entry.getKey(), tableUpdate);
}
return TableUpdates.tableUpdates(tableUpdateMap);
}
/**
* convert the params of Update Notification into TableUpdate.
* @param tableSchema TableSchema entity
* @param value the table-update in params of Update Notification
* @return TableUpdate
*/
public static TableUpdate jsonNodeToTableUpdate(TableSchema tableSchema,
JsonNode value) {
Map<UUID, RowUpdate> rows = Maps.newHashMap();
Iterator<Entry<String, JsonNode>> fields = value.fields();
while (fields.hasNext()) {
Map.Entry<String, JsonNode> idOldNew = fields.next();
String uuidStr = idOldNew.getKey();
UUID uuid = UUID.uuid(uuidStr);
JsonNode newR = idOldNew.getValue().get("new");
JsonNode oldR = idOldNew.getValue().get("old");
Row newRow = newR != null ? createRow(tableSchema, newR) : null;
Row oldRow = oldR != null ? createRow(tableSchema, oldR) : null;
RowUpdate rowUpdate = new RowUpdate(uuid, oldRow, newRow);
rows.put(uuid, rowUpdate);
}
return TableUpdate.tableUpdate(rows);
}
/**
* Convert Operation JsonNode into Row.
* @param tableSchema TableSchema entity
* @param rowNode JsonNode
* @return Row
*/
private static Row createRow(TableSchema tableSchema, JsonNode rowNode) {
List<Column> columns = Lists.newArrayList();
for (Iterator<Map.Entry<String, JsonNode>> iter = rowNode.fields(); iter
.hasNext();) {
Map.Entry<String, JsonNode> next = iter.next();
ColumnSchema schema = tableSchema.getColumnSchema(next.getKey());
if (schema != null) {
Object o = TransValueUtil.getValueFromJson(next.getValue(), schema.type());
columns.add(new Column(schema, o));
}
}
return new Row(tableSchema, columns);
}
}
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.ovsdb.rfc.utils;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.onosproject.ovsdb.rfc.error.AbnormalJsonNodeException;
import org.onosproject.ovsdb.rfc.error.UnsupportedException;
import org.onosproject.ovsdb.rfc.jsonrpc.Callback;
import org.onosproject.ovsdb.rfc.jsonrpc.JsonRpcResponse;
import org.onosproject.ovsdb.rfc.message.OperationResult;
import org.onosproject.ovsdb.rfc.message.RowUpdate;
import org.onosproject.ovsdb.rfc.message.TableUpdate;
import org.onosproject.ovsdb.rfc.message.TableUpdates;
import org.onosproject.ovsdb.rfc.message.UpdateNotification;
import org.onosproject.ovsdb.rfc.notation.Column;
import org.onosproject.ovsdb.rfc.notation.Row;
import org.onosproject.ovsdb.rfc.notation.UUID;
import org.onosproject.ovsdb.rfc.operations.Operation;
import org.onosproject.ovsdb.rfc.schema.ColumnSchema;
import org.onosproject.ovsdb.rfc.schema.DatabaseSchema;
import org.onosproject.ovsdb.rfc.schema.TableSchema;
import org.onosproject.ovsdb.rfc.schema.type.ColumnTypeFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
/**
* JsonNode utility class. convert JsonNode into Object.
*/
public final class FromJsonUtil {
private static final Logger log = LoggerFactory.getLogger(FromJsonUtil.class);
/**
* Constructs a FromJsonUtil object. Utility classes should not have a
* public or default constructor, otherwise IDE will compile unsuccessfully.
* This class should not be instantiated.
*/
private FromJsonUtil() {
}
/**
* Verify whether the jsonNode is normal.
* @param jsonNode JsonNode
* @param nodeStr the node name of JsonNode
*/
private static void validateJsonNode(JsonNode jsonNode, String nodeStr) {
if (!jsonNode.isObject() || !jsonNode.has(nodeStr)) {
String message = "Abnormal DatabaseSchema JsonNode, it should contain " + nodeStr
+ " node but was not found";
throw new AbnormalJsonNodeException(message);
}
}
/**
* convert JsonNode into DatabaseSchema.
* @param dbName database name
* @param dbJson the JsonNode of get_schema result
* @return DatabaseSchema
* @throws AbnormalJsonNodeException this is an abnormal JsonNode exception
*/
public static DatabaseSchema jsonNodeToDbSchema(String dbName, JsonNode dbJson) {
validateJsonNode(dbJson, "tables");
validateJsonNode(dbJson, "version");
String dbVersion = dbJson.get("version").asText();
Map<String, TableSchema> tables = new HashMap<>();
Iterator<Map.Entry<String, JsonNode>> tablesIter = dbJson.get("tables").fields();
while (tablesIter.hasNext()) {
Map.Entry<String, JsonNode> table = tablesIter.next();
tables.put(table.getKey(), jsonNodeToTableSchema(table.getKey(), table.getValue()));
}
return new DatabaseSchema(dbName, dbVersion, tables);
}
/**
* convert JsonNode into TableSchema.
* @param tableName table name
* @param tableJson table JsonNode
* @return TableSchema
* @throws AbnormalJsonNodeException this is an abnormal JsonNode exception
*/
private static TableSchema jsonNodeToTableSchema(String tableName, JsonNode tableJson) {
validateJsonNode(tableJson, "columns");
Map<String, ColumnSchema> columns = new HashMap<>();
Iterator<Map.Entry<String, JsonNode>> columnsIter = tableJson.get("columns").fields();
while (columnsIter.hasNext()) {
Map.Entry<String, JsonNode> column = columnsIter.next();
columns.put(column.getKey(), jsonNodeToColumnSchema(column.getKey(), column.getValue()));
}
return new TableSchema(tableName, columns);
}
/**
* convert JsonNode into ColumnSchema.
* @param name column name
* @param columnJson column JsonNode
* @return ColumnSchema
* @throws AbnormalJsonNodeException this is an abnormal JsonNode exception
*/
private static ColumnSchema jsonNodeToColumnSchema(String name, JsonNode columnJson) {
validateJsonNode(columnJson, "type");
return new ColumnSchema(name, ColumnTypeFactory.getColumnTypeFromJson(columnJson
.get("type")));
}
/**
* convert JsonNode into the returnType of methods in OvsdbRPC class.
* @param resultJsonNode the result JsonNode
* @param methodName the method name of methods in OvsdbRPC class
* @param objectMapper ObjectMapper entity
* @return Object
* @throws UnsupportedException this is an unsupported exception
*/
private static Object convertResultType(JsonNode resultJsonNode, String methodName,
ObjectMapper objectMapper) {
switch (methodName) {
case "getSchema":
case "monitor":
return resultJsonNode;
case "echo":
case "listDbs":
return objectMapper.convertValue(resultJsonNode, objectMapper.getTypeFactory()
.constructParametricType(List.class, String.class));
case "transact":
return objectMapper.convertValue(resultJsonNode, objectMapper.getTypeFactory()
.constructParametricType(List.class, JsonNode.class));
default:
throw new UnsupportedException("does not support this rpc method" + methodName);
}
}
/**
* convert JsonNode into the returnType of methods in OvsdbRPC class.
* @param jsonNode the result JsonNode
* @param methodName the method name of methods in OvsdbRPC class
* @return Object
*/
public static Object jsonResultParser(JsonNode jsonNode, String methodName) {
ObjectMapper objectMapper = ObjectMapperUtil.getObjectMapper();
JsonNode error = jsonNode.get("error");
if (error != null && !error.isNull()) {
log.error("jsonRpcResponse error : {}", error.toString());
}
JsonNode resultJsonNode = jsonNode.get("result");
Object result = convertResultType(resultJsonNode, methodName, objectMapper);
return result;
}
/**
* When monitor the ovsdb tables, if a table update, ovs send update
* notification, then call callback function.
* @param jsonNode the result JsonNode
* @param callback the callback function
* @throws UnsupportedException this is an unsupported exception
*/
public static void jsonCallbackRequestParser(JsonNode jsonNode, Callback callback) {
ObjectMapper objectMapper = ObjectMapperUtil.getObjectMapper();
JsonNode params = jsonNode.get("params");
Object param = null;
String methodName = jsonNode.get("method").asText();
switch (methodName) {
case "update":
param = objectMapper.convertValue(params, UpdateNotification.class);
callback.update((UpdateNotification) param);
break;
default:
throw new UnsupportedException("does not support this callback method: " + methodName);
}
}
/**
* Ovs send echo request to keep the heart, need we return echo result.
* @param jsonNode the result JsonNode
* @return JsonRpcResponse String
*/
public static String getEchoRequestStr(JsonNode jsonNode) {
ObjectMapper objectMapper = ObjectMapperUtil.getObjectMapper();
String str = null;
if (jsonNode.get("method").asText().equals("echo")) {
JsonRpcResponse response = new JsonRpcResponse(jsonNode.get("id").asText());
try {
str = objectMapper.writeValueAsString(response);
} catch (JsonProcessingException e) {
log.error("JsonProcessingException while converting JsonNode into string: ", e);
}
}
return str;
}
/**
* Convert the List of Operation result into List of OperationResult .
* @param input the List of JsonNode
* @param operations the List of Operation
* @return the List of OperationResult
*/
public static List<OperationResult> jsonNodeToOperationResult(List<JsonNode> input,
List<Operation> operations) {
ObjectMapper objectMapper = ObjectMapperUtil.getObjectMapper(false);
List<OperationResult> operationResults = new ArrayList<OperationResult>();
for (int i = 0; i < input.size(); i++) {
JsonNode jsonNode = input.get(i);
Operation operation = operations.get(i);
if (jsonNode != null && jsonNode.size() > 0) {
if (i >= operations.size() || operation.getOp() != "select") {
OperationResult or = objectMapper.convertValue(jsonNode, OperationResult.class);
operationResults.add(or);
} else {
List<Row> rows = createRows(operation.getTableSchema(), jsonNode);
OperationResult or = new OperationResult(rows);
operationResults.add(or);
}
}
}
return operationResults;
}
/**
* Convert Operation JsonNode into Rows.
* @param tableSchema TableSchema entity
* @param rowsNode JsonNode
* @return ArrayList<Row> the List of Row
*/
private static ArrayList<Row> createRows(TableSchema tableSchema, JsonNode rowsNode) {
validateJsonNode(rowsNode, "rows");
ArrayList<Row> rows = Lists.newArrayList();
for (JsonNode rowNode : rowsNode.get("rows")) {
rows.add(createRow(tableSchema, rowNode));
}
return rows;
}
/**
* convert the params of Update Notification into TableUpdates.
* @param updatesJson the params of Update Notification
* @param dbSchema DatabaseSchema entity
* @return TableUpdates
*/
public static TableUpdates jsonNodeToTableUpdates(JsonNode updatesJson, DatabaseSchema dbSchema) {
Map<String, TableUpdate> tableUpdateMap = Maps.newHashMap();
Iterator<Map.Entry<String, JsonNode>> tableUpdatesItr = updatesJson.fields();
while (tableUpdatesItr.hasNext()) {
Map.Entry<String, JsonNode> entry = tableUpdatesItr.next();
TableSchema tableSchema = dbSchema.getTableSchema(entry.getKey());
TableUpdate tableUpdate = jsonNodeToTableUpdate(tableSchema, entry.getValue());
tableUpdateMap.put(entry.getKey(), tableUpdate);
}
return TableUpdates.tableUpdates(tableUpdateMap);
}
/**
* convert the params of Update Notification into TableUpdate.
* @param tableSchema TableSchema entity
* @param updateJson the table-update in params of Update Notification
* @return TableUpdate
*/
public static TableUpdate jsonNodeToTableUpdate(TableSchema tableSchema, JsonNode updateJson) {
Map<UUID, RowUpdate> rows = Maps.newHashMap();
Iterator<Map.Entry<String, JsonNode>> tableUpdateItr = updateJson.fields();
while (tableUpdateItr.hasNext()) {
Map.Entry<String, JsonNode> oldNewRow = tableUpdateItr.next();
String uuidStr = oldNewRow.getKey();
UUID uuid = UUID.uuid(uuidStr);
JsonNode newR = oldNewRow.getValue().get("new");
JsonNode oldR = oldNewRow.getValue().get("old");
Row newRow = newR != null ? createRow(tableSchema, newR) : null;
Row oldRow = oldR != null ? createRow(tableSchema, oldR) : null;
RowUpdate rowUpdate = new RowUpdate(uuid, oldRow, newRow);
rows.put(uuid, rowUpdate);
}
return TableUpdate.tableUpdate(rows);
}
/**
* Convert Operation JsonNode into Row.
* @param tableSchema TableSchema entity
* @param rowNode JsonNode
* @return Row
*/
private static Row createRow(TableSchema tableSchema, JsonNode rowNode) {
if (tableSchema == null) {
return null;
}
Map<String, Column> columns = Maps.newHashMap();
Iterator<Map.Entry<String, JsonNode>> rowIter = rowNode.fields();
while (rowIter.hasNext()) {
Map.Entry<String, JsonNode> next = rowIter.next();
ColumnSchema columnSchema = tableSchema.getColumnSchema(next.getKey());
if (columnSchema != null) {
String columnName = columnSchema.name();
Object obj = TransValueUtil.getValueFromJson(next.getValue(), columnSchema.type());
columns.put(columnName, new Column(columnName, obj));
}
}
return new Row(tableSchema.name(), columns);
}
}
......
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.ovsdb.rfc.utils;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufInputStream;
import java.io.IOException;
import java.util.List;
import java.util.Stack;
import org.onosproject.ovsdb.rfc.error.UnsupportedEncodingException;
import org.onosproject.ovsdb.rfc.jsonrpc.JsonReadContext;
import com.fasterxml.jackson.core.JsonEncoding;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.io.IOContext;
import com.fasterxml.jackson.core.json.ByteSourceJsonBootstrapper;
import com.fasterxml.jackson.core.util.BufferRecycler;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.MappingJsonFactory;
/**
* Decoder utility class.
*/
public final class JsonRpcReaderUtil {
/**
* Constructs a JsonRpcReaderUtil object. Utility classes should not have a
* public or default constructor, otherwise IDE will compile unsuccessfully.
* This class should not be instantiated.
*/
private JsonRpcReaderUtil() {
}
/**
* Decode the bytes to Json object.
* @param in input of bytes
* @param out ouput of Json object list
* @param jrContext context for the last decoding process
* @throws IOException IOException
* @throws JsonParseException JsonParseException
*/
public static void readToJsonNode(ByteBuf in, List<Object> out,
JsonReadContext jrContext)
throws JsonParseException, IOException {
int lastReadBytes = jrContext.getLastReadBytes();
if (lastReadBytes == 0) {
if (in.readableBytes() < 4) {
return;
}
checkEncoding(in);
}
int i = lastReadBytes + in.readerIndex();
Stack<Byte> bufStack = jrContext.getBufStack();
for (; i < in.writerIndex(); i++) {
byte b = in.getByte(i);
switch (b) {
case '{':
if (!isDoubleQuote(bufStack)) {
bufStack.push(b);
jrContext.setStartMatch(true);
}
break;
case '}':
if (!isDoubleQuote(bufStack)) {
bufStack.pop();
}
break;
case '"':
if (in.getByte(i - 1) != '\\') {
if (!bufStack.isEmpty() && bufStack.peek() != '"') {
bufStack.push(b);
} else {
bufStack.pop();
}
}
break;
default:
break;
}
if (jrContext.isStartMatch() && bufStack.isEmpty()) {
ByteBuf buf = in.readSlice(i - in.readerIndex() + 1);
JsonParser jf = new MappingJsonFactory()
.createParser(new ByteBufInputStream(buf));
JsonNode jsonNode = jf.readValueAsTree();
out.add(jsonNode);
lastReadBytes = 0;
jrContext.setLastReadBytes(lastReadBytes);
break;
}
}
if (i >= in.writerIndex()) {
lastReadBytes = in.readableBytes();
jrContext.setLastReadBytes(lastReadBytes);
}
}
/**
* Filter the invalid characters before decoding.
* @param in input of bytes
* @param lastReadBytes the bytes for last decoding incomplete record
*/
private static void fliterCharaters(ByteBuf in) {
while (in.isReadable()) {
int ch = in.getByte(in.readerIndex());
if ((ch != ' ') && (ch != '\n') && (ch != '\t') && (ch != '\r')) {
break;
} else {
in.readByte();
}
}
}
/**
* Check whether the peek of the stack element is double quote.
* @param jrContext context for the last decoding process
* @return boolean
*/
private static boolean isDoubleQuote(Stack<Byte> bufStack) {
if (!bufStack.isEmpty() && bufStack.peek() == '"') {
return true;
}
return false;
}
/**
* Check whether the encoding is valid.
* @param in input of bytes
* @throws IOException this is an IO exception
* @throws UnsupportedEncodingException this is an unsupported encode
* exception
*/
private static void checkEncoding(ByteBuf in) throws IOException {
int inputStart = 0;
int inputLength = 4;
fliterCharaters(in);
byte[] buff = new byte[4];
in.getBytes(in.readerIndex(), buff);
ByteSourceJsonBootstrapper strapper = new ByteSourceJsonBootstrapper(
new IOContext(
new BufferRecycler(),
null,
false),
buff,
inputStart,
inputLength);
JsonEncoding jsonEncoding = strapper.detectEncoding();
if (!JsonEncoding.UTF8.equals(jsonEncoding)) {
throw new UnsupportedEncodingException(
"Only UTF-8 encoding is supported.");
}
}
}
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.ovsdb.rfc.utils;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufInputStream;
import java.io.IOException;
import java.util.List;
import java.util.Stack;
import org.onosproject.ovsdb.rfc.error.UnsupportedException;
import org.onosproject.ovsdb.rfc.jsonrpc.JsonReadContext;
import com.fasterxml.jackson.core.JsonEncoding;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.io.IOContext;
import com.fasterxml.jackson.core.json.ByteSourceJsonBootstrapper;
import com.fasterxml.jackson.core.util.BufferRecycler;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.MappingJsonFactory;
/**
* Decoder utility class.
*/
public final class JsonRpcReaderUtil {
/**
* Constructs a JsonRpcReaderUtil object. Utility classes should not have a
* public or default constructor, otherwise IDE will compile unsuccessfully.
* This class should not be instantiated.
*/
private JsonRpcReaderUtil() {
}
/**
* Decode the bytes to Json object.
* @param in input of bytes
* @param out ouput of Json object list
* @param jrContext context for the last decoding process
* @throws IOException IOException
* @throws JsonParseException JsonParseException
*/
public static void readToJsonNode(ByteBuf in, List<Object> out, JsonReadContext jrContext)
throws JsonParseException, IOException {
int lastReadBytes = jrContext.getLastReadBytes();
if (lastReadBytes == 0) {
if (in.readableBytes() < 4) {
return;
}
checkEncoding(in);
}
int i = lastReadBytes + in.readerIndex();
Stack<Byte> bufStack = jrContext.getBufStack();
for (; i < in.writerIndex(); i++) {
byte b = in.getByte(i);
switch (b) {
case '{':
if (!isDoubleQuote(bufStack)) {
bufStack.push(b);
jrContext.setStartMatch(true);
}
break;
case '}':
if (!isDoubleQuote(bufStack)) {
bufStack.pop();
}
break;
case '"':
if (in.getByte(i - 1) != '\\') {
if (!bufStack.isEmpty() && bufStack.peek() != '"') {
bufStack.push(b);
} else {
bufStack.pop();
}
}
break;
default:
break;
}
if (jrContext.isStartMatch() && bufStack.isEmpty()) {
ByteBuf buf = in.readSlice(i - in.readerIndex() + 1);
JsonParser jf = new MappingJsonFactory().createParser(new ByteBufInputStream(buf));
JsonNode jsonNode = jf.readValueAsTree();
out.add(jsonNode);
lastReadBytes = 0;
jrContext.setLastReadBytes(lastReadBytes);
break;
}
}
if (i >= in.writerIndex()) {
lastReadBytes = in.readableBytes();
jrContext.setLastReadBytes(lastReadBytes);
}
}
/**
* Filter the invalid characters before decoding.
* @param in input of bytes
* @param lastReadBytes the bytes for last decoding incomplete record
*/
private static void fliterCharaters(ByteBuf in) {
while (in.isReadable()) {
int ch = in.getByte(in.readerIndex());
if ((ch != ' ') && (ch != '\n') && (ch != '\t') && (ch != '\r')) {
break;
} else {
in.readByte();
}
}
}
/**
* Check whether the peek of the stack element is double quote.
* @param jrContext context for the last decoding process
* @return boolean
*/
private static boolean isDoubleQuote(Stack<Byte> bufStack) {
if (!bufStack.isEmpty() && bufStack.peek() == '"') {
return true;
}
return false;
}
/**
* Check whether the encoding is valid.
* @param in input of bytes
* @throws IOException this is an IO exception
* @throws UnsupportedException this is an unsupported exception
*/
private static void checkEncoding(ByteBuf in) throws IOException {
int inputStart = 0;
int inputLength = 4;
fliterCharaters(in);
byte[] buff = new byte[4];
in.getBytes(in.readerIndex(), buff);
ByteSourceJsonBootstrapper strapper = new ByteSourceJsonBootstrapper(new IOContext(new BufferRecycler(),
null,
false),
buff, inputStart,
inputLength);
JsonEncoding jsonEncoding = strapper.detectEncoding();
if (!JsonEncoding.UTF8.equals(jsonEncoding)) {
throw new UnsupportedException("Only UTF-8 encoding is supported.");
}
}
}
......
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.ovsdb.rfc.utils;
import java.util.List;
import java.util.Set;
import org.onosproject.ovsdb.rfc.message.MonitorRequest;
import org.onosproject.ovsdb.rfc.message.MonitorSelect;
import org.onosproject.ovsdb.rfc.operations.Operation;
import org.onosproject.ovsdb.rfc.schema.DatabaseSchema;
import org.onosproject.ovsdb.rfc.schema.TableSchema;
import com.google.common.base.Function;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
/**
* Params utility class. Params of the request object, refer to RFC7047's Section
* 4.1.
*/
public final class ParamUtil {
/**
* Constructs a ParamUtil object. Utility classes should not have a
* public or default constructor, otherwise IDE will compile unsuccessfully. This
* class should not be instantiated.
*/
private ParamUtil() {
}
/**
* Returns MonitorRequest, refer to RFC7047's Section 4.1.5.
* @param tableSchema entity
* @return MonitorRequest
*/
private static MonitorRequest getAllColumnsMonitorRequest(TableSchema tableSchema) {
String tableName = tableSchema.name();
Set<String> columns = tableSchema.getColumnNames();
MonitorSelect select = new MonitorSelect(true, true, true, true);
MonitorRequest monitorRequest = new MonitorRequest(tableName, columns,
select);
return monitorRequest;
}
/**
* Returns params of monitor method, refer to RFC7047's Section 4.1.5.
* @param monotorId json-value, refer to RFC7047's Section 4.1.5.
* @param dbSchema DatabaseSchema entity
* @return List of Object, the params of monitor request
*/
public static List<Object> getMonitorParams(String monotorId,
DatabaseSchema dbSchema) {
Set<String> tables = dbSchema.getTableNames();
List<MonitorRequest> monitorRequests = Lists.newArrayList();
for (String tableName : tables) {
TableSchema tableSchema = dbSchema.getTableSchema(tableName);
monitorRequests.add(getAllColumnsMonitorRequest(tableSchema));
}
ImmutableMap<String, MonitorRequest> reqMap = Maps
.uniqueIndex(monitorRequests,
new Function<MonitorRequest, String>() {
@Override
public String apply(MonitorRequest input) {
return input.getTableName();
}
});
return Lists.<Object>newArrayList(dbSchema.name(), monotorId,
reqMap);
}
/**
* Returns params of transact method, refer to RFC7047's Section 4.1.3.
* @param dbSchema DatabaseSchema entity
* @param operations operation*, refer to RFC7047's Section 4.1.3.
* @return List of Object, the params of transact request
*/
public static List<Object> getTransactParams(DatabaseSchema dbSchema,
List<Operation> operations) {
List<Object> lists = Lists.newArrayList((Object) dbSchema.name());
lists.addAll(operations);
return lists;
}
}
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.ovsdb.rfc.utils;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.onosproject.ovsdb.rfc.message.MonitorRequest;
import org.onosproject.ovsdb.rfc.message.MonitorSelect;
import org.onosproject.ovsdb.rfc.operations.Operation;
import org.onosproject.ovsdb.rfc.schema.DatabaseSchema;
import org.onosproject.ovsdb.rfc.schema.TableSchema;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
/**
* Params utility class. Params of the request object, refer to RFC7047's
* Section 4.1.
*/
public final class ParamUtil {
/**
* Constructs a ParamUtil object. Utility classes should not have a public
* or default constructor, otherwise IDE will compile unsuccessfully. This
* class should not be instantiated.
*/
private ParamUtil() {
}
/**
* Returns MonitorRequest, refer to RFC7047's Section 4.1.5.
* @param tableSchema entity
* @return MonitorRequest
*/
private static MonitorRequest getAllColumnsMonitorRequest(TableSchema tableSchema) {
String tableName = tableSchema.name();
Set<String> columns = tableSchema.getColumnNames();
MonitorSelect select = new MonitorSelect(true, true, true, true);
MonitorRequest monitorRequest = new MonitorRequest(tableName, columns, select);
return monitorRequest;
}
/**
* Returns params of monitor method, refer to RFC7047's Section 4.1.5.
* @param monotorId json-value, refer to RFC7047's Section 4.1.5.
* @param dbSchema DatabaseSchema entity
* @return List of Object, the params of monitor request
*/
public static List<Object> getMonitorParams(String monotorId, DatabaseSchema dbSchema) {
Set<String> tables = dbSchema.getTableNames();
Map<String, MonitorRequest> mrMap = Maps.newHashMap();
for (String tableName : tables) {
TableSchema tableSchema = dbSchema.getTableSchema(tableName);
MonitorRequest monitorRequest = getAllColumnsMonitorRequest(tableSchema);
mrMap.put(tableName, monitorRequest);
}
return Lists.newArrayList(dbSchema.name(), monotorId, mrMap);
}
/**
* Returns params of transact method, refer to RFC7047's Section 4.1.3.
* @param dbSchema DatabaseSchema entity
* @param operations operation*, refer to RFC7047's Section 4.1.3.
* @return List of Object, the params of transact request
*/
public static List<Object> getTransactParams(DatabaseSchema dbSchema, List<Operation> operations) {
return Lists.newArrayList(dbSchema.name(), operations);
}
}
......
......@@ -87,33 +87,29 @@ public final class TransValueUtil {
* @param atoType AtomicColumnType entity
* @return Object OvsdbSet or the value of JsonNode
*/
private static Object getValueFromAtoType(JsonNode json,
AtomicColumnType atoType) {
private static Object getValueFromAtoType(JsonNode json, AtomicColumnType atoType) {
BaseType baseType = atoType.baseType();
// If "min" or "max" is not specified, If "min" is not 1 or "max" is not
// 1,
// or both, and "value" is not specified, the type is a set of scalar
// type "key".
// Refer to RFC 7047, Section 3.2 <type>.
// 1, or both, and "value" is not specified, the type is a set of scalar
// type "key". Refer to RFC 7047, Section 3.2 <type>.
if (atoType.min() != atoType.max()) {
Set set = Sets.newHashSet();
if (json.isArray()) {
if (json.size() == 2) {
if (json.get(0).isTextual()
&& "set".equals(json.get(0).asText())) {
if (json.get(0).isTextual() && "set".equals(json.get(0).asText())) {
for (JsonNode node : json.get(1)) {
set.add(TransValueUtil.transToValue(node, baseType));
set.add(transToValue(node, baseType));
}
} else {
set.add(TransValueUtil.transToValue(json, baseType));
set.add(transToValue(json, baseType));
}
}
} else {
set.add(TransValueUtil.transToValue(json, baseType));
set.add(transToValue(json, baseType));
}
return OvsdbSet.ovsdbSet(set);
} else {
return TransValueUtil.transToValue(json, baseType);
return transToValue(json, baseType);
}
}
......@@ -123,19 +119,15 @@ public final class TransValueUtil {
* @param kvType KeyValuedColumnType entity
* @return Object OvsdbMap
*/
private static Object getValueFromKvType(JsonNode json,
KeyValuedColumnType kvType) {
private static Object getValueFromKvType(JsonNode json, KeyValuedColumnType kvType) {
if (json.isArray()) {
if (json.size() == 2) {
if (json.get(0).isTextual()
&& "map".equals(json.get(0).asText())) {
if (json.get(0).isTextual() && "map".equals(json.get(0).asText())) {
Map map = Maps.newHashMap();
for (JsonNode pairNode : json.get(1)) {
if (pairNode.isArray() && json.size() == 2) {
Object key = TransValueUtil.transToValue(pairNode
.get(0), kvType.keyType());
Object value = TransValueUtil.transToValue(pairNode
.get(1), kvType.valueType());
Object key = transToValue(pairNode.get(0), kvType.keyType());
Object value = transToValue(pairNode.get(1), kvType.valueType());
map.put(key, value);
}
}
......@@ -166,14 +158,13 @@ public final class TransValueUtil {
if (valueNode.isArray()) {
if (valueNode.size() == 2) {
if (valueNode.get(0).isTextual()
&& "uuid".equals(valueNode.get(0).asText())
|| "named-uuid".equals(valueNode.get(0).asText())) {
&& ("uuid".equals(valueNode.get(0).asText()) || "named-uuid"
.equals(valueNode.get(0).asText()))) {
return UUID.uuid(valueNode.get(1).asText());
}
}
} else {
return new RefTableRow(((UuidBaseType) baseType).getRefTable(),
valueNode);
return new RefTableRow(((UuidBaseType) baseType).getRefTable(), valueNode);
}
}
return null;
......