CN112235311B - OVSDB client code automatic generation method, system, device and medium - Google Patents

Abstract

The invention discloses a method, a system, equipment and a medium for automatically generating OVSDB client codes, wherein the method comprises the following steps: obtaining a Schema file to be analyzed and carrying out validity check; defining an analyzed data format, and analyzing the content in a legal Schema file into the data format; generating database Go language codes based on the analyzed data, comprising: generating a public code by combining the template code file; generating a code of each table entry by combining the template code file; the generated code is formatted. The invention uses the pre-written template code file to generate all codes, avoids the user from directly constructing the database operation codes by generating the table entry of the OVSDB, avoids the non-structured character string mapping by using the structured table entry data, reduces the difficulty of integrating the OVSDB by the Go language item, and increases the code readability and maintainability.

Description

OVSDB client code automatic generation method, system, device and medium

technical field

The invention belongs to the field of SDN (Software Defined Network) and databases, and in particular relates to an OVSDB client code automatic generation method, system, device and medium.

Background technique

The protocols in the SDN network can be divided into management plane protocols and control plane protocols according to their functions. Taking the SDN controller as the boundary, according to the level of the programmable interface, it can be divided into southbound interface and northbound interface. Strictly speaking, the OpenFlow protocol is a southbound interface protocol at the control level, while the OVSDB management protocol is a southbound interface protocol at the management level.

OVSDB Management Protocol (Open vSwitch Database Management Protocol, Open Virtual Switch Database Management Protocol) was originally proposed by VMware, which is responsible for managing the Open vSwitch Database (OVSDB) of open source software switches (OpenvSwitch, OVS). SDN management protocol for programmable access and configuration management of virtual switches. The OVSDB management protocol defines a set of RPC interfaces. Users can manage OVSDB through remote calls, mainly including communication protocol (JSON-RPC) methods and supported OVSDB operations. OVS is the main application of OVSDB. Its data schema is defined by OVSDB Schema (DB-SCHEMA). The switch supports data exchange with the controller through OVSDB. These data are stored in the OVSDB database in the form of tables. These tables are OVSDBSchema tables. When both the switch and the controller are OVSDB Client (to communicate with the ovsdb database server through the ovsdb management protocol), you can add rows to the table, and you can subscribe to the addition, deletion and modification of rows.

With the development of SDN and virtualization technologies, virtual switches have gradually replaced some traditional hardware switches by virtue of their flexible, elastic, and economical features, occupying a place in data center networks. OVSDB is also constantly optimizing and strengthening functional shortcomings, such as security, compatibility with protocol stacks, disaster recovery and escape. As a database, OVSDB defines the database table structure and member table item relationships based on the JSON format Schema, and supports RPC interface access and other features, and can also be used as a general-purpose database for wider applications.

The OVSDB management protocol in the prior art has the following problems:

1. There are a large number of hard-coded and highly repetitive operations in the database, which are tedious and error-prone;

2. In the business development stage, database table entries and fields are frequently added and modified, and the code that needs to be modified may not be found in time, leaving bugs;

3. The ovsdb-client operation command line needs to construct the database operation by itself, which is troublesome to use and cannot realize the rapid generation of test data.

At present, OVSDB is integrated in the OVS project using c language to implement its server code and client code.

SUMMARY OF THE INVENTION

Purpose of the invention: Aiming at the problems existing in the prior art, the present invention discloses an OVSDB client code automatic generation method, system, device and medium, which uses the database Schema file to automatically generate the relevant database Go language code defined by it, including the client Connection, operation API of each table item, table item data structure, and definition of related member range reduce the complexity of using OVSDB for Go language users, and improve code readability and maintainability.

Technical scheme: the present invention adopts the following technical scheme: a kind of OVSDB client code automatic generation method, is characterized in that, comprises the following steps:

S1. Obtain the schema file to be parsed, and check the validity of the schema file. The schema file defines attributes including database attributes and attributes of each table item in the database;

S2. Define the parsed data format, parse the content in the legal Schema file into the data format, and obtain the parsed data;

S3. Generate database Go language code based on the parsed data and template code file, wherein the template code file includes a pre-generated code template, including steps:

S31, traverse the parsed data, and generate public code according to the database attribute and in combination with the template code file;

S32, traverse the parsed data, and generate the API code of each table item according to the attributes of each table item and combined with the template code file;

S33. Format the common code and the API code of each table item to obtain the final database Go language code.

Preferably, in step S1, checking the validity of the Schema file includes operations: checking whether the Schema file exists and whether the opening and reading are normal; checking whether the content of the Schema file conforms to the Json format grammar; checking whether the relevant keywords in the content of the Schema file are not Compliant with the RFC7047 specification; check if the ovsdb-tool tool can be used to create a Schema file as a temporary database file.

Preferably, if the Schema file passes the validity check, the temporary database file is deleted; if the Schema file fails the validity check, specific error information is returned and the developer is instructed to locate and modify the Schema file.

Preferably, in step S2, the parsed data format is defined according to the RFC7047 specification.

Preferably, in step S2, the json deserialization function of the Go standard library is called to parse the content in the Schema file into a defined data format.

Preferably, before step S31 is performed, a storage path directory of the generated code is created, and if the directory already exists, the old files in the directory are cleared.

Preferably, step S33 includes operations: using the gofmt tool to format the code, including line feed, space, and bracket matching; using the goimport tool to format the code and import the dependency package.

An OVSDB client code automatic generation system is characterized in that, comprising:

Validity check module: used to obtain the schema file to be parsed, and check the validity of the schema file. The schema file defines attributes including the database attributes and the attributes of each table item in the database;

Parsing module: Define the parsed data format, parse the content of the legal Schema file into the data format, and obtain the parsed data;

Code generation module: Generate database Go language code based on the parsed data and template code files, where the template code files include pre-generated code templates, including:

Public code generation module: traverse the parsed data, generate public code according to the database attributes, combined with the template code file;

Table item code generation module: traverse the parsed data, generate the API code of each table item according to the properties of each table item, combined with the template code file;

Formatting module: Format the common code and the API code of each table item to get the final database Go language code.

Preferably, the validity check of the schema file by the validity check module includes: whether the schema file is opened and read normally, whether the content of the schema file conforms to the Json format syntax, whether the relevant keywords in the content of the schema file conform to the RFC7047 specification, and whether it can Use the ovsdb-tool tool to create the Schema file as a temporary database file.

Preferably, if the Schema file passes the validity check, the validity check module deletes the temporary database file; if the Schema file fails the validity check, the validity check module returns specific error information and guides developers to locate and modify the Schema file.

Preferably, the parsing module defines the parsed data format according to the RFC7047 specification.

Preferably, the parsing module calls the json deserialization function of the Go standard library to parse the content in the schema file into a defined data format.

Preferably, the code generation module further includes a directory creation module, which creates a storage path directory for the generated code, and clears old files in the directory if the directory already exists.

Preferably, the execution of the formatting module includes the following operations: using the gofmt tool to format the code, including matching of newlines, spaces, and brackets; using the goimport tool to format the code and import the dependency package.

A device for automatically generating OVSDB client code, comprising a processor, a memory, and a computer program stored in the memory and running on the processor, wherein the processor implements any of the above when executing the program. Describe the automatic generation method of OVSDB client code.

A computer-readable storage medium on which a computer program is stored, characterized in that, when the program is executed by a processor, the method for automatically generating an OVSDB client code described in any one of the above is implemented.

Beneficial effects: the present invention has the following beneficial effects:

The present invention uses the Go Json parsing package to deserialize the OVSDB Schema file, extracts detailed information such as key databases, database table items, table item fields, etc., classifies the OVSDB database, uses pre-written template code files to generate all codes, and generates OVSDB by generating OVSDB. The API for adding, deleting, modifying and checking each table entry prevents users from directly constructing database operation codes, and uses structured table item data to avoid unstructured string mapping, which reduces the difficulty of integrating OVSDB in Go language projects, and increases code readability and maintainability. sex.

Description of drawings

Fig. 1 is the code automatic generation flow chart of the present invention;

Fig. 2 is the process flow that the Schema file is checked for legitimacy in the present invention;

Fig. 3 is the data format after Json analysis in the present invention;

FIG. 4 is a list of APIs supported by various entries in the present invention.

Detailed ways

The present invention will be further described below in conjunction with the accompanying drawings.

The invention discloses an OVSDB client code automatic generation method, which uses the Go Json parsing package to deserialize the OVSDB Schema file, extracts detailed information such as key databases, database table items, table item fields, etc., classifies the OVSDB database, and uses the pre-written OVSDB database. The template code file for generating all codes, the code generation process is shown in Figure 1, including the following steps:

Step S1, Schema file validity check

First, obtain the OVSDB Schema file to be parsed. The Schema file is a collection of database objects, in which the table entry structure, attributes and relationships between table entries in the database are defined according to business requirements, including database name, database version number, The table item name and information about each table item, including the maximum number of rows and the data type, persistent attribute, maximum and minimum value, length range, value range, etc. of the fields in the table item.

After that, check the validity of the Schema file, as shown in Figure 2, including the following steps:

Step S11, check whether the Schema file exists, and whether the opening and reading of the Schema file are normal;

Step S12, after the check of step S11 is passed, check whether the content of the Schema file conforms to the Json format syntax;

Step S13, after the check of step S12 is passed, check whether the relevant keywords in the content of the Schema file conform to the RFC7047 specification;

After the checks of step S14 and step S13 are passed, check whether the Schema file can be created as a temporary database file using the ovsdb-tool tool;

After the checks in step S15 and step S14 are passed, the validity check of the schema file ends, the temporary database file is deleted, and the subsequent process is entered.

In step S11 to step S14, if any step fails, that is, the check fails, a specific error message is returned and the developer is instructed to locate and modify the Schema file.

After modifying the Schema file, the code is regenerated, and the modification of the relevant code can be checked with the compiler or even the editor.

Step S2, Json parsing

Step S21, define the data format after Json parsing according to the RFC7047 specification.

In an embodiment of the present invention, as shown in FIG. 3 , the parsed data will be stored in the structure DatabaseSchema for further processing.

Step S22, calling the Go standard library json deserialization method Unmarshal to parse the content of the Schema file into the DatabaseSchema structure to obtain the parsed data.

The structure DatabaseSchema includes: database name, database version number, and the substructure TableSchema of each table item; the substructure TableSchema of each table item includes: the index of the specific table item, the maximum number of rows, whether the attribute of the root table item or not, and the substructure ColumnSchema of each field ; Each field substructure ColumnSchema includes: the data type of the specific field and the field persistence attribute, the data type of the specific field can be interger, string, uuid, etc.

Extract key-value pairs from the Schema file. The key is the name of the field type in the Schema file, and the value is the value of the specific field type extracted from the Schema file. The reflection mechanism provided by the go language is used to process unstructured key-value pairs ( mapping) to a structure (struct), the specific method is to use the structure generated by the definition to obtain the type of its structure members through reflection, and then traverse the structure members to obtain the corresponding value from the unstructured key-value pair according to its type and write into a structure variable.

The table items according to the RFC specification sometimes cannot fully meet the business requirements, so the attributes of the table items need to be expanded. For example: add a default value attribute to some fields in the table item, obtain its default value during the parsing process and generate the corresponding constant, which can be directly written into the table item in the subsequent code; the extension method is to add the default value in the Schema file Add a json map tag to the specific field attribute of the table entry to describe the default value attribute. For example, add "default": 1000 to the max_number field attribute, and the default value of the maximum value in the table item is 1000.

For each table entry in the database, it is divided into three types: Global, Root and non-Root table entries according to its attributes, among which:

Global table item: the maximum number of rows is 1, one table row globally, no need to define an index, it is used to store system or business global information;

Root entry: The root attribute is true, an index needs to be defined, other entries can be referenced, and most APIs are supported;

Non-Root entry: must be referenced by at least one other entry, independent create and delete operations are not supported.

The specific APIs supported by Global, Root, and non-Root entries are shown in Figure 4.

Step S3, code generation

Generate database Go language code based on the parsed data and template code file, wherein the template code file includes pre-generated code templates, including steps:

Step S31 , creating a storage path directory of the generated code, and clearing the old files if the directory already exists.

Step S32, according to the database attributes, combined with the template code file to generate relevant public code and save it in a separate go file, including: database name, table item name definition; database client connection initialization function; general public constants and functions; database default value map initialization; OVSDB Transact operates public functions, etc.

Public codes include public functions and non-public functions. The names of public functions remain unchanged, and public functions can be directly generated by copying the template code file; the names of non-public functions change according to the content of the Schema file, and non-public functions can be modified by modifying the template code file. Part of the content in the generation, such as modifying part of the string, value.

Step S33, traverse all the table items, generate the API code of each table item according to the maximum number of rows and the attribute of the root table item, combined with the template code file, the API code provides a general function set, and the corresponding table item is developed by calling the API code , including: table entry data structure; table entry field definition; table entry index data structure (there can be multiple groups); definition of the maximum and minimum range of int type fields; , Clear operation API functions; generate appropriate comments for exportable variables or functions.

Save the API code of each table item to a separate go source file for each table item, named table_tablename.go.

For different types of table items, there are different API code templates in the template code file. According to the parsed table item name, field type and other attributes, the corresponding string in the template code can be replaced to generate the API code of the corresponding table item.

Step S34, formatting the code, including operations:

Use the gofmt tool to format all the generated code, so that the code has a uniform format (including line breaks, spaces, bracket matching, etc.);

Use the goimport tool to import the dependency package, format the code again, and get the final database Go language code.

In the code generated by the method of the present invention, regarding the index of the table item, OVSDB allows the table item to define multiple combined indexes, and does not limit the modification of the index field. In actual use, the value of the index field should be specified when adding the table item. , and no subsequent modifications are made; all non-global entries specify at least one index.

For fields of array type, when the maximum and minimum values are not specified or the specified maximum value is 1, the members in the table entry structure are optimized to the basic type, while the update operation is retained.

Regarding floating-point numbers, the basic data types that can be defined by OVSDB json include "real". When json is parsed, all data types are converted to float64 type, which needs to be converted to int type.

Data selection operation conditions support more operators "<", "<=", "==", "!=", ">=" and ">", Mutate also supports "+=", "-" for numbers =", "*=", "/=" or "%=", etc., these operations do not have a current general API, and can be implemented using the encapsulated MutateRows function.

The following uses specific embodiments to illustrate:

1. First, you need to have a database schema file, save it as "ovsdb.ovsschema" file name, the prepared schema file is as follows:

{

"name": "OVS_DB",

"tables": {

"Table_A": {

"columns": {

"name": {"type": "string"},

"num_id_1": {"type": "integer"},

"enable": {"type": "boolean"},

"reftable": {

"type": {"key": {"type": "uuid", "refTable": "Table_B"},

"min": 0, "max": "unlimited"}},

"set": {

"type": {"key": {"type": "string", "enum": ["set",

["physical_port", "lag", "vlan", "bridge_domain", "sub_port"]],

"default": "physical_port"}, "min": 1, "max": 128}},

"number": {

"type": {"key": {"type": "integer", "minInteger": 0, "maxInteger": 4294967295, "default": 1000}, "min": 0, "max": 1}} ,

"map": {

"type": {"key": "string", "value": "string",

"min": 0, "max": "unlimited"}}},

"indexes": [["name"], ["name", "num_id_1"]],

"isRoot": true},

"Table_B": {

"columns": {

"name": {"type": "string"},

"enable": {

"type": {"key": {"type": "boolean", "default": true}, "min": 0, "max": 1}}},

"indexes": [["name"]],

"isRoot": false},

"Table_Global": {

"columns": {

"name": {"type": "string"},

"set": {

"type": {"key": {"type": "string"}, "min": 1, "max": 128}},

"map": {

"type": {"key": "string", "value": "string",

"min": 0, "max": "unlimited"}}},

"maxRows": 1,

"isRoot": true}

},

"version": "1.0.0"

}

2. Execute this automatic code generation method: check the legality of the Schema file, perform Json parsing on the content of the Schema file, generate the database Go language code combined with the template code file and format it:

go run odbgen.go -f ovsdb.ovsschema

3. Check the generated Go code in the project lib/odbapi/ovsdb directory.

Examples of business development using the generated Go code in the project are as follows, including:

Database client connection initialization:

ovsdb.InitOvsdb(addrStr)

Create table entry:

tableA := ovsdb.TableTableA{

Name: "A1",

NumID1: "8",

Enable: true,

Number: 11111,

}

tableAUUID, err := ovsdb.TableAAdd(tableA)

Set the table entry fields:

ovsdb.TableASetField(indexA, ovsdb.TableAFieldSet, "A100")

ovsdb.TableASetField(indexA,ovsdb.TableAFieldNumber, 33333)

Get table entry:

indexA := ovsdb.TableAIndex{

Name: "A1",

}

tableA, err := ovsdb.TableAGetByIndex(indexA)

Traverse the database:

funcprintA(tableATableA){

fmt.printf("A: %v\n", tableA)

}

ovsdb.TableAIterator(printA)

Delete clear data:

ovsdb.TableADelByIndex(indexA)

ovsdb.TableAClear()

The invention discloses an OVSDB client code automatic generation system, comprising:

Validity check module: used to obtain the schema file to be parsed, and check the validity of the schema file. The schema file defines attributes including the database attributes and the attributes of each table item in the database;

Parsing module: Define the parsed data format according to the RFC7047 specification, parse the content of the legal Schema file into the data format, and obtain the parsed data;

Code generation module: Generate database Go language code based on the parsed data and template code files, where the template code files include pre-generated code templates, including:

The directory creation module creates the storage path directory of the generated code, and if the directory already exists, clears the old files in the directory;

Public code generation module: traverse the parsed data, generate public code according to the database attributes, combined with the template code file;

Table entry code generation module: traverse the parsed data, generate the API code of each table entry according to the attributes of each table item, combined with the template code file, and save the API code of each table item as a separate go source file for the table item ;

Formatting module: Format the common code and the API code of each table item to get the final database Go language code.

Among them, the legitimacy check module checks the legitimacy of the Schema file, including: whether the opening and reading of the Schema file are normal, whether the content of the Schema file conforms to the Json format syntax, whether the relevant keywords in the content of the Schema file conform to the RFC7047 specification, and whether it can be used. The ovsdb-tool tool creates schema files as temporary database files. If the schema file passes the validity check, the validity check module deletes the temporary database file; if the schema file fails the validity check, the validity check module returns a specific error message and guides developers to locate and modify the schema file.

The parsing module defines the parsed data format according to the RFC7047 specification, and the parsing module calls the Go standard library json deserialization function to parse the content in the Schema file into the data format.

The execution of the formatting module includes the following operations: the gofmt tool formats the code, including line breaks, spaces, and bracket matching; uses the goimport tool to format the code and import dependent packages.

The invention discloses an OVSDB client code automatic generating device, comprising a processor, a memory and a computer program stored in the memory and running on the processor, the processor implements the above OVSDB client code when the processor executes the program Automatically generate methods.

The present invention discloses a computer-readable storage medium on which a computer program is stored. When the program is executed by a processor, the above-mentioned OVSDB client code automatic generation method is realized.

The above is only the preferred embodiment of the present invention, it should be pointed out that: for those skilled in the art, without departing from the principle of the present invention, several improvements and modifications can also be made, and these improvements and modifications are also It should be regarded as the protection scope of the present invention.

Claims (16)

1. An OVSDB client code automatic generation method is characterized by comprising the following steps:

s1, obtaining a Schema file to be analyzed, and checking the validity of the Schema file, wherein the Schema file defines attributes including the attributes of the database and the attributes of each item in the database;

s2, defining the analyzed data format, and analyzing the content in the legal Schema file into the data format to obtain the analyzed data;

s3, generating a database Go language code based on the analyzed data and a template code file, wherein the template code file comprises a pre-generated code template, and the method comprises the following steps:

s31, traversing the analyzed data, and generating a public code by combining the template code file according to the database attribute;

s32, traversing the analyzed data, and generating an API code of each table entry by combining the template code file according to the attributes of each table entry;

and S33, formatting the public codes and the API codes of each table entry to obtain the final database Go language codes.

2. The method according to claim 1, wherein in step S1, the checking validity of Schema file includes operations of: checking whether the Schema file exists and whether the Schema file is opened and read normally; checking whether the content of the Schema file conforms to Json format grammar; checking whether relevant keywords in the contents of the Schema file conform to RFC7047 specifications; it is checked whether the Schema file can be created as a temporary database file using the ovsdb-tool.

3. The method for automatically generating OVSDB client codes according to claim 2, wherein if the Schema file passes the validity check, the temporary database file is deleted; and if the legality check of the Schema file fails, returning specific error information and guiding a developer to position and modify the Schema file.

4. The OVSDB client code automatic generation method according to claim 1, wherein in step S2, the parsed data format is defined according to the RFC7047 specification.

5. The method for automatically generating OVSDB client codes according to claim 1, wherein in step S2, a Go standard library json deserialization function is called to parse contents in the Schema file into a defined data format.

6. The method of claim 1, wherein before step S31, a storage path directory of the generated code is created, and if the directory already exists, the old file in the directory is cleared.

7. The method for automatically generating OVSDB client code according to claim 1, wherein step S33 includes the operations of: formatting the code by using a gofmt tool, wherein line feed, blank space and bracket matching are included; and formatting the code by using a goimport tool, and importing the dependency package.

8. An OVSDB client code automatic generation system, comprising:

a validity checking module: the method comprises the steps that the method is used for obtaining a Schema file to be analyzed and carrying out validity check on the Schema file, wherein the Schema file defines attributes comprising attributes of a database and attributes of each item in the database;

an analysis module: defining an analyzed data format, and analyzing the content in a legal Schema file into the data format to obtain analyzed data;

a code generation module: generating a database Go language code based on the analyzed data and a template code file, wherein the template code file comprises a pre-generated code template, and the method comprises the following steps:

a common code generation module: traversing the analyzed data, and generating a public code by combining a template code file according to the database attribute;

the table entry code generation module: traversing the analyzed data, and generating an API code of each table entry by combining the template code file according to the attribute of each table entry;

a formatting module: and formatting the public codes and the API codes of each table entry to obtain the final Go language code of the database.

9. The OVSDB client code automatic generation system according to claim 8, wherein the validity checking module performing validity checking on the Schema file includes: whether the Schema file is normally opened and read, whether the Schema file content conforms to Json format syntax, whether related keywords in the Schema file content conform to RFC7047 specifications and whether the Schema file can be created into a temporary database file by using an ovsdb-tool.

10. The OVSDB client code automatic generation system according to claim 9, wherein if the Schema file passes the validity check, the validity check module deletes the temporary database file; and if the Schema file fails to pass the validity check, the validity check module returns specific error information and guides a developer to position and modify the Schema file.

11. The OVSDB client code automatic generation system according to claim 8, wherein the parsing module defines the parsed data format according to the RFC7047 specification.

12. The OVSDB client code automatic generation system according to claim 8, wherein the parsing module invokes a Go standard library json deserialization function to parse contents in the Schema file into a defined data format.

13. The OVSDB client code automatic generation system according to claim 8, wherein the code generation module further comprises a directory creation module that creates a storage path directory of the generated code and clears an old file under the directory if the directory already exists.

14. The OVSDB client code automatic generation system of claim 8, wherein the formatting module performs operations comprising: formatting the code by using a gofmt tool, wherein line feed, blank space and bracket matching are included; and formatting the code by using a goimport tool, and importing the dependency package.

15. An OVSDB client code automatic generation device, comprising a processor, a memory and a computer program stored on the memory and operable on the processor, wherein the processor implements the OVSDB client code automatic generation method according to any one of claims 1 to 7 when executing the program.

16. A computer-readable storage medium, on which a computer program is stored, which, when executed by a processor, implements a method for automatic generation of OVSDB client code according to any one of claims 1 to 7.

Images