Changed self-crawling as experimental, cleanup unused features

node-request-files.go

@@ -1,19 +1,22 @@
+//go:build experimental
+// +build experimental
+
 package main
 
 import (
-	"encoding/json"
+	"bytes"
+	"encoding/binary"
 	"fmt"
 	"time"
 )
 
-func tryOtherNodesForFileSearch(query, safe, lang string, page int, visitedNodes []string) []TorrentResult {
-	for _, nodeAddr := range peers {
-		if contains(visitedNodes, nodeAddr) {
-			continue // Skip nodes already visited
-		}
-		results, err := sendFileSearchRequestToNode(nodeAddr, query, safe, lang, page, visitedNodes)
+var fileResultsChan = make(chan []TorrentResult)
+
+func tryOtherNodesForFileSearch(query, safe, lang string, page int) []TorrentResult {
+	for _, nodeTarget := range sockets {
+		results, err := sendFileSearchRequestToNode(nodeTarget, query, safe, lang, page)
 		if err != nil {
-			printWarn("Error contacting node %s: %v", nodeAddr, err)
+			printWarn("Error contacting node %s: %v", nodeTarget, err)
 			continue
 		}
 		if len(results) > 0 {
@@ -23,60 +26,123 @@ func tryOtherNodesForFileSearch(query, safe, lang string, page int, visitedNodes
 	return nil
 }
 
-func sendFileSearchRequestToNode(nodeAddr, query, safe, lang string, page int, visitedNodes []string) ([]TorrentResult, error) {
-	visitedNodes = append(visitedNodes, nodeAddr)
-	searchParams := struct {
-		Query        string   `json:"query"`
-		Safe         string   `json:"safe"`
-		Lang         string   `json:"lang"`
-		Page         int      `json:"page"`
-		ResponseAddr string   `json:"responseAddr"`
-		VisitedNodes []string `json:"visitedNodes"`
-	}{
-		Query:        query,
-		Safe:         safe,
-		Lang:         lang,
-		Page:         page,
-		ResponseAddr: fmt.Sprintf("http://localhost:%d/node", config.Port),
-		VisitedNodes: visitedNodes,
-	}
-
-	msgBytes, err := json.Marshal(searchParams)
+func sendFileSearchRequestToNode(target, query, safe, lang string, page int) ([]TorrentResult, error) {
+	payload, err := encodeSearchTextParams(query, safe, lang, page)
 	if err != nil {
-		return nil, fmt.Errorf("failed to marshal search parameters: %v", err)
+		return nil, fmt.Errorf("encode error: %v", err)
 	}
 
 	msg := Message{
-		ID:      hostID,
-		Type:    "search-file",
-		Content: string(msgBytes),
+		ID:      generateMessageID(),
+		Type:    MsgTypeSearchFileRequest,
+		Content: payload,
+		Target:  target,
 	}
 
-	err = sendMessage(nodeAddr, msg)
-	if err != nil {
-		return nil, fmt.Errorf("failed to send search request to node %s: %v", nodeAddr, err)
+	if err := sendMessage(msg); err != nil {
+		return nil, fmt.Errorf("send error: %v", err)
 	}
 
-	// Wait for results
 	select {
 	case res := <-fileResultsChan:
 		return res, nil
 	case <-time.After(20 * time.Second):
-		return nil, fmt.Errorf("timeout waiting for results from node %s", nodeAddr)
+		return nil, fmt.Errorf("timeout waiting for results from node %s", target)
 	}
 }
 
 func handleFileResultsMessage(msg Message) {
-	var results []TorrentResult
-	err := json.Unmarshal([]byte(msg.Content), &results)
+	results, err := decodeFileResults([]byte(msg.Content))
 	if err != nil {
-		printWarn("Error unmarshalling file results: %v", err)
+		printWarn("Error decoding file results: %v", err)
 		return
 	}
-
 	printDebug("Received file results: %+v", results)
-	// Send results to fileResultsChan
+
 	go func() {
 		fileResultsChan <- results
 	}()
 }
+
+func encodeFileResults(results []TorrentResult) ([]byte, error) {
+	buf := new(bytes.Buffer)
+
+	if err := binary.Write(buf, binary.BigEndian, uint16(len(results))); err != nil {
+		return nil, err
+	}
+
+	for _, r := range results {
+		if err := writeString(buf, r.URL); err != nil {
+			return nil, err
+		}
+		if err := binary.Write(buf, binary.BigEndian, uint32(r.Seeders)); err != nil {
+			return nil, err
+		}
+		if err := binary.Write(buf, binary.BigEndian, uint32(r.Leechers)); err != nil {
+			return nil, err
+		}
+		if err := writeString(buf, r.Magnet); err != nil {
+			return nil, err
+		}
+		if err := binary.Write(buf, binary.BigEndian, uint32(r.Views)); err != nil {
+			return nil, err
+		}
+		if err := writeString(buf, r.Size); err != nil {
+			return nil, err
+		}
+		if err := writeString(buf, r.Title); err != nil {
+			return nil, err
+		}
+	}
+	return buf.Bytes(), nil
+}
+
+func decodeFileResults(data []byte) ([]TorrentResult, error) {
+	buf := bytes.NewReader(data)
+
+	var count uint16
+	if err := binary.Read(buf, binary.BigEndian, &count); err != nil {
+		return nil, err
+	}
+
+	results := make([]TorrentResult, 0, count)
+	for i := 0; i < int(count); i++ {
+		url, err := readString(buf)
+		if err != nil {
+			return nil, err
+		}
+		var seeders, leechers, views uint32
+		if err := binary.Read(buf, binary.BigEndian, &seeders); err != nil {
+			return nil, err
+		}
+		if err := binary.Read(buf, binary.BigEndian, &leechers); err != nil {
+			return nil, err
+		}
+		magnet, err := readString(buf)
+		if err != nil {
+			return nil, err
+		}
+		if err := binary.Read(buf, binary.BigEndian, &views); err != nil {
+			return nil, err
+		}
+		size, err := readString(buf)
+		if err != nil {
+			return nil, err
+		}
+		title, err := readString(buf)
+		if err != nil {
+			return nil, err
+		}
+
+		results = append(results, TorrentResult{
+			URL:      url,
+			Seeders:  int(seeders),
+			Leechers: int(leechers),
+			Magnet:   magnet,
+			Views:    int(views),
+			Size:     size,
+			Title:    title,
+		})
+	}
+	return results, nil
+}