143 lines
3.5 KiB
Go
143 lines
3.5 KiB
Go
package main
|
|
|
|
import (
|
|
"beckn-onix/plugins/plugin_definition"
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"log"
|
|
"plugin"
|
|
"strings"
|
|
|
|
"gopkg.in/yaml.v2"
|
|
)
|
|
|
|
type PluginConfig struct {
|
|
Plugins Plugins `yaml:"plugins"`
|
|
}
|
|
|
|
type Plugins struct {
|
|
ValidationPlugin ValidationPlugin `yaml:"validation_plugin"`
|
|
}
|
|
|
|
type ValidationPlugin struct {
|
|
ID string `yaml:"id"`
|
|
Config PluginDetails `yaml:"config"`
|
|
PluginPath string `yaml:"plugin_path"`
|
|
}
|
|
|
|
type PluginDetails struct {
|
|
Schema string `yaml:"schema_dir"`
|
|
}
|
|
|
|
type Payload struct {
|
|
Context struct {
|
|
Domain string `json:"domain"`
|
|
Version string `json:"version"`
|
|
} `json:"context"`
|
|
}
|
|
|
|
// PluginManager manages the loading and execution of plugins.
|
|
type PluginManager struct {
|
|
validatorProvider plugin_definition.ValidatorProvider
|
|
}
|
|
|
|
// NewValidatorProvider initializes the PluginManager with the given configuration.
|
|
func NewValidatorProvider(pluginsConfig PluginConfig) (*PluginManager, error) {
|
|
validationPlugin := pluginsConfig.Plugins.ValidationPlugin
|
|
|
|
if validationPlugin.ID == "" {
|
|
return nil, fmt.Errorf("validation_plugin ID is empty")
|
|
}
|
|
|
|
pluginPath := validationPlugin.PluginPath + validationPlugin.ID + ".so"
|
|
|
|
// Check if the plugin path is empty
|
|
if pluginPath == "" {
|
|
return nil, fmt.Errorf("plugin path is empty")
|
|
}
|
|
|
|
// Load the plugin
|
|
p, err := plugin.Open(pluginPath)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to open plugin: %v", err)
|
|
}
|
|
|
|
vpSymbol, err := p.Lookup("GetProvider")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
getProviderFunc, ok := vpSymbol.(func() plugin_definition.ValidatorProvider)
|
|
if !ok {
|
|
return nil, fmt.Errorf("failed to cast to *plugin_definition.ValidatorProvider")
|
|
}
|
|
|
|
validatorProvider := getProviderFunc()
|
|
|
|
return &PluginManager{validatorProvider: validatorProvider}, nil
|
|
}
|
|
|
|
// loadPluginsConfig loads the plugins configuration from a YAML file.
|
|
func loadPluginsConfig(filePath string) (PluginConfig, error) {
|
|
data, err := ioutil.ReadFile(filePath)
|
|
if err != nil {
|
|
return PluginConfig{}, err
|
|
}
|
|
|
|
var config PluginConfig
|
|
err = yaml.Unmarshal(data, &config)
|
|
if err != nil {
|
|
return PluginConfig{}, err
|
|
}
|
|
|
|
return config, nil
|
|
}
|
|
|
|
func main() {
|
|
pluginsConfig, err := loadPluginsConfig("config.yaml")
|
|
if err != nil {
|
|
log.Fatalf("Failed to load plugins configuration: %v", err)
|
|
}
|
|
|
|
pm, err := NewValidatorProvider(pluginsConfig)
|
|
if err != nil {
|
|
log.Fatalf("Failed to create PluginManager: %v", err)
|
|
}
|
|
|
|
schemaDir := pluginsConfig.Plugins.ValidationPlugin.Config.Schema
|
|
|
|
err = pm.validatorProvider.Initialize(schemaDir)
|
|
if err != nil {
|
|
log.Fatalf("Failed to initialize validator provider: %v", err)
|
|
}
|
|
|
|
payloadData, err := ioutil.ReadFile("test/payload.json")
|
|
if err != nil {
|
|
log.Fatalf("Failed to read payload data: %v", err)
|
|
}
|
|
|
|
var payload Payload
|
|
if err := json.Unmarshal(payloadData, &payload); err != nil {
|
|
log.Fatalf("Failed to unmarshal payload: %v", err)
|
|
}
|
|
|
|
// Construct the schema file name based on domain and version
|
|
schemaFileName := fmt.Sprintf("%s_%s.json", strings.ToLower(payload.Context.Domain), strings.ToLower(payload.Context.Version))
|
|
|
|
// Get the validator for the specific schema
|
|
validator, err := pm.validatorProvider.Get(schemaFileName)
|
|
if err != nil {
|
|
log.Fatalf("Failed to get validator: %v", err)
|
|
}
|
|
fmt.Println("printing validator :", validator)
|
|
|
|
// Validate the payload against the schema
|
|
if err := validator.Validate(context.Background(), payloadData); err != nil {
|
|
log.Printf("Validation failed: %v", err)
|
|
} else {
|
|
log.Println("Validation succeeded!")
|
|
}
|
|
}
|