cordova-sqlite-storage:基于 Cordova/PhoneGap 的 SQLite 数据库插件项目

鸿蒙cordova的数据库插件

Branch5Tags3

cordova-sqlite-storage

zh-CN en

This project is developed based on cordova-sqlite-storage@7.0.0. This document focuses on its specific application in the OpenHarmony (OHOS) system.

Introduction

cordova-sqlite-storage is a lightweight and efficient SQLite database plugin designed specifically for Cordova/PhoneGap applications. Based on the native SQLite engine, it provides a simple and easy-to-use API interface, supporting core capabilities such as cross-platform data storage, transaction management, and batch operations. It is an ideal solution for local data persistence in hybrid mobile applications, widely applicable to scenarios such as offline data caching, local business data management, and log storage. This document only introduces the application, installation, configuration, usage methods, and precautions of this plugin in the OHOS system, helping developers quickly integrate local database functionality, with emphasis on the characteristics and usage specifications of the OHOS platform.

Features

  • Full Platform Compatibility: Perfectly supports the three major mobile platforms - Android, iOS, and OHOS, adapting to the latest version features of each system, with a focus on adapting to OHOS 5.0+ system, following OHOS system native specifications

  • Native Performance Enhancement: Developed based on the system's native SQLite engine, avoiding the performance loss of JS-simulated databases, with fast operation response and high read/write efficiency, adapting to OHOS system performance optimization requirements

  • Complete Transaction Support: Supports explicit transactions (BEGIN/COMMIT/ROLLBACK) and implicit transactions, ensuring atomicity and consistency of data operations, effectively avoiding data corruption

  • Batch Operation Optimization: Provides batch execution SQL interface, greatly improving the efficiency of large-scale data insertion and updates, reducing IO overhead, adapting to OHOS system IO operation specifications

  • Version Migration Support: Built-in database version management mechanism, achieving smooth table structure changes and data migration through upgrade callbacks, without manual handling of old version data compatibility issues

  • Flexible Storage Location: Supports configuring database storage paths, adapting to Android partitioned storage and iOS/OHOS sandbox mechanisms, allowing storage location selection based on business requirements, complying with OHOS system sandbox security specifications

  • Rich Error Feedback: Provides detailed error codes and description information, facilitating quick issue identification and debugging for developers, reducing integration difficulty

  • In-Memory Database Support: Supports creating pure in-memory databases, suitable for temporary data processing scenarios, with data automatically cleared after application exit, saving OHOS system storage resources

OHOS Platform Characteristics

The implementation of this plugin on the OHOS platform aligns with the system's native storage specifications. The core characteristics and special restrictions are as follows, requiring special attention:

  • Adapts to OHOS Sandbox Mechanism: Database files are stored in the application sandbox path by default, unable to access files outside the sandbox, ensuring system data security

  • Version Compatibility: Adapts to OHOS 5.0+ system, supports DevEco Studio 5.0+ development environment, SDK must be API12+, ensuring stable plugin functionality

  • Transaction Stability: Optimizes transaction processing for OHOS system asynchronous operation mechanisms, avoiding transaction anomalies caused by system scheduling, ensuring data consistency

  • Memory Optimization: Adapts to OHOS system memory management mechanism, automatically releasing resources after closing the database, reducing memory usage, improving application runtime stability

Supported Platforms

  • OHOS (5.0+, adapts to system sandbox mechanism, supports database creation, transactions, batch operations, compatible with DevEco Studio 5.0+)

  • Android (adapts to mainstream versions, supports full functionality, adapts to partitioned storage, no special permission restrictions)

  • iOS (adapts to mainstream versions, supports full functionality, follows iOS sandbox mechanism, no additional permission configuration required)

Prerequisites

Before integrating the plugin, ensure that the development environment meets the basic requirements and complete the necessary prerequisite configurations. The specific steps are as follows:

  • Node.js (v14.0.0 or higher) and npm (v6.0.0 or higher) installed, versions can be verified with node -v and npm -v commands;

  • HCordova CLI (v10.0.0 or higher) installed globally for plugin installation, uninstallation, and management;

  • Cordova project created (if not yet created, quickly create with cordova create sqliteApp com.example.sqliteapp SQLiteApp command);

  • Ensure the project adapts to OHOS 5.0 or higher version, DevEco Studio version is 5.0+, SDK is API12+, avoiding plugin functionality anomalies due to low versions;

  • Familiar with OHOS system sandbox path specifications, understand Cordova plugin file access methods on OHOS platform.

Installation

Plugins can be quickly installed via HCordova CLI, supporting full platform installation or OHOS-specific platform installation. The installation process is simple and efficient, and installation results can be verified through commands after installation.

Prerequisites

Before installing the plugin, HCordova CLI needs to be installed. Execute the following command for installation:

npm install -g hcordova

Execute the following commands in the Cordova project root directory. The plugin will automatically handle platform dependencies and basic configurations. The latest stable version is installed by default, specifying OHOS platform installation:

# Install for all platforms
hcordova plugin add cordova-sqlite-storage

# Install the latest stable version (OHOS platform only)
hcordova plugin add cordova-sqlite-storage --platform ohos

# Install a specific version (example: version 1.0.0, OHOS platform only)
hcordova plugin add cordova-sqlite-storage@1.0.0 --platform ohos

Install Development Version from GitCode

If you need to use the latest features under development, you can install directly from the GitCode repository, adapted for OHOS platform only:

# Non-encrypted development version
hcordova plugin add https://gitcode.com/CPF-Cordova/Cordova-sqlite-storage.git --platform ohos

# Install from specific tag/branch
hcordova plugin add https://gitcode.com/CPF-Cordova/Cordova-sqlite-storage.git@develop --platform ohos

Offline Installation (Local Package)

For environments without network access, download the plugin package locally first, then perform offline installation:

# Download the plugin package locally (example path: ../Downloads/cordova-sqlite-storage)
# Perform offline installation
hcordova plugin add ../Downloads/cordova-sqlite-storage --platform ohos

Post-Installation Verification

After installation, verify that the plugin has been successfully added to the project using the following command:

# List installed plugins; if the plugin ID appears, the plugin was successfully installed
hcordova plugin list

Uninstall Plugin

To remove the plugin, execute the following command to clean up related configurations and dependencies, supporting full platform uninstallation or OHOS-specific platform uninstallation:

# Uninstall database plugin from all platforms
hcordova plugin remove cordova-sqlite-storage

# Uninstall from OHOS platform only
hcordova plugin remove cordova-sqlite-storage --platform ohos

Constraints and Limitations

  • Dependencies: No mandatory dependencies, @cordova-ohos/ohos version 2.0.0 or higher;

  • Platform Limitations: OHOS platform only supports version 5.0+. Systems below this version may experience issues such as database creation failure and API call exceptions;

  • Path Limitations: Only supports OHOS system sandbox paths, unable to access files outside the sandbox;

  • API Call Timing: All JavaScript APIs must be called after the deviceready event is triggered; otherwise, exceptions such as window.sqlitePlugin object being undefined or call failures will occur;

  • Database Connection Limitations: It is recommended to maintain a single database instance globally in the application to avoid frequent connection creation and closure, which otherwise would cause performance loss and connection exceptions;

Compatibility

Supported:

Item Version/Info
SDK API12+
IDE DevEco Studio: 5.0+
ROM 5.1+
Emulator OpenHarmony 6.0+

Tested with the following versions:

Item Version/Info
@cordova-ohos/ohos 14.0.1-ohos-14.0.1
SDK 5.0.0(12)
IDE DevEco Studio: 6.0.13.200
ROM 5.1.0.120 SP3
Emulator OpenHarmony 6.0.1(21)

Usage Examples

The plugin exposes all core APIs through the global object window.sqlitePlugin. All operations are executed asynchronously, with results handled via callback functions. All APIs must be called after the deviceready event is triggered. The following are complete usage examples of core functions for the OHOS platform, which can be copied directly into your project.

1. Open/Create Database (Core Operation)

Open an existing database, or create a new one if it doesn't exist, and globally maintain a database instance to avoid frequent connection creation:

// Wait for Cordova environment to be ready
document.addEventListener('deviceready', function() {
    /**
     * Open/Create database
     * @param {Object} options - Database configuration options
     * @param {Function} successCallback - Success callback (parameter: db database instance)
     * @param {Function} errorCallback - Error callback (parameter: error error object)
     */
    const global_db = window.sqlitePlugin.openDatabase({
        name: 'tonge.db', // Database name
        location: 'default' // Default storage location
    }, function(db) {
        console.log("Database opened/created successfully");
        // Database instance is globally available
        window.global_db = db;
    }, function(error) {
        console.error("Database opened/creation failed:", error);
        alert("Database initialization failed");
    });
}, false);

2. Transaction Operation (Batch Execute SQL)

Open an explicit transaction to batch execute table creation, data insertion, and other operations, ensuring atomicity, suitable for initializing database table structures:

// Wait for Cordova environment to be ready
document.addEventListener('deviceready', function() {
    // First open the database
    var global_db = window.sqlitePlugin.openDatabase({name: 'tonge.db', location: 'default'});
    
    /**
     * Execute transaction
     * @param {Function} transactionCallback - Transaction callback (parameter: tx transaction object)
     * @param {Function} errorCallback - Transaction failure callback (parameter: error error object)
     * @param {Function} successCallback - Transaction success callback (no parameters)
     */
    global_db.transaction(function(tx) {
        // Batch create table structures
        tx.executeSql('CREATE TABLE IF NOT EXISTS TONGE_CONFIG_SYS(ID INTEGER PRIMARY KEY AUTOINCREMENT, CONF_KEY VARCHAR(64), CONF_VALUE VARCHAR(512))');
        tx.executeSql('CREATE TABLE IF NOT EXISTS TONGE_SYS_CONST(ID INTEGER PRIMARY KEY AUTOINCREMENT, CONF_KEY VARCHAR(64), CONF_VALUE VARCHAR(4096))');
        tx.executeSql('CREATE TABLE IF NOT EXISTS TONGE_MEM_ACCOUNT(ID INTEGER PRIMARY KEY AUTOINCREMENT, MEM_ACCOUNT VARCHAR(64), MEM_NAME VARCHAR(128), MEM_PASSWORD VARCHAR(128))');
    }, function(error){
        // Transaction execution failed, automatically rollback
        console.error("Transaction execution failed:", error);
        alert("Database initialization failed"+error);
    }, function(){
        // Transaction execution successful, all operations committed
        console.log("Database table structure created successfully");
    });
}, false);

3. Execute SQL Statements (CRUD)

Execute query, insert, update, delete and other SQL operations through the executeSql method. The following are examples of common scenarios:

// Wait for Cordova environment to be ready
document.addEventListener('deviceready', function() {
    // Global database instance
    var global_db = window.sqlitePlugin.openDatabase({name: 'tonge.db', location: 'default'});

    // 1. Insert/Update data (example: update system constant, insert if not exists)
    function updateConst(confKey, confVale, callBack) {
        global_db.transaction(function(tx) {
            tx.executeSql("update TONGE_SYS_CONST set CONF_VALUE=? where CONF_KEY=?", [confVale, confKey], function(tx, result){
                if(result.rowsAffected == 0) {
                    // No matching data, execute insert
                    tx.executeSql("insert into TONGE_SYS_CONST(CONF_KEY, CONF_VALUE) values(?, ?)", [confKey, confVale], function(tx, result) {
                        console.log("System constant inserted successfully:", confKey);
                    });
                } else {
                    console.log("System constant updated successfully:", confKey);
                }
            });
        }, function(error){
            console.error("updateConst failed:", error);
        },function(){
            console.log("updateConst execution completed:"+confKey);
            callBack && callBack();
        });
    }

    // 2. Query data (example: query member account information)
    function getMemAccount(memAccount, getMemAccountSuccess) {
        var rows = null;
        // Read transaction (executes only query operations, better performance)
        global_db.readTransaction(function(tx) {
            tx.executeSql("select * from TONGE_MEM_ACCOUNT where MEM_ACCOUNT=?", [memAccount], function(tx, result) {
                rows = result.rows; // Result set
            });
        }, function(error){
            console.error("getMemAccount failed:", error);
        },function(){
            if(rows.length != 0) {
                // Get record at specified index
                getMemAccountSuccess && getMemAccountSuccess(rows.item(0));
            } else {
                console.log("No login member data retrieved");
            }
        });
    }

    // 3. Delete/Insert data (example: insert corporate user, delete old data first)
    function insertCorpUser(user, callBack) {
        global_db.transaction(function(tx) {
            tx.executeSql("delete from TONGE_CORP_USER where USER_NAME=?", [user.userName], function(tx, result) {
                // Execute insert after deletion
                tx.executeSql("insert into TONGE_CORP_USER(USER_NAME, PASSWD, CORP_ID,CORP_NAME,SHOP_ID,SHOP_NAME,MEM_SERVER_ID,SMS_SERVER_ID,CORP_SERVER_ID,USER_TYPE,USER_AUTHORITY1,USER_AUTHORITY2,FUNCTION_ID,CARD_KIND,SELF_OPTION,FUNCTION_OPTION,FUNCTION_OPTION2,DISCOUNT,SHOP_SELF_OPTION,FIELDS_MUST,STAFF_ID, SYS_VERSION, LAST_DT, PIC_URL, FUNCTION_ROLE,START_DT) values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",[user.userName, user.passwd, user.corpId, user.corpName, user.shopId, user.shopName, user.memServerId, user.smsServerId, user.corpServerId, user.userType, user.userAuthority1, user.userAuthority2, user.functionId, user.cardKind, user.selfOption, user.functionOption, user.functionOption2, user.discount, user.shopSelfOption, user.fieldsMust, user.staffId, user.sysVersion, user.lastDt, user.picUrl,user.functionRole,user.startDt], function(tx, result){
                    if(result.rowsAffected != 1) {
                        console.log("insertCorpUser failed, rows affected:"+result.rowsAffected);
                    }
                });
            });
        }, function(error){
            console.error("insertCorpUser failed:", error);
        },function(){
            console.log("insertCorpUser succeeded");
            callBack && callBack();
        });
    }

    // Call examples
    updateConst("system_version", "1.0.0", function() {
        console.log("System version update completed");
    });
    getMemAccount("test123", function(userInfo) {
        console.log("Member information retrieved:", userInfo);
    });
}, false);

4. Close and Delete Database

Close database connections to release resources, delete database files (connection must be closed first), suitable for application exit or data cleanup scenarios:

// Wait for Cordova environment to be ready
document.addEventListener('deviceready', function() {
    // Global database instance
    var global_db = window.sqlitePlugin.openDatabase({name: 'tonge.db', location: 'default'});

    // 1. Close database
    function closeDatabase(callback) {
        global_db.close(function() {
            console.log("Database closed successfully, resources released");
            if (callback) {
                callback();
            }
        }, function(error) {
            console.error("Database close failed:", error);
        });
    }

    // 2. Delete database (database connection must be closed first)
    function deleteDatabase() {
        // First close the connection
        closeDatabase(function() {
            sqlitePlugin.deleteDatabase("tonge.db", function() {
                console.log("Database deleted successfully");
            }, function(error) {
                console.error("Database deletion failed:", error);
            })
        );
    }

    // Call close database before application exit
    window.addEventListener('beforeunload', function() {
        closeDatabase();
    });

    // Call delete database (use with caution, will delete all data)
    // deleteDatabase();
}, false);

5. Database Version Migration

When the database version number increases, the upgrade callback is triggered to execute table structure modifications and data migration operations, ensuring old version data compatibility:

// Wait for Cordova environment to be ready
document.addEventListener('deviceready', function() {
    const global_db = window.sqlitePlugin.openDatabase({
        name: 'tonge.db',
        location: 'default',
        version: '2.0' // Version number increased from 1.0 to 2.0, triggering upgrade callback
    }, function(db) {
        console.log("Database opened successfully (version 2.0)");
    }, function(error) {
        console.error("Database open failed:", error);
    }, function(db, oldVersion, newVersion, tx) {
        // Version migration callback (oldVersion: old version number, newVersion: new version number)
        console.log("Database version migration:", oldVersion, "->", newVersion);
        if(oldVersion < 2) {
            // Migration from version 1.0 to 2.0, add new field
            tx.executeSql("ALTER TABLE TONGE_SYS_CONST ADD COLUMN UPDATE_TIME DATETIME DEFAULT CURRENT_TIMESTAMP");
            console.log("Version migration completed, UPDATE_TIME field added");
        }
    });
}, false);

Usage Instructions

The following are core instructions for plugin usage, including API details, parameter descriptions, frequently asked questions, and important notes, helping developers get started quickly and avoid exceptions, with emphasis on OHOS platform characteristics and limitations.

1. Core API Description

All plugin methods are mounted under the global window.sqlitePlugin object, no additional imports required. All operations are executed asynchronously, with results handled via callback functions. All APIs must be called after the deviceready event is triggered.

1.1 Open/Create Database (Core API)

Function: Opens an existing database, or creates a new one if it doesn't exist, returning a database instance. This is the foundation for all database operations.

Syntax:

sqlitePlugin.openDatabase(options, successCallback, errorCallback);

Parameter Description:

  • options: Configuration parameter object, required, contains the following properties:
    • name: Database name, required, string type;
    • location: Storage location, optional, default "default";
  • successCallback: Success callback, parameter is db (database instance), triggered when database opening/creation is successful;
  • errorCallback: Failure callback, parameter is error (error object), contains error code and description;

1.2 Transaction Operation (Core API)

Function: Opens an explicit transaction to batch execute SQL operations, ensuring atomicity, either all succeed or all roll back.

Syntax (write transaction, supports CRUD):

db.transaction(transactionCallback, errorCallback, successCallback);

Syntax (read transaction, supports only queries, better performance):

db.readTransaction(transactionCallback, errorCallback, successCallback);

Parameter Description:

  • transactionCallback: Transaction callback, required, parameter is tx (transaction object), used to execute SQL operations;
  • errorCallback: Transaction failure callback, optional, parameter is error (error object), triggered when an error occurs during transaction execution, automatically rolls back;
  • successCallback: Transaction success callback, optional, no parameters, triggered when all SQL operations are completed without errors, automatically commits.

1.3 Execute SQL Statement (Core API)

Function: Executes SQL statements through the transaction object, supporting all SQL operations such as query, insert, update, delete.

Syntax:

tx.executeSql(sql, params, successCallback, errorCallback);

Parameter Description:

  • sql: SQL statement, required, string type, supports all standard SQLite SQL statements;
  • params: SQL parameter array, optional, used to replace placeholders (?) in SQL statements, preventing SQL injection;
  • successCallback: Success callback, optional, parameters are (tx, result), result is the result set object;
  • errorCallback: Failure callback, optional, parameter is error (error object), triggered when SQL execution fails.

Result Set (result) Property Description:

  • rows.length: Total number of records in the query result;
  • rows.item(index): Gets the record at the specified index, returns an object;
  • rowsAffected: Number of rows affected by insert, update, or delete operations.

1.4 Close Database

Function: Closes the database connection and releases system resources. It is recommended to execute this before application exit.

Syntax:

db.close(successCallback, errorCallback);

Parameter Description:

  • successCallback: Success callback, optional, no parameters, triggered when the database is closed successfully;
  • errorCallback: Failure callback, optional, parameter is error (error object), triggered when closure fails.

1.5 Delete Database

Function: Deletes the database file with the specified name. The database connection must be closed first; otherwise, deletion will fail.

Syntax:

sqlitePlugin.deleteDatabase(dbName, successCallback, errorCallback);

Parameter Description:

  • dbName: Database name, required, string type, consistent with the name used during creation;
  • successCallback: Success callback, optional, no parameters, triggered when the database is deleted successfully;
  • errorCallback: Failure callback, optional, parameter is error (error object), triggered when deletion fails.

2. Frequently Asked Questions (FAQ)

Q1: What if database creation fails after calling openDatabase?

  1. Check version compatibility: Ensure OHOS system version is 5.0+, DevEco Studio version is 5.0+, SDK is API12+;
  2. Check plugin installation: Execute hcordova plugin list to confirm the plugin is successfully installed. If not, re-run the installation command;
  3. Check database name: Avoid special characters in the database name, recommend using combinations of letters, numbers, and underscores.

Q2: What if "table not found" is prompted when executing SQL statements?

  1. Check table creation statement: Confirm the CREATE TABLE statement syntax is correct, and whether the IF NOT EXISTS keyword is added (to avoid duplicate creation);
  2. Check transaction execution: Ensure the table creation statement is executed within a transaction and the transaction has been successfully committed;
  3. Check database instance: Ensure using the correct database instance to execute SQL statements, avoiding instances that are uninitialized or closed;
  4. Check version migration: If the database version is upgraded, confirm that table structures are correctly created or modified in the version migration callback.

Q3: What if data is not rolled back after transaction execution fails?

The plugin supports transaction rollback by default. If rollback does not occur, check the following points:

  1. Confirm use of explicit transactions: Single SQL operations default to implicit transactions and will roll back automatically on failure; for explicit transactions, ensure no manual commit in the errorCallback;
  2. Check error trigger timing: Ensure that when SQL statement execution fails in the transaction, the errorCallback is triggered, which will then automatically roll back;
  3. Check database connection: Avoid closing the database connection during transaction execution, as this would cause transaction anomalies preventing normal rollback.

Q4: What if batch data insertion/update efficiency is low?

Optimize large-scale data operation efficiency through the following methods:

  1. Use explicit transactions: Place all batch operations in a single transaction to reduce IO overhead;
  2. Use parameterized SQL: Pass parameters through the params array to avoid SQL string concatenation, improving execution speed;
  3. Reduce callback nesting: Avoid triggering callbacks after each SQL execution, handle results uniformly after batch execution completes;
  4. Optimize data volume: If the data volume is extremely large, execute in batches to avoid consuming excessive system resources in a single operation.

Q5: What if database data is lost after the application exits?

  1. Check transaction commit: Ensure all insert, update, delete operations have been committed through transactions; uncommitted transactions result in data not being persisted;
  2. Check database closure: Before application exit, ensure the close method has been called to close the database, avoiding incomplete data writes.

3. Important Notes

  • API Call Timing: All JavaScript APIs must be called after the deviceready event is triggered; otherwise, exceptions such as window.sqlitePlugin object being undefined or call failures will occur.

  • Database Connection: It is recommended to maintain a single database instance globally in the application to avoid frequent connection creation and closure, which otherwise would cause performance loss and connection exceptions; ensure the database is closed before application exit to release resources.

  • Transaction Usage: For large-scale data operations, it is recommended to use explicit transactions to ensure atomicity while improving execution efficiency; for read operations, it is recommended to use readTransaction for better performance.

  • SQL Syntax: Follow SQLite standard SQL syntax, avoid platform-specific SQL statements to ensure cross-platform compatibility; prevent SQL injection by prioritizing parameterized SQL.

  • Version Migration: Database version numbers can only be increased, not decreased; only execute table structure modifications and data migration operations in version migration callbacks, avoiding complex business logic.

  • Data Security: It is recommended to configure database encryption for sensitive data and keep encryption passwords secure; avoid storing large amounts of large data (such as images, videos), recommend storing only file paths with files stored separately.

  • Error Handling: It is recommended to add error callbacks for all API calls to capture exceptions, enabling quick issue identification based on error information and improving application stability.

Directory Structure

cordova-sqlite-storage                 # [Root] SQLite local storage plugin project root directory
├── src                                # [Source] Contains native platform code
│   └── main                           # [Main] Main code directory
│       └── cpp                        # [C++] C++ native code directory
│           └── sqlc                   # [C++ Module] SQLite C++ encapsulation module folder
│               ├── sqlite3.c          # [C Source] C language implementation of SQLite core library
│               ├── sqlite3.h          # [C Header] Header file of SQLite core library
│               ├── SQLiteConnectorDatabase.cpp # [C++ Implementation] Database connector implementation, handles database connection logic
│               ├── SQLiteConnectorDatabase.h   # [C++ Header] Database connector header file
│               ├── SQLiteHarmonyDatabase.cpp   # [C++ Implementation] OHOS system database adaptation implementation
│               ├── SQLiteHarmonyDatabase.h     # [C++ Header] OHOS system database adaptation header file
│               ├── SQLitePlugin.cpp            # [C++ Implementation] Plugin main logic, interfaces exposed to Cordova
│               └── SQLitePlugin.h              # [C++ Header] Plugin interface definitions
├── www                                # [Frontend] Contains JavaScript interface files
│   ├── LICENSE                        # [Text] Open source license for frontend code
│   └── SQLitePlugin.js                # [JS File] JavaScript interface exposed to Web frontend
├── .gitignore                         # [Config] Git version control ignore file configuration
├── LICENSE                            # [Text] Open source license at project root
├── OAT.xml                            # [Config] Gate configuration file
├── package.json                       # [Config] NPM package configuration file
├── plugin.xml                         # [Config] Cordova plugin core configuration file
└── README.md                          # [Document] Project documentation

Contribute

If you encounter any issues during use, please feel free to submit an Issue. Pull requests PR for collaborative development are also very welcome.

License

This plugin is open-sourced under the Apache License 2.0. See the LICENSE file for details.

Official Resources