mirror of
https://github.com/duanhf2012/origin.git
synced 2026-02-03 22:45:13 +08:00
293 lines
7.3 KiB
Go
293 lines
7.3 KiB
Go
package blueprint
|
||
|
||
import (
|
||
"encoding/json"
|
||
"fmt"
|
||
"os"
|
||
"path/filepath"
|
||
"strings"
|
||
)
|
||
|
||
type ExecPool struct {
|
||
baseExecMap map[string]IBaseExec
|
||
execMap map[string]IBaseExec
|
||
}
|
||
|
||
func (em *ExecPool) Load(execDefFilePath string) error {
|
||
em.baseExecMap = make(map[string]IBaseExec, 512)
|
||
|
||
// 检查路径是否存在
|
||
stat, err := os.Stat(execDefFilePath)
|
||
if err != nil {
|
||
return fmt.Errorf("failed to access path %s: %v", execDefFilePath, err)
|
||
}
|
||
|
||
// 如果是单个文件，直接处理
|
||
if !stat.IsDir() {
|
||
return fmt.Errorf("%s is not a directory", execDefFilePath)
|
||
}
|
||
|
||
// 遍历目录及其子目录
|
||
err = filepath.Walk(execDefFilePath, func(path string, info os.FileInfo, err error) error {
|
||
if err != nil {
|
||
fmt.Printf("访问路径出错 %s: %v\n", path, err)
|
||
return nil // 继续遍历其他文件
|
||
}
|
||
|
||
// 如果是目录，继续遍历
|
||
if info.IsDir() {
|
||
return nil
|
||
}
|
||
|
||
// 只处理JSON文件
|
||
if filepath.Ext(path) == ".json" {
|
||
return em.processJSONFile(path)
|
||
}
|
||
|
||
return nil
|
||
})
|
||
if err != nil {
|
||
return fmt.Errorf("failed to walk path %s: %v", execDefFilePath, err)
|
||
}
|
||
|
||
return em.loadSysExec()
|
||
}
|
||
|
||
// 处理单个JSON文件
|
||
func (em *ExecPool) processJSONFile(filePath string) error {
|
||
// 打开文件
|
||
file, err := os.Open(filePath)
|
||
if err != nil {
|
||
return fmt.Errorf("failed to open file %s: %v", filePath, err)
|
||
}
|
||
|
||
defer func(file *os.File) {
|
||
err = file.Close()
|
||
if err != nil {
|
||
fmt.Printf("failed to close file %s: %v\n", filePath, err)
|
||
return
|
||
}
|
||
}(file)
|
||
|
||
var baseExecConfig BaseExecConfig
|
||
decoder := json.NewDecoder(file)
|
||
if err := decoder.Decode(&baseExecConfig); err != nil {
|
||
return fmt.Errorf("failed to decode JSON from file %s: %v", filePath, err)
|
||
}
|
||
|
||
exec, err := em.createExecFromJSON(baseExecConfig)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
if !em.loadBaseExec(exec) {
|
||
return fmt.Errorf("exec %s already registered", exec.GetName())
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
func (em *ExecPool) createPortByDataType(nodeName, portName, dataType string) (IPort, error) {
|
||
switch strings.ToLower(dataType) {
|
||
case Config_DataType_Int, Config_DataType_Integer:
|
||
return NewPortInt(), nil
|
||
case Config_DataType_Float:
|
||
return NewPortFloat(), nil
|
||
case Config_DataType_Str:
|
||
return NewPortStr(), nil
|
||
case Config_DataType_Boolean, Config_DataType_Bool:
|
||
return NewPortBool(), nil
|
||
case Config_DataType_Array:
|
||
return NewPortArray(), nil
|
||
}
|
||
|
||
return nil, fmt.Errorf("invalid data type %s,node %s port %s", dataType, nodeName, portName)
|
||
}
|
||
|
||
func (em *ExecPool) createExecFromJSON(baseExecConfig BaseExecConfig) (IBaseExec, error) {
|
||
var baseExec BaseExec
|
||
baseExec.Name = baseExecConfig.Name
|
||
baseExec.Title = baseExecConfig.Title
|
||
baseExec.Package = baseExecConfig.Package
|
||
baseExec.Description = baseExecConfig.Description
|
||
|
||
// exec数量
|
||
inExecNum := 0
|
||
for index, input := range baseExecConfig.Inputs {
|
||
portType := strings.ToLower(input.DataType)
|
||
if portType != Config_PortType_Exec && portType != Config_PortType_Data {
|
||
return nil, fmt.Errorf("input %s data type %s not support", input.Name, input.DataType)
|
||
}
|
||
|
||
if portType == Config_PortType_Exec {
|
||
if inExecNum > 0 {
|
||
return nil, fmt.Errorf("inPort only allows one Execute,node name %s", baseExec.Name)
|
||
}
|
||
if index > 0 {
|
||
return nil, fmt.Errorf("the exec port is only allowed to be placed on the first one,node name %s", baseExec.Name)
|
||
}
|
||
|
||
inExecNum++
|
||
baseExec.AppendInPort(NewPortExec())
|
||
continue
|
||
}
|
||
|
||
port, err := em.createPortByDataType(baseExec.Name, input.Name, input.DataType)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
baseExec.AppendInPort(port)
|
||
}
|
||
|
||
hasData := false
|
||
for _, output := range baseExecConfig.Outputs {
|
||
portType := strings.ToLower(output.DataType)
|
||
if portType != Config_PortType_Exec && portType != Config_PortType_Data {
|
||
return nil, fmt.Errorf("output %s data type %s not support,node name %s", output.Name, output.DataType, baseExec.Name)
|
||
}
|
||
|
||
// Exec出口只能先Exec，再Data，不能穿插，如果是Data类型，但遇到Exec入口则不允许
|
||
if hasData && portType == Config_PortType_Exec {
|
||
return nil, fmt.Errorf("the exec port can only be placed at the front,node name %s", baseExec.Name)
|
||
}
|
||
|
||
if portType == Config_PortType_Exec {
|
||
baseExec.AppendInPort(NewPortExec())
|
||
continue
|
||
}
|
||
hasData = true
|
||
port, err := em.createPortByDataType(baseExec.Name, output.Name, output.DataType)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
baseExec.AppendOutPort(port)
|
||
}
|
||
return &baseExec, nil
|
||
}
|
||
|
||
func (em *ExecPool) loadBaseExec(exec IBaseExec) bool {
|
||
if _, ok := em.baseExecMap[exec.GetName()]; ok {
|
||
return false
|
||
}
|
||
em.baseExecMap[exec.GetName()] = exec
|
||
return true
|
||
}
|
||
|
||
func (em *ExecPool) Register(exec IExec) bool {
|
||
baseExec, ok := exec.(IBaseExec)
|
||
if !ok {
|
||
return false
|
||
}
|
||
|
||
if _, ok := em.execMap[baseExec.GetName()]; ok {
|
||
return false
|
||
}
|
||
|
||
baseExec.SetExec(exec)
|
||
em.execMap[baseExec.GetName()] = baseExec
|
||
return true
|
||
}
|
||
|
||
func (em *ExecPool) GetExec(name string) IBaseExec {
|
||
if exec, ok := em.execMap[name]; ok {
|
||
return exec
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (em *ExecPool) loadSysExec() error {
|
||
var err error
|
||
if err = em.regGetVariables(Config_DataType_Int); err != nil {
|
||
return err
|
||
}
|
||
if err = em.regGetVariables(Config_DataType_Integer); err != nil {
|
||
return err
|
||
}
|
||
if err = em.regGetVariables(Config_DataType_Float); err != nil {
|
||
return err
|
||
}
|
||
if err = em.regGetVariables(Config_DataType_Str); err != nil {
|
||
return err
|
||
}
|
||
if err = em.regGetVariables(Config_DataType_Boolean); err != nil {
|
||
return err
|
||
}
|
||
if err = em.regGetVariables(Config_DataType_Bool); err != nil {
|
||
return err
|
||
}
|
||
if err = em.regGetVariables(Config_DataType_Array); err != nil {
|
||
return err
|
||
}
|
||
if err = em.regSetVariables(Config_DataType_Int); err != nil {
|
||
return err
|
||
}
|
||
if err = em.regSetVariables(Config_DataType_Integer); err != nil {
|
||
return err
|
||
}
|
||
if err = em.regSetVariables(Config_DataType_Float); err != nil {
|
||
return err
|
||
}
|
||
if err = em.regSetVariables(Config_DataType_Str); err != nil {
|
||
return err
|
||
}
|
||
if err = em.regSetVariables(Config_DataType_Boolean); err != nil {
|
||
return err
|
||
}
|
||
if err = em.regSetVariables(Config_DataType_Bool); err != nil {
|
||
return err
|
||
}
|
||
if err = em.regSetVariables(Config_DataType_Array); err != nil {
|
||
return err
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (em *ExecPool) regGetVariables(typ string) error {
|
||
var baseExec BaseExec
|
||
baseExec.Name = genGetVariablesNodeName(typ)
|
||
|
||
outPort := NewPortByType(typ)
|
||
baseExec.AppendOutPort(outPort)
|
||
baseExec.IExec = &GetVariablesNode{nodeName: baseExec.GetName()}
|
||
|
||
if !em.loadBaseExec(&baseExec) {
|
||
return fmt.Errorf("exec %s already registered", baseExec.GetName())
|
||
}
|
||
if !em.Register(baseExec.IExec) {
|
||
return fmt.Errorf("exec %s already registered", baseExec.GetName())
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
func genSetVariablesNodeName(typ string) string {
|
||
return fmt.Sprintf("%s_%s", SetVariables, typ)
|
||
}
|
||
|
||
func genGetVariablesNodeName(typ string) string {
|
||
return fmt.Sprintf("%s_%s", GetVariables, typ)
|
||
}
|
||
|
||
func (em *ExecPool) regSetVariables(typ string) error {
|
||
var baseExec BaseExec
|
||
baseExec.Name = genSetVariablesNodeName(typ)
|
||
|
||
inPort := NewPortByType(typ)
|
||
outPort := NewPortByType(typ)
|
||
|
||
baseExec.AppendInPort(inPort)
|
||
baseExec.AppendOutPort(outPort)
|
||
|
||
baseExec.IExec = &SetVariablesNode{nodeName: baseExec.GetName()}
|
||
if !em.loadBaseExec(&baseExec) {
|
||
return fmt.Errorf("exec %s already registered", baseExec.GetName())
|
||
}
|
||
if !em.Register(baseExec.IExec) {
|
||
return fmt.Errorf("exec %s already registered", baseExec.GetName())
|
||
}
|
||
|
||
return nil
|
||
}
|