Add files via upload

Author: arshiacomplus

core_engine/main.go

@@ -14,17 +14,17 @@ import (
 	"strings"
 	"sync"
 	"time"
-
 	"golang.org/x/net/proxy"
 )
 
-type TestConfig struct {
+type TestJob struct {
 	Tag            string          `json:"tag"`
 	Protocol       string          `json:"protocol"`
-	Config         json.RawMessage `json:"config"`
+	Config         json.RawMessage `json:"config,omitempty"`
+	ConfigURI      string          `json:"config_uri,omitempty"`
 	ListenIP       string          `json:"listen_ip"`
 	TestPort       int             `json:"test_port"`
-	ClientPath     string          `json:"client_path"`
+	ClientPath     string          `json:"client_path,omitempty"`
 	FragmentConfig json.RawMessage `json:"fragment_config,omitempty"`
 }
 
@@ -37,91 +37,79 @@ type TestResult struct {
 func main() {
 	inputData, err := io.ReadAll(os.Stdin)
 	if err != nil { os.Exit(1) }
-	var configs []TestConfig
-	if err := json.Unmarshal(inputData, &configs); err != nil { os.Exit(1) }
+	var jobs []TestJob
+	if err := json.Unmarshal(inputData, &jobs); err != nil { os.Exit(1) }
 
-	results := make(chan TestResult, len(configs))
+	results := make(chan TestResult, len(jobs))
 	var wg sync.WaitGroup
 
-	for _, conf := range configs {
+	for _, job := range jobs {
 		wg.Add(1)
-		go func(c TestConfig) {
+		go func(j TestJob) {
 			defer wg.Done()
 
-			var cmd *exec.Cmd
-			var configFile *os.File
-
-			ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
-			defer cancel()
-
-			if c.Protocol == "hysteria" || c.Protocol == "hysteria2" {
-				configFile, err = os.CreateTemp("", "hysteria-*.json")
-				if err != nil { results <- TestResult{Tag: c.Tag, Ping: -1, Status: "tempfile_error"}; return }
-				defer os.Remove(configFile.Name())
-				configFile.Write(c.Config)
-				configFile.Close()
-				cmd = exec.CommandContext(ctx, c.ClientPath, "client", "-c", configFile.Name())
-
+			if j.ClientPath != "" {
+				runIndividualTest(j, results)
 			} else {
-				configFile, err = os.CreateTemp("", "xray-*.json")
-				if err != nil { results <- TestResult{Tag: c.Tag, Ping: -1, Status: "tempfile_error"}; return }
-				defer os.Remove(configFile.Name())
-
-				outbounds := []json.RawMessage{c.Config}
-				if len(c.FragmentConfig) > 0 && string(c.FragmentConfig) != "null" {
-					fragmentOutbound := map[string]interface{}{ "protocol": "freedom", "tag": "fragment", "settings": map[string]json.RawMessage{"fragment": c.FragmentConfig}}
-					fragmentBytes, _ := json.Marshal(fragmentOutbound)
-					outbounds = append(outbounds, json.RawMessage(fragmentBytes))
-				}
-
-				fullConfig := map[string]interface{}{
-					"log":       map[string]string{"loglevel": "warning"},
-					"inbounds":  []map[string]interface{}{{"protocol": "socks", "port": c.TestPort, "listen": c.ListenIP, "settings": map[string]interface{}{"auth": "noauth", "udp": true}}},
-					"outbounds": outbounds,
-				}
-				configBytes, _ := json.Marshal(fullConfig)
-				configFile.Write(configBytes)
-				configFile.Close()
-
-				cmd = exec.CommandContext(ctx, c.ClientPath, "-c", configFile.Name())
+				ping, status := testProxy(j.ListenIP, j.TestPort)
+				results <- TestResult{Tag: j.Tag, Ping: ping, Status: status}
 			}
+		}(job)
+	}
 
+	wg.Wait()
+	close(results)
 
-			if runtime.GOOS == "windows" {
-				setHideWindow(cmd)
-			}
-
-			var clientOutput bytes.Buffer
-			cmd.Stdout = &clientOutput
-			cmd.Stderr = &clientOutput
+	finalResults := make([]TestResult, 0, len(jobs))
+	for res := range results { finalResults = append(finalResults, res) }
+	outputData, _ := json.Marshal(finalResults)
+	fmt.Println(string(outputData))
+}
 
-			if err := cmd.Start(); err != nil {
-				results <- TestResult{Tag: c.Tag, Ping: -1, Status: "client_start_failed"}; return
-			}
+func runIndividualTest(j TestJob, results chan<- TestResult) {
+	var cmd *exec.Cmd
+	configFile, err := os.CreateTemp("", "client-test-*.json")
+	if err != nil { results <- TestResult{Tag: j.Tag, Ping: -1, Status: "tempfile_error"}; return }
+	defer os.Remove(configFile.Name())
+
+	if j.Protocol == "hysteria2" {
+		// Simplified Hysteria config creation
+		uriParts := strings.Split(strings.Split(j.ConfigURI, "://")[1], "@")
+		serverParts := strings.Split(uriParts[1], "?")[0]
+		sni := strings.Split(strings.Split(j.ConfigURI, "sni=")[1], "#")[0]
+		config := map[string]interface{}{
+			"server":   serverParts, "auth": uriParts[0],
+			"socks5":   map[string]string{"listen": fmt.Sprintf("%s:%d", j.ListenIP, j.TestPort)},
+			"tls":      map[string]interface{}{"sni": sni, "insecure": true},
+		}
+		configBytes, _ := json.Marshal(config)
+		configFile.Write(configBytes)
+		configFile.Close()
+		cmd = exec.Command(j.ClientPath, "client", "-c", configFile.Name())
+	} else {
+		// Logic for other individual clients can be added here
+		results <- TestResult{Tag: j.Tag, Ping: -1, Status: "unsupported_individual_client"}; return
+	}
 
-			time.Sleep(900 * time.Millisecond)
-			ping, status := testProxy(c.ListenIP,c.TestPort)
+	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
+	defer cancel()
+	if runtime.GOOS == "windows" { setHideWindow(cmd) }
 
-			if status != "success" {
-				logStr := strings.ReplaceAll(string(clientOutput.Bytes()), "\n", " ")
-				if len(logStr) > 200 { logStr = logStr[:200] }
-				status = fmt.Sprintf("%s | log: %s", status, logStr)
-			}
+	var clientOutput bytes.Buffer
+	cmd.Stdout, cmd.Stderr = &clientOutput, &clientOutput
 
-			cmd.Process.Kill()
-			cmd.Wait()
+	if err := cmd.Start(); err != nil { results <- TestResult{Tag: j.Tag, Ping: -1, Status: "client_start_failed"}; return }
+	time.Sleep(1200 * time.Millisecond) // Hysteria might take longer to start
 
-			results <- TestResult{Tag: c.Tag, Ping: ping, Status: status}
-		}(conf)
+	ping, status := testProxy(j.ListenIP, j.TestPort)
+	if status != "success" {
+		logStr := strings.ReplaceAll(string(clientOutput.Bytes()), "\n", " ")
+		status = fmt.Sprintf("%s | log: %s", status, logStr[:200])
 	}
 
-	wg.Wait()
-	close(results)
-
-	finalResults := make([]TestResult, 0, len(configs))
-	for res := range results { finalResults = append(finalResults, res) }
-	outputData, _ := json.Marshal(finalResults)
-	fmt.Println(string(outputData))
+	cmd.Process.Kill()
+	cmd.Wait()
+	results <- TestResult{Tag: j.Tag, Ping: ping, Status: status}
 }
 
 func testProxy(listenIP string, port int) (int64, string) {