删除无效的节点
This commit is contained in:
parent
99491e0b9b
commit
a7bcc7f06f
@ -1,31 +0,0 @@
|
||||
{
|
||||
"name": "数据处理节点",
|
||||
"description": "对输入数据进行处理和转换",
|
||||
"version": "1.0.0",
|
||||
"author": "jingrow",
|
||||
"category": "processing",
|
||||
"inputs": [
|
||||
{
|
||||
"name": "data",
|
||||
"type": "array",
|
||||
"description": "要处理的数据数组",
|
||||
"required": true
|
||||
}
|
||||
],
|
||||
"outputs": [
|
||||
{
|
||||
"name": "processed_data",
|
||||
"type": "array",
|
||||
"description": "处理后的数据"
|
||||
},
|
||||
{
|
||||
"name": "summary",
|
||||
"type": "object",
|
||||
"description": "处理摘要信息"
|
||||
}
|
||||
],
|
||||
"config": {
|
||||
"timeout": 30,
|
||||
"memory_limit": "256m"
|
||||
}
|
||||
}
|
||||
@ -1,43 +0,0 @@
|
||||
def execute(context=None, inputs=None, config=None):
|
||||
"""
|
||||
数据处理节点
|
||||
对输入数据进行处理和转换
|
||||
"""
|
||||
try:
|
||||
data = inputs.get('data', [])
|
||||
if not data:
|
||||
return {"success": False, "error": "没有提供数据"}
|
||||
|
||||
# 数据处理逻辑
|
||||
processed_data = []
|
||||
for item in data:
|
||||
if isinstance(item, dict):
|
||||
# 添加处理时间戳
|
||||
item['processed_at'] = context.get('timestamp', 'unknown')
|
||||
# 添加处理节点信息
|
||||
item['processed_by'] = 'data_processing_node'
|
||||
processed_data.append(item)
|
||||
else:
|
||||
# 简单数据类型处理
|
||||
processed_data.append({
|
||||
'original_value': item,
|
||||
'processed_at': context.get('timestamp', 'unknown'),
|
||||
'processed_by': 'data_processing_node'
|
||||
})
|
||||
|
||||
return {
|
||||
"success": True,
|
||||
"processed_data": processed_data,
|
||||
"summary": {
|
||||
"total_items": len(data),
|
||||
"processed_items": len(processed_data),
|
||||
"processing_time": 0.1
|
||||
}
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
return {
|
||||
"success": False,
|
||||
"error": str(e),
|
||||
"error_type": type(e).__name__
|
||||
}
|
||||
@ -1,305 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"os"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Go并发任务调度节点请求结构
|
||||
type GoConcurrentTasksRequest struct {
|
||||
Context map[string]interface{} `json:"context"`
|
||||
Inputs map[string]interface{} `json:"inputs"`
|
||||
Config map[string]interface{} `json:"config"`
|
||||
}
|
||||
|
||||
// Go并发任务调度节点响应结构
|
||||
type GoConcurrentTasksResponse struct {
|
||||
Success bool `json:"success"`
|
||||
Output string `json:"output,omitempty"`
|
||||
Result map[string]interface{} `json:"result,omitempty"`
|
||||
Error string `json:"error,omitempty"`
|
||||
}
|
||||
|
||||
// 任务结果结构
|
||||
type TaskResult struct {
|
||||
TaskID string `json:"task_id"`
|
||||
Success bool `json:"success"`
|
||||
Result interface{} `json:"result"`
|
||||
Error string `json:"error"`
|
||||
Duration int64 `json:"duration_ms"`
|
||||
}
|
||||
|
||||
func main() {
|
||||
var req GoConcurrentTasksRequest
|
||||
json.NewDecoder(os.Stdin).Decode(&req)
|
||||
|
||||
result := execute(req.Context, req.Inputs, req.Config)
|
||||
|
||||
output, _ := json.Marshal(result)
|
||||
fmt.Println(string(output))
|
||||
}
|
||||
|
||||
// Go并发任务调度节点执行函数
|
||||
func execute(context, inputs, config map[string]interface{}) GoConcurrentTasksResponse {
|
||||
// 获取配置参数
|
||||
tasks, ok := config["tasks"].([]interface{})
|
||||
if !ok {
|
||||
return GoConcurrentTasksResponse{
|
||||
Success: false,
|
||||
Error: "缺少任务列表配置",
|
||||
}
|
||||
}
|
||||
|
||||
maxConcurrency, ok := config["max_concurrency"].(float64)
|
||||
if !ok {
|
||||
maxConcurrency = 10 // 默认最大并发数
|
||||
}
|
||||
|
||||
timeout, ok := config["timeout"].(float64)
|
||||
if !ok {
|
||||
timeout = 30 // 默认超时30秒
|
||||
}
|
||||
|
||||
// 创建并发控制
|
||||
semaphore := make(chan struct{}, int(maxConcurrency))
|
||||
var wg sync.WaitGroup
|
||||
var mu sync.Mutex
|
||||
var results []TaskResult
|
||||
|
||||
// 并发执行任务
|
||||
for i, taskInterface := range tasks {
|
||||
task, ok := taskInterface.(map[string]interface{})
|
||||
if !ok {
|
||||
continue
|
||||
}
|
||||
|
||||
wg.Add(1)
|
||||
go func(taskID int, task map[string]interface{}) {
|
||||
defer wg.Done()
|
||||
|
||||
// 获取信号量
|
||||
semaphore <- struct{}{}
|
||||
defer func() { <-semaphore }()
|
||||
|
||||
// 执行任务
|
||||
result := executeTask(taskID, task, timeout)
|
||||
|
||||
// 线程安全地添加结果
|
||||
mu.Lock()
|
||||
results = append(results, result)
|
||||
mu.Unlock()
|
||||
}(i, task)
|
||||
}
|
||||
|
||||
// 等待所有任务完成
|
||||
wg.Wait()
|
||||
|
||||
// 统计结果
|
||||
successCount := 0
|
||||
failureCount := 0
|
||||
totalDuration := int64(0)
|
||||
|
||||
for _, result := range results {
|
||||
if result.Success {
|
||||
successCount++
|
||||
} else {
|
||||
failureCount++
|
||||
}
|
||||
totalDuration += result.Duration
|
||||
}
|
||||
|
||||
return GoConcurrentTasksResponse{
|
||||
Success: true,
|
||||
Output: fmt.Sprintf("并发任务执行完成: 成功%d个, 失败%d个", successCount, failureCount),
|
||||
Result: map[string]interface{}{
|
||||
"total_tasks": len(tasks),
|
||||
"success_count": successCount,
|
||||
"failure_count": failureCount,
|
||||
"total_duration": totalDuration,
|
||||
"avg_duration": float64(totalDuration) / float64(len(results)),
|
||||
"max_concurrency": maxConcurrency,
|
||||
"results": results,
|
||||
"language": "go",
|
||||
"performance": "high",
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
// 执行单个任务
|
||||
func executeTask(taskID int, task map[string]interface{}, timeout float64) TaskResult {
|
||||
startTime := time.Now()
|
||||
|
||||
taskType, ok := task["type"].(string)
|
||||
if !ok {
|
||||
return TaskResult{
|
||||
TaskID: fmt.Sprintf("task_%d", taskID),
|
||||
Success: false,
|
||||
Error: "任务类型未指定",
|
||||
Duration: time.Since(startTime).Milliseconds(),
|
||||
}
|
||||
}
|
||||
|
||||
var result interface{}
|
||||
var err error
|
||||
|
||||
switch taskType {
|
||||
case "http_request":
|
||||
result, err = executeHTTPTask(task)
|
||||
case "data_processing":
|
||||
result, err = executeDataProcessingTask(task)
|
||||
case "file_operation":
|
||||
result, err = executeFileOperationTask(task)
|
||||
case "sleep":
|
||||
result, err = executeSleepTask(task)
|
||||
default:
|
||||
err = fmt.Errorf("不支持的任务类型: %s", taskType)
|
||||
}
|
||||
|
||||
duration := time.Since(startTime).Milliseconds()
|
||||
|
||||
if err != nil {
|
||||
return TaskResult{
|
||||
TaskID: fmt.Sprintf("task_%d", taskID),
|
||||
Success: false,
|
||||
Error: err.Error(),
|
||||
Duration: duration,
|
||||
}
|
||||
}
|
||||
|
||||
return TaskResult{
|
||||
TaskID: fmt.Sprintf("task_%d", taskID),
|
||||
Success: true,
|
||||
Result: result,
|
||||
Duration: duration,
|
||||
}
|
||||
}
|
||||
|
||||
// HTTP请求任务
|
||||
func executeHTTPTask(task map[string]interface{}) (interface{}, error) {
|
||||
url, ok := task["url"].(string)
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("缺少URL参数")
|
||||
}
|
||||
|
||||
method, ok := task["method"].(string)
|
||||
if !ok {
|
||||
method = "GET"
|
||||
}
|
||||
|
||||
client := &http.Client{Timeout: 10 * time.Second}
|
||||
req, err := http.NewRequest(method, url, nil)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
resp, err := client.Do(req)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
return map[string]interface{}{
|
||||
"status_code": resp.StatusCode,
|
||||
"url": url,
|
||||
"method": method,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// 数据处理任务
|
||||
func executeDataProcessingTask(task map[string]interface{}) (interface{}, error) {
|
||||
data, ok := task["data"].([]interface{})
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("缺少数据参数")
|
||||
}
|
||||
|
||||
operation, ok := task["operation"].(string)
|
||||
if !ok {
|
||||
operation = "count"
|
||||
}
|
||||
|
||||
var result interface{}
|
||||
switch operation {
|
||||
case "count":
|
||||
result = len(data)
|
||||
case "sum":
|
||||
sum := 0.0
|
||||
for _, item := range data {
|
||||
if num, ok := item.(float64); ok {
|
||||
sum += num
|
||||
}
|
||||
}
|
||||
result = sum
|
||||
case "reverse":
|
||||
reversed := make([]interface{}, len(data))
|
||||
for i, item := range data {
|
||||
reversed[len(data)-1-i] = item
|
||||
}
|
||||
result = reversed
|
||||
default:
|
||||
return nil, fmt.Errorf("不支持的操作: %s", operation)
|
||||
}
|
||||
|
||||
return map[string]interface{}{
|
||||
"operation": operation,
|
||||
"result": result,
|
||||
"count": len(data),
|
||||
}, nil
|
||||
}
|
||||
|
||||
// 文件操作任务
|
||||
func executeFileOperationTask(task map[string]interface{}) (interface{}, error) {
|
||||
operation, ok := task["operation"].(string)
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("缺少操作类型")
|
||||
}
|
||||
|
||||
switch operation {
|
||||
case "list_directory":
|
||||
path, ok := task["path"].(string)
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("缺少路径参数")
|
||||
}
|
||||
|
||||
// 模拟目录列表
|
||||
return map[string]interface{}{
|
||||
"operation": "list_directory",
|
||||
"path": path,
|
||||
"files": []string{"file1.txt", "file2.txt", "file3.txt"},
|
||||
}, nil
|
||||
|
||||
case "file_info":
|
||||
filename, ok := task["filename"].(string)
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("缺少文件名参数")
|
||||
}
|
||||
|
||||
return map[string]interface{}{
|
||||
"operation": "file_info",
|
||||
"filename": filename,
|
||||
"size": 1024,
|
||||
"modified": time.Now().Format(time.RFC3339),
|
||||
}, nil
|
||||
|
||||
default:
|
||||
return nil, fmt.Errorf("不支持的文件操作: %s", operation)
|
||||
}
|
||||
}
|
||||
|
||||
// 睡眠任务（用于测试）
|
||||
func executeSleepTask(task map[string]interface{}) (interface{}, error) {
|
||||
duration, ok := task["duration"].(float64)
|
||||
if !ok {
|
||||
duration = 1.0
|
||||
}
|
||||
|
||||
time.Sleep(time.Duration(duration) * time.Second)
|
||||
|
||||
return map[string]interface{}{
|
||||
"operation": "sleep",
|
||||
"duration": duration,
|
||||
}, nil
|
||||
}
|
||||
@ -1,174 +0,0 @@
|
||||
{
|
||||
"properties": {
|
||||
"node_info": {
|
||||
"type": "string",
|
||||
"title": "节点说明",
|
||||
"description": "",
|
||||
"default": "Go并发任务调度节点利用Go语言的goroutine特性，实现高性能并发任务执行。支持多种任务类型，包括HTTP请求、数据处理、文件操作等。",
|
||||
"format": "info"
|
||||
},
|
||||
"tasks": {
|
||||
"type": "array",
|
||||
"title": "任务列表",
|
||||
"description": "要并发执行的任务列表",
|
||||
"default": [
|
||||
{
|
||||
"type": "data_processing",
|
||||
"data": [1, 2, 3, 4, 5],
|
||||
"operation": "sum"
|
||||
}
|
||||
],
|
||||
"items": {
|
||||
"type": "object",
|
||||
"title": "任务配置",
|
||||
"properties": {
|
||||
"type": {
|
||||
"type": "string",
|
||||
"title": "任务类型",
|
||||
"description": "选择要执行的任务类型",
|
||||
"enum": [
|
||||
"http_request",
|
||||
"data_processing",
|
||||
"file_operation",
|
||||
"sleep"
|
||||
],
|
||||
"enumNames": [
|
||||
"HTTP请求",
|
||||
"数据处理",
|
||||
"文件操作",
|
||||
"睡眠测试"
|
||||
],
|
||||
"default": "data_processing"
|
||||
},
|
||||
"url": {
|
||||
"type": "string",
|
||||
"title": "请求URL",
|
||||
"description": "HTTP请求任务的URL地址",
|
||||
"placeholder": "https://api.example.com/data"
|
||||
},
|
||||
"method": {
|
||||
"type": "string",
|
||||
"title": "请求方法",
|
||||
"description": "HTTP请求方法",
|
||||
"enum": ["GET", "POST", "PUT", "DELETE"],
|
||||
"enumNames": ["GET", "POST", "PUT", "DELETE"],
|
||||
"default": "GET"
|
||||
},
|
||||
"data": {
|
||||
"type": "array",
|
||||
"title": "数据",
|
||||
"description": "数据处理任务的数据数组"
|
||||
},
|
||||
"operation": {
|
||||
"type": "string",
|
||||
"title": "操作类型",
|
||||
"description": "数据处理操作类型",
|
||||
"enum": ["count", "sum", "reverse"],
|
||||
"enumNames": ["计数", "求和", "反转"],
|
||||
"default": "sum"
|
||||
},
|
||||
"path": {
|
||||
"type": "string",
|
||||
"title": "路径",
|
||||
"description": "文件操作的路径",
|
||||
"placeholder": "/path/to/file"
|
||||
},
|
||||
"filename": {
|
||||
"type": "string",
|
||||
"title": "文件名",
|
||||
"description": "文件操作的文件名",
|
||||
"placeholder": "example.txt"
|
||||
},
|
||||
"duration": {
|
||||
"type": "number",
|
||||
"title": "持续时间(秒)",
|
||||
"description": "睡眠任务的持续时间",
|
||||
"default": 1,
|
||||
"minimum": 0.1,
|
||||
"maximum": 60
|
||||
}
|
||||
},
|
||||
"required": ["type"]
|
||||
},
|
||||
"minItems": 1
|
||||
},
|
||||
"max_concurrency": {
|
||||
"type": "number",
|
||||
"title": "最大并发数",
|
||||
"description": "同时执行的最大任务数，控制并发度",
|
||||
"default": 10,
|
||||
"minimum": 1,
|
||||
"maximum": 100
|
||||
},
|
||||
"timeout": {
|
||||
"type": "number",
|
||||
"title": "超时时间(秒)",
|
||||
"description": "单个任务的超时时间",
|
||||
"default": 30,
|
||||
"minimum": 1,
|
||||
"maximum": 300
|
||||
},
|
||||
"usage_guide": {
|
||||
"type": "string",
|
||||
"title": "使用说明",
|
||||
"description": "Go并发任务调度的使用指南",
|
||||
"default": "Go并发任务调度节点特色：\n• 利用goroutine实现真正的并发执行\n• 支持多种任务类型：HTTP请求、数据处理、文件操作\n• 可控制并发度和超时时间\n• 提供详细的执行统计信息\n\n最佳实践：\n• 合理设置最大并发数，避免资源过载\n• 为长时间任务设置合适的超时时间\n• 使用睡眠任务测试并发性能\n• 监控任务执行统计信息",
|
||||
"format": "info"
|
||||
}
|
||||
},
|
||||
"required": [
|
||||
"tasks"
|
||||
],
|
||||
"_layout": {
|
||||
"tabs": [
|
||||
{
|
||||
"id": "tab_1",
|
||||
"label": "基础配置",
|
||||
"sections": [
|
||||
{
|
||||
"id": "section_1",
|
||||
"label": "基本属性",
|
||||
"columns": [
|
||||
{
|
||||
"id": "column_1",
|
||||
"label": "主要设置",
|
||||
"fields": [
|
||||
"node_info",
|
||||
"tasks"
|
||||
]
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"id": "section_2",
|
||||
"label": "并发控制",
|
||||
"columns": [
|
||||
{
|
||||
"id": "column_2",
|
||||
"label": "性能参数",
|
||||
"fields": [
|
||||
"max_concurrency",
|
||||
"timeout"
|
||||
]
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"id": "section_3",
|
||||
"label": "使用说明",
|
||||
"columns": [
|
||||
{
|
||||
"id": "column_3",
|
||||
"label": "说明文档",
|
||||
"fields": [
|
||||
"usage_guide"
|
||||
]
|
||||
}
|
||||
]
|
||||
}
|
||||
]
|
||||
}
|
||||
],
|
||||
"activeTab": "tab_1"
|
||||
}
|
||||
}
|
||||
@ -1,273 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"os"
|
||||
"sort"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Go数据处理节点请求结构
|
||||
type GoDataProcessingRequest struct {
|
||||
Context map[string]interface{} `json:"context"`
|
||||
Inputs map[string]interface{} `json:"inputs"`
|
||||
Config map[string]interface{} `json:"config"`
|
||||
}
|
||||
|
||||
// Go数据处理节点响应结构
|
||||
type GoDataProcessingResponse struct {
|
||||
Success bool `json:"success"`
|
||||
Output string `json:"output,omitempty"`
|
||||
Result map[string]interface{} `json:"result,omitempty"`
|
||||
Error string `json:"error,omitempty"`
|
||||
}
|
||||
|
||||
func main() {
|
||||
var req GoDataProcessingRequest
|
||||
json.NewDecoder(os.Stdin).Decode(&req)
|
||||
|
||||
result := execute(req.Context, req.Inputs, req.Config)
|
||||
|
||||
output, _ := json.Marshal(result)
|
||||
fmt.Println(string(output))
|
||||
}
|
||||
|
||||
// Go数据处理节点执行函数
|
||||
func execute(context, inputs, config map[string]interface{}) GoDataProcessingResponse {
|
||||
// 获取配置参数
|
||||
operation, ok := config["operation"].(string)
|
||||
if !ok {
|
||||
operation = "sort"
|
||||
}
|
||||
|
||||
data, ok := inputs["data"]
|
||||
if !ok {
|
||||
return GoDataProcessingResponse{
|
||||
Success: false,
|
||||
Error: "缺少输入数据",
|
||||
}
|
||||
}
|
||||
|
||||
startTime := time.Now()
|
||||
|
||||
switch operation {
|
||||
case "sort":
|
||||
return executeSort(data)
|
||||
case "filter":
|
||||
return executeFilter(data, config)
|
||||
case "aggregate":
|
||||
return executeAggregate(data, config)
|
||||
case "transform":
|
||||
return executeTransform(data, config)
|
||||
default:
|
||||
return GoDataProcessingResponse{
|
||||
Success: false,
|
||||
Error: fmt.Sprintf("不支持的操作: %s", operation),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 排序操作
|
||||
func executeSort(data interface{}) GoDataProcessingResponse {
|
||||
var result []interface{}
|
||||
|
||||
switch v := data.(type) {
|
||||
case []interface{}:
|
||||
// 复制切片
|
||||
result = make([]interface{}, len(v))
|
||||
copy(result, v)
|
||||
|
||||
// 尝试排序
|
||||
if len(result) > 0 {
|
||||
switch result[0].(type) {
|
||||
case string:
|
||||
stringSlice := make([]string, len(result))
|
||||
for i, item := range result {
|
||||
stringSlice[i] = item.(string)
|
||||
}
|
||||
sort.Strings(stringSlice)
|
||||
for i, item := range stringSlice {
|
||||
result[i] = item
|
||||
}
|
||||
case float64:
|
||||
floatSlice := make([]float64, len(result))
|
||||
for i, item := range result {
|
||||
floatSlice[i] = item.(float64)
|
||||
}
|
||||
sort.Float64s(floatSlice)
|
||||
for i, item := range floatSlice {
|
||||
result[i] = item
|
||||
}
|
||||
}
|
||||
}
|
||||
default:
|
||||
return GoDataProcessingResponse{
|
||||
Success: false,
|
||||
Error: "数据格式不支持排序",
|
||||
}
|
||||
}
|
||||
|
||||
return GoDataProcessingResponse{
|
||||
Success: true,
|
||||
Output: "Go数据处理完成",
|
||||
Result: map[string]interface{}{
|
||||
"operation": "sort",
|
||||
"processed_data": result,
|
||||
"count": len(result),
|
||||
"language": "go",
|
||||
"performance": "high",
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
// 过滤操作
|
||||
func executeFilter(data interface{}, config map[string]interface{}) GoDataProcessingResponse {
|
||||
filterValue, ok := config["filter_value"].(string)
|
||||
if !ok {
|
||||
filterValue = ""
|
||||
}
|
||||
|
||||
var result []interface{}
|
||||
|
||||
switch v := data.(type) {
|
||||
case []interface{}:
|
||||
for _, item := range v {
|
||||
if str, ok := item.(string); ok {
|
||||
if strings.Contains(str, filterValue) {
|
||||
result = append(result, item)
|
||||
}
|
||||
}
|
||||
}
|
||||
default:
|
||||
return GoDataProcessingResponse{
|
||||
Success: false,
|
||||
Error: "数据格式不支持过滤",
|
||||
}
|
||||
}
|
||||
|
||||
return GoDataProcessingResponse{
|
||||
Success: true,
|
||||
Output: "Go数据过滤完成",
|
||||
Result: map[string]interface{}{
|
||||
"operation": "filter",
|
||||
"filter_value": filterValue,
|
||||
"processed_data": result,
|
||||
"count": len(result),
|
||||
"language": "go",
|
||||
"performance": "high",
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
// 聚合操作
|
||||
func executeAggregate(data interface{}, config map[string]interface{}) GoDataProcessingResponse {
|
||||
aggregateType, ok := config["aggregate_type"].(string)
|
||||
if !ok {
|
||||
aggregateType = "sum"
|
||||
}
|
||||
|
||||
var result interface{}
|
||||
var count int
|
||||
|
||||
switch v := data.(type) {
|
||||
case []interface{}:
|
||||
count = len(v)
|
||||
switch aggregateType {
|
||||
case "sum":
|
||||
sum := 0.0
|
||||
for _, item := range v {
|
||||
if num, ok := item.(float64); ok {
|
||||
sum += num
|
||||
}
|
||||
}
|
||||
result = sum
|
||||
case "count":
|
||||
result = len(v)
|
||||
case "avg":
|
||||
sum := 0.0
|
||||
validCount := 0
|
||||
for _, item := range v {
|
||||
if num, ok := item.(float64); ok {
|
||||
sum += num
|
||||
validCount++
|
||||
}
|
||||
}
|
||||
if validCount > 0 {
|
||||
result = sum / float64(validCount)
|
||||
} else {
|
||||
result = 0.0
|
||||
}
|
||||
}
|
||||
default:
|
||||
return GoDataProcessingResponse{
|
||||
Success: false,
|
||||
Error: "数据格式不支持聚合",
|
||||
}
|
||||
}
|
||||
|
||||
return GoDataProcessingResponse{
|
||||
Success: true,
|
||||
Output: "Go数据聚合完成",
|
||||
Result: map[string]interface{}{
|
||||
"operation": aggregateType,
|
||||
"result": result,
|
||||
"count": count,
|
||||
"language": "go",
|
||||
"performance": "high",
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
// 转换操作
|
||||
func executeTransform(data interface{}, config map[string]interface{}) GoDataProcessingResponse {
|
||||
transformType, ok := config["transform_type"].(string)
|
||||
if !ok {
|
||||
transformType = "uppercase"
|
||||
}
|
||||
|
||||
var result []interface{}
|
||||
|
||||
switch v := data.(type) {
|
||||
case []interface{}:
|
||||
for _, item := range v {
|
||||
if str, ok := item.(string); ok {
|
||||
switch transformType {
|
||||
case "uppercase":
|
||||
result = append(result, strings.ToUpper(str))
|
||||
case "lowercase":
|
||||
result = append(result, strings.ToLower(str))
|
||||
case "reverse":
|
||||
runes := []rune(str)
|
||||
for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
|
||||
runes[i], runes[j] = runes[j], runes[i]
|
||||
}
|
||||
result = append(result, string(runes))
|
||||
default:
|
||||
result = append(result, str)
|
||||
}
|
||||
} else {
|
||||
result = append(result, item)
|
||||
}
|
||||
}
|
||||
default:
|
||||
return GoDataProcessingResponse{
|
||||
Success: false,
|
||||
Error: "数据格式不支持转换",
|
||||
}
|
||||
}
|
||||
|
||||
return GoDataProcessingResponse{
|
||||
Success: true,
|
||||
Output: "Go数据转换完成",
|
||||
Result: map[string]interface{}{
|
||||
"operation": "transform",
|
||||
"transform_type": transformType,
|
||||
"processed_data": result,
|
||||
"count": len(result),
|
||||
"language": "go",
|
||||
"performance": "high",
|
||||
},
|
||||
}
|
||||
}
|
||||
@ -1,86 +0,0 @@
|
||||
{
|
||||
"name": "Go数据处理",
|
||||
"description": "使用Go语言进行高性能数据处理",
|
||||
"version": "1.0.0",
|
||||
"category": "data",
|
||||
"inputs": [
|
||||
{
|
||||
"name": "context",
|
||||
"type": "object",
|
||||
"description": "上下文数据"
|
||||
},
|
||||
{
|
||||
"name": "inputs",
|
||||
"type": "object",
|
||||
"description": "输入数据"
|
||||
},
|
||||
{
|
||||
"name": "config",
|
||||
"type": "object",
|
||||
"description": "配置参数"
|
||||
}
|
||||
],
|
||||
"outputs": [
|
||||
{
|
||||
"name": "success",
|
||||
"type": "boolean",
|
||||
"description": "执行是否成功"
|
||||
},
|
||||
{
|
||||
"name": "output",
|
||||
"type": "string",
|
||||
"description": "执行结果消息"
|
||||
},
|
||||
{
|
||||
"name": "result",
|
||||
"type": "object",
|
||||
"description": "处理结果数据"
|
||||
}
|
||||
],
|
||||
"config": [
|
||||
{
|
||||
"name": "operation",
|
||||
"type": "select",
|
||||
"label": "操作类型",
|
||||
"required": true,
|
||||
"default": "sort",
|
||||
"options": [
|
||||
{"value": "sort", "label": "排序"},
|
||||
{"value": "filter", "label": "过滤"},
|
||||
{"value": "aggregate", "label": "聚合"},
|
||||
{"value": "transform", "label": "转换"}
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "filter_value",
|
||||
"type": "text",
|
||||
"label": "过滤值",
|
||||
"required": false,
|
||||
"description": "过滤操作时使用的值"
|
||||
},
|
||||
{
|
||||
"name": "aggregate_type",
|
||||
"type": "select",
|
||||
"label": "聚合类型",
|
||||
"required": false,
|
||||
"default": "sum",
|
||||
"options": [
|
||||
{"value": "sum", "label": "求和"},
|
||||
{"value": "count", "label": "计数"},
|
||||
{"value": "avg", "label": "平均值"}
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "transform_type",
|
||||
"type": "select",
|
||||
"label": "转换类型",
|
||||
"required": false,
|
||||
"default": "uppercase",
|
||||
"options": [
|
||||
{"value": "uppercase", "label": "转大写"},
|
||||
{"value": "lowercase", "label": "转小写"},
|
||||
{"value": "reverse", "label": "反转字符串"}
|
||||
]
|
||||
}
|
||||
]
|
||||
}
|
||||
@ -1,311 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io/ioutil"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Go文件系统操作节点请求结构
|
||||
type GoFileOperationsRequest struct {
|
||||
Context map[string]interface{} `json:"context"`
|
||||
Inputs map[string]interface{} `json:"inputs"`
|
||||
Config map[string]interface{} `json:"config"`
|
||||
}
|
||||
|
||||
// Go文件系统操作节点响应结构
|
||||
type GoFileOperationsResponse struct {
|
||||
Success bool `json:"success"`
|
||||
Output string `json:"output,omitempty"`
|
||||
Result map[string]interface{} `json:"result,omitempty"`
|
||||
Error string `json:"error,omitempty"`
|
||||
}
|
||||
|
||||
func main() {
|
||||
var req GoFileOperationsRequest
|
||||
json.NewDecoder(os.Stdin).Decode(&req)
|
||||
|
||||
result := execute(req.Context, req.Inputs, req.Config)
|
||||
|
||||
output, _ := json.Marshal(result)
|
||||
fmt.Println(string(output))
|
||||
}
|
||||
|
||||
// Go文件系统操作节点执行函数
|
||||
func execute(context, inputs, config map[string]interface{}) GoFileOperationsResponse {
|
||||
// 获取配置参数
|
||||
operation, ok := config["operation"].(string)
|
||||
if !ok {
|
||||
return GoFileOperationsResponse{
|
||||
Success: false,
|
||||
Error: "缺少操作类型配置",
|
||||
}
|
||||
}
|
||||
|
||||
startTime := time.Now()
|
||||
|
||||
var result map[string]interface{}
|
||||
var err error
|
||||
|
||||
switch operation {
|
||||
case "read_file":
|
||||
result, err = executeReadFile(config)
|
||||
case "write_file":
|
||||
result, err = executeWriteFile(config, inputs)
|
||||
case "list_directory":
|
||||
result, err = executeListDirectory(config)
|
||||
case "create_directory":
|
||||
result, err = executeCreateDirectory(config)
|
||||
case "delete_file":
|
||||
result, err = executeDeleteFile(config)
|
||||
case "copy_file":
|
||||
result, err = executeCopyFile(config)
|
||||
case "file_info":
|
||||
result, err = executeFileInfo(config)
|
||||
case "search_files":
|
||||
result, err = executeSearchFiles(config)
|
||||
case "batch_operations":
|
||||
result, err = executeBatchOperations(config, inputs)
|
||||
default:
|
||||
return GoFileOperationsResponse{
|
||||
Success: false,
|
||||
Error: fmt.Sprintf("不支持的操作类型: %s", operation),
|
||||
}
|
||||
}
|
||||
|
||||
duration := time.Since(startTime).Milliseconds()
|
||||
|
||||
if err != nil {
|
||||
return GoFileOperationsResponse{
|
||||
Success: false,
|
||||
Error: err.Error(),
|
||||
}
|
||||
}
|
||||
|
||||
// 添加执行信息
|
||||
result["operation"] = operation
|
||||
result["duration_ms"] = duration
|
||||
result["language"] = "go"
|
||||
result["performance"] = "high"
|
||||
|
||||
return GoFileOperationsResponse{
|
||||
Success: true,
|
||||
Output: fmt.Sprintf("Go文件操作完成: %s", operation),
|
||||
Result: result,
|
||||
}
|
||||
}
|
||||
|
||||
// 读取文件
|
||||
func executeReadFile(config map[string]interface{}) (map[string]interface{}, error) {
|
||||
filePath, ok := config["file_path"].(string)
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("缺少文件路径参数")
|
||||
}
|
||||
|
||||
// 模拟文件读取
|
||||
content := fmt.Sprintf("模拟文件内容: %s\n时间: %s", filePath, time.Now().Format(time.RFC3339))
|
||||
|
||||
return map[string]interface{}{
|
||||
"file_path": filePath,
|
||||
"content": content,
|
||||
"size": len(content),
|
||||
"encoding": "utf-8",
|
||||
}, nil
|
||||
}
|
||||
|
||||
// 写入文件
|
||||
func executeWriteFile(config map[string]interface{}, inputs map[string]interface{}) (map[string]interface{}, error) {
|
||||
filePath, ok := config["file_path"].(string)
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("缺少文件路径参数")
|
||||
}
|
||||
|
||||
content, ok := inputs["content"].(string)
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("缺少文件内容")
|
||||
}
|
||||
|
||||
// 模拟文件写入
|
||||
fileName := filepath.Base(filePath)
|
||||
|
||||
return map[string]interface{}{
|
||||
"file_path": filePath,
|
||||
"file_name": fileName,
|
||||
"content": content,
|
||||
"size": len(content),
|
||||
"created": time.Now().Format(time.RFC3339),
|
||||
}, nil
|
||||
}
|
||||
|
||||
// 列出目录
|
||||
func executeListDirectory(config map[string]interface{}) (map[string]interface{}, error) {
|
||||
dirPath, ok := config["dir_path"].(string)
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("缺少目录路径参数")
|
||||
}
|
||||
|
||||
// 模拟目录列表
|
||||
files := []map[string]interface{}{
|
||||
{
|
||||
"name": "file1.txt",
|
||||
"size": 1024,
|
||||
"is_dir": false,
|
||||
"modified": time.Now().Add(-time.Hour).Format(time.RFC3339),
|
||||
},
|
||||
{
|
||||
"name": "file2.txt",
|
||||
"size": 2048,
|
||||
"is_dir": false,
|
||||
"modified": time.Now().Add(-2 * time.Hour).Format(time.RFC3339),
|
||||
},
|
||||
{
|
||||
"name": "subdir",
|
||||
"size": 0,
|
||||
"is_dir": true,
|
||||
"modified": time.Now().Add(-3 * time.Hour).Format(time.RFC3339),
|
||||
},
|
||||
}
|
||||
|
||||
return map[string]interface{}{
|
||||
"dir_path": dirPath,
|
||||
"files": files,
|
||||
"count": len(files),
|
||||
}, nil
|
||||
}
|
||||
|
||||
// 创建目录
|
||||
func executeCreateDirectory(config map[string]interface{}) (map[string]interface{}, error) {
|
||||
dirPath, ok := config["dir_path"].(string)
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("缺少目录路径参数")
|
||||
}
|
||||
|
||||
// 模拟目录创建
|
||||
return map[string]interface{}{
|
||||
"dir_path": dirPath,
|
||||
"created": time.Now().Format(time.RFC3339),
|
||||
"success": true,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// 删除文件
|
||||
func executeDeleteFile(config map[string]interface{}) (map[string]interface{}, error) {
|
||||
filePath, ok := config["file_path"].(string)
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("缺少文件路径参数")
|
||||
}
|
||||
|
||||
// 模拟文件删除
|
||||
return map[string]interface{}{
|
||||
"file_path": filePath,
|
||||
"deleted": time.Now().Format(time.RFC3339),
|
||||
"success": true,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// 复制文件
|
||||
func executeCopyFile(config map[string]interface{}) (map[string]interface{}, error) {
|
||||
sourcePath, ok := config["source_path"].(string)
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("缺少源文件路径参数")
|
||||
}
|
||||
|
||||
targetPath, ok := config["target_path"].(string)
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("缺少目标文件路径参数")
|
||||
}
|
||||
|
||||
// 模拟文件复制
|
||||
return map[string]interface{}{
|
||||
"source_path": sourcePath,
|
||||
"target_path": targetPath,
|
||||
"copied": time.Now().Format(time.RFC3339),
|
||||
"success": true,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// 获取文件信息
|
||||
func executeFileInfo(config map[string]interface{}) (map[string]interface{}, error) {
|
||||
filePath, ok := config["file_path"].(string)
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("缺少文件路径参数")
|
||||
}
|
||||
|
||||
// 模拟文件信息
|
||||
return map[string]interface{}{
|
||||
"file_path": filePath,
|
||||
"size": 4096,
|
||||
"is_dir": false,
|
||||
"modified": time.Now().Add(-time.Hour).Format(time.RFC3339),
|
||||
"created": time.Now().Add(-24 * time.Hour).Format(time.RFC3339),
|
||||
"permissions": "rw-r--r--",
|
||||
}, nil
|
||||
}
|
||||
|
||||
// 搜索文件
|
||||
func executeSearchFiles(config map[string]interface{}) (map[string]interface{}, error) {
|
||||
searchPath, ok := config["search_path"].(string)
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("缺少搜索路径参数")
|
||||
}
|
||||
|
||||
pattern, ok := config["pattern"].(string)
|
||||
if !ok {
|
||||
pattern = "*"
|
||||
}
|
||||
|
||||
// 模拟文件搜索
|
||||
matches := []string{
|
||||
filepath.Join(searchPath, "file1.txt"),
|
||||
filepath.Join(searchPath, "file2.txt"),
|
||||
filepath.Join(searchPath, "subdir", "file3.txt"),
|
||||
}
|
||||
|
||||
return map[string]interface{}{
|
||||
"search_path": searchPath,
|
||||
"pattern": pattern,
|
||||
"matches": matches,
|
||||
"count": len(matches),
|
||||
}, nil
|
||||
}
|
||||
|
||||
// 批量操作
|
||||
func executeBatchOperations(config map[string]interface{}, inputs map[string]interface{}) (map[string]interface{}, error) {
|
||||
operations, ok := inputs["operations"].([]interface{})
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("缺少批量操作列表")
|
||||
}
|
||||
|
||||
var results []map[string]interface{}
|
||||
successCount := 0
|
||||
failureCount := 0
|
||||
|
||||
for i, opInterface := range operations {
|
||||
op, ok := opInterface.(map[string]interface{})
|
||||
if !ok {
|
||||
failureCount++
|
||||
continue
|
||||
}
|
||||
|
||||
// 模拟批量操作
|
||||
result := map[string]interface{}{
|
||||
"operation_id": i,
|
||||
"success": true,
|
||||
"result": fmt.Sprintf("批量操作 %d 完成", i),
|
||||
}
|
||||
|
||||
results = append(results, result)
|
||||
successCount++
|
||||
}
|
||||
|
||||
return map[string]interface{}{
|
||||
"total_operations": len(operations),
|
||||
"success_count": successCount,
|
||||
"failure_count": failureCount,
|
||||
"results": results,
|
||||
}, nil
|
||||
}
|
||||
@ -1,160 +0,0 @@
|
||||
{
|
||||
"properties": {
|
||||
"node_info": {
|
||||
"type": "string",
|
||||
"title": "节点说明",
|
||||
"description": "",
|
||||
"default": "Go文件系统操作节点利用Go语言优秀的系统调用性能，实现高性能文件读写、目录操作、文件监控等功能。",
|
||||
"format": "info"
|
||||
},
|
||||
"operation": {
|
||||
"type": "string",
|
||||
"title": "操作类型",
|
||||
"description": "选择要执行的文件系统操作类型",
|
||||
"enum": [
|
||||
"read_file",
|
||||
"write_file",
|
||||
"list_directory",
|
||||
"create_directory",
|
||||
"delete_file",
|
||||
"copy_file",
|
||||
"file_info",
|
||||
"search_files",
|
||||
"batch_operations"
|
||||
],
|
||||
"enumNames": [
|
||||
"读取文件",
|
||||
"写入文件",
|
||||
"列出目录",
|
||||
"创建目录",
|
||||
"删除文件",
|
||||
"复制文件",
|
||||
"文件信息",
|
||||
"搜索文件",
|
||||
"批量操作"
|
||||
],
|
||||
"default": "read_file"
|
||||
},
|
||||
"file_path": {
|
||||
"type": "string",
|
||||
"title": "文件路径",
|
||||
"description": "文件操作的路径",
|
||||
"placeholder": "/path/to/file.txt"
|
||||
},
|
||||
"dir_path": {
|
||||
"type": "string",
|
||||
"title": "目录路径",
|
||||
"description": "目录操作的路径",
|
||||
"placeholder": "/path/to/directory"
|
||||
},
|
||||
"source_path": {
|
||||
"type": "string",
|
||||
"title": "源路径",
|
||||
"description": "复制操作的源路径",
|
||||
"placeholder": "/source/file.txt"
|
||||
},
|
||||
"target_path": {
|
||||
"type": "string",
|
||||
"title": "目标路径",
|
||||
"description": "复制操作的目标路径",
|
||||
"placeholder": "/target/file.txt"
|
||||
},
|
||||
"search_path": {
|
||||
"type": "string",
|
||||
"title": "搜索路径",
|
||||
"description": "文件搜索的路径",
|
||||
"placeholder": "/path/to/search"
|
||||
},
|
||||
"pattern": {
|
||||
"type": "string",
|
||||
"title": "搜索模式",
|
||||
"description": "文件搜索的模式",
|
||||
"default": "*",
|
||||
"placeholder": "*.txt"
|
||||
},
|
||||
"usage_guide": {
|
||||
"type": "string",
|
||||
"title": "使用说明",
|
||||
"description": "Go文件系统操作的使用指南",
|
||||
"default": "Go文件系统操作节点特色：\n• 利用Go语言优秀的系统调用性能\n• 支持多种文件操作：读写、目录管理、文件搜索\n• 提供批量操作功能\n• 高性能文件处理能力\n\n最佳实践：\n• 使用合适的操作类型提高效率\n• 批量操作时注意文件数量限制\n• 搜索操作使用合适的模式匹配\n• 注意文件路径的正确性",
|
||||
"format": "info"
|
||||
}
|
||||
},
|
||||
"required": [
|
||||
"operation"
|
||||
],
|
||||
"_layout": {
|
||||
"tabs": [
|
||||
{
|
||||
"id": "tab_1",
|
||||
"label": "基础配置",
|
||||
"sections": [
|
||||
{
|
||||
"id": "section_1",
|
||||
"label": "基本属性",
|
||||
"columns": [
|
||||
{
|
||||
"id": "column_1",
|
||||
"label": "主要设置",
|
||||
"fields": [
|
||||
"node_info",
|
||||
"operation"
|
||||
]
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"id": "section_2",
|
||||
"label": "路径配置",
|
||||
"columns": [
|
||||
{
|
||||
"id": "column_2",
|
||||
"label": "文件路径",
|
||||
"fields": [
|
||||
"file_path",
|
||||
"dir_path"
|
||||
]
|
||||
},
|
||||
{
|
||||
"id": "column_3",
|
||||
"label": "复制路径",
|
||||
"fields": [
|
||||
"source_path",
|
||||
"target_path"
|
||||
]
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"id": "section_3",
|
||||
"label": "搜索配置",
|
||||
"columns": [
|
||||
{
|
||||
"id": "column_4",
|
||||
"label": "搜索设置",
|
||||
"fields": [
|
||||
"search_path",
|
||||
"pattern"
|
||||
]
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"id": "section_4",
|
||||
"label": "使用说明",
|
||||
"columns": [
|
||||
{
|
||||
"id": "column_5",
|
||||
"label": "说明文档",
|
||||
"fields": [
|
||||
"usage_guide"
|
||||
]
|
||||
}
|
||||
]
|
||||
}
|
||||
]
|
||||
}
|
||||
],
|
||||
"activeTab": "tab_1"
|
||||
}
|
||||
}
|
||||
@ -1,138 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"os"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Go HTTP客户端节点请求结构
|
||||
type GoHttpClientRequest struct {
|
||||
Context map[string]interface{} `json:"context"`
|
||||
Inputs map[string]interface{} `json:"inputs"`
|
||||
Config map[string]interface{} `json:"config"`
|
||||
}
|
||||
|
||||
// Go HTTP客户端节点响应结构
|
||||
type GoHttpClientResponse struct {
|
||||
Success bool `json:"success"`
|
||||
Output string `json:"output,omitempty"`
|
||||
Result map[string]interface{} `json:"result,omitempty"`
|
||||
Error string `json:"error,omitempty"`
|
||||
}
|
||||
|
||||
func main() {
|
||||
var req GoHttpClientRequest
|
||||
json.NewDecoder(os.Stdin).Decode(&req)
|
||||
|
||||
result := execute(req.Context, req.Inputs, req.Config)
|
||||
|
||||
output, _ := json.Marshal(result)
|
||||
fmt.Println(string(output))
|
||||
}
|
||||
|
||||
// Go HTTP客户端节点执行函数
|
||||
func execute(context, inputs, config map[string]interface{}) GoHttpClientResponse {
|
||||
// 获取配置参数
|
||||
url, ok := config["url"].(string)
|
||||
if !ok || url == "" {
|
||||
return GoHttpClientResponse{
|
||||
Success: false,
|
||||
Error: "缺少URL配置",
|
||||
}
|
||||
}
|
||||
|
||||
method, ok := config["method"].(string)
|
||||
if !ok {
|
||||
method = "GET"
|
||||
}
|
||||
|
||||
timeout, ok := config["timeout"].(float64)
|
||||
if !ok {
|
||||
timeout = 30
|
||||
}
|
||||
|
||||
// 准备请求数据
|
||||
var requestBody []byte
|
||||
if data, exists := inputs["data"]; exists {
|
||||
if jsonData, err := json.Marshal(data); err == nil {
|
||||
requestBody = jsonData
|
||||
}
|
||||
}
|
||||
|
||||
// 创建HTTP客户端
|
||||
client := &http.Client{
|
||||
Timeout: time.Duration(timeout) * time.Second,
|
||||
}
|
||||
|
||||
// 创建请求
|
||||
req, err := http.NewRequest(method, url, bytes.NewBuffer(requestBody))
|
||||
if err != nil {
|
||||
return GoHttpClientResponse{
|
||||
Success: false,
|
||||
Error: fmt.Sprintf("创建请求失败: %v", err),
|
||||
}
|
||||
}
|
||||
|
||||
// 设置请求头
|
||||
if headers, ok := config["headers"].(map[string]interface{}); ok {
|
||||
for key, value := range headers {
|
||||
if strValue, ok := value.(string); ok {
|
||||
req.Header.Set(key, strValue)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 设置默认Content-Type
|
||||
if req.Header.Get("Content-Type") == "" && requestBody != nil {
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
}
|
||||
|
||||
// 执行请求
|
||||
startTime := time.Now()
|
||||
resp, err := client.Do(req)
|
||||
if err != nil {
|
||||
return GoHttpClientResponse{
|
||||
Success: false,
|
||||
Error: fmt.Sprintf("请求执行失败: %v", err),
|
||||
}
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
// 读取响应
|
||||
responseBody, err := io.ReadAll(resp.Body)
|
||||
if err != nil {
|
||||
return GoHttpClientResponse{
|
||||
Success: false,
|
||||
Error: fmt.Sprintf("读取响应失败: %v", err),
|
||||
}
|
||||
}
|
||||
|
||||
// 尝试解析JSON响应
|
||||
var jsonResponse interface{}
|
||||
if err := json.Unmarshal(responseBody, &jsonResponse); err != nil {
|
||||
// 如果不是JSON，直接返回字符串
|
||||
jsonResponse = string(responseBody)
|
||||
}
|
||||
|
||||
duration := time.Since(startTime)
|
||||
|
||||
return GoHttpClientResponse{
|
||||
Success: true,
|
||||
Output: "Go HTTP请求完成",
|
||||
Result: map[string]interface{}{
|
||||
"url": url,
|
||||
"method": method,
|
||||
"status_code": resp.StatusCode,
|
||||
"response": jsonResponse,
|
||||
"headers": resp.Header,
|
||||
"duration_ms": duration.Milliseconds(),
|
||||
"language": "go",
|
||||
"performance": "high",
|
||||
},
|
||||
}
|
||||
}
|
||||
@ -1,79 +0,0 @@
|
||||
{
|
||||
"name": "Go HTTP客户端",
|
||||
"description": "使用Go语言进行高性能HTTP请求",
|
||||
"version": "1.0.0",
|
||||
"category": "network",
|
||||
"inputs": [
|
||||
{
|
||||
"name": "context",
|
||||
"type": "object",
|
||||
"description": "上下文数据"
|
||||
},
|
||||
{
|
||||
"name": "inputs",
|
||||
"type": "object",
|
||||
"description": "输入数据"
|
||||
},
|
||||
{
|
||||
"name": "config",
|
||||
"type": "object",
|
||||
"description": "配置参数"
|
||||
}
|
||||
],
|
||||
"outputs": [
|
||||
{
|
||||
"name": "success",
|
||||
"type": "boolean",
|
||||
"description": "执行是否成功"
|
||||
},
|
||||
{
|
||||
"name": "output",
|
||||
"type": "string",
|
||||
"description": "执行结果消息"
|
||||
},
|
||||
{
|
||||
"name": "result",
|
||||
"type": "object",
|
||||
"description": "HTTP响应数据"
|
||||
}
|
||||
],
|
||||
"config": [
|
||||
{
|
||||
"name": "url",
|
||||
"type": "text",
|
||||
"label": "请求URL",
|
||||
"required": true,
|
||||
"description": "要请求的URL地址"
|
||||
},
|
||||
{
|
||||
"name": "method",
|
||||
"type": "select",
|
||||
"label": "请求方法",
|
||||
"required": false,
|
||||
"default": "GET",
|
||||
"options": [
|
||||
{"value": "GET", "label": "GET"},
|
||||
{"value": "POST", "label": "POST"},
|
||||
{"value": "PUT", "label": "PUT"},
|
||||
{"value": "DELETE", "label": "DELETE"},
|
||||
{"value": "PATCH", "label": "PATCH"}
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "timeout",
|
||||
"type": "number",
|
||||
"label": "超时时间(秒)",
|
||||
"required": false,
|
||||
"default": 30,
|
||||
"min": 1,
|
||||
"max": 300
|
||||
},
|
||||
{
|
||||
"name": "headers",
|
||||
"type": "object",
|
||||
"label": "请求头",
|
||||
"required": false,
|
||||
"description": "HTTP请求头配置"
|
||||
}
|
||||
]
|
||||
}
|
||||
@ -1,52 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"os"
|
||||
)
|
||||
|
||||
type ExecuteRequest struct {
|
||||
Context map[string]interface{} `json:"context"`
|
||||
Inputs map[string]interface{} `json:"inputs"`
|
||||
Config map[string]interface{} `json:"config"`
|
||||
}
|
||||
|
||||
type ExecuteResponse struct {
|
||||
Success bool `json:"success"`
|
||||
Output string `json:"output,omitempty"`
|
||||
Result interface{} `json:"result,omitempty"`
|
||||
Error string `json:"error,omitempty"`
|
||||
}
|
||||
|
||||
func main() {
|
||||
var req ExecuteRequest
|
||||
json.NewDecoder(os.Stdin).Decode(&req)
|
||||
|
||||
result := execute(req.Context, req.Inputs, req.Config)
|
||||
|
||||
output, _ := json.Marshal(result)
|
||||
fmt.Println(string(output))
|
||||
}
|
||||
|
||||
func execute(context, inputs, config map[string]interface{}) ExecuteResponse {
|
||||
code, ok := config["code"].(string)
|
||||
if !ok {
|
||||
return ExecuteResponse{
|
||||
Success: false,
|
||||
Error: "没有提供Go代码",
|
||||
}
|
||||
}
|
||||
|
||||
// 这里可以实现Go代码的动态执行
|
||||
// 目前返回示例结果
|
||||
return ExecuteResponse{
|
||||
Success: true,
|
||||
Output: "Go代码执行完成",
|
||||
Result: map[string]interface{}{
|
||||
"language": "go",
|
||||
"code_length": len(code),
|
||||
"execution_time": 0.1,
|
||||
},
|
||||
}
|
||||
}
|
||||
@ -1,31 +0,0 @@
|
||||
{
|
||||
"name": "Go语言执行节点",
|
||||
"description": "执行Go代码的节点",
|
||||
"version": "1.0.0",
|
||||
"author": "jingrow",
|
||||
"category": "language",
|
||||
"inputs": [
|
||||
{
|
||||
"name": "code",
|
||||
"type": "string",
|
||||
"description": "要执行的Go代码",
|
||||
"required": true
|
||||
}
|
||||
],
|
||||
"outputs": [
|
||||
{
|
||||
"name": "output",
|
||||
"type": "string",
|
||||
"description": "代码执行的标准输出"
|
||||
},
|
||||
{
|
||||
"name": "result",
|
||||
"type": "object",
|
||||
"description": "代码执行的结果数据"
|
||||
}
|
||||
],
|
||||
"config": {
|
||||
"timeout": 30,
|
||||
"memory_limit": "512m"
|
||||
}
|
||||
}
|
||||
@ -1,31 +0,0 @@
|
||||
{
|
||||
"name": "Python语言执行节点",
|
||||
"description": "执行Python代码的节点",
|
||||
"version": "1.0.0",
|
||||
"author": "jingrow",
|
||||
"category": "language",
|
||||
"inputs": [
|
||||
{
|
||||
"name": "code",
|
||||
"type": "string",
|
||||
"description": "要执行的Python代码",
|
||||
"required": true
|
||||
}
|
||||
],
|
||||
"outputs": [
|
||||
{
|
||||
"name": "output",
|
||||
"type": "string",
|
||||
"description": "代码执行的标准输出"
|
||||
},
|
||||
{
|
||||
"name": "result",
|
||||
"type": "object",
|
||||
"description": "代码执行的结果数据"
|
||||
}
|
||||
],
|
||||
"config": {
|
||||
"timeout": 30,
|
||||
"memory_limit": "512m"
|
||||
}
|
||||
}
|
||||
@ -1,43 +0,0 @@
|
||||
def execute(context=None, inputs=None, config=None):
|
||||
"""
|
||||
Python语言执行节点
|
||||
执行用户提供的Python代码
|
||||
"""
|
||||
try:
|
||||
code = config.get('code', '')
|
||||
if not code:
|
||||
return {"success": False, "error": "没有提供Python代码"}
|
||||
|
||||
# 创建执行环境
|
||||
exec_globals = {
|
||||
'context': context,
|
||||
'inputs': inputs,
|
||||
'config': config,
|
||||
'__builtins__': __builtins__
|
||||
}
|
||||
exec_locals = {}
|
||||
|
||||
# 执行代码
|
||||
exec(code, exec_globals, exec_locals)
|
||||
|
||||
# 获取输出结果
|
||||
output = exec_locals.get('output', '')
|
||||
result = exec_locals.get('result', exec_locals)
|
||||
|
||||
return {
|
||||
"success": True,
|
||||
"output": output,
|
||||
"result": result,
|
||||
"execution_info": {
|
||||
"language": "python",
|
||||
"code_length": len(code),
|
||||
"variables": list(exec_locals.keys())
|
||||
}
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
return {
|
||||
"success": False,
|
||||
"error": str(e),
|
||||
"error_type": type(e).__name__
|
||||
}
|
||||
@ -1,31 +0,0 @@
|
||||
{
|
||||
"name": "Rust语言执行节点",
|
||||
"description": "执行Rust代码的节点",
|
||||
"version": "1.0.0",
|
||||
"author": "jingrow",
|
||||
"category": "language",
|
||||
"inputs": [
|
||||
{
|
||||
"name": "code",
|
||||
"type": "string",
|
||||
"description": "要执行的Rust代码",
|
||||
"required": true
|
||||
}
|
||||
],
|
||||
"outputs": [
|
||||
{
|
||||
"name": "output",
|
||||
"type": "string",
|
||||
"description": "代码执行的标准输出"
|
||||
},
|
||||
{
|
||||
"name": "result",
|
||||
"type": "object",
|
||||
"description": "代码执行的结果数据"
|
||||
}
|
||||
],
|
||||
"config": {
|
||||
"timeout": 30,
|
||||
"memory_limit": "512m"
|
||||
}
|
||||
}
|
||||
@ -1,53 +0,0 @@
|
||||
use serde_json::{json, Value};
|
||||
use std::io::{self, Read};
|
||||
|
||||
#[derive(serde::Deserialize)]
|
||||
struct ExecuteRequest {
|
||||
context: Value,
|
||||
inputs: Value,
|
||||
config: Value,
|
||||
}
|
||||
|
||||
#[derive(serde::Serialize)]
|
||||
struct ExecuteResponse {
|
||||
success: bool,
|
||||
output: Option<String>,
|
||||
result: Option<Value>,
|
||||
error: Option<String>,
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let mut input = String::new();
|
||||
io::stdin().read_to_string(&mut input).unwrap();
|
||||
|
||||
let req: ExecuteRequest = serde_json::from_str(&input).unwrap();
|
||||
let result = execute(&req.context, &req.inputs, &req.config);
|
||||
|
||||
println!("{}", serde_json::to_string(&result).unwrap());
|
||||
}
|
||||
|
||||
fn execute(context: &Value, inputs: &Value, config: &Value) -> ExecuteResponse {
|
||||
let code = config["code"].as_str().unwrap_or("");
|
||||
|
||||
if code.is_empty() {
|
||||
return ExecuteResponse {
|
||||
success: false,
|
||||
output: None,
|
||||
result: None,
|
||||
error: Some("没有提供Rust代码".to_string()),
|
||||
};
|
||||
}
|
||||
|
||||
// 这里可以实现Rust代码的动态执行
|
||||
// 目前返回示例结果
|
||||
ExecuteResponse {
|
||||
success: true,
|
||||
output: Some("Rust代码执行完成".to_string()),
|
||||
result: Some(json!({
|
||||
"language": "rust",
|
||||
"code_length": code.len(),
|
||||
"execution_time": 0.05
|
||||
})),
|
||||
error: None,
|
||||
}
|
||||
}
|
||||
@ -1,93 +0,0 @@
|
||||
{
|
||||
"name": "Rust加密处理",
|
||||
"description": "使用Rust语言进行高性能加密和安全处理",
|
||||
"version": "1.0.0",
|
||||
"category": "security",
|
||||
"inputs": [
|
||||
{
|
||||
"name": "context",
|
||||
"type": "object",
|
||||
"description": "上下文数据"
|
||||
},
|
||||
{
|
||||
"name": "inputs",
|
||||
"type": "object",
|
||||
"description": "输入数据"
|
||||
},
|
||||
{
|
||||
"name": "config",
|
||||
"type": "object",
|
||||
"description": "配置参数"
|
||||
}
|
||||
],
|
||||
"outputs": [
|
||||
{
|
||||
"name": "success",
|
||||
"type": "boolean",
|
||||
"description": "执行是否成功"
|
||||
},
|
||||
{
|
||||
"name": "output",
|
||||
"type": "string",
|
||||
"description": "执行结果消息"
|
||||
},
|
||||
{
|
||||
"name": "result",
|
||||
"type": "object",
|
||||
"description": "加密处理结果"
|
||||
}
|
||||
],
|
||||
"config": [
|
||||
{
|
||||
"name": "operation",
|
||||
"type": "select",
|
||||
"label": "加密操作",
|
||||
"required": true,
|
||||
"default": "encrypt",
|
||||
"options": [
|
||||
{"value": "encrypt", "label": "加密"},
|
||||
{"value": "decrypt", "label": "解密"},
|
||||
{"value": "hash", "label": "哈希"},
|
||||
{"value": "sign", "label": "数字签名"},
|
||||
{"value": "verify", "label": "签名验证"}
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "algorithm",
|
||||
"type": "select",
|
||||
"label": "加密算法",
|
||||
"required": false,
|
||||
"default": "AES-256",
|
||||
"options": [
|
||||
{"value": "AES-256", "label": "AES-256"},
|
||||
{"value": "AES-128", "label": "AES-128"},
|
||||
{"value": "RSA-2048", "label": "RSA-2048"},
|
||||
{"value": "ECDSA", "label": "ECDSA"},
|
||||
{"value": "SHA-256", "label": "SHA-256"},
|
||||
{"value": "SHA-512", "label": "SHA-512"}
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "key_length",
|
||||
"type": "number",
|
||||
"label": "密钥长度",
|
||||
"required": false,
|
||||
"default": 256,
|
||||
"min": 128,
|
||||
"max": 4096
|
||||
},
|
||||
{
|
||||
"name": "mode",
|
||||
"type": "select",
|
||||
"label": "加密模式",
|
||||
"required": false,
|
||||
"default": "CBC",
|
||||
"options": [
|
||||
{"value": "CBC", "label": "CBC"},
|
||||
{"value": "GCM", "label": "GCM"},
|
||||
{"value": "CTR", "label": "CTR"},
|
||||
{"value": "OFB", "label": "OFB"}
|
||||
]
|
||||
}
|
||||
]
|
||||
}
|
||||
@ -1,28 +0,0 @@
|
||||
use std::io::{self, Read};
|
||||
|
||||
fn main() {
|
||||
let mut input = String::new();
|
||||
io::stdin().read_to_string(&mut input).unwrap();
|
||||
|
||||
let result = execute_crypto(&input);
|
||||
println!("{}", result);
|
||||
}
|
||||
|
||||
fn execute_crypto(input: &str) -> String {
|
||||
// 简化的Rust加密处理逻辑
|
||||
// 在实际实现中，这里会使用ring或crypto crate进行真实的加密操作
|
||||
|
||||
if input.contains("encrypt") {
|
||||
return r#"{"success": true, "output": "Rust加密完成", "result": {"operation": "encrypt", "algorithm": "AES-256", "key_length": 256, "encrypted_data": "encrypted_base64_string", "language": "rust", "performance": "highest", "security": "maximum"}}"#.to_string();
|
||||
} else if input.contains("decrypt") {
|
||||
return r#"{"success": true, "output": "Rust解密完成", "result": {"operation": "decrypt", "algorithm": "AES-256", "decrypted_data": "original_data", "language": "rust", "performance": "highest", "security": "maximum"}}"#.to_string();
|
||||
} else if input.contains("hash") {
|
||||
return r#"{"success": true, "output": "Rust哈希计算完成", "result": {"operation": "hash", "algorithm": "SHA-256", "hash_value": "a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3", "language": "rust", "performance": "highest", "security": "maximum"}}"#.to_string();
|
||||
} else if input.contains("sign") {
|
||||
return r#"{"success": true, "output": "Rust数字签名完成", "result": {"operation": "sign", "algorithm": "ECDSA", "signature": "signature_base64_string", "public_key": "public_key_base64", "language": "rust", "performance": "highest", "security": "maximum"}}"#.to_string();
|
||||
} else if input.contains("verify") {
|
||||
return r#"{"success": true, "output": "Rust签名验证完成", "result": {"operation": "verify", "algorithm": "ECDSA", "valid": true, "language": "rust", "performance": "highest", "security": "maximum"}}"#.to_string();
|
||||
} else {
|
||||
return r#"{"success": true, "output": "Rust加密操作完成", "result": {"operation": "default", "language": "rust", "performance": "highest", "security": "maximum"}}"#.to_string();
|
||||
}
|
||||
}
|
||||
@ -1,95 +0,0 @@
|
||||
{
|
||||
"name": "Rust图像处理",
|
||||
"description": "使用Rust语言进行高性能图像处理",
|
||||
"version": "1.0.0",
|
||||
"category": "image",
|
||||
"inputs": [
|
||||
{
|
||||
"name": "context",
|
||||
"type": "object",
|
||||
"description": "上下文数据"
|
||||
},
|
||||
{
|
||||
"name": "inputs",
|
||||
"type": "object",
|
||||
"description": "输入数据"
|
||||
},
|
||||
{
|
||||
"name": "config",
|
||||
"type": "object",
|
||||
"description": "配置参数"
|
||||
}
|
||||
],
|
||||
"outputs": [
|
||||
{
|
||||
"name": "success",
|
||||
"type": "boolean",
|
||||
"description": "执行是否成功"
|
||||
},
|
||||
{
|
||||
"name": "output",
|
||||
"type": "string",
|
||||
"description": "执行结果消息"
|
||||
},
|
||||
{
|
||||
"name": "result",
|
||||
"type": "object",
|
||||
"description": "图像处理结果"
|
||||
}
|
||||
],
|
||||
"config": [
|
||||
{
|
||||
"name": "operation",
|
||||
"type": "select",
|
||||
"label": "处理操作",
|
||||
"required": true,
|
||||
"default": "resize",
|
||||
"options": [
|
||||
{"value": "resize", "label": "缩放"},
|
||||
{"value": "crop", "label": "裁剪"},
|
||||
{"value": "filter", "label": "滤镜"},
|
||||
{"value": "convert", "label": "格式转换"}
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "width",
|
||||
"type": "number",
|
||||
"label": "宽度",
|
||||
"required": false,
|
||||
"default": 800,
|
||||
"min": 1,
|
||||
"max": 4096
|
||||
},
|
||||
{
|
||||
"name": "height",
|
||||
"type": "number",
|
||||
"label": "高度",
|
||||
"required": false,
|
||||
"default": 600,
|
||||
"min": 1,
|
||||
"max": 4096
|
||||
},
|
||||
{
|
||||
"name": "quality",
|
||||
"type": "number",
|
||||
"label": "质量",
|
||||
"required": false,
|
||||
"default": 95,
|
||||
"min": 1,
|
||||
"max": 100
|
||||
},
|
||||
{
|
||||
"name": "filter_type",
|
||||
"type": "select",
|
||||
"label": "滤镜类型",
|
||||
"required": false,
|
||||
"default": "blur",
|
||||
"options": [
|
||||
{"value": "blur", "label": "模糊"},
|
||||
{"value": "sharpen", "label": "锐化"},
|
||||
{"value": "grayscale", "label": "灰度"},
|
||||
{"value": "sepia", "label": "棕褐色"}
|
||||
]
|
||||
}
|
||||
]
|
||||
}
|
||||
@ -1,26 +0,0 @@
|
||||
use std::io::{self, Read};
|
||||
|
||||
fn main() {
|
||||
let mut input = String::new();
|
||||
io::stdin().read_to_string(&mut input).unwrap();
|
||||
|
||||
let result = execute_image_processing(&input);
|
||||
println!("{}", result);
|
||||
}
|
||||
|
||||
fn execute_image_processing(input: &str) -> String {
|
||||
// 简化的Rust图像处理逻辑
|
||||
// 在实际实现中，这里会使用image crate进行真实的图像处理
|
||||
|
||||
if input.contains("resize") {
|
||||
return r#"{"success": true, "output": "Rust图像缩放完成", "result": {"operation": "resize", "width": 800, "height": 600, "format": "png", "language": "rust", "performance": "highest"}}"#.to_string();
|
||||
} else if input.contains("crop") {
|
||||
return r#"{"success": true, "output": "Rust图像裁剪完成", "result": {"operation": "crop", "x": 100, "y": 100, "width": 400, "height": 300, "language": "rust", "performance": "highest"}}"#.to_string();
|
||||
} else if input.contains("filter") {
|
||||
return r#"{"success": true, "output": "Rust图像滤镜完成", "result": {"operation": "filter", "filter_type": "blur", "intensity": 5, "language": "rust", "performance": "highest"}}"#.to_string();
|
||||
} else if input.contains("convert") {
|
||||
return r#"{"success": true, "output": "Rust图像格式转换完成", "result": {"operation": "convert", "from_format": "jpg", "to_format": "png", "quality": 95, "language": "rust", "performance": "highest"}}"#.to_string();
|
||||
} else {
|
||||
return r#"{"success": true, "output": "Rust图像处理完成", "result": {"operation": "default", "language": "rust", "performance": "highest"}}"#.to_string();
|
||||
}
|
||||
}
|
||||
@ -1,224 +0,0 @@
|
||||
{
|
||||
"properties": {
|
||||
"node_info": {
|
||||
"type": "string",
|
||||
"title": "节点说明",
|
||||
"description": "",
|
||||
"default": "Rust数值计算节点利用Rust语言的ndarray、statrs等高性能数学库，实现极速数值计算、统计分析、科学计算等功能。性能接近C语言水平。",
|
||||
"format": "info"
|
||||
},
|
||||
"operation": {
|
||||
"type": "string",
|
||||
"title": "计算类型",
|
||||
"description": "选择要执行的数值计算类型",
|
||||
"enum": [
|
||||
"statistics",
|
||||
"matrix",
|
||||
"interpolation",
|
||||
"optimization",
|
||||
"integration",
|
||||
"fourier",
|
||||
"clustering",
|
||||
"regression"
|
||||
],
|
||||
"enumNames": [
|
||||
"统计分析",
|
||||
"矩阵运算",
|
||||
"插值计算",
|
||||
"优化计算",
|
||||
"积分计算",
|
||||
"傅里叶变换",
|
||||
"聚类分析",
|
||||
"回归分析"
|
||||
],
|
||||
"default": "statistics"
|
||||
},
|
||||
"data": {
|
||||
"type": "array",
|
||||
"title": "数值数据",
|
||||
"description": "要计算的数值数组",
|
||||
"items": {
|
||||
"type": "number"
|
||||
}
|
||||
},
|
||||
"matrix_a": {
|
||||
"type": "array",
|
||||
"title": "矩阵A",
|
||||
"description": "矩阵运算的第一个矩阵",
|
||||
"items": {
|
||||
"type": "array",
|
||||
"items": {
|
||||
"type": "number"
|
||||
}
|
||||
}
|
||||
},
|
||||
"matrix_b": {
|
||||
"type": "array",
|
||||
"title": "矩阵B",
|
||||
"description": "矩阵运算的第二个矩阵",
|
||||
"items": {
|
||||
"type": "array",
|
||||
"items": {
|
||||
"type": "number"
|
||||
}
|
||||
}
|
||||
},
|
||||
"operation_type": {
|
||||
"type": "string",
|
||||
"title": "矩阵运算类型",
|
||||
"description": "矩阵运算的具体操作类型",
|
||||
"enum": [
|
||||
"multiply",
|
||||
"add",
|
||||
"subtract",
|
||||
"transpose",
|
||||
"determinant",
|
||||
"inverse"
|
||||
],
|
||||
"enumNames": [
|
||||
"矩阵乘法",
|
||||
"矩阵加法",
|
||||
"矩阵减法",
|
||||
"矩阵转置",
|
||||
"行列式",
|
||||
"矩阵逆"
|
||||
],
|
||||
"default": "multiply"
|
||||
},
|
||||
"method": {
|
||||
"type": "string",
|
||||
"title": "计算方法",
|
||||
"description": "数值计算的具体方法",
|
||||
"enum": [
|
||||
"linear",
|
||||
"polynomial",
|
||||
"spline",
|
||||
"nearest"
|
||||
],
|
||||
"enumNames": [
|
||||
"线性",
|
||||
"多项式",
|
||||
"样条",
|
||||
"最近邻"
|
||||
],
|
||||
"default": "linear"
|
||||
},
|
||||
"precision": {
|
||||
"type": "number",
|
||||
"title": "计算精度",
|
||||
"description": "数值计算的精度要求",
|
||||
"default": 0.001,
|
||||
"minimum": 0.000001,
|
||||
"maximum": 0.1
|
||||
},
|
||||
"iterations": {
|
||||
"type": "number",
|
||||
"title": "迭代次数",
|
||||
"description": "迭代算法的最大迭代次数",
|
||||
"default": 1000,
|
||||
"minimum": 1,
|
||||
"maximum": 10000
|
||||
},
|
||||
"clusters": {
|
||||
"type": "number",
|
||||
"title": "聚类数量",
|
||||
"description": "聚类分析的聚类数量",
|
||||
"default": 3,
|
||||
"minimum": 2,
|
||||
"maximum": 20
|
||||
},
|
||||
"usage_guide": {
|
||||
"type": "string",
|
||||
"title": "使用说明",
|
||||
"description": "Rust数值计算的使用指南",
|
||||
"default": "Rust数值计算节点特色：\n• 利用ndarray、statrs等高性能数学库\n• 支持多种计算：统计、矩阵、插值、优化\n• 提供科学计算和机器学习预处理功能\n• 性能接近C语言水平\n\n最佳实践：\n• 根据数据类型选择合适的计算方法\n• 设置合适的精度和迭代次数\n• 大数据集建议分批处理\n• 矩阵运算注意维度匹配",
|
||||
"format": "info"
|
||||
}
|
||||
},
|
||||
"required": [
|
||||
"operation",
|
||||
"data"
|
||||
],
|
||||
"_layout": {
|
||||
"tabs": [
|
||||
{
|
||||
"id": "tab_1",
|
||||
"label": "基础配置",
|
||||
"sections": [
|
||||
{
|
||||
"id": "section_1",
|
||||
"label": "基本属性",
|
||||
"columns": [
|
||||
{
|
||||
"id": "column_1",
|
||||
"label": "主要设置",
|
||||
"fields": [
|
||||
"node_info",
|
||||
"operation"
|
||||
]
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"id": "section_2",
|
||||
"label": "数据配置",
|
||||
"columns": [
|
||||
{
|
||||
"id": "column_2",
|
||||
"label": "输入数据",
|
||||
"fields": [
|
||||
"data"
|
||||
]
|
||||
},
|
||||
{
|
||||
"id": "column_3",
|
||||
"label": "矩阵数据",
|
||||
"fields": [
|
||||
"matrix_a",
|
||||
"matrix_b"
|
||||
]
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"id": "section_3",
|
||||
"label": "计算配置",
|
||||
"columns": [
|
||||
{
|
||||
"id": "column_4",
|
||||
"label": "运算设置",
|
||||
"fields": [
|
||||
"operation_type",
|
||||
"method"
|
||||
]
|
||||
},
|
||||
{
|
||||
"id": "column_5",
|
||||
"label": "参数设置",
|
||||
"fields": [
|
||||
"precision",
|
||||
"iterations",
|
||||
"clusters"
|
||||
]
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"id": "section_4",
|
||||
"label": "使用说明",
|
||||
"columns": [
|
||||
{
|
||||
"id": "column_6",
|
||||
"label": "说明文档",
|
||||
"fields": [
|
||||
"usage_guide"
|
||||
]
|
||||
}
|
||||
]
|
||||
}
|
||||
]
|
||||
}
|
||||
],
|
||||
"activeTab": "tab_1"
|
||||
}
|
||||
}
|
||||
@ -1,34 +0,0 @@
|
||||
use std::io::{self, Read};
|
||||
|
||||
fn main() {
|
||||
let mut input = String::new();
|
||||
io::stdin().read_to_string(&mut input).unwrap();
|
||||
|
||||
let result = execute_numeric_computing(&input);
|
||||
println!("{}", result);
|
||||
}
|
||||
|
||||
fn execute_numeric_computing(input: &str) -> String {
|
||||
// 简化的Rust数值计算逻辑
|
||||
// 在实际实现中，这里会使用ndarray、statrs等crate进行真实的数值计算
|
||||
|
||||
if input.contains("statistics") {
|
||||
return r#"{"success": true, "output": "Rust统计分析完成", "result": {"operation": "statistics", "data": [1.0, 2.0, 3.0, 4.0, 5.0], "mean": 3.0, "median": 3.0, "std_dev": 1.58, "variance": 2.5, "min": 1.0, "max": 5.0, "sum": 15.0, "count": 5, "language": "rust", "performance": "highest"}}"#.to_string();
|
||||
} else if input.contains("matrix") {
|
||||
return r#"{"success": true, "output": "Rust矩阵运算完成", "result": {"operation": "matrix", "operation_type": "multiply", "matrix_a": [[1, 2], [3, 4]], "matrix_b": [[5, 6], [7, 8]], "result": [[19, 22], [43, 50]], "dimensions": "2x2", "language": "rust", "performance": "highest"}}"#.to_string();
|
||||
} else if input.contains("interpolation") {
|
||||
return r#"{"success": true, "output": "Rust插值计算完成", "result": {"operation": "interpolation", "method": "linear", "x_values": [1.0, 2.0, 3.0, 4.0], "y_values": [2.0, 4.0, 6.0, 8.0], "interpolated_x": 2.5, "interpolated_y": 5.0, "language": "rust", "performance": "highest"}}"#.to_string();
|
||||
} else if input.contains("optimization") {
|
||||
return r#"{"success": true, "output": "Rust优化计算完成", "result": {"operation": "optimization", "method": "gradient_descent", "function": "x^2 + y^2", "initial_point": [5.0, 5.0], "optimal_point": [0.0, 0.0], "iterations": 100, "converged": true, "language": "rust", "performance": "highest"}}"#.to_string();
|
||||
} else if input.contains("integration") {
|
||||
return r#"{"success": true, "output": "Rust积分计算完成", "result": {"operation": "integration", "method": "simpson", "function": "x^2", "lower_bound": 0.0, "upper_bound": 2.0, "result": 2.67, "error": 0.001, "language": "rust", "performance": "highest"}}"#.to_string();
|
||||
} else if input.contains("fourier") {
|
||||
return r#"{"success": true, "output": "Rust傅里叶变换完成", "result": {"operation": "fourier", "transform_type": "fft", "input_signal": [1.0, 0.0, -1.0, 0.0], "frequency_domain": [0.0, 2.0, 0.0, -2.0], "sample_rate": 1000.0, "language": "rust", "performance": "highest"}}"#.to_string();
|
||||
} else if input.contains("clustering") {
|
||||
return r#"{"success": true, "output": "Rust聚类分析完成", "result": {"operation": "clustering", "algorithm": "kmeans", "data_points": [[1, 1], [2, 2], [8, 8], [9, 9]], "clusters": 2, "centroids": [[1.5, 1.5], [8.5, 8.5]], "labels": [0, 0, 1, 1], "language": "rust", "performance": "highest"}}"#.to_string();
|
||||
} else if input.contains("regression") {
|
||||
return r#"{"success": true, "output": "Rust回归分析完成", "result": {"operation": "regression", "method": "linear", "x_values": [1.0, 2.0, 3.0, 4.0], "y_values": [2.1, 3.9, 6.1, 8.0], "slope": 2.0, "intercept": 0.1, "r_squared": 0.99, "language": "rust", "performance": "highest"}}"#.to_string();
|
||||
} else {
|
||||
return r#"{"success": true, "output": "Rust数值计算完成", "result": {"operation": "default", "language": "rust", "performance": "highest"}}"#.to_string();
|
||||
}
|
||||
}
|
||||
@ -1,184 +0,0 @@
|
||||
{
|
||||
"properties": {
|
||||
"node_info": {
|
||||
"type": "string",
|
||||
"title": "节点说明",
|
||||
"description": "",
|
||||
"default": "Rust正则表达式处理节点利用Rust语言的regex crate，实现极速正则匹配、文本解析、模式提取等功能。性能接近C语言水平。",
|
||||
"format": "info"
|
||||
},
|
||||
"operation": {
|
||||
"type": "string",
|
||||
"title": "操作类型",
|
||||
"description": "选择要执行的正则表达式操作类型",
|
||||
"enum": [
|
||||
"extract",
|
||||
"replace",
|
||||
"validate",
|
||||
"split",
|
||||
"find_all",
|
||||
"capture",
|
||||
"count",
|
||||
"analyze"
|
||||
],
|
||||
"enumNames": [
|
||||
"提取匹配",
|
||||
"替换匹配",
|
||||
"验证格式",
|
||||
"分割文本",
|
||||
"查找所有",
|
||||
"捕获分组",
|
||||
"计数匹配",
|
||||
"分析文本"
|
||||
],
|
||||
"default": "extract"
|
||||
},
|
||||
"pattern": {
|
||||
"type": "string",
|
||||
"title": "正则模式",
|
||||
"description": "正则表达式模式",
|
||||
"placeholder": "\\d{4}-\\d{2}-\\d{2}",
|
||||
"examples": [
|
||||
"\\d{4}-\\d{2}-\\d{2}",
|
||||
"\\b[A-Z][a-z]+\\b",
|
||||
"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$"
|
||||
]
|
||||
},
|
||||
"text": {
|
||||
"type": "string",
|
||||
"title": "输入文本",
|
||||
"description": "要处理的文本内容",
|
||||
"format": "textarea"
|
||||
},
|
||||
"replacement": {
|
||||
"type": "string",
|
||||
"title": "替换文本",
|
||||
"description": "替换操作时的替换文本",
|
||||
"placeholder": "[REPLACED]"
|
||||
},
|
||||
"flags": {
|
||||
"type": "object",
|
||||
"title": "正则标志",
|
||||
"description": "正则表达式的标志设置",
|
||||
"properties": {
|
||||
"case_insensitive": {
|
||||
"type": "boolean",
|
||||
"title": "忽略大小写",
|
||||
"description": "是否忽略大小写匹配",
|
||||
"default": false
|
||||
},
|
||||
"multiline": {
|
||||
"type": "boolean",
|
||||
"title": "多行模式",
|
||||
"description": "是否启用多行模式",
|
||||
"default": false
|
||||
},
|
||||
"dotall": {
|
||||
"type": "boolean",
|
||||
"title": "点匹配换行",
|
||||
"description": "是否让.匹配换行符",
|
||||
"default": false
|
||||
}
|
||||
}
|
||||
},
|
||||
"max_matches": {
|
||||
"type": "number",
|
||||
"title": "最大匹配数",
|
||||
"description": "限制最大匹配数量",
|
||||
"default": 1000,
|
||||
"minimum": 1,
|
||||
"maximum": 10000
|
||||
},
|
||||
"usage_guide": {
|
||||
"type": "string",
|
||||
"title": "使用说明",
|
||||
"description": "Rust正则表达式处理的使用指南",
|
||||
"default": "Rust正则表达式处理节点特色：\n• 利用regex crate实现极速正则匹配\n• 支持多种操作：提取、替换、验证、分割\n• 提供分组捕获和文本分析功能\n• 性能接近C语言水平\n\n最佳实践：\n• 使用合适的正则模式提高匹配效率\n• 设置最大匹配数避免内存过载\n• 利用标志位优化匹配行为\n• 复杂模式建议先测试验证",
|
||||
"format": "info"
|
||||
}
|
||||
},
|
||||
"required": [
|
||||
"operation",
|
||||
"pattern",
|
||||
"text"
|
||||
],
|
||||
"_layout": {
|
||||
"tabs": [
|
||||
{
|
||||
"id": "tab_1",
|
||||
"label": "基础配置",
|
||||
"sections": [
|
||||
{
|
||||
"id": "section_1",
|
||||
"label": "基本属性",
|
||||
"columns": [
|
||||
{
|
||||
"id": "column_1",
|
||||
"label": "主要设置",
|
||||
"fields": [
|
||||
"node_info",
|
||||
"operation"
|
||||
]
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"id": "section_2",
|
||||
"label": "正则配置",
|
||||
"columns": [
|
||||
{
|
||||
"id": "column_2",
|
||||
"label": "模式设置",
|
||||
"fields": [
|
||||
"pattern",
|
||||
"text"
|
||||
]
|
||||
},
|
||||
{
|
||||
"id": "column_3",
|
||||
"label": "替换设置",
|
||||
"fields": [
|
||||
"replacement"
|
||||
]
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"id": "section_3",
|
||||
"label": "高级配置",
|
||||
"columns": [
|
||||
{
|
||||
"id": "column_4",
|
||||
"label": "标志设置",
|
||||
"fields": [
|
||||
"flags"
|
||||
]
|
||||
},
|
||||
{
|
||||
"id": "column_5",
|
||||
"label": "性能设置",
|
||||
"fields": [
|
||||
"max_matches"
|
||||
]
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"id": "section_4",
|
||||
"label": "使用说明",
|
||||
"columns": [
|
||||
{
|
||||
"id": "column_6",
|
||||
"label": "说明文档",
|
||||
"fields": [
|
||||
"usage_guide"
|
||||
]
|
||||
}
|
||||
]
|
||||
}
|
||||
]
|
||||
}
|
||||
],
|
||||
"activeTab": "tab_1"
|
||||
}
|
||||
}
|
||||
@ -1,34 +0,0 @@
|
||||
use std::io::{self, Read};
|
||||
|
||||
fn main() {
|
||||
let mut input = String::new();
|
||||
io::stdin().read_to_string(&mut input).unwrap();
|
||||
|
||||
let result = execute_regex_processing(&input);
|
||||
println!("{}", result);
|
||||
}
|
||||
|
||||
fn execute_regex_processing(input: &str) -> String {
|
||||
// 简化的Rust正则表达式处理逻辑
|
||||
// 在实际实现中，这里会使用regex crate进行真实的正则处理
|
||||
|
||||
if input.contains("extract") {
|
||||
return r#"{"success": true, "output": "Rust正则提取完成", "result": {"operation": "extract", "pattern": "\\d{4}-\\d{2}-\\d{2}", "matches": ["2024-01-01", "2024-12-31"], "count": 2, "language": "rust", "performance": "highest"}}"#.to_string();
|
||||
} else if input.contains("replace") {
|
||||
return r#"{"success": true, "output": "Rust正则替换完成", "result": {"operation": "replace", "pattern": "\\b(\\w+)@(\\w+)\\.(\\w+)\\b", "replacement": "[EMAIL]", "original": "Contact: john@example.com", "result": "Contact: [EMAIL]", "replacements": 1, "language": "rust", "performance": "highest"}}"#.to_string();
|
||||
} else if input.contains("validate") {
|
||||
return r#"{"success": true, "output": "Rust正则验证完成", "result": {"operation": "validate", "pattern": "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$", "text": "test@example.com", "valid": true, "language": "rust", "performance": "highest"}}"#.to_string();
|
||||
} else if input.contains("split") {
|
||||
return r#"{"success": true, "output": "Rust正则分割完成", "result": {"operation": "split", "pattern": "\\s+", "text": "hello world rust", "parts": ["hello", "world", "rust"], "count": 3, "language": "rust", "performance": "highest"}}"#.to_string();
|
||||
} else if input.contains("find_all") {
|
||||
return r#"{"success": true, "output": "Rust正则查找完成", "result": {"operation": "find_all", "pattern": "\\b\\w{4}\\b", "text": "This is a test string with words", "matches": ["This", "test", "with", "word"], "count": 4, "language": "rust", "performance": "highest"}}"#.to_string();
|
||||
} else if input.contains("capture") {
|
||||
return r#"{"success": true, "output": "Rust正则捕获完成", "result": {"operation": "capture", "pattern": "(\\d{4})-(\\d{2})-(\\d{2})", "text": "Date: 2024-01-01", "captures": [{"full": "2024-01-01", "year": "2024", "month": "01", "day": "01"}], "count": 1, "language": "rust", "performance": "highest"}}"#.to_string();
|
||||
} else if input.contains("count") {
|
||||
return r#"{"success": true, "output": "Rust正则计数完成", "result": {"operation": "count", "pattern": "\\d+", "text": "There are 123 apples and 456 oranges", "count": 2, "language": "rust", "performance": "highest"}}"#.to_string();
|
||||
} else if input.contains("analyze") {
|
||||
return r#"{"success": true, "output": "Rust正则分析完成", "result": {"operation": "analyze", "pattern": "\\b[A-Z][a-z]+\\b", "text": "Hello World Rust Programming", "analysis": {"total_matches": 4, "unique_matches": 4, "average_length": 6.5, "longest_match": "Programming"}, "language": "rust", "performance": "highest"}}"#.to_string();
|
||||
} else {
|
||||
return r#"{"success": true, "output": "Rust正则处理完成", "result": {"operation": "default", "language": "rust", "performance": "highest"}}"#.to_string();
|
||||
}
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user